![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to varasm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to varasm.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Output variables, constants and external declarations, for GNU compiler.
2: Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
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)
9: any later version.
10:
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.
15:
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. */
19:
20:
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.
24:
25: We also output the assembler code for constants stored in memory
26: and are responsible for combining constants with the same value. */
27:
28: #include <stdio.h>
29: #include <setjmp.h>
30: /* #include <stab.h> */
31: #include "config.h"
32: #include "rtl.h"
33: #include "tree.h"
34: #include "flags.h"
35: #include "expr.h"
36: #include "hard-reg-set.h"
37: #include "regs.h"
38:
39: #include "obstack.h"
40:
41: #ifndef ASM_STABS_OP
42: #define ASM_STABS_OP ".stabs"
43: #endif
44:
45: /* File in which assembler code is being written. */
46:
47: extern FILE *asm_out_file;
48:
49: /* The (assembler) name of the first globally-visible object output. */
50: char *first_global_object_name;
51:
52: extern struct obstack *current_obstack;
53: extern struct obstack *saveable_obstack;
54: extern struct obstack permanent_obstack;
55: #define obstack_chunk_alloc xmalloc
56: extern int xmalloc ();
57:
58: /* Number for making the label on the next
59: constant that is stored in memory. */
60:
61: int const_labelno;
62:
63: /* Number for making the label on the next
64: static variable internal to a function. */
65:
66: int var_labelno;
67:
68: /* Nonzero if at least one function definition has been seen. */
69: static int function_defined;
70:
71: extern FILE *asm_out_file;
72:
73: static char *compare_constant_1 ();
74: static void record_constant_1 ();
75: void output_constant_pool ();
76: void assemble_name ();
77: int output_addressed_constants ();
78: void output_constant ();
79: void output_constructor ();
80:
81: #ifdef EXTRA_SECTIONS
82: static enum in_section {no_section, in_text, in_data, EXTRA_SECTIONS} in_section
83: = no_section;
84: #else
85: static enum in_section {no_section, in_text, in_data} in_section
86: = no_section;
87: #endif
88:
89: /* Define functions like text_section for any extra sections. */
90: #ifdef EXTRA_SECTION_FUNCTIONS
91: EXTRA_SECTION_FUNCTIONS
92: #endif
93:
94: /* Tell assembler to switch to text section. */
95:
96: void
97: text_section ()
98: {
99: if (in_section != in_text)
100: {
101: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
102: in_section = in_text;
103: }
104: }
105:
106: /* Tell assembler to switch to read-only data section. This is normally
107: the text section. */
108:
109: void
110: readonly_data_section ()
111: {
112: #ifdef READONLY_DATA_SECTION
113: READONLY_DATA_SECTION ();
114: #else
115: text_section ();
116: #endif
117: }
118:
119: /* Tell assembler to switch to data section. */
120:
121: void
122: data_section ()
123: {
124: if (in_section != in_data)
125: {
126: if (flag_shared_data)
127: {
128: #ifdef SHARED_SECTION_ASM_OP
129: fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
130: #else
131: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
132: #endif
133: }
134: else
135: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
136:
137: in_section = in_data;
138: }
139: }
140:
141: /* Determine if we're in the text section. */
142:
143: int
144: in_text_section ()
145: {
146: return in_section == in_text;
147: }
148:
149: /* Create the rtl to represent a function, for a function definition.
150: DECL is a FUNCTION_DECL node which describes which function.
151: The rtl is stored into DECL. */
152:
153: void
154: make_function_rtl (decl)
155: tree decl;
156: {
157: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
158:
159: /* Rename a nested function to avoid conflicts. */
160: if (decl_function_context (decl) != 0
161: && DECL_INITIAL (decl) != 0
162: && DECL_RTL (decl) == 0)
163: {
164: char *label;
165:
166: name = IDENTIFIER_POINTER (DECL_NAME (decl));
167: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
168: name = obstack_copy0 (saveable_obstack, label, strlen (label));
169: var_labelno++;
170: }
171:
172: if (DECL_RTL (decl) == 0)
173: {
174: DECL_RTL (decl)
175: = gen_rtx (MEM, DECL_MODE (decl),
176: gen_rtx (SYMBOL_REF, Pmode, name));
177:
178: /* Optionally set flags or add text to the name to record information
179: such as that it is a function name. If the name is changed, the macro
180: ASM_OUTPUT_LABELREF will have to know how to strip this information.
181: And if it finds a * at the beginning after doing so, it must handle
182: that too. */
183: #ifdef ENCODE_SECTION_INFO
184: ENCODE_SECTION_INFO (decl);
185: #endif
186: }
187:
188: /* Record at least one function has been defined. */
189: function_defined = 1;
190: }
191:
192: /* Decode an `asm' spec for a declaration as a register name.
193: Return the register number, or -1 if nothing specified,
194: or -2 if the name is not a register. */
195:
196: int
197: decode_reg_name (asmspec)
198: char *asmspec;
199: {
200: if (asmspec != 0)
201: {
202: int i;
203:
204: /* Allow a decimal number as a "register name". */
205: for (i = strlen (asmspec) - 1; i >= 0; i--)
206: if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
207: break;
208: if (asmspec[0] != 0 && i < 0)
209: {
210: i = atoi (asmspec);
211: if (i < FIRST_PSEUDO_REGISTER && i >= 0)
212: return i;
213: else
214: return -2;
215: }
216:
217: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
218: if (reg_names[i][0] && ! strcmp (asmspec, reg_names[i]))
219: return i;
220:
221: if (asmspec[0] == '%')
222: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
223: if (reg_names[i][0] && ! strcmp (asmspec + 1, reg_names[i]))
224: return i;
225:
226: #ifdef ADDITIONAL_REGISTER_NAMES
227: {
228: static struct { char *name; int number; } table[]
229: = ADDITIONAL_REGISTER_NAMES;
230:
231: for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
232: if (! strcmp (asmspec, table[i].name))
233: return table[i].number;
234:
235: if (asmspec[0] == '%')
236: for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
237: if (! strcmp (asmspec + 1, table[i].name))
238: return table[i].number;
239: }
240: #endif /* ADDITIONAL_REGISTER_NAMES */
241:
242: return -2;
243: }
244:
245: return -1;
246: }
247:
248: /* Create the DECL_RTL for a declaration for a static or external variable
249: or static or external function.
250: ASMSPEC, if not 0, is the string which the user specified
251: as the assembler symbol name.
252: TOP_LEVEL is nonzero if this is a file-scope variable.
253:
254: This is never called for PARM_DECL nodes. */
255:
256: void
257: make_decl_rtl (decl, asmspec, top_level)
258: tree decl;
259: char *asmspec;
260: int top_level;
261: {
262: register char *name;
263: int reg_number = decode_reg_name (asmspec);
264:
265: if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
266: name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
267:
268: if (reg_number == -2)
269: {
270: /* ASMSPEC is given, and not the name of a register. */
271: name = (char *) obstack_alloc (saveable_obstack,
272: strlen (asmspec) + 2);
273: name[0] = '*';
274: strcpy (&name[1], asmspec);
275: }
276:
277: /* For a duplicate declaration, we can be called twice on the
278: same DECL node. Don't alter the RTL already made
279: unless the old mode is wrong (which can happen when
280: the previous rtl was made when the type was incomplete). */
281: if (DECL_RTL (decl) == 0
282: || GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
283: {
284: DECL_RTL (decl) = 0;
285:
286: /* First detect errors in declaring global registers. */
287: if (TREE_REGDECL (decl) && reg_number == -1)
288: error_with_decl (decl,
289: "register name not specified for `%s'");
290: else if (TREE_REGDECL (decl) && reg_number == -2)
291: error_with_decl (decl,
292: "invalid register name for `%s'");
293: else if (reg_number >= 0 && ! TREE_REGDECL (decl))
294: error_with_decl (decl,
295: "register name given for non-register variable `%s'");
296: else if (TREE_REGDECL (decl) && TREE_CODE (decl) == FUNCTION_DECL)
297: error ("function declared `register'");
298: else if (TREE_REGDECL (decl) && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
299: error_with_decl (decl, "data type of `%s' isn't suitable for a register");
300: /* Now handle properly declared static register variables. */
301: else if (TREE_REGDECL (decl))
302: {
303: int nregs;
304: #if 0 /* yylex should print the warning for this */
305: if (pedantic)
306: pedwarn ("ANSI C forbids global register variables");
307: #endif
308: if (DECL_INITIAL (decl) != 0 && top_level)
309: {
310: DECL_INITIAL (decl) = 0;
311: error ("global register variable has initial value");
312: }
313: if (fixed_regs[reg_number] == 0
314: && function_defined && top_level)
315: error ("global register variable follows a function definition");
316: if (TREE_THIS_VOLATILE (decl))
317: warning ("volatile register variables don't work as you might wish");
318: DECL_RTL (decl) = gen_rtx (REG, DECL_MODE (decl), reg_number);
319: REG_USERVAR_P (DECL_RTL (decl)) = 1;
320:
321: if (top_level)
322: {
323: /* Make this register fixed, so not usable for anything else. */
324: nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
325: while (nregs > 0)
326: global_regs[reg_number + --nregs] = 1;
327: init_reg_sets_1 ();
328: }
329: }
330:
331: /* Now handle ordinary static variables and functions (in memory).
332: Also handle vars declared register invalidly. */
333: if (DECL_RTL (decl) == 0)
334: {
335: /* Can't use just the variable's own name for a variable
336: whose scope is less than the whole file.
337: Concatenate a distinguishing number. */
338: if (!top_level && !TREE_EXTERNAL (decl) && asmspec == 0)
339: {
340: char *label;
341:
342: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
343: name = obstack_copy0 (saveable_obstack, label, strlen (label));
344: var_labelno++;
345: }
346:
347: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
348: gen_rtx (SYMBOL_REF, Pmode, name));
349: if (TREE_THIS_VOLATILE (decl))
350: MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
351: if (TREE_READONLY (decl))
352: RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
353: MEM_IN_STRUCT_P (DECL_RTL (decl))
354: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
355: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
356: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE);
357:
358: /* Optionally set flags or add text to the name to record information
359: such as that it is a function name.
360: If the name is changed, the macro ASM_OUTPUT_LABELREF
361: will have to know how to strip this information.
362: And if it finds a * at the beginning after doing so,
363: it must handle that too. */
364: #ifdef ENCODE_SECTION_INFO
365: ENCODE_SECTION_INFO (decl);
366: #endif
367: }
368: }
369: }
370:
371: /* Output a string of literal assembler code
372: for an `asm' keyword used between functions. */
373:
374: void
375: assemble_asm (string)
376: tree string;
377: {
378: app_enable ();
379:
380: if (TREE_CODE (string) == ADDR_EXPR)
381: string = TREE_OPERAND (string, 0);
382:
383: fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
384: }
385:
386: /* Tiemann: please get rid of this conditional and put appropriate
387: definitions in each of the files that should have them.
388: The type of debugging format is not the right parameter to
389: control how some other aspect of assembler output is done. */
390:
391: #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
392: #ifndef ASM_OUTPUT_CONSTRUCTOR
393: #define ASM_OUTPUT_CONSTRUCTOR(file, name)
394: #endif
395: #ifndef ASM_OUTPUT_DESTRUCTOR
396: #define ASM_OUTPUT_DESTRUCTOR(file, name)
397: #endif
398: #endif
399:
400: /* Record an element in the table of global destructors.
401: How this is done depends on what sort of assembler and linker
402: are in use.
403:
404: NAME should be the name of a global function to be called
405: at exit time. This name is output using assemble_name. */
406:
407: void
408: assemble_destructor (name)
409: char *name;
410: {
411: #ifdef ASM_OUTPUT_DESTRUCTOR
412: ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
413: #else
414: if (flag_gnu_linker)
415: {
416: /* Now tell GNU LD that this is part of the static destructor set. */
417: /* This code works for any machine provided you use GNU as/ld. */
418: fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
419: assemble_name (asm_out_file, name);
420: fputc ('\n', asm_out_file);
421: }
422: #endif
423: }
424:
425: /* Likewise for global constructors. */
426:
427: void
428: assemble_constructor (name)
429: char *name;
430: {
431: #ifdef ASM_OUTPUT_CONSTRUCTOR
432: ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
433: #else
434: if (flag_gnu_linker)
435: {
436: /* Now tell GNU LD that this is part of the static constructor set. */
437: /* This code works for any machine provided you use GNU as/ld. */
438: fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
439: assemble_name (asm_out_file, name);
440: fputc ('\n', asm_out_file);
441: }
442: #endif
443: }
444:
445: /* Likewise for entries we want to record for garbage collection.
446: Garbage collection is still under development. */
447:
448: void
449: assemble_gc_entry (name)
450: char *name;
451: {
452: #ifdef ASM_OUTPUT_GC_ENTRY
453: ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
454: #else
455: if (flag_gnu_linker)
456: {
457: /* Now tell GNU LD that this is part of the static constructor set. */
458: fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
459: assemble_name (asm_out_file, name);
460: fputc ('\n', asm_out_file);
461: }
462: #endif
463: }
464:
465: /* Output assembler code for the constant pool of a function and associated
466: with defining the name of the function. DECL describes the function.
467: NAME is the function's name. For the constant pool, we use the current
468: constant pool data. */
469:
470: void
471: assemble_start_function (decl, fnname)
472: tree decl;
473: char *fnname;
474: {
475: int align;
476:
477: /* The following code does not need preprocessing in the assembler. */
478:
479: app_disable ();
480:
481: output_constant_pool (fnname, decl);
482:
483: text_section ();
484:
485:
486: /* Tell assembler to move to target machine's alignment for functions. */
487: align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
488: if (align > 0)
489: ASM_OUTPUT_ALIGN (asm_out_file, align);
490:
491: #ifdef ASM_OUTPUT_FUNCTION_PREFIX
492: ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
493: #endif
494:
495: #ifdef SDB_DEBUGGING_INFO
496: /* Output SDB definition of the function. */
497: if (write_symbols == SDB_DEBUG)
498: sdbout_mark_begin_function ();
499: #endif
500:
501: #ifdef DBX_DEBUGGING_INFO
502: /* Output SDB definition of the function. */
503: if (write_symbols == DBX_DEBUG)
504: dbxout_begin_function ();
505: #endif
506:
507: /* Make function name accessible from other files, if appropriate. */
508:
509: if (TREE_PUBLIC (decl))
510: {
511: if (!first_global_object_name)
512: first_global_object_name = fnname + (fnname[0] == '*');
513: ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
514: }
515:
516: /* Do any machine/system dependent processing of the function name */
517: #ifdef ASM_DECLARE_FUNCTION_NAME
518: ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
519: #else
520: /* Standard thing is just output label for the function. */
521: ASM_OUTPUT_LABEL (asm_out_file, fnname);
522: #endif /* ASM_DECLARE_FUNCTION_NAME */
523: }
524:
525: /* Output assembler code associated with defining the size of the
526: function. DECL describes the function. NAME is the function's name. */
527:
528: void
529: assemble_end_function (decl, fnname)
530: tree decl;
531: char *fnname;
532: {
533: #ifdef ASM_DECLARE_FUNCTION_SIZE
534: ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
535: #endif
536: }
537:
538: /* Assemble code to leave SIZE bytes of zeros. */
539:
540: void
541: assemble_zeros (size)
542: int size;
543: {
544: #ifdef ASM_NO_SKIP_IN_TEXT
545: /* The `space' pseudo in the text section outputs nop insns rather than 0s,
546: so we must output 0s explicitly in the text section. */
547: if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
548: {
549: int i;
550:
551: for (i = 0; i < size - 20; i += 20)
552: {
553: #ifdef ASM_BYTE_OP
554: fprintf (asm_out_file,
555: "%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);
556: #else
557: fprintf (asm_out_file,
558: "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
559: #endif
560: }
561: if (i < size)
562: {
563: #ifdef ASM_BYTE_OP
564: fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
565: #else
566: fprintf (asm_out_file, "\tbyte 0");
567: #endif
568: i++;
569: for (; i < size; i++)
570: fprintf (asm_out_file, ",0");
571: fprintf (asm_out_file, "\n");
572: }
573: }
574: else
575: #endif
576: ASM_OUTPUT_SKIP (asm_out_file, size);
577: }
578:
579: /* Assemble a string constant with the specified C string as contents. */
580:
581: void
582: assemble_string (p, size)
583: unsigned char *p;
584: int size;
585: {
586: register int i;
587: int pos = 0;
588: int maximum = 2000;
589:
590: /* If the string is very long, split it up. */
591:
592: while (pos < size)
593: {
594: int thissize = size - pos;
595: if (thissize > maximum)
596: thissize = maximum;
597:
598: #ifdef ASM_OUTPUT_ASCII
599: ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
600: #else
601: fprintf (asm_out_file, "\t.ascii \"");
602:
603: for (i = 0; i < thissize; i++)
604: {
605: register int c = p[i];
606: if (c == '\"' || c == '\\')
607: putc ('\\', asm_out_file);
608: if (c >= ' ' && c < 0177)
609: putc (c, asm_out_file);
610: else
611: {
612: fprintf (asm_out_file, "\\%o", c);
613: /* After an octal-escape, if a digit follows,
614: terminate one string constant and start another.
615: The Vax assembler fails to stop reading the escape
616: after three digits, so this is the only way we
617: can get it to parse the data properly. */
618: if (i < thissize - 1
619: && p[i + 1] >= '0' && p[i + 1] <= '9')
620: fprintf (asm_out_file, "\"\n\t.ascii \"");
621: }
622: }
623: fprintf (asm_out_file, "\"\n");
624: #endif /* no ASM_OUTPUT_ASCII */
625:
626: pos += thissize;
627: p += thissize;
628: }
629: }
630:
631: /* Assemble everything that is needed for a variable or function declaration.
632: Not used for automatic variables, and not used for function definitions.
633: Should not be called for variables of incomplete structure type.
634:
635: TOP_LEVEL is nonzero if this variable has file scope.
636: AT_END is nonzero if this is the special handling, at end of compilation,
637: to define things that have had only tentative definitions. */
638:
639: void
640: assemble_variable (decl, top_level, at_end)
641: tree decl;
642: int top_level;
643: int at_end;
644: {
645: register char *name;
646: int align;
647: tree size_tree;
648: int reloc = 0;
649:
650: if (GET_CODE (DECL_RTL (decl)) == REG)
651: {
652: /* Do output symbol info for global register variables, but do nothing
653: else for them. */
654:
655: if (TREE_ASM_WRITTEN (decl))
656: return;
657: TREE_ASM_WRITTEN (decl) = 1;
658:
659: #ifdef DBX_DEBUGGING_INFO
660: /* File-scope global variables are output here. */
661: if (write_symbols == DBX_DEBUG && top_level)
662: dbxout_symbol (decl, 0);
663: #endif
664: #ifdef SDB_DEBUGGING_INFO
665: if (write_symbols == SDB_DEBUG && top_level
666: /* Leave initialized global vars for end of compilation;
667: see comment in compile_file. */
668: && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
669: sdbout_symbol (decl, 0);
670: #endif
671:
672: /* Don't output any DWARF debugging information for variables here.
673: In the case of local variables, the information for them is output
674: when we do our recursive traversal of the tree representation for
675: the entire containing function. In the case of file-scope variables,
676: we output information for all of them at the very end of compilation
677: while we are doing our final traversal of the chain of file-scope
678: declarations. */
679:
680: return;
681: }
682:
683: /* Normally no need to say anything for external references,
684: since assembler considers all undefined symbols external. */
685:
686: if (TREE_EXTERNAL (decl))
687: return;
688:
689: /* Output no assembler code for a function declaration.
690: Only definitions of functions output anything. */
691:
692: if (TREE_CODE (decl) == FUNCTION_DECL)
693: return;
694:
695: /* If type was incomplete when the variable was declared,
696: see if it is complete now. */
697:
698: if (DECL_SIZE (decl) == 0)
699: layout_decl (decl, 0);
700:
701: /* Still incomplete => don't allocate it; treat the tentative defn
702: (which is what it must have been) as an `extern' reference. */
703:
704: if (DECL_SIZE (decl) == 0)
705: {
706: error_with_file_and_line (DECL_SOURCE_FILE (decl),
707: DECL_SOURCE_LINE (decl),
708: "storage size of static var `%s' isn't known",
709: IDENTIFIER_POINTER (DECL_NAME (decl)));
710: return;
711: }
712:
713: /* The first declaration of a variable that comes through this function
714: decides whether it is global (in C, has external linkage)
715: or local (in C, has internal linkage). So do nothing more
716: if this function has already run. */
717:
718: if (TREE_ASM_WRITTEN (decl))
719: return;
720:
721: TREE_ASM_WRITTEN (decl) = 1;
722:
723: #ifdef DBX_DEBUGGING_INFO
724: /* File-scope global variables are output here. */
725: if (write_symbols == DBX_DEBUG && top_level)
726: dbxout_symbol (decl, 0);
727: #endif
728: #ifdef SDB_DEBUGGING_INFO
729: if (write_symbols == SDB_DEBUG && top_level
730: /* Leave initialized global vars for end of compilation;
731: see comment in compile_file. */
732: && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
733: sdbout_symbol (decl, 0);
734: #endif
735:
736: /* Don't output any DWARF debugging information for variables here.
737: In the case of local variables, the information for them is output
738: when we do our recursive traversal of the tree representation for
739: the entire containing function. In the case of file-scope variables,
740: we output information for all of them at the very end of compilation
741: while we are doing our final traversal of the chain of file-scope
742: declarations. */
743:
744: /* If storage size is erroneously variable, just continue.
745: Error message was already made. */
746:
747: if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
748: return;
749:
750: app_disable ();
751:
752: /* This is better than explicit arithmetic, since it avoids overflow. */
753: size_tree = size_binop (CEIL_DIV_EXPR,
754: DECL_SIZE (decl), size_int (BITS_PER_UNIT));
755:
756: if (TREE_INT_CST_HIGH (size_tree) != 0)
757: {
758: error_with_decl (decl, "size of variable `%s' is too large");
759: return;
760: }
761:
762: name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
763:
764: /* Handle uninitialized definitions. */
765:
766: /* ANSI specifies that a tentative definition which is not merged with
767: a non-tentative definition behaves exactly like a definition with an
768: initializer equal to zero. (Section 3.7.2)
769: -fno-common gives strict ANSI behavior. Usually you don't want it. */
770: if (! flag_no_common
771: && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
772: {
773: int size = TREE_INT_CST_LOW (size_tree);
774: int rounded = size;
775:
776: if (TREE_INT_CST_HIGH (size_tree) != 0)
777: error_with_decl (decl, "size of variable `%s' is too large");
778: /* Don't allocate zero bytes of common,
779: since that means "undefined external" in the linker. */
780: if (size == 0) rounded = 1;
781: /* Round size up to multiple of BIGGEST_ALIGNMENT bits
782: so that each uninitialized object starts on such a boundary. */
783: rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
784: rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
785: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
786: #if 0
787: if (flag_shared_data)
788: data_section ();
789: #endif
790: if (TREE_PUBLIC (decl))
791: {
792: #ifdef ASM_OUTPUT_SHARED_COMMON
793: if (flag_shared_data)
794: ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
795: else
796: #endif
797: #ifdef ASM_OUTPUT_ALIGNED_COMMON
798: ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
799: DECL_ALIGN (decl));
800: #else
801: ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
802: #endif
803: }
804: else
805: {
806: #ifdef ASM_OUTPUT_SHARED_LOCAL
807: if (flag_shared_data)
808: ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
809: else
810: #endif
811: #ifdef ASM_OUTPUT_ALIGNED_LOCAL
812: ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
813: DECL_ALIGN (decl));
814: #else
815: ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
816: #endif
817: }
818: return;
819: }
820:
821: /* Handle initialized definitions. */
822:
823: /* First make the assembler name(s) global if appropriate. */
824: if (TREE_PUBLIC (decl) && DECL_NAME (decl))
825: {
826: if (!first_global_object_name)
827: first_global_object_name = name + (name[0] == '*');
828: ASM_GLOBALIZE_LABEL (asm_out_file, name);
829: }
830: #if 0
831: for (d = equivalents; d; d = TREE_CHAIN (d))
832: {
833: tree e = TREE_VALUE (d);
834: if (TREE_PUBLIC (e) && DECL_NAME (e))
835: ASM_GLOBALIZE_LABEL (asm_out_file,
836: XSTR (XEXP (DECL_RTL (e), 0), 0));
837: }
838: #endif
839:
840: /* Output any data that we will need to use the address of. */
841: if (DECL_INITIAL (decl))
842: reloc = output_addressed_constants (DECL_INITIAL (decl));
843:
844: /* Switch to the proper section for this data. */
845: #ifdef SELECT_SECTION
846: SELECT_SECTION (decl, reloc);
847: #else
848: if (TREE_READONLY (decl)
849: && ! TREE_THIS_VOLATILE (decl)
850: && ! (flag_pic && reloc))
851: readonly_data_section ();
852: else
853: data_section ();
854: #endif
855:
856: /* Compute and output the alignment of this data. */
857:
858: align = DECL_ALIGN (decl);
859: /* Some object file formats have a maximum alignment which they support.
860: In particular, a.out format supports a maximum alignment of 4. */
861: #ifndef MAX_OFILE_ALIGNMENT
862: #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
863: #endif
864: if (align > MAX_OFILE_ALIGNMENT)
865: {
866: warning_with_decl (decl,
867: "alignment of `%s' is greater than maximum object file alignment");
868: align = MAX_OFILE_ALIGNMENT;
869: }
870: #ifdef DATA_ALIGNMENT
871: /* On some machines, it is good to increase alignment sometimes. */
872: align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
873: #endif
874: #ifdef CONSTANT_ALIGNMENT
875: if (DECL_INITIAL (decl))
876: align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
877: #endif
878:
879: /* Reset the alignment in case we have made it tighter, so we can benefit
880: from it in get_pointer_alignment. */
881: DECL_ALIGN (decl) = align;
882:
883: if (align > BITS_PER_UNIT)
884: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
885:
886: /* Do any machine/system dependent processing of the object. */
887: #ifdef ASM_DECLARE_OBJECT_NAME
888: ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
889: #else
890: /* Standard thing is just output label for the object. */
891: ASM_OUTPUT_LABEL (asm_out_file, name);
892: #endif /* ASM_DECLARE_OBJECT_NAME */
893:
894: #if 0
895: for (d = equivalents; d; d = TREE_CHAIN (d))
896: {
897: tree e = TREE_VALUE (d);
898: ASM_OUTPUT_LABEL (asm_out_file, XSTR (XEXP (DECL_RTL (e), 0), 0));
899: }
900: #endif
901:
902: if (DECL_INITIAL (decl))
903: /* Output the actual data. */
904: output_constant (DECL_INITIAL (decl),
905: int_size_in_bytes (TREE_TYPE (decl)));
906: else
907: /* Leave space for it. */
908: assemble_zeros (int_size_in_bytes (TREE_TYPE (decl)));
909: }
910:
911: /* Output something to declare an external symbol to the assembler.
912: (Most assemblers don't need this, so we normally output nothing.)
913: Do nothing if DECL is not external. */
914:
915: void
916: assemble_external (decl)
917: tree decl;
918: {
919: #ifdef ASM_OUTPUT_EXTERNAL
920: if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
921: && TREE_EXTERNAL (decl) && TREE_PUBLIC (decl))
922: {
923: rtx rtl = DECL_RTL (decl);
924:
925: if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
926: && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
927: {
928: /* Some systems do require some output. */
929: SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
930: ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
931: }
932: }
933: #endif
934: }
935:
936: /* Similar, for calling a library function FUN. */
937:
938: void
939: assemble_external_libcall (fun)
940: rtx fun;
941: {
942: #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
943: /* Declare library function name external when first used, if nec. */
944: if (! SYMBOL_REF_USED (fun))
945: {
946: SYMBOL_REF_USED (fun) = 1;
947: ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
948: }
949: #endif
950: }
951:
952: /* Declare the label NAME global. */
953:
954: void
955: assemble_global (name)
956: char *name;
957: {
958: ASM_GLOBALIZE_LABEL (asm_out_file, name);
959: }
960:
961: /* Assemble a label named NAME. */
962:
963: void
964: assemble_label (name)
965: char *name;
966: {
967: ASM_OUTPUT_LABEL (asm_out_file, name);
968: }
969:
970: /* Output to FILE a reference to the assembler name of a C-level name NAME.
971: If NAME starts with a *, the rest of NAME is output verbatim.
972: Otherwise NAME is transformed in an implementation-defined way
973: (usually by the addition of an underscore).
974: Many macros in the tm file are defined to call this function. */
975:
976: void
977: assemble_name (file, name)
978: FILE *file;
979: char *name;
980: {
981: if (name[0] == '*')
982: fputs (&name[1], file);
983: else
984: ASM_OUTPUT_LABELREF (file, name);
985: }
986:
987: /* Allocate SIZE bytes writable static space with a gensym name
988: and return an RTX to refer to its address. */
989:
990: rtx
991: assemble_static_space (size)
992: int size;
993: {
994: char name[12];
995: char *namestring;
996: rtx x;
997: /* Round size up to multiple of BIGGEST_ALIGNMENT bits
998: so that each uninitialized object starts on such a boundary. */
999: int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1000: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1001: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1002:
1003: #if 0
1004: if (flag_shared_data)
1005: data_section ();
1006: #endif
1007:
1008: ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1009: ++const_labelno;
1010:
1011: namestring = (char *) obstack_alloc (saveable_obstack,
1012: strlen (name) + 2);
1013: strcpy (namestring, name);
1014:
1015: x = gen_rtx (SYMBOL_REF, Pmode, namestring);
1016: #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1017: ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1018: #else
1019: ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1020: #endif
1021: return x;
1022: }
1023:
1024: /* Assemble the static constant template for function entry trampolines.
1025: This is done at most once per compilation.
1026: Returns an RTX for the address of the template. */
1027:
1028: rtx
1029: assemble_trampoline_template ()
1030: {
1031: char label[256];
1032: char *name;
1033: int align;
1034:
1035: /* Write the assembler code to define one. */
1036: align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1037: if (align > 0)
1038: ASM_OUTPUT_ALIGN (asm_out_file, align);
1039:
1040: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1041: TRAMPOLINE_TEMPLATE (asm_out_file);
1042:
1043: /* Record the rtl to refer to it. */
1044: ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1045: name
1046: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1047: return gen_rtx (SYMBOL_REF, Pmode, name);
1048: }
1049:
1050: /* Assemble the integer constant X into an object of SIZE bytes.
1051: X must be either a CONST_INT or CONST_DOUBLE.
1052:
1053: Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1054: non-zero, abort if we can't output the constant. */
1055:
1056: int
1057: assemble_integer (x, size, force)
1058: rtx x;
1059: int size;
1060: int force;
1061: {
1062: /* First try to use the standard 1, 2, 4, 8, and 16 byte
1063: ASM_OUTPUT... macros. */
1064:
1065: switch (size)
1066: {
1067: #ifdef ASM_OUTPUT_CHAR
1068: case 1:
1069: ASM_OUTPUT_CHAR (asm_out_file, x);
1070: return 1;
1071: #endif
1072:
1073: #ifdef ASM_OUTPUT_SHORT
1074: case 2:
1075: ASM_OUTPUT_SHORT (asm_out_file, x);
1076: return 1;
1077: #endif
1078:
1079: #ifdef ASM_OUTPUT_INT
1080: case 4:
1081: ASM_OUTPUT_INT (asm_out_file, x);
1082: return 1;
1083: #endif
1084:
1085: #ifdef ASM_OUTPUT_DOUBLE_INT
1086: case 8:
1087: ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1088: return 1;
1089: #endif
1090:
1091: #ifdef ASM_OUTPUT_QUADRUPLE_INT
1092: case 16:
1093: ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1094: return 1;
1095: #endif
1096: }
1097:
1098: /* If we couldn't do it that way, there are two other possibilities: First,
1099: if the machine can output an explicit byte and this is a 1 byte constant,
1100: we can use ASM_OUTPUT_BYTE. */
1101:
1102: #ifdef ASM_OUTPUT_BYTE
1103: if (size == 1 && GET_CODE (x) == CONST_INT)
1104: {
1105: ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1106: return 1;
1107: }
1108: #endif
1109:
1110: /* Finally, if SIZE is larger than a single word, try to output the constant
1111: one word at a time. */
1112:
1113: if (size > UNITS_PER_WORD)
1114: {
1115: int i;
1116: enum machine_mode mode
1117: = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1118: rtx word;
1119:
1120: for (i = 0; i < size / UNITS_PER_WORD; i++)
1121: {
1122: word = operand_subword (x, i, 0, mode);
1123:
1124: if (word == 0)
1125: break;
1126:
1127: if (! assemble_integer (word, UNITS_PER_WORD, 0))
1128: break;
1129: }
1130:
1131: if (i == size / UNITS_PER_WORD)
1132: return 1;
1133: /* If we output at least one word and then could not finish,
1134: there is no valid way to continue. */
1135: if (i > 0)
1136: abort ();
1137: }
1138:
1139: if (force)
1140: abort ();
1141:
1142: return 0;
1143: }
1144:
1145: /* Assemble the floating-point constant D into an object of size MODE. */
1146:
1147: void
1148: assemble_real (d, mode)
1149: REAL_VALUE_TYPE d;
1150: enum machine_mode mode;
1151: {
1152: jmp_buf output_constant_handler;
1153:
1154: if (setjmp (output_constant_handler))
1155: {
1156: error ("floating point trap outputting a constant");
1157: #ifdef REAL_IS_NOT_DOUBLE
1158: bzero (&d, sizeof d);
1159: d = dconst0;
1160: #else
1161: d = 0;
1162: #endif
1163: }
1164:
1165: set_float_handler (output_constant_handler);
1166:
1167: switch (mode)
1168: {
1169: #ifdef ASM_OUTPUT_FLOAT
1170: case SFmode:
1171: ASM_OUTPUT_FLOAT (asm_out_file, d);
1172: break;
1173: #endif
1174:
1175: #ifdef ASM_OUTPUT_DOUBLE
1176: case DFmode:
1177: ASM_OUTPUT_DOUBLE (asm_out_file, d);
1178: break;
1179: #endif
1180:
1181: #ifdef ASM_OUTPUT_LONG_DOUBLE
1182: case TFmode:
1183: ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1184: break;
1185: #endif
1186:
1187: default:
1188: abort ();
1189: }
1190:
1191: set_float_handler (0);
1192: }
1193:
1194: /* Here we combine duplicate floating constants to make
1195: CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1196:
1197: /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
1198: They are chained through the CONST_DOUBLE_CHAIN.
1199: A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
1200: In that case, CONST_DOUBLE_MEM is either a MEM,
1201: or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
1202:
1203: static rtx const_double_chain;
1204:
1205: /* Return a CONST_DOUBLE for a value specified as a pair of ints.
1206: For an integer, I0 is the low-order word and I1 is the high-order word.
1207: For a real number, I0 is the word with the low address
1208: and I1 is the word with the high address. */
1209:
1210: rtx
1211: immed_double_const (i0, i1, mode)
1212: int i0, i1;
1213: enum machine_mode mode;
1214: {
1215: register rtx r;
1216: int in_current_obstack;
1217:
1218: if (GET_MODE_CLASS (mode) == MODE_INT)
1219: {
1220: /* We clear out all bits that don't belong in MODE, unless they and our
1221: sign bit are all one. So we get either a reasonable negative value
1222: or a reasonable unsigned value for this mode. */
1223: int width = GET_MODE_BITSIZE (mode);
1224: if (width < HOST_BITS_PER_INT
1225: && ((i0 & ((-1) << (width - 1))) != ((-1) << (width - 1))))
1226: i0 &= (1 << width) - 1, i1 = 0;
1227: else if (width == HOST_BITS_PER_INT
1228: && ! (i1 == ~0 && i0 < 0))
1229: i1 = 0;
1230: else if (width > 2 * HOST_BITS_PER_INT)
1231: /* We cannot represent this value as a constant. */
1232: abort ();
1233:
1234: /* If MODE fits within HOST_BITS_PER_INT, always use a CONST_INT.
1235:
1236: ??? Strictly speaking, this is wrong if we create a CONST_INT
1237: for a large unsigned constant with the size of MODE being
1238: HOST_BITS_PER_INT and later try to interpret that constant in a wider
1239: mode. In that case we will mis-interpret it as a negative number.
1240:
1241: Unfortunately, the only alternative is to make a CONST_DOUBLE
1242: for any constant in any mode if it is an unsigned constant larger
1243: than the maximum signed integer in an int on the host. However,
1244: doing this will break everyone that always expects to see a CONST_INT
1245: for SImode and smaller.
1246:
1247: We have always been making CONST_INTs in this case, so nothing new
1248: is being broken. */
1249:
1250: if (width <= HOST_BITS_PER_INT)
1251: i1 = (i0 < 0) ? ~0 : 0;
1252:
1253: /* If this integer fits in one word, return a CONST_INT. */
1254: if ((i1 == 0 && i0 >= 0)
1255: || (i1 == ~0 && i0 < 0))
1256: return gen_rtx (CONST_INT, VOIDmode, i0);
1257:
1258: /* We use VOIDmode for integers. */
1259: mode = VOIDmode;
1260: }
1261:
1262: /* Search the chain for an existing CONST_DOUBLE with the right value.
1263: If one is found, return it. */
1264:
1265: for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1266: if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
1267: && GET_MODE (r) == mode)
1268: return r;
1269:
1270: /* No; make a new one and add it to the chain.
1271:
1272: We may be called by an optimizer which may be discarding any memory
1273: allocated during its processing (such as combine and loop). However,
1274: we will be leaving this constant on the chain, so we cannot tolerate
1275: freed memory. So switch to saveable_obstack for this allocation
1276: and then switch back if we were in current_obstack. */
1277:
1278: in_current_obstack = rtl_in_saveable_obstack ();
1279: r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
1280: if (in_current_obstack)
1281: rtl_in_current_obstack ();
1282:
1283: CONST_DOUBLE_CHAIN (r) = const_double_chain;
1284: const_double_chain = r;
1285:
1286: /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
1287: Actual use of mem-slot is only through force_const_mem. */
1288:
1289: CONST_DOUBLE_MEM (r) = const0_rtx;
1290:
1291: return r;
1292: }
1293:
1294: /* Return a CONST_DOUBLE for a specified `double' value
1295: and machine mode. */
1296:
1297: rtx
1298: immed_real_const_1 (d, mode)
1299: REAL_VALUE_TYPE d;
1300: enum machine_mode mode;
1301: {
1302: union real_extract u;
1303: register rtx r;
1304: int in_current_obstack;
1305:
1306: /* Get the desired `double' value as a sequence of ints
1307: since that is how they are stored in a CONST_DOUBLE. */
1308:
1309: u.d = d;
1310:
1311: /* Detect special cases. */
1312:
1313: if (REAL_VALUES_EQUAL (dconst0, d))
1314: return CONST0_RTX (mode);
1315: else if (REAL_VALUES_EQUAL (dconst1, d))
1316: return CONST1_RTX (mode);
1317:
1318: if (sizeof u == 2 * sizeof (int))
1319: return immed_double_const (u.i[0], u.i[1], mode);
1320:
1321: /* The rest of this function handles the case where
1322: a float value requires more than 2 ints of space.
1323: It will be deleted as dead code on machines that don't need it. */
1324:
1325: /* Search the chain for an existing CONST_DOUBLE with the right value.
1326: If one is found, return it. */
1327:
1328: for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1329: if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
1330: && GET_MODE (r) == mode)
1331: return r;
1332:
1333: /* No; make a new one and add it to the chain.
1334:
1335: We may be called by an optimizer which may be discarding any memory
1336: allocated during its processing (such as combine and loop). However,
1337: we will be leaving this constant on the chain, so we cannot tolerate
1338: freed memory. So switch to saveable_obstack for this allocation
1339: and then switch back if we were in current_obstack. */
1340:
1341: in_current_obstack = rtl_in_saveable_obstack ();
1342: r = rtx_alloc (CONST_DOUBLE);
1343: PUT_MODE (r, mode);
1344: bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
1345: if (in_current_obstack)
1346: rtl_in_current_obstack ();
1347:
1348: CONST_DOUBLE_CHAIN (r) = const_double_chain;
1349: const_double_chain = r;
1350:
1351: /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
1352: chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
1353: is only through force_const_mem. */
1354:
1355: CONST_DOUBLE_MEM (r) = const0_rtx;
1356:
1357: return r;
1358: }
1359:
1360: /* Return a CONST_DOUBLE rtx for a value specified by EXP,
1361: which must be a REAL_CST tree node. */
1362:
1363: rtx
1364: immed_real_const (exp)
1365: tree exp;
1366: {
1367: return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
1368: }
1369:
1370: /* At the end of a function, forget the memory-constants
1371: previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
1372: Also clear out real_constant_chain and clear out all the chain-pointers. */
1373:
1374: void
1375: clear_const_double_mem ()
1376: {
1377: register rtx r, next;
1378:
1379: for (r = const_double_chain; r; r = next)
1380: {
1381: next = CONST_DOUBLE_CHAIN (r);
1382: CONST_DOUBLE_CHAIN (r) = 0;
1383: CONST_DOUBLE_MEM (r) = cc0_rtx;
1384: }
1385: const_double_chain = 0;
1386: }
1387:
1388: /* Given an expression EXP with a constant value,
1389: reduce it to the sum of an assembler symbol and an integer.
1390: Store them both in the structure *VALUE.
1391: Abort if EXP does not reduce. */
1392:
1393: struct addr_const
1394: {
1395: rtx base;
1396: int offset;
1397: };
1398:
1399: static void
1400: decode_addr_const (exp, value)
1401: tree exp;
1402: struct addr_const *value;
1403: {
1404: register tree target = TREE_OPERAND (exp, 0);
1405: register int offset = 0;
1406: register rtx x;
1407:
1408: while (1)
1409: {
1410: if (TREE_CODE (target) == COMPONENT_REF
1411: && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
1412: == INTEGER_CST))
1413: {
1414: offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
1415: target = TREE_OPERAND (target, 0);
1416: }
1417: else if (TREE_CODE (target) == ARRAY_REF)
1418: {
1419: if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
1420: || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
1421: abort ();
1422: offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
1423: * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
1424: / BITS_PER_UNIT);
1425: target = TREE_OPERAND (target, 0);
1426: }
1427: else
1428: break;
1429: }
1430:
1431: switch (TREE_CODE (target))
1432: {
1433: case VAR_DECL:
1434: case FUNCTION_DECL:
1435: x = DECL_RTL (target);
1436: break;
1437:
1438: case LABEL_DECL:
1439: x = gen_rtx (MEM, FUNCTION_MODE,
1440: gen_rtx (LABEL_REF, VOIDmode,
1441: label_rtx (TREE_OPERAND (exp, 0))));
1442: break;
1443:
1444: case REAL_CST:
1445: case STRING_CST:
1446: case COMPLEX_CST:
1447: case CONSTRUCTOR:
1448: x = TREE_CST_RTL (target);
1449: break;
1450:
1451: default:
1452: abort ();
1453: }
1454:
1455: if (GET_CODE (x) != MEM)
1456: abort ();
1457: x = XEXP (x, 0);
1458:
1459: value->base = x;
1460: value->offset = offset;
1461: }
1462:
1463: /* Uniquize all constants that appear in memory.
1464: Each constant in memory thus far output is recorded
1465: in `const_hash_table' with a `struct constant_descriptor'
1466: that contains a polish representation of the value of
1467: the constant.
1468:
1469: We cannot store the trees in the hash table
1470: because the trees may be temporary. */
1471:
1472: struct constant_descriptor
1473: {
1474: struct constant_descriptor *next;
1475: char *label;
1476: char contents[1];
1477: };
1478:
1479: #define HASHBITS 30
1480: #define MAX_HASH_TABLE 1009
1481: static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
1482:
1483: /* Compute a hash code for a constant expression. */
1484:
1485: int
1486: const_hash (exp)
1487: tree exp;
1488: {
1489: register char *p;
1490: register int len, hi, i;
1491: register enum tree_code code = TREE_CODE (exp);
1492:
1493: if (code == INTEGER_CST)
1494: {
1495: p = (char *) &TREE_INT_CST_LOW (exp);
1496: len = 2 * sizeof TREE_INT_CST_LOW (exp);
1497: }
1498: else if (code == REAL_CST)
1499: {
1500: p = (char *) &TREE_REAL_CST (exp);
1501: len = sizeof TREE_REAL_CST (exp);
1502: }
1503: else if (code == STRING_CST)
1504: p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
1505: else if (code == COMPLEX_CST)
1506: return const_hash (TREE_REALPART (exp)) * 5
1507: + const_hash (TREE_IMAGPART (exp));
1508: else if (code == CONSTRUCTOR)
1509: {
1510: register tree link;
1511:
1512: /* For record type, include the type in the hashing.
1513: We do not do so for array types
1514: because (1) the sizes of the elements are sufficient
1515: and (2) distinct array types can have the same constructor. */
1516: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
1517: hi = ((int) TREE_TYPE (exp) & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
1518: else
1519: hi = 5;
1520:
1521: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
1522: hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
1523:
1524: return hi;
1525: }
1526: else if (code == ADDR_EXPR)
1527: {
1528: struct addr_const value;
1529: decode_addr_const (exp, &value);
1530: if (GET_CODE (value.base) == SYMBOL_REF)
1531: {
1532: /* Don't hash the address of the SYMBOL_REF;
1533: only use the offset and the symbol name. */
1534: hi = value.offset;
1535: p = XSTR (value.base, 0);
1536: for (i = 0; p[i] != 0; i++)
1537: hi = ((hi * 613) + (unsigned)(p[i]));
1538: }
1539: else if (GET_CODE (value.base) == LABEL_REF)
1540: hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
1541:
1542: hi &= (1 << HASHBITS) - 1;
1543: hi %= MAX_HASH_TABLE;
1544: return hi;
1545: }
1546: else if (code == PLUS_EXPR || code == MINUS_EXPR)
1547: return const_hash (TREE_OPERAND (exp, 0)) * 9
1548: + const_hash (TREE_OPERAND (exp, 1));
1549: else if (code == NOP_EXPR || code == CONVERT_EXPR)
1550: return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
1551:
1552: /* Compute hashing function */
1553: hi = len;
1554: for (i = 0; i < len; i++)
1555: hi = ((hi * 613) + (unsigned)(p[i]));
1556:
1557: hi &= (1 << HASHBITS) - 1;
1558: hi %= MAX_HASH_TABLE;
1559: return hi;
1560: }
1561:
1562: /* Compare a constant expression EXP with a constant-descriptor DESC.
1563: Return 1 if DESC describes a constant with the same value as EXP. */
1564:
1565: static int
1566: compare_constant (exp, desc)
1567: tree exp;
1568: struct constant_descriptor *desc;
1569: {
1570: return 0 != compare_constant_1 (exp, desc->contents);
1571: }
1572:
1573: /* Compare constant expression EXP with a substring P of a constant descriptor.
1574: If they match, return a pointer to the end of the substring matched.
1575: If they do not match, return 0.
1576:
1577: Since descriptors are written in polish prefix notation,
1578: this function can be used recursively to test one operand of EXP
1579: against a subdescriptor, and if it succeeds it returns the
1580: address of the subdescriptor for the next operand. */
1581:
1582: static char *
1583: compare_constant_1 (exp, p)
1584: tree exp;
1585: char *p;
1586: {
1587: register char *strp;
1588: register int len;
1589: register enum tree_code code = TREE_CODE (exp);
1590:
1591: if (code != (enum tree_code) *p++)
1592: return 0;
1593:
1594: if (code == INTEGER_CST)
1595: {
1596: /* Integer constants are the same only if the same width of type. */
1597: if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
1598: return 0;
1599: strp = (char *) &TREE_INT_CST_LOW (exp);
1600: len = 2 * sizeof TREE_INT_CST_LOW (exp);
1601: }
1602: else if (code == REAL_CST)
1603: {
1604: /* Real constants are the same only if the same width of type. */
1605: if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
1606: return 0;
1607: strp = (char *) &TREE_REAL_CST (exp);
1608: len = sizeof TREE_REAL_CST (exp);
1609: }
1610: else if (code == STRING_CST)
1611: {
1612: if (flag_writable_strings)
1613: return 0;
1614: strp = TREE_STRING_POINTER (exp);
1615: len = TREE_STRING_LENGTH (exp);
1616: if (bcmp (&TREE_STRING_LENGTH (exp), p,
1617: sizeof TREE_STRING_LENGTH (exp)))
1618: return 0;
1619: p += sizeof TREE_STRING_LENGTH (exp);
1620: }
1621: else if (code == COMPLEX_CST)
1622: {
1623: p = compare_constant_1 (TREE_REALPART (exp), p);
1624: if (p == 0) return 0;
1625: p = compare_constant_1 (TREE_IMAGPART (exp), p);
1626: return p;
1627: }
1628: else if (code == CONSTRUCTOR)
1629: {
1630: register tree link;
1631: int length = list_length (CONSTRUCTOR_ELTS (exp));
1632: tree type;
1633:
1634: if (bcmp (&length, p, sizeof length))
1635: return 0;
1636: p += sizeof length;
1637:
1638: /* For record constructors, insist that the types match.
1639: For arrays, just verify both constructors are for arrays. */
1640: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
1641: type = TREE_TYPE (exp);
1642: else
1643: type = 0;
1644: if (bcmp (&type, p, sizeof type))
1645: return 0;
1646: p += sizeof type;
1647:
1648: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
1649: if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
1650: return 0;
1651: return p;
1652: }
1653: else if (code == ADDR_EXPR)
1654: {
1655: struct addr_const value;
1656: decode_addr_const (exp, &value);
1657: strp = (char *) &value.offset;
1658: len = sizeof value.offset;
1659: /* Compare the offset. */
1660: while (--len >= 0)
1661: if (*p++ != *strp++)
1662: return 0;
1663: /* Compare symbol name. */
1664: strp = XSTR (value.base, 0);
1665: len = strlen (strp) + 1;
1666: }
1667: else if (code == PLUS_EXPR || code == MINUS_EXPR)
1668: {
1669: p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
1670: if (p == 0) return 0;
1671: p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
1672: return p;
1673: }
1674: else if (code == NOP_EXPR || code == CONVERT_EXPR)
1675: {
1676: p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
1677: return p;
1678: }
1679:
1680: /* Compare constant contents. */
1681: while (--len >= 0)
1682: if (*p++ != *strp++)
1683: return 0;
1684:
1685: return p;
1686: }
1687:
1688: /* Construct a constant descriptor for the expression EXP.
1689: It is up to the caller to enter the descriptor in the hash table. */
1690:
1691: static struct constant_descriptor *
1692: record_constant (exp)
1693: tree exp;
1694: {
1695: struct constant_descriptor *ptr = 0;
1696: int buf;
1697:
1698: obstack_grow (&permanent_obstack, &ptr, sizeof ptr);
1699: obstack_grow (&permanent_obstack, &buf, sizeof buf);
1700: record_constant_1 (exp);
1701: return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
1702: }
1703:
1704: /* Add a description of constant expression EXP
1705: to the object growing in `permanent_obstack'.
1706: No need to return its address; the caller will get that
1707: from the obstack when the object is complete. */
1708:
1709: static void
1710: record_constant_1 (exp)
1711: tree exp;
1712: {
1713: register char *strp;
1714: register int len;
1715: register enum tree_code code = TREE_CODE (exp);
1716:
1717: obstack_1grow (&permanent_obstack, (unsigned int) code);
1718:
1719: if (code == INTEGER_CST)
1720: {
1721: obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
1722: strp = (char *) &TREE_INT_CST_LOW (exp);
1723: len = 2 * sizeof TREE_INT_CST_LOW (exp);
1724: }
1725: else if (code == REAL_CST)
1726: {
1727: obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
1728: strp = (char *) &TREE_REAL_CST (exp);
1729: len = sizeof TREE_REAL_CST (exp);
1730: }
1731: else if (code == STRING_CST)
1732: {
1733: if (flag_writable_strings)
1734: return;
1735: strp = TREE_STRING_POINTER (exp);
1736: len = TREE_STRING_LENGTH (exp);
1737: obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
1738: sizeof TREE_STRING_LENGTH (exp));
1739: }
1740: else if (code == COMPLEX_CST)
1741: {
1742: record_constant_1 (TREE_REALPART (exp));
1743: record_constant_1 (TREE_IMAGPART (exp));
1744: return;
1745: }
1746: else if (code == CONSTRUCTOR)
1747: {
1748: register tree link;
1749: int length = list_length (CONSTRUCTOR_ELTS (exp));
1750: tree type;
1751:
1752: obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
1753:
1754: /* For record constructors, insist that the types match.
1755: For arrays, just verify both constructors are for arrays. */
1756: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
1757: type = TREE_TYPE (exp);
1758: else
1759: type = 0;
1760: obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
1761:
1762: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
1763: record_constant_1 (TREE_VALUE (link));
1764: return;
1765: }
1766: else if (code == ADDR_EXPR)
1767: {
1768: struct addr_const value;
1769: decode_addr_const (exp, &value);
1770: /* Record the offset. */
1771: obstack_grow (&permanent_obstack,
1772: (char *) &value.offset, sizeof value.offset);
1773: /* Record the symbol name. */
1774: obstack_grow (&permanent_obstack, XSTR (value.base, 0),
1775: strlen (XSTR (value.base, 0)) + 1);
1776: return;
1777: }
1778: else if (code == PLUS_EXPR || code == MINUS_EXPR)
1779: {
1780: record_constant_1 (TREE_OPERAND (exp, 0));
1781: record_constant_1 (TREE_OPERAND (exp, 1));
1782: return;
1783: }
1784: else if (code == NOP_EXPR || code == CONVERT_EXPR)
1785: {
1786: record_constant_1 (TREE_OPERAND (exp, 0));
1787: return;
1788: }
1789:
1790: /* Record constant contents. */
1791: obstack_grow (&permanent_obstack, strp, len);
1792: }
1793:
1794: /* Return an rtx representing a reference to constant data in memory
1795: for the constant expression EXP.
1796: If assembler code for such a constant has already been output,
1797: return an rtx to refer to it.
1798: Otherwise, output such a constant in memory and generate
1799: an rtx for it. The TREE_CST_RTL of EXP is set up to point to that rtx.
1800: The const_hash_table records which constants already have label strings. */
1801:
1802: rtx
1803: output_constant_def (exp)
1804: tree exp;
1805: {
1806: register int hash, align;
1807: register struct constant_descriptor *desc;
1808: char label[256];
1809: char *found = 0;
1810: int reloc;
1811: register rtx def;
1812:
1813: if (TREE_CODE (exp) == INTEGER_CST)
1814: abort (); /* No TREE_CST_RTL slot in these. */
1815:
1816: if (TREE_CST_RTL (exp))
1817: return TREE_CST_RTL (exp);
1818:
1819: /* Make sure any other constants whose addresses appear in EXP
1820: are assigned label numbers. */
1821:
1822: reloc = output_addressed_constants (exp);
1823:
1824: /* Compute hash code of EXP. Search the descriptors for that hash code
1825: to see if any of them describes EXP. If yes, the descriptor records
1826: the label number already assigned. */
1827:
1828: hash = const_hash (exp) % MAX_HASH_TABLE;
1829:
1830: for (desc = const_hash_table[hash]; desc; desc = desc->next)
1831: if (compare_constant (exp, desc))
1832: {
1833: found = desc->label;
1834: break;
1835: }
1836:
1837: if (found == 0)
1838: {
1839: /* No constant equal to EXP is known to have been output.
1840: Make a constant descriptor to enter EXP in the hash table.
1841: Assign the label number and record it in the descriptor for
1842: future calls to this function to find. */
1843:
1844: /* Create a string containing the label name, in LABEL. */
1845: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
1846:
1847: desc = record_constant (exp);
1848: desc->next = const_hash_table[hash];
1849: desc->label
1850: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1851: const_hash_table[hash] = desc;
1852: }
1853:
1854: /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
1855:
1856: push_obstacks_nochange ();
1857: if (TREE_PERMANENT (exp))
1858: end_temporary_allocation ();
1859:
1860: def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
1861:
1862: TREE_CST_RTL (exp)
1863: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
1864: RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
1865:
1866: pop_obstacks ();
1867:
1868: /* Optionally set flags or add text to the name to record information
1869: such as that it is a function name. If the name is changed, the macro
1870: ASM_OUTPUT_LABELREF will have to know how to strip this information.
1871: And if it finds a * at the beginning after doing so, it must handle
1872: that too. */
1873: #ifdef ENCODE_SECTION_INFO
1874: ENCODE_SECTION_INFO (exp);
1875: #endif
1876:
1877: if (found == 0)
1878: {
1879: /* Now output assembler code to define that label
1880: and follow it with the data of EXP. */
1881:
1882: /* First switch to text section, except for writable strings. */
1883: #ifdef SELECT_SECTION
1884: SELECT_SECTION (exp, reloc);
1885: #else
1886: if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
1887: || (flag_pic && reloc))
1888: data_section ();
1889: else
1890: readonly_data_section ();
1891: #endif
1892:
1893: /* Align the location counter as required by EXP's data type. */
1894: align = TYPE_ALIGN (TREE_TYPE (exp));
1895: #ifdef CONSTANT_ALIGNMENT
1896: align = CONSTANT_ALIGNMENT (exp, align);
1897: #endif
1898:
1899: if (align > BITS_PER_UNIT)
1900: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1901:
1902: /* Output the label itself. */
1903: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno);
1904:
1905: /* Output the value of EXP. */
1906: output_constant (exp,
1907: (TREE_CODE (exp) == STRING_CST
1908: ? TREE_STRING_LENGTH (exp)
1909: : int_size_in_bytes (TREE_TYPE (exp))));
1910:
1911: ++const_labelno;
1912: }
1913:
1914: return TREE_CST_RTL (exp);
1915: }
1916:
1917: /* Similar hash facility for making memory-constants
1918: from constant rtl-expressions. It is used on RISC machines
1919: where immediate integer arguments and constant addresses are restricted
1920: so that such constants must be stored in memory.
1921:
1922: This pool of constants is reinitialized for each function
1923: so each function gets its own constants-pool that comes right before it.
1924:
1925: All structures allocated here are discarded when functions are saved for
1926: inlining, so they do not need to be allocated permanently. */
1927:
1928: #define MAX_RTX_HASH_TABLE 61
1929: static struct constant_descriptor *const_rtx_hash_table[MAX_RTX_HASH_TABLE];
1930:
1931: /* Structure to represent sufficient information about a constant so that
1932: it can be output when the constant pool is output, so that function
1933: integration can be done, and to simplify handling on machines that reference
1934: constant pool as base+displacement. */
1935:
1936: struct pool_constant
1937: {
1938: struct constant_descriptor *desc;
1939: struct pool_constant *next;
1940: enum machine_mode mode;
1941: rtx constant;
1942: int labelno;
1943: int align;
1944: int offset;
1945: };
1946:
1947: /* Pointers to first and last constant in pool. */
1948:
1949: static struct pool_constant *first_pool, *last_pool;
1950:
1951: /* Current offset in constant pool (does not include any machine-specific
1952: header. */
1953:
1954: static int pool_offset;
1955:
1956: /* Structure used to maintain hash table mapping symbols used to their
1957: corresponding constants. */
1958:
1959: struct pool_sym
1960: {
1961: char *label;
1962: struct pool_constant *pool;
1963: struct pool_sym *next;
1964: };
1965:
1966: static struct pool_sym *const_rtx_sym_hash_table[MAX_RTX_HASH_TABLE];
1967:
1968: /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
1969: The argument is XSTR (... , 0) */
1970:
1971: #define SYMHASH(LABEL) \
1972: ((((int) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
1973:
1974: /* Initialize constant pool hashing for next function. */
1975:
1976: void
1977: init_const_rtx_hash_table ()
1978: {
1979: bzero (const_rtx_hash_table, sizeof const_rtx_hash_table);
1980: bzero (const_rtx_sym_hash_table, sizeof const_rtx_sym_hash_table);
1981:
1982: first_pool = last_pool = 0;
1983: pool_offset = 0;
1984: }
1985:
1986: enum kind { RTX_DOUBLE, RTX_INT };
1987:
1988: struct rtx_const
1989: {
1990: #ifdef ONLY_INT_FIELDS
1991: unsigned int kind : 16;
1992: unsigned int mode : 16;
1993: #else
1994: enum kind kind : 16;
1995: enum machine_mode mode : 16;
1996: #endif
1997: union {
1998: union real_extract du;
1999: struct addr_const addr;
2000: } un;
2001: };
2002:
2003: /* Express an rtx for a constant integer (perhaps symbolic)
2004: as the sum of a symbol or label plus an explicit integer.
2005: They are stored into VALUE. */
2006:
2007: static void
2008: decode_rtx_const (mode, x, value)
2009: enum machine_mode mode;
2010: rtx x;
2011: struct rtx_const *value;
2012: {
2013: /* Clear the whole structure, including any gaps. */
2014:
2015: {
2016: int *p = (int *) value;
2017: int *end = (int *) (value + 1);
2018: while (p < end)
2019: *p++ = 0;
2020: }
2021:
2022: value->kind = RTX_INT; /* Most usual kind. */
2023: value->mode = mode;
2024:
2025: switch (GET_CODE (x))
2026: {
2027: case CONST_DOUBLE:
2028: value->kind = RTX_DOUBLE;
2029: value->mode = GET_MODE (x);
2030: bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
2031: break;
2032:
2033: case CONST_INT:
2034: value->un.addr.offset = INTVAL (x);
2035: break;
2036:
2037: case SYMBOL_REF:
2038: case LABEL_REF:
2039: value->un.addr.base = x;
2040: break;
2041:
2042: case CONST:
2043: x = XEXP (x, 0);
2044: if (GET_CODE (x) == PLUS)
2045: {
2046: value->un.addr.base = XEXP (x, 0);
2047: if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2048: abort ();
2049: value->un.addr.offset = INTVAL (XEXP (x, 1));
2050: }
2051: else if (GET_CODE (x) == MINUS)
2052: {
2053: value->un.addr.base = XEXP (x, 0);
2054: if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2055: abort ();
2056: value->un.addr.offset = - INTVAL (XEXP (x, 1));
2057: }
2058: else
2059: abort ();
2060: break;
2061:
2062: default:
2063: abort ();
2064: }
2065:
2066: if (value->kind == RTX_INT && value->un.addr.base != 0)
2067: switch (GET_CODE (value->un.addr.base))
2068: {
2069: case SYMBOL_REF:
2070: case LABEL_REF:
2071: /* Use the string's address, not the SYMBOL_REF's address,
2072: for the sake of addresses of library routines.
2073: For a LABEL_REF, compare labels. */
2074: value->un.addr.base = XEXP (value->un.addr.base, 0);
2075: }
2076: }
2077:
2078: /* Compute a hash code for a constant RTL expression. */
2079:
2080: int
2081: const_hash_rtx (mode, x)
2082: enum machine_mode mode;
2083: rtx x;
2084: {
2085: register int hi, i;
2086:
2087: struct rtx_const value;
2088: decode_rtx_const (mode, x, &value);
2089:
2090: /* Compute hashing function */
2091: hi = 0;
2092: for (i = 0; i < sizeof value / sizeof (int); i++)
2093: hi += ((int *) &value)[i];
2094:
2095: hi &= (1 << HASHBITS) - 1;
2096: hi %= MAX_RTX_HASH_TABLE;
2097: return hi;
2098: }
2099:
2100: /* Compare a constant rtl object X with a constant-descriptor DESC.
2101: Return 1 if DESC describes a constant with the same value as X. */
2102:
2103: static int
2104: compare_constant_rtx (mode, x, desc)
2105: enum machine_mode mode;
2106: rtx x;
2107: struct constant_descriptor *desc;
2108: {
2109: register int *p = (int *) desc->contents;
2110: register int *strp;
2111: register int len;
2112: struct rtx_const value;
2113:
2114: decode_rtx_const (mode, x, &value);
2115: strp = (int *) &value;
2116: len = sizeof value / sizeof (int);
2117:
2118: /* Compare constant contents. */
2119: while (--len >= 0)
2120: if (*p++ != *strp++)
2121: return 0;
2122:
2123: return 1;
2124: }
2125:
2126: /* Construct a constant descriptor for the rtl-expression X.
2127: It is up to the caller to enter the descriptor in the hash table. */
2128:
2129: static struct constant_descriptor *
2130: record_constant_rtx (mode, x)
2131: enum machine_mode mode;
2132: rtx x;
2133: {
2134: struct constant_descriptor *ptr;
2135: char *label;
2136: struct rtx_const value;
2137:
2138: decode_rtx_const (mode, x, &value);
2139:
2140: obstack_grow (current_obstack, &ptr, sizeof ptr);
2141: obstack_grow (current_obstack, &label, sizeof label);
2142:
2143: /* Record constant contents. */
2144: obstack_grow (current_obstack, &value, sizeof value);
2145:
2146: return (struct constant_descriptor *) obstack_finish (current_obstack);
2147: }
2148:
2149: /* Given a constant rtx X, make (or find) a memory constant for its value
2150: and return a MEM rtx to refer to it in memory. */
2151:
2152: rtx
2153: force_const_mem (mode, x)
2154: enum machine_mode mode;
2155: rtx x;
2156: {
2157: register int hash;
2158: register struct constant_descriptor *desc;
2159: char label[256];
2160: char *found = 0;
2161: rtx def;
2162:
2163: /* If we want this CONST_DOUBLE in the same mode as it is in memory
2164: (this will always be true for floating CONST_DOUBLEs that have been
2165: placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
2166: use the previous copy. Otherwise, make a new one. Note that in
2167: the unlikely event that this same CONST_DOUBLE is used in two different
2168: modes in an alternating fashion, we will allocate a lot of different
2169: memory locations, but this should be extremely rare. */
2170:
2171: if (GET_CODE (x) == CONST_DOUBLE
2172: && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
2173: && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
2174: return CONST_DOUBLE_MEM (x);
2175:
2176: /* Compute hash code of X. Search the descriptors for that hash code
2177: to see if any of them describes X. If yes, the descriptor records
2178: the label number already assigned. */
2179:
2180: hash = const_hash_rtx (mode, x);
2181:
2182: for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
2183: if (compare_constant_rtx (mode, x, desc))
2184: {
2185: found = desc->label;
2186: break;
2187: }
2188:
2189: if (found == 0)
2190: {
2191: register struct pool_constant *pool;
2192: register struct pool_sym *sym;
2193: int align;
2194:
2195: /* No constant equal to X is known to have been output.
2196: Make a constant descriptor to enter X in the hash table.
2197: Assign the label number and record it in the descriptor for
2198: future calls to this function to find. */
2199:
2200: desc = record_constant_rtx (mode, x);
2201: desc->next = const_rtx_hash_table[hash];
2202: const_rtx_hash_table[hash] = desc;
2203:
2204: /* Align the location counter as required by EXP's data type. */
2205: align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
2206: if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2207: align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
2208:
2209: pool_offset += align - 1;
2210: pool_offset &= ~ (align - 1);
2211:
2212: /* Allocate a pool constant descriptor, fill it in, and chain it in. */
2213:
2214: pool = (struct pool_constant *) oballoc (sizeof (struct pool_constant));
2215: pool->desc = desc;
2216: pool->constant = x;
2217: pool->mode = mode;
2218: pool->labelno = const_labelno;
2219: pool->align = align;
2220: pool->offset = pool_offset;
2221: pool->next = 0;
2222:
2223: if (last_pool == 0)
2224: first_pool = pool;
2225: else
2226: last_pool->next = pool;
2227:
2228: last_pool = pool;
2229: pool_offset += GET_MODE_SIZE (mode);
2230:
2231: /* Create a string containing the label name, in LABEL. */
2232: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2233:
2234: ++const_labelno;
2235:
2236: desc->label = found
2237: = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
2238:
2239: /* Add label to symbol hash table. */
2240: hash = SYMHASH (found);
2241: sym = (struct pool_sym *) oballoc (sizeof (struct pool_sym));
2242: sym->label = found;
2243: sym->pool = pool;
2244: sym->next = const_rtx_sym_hash_table[hash];
2245: const_rtx_sym_hash_table[hash] = sym;
2246: }
2247:
2248: /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2249:
2250: def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, found));
2251:
2252: RTX_UNCHANGING_P (def) = 1;
2253: /* Mark the symbol_ref as belonging to this constants pool. */
2254: CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
2255: current_function_uses_const_pool = 1;
2256:
2257: if (GET_CODE (x) == CONST_DOUBLE)
2258: {
2259: if (CONST_DOUBLE_MEM (x) == cc0_rtx)
2260: {
2261: CONST_DOUBLE_CHAIN (x) = const_double_chain;
2262: const_double_chain = x;
2263: }
2264: CONST_DOUBLE_MEM (x) = def;
2265: }
2266:
2267: return def;
2268: }
2269:
2270: /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
2271: the corresponding pool_constant structure. */
2272:
2273: static struct pool_constant *
2274: find_pool_constant (addr)
2275: rtx addr;
2276: {
2277: struct pool_sym *sym;
2278: char *label = XSTR (addr, 0);
2279:
2280: for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
2281: if (sym->label == label)
2282: return sym->pool;
2283:
2284: abort ();
2285: }
2286:
2287: /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
2288:
2289: rtx
2290: get_pool_constant (addr)
2291: rtx addr;
2292: {
2293: return (find_pool_constant (addr))->constant;
2294: }
2295:
2296: /* Similar, return the mode. */
2297:
2298: enum machine_mode
2299: get_pool_mode (addr)
2300: rtx addr;
2301: {
2302: return (find_pool_constant (addr))->mode;
2303: }
2304:
2305: /* Similar, return the offset in the constant pool. */
2306:
2307: int
2308: get_pool_offset (addr)
2309: rtx addr;
2310: {
2311: return (find_pool_constant (addr))->offset;
2312: }
2313:
2314: /* Return the size of the constant pool. */
2315:
2316: int
2317: get_pool_size ()
2318: {
2319: return pool_offset;
2320: }
2321:
2322: /* Write all the constants in the constant pool. */
2323:
2324: void
2325: output_constant_pool (fnname, fndecl)
2326: char *fnname;
2327: tree fndecl;
2328: {
2329: struct pool_constant *pool;
2330: rtx x;
2331: union real_extract u;
2332:
2333: #ifdef ASM_OUTPUT_POOL_PROLOGUE
2334: ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
2335: #endif
2336:
2337: for (pool = first_pool; pool; pool = pool->next)
2338: {
2339: x = pool->constant;
2340:
2341: /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
2342: whose CODE_LABEL has been deleted. This can occur if a jump table
2343: is eliminated by optimization. If so, write a constant of zero
2344: instead. */
2345: if ((GET_CODE (x) == LABEL_REF && INSN_DELETED_P (XEXP (x, 0)))
2346: || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
2347: && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
2348: && INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))))
2349: x = const0_rtx;
2350:
2351: /* First switch to correct section. */
2352: #ifdef SELECT_RTX_SECTION
2353: SELECT_RTX_SECTION (pool->mode, x);
2354: #else
2355: readonly_data_section ();
2356: #endif
2357:
2358: #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
2359: ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
2360: pool->align, pool->labelno, done);
2361: #endif
2362:
2363: if (pool->align > 1)
2364: ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
2365:
2366: /* Output the label. */
2367: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
2368:
2369: /* Output the value of the constant itself. */
2370: switch (GET_MODE_CLASS (pool->mode))
2371: {
2372: case MODE_FLOAT:
2373: if (GET_CODE (x) != CONST_DOUBLE)
2374: abort ();
2375:
2376: bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
2377: assemble_real (u.d, pool->mode);
2378: break;
2379:
2380: case MODE_INT:
2381: assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
2382: break;
2383:
2384: default:
2385: abort ();
2386: }
2387:
2388: done: ;
2389: }
2390:
2391: /* Done with this pool. */
2392: first_pool = last_pool = 0;
2393: }
2394:
2395: /* Find all the constants whose addresses are referenced inside of EXP,
2396: and make sure assembler code with a label has been output for each one.
2397: Indicate whether an ADDR_EXPR has been encountered. */
2398:
2399: int
2400: output_addressed_constants (exp)
2401: tree exp;
2402: {
2403: int reloc = 0;
2404:
2405: switch (TREE_CODE (exp))
2406: {
2407: case ADDR_EXPR:
2408: {
2409: register tree constant = TREE_OPERAND (exp, 0);
2410:
2411: while (TREE_CODE (constant) == COMPONENT_REF)
2412: {
2413: constant = TREE_OPERAND (constant, 0);
2414: }
2415:
2416: if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
2417: || TREE_CODE (constant) == CONSTRUCTOR)
2418: /* No need to do anything here
2419: for addresses of variables or functions. */
2420: output_constant_def (constant);
2421: }
2422: reloc = 1;
2423: break;
2424:
2425: case PLUS_EXPR:
2426: case MINUS_EXPR:
2427: reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
2428: reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
2429: break;
2430:
2431: case NOP_EXPR:
2432: case CONVERT_EXPR:
2433: reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
2434: break;
2435:
2436: case CONSTRUCTOR:
2437: {
2438: register tree link;
2439: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2440: if (TREE_VALUE (link) != 0)
2441: reloc |= output_addressed_constants (TREE_VALUE (link));
2442: }
2443: break;
2444:
2445: case ERROR_MARK:
2446: break;
2447: }
2448: return reloc;
2449: }
2450:
2451: /* Output assembler code for constant EXP to FILE, with no label.
2452: This includes the pseudo-op such as ".int" or ".byte", and a newline.
2453: Assumes output_addressed_constants has been done on EXP already.
2454:
2455: Generate exactly SIZE bytes of assembler data, padding at the end
2456: with zeros if necessary. SIZE must always be specified.
2457:
2458: SIZE is important for structure constructors,
2459: since trailing members may have been omitted from the constructor.
2460: It is also important for initialization of arrays from string constants
2461: since the full length of the string constant might not be wanted.
2462: It is also needed for initialization of unions, where the initializer's
2463: type is just one member, and that may not be as long as the union.
2464:
2465: There a case in which we would fail to output exactly SIZE bytes:
2466: for a structure constructor that wants to produce more than SIZE bytes.
2467: But such constructors will never be generated for any possible input. */
2468:
2469: void
2470: output_constant (exp, size)
2471: register tree exp;
2472: register int size;
2473: {
2474: register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
2475: rtx x;
2476:
2477: if (size == 0)
2478: return;
2479:
2480: /* Allow a constructor with no elements for any data type.
2481: This means to fill the space with zeros. */
2482: if (TREE_CODE (exp) == CONSTRUCTOR
2483: && TREE_OPERAND (exp, 1) == 0)
2484: {
2485: assemble_zeros (size);
2486: return;
2487: }
2488:
2489: /* Eliminate the NOP_EXPR that makes a cast not be an lvalue.
2490: That way we get the constant (we hope) inside it. */
2491: if (TREE_CODE (exp) == NOP_EXPR
2492: && TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0)))
2493: exp = TREE_OPERAND (exp, 0);
2494:
2495: switch (code)
2496: {
2497: case INTEGER_TYPE:
2498: case ENUMERAL_TYPE:
2499: case POINTER_TYPE:
2500: case REFERENCE_TYPE:
2501: /* ??? What about (int)((float)(int)&foo + 4) */
2502: while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
2503: || TREE_CODE (exp) == NON_LVALUE_EXPR)
2504: exp = TREE_OPERAND (exp, 0);
2505:
2506: if (! assemble_integer (expand_expr (exp, 0, VOIDmode,
2507: EXPAND_INITIALIZER),
2508: size, 0))
2509: error ("initializer for integer value is too complicated");
2510: size = 0;
2511: break;
2512:
2513: case REAL_TYPE:
2514: if (TREE_CODE (exp) != REAL_CST)
2515: error ("initializer for floating value is not a floating constant");
2516:
2517: assemble_real (TREE_REAL_CST (exp),
2518: mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
2519: size = 0;
2520: break;
2521:
2522: case COMPLEX_TYPE:
2523: output_constant (TREE_REALPART (exp), size / 2);
2524: output_constant (TREE_IMAGPART (exp), size / 2);
2525: size -= (size / 2) * 2;
2526: break;
2527:
2528: case ARRAY_TYPE:
2529: if (TREE_CODE (exp) == CONSTRUCTOR)
2530: {
2531: output_constructor (exp, size);
2532: return;
2533: }
2534: else if (TREE_CODE (exp) == STRING_CST)
2535: {
2536: int excess = 0;
2537:
2538: if (size > TREE_STRING_LENGTH (exp))
2539: {
2540: excess = size - TREE_STRING_LENGTH (exp);
2541: size = TREE_STRING_LENGTH (exp);
2542: }
2543:
2544: assemble_string (TREE_STRING_POINTER (exp), size);
2545: size = excess;
2546: }
2547: else
2548: abort ();
2549: break;
2550:
2551: case RECORD_TYPE:
2552: case UNION_TYPE:
2553: if (TREE_CODE (exp) == CONSTRUCTOR)
2554: output_constructor (exp, size);
2555: else
2556: abort ();
2557: return;
2558: }
2559:
2560: if (size > 0)
2561: assemble_zeros (size);
2562: }
2563:
2564: /* Subroutine of output_constant, used for CONSTRUCTORs
2565: (aggregate constants).
2566: Generate at least SIZE bytes, padding if necessary. */
2567:
2568: void
2569: output_constructor (exp, size)
2570: tree exp;
2571: int size;
2572: {
2573: register tree link, field = 0;
2574: /* Number of bytes output or skipped so far.
2575: In other words, current position within the constructor. */
2576: int total_bytes = 0;
2577: /* Non-zero means BYTE contains part of a byte, to be output. */
2578: int byte_buffer_in_use = 0;
2579: register int byte;
2580:
2581: if (HOST_BITS_PER_INT < BITS_PER_UNIT)
2582: abort ();
2583:
2584: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2585: field = TYPE_FIELDS (TREE_TYPE (exp));
2586:
2587: /* As LINK goes through the elements of the constant,
2588: FIELD goes through the structure fields, if the constant is a structure.
2589: if the constant is a union, then we override this,
2590: by getting the field from the TREE_LIST element.
2591: But the constant could also be an array. Then FIELD is zero. */
2592: for (link = CONSTRUCTOR_ELTS (exp);
2593: link;
2594: link = TREE_CHAIN (link),
2595: field = field ? TREE_CHAIN (field) : 0)
2596: {
2597: tree val = TREE_VALUE (link);
2598: /* the element in a union constructor specifies the proper field. */
2599: if (TREE_PURPOSE (link) != 0)
2600: field = TREE_PURPOSE (link);
2601:
2602: /* Eliminate the marker that makes a cast not be an lvalue. */
2603: if (val != 0 && TREE_CODE (val) == NON_LVALUE_EXPR)
2604: val = TREE_OPERAND (val, 0);
2605:
2606: if (field == 0 || !DECL_BIT_FIELD (field))
2607: {
2608: register int fieldsize;
2609: /* Since this structure is static,
2610: we know the positions are constant. */
2611: int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
2612: / BITS_PER_UNIT)
2613: : 0);
2614:
2615: /* An element that is not a bit-field.
2616: Output any buffered-up bit-fields preceding it. */
2617: if (byte_buffer_in_use)
2618: {
2619: ASM_OUTPUT_BYTE (asm_out_file, byte);
2620: total_bytes++;
2621: byte_buffer_in_use = 0;
2622: }
2623:
2624: /* Advance to offset of this element.
2625: Note no alignment needed in an array, since that is guaranteed
2626: if each element has the proper size. */
2627: if (field != 0 && bitpos != total_bytes)
2628: {
2629: assemble_zeros (bitpos - total_bytes);
2630: total_bytes = bitpos;
2631: }
2632:
2633: /* Determine size this element should occupy. */
2634: if (field)
2635: {
2636: if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
2637: abort ();
2638: if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
2639: {
2640: /* This avoids overflow trouble. */
2641: tree size_tree = size_binop (CEIL_DIV_EXPR,
2642: DECL_SIZE (field),
2643: size_int (BITS_PER_UNIT));
2644: fieldsize = TREE_INT_CST_LOW (size_tree);
2645: }
2646: else
2647: {
2648: fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
2649: fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
2650: }
2651: }
2652: else
2653: fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
2654:
2655: /* Output the element's initial value. */
2656: if (val == 0)
2657: assemble_zeros (fieldsize);
2658: else
2659: output_constant (val, fieldsize);
2660:
2661: /* Count its size. */
2662: total_bytes += fieldsize;
2663: }
2664: else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
2665: error ("invalid initial value for member `%s'",
2666: IDENTIFIER_POINTER (DECL_NAME (field)));
2667: else
2668: {
2669: /* Element that is a bit-field. */
2670:
2671: int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
2672: int end_offset
2673: = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
2674:
2675: if (val == 0)
2676: val = integer_zero_node;
2677:
2678: /* If this field does not start in this (or, next) byte,
2679: skip some bytes. */
2680: if (next_offset / BITS_PER_UNIT != total_bytes)
2681: {
2682: /* Output remnant of any bit field in previous bytes. */
2683: if (byte_buffer_in_use)
2684: {
2685: ASM_OUTPUT_BYTE (asm_out_file, byte);
2686: total_bytes++;
2687: byte_buffer_in_use = 0;
2688: }
2689:
2690: /* If still not at proper byte, advance to there. */
2691: if (next_offset / BITS_PER_UNIT != total_bytes)
2692: {
2693: assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
2694: total_bytes = next_offset / BITS_PER_UNIT;
2695: }
2696: }
2697:
2698: if (! byte_buffer_in_use)
2699: byte = 0;
2700:
2701: /* We must split the element into pieces that fall within
2702: separate bytes, and combine each byte with previous or
2703: following bit-fields. */
2704:
2705: /* next_offset is the offset n fbits from the begining of
2706: the structure to the next bit of this element to be processed.
2707: end_offset is the offset of the first bit past the end of
2708: this element. */
2709: while (next_offset < end_offset)
2710: {
2711: int this_time;
2712: int shift, value;
2713: int next_byte = next_offset / BITS_PER_UNIT;
2714: int next_bit = next_offset % BITS_PER_UNIT;
2715:
2716: /* Advance from byte to byte
2717: within this element when necessary. */
2718: while (next_byte != total_bytes)
2719: {
2720: ASM_OUTPUT_BYTE (asm_out_file, byte);
2721: total_bytes++;
2722: byte = 0;
2723: }
2724:
2725: /* Number of bits we can process at once
2726: (all part of the same byte). */
2727: this_time = MIN (end_offset - next_offset,
2728: BITS_PER_UNIT - next_bit);
2729: #if BYTES_BIG_ENDIAN
2730: /* On big-endian machine, take the most significant bits
2731: first (of the bits that are significant)
2732: and put them into bytes from the most significant end. */
2733: shift = end_offset - next_offset - this_time;
2734: /* Don't try to take a bunch of bits that cross
2735: the word boundary in the INTEGER_CST. */
2736: if (shift < HOST_BITS_PER_INT
2737: && shift + this_time > HOST_BITS_PER_INT)
2738: {
2739: this_time -= (HOST_BITS_PER_INT - shift);
2740: shift = HOST_BITS_PER_INT;
2741: }
2742:
2743: /* Now get the bits from the appropriate constant word. */
2744: if (shift < HOST_BITS_PER_INT)
2745: {
2746: value = TREE_INT_CST_LOW (val);
2747: }
2748: else if (shift < 2 * HOST_BITS_PER_INT)
2749: {
2750: value = TREE_INT_CST_HIGH (val);
2751: shift -= HOST_BITS_PER_INT;
2752: }
2753: else
2754: abort ();
2755: byte |= (((value >> shift) & ((1 << this_time) - 1))
2756: << (BITS_PER_UNIT - this_time - next_bit));
2757: #else
2758: /* On little-endian machines,
2759: take first the least significant bits of the value
2760: and pack them starting at the least significant
2761: bits of the bytes. */
2762: shift = (next_offset
2763: - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
2764: /* Don't try to take a bunch of bits that cross
2765: the word boundary in the INTEGER_CST. */
2766: if (shift < HOST_BITS_PER_INT
2767: && shift + this_time > HOST_BITS_PER_INT)
2768: {
2769: this_time -= (HOST_BITS_PER_INT - shift);
2770: shift = HOST_BITS_PER_INT;
2771: }
2772:
2773: /* Now get the bits from the appropriate constant word. */
2774: if (shift < HOST_BITS_PER_INT)
2775: value = TREE_INT_CST_LOW (val);
2776: else if (shift < 2 * HOST_BITS_PER_INT)
2777: {
2778: value = TREE_INT_CST_HIGH (val);
2779: shift -= HOST_BITS_PER_INT;
2780: }
2781: else
2782: abort ();
2783: byte |= ((value >> shift) & ((1 << this_time) - 1)) << next_bit;
2784: #endif
2785: next_offset += this_time;
2786: byte_buffer_in_use = 1;
2787: }
2788: }
2789: }
2790: if (byte_buffer_in_use)
2791: {
2792: ASM_OUTPUT_BYTE (asm_out_file, byte);
2793: total_bytes++;
2794: }
2795: if (total_bytes < size)
2796: assemble_zeros (size - total_bytes);
2797: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.