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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [genextract.c] - Blame information for rev 154

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Generate code from machine description to extract operands from insn as rtl.
2
   Copyright (C) 1987, 1991, 1992, 1993, 1997, 1998, 1999, 2000, 2003,
3
   2004, 2005, 2007
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
 
23
#include "bconfig.h"
24
#include "system.h"
25
#include "coretypes.h"
26
#include "tm.h"
27
#include "rtl.h"
28
#include "errors.h"
29
#include "gensupport.h"
30
#include "vec.h"
31
#include "vecprim.h"
32
 
33
/* This structure contains all the information needed to describe one
34
   set of extractions methods.  Each method may be used by more than
35
   one pattern if the operands are in the same place.
36
 
37
   The string for each operand describes that path to the operand and
38
   contains `0' through `9' when going into an expression and `a' through
39
   `z' when going into a vector.  We assume here that only the first operand
40
   of an rtl expression is a vector.  genrecog.c makes the same assumption
41
   (and uses the same representation) and it is currently true.  */
42
 
43
typedef char *locstr;
44
 
45
struct extraction
46
{
47
  unsigned int op_count;
48
  unsigned int dup_count;
49
  locstr *oplocs;
50
  locstr *duplocs;
51
  int *dupnums;
52
  struct code_ptr *insns;
53
  struct extraction *next;
54
};
55
 
56
/* Holds a single insn code that uses an extraction method.  */
57
struct code_ptr
58
{
59
  int insn_code;
60
  struct code_ptr *next;
61
};
62
 
63
/* All extractions needed for this machine description.  */
64
static struct extraction *extractions;
65
 
66
/* All insn codes for old-style peepholes.  */
67
static struct code_ptr *peepholes;
68
 
69
/* This structure is used by gen_insn and walk_rtx to accumulate the
70
   data that will be used to produce an extractions structure.  */
71
 
72
DEF_VEC_P(locstr);
73
DEF_VEC_ALLOC_P(locstr,heap);
74
 
75
struct accum_extract
76
{
77
  VEC(locstr,heap) *oplocs;
78
  VEC(locstr,heap) *duplocs;
79
  VEC(int,heap)    *dupnums;
80
  VEC(char,heap)   *pathstr;
81
};
82
 
83
/* Forward declarations.  */
84
static void walk_rtx (rtx, struct accum_extract *);
85
 
