(all output patterns): Use new capabilities of arm_print_operand to
[official-gcc.git] / gcc / rtl.c
blob6f29f7f7005f524fd27cdef5af79f41bf677954a
1 /* Allocate and read RTL for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991, 1994 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include "config.h"
22 #include <ctype.h>
23 #include <stdio.h>
24 #include "rtl.h"
25 #include "real.h"
27 #include "obstack.h"
28 #define obstack_chunk_alloc xmalloc
29 #define obstack_chunk_free free
31 /* Obstack used for allocating RTL objects.
32 Between functions, this is the permanent_obstack.
33 While parsing and expanding a function, this is maybepermanent_obstack
34 so we can save it if it is an inline function.
35 During optimization and output, this is function_obstack. */
37 extern struct obstack *rtl_obstack;
39 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
40 extern long atol();
41 #endif
43 /* Indexed by rtx code, gives number of operands for an rtx with that code.
44 Does NOT include rtx header data (code and links).
45 This array is initialized in init_rtl. */
47 int rtx_length[NUM_RTX_CODE + 1];
49 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
51 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
53 char *rtx_name[] = {
54 #include "rtl.def" /* rtl expressions are documented here */
57 #undef DEF_RTL_EXPR
59 /* Indexed by machine mode, gives the name of that machine mode.
60 This name does not include the letters "mode". */
62 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME,
64 char *mode_name[(int) MAX_MACHINE_MODE] = {
65 #include "machmode.def"
67 #ifdef EXTRA_CC_MODES
68 EXTRA_CC_NAMES
69 #endif
73 #undef DEF_MACHMODE
75 /* Indexed by machine mode, gives the length of the mode, in bytes.
76 GET_MODE_CLASS uses this. */
78 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS,
80 enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
81 #include "machmode.def"
84 #undef DEF_MACHMODE
86 /* Indexed by machine mode, gives the length of the mode, in bytes.
87 GET_MODE_SIZE uses this. */
89 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE,
91 int mode_size[(int) MAX_MACHINE_MODE] = {
92 #include "machmode.def"
95 #undef DEF_MACHMODE
97 /* Indexed by machine mode, gives the length of the mode's subunit.
98 GET_MODE_UNIT_SIZE uses this. */
100 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT,
102 int mode_unit_size[(int) MAX_MACHINE_MODE] = {
103 #include "machmode.def" /* machine modes are documented here */
106 #undef DEF_MACHMODE
108 /* Indexed by machine mode, gives next wider natural mode
109 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
110 use this. */
112 #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \
113 (enum machine_mode) WIDER,
115 enum machine_mode mode_wider_mode[(int) MAX_MACHINE_MODE] = {
116 #include "machmode.def" /* machine modes are documented here */
119 #undef DEF_MACHMODE
121 /* Indexed by mode class, gives the narrowest mode for each class. */
123 enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS];
125 /* Indexed by rtx code, gives a sequence of operand-types for
126 rtx's of that code. The sequence is a C string in which
127 each character describes one operand. */
129 char *rtx_format[] = {
130 /* "*" undefined.
131 can cause a warning message
132 "0" field is unused (or used in a phase-dependent manner)
133 prints nothing
134 "i" an integer
135 prints the integer
136 "n" like "i", but prints entries from `note_insn_name'
137 "w" an integer of width HOST_BITS_PER_WIDE_INT
138 prints the integer
139 "s" a pointer to a string
140 prints the string
141 "S" like "s", but optional:
142 the containing rtx may end before this operand
143 "e" a pointer to an rtl expression
144 prints the expression
145 "E" a pointer to a vector that points to a number of rtl expressions
146 prints a list of the rtl expressions
147 "V" like "E", but optional:
148 the containing rtx may end before this operand
149 "u" a pointer to another insn
150 prints the uid of the insn. */
152 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
153 #include "rtl.def" /* rtl expressions are defined here */
154 #undef DEF_RTL_EXPR
157 /* Indexed by rtx code, gives a character representing the "class" of
158 that rtx code. See rtl.def for documentation on the defined classes. */
160 char rtx_class[] = {
161 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
162 #include "rtl.def" /* rtl expressions are defined here */
163 #undef DEF_RTL_EXPR
166 /* Names for kinds of NOTEs and REG_NOTEs. */
168 char *note_insn_name[] = { 0 , "NOTE_INSN_DELETED",
169 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
170 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
171 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
172 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
173 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
174 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG"};
176 char *reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
177 "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
178 "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
179 "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
180 "REG_DEP_ANTI", "REG_DEP_OUTPUT" };
182 /* Allocate an rtx vector of N elements.
183 Store the length, and initialize all elements to zero. */
185 rtvec
186 rtvec_alloc (n)
187 int n;
189 rtvec rt;
190 int i;
192 rt = (rtvec) obstack_alloc (rtl_obstack,
193 sizeof (struct rtvec_def)
194 + (( n - 1) * sizeof (rtunion)));
196 /* clear out the vector */
197 PUT_NUM_ELEM(rt, n);
198 for (i=0; i < n; i++)
199 rt->elem[i].rtvec = NULL; /* @@ not portable due to rtunion */
201 return rt;
204 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
205 all the rest is initialized to zero. */
208 rtx_alloc (code)
209 RTX_CODE code;
211 rtx rt;
212 register struct obstack *ob = rtl_obstack;
213 register int nelts = GET_RTX_LENGTH (code);
214 register int length = sizeof (struct rtx_def)
215 + (nelts - 1) * sizeof (rtunion);
217 /* This function is called more than any other in GCC,
218 so we manipulate the obstack directly.
220 Even though rtx objects are word aligned, we may be sharing an obstack
221 with tree nodes, which may have to be double-word aligned. So align
222 our length to the alignment mask in the obstack. */
224 length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
226 if (ob->chunk_limit - ob->next_free < length)
227 _obstack_newchunk (ob, length);
228 rt = (rtx)ob->object_base;
229 ob->next_free += length;
230 ob->object_base = ob->next_free;
232 /* We want to clear everything up to the FLD array. Normally, this is
233 one int, but we don't want to assume that and it isn't very portable
234 anyway; this is. */
236 length = (sizeof (struct rtx_def) - sizeof (rtunion) - 1) / sizeof (int);
237 for (; length >= 0; length--)
238 ((int *) rt)[length] = 0;
240 PUT_CODE (rt, code);
242 return rt;
245 /* Free the rtx X and all RTL allocated since X. */
247 void
248 rtx_free (x)
249 rtx x;
251 obstack_free (rtl_obstack, x);
254 /* Create a new copy of an rtx.
255 Recursively copies the operands of the rtx,
256 except for those few rtx codes that are sharable. */
259 copy_rtx (orig)
260 register rtx orig;
262 register rtx copy;
263 register int i, j;
264 register RTX_CODE code;
265 register char *format_ptr;
267 code = GET_CODE (orig);
269 switch (code)
271 case REG:
272 case QUEUED:
273 case CONST_INT:
274 case CONST_DOUBLE:
275 case SYMBOL_REF:
276 case CODE_LABEL:
277 case PC:
278 case CC0:
279 case SCRATCH:
280 /* SCRATCH must be shared because they represent distinct values. */
281 return orig;
283 case CONST:
284 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
285 a LABEL_REF, it isn't sharable. */
286 if (GET_CODE (XEXP (orig, 0)) == PLUS
287 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
288 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
289 return orig;
290 break;
292 /* A MEM with a constant address is not sharable. The problem is that
293 the constant address may need to be reloaded. If the mem is shared,
294 then reloading one copy of this mem will cause all copies to appear
295 to have been reloaded. */
298 copy = rtx_alloc (code);
299 PUT_MODE (copy, GET_MODE (orig));
300 copy->in_struct = orig->in_struct;
301 copy->volatil = orig->volatil;
302 copy->unchanging = orig->unchanging;
303 copy->integrated = orig->integrated;
305 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
307 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
309 switch (*format_ptr++)
311 case 'e':
312 XEXP (copy, i) = XEXP (orig, i);
313 if (XEXP (orig, i) != NULL)
314 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
315 break;
317 case '0':
318 case 'u':
319 XEXP (copy, i) = XEXP (orig, i);
320 break;
322 case 'E':
323 case 'V':
324 XVEC (copy, i) = XVEC (orig, i);
325 if (XVEC (orig, i) != NULL)
327 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
328 for (j = 0; j < XVECLEN (copy, i); j++)
329 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
331 break;
333 case 'w':
334 XWINT (copy, i) = XWINT (orig, i);
335 break;
337 case 'i':
338 XINT (copy, i) = XINT (orig, i);
339 break;
341 case 's':
342 case 'S':
343 XSTR (copy, i) = XSTR (orig, i);
344 break;
346 default:
347 abort ();
350 return copy;
353 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
354 placed in the result directly, rather than being copied. */
357 copy_most_rtx (orig, may_share)
358 register rtx orig;
359 register rtx may_share;
361 register rtx copy;
362 register int i, j;
363 register RTX_CODE code;
364 register char *format_ptr;
366 if (orig == may_share)
367 return orig;
369 code = GET_CODE (orig);
371 switch (code)
373 case REG:
374 case QUEUED:
375 case CONST_INT:
376 case CONST_DOUBLE:
377 case SYMBOL_REF:
378 case CODE_LABEL:
379 case PC:
380 case CC0:
381 return orig;
384 copy = rtx_alloc (code);
385 PUT_MODE (copy, GET_MODE (orig));
386 copy->in_struct = orig->in_struct;
387 copy->volatil = orig->volatil;
388 copy->unchanging = orig->unchanging;
389 copy->integrated = orig->integrated;
391 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
393 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
395 switch (*format_ptr++)
397 case 'e':
398 XEXP (copy, i) = XEXP (orig, i);
399 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
400 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
401 break;
403 case '0':
404 case 'u':
405 XEXP (copy, i) = XEXP (orig, i);
406 break;
408 case 'E':
409 case 'V':
410 XVEC (copy, i) = XVEC (orig, i);
411 if (XVEC (orig, i) != NULL)
413 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
414 for (j = 0; j < XVECLEN (copy, i); j++)
415 XVECEXP (copy, i, j)
416 = copy_most_rtx (XVECEXP (orig, i, j), may_share);
418 break;
420 case 'w':
421 XWINT (copy, i) = XWINT (orig, i);
422 break;
424 case 'n':
425 case 'i':
426 XINT (copy, i) = XINT (orig, i);
427 break;
429 case 's':
430 case 'S':
431 XSTR (copy, i) = XSTR (orig, i);
432 break;
434 default:
435 abort ();
438 return copy;
441 /* Subroutines of read_rtx. */
443 /* Dump code after printing a message. Used when read_rtx finds
444 invalid data. */
446 static void
447 dump_and_abort (expected_c, actual_c, infile)
448 int expected_c, actual_c;
449 FILE *infile;
451 int c, i;
453 if (expected_c >= 0)
454 fprintf (stderr,
455 "Expected character %c. Found character %c.",
456 expected_c, actual_c);
457 fprintf (stderr, " At file position: %ld\n", ftell (infile));
458 fprintf (stderr, "Following characters are:\n\t");
459 for (i = 0; i < 200; i++)
461 c = getc (infile);
462 if (EOF == c) break;
463 putc (c, stderr);
465 fprintf (stderr, "Aborting.\n");
466 abort ();
469 /* Read chars from INFILE until a non-whitespace char
470 and return that. Comments, both Lisp style and C style,
471 are treated as whitespace.
472 Tools such as genflags use this function. */
475 read_skip_spaces (infile)
476 FILE *infile;
478 register int c;
479 while (c = getc (infile))
481 if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
483 else if (c == ';')
485 while ((c = getc (infile)) && c != '\n') ;
487 else if (c == '/')
489 register int prevc;
490 c = getc (infile);
491 if (c != '*')
492 dump_and_abort ('*', c, infile);
494 prevc = 0;
495 while (c = getc (infile))
497 if (prevc == '*' && c == '/')
498 break;
499 prevc = c;
502 else break;
504 return c;
507 /* Read an rtx code name into the buffer STR[].
508 It is terminated by any of the punctuation chars of rtx printed syntax. */
510 static void
511 read_name (str, infile)
512 char *str;
513 FILE *infile;
515 register char *p;
516 register int c;
518 c = read_skip_spaces(infile);
520 p = str;
521 while (1)
523 if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
524 break;
525 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
526 || c == '(' || c == '[')
528 ungetc (c, infile);
529 break;
531 *p++ = c;
532 c = getc (infile);
534 if (p == str)
536 fprintf (stderr, "missing name or number");
537 dump_and_abort (-1, -1, infile);
540 *p = 0;
543 /* Read an rtx in printed representation from INFILE
544 and return an actual rtx in core constructed accordingly.
545 read_rtx is not used in the compiler proper, but rather in
546 the utilities gen*.c that construct C code from machine descriptions. */
549 read_rtx (infile)
550 FILE *infile;
552 register int i, j, list_counter;
553 RTX_CODE tmp_code;
554 register char *format_ptr;
555 /* tmp_char is a buffer used for reading decimal integers
556 and names of rtx types and machine modes.
557 Therefore, 256 must be enough. */
558 char tmp_char[256];
559 rtx return_rtx;
560 register int c;
561 int tmp_int;
562 HOST_WIDE_INT tmp_wide;
564 /* Linked list structure for making RTXs: */
565 struct rtx_list
567 struct rtx_list *next;
568 rtx value; /* Value of this node... */
571 c = read_skip_spaces (infile); /* Should be open paren. */
572 if (c != '(')
573 dump_and_abort ('(', c, infile);
575 read_name (tmp_char, infile);
577 tmp_code = UNKNOWN;
579 for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */
581 if (!(strcmp (tmp_char, GET_RTX_NAME (i))))
583 tmp_code = (RTX_CODE) i; /* get value for name */
584 break;
587 if (tmp_code == UNKNOWN)
589 fprintf (stderr,
590 "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
591 tmp_char);
593 /* (NIL) stands for an expression that isn't there. */
594 if (tmp_code == NIL)
596 /* Discard the closeparen. */
597 while ((c = getc (infile)) && c != ')');
598 return 0;
601 return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression
602 then we free this space below. */
603 format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
605 /* If what follows is `: mode ', read it and
606 store the mode in the rtx. */
608 i = read_skip_spaces (infile);
609 if (i == ':')
611 register int k;
612 read_name (tmp_char, infile);
613 for (k = 0; k < NUM_MACHINE_MODES; k++)
614 if (!strcmp (GET_MODE_NAME (k), tmp_char))
615 break;
617 PUT_MODE (return_rtx, (enum machine_mode) k );
619 else
620 ungetc (i, infile);
622 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
623 switch (*format_ptr++)
625 /* 0 means a field for internal use only.
626 Don't expect it to be present in the input. */
627 case '0':
628 break;
630 case 'e':
631 case 'u':
632 XEXP (return_rtx, i) = read_rtx (infile);
633 break;
635 case 'V':
636 /* 'V' is an optional vector: if a closeparen follows,
637 just store NULL for this element. */
638 c = read_skip_spaces (infile);
639 ungetc (c, infile);
640 if (c == ')')
642 XVEC (return_rtx, i) = 0;
643 break;
645 /* Now process the vector. */
647 case 'E':
649 register struct rtx_list *next_rtx, *rtx_list_link;
650 struct rtx_list *list_rtx;
652 c = read_skip_spaces (infile);
653 if (c != '[')
654 dump_and_abort ('[', c, infile);
656 /* add expressions to a list, while keeping a count */
657 next_rtx = NULL;
658 list_counter = 0;
659 while ((c = read_skip_spaces (infile)) && c != ']')
661 ungetc (c, infile);
662 list_counter++;
663 rtx_list_link = (struct rtx_list *)
664 alloca (sizeof (struct rtx_list));
665 rtx_list_link->value = read_rtx (infile);
666 if (next_rtx == 0)
667 list_rtx = rtx_list_link;
668 else
669 next_rtx->next = rtx_list_link;
670 next_rtx = rtx_list_link;
671 rtx_list_link->next = 0;
673 /* get vector length and allocate it */
674 XVEC (return_rtx, i) = (list_counter
675 ? rtvec_alloc (list_counter) : NULL_RTVEC);
676 if (list_counter > 0)
678 next_rtx = list_rtx;
679 for (j = 0; j < list_counter; j++,
680 next_rtx = next_rtx->next)
681 XVECEXP (return_rtx, i, j) = next_rtx->value;
683 /* close bracket gotten */
685 break;
687 case 'S':
688 /* 'S' is an optional string: if a closeparen follows,
689 just store NULL for this element. */
690 c = read_skip_spaces (infile);
691 ungetc (c, infile);
692 if (c == ')')
694 XSTR (return_rtx, i) = 0;
695 break;
698 case 's':
700 int saw_paren = 0;
701 register char *stringbuf;
703 c = read_skip_spaces (infile);
704 if (c == '(')
706 saw_paren = 1;
707 c = read_skip_spaces (infile);
709 if (c != '"')
710 dump_and_abort ('"', c, infile);
712 while (1)
714 c = getc (infile); /* Read the string */
715 if (c == '\\')
717 c = getc (infile); /* Read the string */
718 /* \; makes stuff for a C string constant containing
719 newline and tab. */
720 if (c == ';')
722 obstack_grow (rtl_obstack, "\\n\\t", 4);
723 continue;
726 else if (c == '"')
727 break;
729 obstack_1grow (rtl_obstack, c);
732 obstack_1grow (rtl_obstack, 0);
733 stringbuf = (char *) obstack_finish (rtl_obstack);
735 if (saw_paren)
737 c = read_skip_spaces (infile);
738 if (c != ')')
739 dump_and_abort (')', c, infile);
741 XSTR (return_rtx, i) = stringbuf;
743 break;
745 case 'w':
746 read_name (tmp_char, infile);
747 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
748 tmp_wide = atoi (tmp_char);
749 #else
750 tmp_wide = atol (tmp_char);
751 #endif
752 XWINT (return_rtx, i) = tmp_wide;
753 break;
755 case 'i':
756 case 'n':
757 read_name (tmp_char, infile);
758 tmp_int = atoi (tmp_char);
759 XINT (return_rtx, i) = tmp_int;
760 break;
762 default:
763 fprintf (stderr,
764 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
765 format_ptr[-1]);
766 fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
767 abort ();
770 c = read_skip_spaces (infile);
771 if (c != ')')
772 dump_and_abort (')', c, infile);
774 return return_rtx;
777 /* This is called once per compilation, before any rtx's are constructed.
778 It initializes the vector `rtx_length', the extra CC modes, if any,
779 and computes certain commonly-used modes. */
781 void
782 init_rtl ()
784 int min_class_size[(int) MAX_MODE_CLASS];
785 enum machine_mode mode;
786 int i;
788 for (i = 0; i < NUM_RTX_CODE; i++)
789 rtx_length[i] = strlen (rtx_format[i]);
791 /* Make CONST_DOUBLE bigger, if real values are bigger than
792 it normally expects to have room for.
793 Note that REAL_VALUE_TYPE is not defined by default,
794 since tree.h is not included. But the default dfn as `double'
795 would do no harm. */
796 #ifdef REAL_VALUE_TYPE
797 i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2;
798 if (rtx_length[(int) CONST_DOUBLE] < i)
800 char *s = (char *) xmalloc (i + 1);
801 rtx_length[(int) CONST_DOUBLE] = i;
802 rtx_format[(int) CONST_DOUBLE] = s;
803 *s++ = 'e';
804 *s++ = '0';
805 /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
806 of as many `w's as we now have elements. Subtract two from
807 the size to account for the 'e' and the '0'. */
808 for (i = 2; i < rtx_length[(int) CONST_DOUBLE]; i++)
809 *s++ = 'w';
810 *s++ = 0;
812 #endif
814 #ifdef EXTRA_CC_MODES
815 for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++)
817 mode_class[i] = MODE_CC;
818 mode_size[i] = mode_size[(int) CCmode];
819 mode_unit_size[i] = mode_unit_size[(int) CCmode];
820 mode_wider_mode[i - 1] = (enum machine_mode) i;
821 mode_wider_mode[i] = VOIDmode;
823 #endif
825 /* Find the narrowest mode for each class. */
827 for (i = 0; i < (int) MAX_MODE_CLASS; i++)
828 min_class_size[i] = 1000;
830 for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
831 mode = (enum machine_mode) ((int) mode + 1))
833 if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)])
835 class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode;
836 min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode);
841 #ifdef memset
842 gcc_memset (dest, value, len)
843 char *dest;
844 int value;
845 int len;
847 while (len-- > 0)
848 *dest++ = value;
850 #endif /* memset */