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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [genoutput.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* 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, 2008 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_code;
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_code;
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_code)
660
{
661
  const char *cp;
662
  int i;
663
 
664
  /* Templates starting with * contain straight code to be run.  */
665
  if (template_code[0] == '*')
666
    {
667
      d->template_code = 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_code);
675
      puts (template_code + 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_code[0] == '@')
682
    {
683
      d->template_code = 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_code[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_code = template_code;
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
static void
835
validate_optab_operands (struct data *d)
836
{
837
  if (!d->name || d->name[0] == '\0' || d->name[0] == '*')
838
    return;
839
 
840
  /* Miscellaneous tests.  */
841
  if (strncmp (d->name, "cstore", 6) == 0
842
      && d->name[strlen (d->name) - 1] == '4'
843
      && d->operand[0].mode == VOIDmode)
844
    {
845
      message_with_line (d->lineno, "missing mode for operand 0 of cstore");
846
      have_error = 1;
847
    }
848
}
849
 
850
/* Look at a define_insn just read.  Assign its code number.  Record
851
   on idata the template and the number of arguments.  If the insn has
852
   a hairy output action, output a function for now.  */
853
 
854
static void
855
gen_insn (rtx insn, int lineno)
856
{
857
  struct data *d = XNEW (struct data);
858
  int i;
859
 
860
  d->code_number = next_code_number;
861
  d->index_number = next_index_number;
862
  d->filename = read_rtx_filename;
863
  d->lineno = lineno;
864
  if (XSTR (insn, 0)[0])
865
    d->name = XSTR (insn, 0);
866
  else
867
    d->name = 0;
868
 
869
  /* Build up the list in the same order as the insns are seen
870
     in the machine description.  */
871
  d->next = 0;
872
  *idata_end = d;
873
  idata_end = &d->next;
874
 
875
  max_opno = -1;
876
  num_dups = 0;
877
  memset (d->operand, 0, sizeof (d->operand));
878
 
879
  for (i = 0; i < XVECLEN (insn, 1); i++)
880
    scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
881
 
882
  d->n_operands = max_opno + 1;
883
  d->n_dups = num_dups;
884
 
885
#ifndef USE_MD_CONSTRAINTS
886
  check_constraint_len ();
887
#endif
888
  validate_insn_operands (d);
889
  validate_insn_alternatives (d);
890
  validate_optab_operands (d);
891
  place_operands (d);
892
  process_template (d, XTMPL (insn, 3));
893
}
894
 
895
/* Look at a define_peephole just read.  Assign its code number.
896
   Record on idata the template and the number of arguments.
897
   If the insn has a hairy output action, output it now.  */
898
 
899
static void
900
gen_peephole (rtx peep, int lineno)
901
{
902
  struct data *d = XNEW (struct data);
903
  int i;
904
 
905
  d->code_number = next_code_number;
906
  d->index_number = next_index_number;
907
  d->filename = read_rtx_filename;
908
  d->lineno = lineno;
909
  d->name = 0;
910
 
911
  /* Build up the list in the same order as the insns are seen
912
     in the machine description.  */
913
  d->next = 0;
914
  *idata_end = d;
915
  idata_end = &d->next;
916
 
917
  max_opno = -1;
918
  num_dups = 0;
919
  memset (d->operand, 0, sizeof (d->operand));
920
 
921
  /* Get the number of operands by scanning all the patterns of the
922
     peephole optimizer.  But ignore all the rest of the information
923
     thus obtained.  */
924
  for (i = 0; i < XVECLEN (peep, 0); i++)
925
    scan_operands (d, XVECEXP (peep, 0, i), 0, 0);
926
 
927
  d->n_operands = max_opno + 1;
928
  d->n_dups = 0;
929
 
930
  validate_insn_alternatives (d);
931
  place_operands (d);
932
  process_template (d, XTMPL (peep, 2));
933
}
934
 
935
/* Process a define_expand just read.  Assign its code number,
936
   only for the purposes of `insn_gen_function'.  */
937
 
938
static void
939
gen_expand (rtx insn, int lineno)
940
{
941
  struct data *d = XNEW (struct data);
942
  int i;
943
 
944
  d->code_number = next_code_number;
945
  d->index_number = next_index_number;
946
  d->filename = read_rtx_filename;
947
  d->lineno = lineno;
948
  if (XSTR (insn, 0)[0])
949
    d->name = XSTR (insn, 0);
950
  else
951
    d->name = 0;
952
 
953
  /* Build up the list in the same order as the insns are seen
954
     in the machine description.  */
955
  d->next = 0;
956
  *idata_end = d;
957
  idata_end = &d->next;
958
 
959
  max_opno = -1;
960
  num_dups = 0;
961
  memset (d->operand, 0, sizeof (d->operand));
962
 
963
  /* Scan the operands to get the specified predicates and modes,
964
     since expand_binop needs to know them.  */
965
 
966
  if (XVEC (insn, 1))
967
    for (i = 0; i < XVECLEN (insn, 1); i++)
968
      scan_operands (d, XVECEXP (insn, 1, i), 0, 0);
969
 
970
  d->n_operands = max_opno + 1;
971
  d->n_dups = num_dups;
972
  d->template_code = 0;
973
  d->output_format = INSN_OUTPUT_FORMAT_NONE;
974
 
975
  validate_insn_alternatives (d);
976
  validate_optab_operands (d);
977
  place_operands (d);
978
}
979
 
980
/* Process a define_split just read.  Assign its code number,
981
   only for reasons of consistency and to simplify genrecog.  */
982
 
983
static void
984
gen_split (rtx split, int lineno)
985
{
986
  struct data *d = XNEW (struct data);
987
  int i;
988
 
989
  d->code_number = next_code_number;
990
  d->index_number = next_index_number;
991
  d->filename = read_rtx_filename;
992
  d->lineno = lineno;
993
  d->name = 0;
994
 
995
  /* Build up the list in the same order as the insns are seen
996
     in the machine description.  */
997
  d->next = 0;
998
  *idata_end = d;
999
  idata_end = &d->next;
1000
 
1001
  max_opno = -1;
1002
  num_dups = 0;
1003
  memset (d->operand, 0, sizeof (d->operand));
1004
 
1005
  /* Get the number of operands by scanning all the patterns of the
1006
     split patterns.  But ignore all the rest of the information thus
1007
     obtained.  */
1008
  for (i = 0; i < XVECLEN (split, 0); i++)
1009
    scan_operands (d, XVECEXP (split, 0, i), 0, 0);
1010
 
1011
  d->n_operands = max_opno + 1;
1012
  d->n_dups = 0;
1013
  d->n_alternatives = 0;
1014
  d->template_code = 0;
1015
  d->output_format = INSN_OUTPUT_FORMAT_NONE;
1016
 
1017
  place_operands (d);
1018
}
1019
 
1020
extern int main (int, char **);
1021
 
1022
int
1023
main (int argc, char **argv)
1024
{
1025
  rtx desc;
1026
 
1027
  progname = "genoutput";
1028
 
1029
  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
1030
    return (FATAL_EXIT_CODE);
1031
 
1032
  output_prologue ();
1033
  next_code_number = 0;
1034
  next_index_number = 0;
1035
 
1036
  /* Read the machine description.  */
1037
 
1038
  while (1)
1039
    {
1040
      int line_no;
1041
 
1042
      desc = read_md_rtx (&line_no, &next_code_number);
1043
      if (desc == NULL)
1044
        break;
1045
 
1046
      switch (GET_CODE (desc))
1047
        {
1048
        case DEFINE_INSN:
1049
          gen_insn (desc, line_no);
1050
          break;
1051
 
1052
        case DEFINE_PEEPHOLE:
1053
          gen_peephole (desc, line_no);
1054
          break;
1055
 
1056
        case DEFINE_EXPAND:
1057
          gen_expand (desc, line_no);
1058
          break;
1059
 
1060
        case DEFINE_SPLIT:
1061
        case DEFINE_PEEPHOLE2:
1062
          gen_split (desc, line_no);
1063
          break;
1064
 
1065
#ifdef USE_MD_CONSTRAINTS
1066
        case DEFINE_CONSTRAINT:
1067
        case DEFINE_REGISTER_CONSTRAINT:
1068
        case DEFINE_ADDRESS_CONSTRAINT:
1069
        case DEFINE_MEMORY_CONSTRAINT:
1070
          note_constraint (desc, line_no);
1071
          break;
1072
#endif
1073
 
1074
        default:
1075
          break;
1076
        }
1077
      next_index_number++;
1078
    }
1079
 
1080
  printf("\n\n");
1081
  output_operand_data ();
1082
  output_insn_data ();
1083
  output_get_insn_name ();
1084
 
1085
  fflush (stdout);
1086
  return (ferror (stdout) != 0 || have_error
1087
        ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
1088
}
1089
 
1090
/* Return the number of occurrences of character C in string S or
1091
   -1 if S is the null string.  */
1092
 
1093
static int
1094
n_occurrences (int c, const char *s)
1095
{
1096
  int n = 0;
1097
 
1098
  if (s == 0 || *s == '\0')
1099
    return -1;
1100
 
1101
  while (*s)
1102
    n += (*s++ == c);
1103
 
1104
  return n;
1105
}
1106
 
1107
/* Remove whitespace in `s' by moving up characters until the end.
1108
   Return a new string.  */
1109
 
1110
static const char *
1111
strip_whitespace (const char *s)
1112
{
1113
  char *p, *q;
1114
  char ch;
1115
 
1116
  if (s == 0)
1117
    return 0;
1118
 
1119
  p = q = XNEWVEC (char, strlen (s) + 1);
1120
  while ((ch = *s++) != '\0')
1121
    if (! ISSPACE (ch))
1122
      *p++ = ch;
1123
 
1124
  *p = '\0';
1125
  return q;
1126
}
1127
 
1128
#ifdef USE_MD_CONSTRAINTS
1129
 
1130
/* Record just enough information about a constraint to allow checking
1131
   of operand constraint strings above, in validate_insn_alternatives.
1132
   Does not validate most properties of the constraint itself; does
1133
   enforce no duplicate names, no overlap with MI constraints, and no
1134
   prefixes.  EXP is the define_*constraint form, LINENO the line number
1135
   reported by the reader.  */
1136
static void
1137
note_constraint (rtx exp, int lineno)
1138
{
1139
  const char *name = XSTR (exp, 0);
1140
  unsigned int namelen = strlen (name);
1141
  struct constraint_data **iter, **slot, *new_cdata;
1142
 
1143
  /* The 'm' constraint is special here since that constraint letter
1144
     can be overridden by the back end by defining the
1145
     TARGET_MEM_CONSTRAINT macro.  */
1146
  if (strchr (indep_constraints, name[0]) && name[0] != 'm')
1147
    {
1148
      if (name[1] == '\0')
1149
        message_with_line (lineno, "constraint letter '%s' cannot be "
1150
                           "redefined by the machine description", name);
1151
      else
1152
        message_with_line (lineno, "constraint name '%s' cannot be defined by "
1153
                           "the machine description, as it begins with '%c'",
1154
                           name, name[0]);
1155
      have_error = 1;
1156
      return;
1157
    }
1158
 
1159
  slot = &constraints_by_letter_table[(unsigned int)name[0]];
1160
  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
1161
    {
1162
      /* This causes slot to end up pointing to the
1163
         next_this_letter field of the last constraint with a name
1164
         of equal or greater length than the new constraint; hence
1165
         the new constraint will be inserted after all previous
1166
         constraints with names of the same length.  */
1167
      if ((*iter)->namelen >= namelen)
1168
        slot = iter;
1169
 
1170
      if (!strcmp ((*iter)->name, name))
1171
        {
1172
          message_with_line (lineno, "redefinition of constraint '%s'", name);
1173
          message_with_line ((*iter)->lineno, "previous definition is here");
1174
          have_error = 1;
1175
          return;
1176
        }
1177
      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
1178
        {
1179
          message_with_line (lineno, "defining constraint '%s' here", name);
1180
          message_with_line ((*iter)->lineno, "renders constraint '%s' "
1181
                             "(defined here) a prefix", (*iter)->name);
1182
          have_error = 1;
1183
          return;
1184
        }
1185
      else if (!strncmp ((*iter)->name, name, namelen))
1186
        {
1187
          message_with_line (lineno, "constraint '%s' is a prefix", name);
1188
          message_with_line ((*iter)->lineno, "of constraint '%s' "
1189
                             "(defined here)", (*iter)->name);
1190
          have_error = 1;
1191
          return;
1192
        }
1193
    }
1194
  new_cdata = XNEWVAR (struct constraint_data, sizeof (struct constraint_data) + namelen);
1195
  strcpy ((char *)new_cdata + offsetof(struct constraint_data, name), name);
1196
  new_cdata->namelen = namelen;
1197
  new_cdata->lineno = lineno;
1198
  new_cdata->next_this_letter = *slot;
1199
  *slot = new_cdata;
1200
}
1201
 
1202
/* Return the length of the constraint name beginning at position S
1203
   of an operand constraint string, or issue an error message if there
1204
   is no such constraint.  Does not expect to be called for generic
1205
   constraints.  */
1206
static int
1207
mdep_constraint_len (const char *s, int lineno, int opno)
1208
{
1209
  struct constraint_data *p;
1210
 
1211
  p = constraints_by_letter_table[(unsigned int)s[0]];
1212
 
1213
  if (p)
1214
    for (; p; p = p->next_this_letter)
1215
      if (!strncmp (s, p->name, p->namelen))
1216
        return p->namelen;
1217
 
1218
  message_with_line (lineno,
1219
                     "error: undefined machine-specific constraint "
1220
                     "at this point: \"%s\"", s);
1221
  message_with_line (lineno, "note:  in operand %d", opno);
1222
  have_error = 1;
1223
  return 1; /* safe */
1224
}
1225
 
1226
#else
1227
/* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
1228
   tampered with.  This isn't bullet-proof, but it should catch
1229
   most genuine mistakes.  */
1230
static void
1231
check_constraint_len (void)
1232
{
1233
  const char *p;
1234
  int d;
1235
 
1236
  for (p = ",#*+=&%!1234567890"; *p; p++)
1237
    for (d = -9; d < 9; d++)
1238
      gcc_assert (constraint_len (p, d) == d);
1239
}
1240
 
1241
static int
1242
constraint_len (const char *p, int genoutput_default_constraint_len)
1243
{
1244
  /* Check that we still match defaults.h .  First we do a generation-time
1245
     check that fails if the value is not the expected one...  */
1246
  gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
1247
  /* And now a compile-time check that should give a diagnostic if the
1248
     definition doesn't exactly match.  */
1249
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1250
  /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
1251
     being used.  */
1252
#undef DEFAULT_CONSTRAINT_LEN
1253
#define DEFAULT_CONSTRAINT_LEN(C,STR) \
1254
  ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
1255
  return CONSTRAINT_LEN (*p, p);
1256
  /* And set it back.  */
1257
#undef DEFAULT_CONSTRAINT_LEN
1258
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
1259
}
1260
#endif

powered by: WebSVN 2.1.0

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