86
static void
87
gen_insn (rtx insn, int insn_code_number)
88
{
89
  int i;
90
  unsigned int op_count, dup_count, j;
91
  struct extraction *p;
92
  struct code_ptr *link;
93
  struct accum_extract acc;
94
 
95
  acc.oplocs  = VEC_alloc (locstr,heap, 10);
96
  acc.duplocs = VEC_alloc (locstr,heap, 10);
97
  acc.dupnums = VEC_alloc (int,heap,    10);
98
  acc.pathstr = VEC_alloc (char,heap,   20);
99
 
100
  /* Walk the insn's pattern, remembering at all times the path
101
     down to the walking point.  */
102
 
103
  if (XVECLEN (insn, 1) == 1)
104
    walk_rtx (XVECEXP (insn, 1, 0), &acc);
105
  else
106
    for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
107
      {
108
        VEC_safe_push (char,heap, acc.pathstr, 'a' + i);
109
        walk_rtx (XVECEXP (insn, 1, i), &acc);
110
        VEC_pop (char, acc.pathstr);
111
      }
112
 
113
  link = XNEW (struct code_ptr);
114
  link->insn_code = insn_code_number;
115
 
116
  /* See if we find something that already had this extraction method.  */
117
 
118
  op_count = VEC_length (locstr, acc.oplocs);
119
  dup_count = VEC_length (locstr, acc.duplocs);
120
  gcc_assert (dup_count == VEC_length (int, acc.dupnums));
121
 
122
  for (p = extractions; p; p = p->next)
123
    {
124
      if (p->op_count != op_count || p->dup_count != dup_count)
125
        continue;
126
 
127
      for (j = 0; j < op_count; j++)
128
        {
129
          char *a = p->oplocs[j];
130
          char *b = VEC_index (locstr, acc.oplocs, j);
131
          if (a != b && (!a || !b || strcmp (a, b)))
132
            break;
133
        }
134
 
135
      if (j != op_count)
136
        continue;
137
 
138
      for (j = 0; j < dup_count; j++)
139
        if (p->dupnums[j] != VEC_index (int, acc.dupnums, j)
140
            || strcmp (p->duplocs[j], VEC_index (locstr, acc.duplocs, j)))
141
          break;
142
 
143
      if (j != dup_count)
144
        continue;
145
 
146
      /* This extraction is the same as ours.  Just link us in.  */
147
      link->next = p->insns;
148
      p->insns = link;
149
      goto done;
150
    }
151
 
152
  /* Otherwise, make a new extraction method.  We stash the arrays
153
     after the extraction structure in memory.  */
154
 
155
  p = xmalloc (sizeof (struct extraction)
156
               + op_count*sizeof (char *)
157
               + dup_count*sizeof (char *)
158
               + dup_count*sizeof (int));
159
  p->op_count = op_count;
160
  p->dup_count = dup_count;
161
  p->next = extractions;
162
  extractions = p;
163
  p->insns = link;
164
  link->next = 0;
165
 
166
  p->oplocs = (char **)((char *)p + sizeof (struct extraction));
167
  p->duplocs = p->oplocs + op_count;
168
  p->dupnums = (int *)(p->duplocs + dup_count);
169
 
170
  memcpy(p->oplocs,  VEC_address(locstr,acc.oplocs),   op_count*sizeof(locstr));
171
  memcpy(p->duplocs, VEC_address(locstr,acc.duplocs), dup_count*sizeof(locstr));
172
  memcpy(p->dupnums, VEC_address(int,   acc.dupnums), dup_count*sizeof(int));
173
 
174
 done:
175
  VEC_free (locstr,heap, acc.oplocs);
176
  VEC_free (locstr,heap, acc.duplocs);
177
  VEC_free (int,heap,    acc.dupnums);
178
  VEC_free (char,heap,   acc.pathstr);
179
}
180
 
181
/* Helper subroutine of walk_rtx: given a VEC(locstr), an index, and a
182
   string, insert the string at the index, which should either already
183
   exist and be NULL, or not yet exist within the vector.  In the latter
184
   case the vector is enlarged as appropriate.  */
185
static void
186
VEC_safe_set_locstr (VEC(locstr,heap) **vp, unsigned int ix, char *str)
187
{
188
  if (ix < VEC_length (locstr, *vp))
189
    {
190
      gcc_assert (VEC_index (locstr, *vp, ix) == 0);
191
      VEC_replace (locstr, *vp, ix, str);
192
    }
193
  else
194
    {
195
      while (ix > VEC_length (locstr, *vp))
196
        VEC_safe_push (locstr, heap, *vp, 0);
197
      VEC_safe_push (locstr, heap, *vp, str);
198
    }
199
}
200
 
201
/* Another helper subroutine of walk_rtx: given a VEC(char), convert it
202
   to a NUL-terminated string in malloc memory.  */
203
static char *
204
VEC_char_to_string (VEC(char,heap) *v)
205
{
206
  size_t n = VEC_length (char, v);
207
  char *s = XNEWVEC (char, n + 1);
208
  memcpy (s, VEC_address (char, v), n);
209
  s[n] = '\0';
210
  return s;
211
}
212
 
213
static void
214
walk_rtx (rtx x, struct accum_extract *acc)
215
{
216
  RTX_CODE code;
217
  int i, len, base;
218
  const char *fmt;
219
 
220
  if (x == 0)
221
    return;
222
 
223
  code = GET_CODE (x);
224
  switch (code)
225
    {
226
    case PC:
227
    case CC0:
228
    case CONST_INT:
229
    case SYMBOL_REF:
230
      return;
231
 
232
    case MATCH_OPERAND:
233
    case MATCH_SCRATCH:
234
      VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
235
                           VEC_char_to_string (acc->pathstr));
236
      break;
237
 
238
    case MATCH_OPERATOR:
239
    case MATCH_PARALLEL:
240
      VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
241
                           VEC_char_to_string (acc->pathstr));
