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
|
/*
* Copyright (c) 2011-2022 Stephen Williams (steve@icarus.com)
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
# include "netlist.h"
# include "netstruct.h"
# include "netvector.h"
# include <iostream>
# include "ivl_assert.h"
using namespace std;
netstruct_t::netstruct_t()
: union_(false), packed_(false), signed_(false)
{
}
netstruct_t::~netstruct_t()
{
}
void netstruct_t::union_flag(bool flag)
{
// This MUST be called before any members are pushed into the
// definition. This is because the append relies on this flag
// being accurate.
ivl_assert(*this, members_.empty());
union_ = flag;
}
void netstruct_t::packed(bool flag)
{
ivl_assert(*this, members_.empty());
packed_ = flag;
}
void netstruct_t::append_member(Design*des, const netstruct_t::member_t&val)
{
ivl_assert(*this, val.net_type);
members_.push_back(val);
if (packed_) {
if (! members_.back().net_type->packed()) {
cerr << get_fileline() << ": error: "
<< "Member " << members_.back().name
<< " of packed struct/union"
<< " must be packed." << endl;
des->errors += 1;
}
}
if (union_ && packed_ && members_.size() > 1) {
unsigned long expect_wid = members_.front().net_type->packed_width();
unsigned long got_wid = members_.back().net_type->packed_width();
if (expect_wid != got_wid) {
cerr << get_fileline() << ": error: "
<< "Member " << val.name
<< " of packed union"
<< " is " << got_wid
<< " bits, expecting " << expect_wid << " bits." << endl;
des->errors += 1;
}
}
}
const netstruct_t::member_t* netstruct_t::packed_member(perm_string name, unsigned long&off) const
{
unsigned long count_off = 0;
for (size_t idx = members_.size() ; idx > 0 ; idx -= 1) {
if (members_[idx-1].name == name) {
off = count_off;
return &members_[idx-1];
}
// If this is not a union, then the members are lined up
// from LSB to MSB. If this is a union, then all
// members are at offset 0.
if (!union_)
count_off += members_[idx-1].net_type->packed_width();
}
return 0;
}
long netstruct_t::packed_width(void) const
{
if (! packed_)
return -1;
// If this is a packed union, then all the members are the
// same width, so it is sufficient to return the width of any
// single member.
if (union_)
return members_.front().net_type->packed_width();
// The width of a packed struct is the sum of member widths.
long res = 0;
for (size_t idx = 0 ; idx < members_.size() ; idx += 1)
res += members_[idx].net_type->packed_width();
return res;
}
netranges_t netstruct_t::slice_dimensions() const
{
netranges_t tmp;
tmp .push_back(netrange_t(packed_width()-1, 0));
return tmp;
}
ivl_variable_type_t netstruct_t::base_type() const
{
if (! packed_)
return IVL_VT_NO_TYPE;
for (size_t idx = 0 ; idx < members_.size() ; idx += 1) {
if (members_[idx].data_type() != IVL_VT_BOOL)
return members_[idx].data_type();
}
return IVL_VT_BOOL;
}
bool netstruct_t::test_compatibility(ivl_type_t that) const
{
return packed_type_compatible(that);
}
bool netstruct_t::test_equivalence(ivl_type_t that) const
{
if (!packed_)
return this == that;
return packed_types_equivalent(this, that);
}
|
