diff options
Diffstat (limited to 'ortho/agcc/gen_tree.c')
| -rw-r--r-- | ortho/agcc/gen_tree.c | 575 |
1 files changed, 575 insertions, 0 deletions
diff --git a/ortho/agcc/gen_tree.c b/ortho/agcc/gen_tree.c new file mode 100644 index 000000000..ff826b408 --- /dev/null +++ b/ortho/agcc/gen_tree.c @@ -0,0 +1,575 @@ +/* Ada bindings for GCC internals - generate Ada files. + Copyright (C) 2002, 2003, 2004, 2005 Tristan Gingold + + GHDL is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2, or (at your option) any later + version. + + GHDL is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING. If not, write to the Free + Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. +*/ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "flags.h" +#include "tree.h" +#include "real.h" +#include "options.h" +#undef abort + +static const char *progname; + +/* Taken from tree.h. */ + + +#define XSTR(X) #X +#define STR(X) XSTR(X) +static const char *treecode_sym[] = +{ +#define DEFTREECODE(SYM, STRING, TYPE, NARGS) #SYM, +#include "tree.def" +#undef DEFTREECODE + NULL +}; + +static const char *treecode_string[] = +{ +#define DEFTREECODE(SYM, STRING, TYPE, NARGS) STRING, +#include "tree.def" +#undef DEFTREECODE + NULL +}; + +void +gen_tree_code (void) +{ + int i, j; + size_t len; + const size_t indent = 24; + + for (i = 0; treecode_sym[i] != NULL; i++) + { + len = strlen (treecode_sym[i]); + printf (" %s, ", treecode_sym[i]); + for (j = len; j < indent; j++) + putchar (' '); + printf ("-- %s\n", treecode_string[i]); + } + printf (" LAST_AND_UNUSED_TREE_CODE\n"); +} + +static const char *built_in_function_sym[] = +{ +#if 0 +#define DEF_BUILTIN(x) #x, +#else +#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, ATTR, IMP) #ENUM, +#endif +#include "builtins.def" +#undef DEF_BUILTIN + NULL +}; + +static void +print_underscore (const char *sym) +{ + for (; *sym != 0; sym++) + { + if (sym[0] == '_' && (sym[1] == '_' || sym[1] == 0)) + fputs ("_u", stdout); + else + fputc (sym[0], stdout); + } +} + +void +gen_built_in_function (void) +{ + int i; + + for (i = 0; built_in_function_sym[i] != NULL; i++) + { + fputs (" ", stdout); + print_underscore (built_in_function_sym[i]); + fputs (",\n", stdout); + } + + printf (" END_BUILTINS\n"); +} + +#if 0 +static const char *machmode_sym[] = +{ +#if 0 +#define DEF_MACHMODE(SYM, NAME, TYPE, BITSIZE, SIZE, UNIT, WIDER) #SYM, +#else +#define DEF_MACHMODE(SYM, NAME, TYPE, BITSIZE, SIZE, UNIT, WIDER, INNER) \ + #SYM, +#endif +#include "machmode.def" +#undef DEF_MACHMODE + NULL +}; +#endif + +static void +gen_machmode (void) +{ + int i; + char line[128]; + FILE *f; + int do_emit; + char *p; + + f = fopen ("insn-modes.h", "r"); + if (f == NULL) + { + fprintf (stderr, "cannot open insn-modes\n"); + exit (1); + } + + do_emit = 0; + while (1) + { + if (fgets (line, sizeof (line), f) == NULL) + break; + if (!do_emit) + { + if (strncmp (line, "enum machine_mode", 17) == 0) + do_emit = 1; + } + else if (memcmp (line, " MAX_MACHINE_MODE,", 19) == 0) + { + fclose (f); + break; + } + else + { + /* Search for " [A-Z0-9_]*mode,". */ + p = line; + if (p[0] != ' ' || p[1] != ' ') + continue; + p += 2; + while ((*p >= 'A' && *p <= 'Z') + || (*p >= '0' && *p <= '9') + || (*p == '_')) + p++; + if (memcmp (p, "mode,", 5) == 0) + { + p[4] = 0; + printf (" %s,\n", line + 2); + } + } + + } + printf (" MAX_MACHINE_MODE\n"); +} + +static void +gen_options_CL (void) +{ + printf (" CL_C : constant Integer := %d;\n", CL_C); + printf (" CL_vhdl : constant Integer := %d;\n", CL_vhdl); +} + +static void +gen_options_OPTs (void) +{ + char line[128]; + FILE *f; + int do_emit; + char *p; + + f = fopen ("options.h", "r"); + if (f == NULL) + { + fprintf (stderr, "cannot open options.h\n"); + exit (1); + } + + do_emit = 0; + while (1) + { + if (fgets (line, sizeof (line), f) == NULL) + break; + if (!do_emit) + { + if (strncmp (line, "enum opt_code", 13) == 0) + do_emit = 1; + } + else if (memcmp (line, " N_OPTS", 9) == 0) + { + fclose (f); + break; + } + else + { + /* Search for " [A-Z0-9]*mode,". */ + p = line; + if (memcmp (p, " OPT_", 6) != 0) + continue; + printf (" OPT"); + for (p = line + 5; *p != ','; p++) + { + if (p[0] == '_' && (p[1] == ',' || p[1] == '_')) + fputs ("_U", stdout); + else + { + if (p[0] >= 'A' && p[0] <= 'Z') + putchar ('U'); + putchar (p[0]); + } + } + printf (",\n"); + } + + } + printf (" N_OPTS\n"); +} + +struct xtab_t +{ + int val; + const char *name; +}; + +void +gen_enumeration (const struct xtab_t *xtab, int max, const char *max_name) +{ + int i; + + for (i = 0; i < max; i++) + { + const struct xtab_t *t; + + for (t = xtab; t->name; t++) + if (t->val == i) + break; + + if (t->name == NULL) + { + fprintf (stderr, "gen_enumeration: kind %d unknown (max is %s)\n", + i, max_name); + exit (1); + } + + printf (" %s,\n", t->name); + } + printf (" %s\n", max_name); +} + +const struct xtab_t size_type_names[] = +{ + { SIZETYPE, "TK_SIZETYPE" }, + { SSIZETYPE, "TK_SSIZETYPE" }, + { USIZETYPE, "TK_USIZETYPE" }, + { BITSIZETYPE, "TK_BITSIZETYPE" }, + { SBITSIZETYPE, "TK_SBITSIZETYPE" }, + { UBITSIZETYPE, "TK_UBITSIZETYPE" }, + { 0, NULL} +}; + +static void +gen_size_type (void) +{ + gen_enumeration (size_type_names, TYPE_KIND_LAST, "TYPE_KIND_LAST"); +} + + +const struct xtab_t type_qual_tab[] = +{ + { TYPE_UNQUALIFIED, "TYPE_UNQUALIFIED" }, + { TYPE_QUAL_CONST, "TYPE_QUAL_CONST" }, + { TYPE_QUAL_VOLATILE, "TYPE_QUAL_VOLATILE" }, + { TYPE_QUAL_RESTRICT, "TYPE_QUAL_RESTRICT" }, + { 0, NULL} +}; + +void +gen_type_qual (void) +{ + const struct xtab_t *t; + for (t = type_qual_tab; t->name; t++) + printf (" %s : constant Type_Qual_Type := %d;\n", t->name, t->val); +} + +const struct xtab_t tree_index_tab[] = +{ + /* Defined in tree.h */ + { TI_ERROR_MARK, "TI_ERROR_MARK" }, + { TI_INTQI_TYPE, "TI_INTQI_TYPE" }, + { TI_INTHI_TYPE, "TI_INTHI_TYPE" }, + { TI_INTSI_TYPE, "TI_INTSI_TYPE" }, + { TI_INTDI_TYPE, "TI_INTDI_TYPE" }, + { TI_INTTI_TYPE, "TI_INTTI_TYPE" }, + + { TI_UINTQI_TYPE, "TI_UINTQI_TYPE" }, + { TI_UINTHI_TYPE, "TI_UINTHI_TYPE" }, + { TI_UINTSI_TYPE, "TI_UINTSI_TYPE" }, + { TI_UINTDI_TYPE, "TI_UINTDI_TYPE" }, + { TI_UINTTI_TYPE, "TI_UINTTI_TYPE" }, + + { TI_INTEGER_ZERO, "TI_INTEGER_ZERO" }, + { TI_INTEGER_ONE, "TI_INTEGER_ONE" }, + { TI_INTEGER_MINUS_ONE, "TI_INTEGER_MINUS_ONE" }, + { TI_NULL_POINTER, "TI_NULL_POINTER" }, + + { TI_SIZE_ZERO, "TI_SIZE_ZERO" }, + { TI_SIZE_ONE, "TI_SIZE_ONE" }, + + { TI_BITSIZE_ZERO, "TI_BITSIZE_ZERO" }, + { TI_BITSIZE_ONE, "TI_BITSIZE_ONE" }, + { TI_BITSIZE_UNIT, "TI_BITSIZE_UNIT" }, + + { TI_PUBLIC, "TI_PUBLIC" }, + { TI_PROTECTED, "TI_PROTECTED" }, + { TI_PRIVATE, "TI_PRIVATE" }, + + { TI_BOOLEAN_FALSE, "TI_BOOLEAN_FALSE" }, + { TI_BOOLEAN_TRUE, "TI_BOOLEAN_TRUE" }, + + { TI_COMPLEX_INTEGER_TYPE, "TI_COMPLEX_INTEGER_TYPE" }, + { TI_COMPLEX_FLOAT_TYPE, "TI_COMPLEX_FLOAT_TYPE" }, + { TI_COMPLEX_DOUBLE_TYPE, "TI_COMPLEX_DOUBLE_TYPE" }, + { TI_COMPLEX_LONG_DOUBLE_TYPE, "TI_COMPLEX_LONG_DOUBLE_TYPE" }, + + { TI_FLOAT_TYPE, "TI_FLOAT_TYPE" }, + { TI_DOUBLE_TYPE, "TI_DOUBLE_TYPE" }, + { TI_LONG_DOUBLE_TYPE, "TI_LONG_DOUBLE_TYPE" }, + + { TI_FLOAT_PTR_TYPE, "TI_FLOAT_PTR_TYPE" }, + { TI_DOUBLE_PTR_TYPE, "TI_DOUBLE_PTR_TYPE" }, + { TI_LONG_DOUBLE_PTR_TYPE, "TI_LONG_DOUBLE_PTR_TYPE" }, + { TI_INTEGER_PTR_TYPE, "TI_INTEGER_PTR_TYPE" }, + + { TI_VOID_TYPE, "TI_VOID_TYPE" }, + { TI_PTR_TYPE, "TI_PTR_TYPE" }, + { TI_CONST_PTR_TYPE, "TI_CONST_PTR_TYPE" }, + { TI_SIZE_TYPE, "TI_SIZE_TYPE" }, + { TI_PTRDIFF_TYPE, "TI_PTRDIFF_TYPE" }, + { TI_VA_LIST_TYPE, "TI_VA_LIST_TYPE" }, + { TI_BOOLEAN_TYPE, "TI_BOOLEAN_TYPE" }, + + { TI_VOID_LIST_NODE, "TI_VOID_LIST_NODE" }, + + { TI_UV4SF_TYPE, "TI_UV4SF_TYPE" }, + { TI_UV4SI_TYPE, "TI_UV4SI_TYPE" }, + { TI_UV8HI_TYPE, "TI_UV8HI_TYPE" }, + { TI_UV8QI_TYPE, "TI_UV8QI_TYPE" }, + { TI_UV4HI_TYPE, "TI_UV4HI_TYPE" }, + { TI_UV2HI_TYPE, "TI_UV2HI_TYPE" }, + { TI_UV2SI_TYPE, "TI_UV2SI_TYPE" }, + { TI_UV2SF_TYPE, "TI_UV2SF_TYPE" }, + { TI_UV2DI_TYPE, "TI_UV2DI_TYPE" }, + { TI_UV1DI_TYPE, "TI_UV1DI_TYPE" }, + { TI_UV16QI_TYPE, "TI_UV16QI_TYPE" }, + + { TI_V4SF_TYPE, "TI_V4SF_TYPE" }, + { TI_V16SF_TYPE, "TI_V16SF_TYPE" }, + { TI_V4SI_TYPE, "TI_V4SI_TYPE" }, + { TI_V8HI_TYPE, "TI_V8HI_TYPE" }, + { TI_V8QI_TYPE, "TI_V8QI_TYPE" }, + { TI_V4HI_TYPE, "TI_V4HI_TYPE" }, + { TI_V2HI_TYPE, "TI_V2HI_TYPE" }, + { TI_V2SI_TYPE, "TI_V2SI_TYPE" }, + { TI_V2SF_TYPE, "TI_V2SF_TYPE" }, + { TI_V2DF_TYPE, "TI_V2DF_TYPE" }, + { TI_V2DI_TYPE, "TI_V2DI_TYPE" }, + { TI_V1DI_TYPE, "TI_V1DI_TYPE" }, + { TI_V16QI_TYPE, "TI_V16QI_TYPE" }, + { TI_V4DF_TYPE, "TI_V4DF_TYPE" }, + + { TI_MAIN_IDENTIFIER, "TI_MAIN_IDENTIFIER" }, + + { 0, NULL } +}; + +const struct xtab_t integer_types_tab[] = +{ + { itk_char, "itk_char" }, + { itk_signed_char, "itk_signed_char" }, + { itk_unsigned_char, "itk_unsigned_char" }, + { itk_short, "itk_short" }, + { itk_unsigned_short, "itk_unsigned_short" }, + { itk_int, "itk_int" }, + { itk_unsigned_int, "itk_unsigned_int" }, + { itk_long, "itk_long" }, + { itk_unsigned_long, "itk_unsigned_long" }, + { itk_long_long, "itk_long_long" }, + { itk_unsigned_long_long, "itk_unsigned_long_long" }, + { 0, NULL } +}; + + +void +gen_tree_index (void) +{ + gen_enumeration (tree_index_tab, TI_MAX, "TI_MAX"); +} + +void +gen_integer_types (void) +{ + gen_enumeration (integer_types_tab, itk_none, "itk_none"); +} + +static void +gen_host_wide_int_decl (void) +{ + int l; + switch (sizeof (HOST_WIDE_INT)) + { + case 4: + l = 32; + break; + case 8: + l = 64; + break; + default: + fprintf (stderr, "%s: cannot handle sizeof (HOST_WIDE_INT) %d\n", + progname, sizeof (HOST_WIDE_INT)); + exit (1); + } + printf (" type HOST_WIDE_INT is new Interfaces.Integer_%d;\n", l); + printf (" type UNSIGNED_HOST_WIDE_INT is new Interfaces.Unsigned_%d;\n", + l); +} + +static void +gen_host_big_endian (void) +{ +#ifdef HOST_WORDS_BIG_ENDIAN + printf (" HOST_WORDS_BIG_ENDIAN : constant Boolean := True;\n"); +#else + printf (" HOST_WORDS_BIG_ENDIAN : constant Boolean := False;\n"); +#endif +} + +static void +gen_real (void) +{ + printf (" type Real_Value_Type_Arr is array (0 .. %d) of HOST_WIDE_INT;\n", + (sizeof (REAL_VALUE_TYPE) / sizeof (HOST_WIDE_INT)) - 1); + printf (" type REAL_VALUE_TYPE is record\n" + " r : Real_Value_Type_Arr;\n" + " end record;\n"); +} + +static void +gen_tm (void) +{ +#ifndef MAX_BITS_PER_WORD +#define MAX_BITS_PER_WORD BITS_PER_WORD +#endif + /* This is a constant. */ + printf (" MAX_BITS_PER_WORD : constant Natural := %d;\n", + MAX_BITS_PER_WORD); +} + +int +main (int argc, char *argv[]) +{ + FILE *infile; + char line[2048]; + const char *filename; + int c; + + progname = argv[0]; + + while ((c = getopt (argc, argv, "C:")) != -1) + switch (c) + { + case 'C': + chdir (optarg); + break; + case '?': + fprintf (stderr, "%s: unknown option '%s'\n", progname, optopt); + exit (1); + default: + abort (); + } + + if (argc - optind != 1) + { + fprintf (stderr, "usage: %s FILENAME\n", progname); + exit (1); + } + filename = argv[optind]; + if (strcmp (filename, "-") == 0) + infile = stdin; + else + infile = fopen (filename, "r"); + if (infile == NULL) + { + fprintf (stderr, "%s: cannot open %s (%s)\n", progname, filename, + strerror (errno)); + exit (1); + } +#if 0 +#ifdef REAL_IS_NOT_DOUBLE + printf ("-- REAL_IS_NOT_DOUBLE is not yet implemented\n"); + printf ("You loose\n"); + return 1; +#endif +#endif + printf ("-- Automatically generated by %s\n", progname); + printf ("-- from %s\n", filename); + printf ("-- DO NOT EDIT THIS FILE\n"); + + while (fgets (line, sizeof (line), infile) != NULL) + { + if (line[0] != '@') + fputs (line, stdout); + else + { + char *p; + + for (p = line + 1; isalpha (*p) || *p == '_'; p++) + ; + *p = 0; + + if (!strcmp (line, "@tree_code")) + gen_tree_code (); + else if (!strcmp (line, "@built_in_function")) + gen_built_in_function (); + else if (!strcmp (line, "@size_type_kind")) + gen_size_type (); + else if (!strcmp (line, "@type_qual")) + gen_type_qual (); + else if (!strcmp (line, "@host_wide_int")) + gen_host_wide_int_decl (); + else if (!strcmp (line, "@tree_index")) + gen_tree_index (); + else if (!strcmp (line, "@integer_types")) + gen_integer_types (); + else if (!strcmp (line, "@host_big_endian")) + gen_host_big_endian (); + else if (!strcmp (line, "@real")) + gen_real (); + else if (!strcmp (line, "@machmode")) + gen_machmode (); + else if (!strcmp (line, "@tm")) + gen_tm (); + else if (!strcmp (line, "@options_CL")) + gen_options_CL (); + else if (!strcmp (line, "@options_OPTs")) + gen_options_OPTs (); + else + { + fprintf (stderr, "unknown code `%s'\n", line); + exit (1); + } + } + } + return 0; +} |