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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [ppc/] [dgen.c] - Blame information for rev 866

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

Line No. Rev Author Line
1 330 jeremybenn
/*  This file is part of the program psim.
2
 
3
    Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
4
 
5
    This program is free software; you can redistribute it and/or modify
6
    it under the terms of the GNU General Public License as published by
7
    the Free Software Foundation; either version 2 of the License, or
8
    (at your option) any later version.
9
 
10
    This program is distributed in the hope that it will be useful,
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
    GNU General Public License for more details.
14
 
15
    You should have received a copy of the GNU General Public License
16
    along with this program; if not, write to the Free Software
17
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
 
19
    */
20
 
21
 
22
#include <sys/types.h>
23
#include <sys/stat.h>
24
#include <fcntl.h>
25
#include <getopt.h>
26
#include <stdio.h>
27
#include <ctype.h>
28
#include <stdarg.h>
29
 
30
#include "build-config.h"
31
#include "misc.h"
32
#include "lf.h"
33
#include "table.h"
34
 
35
#ifdef HAVE_UNISTD_H
36
#include <unistd.h>
37
#endif
38
 
39
#ifdef HAVE_STDLIB_H
40
#include <stdlib.h>
41
#endif
42
 
43
#ifdef HAVE_STRING_H
44
#include <string.h>
45
#else
46
#ifdef HAVE_STRINGS_H
47
#include <strings.h>
48
#endif
49
#endif
50
 
51
/****************************************************************/
52
 
53
int spreg_lookup_table = 1;
54
enum {
55
  nr_of_sprs = 1024,
56
};
57
 
58
/****************************************************************/
59
 
60
 
61
typedef enum {
62
  spreg_name,
63
  spreg_reg_nr,
64
  spreg_readonly,
65
  spreg_length,
66
  nr_spreg_fields,
67
} spreg_fields;
68
 
69
typedef struct _spreg_table_entry spreg_table_entry;
70
struct _spreg_table_entry {
71
  char *name;
72
  int spreg_nr;
73
  int is_readonly;
74
  int length;
75
  table_entry *entry;
76
  spreg_table_entry *next;
77
};
78
 
79
typedef struct _spreg_table spreg_table;
80
struct _spreg_table {
81
  spreg_table_entry *sprs;
82
};
83
 
84
static void
85
spreg_table_insert(spreg_table *table, table_entry *entry)
86
{
87
  /* create a new spr entry */
88
  spreg_table_entry *new_spr = ZALLOC(spreg_table_entry);
89
  new_spr->next = NULL;
90
  new_spr->entry = entry;
91
  new_spr->spreg_nr = atoi(entry->fields[spreg_reg_nr]);
92
  new_spr->is_readonly = (entry->fields[spreg_readonly]
93
                          ? atoi(entry->fields[spreg_readonly])
94
                          : 0);
95
  new_spr->length = atoi(entry->fields[spreg_length]);
96
  new_spr->name = (char*)zalloc(strlen(entry->fields[spreg_name]) + 1);
97
  ASSERT(new_spr->name != NULL);
98
  {
99
    int i;
100
    for (i = 0; entry->fields[spreg_name][i] != '\0'; i++) {
101
      if (isupper(entry->fields[spreg_name][i]))
102
        new_spr->name[i] = tolower(entry->fields[spreg_name][i]);
103
      else
104
        new_spr->name[i] = entry->fields[spreg_name][i];
105
    }
106
  }
107
 
108
  /* insert, by spreg_nr order */
109
  {
110
    spreg_table_entry **ptr_to_spreg_entry = &table->sprs;
111
    spreg_table_entry *spreg_entry = *ptr_to_spreg_entry;
112
    while (spreg_entry != NULL && spreg_entry->spreg_nr < new_spr->spreg_nr) {
113
      ptr_to_spreg_entry = &spreg_entry->next;
114
      spreg_entry = *ptr_to_spreg_entry;
115
    }
116
    ASSERT(spreg_entry == NULL || spreg_entry->spreg_nr != new_spr->spreg_nr);
117
    *ptr_to_spreg_entry = new_spr;
118
    new_spr->next = spreg_entry;
119
  }
120
 
121
}
122
 
