1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/* Ghdlsynth -*- C++ -*- interface
This file is part of GHDL.
This program 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 of the License, or
(at your option) any later version.
This program 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 this program. If not, see <gnu.org/licenses>.
*/
namespace GhdlSynth {
struct logic_32 {
unsigned int va;
unsigned int zx;
};
// Use struct wrappers for type safety.
// Convention: W for wrapped, D for direct, B for boolean.
#define GHDLSYNTH_ADA_PREFIX(N) netlists__##N
#define GHDLSYNTH_ADA_WRAPPER_WW(NAME, RESTYPE, ARGTYPE) \
extern "C" unsigned int GHDLSYNTH_ADA_PREFIX(NAME) (unsigned int); \
inline RESTYPE NAME(ARGTYPE arg) { \
RESTYPE res; \
res.id = GHDLSYNTH_ADA_PREFIX(NAME) (arg.id); \
return res; \
}
#define GHDLSYNTH_ADA_WRAPPER_WWD(NAME, RESTYPE, ARGTYPE1, ARGTYPE2) \
extern "C" unsigned int GHDLSYNTH_ADA_PREFIX(NAME) (unsigned int, ARGTYPE2);\
inline RESTYPE NAME(ARGTYPE1 arg1, ARGTYPE2 arg2) { \
RESTYPE res; \
res.id = GHDLSYNTH_ADA_PREFIX(NAME) (arg1.id, arg2); \
return res; \
}
#define GHDLSYNTH_ADA_WRAPPER_DWD(NAME, RESTYPE, ARGTYPE1, ARGTYPE2) \
extern "C" RESTYPE GHDLSYNTH_ADA_PREFIX(NAME) (unsigned int, ARGTYPE2);\
inline RESTYPE NAME(ARGTYPE1 arg1, ARGTYPE2 arg2) { \
return GHDLSYNTH_ADA_PREFIX(NAME) (arg1.id, arg2); \
}
#define GHDLSYNTH_ADA_WRAPPER_DW(NAME, RESTYPE, ARGTYPE) \
extern "C" RESTYPE GHDLSYNTH_ADA_PREFIX(NAME) (unsigned int); \
inline RESTYPE NAME(ARGTYPE arg) { \
return GHDLSYNTH_ADA_PREFIX(NAME) (arg.id); \
}
#define GHDLSYNTH_ADA_WRAPPER_BW(NAME, ARGTYPE) \
extern "C" unsigned int GHDLSYNTH_ADA_PREFIX(NAME) (unsigned int); \
inline bool NAME(ARGTYPE arg) { \
return (GHDLSYNTH_ADA_PREFIX(NAME) (arg.id) & 1); \
}
#define GHDLSYNTH_ADA_WRAPPER_BWD(NAME, ARGTYPE1, ARGTYPE2) \
extern "C" unsigned int GHDLSYNTH_ADA_PREFIX(NAME) (unsigned, unsigned); \
inline bool NAME(ARGTYPE1 arg1, ARGTYPE2 arg2) { \
return (GHDLSYNTH_ADA_PREFIX(NAME) (arg1.id, arg2) & 1); \
}
struct Name_Id { unsigned int id; };
extern "C" const char *name_table__get_address (unsigned int);
inline const char *get_cstr(Name_Id n) {
return name_table__get_address (n.id);
}
extern "C" unsigned name_table__get_identifier_with_len(const char *s, unsigned l);
inline Name_Id get_identifier(const char *s) {
Name_Id n;
n.id = name_table__get_identifier_with_len(s, strlen(s));
return n;
}
struct Sname { unsigned int id; };
const Sname No_Sname = {0 };
enum Sname_Kind { Sname_User, Sname_Artificial, Sname_Version };
GHDLSYNTH_ADA_WRAPPER_DW(get_sname_kind, Sname_Kind, Sname);
inline bool is_valid(Sname l) { return l.id != 0; }
GHDLSYNTH_ADA_WRAPPER_WW(get_sname_prefix, Sname, Sname);
GHDLSYNTH_ADA_WRAPPER_WW(get_sname_suffix, Name_Id, Sname);
GHDLSYNTH_ADA_WRAPPER_DW(get_sname_version, unsigned int, Sname);
typedef unsigned int Width;
typedef unsigned int Port_Idx;
typedef unsigned int Param_Idx;
struct Pval { unsigned int id; };
#include "ghdl/synth_gates.h"
struct Module { unsigned int id; };
inline bool is_valid(Module m) { return m.id != 0; }
GHDLSYNTH_ADA_WRAPPER_WW(get_module_name, Sname, Module);
GHDLSYNTH_ADA_WRAPPER_WW(get_first_sub_module, Module, Module);
GHDLSYNTH_ADA_WRAPPER_WW(get_next_sub_module, Module, Module);
GHDLSYNTH_ADA_WRAPPER_DW(get_id, Module_Id, Module);
GHDLSYNTH_ADA_WRAPPER_DW(get_nbr_outputs, unsigned int, Module);
GHDLSYNTH_ADA_WRAPPER_DW(get_nbr_inputs, unsigned int, Module);
GHDLSYNTH_ADA_WRAPPER_DW(get_nbr_params, unsigned int, Module);
struct Net { unsigned int id; };
GHDLSYNTH_ADA_WRAPPER_DW(get_width, Width, Net);
struct Instance { unsigned int id; };
inline bool is_valid(Instance inst) { return inst.id != 0; }
GHDLSYNTH_ADA_WRAPPER_WW(get_self_instance, Instance, Module);
GHDLSYNTH_ADA_WRAPPER_WW(get_first_instance, Instance, Module);
GHDLSYNTH_ADA_WRAPPER_WW(get_next_instance, Instance, Instance);
GHDLSYNTH_ADA_WRAPPER_WW(get_instance_name, Sname, Instance);
GHDLSYNTH_ADA_WRAPPER_WW(get_module, Module, Instance);
GHDLSYNTH_ADA_WRAPPER_WW(get_net_parent, Instance, Net);
GHDLSYNTH_ADA_WRAPPER_DWD(get_param_uns32, unsigned int, Instance, Param_Idx);
GHDLSYNTH_ADA_WRAPPER_WWD(get_param_pval, Pval, Instance, Param_Idx);
GHDLSYNTH_ADA_WRAPPER_DW(get_pval_length, unsigned int, Pval);
GHDLSYNTH_ADA_WRAPPER_DWD(read_pval, struct logic_32, Pval, unsigned int);
struct Input { unsigned int id; };
GHDLSYNTH_ADA_WRAPPER_WWD(get_input, Input, Instance, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_WWD(get_output, Net, Instance, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_WW(get_driver, Net, Input);
GHDLSYNTH_ADA_WRAPPER_WW(get_input_parent, Instance, Input);
GHDLSYNTH_ADA_WRAPPER_WW(get_first_sink, Input, Net);
GHDLSYNTH_ADA_WRAPPER_WW(get_next_sink, Input, Input);
struct Attribute { unsigned int id; };
GHDLSYNTH_ADA_WRAPPER_WW(get_first_attribute, Attribute, Instance);
GHDLSYNTH_ADA_WRAPPER_WW(get_attribute_name, Name_Id, Attribute);
GHDLSYNTH_ADA_WRAPPER_DW(get_attribute_type, Param_Type, Attribute);
GHDLSYNTH_ADA_WRAPPER_WW(get_attribute_pval, Pval, Attribute);
GHDLSYNTH_ADA_WRAPPER_WW(get_attribute_next, Attribute, Attribute);
// Utils
#undef GHDLSYNTH_ADA_PREFIX
#define GHDLSYNTH_ADA_PREFIX(N) netlists__utils__##N
GHDLSYNTH_ADA_WRAPPER_DW(get_id, Module_Id, Instance);
GHDLSYNTH_ADA_WRAPPER_WWD(get_input_name, Sname, Module, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_WWD(get_output_name, Sname, Module, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_DWD(get_input_width, Width, Module, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_DWD(get_output_width, Width, Module, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_BWD(get_inout_flag, Module, Port_Idx);
GHDLSYNTH_ADA_WRAPPER_WWD(get_param_name, Sname, Module, Param_Idx);
GHDLSYNTH_ADA_WRAPPER_DWD(get_param_type, Param_Type, Module, Param_Idx);
GHDLSYNTH_ADA_WRAPPER_BW(has_one_connection, Net);
GHDLSYNTH_ADA_WRAPPER_WWD(get_input_net, Net, Instance, Port_Idx);
extern "C" unsigned int ghdlsynth__ghdl_synth(int init,
int argc, const char **argv);
inline Module ghdl_synth(int init, int argc, const char **argv) {
Module res;
res.id = ghdlsynth__ghdl_synth(init, argc, argv);
return res;
}
// Disp ghdl configuration.
extern "C" void ghdlcomp__disp_config (void);
// Initialize the whole library.
extern "C" void libghdl_init (void);
// More initialization for synthesis.
extern "C" void ghdlsynth__init_for_ghdl_synth (void);
};
|
