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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [genpreds.c] - Blame information for rev 859

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

Line No. Rev Author Line
1 280 jeremybenn
/* Generate from machine description:
2
   - prototype declarations for operand predicates (tm-preds.h)
3
   - function definitions of operand predicates, if defined new-style
4
     (insn-preds.c)
5
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
6
   Free Software Foundation, Inc.
7
 
8
This file is part of GCC.
9
 
10
GCC is free software; you can redistribute it and/or modify
11
it under the terms of the GNU General Public License as published by
12
the Free Software Foundation; either version 3, or (at your option)
13
any later version.
14
 
15
GCC is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
GNU General Public License for more details.
19
 
20
You should have received a copy of the GNU General Public License
21
along with GCC; see the file COPYING3.  If not see
22
<http://www.gnu.org/licenses/>.  */
23
 
24
#include "bconfig.h"
25
#include "system.h"
26
#include "coretypes.h"
27
#include "tm.h"
28
#include "rtl.h"
29
#include "errors.h"
30
#include "obstack.h"
31
#include "gensupport.h"
32
 
33
/* Given a predicate expression EXP, from form NAME at line LINENO,
34
   verify that it does not contain any RTL constructs which are not
35
   valid in predicate definitions.  Returns true if EXP is
36
   INvalid; issues error messages, caller need not.  */
37
static bool
38
validate_exp (rtx exp, const char *name, int lineno)
39
{
40
  if (exp == 0)
41
    {
42
      message_with_line (lineno, "%s: must give a predicate expression", name);
43
      return true;
44
    }
45
 
46
  switch (GET_CODE (exp))
47
    {
48
      /* Ternary, binary, unary expressions: recurse into subexpressions.  */
49
    case IF_THEN_ELSE:
50
      if (validate_exp (XEXP (exp, 2), name, lineno))
51
        return true;
52
      /* else fall through */
53
    case AND:
54
    case IOR:
55
      if (validate_exp (XEXP (exp, 1), name, lineno))
56
        return true;
57
      /* else fall through */
58
    case NOT:
59
      return validate_exp (XEXP (exp, 0), name, lineno);
60
 
61
      /* MATCH_CODE might have a syntax error in its path expression.  */
62
    case MATCH_CODE:
63
      {
64
        const char *p;
65
        for (p = XSTR (exp, 1); *p; p++)
66
          {
67
            if (!ISDIGIT (*p) && !ISLOWER (*p))
68
              {
69
                message_with_line (lineno, "%s: invalid character in path "
70
                                   "string '%s'", name, XSTR (exp, 1));
71
                have_error = 1;
72
                return true;
73
              }
74
          }
75
      }
76
      /* fall through */
77
 
78
      /* These need no special checking.  */
79
    case MATCH_OPERAND:
80
    case MATCH_TEST:
81
      return false;
82
 
83
    default:
84
      message_with_line (lineno,
85
                         "%s: cannot use '%s' in a predicate expression",
86
                         name, GET_RTX_NAME (GET_CODE (exp)));
87
      have_error = 1;
88
      return true;
89
    }
90
}
91
 
92
/* Predicates are defined with (define_predicate) or
93
   (define_special_predicate) expressions in the machine description.  */
94
static void
95
process_define_predicate (rtx defn, int lineno)
96
{
97
  struct pred_data *pred;
98
  const char *p;
99
 
100
  if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
101
    goto bad_name;
102
  for (p = XSTR (defn, 0) + 1; *p; p++)
103
    if (!ISALNUM (*p) && *p != '_')
104
      goto bad_name;
105
 
106
  if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
107
    return;
108
 
109
  pred = XCNEW (struct pred_data);
110
  pred->name = XSTR (defn, 0);
111
  pred->exp = XEXP (defn, 1);
112
  pred->c_block = XSTR (defn, 2);
113
 
114
  if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
115
    pred->special = true;
116
 
117
  add_predicate (pred);
118
  return;
119
 
120
 bad_name:
121
  message_with_line (lineno,
122
                     "%s: predicate name must be a valid C function name",
123
                     XSTR (defn, 0));
124
  have_error = 1;
125
  return;
126
}
127
 
128
/* Given a predicate, if it has an embedded C block, write the block
129
   out as a static inline subroutine, and augment the RTL test with a
130
   match_test that calls that subroutine.  For instance,
131
 
132
       (define_predicate "basereg_operand"
133
         (match_operand 0 "register_operand")
134
       {
135
         if (GET_CODE (op) == SUBREG)
136
           op = SUBREG_REG (op);
137
         return REG_POINTER (op);
138
       })
139
 
140
   becomes
141
 
142
       static inline int basereg_operand_1(rtx op, enum machine_mode mode)
143
       {
144
         if (GET_CODE (op) == SUBREG)
145
           op = SUBREG_REG (op);
146
         return REG_POINTER (op);
147
       }
148
 
149
       (define_predicate "basereg_operand"
150
         (and (match_operand 0 "register_operand")
151
              (match_test "basereg_operand_1 (op, mode)")))
152
 
153
   The only wart is that there's no way to insist on a { } string in
154
   an RTL template, so we have to handle "" strings.  */
155
 
156
 
157
static void
158
write_predicate_subfunction (struct pred_data *p)
159
{
160
  const char *match_test_str;
161
  rtx match_test_exp, and_exp;
162
 
163
  if (p->c_block[0] == '\0')
164
    return;
165
 
166
  /* Construct the function-call expression.  */
167
  obstack_grow (rtl_obstack, p->name, strlen (p->name));
168
  obstack_grow (rtl_obstack, "_1 (op, mode)",
169
                sizeof "_1 (op, mode)");
170
  match_test_str = XOBFINISH (rtl_obstack, const char *);
171
 
172
  /* Add the function-call expression to the complete expression to be
173
     evaluated.  */
174
  match_test_exp = rtx_alloc (MATCH_TEST);
175
  XSTR (match_test_exp, 0) = match_test_str;
176
 
177
  and_exp = rtx_alloc (AND);
178
  XEXP (and_exp, 0) = p->exp;
179
  XEXP (and_exp, 1) = match_test_exp;
180
 
181
  p->exp = and_exp;
182
 
183
  printf ("static inline int\n"
184
          "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
185
          p->name);
186
  print_rtx_ptr_loc (p->c_block);
187
  if (p->c_block[0] == '{')
188
    fputs (p->c_block, stdout);
189
  else
190
    printf ("{\n  %s\n}", p->c_block);
191
  fputs ("\n\n", stdout);
192
}
193
 