123
 
124
static spreg_table *
125
spreg_table_load(char *file_name)
126
{
127
  table *file = table_open(file_name, nr_spreg_fields, 0);
128
  spreg_table *table = ZALLOC(spreg_table);
129
 
130
  {
131
    table_entry *entry;
132
    while ((entry = table_entry_read(file)) != NULL) {
133
      spreg_table_insert(table, entry);
134
    }
135
  }
136
 
137
  return table;
138
}
139
 
140
 
141
/****************************************************************/
142
 
143
char *spreg_attributes[] = {
144
  "is_valid",
145
  "is_readonly",
146
  "name",
147
  "index",
148
  "length",
149
 
150
};
151
 
152
static void
153
gen_spreg_h(spreg_table *table, lf *file)
154
{
155
  spreg_table_entry *entry;
156
  char **attribute;
157
 
158
  lf_print__gnu_copyleft(file);
159
  lf_printf(file, "\n");
160
  lf_printf(file, "#ifndef _SPREG_H_\n");
161
  lf_printf(file, "#define _SPREG_H_\n");
162
  lf_printf(file, "\n");
163
  lf_printf(file, "typedef unsigned_word spreg;\n");
164
  lf_printf(file, "\n");
165
  lf_printf(file, "typedef enum {\n");
166
 
167
  for (entry = table->sprs;
168
       entry != NULL ;
169
       entry = entry->next) {
170
    lf_printf(file, "  spr_%s = %d,\n", entry->name, entry->spreg_nr);
171
  }
172
 
173
  lf_printf(file, "  nr_of_sprs = %d\n", nr_of_sprs);
174
  lf_printf(file, "} sprs;\n");
175
  lf_printf(file, "\n");
176
  for (attribute = spreg_attributes;
177
       *attribute != NULL;
178
       attribute++) {
179
    if (strcmp(*attribute, "name") == 0) {
180
      lf_print_function_type(file, "const char *", "INLINE_SPREG", " ");
181
      lf_printf(file, "spr_%s(sprs spr);\n", *attribute);
182
    }
183
    else {
184
      lf_print_function_type(file, "int", "INLINE_SPREG", " ");
185
      lf_printf(file, "spr_%s(sprs spr);\n", *attribute);
186
    }
187
  }
188
  lf_printf(file, "\n");
189
  lf_printf(file, "#endif /* _SPREG_H_ */\n");
190
}
191
 
192
 
