OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [genoutput.c] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Generate code from to output assembler insns as recognized from rtl.
2
   Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002,
3
   2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
 
22
/* This program reads the machine description for the compiler target machine
23
   and produces a file containing these things:
24
 
25
   1. An array of `struct insn_data', which is indexed by insn code number,
26
   which contains:
27
 
28
     a. `name' is the name for that pattern.  Nameless patterns are
29
     given a name.
30
 
31
     b. `output' hold either the output template, an array of output
32
     templates, or an output function.
33
 
34
     c. `genfun' is the function to generate a body for that pattern,
35
     given operands as arguments.
36
 
37
     d. `n_operands' is the number of distinct operands in the pattern
38
     for that insn,
39
 
40
     e. `n_dups' is the number of match_dup's that appear in the insn's
41
     pattern.  This says how many elements of `recog_data.dup_loc' are
42
     significant after an insn has been recognized.
43
 
44
     f. `n_alternatives' is the number of alternatives in the constraints
45
     of each pattern.
46
 
47
     g. `output_format' tells what type of thing `output' is.
48
 
49
     h. `operand' is the base of an array of operand data for the insn.
50
 
51
   2. An array of `struct insn_operand data', used by `operand' above.
52
 
53
     a. `predicate', an int-valued function, is the match_operand predicate
54
     for this operand.
55
 
56
     b. `constraint' is the constraint for this operand.
57
 
58
     c. `address_p' indicates that the operand appears within ADDRESS
59
     rtx's.
60
 
61
     d. `mode' is the machine mode that that operand is supposed to have.
62
 
63
     e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART.
64
 
65
     f. `eliminable', is nonzero for operands that are matched normally by
66
     MATCH_OPERAND; it is zero for operands that should not be changed during
67
     register elimination such as MATCH_OPERATORs.
68
 
69
  The code number of an insn is simply its position in the machine
70
  description; code numbers are assigned sequentially to entries in
71
  the description, starting with code number 0.
72
 
73
  Thus, the following entry in the machine description
74
 
75
    (define_insn "clrdf"
76
      [(set (match_operand:DF 0 "general_operand" "")
77
            (const_int 0))]
78
      ""
79
      "clrd %0")
80
 
81
  assuming it is the 25th entry present, would cause
82
  insn_data[24].template to be "clrd %0", and
83
  insn_data[24].n_operands to be 1.  */
84
 
85
#include "bconfig.h"
86
#include "system.h"
87
#include "coretypes.h"
88
#include "tm.h"
89
#include "rtl.h"
90
#include "errors.h"
91
#include "gensupport.h"
92
 
93
/* No instruction can have more operands than this.  Sorry for this
94
   arbitrary limit, but what machine will have an instruction with
95
   this many operands?  */
96
 
97
#define MAX_MAX_OPERANDS 40
98
 
99
static int n_occurrences                (int, const char *);
100
static const char *strip_whitespace     (const char *);
101
 
102
/* insns in the machine description are assigned sequential code numbers
103
   that are used by insn-recog.c (produced by genrecog) to communicate
104
   to insn-output.c (produced by this program).  */
105
 
106
static int next_code_number;
107
 
108
/* This counts all definitions in the md file,
109
   for the sake of error messages.  */
110
 
111
static int next_index_number;
112
 
113
/* This counts all operands used in the md file.  The first is null.  */
114
 
115
static int next_operand_number = 1;
116
 
117
/* Record in this chain all information about the operands we will output.  */
118
 
119
struct operand_data
120
{
121
  struct operand_data *next;
122
  int index;
123
  const char *predicate;
124
  const char *constraint;
125
  enum machine_mode mode;
126
  unsigned char n_alternatives;
127
  char address_p;
128
  char strict_low;
129
  char eliminable;
130
  char seen;
131
};
132
 
133
/* Begin with a null operand at index 0.  */
134
 
135
static struct operand_data null_operand =
136
{
137
  0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0
138
};
139
 
140
static struct operand_data *odata = &null_operand;
141
static struct operand_data **odata_end = &null_operand.next;
142
 
143
/* Must match the constants in recog.h.  */
144
 
145
#define INSN_OUTPUT_FORMAT_NONE         0       /* abort */
146
#define INSN_OUTPUT_FORMAT_SINGLE       1       /* const char * */
147
#define INSN_OUTPUT_FORMAT_MULTI        2       /* const char * const * */
148
#define INSN_OUTPUT_FORMAT_FUNCTION     3       /* const char * (*)(...) */
149
 
150
/* Record in this chain all information that we will output,
151
   associated with the code number of the insn.  */
152
 
153
struct data
154
{
155
  struct data *next;
156
  const char *name;
157
  const char *template;
158
  int code_number;
159
  int index_number;
160
  const char *filename;
161
  int lineno;
162
  int n_operands;               /* Number of operands this insn recognizes */
163
  int n_dups;                   /* Number times match_dup appears in pattern */
164
  int n_alternatives;           /* Number of alternatives in each constraint */
165
  int operand_number;           /* Operand index in the big array.  */
166
  int output_format;            /* INSN_OUTPUT_FORMAT_*.  */
167
  struct operand_data operand[MAX_MAX_OPERANDS];
168
};
169
 
