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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [cgen-asm.in] - Blame information for rev 157

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

Line No. Rev Author Line
1 24 jeremybenn
/* Assembler interface for targets using CGEN. -*- C -*-
2
   CGEN: Cpu tools GENerator
3
 
4
   THIS FILE IS MACHINE GENERATED WITH CGEN.
5
   - the resultant file is machine generated, cgen-asm.in isn't
6
 
7
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007
8
   Free Software Foundation, Inc.
9
 
10
   This file is part of libopcodes.
11
 
12
   This library is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3, or (at your option)
15
   any later version.
16
 
17
   It is distributed in the hope that it will be useful, but WITHOUT
18
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
20
   License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program; if not, write to the Free Software Foundation, Inc.,
24
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
25
 
26
 
27
/* ??? Eventually more and more of this stuff can go to cpu-independent files.
28
   Keep that in mind.  */
29
 
30
#include "sysdep.h"
31
#include 
32
#include "ansidecl.h"
33
#include "bfd.h"
34
#include "symcat.h"
35
#include "@prefix@-desc.h"
36
#include "@prefix@-opc.h"
37
#include "opintl.h"
38
#include "xregex.h"
39
#include "libiberty.h"
40
#include "safe-ctype.h"
41
 
42
#undef  min
43
#define min(a,b) ((a) < (b) ? (a) : (b))
44
#undef  max
45
#define max(a,b) ((a) > (b) ? (a) : (b))
46
 