194
/* Given a predicate expression EXP, from form NAME, determine whether
195
   it refers to the variable given as VAR.  */
196
static bool
197
needs_variable (rtx exp, const char *var)
198
{
199
  switch (GET_CODE (exp))
200
    {
201
      /* Ternary, binary, unary expressions need a variable if
202
         any of their subexpressions do.  */
203
    case IF_THEN_ELSE:
204
      if (needs_variable (XEXP (exp, 2), var))
205
        return true;
206
      /* else fall through */
207
    case AND:
208
    case IOR:
209
      if (needs_variable (XEXP (exp, 1), var))
210
        return true;
211
      /* else fall through */
212
    case NOT:
213
      return needs_variable (XEXP (exp, 0), var);
214
 
215
      /* MATCH_CODE uses "op", but nothing else.  */
216
    case MATCH_CODE:
217
      return !strcmp (var, "op");
218
 
219
      /* MATCH_OPERAND uses "op" and may use "mode".  */
220
    case MATCH_OPERAND:
221
      if (!strcmp (var, "op"))
222
        return true;
223
      if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
224
        return true;
225
      return false;
226
 
227
      /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
228
    case MATCH_TEST:
229
      {
230
        const char *p = XSTR (exp, 0);
231
        const char *q = strstr (p, var);
232
        if (!q)
233
          return false;
234
        if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
235
          return false;
236
        q += strlen (var);
237
        if (ISALNUM (q[0]) || q[0] == '_')
238
          return false;
239
      }
240
      return true;
241
 
242
    default:
243
      gcc_unreachable ();
244
    }
245
}
246
 
247
/* Given an RTL expression EXP, find all subexpressions which we may
248
   assume to perform mode tests.  Normal MATCH_OPERAND does;
249
   MATCH_CODE does if it applies to the whole expression and accepts
250
   CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
251
   does not.  These combine in almost-boolean fashion - the only
252
   exception is that (not X) must be assumed not to perform a mode
253
   test, whether or not X does.
254
 
255
   The mark is the RTL /v flag, which is true for subexpressions which
256
   do *not* perform mode tests.
257
*/
258
#define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
259
static void
260
mark_mode_tests (rtx exp)
261
{
262
  switch (GET_CODE (exp))
263
    {
264
    case MATCH_OPERAND:
265
      {
266
        struct pred_data *p = lookup_predicate (XSTR (exp, 1));
267
        if (!p)
268
          error ("reference to undefined predicate '%s'", XSTR (exp, 1));
269
        else if (p->special || GET_MODE (exp) != VOIDmode)
270
          NO_MODE_TEST (exp) = 1;
271
      }
272
      break;
273
 
274
    case MATCH_CODE:
275
      if (XSTR (exp, 1)[0] != '\0'
276
          || (!strstr (XSTR (exp, 0), "const_int")
277
              && !strstr (XSTR (exp, 0), "const_double")))
278
        NO_MODE_TEST (exp) = 1;
279
      break;
280
 
281
    case MATCH_TEST:
282
    case NOT:
283
      NO_MODE_TEST (exp) = 1;
284
      break;
285
 
286
    case AND:
287
      mark_mode_tests (XEXP (exp, 0));
288
      mark_mode_tests (XEXP (exp, 1));
289
 
290
      NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
291
                            && NO_MODE_TEST (XEXP (exp, 1)));
292
      break;
293
 
294
    case IOR:
295
      mark_mode_tests (XEXP (exp, 0));
296
      mark_mode_tests (XEXP (exp, 1));
297
 
298
      NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
299
                            || NO_MODE_TEST (XEXP (exp, 1)));
300
      break;
301
 
302
    case IF_THEN_ELSE:
303
      /* A ? B : C does a mode test if (one of A and B) does a mode
304
         test, and C does too.  */
305
      mark_mode_tests (XEXP (exp, 0));
306
      mark_mode_tests (XEXP (exp, 1));
307
      mark_mode_tests (XEXP (exp, 2));
308
 
309
      NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
310
                             && NO_MODE_TEST (XEXP (exp, 1)))
311
                            || NO_MODE_TEST (XEXP (exp, 2)));
312
      break;
313
 
314
    default:
315
      gcc_unreachable ();
316
    }
317
}
318
 
319
/* Determine whether the expression EXP is a MATCH_CODE that should
320
   be written as a switch statement.  */
321
static bool
322
generate_switch_p (rtx exp)
323
{
324
  return GET_CODE (exp) == MATCH_CODE
325
         && strchr (XSTR (exp, 0), ',');
326
}
327
 
328
/* Given a predicate, work out where in its RTL expression to add
329
   tests for proper modes.  Special predicates do not get any such
330
   tests.  We try to avoid adding tests when we don't have to; in
331
   particular, other normal predicates can be counted on to do it for
332
   us.  */
333
 