170
/* This variable points to the first link in the insn chain.  */
171
 
172
static struct data *idata, **idata_end = &idata;
173
 
174
static void output_prologue (void);
175
static void output_operand_data (void);
176
static void output_insn_data (void);
177
static void output_get_insn_name (void);
178
static void scan_operands (struct data *, rtx, int, int);
179
static int compare_operands (struct operand_data *,
180
                             struct operand_data *);
181
static void place_operands (struct data *);
182
static void process_template (struct data *, const char *);
183
static void validate_insn_alternatives (struct data *);
184
static void validate_insn_operands (struct data *);
185
static void gen_insn (rtx, int);
186
static void gen_peephole (rtx, int);
187
static void gen_expand (rtx, int);
188
static void gen_split (rtx, int);
189
 
190
#ifdef USE_MD_CONSTRAINTS
191
 
192
struct constraint_data
193
{
194
  struct constraint_data *next_this_letter;
195
  int lineno;
196
  unsigned int namelen;
197
  const char name[1];
198
};
199
 
200
/* This is a complete list (unlike the one in genpreds.c) of constraint
201
   letters and modifiers with machine-independent meaning.  The only
202
   omission is digits, as these are handled specially.  */
203
static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs";
204
 
205
static struct constraint_data *
206
constraints_by_letter_table[1 << CHAR_BIT];
207
 
208
static int mdep_constraint_len (const char *, int, int);
209
static void note_constraint (rtx, int);
210
 
211
#else  /* !USE_MD_CONSTRAINTS */
212
 
213
static void check_constraint_len (void);
214
static int constraint_len (const char *, int);
215
 
216
#endif /* !USE_MD_CONSTRAINTS */
217
 
218
 