242
 
243
      base = (code == MATCH_OPERATOR ? '0' : 'a');
244
      for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
245
        {
246
          VEC_safe_push (char,heap, acc->pathstr, base + i);
247
          walk_rtx (XVECEXP (x, 2, i), acc);
248
          VEC_pop (char, acc->pathstr);
249
        }
250
      return;
251
 
252
    case MATCH_DUP:
253
    case MATCH_PAR_DUP:
254
    case MATCH_OP_DUP:
255
      VEC_safe_push (locstr,heap, acc->duplocs,
256
                     VEC_char_to_string (acc->pathstr));
257
      VEC_safe_push (int,heap, acc->dupnums, XINT (x, 0));
258
 
259
      if (code == MATCH_DUP)
260
        break;
261
 
262
      base = (code == MATCH_OP_DUP ? '0' : 'a');
263
      for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
264
        {
265
          VEC_safe_push (char,heap, acc->pathstr, base + i);
266
          walk_rtx (XVECEXP (x, 1, i), acc);
267
          VEC_pop (char, acc->pathstr);
268
        }
269
      return;
270
 
271
    default:
272
      break;
273
    }
274
 
275
  fmt = GET_RTX_FORMAT (code);
276
  len = GET_RTX_LENGTH (code);
277
  for (i = 0; i < len; i++)
278
    {
279
      if (fmt[i] == 'e' || fmt[i] == 'u')
280
        {
281
          VEC_safe_push (char,heap, acc->pathstr, '0' + i);
282
          walk_rtx (XEXP (x, i), acc);
283
          VEC_pop (char, acc->pathstr);
284
        }
285
      else if (fmt[i] == 'E')
286
        {
287
          int j;
288
          for (j = XVECLEN (x, i) - 1; j >= 0; j--)
289
            {
290
              VEC_safe_push (char,heap, acc->pathstr, 'a' + j);
291
              walk_rtx (XVECEXP (x, i, j), acc);
292
              VEC_pop (char, acc->pathstr);
293
            }
294
        }
295
    }
296
}
297
 
298
/* Given a PATH, representing a path down the instruction's
299
   pattern from the root to a certain point, output code to
300
   evaluate to the rtx at that point.  */
301
 
302
static void
303
print_path (const char *path)
304
{
305
  int len = strlen (path);
306
  int i;
307
 
308
  if (len == 0)
309
    {
310
      /* Don't emit "pat", since we may try to take the address of it,
311
         which isn't what is intended.  */
312
      fputs ("PATTERN (insn)", stdout);
313
      return;
314
    }
315
 
316
  /* We first write out the operations (XEXP or XVECEXP) in reverse
317
     order, then write "pat", then the indices in forward order.  */
318
 
319
  for (i = len - 1; i >= 0 ; i--)
320
    {
321
      if (ISLOWER (path[i]))
322
        fputs ("XVECEXP (", stdout);
323
      else if (ISDIGIT (path[i]))
324
        fputs ("XEXP (", stdout);
325
      else
326
        gcc_unreachable ();
327
    }
328
 
329
  fputs ("pat", stdout);
330
 
331
  for (i = 0; i < len; i++)
332
    {
333
      if (ISLOWER (path[i]))
334
        printf (", 0, %d)", path[i] - 'a');
335
      else if (ISDIGIT(path[i]))
336
        printf (", %d)", path[i] - '0');
337
      else
338
        gcc_unreachable ();
339
    }
340
}
341
 