334
static void
335
add_mode_tests (struct pred_data *p)
336
{
337
  rtx match_test_exp, and_exp;
338
  rtx *pos;
339
 
340
  /* Don't touch special predicates.  */
341
  if (p->special)
342
    return;
343
 
344
  mark_mode_tests (p->exp);
345
 
346
  /* If the whole expression already tests the mode, we're done.  */
347
  if (!NO_MODE_TEST (p->exp))
348
    return;
349
 
350
  match_test_exp = rtx_alloc (MATCH_TEST);
351
  XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
352
  and_exp = rtx_alloc (AND);
353
  XEXP (and_exp, 1) = match_test_exp;
354
 
355
  /* It is always correct to rewrite p->exp as
356
 
357
        (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
358
 
359
     but there are a couple forms where we can do better.  If the
360
     top-level pattern is an IOR, and one of the two branches does test
361
     the mode, we can wrap just the branch that doesn't.  Likewise, if
362
     we have an IF_THEN_ELSE, and one side of it tests the mode, we can
363
     wrap just the side that doesn't.  And, of course, we can repeat this
364
     descent as many times as it works.  */
365
 
366
  pos = &p->exp;
367
  for (;;)
368
    {
369
      rtx subexp = *pos;
370
 
371
      switch (GET_CODE (subexp))
372
        {
373
        case AND:
374
          /* The switch code generation in write_predicate_stmts prefers
375
             rtx code tests to be at the top of the expression tree.  So
376
             push this AND down into the second operand of an existing
377
             AND expression.  */
378
          if (generate_switch_p (XEXP (subexp, 0)))
379
            pos = &XEXP (subexp, 1);
380
          goto break_loop;
381
 
382
        case IOR:
383
          {
384
            int test0 = NO_MODE_TEST (XEXP (subexp, 0));
385
            int test1 = NO_MODE_TEST (XEXP (subexp, 1));
386
 
387
            gcc_assert (test0 || test1);
388
 
389
            if (test0 && test1)
390
              goto break_loop;
391
            pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
392
          }
393
          break;
394
 
395
        case IF_THEN_ELSE:
396
          {
397
            int test0 = NO_MODE_TEST (XEXP (subexp, 0));
398
            int test1 = NO_MODE_TEST (XEXP (subexp, 1));
399
            int test2 = NO_MODE_TEST (XEXP (subexp, 2));
400
 
401
            gcc_assert ((test0 && test1) || test2);
402
 
403
            if (test0 && test1 && test2)
404
              goto break_loop;
405
            if (test0 && test1)
406
              /* Must put it on the dependent clause, not the
407
                 controlling expression, or we change the meaning of
408
                 the test.  */
409
              pos = &XEXP (subexp, 1);
410
            else
411
              pos = &XEXP (subexp, 2);
412
          }
413
          break;
414
 
415
        default:
416
          goto break_loop;
417
        }
418
    }
419
 break_loop:
420
  XEXP (and_exp, 0) = *pos;
421
  *pos = and_exp;
422
}
423
 
424
/* PATH is a string describing a path from the root of an RTL
425
   expression to an inner subexpression to be tested.  Output
426
   code which computes the subexpression from the variable
427
   holding the root of the expression.  */
428
static void
429
write_extract_subexp (const char *path)
430
{
431
  int len = strlen (path);
432
  int i;
433
 
434
  /* We first write out the operations (XEXP or XVECEXP) in reverse
435
     order, then write "op", then the indices in forward order.  */
436
  for (i = len - 1; i >= 0; i--)
437
    {
438
      if (ISLOWER (path[i]))
439
        fputs ("XVECEXP (", stdout);
440
      else if (ISDIGIT (path[i]))
441
        fputs ("XEXP (", stdout);
442
      else
443
        gcc_unreachable ();
444
    }
445
 
446
  fputs ("op", stdout);
447
 
448
  for (i = 0; i < len; i++)
449
    {
450
      if (ISLOWER (path[i]))
451
        printf (", 0, %d)", path[i] - 'a');
452
      else if (ISDIGIT (path[i]))
453
        printf (", %d)", path[i] - '0');
454
      else
455
        gcc_unreachable ();
456
    }
457
}
458
 
459
/* CODES is a list of RTX codes.  Write out an expression which
460
   determines whether the operand has one of those codes.  */
461
static void
462
write_match_code (const char *path, const char *codes)
463
{
464
  const char *code;
465
 
466
  while ((code = scan_comma_elt (&codes)) != 0)
467
    {
468
      fputs ("GET_CODE (", stdout);
469
      write_extract_subexp (path);
470
      fputs (") == ", stdout);
471
      while (code < codes)
472
        {
473
          putchar (TOUPPER (*code));
474
          code++;
475
        }
476
 
477
      if (*codes == ',')
478
        fputs (" || ", stdout);
479
    }
480
}
481
 
482
/* EXP is an RTL (sub)expression for a predicate.  Recursively
483
   descend the expression and write out an equivalent C expression.  */
484
static void
485
write_predicate_expr (rtx exp)
486
{
487
  switch (GET_CODE (exp))
488
    {
489
    case AND:
490
      putchar ('(');
491
      write_predicate_expr (XEXP (exp, 0));
492
      fputs (") && (", stdout);
493
      write_predicate_expr (XEXP (exp, 1));
494
      putchar (')');
495
      break;
496
 
497
    case IOR:
498
      putchar ('(');
499
      write_predicate_expr (XEXP (exp, 0));
500
      fputs (") || (", stdout);
501
      write_predicate_expr (XEXP (exp, 1));
502
      putchar (')');
503
      break;
504
 
505
    case NOT:
506
      fputs ("!(", stdout);
507
      write_predicate_expr (XEXP (exp, 0));
508
      putchar (')');
509
      break;
510
 
511
    case IF_THEN_ELSE:
512
      putchar ('(');
513
      write_predicate_expr (XEXP (exp, 0));
514
      fputs (") ? (", stdout);
515
      write_predicate_expr (XEXP (exp, 1));
516
      fputs (") : (", stdout);
517
      write_predicate_expr (XEXP (exp, 2));
518
      putchar (')');
519
      break;
520
 
521
    case MATCH_OPERAND:
522
      if (GET_MODE (exp) == VOIDmode)
523
        printf ("%s (op, mode)", XSTR (exp, 1));
524
      else
525
        printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
526
      break;
527
 
528
    case MATCH_CODE:
529
      write_match_code (XSTR (exp, 1), XSTR (exp, 0));
530
      break;
531
 
532
    case MATCH_TEST:
533
      print_c_condition (XSTR (exp, 0));
534
      break;
535
 
536
    default:
537
      gcc_unreachable ();
538
    }
539
}
540
 
541
/* Write the MATCH_CODE expression EXP as a switch statement.  */
542
 
543
static void
544
write_match_code_switch (rtx exp)
545
{
546
  const char *codes = XSTR (exp, 0);
547
  const char *path = XSTR (exp, 1);
548
  const char *code;
549
 
550
  fputs ("  switch (GET_CODE (", stdout);
551
  write_extract_subexp (path);
552
  fputs ("))\n    {\n", stdout);
553
 
554
  while ((code = scan_comma_elt (&codes)) != 0)
555
    {
556
      fputs ("    case ", stdout);
557
      while (code < codes)
558
        {
559
          putchar (TOUPPER (*code));
560
          code++;
561
        }
562
      fputs(":\n", stdout);
563
    }
564
}
565
 
