![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to varasm.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* Output variables, constants and external declarations, for GNU compiler. ! 2: Copyright (C) 1987, 1988 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* This file handles generation of all the assembler code ! 23: *except* the instructions of a function. ! 24: This includes declarations of variables and their initial values. ! 25: ! 26: We also output the assembler code for constants stored in memory ! 27: and are responsible for combining constants with the same value. */ ! 28: ! 29: #include <stdio.h> ! 30: /* #include <stab.h> */ ! 31: #include "config.h" ! 32: #include "rtl.h" ! 33: #include "tree.h" ! 34: #include "flags.h" ! 35: #include "expr.h" ! 36: ! 37: #include "obstack.h" ! 38: ! 39: #define MIN(a, b) ((a) < (b) ? (a) : (b)) ! 40: ! 41: /* File in which assembler code is being written. */ ! 42: ! 43: extern FILE *asm_out_file; ! 44: ! 45: extern struct obstack *current_obstack; ! 46: extern struct obstack *saveable_obstack; ! 47: extern struct obstack permanent_obstack; ! 48: #define obstack_chunk_alloc xmalloc ! 49: extern int xmalloc (); ! 50: ! 51: /* Number for making the label on the next ! 52: constant that is stored in memory. */ ! 53: ! 54: int const_labelno; ! 55: ! 56: /* Number for making the label on the next ! 57: static variable internal to a function. */ ! 58: ! 59: int var_labelno; ! 60: ! 61: extern FILE *asm_out_file; ! 62: ! 63: static char *compare_constant_1 (); ! 64: static void record_constant_1 (); ! 65: void assemble_name (); ! 66: void output_addressed_constants (); ! 67: void output_constant (); ! 68: void output_constructor (); ! 69: ! 70: /* Output a string of literal assembler code ! 71: for an `asm' keyword used between functions. */ ! 72: ! 73: void ! 74: assemble_asm (string) ! 75: tree string; ! 76: { ! 77: app_enable (); ! 78: ! 79: fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string)); ! 80: } ! 81: ! 82: /* Output assembler code associated with defining the name of a function ! 83: as described by DECL. */ ! 84: ! 85: void ! 86: assemble_function (decl) ! 87: tree decl; ! 88: { ! 89: rtx x, n; ! 90: char *fnname; ! 91: ! 92: /* Get the function's name, as described by its RTL. ! 93: This may be different from the DECL_NAME name used in the source file. */ ! 94: ! 95: x = DECL_RTL (decl); ! 96: if (GET_CODE (x) != MEM) ! 97: abort (); ! 98: n = XEXP (x, 0); ! 99: if (GET_CODE (n) != SYMBOL_REF) ! 100: abort (); ! 101: fnname = XSTR (n, 0); ! 102: ! 103: /* The following code does not need preprocessing in the assembler. */ ! 104: ! 105: app_disable (); ! 106: ! 107: /* Tell assembler to switch to text segment. */ ! 108: ! 109: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP); ! 110: ! 111: /* Tell assembler to move to target machine's alignment for functions. */ ! 112: ! 113: ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT)); ! 114: ! 115: /* Make function name accessible from other files, if appropriate. */ ! 116: ! 117: if (TREE_PUBLIC (decl)) ! 118: ASM_GLOBALIZE_LABEL (asm_out_file, fnname); ! 119: ! 120: /* Do any machine/system dependent processing of the function name */ ! 121: #ifdef ASM_DECLARE_FUNCTION_NAME ! 122: ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname); ! 123: #else ! 124: /* Standard thing is just output label for the function. */ ! 125: ASM_OUTPUT_LABEL (asm_out_file, fnname); ! 126: #endif /* ASM_DECLARE_FUNCTION_NAME */ ! 127: } ! 128: ! 129: /* Assemble " .int 0\n" or whatever this assembler wants. */ ! 130: ! 131: void ! 132: assemble_integer_zero () ! 133: { ! 134: ASM_OUTPUT_INT (asm_out_file, const0_rtx); ! 135: } ! 136: ! 137: /* Create the rtx to represent a function in calls to it. ! 138: DECL is a FUNCTION_DECL node which describes which function. ! 139: The rtl is stored in DECL. */ ! 140: ! 141: void ! 142: make_function_rtl (decl) ! 143: tree decl; ! 144: { ! 145: if (DECL_RTL (decl) == 0) ! 146: DECL_RTL (decl) ! 147: = gen_rtx (MEM, DECL_MODE (decl), ! 148: gen_rtx (SYMBOL_REF, Pmode, ! 149: IDENTIFIER_POINTER (DECL_NAME (decl)))); ! 150: } ! 151: ! 152: /* Assemble everything that is needed for a variable or function declaration. ! 153: Not used for automatic variables, and not used for function definitions. ! 154: Should not be called for variables of incomplete structure type. ! 155: ! 156: ASMSPEC is the user's specification of assembler symbol name to use. ! 157: TOP_LEVEL is nonzero if this variable has file scope. ! 158: WRITE_SYMBOLS is 2 if writing dbx symbol output. ! 159: The dbx data for a file-scope variable is written here. ! 160: AT_END is nonzero if this is the special handling, at end of compilation, ! 161: to define things that have had only tentative definitions. */ ! 162: ! 163: void ! 164: assemble_variable (decl, asmspec, top_level, write_symbols, at_end) ! 165: tree decl; ! 166: tree asmspec; ! 167: int top_level; ! 168: int write_symbols; ! 169: int at_end; ! 170: { ! 171: register char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); ! 172: register int i; ! 173: ! 174: if (asmspec != 0) ! 175: { ! 176: if (TREE_CODE (asmspec) != STRING_CST) ! 177: abort (); ! 178: name = (char *) oballoc (strlen (TREE_STRING_POINTER (asmspec)) + 2); ! 179: name[0] = '*'; ! 180: strcpy (&name[1], TREE_STRING_POINTER (asmspec)); ! 181: } ! 182: ! 183: /* For a duplicate declaration, we can be called twice on the ! 184: same DECL node. Don't alter the RTL already made ! 185: unless the old mode is wrong (which can happen when ! 186: the previous rtl was made when the type was incomplete). */ ! 187: if (DECL_RTL (decl) == 0 ! 188: || GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl)) ! 189: { ! 190: if (DECL_RTL (decl) && asmspec == 0) ! 191: name = XSTR (XEXP (DECL_RTL (decl), 0), 0); ! 192: ! 193: /* Can't use just the variable's own name for a variable ! 194: whose scope is less than the whole file. ! 195: Concatenate a distinguishing number. */ ! 196: else if (!top_level && !TREE_EXTERNAL (decl) && asmspec == 0) ! 197: { ! 198: char *label; ! 199: ! 200: ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno); ! 201: name = obstack_copy0 (current_obstack, label, strlen (label)); ! 202: var_labelno++; ! 203: } ! 204: ! 205: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), ! 206: gen_rtx (SYMBOL_REF, Pmode, name)); ! 207: if (TREE_VOLATILE (decl)) ! 208: DECL_RTL (decl)->volatil = 1; ! 209: if (TREE_READONLY (decl)) ! 210: DECL_RTL (decl)->unchanging = 1; ! 211: DECL_RTL (decl)->in_struct ! 212: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE ! 213: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE ! 214: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE); ! 215: } ! 216: ! 217: /* Output no assembler code for a function declaration. ! 218: Only definitions of functions output anything. */ ! 219: ! 220: if (TREE_CODE (decl) == FUNCTION_DECL) ! 221: return; ! 222: ! 223: /* Normally no need to say anything for external references, ! 224: since assembler considers all undefined symbols external. */ ! 225: ! 226: if (TREE_EXTERNAL (decl)) ! 227: { ! 228: #ifdef ASM_OUTPUT_EXTERNAL ! 229: /* Some systems do require some output. */ ! 230: ASM_OUTPUT_EXTERNAL (asm_out_file, decl, name); ! 231: #endif ! 232: return; ! 233: } ! 234: /* Don't output anything when a tentative file-scope definition is seen. ! 235: But at end of compilation, do output code for them. */ ! 236: if (! at_end && top_level ! 237: && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)) ! 238: return; ! 239: ! 240: /* If type was incomplete when the variable was declared, ! 241: see if it is complete now. */ ! 242: ! 243: if (DECL_SIZE (decl) == 0) ! 244: layout_decl (decl); ! 245: ! 246: /* Still incomplete => don't allocate it; treat the tentative defn ! 247: (which is what it must have been) as an `extern' reference. */ ! 248: ! 249: if (DECL_SIZE (decl) == 0) ! 250: { ! 251: error_with_file_and_line (DECL_SOURCE_FILE (decl), ! 252: DECL_SOURCE_LINE (decl), ! 253: "storage size of static var `%s' isn't known", ! 254: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 255: return; ! 256: } ! 257: ! 258: /* The first declaration of a variable that comes through this function ! 259: decides whether it is global (in C, has external linkage) ! 260: or local (in C, has internal linkage). So do nothing more ! 261: if this function has already run. */ ! 262: ! 263: if (TREE_ASM_WRITTEN (decl)) ! 264: return; ! 265: ! 266: TREE_ASM_WRITTEN (decl) = 1; ! 267: ! 268: if (write_symbols == 2) ! 269: dbxout_symbol (decl, 0); ! 270: else if (write_symbols != 0) ! 271: /* Make sure the file is known to GDB even if it has no functions. */ ! 272: set_current_gdbfile (DECL_SOURCE_FILE (decl)); ! 273: ! 274: /* If storage size is erroneously variable, just continue. ! 275: Error message was already made. */ ! 276: ! 277: if (! TREE_LITERAL (DECL_SIZE (decl))) ! 278: return; ! 279: ! 280: app_disable (); ! 281: ! 282: /* Handle uninitialized definitions. */ ! 283: ! 284: if (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node) ! 285: { ! 286: int size = (TREE_INT_CST_LOW (DECL_SIZE (decl)) ! 287: * DECL_SIZE_UNIT (decl) ! 288: / BITS_PER_UNIT); ! 289: /* Round size up to multiple of BIGGEST_ALIGNMENT bits ! 290: so that each uninitialized object starts on such a boundary. */ ! 291: size = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1) ! 292: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) ! 293: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); ! 294: if (TREE_PUBLIC (decl)) ! 295: ASM_OUTPUT_COMMON (asm_out_file, name, size); ! 296: else ! 297: ASM_OUTPUT_LOCAL (asm_out_file, name, size); ! 298: return; ! 299: } ! 300: ! 301: /* Handle initialized definitions. */ ! 302: ! 303: if (TREE_PUBLIC (decl)) ! 304: ASM_GLOBALIZE_LABEL (asm_out_file, name); ! 305: ! 306: output_addressed_constants (DECL_INITIAL (decl)); ! 307: ! 308: if (TREE_READONLY (decl) && ! TREE_VOLATILE (decl)) ! 309: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP); ! 310: else ! 311: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP); ! 312: ! 313: for (i = 0; DECL_ALIGN (decl) >= BITS_PER_UNIT << (i + 1); i++); ! 314: ! 315: ASM_OUTPUT_ALIGN (asm_out_file, i); ! 316: ! 317: ASM_OUTPUT_LABEL (asm_out_file, name); ! 318: output_constant (DECL_INITIAL (decl), int_size_in_bytes (TREE_TYPE (decl))); ! 319: } ! 320: ! 321: /* Output to FILE a reference to the assembler name of a C-level name NAME. ! 322: If NAME starts with a *, the rest of NAME is output verbatim. ! 323: Otherwise NAME is transformed in an implementation-defined way ! 324: (usually by the addition of an underscore). ! 325: Many macros in the tm file are defined to call this function. */ ! 326: ! 327: void ! 328: assemble_name (file, name) ! 329: FILE *file; ! 330: char *name; ! 331: { ! 332: if (name[0] == '*') ! 333: fputs (&name[1], file); ! 334: else ! 335: ASM_OUTPUT_LABELREF (file, name); ! 336: } ! 337: ! 338: /* Here we combine duplicate floating constants to make ! 339: CONST_DOUBLE rtx's, and force those out to memory when necessary. */ ! 340: ! 341: /* Chain of all CONST_DOUBLE rtx's constructed for the current function. ! 342: They are chained through the third operand slot. */ ! 343: ! 344: extern rtx real_constant_chain; ! 345: ! 346: /* Return a CONST_DOUBLE for a specified `double' value ! 347: and machine mode. */ ! 348: ! 349: rtx ! 350: immed_real_const_1 (d, mode) ! 351: double d; ! 352: enum machine_mode mode; ! 353: ! 354: { ! 355: register rtx r; ! 356: union {double d; int i[2];} u; ! 357: register int i0, i1; ! 358: ! 359: /* Get the desired `double' value as two ints ! 360: since that is how they are stored in a CONST_DOUBLE. */ ! 361: ! 362: u.d = d; ! 363: i0 = u.i[0]; ! 364: i1 = u.i[1]; ! 365: ! 366: /* Search the chain for an existing CONST_DOUBLE with the right value. ! 367: If one is found, return it. */ ! 368: ! 369: for (r = real_constant_chain; r; r = XEXP (r, 3)) ! 370: if (XINT (r, 0) == i0 && XINT (r, 1) == i1 ! 371: && GET_MODE (r) == mode) ! 372: return r; ! 373: ! 374: /* No; make a new one and add it to the chain. */ ! 375: ! 376: r = gen_rtx (CONST_DOUBLE, mode, i0, i1, 0); ! 377: XEXP (r, 3) = real_constant_chain; ! 378: real_constant_chain = r; ! 379: ! 380: /* Store const0_rtx in slot 2 just so most things won't barf. ! 381: Actual use of slot 2 is only through force_const_double_mem. */ ! 382: ! 383: XEXP (r, 2) = const0_rtx; ! 384: ! 385: return r; ! 386: } ! 387: ! 388: /* Return a CONST_DOUBLE rtx for a value specified by EXP, ! 389: which must be a REAL_CST tree node. Make only one CONST_DOUBLE ! 390: for each distinct value. */ ! 391: ! 392: rtx ! 393: immed_real_const (exp) ! 394: tree exp; ! 395: { ! 396: register rtx r; ! 397: r = immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp))); ! 398: ! 399: /* Associate exp and with this rtl value. */ ! 400: TREE_CST_RTL (exp) = r; ! 401: ! 402: return r; ! 403: } ! 404: ! 405: /* Given a CONST_DOUBLE, cause a constant in memory to be created ! 406: (unless we already have one for the same value) ! 407: and return a MEM rtx to refer to it. */ ! 408: ! 409: rtx ! 410: force_const_double_mem (r) ! 411: rtx r; ! 412: { ! 413: if (XEXP (r, 2) == const0_rtx) ! 414: { ! 415: XEXP (r, 2) = force_const_mem (GET_MODE (r), r); ! 416: } ! 417: /* XEXP (r, 2) is now a MEM with a constant address. ! 418: If that is legitimate, return it. ! 419: Othewise it will need reloading, so return a copy of it. */ ! 420: if (memory_address_p (GET_MODE (r), XEXP (XEXP (r, 2), 0))) ! 421: return XEXP (r, 2); ! 422: return gen_rtx (MEM, GET_MODE (r), XEXP (XEXP (r, 2), 0)); ! 423: } ! 424: ! 425: /* At the start of a function, forget the memory-constants ! 426: previously made for CONST_DOUBLEs. */ ! 427: ! 428: static void ! 429: clear_const_double_mem () ! 430: { ! 431: register rtx r; ! 432: ! 433: for (r = real_constant_chain; r; r = XEXP (r, 3)) ! 434: XEXP (r, 2) = 0; ! 435: } ! 436: ! 437: /* Given an expression EXP with a constant value, ! 438: reduce it to the sum of an assembler symbol and an integer. ! 439: Store them both in the structure *VALUE. ! 440: Abort if EXP does not reduce. */ ! 441: ! 442: struct addr_const ! 443: { ! 444: rtx base; ! 445: int offset; ! 446: }; ! 447: ! 448: static void ! 449: decode_addr_const (exp, value) ! 450: tree exp; ! 451: struct addr_const *value; ! 452: { ! 453: register tree target = TREE_OPERAND (exp, 0); ! 454: register int offset = 0; ! 455: register rtx x; ! 456: ! 457: while (1) ! 458: { ! 459: if (TREE_CODE (target) == COMPONENT_REF) ! 460: { ! 461: offset += DECL_OFFSET (TREE_OPERAND (target, 1)) / BITS_PER_UNIT; ! 462: target = TREE_OPERAND (target, 0); ! 463: } ! 464: else if (TREE_CODE (target) == ARRAY_REF) ! 465: { ! 466: if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST ! 467: || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST) ! 468: abort (); ! 469: offset += ((TYPE_SIZE_UNIT (TREE_TYPE (target)) ! 470: * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target))) ! 471: * TREE_INT_CST_LOW (TREE_OPERAND (target, 1))) ! 472: / BITS_PER_UNIT); ! 473: target = TREE_OPERAND (target, 0); ! 474: } ! 475: else break; ! 476: } ! 477: ! 478: if (TREE_CODE (target) == VAR_DECL ! 479: || TREE_CODE (target) == FUNCTION_DECL) ! 480: x = DECL_RTL (target); ! 481: else if (TREE_LITERAL (target)) ! 482: x = TREE_CST_RTL (target); ! 483: else ! 484: abort (); ! 485: ! 486: if (GET_CODE (x) != MEM) ! 487: abort (); ! 488: x = XEXP (x, 0); ! 489: ! 490: value->base = x; ! 491: value->offset = offset; ! 492: } ! 493: ! 494: /* Uniquize all constants that appear in memory. ! 495: Each constant in memory thus far output is recorded ! 496: in `const_hash_table' with a `struct constant_descriptor' ! 497: that contains a polish representation of the value of ! 498: the constant. ! 499: ! 500: We cannot store the trees in the hash table ! 501: because the trees may be temporary. */ ! 502: ! 503: struct constant_descriptor ! 504: { ! 505: struct constant_descriptor *next; ! 506: char *label; ! 507: char contents[1]; ! 508: }; ! 509: ! 510: #define HASHBITS 30 ! 511: #define MAX_HASH_TABLE 1007 ! 512: static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE]; ! 513: ! 514: /* Compute a hash code for a constant expression. */ ! 515: ! 516: int ! 517: const_hash (exp) ! 518: tree exp; ! 519: { ! 520: register char *p; ! 521: register int len, hi, i; ! 522: register enum tree_code code = TREE_CODE (exp); ! 523: ! 524: if (code == INTEGER_CST) ! 525: { ! 526: p = (char *) &TREE_INT_CST_LOW (exp); ! 527: len = 2 * sizeof TREE_INT_CST_LOW (exp); ! 528: } ! 529: else if (code == REAL_CST) ! 530: { ! 531: p = (char *) &TREE_REAL_CST (exp); ! 532: len = sizeof TREE_REAL_CST (exp); ! 533: } ! 534: else if (code == STRING_CST) ! 535: p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp); ! 536: else if (code == COMPLEX_CST) ! 537: return const_hash (TREE_REALPART (exp)) * 5 ! 538: + const_hash (TREE_IMAGPART (exp)); ! 539: else if (code == CONSTRUCTOR) ! 540: { ! 541: register tree link; ! 542: hi = 5; ! 543: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link)) ! 544: hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE; ! 545: return hi; ! 546: } ! 547: else if (code == ADDR_EXPR) ! 548: { ! 549: struct addr_const value; ! 550: decode_addr_const (exp, &value); ! 551: p = (char *) &value; ! 552: len = sizeof value; ! 553: } ! 554: else if (code == PLUS_EXPR || code == MINUS_EXPR) ! 555: return const_hash (TREE_OPERAND (exp, 0)) * 9 ! 556: + const_hash (TREE_OPERAND (exp, 1)); ! 557: else if (code == NOP_EXPR || code == CONVERT_EXPR) ! 558: return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2; ! 559: ! 560: /* Compute hashing function */ ! 561: hi = len; ! 562: for (i = 0; i < len; i++) ! 563: hi = ((hi * 613) + (unsigned)(p[i])); ! 564: ! 565: hi &= (1 << HASHBITS) - 1; ! 566: hi %= MAX_HASH_TABLE; ! 567: return hi; ! 568: } ! 569: ! 570: /* Compare a constant expression EXP with a constant-descriptor DESC. ! 571: Return 1 if DESC describes a constant with the same value as EXP. */ ! 572: ! 573: static int ! 574: compare_constant (exp, desc) ! 575: tree exp; ! 576: struct constant_descriptor *desc; ! 577: { ! 578: return 0 != compare_constant_1 (exp, desc->contents); ! 579: } ! 580: ! 581: /* Compare constant expression EXP with a substring P of a constant descriptor. ! 582: If they match, return a pointer to the end of the substring matched. ! 583: If they do not match, return 0. ! 584: ! 585: Since descriptors are written in polish prefix notation, ! 586: this function can be used recursively to test one operand of EXP ! 587: against a subdescriptor, and if it succeeds it returns the ! 588: address of the subdescriptor for the next operand. */ ! 589: ! 590: static char * ! 591: compare_constant_1 (exp, p) ! 592: tree exp; ! 593: char *p; ! 594: { ! 595: register char *strp; ! 596: register int len; ! 597: register enum tree_code code = TREE_CODE (exp); ! 598: ! 599: if (code != (enum tree_code) *p++) ! 600: return 0; ! 601: ! 602: if (code == INTEGER_CST) ! 603: { ! 604: strp = (char *) &TREE_INT_CST_LOW (exp); ! 605: len = 2 * sizeof TREE_INT_CST_LOW (exp); ! 606: } ! 607: else if (code == REAL_CST) ! 608: { ! 609: /* Real constants are the same only if the same width of type. */ ! 610: if (*p++ != TYPE_PRECISION (TREE_TYPE (exp))) ! 611: return 0; ! 612: strp = (char *) &TREE_REAL_CST (exp); ! 613: len = sizeof TREE_REAL_CST (exp); ! 614: } ! 615: else if (code == STRING_CST) ! 616: { ! 617: if (flag_writable_strings) ! 618: return 0; ! 619: strp = TREE_STRING_POINTER (exp); ! 620: len = TREE_STRING_LENGTH (exp); ! 621: if (bcmp (&TREE_STRING_LENGTH (exp), p, ! 622: sizeof TREE_STRING_LENGTH (exp))) ! 623: return 0; ! 624: p += sizeof TREE_STRING_LENGTH (exp); ! 625: } ! 626: else if (code == COMPLEX_CST) ! 627: { ! 628: p = compare_constant_1 (TREE_REALPART (exp), p); ! 629: if (p == 0) return 0; ! 630: p = compare_constant_1 (TREE_IMAGPART (exp), p); ! 631: return p; ! 632: } ! 633: else if (code == CONSTRUCTOR) ! 634: { ! 635: register tree link; ! 636: int length = list_length (CONSTRUCTOR_ELTS (exp)); ! 637: if (bcmp (&length, p, sizeof length)) ! 638: return 0; ! 639: p += sizeof length; ! 640: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link)) ! 641: if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0) ! 642: return 0; ! 643: return p; ! 644: } ! 645: else if (code == ADDR_EXPR) ! 646: { ! 647: struct addr_const value; ! 648: decode_addr_const (exp, &value); ! 649: strp = (char *) &value; ! 650: len = sizeof value; ! 651: } ! 652: else if (code == PLUS_EXPR || code == MINUS_EXPR) ! 653: { ! 654: if (*p++ != (char) code) ! 655: return 0; ! 656: p = compare_constant_1 (TREE_OPERAND (exp, 0), p); ! 657: if (p == 0) return 0; ! 658: p = compare_constant_1 (TREE_OPERAND (exp, 1), p); ! 659: return p; ! 660: } ! 661: else if (code == NOP_EXPR || code == CONVERT_EXPR) ! 662: { ! 663: if (*p++ != (char) code) ! 664: return 0; ! 665: p = compare_constant_1 (TREE_OPERAND (exp, 0), p); ! 666: return p; ! 667: } ! 668: ! 669: /* Compare constant contents. */ ! 670: while (--len >= 0) ! 671: if (*p++ != *strp++) ! 672: return 0; ! 673: ! 674: return p; ! 675: } ! 676: ! 677: /* Construct a constant descriptor for the expression EXP. ! 678: It is up to the caller to enter the descriptor in the hash table. */ ! 679: ! 680: static struct constant_descriptor * ! 681: record_constant (exp) ! 682: tree exp; ! 683: { ! 684: struct constant_descriptor *ptr = 0; ! 685: int buf; ! 686: ! 687: obstack_grow (&permanent_obstack, &ptr, sizeof ptr); ! 688: obstack_grow (&permanent_obstack, &buf, sizeof buf); ! 689: record_constant_1 (exp); ! 690: return (struct constant_descriptor *) obstack_finish (&permanent_obstack); ! 691: } ! 692: ! 693: /* Add a description of constant expression EXP ! 694: to the object growing in `permanent_obstack'. ! 695: No need to return its address; the caller will get that ! 696: from the obstack when the object is complete. */ ! 697: ! 698: static void ! 699: record_constant_1 (exp) ! 700: tree exp; ! 701: { ! 702: register char *strp; ! 703: register int len; ! 704: register enum tree_code code = TREE_CODE (exp); ! 705: ! 706: obstack_1grow (&permanent_obstack, (unsigned char) code); ! 707: ! 708: if (code == INTEGER_CST) ! 709: { ! 710: strp = (char *) &TREE_INT_CST_LOW (exp); ! 711: len = 2 * sizeof TREE_INT_CST_LOW (exp); ! 712: } ! 713: else if (code == REAL_CST) ! 714: { ! 715: obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp))); ! 716: strp = (char *) &TREE_REAL_CST (exp); ! 717: len = sizeof TREE_REAL_CST (exp); ! 718: } ! 719: else if (code == STRING_CST) ! 720: { ! 721: if (flag_writable_strings) ! 722: return; ! 723: strp = TREE_STRING_POINTER (exp); ! 724: len = TREE_STRING_LENGTH (exp); ! 725: obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp), ! 726: sizeof TREE_STRING_LENGTH (exp)); ! 727: } ! 728: else if (code == COMPLEX_CST) ! 729: { ! 730: record_constant_1 (TREE_REALPART (exp)); ! 731: record_constant_1 (TREE_IMAGPART (exp)); ! 732: return; ! 733: } ! 734: else if (code == CONSTRUCTOR) ! 735: { ! 736: register tree link; ! 737: int length = list_length (CONSTRUCTOR_ELTS (exp)); ! 738: obstack_grow (&permanent_obstack, (char *) &length, sizeof length); ! 739: ! 740: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link)) ! 741: record_constant_1 (TREE_VALUE (link)); ! 742: return; ! 743: } ! 744: else if (code == ADDR_EXPR) ! 745: { ! 746: struct addr_const value; ! 747: decode_addr_const (exp, &value); ! 748: strp = (char *) &value; ! 749: len = sizeof value; ! 750: } ! 751: else if (code == PLUS_EXPR || code == MINUS_EXPR) ! 752: { ! 753: obstack_1grow (&permanent_obstack, (char) code); ! 754: record_constant_1 (TREE_OPERAND (exp, 0)); ! 755: record_constant_1 (TREE_OPERAND (exp, 1)); ! 756: return; ! 757: } ! 758: else if (code == NOP_EXPR || code == CONVERT_EXPR) ! 759: { ! 760: obstack_1grow (&permanent_obstack, (char) code); ! 761: record_constant_1 (TREE_OPERAND (exp, 0)); ! 762: return; ! 763: } ! 764: ! 765: /* Record constant contents. */ ! 766: obstack_grow (&permanent_obstack, strp, len); ! 767: } ! 768: ! 769: /* Return the constant-label-string for constant value EXP. ! 770: If no constant equal to EXP has yet been output, ! 771: define a new label and output assembler code for it. ! 772: The const_hash_table records which constants already have label strings. */ ! 773: ! 774: static char * ! 775: get_or_assign_label (exp) ! 776: tree exp; ! 777: { ! 778: register int hash, i; ! 779: register struct constant_descriptor *desc; ! 780: char label[10]; ! 781: ! 782: /* Make sure any other constants whose addresses appear in EXP ! 783: are assigned label numbers. */ ! 784: ! 785: output_addressed_constants (exp); ! 786: ! 787: /* Compute hash code of EXP. Search the descriptors for that hash code ! 788: to see if any of them describes EXP. If yes, the descriptor records ! 789: the label number already assigned. */ ! 790: ! 791: hash = const_hash (exp) % MAX_HASH_TABLE; ! 792: ! 793: for (desc = const_hash_table[hash]; desc; desc = desc->next) ! 794: if (compare_constant (exp, desc)) ! 795: return desc->label; ! 796: ! 797: /* No constant equal to EXP is known to have been output. ! 798: Make a constant descriptor to enter EXP in the hash table. ! 799: Assign the label number and record it in the descriptor for ! 800: future calls to this function to find. */ ! 801: ! 802: desc = record_constant (exp); ! 803: desc->next = const_hash_table[hash]; ! 804: const_hash_table[hash] = desc; ! 805: ! 806: /* Now output assembler code to define that label ! 807: and follow it with the data of EXP. */ ! 808: ! 809: /* First switch to text segment, except for writable strings. */ ! 810: if ((TREE_CODE (exp) == STRING_CST) && flag_writable_strings) ! 811: fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP); ! 812: else ! 813: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP); ! 814: ! 815: /* Align the location counter as required by EXP's data type. */ ! 816: for (i = 0; TYPE_ALIGN (TREE_TYPE (exp)) >= BITS_PER_UNIT << (i + 1); i++); ! 817: ASM_OUTPUT_ALIGN (asm_out_file, i); ! 818: ! 819: /* Output the label itself. */ ! 820: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno); ! 821: ! 822: /* Output the value of EXP. */ ! 823: output_constant (exp, ! 824: (TREE_CODE (exp) == STRING_CST ! 825: ? TREE_STRING_LENGTH (exp) ! 826: : int_size_in_bytes (TREE_TYPE (exp)))); ! 827: ! 828: /* Create a string containing the label name, in LABEL. */ ! 829: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno); ! 830: ! 831: ++const_labelno; ! 832: ! 833: desc->label ! 834: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label)); ! 835: ! 836: return desc->label; ! 837: } ! 838: ! 839: /* Return an rtx representing a reference to constant data in memory ! 840: for the constant expression EXP. ! 841: If assembler code for such a constant has already been output, ! 842: return an rtx to refer to it. ! 843: Otherwise, output such a constant in memory and generate ! 844: an rtx for it. The TREE_CST_RTL of EXP is set up to point to that rtx. */ ! 845: ! 846: rtx ! 847: output_constant_def (exp) ! 848: tree exp; ! 849: { ! 850: register rtx def; ! 851: char label[10]; ! 852: ! 853: if (TREE_CST_RTL (exp)) ! 854: return TREE_CST_RTL (exp); ! 855: ! 856: def = gen_rtx (SYMBOL_REF, Pmode, get_or_assign_label (exp)); ! 857: ! 858: TREE_CST_RTL (exp) ! 859: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def); ! 860: TREE_CST_RTL (exp)->unchanging = 1; ! 861: ! 862: return TREE_CST_RTL (exp); ! 863: } ! 864: ! 865: /* Similar hash facility for making memory-constants ! 866: from constant rtl-expressions. It is used on RISC machines ! 867: where immediate integer arguments and constant addresses are restricted ! 868: so that such constants must be stored in memory. ! 869: ! 870: This pool of constants is reinitialized for each function ! 871: so each function gets its own constants-pool that comes right before it. */ ! 872: ! 873: #define MAX_RTX_HASH_TABLE 61 ! 874: static struct constant_descriptor *const_rtx_hash_table[MAX_RTX_HASH_TABLE]; ! 875: ! 876: void ! 877: init_const_rtx_hash_table () ! 878: { ! 879: bzero (const_rtx_hash_table, sizeof const_rtx_hash_table); ! 880: clear_const_double_mem (); ! 881: } ! 882: ! 883: struct rtx_const ! 884: { ! 885: enum kind { RTX_DOUBLE, RTX_INT } kind : 16; ! 886: enum machine_mode mode : 16; ! 887: union { ! 888: int d[2]; ! 889: struct addr_const addr; ! 890: } un; ! 891: }; ! 892: ! 893: /* Express an rtx for a constant integer (perhaps symbolic) ! 894: as the sum of a symbol or label plus an explicit integer. ! 895: They are stored into VALUE. */ ! 896: ! 897: static void ! 898: decode_rtx_const (x, value) ! 899: rtx x; ! 900: struct rtx_const *value; ! 901: { ! 902: value->kind = RTX_INT; /* Most usual kind. */ ! 903: value->mode = GET_MODE (x); ! 904: value->un.addr.base = 0; ! 905: value->un.addr.offset = 0; ! 906: ! 907: switch (GET_CODE (x)) ! 908: { ! 909: case CONST_DOUBLE: ! 910: value->kind = RTX_DOUBLE; ! 911: value->mode = GET_MODE (x); ! 912: value->un.d[0] = XINT (x, 0); ! 913: value->un.d[1] = XINT (x, 1); ! 914: break; ! 915: ! 916: case CONST_INT: ! 917: value->un.addr.offset = INTVAL (x); ! 918: break; ! 919: ! 920: case SYMBOL_REF: ! 921: /* Use the string's address, not the SYMBOL_REF's address, ! 922: for the sake of addresses of library routines. */ ! 923: value->un.addr.base = XEXP (x, 0); ! 924: break; ! 925: ! 926: case LABEL_REF: ! 927: /* Return the CODE_LABEL, not the LABEL_REF. */ ! 928: value->un.addr.base = XEXP (x, 0); ! 929: break; ! 930: ! 931: case CONST: ! 932: x = XEXP (x, 0); ! 933: if (GET_CODE (x) == PLUS) ! 934: { ! 935: value->un.addr.base = XEXP (x, 0); ! 936: if (GET_CODE (XEXP (x, 1)) != CONST_INT) ! 937: abort (); ! 938: value->un.addr.offset = INTVAL (XEXP (x, 1)); ! 939: } ! 940: else if (GET_CODE (x) == MINUS) ! 941: { ! 942: value->un.addr.base = XEXP (x, 0); ! 943: if (GET_CODE (XEXP (x, 1)) != CONST_INT) ! 944: abort (); ! 945: value->un.addr.offset = - INTVAL (XEXP (x, 1)); ! 946: } ! 947: else ! 948: abort (); ! 949: break; ! 950: ! 951: default: ! 952: abort (); ! 953: } ! 954: } ! 955: ! 956: /* Compute a hash code for a constant RTL expression. */ ! 957: ! 958: int ! 959: const_hash_rtx (x) ! 960: rtx x; ! 961: { ! 962: register int hi, i, len; ! 963: register char *p; ! 964: ! 965: struct rtx_const value; ! 966: decode_rtx_const (x, &value); ! 967: ! 968: /* Compute hashing function */ ! 969: hi = 0; ! 970: for (i = 0; i < sizeof value / sizeof (int); i++) ! 971: hi += ((int *) &value)[i]; ! 972: ! 973: hi &= (1 << HASHBITS) - 1; ! 974: hi %= MAX_RTX_HASH_TABLE; ! 975: return hi; ! 976: } ! 977: ! 978: /* Compare a constant rtl object X with a constant-descriptor DESC. ! 979: Return 1 if DESC describes a constant with the same value as X. */ ! 980: ! 981: static int ! 982: compare_constant_rtx (x, desc) ! 983: rtx x; ! 984: struct constant_descriptor *desc; ! 985: { ! 986: register int *p = (int *) desc->contents; ! 987: register int *strp; ! 988: register int len; ! 989: struct rtx_const value; ! 990: ! 991: decode_rtx_const (x, &value); ! 992: strp = (int *) &value; ! 993: len = sizeof value / sizeof (int); ! 994: ! 995: /* Compare constant contents. */ ! 996: while (--len >= 0) ! 997: if (*p++ != *strp++) ! 998: return 0; ! 999: ! 1000: return 1; ! 1001: } ! 1002: ! 1003: /* Construct a constant descriptor for the rtl-expression X. ! 1004: It is up to the caller to enter the descriptor in the hash table. */ ! 1005: ! 1006: static struct constant_descriptor * ! 1007: record_constant_rtx (x) ! 1008: rtx x; ! 1009: { ! 1010: struct constant_descriptor *ptr = 0; ! 1011: int buf; ! 1012: struct rtx_const value; ! 1013: ! 1014: decode_rtx_const (x, &value); ! 1015: ! 1016: obstack_grow (saveable_obstack, &ptr, sizeof ptr); ! 1017: obstack_grow (saveable_obstack, &buf, sizeof buf); ! 1018: ! 1019: /* Record constant contents. */ ! 1020: obstack_grow (saveable_obstack, &value, sizeof value); ! 1021: ! 1022: return (struct constant_descriptor *) obstack_finish (saveable_obstack); ! 1023: } ! 1024: ! 1025: /* Given a constant rtx X, make (or find) a memory constant for its value ! 1026: and return a MEM rtx to refer to it in memory. */ ! 1027: ! 1028: rtx ! 1029: force_const_mem (mode, x) ! 1030: enum machine_mode mode; ! 1031: rtx x; ! 1032: { ! 1033: register int hash, i; ! 1034: register struct constant_descriptor *desc; ! 1035: char label[10]; ! 1036: char *found = 0; ! 1037: rtx def; ! 1038: ! 1039: /* Compute hash code of X. Search the descriptors for that hash code ! 1040: to see if any of them describes X. If yes, the descriptor records ! 1041: the label number already assigned. */ ! 1042: ! 1043: hash = const_hash_rtx (x); ! 1044: ! 1045: for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next) ! 1046: if (compare_constant_rtx (x, desc)) ! 1047: { ! 1048: found = desc->label; ! 1049: break; ! 1050: } ! 1051: ! 1052: if (found == 0) ! 1053: { ! 1054: /* No constant equal to X is known to have been output. ! 1055: Make a constant descriptor to enter X in the hash table. ! 1056: Assign the label number and record it in the descriptor for ! 1057: future calls to this function to find. */ ! 1058: ! 1059: desc = record_constant_rtx (x); ! 1060: desc->next = const_rtx_hash_table[hash]; ! 1061: const_rtx_hash_table[hash] = desc; ! 1062: ! 1063: /* Now output assembler code to define that label ! 1064: and follow it with the data of EXP. */ ! 1065: ! 1066: /* First switch to text segment. */ ! 1067: fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP); ! 1068: ! 1069: /* Align the location counter as required by EXP's data type. */ ! 1070: ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (UNITS_PER_WORD)); ! 1071: ! 1072: /* Output the label itself. */ ! 1073: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno); ! 1074: ! 1075: /* Output the value of EXP. */ ! 1076: if (GET_CODE (x) == CONST_DOUBLE) ! 1077: { ! 1078: union {double d; int i[2];} u; ! 1079: ! 1080: u.i[0] = XINT (x, 0); ! 1081: u.i[1] = XINT (x, 1); ! 1082: if (GET_MODE_SIZE (GET_MODE (x)) == GET_MODE_SIZE (DFmode)) ! 1083: ASM_OUTPUT_DOUBLE (asm_out_file, u.d); ! 1084: else ! 1085: ASM_OUTPUT_FLOAT (asm_out_file, u.d); ! 1086: } ! 1087: else ! 1088: ASM_OUTPUT_INT (asm_out_file, x); ! 1089: ! 1090: /* Create a string containing the label name, in LABEL. */ ! 1091: ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno); ! 1092: ! 1093: ++const_labelno; ! 1094: ! 1095: desc->label = found ! 1096: = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label)); ! 1097: } ! 1098: ! 1099: /* We have a symbol name; construct the SYMBOL_REF and the MEM. */ ! 1100: ! 1101: def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, desc->label)); ! 1102: ! 1103: def->unchanging = 1; ! 1104: /* Mark the symbol_ref as belonging to this constants pool. */ ! 1105: XEXP (def, 0)->unchanging = 1; ! 1106: ! 1107: return def; ! 1108: } ! 1109: ! 1110: /* Find all the constants whose addresses are referenced inside of EXP, ! 1111: and make sure assembler code with a label has been output for each one. */ ! 1112: ! 1113: void ! 1114: output_addressed_constants (exp) ! 1115: tree exp; ! 1116: { ! 1117: switch (TREE_CODE (exp)) ! 1118: { ! 1119: case ADDR_EXPR: ! 1120: { ! 1121: register tree constant = TREE_OPERAND (exp, 0); ! 1122: ! 1123: while (TREE_CODE (constant) == COMPONENT_REF) ! 1124: { ! 1125: constant = TREE_OPERAND (constant, 0); ! 1126: } ! 1127: ! 1128: if (TREE_LITERAL (constant)) ! 1129: /* No need to do anything here ! 1130: for addresses of variables or functions. */ ! 1131: output_constant_def (constant); ! 1132: } ! 1133: break; ! 1134: ! 1135: case PLUS_EXPR: ! 1136: case MINUS_EXPR: ! 1137: output_addressed_constants (TREE_OPERAND (exp, 0)); ! 1138: output_addressed_constants (TREE_OPERAND (exp, 1)); ! 1139: break; ! 1140: ! 1141: case NOP_EXPR: ! 1142: case CONVERT_EXPR: ! 1143: output_addressed_constants (TREE_OPERAND (exp, 0)); ! 1144: break; ! 1145: ! 1146: case CONSTRUCTOR: ! 1147: { ! 1148: register tree link; ! 1149: for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link)) ! 1150: output_addressed_constants (TREE_VALUE (link)); ! 1151: } ! 1152: break; ! 1153: ! 1154: case ERROR_MARK: ! 1155: break; ! 1156: ! 1157: default: ! 1158: if (! TREE_LITERAL (exp)) ! 1159: abort (); ! 1160: } ! 1161: } ! 1162: ! 1163: /* Output assembler code for constant EXP to FILE, with no label. ! 1164: This includes the pseudo-op such as ".int" or ".byte", and a newline. ! 1165: Assumes output_addressed_constants has been done on EXP already. ! 1166: ! 1167: Generate exactly SIZE bytes of assembler data, padding at the end ! 1168: with zeros if necessary. SIZE must always be specified. ! 1169: ! 1170: SIZE is important for structure constructors, ! 1171: since trailing members may have been omitted from the constructor. ! 1172: It is also important for initialization of arrays from string constants ! 1173: since the full length of the string constant might not be wanted. ! 1174: It is also needed for initialization of unions, where the initializer's ! 1175: type is just one member, and that may not be as long as the union. ! 1176: ! 1177: There a case in which we would fail to output exactly SIZE bytes: ! 1178: for a structure constructor that wants to produce more than SIZE bytes. ! 1179: But such constructors will never be generated for any possible input. */ ! 1180: ! 1181: void ! 1182: output_constant (exp, size) ! 1183: register tree exp; ! 1184: register int size; ! 1185: { ! 1186: register enum tree_code code = TREE_CODE (TREE_TYPE (exp)); ! 1187: rtx x; ! 1188: ! 1189: if (size == 0) ! 1190: return; ! 1191: ! 1192: switch (code) ! 1193: { ! 1194: case INTEGER_TYPE: ! 1195: case ENUMERAL_TYPE: ! 1196: case POINTER_TYPE: ! 1197: x = expand_expr (exp, 0, VOIDmode, EXPAND_SUM); ! 1198: ! 1199: if (size == 1) ! 1200: { ! 1201: ASM_OUTPUT_CHAR (asm_out_file, x); ! 1202: size -= 1; ! 1203: } ! 1204: else if (size == 2) ! 1205: { ! 1206: ASM_OUTPUT_SHORT (asm_out_file, x); ! 1207: size -= 2; ! 1208: } ! 1209: else if (size == 4) ! 1210: { ! 1211: ASM_OUTPUT_INT (asm_out_file, x); ! 1212: size -= 4; ! 1213: } ! 1214: else ! 1215: abort (); ! 1216: ! 1217: break; ! 1218: ! 1219: case REAL_TYPE: ! 1220: if (TREE_CODE (exp) != REAL_CST) ! 1221: error ("initializer for floating value is not a floating constant"); ! 1222: ! 1223: if (size < 4) ! 1224: break; ! 1225: else if (size < 8) ! 1226: { ! 1227: ASM_OUTPUT_FLOAT (asm_out_file, TREE_REAL_CST (exp)); ! 1228: size -= 4; ! 1229: } ! 1230: else ! 1231: { ! 1232: ASM_OUTPUT_DOUBLE (asm_out_file, TREE_REAL_CST (exp)); ! 1233: size -= 8; ! 1234: } ! 1235: break; ! 1236: ! 1237: case COMPLEX_TYPE: ! 1238: output_constant (TREE_REALPART (exp), size / 2); ! 1239: output_constant (TREE_IMAGPART (exp), size / 2); ! 1240: size -= (size / 2) * 2; ! 1241: break; ! 1242: ! 1243: case ARRAY_TYPE: ! 1244: if (TREE_CODE (exp) == CONSTRUCTOR) ! 1245: { ! 1246: output_constructor (exp, size); ! 1247: return; ! 1248: } ! 1249: else if (TREE_CODE (exp) == STRING_CST) ! 1250: { ! 1251: register int i; ! 1252: register unsigned char *p ! 1253: = (unsigned char *) TREE_STRING_POINTER (exp); ! 1254: int excess = 0; ! 1255: ! 1256: if (size > TREE_STRING_LENGTH (exp)) ! 1257: { ! 1258: excess = size - TREE_STRING_LENGTH (exp); ! 1259: size = TREE_STRING_LENGTH (exp); ! 1260: } ! 1261: ! 1262: #ifdef ASM_OUTPUT_ASCII ! 1263: ASM_OUTPUT_ASCII (asm_out_file, p, size); ! 1264: #else ! 1265: fprintf (asm_out_file, "\t.ascii \""); ! 1266: ! 1267: for (i = 0; i < size; i++) ! 1268: { ! 1269: register int c = p[i]; ! 1270: if (c == '\"' || c == '\\') ! 1271: putc ('\\', asm_out_file); ! 1272: if (c >= ' ' && c < 0177) ! 1273: putc (c, asm_out_file); ! 1274: else ! 1275: { ! 1276: fprintf (asm_out_file, "\\%o", c); ! 1277: /* After an octal-escape, if a digit follows, ! 1278: terminate one string constant and start another. ! 1279: The Vax assembler fails to stop reading the escape ! 1280: after three digits, so this is the only way we ! 1281: can get it to parse the data properly. */ ! 1282: if (i < size - 1 && p[i + 1] >= '0' && p[i + 1] <= '9') ! 1283: fprintf (asm_out_file, "\"\n\t.ascii \""); ! 1284: } ! 1285: } ! 1286: fprintf (asm_out_file, "\"\n"); ! 1287: #endif /* no ASM_OUTPUT_ASCII */ ! 1288: ! 1289: size = excess; ! 1290: } ! 1291: else ! 1292: abort (); ! 1293: break; ! 1294: ! 1295: case RECORD_TYPE: ! 1296: case UNION_TYPE: ! 1297: if (TREE_CODE (exp) == CONSTRUCTOR) ! 1298: output_constructor (exp, size); ! 1299: else ! 1300: abort (); ! 1301: return; ! 1302: } ! 1303: ! 1304: if (size > 0) ! 1305: ASM_OUTPUT_SKIP (asm_out_file, size); ! 1306: } ! 1307: ! 1308: /* Subroutine of output_constant, used for CONSTRUCTORs ! 1309: (aggregate constants). ! 1310: Generate at least SIZE bytes, padding if necessary. */ ! 1311: ! 1312: void ! 1313: output_constructor (exp, size) ! 1314: tree exp; ! 1315: int size; ! 1316: { ! 1317: register tree link, field = 0; ! 1318: register int byte; ! 1319: int total_bytes = 0; ! 1320: int byte_offset = -1; ! 1321: ! 1322: if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE ! 1323: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE) ! 1324: field = TYPE_FIELDS (TREE_TYPE (exp)); ! 1325: ! 1326: /* As LINK goes through the elements of the constant, ! 1327: FIELD goes through the structure fields, if the constant is a structure. ! 1328: But the constant could also be an array. Then FIELD is zero. */ ! 1329: for (link = CONSTRUCTOR_ELTS (exp); ! 1330: link; ! 1331: link = TREE_CHAIN (link), ! 1332: field = field ? TREE_CHAIN (field) : 0) ! 1333: { ! 1334: if (field == 0 ! 1335: || (DECL_MODE (field) != BImode)) ! 1336: { ! 1337: register int fieldsize; ! 1338: ! 1339: /* An element that is not a bit-field. ! 1340: Output any buffered-up bit-fields preceding it. */ ! 1341: if (byte_offset >= 0) ! 1342: { ! 1343: ASM_OUTPUT_BYTE (asm_out_file, byte); ! 1344: total_bytes++; ! 1345: byte_offset = -1; ! 1346: } ! 1347: ! 1348: /* Align to this element's alignment, ! 1349: if it isn't aligned properly by its predecessors. */ ! 1350: if (field && (total_bytes * BITS_PER_UNIT) % DECL_ALIGN (field) != 0) ! 1351: { ! 1352: int byte_align = DECL_ALIGN (field) / BITS_PER_UNIT; ! 1353: int to_byte = (((total_bytes + byte_align - 1) / byte_align) ! 1354: * byte_align); ! 1355: ASM_OUTPUT_SKIP (asm_out_file, to_byte - total_bytes); ! 1356: total_bytes = to_byte; ! 1357: } ! 1358: ! 1359: /* Output the element's initial value. */ ! 1360: if (field) ! 1361: { ! 1362: if (! TREE_LITERAL (DECL_SIZE (field))) ! 1363: abort (); ! 1364: fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field)) ! 1365: * DECL_SIZE_UNIT (field); ! 1366: fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT; ! 1367: } ! 1368: else ! 1369: fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp))); ! 1370: ! 1371: output_constant (TREE_VALUE (link), fieldsize); ! 1372: ! 1373: /* Count its size. */ ! 1374: total_bytes += fieldsize; ! 1375: } ! 1376: else if (TREE_CODE (TREE_VALUE (link)) != INTEGER_CST) ! 1377: error ("invalid initial value for member `%s'", ! 1378: IDENTIFIER_POINTER (DECL_NAME (field))); ! 1379: else ! 1380: { ! 1381: /* Element that is a bit-field. */ ! 1382: ! 1383: int next_offset = DECL_OFFSET (field); ! 1384: int end_offset ! 1385: = (next_offset ! 1386: + (TREE_INT_CST_LOW (DECL_SIZE (field)) ! 1387: * DECL_SIZE_UNIT (field))); ! 1388: ! 1389: /* We must split the element into pieces that fall within ! 1390: separate bytes, and combine each byte with previous or ! 1391: following bit-fields. */ ! 1392: ! 1393: /* next_offset is the offset n fbits from the begining of ! 1394: the structure to the next bit of this element to be processed. ! 1395: end_offset is the offset of the first bit past the end of ! 1396: this element. */ ! 1397: while (next_offset < end_offset) ! 1398: { ! 1399: int this_time; ! 1400: int next_byte = next_offset / BITS_PER_UNIT; ! 1401: int next_bit = next_offset % BITS_PER_UNIT; ! 1402: if (byte_offset < 0) ! 1403: { ! 1404: byte_offset = next_byte; ! 1405: byte = 0; ! 1406: } ! 1407: else ! 1408: while (next_byte != byte_offset) ! 1409: { ! 1410: ASM_OUTPUT_BYTE (asm_out_file, byte); ! 1411: byte_offset++; ! 1412: total_bytes++; ! 1413: byte = 0; ! 1414: } ! 1415: /* Number of bits we can process at once ! 1416: (all part of the same byte). */ ! 1417: this_time = MIN (end_offset - next_offset, ! 1418: BITS_PER_UNIT - next_bit); ! 1419: #ifdef BYTES_BIG_ENDIAN ! 1420: /* On big-endian machine, take the most significant bits ! 1421: first (of the bits that are significant) ! 1422: and put them into bytes from the most significant end. */ ! 1423: byte |= (((TREE_INT_CST_LOW (TREE_VALUE (link)) ! 1424: >> (end_offset - next_offset - this_time)) ! 1425: & ((1 << this_time) - 1)) ! 1426: << (BITS_PER_UNIT - this_time - next_bit)); ! 1427: #else ! 1428: /* On little-endian machines, ! 1429: take first the least significant bits of the value ! 1430: and pack them starting at the least significant ! 1431: bits of the bytes. */ ! 1432: byte |= ((TREE_INT_CST_LOW (TREE_VALUE (link)) ! 1433: >> (next_offset - DECL_OFFSET (field))) ! 1434: & ((1 << this_time) - 1)) << next_bit; ! 1435: #endif ! 1436: next_offset += this_time; ! 1437: } ! 1438: } ! 1439: } ! 1440: if (byte_offset >= 0) ! 1441: { ! 1442: ASM_OUTPUT_BYTE (asm_out_file, byte); ! 1443: byte_offset = -1; ! 1444: total_bytes++; ! 1445: } ! 1446: if (total_bytes < size) ! 1447: ASM_OUTPUT_SKIP (asm_out_file, size - total_bytes); ! 1448: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.