![[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 [Apple XNU] / GNUtools / cc|
Return to varasm.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Output variables, constants and external declarations, for GNU compiler.
2: Copyright (C) 1987, 1988, 1989, 1992, 1993 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 "function.h"
36: #include "expr.h"
37: #include "hard-reg-set.h"
38: #include "regs.h"
39: #include "defaults.h"
40: #include "real.h"
41: #include "bytecode.h"
42:
43: #include "obstack.h"
44:
45: #ifdef XCOFF_DEBUGGING_INFO
46: #include "xcoffout.h"
47: #endif
48:
49: #include <ctype.h>
50:
51: #ifndef ASM_STABS_OP
52: #define ASM_STABS_OP ".stabs"
53: #endif
54:
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] == '*'))
61: #endif
62:
63: /* File in which assembler code is being written. */
64:
65: extern FILE *asm_out_file;
66:
67: /* The (assembler) name of the first globally-visible object output. */
68: char *first_global_object_name;
69:
70: extern struct obstack *current_obstack;
71: extern struct obstack *saveable_obstack;
72: extern struct obstack permanent_obstack;
73: #define obstack_chunk_alloc xmalloc
74:
75: /* Number for making the label on the next
76: constant that is stored in memory. */
77:
78: int const_labelno;
79:
80: /* Number for making the label on the next
81: static variable internal to a function. */
82:
83: int var_labelno;
84:
85: /* Carry information from ASM_DECLARE_OBJECT_NAME
86: to ASM_FINISH_DECLARE_OBJECT. */
87:
88: int size_directive_output;
89:
90: /* The last decl for which assemble_variable was called,
91: if it did ASM_DECLARE_OBJECT_NAME.
92: If the last call to assemble_variable didn't do that,
93: this holds 0. */
94:
95: tree last_assemble_variable_decl;
96:
97: /* Nonzero if at least one function definition has been seen. */
98: static int function_defined;
99:
100: extern FILE *asm_out_file;
101:
102: static char *compare_constant_1 ();
103: static void record_constant_1 ();
104: static void output_constant_def_contents ();
105: static int contains_pointers_p ();
106: static void bc_output_ascii ();
107:
108: void output_constant_pool ();
109: void assemble_name ();
110: int output_addressed_constants ();
111: void output_constant ();
112: void output_constructor ();
113: void output_byte_asm ();
114: void text_section ();
115: void readonly_data_section ();
116: void data_section ();
117: static void bc_assemble_integer ();
118:
119: #ifdef EXTRA_SECTIONS
120: static enum in_section {no_section, in_text, in_data, EXTRA_SECTIONS} in_section
121: = no_section;
122: #else
123: static enum in_section {no_section, in_text, in_data} in_section
124: = no_section;
125: #endif
126:
127: /* Define functions like text_section for any extra sections. */
128: #ifdef EXTRA_SECTION_FUNCTIONS
129: EXTRA_SECTION_FUNCTIONS
130: #endif
131:
132: /* Tell assembler to switch to text section. */
133:
134: void
135: text_section ()
136: {
137: if (in_section != in_text)
138: {
139: if (output_bytecode)
140: bc_text ();
141: else
142: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
143:
144: in_section = in_text;
145: }
146: }
147:
148: /* Tell assembler to switch to data section. */
149:
150: void
151: data_section ()
152: {
153: if (in_section != in_data)
154: {
155: if (output_bytecode)
156: bc_data ();
157: else
158: {
159: if (flag_shared_data)
160: {
161: #ifdef SHARED_SECTION_ASM_OP
162: fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
163: #else
164: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
165: #endif
166: }
167: else
168: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
169: }
170:
171: in_section = in_data;
172: }
173: }
174:
175: /* Tell assembler to switch to read-only data section. This is normally
176: the text section. */
177:
178: void
179: readonly_data_section ()
180: {
181: #ifdef READONLY_DATA_SECTION
182: READONLY_DATA_SECTION (); /* Note this can call data_section. */
183: #else
184: text_section ();
185: #endif
186: }
187:
188: /* Determine if we're in the text section. */
189:
190: int
191: in_text_section ()
192: {
193: return in_section == in_text;
194: }
195:
196: /* Create the rtl to represent a function, for a function definition.
197: DECL is a FUNCTION_DECL node which describes which function.
198: The rtl is stored into DECL. */
199:
200: void
201: make_function_rtl (decl)
202: tree decl;
203: {
204: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
205:
206: if (output_bytecode)
207: {
208: if (DECL_RTL (decl) == 0)
209: DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
210:
211: /* Record that at least one function has been defined. */
212: function_defined = 1;
213: return;
214: }
215:
216: /* Rename a nested function to avoid conflicts. */
217: if (decl_function_context (decl) != 0
218: && DECL_INITIAL (decl) != 0
219: && DECL_RTL (decl) == 0)
220: {
221: char *label;
222:
223: name = IDENTIFIER_POINTER (DECL_NAME (decl));
224: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
225: name = obstack_copy0 (saveable_obstack, label, strlen (label));
226: var_labelno++;
227: }
228:
229: if (DECL_RTL (decl) == 0)
230: {
231: DECL_RTL (decl)
232: = gen_rtx (MEM, DECL_MODE (decl),
233: gen_rtx (SYMBOL_REF, Pmode, name));
234:
235: /* Optionally set flags or add text to the name to record information
236: such as that it is a function name. If the name is changed, the macro
237: ASM_OUTPUT_LABELREF will have to know how to strip this information.
238: And if it finds a * at the beginning after doing so, it must handle
239: that too. */
240: #ifdef ENCODE_SECTION_INFO
241: ENCODE_SECTION_INFO (decl);
242: #endif
243: }
244:
245: /* Record at least one function has been defined. */
246: function_defined = 1;
247: }
248:
249: /* Create the DECL_RTL for a declaration for a static or external
250: variable or static or external function.
251: ASMSPEC, if not 0, is the string which the user specified
252: as the assembler symbol name.
253: TOP_LEVEL is nonzero if this is a file-scope variable.
254: This is never called for PARM_DECLs. */
255: void
256: bc_make_decl_rtl (decl, asmspec, top_level)
257: tree decl;
258: char *asmspec;
259: int top_level;
260: {
261: register char *name = TREE_STRING_POINTER (DECL_ASSEMBLER_NAME (decl));
262:
263: if (DECL_RTL (decl) == 0)
264: {
265: /* Print an error message for register variables. */
266: if (DECL_REGISTER (decl) && TREE_CODE (decl) == FUNCTION_DECL)
267: error ("function declared `register'");
268: else if (DECL_REGISTER (decl))
269: error ("global register variables not supported in the interpreter");
270:
271: /* Handle ordinary static variables and functions. */
272: if (DECL_RTL (decl) == 0)
273: {
274: /* Can't use just the variable's own name for a variable
275: whose scope is less than the whole file.
276: Concatenate a distinguishing number. */
277: if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
278: {
279: char *label;
280:
281: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
282: name = obstack_copy0 (saveable_obstack, label, strlen (label));
283: var_labelno++;
284: }
285:
286: DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
287: }
288: }
289: }
290:
291: /* Given NAME, a putative register name, discard any customary prefixes. */
292:
293: static char *
294: strip_reg_name (name)
295: char *name;
296: {
297: #ifdef REGISTER_PREFIX
298: if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
299: name += strlen (REGISTER_PREFIX);
300: #endif
301: if (name[0] == '%' || name[0] == '#')
302: name++;
303: return name;
304: }
305:
306: /* Decode an `asm' spec for a declaration as a register name.
307: Return the register number, or -1 if nothing specified,
308: or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
309: or -3 if ASMSPEC is `cc' and is not recognized,
310: or -4 if ASMSPEC is `memory' and is not recognized.
311: Accept an exact spelling or a decimal number.
312: Prefixes such as % are optional. */
313:
314: int
315: decode_reg_name (asmspec)
316: char *asmspec;
317: {
318: if (asmspec != 0)
319: {
320: int i;
321:
322: /* Get rid of confusing prefixes. */
323: asmspec = strip_reg_name (asmspec);
324:
325: /* Allow a decimal number as a "register name". */
326: for (i = strlen (asmspec) - 1; i >= 0; i--)
327: if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
328: break;
329: if (asmspec[0] != 0 && i < 0)
330: {
331: i = atoi (asmspec);
332: if (i < FIRST_PSEUDO_REGISTER && i >= 0)
333: return i;
334: else
335: return -2;
336: }
337:
338: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
339: if (reg_names[i][0]
340: && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
341: return i;
342:
343: #ifdef ADDITIONAL_REGISTER_NAMES
344: {
345: static struct { char *name; int number; } table[]
346: = ADDITIONAL_REGISTER_NAMES;
347:
348: for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
349: if (! strcmp (asmspec, table[i].name))
350: return table[i].number;
351: }
352: #endif /* ADDITIONAL_REGISTER_NAMES */
353:
354: if (!strcmp (asmspec, "memory"))
355: return -4;
356:
357: if (!strcmp (asmspec, "cc"))
358: return -3;
359:
360: return -2;
361: }
362:
363: return -1;
364: }
365:
366: /* Create the DECL_RTL for a declaration for a static or external variable
367: or static or external function.
368: ASMSPEC, if not 0, is the string which the user specified
369: as the assembler symbol name.
370: TOP_LEVEL is nonzero if this is a file-scope variable.
371:
372: This is never called for PARM_DECL nodes. */
373:
374: void
375: make_decl_rtl (decl, asmspec, top_level)
376: tree decl;
377: char *asmspec;
378: int top_level;
379: {
380: register char *name;
381: int reg_number;
382:
383: if (output_bytecode)
384: {
385: bc_make_decl_rtl (decl, asmspec, top_level);
386: return;
387: }
388:
389: reg_number = decode_reg_name (asmspec);
390:
391: if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
392: name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
393:
394: if (reg_number == -2)
395: {
396: /* ASMSPEC is given, and not the name of a register. */
397: name = (char *) obstack_alloc (saveable_obstack,
398: strlen (asmspec) + 2);
399: name[0] = '*';
400: strcpy (&name[1], asmspec);
401: }
402:
403: /* For a duplicate declaration, we can be called twice on the
404: same DECL node. Don't discard the RTL already made. */
405: if (DECL_RTL (decl) == 0)
406: {
407: DECL_RTL (decl) = 0;
408:
409: /* First detect errors in declaring global registers. */
410: if (DECL_REGISTER (decl) && reg_number == -1)
411: error_with_decl (decl,
412: "register name not specified for `%s'");
413: else if (DECL_REGISTER (decl) && reg_number < 0)
414: error_with_decl (decl,
415: "invalid register name for `%s'");
416: else if ((reg_number >= 0 || reg_number == -3) && ! DECL_REGISTER (decl))
417: error_with_decl (decl,
418: "register name given for non-register variable `%s'");
419: else if (DECL_REGISTER (decl) && TREE_CODE (decl) == FUNCTION_DECL)
420: error ("function declared `register'");
421: else if (DECL_REGISTER (decl) && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
422: error_with_decl (decl, "data type of `%s' isn't suitable for a register");
423: else if (DECL_REGISTER (decl)
424: && ! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
425: error_with_decl (decl, "register number for `%s' isn't suitable for the data type");
426: /* Now handle properly declared static register variables. */
427: else if (DECL_REGISTER (decl))
428: {
429: int nregs;
430: #if 0 /* yylex should print the warning for this */
431: if (pedantic)
432: pedwarn ("ANSI C forbids global register variables");
433: #endif
434: if (DECL_INITIAL (decl) != 0 && top_level)
435: {
436: DECL_INITIAL (decl) = 0;
437: error ("global register variable has initial value");
438: }
439: if (fixed_regs[reg_number] == 0
440: && function_defined && top_level)
441: error ("global register variable follows a function definition");
442: if (TREE_THIS_VOLATILE (decl))
443: warning ("volatile register variables don't work as you might wish");
444:
445: /* If the user specified one of the eliminables registers here,
446: e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
447: confused with that register and be eliminated. Although this
448: usage is somewhat suspect, we nevertheless use the following
449: kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
450:
451: DECL_RTL (decl)
452: = gen_rtx (REG, DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
453: REGNO (DECL_RTL (decl)) = reg_number;
454: REG_USERVAR_P (DECL_RTL (decl)) = 1;
455:
456: if (top_level)
457: {
458: /* Make this register fixed, so not usable for anything else. */
459: nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
460: while (nregs > 0)
461: global_regs[reg_number + --nregs] = 1;
462: init_reg_sets_1 ();
463: }
464: }
465:
466: /* Now handle ordinary static variables and functions (in memory).
467: Also handle vars declared register invalidly. */
468: if (DECL_RTL (decl) == 0)
469: {
470: /* Can't use just the variable's own name for a variable
471: whose scope is less than the whole file.
472: Concatenate a distinguishing number. */
473: if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
474: {
475: char *label;
476:
477: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
478: name = obstack_copy0 (saveable_obstack, label, strlen (label));
479: var_labelno++;
480: }
481:
482: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
483: gen_rtx (SYMBOL_REF, Pmode, name));
484:
485: /* If this variable is to be treated as volatile, show its
486: tree node has side effects. If it has side effects, either
487: because of this test or from TREE_THIS_VOLATILE also
488: being set, show the MEM is volatile. */
489: if (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
490: && TREE_PUBLIC (decl))
491: TREE_SIDE_EFFECTS (decl) = 1;
492: if (TREE_SIDE_EFFECTS (decl))
493: MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
494:
495: if (TREE_READONLY (decl))
496: RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
497: MEM_IN_STRUCT_P (DECL_RTL (decl))
498: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
499: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
500: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
501: || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE);
502:
503: /* Optionally set flags or add text to the name to record information
504: such as that it is a function name.
505: If the name is changed, the macro ASM_OUTPUT_LABELREF
506: will have to know how to strip this information.
507: And if it finds a * at the beginning after doing so,
508: it must handle that too. */
509: #ifdef ENCODE_SECTION_INFO
510: ENCODE_SECTION_INFO (decl);
511: #endif
512: }
513: }
514: /* If the old RTL had the wrong mode, fix the mode. */
515: else if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
516: {
517: rtx rtl = DECL_RTL (decl);
518: PUT_MODE (rtl, DECL_MODE (decl));
519: }
520: }
521:
522: /* Make the rtl for variable VAR be volatile.
523: Use this only for static variables. */
524:
525: void
526: make_var_volatile (var)
527: tree var;
528: {
529: if (GET_CODE (DECL_RTL (var)) != MEM)
530: abort ();
531:
532: MEM_VOLATILE_P (DECL_RTL (var)) = 1;
533: }
534:
535: /* Output alignment directive to align for constant expression EXP. */
536:
537: void
538: assemble_constant_align (exp)
539: tree exp;
540: {
541: int align;
542:
543: /* Align the location counter as required by EXP's data type. */
544: align = TYPE_ALIGN (TREE_TYPE (exp));
545: #ifdef CONSTANT_ALIGNMENT
546: align = CONSTANT_ALIGNMENT (exp, align);
547: #endif
548:
549: if (align > BITS_PER_UNIT)
550: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
551: }
552:
553: /* Output a string of literal assembler code
554: for an `asm' keyword used between functions. */
555:
556: void
557: assemble_asm (string)
558: tree string;
559: {
560: if (output_bytecode)
561: {
562: error ("asm statements not allowed in interpreter");
563: return;
564: }
565:
566: app_enable ();
567:
568: if (TREE_CODE (string) == ADDR_EXPR)
569: string = TREE_OPERAND (string, 0);
570:
571: fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
572: }
573:
574: #if 0 /* This should no longer be needed, because
575: flag_gnu_linker should be 0 on these systems,
576: which should prevent any output
577: if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
578: #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
579: #ifndef ASM_OUTPUT_CONSTRUCTOR
580: #define ASM_OUTPUT_CONSTRUCTOR(file, name)
581: #endif
582: #ifndef ASM_OUTPUT_DESTRUCTOR
583: #define ASM_OUTPUT_DESTRUCTOR(file, name)
584: #endif
585: #endif
586: #endif /* 0 */
587:
588: /* Record an element in the table of global destructors.
589: How this is done depends on what sort of assembler and linker
590: are in use.
591:
592: NAME should be the name of a global function to be called
593: at exit time. This name is output using assemble_name. */
594:
595: void
596: assemble_destructor (name)
597: char *name;
598: {
599: #ifdef ASM_OUTPUT_DESTRUCTOR
600: ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
601: #else
602: if (flag_gnu_linker)
603: {
604: /* Now tell GNU LD that this is part of the static destructor set. */
605: /* This code works for any machine provided you use GNU as/ld. */
606: fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
607: assemble_name (asm_out_file, name);
608: fputc ('\n', asm_out_file);
609: }
610: #endif
611: }
612:
613: /* Likewise for global constructors. */
614:
615: void
616: assemble_constructor (name)
617: char *name;
618: {
619: #ifdef ASM_OUTPUT_CONSTRUCTOR
620: ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
621: #else
622: if (flag_gnu_linker)
623: {
624: /* Now tell GNU LD that this is part of the static constructor set. */
625: /* This code works for any machine provided you use GNU as/ld. */
626: fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
627: assemble_name (asm_out_file, name);
628: fputc ('\n', asm_out_file);
629: }
630: #endif
631: }
632:
633: /* Likewise for entries we want to record for garbage collection.
634: Garbage collection is still under development. */
635:
636: void
637: assemble_gc_entry (name)
638: char *name;
639: {
640: #ifdef ASM_OUTPUT_GC_ENTRY
641: ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
642: #else
643: if (flag_gnu_linker)
644: {
645: /* Now tell GNU LD that this is part of the static constructor set. */
646: fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
647: assemble_name (asm_out_file, name);
648: fputc ('\n', asm_out_file);
649: }
650: #endif
651: }
652:
653: /* Output assembler code for the constant pool of a function and associated
654: with defining the name of the function. DECL describes the function.
655: NAME is the function's name. For the constant pool, we use the current
656: constant pool data. */
657:
658: void
659: assemble_start_function (decl, fnname)
660: tree decl;
661: char *fnname;
662: {
663: int align;
664:
665: /* The following code does not need preprocessing in the assembler. */
666:
667: app_disable ();
668:
669: output_constant_pool (fnname, decl);
670:
671: text_section ();
672:
673:
674: /* Tell assembler to move to target machine's alignment for functions. */
675: align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
676: if (align > 0)
677: {
678: if (output_bytecode)
679: BC_OUTPUT_ALIGN (asm_out_file, align);
680: else
681: ASM_OUTPUT_ALIGN (asm_out_file, align);
682: }
683:
684: #ifdef ASM_OUTPUT_FUNCTION_PREFIX
685: ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
686: #endif
687:
688: #ifdef SDB_DEBUGGING_INFO
689: /* Output SDB definition of the function. */
690: if (write_symbols == SDB_DEBUG)
691: sdbout_mark_begin_function ();
692: #endif
693:
694: #ifdef DBX_DEBUGGING_INFO
695: /* Output DBX definition of the function. */
696: if (write_symbols == DBX_DEBUG)
697: dbxout_begin_function (decl);
698: #endif
699:
700: /* Make function name accessible from other files, if appropriate. */
701:
702: if (TREE_PUBLIC (decl))
703: {
704: if (!first_global_object_name)
705: STRIP_NAME_ENCODING (first_global_object_name, fnname);
706: if (output_bytecode)
707: BC_GLOBALIZE_LABEL (asm_out_file, fnname);
708: else
709: ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
710: }
711:
712: /* Do any machine/system dependent processing of the function name */
713: #ifdef ASM_DECLARE_FUNCTION_NAME
714: ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
715: #else
716: /* Standard thing is just output label for the function. */
717: if (output_bytecode)
718: BC_OUTPUT_LABEL (asm_out_file, fnname);
719: else
720: ASM_OUTPUT_LABEL (asm_out_file, fnname);
721: #endif /* ASM_DECLARE_FUNCTION_NAME */
722: }
723:
724: /* Output assembler code associated with defining the size of the
725: function. DECL describes the function. NAME is the function's name. */
726:
727: void
728: assemble_end_function (decl, fnname)
729: tree decl;
730: char *fnname;
731: {
732: #ifdef ASM_DECLARE_FUNCTION_SIZE
733: ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
734: #endif
735: }
736:
737: /* Assemble code to leave SIZE bytes of zeros. */
738:
739: void
740: assemble_zeros (size)
741: int size;
742: {
743: if (output_bytecode)
744: {
745: bc_emit_const_skip (size);
746: return;
747: }
748:
749: #ifdef ASM_NO_SKIP_IN_TEXT
750: /* The `space' pseudo in the text section outputs nop insns rather than 0s,
751: so we must output 0s explicitly in the text section. */
752: if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
753: {
754: int i;
755:
756: for (i = 0; i < size - 20; i += 20)
757: {
758: #ifdef ASM_BYTE_OP
759: fprintf (asm_out_file,
760: "%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);
761: #else
762: fprintf (asm_out_file,
763: "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
764: #endif
765: }
766: if (i < size)
767: {
768: #ifdef ASM_BYTE_OP
769: fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
770: #else
771: fprintf (asm_out_file, "\tbyte 0");
772: #endif
773: i++;
774: for (; i < size; i++)
775: fprintf (asm_out_file, ",0");
776: fprintf (asm_out_file, "\n");
777: }
778: }
779: else
780: #endif
781: if (size > 0)
782: {
783: if (output_bytecode)
784: BC_OUTPUT_SKIP (asm_out_file, size);
785: else
786: ASM_OUTPUT_SKIP (asm_out_file, size);
787: }
788: }
789:
790: /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
791:
792: void
793: assemble_align (align)
794: int align;
795: {
796: if (align > BITS_PER_UNIT)
797: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
798: }
799:
800: /* Assemble a string constant with the specified C string as contents. */
801:
802: void
803: assemble_string (p, size)
804: char *p;
805: int size;
806: {
807: register int i;
808: int pos = 0;
809: int maximum = 2000;
810:
811: if (output_bytecode)
812: {
813: bc_emit (p, size);
814: return;
815: }
816:
817: /* If the string is very long, split it up. */
818:
819: while (pos < size)
820: {
821: int thissize = size - pos;
822: if (thissize > maximum)
823: thissize = maximum;
824:
825: if (output_bytecode)
826: bc_output_ascii (asm_out_file, p, thissize);
827: else
828: {
829: ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
830: }
831:
832: pos += thissize;
833: p += thissize;
834: }
835: }
836:
837: static void
838: bc_output_ascii (file, p, size)
839: FILE *file;
840: char *p;
841: int size;
842: {
843: BC_OUTPUT_ASCII (file, p, size);
844: }
845:
846: /* Assemble everything that is needed for a variable or function declaration.
847: Not used for automatic variables, and not used for function definitions.
848: Should not be called for variables of incomplete structure type.
849:
850: TOP_LEVEL is nonzero if this variable has file scope.
851: AT_END is nonzero if this is the special handling, at end of compilation,
852: to define things that have had only tentative definitions.
853: DONT_OUTPUT_DATA if nonzero means don't actually output the
854: initial value (that will be done by the caller). */
855:
856: void
857: assemble_variable (decl, top_level, at_end, dont_output_data)
858: tree decl;
859: int top_level;
860: int at_end;
861: {
862: register char *name;
863: int align;
864: tree size_tree;
865: int reloc = 0;
866: enum in_section saved_in_section;
867:
868: last_assemble_variable_decl = 0;
869:
870: if (output_bytecode)
871: return;
872:
873: if (GET_CODE (DECL_RTL (decl)) == REG)
874: {
875: /* Do output symbol info for global register variables, but do nothing
876: else for them. */
877:
878: if (TREE_ASM_WRITTEN (decl))
879: return;
880: TREE_ASM_WRITTEN (decl) = 1;
881:
882: if (!output_bytecode)
883: {
884: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
885: /* File-scope global variables are output here. */
886: if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
887: && top_level)
888: dbxout_symbol (decl, 0);
889: #endif
890: #ifdef SDB_DEBUGGING_INFO
891: if (write_symbols == SDB_DEBUG && top_level
892: /* Leave initialized global vars for end of compilation;
893: see comment in compile_file. */
894: && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
895: sdbout_symbol (decl, 0);
896: #endif
897: }
898:
899: /* Don't output any DWARF debugging information for variables here.
900: In the case of local variables, the information for them is output
901: when we do our recursive traversal of the tree representation for
902: the entire containing function. In the case of file-scope variables,
903: we output information for all of them at the very end of compilation
904: while we are doing our final traversal of the chain of file-scope
905: declarations. */
906:
907: return;
908: }
909:
910: /* Normally no need to say anything here for external references,
911: since assemble_external is called by the langauge-specific code
912: when a declaration is first seen. */
913:
914: if (DECL_EXTERNAL (decl))
915: return;
916:
917: /* Output no assembler code for a function declaration.
918: Only definitions of functions output anything. */
919:
920: if (TREE_CODE (decl) == FUNCTION_DECL)
921: return;
922:
923: /* If type was incomplete when the variable was declared,
924: see if it is complete now. */
925:
926: if (DECL_SIZE (decl) == 0)
927: layout_decl (decl, 0);
928:
929: /* Still incomplete => don't allocate it; treat the tentative defn
930: (which is what it must have been) as an `extern' reference. */
931:
932: if (!dont_output_data && DECL_SIZE (decl) == 0)
933: {
934: error_with_file_and_line (DECL_SOURCE_FILE (decl),
935: DECL_SOURCE_LINE (decl),
936: "storage size of `%s' isn't known",
937: IDENTIFIER_POINTER (DECL_NAME (decl)));
938: return;
939: }
940:
941: /* The first declaration of a variable that comes through this function
942: decides whether it is global (in C, has external linkage)
943: or local (in C, has internal linkage). So do nothing more
944: if this function has already run. */
945:
946: if (TREE_ASM_WRITTEN (decl))
947: return;
948:
949: TREE_ASM_WRITTEN (decl) = 1;
950:
951: /* If storage size is erroneously variable, just continue.
952: Error message was already made. */
953:
954: if (DECL_SIZE (decl))
955: {
956: if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
957: goto finish;
958:
959: app_disable ();
960:
961: /* This is better than explicit arithmetic, since it avoids overflow. */
962: size_tree = size_binop (CEIL_DIV_EXPR,
963: DECL_SIZE (decl), size_int (BITS_PER_UNIT));
964:
965: if (TREE_INT_CST_HIGH (size_tree) != 0)
966: {
967: error_with_decl (decl, "size of variable `%s' is too large");
968: goto finish;
969: }
970: }
971:
972: name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
973:
974: #ifdef MACHO_PIC
975: if (GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
976: name = IDENTIFIER_POINTER (DECL_NAME (decl));
977:
978: if (TREE_STATIC (decl) || DECL_INITIAL (decl))
979: machopic_define_name (name);
980: #endif
981:
982: /* Handle uninitialized definitions. */
983:
984: /* ANSI specifies that a tentative definition which is not merged with
985: a non-tentative definition behaves exactly like a definition with an
986: initializer equal to zero. (Section 3.7.2)
987: -fno-common gives strict ANSI behavior. Usually you don't want it.
988: This matters only for variables with external linkage. */
989: if ((! flag_no_common || ! TREE_PUBLIC (decl))
990: && ! dont_output_data
991: && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
992: {
993: int size = TREE_INT_CST_LOW (size_tree);
994: int rounded = size;
995:
996: if (TREE_INT_CST_HIGH (size_tree) != 0)
997: error_with_decl (decl, "size of variable `%s' is too large");
998: /* Don't allocate zero bytes of common,
999: since that means "undefined external" in the linker. */
1000: if (size == 0) rounded = 1;
1001: /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1002: so that each uninitialized object starts on such a boundary. */
1003: rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1004: rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1005: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1006:
1007: #ifdef DBX_DEBUGGING_INFO
1008: /* File-scope global variables are output here. */
1009: if (write_symbols == DBX_DEBUG && top_level)
1010: dbxout_symbol (decl, 0);
1011: #endif
1012: #ifdef SDB_DEBUGGING_INFO
1013: if (write_symbols == SDB_DEBUG && top_level
1014: /* Leave initialized global vars for end of compilation;
1015: see comment in compile_file. */
1016: && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1017: sdbout_symbol (decl, 0);
1018: #endif
1019:
1020: /* Don't output any DWARF debugging information for variables here.
1021: In the case of local variables, the information for them is output
1022: when we do our recursive traversal of the tree representation for
1023: the entire containing function. In the case of file-scope variables,
1024: we output information for all of them at the very end of compilation
1025: while we are doing our final traversal of the chain of file-scope
1026: declarations. */
1027:
1028: #if 0
1029: if (flag_shared_data)
1030: data_section ();
1031: #endif
1032: if (TREE_PUBLIC (decl))
1033: {
1034: #ifdef ASM_OUTPUT_SHARED_COMMON
1035: if (flag_shared_data)
1036: ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1037: else
1038: #endif
1039: if (output_bytecode)
1040: {
1041: BC_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1042: }
1043: else
1044: {
1045: #ifdef ASM_OUTPUT_ALIGNED_COMMON
1046: ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
1047: DECL_ALIGN (decl));
1048: #else
1049: ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1050: #endif
1051: }
1052: }
1053: else
1054: {
1055: #ifdef ASM_OUTPUT_SHARED_LOCAL
1056: if (flag_shared_data)
1057: ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1058: else
1059: #endif
1060: if (output_bytecode)
1061: {
1062: BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1063: }
1064: else
1065: {
1066: #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1067: ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
1068: DECL_ALIGN (decl));
1069: #else
1070: ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1071: #endif
1072: }
1073: }
1074: goto finish;
1075: }
1076:
1077: /* Handle initialized definitions. */
1078:
1079: /* First make the assembler name(s) global if appropriate. */
1080: if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1081: {
1082: if (!first_global_object_name)
1083: STRIP_NAME_ENCODING(first_global_object_name, name);
1084: ASM_GLOBALIZE_LABEL (asm_out_file, name);
1085: }
1086: #if 0
1087: for (d = equivalents; d; d = TREE_CHAIN (d))
1088: {
1089: tree e = TREE_VALUE (d);
1090: if (TREE_PUBLIC (e) && DECL_NAME (e))
1091: ASM_GLOBALIZE_LABEL (asm_out_file,
1092: XSTR (XEXP (DECL_RTL (e), 0), 0));
1093: }
1094: #endif
1095:
1096: /* Output any data that we will need to use the address of. */
1097: if (DECL_INITIAL (decl) == error_mark_node)
1098: reloc = contains_pointers_p (TREE_TYPE (decl));
1099: else if (DECL_INITIAL (decl))
1100: reloc = output_addressed_constants (DECL_INITIAL (decl));
1101:
1102: /* Switch to the proper section for this data. */
1103: #ifdef SELECT_SECTION
1104: SELECT_SECTION (decl, reloc);
1105: #else
1106: if (TREE_READONLY (decl)
1107: && ! TREE_THIS_VOLATILE (decl)
1108: && ! (flag_pic && reloc))
1109: readonly_data_section ();
1110: else
1111: data_section ();
1112: #endif
1113:
1114: /* dbxout.c needs to know this. */
1115: if (in_text_section ())
1116: DECL_IN_TEXT_SECTION (decl) = 1;
1117:
1118: /* Record current section so we can restore it if dbxout.c clobbers it. */
1119: saved_in_section = in_section;
1120:
1121: /* Output the dbx info now that we have chosen the section. */
1122:
1123: #ifdef DBX_DEBUGGING_INFO
1124: /* File-scope global variables are output here. */
1125: if (write_symbols == DBX_DEBUG && top_level)
1126: dbxout_symbol (decl, 0);
1127: #endif
1128: #ifdef SDB_DEBUGGING_INFO
1129: if (write_symbols == SDB_DEBUG && top_level
1130: /* Leave initialized global vars for end of compilation;
1131: see comment in compile_file. */
1132: && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1133: sdbout_symbol (decl, 0);
1134: #endif
1135:
1136: /* Don't output any DWARF debugging information for variables here.
1137: In the case of local variables, the information for them is output
1138: when we do our recursive traversal of the tree representation for
1139: the entire containing function. In the case of file-scope variables,
1140: we output information for all of them at the very end of compilation
1141: while we are doing our final traversal of the chain of file-scope
1142: declarations. */
1143:
1144: /* If the debugging output changed sections, reselect the section
1145: that's supposed to be selected. */
1146: if (in_section != saved_in_section)
1147: {
1148: /* Switch to the proper section for this data. */
1149: #ifdef SELECT_SECTION
1150: SELECT_SECTION (decl, reloc);
1151: #else
1152: if (TREE_READONLY (decl)
1153: && ! TREE_THIS_VOLATILE (decl)
1154: && ! (flag_pic && reloc))
1155: readonly_data_section ();
1156: else
1157: data_section ();
1158: #endif
1159: }
1160:
1161: /* Compute and output the alignment of this data. */
1162:
1163: align = DECL_ALIGN (decl);
1164: /* In the case for initialing an array whose length isn't specified,
1165: where we have not yet been able to do the layout,
1166: figure out the proper alignment now. */
1167: if (dont_output_data && DECL_SIZE (decl) == 0
1168: && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1169: align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1170:
1171: /* Some object file formats have a maximum alignment which they support.
1172: In particular, a.out format supports a maximum alignment of 4. */
1173: #ifndef MAX_OFILE_ALIGNMENT
1174: #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1175: #endif
1176: if (align > MAX_OFILE_ALIGNMENT)
1177: {
1178: warning_with_decl (decl,
1179: "alignment of `%s' is greater than maximum object file alignment");
1180: align = MAX_OFILE_ALIGNMENT;
1181: }
1182: #ifdef DATA_ALIGNMENT
1183: /* On some machines, it is good to increase alignment sometimes. */
1184: align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1185: #endif
1186: #ifdef CONSTANT_ALIGNMENT
1187: if (DECL_INITIAL (decl))
1188: align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1189: #endif
1190:
1191: /* Reset the alignment in case we have made it tighter, so we can benefit
1192: from it in get_pointer_alignment. */
1193: DECL_ALIGN (decl) = align;
1194:
1195: if (align > BITS_PER_UNIT)
1196: {
1197: if (output_bytecode)
1198: BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1199: else
1200: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1201: }
1202:
1203: /* Do any machine/system dependent processing of the object. */
1204: #ifdef ASM_DECLARE_OBJECT_NAME
1205: last_assemble_variable_decl = decl;
1206: ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1207: #else
1208: /* Standard thing is just output label for the object. */
1209: if (output_bytecode)
1210: BC_OUTPUT_LABEL (asm_out_file, name);
1211: else
1212: ASM_OUTPUT_LABEL (asm_out_file, name);
1213: #endif /* ASM_DECLARE_OBJECT_NAME */
1214:
1215: if (!dont_output_data)
1216: {
1217: if (DECL_INITIAL (decl))
1218: /* Output the actual data. */
1219: output_constant (DECL_INITIAL (decl),
1220: int_size_in_bytes (TREE_TYPE (decl)));
1221: else
1222: /* Leave space for it. */
1223: assemble_zeros (int_size_in_bytes (TREE_TYPE (decl)));
1224: }
1225:
1226: finish:
1227: #ifdef XCOFF_DEBUGGING_INFO
1228: /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1229: declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1230: and `aa' hasn't been output yet, the assembler generates a stab entry with
1231: a value of zero, in addition to creating an unnecessary external entry
1232: for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1233:
1234: /* File-scope global variables are output here. */
1235: if (write_symbols == XCOFF_DEBUG && top_level)
1236: {
1237: saved_in_section = in_section;
1238:
1239: dbxout_symbol (decl, 0);
1240:
1241: if (in_section != saved_in_section)
1242: {
1243: /* Switch to the proper section for this data. */
1244: #ifdef SELECT_SECTION
1245: SELECT_SECTION (decl, reloc);
1246: #else
1247: if (TREE_READONLY (decl)
1248: && ! TREE_THIS_VOLATILE (decl)
1249: && ! (flag_pic && reloc))
1250: readonly_data_section ();
1251: else
1252: data_section ();
1253: #endif
1254: }
1255: }
1256: #else
1257: /* There must be a statement after a label. */
1258: ;
1259: #endif
1260: }
1261:
1262: /* Return 1 if type TYPE contains any pointers. */
1263:
1264: static int
1265: contains_pointers_p (type)
1266: tree type;
1267: {
1268: switch (TREE_CODE (type))
1269: {
1270: case POINTER_TYPE:
1271: case REFERENCE_TYPE:
1272: /* I'm not sure whether OFFSET_TYPE needs this treatment,
1273: so I'll play safe and return 1. */
1274: case OFFSET_TYPE:
1275: return 1;
1276:
1277: case RECORD_TYPE:
1278: case UNION_TYPE:
1279: case QUAL_UNION_TYPE:
1280: {
1281: tree fields;
1282: /* For a type that has fields, see if the fields have pointers. */
1283: for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1284: if (contains_pointers_p (TREE_TYPE (fields)))
1285: return 1;
1286: return 0;
1287: }
1288:
1289: case ARRAY_TYPE:
1290: /* An array type contains pointers if its element type does. */
1291: return contains_pointers_p (TREE_TYPE (type));
1292:
1293: default:
1294: return 0;
1295: }
1296: }
1297:
1298: /* Output text storage for constructor CONSTR. Returns rtx of
1299: storage. */
1300:
1301: rtx
1302: bc_output_constructor (constr)
1303: tree constr;
1304: {
1305: int i;
1306:
1307: /* Must always be a literal; non-literal constructors are handled
1308: differently. */
1309:
1310: if (!TREE_CONSTANT (constr))
1311: abort ();
1312:
1313: /* Always const */
1314: text_section ();
1315:
1316: /* Align */
1317: for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1318: if (i > 0)
1319: BC_OUTPUT_ALIGN (asm_out_file, i);
1320:
1321: /* Output data */
1322: output_constant (constr, int_size_in_bytes (TREE_TYPE (constr)));
1323: }
1324:
1325:
1326: /* Create storage for constructor CONSTR. */
1327:
1328: void
1329: bc_output_data_constructor (constr)
1330: tree constr;
1331: {
1332: int i;
1333:
1334: /* Put in data section */
1335: data_section ();
1336:
1337: /* Align */
1338: for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1339: if (i > 0)
1340: BC_OUTPUT_ALIGN (asm_out_file, i);
1341:
1342: /* The constructor is filled in at runtime. */
1343: BC_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (constr)));
1344: }
1345:
1346:
1347: /* Output something to declare an external symbol to the assembler.
1348: (Most assemblers don't need this, so we normally output nothing.)
1349: Do nothing if DECL is not external. */
1350:
1351: void
1352: assemble_external (decl)
1353: tree decl;
1354: {
1355: if (output_bytecode)
1356: return;
1357:
1358: #ifdef ASM_OUTPUT_EXTERNAL
1359: if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1360: && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1361: {
1362: rtx rtl = DECL_RTL (decl);
1363:
1364: if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1365: && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1366: {
1367: /* Some systems do require some output. */
1368: SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1369: ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1370: }
1371: }
1372: #endif
1373: }
1374:
1375: /* Similar, for calling a library function FUN. */
1376:
1377: void
1378: assemble_external_libcall (fun)
1379: rtx fun;
1380: {
1381: #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1382: if (!output_bytecode)
1383: {
1384: /* Declare library function name external when first used, if nec. */
1385: if (! SYMBOL_REF_USED (fun))
1386: {
1387: SYMBOL_REF_USED (fun) = 1;
1388: ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1389: }
1390: }
1391: #endif
1392: }
1393:
1394: /* Declare the label NAME global. */
1395:
1396: void
1397: assemble_global (name)
1398: char *name;
1399: {
1400: ASM_GLOBALIZE_LABEL (asm_out_file, name);
1401: }
1402:
1403: /* Assemble a label named NAME. */
1404:
1405: void
1406: assemble_label (name)
1407: char *name;
1408: {
1409: #ifdef MACHO_PIC
1410: if (!(name[0] == '*' && name[1] == 'L'))
1411: machopic_define_name (name);
1412: #endif
1413: if (output_bytecode)
1414: BC_OUTPUT_LABEL (asm_out_file, name);
1415: else
1416: ASM_OUTPUT_LABEL (asm_out_file, name);
1417: }
1418:
1419: /* Output to FILE a reference to the assembler name of a C-level name NAME.
1420: If NAME starts with a *, the rest of NAME is output verbatim.
1421: Otherwise NAME is transformed in an implementation-defined way
1422: (usually by the addition of an underscore).
1423: Many macros in the tm file are defined to call this function. */
1424:
1425: void
1426: assemble_name (file, name)
1427: FILE *file;
1428: char *name;
1429: {
1430: if (name[0] == '*')
1431: {
1432: if (output_bytecode)
1433: bc_emit_labelref (name);
1434: else
1435: fputs (&name[1], file);
1436: }
1437: else
1438: {
1439: if (output_bytecode)
1440: BC_OUTPUT_LABELREF (file, name);
1441: else
1442: ASM_OUTPUT_LABELREF (file, name);
1443: }
1444: }
1445:
1446: /* Allocate SIZE bytes writable static space with a gensym name
1447: and return an RTX to refer to its address. */
1448:
1449: rtx
1450: assemble_static_space (size)
1451: int size;
1452: {
1453: char name[12];
1454: char *namestring;
1455: rtx x;
1456: /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1457: so that each uninitialized object starts on such a boundary. */
1458: int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1459: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1460: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1461:
1462: #if 0
1463: if (flag_shared_data)
1464: data_section ();
1465: #endif
1466:
1467: ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1468: ++const_labelno;
1469:
1470: namestring = (char *) obstack_alloc (saveable_obstack,
1471: strlen (name) + 2);
1472: strcpy (namestring, name);
1473:
1474: if (output_bytecode)
1475: x = bc_gen_rtx (namestring, 0, (struct bc_label *) 0);
1476: else
1477: x = gen_rtx (SYMBOL_REF, Pmode, namestring);
1478:
1479: if (output_bytecode)
1480: {
1481: BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1482: }
1483: else
1484: {
1485: #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1486: ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1487: #else
1488: ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1489: #endif
1490: }
1491: return x;
1492: }
1493:
1494: /* Assemble the static constant template for function entry trampolines.
1495: This is done at most once per compilation.
1496: Returns an RTX for the address of the template. */
1497:
1498: rtx
1499: assemble_trampoline_template ()
1500: {
1501: char label[256];
1502: char *name;
1503: int align;
1504:
1505: /* Shouldn't get here */
1506: if (output_bytecode)
1507: abort ();
1508:
1509: /* By default, put trampoline templates in read-only data section. */
1510:
1511: #ifdef TRAMPOLINE_SECTION
1512: TRAMPOLINE_SECTION ();
1513: #else
1514: readonly_data_section ();
1515: #endif
1516:
1517: /* Write the assembler code to define one. */
1518: align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1519: if (align > 0)
1520: ASM_OUTPUT_ALIGN (asm_out_file, align);
1521:
1522: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1523: TRAMPOLINE_TEMPLATE (asm_out_file);
1524:
1525: /* Record the rtl to refer to it. */
1526: ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1527: name
1528: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1529: return gen_rtx (SYMBOL_REF, Pmode, name);
1530: }
1531:
1532: /* Assemble the integer constant X into an object of SIZE bytes.
1533: X must be either a CONST_INT or CONST_DOUBLE.
1534:
1535: Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1536: non-zero, abort if we can't output the constant. */
1537:
1538: int
1539: assemble_integer (x, size, force)
1540: rtx x;
1541: int size;
1542: int force;
1543: {
1544: /* First try to use the standard 1, 2, 4, 8, and 16 byte
1545: ASM_OUTPUT... macros. */
1546:
1547: switch (size)
1548: {
1549: #ifdef ASM_OUTPUT_CHAR
1550: case 1:
1551: ASM_OUTPUT_CHAR (asm_out_file, x);
1552: return 1;
1553: #endif
1554:
1555: #ifdef ASM_OUTPUT_SHORT
1556: case 2:
1557: ASM_OUTPUT_SHORT (asm_out_file, x);
1558: return 1;
1559: #endif
1560:
1561: #ifdef ASM_OUTPUT_INT
1562: case 4:
1563: ASM_OUTPUT_INT (asm_out_file, x);
1564: return 1;
1565: #endif
1566:
1567: #ifdef ASM_OUTPUT_DOUBLE_INT
1568: case 8:
1569: ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1570: return 1;
1571: #endif
1572:
1573: #ifdef ASM_OUTPUT_QUADRUPLE_INT
1574: case 16:
1575: ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1576: return 1;
1577: #endif
1578: }
1579:
1580: /* If we couldn't do it that way, there are two other possibilities: First,
1581: if the machine can output an explicit byte and this is a 1 byte constant,
1582: we can use ASM_OUTPUT_BYTE. */
1583:
1584: #ifdef ASM_OUTPUT_BYTE
1585: if (size == 1 && GET_CODE (x) == CONST_INT)
1586: {
1587: ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1588: return 1;
1589: }
1590: #endif
1591:
1592: /* Finally, if SIZE is larger than a single word, try to output the constant
1593: one word at a time. */
1594:
1595: if (size > UNITS_PER_WORD)
1596: {
1597: int i;
1598: enum machine_mode mode
1599: = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1600: rtx word;
1601:
1602: for (i = 0; i < size / UNITS_PER_WORD; i++)
1603: {
1604: word = operand_subword (x, i, 0, mode);
1605:
1606: if (word == 0)
1607: break;
1608:
1609: if (! assemble_integer (word, UNITS_PER_WORD, 0))
1610: break;
1611: }
1612:
1613: if (i == size / UNITS_PER_WORD)
1614: return 1;
1615: /* If we output at least one word and then could not finish,
1616: there is no valid way to continue. */
1617: if (i > 0)
1618: abort ();
1619: }
1620:
1621: if (force)
1622: abort ();
1623:
1624: return 0;
1625: }
1626:
1627: /* Assemble the floating-point constant D into an object of size MODE. */
1628:
1629: void
1630: assemble_real (d, mode)
1631: REAL_VALUE_TYPE d;
1632: enum machine_mode mode;
1633: {
1634: jmp_buf output_constant_handler;
1635:
1636: if (setjmp (output_constant_handler))
1637: {
1638: error ("floating point trap outputting a constant");
1639: #ifdef REAL_IS_NOT_DOUBLE
1640: bzero (&d, sizeof d);
1641: d = dconst0;
1642: #else
1643: d = 0;
1644: #endif
1645: }
1646:
1647: set_float_handler (output_constant_handler);
1648:
1649: switch (mode)
1650: {
1651: #ifdef ASM_OUTPUT_BYTE_FLOAT
1652: case QFmode:
1653: ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1654: break;
1655: #endif
1656: #ifdef ASM_OUTPUT_SHORT_FLOAT
1657: case HFmode:
1658: ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1659: break;
1660: #endif
1661: #ifdef ASM_OUTPUT_FLOAT
1662: case SFmode:
1663: ASM_OUTPUT_FLOAT (asm_out_file, d);
1664: break;
1665: #endif
1666:
1667: #ifdef ASM_OUTPUT_DOUBLE
1668: case DFmode:
1669: ASM_OUTPUT_DOUBLE (asm_out_file, d);
1670: break;
1671: #endif
1672:
1673: #ifdef ASM_OUTPUT_LONG_DOUBLE
1674: case XFmode:
1675: case TFmode:
1676: ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1677: break;
1678: #endif
1679:
1680: default:
1681: abort ();
1682: }
1683:
1684: set_float_handler (NULL_PTR);
1685: }
1686:
1687: /* Here we combine duplicate floating constants to make
1688: CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1689:
1690: /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
1691: They are chained through the CONST_DOUBLE_CHAIN.
1692: A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
1693: In that case, CONST_DOUBLE_MEM is either a MEM,
1694: or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.
1695:
1696: (CONST_DOUBLE_MEM is used only for top-level functions.
1697: See force_const_mem for explanation.) */
1698:
1699: static rtx const_double_chain;
1700:
1701: /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1702: For an integer, I0 is the low-order word and I1 is the high-order word.
1703: For a real number, I0 is the word with the low address
1704: and I1 is the word with the high address. */
1705:
1706: rtx
1707: immed_double_const (i0, i1, mode)
1708: HOST_WIDE_INT i0, i1;
1709: enum machine_mode mode;
1710: {
1711: register rtx r;
1712: int in_current_obstack;
1713:
1714: if (GET_MODE_CLASS (mode) == MODE_INT
1715: || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1716: {
1717: /* We clear out all bits that don't belong in MODE, unless they and our
1718: sign bit are all one. So we get either a reasonable negative value
1719: or a reasonable unsigned value for this mode. */
1720: int width = GET_MODE_BITSIZE (mode);
1721: if (width < HOST_BITS_PER_WIDE_INT
1722: && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
1723: != ((HOST_WIDE_INT) (-1) << (width - 1))))
1724: i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
1725: else if (width == HOST_BITS_PER_WIDE_INT
1726: && ! (i1 == ~0 && i0 < 0))
1727: i1 = 0;
1728: else if (width > 2 * HOST_BITS_PER_WIDE_INT)
1729: /* We cannot represent this value as a constant. */
1730: abort ();
1731:
1732: /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
1733:
1734: ??? Strictly speaking, this is wrong if we create a CONST_INT
1735: for a large unsigned constant with the size of MODE being
1736: HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
1737: wider mode. In that case we will mis-interpret it as a negative
1738: number.
1739:
1740: Unfortunately, the only alternative is to make a CONST_DOUBLE
1741: for any constant in any mode if it is an unsigned constant larger
1742: than the maximum signed integer in an int on the host. However,
1743: doing this will break everyone that always expects to see a CONST_INT
1744: for SImode and smaller.
1745:
1746: We have always been making CONST_INTs in this case, so nothing new
1747: is being broken. */
1748:
1749: if (width <= HOST_BITS_PER_WIDE_INT)
1750: i1 = (i0 < 0) ? ~0 : 0;
1751:
1752: /* If this integer fits in one word, return a CONST_INT. */
1753: if ((i1 == 0 && i0 >= 0)
1754: || (i1 == ~0 && i0 < 0))
1755: return GEN_INT (i0);
1756:
1757: /* We use VOIDmode for integers. */
1758: mode = VOIDmode;
1759: }
1760:
1761: /* Search the chain for an existing CONST_DOUBLE with the right value.
1762: If one is found, return it. */
1763:
1764: for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1765: if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
1766: && GET_MODE (r) == mode)
1767: return r;
1768:
1769: /* No; make a new one and add it to the chain.
1770:
1771: We may be called by an optimizer which may be discarding any memory
1772: allocated during its processing (such as combine and loop). However,
1773: we will be leaving this constant on the chain, so we cannot tolerate
1774: freed memory. So switch to saveable_obstack for this allocation
1775: and then switch back if we were in current_obstack. */
1776:
1777: push_obstacks_nochange ();
1778: rtl_in_saveable_obstack ();
1779: r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
1780: pop_obstacks ();
1781:
1782: /* Don't touch const_double_chain in nested function; see force_const_mem.
1783: Also, don't touch it if not inside any function. */
1784: if (outer_function_chain == 0 && current_function_decl != 0)
1785: {
1786: CONST_DOUBLE_CHAIN (r) = const_double_chain;
1787: const_double_chain = r;
1788: }
1789:
1790: /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
1791: Actual use of mem-slot is only through force_const_mem. */
1792:
1793: CONST_DOUBLE_MEM (r) = const0_rtx;
1794:
1795: return r;
1796: }
1797:
1798: /* Return a CONST_DOUBLE for a specified `double' value
1799: and machine mode. */
1800:
1801: rtx
1802: immed_real_const_1 (d, mode)
1803: REAL_VALUE_TYPE d;
1804: enum machine_mode mode;
1805: {
1806: union real_extract u;
1807: register rtx r;
1808: int in_current_obstack;
1809:
1810: /* Get the desired `double' value as a sequence of ints
1811: since that is how they are stored in a CONST_DOUBLE. */
1812:
1813: u.d = d;
1814:
1815: /* Detect special cases. */
1816:
1817: /* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero. */
1818: if (!bcmp (&dconst0, &d, sizeof d))
1819: return CONST0_RTX (mode);
1820: /* Check for NaN first, because some ports (specifically the i386) do not
1821: emit correct ieee-fp code by default, and thus will generate a core
1822: dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
1823: does a floating point comparison. */
1824: else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
1825: return CONST1_RTX (mode);
1826:
1827: if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
1828: return immed_double_const (u.i[0], u.i[1], mode);
1829:
1830: /* The rest of this function handles the case where
1831: a float value requires more than 2 ints of space.
1832: It will be deleted as dead code on machines that don't need it. */
1833:
1834: /* Search the chain for an existing CONST_DOUBLE with the right value.
1835: If one is found, return it. */
1836:
1837: for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1838: if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
1839: && GET_MODE (r) == mode)
1840: return r;
1841:
1842: /* No; make a new one and add it to the chain.
1843:
1844: We may be called by an optimizer which may be discarding any memory
1845: allocated during its processing (such as combine and loop). However,
1846: we will be leaving this constant on the chain, so we cannot tolerate
1847: freed memory. So switch to saveable_obstack for this allocation
1848: and then switch back if we were in current_obstack. */
1849:
1850: push_obstacks_nochange ();
1851: rtl_in_saveable_obstack ();
1852: r = rtx_alloc (CONST_DOUBLE);
1853: PUT_MODE (r, mode);
1854: bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
1855: pop_obstacks ();
1856:
1857: /* Don't touch const_double_chain in nested function; see force_const_mem.
1858: Also, don't touch it if not inside any function. */
1859: if (outer_function_chain == 0 && current_function_decl != 0)
1860: {
1861: CONST_DOUBLE_CHAIN (r) = const_double_chain;
1862: const_double_chain = r;
1863: }
1864:
1865: /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
1866: chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
1867: is only through force_const_mem. */
1868:
1869: CONST_DOUBLE_MEM (r) = const0_rtx;
1870:
1871: return r;
1872: }
1873:
1874: /* Return a CONST_DOUBLE rtx for a value specified by EXP,
1875: which must be a REAL_CST tree node. */
1876:
1877: rtx
1878: immed_real_const (exp)
1879: tree exp;
1880: {
1881: return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
1882: }
1883:
1884: /* At the end of a function, forget the memory-constants
1885: previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
1886: Also clear out real_constant_chain and clear out all the chain-pointers. */
1887:
1888: void
1889: clear_const_double_mem ()
1890: {
1891: register rtx r, next;
1892:
1893: /* Don't touch CONST_DOUBLE_MEM for nested functions.
1894: See force_const_mem for explanation. */
1895: if (outer_function_chain != 0)
1896: return;
1897:
1898: for (r = const_double_chain; r; r = next)
1899: {
1900: next = CONST_DOUBLE_CHAIN (r);
1901: CONST_DOUBLE_CHAIN (r) = 0;
1902: CONST_DOUBLE_MEM (r) = cc0_rtx;
1903: }
1904: const_double_chain = 0;
1905: }
1906:
1907: /* Given an expression EXP with a constant value,
1908: reduce it to the sum of an assembler symbol and an integer.
1909: Store them both in the structure *VALUE.
1910: Abort if EXP does not reduce. */
1911:
1912: struct addr_const
1913: {
1914: rtx base;
1915: HOST_WIDE_INT offset;
1916: };
1917:
1918: static void
1919: decode_addr_const (exp, value)
1920: tree exp;
1921: struct addr_const *value;
1922: {
1923: register tree target = TREE_OPERAND (exp, 0);
1924: register int offset = 0;
1925: register rtx x;
1926:
1927: while (1)
1928: {
1929: if (TREE_CODE (target) == COMPONENT_REF
1930: && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
1931: == INTEGER_CST))
1932: {
1933: offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
1934: target = TREE_OPERAND (target, 0);
1935: }
1936: else if (TREE_CODE (target) == ARRAY_REF)
1937: {
1938: if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
1939: || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
1940: abort ();
1941: offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
1942: * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
1943: / BITS_PER_UNIT);
1944: target = TREE_OPERAND (target, 0);
1945: }
1946: else
1947: break;
1948: }
1949:
1950: switch (TREE_CODE (target))
1951: {
1952: case VAR_DECL:
1953: case FUNCTION_DECL:
1954: x = DECL_RTL (target);
1955: break;
1956:
1957: case LABEL_DECL:
1958: if (output_bytecode)
1959: /* FIXME: this may not be correct, check it */
1960: x = bc_gen_rtx (TREE_STRING_POINTER (target), 0, (struct bc_label *) 0);
1961: else
1962: x = gen_rtx (MEM, FUNCTION_MODE,
1963: gen_rtx (LABEL_REF, VOIDmode,
1964: label_rtx (TREE_OPERAND (exp, 0))));
1965: break;
1966:
1967: case REAL_CST:
1968: case STRING_CST:
1969: case COMPLEX_CST:
1970: case CONSTRUCTOR:
1971: x = TREE_CST_RTL (target);
1972: break;
1973:
1974: default:
1975: abort ();
1976: }
1977:
1978: if (!output_bytecode)
1979: {
1980: if (GET_CODE (x) != MEM)
1981: abort ();
1982: x = XEXP (x, 0);
1983: }
1984:
1985: value->base = x;
1986: value->offset = offset;
1987: }
1988:
1989: /* Uniquize all constants that appear in memory.
1990: Each constant in memory thus far output is recorded
1991: in `const_hash_table' with a `struct constant_descriptor'
1992: that contains a polish representation of the value of
1993: the constant.
1994:
1995: We cannot store the trees in the hash table
1996: because the trees may be temporary. */
1997:
1998: struct constant_descriptor
1999: {
2000: struct constant_descriptor *next;
2001: char *label;
2002: char contents[1];
2003: };
2004:
2005: #define HASHBITS 30
2006: #define MAX_HASH_TABLE 1009
2007: static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2008:
2009: /* Compute a hash code for a constant expression. */
2010:
2011: int
2012: const_hash (exp)
2013: tree exp;
2014: {
2015: register char *p;
2016: register int len, hi, i;
2017: register enum tree_code code = TREE_CODE (exp);
2018:
2019: if (code == INTEGER_CST)
2020: {
2021: p = (char *) &TREE_INT_CST_LOW (exp);
2022: len = 2 * sizeof TREE_INT_CST_LOW (exp);
2023: }
2024: else if (code == REAL_CST)
2025: {
2026: p = (char *) &TREE_REAL_CST (exp);
2027: len = sizeof TREE_REAL_CST (exp);
2028: }
2029: else if (code == STRING_CST)
2030: p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
2031: else if (code == COMPLEX_CST)
2032: return const_hash (TREE_REALPART (exp)) * 5
2033: + const_hash (TREE_IMAGPART (exp));
2034: else if (code == CONSTRUCTOR)
2035: {
2036: register tree link;
2037:
2038: /* For record type, include the type in the hashing.
2039: We do not do so for array types
2040: because (1) the sizes of the elements are sufficient
2041: and (2) distinct array types can have the same constructor.
2042: Instead, we include the array size because the constructor could
2043: be shorter. */
2044: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2045: hi = ((HOST_WIDE_INT) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2046: % MAX_HASH_TABLE;
2047: else
2048: hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2049: & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2050:
2051: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2052: if (TREE_VALUE (link))
2053: hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2054:
2055: return hi;
2056: }
2057: else if (code == ADDR_EXPR)
2058: {
2059: struct addr_const value;
2060: decode_addr_const (exp, &value);
2061: if (GET_CODE (value.base) == SYMBOL_REF)
2062: {
2063: /* Don't hash the address of the SYMBOL_REF;
2064: only use the offset and the symbol name. */
2065: hi = value.offset;
2066: p = XSTR (value.base, 0);
2067: for (i = 0; p[i] != 0; i++)
2068: hi = ((hi * 613) + (unsigned)(p[i]));
2069: }
2070: else if (GET_CODE (value.base) == LABEL_REF)
2071: hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2072:
2073: hi &= (1 << HASHBITS) - 1;
2074: hi %= MAX_HASH_TABLE;
2075: return hi;
2076: }
2077: else if (code == PLUS_EXPR || code == MINUS_EXPR)
2078: return const_hash (TREE_OPERAND (exp, 0)) * 9
2079: + const_hash (TREE_OPERAND (exp, 1));
2080: else if (code == NOP_EXPR || code == CONVERT_EXPR)
2081: return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2082:
2083: /* Compute hashing function */
2084: hi = len;
2085: for (i = 0; i < len; i++)
2086: hi = ((hi * 613) + (unsigned)(p[i]));
2087:
2088: hi &= (1 << HASHBITS) - 1;
2089: hi %= MAX_HASH_TABLE;
2090: return hi;
2091: }
2092:
2093: /* Compare a constant expression EXP with a constant-descriptor DESC.
2094: Return 1 if DESC describes a constant with the same value as EXP. */
2095:
2096: static int
2097: compare_constant (exp, desc)
2098: tree exp;
2099: struct constant_descriptor *desc;
2100: {
2101: return 0 != compare_constant_1 (exp, desc->contents);
2102: }
2103:
2104: /* Compare constant expression EXP with a substring P of a constant descriptor.
2105: If they match, return a pointer to the end of the substring matched.
2106: If they do not match, return 0.
2107:
2108: Since descriptors are written in polish prefix notation,
2109: this function can be used recursively to test one operand of EXP
2110: against a subdescriptor, and if it succeeds it returns the
2111: address of the subdescriptor for the next operand. */
2112:
2113: static char *
2114: compare_constant_1 (exp, p)
2115: tree exp;
2116: char *p;
2117: {
2118: register char *strp;
2119: register int len;
2120: register enum tree_code code = TREE_CODE (exp);
2121:
2122: if (code != (enum tree_code) *p++)
2123: return 0;
2124:
2125: if (code == INTEGER_CST)
2126: {
2127: /* Integer constants are the same only if the same width of type. */
2128: if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2129: return 0;
2130: strp = (char *) &TREE_INT_CST_LOW (exp);
2131: len = 2 * sizeof TREE_INT_CST_LOW (exp);
2132: }
2133: else if (code == REAL_CST)
2134: {
2135: /* Real constants are the same only if the same width of type. */
2136: if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2137: return 0;
2138: strp = (char *) &TREE_REAL_CST (exp);
2139: len = sizeof TREE_REAL_CST (exp);
2140: }
2141: else if (code == STRING_CST)
2142: {
2143: if (flag_writable_strings)
2144: return 0;
2145: strp = TREE_STRING_POINTER (exp);
2146: len = TREE_STRING_LENGTH (exp);
2147: if (bcmp (&TREE_STRING_LENGTH (exp), p,
2148: sizeof TREE_STRING_LENGTH (exp)))
2149: return 0;
2150: p += sizeof TREE_STRING_LENGTH (exp);
2151: }
2152: else if (code == COMPLEX_CST)
2153: {
2154: p = compare_constant_1 (TREE_REALPART (exp), p);
2155: if (p == 0) return 0;
2156: p = compare_constant_1 (TREE_IMAGPART (exp), p);
2157: return p;
2158: }
2159: else if (code == CONSTRUCTOR)
2160: {
2161: register tree link;
2162: int length = list_length (CONSTRUCTOR_ELTS (exp));
2163: tree type;
2164:
2165: if (bcmp (&length, p, sizeof length))
2166: return 0;
2167: p += sizeof length;
2168:
2169: /* For record constructors, insist that the types match.
2170: For arrays, just verify both constructors are for arrays. */
2171: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2172: type = TREE_TYPE (exp);
2173: else
2174: type = 0;
2175: if (bcmp (&type, p, sizeof type))
2176: return 0;
2177: p += sizeof type;
2178:
2179: /* For arrays, insist that the size in bytes match. */
2180: if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2181: {
2182: int size = int_size_in_bytes (TREE_TYPE (exp));
2183: if (bcmp (&size, p, sizeof size))
2184: return 0;
2185: p += sizeof size;
2186: }
2187:
2188: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2189: {
2190: if (TREE_VALUE (link))
2191: {
2192: if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2193: return 0;
2194: }
2195: else
2196: {
2197: tree zero = 0;
2198:
2199: if (bcmp (&zero, p, sizeof zero))
2200: return 0;
2201: p += sizeof zero;
2202: }
2203: }
2204:
2205: return p;
2206: }
2207: else if (code == ADDR_EXPR)
2208: {
2209: struct addr_const value;
2210: decode_addr_const (exp, &value);
2211: strp = (char *) &value.offset;
2212: len = sizeof value.offset;
2213: /* Compare the offset. */
2214: while (--len >= 0)
2215: if (*p++ != *strp++)
2216: return 0;
2217: /* Compare symbol name. */
2218: strp = XSTR (value.base, 0);
2219: len = strlen (strp) + 1;
2220: }
2221: else if (code == PLUS_EXPR || code == MINUS_EXPR)
2222: {
2223: p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2224: if (p == 0) return 0;
2225: p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
2226: return p;
2227: }
2228: else if (code == NOP_EXPR || code == CONVERT_EXPR)
2229: {
2230: p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2231: return p;
2232: }
2233:
2234: /* Compare constant contents. */
2235: while (--len >= 0)
2236: if (*p++ != *strp++)
2237: return 0;
2238:
2239: return p;
2240: }
2241:
2242: /* Construct a constant descriptor for the expression EXP.
2243: It is up to the caller to enter the descriptor in the hash table. */
2244:
2245: static struct constant_descriptor *
2246: record_constant (exp)
2247: tree exp;
2248: {
2249: struct constant_descriptor *next = 0;
2250: char *label = 0;
2251:
2252: /* Make a struct constant_descriptor. The first two pointers will
2253: be filled in later. Here we just leave space for them. */
2254:
2255: obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2256: obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2257: record_constant_1 (exp);
2258: return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2259: }
2260:
2261: /* Add a description of constant expression EXP
2262: to the object growing in `permanent_obstack'.
2263: No need to return its address; the caller will get that
2264: from the obstack when the object is complete. */
2265:
2266: static void
2267: record_constant_1 (exp)
2268: tree exp;
2269: {
2270: register char *strp;
2271: register int len;
2272: register enum tree_code code = TREE_CODE (exp);
2273:
2274: obstack_1grow (&permanent_obstack, (unsigned int) code);
2275:
2276: if (code == INTEGER_CST)
2277: {
2278: obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2279: strp = (char *) &TREE_INT_CST_LOW (exp);
2280: len = 2 * sizeof TREE_INT_CST_LOW (exp);
2281: }
2282: else if (code == REAL_CST)
2283: {
2284: obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2285: strp = (char *) &TREE_REAL_CST (exp);
2286: len = sizeof TREE_REAL_CST (exp);
2287: }
2288: else if (code == STRING_CST)
2289: {
2290: if (flag_writable_strings)
2291: return;
2292: strp = TREE_STRING_POINTER (exp);
2293: len = TREE_STRING_LENGTH (exp);
2294: obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2295: sizeof TREE_STRING_LENGTH (exp));
2296: }
2297: else if (code == COMPLEX_CST)
2298: {
2299: record_constant_1 (TREE_REALPART (exp));
2300: record_constant_1 (TREE_IMAGPART (exp));
2301: return;
2302: }
2303: else if (code == CONSTRUCTOR)
2304: {
2305: register tree link;
2306: int length = list_length (CONSTRUCTOR_ELTS (exp));
2307: tree type;
2308:
2309: obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2310:
2311: /* For record constructors, insist that the types match.
2312: For arrays, just verify both constructors are for arrays. */
2313: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2314: type = TREE_TYPE (exp);
2315: else
2316: type = 0;
2317: obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2318:
2319: /* For arrays, insist that the size in bytes match. */
2320: if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2321: {
2322: int size = int_size_in_bytes (TREE_TYPE (exp));
2323: obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2324: }
2325:
2326: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2327: {
2328: if (TREE_VALUE (link))
2329: record_constant_1 (TREE_VALUE (link));
2330: else
2331: {
2332: tree zero = 0;
2333:
2334: obstack_grow (&permanent_obstack, (char *) &zero, sizeof zero);
2335: }
2336: }
2337:
2338: return;
2339: }
2340: else if (code == ADDR_EXPR)
2341: {
2342: struct addr_const value;
2343: decode_addr_const (exp, &value);
2344: /* Record the offset. */
2345: obstack_grow (&permanent_obstack,
2346: (char *) &value.offset, sizeof value.offset);
2347: /* Record the symbol name. */
2348: obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2349: strlen (XSTR (value.base, 0)) + 1);
2350: return;
2351: }
2352: else if (code == PLUS_EXPR || code == MINUS_EXPR)
2353: {
2354: record_constant_1 (TREE_OPERAND (exp, 0));
2355: record_constant_1 (TREE_OPERAND (exp, 1));
2356: return;
2357: }
2358: else if (code == NOP_EXPR || code == CONVERT_EXPR)
2359: {
2360: record_constant_1 (TREE_OPERAND (exp, 0));
2361: return;
2362: }
2363:
2364: /* Record constant contents. */
2365: obstack_grow (&permanent_obstack, strp, len);
2366: }
2367:
2368: /* Record a list of constant expressions that were passed to
2369: output_constant_def but that could not be output right away. */
2370:
2371: struct deferred_constant
2372: {
2373: struct deferred_constant *next;
2374: tree exp;
2375: int reloc;
2376: int labelno;
2377: };
2378:
2379: static struct deferred_constant *deferred_constants;
2380:
2381: /* Nonzero means defer output of addressed subconstants
2382: (i.e., those for which output_constant_def is called.) */
2383: static int defer_addressed_constants_flag;
2384:
2385: /* Start deferring output of subconstants. */
2386:
2387: void
2388: defer_addressed_constants ()
2389: {
2390: defer_addressed_constants_flag++;
2391: }
2392:
2393: /* Stop deferring output of subconstants,
2394: and output now all those that have been deferred. */
2395:
2396: void
2397: output_deferred_addressed_constants ()
2398: {
2399: struct deferred_constant *p, *next;
2400:
2401: defer_addressed_constants_flag--;
2402:
2403: if (defer_addressed_constants_flag > 0)
2404: return;
2405:
2406: for (p = deferred_constants; p; p = next)
2407: {
2408: output_constant_def_contents (p->exp, p->reloc, p->labelno);
2409: next = p->next;
2410: free (p);
2411: }
2412:
2413: deferred_constants = 0;
2414: }
2415:
2416: /* Make a copy of the whole tree structure for a constant.
2417: This handles the same types of nodes that compare_constant
2418: and record_constant handle. */
2419:
2420: static tree
2421: copy_constant (exp)
2422: tree exp;
2423: {
2424: switch (TREE_CODE (exp))
2425: {
2426: case INTEGER_CST:
2427: case REAL_CST:
2428: case STRING_CST:
2429: case ADDR_EXPR:
2430: /* For ADDR_EXPR, we do not want to copy the decl
2431: whose address is requested. */
2432: return copy_node (exp);
2433:
2434: case COMPLEX_CST:
2435: return build_complex (copy_constant (TREE_REALPART (exp)),
2436: copy_constant (TREE_IMAGPART (exp)));
2437:
2438: case PLUS_EXPR:
2439: case MINUS_EXPR:
2440: return build (TREE_CODE (exp), TREE_TYPE (exp),
2441: copy_constant (TREE_OPERAND (exp, 0)),
2442: copy_constant (TREE_OPERAND (exp, 1)));
2443:
2444: case NOP_EXPR:
2445: case CONVERT_EXPR:
2446: return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2447: copy_constant (TREE_OPERAND (exp, 0)));
2448:
2449: case CONSTRUCTOR:
2450: {
2451: tree copy = copy_node (exp);
2452: tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2453: tree tail;
2454:
2455: CONSTRUCTOR_ELTS (exp) = list;
2456: for (tail = list; tail; tail = TREE_CHAIN (tail))
2457: TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2458:
2459: return copy;
2460: }
2461:
2462: default:
2463: abort ();
2464: }
2465: }
2466:
2467: /* Return an rtx representing a reference to constant data in memory
2468: for the constant expression EXP.
2469:
2470: If assembler code for such a constant has already been output,
2471: return an rtx to refer to it.
2472: Otherwise, output such a constant in memory (or defer it for later)
2473: and generate an rtx for it.
2474:
2475: The TREE_CST_RTL of EXP is set up to point to that rtx.
2476: The const_hash_table records which constants already have label strings. */
2477:
2478: rtx
2479: output_constant_def (exp)
2480: tree exp;
2481: {
2482: register int hash;
2483: register struct constant_descriptor *desc;
2484: char label[256];
2485: char *found = 0;
2486: int reloc;
2487: register rtx def;
2488:
2489: if (TREE_CODE (exp) == INTEGER_CST)
2490: abort (); /* No TREE_CST_RTL slot in these. */
2491:
2492: if (TREE_CST_RTL (exp))
2493: return TREE_CST_RTL (exp);
2494:
2495: /* Make sure any other constants whose addresses appear in EXP
2496: are assigned label numbers. */
2497:
2498: reloc = output_addressed_constants (exp);
2499:
2500: /* Compute hash code of EXP. Search the descriptors for that hash code
2501: to see if any of them describes EXP. If yes, the descriptor records
2502: the label number already assigned. */
2503:
2504: if (!output_bytecode)
2505: {
2506: hash = const_hash (exp) % MAX_HASH_TABLE;
2507:
2508: for (desc = const_hash_table[hash]; desc; desc = desc->next)
2509: if (compare_constant (exp, desc))
2510: {
2511: found = desc->label;
2512: break;
2513: }
2514:
2515: if (found == 0)
2516: {
2517: /* No constant equal to EXP is known to have been output.
2518: Make a constant descriptor to enter EXP in the hash table.
2519: Assign the label number and record it in the descriptor for
2520: future calls to this function to find. */
2521:
2522: /* Create a string containing the label name, in LABEL. */
2523: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2524:
2525: desc = record_constant (exp);
2526: desc->next = const_hash_table[hash];
2527: desc->label
2528: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
2529: const_hash_table[hash] = desc;
2530: }
2531: else
2532: {
2533: /* Create a string containing the label name, in LABEL. */
2534: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2535: }
2536: }
2537:
2538: /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2539:
2540: push_obstacks_nochange ();
2541: if (TREE_PERMANENT (exp))
2542: end_temporary_allocation ();
2543:
2544: if (!output_bytecode)
2545: {
2546: def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
2547:
2548: TREE_CST_RTL (exp)
2549: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
2550: RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
2551: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
2552: || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2553: MEM_IN_STRUCT_P (TREE_CST_RTL (exp)) = 1;
2554: }
2555: pop_obstacks ();
2556:
2557: /* Optionally set flags or add text to the name to record information
2558: such as that it is a function name. If the name is changed, the macro
2559: ASM_OUTPUT_LABELREF will have to know how to strip this information.
2560: And if it finds a * at the beginning after doing so, it must handle
2561: that too. */
2562: #ifdef ENCODE_SECTION_INFO
2563: ENCODE_SECTION_INFO (exp);
2564: #endif
2565:
2566: /* If this is the first time we've seen this particular constant,
2567: output it (or defer its output for later). */
2568: if (found == 0)
2569: {
2570: if (defer_addressed_constants_flag)
2571: {
2572: struct deferred_constant *p;
2573: p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
2574:
2575: push_obstacks_nochange ();
2576: suspend_momentary ();
2577: p->exp = copy_constant (exp);
2578: pop_obstacks ();
2579: p->reloc = reloc;
2580: p->labelno = const_labelno++;
2581: p->next = deferred_constants;
2582: deferred_constants = p;
2583: }
2584: else
2585: output_constant_def_contents (exp, reloc, const_labelno++);
2586: }
2587:
2588: return TREE_CST_RTL (exp);
2589: }
2590:
2591: /* Now output assembler code to define the label for EXP,
2592: and follow it with the data of EXP. */
2593:
2594: static void
2595: output_constant_def_contents (exp, reloc, labelno)
2596: tree exp;
2597: int reloc;
2598: int labelno;
2599: {
2600: int align;
2601:
2602: /* First switch to text section, except for writable strings. */
2603: #ifdef SELECT_SECTION
2604: SELECT_SECTION (exp, reloc);
2605: #else
2606: if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
2607: || (flag_pic && reloc))
2608: data_section ();
2609: else
2610: readonly_data_section ();
2611: #endif
2612:
2613: /* Align the location counter as required by EXP's data type. */
2614: align = TYPE_ALIGN (TREE_TYPE (exp));
2615: #ifdef CONSTANT_ALIGNMENT
2616: align = CONSTANT_ALIGNMENT (exp, align);
2617: #endif
2618:
2619: if (align > BITS_PER_UNIT)
2620: {
2621: if (!output_bytecode)
2622: {
2623: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2624: }
2625: else
2626: {
2627: BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2628: }
2629: }
2630:
2631: /* Output the label itself. */
2632: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
2633:
2634: /* Output the value of EXP. */
2635: output_constant (exp,
2636: (TREE_CODE (exp) == STRING_CST
2637: ? TREE_STRING_LENGTH (exp)
2638: : int_size_in_bytes (TREE_TYPE (exp))));
2639:
2640: }
2641:
2642: /* Similar hash facility for making memory-constants
2643: from constant rtl-expressions. It is used on RISC machines
2644: where immediate integer arguments and constant addresses are restricted
2645: so that such constants must be stored in memory.
2646:
2647: This pool of constants is reinitialized for each function
2648: so each function gets its own constants-pool that comes right before it.
2649:
2650: All structures allocated here are discarded when functions are saved for
2651: inlining, so they do not need to be allocated permanently. */
2652:
2653: #define MAX_RTX_HASH_TABLE 61
2654: static struct constant_descriptor **const_rtx_hash_table;
2655:
2656: /* Structure to represent sufficient information about a constant so that
2657: it can be output when the constant pool is output, so that function
2658: integration can be done, and to simplify handling on machines that reference
2659: constant pool as base+displacement. */
2660:
2661: struct pool_constant
2662: {
2663: struct constant_descriptor *desc;
2664: struct pool_constant *next;
2665: enum machine_mode mode;
2666: rtx constant;
2667: int labelno;
2668: int align;
2669: int offset;
2670: };
2671:
2672: /* Pointers to first and last constant in pool. */
2673:
2674: static struct pool_constant *first_pool, *last_pool;
2675:
2676: /* Current offset in constant pool (does not include any machine-specific
2677: header. */
2678:
2679: static int pool_offset;
2680:
2681: /* Structure used to maintain hash table mapping symbols used to their
2682: corresponding constants. */
2683:
2684: struct pool_sym
2685: {
2686: char *label;
2687: struct pool_constant *pool;
2688: struct pool_sym *next;
2689: };
2690:
2691: static struct pool_sym **const_rtx_sym_hash_table;
2692:
2693: /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
2694: The argument is XSTR (... , 0) */
2695:
2696: #define SYMHASH(LABEL) \
2697: ((((HOST_WIDE_INT) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
2698:
2699: /* Initialize constant pool hashing for next function. */
2700:
2701: void
2702: init_const_rtx_hash_table ()
2703: {
2704: const_rtx_hash_table
2705: = ((struct constant_descriptor **)
2706: oballoc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
2707: const_rtx_sym_hash_table
2708: = ((struct pool_sym **)
2709: oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
2710: bzero (const_rtx_hash_table,
2711: MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
2712: bzero (const_rtx_sym_hash_table,
2713: MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
2714:
2715: first_pool = last_pool = 0;
2716: pool_offset = 0;
2717: }
2718:
2719: /* Save and restore it for a nested function. */
2720:
2721: void
2722: save_varasm_status (p)
2723: struct function *p;
2724: {
2725: p->const_rtx_hash_table = const_rtx_hash_table;
2726: p->const_rtx_sym_hash_table = const_rtx_sym_hash_table;
2727: p->first_pool = first_pool;
2728: p->last_pool = last_pool;
2729: p->pool_offset = pool_offset;
2730: }
2731:
2732: void
2733: restore_varasm_status (p)
2734: struct function *p;
2735: {
2736: const_rtx_hash_table = p->const_rtx_hash_table;
2737: const_rtx_sym_hash_table = p->const_rtx_sym_hash_table;
2738: first_pool = p->first_pool;
2739: last_pool = p->last_pool;
2740: pool_offset = p->pool_offset;
2741: }
2742:
2743: enum kind { RTX_DOUBLE, RTX_INT };
2744:
2745: struct rtx_const
2746: {
2747: #ifdef ONLY_INT_FIELDS
2748: unsigned int kind : 16;
2749: unsigned int mode : 16;
2750: #else
2751: enum kind kind : 16;
2752: enum machine_mode mode : 16;
2753: #endif
2754: union {
2755: union real_extract du;
2756: struct addr_const addr;
2757: } un;
2758: };
2759:
2760: /* Express an rtx for a constant integer (perhaps symbolic)
2761: as the sum of a symbol or label plus an explicit integer.
2762: They are stored into VALUE. */
2763:
2764: static void
2765: decode_rtx_const (mode, x, value)
2766: enum machine_mode mode;
2767: rtx x;
2768: struct rtx_const *value;
2769: {
2770: /* Clear the whole structure, including any gaps. */
2771:
2772: {
2773: int *p = (int *) value;
2774: int *end = (int *) (value + 1);
2775: while (p < end)
2776: *p++ = 0;
2777: }
2778:
2779: value->kind = RTX_INT; /* Most usual kind. */
2780: value->mode = mode;
2781:
2782: switch (GET_CODE (x))
2783: {
2784: case CONST_DOUBLE:
2785: value->kind = RTX_DOUBLE;
2786: if (GET_MODE (x) != VOIDmode)
2787: value->mode = GET_MODE (x);
2788: bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
2789: break;
2790:
2791: case CONST_INT:
2792: value->un.addr.offset = INTVAL (x);
2793: break;
2794:
2795: case SYMBOL_REF:
2796: case LABEL_REF:
2797: case PC:
2798: value->un.addr.base = x;
2799: break;
2800:
2801: #ifdef NEXT_SEMANTICS
2802: case SIGN_EXTEND:
2803: decode_rtx_const (mode, XEXP (x, 0), value);
2804: return;
2805: #endif
2806:
2807: case CONST:
2808: x = XEXP (x, 0);
2809: if (GET_CODE (x) == PLUS)
2810: {
2811: value->un.addr.base = XEXP (x, 0);
2812: if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2813: abort ();
2814: value->un.addr.offset = INTVAL (XEXP (x, 1));
2815: }
2816: else if (GET_CODE (x) == MINUS)
2817: {
2818: value->un.addr.base = XEXP (x, 0);
2819: if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2820: abort ();
2821: value->un.addr.offset = - INTVAL (XEXP (x, 1));
2822: }
2823: else
2824: abort ();
2825: break;
2826:
2827: default:
2828: abort ();
2829: }
2830:
2831: if (value->kind == RTX_INT && value->un.addr.base != 0)
2832: switch (GET_CODE (value->un.addr.base))
2833: {
2834: case SYMBOL_REF:
2835: case LABEL_REF:
2836: /* Use the string's address, not the SYMBOL_REF's address,
2837: for the sake of addresses of library routines.
2838: For a LABEL_REF, compare labels. */
2839: value->un.addr.base = XEXP (value->un.addr.base, 0);
2840: }
2841: }
2842:
2843: /* Given a MINUS expression, simplify it if both sides
2844: include the same symbol. */
2845:
2846: rtx
2847: simplify_subtraction (x)
2848: rtx x;
2849: {
2850: struct rtx_const val0, val1;
2851:
2852: decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
2853: decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
2854:
2855: if (val0.un.addr.base == val1.un.addr.base)
2856: return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
2857: return x;
2858: }
2859:
2860: /* Compute a hash code for a constant RTL expression. */
2861:
2862: int
2863: const_hash_rtx (mode, x)
2864: enum machine_mode mode;
2865: rtx x;
2866: {
2867: register int hi, i;
2868:
2869: struct rtx_const value;
2870: decode_rtx_const (mode, x, &value);
2871:
2872: /* Compute hashing function */
2873: hi = 0;
2874: for (i = 0; i < sizeof value / sizeof (int); i++)
2875: hi += ((int *) &value)[i];
2876:
2877: hi &= (1 << HASHBITS) - 1;
2878: hi %= MAX_RTX_HASH_TABLE;
2879: return hi;
2880: }
2881:
2882: /* Compare a constant rtl object X with a constant-descriptor DESC.
2883: Return 1 if DESC describes a constant with the same value as X. */
2884:
2885: static int
2886: compare_constant_rtx (mode, x, desc)
2887: enum machine_mode mode;
2888: rtx x;
2889: struct constant_descriptor *desc;
2890: {
2891: register int *p = (int *) desc->contents;
2892: register int *strp;
2893: register int len;
2894: struct rtx_const value;
2895:
2896: decode_rtx_const (mode, x, &value);
2897: strp = (int *) &value;
2898: len = sizeof value / sizeof (int);
2899:
2900: /* Compare constant contents. */
2901: while (--len >= 0)
2902: if (*p++ != *strp++)
2903: return 0;
2904:
2905: return 1;
2906: }
2907:
2908: /* Construct a constant descriptor for the rtl-expression X.
2909: It is up to the caller to enter the descriptor in the hash table. */
2910:
2911: static struct constant_descriptor *
2912: record_constant_rtx (mode, x)
2913: enum machine_mode mode;
2914: rtx x;
2915: {
2916: struct constant_descriptor *ptr;
2917: char *label;
2918: struct rtx_const value;
2919:
2920: decode_rtx_const (mode, x, &value);
2921:
2922: obstack_grow (current_obstack, &ptr, sizeof ptr);
2923: obstack_grow (current_obstack, &label, sizeof label);
2924:
2925: /* Record constant contents. */
2926: obstack_grow (current_obstack, &value, sizeof value);
2927:
2928: return (struct constant_descriptor *) obstack_finish (current_obstack);
2929: }
2930:
2931: /* Given a constant rtx X, make (or find) a memory constant for its value
2932: and return a MEM rtx to refer to it in memory. */
2933:
2934: rtx
2935: force_const_mem (mode, x)
2936: enum machine_mode mode;
2937: rtx x;
2938: {
2939: register int hash;
2940: register struct constant_descriptor *desc;
2941: char label[256];
2942: char *found = 0;
2943: rtx def;
2944:
2945: /* If we want this CONST_DOUBLE in the same mode as it is in memory
2946: (this will always be true for floating CONST_DOUBLEs that have been
2947: placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
2948: use the previous copy. Otherwise, make a new one. Note that in
2949: the unlikely event that this same CONST_DOUBLE is used in two different
2950: modes in an alternating fashion, we will allocate a lot of different
2951: memory locations, but this should be extremely rare. */
2952:
2953: /* Don't use CONST_DOUBLE_MEM in a nested function.
2954: Nested functions have their own constant pools,
2955: so they can't share the same values in CONST_DOUBLE_MEM
2956: with the containing function. */
2957: if (outer_function_chain == 0)
2958: if (GET_CODE (x) == CONST_DOUBLE
2959: && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
2960: && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
2961: return CONST_DOUBLE_MEM (x);
2962:
2963: /* Compute hash code of X. Search the descriptors for that hash code
2964: to see if any of them describes X. If yes, the descriptor records
2965: the label number already assigned. */
2966:
2967: hash = const_hash_rtx (mode, x);
2968:
2969: for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
2970: if (compare_constant_rtx (mode, x, desc))
2971: {
2972: found = desc->label;
2973: break;
2974: }
2975:
2976: if (found == 0)
2977: {
2978: register struct pool_constant *pool;
2979: register struct pool_sym *sym;
2980: int align;
2981:
2982: /* No constant equal to X is known to have been output.
2983: Make a constant descriptor to enter X in the hash table.
2984: Assign the label number and record it in the descriptor for
2985: future calls to this function to find. */
2986:
2987: desc = record_constant_rtx (mode, x);
2988: desc->next = const_rtx_hash_table[hash];
2989: const_rtx_hash_table[hash] = desc;
2990:
2991: /* Align the location counter as required by EXP's data type. */
2992: align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
2993: if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2994: align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
2995:
2996: pool_offset += align - 1;
2997: pool_offset &= ~ (align - 1);
2998:
2999: /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3000:
3001: pool = (struct pool_constant *) oballoc (sizeof (struct pool_constant));
3002: pool->desc = desc;
3003: pool->constant = x;
3004: pool->mode = mode;
3005: pool->labelno = const_labelno;
3006: pool->align = align;
3007: pool->offset = pool_offset;
3008: pool->next = 0;
3009:
3010: if (last_pool == 0)
3011: first_pool = pool;
3012: else
3013: last_pool->next = pool;
3014:
3015: last_pool = pool;
3016: pool_offset += GET_MODE_SIZE (mode);
3017:
3018: /* Create a string containing the label name, in LABEL. */
3019: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3020:
3021: ++const_labelno;
3022:
3023: desc->label = found
3024: = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
3025:
3026: /* Add label to symbol hash table. */
3027: hash = SYMHASH (found);
3028: sym = (struct pool_sym *) oballoc (sizeof (struct pool_sym));
3029: sym->label = found;
3030: sym->pool = pool;
3031: sym->next = const_rtx_sym_hash_table[hash];
3032: const_rtx_sym_hash_table[hash] = sym;
3033: }
3034:
3035: /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3036:
3037: def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, found));
3038:
3039: RTX_UNCHANGING_P (def) = 1;
3040: /* Mark the symbol_ref as belonging to this constants pool. */
3041: CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3042: current_function_uses_const_pool = 1;
3043:
3044: if (outer_function_chain == 0)
3045: if (GET_CODE (x) == CONST_DOUBLE)
3046: {
3047: if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3048: {
3049: CONST_DOUBLE_CHAIN (x) = const_double_chain;
3050: const_double_chain = x;
3051: }
3052: CONST_DOUBLE_MEM (x) = def;
3053: }
3054:
3055: return def;
3056: }
3057:
3058: /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3059: the corresponding pool_constant structure. */
3060:
3061: static struct pool_constant *
3062: find_pool_constant (addr)
3063: rtx addr;
3064: {
3065: struct pool_sym *sym;
3066: char *label = XSTR (addr, 0);
3067:
3068: for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
3069: if (sym->label == label)
3070: return sym->pool;
3071:
3072: abort ();
3073: }
3074:
3075: /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3076:
3077: rtx
3078: get_pool_constant (addr)
3079: rtx addr;
3080: {
3081: return (find_pool_constant (addr))->constant;
3082: }
3083:
3084: /* Similar, return the mode. */
3085:
3086: enum machine_mode
3087: get_pool_mode (addr)
3088: rtx addr;
3089: {
3090: return (find_pool_constant (addr))->mode;
3091: }
3092:
3093: /* Similar, return the offset in the constant pool. */
3094:
3095: int
3096: get_pool_offset (addr)
3097: rtx addr;
3098: {
3099: return (find_pool_constant (addr))->offset;
3100: }
3101:
3102: /* Return the size of the constant pool. */
3103:
3104: int
3105: get_pool_size ()
3106: {
3107: return pool_offset;
3108: }
3109:
3110: /* Write all the constants in the constant pool. */
3111:
3112: void
3113: output_constant_pool (fnname, fndecl)
3114: char *fnname;
3115: tree fndecl;
3116: {
3117: struct pool_constant *pool;
3118: rtx x;
3119: union real_extract u;
3120:
3121: #ifdef ASM_RELAXATION_BROKEN
3122: int previous_alignment = 0;
3123: #endif
3124:
3125: #ifdef ASM_OUTPUT_POOL_PROLOGUE
3126: ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3127: #endif
3128:
3129: for (pool = first_pool; pool; pool = pool->next)
3130: {
3131: x = pool->constant;
3132:
3133: /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3134: whose CODE_LABEL has been deleted. This can occur if a jump table
3135: is eliminated by optimization. If so, write a constant of zero
3136: instead. Note that this can also happen by turning the
3137: CODE_LABEL into a NOTE. */
3138: if (((GET_CODE (x) == LABEL_REF
3139: && (INSN_DELETED_P (XEXP (x, 0))
3140: || GET_CODE (XEXP (x, 0)) == NOTE)))
3141: || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3142: && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3143: && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3144: || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3145: x = const0_rtx;
3146:
3147: /* First switch to correct section. */
3148: #ifdef SELECT_RTX_SECTION
3149: SELECT_RTX_SECTION (pool->mode, x);
3150: #else
3151: readonly_data_section ();
3152: #endif
3153:
3154: #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3155: ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3156: pool->align, pool->labelno, done);
3157: #endif
3158:
3159: #ifdef ASM_RELAXATION_BROKEN
3160: if (pool->align > 1 && pool->align != previous_alignment) {
3161: ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
3162: previous_alignment = pool->align;
3163: }
3164: #else
3165: if (pool->align > 1)
3166: ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
3167: #endif
3168:
3169: /* Output the label. */
3170: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3171:
3172: /* Output the value of the constant itself. */
3173: switch (GET_MODE_CLASS (pool->mode))
3174: {
3175: case MODE_FLOAT:
3176: if (GET_CODE (x) != CONST_DOUBLE)
3177: abort ();
3178:
3179: bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
3180: assemble_real (u.d, pool->mode);
3181: break;
3182:
3183: case MODE_INT:
3184: case MODE_PARTIAL_INT:
3185: assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3186: break;
3187:
3188: default:
3189: abort ();
3190: }
3191:
3192: done: ;
3193: }
3194:
3195: /* Done with this pool. */
3196: first_pool = last_pool = 0;
3197: }
3198:
3199: /* Find all the constants whose addresses are referenced inside of EXP,
3200: and make sure assembler code with a label has been output for each one.
3201: Indicate whether an ADDR_EXPR has been encountered. */
3202:
3203: int
3204: output_addressed_constants (exp)
3205: tree exp;
3206: {
3207: int reloc = 0;
3208:
3209: switch (TREE_CODE (exp))
3210: {
3211: case ADDR_EXPR:
3212: {
3213: register tree constant = TREE_OPERAND (exp, 0);
3214:
3215: while (TREE_CODE (constant) == COMPONENT_REF)
3216: {
3217: constant = TREE_OPERAND (constant, 0);
3218: }
3219:
3220: if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3221: || TREE_CODE (constant) == CONSTRUCTOR)
3222: /* No need to do anything here
3223: for addresses of variables or functions. */
3224: output_constant_def (constant);
3225: }
3226: reloc = 1;
3227: break;
3228:
3229: case PLUS_EXPR:
3230: case MINUS_EXPR:
3231: reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3232: reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3233: break;
3234:
3235: case NOP_EXPR:
3236: case CONVERT_EXPR:
3237: case NON_LVALUE_EXPR:
3238: reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3239: break;
3240:
3241: case CONSTRUCTOR:
3242: {
3243: register tree link;
3244: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
3245: if (TREE_VALUE (link) != 0)
3246: reloc |= output_addressed_constants (TREE_VALUE (link));
3247: }
3248: break;
3249:
3250: case ERROR_MARK:
3251: break;
3252: }
3253: return reloc;
3254: }
3255:
3256:
3257: /* Output assembler for byte constant */
3258: void
3259: output_byte_asm (byte)
3260: int byte;
3261: {
3262: if (output_bytecode)
3263: bc_emit_const ((char *) &byte, sizeof (char));
3264: #ifdef ASM_OUTPUT_BYTE
3265: else
3266: {
3267: ASM_OUTPUT_BYTE (asm_out_file, byte);
3268: }
3269: #endif
3270: }
3271:
3272: /* Output assembler code for constant EXP to FILE, with no label.
3273: This includes the pseudo-op such as ".int" or ".byte", and a newline.
3274: Assumes output_addressed_constants has been done on EXP already.
3275:
3276: Generate exactly SIZE bytes of assembler data, padding at the end
3277: with zeros if necessary. SIZE must always be specified.
3278:
3279: SIZE is important for structure constructors,
3280: since trailing members may have been omitted from the constructor.
3281: It is also important for initialization of arrays from string constants
3282: since the full length of the string constant might not be wanted.
3283: It is also needed for initialization of unions, where the initializer's
3284: type is just one member, and that may not be as long as the union.
3285:
3286: There a case in which we would fail to output exactly SIZE bytes:
3287: for a structure constructor that wants to produce more than SIZE bytes.
3288: But such constructors will never be generated for any possible input. */
3289:
3290: void
3291: output_constant (exp, size)
3292: register tree exp;
3293: register int size;
3294: {
3295: register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
3296: rtx x;
3297: char self_label[256];
3298:
3299: if (size == 0)
3300: return;
3301:
3302: /* Allow a constructor with no elements for any data type.
3303: This means to fill the space with zeros. */
3304: if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3305: {
3306: if (output_bytecode)
3307: bc_emit_const_skip (size);
3308: else
3309: assemble_zeros (size);
3310: return;
3311: }
3312:
3313: /* Eliminate the NOP_EXPR that makes a cast not be an lvalue.
3314: That way we get the constant (we hope) inside it. */
3315: if (TREE_CODE (exp) == NOP_EXPR
3316: && TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0)))
3317: exp = TREE_OPERAND (exp, 0);
3318:
3319: switch (code)
3320: {
3321:
3322: case POINTER_TYPE:
3323: case CHAR_TYPE:
3324: case BOOLEAN_TYPE:
3325: case INTEGER_TYPE:
3326: case ENUMERAL_TYPE:
3327: case REFERENCE_TYPE:
3328: /* ??? What about (int)((float)(int)&foo + 4) */
3329:
3330: /*
3331: if (TREE_SELF_OFFSET (exp))
3332: {
3333: extern tree ptr_type_node;
3334: tree decl;
3335: static int label = 0;
3336: sprintf (self_label, "LO$%d", label++);
3337: assemble_label (self_label);
3338: decl = build_decl (VAR_DECL, get_identifier (self_label),
3339: ptr_type_node);
3340: DECL_RTL (decl) = gen_rtx (SYMBOL_REF, Pmode, self_label);
3341: while (TREE_CODE (exp) == NOP_EXPR
3342: || TREE_CODE (exp) == CONVERT_EXPR
3343: || TREE_CODE (exp) == NON_LVALUE_EXPR)
3344: exp = TREE_OPERAND (exp, 0);
3345:
3346: TREE_TYPE (exp) = ptr_type_node;
3347: exp = build_binary_op (MINUS_EXPR, exp,
3348: build1 (ADDR_EXPR, ptr_type_node, decl));
3349: }
3350: */
3351: while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3352: || TREE_CODE (exp) == NON_LVALUE_EXPR)
3353: exp = TREE_OPERAND (exp, 0);
3354:
3355: if (output_bytecode)
3356: bc_assemble_integer (exp, size);
3357: else
3358: if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3359: EXPAND_INITIALIZER),
3360: size, 0))
3361: error ("initializer for integer value is too complicated");
3362: size = 0;
3363: break;
3364:
3365: case REAL_TYPE:
3366: if (TREE_CODE (exp) != REAL_CST)
3367: error ("initializer for floating value is not a floating constant");
3368:
3369: assemble_real (TREE_REAL_CST (exp),
3370: mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
3371: size = 0;
3372: break;
3373:
3374: case COMPLEX_TYPE:
3375: output_constant (TREE_REALPART (exp), size / 2);
3376: output_constant (TREE_IMAGPART (exp), size / 2);
3377: size -= (size / 2) * 2;
3378: break;
3379:
3380: case ARRAY_TYPE:
3381: if (TREE_CODE (exp) == CONSTRUCTOR)
3382: {
3383: output_constructor (exp, size);
3384: return;
3385: }
3386: else if (TREE_CODE (exp) == STRING_CST)
3387: {
3388: int excess = 0;
3389:
3390: if (size > TREE_STRING_LENGTH (exp))
3391: {
3392: excess = size - TREE_STRING_LENGTH (exp);
3393: size = TREE_STRING_LENGTH (exp);
3394: }
3395:
3396: assemble_string (TREE_STRING_POINTER (exp), size);
3397: size = excess;
3398: }
3399: else
3400: abort ();
3401: break;
3402:
3403: case RECORD_TYPE:
3404: case UNION_TYPE:
3405: if (TREE_CODE (exp) == CONSTRUCTOR)
3406: output_constructor (exp, size);
3407: else
3408: abort ();
3409: return;
3410: }
3411:
3412: if (size > 0)
3413: assemble_zeros (size);
3414: }
3415:
3416:
3417: /* Bytecode specific code to output assembler for integer. */
3418: static void
3419: bc_assemble_integer (exp, size)
3420: tree exp;
3421: int size;
3422: {
3423: tree const_part;
3424: tree addr_part;
3425: tree tmp;
3426:
3427: /* FIXME: is this fold() business going to be as good as the
3428: expand_expr() using EXPAND_SUM above in the RTL case? I
3429: hate RMS.
3430: FIXME: Copied as is from BC-GCC1; may need work. Don't hate. -bson */
3431:
3432: exp = fold (exp);
3433:
3434: while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
3435: exp = TREE_OPERAND (exp, 0);
3436: if (TREE_CODE (exp) == INTEGER_CST)
3437: {
3438: const_part = exp;
3439: addr_part = 0;
3440: }
3441: else if (TREE_CODE (exp) == PLUS_EXPR)
3442: {
3443: const_part = TREE_OPERAND (exp, 0);
3444: while (TREE_CODE (const_part) == NOP_EXPR
3445: || TREE_CODE (const_part) == CONVERT_EXPR)
3446: const_part = TREE_OPERAND (const_part, 0);
3447: addr_part = TREE_OPERAND (exp, 1);
3448: while (TREE_CODE (addr_part) == NOP_EXPR
3449: || TREE_CODE (addr_part) == CONVERT_EXPR)
3450: addr_part = TREE_OPERAND (addr_part, 0);
3451: if (TREE_CODE (const_part) != INTEGER_CST)
3452: tmp = const_part, const_part = addr_part, addr_part = tmp;
3453: if (TREE_CODE (const_part) != INTEGER_CST
3454: || TREE_CODE (addr_part) != ADDR_EXPR)
3455: abort (); /* FIXME: we really haven't considered
3456: all the possible cases here. */
3457: }
3458: else if (TREE_CODE (exp) == ADDR_EXPR)
3459: {
3460: const_part = integer_zero_node;
3461: addr_part = exp;
3462: }
3463: else
3464: abort (); /* FIXME: ditto previous. */
3465:
3466: if (addr_part == 0)
3467: {
3468: if (size == 1)
3469: {
3470: char c = TREE_INT_CST_LOW (const_part);
3471: bc_emit (&c, 1);
3472: size -= 1;
3473: }
3474: else if (size == 2)
3475: {
3476: short s = TREE_INT_CST_LOW (const_part);
3477: bc_emit ((char *) &s, 2);
3478: size -= 2;
3479: }
3480: else if (size == 4)
3481: {
3482: int i = TREE_INT_CST_LOW (const_part);
3483: bc_emit ((char *) &i, 4);
3484: size -= 4;
3485: }
3486: else if (size == 8)
3487: {
3488: #if WORDS_BIG_ENDIAN
3489: int i = TREE_INT_CST_HIGH (const_part);
3490: bc_emit ((char *) &i, 4);
3491: i = TREE_INT_CST_LOW (const_part);
3492: bc_emit ((char *) &i, 4);
3493: #else
3494: int i = TREE_INT_CST_LOW (const_part);
3495: bc_emit ((char *) &i, 4);
3496: i = TREE_INT_CST_HIGH (const_part);
3497: bc_emit ((char *) &i, 4);
3498: #endif
3499: size -= 8;
3500: }
3501: }
3502: else
3503: if (size == 4
3504: && TREE_CODE (TREE_OPERAND (addr_part, 0)) == VAR_DECL)
3505: bc_emit_labelref (DECL_ASSEMBLER_NAME (TREE_OPERAND (addr_part, 0)),
3506: TREE_INT_CST_LOW (const_part));
3507: else
3508: abort (); /* FIXME: there may be more cases. */
3509: }
3510:
3511: /* Subroutine of output_constant, used for CONSTRUCTORs
3512: (aggregate constants).
3513: Generate at least SIZE bytes, padding if necessary. */
3514:
3515: void
3516: output_constructor (exp, size)
3517: tree exp;
3518: int size;
3519: {
3520: register tree link, field = 0;
3521: HOST_WIDE_INT min_index = 0;
3522: /* Number of bytes output or skipped so far.
3523: In other words, current position within the constructor. */
3524: int total_bytes = 0;
3525: /* Non-zero means BYTE contains part of a byte, to be output. */
3526: int byte_buffer_in_use = 0;
3527: register int byte;
3528:
3529: if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
3530: abort ();
3531:
3532: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
3533: field = TYPE_FIELDS (TREE_TYPE (exp));
3534:
3535: if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
3536: && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
3537: min_index
3538: = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
3539:
3540: /* As LINK goes through the elements of the constant,
3541: FIELD goes through the structure fields, if the constant is a structure.
3542: if the constant is a union, then we override this,
3543: by getting the field from the TREE_LIST element.
3544: But the constant could also be an array. Then FIELD is zero. */
3545: for (link = CONSTRUCTOR_ELTS (exp);
3546: link;
3547: link = TREE_CHAIN (link),
3548: field = field ? TREE_CHAIN (field) : 0)
3549: {
3550: tree val = TREE_VALUE (link);
3551: tree index = 0;
3552:
3553: /* the element in a union constructor specifies the proper field. */
3554:
3555: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
3556: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
3557: {
3558: /* if available, use the type given by link */
3559: if (TREE_PURPOSE (link) != 0)
3560: field = TREE_PURPOSE (link);
3561: }
3562:
3563: if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
3564: index = TREE_PURPOSE (link);
3565:
3566: /* Eliminate the marker that makes a cast not be an lvalue. */
3567: if (val != 0)
3568: STRIP_NOPS (val);
3569:
3570: if (field == 0 || !DECL_BIT_FIELD (field))
3571: {
3572: /* An element that is not a bit-field. */
3573:
3574: register int fieldsize;
3575: /* Since this structure is static,
3576: we know the positions are constant. */
3577: int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
3578: / BITS_PER_UNIT)
3579: : 0);
3580: if (index != 0)
3581: bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
3582: / BITS_PER_UNIT
3583: * (TREE_INT_CST_LOW (index) - min_index));
3584:
3585: /* Output any buffered-up bit-fields preceding this element. */
3586: if (byte_buffer_in_use)
3587: {
3588: ASM_OUTPUT_BYTE (asm_out_file, byte);
3589: total_bytes++;
3590: byte_buffer_in_use = 0;
3591: }
3592:
3593: /* Advance to offset of this element.
3594: Note no alignment needed in an array, since that is guaranteed
3595: if each element has the proper size. */
3596: if ((field != 0 || index != 0) && bitpos != total_bytes)
3597: {
3598: if (!output_bytecode)
3599: assemble_zeros (bitpos - total_bytes);
3600: else
3601: bc_emit_const_skip (bitpos - total_bytes);
3602: total_bytes = bitpos;
3603: }
3604:
3605: /* Determine size this element should occupy. */
3606: if (field)
3607: {
3608: if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
3609: abort ();
3610: if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
3611: {
3612: /* This avoids overflow trouble. */
3613: tree size_tree = size_binop (CEIL_DIV_EXPR,
3614: DECL_SIZE (field),
3615: size_int (BITS_PER_UNIT));
3616: fieldsize = TREE_INT_CST_LOW (size_tree);
3617: }
3618: else
3619: {
3620: fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
3621: fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
3622: }
3623: }
3624: else
3625: fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
3626:
3627: /* Output the element's initial value. */
3628: if (val == 0)
3629: assemble_zeros (fieldsize);
3630: else
3631: output_constant (val, fieldsize);
3632:
3633: /* Count its size. */
3634: total_bytes += fieldsize;
3635: }
3636: else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
3637: error ("invalid initial value for member `%s'",
3638: IDENTIFIER_POINTER (DECL_NAME (field)));
3639: else
3640: {
3641: /* Element that is a bit-field. */
3642:
3643: int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
3644: int end_offset
3645: = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
3646:
3647: if (val == 0)
3648: val = integer_zero_node;
3649:
3650: /* If this field does not start in this (or, next) byte,
3651: skip some bytes. */
3652: if (next_offset / BITS_PER_UNIT != total_bytes)
3653: {
3654: /* Output remnant of any bit field in previous bytes. */
3655: if (byte_buffer_in_use)
3656: {
3657: ASM_OUTPUT_BYTE (asm_out_file, byte);
3658: total_bytes++;
3659: byte_buffer_in_use = 0;
3660: }
3661:
3662: /* If still not at proper byte, advance to there. */
3663: if (next_offset / BITS_PER_UNIT != total_bytes)
3664: {
3665: assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
3666: total_bytes = next_offset / BITS_PER_UNIT;
3667: }
3668: }
3669:
3670: if (! byte_buffer_in_use)
3671: byte = 0;
3672:
3673: /* We must split the element into pieces that fall within
3674: separate bytes, and combine each byte with previous or
3675: following bit-fields. */
3676:
3677: /* next_offset is the offset n fbits from the beginning of
3678: the structure to the next bit of this element to be processed.
3679: end_offset is the offset of the first bit past the end of
3680: this element. */
3681: while (next_offset < end_offset)
3682: {
3683: int this_time;
3684: int shift, value;
3685: int next_byte = next_offset / BITS_PER_UNIT;
3686: int next_bit = next_offset % BITS_PER_UNIT;
3687:
3688: /* Advance from byte to byte
3689: within this element when necessary. */
3690: while (next_byte != total_bytes)
3691: {
3692: ASM_OUTPUT_BYTE (asm_out_file, byte);
3693: total_bytes++;
3694: byte = 0;
3695: }
3696:
3697: /* Number of bits we can process at once
3698: (all part of the same byte). */
3699: this_time = MIN (end_offset - next_offset,
3700: BITS_PER_UNIT - next_bit);
3701: #if BYTES_BIG_ENDIAN
3702: /* On big-endian machine, take the most significant bits
3703: first (of the bits that are significant)
3704: and put them into bytes from the most significant end. */
3705: shift = end_offset - next_offset - this_time;
3706: /* Don't try to take a bunch of bits that cross
3707: the word boundary in the INTEGER_CST. */
3708: if (shift < HOST_BITS_PER_WIDE_INT
3709: && shift + this_time > HOST_BITS_PER_WIDE_INT)
3710: {
3711: this_time -= (HOST_BITS_PER_WIDE_INT - shift);
3712: shift = HOST_BITS_PER_WIDE_INT;
3713: }
3714:
3715: /* Now get the bits from the appropriate constant word. */
3716: if (shift < HOST_BITS_PER_WIDE_INT)
3717: {
3718: value = TREE_INT_CST_LOW (val);
3719: }
3720: else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
3721: {
3722: value = TREE_INT_CST_HIGH (val);
3723: shift -= HOST_BITS_PER_WIDE_INT;
3724: }
3725: else
3726: abort ();
3727: byte |= (((value >> shift)
3728: & (((HOST_WIDE_INT) 1 << this_time) - 1))
3729: << (BITS_PER_UNIT - this_time - next_bit));
3730: #else
3731: /* On little-endian machines,
3732: take first the least significant bits of the value
3733: and pack them starting at the least significant
3734: bits of the bytes. */
3735: shift = (next_offset
3736: - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
3737: /* Don't try to take a bunch of bits that cross
3738: the word boundary in the INTEGER_CST. */
3739: if (shift < HOST_BITS_PER_WIDE_INT
3740: && shift + this_time > HOST_BITS_PER_WIDE_INT)
3741: {
3742: this_time -= (HOST_BITS_PER_WIDE_INT - shift);
3743: shift = HOST_BITS_PER_WIDE_INT;
3744: }
3745:
3746: /* Now get the bits from the appropriate constant word. */
3747: if (shift < HOST_BITS_PER_INT)
3748: value = TREE_INT_CST_LOW (val);
3749: else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
3750: {
3751: value = TREE_INT_CST_HIGH (val);
3752: shift -= HOST_BITS_PER_WIDE_INT;
3753: }
3754: else
3755: abort ();
3756: byte |= ((value >> shift)
3757: & (((HOST_WIDE_INT) 1 << this_time) - 1)) << next_bit;
3758: #endif
3759: next_offset += this_time;
3760: byte_buffer_in_use = 1;
3761: }
3762: }
3763: }
3764: if (byte_buffer_in_use)
3765: {
3766: ASM_OUTPUT_BYTE (asm_out_file, byte);
3767: total_bytes++;
3768: }
3769: if (total_bytes < size)
3770: assemble_zeros (size - total_bytes);
3771: }
3772:
3773:
3774: #ifdef HANDLE_SYSV_PRAGMA
3775:
3776: /* Support #pragma weak by default if WEAK_ASM_OP is defined. */
3777: #if defined (HANDLE_PRAGMA_WEAK) || (defined (WEAK_ASM_OP) && defined (SET_ASM_OP))
3778:
3779: /* See c-pragma.c for an identical definition. */
3780: enum pragma_state
3781: {
3782: ps_start,
3783: ps_done,
3784: ps_bad,
3785: ps_weak,
3786: ps_name,
3787: ps_equals,
3788: ps_value,
3789: ps_pack,
3790: ps_left,
3791: ps_align,
3792: ps_right
3793: };
3794:
3795: /* Output asm to handle ``#pragma weak'' */
3796: void
3797: handle_pragma_weak (what, asm_out_file, name, value)
3798: enum pragma_state what;
3799: FILE *asm_out_file;
3800: char *name, *value;
3801: {
3802: if (what == ps_name || what == ps_value)
3803: {
3804: fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
3805:
3806: if (output_bytecode)
3807: BC_OUTPUT_LABELREF (asm_out_file, name);
3808: else
3809: ASM_OUTPUT_LABELREF (asm_out_file, name);
3810:
3811: fputc ('\n', asm_out_file);
3812: if (what == ps_value)
3813: {
3814: fprintf (asm_out_file, "\t%s\t", SET_ASM_OP);
3815: if (output_bytecode)
3816: BC_OUTPUT_LABELREF (asm_out_file, name);
3817: else
3818: ASM_OUTPUT_LABELREF (asm_out_file, name);
3819:
3820: fputc (',', asm_out_file);
3821: if (output_bytecode)
3822: BC_OUTPUT_LABELREF (asm_out_file, value);
3823: else
3824: ASM_OUTPUT_LABELREF (asm_out_file, value);
3825:
3826: fputc ('\n', asm_out_file);
3827: }
3828: }
3829: else if (! (what == ps_done || what == ps_start))
3830: warning ("malformed `#pragma weak'");
3831: }
3832:
3833: #endif /* HANDLE_PRAGMA_WEAK or (WEAK_ASM_OP and SET_ASM_OP) */
3834:
3835: #endif /* HANDLE_SYSV_PRAGMA */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.