566
/* Given a predicate expression EXP, write out a sequence of stmts
567
   to evaluate it.  This is similar to write_predicate_expr but can
568
   generate efficient switch statements.  */
569
 
570
static void
571
write_predicate_stmts (rtx exp)
572
{
573
  switch (GET_CODE (exp))
574
    {
575
    case MATCH_CODE:
576
      if (generate_switch_p (exp))
577
        {
578
          write_match_code_switch (exp);
579
          puts ("      return true;\n"
580
                "    default:\n"
581
                "      break;\n"
582
                "    }\n"
583
                "  return false;");
584
          return;
585
        }
586
      break;
587
 
588
    case AND:
589
      if (generate_switch_p (XEXP (exp, 0)))
590
        {
591
          write_match_code_switch (XEXP (exp, 0));
592
          puts ("      break;\n"
593
                "    default:\n"
594
                "      return false;\n"
595
                "    }");
596
          exp = XEXP (exp, 1);
597
        }
598
      break;
599
 
600
    case IOR:
601
      if (generate_switch_p (XEXP (exp, 0)))
602
        {
603
          write_match_code_switch (XEXP (exp, 0));
604
          puts ("      return true;\n"
605
                "    default:\n"
606
                "      break;\n"
607
                "    }");
608
          exp = XEXP (exp, 1);
609
        }
610
      break;
611
 
612
    case NOT:
613
      if (generate_switch_p (XEXP (exp, 0)))
614
        {
615
          write_match_code_switch (XEXP (exp, 0));
616
          puts ("      return false;\n"
617
                "    default:\n"
618
                "      break;\n"
619
                "    }\n"
620
                "  return true;");
621
          return;
622
        }
623
      break;
624
 
625
    default:
626
      break;
627
    }
628
 
629
  fputs("  return ",stdout);
630
  write_predicate_expr (exp);
631
  fputs(";\n", stdout);
632
}
633
 
634
/* Given a predicate, write out a complete C function to compute it.  */
635
static void
636
write_one_predicate_function (struct pred_data *p)
637
{
638
  if (!p->exp)
639
    return;
640
 
641
  write_predicate_subfunction (p);
642
  add_mode_tests (p);
643
 
644
  /* A normal predicate can legitimately not look at enum machine_mode
645
     if it accepts only CONST_INTs and/or CONST_DOUBLEs.  */
646
  printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
647
          p->name);
648
  write_predicate_stmts (p->exp);
649
  fputs ("}\n\n", stdout);
650
}
651
 
652
/* Constraints fall into two categories: register constraints
653
   (define_register_constraint), and others (define_constraint,
654
   define_memory_constraint, define_address_constraint).  We
655
   work out automatically which of the various old-style macros
656
   they correspond to, and produce appropriate code.  They all
657
   go in the same hash table so we can verify that there are no
658
   duplicate names.  */
659
 
660
/* All data from one constraint definition.  */
661
struct constraint_data
662
{
663
  struct constraint_data *next_this_letter;
664
  struct constraint_data *next_textual;
665
  const char *name;
666
  const char *c_name;    /* same as .name unless mangling is necessary */
667
  size_t namelen;
668
  const char *regclass;  /* for register constraints */
669
  rtx exp;               /* for other constraints */
670
  unsigned int lineno;   /* line of definition */
671
  unsigned int is_register  : 1;
672
  unsigned int is_const_int : 1;
673
  unsigned int is_const_dbl : 1;
674
  unsigned int is_extra     : 1;
675
  unsigned int is_memory    : 1;
676
  unsigned int is_address   : 1;
677
};
678
 
679
/* Overview of all constraints beginning with a given letter.  */
680
 
681
static struct constraint_data *
682
constraints_by_letter_table[1<<CHAR_BIT];
683
 
684
/* For looking up all the constraints in the order that they appeared
685
   in the machine description.  */
686
static struct constraint_data *first_constraint;
687
static struct constraint_data **last_constraint_ptr = &first_constraint;
688
 
689
#define FOR_ALL_CONSTRAINTS(iter_) \
690
  for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
691
 
692
/* These letters, and all names beginning with them, are reserved for
693
   generic constraints.
694
   The 'm' constraint is not mentioned here since that constraint
695
   letter can be overridden by the back end by defining the
696
   TARGET_MEM_CONSTRAINT macro.  */
697
static const char generic_constraint_letters[] = "EFVXginoprs";
698
 
699
/* Machine-independent code expects that constraints with these
700
   (initial) letters will allow only (a subset of all) CONST_INTs.  */
701
 
702
static const char const_int_constraints[] = "IJKLMNOP";
703
 
704
/* Machine-independent code expects that constraints with these
705
   (initial) letters will allow only (a subset of all) CONST_DOUBLEs.  */
706
 
707
static const char const_dbl_constraints[] = "GH";
708
 
709
/* Summary data used to decide whether to output various functions and
710
   macro definitions.  */
711
static unsigned int constraint_max_namelen;
712
static bool have_register_constraints;
713
static bool have_memory_constraints;
714
static bool have_address_constraints;
715
static bool have_extra_constraints;
716
static bool have_const_int_constraints;
717
static bool have_const_dbl_constraints;
718
 
719
/* Convert NAME, which contains angle brackets and/or underscores, to
720
   a string that can be used as part of a C identifier.  The string
721
   comes from the rtl_obstack.  */
722
static const char *
723
mangle (const char *name)
724
{
725
  for (; *name; name++)
726
    switch (*name)
727
      {
728
      case '_': obstack_grow (rtl_obstack, "__", 2); break;
729
      case '<': obstack_grow (rtl_obstack, "_l", 2); break;
730
      case '>': obstack_grow (rtl_obstack, "_g", 2); break;
731
      default: obstack_1grow (rtl_obstack, *name); break;
732
      }
733
 
734
  obstack_1grow (rtl_obstack, '\0');
735
  return XOBFINISH (rtl_obstack, const char *);
736
}
737
 
