292 lines
9.0 KiB
C++
292 lines
9.0 KiB
C++
/*
|
|
* Copyright (c) 2011-2021 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 "architec.h"
|
|
# include "entity.h"
|
|
# include "expression.h"
|
|
# include "sequential.h"
|
|
# include "subprogram.h"
|
|
# include <typeinfo>
|
|
# include <cassert>
|
|
|
|
using namespace std;
|
|
|
|
int Architecture::elaborate(Entity*entity)
|
|
{
|
|
int errors = 0;
|
|
|
|
// Constant assignments in the architecture get their types
|
|
// from the constant declaration itself. Elaborate the value
|
|
// expression with the declared type.
|
|
|
|
for (map<perm_string,struct const_t*>::iterator cur = use_constants_.begin()
|
|
; cur != use_constants_.end() ; ++cur) {
|
|
cur->second->val->elaborate_expr(entity, this, cur->second->typ);
|
|
}
|
|
for (map<perm_string,struct const_t*>::iterator cur = cur_constants_.begin()
|
|
; cur != cur_constants_.end() ; ++cur) {
|
|
cur->second->val->elaborate_expr(entity, this, cur->second->typ);
|
|
}
|
|
|
|
// Elaborate initializer expressions for signals & variables
|
|
for (map<perm_string,Signal*>::iterator cur = old_signals_.begin()
|
|
; cur != old_signals_.end() ; ++cur) {
|
|
cur->second->elaborate(entity, this);
|
|
}
|
|
for (map<perm_string,Signal*>::iterator cur = new_signals_.begin()
|
|
; cur != new_signals_.end() ; ++cur) {
|
|
cur->second->elaborate(entity, this);
|
|
}
|
|
for (map<perm_string,Variable*>::iterator cur = old_variables_.begin()
|
|
; cur != old_variables_.end() ; ++cur) {
|
|
cur->second->elaborate(entity, this);
|
|
}
|
|
for (map<perm_string,Variable*>::iterator cur = new_variables_.begin()
|
|
; cur != new_variables_.end() ; ++cur) {
|
|
cur->second->elaborate(entity, this);
|
|
}
|
|
|
|
// Elaborate subprograms
|
|
for (map<perm_string,SubHeaderList>::const_iterator cur = cur_subprograms_.begin()
|
|
; cur != cur_subprograms_.end() ; ++cur) {
|
|
const SubHeaderList& subp_list = cur->second;
|
|
|
|
for(SubHeaderList::const_iterator it = subp_list.begin();
|
|
it != subp_list.end(); ++it) {
|
|
errors += (*it)->elaborate();
|
|
}
|
|
}
|
|
// Create 'initial' and 'final' blocks for implicit
|
|
// initialization and clean-up actions
|
|
if(!initializers_.empty())
|
|
statements_.push_front(new InitialStatement(&initializers_));
|
|
|
|
if(!finalizers_.empty())
|
|
statements_.push_front(new FinalStatement(&finalizers_));
|
|
|
|
for (list<Architecture::Statement*>::iterator cur = statements_.begin()
|
|
; cur != statements_.end() ; ++cur) {
|
|
|
|
int cur_errors = (*cur)->elaborate(entity, this);
|
|
errors += cur_errors;
|
|
}
|
|
|
|
if (errors > 0) {
|
|
cerr << errors << " errors in "
|
|
<< name_ << " architecture of "
|
|
<< entity->get_name() << "." << endl;
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
int Architecture::Statement::elaborate(Entity*, Architecture*)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ComponentInstantiation::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
|
|
ComponentBase*base = arc->find_component(cname_);
|
|
if (base == 0) {
|
|
cerr << get_fileline() << ": error: No component declaration"
|
|
<< " for instance " << iname_
|
|
<< " of " << cname_ << "." << endl;
|
|
return 1;
|
|
}
|
|
|
|
arc->set_cur_component(this);
|
|
|
|
for (map<perm_string,Expression*>::const_iterator cur = generic_map_.begin()
|
|
; cur != generic_map_.end() ; ++cur) {
|
|
// check if generic from component instantiation
|
|
// exists in the component declaration
|
|
const InterfacePort*iparm = base->find_generic(cur->first);
|
|
if (iparm == 0) {
|
|
cerr << get_fileline() << ": warning: No generic " << cur->first
|
|
<< " in component " << cname_ << "." << endl;
|
|
continue;
|
|
}
|
|
|
|
ExpName* tmp;
|
|
if (cur->second && (tmp = dynamic_cast<ExpName*>(cur->second)))
|
|
errors += tmp->elaborate_rval(ent, arc, iparm);
|
|
|
|
if (cur->second)
|
|
errors += cur->second->elaborate_expr(ent, arc, iparm->type);
|
|
}
|
|
|
|
for (map<perm_string,Expression*>::const_iterator cur = port_map_.begin()
|
|
; cur != port_map_.end() ; ++cur) {
|
|
// check if a port from component instantiation
|
|
// exists in the component declaration
|
|
const InterfacePort*iport = base->find_port(cur->first);
|
|
if (iport == 0) {
|
|
cerr << get_fileline() << ": error: No port " << cur->first
|
|
<< " in component " << cname_ << "." << endl;
|
|
errors += 1;
|
|
continue;
|
|
}
|
|
|
|
ExpName* tmp;
|
|
if (cur->second && (tmp = dynamic_cast<ExpName*>(cur->second)))
|
|
errors += tmp->elaborate_rval(ent, arc, iport);
|
|
/* It is possible for the port to be explicitly
|
|
unconnected. In that case, the Expression will be nil */
|
|
|
|
if (cur->second)
|
|
cur->second->elaborate_expr(ent, arc, iport->type);
|
|
}
|
|
|
|
arc->set_cur_component(NULL);
|
|
|
|
return errors;
|
|
}
|
|
|
|
int GenerateStatement::elaborate_statements(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
for (list<Architecture::Statement*>::iterator cur = statements_.begin()
|
|
; cur != statements_.end() ; ++cur) {
|
|
Architecture::Statement*curp = *cur;
|
|
errors += curp->elaborate(ent, arc);
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
int ForGenerate::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
arc->push_genvar_type(genvar_, lsb_->probe_type(ent, arc));
|
|
errors += elaborate_statements(ent, arc);
|
|
arc->pop_genvar_type();
|
|
return errors;
|
|
}
|
|
|
|
int IfGenerate::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
errors += elaborate_statements(ent, arc);
|
|
return errors;
|
|
}
|
|
|
|
int StatementList::elaborate(Entity*ent, ScopeBase*scope)
|
|
{
|
|
int errors = 0;
|
|
|
|
for (std::list<SequentialStmt*>::iterator it = statements_.begin();
|
|
it != statements_.end(); ++it) {
|
|
errors += (*it)->elaborate(ent, scope);
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
int ProcessStatement::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
|
|
arc->set_cur_process(this);
|
|
|
|
for (map<perm_string,Variable*>::iterator cur = new_variables_.begin()
|
|
; cur != new_variables_.end() ; ++cur) {
|
|
cur->second->elaborate(ent, arc);
|
|
}
|
|
|
|
StatementList::elaborate(ent, arc);
|
|
|
|
arc->set_cur_process(NULL);
|
|
|
|
return errors;
|
|
}
|
|
|
|
int SignalAssignment::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
|
|
// Elaborate the l-value expression.
|
|
errors += lval_->elaborate_lval(ent, arc, false);
|
|
|
|
// The elaborate_lval should have resolved the type of the
|
|
// l-value expression. We'll use that type to elaborate the
|
|
// r-value.
|
|
const VType*lval_type = lval_->peek_type();
|
|
if (lval_type == 0) {
|
|
if (errors == 0) {
|
|
errors += 1;
|
|
cerr << get_fileline() << ": error: Unable to calculate type for l-value expression." << endl;
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
for (list<Expression*>::iterator cur = rval_.begin()
|
|
; cur != rval_.end() ; ++cur) {
|
|
errors += (*cur)->elaborate_expr(ent, arc, lval_type);
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
int CondSignalAssignment::elaborate(Entity*ent, Architecture*arc)
|
|
{
|
|
int errors = 0;
|
|
|
|
// Visitor to extract signal names occurring in the conditional
|
|
// statements to create the sensitivity list
|
|
struct name_extractor_t : public ExprVisitor {
|
|
explicit name_extractor_t(list<const ExpName*>& name_list)
|
|
: name_list_(name_list) {}
|
|
void operator() (Expression*s) {
|
|
if(const ExpName*name = dynamic_cast<const ExpName*>(s))
|
|
name_list_.push_back(name);
|
|
}
|
|
|
|
private:
|
|
list<const ExpName*>& name_list_;
|
|
} name_extractor(sens_list_);
|
|
|
|
// Elaborate the l-value expression.
|
|
errors += lval_->elaborate_lval(ent, arc, true);
|
|
|
|
// The elaborate_lval should have resolved the type of the
|
|
// l-value expression. We'll use that type to elaborate the
|
|
// r-value.
|
|
const VType*lval_type = lval_->peek_type();
|
|
if (lval_type == 0) {
|
|
if (errors == 0) {
|
|
errors += 1;
|
|
cerr << get_fileline()
|
|
<< ": error: Unable to calculate type for l-value expression."
|
|
<< endl;
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
for(list<ExpConditional::case_t*>::iterator it = options_.begin();
|
|
it != options_.end(); ++it) {
|
|
ExpConditional::case_t*cas = (*it);
|
|
cas->elaborate_expr(ent, arc, lval_type);
|
|
cas->visit(name_extractor);
|
|
}
|
|
|
|
return errors;
|
|
}
|