342
static void
343
print_header (void)
344
{
345
  /* N.B. Code below avoids putting squiggle braces in column 1 inside
346
     a string, because this confuses some editors' syntax highlighting
347
     engines.  */
348
 
349
  puts ("\
350
/* Generated automatically by the program `genextract'\n\
351
   from the machine description file `md'.  */\n\
352
\n\
353
#include \"config.h\"\n\
354
#include \"system.h\"\n\
355
#include \"coretypes.h\"\n\
356
#include \"tm.h\"\n\
357
#include \"rtl.h\"\n\
358
#include \"insn-config.h\"\n\
359
#include \"recog.h\"\n\
360
#include \"toplev.h\"\n\
361
\n\
362
/* This variable is used as the \"location\" of any missing operand\n\
363
   whose numbers are skipped by a given pattern.  */\n\
364
static rtx junk ATTRIBUTE_UNUSED;\n");
365
 
366
  puts ("\
367
void\n\
368
insn_extract (rtx insn)\n{\n\
369
  rtx *ro = recog_data.operand;\n\
370
  rtx **ro_loc = recog_data.operand_loc;\n\
371
  rtx pat = PATTERN (insn);\n\
372
  int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
373
\n\
374
#ifdef ENABLE_CHECKING\n\
375
  memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
376
  memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
377
#endif\n");
378
 
379
  puts ("\
380
  switch (INSN_CODE (insn))\n\
381
    {\n\
382
    default:\n\
383
      /* Control reaches here if insn_extract has been called with an\n\
384
         unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
385
         corresponds to a DEFINE_EXPAND in the machine description;\n\
386
         either way, a bug.  */\n\
387
      if (INSN_CODE (insn) < 0)\n\
388
        fatal_insn (\"unrecognizable insn:\", insn);\n\
389
      else\n\
390
        fatal_insn (\"insn with invalid code number:\", insn);\n");
391
}
392
 
393
int
394
main (int argc, char **argv)
395
{
396
  rtx desc;
397
  unsigned int i;
398
  struct extraction *p;
399
  struct code_ptr *link;
400
  const char *name;
401
  int insn_code_number;
402
  int line_no;
403
 
404
  progname = "genextract";
405
 
406
  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
407
    return (FATAL_EXIT_CODE);
408
 
409
  /* Read the machine description.  */
410
 
411
  while ((desc = read_md_rtx (&line_no, &insn_code_number)) != NULL)
412
    {
413
       if (GET_CODE (desc) == DEFINE_INSN)
414
         gen_insn (desc, insn_code_number);
415
 
416
      else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
417
        {
418
          struct code_ptr *link = XNEW (struct code_ptr);
419
 
420
          link->insn_code = insn_code_number;
421
          link->next = peepholes;
422
          peepholes = link;
423
        }
424
    }
425
 
426
  print_header ();
427
 
428
  /* Write out code to handle peepholes and the insn_codes that it should
429
     be called for.  */
430
  if (peepholes)
431
    {
432
      for (link = peepholes; link; link = link->next)
433
        printf ("    case %d:\n", link->insn_code);
434
 
435
      /* The vector in the insn says how many operands it has.
436
         And all it contains are operands.  In fact, the vector was
437
         created just for the sake of this function.  We need to set the
438
         location of the operands for sake of simplifications after
439
         extraction, like eliminating subregs.  */
440
      puts ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
441
            "          ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
442
            "      break;\n");
443
    }
444
 
445
  /* Write out all the ways to extract insn operands.  */
446
  for (p = extractions; p; p = p->next)
447
    {
448
      for (link = p->insns; link; link = link->next)
449
        {
450
          i = link->insn_code;
451
          name = get_insn_name (i);
452
          if (name)
453
            printf ("    case %d:  /* %s */\n", i, name);
454
          else
455
            printf ("    case %d:\n", i);
456
        }
457
 
458
      for (i = 0; i < p->op_count; i++)
459
        {
460
          if (p->oplocs[i] == 0)
461
            {
462
              printf ("      ro[%d] = const0_rtx;\n", i);
463
              printf ("      ro_loc[%d] = &junk;\n", i);
464
            }
465
          else
466
            {
467
              printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
468
              print_path (p->oplocs[i]);
469
              puts (");");
470
            }
471
        }
472
 
473
      for (i = 0; i < p->dup_count; i++)
474
        {
475
          printf ("      recog_data.dup_loc[%d] = &", i);
476
          print_path (p->duplocs[i]);
477
          puts (";");
478
          printf ("      recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
479
        }
480
 
481
      puts ("      break;\n");
482
    }
483
 
484
  puts ("    }\n}");
485
  fflush (stdout);
486
  return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
487
}

powered by: WebSVN 2.1.0

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