738
/* Add one constraint, of any sort, to the tables.  NAME is its name;
739
   REGCLASS is the register class, if any; EXP is the expression to
740
   test, if any;  IS_MEMORY and IS_ADDRESS indicate memory and address
741
   constraints, respectively; LINENO is the line number from the MD reader.
742
   Not all combinations of arguments are valid; most importantly, REGCLASS
743
   is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
744
   meaningful for constraints with EXP.
745
 
746
   This function enforces all syntactic and semantic rules about what
747
   constraints can be defined.  */
748
 
749
static void
750
add_constraint (const char *name, const char *regclass,
751
                rtx exp, bool is_memory, bool is_address,
752
                int lineno)
753
{
754
  struct constraint_data *c, **iter, **slot;
755
  const char *p;
756
  bool need_mangled_name = false;
757
  bool is_const_int;
758
  bool is_const_dbl;
759
  size_t namelen;
760
 
761
  if (exp && validate_exp (exp, name, lineno))
762
    return;
763
 
764
  if (!ISALPHA (name[0]) && name[0] != '_')
765
    {
766
      if (name[1] == '\0')
767
        message_with_line (lineno, "constraint name '%s' is not "
768
                           "a letter or underscore", name);
769
      else
770
        message_with_line (lineno, "constraint name '%s' does not begin "
771
                           "with a letter or underscore", name);
772
      have_error = 1;
773
      return;
774
    }
775
  for (p = name; *p; p++)
776
    if (!ISALNUM (*p))
777
      {
778
        if (*p == '<' || *p == '>' || *p == '_')
779
          need_mangled_name = true;
780
        else
781
          {
782
            message_with_line (lineno,
783
                               "constraint name '%s' must be composed of "
784
                               "letters, digits, underscores, and "
785
                               "angle brackets", name);
786
            have_error = 1;
787
            return;
788
          }
789
      }
790
 
791
  if (strchr (generic_constraint_letters, name[0]))
792
    {
793
      if (name[1] == '\0')
794
        message_with_line (lineno, "constraint letter '%s' cannot be "
795
                           "redefined by the machine description", name);
796
      else
797
        message_with_line (lineno, "constraint name '%s' cannot be defined by "
798
                           "the machine description, as it begins with '%c'",
799
                           name, name[0]);
800
      have_error = 1;
801
      return;
802
    }
803
 
804
 
805
  namelen = strlen (name);
806
  slot = &constraints_by_letter_table[(unsigned int)name[0]];
807
  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
808
    {
809
      /* This causes slot to end up pointing to the
810
         next_this_letter field of the last constraint with a name
811
         of equal or greater length than the new constraint; hence
812
         the new constraint will be inserted after all previous
813
         constraints with names of the same length.  */
814
      if ((*iter)->namelen >= namelen)
815
        slot = iter;
816
 
817
      if (!strcmp ((*iter)->name, name))
818
        {
819
          message_with_line (lineno, "redefinition of constraint '%s'", name);
820
          message_with_line ((*iter)->lineno, "previous definition is here");
821
          have_error = 1;
822
          return;
823
        }
824
      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
825
        {
826
          message_with_line (lineno, "defining constraint '%s' here", name);
827
          message_with_line ((*iter)->lineno, "renders constraint '%s' "
828
                             "(defined here) a prefix", (*iter)->name);
829
          have_error = 1;
830
          return;
831
        }
832
      else if (!strncmp ((*iter)->name, name, namelen))
833
        {
834
          message_with_line (lineno, "constraint '%s' is a prefix", name);
835
          message_with_line ((*iter)->lineno, "of constraint '%s' "
836
                             "(defined here)", (*iter)->name);
837
          have_error = 1;
838
          return;
839
        }
840
    }
841
 
842
  is_const_int = strchr (const_int_constraints, name[0]) != 0;
843
  is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
844
 
845
  if (is_const_int || is_const_dbl)
846
    {
847
      enum rtx_code appropriate_code
848
        = is_const_int ? CONST_INT : CONST_DOUBLE;
849
 
850
      /* Consider relaxing this requirement in the future.  */
851
      if (regclass
852
          || GET_CODE (exp) != AND
853
          || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
854
          || strcmp (XSTR (XEXP (exp, 0), 0),
855
                     GET_RTX_NAME (appropriate_code)))
856
        {
857
          if (name[1] == '\0')
858
            message_with_line (lineno, "constraint letter '%c' is reserved "
859
                               "for %s constraints",
860
                               name[0], GET_RTX_NAME (appropriate_code));
861
          else
862
            message_with_line (lineno, "constraint names beginning with '%c' "
863
                               "(%s) are reserved for %s constraints",
864
                               name[0], name,
865
                               GET_RTX_NAME (appropriate_code));
866
 
867
          have_error = 1;
868
          return;
869
        }
870
 
871
      if (is_memory)
872
        {
873
          if (name[1] == '\0')
874
            message_with_line (lineno, "constraint letter '%c' cannot be a "
875
                               "memory constraint", name[0]);
876
          else
877
            message_with_line (lineno, "constraint name '%s' begins with '%c', "
878
                               "and therefore cannot be a memory constraint",
879
                               name, name[0]);
880
 
881
          have_error = 1;
882
          return;
883
        }
884
      else if (is_address)
885
        {
886
          if (name[1] == '\0')
887
            message_with_line (lineno, "constraint letter '%c' cannot be a "
888
                               "memory constraint", name[0]);
889
          else
890
            message_with_line (lineno, "constraint name '%s' begins with '%c', "
891
                               "and therefore cannot be a memory constraint",
892
                               name, name[0]);
893
 
894
          have_error = 1;
895
          return;
896
        }
897
    }
898
 
899
 
900
  c = XOBNEW (rtl_obstack, struct constraint_data);
901
  c->name = name;
902
  c->c_name = need_mangled_name ? mangle (name) : name;
903
  c->lineno = lineno;
904
  c->namelen = namelen;
905
  c->regclass = regclass;
906
  c->exp = exp;
907
  c->is_register = regclass != 0;
908
  c->is_const_int = is_const_int;
909
  c->is_const_dbl = is_const_dbl;
910
  c->is_extra = !(regclass || is_const_int || is_const_dbl);
911
  c->is_memory = is_memory;
912
  c->is_address = is_address;
913
 
914
  c->next_this_letter = *slot;
915
  *slot = c;
916
 
917
  /* Insert this constraint in the list of all constraints in textual
918
     order.  */
919
  c->next_textual = 0;
920
  *last_constraint_ptr = c;
921
  last_constraint_ptr = &c->next_textual;
922
 
923
  constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
924
  have_register_constraints |= c->is_register;
925
  have_const_int_constraints |= c->is_const_int;
926
  have_const_dbl_constraints |= c->is_const_dbl;
927
  have_extra_constraints |= c->is_extra;
928
  have_memory_constraints |= c->is_memory;
929
  have_address_constraints |= c->is_address;
930
}
931
 