47
static const char * parse_insn_normal
48
  (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
49
 
50
/* -- assembler routines inserted here.  */
51
 
52
 
53
/* Regex construction routine.
54
 
55
   This translates an opcode syntax string into a regex string,
56
   by replacing any non-character syntax element (such as an
57
   opcode) with the pattern '.*'
58
 
59
   It then compiles the regex and stores it in the opcode, for
60
   later use by @arch@_cgen_assemble_insn
61
 
62
   Returns NULL for success, an error message for failure.  */
63
 
64
char *
65
@arch@_cgen_build_insn_regex (CGEN_INSN *insn)
66
{
67
  CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
68
  const char *mnem = CGEN_INSN_MNEMONIC (insn);
69
  char rxbuf[CGEN_MAX_RX_ELEMENTS];
70
  char *rx = rxbuf;
71
  const CGEN_SYNTAX_CHAR_TYPE *syn;
72
  int reg_err;
73
 
74
  syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
75
 
76
  /* Mnemonics come first in the syntax string.  */
77
  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
78
    return _("missing mnemonic in syntax string");
79
  ++syn;
80
 
81
  /* Generate a case sensitive regular expression that emulates case
82
     insensitive matching in the "C" locale.  We cannot generate a case
83
     insensitive regular expression because in Turkish locales, 'i' and 'I'
84
     are not equal modulo case conversion.  */
85
 
86
  /* Copy the literal mnemonic out of the insn.  */
87
  for (; *mnem; mnem++)
88
    {
89
      char c = *mnem;
90
 
91
      if (ISALPHA (c))
92
        {
93
          *rx++ = '[';
94
          *rx++ = TOLOWER (c);
95
          *rx++ = TOUPPER (c);
96
          *rx++ = ']';
97
        }
98
      else
99
        *rx++ = c;
100
    }
101
 
102
  /* Copy any remaining literals from the syntax string into the rx.  */
103
  for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
104
    {
105
      if (CGEN_SYNTAX_CHAR_P (* syn))
106
        {
107
          char c = CGEN_SYNTAX_CHAR (* syn);
108
 
109
          switch (c)
110
            {
111
              /* Escape any regex metacharacters in the syntax.  */
112
            case '.': case '[': case '\\':
113
            case '*': case '^': case '$':
114
 
115
#ifdef CGEN_ESCAPE_EXTENDED_REGEX
116
            case '?': case '{': case '}':
117
            case '(': case ')': case '*':
118
            case '|': case '+': case ']':
119
#endif
120
              *rx++ = '\\';
121
              *rx++ = c;
122
              break;
123
 
124
            default:
125
              if (ISALPHA (c))
126
                {
127
                  *rx++ = '[';
128
                  *rx++ = TOLOWER (c);
129
                  *rx++ = TOUPPER (c);
130
                  *rx++ = ']';
131
                }
132
              else
133
                *rx++ = c;
134
              break;
135
            }
136
        }
137
      else
138
        {
139
          /* Replace non-syntax fields with globs.  */
140
          *rx++ = '.';
141
          *rx++ = '*';
142
        }
143
    }
144
 
145
  /* Trailing whitespace ok.  */
146
  * rx++ = '[';
147
  * rx++ = ' ';
148
  * rx++ = '\t';
149
  * rx++ = ']';
150
  * rx++ = '*';
151
 
152
  /* But anchor it after that.  */
153
  * rx++ = '$';
154
  * rx = '\0';
155
 
156
  CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
157
  reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
158
 
159
  if (reg_err == 0)
160
    return NULL;
161
  else
162
    {
163
      static char msg[80];
164
 
165
      regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
166
      regfree ((regex_t *) CGEN_INSN_RX (insn));
167
      free (CGEN_INSN_RX (insn));
168
      (CGEN_INSN_RX (insn)) = NULL;
169
      return msg;
170
    }
171
}
172
 
173
 
174
/* Default insn parser.
175
 
176
   The syntax string is scanned and operands are parsed and stored in FIELDS.
177
   Relocs are queued as we go via other callbacks.
178
 
179
   ??? Note that this is currently an all-or-nothing parser.  If we fail to
180
   parse the instruction, we return 0 and the caller will start over from
181
   the beginning.  Backtracking will be necessary in parsing subexpressions,
182
   but that can be handled there.  Not handling backtracking here may get
183
   expensive in the case of the m68k.  Deal with later.
184
 
185
   Returns NULL for success, an error message for failure.  */
186
 
187
static const char *
188
parse_insn_normal (CGEN_CPU_DESC cd,
189
                   const CGEN_INSN *insn,
190
                   const char **strp,
191
                   CGEN_FIELDS *fields)
192
{
193
  /* ??? Runtime added insns not handled yet.  */
194
  const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
195
  const char *str = *strp;
196
  const char *errmsg;
197
  const char *p;
198
  const CGEN_SYNTAX_CHAR_TYPE * syn;
199
#ifdef CGEN_MNEMONIC_OPERANDS
200
  /* FIXME: wip */
201
  int past_opcode_p;
202
#endif
203
 
204
  /* For now we assume the mnemonic is first (there are no leading operands).
205
     We can parse it without needing to set up operand parsing.
206
     GAS's input scrubber will ensure mnemonics are lowercase, but we may
207
     not be called from GAS.  */
208
  p = CGEN_INSN_MNEMONIC (insn);
209
  while (*p && TOLOWER (*p) == TOLOWER (*str))
210
    ++p, ++str;
211
 
212
  if (* p)
213
    return _("unrecognized instruction");
214
 
215
#ifndef CGEN_MNEMONIC_OPERANDS
216
  if (* str && ! ISSPACE (* str))
217
    return _("unrecognized instruction");
218
#endif
219
 
220
  CGEN_INIT_PARSE (cd);
221
  cgen_init_parse_operand (cd);
222
#ifdef CGEN_MNEMONIC_OPERANDS
223
  past_opcode_p = 0;
224
#endif
225
 
226
  /* We don't check for (*str != '\0') here because we want to parse
227
     any trailing fake arguments in the syntax string.  */
228
  syn = CGEN_SYNTAX_STRING (syntax);
229
 
230
  /* Mnemonics come first for now, ensure valid string.  */
231
  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
232
    abort ();
233
 
234
  ++syn;
235
 
236
  while (* syn != 0)
237
    {
238
      /* Non operand chars must match exactly.  */
239
      if (CGEN_SYNTAX_CHAR_P (* syn))
240
        {
241
          /* FIXME: While we allow for non-GAS callers above, we assume the
242
             first char after the mnemonic part is a space.  */
243
          /* FIXME: We also take inappropriate advantage of the fact that
244
             GAS's input scrubber will remove extraneous blanks.  */
245
          if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
246
            {
247
#ifdef CGEN_MNEMONIC_OPERANDS
248
              if (CGEN_SYNTAX_CHAR(* syn) == ' ')
249
                past_opcode_p = 1;
250
#endif
251
              ++ syn;
252
              ++ str;
253
            }
254
          else if (*str)
255
            {
256
              /* Syntax char didn't match.  Can't be this insn.  */
257
              static char msg [80];
258
 
259
              /* xgettext:c-format */
260
              sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
261
                       CGEN_SYNTAX_CHAR(*syn), *str);
262
              return msg;
263
            }
264
          else
265
            {
266
              /* Ran out of input.  */
267
              static char msg [80];
268
 
269
              /* xgettext:c-format */
270
              sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
271
                       CGEN_SYNTAX_CHAR(*syn));
272
              return msg;
273
            }
274
          continue;
275
        }
276
 
277
      /* We have an operand of some sort.  */
278
      errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
279
                                          &str, fields);
280
      if (errmsg)
281
        return errmsg;
282
 
283
      /* Done with this operand, continue with next one.  */
284
      ++ syn;
285
    }
286
 
287
  /* If we're at the end of the syntax string, we're done.  */
288
  if (* syn == 0)