193
static void
194
gen_spreg_c(spreg_table *table, lf *file)
195
{
196
  spreg_table_entry *entry;
197
  char **attribute;
198
  int spreg_nr;
199
 
200
  lf_print__gnu_copyleft(file);
201
  lf_printf(file, "\n");
202
  lf_printf(file, "#ifndef _SPREG_C_\n");
203
  lf_printf(file, "#define _SPREG_C_\n");
204
  lf_printf(file, "\n");
205
  lf_printf(file, "#include \"basics.h\"\n");
206
  lf_printf(file, "#include \"spreg.h\"\n");
207
 
208
  lf_printf(file, "\n");
209
  lf_printf(file, "typedef struct _spreg_info {\n");
210
  lf_printf(file, "  char *name;\n");
211
  lf_printf(file, "  int is_valid;\n");
212
  lf_printf(file, "  int length;\n");
213
  lf_printf(file, "  int is_readonly;\n");
214
  lf_printf(file, "  int index;\n");
215
  lf_printf(file, "} spreg_info;\n");
216
  lf_printf(file, "\n");
217
  lf_printf(file, "static spreg_info spr_info[nr_of_sprs+1] = {\n");
218
  entry = table->sprs;
219
  for (spreg_nr = 0; spreg_nr < nr_of_sprs+1; spreg_nr++) {
220
    if (entry == NULL || spreg_nr < entry->spreg_nr)
221
      lf_printf(file, "  { 0, 0, 0, 0, %d},\n", spreg_nr);
222
    else {
223
      lf_printf(file, "  { \"%s\", %d, %d, %d, spr_%s /*%d*/ },\n",
224
                entry->name, 1, entry->length, entry->is_readonly,
225
                entry->name, entry->spreg_nr);
226
      entry = entry->next;
227
    }
228
  }
229
  lf_printf(file, "};\n");
230
 
231
  for (attribute = spreg_attributes;
232
       *attribute != NULL;
233
       attribute++) {
234
    lf_printf(file, "\n");
235
    if (strcmp(*attribute, "name") == 0) {
236
      lf_print_function_type(file, "const char *", "INLINE_SPREG", "\n");
237
    }
238
    else {
239
      lf_print_function_type(file, "int", "INLINE_SPREG", "\n");
240
    }
241
    lf_printf(file, "spr_%s(sprs spr)\n", *attribute);
242
    lf_printf(file, "{\n");
243
    if (spreg_lookup_table
244
        || strcmp(*attribute, "name") == 0
245
        || strcmp(*attribute, "index") == 0)
246
      lf_printf(file, "  return spr_info[spr].%s;\n",
247
                *attribute);
248
    else {
249
      spreg_table_entry *entry;
250
      lf_printf(file, "  switch (spr) {\n");
251
      for (entry = table->sprs; entry != NULL; entry = entry->next) {
252
        lf_printf(file, "  case %d:\n", entry->spreg_nr);
253
        if (strcmp(*attribute, "is_valid") == 0)
254
          lf_printf(file, "    return 1;\n");
255
        else if (strcmp(*attribute, "is_readonly") == 0)
256
          lf_printf(file, "    return %d;\n", entry->is_readonly);
257
        else if (strcmp(*attribute, "length") == 0)
258
          lf_printf(file, "    return %d;\n", entry->length);
259
        else
260
          ASSERT(0);
261
      }
262
      lf_printf(file, "  default:\n");
263
      lf_printf(file, "    return 0;\n");
264
      lf_printf(file, "  }\n");
265
    }
266
    lf_printf(file, "}\n");
267
  }
268
 
269
  lf_printf(file, "\n");
270
  lf_printf(file, "#endif /* _SPREG_C_ */\n");
271
}
272
 
273
 
274
 
275
/****************************************************************/
276
 
277
 
278
int
279
main(int argc,
280
     char **argv,
281
     char **envp)
282
{
283
  lf_file_references file_references = lf_include_references;
284
  spreg_table *sprs = NULL;
285
  char *real_file_name = NULL;
286
  int is_header = 0;
287
  int ch;
288
 
289
  if (argc <= 1) {
290
    printf("Usage: dgen ...\n");
291
    printf("-s  Use switch instead of table\n");
292
    printf("-n <file-name>  Use this as cpp line numbering name\n");
293
    printf("-h  Output header file\n");
294
    printf("-p <spreg-file>  Output spreg.h(P) or spreg.c(p)\n");
295
    printf("-L  Suppress cpp line numbering in output files\n");
296
  }
297
 
298
 
299
  while ((ch = getopt(argc, argv, "hLsn:r:p:")) != -1) {
300
    fprintf(stderr, "\t-%c %s\n", ch, ( optarg ? optarg : ""));
301
    switch(ch) {
302
    case 's':
303
      spreg_lookup_table = 0;
304
      break;
305
    case 'r':
306
      sprs = spreg_table_load(optarg);
307
      break;
308
    case 'n':
309
      real_file_name = strdup(optarg);
310
      break;
311
    case 'L':
312
      file_references = lf_omit_references;
313
      break;
314
    case 'h':
315
      is_header = 1;
316
      break;
317
    case 'p':
318
      {
319
        lf *file = lf_open(optarg, real_file_name, file_references,
320
                           (is_header ? lf_is_h : lf_is_c),
321
                           argv[0]);
322
        if (is_header)
323
          gen_spreg_h(sprs, file);
324
        else
325
          gen_spreg_c(sprs, file);
326
        lf_close(file);
327
        is_header = 0;
328
      }
329
      real_file_name = NULL;
330
      break;
331
    default:
332
      error("unknown option\n");
333
    }
334
  }
335
  return 0;
336
}

powered by: WebSVN 2.1.0

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