932
/* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
933
   DEFINE_ADDRESS_CONSTRAINT expression, C.  */
934
static void
935
process_define_constraint (rtx c, int lineno)
936
{
937
  add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
938
                  GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
939
                  GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
940
                  lineno);
941
}
942
 
943
/* Process a DEFINE_REGISTER_CONSTRAINT expression, C.  */
944
static void
945
process_define_register_constraint (rtx c, int lineno)
946
{
947
  add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
948
}
949
 
950
/* Write out an enumeration with one entry per machine-specific
951
   constraint.  */
952
static void
953
write_enum_constraint_num (void)
954
{
955
  struct constraint_data *c;
956
 
957
  fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
958
  fputs ("enum constraint_num\n"
959
         "{\n"
960
         "  CONSTRAINT__UNKNOWN = 0", stdout);
961
  FOR_ALL_CONSTRAINTS (c)
962
    printf (",\n  CONSTRAINT_%s", c->c_name);
963
  puts (",\n  CONSTRAINT__LIMIT\n};\n");
964
}
965
 
966
/* Write out a function which looks at a string and determines what
967
   constraint name, if any, it begins with.  */
968
static void
969
write_lookup_constraint (void)
970
{
971
  unsigned int i;
972
  puts ("enum constraint_num\n"
973
        "lookup_constraint (const char *str)\n"
974
        "{\n"
975
        "  switch (str[0])\n"
976
        "    {");
977
 
978
  for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
979
    {
980
      struct constraint_data *c = constraints_by_letter_table[i];
981
      if (!c)
982
        continue;
983
 
984
      printf ("    case '%c':\n", i);
985
      if (c->namelen == 1)
986
        printf ("      return CONSTRAINT_%s;\n", c->c_name);
987
      else
988
        {
989
          do
990
            {
991
              printf ("      if (!strncmp (str, \"%s\", %lu))\n"
992
                      "        return CONSTRAINT_%s;\n",
993
                      c->name, (unsigned long int) c->namelen, c->c_name);
994
              c = c->next_this_letter;
995
            }
996
          while (c);
997
          puts ("      break;");
998
        }
999
    }
1000
 
1001
  puts ("    default: break;\n"
1002
        "    }\n"
1003
        "  return CONSTRAINT__UNKNOWN;\n"
1004
        "}\n");
1005
}
1006
 
1007
/* Write out a function which looks at a string and determines what
1008
   the constraint name length is.  */
1009
static void
1010
write_insn_constraint_len (void)
1011
{
1012
  unsigned int i;
1013
 
1014
  puts ("static inline size_t\n"
1015
        "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1016
        "{\n"
1017
        "  switch (fc)\n"
1018
        "    {");
1019
 
1020
  for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
1021
    {
1022
      struct constraint_data *c = constraints_by_letter_table[i];
1023
 
1024
      if (!c
1025
          || c->namelen == 1)
1026
        continue;
1027
 
1028
      /* Constraints with multiple characters should have the same
1029
         length.  */
1030
      {
1031
        struct constraint_data *c2 = c->next_this_letter;
1032
        size_t len = c->namelen;
1033
        while (c2)
1034
          {
1035
            if (c2->namelen != len)
1036
              error ("Multi-letter constraints with first letter '%c' "
1037
                     "should have same length", i);
1038
            c2 = c2->next_this_letter;
1039
          }
1040
      }
1041
 
1042
      printf ("    case '%c': return %lu;\n",
1043
              i, (unsigned long int) c->namelen);
1044
    }
1045
 
1046
  puts ("    default: break;\n"
1047
        "    }\n"
1048
        "  return 1;\n"
1049
        "}\n");
1050
}
1051
 
1052
/* Write out the function which computes the register class corresponding
1053
   to a register constraint.  */