289
    {
290
      /* FIXME: For the moment we assume a valid `str' can only contain
291
         blanks now.  IE: We needn't try again with a longer version of
292
         the insn and it is assumed that longer versions of insns appear
293
         before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
294
      while (ISSPACE (* str))
295
        ++ str;
296
 
297
      if (* str != '\0')
298
        return _("junk at end of line"); /* FIXME: would like to include `str' */
299
 
300
      return NULL;
301
    }
302
 
303
  /* We couldn't parse it.  */
304
  return _("unrecognized instruction");
305
}
306
 
307
/* Main entry point.
308
   This routine is called for each instruction to be assembled.
309
   STR points to the insn to be assembled.
310
   We assume all necessary tables have been initialized.
311
   The assembled instruction, less any fixups, is stored in BUF.
312
   Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
313
   still needs to be converted to target byte order, otherwise BUF is an array
314
   of bytes in target byte order.
315
   The result is a pointer to the insn's entry in the opcode table,
316
   or NULL if an error occured (an error message will have already been
317
   printed).
318
 
319
   Note that when processing (non-alias) macro-insns,
320
   this function recurses.
321
 
322
   ??? It's possible to make this cpu-independent.
323
   One would have to deal with a few minor things.
324
   At this point in time doing so would be more of a curiosity than useful
325
   [for example this file isn't _that_ big], but keeping the possibility in
326
   mind helps keep the design clean.  */
327
 
328
const CGEN_INSN *
329
@arch@_cgen_assemble_insn (CGEN_CPU_DESC cd,
330
                           const char *str,
331
                           CGEN_FIELDS *fields,
332
                           CGEN_INSN_BYTES_PTR buf,
333
                           char **errmsg)
334
{
335
  const char *start;
336
  CGEN_INSN_LIST *ilist;
337
  const char *parse_errmsg = NULL;
338
  const char *insert_errmsg = NULL;
339
  int recognized_mnemonic = 0;
340
 
341
  /* Skip leading white space.  */
342
  while (ISSPACE (* str))
343
    ++ str;
344
 
345
  /* The instructions are stored in hashed lists.
346
     Get the first in the list.  */
347
  ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
348
 
349
  /* Keep looking until we find a match.  */
350
  start = str;
351
  for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
352
    {
353
      const CGEN_INSN *insn = ilist->insn;
354
      recognized_mnemonic = 1;
355
 
356
#ifdef CGEN_VALIDATE_INSN_SUPPORTED
357
      /* Not usually needed as unsupported opcodes
358
         shouldn't be in the hash lists.  */
359
      /* Is this insn supported by the selected cpu?  */
360
      if (! @arch@_cgen_insn_supported (cd, insn))
361
        continue;
362
#endif
363
      /* If the RELAXED attribute is set, this is an insn that shouldn't be
364
         chosen immediately.  Instead, it is used during assembler/linker
365
         relaxation if possible.  */
366
      if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
367
        continue;
368
 
369
      str = start;
370
 
371
      /* Skip this insn if str doesn't look right lexically.  */
372
      if (CGEN_INSN_RX (insn) != NULL &&
373
          regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
374
        continue;
375
 
376
      /* Allow parse/insert handlers to obtain length of insn.  */
377
      CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
378
 
379
      parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
380
      if (parse_errmsg != NULL)
381
        continue;
382
 
383
      /* ??? 0 is passed for `pc'.  */
384
      insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
385
                                                 (bfd_vma) 0);
386
      if (insert_errmsg != NULL)
387
        continue;
388
 
389
      /* It is up to the caller to actually output the insn and any
390
         queued relocs.  */
391
      return insn;
392
    }
393
 
394
  {
395
    static char errbuf[150];
396
#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
397
    const char *tmp_errmsg;
398
 
399
    /* If requesting verbose error messages, use insert_errmsg.
400
       Failing that, use parse_errmsg.  */
401
    tmp_errmsg = (insert_errmsg ? insert_errmsg :
402
                  parse_errmsg ? parse_errmsg :
403
                  recognized_mnemonic ?
404
                  _("unrecognized form of instruction") :
405
                  _("unrecognized instruction"));
406
 
407
    if (strlen (start) > 50)
408
      /* xgettext:c-format */
409
      sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
410
    else
411
      /* xgettext:c-format */
412
      sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
413
#else
414
    if (strlen (start) > 50)
415
      /* xgettext:c-format */
416
      sprintf (errbuf, _("bad instruction `%.50s...'"), start);
417
    else
418
      /* xgettext:c-format */
419
      sprintf (errbuf, _("bad instruction `%.50s'"), start);
420
#endif
421
 
422
    *errmsg = errbuf;
423
    return NULL;
424
  }
425
}

powered by: WebSVN 2.1.0

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