219
static void
220
output_prologue (void)
221
{
222
  printf ("/* Generated automatically by the program `genoutput'\n\
223
   from the machine description file `md'.  */\n\n");
224
 
225
  printf ("#include \"config.h\"\n");
226
  printf ("#include \"system.h\"\n");
227
  printf ("#include \"coretypes.h\"\n");
228
  printf ("#include \"tm.h\"\n");
229
  printf ("#include \"flags.h\"\n");
230
  printf ("#include \"ggc.h\"\n");
231
  printf ("#include \"rtl.h\"\n");
232
  printf ("#include \"expr.h\"\n");
233
  printf ("#include \"insn-codes.h\"\n");
234
  printf ("#include \"tm_p.h\"\n");
235
  printf ("#include \"function.h\"\n");
236
  printf ("#include \"regs.h\"\n");
237
  printf ("#include \"hard-reg-set.h\"\n");
238
  printf ("#include \"real.h\"\n");
239
  printf ("#include \"insn-config.h\"\n\n");
240
  printf ("#include \"conditions.h\"\n");
241
  printf ("#include \"insn-attr.h\"\n\n");
242
  printf ("#include \"recog.h\"\n\n");
243
  printf ("#include \"toplev.h\"\n");
244
  printf ("#include \"output.h\"\n");
245
  printf ("#include \"target.h\"\n");
246
  printf ("#include \"tm-constrs.h\"\n");
247
}
248
 
249
static void
250
output_operand_data (void)
251
{
252
  struct operand_data *d;
253
 
254
  printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n");
255
 
256
  for (d = odata; d; d = d->next)
257
    {
258
      printf ("  {\n");
259
 
260
      printf ("    %s,\n",
261
              d->predicate && d->predicate[0] ? d->predicate : "0");
262
 
263
      printf ("    \"%s\",\n", d->constraint ? d->constraint : "");
264
 
265
      printf ("    %smode,\n", GET_MODE_NAME (d->mode));
266
 
267
      printf ("    %d,\n", d->strict_low);
268
 
269
      printf ("    %d\n", d->eliminable);
270
 
271
      printf("  },\n");
272
    }
273
  printf("};\n\n\n");
274
}
275
 
276
static void
277
output_insn_data (void)
278
{
279
  struct data *d;
280
  int name_offset = 0;
281
  int next_name_offset;
282
  const char * last_name = 0;
283
  const char * next_name = 0;
284
  struct data *n;
285
 
286
  for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++)
287
    if (n->name)
288
      {
289
        next_name = n->name;
290
        break;
291
      }
292
 
293
  printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n");
294
  printf ("\nconst struct insn_data insn_data[] = \n{\n");
295
 
296
  for (d = idata; d; d = d->next)
297
    {
298
      printf ("  /* %s:%d */\n", d->filename, d->lineno);
299
      printf ("  {\n");
300
 
301
      if (d->name)
302
        {
303
          printf ("    \"%s\",\n", d->name);
304
          name_offset = 0;
305
          last_name = d->name;
306
          next_name = 0;
307
          for (n = d->next, next_name_offset = 1; n;
308
               n = n->next, next_name_offset++)
309
            {
310
              if (n->name)
311
                {
312
                  next_name = n->name;
313
                  break;
314
                }
315
            }
316
        }
317
      else
318
        {
319
          name_offset++;
320
          if (next_name && (last_name == 0
321
                            || name_offset > next_name_offset / 2))
322
            printf ("    \"%s-%d\",\n", next_name,
323
                    next_name_offset - name_offset);
324
          else
325
            printf ("    \"%s+%d\",\n", last_name, name_offset);
326
        }
327
 
328
      switch (d->output_format)
329
        {
330
        case INSN_OUTPUT_FORMAT_NONE:
331
          printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
332
          printf ("    { 0 },\n");
333
          printf ("#else\n");
334
          printf ("    { 0, 0, 0 },\n");
335
          printf ("#endif\n");
336
          break;
337
        case INSN_OUTPUT_FORMAT_SINGLE:
338
          {
339
            const char *p = d->template;
340
            char prev = 0;
341
 
342
            printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
343
            printf ("    { .single =\n");
344
            printf ("#else\n");
345
            printf ("    {\n");
346
            printf ("#endif\n");
347
            printf ("    \"");
348
            while (*p)
349
              {
350
                if (IS_VSPACE (*p) && prev != '\\')
351
                  {
352
                    /* Preserve two consecutive \n's or \r's, but treat \r\n
353
                       as a single newline.  */
354
                    if (*p == '\n' && prev != '\r')
355
                      printf ("\\n\\\n");
356
                  }
357
                else
358
                  putchar (*p);
359
                prev = *p;
360
                ++p;
361
              }
362
            printf ("\",\n");
363
            printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
364
            printf ("    },\n");
365
            printf ("#else\n");
366
            printf ("    0, 0 },\n");
367
            printf ("#endif\n");
368
          }
369
          break;
370
        case INSN_OUTPUT_FORMAT_MULTI:
371
          printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
372
          printf ("    { .multi = output_%d },\n", d->code_number);
373
          printf ("#else\n");
374
          printf ("    { 0, output_%d, 0 },\n", d->code_number);
375
          printf ("#endif\n");
376
          break;
377
        case INSN_OUTPUT_FORMAT_FUNCTION:
378
          printf ("#if HAVE_DESIGNATED_INITIALIZERS\n");
379
          printf ("    { .function = output_%d },\n", d->code_number);
380
          printf ("#else\n");
381
          printf ("    { 0, 0, output_%d },\n", d->code_number);
382
          printf ("#endif\n");
383
          break;
384
        default:
385
          gcc_unreachable ();
386
        }
387
 
388
      if (d->name && d->name[0] != '*')
389
        printf ("    (insn_gen_fn) gen_%s,\n", d->name);
390
      else
391
        printf ("    0,\n");
392
 
393
      printf ("    &operand_data[%d],\n", d->operand_number);
394
      printf ("    %d,\n", d->n_operands);
395
      printf ("    %d,\n", d->n_dups);
396
      printf ("    %d,\n", d->n_alternatives);
397
      printf ("    %d\n", d->output_format);
398
 
399
      printf("  },\n");
400
    }
401
  printf ("};\n\n\n");
402
}
403
 
404
static void
405
output_get_insn_name (void)
406
{
407
  printf ("const char *\n");
408
  printf ("get_insn_name (int code)\n");
409
  printf ("{\n");
410
  printf ("  if (code == NOOP_MOVE_INSN_CODE)\n");
411
  printf ("    return \"NOOP_MOVE\";\n");
412
  printf ("  else\n");
413
  printf ("    return insn_data[code].name;\n");
414
  printf ("}\n");
415
}
416
 
417
 
418
/* Stores in max_opno the largest operand number present in `part', if
419
   that is larger than the previous value of max_opno, and the rest of
420
   the operand data into `d->operand[i]'.
421
 
422
   THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS.
423
   THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART.  */
424
 
425
static int max_opno;
426
static int num_dups;
427
 
428
static void
429
scan_operands (struct data *d, rtx part, int this_address_p,
430
               int this_strict_low)
431
{
432
  int i, j;
433
  const char *format_ptr;
434
  int opno;
435
 
436
  if (part == 0)
437
    return;
438
 
439
  switch (GET_CODE (part))
440
    {
441
    case MATCH_OPERAND:
442
      opno = XINT (part, 0);
443
      if (opno > max_opno)
444
        max_opno = opno;
445
      if (max_opno >= MAX_MAX_OPERANDS)
446
        {
447
          message_with_line (d->lineno,
448
                             "maximum number of operands exceeded");
449
          have_error = 1;
450
          return;
451
        }
452
      if (d->operand[opno].seen)
453
        {
454
          message_with_line (d->lineno,
455
                             "repeated operand number %d\n", opno);
456
          have_error = 1;
457
        }
458
 
459
      d->operand[opno].seen = 1;
460
      d->operand[opno].mode = GET_MODE (part);
461
      d->operand[opno].strict_low = this_strict_low;
462
      d->operand[opno].predicate = XSTR (part, 1);
463
      d->operand[opno].constraint = strip_whitespace (XSTR (part, 2));
464
      d->operand[opno].n_alternatives
465
        = n_occurrences (',', d->operand[opno].constraint) + 1;
466
      d->operand[opno].address_p = this_address_p;
467
      d->operand[opno].eliminable = 1;
468
      return;
469
 
470
    case MATCH_SCRATCH:
471
      opno = XINT (part, 0);
472
      if (opno > max_opno)
473
        max_opno = opno;
474
      if (max_opno >= MAX_MAX_OPERANDS)
475
        {
476
          message_with_line (d->lineno,
477
                             "maximum number of operands exceeded");
478
          have_error = 1;
479
          return;
480
        }
481
      if (d->operand[opno].seen)
482
        {
483
          message_with_line (d->lineno,
484
                             "repeated operand number %d\n", opno);
485
          have_error = 1;
486
        }
487
 
488
      d->operand[opno].seen = 1;
489
      d->operand[opno].mode = GET_MODE (part);
490
      d->operand[opno].strict_low = 0;
491
      d->operand[opno].predicate = "scratch_operand";
492
      d->operand[opno].constraint = strip_whitespace (XSTR (part, 1));
493
      d->operand[opno].n_alternatives
494
        = n_occurrences (',', d->operand[opno].constraint) + 1;
495
      d->operand[opno].address_p = 0;
496
      d->operand[opno].eliminable = 0;
497
      return;
498
 
499
    case MATCH_OPERATOR:
500
    case MATCH_PARALLEL:
501
      opno = XINT (part, 0);
502
      if (opno > max_opno)
503
        max_opno = opno;
504
      if (max_opno >= MAX_MAX_OPERANDS)
505
        {
506
          message_with_line (d->lineno,
507
                             "maximum number of operands exceeded");
508
          have_error = 1;
509
          return;
510
        }
511
      if (d->operand[opno].seen)
512
        {
513
          message_with_line (d->lineno,
514
                             "repeated operand number %d\n", opno);
515
          have_error = 1;
516
        }
517
 
518
      d->operand[opno].seen = 1;
519
      d->operand[opno].mode = GET_MODE (part);
520
      d->operand[opno].strict_low = 0;
521
      d->operand[opno].predicate = XSTR (part, 1);
522
      d->operand[opno].constraint = 0;
523
      d->operand[opno].address_p = 0;
524
      d->operand[opno].eliminable = 0;
525
      for (i = 0; i < XVECLEN (part, 2); i++)
526
        scan_operands (d, XVECEXP (part, 2, i), 0, 0);
527
      return;
528
 
529
    case MATCH_DUP:
530
    case MATCH_OP_DUP:
531
    case MATCH_PAR_DUP:
532
      ++num_dups;
533
      break;
534
 
535
    case ADDRESS:
536
      scan_operands (d, XEXP (part, 0), 1, 0);
537
      return;
538
 
539
    case STRICT_LOW_PART:
540
      scan_operands (d, XEXP (part, 0), 0, 1);
541
      return;
542
 
543
    default:
544
      break;
545
    }
546
 
547
  format_ptr = GET_RTX_FORMAT (GET_CODE (part));
548
 
549
  for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
550
    switch (*format_ptr++)
551
      {
552
      case 'e':
553
      case 'u':
554
        scan_operands (d, XEXP (part, i), 0, 0);
555
        break;
556
      case 'E':
557
        if (XVEC (part, i) != NULL)
558
          for (j = 0; j < XVECLEN (part, i); j++)
559
            scan_operands (d, XVECEXP (part, i, j), 0, 0);
560
        break;
561
      }
562
}
563
 
564
/* Compare two operands for content equality.  */
565
 
566
static int
567
compare_operands (struct operand_data *d0, struct operand_data *d1)
568
{
569
  const char *p0, *p1;
570
 
571
  p0 = d0->predicate;
572
  if (!p0)
573
    p0 = "";
574
  p1 = d1->predicate;
575
  if (!p1)
576
    p1 = "";
577
  if (strcmp (p0, p1) != 0)
578
    return 0;
579
 
580
  p0 = d0->constraint;
581
  if (!p0)
582
    p0 = "";
583
  p1 = d1->constraint;
584
  if (!p1)
585
    p1 = "";
586
  if (strcmp (p0, p1) != 0)
587
    return 0;
588
 
589
  if (d0->mode != d1->mode)
590
    return 0;
591
 
592
  if (d0->strict_low != d1->strict_low)
593
    return 0;
594
 
595
  if (d0->eliminable != d1->eliminable)
596
    return 0;
597
 
598
  return 1;
599
}
600
 
601
/* Scan the list of operands we've already committed to output and either
602
   find a subsequence that is the same, or allocate a new one at the end.  */
603
 
604
static void
605
place_operands (struct data *d)
606
{
607
  struct operand_data *od, *od2;
608
  int i;
609
 
610
  if (d->n_operands == 0)
611
    {
612
      d->operand_number = 0;
613
      return;
614
    }
615
 
616
  /* Brute force substring search.  */
617
  for (od = odata, i = 0; od; od = od->next, i = 0)
618
    if (compare_operands (od, &d->operand[0]))
619
      {
620
        od2 = od->next;
621
        i = 1;
622
        while (1)
623
          {
624
            if (i == d->n_operands)
625
              goto full_match;
626
            if (od2 == NULL)
627
              goto partial_match;
628
            if (! compare_operands (od2, &d->operand[i]))
629
              break;
630
            ++i, od2 = od2->next;
631
          }
632
      }
633
 
634
  /* Either partial match at the end of the list, or no match.  In either
635
     case, we tack on what operands are remaining to the end of the list.  */
636
 partial_match:
637
  d->operand_number = next_operand_number - i;
638
  for (; i < d->n_operands; ++i)
639
    {
640
      od2 = &d->operand[i];
641
      *odata_end = od2;
642
      odata_end = &od2->next;
643
      od2->index = next_operand_number++;
644
    }
645
  *odata_end = NULL;
646
  return;
647
 
648
 full_match:
649
  d->operand_number = od->index;
650
  return;
651
}
652
 
653
 
654
/* Process an assembler template from a define_insn or a define_peephole.
655
   It is either the assembler code template, a list of assembler code
656
   templates, or C code to generate the assembler code template.  */
657
 
658
static void
659
process_template (struct data *d, const char *template)
660
{
661
  const char *cp;
662
  int i;
663
 
664
  /* Templates starting with * contain straight code to be run.  */
665
  if (template[0] == '*')
666
    {
667
      d->template = 0;
668
      d->output_format = INSN_OUTPUT_FORMAT_FUNCTION;
669
 
670
      puts ("\nstatic const char *");
671
      printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n",
672
              d->code_number);
673
      puts ("{");
674
      print_rtx_ptr_loc (template);
675
      puts (template + 1);
676
      puts ("}");
677
    }
678
 
679
  /* If the assembler code template starts with a @ it is a newline-separated
680
     list of assembler code templates, one for each alternative.  */
681
  else if (template[0] == '@')
682
    {
683
      d->template = 0;
684
      d->output_format = INSN_OUTPUT_FORMAT_MULTI;
685
 
686
      printf ("\nstatic const char * const output_%d[] = {\n", d->code_number);
687
 
688
      for (i = 0, cp = &template[1]; *cp; )
689
        {
690
          const char *ep, *sp;
691
 
692
          while (ISSPACE (*cp))
693
            cp++;
694
 
695
          printf ("  \"");
696
 
697
          for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep)
698
            if (!ISSPACE (*ep))
699
              sp = ep + 1;
700
 
701
          if (sp != ep)
702
            message_with_line (d->lineno,
703
                               "trailing whitespace in output template");
704
 
705
          while (cp < sp)
706
            {
707
              putchar (*cp);
708
              cp++;
709
            }
710
 
711
          printf ("\",\n");
712
          i++;
713
        }
714
      if (i == 1)
715
        message_with_line (d->lineno,
716
                           "'@' is redundant for output template with single alternative");
717
      if (i != d->n_alternatives)
718
        {
719
          message_with_line (d->lineno,
720
                             "wrong number of alternatives in the output template");
721
          have_error = 1;
722
        }
723
 
724
      printf ("};\n");
725
    }
726
  else
727
    {
728
      d->template = template;
729
      d->output_format = INSN_OUTPUT_FORMAT_SINGLE;
730
    }
731
}
732
 
733
/* Check insn D for consistency in number of constraint alternatives.  */
734
 
735
static void
736
validate_insn_alternatives (struct data *d)
737
{
738
  int n = 0, start;
739
 
740
  /* Make sure all the operands have the same number of alternatives
741
     in their constraints.  Let N be that number.  */
742
  for (start = 0; start < d->n_operands; start++)
743
    if (d->operand[start].n_alternatives > 0)
744
      {
745
        int len, i;
746
        const char *p;
747
        char c;
748
        int which_alternative = 0;
749
        int alternative_count_unsure = 0;
750
 
751
        for (p = d->operand[start].constraint; (c = *p); p += len)
752
          {
753
#ifdef USE_MD_CONSTRAINTS
754
            if (ISSPACE (c) || strchr (indep_constraints, c))
755
              len = 1;
756
            else if (ISDIGIT (c))
757
              {
758
                const char *q = p;
759
                do
760
                  q++;
761
                while (ISDIGIT (*q));
762
                len = q - p;
763
              }
764
            else
765
              len = mdep_constraint_len (p, d->lineno, start);
766
#else
767
            len = CONSTRAINT_LEN (c, p);
768
 
769
            if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
770
              {
771
                message_with_line (d->lineno,
772
                                   "invalid length %d for char '%c' in alternative %d of operand %d",
773
                                    len, c, which_alternative, start);
774
                len = 1;
775
                have_error = 1;
776
              }
777
#endif
778
 
779
            if (c == ',')
780
              {
781
                which_alternative++;
782
                continue;
783
              }
784
 
785
            for (i = 1; i < len; i++)
786
              if (p[i] == '\0')
787
                {
788
                  message_with_line (d->lineno,
789
                                     "NUL in alternative %d of operand %d",
790
                                     which_alternative, start);
791
                  alternative_count_unsure = 1;
792
                  break;
793
                }
794
              else if (strchr (",#*", p[i]))
795
                {
796
                  message_with_line (d->lineno,
797
                                     "'%c' in alternative %d of operand %d",
798
                                     p[i], which_alternative, start);
799
                  alternative_count_unsure = 1;
800
                }
801
          }
802
        if (alternative_count_unsure)
803
          have_error = 1;
804
        else if (n == 0)
805
          n = d->operand[start].n_alternatives;
806
        else if (n != d->operand[start].n_alternatives)
807
          {
808
            message_with_line (d->lineno,
809
                               "wrong number of alternatives in operand %d",
810
                               start);
811
            have_error = 1;
812
          }
813
      }
814
 
815
  /* Record the insn's overall number of alternatives.  */
816
  d->n_alternatives = n;
817
}
818
 
819
/* Verify that there are no gaps in operand numbers for INSNs.  */
820
 
821
static void
822
validate_insn_operands (struct data *d)
823
{
824
  int i;
825
 
826
  for (i = 0; i < d->n_operands; ++i)
827
    if (d->operand[i].seen == 0)
828
      {
829
        message_with_line (d->lineno, "missing operand %d", i);
830
        have_error = 1;
831
      }
832
}
833
 
834
/* Look at a define_insn just read.  Assign its code number.  Record
835
   on idata the template and the number of arguments.  If the insn has
836
   a hairy output action, output a function for now.  */
837
 
838
static void
839
gen_insn (rtx insn, int lineno)
840
{
841
  struct data *d = XNEW (struct data);
842
  int i;
843
 
844
  d->code_number = next_code_number;
845
  d->index_number = next_index_number;
846
  d->filename = read_rtx_filename;
847
  d->lineno = lineno;
848
  if (XSTR (insn, 0)[0])
849
    d->name = XSTR (insn, 0);
850
  else
851
    d->name = 0;
852
 
853
  /* Build up the list in the same order as the insns are seen
854
     in the machine description.  */
855
  d->next = 0;
856
  *idata_end = d;
857
  idata_end = &d->next;
858
 
859
  max_opno = -1;
860
  num_dups = 0;
861
  memset (d->operand, 0, sizeof (d->operand));
862
 
863
  for (i = 0; i < XVECLEN (insn, 1); i++)
864
    scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
865
 
866
  d->n_operands = max_opno + 1;
867
  d->n_dups = num_dups;
868
 
869
#ifndef USE_MD_CONSTRAINTS
870
  check_constraint_len ();
871
#endif
872
  validate_insn_operands (d);
873
  validate_insn_alternatives (d);
874
  place_operands (d);
875
  process_template (d, XTMPL (insn, 3));
876
}
877
 
878
/* Look at a define_peephole just read.  Assign its code number.
879
   Record on idata the template and the number of arguments.
880
   If the insn has a hairy output action, output it now.  */
881
 
882
static void
883
gen_peephole (rtx peep, int lineno)
884
{
885
  struct data *d = XNEW (struct data);
886
  int i;
887
 
888
  d->code_number = next_code_number;
889
  d->index_number = next_index_number;
890
  d->filename = read_rtx_filename;
891
  d->lineno = lineno;
892
  d->name = 0;
893
 
894
  /* Build up the list in the same order as the insns are seen
895
     in the machine description.  */
896
  d->next = 0;
897
  *idata_end = d;
898
  idata_end = &d->next;
899
 
900
  max_opno = -1;
901
  num_dups = 0;
902
  memset (d->operand, 0, sizeof (d->operand));
903
 
904
  /* Get the number of operands by scanning all the patterns of the
905
     peephole optimizer.  But ignore all the rest of the information
906
     thus obtained.  */
907
  for (i = 0; i < XVECLEN (peep, 0); i++)
908
    scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
909
 
910
  d->n_operands = max_opno + 1;
911
  d->n_dups = 0;
912
 
913
  validate_insn_alternatives (d);
914
  place_operands (d);
915
  process_template (d, XTMPL (peep, 2));
916
}
917
 
918
/* Process a define_expand just read.  Assign its code number,
919
   only for the purposes of `insn_gen_function'.  */
920
 
921
static void
922
gen_expand (rtx insn, int lineno)
923
{
924
  struct data *d = XNEW (struct data);
925
  int i;
926
 
927
  d->code_number = next_code_number;
928
  d->index_number = next_index_number;
929
  d->filename = read_rtx_filename;
930
  d->lineno = lineno;
931
  if (XSTR (insn, 0)[0])
932
    d->name = XSTR (insn, 0);
933
  else
934
    d->name = 0;
935
 
936
  /* Build up the list in the same order as the insns are seen
937
     in the machine description.  */
938
  d->next = 0;
939
  *idata_end = d;
940
  idata_end = &d->next;
941
 
942
  max_opno = -1;
943
  num_dups = 0;
944
  memset (d->operand, 0, sizeof (d->operand));
945
 
946
  /* Scan the operands to get the specified predicates and modes,
947
     since expand_binop needs to know them.  */
948
 
949
  if (XVEC (insn, 1))
950
    for (i = 0; i < XVECLEN (insn, 1); i++)
951
      scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
952
 
953
  d->n_operands = max_opno + 1;
954
  d->n_dups = num_dups;
955
  d->template = 0;
956
  d->output_format = INSN_OUTPUT_FORMAT_NONE;
957
 
958
  validate_insn_alternatives (d);
959
  place_operands (d);
960
}
961
 
962
/* Process a define_split just read.  Assign its code number,
963
   only for reasons of consistency and to simplify genrecog.  */
964
 
965
static void
966
gen_split (rtx split, int lineno)
967
{
968
  struct data *d = XNEW (struct data);
969
  int i;
970
 
971
  d->code_number = next_code_number;
972
  d->index_number = next_index_number;
973
  d->filename = read_rtx_filename;
974
  d->lineno = lineno;
975
  d->name = 0;
976
 
977
  /* Build up the list in the same order as the insns are seen
978
     in the machine description.  */
979
  d->next = 0;
980
  *idata_end = d;
981
  idata_end = &d->next;
982
 
983
  max_opno = -1;
984
  num_dups = 0;
985
  memset (d->operand, 0, sizeof (d->operand));
986
 
987
  /* Get the number of operands by scanning all the patterns of the
988
     split patterns.  But ignore all the rest of the information thus
989
     obtained.  */
990
  for (i = 0; i < XVECLEN (split, 0); i++)
991
    scan_operands (d, XVECEXP (split, 0, i), 0, 0);
992
 
993
  d->n_operands = max_opno + 1;
994
  d->n_dups = 0;
995
  d->n_alternatives = 0;
996
  d->template = 0;
997
  d->output_format = INSN_OUTPUT_FORMAT_NONE;
998
 
999
  place_operands (d);
1000
}
1001
 
1002
extern int main (int, char **);
1003
 
1004
int
1005
main (int argc, char **argv)
1006
{
1007
  rtx desc;
1008
 
1009
  progname = "genoutput";
1010
 
1011
  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
1012
    return (FATAL_EXIT_CODE);
1013
 
1014
  output_prologue ();
1015
  next_code_number = 0;
1016
  next_index_number = 0;
1017
 
1018
  /* Read the machine description.  */
1019
 
1020
  while (1)
1021
    {
1022
      int line_no;
1023
 
1024
      desc = read_md_rtx (&line_no, &next_code_number);
1025
      if (desc == NULL)
1026
        break;
1027
 
1028
      switch (GET_CODE (desc))
1029
        {
1030
        case DEFINE_INSN:
1031
          gen_insn (desc, line_no);
1032
          break;
1033
 
1034
        case DEFINE_PEEPHOLE:
1035
          gen_peephole (desc, line_no);
1036
          break;
1037
 
1038
        case DEFINE_EXPAND:
1039
          gen_expand (desc, line_no);
1040
          break;
1041
 
1042
        case DEFINE_SPLIT:
1043
        case DEFINE_PEEPHOLE2:
1044
          gen_split (desc, line_no);
1045
          break;
1046
 
1047
#ifdef USE_MD_CONSTRAINTS
1048
        case DEFINE_CONSTRAINT:
1049
        case DEFINE_REGISTER_CONSTRAINT:
1050
        case DEFINE_ADDRESS_CONSTRAINT:
1051
        case DEFINE_MEMORY_CONSTRAINT:
1052
          note_constraint (desc, line_no);
1053
          break;
1054
#endif
1055
 
1056
        default:
1057
          break;
1058
        }
1059
      next_index_number++;
1060
    }
1061
 
1062
  printf("\n\n");
1063
  output_operand_data ();
1064
  output_insn_data ();
1065
  output_get_insn_name ();
1066
 
1067
  fflush (stdout);
1068
  return (ferror (stdout) != 0 || have_error
1069
        ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1070
}
1071
 
1072
/* Return the number of occurrences of character C in string S or
1073
   -1 if S is the null string.  */
1074
 
1075
static int
1076
n_occurrences (int c, const char *s)
1077
{
1078
  int n = 0;
1079
 
1080
  if (s == 0 || *s == '\0')
1081
    return -1;
1082
 
1083
  while (*s)
1084
    n += (*s++ == c);
1085
 
1086
  return n;
1087
}
1088
 
1089
/* Remove whitespace in `s' by moving up characters until the end.
1090
   Return a new string.  */
1091
 
1092
static const char *
1093
strip_whitespace (const char *s)
1094
{
1095
  char *p, *q;
1096
  char ch;
1097
 
1098
  if (s == 0)
1099
    return 0;
1100
 
1101
  p = q = XNEWVEC (char, strlen (s) + 1);
1102
  while ((ch = *s++) != '\0')
1103
    if (! ISSPACE (ch))
1104
      *p++ = ch;
1105
 
1106
  *p = '\0';
1107
  return q;
1108
}
1109
 
1110
#ifdef USE_MD_CONSTRAINTS
1111
 
1112
/* Record just enough information about a constraint to allow checking
1113
   of operand constraint strings above, in validate_insn_alternatives.
1114
   Does not validate most properties of the constraint itself; does
1115
   enforce no duplicate names, no overlap with MI constraints, and no
1116
   prefixes.  EXP is the define_*constraint form, LINENO the line number
1117
   reported by the reader.  */
1118
static void
1119
note_constraint (rtx exp, int lineno)
1120
{
1121
  const char *name = XSTR (exp, 0);
1122
  unsigned int namelen = strlen (name);
1123
  struct constraint_data **iter, **slot, *new;
1124
 
1125
  if (strchr (indep_constraints, name[0]))
1126
    {
1127
      if (name[1] == '\0')
1128
        message_with_line (lineno, "constraint letter '%s' cannot be "
1129
                           "redefined by the machine description", name);
1130
      else
1131
        message_with_line (lineno, "constraint name '%s' cannot be defined by "
1132
                           "the machine description, as it begins with '%c'",
1133
                           name, name[0]);
1134
      have_error = 1;
1135
      return;
1136
    }
1137
 
1138
  slot = &constraints_by_letter_table[(unsigned int)name[0]];
1139
  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
1140
    {
1141
      /* This causes slot to end up pointing to the
1142
         next_this_letter field of the last constraint with a name
1143
         of equal or greater length than the new constraint; hence
1144
         the new constraint will be inserted after all previous
1145
         constraints with names of the same length.  */
1146
      if ((*iter)->namelen >= namelen)
1147
        slot = iter;
1148
 
1149
      if (!strcmp ((*iter)->name, name))
1150
        {
1151
          message_with_line (lineno, "redefinition of constraint '%s'", name);
1152
          message_with_line ((*iter)->lineno, "previous definition is here");
1153
          have_error = 1;
1154
          return;
1155
        }
1156
      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
1157
        {
1158
          message_with_line (lineno, "defining constraint '%s' here", name);
1159
          message_with_line ((*iter)->lineno, "renders constraint '%s' "
1160
                             "(defined here) a prefix", (*iter)->name);
1161
          have_error = 1;
1162
          return;
1163
        }
1164
      else if (!strncmp ((*iter)->name, name, namelen))
1165
        {
1166
          message_with_line (lineno, "constraint '%s' is a prefix", name);
1167
          message_with_line ((*iter)->lineno, "of constraint '%s' "
1168
                             "(defined here)", (*iter)->name);
1169
          have_error = 1;
1170
          return;
1171
        }
1172
    }
1173
  new = xmalloc (sizeof (struct constraint_data) + namelen);
1174
  strcpy ((char *)new + offsetof(struct constraint_data, name), name);
1175
  new->namelen = namelen;
1176
  new->lineno = lineno;
1177
  new->next_this_letter = *slot;
1178
  *slot = new;
1179
}
1180
 
1181
/* Return the length of the constraint name beginning at position S
1182
   of an operand constraint string, or issue an error message if there
1183
   is no such constraint.  Does not expect to be called for generic
1184
   constraints.  */
1185
static int
1186
mdep_constraint_len (const char *s, int lineno, int opno)
1187
{
1188
  struct constraint_data *p;
1189
 
1190
  p = constraints_by_letter_table[(unsigned int)s[0]];
1191
 
1192
  if (p)
1193
    for (; p; p = p->next_this_letter)
1194
      if (!strncmp (s, p->name, p->namelen))
1195
        return p->namelen;
1196
 
1197
  message_with_line (lineno,
1198
                     "error: undefined machine-specific constraint "
1199
                     "at this point: \"%s\"", s);
1200
  message_with_line (lineno, "note:  in operand %d", opno);
1201
  have_error = 1;
1202
  return 1; /* safe */
1203
}
1204
 
1205
#else
1206
/* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1207
   tampered with.  This isn't bullet-proof, but it should catch
1208
   most genuine mistakes.  */
1209
static void
1210
check_constraint_len (void)
1211
{
1212
  const char *p;
1213
  int d;
1214
 
1215
  for (p = ",#*+=&%!1234567890"; *p; p++)
1216
    for (d = -9; d < 9; d++)
1217
      gcc_assert (constraint_len (p, d) == d);
1218
}
1219
 
1220
static int
1221
constraint_len (const char *p, int genoutput_default_constraint_len)
1222
{
1223
  /* Check that we still match defaults.h .  First we do a generation-time
1224
     check that fails if the value is not the expected one...  */
1225
  gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
1226
  /* And now a compile-time check that should give a diagnostic if the
1227
     definition doesn't exactly match.  */
1228
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1229
  /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1230
     being used.  */
1231
#undef DEFAULT_CONSTRAINT_LEN
1232
#define DEFAULT_CONSTRAINT_LEN(C,STR) \
1233
  ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1234
  return CONSTRAINT_LEN (*p, p);
1235
  /* And set it back.  */
1236
#undef DEFAULT_CONSTRAINT_LEN
1237
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1238
}
1239
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.