1054
static void
1055
write_regclass_for_constraint (void)
1056
{
1057
  struct constraint_data *c;
1058
 
1059
  puts ("enum reg_class\n"
1060
        "regclass_for_constraint (enum constraint_num c)\n"
1061
        "{\n"
1062
        "  switch (c)\n"
1063
        "    {");
1064
 
1065
  FOR_ALL_CONSTRAINTS (c)
1066
    if (c->is_register)
1067
      printf ("    case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1068
 
1069
  puts ("    default: break;\n"
1070
        "    }\n"
1071
        "  return NO_REGS;\n"
1072
        "}\n");
1073
}
1074
 
1075
/* Write out the functions which compute whether a given value matches
1076
   a given non-register constraint.  */
1077
static void
1078
write_tm_constrs_h (void)
1079
{
1080
  struct constraint_data *c;
1081
 
1082
  printf ("\
1083
/* Generated automatically by the program '%s'\n\
1084
   from the machine description file '%s'.  */\n\n", progname, in_fname);
1085
 
1086
  puts ("\
1087
#ifndef GCC_TM_CONSTRS_H\n\
1088
#define GCC_TM_CONSTRS_H\n");
1089
 
1090
  FOR_ALL_CONSTRAINTS (c)
1091
    if (!c->is_register)
1092
      {
1093
        bool needs_ival = needs_variable (c->exp, "ival");
1094
        bool needs_hval = needs_variable (c->exp, "hval");
1095
        bool needs_lval = needs_variable (c->exp, "lval");
1096
        bool needs_rval = needs_variable (c->exp, "rval");
1097
        bool needs_mode = (needs_variable (c->exp, "mode")
1098
                           || needs_hval || needs_lval || needs_rval);
1099
        bool needs_op = (needs_variable (c->exp, "op")
1100
                         || needs_ival || needs_mode);
1101
 
1102
        printf ("static inline bool\n"
1103
                "satisfies_constraint_%s (rtx %s)\n"
1104
                "{\n", c->c_name,
1105
                needs_op ? "op" : "ARG_UNUSED (op)");
1106
        if (needs_mode)
1107
          puts ("  enum machine_mode mode = GET_MODE (op);");
1108
        if (needs_ival)
1109
          puts ("  HOST_WIDE_INT ival = 0;");
1110
        if (needs_hval)
1111
          puts ("  HOST_WIDE_INT hval = 0;");
1112
        if (needs_lval)
1113
          puts ("  unsigned HOST_WIDE_INT lval = 0;");
1114
        if (needs_rval)
1115
          puts ("  const REAL_VALUE_TYPE *rval = 0;");
1116
 
1117
        if (needs_ival)
1118
          puts ("  if (CONST_INT_P (op))\n"
1119
                "    ival = INTVAL (op);");
1120
        if (needs_hval)
1121
          puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1122
                "    hval = CONST_DOUBLE_HIGH (op);");
1123
        if (needs_lval)
1124
          puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1125
                "    lval = CONST_DOUBLE_LOW (op);");
1126
        if (needs_rval)
1127
          puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1128
                "    rval = CONST_DOUBLE_REAL_VALUE (op);");
1129
 
1130
        write_predicate_stmts (c->exp);
1131
        fputs ("}\n", stdout);
1132
      }
1133
  puts ("#endif /* tm-constrs.h */");
1134
}
1135
 
1136
/* Write out the wrapper function, constraint_satisfied_p, that maps
1137
   a CONSTRAINT_xxx constant to one of the predicate functions generated
1138
   above.  */
1139
static void
1140
write_constraint_satisfied_p (void)
1141
{
1142
  struct constraint_data *c;
1143
 
1144
  puts ("bool\n"
1145
        "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1146
        "{\n"
1147
        "  switch (c)\n"
1148
        "    {");
1149
 
1150
  FOR_ALL_CONSTRAINTS (c)
1151
    if (!c->is_register)
1152
      printf ("    case CONSTRAINT_%s: "
1153
              "return satisfies_constraint_%s (op);\n",
1154
              c->c_name, c->c_name);
1155
 
1156
  puts ("    default: break;\n"
1157
        "    }\n"
1158
        "  return false;\n"
1159
        "}\n");
1160
}
1161
 
1162
/* Write out the function which computes whether a given value matches
1163
   a given CONST_INT constraint.  This doesn't just forward to
1164
   constraint_satisfied_p because caller passes the INTVAL, not the RTX.  */
1165
static void
1166
write_insn_const_int_ok_for_constraint (void)
1167
{
1168
  struct constraint_data *c;
1169
 
1170
  puts ("bool\n"
1171
        "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1172
                                          "enum constraint_num c)\n"
1173
        "{\n"
1174
        "  switch (c)\n"
1175
        "    {");
1176
 
1177
  FOR_ALL_CONSTRAINTS (c)
1178
    if (c->is_const_int)
1179
      {
1180
        printf ("    case CONSTRAINT_%s:\n      return ", c->c_name);
1181
        /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1182
           we know at this point that we have a const_int, so we need not
1183
           bother with that part of the test.  */
1184
        write_predicate_expr (XEXP (c->exp, 1));
1185
        fputs (";\n\n", stdout);
1186
      }
1187
 
1188
  puts ("    default: break;\n"
1189
        "    }\n"
1190
        "  return false;\n"
1191
        "}\n");
1192
}
1193
 
1194
 
1195
/* Write out the function which computes whether a given constraint is
1196
   a memory constraint.  */
1197
static void
1198
write_insn_extra_memory_constraint (void)
1199
{
1200
  struct constraint_data *c;
1201
 
1202
  puts ("bool\n"
1203
        "insn_extra_memory_constraint (enum constraint_num c)\n"
1204
        "{\n"
1205
        "  switch (c)\n"
1206
        "    {");
1207
 
1208
  FOR_ALL_CONSTRAINTS (c)
1209
    if (c->is_memory)
1210
      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1211
 
1212
  puts ("    default: break;\n"
1213
        "    }\n"
1214
        "  return false;\n"
1215
        "}\n");
1216
}
1217
 
1218
/* Write out the function which computes whether a given constraint is
1219
   an address constraint.  */
1220
static void
1221
write_insn_extra_address_constraint (void)
1222
{
1223
  struct constraint_data *c;
1224
 
1225
  puts ("bool\n"
1226
        "insn_extra_address_constraint (enum constraint_num c)\n"
1227
        "{\n"
1228
        "  switch (c)\n"
1229
        "    {");
1230
 
1231
  FOR_ALL_CONSTRAINTS (c)
1232
    if (c->is_address)
1233
      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1234
 
1235
  puts ("    default: break;\n"
1236
        "    }\n"
1237
        "  return false;\n"
1238
        "}\n");
1239
}
1240
 
1241
 
1242
/* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
1243
   an enumeration in portable C, so we have to condition all these
1244
   prototypes on HAVE_MACHINE_MODES.  */
1245
static void
1246
write_tm_preds_h (void)
1247
{
1248
  struct pred_data *p;
1249
 
1250
  printf ("\
1251
/* Generated automatically by the program '%s'\n\
1252
   from the machine description file '%s'.  */\n\n", progname, in_fname);
1253
 
1254
  puts ("\
1255
#ifndef GCC_TM_PREDS_H\n\
1256
#define GCC_TM_PREDS_H\n\
1257
\n\
1258
#ifdef HAVE_MACHINE_MODES");
1259
 
1260
  FOR_ALL_PREDICATES (p)
1261
    printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1262
 
1263
  puts ("#endif /* HAVE_MACHINE_MODES */\n");
1264
 
1265
  if (constraint_max_namelen > 0)
1266
    {
1267
      write_enum_constraint_num ();
1268
      puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1269
            "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1270
 
1271
      if (constraint_max_namelen > 1)
1272
        {
1273
          write_insn_constraint_len ();
1274
          puts ("#define CONSTRAINT_LEN(c_,s_) "
1275
                "insn_constraint_len (c_,s_)\n");
1276
        }
1277
      else
1278
        puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1279
      if (have_register_constraints)
1280
        puts ("extern enum reg_class regclass_for_constraint "
1281
              "(enum constraint_num);\n"
1282
              "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1283
              "    regclass_for_constraint (lookup_constraint (s_))\n"
1284
              "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1285
              "    regclass_for_constraint (x_)\n");
1286
      else
1287
        puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n"
1288
              "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1289
              "    NO_REGS\n");
1290
      if (have_const_int_constraints)
1291
        puts ("extern bool insn_const_int_ok_for_constraint "
1292
              "(HOST_WIDE_INT, enum constraint_num);\n"
1293
              "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1294
              "    insn_const_int_ok_for_constraint (v_, "
1295
              "lookup_constraint (s_))\n");
1296
      if (have_const_dbl_constraints)
1297
        puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1298
              "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1299
      else
1300
        puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1301
      if (have_extra_constraints)
1302
        puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1303
              "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1304
      if (have_memory_constraints)
1305
        puts ("extern bool "
1306
              "insn_extra_memory_constraint (enum constraint_num);\n"
1307
              "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1308
              "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1309
      else
1310
        puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1311
      if (have_address_constraints)
1312
        puts ("extern bool "
1313
              "insn_extra_address_constraint (enum constraint_num);\n"
1314
              "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1315
              "insn_extra_address_constraint (lookup_constraint (s_))\n");
1316
      else
1317
        puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1318
    }
1319
 
1320
  puts ("#endif /* tm-preds.h */");
1321
}
1322
 
1323
/* Write insn-preds.c.
1324
   N.B. the list of headers to include was copied from genrecog; it
1325
   may not be ideal.
1326
 
1327
   FUTURE: Write #line markers referring back to the machine
1328
   description.  (Can't practically do this now since we don't know
1329
   the line number of the C block - just the line number of the enclosing
1330
   expression.)  */
1331
static void
1332
write_insn_preds_c (void)
1333
{
1334
  struct pred_data *p;
1335
 
1336
  printf ("\
1337
/* Generated automatically by the program '%s'\n\
1338
   from the machine description file '%s'.  */\n\n", progname, in_fname);
1339
 
1340
  puts ("\
1341
#include \"config.h\"\n\
1342
#include \"system.h\"\n\
1343
#include \"coretypes.h\"\n\
1344
#include \"tm.h\"\n\
1345
#include \"rtl.h\"\n\
1346
#include \"tree.h\"\n\
1347
#include \"tm_p.h\"\n\
1348
#include \"function.h\"\n\
1349
#include \"insn-config.h\"\n\
1350
#include \"recog.h\"\n\
1351
#include \"real.h\"\n\
1352
#include \"output.h\"\n\
1353
#include \"flags.h\"\n\
1354
#include \"hard-reg-set.h\"\n\
1355
#include \"resource.h\"\n\
1356
#include \"toplev.h\"\n\
1357
#include \"reload.h\"\n\
1358
#include \"regs.h\"\n\
1359
#include \"tm-constrs.h\"\n");
1360
 
1361
  FOR_ALL_PREDICATES (p)
1362
    write_one_predicate_function (p);
1363
 
1364
  if (constraint_max_namelen > 0)
1365
    {
1366
      write_lookup_constraint ();
1367
      if (have_register_constraints)
1368
        write_regclass_for_constraint ();
1369
      write_constraint_satisfied_p ();
1370
 
1371
      if (have_const_int_constraints)
1372
        write_insn_const_int_ok_for_constraint ();
1373
 
1374
      if (have_memory_constraints)
1375
        write_insn_extra_memory_constraint ();
1376
      if (have_address_constraints)
1377
        write_insn_extra_address_constraint ();
1378
    }
1379
}
1380
 
1381
/* Argument parsing.  */
1382
static bool gen_header;
1383
static bool gen_constrs;
1384
 
1385
static bool
1386
parse_option (const char *opt)
1387
{
1388
  if (!strcmp (opt, "-h"))
1389
    {
1390
      gen_header = true;
1391
      return 1;
1392
    }
1393
  else if (!strcmp (opt, "-c"))
1394
    {
1395
      gen_constrs = true;
1396
      return 1;
1397
    }
1398
  else
1399
    return 0;
1400
}
1401
 
1402
/* Master control.  */
1403
int
1404
main (int argc, char **argv)
1405
{
1406
  rtx defn;
1407
  int pattern_lineno, next_insn_code = 0;
1408
 
1409
  progname = argv[0];
1410
  if (argc <= 1)
1411
    fatal ("no input file name");
1412
  if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE)
1413
    return FATAL_EXIT_CODE;
1414
 
1415
  while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1416
    switch (GET_CODE (defn))
1417
      {
1418
      case DEFINE_PREDICATE:
1419
      case DEFINE_SPECIAL_PREDICATE:
1420
        process_define_predicate (defn, pattern_lineno);
1421
        break;
1422
 
1423
      case DEFINE_CONSTRAINT:
1424
      case DEFINE_MEMORY_CONSTRAINT:
1425
      case DEFINE_ADDRESS_CONSTRAINT:
1426
        process_define_constraint (defn, pattern_lineno);
1427
        break;
1428
 
1429
      case DEFINE_REGISTER_CONSTRAINT:
1430
        process_define_register_constraint (defn, pattern_lineno);
1431
        break;
1432
 
1433
      default:
1434
        break;
1435
      }
1436
 
1437
  if (gen_header)
1438
    write_tm_preds_h ();
1439
  else if (gen_constrs)
1440
    write_tm_constrs_h ();
1441
  else
1442
    write_insn_preds_c ();
1443
 
1444
  if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1445
    return FATAL_EXIT_CODE;
1446
 
1447
  return SUCCESS_EXIT_CODE;
1448
}

powered by: WebSVN 2.1.0

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