代码拉取完成，页面将自动刷新
/*
* Copyright (c) 2000-2018 Stephen Williams (steve@icarus.com)
* Copyright CERN 2013 / 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 "config.h"
# include <iostream>
# include <cstring>
# include <cstdio> // sprintf()
# include "compiler.h"
# include "t-dll.h"
# include "netclass.h"
# include "netmisc.h"
# include "discipline.h"
# include <cstdlib>
# include "ivl_assert.h"
# include "ivl_alloc.h"
struct dll_target dll_target_obj;
#if defined(__WIN32__)
inline ivl_dll_t ivl_dlopen(const char *name)
{
ivl_dll_t res = (ivl_dll_t) LoadLibrary(name);
return res;
}
inline void * ivl_dlsym(ivl_dll_t dll, const char *nm)
{
return (void*)GetProcAddress((HMODULE)dll, nm);
}
inline void ivl_dlclose(ivl_dll_t dll)
{
FreeLibrary((HMODULE)dll);
}
const char *dlerror(void)
{
static char msg[256];
unsigned long err = GetLastError();
FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &msg,
sizeof(msg) - 1,
NULL
);
return msg;
}
#elif defined(HAVE_DLFCN_H)
inline ivl_dll_t ivl_dlopen(const char*name)
{ return dlopen(name,RTLD_LAZY); }
inline void* ivl_dlsym(ivl_dll_t dll, const char*nm)
{
void*sym = dlsym(dll, nm);
/* Not found? try without the leading _ */
if (sym == 0 && nm[0] == '_')
sym = dlsym(dll, nm+1);
return sym;
}
inline void ivl_dlclose(ivl_dll_t dll)
{ dlclose(dll); }
#elif defined(HAVE_DL_H)
inline ivl_dll_t ivl_dlopen(const char*name)
{ return shl_load(name, BIND_IMMEDIATE, 0); }
inline void* ivl_dlsym(ivl_dll_t dll, const char*nm)
{
void*sym;
int rc = shl_findsym(&dll, nm, TYPE_PROCEDURE, &sym);
return (rc == 0) ? sym : 0;
}
inline void ivl_dlclose(ivl_dll_t dll)
{ shl_unload(dll); }
inline const char*dlerror(void)
{ return strerror( errno ); }
#endif
ivl_scope_s::ivl_scope_s()
{
func_type = IVL_VT_NO_TYPE;
func_signed = false;
func_width = 0;
}
/*
* The custom new operator for the ivl_nexus_s type allows us to
* allocate nexus objects in blocks. There are generally lots of them
* permanently allocated, and allocating them in blocks reduces the
* allocation overhead.
*/
template <class TYPE> void* pool_permalloc(size_t s)
{
static TYPE * pool_ptr = 0;
static int pool_remaining = 0;
static const size_t POOL_SIZE = 4096;
assert(s == sizeof(TYPE));
if (pool_remaining <= 0) {
pool_ptr = new TYPE[POOL_SIZE];
pool_remaining = POOL_SIZE;
}
TYPE*tmp = pool_ptr;
pool_ptr += 1;
pool_remaining -= 1;
return tmp;
}
void* ivl_nexus_s::operator new(size_t s)
{
return pool_permalloc<struct ivl_nexus_s>(s);
}
void ivl_nexus_s::operator delete(void*, size_t)
{
assert(0);
}
void* ivl_net_const_s::operator new(size_t s)
{
return pool_permalloc<struct ivl_net_const_s>(s);
}
void ivl_net_const_s::operator delete(void*, size_t)
{
assert(0);
}
static StringHeapLex net_const_strings;
static perm_string make_scope_name(const hname_t&name)
{
if (! name.has_numbers())
return name.peek_name();
char buf[1024];
snprintf(buf, sizeof buf, "%s", name.peek_name().str());
char*cp = buf + strlen(buf);
size_t ncp = sizeof buf - (cp-buf);
for (size_t idx = 0 ; idx < name.has_numbers() ; idx += 1) {
int len = snprintf(cp, ncp, "[%d]", name.peek_number(idx));
cp += len;
ncp -= len;
}
return lex_strings.make(buf);
}
static void drive_from_link(const Link&lnk, ivl_drive_t&drv0, ivl_drive_t&drv1)
{
drv0 = lnk.drive0();
drv1 = lnk.drive1();
}
ivl_attribute_s* dll_target::fill_in_attributes(const Attrib*net)
{
ivl_attribute_s*attr;
unsigned nattr = net->attr_cnt();
if (nattr == 0)
return 0;
attr = new struct ivl_attribute_s[nattr];
for (unsigned idx = 0 ; idx < nattr ; idx += 1) {
verinum tmp = net->attr_value(idx);
attr[idx].key = net->attr_key(idx);
if (tmp.is_string()) {
attr[idx].type = IVL_ATT_STR;
attr[idx].val.str = strings_.add(tmp.as_string().c_str());
} else if (tmp == verinum()) {
attr[idx].type = IVL_ATT_VOID;
} else {
attr[idx].type = IVL_ATT_NUM;
attr[idx].val.num = tmp.as_long();
}
}
return attr;
}
/*
* This function locates an ivl_scope_t object that matches the
* NetScope object. The search works by looking for the parent scope,
* then scanning the parent scope for the NetScope object.
*/
static ivl_scope_t find_scope_from_root(ivl_scope_t root, const NetScope*cur)
{
if (const NetScope*par = cur->parent()) {
ivl_scope_t parent = find_scope_from_root(root, par);
if (parent == 0) {
return 0;
}
map<hname_t,ivl_scope_t>::iterator idx = parent->children.find(cur->fullname());
if (idx == parent->children.end())
return 0;
else
return idx->second;
} else {
perm_string cur_name = make_scope_name(cur->fullname());
if (strcmp(root->name_, cur_name) == 0)
return root;
}
return 0;
}
ivl_scope_t dll_target::find_scope(ivl_design_s &des, const NetScope*cur)
{
assert(cur);
// If the scope is a PACKAGE, then it is a special kind of
// root scope and it in the packages array instead.
if (cur->type() == NetScope::PACKAGE) {
perm_string cur_name = cur->module_name();
for (size_t idx = 0 ; idx < des.packages.size() ; idx += 1) {
if (des.packages[idx]->name_ == cur_name)
return des.packages[idx];
}
return 0;
}
if (cur->type() == NetScope::CLASS) {
ivl_scope_t tmp = des.classes[cur];
return tmp;
}
for (unsigned idx = 0; idx < des.roots.size(); idx += 1) {
assert(des.roots[idx]);
ivl_scope_t scope = find_scope_from_root(des.roots[idx], cur);
if (scope)
return scope;
}
for (size_t idx = 0; idx < des.packages.size(); idx += 1) {
assert(des.packages[idx]);
ivl_scope_t scope = find_scope_from_root(des.packages[idx], cur);
if (scope)
return scope;
}
for (map<const NetScope*,ivl_scope_t>::iterator idx = des.classes.begin()
; idx != des.classes.end() ; ++ idx) {
ivl_scope_t scope = find_scope_from_root(idx->second, cur);
if (scope)
return scope;
}
return 0;
}
ivl_scope_t dll_target::lookup_scope_(const NetScope*cur)
{
return find_scope(des_, cur);
}
/*
* This is a convenience function to locate an ivl_signal_t object
* given the NetESignal that has the signal name.
*/
ivl_signal_t dll_target::find_signal(ivl_design_s &des, const NetNet*net)
{
ivl_scope_t scope = find_scope(des, net->scope());
assert(scope);
perm_string nname = net->name();
for (unsigned idx = 0 ; idx < scope->sigs_.size() ; idx += 1) {
if (strcmp(scope->sigs_[idx]->name_, nname) == 0)
return scope->sigs_[idx];
}
assert(0);
return 0;
}
static ivl_nexus_t nexus_sig_make(ivl_signal_t net, unsigned pin)
{
ivl_nexus_t tmp = new struct ivl_nexus_s;
tmp->ptrs_.resize(1);
tmp->ptrs_[0].pin_ = pin;
tmp->ptrs_[0].type_ = __NEXUS_PTR_SIG;
tmp->ptrs_[0].l.sig = net;
ivl_drive_t drive = IVL_DR_HiZ;
switch (ivl_signal_type(net)) {
case IVL_SIT_REG:
drive = IVL_DR_STRONG;
break;
default:
break;
}
tmp->ptrs_[0].drive0 = drive;
tmp->ptrs_[0].drive1 = drive;
return tmp;
}
static void nexus_sig_add(ivl_nexus_t nex, ivl_signal_t net, unsigned pin)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
ivl_drive_t drive = IVL_DR_HiZ;
switch (ivl_signal_type(net)) {
case IVL_SIT_REG:
drive = IVL_DR_STRONG;
break;
default:
break;
}
nex->ptrs_[top].type_= __NEXUS_PTR_SIG;
nex->ptrs_[top].drive0 = drive;
nex->ptrs_[top].drive1 = drive;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.sig= net;
}
static void nexus_bra_add(ivl_nexus_t nex, ivl_branch_t net, unsigned pin)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
nex->ptrs_[top].type_= __NEXUS_PTR_BRA;
nex->ptrs_[top].drive0 = 0;
nex->ptrs_[top].drive1 = 0;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.bra= net;
}
/*
* Add the pin of the logic object to the nexus, and return the nexus
* pointer used for the pin.
*
* NOTE: This pointer is only valid until another pin is added to the
* nexus.
*/
static ivl_nexus_ptr_t nexus_log_add(ivl_nexus_t nex,
ivl_net_logic_t net,
unsigned pin)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
nex->ptrs_[top].type_= __NEXUS_PTR_LOG;
nex->ptrs_[top].drive0 = (pin == 0)? IVL_DR_STRONG : IVL_DR_HiZ;
nex->ptrs_[top].drive1 = (pin == 0)? IVL_DR_STRONG : IVL_DR_HiZ;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.log= net;
return & (nex->ptrs_[top]);
}
static void nexus_con_add(ivl_nexus_t nex, ivl_net_const_t net, unsigned pin,
ivl_drive_t drive0, ivl_drive_t drive1)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
nex->ptrs_[top].type_= __NEXUS_PTR_CON;
nex->ptrs_[top].drive0 = drive0;
nex->ptrs_[top].drive1 = drive1;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.con= net;
}
static void nexus_lpm_add(ivl_nexus_t nex, ivl_lpm_t net, unsigned pin,
ivl_drive_t drive0, ivl_drive_t drive1)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
nex->ptrs_[top].type_= __NEXUS_PTR_LPM;
nex->ptrs_[top].drive0 = drive0;
nex->ptrs_[top].drive1 = drive1;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.lpm= net;
}
static void nexus_switch_add(ivl_nexus_t nex, ivl_switch_t net, unsigned pin)
{
unsigned top = nex->ptrs_.size();
nex->ptrs_.resize(top+1);
nex->ptrs_[top].type_= __NEXUS_PTR_SWI;
nex->ptrs_[top].drive0 = IVL_DR_HiZ;
nex->ptrs_[top].drive1 = IVL_DR_HiZ;
nex->ptrs_[top].pin_ = pin;
nex->ptrs_[top].l.swi= net;
}
void scope_add_logic(ivl_scope_t scope, ivl_net_logic_t net)
{
if (scope->nlog_ == 0) {
scope->nlog_ = 1;
scope->log_ = (ivl_net_logic_t*)malloc(sizeof(ivl_net_logic_t));
scope->log_[0] = net;
} else {
scope->nlog_ += 1;
scope->log_ = (ivl_net_logic_t*)
realloc(scope->log_, scope->nlog_*sizeof(ivl_net_logic_t));
scope->log_[scope->nlog_-1] = net;
}
}
void scope_add_event(ivl_scope_t scope, ivl_event_t net)
{
if (scope->nevent_ == 0) {
scope->nevent_ = 1;
scope->event_ = (ivl_event_t*)malloc(sizeof(ivl_event_t));
scope->event_[0] = net;
} else {
scope->nevent_ += 1;
scope->event_ = (ivl_event_t*)
realloc(scope->event_, scope->nevent_*sizeof(ivl_event_t));
scope->event_[scope->nevent_-1] = net;
}
}
static void scope_add_lpm(ivl_scope_t scope, ivl_lpm_t net)
{
if (scope->nlpm_ == 0) {
assert(scope->lpm_ == 0);
scope->nlpm_ = 1;
scope->lpm_ = (ivl_lpm_t*)malloc(sizeof(ivl_lpm_t));
scope->lpm_[0] = net;
} else {
assert(scope->lpm_);
scope->nlpm_ += 1;
scope->lpm_ = (ivl_lpm_t*)
realloc(scope->lpm_,
scope->nlpm_*sizeof(ivl_lpm_t));
scope->lpm_[scope->nlpm_-1] = net;
}
}
static void scope_add_switch(ivl_scope_t scope, ivl_switch_t net)
{
scope->switches.push_back(net);
}
ivl_parameter_t dll_target::scope_find_param(ivl_scope_t scope,
const char*name)
{
unsigned idx = 0;
while (idx < scope->param.size()) {
if (strcmp(name, scope->param[idx].basename) == 0)
return &scope->param[idx];
idx += 1;
}
return 0;
}
/*
* This method scans the parameters of the scope, and makes
* ivl_parameter_t objects. This involves saving the name and scanning
* the expression value.
*/
void dll_target::make_scope_parameters(ivl_scope_t scop, const NetScope*net)
{
if (net->parameters.empty()) {
scop->param.clear();
return;
}
scop->param.resize(net->parameters.size());
unsigned idx = 0;
typedef map<perm_string,NetScope::param_expr_t>::const_iterator pit_t;
for (pit_t cur_pit = net->parameters.begin()
; cur_pit != net->parameters.end() ; ++ cur_pit ) {
assert(idx < scop->param.size());
ivl_parameter_t cur_par = &scop->param[idx];
cur_par->basename = cur_pit->first;
cur_par->local = cur_pit->second.local_flag;
/* Either both the MSB and LSB expressions are provided or
* neither are provided. */
if (cur_pit->second.msb) {
assert(cur_pit->second.lsb);
/* The MSB and LSB expressions must be integral constants. */
const NetEConst *msbc =
dynamic_cast<const NetEConst*>(cur_pit->second.msb);
const NetEConst *lsbc =
dynamic_cast<const NetEConst*>(cur_pit->second.lsb);
assert(msbc);
assert(lsbc);
cur_par->msb = msbc->value().as_long();
cur_par->lsb = lsbc->value().as_long();
} else {
assert(! cur_pit->second.lsb);
cur_par->msb = cur_pit->second.val->expr_width() - 1;
assert(cur_par->msb >= 0);
cur_par->lsb = 0;
}
cur_par->signed_flag = cur_pit->second.signed_flag;
cur_par->scope = scop;
FILE_NAME(cur_par, &(cur_pit->second));
NetExpr*etmp = cur_pit->second.val;
if (etmp == 0) {
cerr << "?:?: internal error: What is the parameter "
<< "expression for " << cur_pit->first
<< " in " << net->fullname() << "?" << endl;
}
assert(etmp);
make_scope_param_expr(cur_par, etmp);
idx += 1;
}
}
void dll_target::make_scope_param_expr(ivl_parameter_t cur_par, NetExpr*etmp)
{
if (const NetEConst*e = dynamic_cast<const NetEConst*>(etmp)) {
expr_const(e);
assert(expr_);
switch (expr_->type_) {
case IVL_EX_STRING:
expr_->u_.string_.parameter = cur_par;
break;
case IVL_EX_NUMBER:
expr_->u_.number_.parameter = cur_par;
break;
default:
assert(0);
}
} else if (const NetECReal*er = dynamic_cast<const NetECReal*>(etmp)) {
expr_creal(er);
assert(expr_);
assert(expr_->type_ == IVL_EX_REALNUM);
expr_->u_.real_.parameter = cur_par;
}
if (expr_ == 0) {
cerr << etmp->get_fileline() << ": internal error: "
<< "Parameter expression not reduced to constant? "
<< *etmp << endl;
}
ivl_assert(*etmp, expr_);
cur_par->value = expr_;
expr_ = 0;
}
static void fill_in_scope_function(ivl_scope_t scope, const NetScope*net)
{
scope->type_ = IVL_SCT_FUNCTION;
const NetFuncDef*def = net->func_def();
assert(def);
const NetNet*return_sig = def->return_sig();
if (return_sig == 0) {
// Special case: If there is no return signal, this is
// apparently a VOID function.
scope->func_type = IVL_VT_VOID;
scope->func_signed = 0;
scope->func_width = 0;
} else {
scope->func_type = return_sig->data_type();
scope->func_signed = return_sig->get_signed();
scope->func_width = return_sig->vector_width();
}
scope->tname_ = def->scope()->basename();
}
void dll_target::add_root(const NetScope *s)
{
ivl_scope_t root_ = new struct ivl_scope_s;
perm_string name = s->basename();
root_->name_ = name;
FILE_NAME(root_, s);
root_->parent = 0;
root_->nlog_ = 0;
root_->log_ = 0;
root_->nevent_ = 0;
root_->event_ = 0;
root_->nlpm_ = 0;
root_->lpm_ = 0;
root_->def = 0;
make_scope_parameters(root_, s);
root_->tname_ = root_->name_;
root_->time_precision = s->time_precision();
root_->time_units = s->time_unit();
root_->nattr = s->attr_cnt();
root_->attr = fill_in_attributes(s);
root_->is_auto = 0;
root_->is_cell = s->is_cell();
switch (s->type()) {
case NetScope::PACKAGE:
root_->type_ = IVL_SCT_PACKAGE;
break;
case NetScope::MODULE:
root_->type_ = IVL_SCT_MODULE;
break;
case NetScope::CLASS:
root_->type_ = IVL_SCT_CLASS;
break;
default:
assert(0);
}
switch (s->type()) {
case NetScope::MODULE:
root_->ports = s->module_port_nets();
if (root_->ports > 0) {
root_->u_.net = new NetNet*[root_->ports];
for (unsigned idx = 0; idx < root_->ports; idx += 1) {
root_->u_.net[idx] = s->module_port_net(idx);
}
}
root_->module_ports_info = s->module_port_info();
des_.roots.push_back(root_);
break;
case NetScope::PACKAGE:
root_->ports = 0;
des_.packages.push_back(root_);
break;
case NetScope::CLASS:
root_->ports = 0;
des_.classes[s] = root_;
break;
default:
assert(0);
break;
}
}
bool dll_target::start_design(const Design*des)
{
const char*dll_path_ = des->get_flag("DLL");
dll_ = ivl_dlopen(dll_path_);
if ((dll_ == 0) && (dll_path_[0] != '/')) {
size_t len = strlen(basedir) + 1 + strlen(dll_path_) + 1;
char*tmp = new char[len];
sprintf(tmp, "%s/%s", basedir, dll_path_);
dll_ = ivl_dlopen(tmp);
delete[]tmp;
}
if (dll_ == 0) {
cerr << "error: " << dll_path_ << " failed to load." << endl;
cerr << dll_path_ << ": " << dlerror() << endl;
return false;
}
stmt_cur_ = 0;
// Initialize the design object.
des_.self = des;
des_.time_precision = des->get_precision();
des_.disciplines.resize(disciplines.size());
unsigned idx = 0;
for (map<perm_string,ivl_discipline_t>::const_iterator cur = disciplines.begin()
; cur != disciplines.end() ; ++ cur ) {
des_.disciplines[idx] = cur->second;
idx += 1;
}
assert(idx == des_.disciplines.size());
list<NetScope *> scope_list;
scope_list = des->find_package_scopes();
for (list<NetScope*>::const_iterator cur = scope_list.begin()
; cur != scope_list.end(); ++ cur ) {
add_root(*cur);
}
scope_list = des->find_root_scopes();
for (list<NetScope*>::const_iterator cur = scope_list.begin()
; cur != scope_list.end(); ++ cur ) {
add_root(*cur);
}
target_ = (target_design_f)ivl_dlsym(dll_, LU "target_design" TU);
if (target_ == 0) {
cerr << dll_path_ << ": error: target_design entry "
"point is missing." << endl;
return false;
}
return true;
}
/*
* Here ivl is telling us that the design is scanned completely, and
* here is where we call the API to process the constructed design.
*/
int dll_target::end_design(const Design*)
{
int rc;
if (errors == 0) {
if (verbose_flag) {
cout << " ... invoking target_design" << endl;
}
rc = (target_)(&des_);
} else {
if (verbose_flag) {
cout << " ... skipping target_design due to errors." << endl;
}
rc = errors;
}
ivl_dlclose(dll_);
return rc;
}
void dll_target::switch_attributes(struct ivl_switch_s *obj,
const NetNode*net)
{
obj->nattr = net->attr_cnt();
obj->attr = fill_in_attributes(net);
}
void dll_target::logic_attributes(struct ivl_net_logic_s *obj,
const NetNode*net)
{
obj->nattr = net->attr_cnt();
obj->attr = fill_in_attributes(net);
}
void dll_target::make_delays_(ivl_expr_t*delay, const NetObj*net)
{
delay[0] = 0;
delay[1] = 0;
delay[2] = 0;
/* Translate delay expressions to ivl_target form. Try to
preserve pointer equality, not as a rule but to save on
expression trees. */
if (net->rise_time()) {
expr_ = 0;
net->rise_time()->expr_scan(this);
delay[0] = expr_;
expr_ = 0;
}
if (net->fall_time()) {
if (net->fall_time() == net->rise_time()) {
delay[1] = delay[0];
} else {
expr_ = 0;
net->fall_time()->expr_scan(this);
delay[1] = expr_;
expr_ = 0;
}
}
if (net->decay_time()) {
if (net->decay_time() == net->rise_time()) {
delay[2] = delay[0];
} else {
expr_ = 0;
net->decay_time()->expr_scan(this);
delay[2] = expr_;
expr_ = 0;
}
}
}
void dll_target::make_logic_delays_(struct ivl_net_logic_s*obj,
const NetObj*net)
{
make_delays_(obj->delay, net);
}
void dll_target::make_switch_delays_(struct ivl_switch_s*obj,
const NetObj*net)
{
make_delays_(obj->delay, net);
}
void dll_target::make_lpm_delays_(struct ivl_lpm_s*obj,
const NetObj*net)
{
make_delays_(obj->delay, net);
}
void dll_target::make_const_delays_(struct ivl_net_const_s*obj,
const NetObj*net)
{
make_delays_(obj->delay, net);
}
bool dll_target::branch(const NetBranch*net)
{
struct ivl_branch_s*obj = net->target_obj();
ivl_assert(*net, net->pin_count() == 2);
assert(net->pin(0).nexus()->t_cookie());
obj->pins[0] = net->pin(0).nexus()->t_cookie();
nexus_bra_add(obj->pins[0], obj, 0);
assert(net->pin(1).nexus()->t_cookie());
obj->pins[1] = net->pin(1).nexus()->t_cookie();
nexus_bra_add(obj->pins[1], obj, 1);
obj->island = net->get_island();
return true;
}
/*
* Add a bufz object to the scope that contains it.
*
* Note that in the ivl_target API a BUFZ device is a special kind of
* ivl_net_logic_t device, so create an ivl_net_logic_t cookie to
* handle it.
*/
bool dll_target::bufz(const NetBUFZ*net)
{
struct ivl_net_logic_s *obj = new struct ivl_net_logic_s;
assert(net->pin_count() == 2);
obj->type_ = net->transparent()? IVL_LO_BUFT : IVL_LO_BUFZ;
obj->width_= net->width();
obj->is_cassign = 0;
obj->npins_= 2;
obj->pins_ = new ivl_nexus_t[2];
FILE_NAME(obj, net);
/* Get the ivl_nexus_t objects connected to the two pins.
(We know a priori that the ivl_nexus_t objects have been
allocated, because the signals have been scanned before
me. This saves me the trouble of allocating them.) */
assert(net->pin(0).nexus()->t_cookie());
obj->pins_[0] = net->pin(0).nexus()->t_cookie();
ivl_nexus_ptr_t out_ptr = nexus_log_add(obj->pins_[0], obj, 0);
out_ptr->drive0 = net->pin(0).drive0();
out_ptr->drive1 = net->pin(0).drive1();
assert(net->pin(1).nexus()->t_cookie());
obj->pins_[1] = net->pin(1).nexus()->t_cookie();
nexus_log_add(obj->pins_[1], obj, 1);
/* Attach the logic device to the scope that contains it. */
assert(net->scope());
ivl_scope_t scop = find_scope(des_, net->scope());
assert(scop);
obj->scope_ = scop;
obj->name_ = net->name();
logic_attributes(obj, net);
make_logic_delays_(obj, net);
scope_add_logic(scop, obj);
return true;
}
bool dll_target::class_type(const NetScope*in_scope, netclass_t*net)
{
ivl_scope_t use_scope = find_scope(des_, in_scope);
use_scope->classes.push_back(net);
return true;
}
bool dll_target::enumeration(const NetScope*in_scope, netenum_t*net)
{
ivl_scope_t use_scope = find_scope(des_, in_scope);
use_scope->enumerations_.push_back(net);
return true;
}
void dll_target::event(const NetEvent*net)
{
struct ivl_event_s *obj = new struct ivl_event_s;
FILE_NAME(obj, net);
ivl_scope_t scop = find_scope(des_, net->scope());
obj->name = net->name();
obj->scope = scop;
scope_add_event(scop, obj);
obj->nany = 0;
obj->nneg = 0;
obj->npos = 0;
if (net->nprobe() >= 1) {
for (unsigned idx = 0 ; idx < net->nprobe() ; idx += 1) {
const NetEvProbe*pr = net->probe(idx);
switch (pr->edge()) {
case NetEvProbe::ANYEDGE:
obj->nany += pr->pin_count();
break;
case NetEvProbe::NEGEDGE:
obj->nneg += pr->pin_count();
break;
case NetEvProbe::POSEDGE:
obj->npos += pr->pin_count();
break;
}
}
unsigned npins = obj->nany + obj->nneg + obj->npos;
obj->pins = (ivl_nexus_t*)calloc(npins, sizeof(ivl_nexus_t));
} else {
obj->pins = 0;
}
}
void dll_target::logic(const NetLogic*net)
{
struct ivl_net_logic_s *obj = new struct ivl_net_logic_s;
obj->width_ = net->width();
FILE_NAME(obj, net);
switch (net->type()) {
case NetLogic::AND:
obj->type_ = IVL_LO_AND;
break;
case NetLogic::BUF:
obj->type_ = IVL_LO_BUF;
break;
case NetLogic::BUFIF0:
obj->type_ = IVL_LO_BUFIF0;
break;
case NetLogic::BUFIF1:
obj->type_ = IVL_LO_BUFIF1;
break;
case NetLogic::CMOS:
obj->type_ = IVL_LO_CMOS;
break;
case NetLogic::NAND:
obj->type_ = IVL_LO_NAND;
break;
case NetLogic::NMOS:
obj->type_ = IVL_LO_NMOS;
break;
case NetLogic::NOR:
obj->type_ = IVL_LO_NOR;
break;
case NetLogic::NOT:
obj->type_ = IVL_LO_NOT;
break;
case NetLogic::NOTIF0:
obj->type_ = IVL_LO_NOTIF0;
break;
case NetLogic::NOTIF1:
obj->type_ = IVL_LO_NOTIF1;
break;
case NetLogic::OR:
obj->type_ = IVL_LO_OR;
break;
case NetLogic::PULLDOWN:
obj->type_ = IVL_LO_PULLDOWN;
break;
case NetLogic::PULLUP:
obj->type_ = IVL_LO_PULLUP;
break;
case NetLogic::RCMOS:
obj->type_ = IVL_LO_RCMOS;
break;
case NetLogic::RNMOS:
obj->type_ = IVL_LO_RNMOS;
break;
case NetLogic::RPMOS:
obj->type_ = IVL_LO_RPMOS;
break;
case NetLogic::PMOS:
obj->type_ = IVL_LO_PMOS;
break;
case NetLogic::XNOR:
obj->type_ = IVL_LO_XNOR;
break;
case NetLogic::XOR:
obj->type_ = IVL_LO_XOR;
break;
default:
assert(0);
obj->type_ = IVL_LO_NONE;
break;
}
/* Some of the logical gates are used to represent operators in a
* continuous assignment, so set a flag if that is the case. */
obj->is_cassign = net->is_cassign();
/* Connect all the ivl_nexus_t objects to the pins of the
device. */
obj->npins_ = net->pin_count();
obj->pins_ = new ivl_nexus_t[obj->npins_];
for (unsigned idx = 0 ; idx < obj->npins_ ; idx += 1) {
const Nexus*nex = net->pin(idx).nexus();
assert(nex->t_cookie());
obj->pins_[idx] = nex->t_cookie();
ivl_nexus_ptr_t tmp = nexus_log_add(obj->pins_[idx], obj, idx);
if (idx == 0) {
tmp->drive0 = net->pin(0).drive0();
tmp->drive1 = net->pin(0).drive1();
}
}
assert(net->scope());
ivl_scope_t scop = find_scope(des_, net->scope());
assert(scop);
obj->scope_= scop;
obj->name_ = net->name();
logic_attributes(obj, net);
make_logic_delays_(obj, net);
scope_add_logic(scop, obj);
}
bool dll_target::tran(const NetTran*net)
{
struct ivl_switch_s*obj = new struct ivl_switch_s;
obj->type = net->type();
obj->width = net->vector_width();
obj->part = 0;
obj->offset = 0;
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
obj->island = net->get_island();
assert(obj->scope);
assert(obj->island);
FILE_NAME(obj, net);
const Nexus*nex;
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->pins[0] = nex->t_cookie();
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->pins[1] = nex->t_cookie();
nexus_switch_add(obj->pins[0], obj, 0);
nexus_switch_add(obj->pins[1], obj, 1);
if (net->pin_count() > 2) {
nex = net->pin(2).nexus();
assert(nex->t_cookie());
obj->pins[2] = nex->t_cookie();
nexus_switch_add(obj->pins[2], obj, 2);
} else {
obj->pins[2] = 0;
}
if (obj->type == IVL_SW_TRAN_VP) {
obj->part = net->part_width();
obj->offset= net->part_offset();
}
switch_attributes(obj, net);
make_switch_delays_(obj, net);
scope_add_switch(obj->scope, obj);
return true;
}
bool dll_target::substitute(const NetSubstitute*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_SUBSTITUTE;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.substitute.base = net->base();
obj->u_.substitute.q = net->pin(0).nexus()->t_cookie();
obj->u_.substitute.a = net->pin(1).nexus()->t_cookie();
obj->u_.substitute.s = net->pin(2).nexus()->t_cookie();
nexus_lpm_add(obj->u_.substitute.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nexus_lpm_add(obj->u_.substitute.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nexus_lpm_add(obj->u_.substitute.s, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
bool dll_target::sign_extend(const NetSignExtend*net)
{
struct ivl_lpm_s*obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_SIGN_EXT;
obj->width = net->width();
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
const Nexus*nex;
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.reduce.q = nex->t_cookie();
nexus_lpm_add(obj->u_.reduce.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.reduce.a = nex->t_cookie();
nexus_lpm_add(obj->u_.reduce.a, obj, 1, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
bool dll_target::ureduce(const NetUReduce*net)
{
struct ivl_lpm_s*obj = new struct ivl_lpm_s;
switch (net->type()) {
case NetUReduce::NONE:
assert(0);
delete obj;
return false;
case NetUReduce::AND:
obj->type = IVL_LPM_RE_AND;
break;
case NetUReduce::OR:
obj->type = IVL_LPM_RE_OR;
break;
case NetUReduce::XOR:
obj->type = IVL_LPM_RE_XOR;
break;
case NetUReduce::NAND:
obj->type = IVL_LPM_RE_NAND;
break;
case NetUReduce::NOR:
obj->type = IVL_LPM_RE_NOR;
break;
case NetUReduce::XNOR:
obj->type = IVL_LPM_RE_XNOR;
break;
}
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
const Nexus*nex;
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.reduce.q = nex->t_cookie();
nexus_lpm_add(obj->u_.reduce.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.reduce.a = nex->t_cookie();
nexus_lpm_add(obj->u_.reduce.a, obj, 1, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
void dll_target::net_case_cmp(const NetCaseCmp*net)
{
struct ivl_lpm_s*obj = new struct ivl_lpm_s;
switch (net->kind()) {
case NetCaseCmp::EEQ:
obj->type = IVL_LPM_CMP_EEQ;
break;
case NetCaseCmp::NEQ:
obj->type = IVL_LPM_CMP_NEE;
break;
case NetCaseCmp::WEQ:
obj->type = IVL_LPM_CMP_WEQ;
break;
case NetCaseCmp::WNE:
obj->type = IVL_LPM_CMP_WNE;
break;
case NetCaseCmp::XEQ:
obj->type = IVL_LPM_CMP_EQX;
break;
case NetCaseCmp::ZEQ:
obj->type = IVL_LPM_CMP_EQZ;
break;
}
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.arith.signed_flag = 0;
const Nexus*nex;
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin(2).nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
ivl_event_t dll_target::make_lpm_trigger(const NetEvWait*net)
{
ivl_event_t trigger = 0;
if (net) {
const NetEvent*ev = net->event(0);
/* Locate the event by name. */
ivl_scope_t ev_scope = lookup_scope_(ev->scope());
assert(ev_scope);
assert(ev_scope->nevent_ > 0);
for (unsigned idx = 0; idx < ev_scope->nevent_; idx += 1) {
const char*ename =
ivl_event_basename(ev_scope->event_[idx]);
if (strcmp(ev->name(), ename) == 0) {
trigger = ev_scope->event_[idx];
break;
}
}
/* Connect up the probe pins. This wasn't done during the
::event method because the signals weren't scanned yet. */
assert(ev->nprobe() == 1);
const NetEvProbe*pr = ev->probe(0);
for (unsigned bit = 0; bit < pr->pin_count(); bit += 1) {
ivl_nexus_t nex = (ivl_nexus_t)
pr->pin(bit).nexus()->t_cookie();
assert(nex);
trigger->pins[bit] = nex;
}
}
return trigger;
}
bool dll_target::net_sysfunction(const NetSysFunc*net)
{
unsigned idx;
const Nexus*nex;
struct ivl_lpm_s*obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_SFUNC;
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->u_.sfunc.ports = net->pin_count();
assert(net->pin_count() >= 1);
obj->width = net->vector_width();
obj->u_.sfunc.fun_name = net->func_name();
obj->u_.sfunc.pins = new ivl_nexus_t[net->pin_count()];
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.sfunc.pins[0] = nex->t_cookie();
nexus_lpm_add(obj->u_.sfunc.pins[0], obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
for (idx = 1 ; idx < net->pin_count() ; idx += 1) {
nex = net->pin(idx).nexus();
assert(nex->t_cookie());
obj->u_.sfunc.pins[idx] = nex->t_cookie();
nexus_lpm_add(obj->u_.sfunc.pins[idx], obj, 0,
IVL_DR_HiZ, IVL_DR_HiZ);
}
/* Save information about the trigger event if it exists. */
obj->u_.sfunc.trigger = make_lpm_trigger(net->trigger());
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
/*
* An IVL_LPM_UFUNC represents a node in a combinational expression
* that calls a user defined function. I create an LPM object that has
* the right connections, and refers to the ivl_scope_t of the
* definition.
*/
bool dll_target::net_function(const NetUserFunc*net)
{
struct ivl_lpm_s*obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_UFUNC;
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
/* Get the definition of the function and save it. */
const NetScope*def = net->def();
assert(def);
obj->u_.ufunc.def = lookup_scope_(def);
/* Save information about the ports in the ivl_lpm_s
structure. Note that port 0 is the return value. */
obj->u_.ufunc.ports = net->pin_count();
assert(net->pin_count() >= 1);
obj->width = net->port_width(0);
/* Now collect all the pins and connect them to the nexa of
the net. The output pins have strong drive, and the
remaining input pins are HiZ. */
obj->u_.ufunc.pins = new ivl_nexus_t[net->pin_count()];
for (unsigned idx = 0 ; idx < net->pin_count() ; idx += 1) {
const Nexus*nex = net->pin(idx).nexus();
assert(nex->t_cookie());
ivl_nexus_t nn = nex->t_cookie();
assert(nn);
obj->u_.ufunc.pins[idx] = nn;
ivl_drive_t drive = idx == 0 ? IVL_DR_STRONG : IVL_DR_HiZ;
nexus_lpm_add(obj->u_.ufunc.pins[idx], obj, idx, drive, drive);
}
/* Save information about the trigger event if it exists. */
obj->u_.ufunc.trigger = make_lpm_trigger(net->trigger());
make_lpm_delays_(obj, net);
/* All done. Add this LPM to the scope. */
scope_add_lpm(obj->scope, obj);
return true;
}
void dll_target::udp(const NetUDP*net)
{
struct ivl_net_logic_s *obj = new struct ivl_net_logic_s;
obj->type_ = IVL_LO_UDP;
FILE_NAME(obj, net);
/* The NetUDP class hasn't learned about width yet, so we
assume a width of 1. */
obj->width_ = 1;
obj->is_cassign = 0;
static map<perm_string,ivl_udp_t> udps;
ivl_udp_t u;
if (udps.find(net->udp_name()) != udps.end()) {
u = udps[net->udp_name()];
} else {
u = new struct ivl_udp_s;
u->nrows = net->rows();
u->table = (ivl_udp_s::ccharp_t*)malloc((u->nrows+1)*sizeof(char*));
u->table[u->nrows] = 0x0;
u->nin = net->nin();
u->sequ = net->is_sequential();
u->file = net->udp_file();
u->lineno = net->udp_lineno();
if (u->sequ) u->init = net->get_initial();
else u->init = 'x';
u->name = net->udp_name();
string inp;
char out;
unsigned int i = 0;
if (net->first(inp, out)) do {
string tt = inp+out;
u->table[i++] = strings_.add(tt.c_str());
} while (net->next(inp, out));
assert(i==u->nrows);
assert((u->nin + 1) == net->port_count());
u->ports = new string [u->nin + 1];
for(unsigned idx = 0; idx <= u->nin; idx += 1) {
u->ports[idx] = net->port_name(idx);
}
udps[net->udp_name()] = u;
}
obj->udp = u;
// Some duplication of code here, see: dll_target::logic()
/* Connect all the ivl_nexus_t objects to the pins of the
device. */
obj->npins_ = net->pin_count();
obj->pins_ = new ivl_nexus_t[obj->npins_];
for (unsigned idx = 0 ; idx < obj->npins_ ; idx += 1) {
/* Skip unconnected input pins. These will take on HiZ
values by the code generators. */
if (! net->pin(idx).is_linked()) {
obj->pins_[idx] = 0;
continue;
}
const Nexus*nex = net->pin(idx).nexus();
ivl_assert(*net, nex && nex->t_cookie());
obj->pins_[idx] = nex->t_cookie();
nexus_log_add(obj->pins_[idx], obj, idx);
}
assert(net->scope());
ivl_scope_t scop = find_scope(des_, net->scope());
assert(scop);
obj->scope_= scop;
obj->name_ = net->name();
FILE_NAME(obj, net);
make_logic_delays_(obj, net);
obj->nattr = 0;
obj->attr = 0;
scope_add_logic(scop, obj);
}
void dll_target::lpm_abs(const NetAbs*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_ABS;
obj->name = net->name(); // NetAddSub names are permallocated.
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->u_.arith.signed_flag = 0;
obj->width = net->width();
const Nexus*nex;
/* the output is pin(0) */
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin(1).nexus();
assert(nex->t_cookie());
/* pin(1) is the input data. */
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
void dll_target::lpm_add_sub(const NetAddSub*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
if (net->attribute(perm_string::literal("LPM_Direction")) == verinum("SUB"))
obj->type = IVL_LPM_SUB;
else
obj->type = IVL_LPM_ADD;
obj->name = net->name(); // NetAddSub names are permallocated.
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->u_.arith.signed_flag = 0;
/* Choose the width of the adder. If the carry bit is
connected, then widen the adder by one and plan on leaving
the fake inputs unconnected. */
obj->width = net->width();
if (net->pin_Cout().is_linked()) {
obj->width += 1;
}
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
/* If the carry output is connected, then connect the extra Q
pin to the carry nexus and zero the a and b inputs. */
if (net->pin_Cout().is_linked()) {
cerr << "XXXX: t-dll.cc: Forgot how to connect cout." << endl;
}
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
bool dll_target::lpm_array_dq(const NetArrayDq*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_ARRAY;
obj->name = net->name();
obj->u_.array.sig = find_signal(des_, net->mem());
assert(obj->u_.array.sig);
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.array.swid = net->awidth();
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
const Nexus*nex;
nex = net->pin_Address().nexus();
assert(nex->t_cookie());
obj->u_.array.a = nex->t_cookie();
nexus_lpm_add(obj->u_.array.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.array.q = nex->t_cookie();
nexus_lpm_add(obj->u_.array.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
return true;
}
/*
* The lpm_clshift device represents both left and right shifts,
* depending on what is connected to the Direction pin. We convert
* this device into SHIFTL or SHIFTR devices.
*/
void dll_target::lpm_clshift(const NetCLShift*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_SHIFTL;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
/* Look at the direction input of the device, and select the
shift direction accordingly. */
if (net->right_flag())
obj->type = IVL_LPM_SHIFTR;
if (net->signed_flag())
obj->u_.shift.signed_flag = 1;
else
obj->u_.shift.signed_flag = 0;
obj->width = net->width();
obj->u_.shift.select = net->width_dist();
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.shift.q = nex->t_cookie();
nexus_lpm_add(obj->u_.shift.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_Data().nexus();
assert(nex->t_cookie());
obj->u_.shift.d = nex->t_cookie();
nexus_lpm_add(obj->u_.shift.d, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_Distance().nexus();
assert(nex->t_cookie());
obj->u_.shift.s = nex->t_cookie();
nexus_lpm_add(obj->u_.shift.s, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
bool dll_target::lpm_arith1_(ivl_lpm_type_t lpm_type, unsigned width, bool signed_flag, const NetNode*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = lpm_type;
obj->name = net->name(); // NetCastInt2 names are permallocated
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = width;
obj->u_.arith.signed_flag = signed_flag? 1 : 0;
const Nexus*nex;
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
bool dll_target::lpm_cast_int2(const NetCastInt2*net)
{
return lpm_arith1_(IVL_LPM_CAST_INT2, net->width(), true, net);
}
bool dll_target::lpm_cast_int4(const NetCastInt4*net)
{
return lpm_arith1_(IVL_LPM_CAST_INT, net->width(), true, net);
}
bool dll_target::lpm_cast_real(const NetCastReal*net)
{
return lpm_arith1_(IVL_LPM_CAST_REAL, 0, net->signed_flag(), net);
}
/*
* Make out of the NetCompare object an ivl_lpm_s object. The
* comparators in ivl_target do not support < or <=, but they can be
* trivially converted to > and >= by swapping the operands.
*/
void dll_target::lpm_compare(const NetCompare*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->name = net->name(); // NetCompare names are permallocated
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
bool swap_operands = false;
obj->width = net->width();
obj->u_.arith.signed_flag = net->get_signed()? 1 : 0;
const Nexus*nex;
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
if (net->pin_AGEB().is_linked()) {
nex = net->pin_AGEB().nexus();
obj->type = IVL_LPM_CMP_GE;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
} else if (net->pin_AGB().is_linked()) {
nex = net->pin_AGB().nexus();
obj->type = IVL_LPM_CMP_GT;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
} else if (net->pin_ALEB().is_linked()) {
nex = net->pin_ALEB().nexus();
obj->type = IVL_LPM_CMP_GE;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
swap_operands = true;
} else if (net->pin_ALB().is_linked()) {
nex = net->pin_ALB().nexus();
obj->type = IVL_LPM_CMP_GT;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
swap_operands = true;
} else if (net->pin_AEB().is_linked()) {
nex = net->pin_AEB().nexus();
obj->type = IVL_LPM_CMP_EQ;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
} else if (net->pin_ANEB().is_linked()) {
nex = net->pin_ANEB().nexus();
obj->type = IVL_LPM_CMP_NE;
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
} else {
assert(0);
}
if (swap_operands) {
ivl_nexus_t tmp = obj->u_.arith.a;
obj->u_.arith.a = obj->u_.arith.b;
obj->u_.arith.b = tmp;
}
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
void dll_target::lpm_divide(const NetDivide*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_DIVIDE;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
unsigned wid = net->width_r();
obj->width = wid;
obj->u_.arith.signed_flag = net->get_signed()? 1 : 0;
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
void dll_target::lpm_modulo(const NetModulo*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_MOD;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
unsigned wid = net->width_r();
obj->width = wid;
obj->u_.arith.signed_flag = net->get_signed()? 1 : 0;
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
void dll_target::lpm_ff(const NetFF*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_FF;
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
scope_add_lpm(obj->scope, obj);
const Nexus*nex;
/* Set the clock polarity. */
obj->u_.ff.negedge_flag = net->is_negedge();
/* Set the clk signal to point to the nexus, and the nexus to
point back to this device. */
nex = net->pin_Clock().nexus();
assert(nex->t_cookie());
obj->u_.ff.clk = nex->t_cookie();
assert(obj->u_.ff.clk);
nexus_lpm_add(obj->u_.ff.clk, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
/* If there is a clock enable, then connect it up to the FF
device. */
if (net->pin_Enable().is_linked()) {
nex = net->pin_Enable().nexus();
assert(nex->t_cookie());
obj->u_.ff.we = nex->t_cookie();
assert(obj->u_.ff.we);
nexus_lpm_add(obj->u_.ff.we, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
} else {
obj->u_.ff.we = 0;
}
if (net->pin_Aclr().is_linked()) {
nex = net->pin_Aclr().nexus();
assert(nex->t_cookie());
obj->u_.ff.aclr = nex->t_cookie();
assert(obj->u_.ff.aclr);
nexus_lpm_add(obj->u_.ff.aclr, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
} else {
obj->u_.ff.aclr = 0;
}
if (net->pin_Aset().is_linked()) {
nex = net->pin_Aset().nexus();
assert(nex->t_cookie());
obj->u_.ff.aset = nex->t_cookie();
assert(obj->u_.ff.aset);
nexus_lpm_add(obj->u_.ff.aset, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
verinum tmp = net->aset_value();
if (tmp.len() > 0)
obj->u_.ff.aset_value = expr_from_value_(tmp);
else
obj->u_.ff.aset_value = 0;
} else {
obj->u_.ff.aset = 0;
obj->u_.ff.aset_value = 0;
}
if (net->pin_Sclr().is_linked()) {
nex = net->pin_Sclr().nexus();
assert(nex->t_cookie());
obj->u_.ff.sclr = nex->t_cookie();
assert(obj->u_.ff.sclr);
nexus_lpm_add(obj->u_.ff.sclr, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
} else {
obj->u_.ff.sclr = 0;
}
if (net->pin_Sset().is_linked()) {
nex = net->pin_Sset().nexus();
assert(nex->t_cookie());
obj->u_.ff.sset = nex->t_cookie();
assert(obj->u_.ff.sset);
nexus_lpm_add(obj->u_.ff.sset, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
verinum tmp = net->sset_value();
if (tmp.len() > 0)
obj->u_.ff.sset_value = expr_from_value_(tmp);
else
obj->u_.ff.sset_value = 0;
} else {
obj->u_.ff.sset = 0;
obj->u_.ff.sset_value = 0;
}
nex = net->pin_Q().nexus();
assert(nex->t_cookie());
obj->u_.ff.q.pin = nex->t_cookie();
nexus_lpm_add(obj->u_.ff.q.pin, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_Data().nexus();
assert(nex->t_cookie());
obj->u_.ff.d.pin = nex->t_cookie();
nexus_lpm_add(obj->u_.ff.d.pin, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
}
void dll_target::lpm_latch(const NetLatch*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_LATCH;
obj->name = net->name();
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
scope_add_lpm(obj->scope, obj);
const Nexus*nex;
nex = net->pin_Enable().nexus();
assert(nex->t_cookie());
obj->u_.latch.e = nex->t_cookie();
assert(obj->u_.latch.e);
nexus_lpm_add(obj->u_.latch.e, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_Q().nexus();
assert(nex->t_cookie());
obj->u_.latch.q.pin = nex->t_cookie();
nexus_lpm_add(obj->u_.latch.q.pin, obj, 0,
IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_Data().nexus();
assert(nex->t_cookie());
obj->u_.latch.d.pin = nex->t_cookie();
nexus_lpm_add(obj->u_.latch.d.pin, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
}
/*
* Make the NetMult object into an IVL_LPM_MULT node.
*/
void dll_target::lpm_mult(const NetMult*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_MULT;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
unsigned wid = net->width_r();
obj->width = wid;
obj->u_.arith.signed_flag = 0;
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
/*
* Hook up the mux devices so that the select expression selects the
* correct sub-expression with the ivl_lpm_data2 function.
*/
void dll_target::lpm_mux(const NetMux*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_MUX;
obj->name = net->name(); // The NetMux permallocates its name.
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.mux.size = net->size();
obj->u_.mux.swid = net->sel_width();
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
const Nexus*nex;
/* Connect the output bits. */
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.mux.q = nex->t_cookie();
nexus_lpm_add(obj->u_.mux.q, obj, 0,
net->pin_Result().drive0(),
net->pin_Result().drive1());
/* Connect the select bits. */
nex = net->pin_Sel().nexus();
assert(nex->t_cookie());
obj->u_.mux.s = nex->t_cookie();
nexus_lpm_add(obj->u_.mux.s, obj, 0,
IVL_DR_HiZ, IVL_DR_HiZ);
unsigned selects = obj->u_.mux.size;
obj->u_.mux.d = new ivl_nexus_t [selects];
for (unsigned sdx = 0 ; sdx < selects ; sdx += 1) {
nex = net->pin_Data(sdx).nexus();
ivl_nexus_t tmp = nex->t_cookie();
obj->u_.mux.d[sdx] = tmp;
if (tmp == 0) {
cerr << net->get_fileline() << ": internal error: "
<< "dll_target::lpm_mux: "
<< "Missing data port " << sdx
<< " of mux " << obj->name << "." << endl;
}
ivl_assert(*net, tmp);
nexus_lpm_add(tmp, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
}
}
/*
* Make the NetPow object into an IVL_LPM_POW node.
*/
void dll_target::lpm_pow(const NetPow*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_POW;
FILE_NAME(obj, net);
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
unsigned wid = net->width_r();
obj->u_.arith.signed_flag = net->get_signed()? 1 : 0;
obj->width = wid;
const Nexus*nex;
nex = net->pin_Result().nexus();
assert(nex->t_cookie());
obj->u_.arith.q = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nex = net->pin_DataA().nexus();
assert(nex->t_cookie());
obj->u_.arith.a = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
nex = net->pin_DataB().nexus();
assert(nex->t_cookie());
obj->u_.arith.b = nex->t_cookie();
nexus_lpm_add(obj->u_.arith.b, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
}
bool dll_target::concat(const NetConcat*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = net->transparent()? IVL_LPM_CONCATZ : IVL_LPM_CONCAT;
obj->name = net->name(); // NetConcat names are permallocated
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.concat.inputs = net->pin_count() - 1;
obj->u_.concat.pins = new ivl_nexus_t[obj->u_.concat.inputs+1];
for (unsigned idx = 0 ; idx < obj->u_.concat.inputs+1 ; idx += 1) {
ivl_drive_t dr = idx == 0? IVL_DR_STRONG : IVL_DR_HiZ;
const Nexus*nex = net->pin(idx).nexus();
assert(nex->t_cookie());
obj->u_.concat.pins[idx] = nex->t_cookie();
nexus_lpm_add(obj->u_.concat.pins[idx], obj, 0, dr, dr);
}
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
bool dll_target::part_select(const NetPartSelect*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
switch (net->dir()) {
case NetPartSelect::VP:
obj->type = IVL_LPM_PART_VP;
break;
case NetPartSelect::PV:
obj->type = IVL_LPM_PART_PV;
break;
}
obj->name = net->name(); // NetPartSelect names are permallocated.
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
/* Part selects are always unsigned, so we use this to indicate
* if the part select base signal is signed or not. */
if (net->signed_flag())
obj->u_.part.signed_flag = 1;
else
obj->u_.part.signed_flag = 0;
/* Choose the width of the part select. */
obj->width = net->width();
obj->u_.part.base = net->base();
obj->u_.part.s = 0;
const Nexus*nex;
switch (obj->type) {
case IVL_LPM_PART_VP:
/* NetPartSelect:pin(0) is the output pin. */
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.part.q = nex->t_cookie();
/* NetPartSelect:pin(1) is the input pin. */
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.part.a = nex->t_cookie();
/* If the part select has an additional pin, that pin is
a variable select base. */
if (net->pin_count() >= 3) {
nex = net->pin(2).nexus();
assert(nex->t_cookie());
obj->u_.part.s = nex->t_cookie();
}
break;
case IVL_LPM_PART_PV:
/* NetPartSelect:pin(1) is the output pin. */
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.part.q = nex->t_cookie();
/* NetPartSelect:pin(0) is the input pin. */
nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.part.a = nex->t_cookie();
break;
default:
assert(0);
}
nexus_lpm_add(obj->u_.part.q, obj, 0, IVL_DR_STRONG, IVL_DR_STRONG);
nexus_lpm_add(obj->u_.part.a, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
/* The select input is optional. */
if (obj->u_.part.s)
nexus_lpm_add(obj->u_.part.s, obj, 0, IVL_DR_HiZ, IVL_DR_HiZ);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
bool dll_target::replicate(const NetReplicate*net)
{
ivl_lpm_t obj = new struct ivl_lpm_s;
obj->type = IVL_LPM_REPEAT;
obj->name = net->name();
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
assert(obj->scope);
FILE_NAME(obj, net);
obj->width = net->width();
obj->u_.repeat.count = net->repeat();
ivl_drive_t dr = IVL_DR_STRONG;
const Nexus*nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->u_.repeat.q = nex->t_cookie();
nexus_lpm_add(obj->u_.repeat.q, obj, 0, dr, dr);
dr = IVL_DR_HiZ;
nex = net->pin(1).nexus();
assert(nex->t_cookie());
obj->u_.repeat.a = nex->t_cookie();
nexus_lpm_add(obj->u_.repeat.a, obj, 0, dr, dr);
make_lpm_delays_(obj, net);
scope_add_lpm(obj->scope, obj);
return true;
}
/*
* The assignment l-values are captured by the assignment statements
* themselves in the process handling.
*/
void dll_target::net_assign(const NetAssign_*) const
{
}
bool dll_target::net_const(const NetConst*net)
{
unsigned idx;
char*bits;
static char*bits_tmp = 0;
static unsigned bits_cnt = 0;
struct ivl_net_const_s *obj = new struct ivl_net_const_s;
if (net->is_string()) {
obj->type = IVL_VT_STRING;
assert((net->width() % 8) == 0);
} else obj->type = IVL_VT_BOOL;
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
FILE_NAME(obj, net);
/* constants have a single vector output. */
assert(net->pin_count() == 1);
obj->width_ = net->width();
obj->signed_ = net->value().has_sign();
if (obj->width_ <= sizeof(obj->b.bit_)) {
bits = obj->b.bit_;
} else {
if (obj->width_ >= bits_cnt) {
bits_tmp = (char*)realloc(bits_tmp, obj->width_+1);
bits_cnt = obj->width_+1;
}
bits = bits_tmp;
}
for (idx = 0 ; idx < obj->width_ ; idx += 1)
switch (net->value(idx)) {
case verinum::V0:
bits[idx] = '0';
break;
case verinum::V1:
bits[idx] = '1';
break;
case verinum::Vx:
if (obj->type == IVL_VT_BOOL)
obj->type = IVL_VT_LOGIC;
bits[idx] = 'x';
assert(! net->is_string());
break;
case verinum::Vz:
if (obj->type == IVL_VT_BOOL)
obj->type = IVL_VT_LOGIC;
bits[idx] = 'z';
assert(! net->is_string());
break;
}
if (obj->width_ > sizeof(obj->b.bit_)) {
bits[obj->width_] = 0;
obj->b.bits_ = net_const_strings.make(bits);
}
/* Connect to all the nexus objects. Note that the one-bit
case can be handled more efficiently without allocating
array space. */
ivl_drive_t drv0, drv1;
drive_from_link(net->pin(0), drv0, drv1);
const Nexus*nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->pin_ = nex->t_cookie();
nexus_con_add(obj->pin_, obj, 0, drv0, drv1);
des_.consts.push_back(obj);
make_const_delays_(obj, net);
return true;
}
bool dll_target::net_literal(const NetLiteral*net)
{
struct ivl_net_const_s *obj = new struct ivl_net_const_s;
obj->type = IVL_VT_REAL;
assert(net->scope());
obj->scope = find_scope(des_, net->scope());
FILE_NAME(obj, net);
obj->width_ = 1;
obj->signed_ = 1;
obj->b.real_value = net->value_real().as_double();
/* Connect to all the nexus objects. Note that the one-bit
case can be handled more efficiently without allocating
array space. */
ivl_drive_t drv0, drv1;
drive_from_link(net->pin(0), drv0, drv1);
const Nexus*nex = net->pin(0).nexus();
assert(nex->t_cookie());
obj->pin_ = nex->t_cookie();
nexus_con_add(obj->pin_, obj, 0, drv0, drv1);
des_.consts.push_back(obj);
make_const_delays_(obj, net);
return true;
}
void dll_target::net_probe(const NetEvProbe*)
{
}
void dll_target::scope(const NetScope*net)
{
if (net->parent()==0 && net->type()==NetScope::CLASS) {
if (debug_emit) {
cerr << "dll_target::scope: "
<< "Add class " << scope_path(net)
<< " as a root scope." << endl;
}
add_root(net);
} if (net->parent() == 0) {
// Root scopes are already created...
} else {
perm_string sname = make_scope_name(net->fullname());
ivl_scope_t scop = new struct ivl_scope_s;
scop->name_ = sname;
FILE_NAME(scop, net);
scop->parent = find_scope(des_, net->parent());
assert(scop->parent);
scop->parent->children[net->fullname()] = scop;
scop->parent->child .push_back(scop);
scop->nlog_ = 0;
scop->log_ = 0;
scop->nevent_ = 0;
scop->event_ = 0;
scop->nlpm_ = 0;
scop->lpm_ = 0;
scop->def = 0;
make_scope_parameters(scop, net);
scop->time_precision = net->time_precision();
scop->time_units = net->time_unit();
scop->nattr = net->attr_cnt();
scop->attr = fill_in_attributes(net);
scop->is_auto = net->is_auto();
scop->is_cell = net->is_cell();
switch (net->type()) {
case NetScope::PACKAGE:
cerr << "?:?" << ": internal error: "
<< "Package scopes should not have parents." << endl;
// fallthrough
case NetScope::MODULE:
scop->type_ = IVL_SCT_MODULE;
scop->tname_ = net->module_name();
scop->ports = net->module_port_nets();
if (scop->ports > 0) {
scop->u_.net = new NetNet*[scop->ports];
for (unsigned idx = 0; idx < scop->ports; idx += 1) {
scop->u_.net[idx] = net->module_port_net(idx);
}
}
scop->module_ports_info = net->module_port_info();
break;
case NetScope::TASK: {
const NetTaskDef*def = net->task_def();
if (def == 0) {
cerr << "?:?" << ": internal error: "
<< "task " << scop->name_
<< " has no definition." << endl;
}
assert(def);
scop->type_ = IVL_SCT_TASK;
scop->tname_ = def->scope()->basename();
break;
}
case NetScope::FUNC:
fill_in_scope_function(scop, net);
break;
case NetScope::BEGIN_END:
scop->type_ = IVL_SCT_BEGIN;
scop->tname_ = scop->name_;
break;
case NetScope::FORK_JOIN:
scop->type_ = IVL_SCT_FORK;
scop->tname_ = scop->name_;
break;
case NetScope::GENBLOCK:
scop->type_ = IVL_SCT_GENERATE;
scop->tname_ = scop->name_;
break;
case NetScope::CLASS:
assert(0);
break;
}
}
}
void dll_target::convert_module_ports(const NetScope*net)
{
ivl_scope_t scop = find_scope(des_, net);
if (scop->ports > 0) {
NetNet**nets = scop->u_.net;
scop->u_.nex = new ivl_nexus_t[scop->ports];
for (unsigned idx = 0; idx < scop->ports; idx += 1) {
ivl_signal_t sig = find_signal(des_, nets[idx]);
scop->u_.nex[idx] = nexus_sig_make(sig, 0);
}
delete [] nets;
}
}
void dll_target::signal(const NetNet*net)
{
ivl_signal_t obj = new struct ivl_signal_s;
obj->name_ = net->name();
/* Attach the signal to the ivl_scope_t object that contains
it. This involves growing the sigs_ array in the scope
object, or creating the sigs_ array if this is the first
signal. */
obj->scope_ = find_scope(des_, net->scope());
assert(obj->scope_);
FILE_NAME(obj, net);
obj->scope_->sigs_.push_back(obj);
/* Save the primitive properties of the signal in the
ivl_signal_t object. */
{ size_t idx = 0;
vector<netrange_t>::const_iterator cur;
obj->packed_dims.resize(net->packed_dims().size());
for (cur = net->packed_dims().begin(), idx = 0
; cur != net->packed_dims().end() ; ++cur, idx += 1) {
obj->packed_dims[idx] = *cur;
}
}
obj->net_type = net->net_type();
obj->local_ = net->local_flag()? 1 : 0;
obj->forced_net_ = (net->type() != NetNet::REG) &&
(net->peek_lref() > 0) ? 1 : 0;
obj->discipline = net->get_discipline();
obj->array_dimensions_ = net->unpacked_dimensions();
assert(obj->array_dimensions_ == net->unpacked_dimensions());
switch (net->port_type()) {
case NetNet::PINPUT:
obj->port_ = IVL_SIP_INPUT;
break;
case NetNet::POUTPUT:
obj->port_ = IVL_SIP_OUTPUT;
break;
case NetNet::PINOUT:
obj->port_ = IVL_SIP_INOUT;
break;
default:
obj->port_ = IVL_SIP_NONE;
break;
}
obj->module_port_index_ = net->get_module_port_index();
switch (net->type()) {
case NetNet::REG:
obj->type_ = IVL_SIT_REG;
break;
/* The SUPPLY0/1 net types are replaced with pulldown/up
by elaborate. They should not make it here. */
case NetNet::SUPPLY0:
assert(0);
break;
case NetNet::SUPPLY1:
assert(0);
break;
/* We will convert this to a TRI after we check that there
is only one driver. */
case NetNet::UNRESOLVED_WIRE:
obj->type_ = IVL_SIT_UWIRE;
break;
case NetNet::TRI:
case NetNet::WIRE:
case NetNet::IMPLICIT:
obj->type_ = IVL_SIT_TRI;
break;
case NetNet::TRI0:
obj->type_ = IVL_SIT_TRI0;
break;
case NetNet::TRI1:
obj->type_ = IVL_SIT_TRI1;
break;
case NetNet::TRIAND:
case NetNet::WAND:
obj->type_ = IVL_SIT_TRIAND;
break;
case NetNet::TRIOR:
case NetNet::WOR:
obj->type_ = IVL_SIT_TRIOR;
break;
default:
obj->type_ = IVL_SIT_NONE;
break;
}
/* Initialize the path fields to be filled in later. */
obj->npath = 0;
obj->path = 0;
obj->nattr = net->attr_cnt();
obj->attr = fill_in_attributes(net);
/* Get the nexus objects for all the pins of the signal. If
the signal has only one pin, then write the single
ivl_nexus_t object into n.pin_. Otherwise, make an array of
ivl_nexus_t cookies.
When I create an ivl_nexus_t object, store it in the
t_cookie of the Nexus object so that I find it again when I
next encounter the nexus. */
if (obj->array_dimensions_ == 1) {
const vector<netrange_t>& dims = net->unpacked_dims();
if (dims[0].get_msb() < dims[0].get_lsb()) {
obj->array_base = dims[0].get_msb();
obj->array_addr_swapped = false;
} else {
obj->array_base = dims[0].get_lsb();
obj->array_addr_swapped = true;
}
obj->array_words = net->unpacked_count();
} else {
// The back-end API doesn't yet support multi-dimension
// unpacked arrays, so just report the canonical dimensions.
obj->array_base = 0;
obj->array_words = net->unpacked_count();
obj->array_addr_swapped = 0;
}
ivl_assert(*net, obj->array_words == net->pin_count());
if (debug_optimizer && obj->array_words > 1000) cerr << "debug: "
"t-dll creating nexus array " << obj->array_words << " long" << endl;
if (obj->array_words > 1 && net->pins_are_virtual()) {
obj->pins = NULL;
if (debug_optimizer && obj->array_words > 1000) cerr << "debug: "
"t-dll used NULL for big nexus array" << endl;
return;
}
if (obj->array_words > 1)
obj->pins = new ivl_nexus_t[obj->array_words];
for (unsigned idx = 0 ; idx < obj->array_words ; idx += 1) {
const Nexus*nex = net->pins_are_virtual() ? 0 : net->pin(idx).nexus();
if (nex == 0) {
// Special case: This pin is connected to
// nothing. This can happen, for example, if the
// variable is only used in behavioral
// code. Create a stub nexus.
ivl_nexus_t tmp = nexus_sig_make(obj, idx);
tmp->nexus_ = nex;
tmp->name_ = 0;
if (obj->array_words > 1)
obj->pins[idx] = tmp;
else
obj->pin = tmp;
} else if (nex->t_cookie()) {
if (obj->array_words > 1) {
obj->pins[idx] = nex->t_cookie();
nexus_sig_add(obj->pins[idx], obj, idx);
} else {
obj->pin = nex->t_cookie();
nexus_sig_add(obj->pin, obj, idx);
}
} else {
ivl_nexus_t tmp = nexus_sig_make(obj, idx);
tmp->nexus_ = nex;
tmp->name_ = 0;
nex->t_cookie(tmp);
if (obj->array_words > 1)
obj->pins[idx] = tmp;
else
obj->pin = tmp;
}
}
if (debug_optimizer && obj->array_words > 1000) cerr << "debug: t-dll done with big nexus array" << endl;
}
bool dll_target::signal_paths(const NetNet*net)
{
/* Nothing to do if there are no paths for this signal. */
if (net->delay_paths() == 0)
return true;
ivl_signal_t obj = find_signal(des_, net);
assert(obj);
/* We cannot have already set up the paths for this signal. */
assert(obj->npath == 0);
assert(obj->path == 0);
/* Figure out how many paths there really are. */
for (unsigned idx = 0 ; idx < net->delay_paths() ; idx += 1) {
const NetDelaySrc*src = net->delay_path(idx);
obj->npath += src->src_count();
}
obj->path = new struct ivl_delaypath_s[obj->npath];
unsigned ptr = 0;
for (unsigned idx = 0 ; idx < net->delay_paths() ; idx += 1) {
const NetDelaySrc*src = net->delay_path(idx);
/* If this path has a condition, then hook it up. */
ivl_nexus_t path_condit = 0;
if (src->has_condit()) {
const Nexus*nt = src->condit_pin().nexus();
path_condit = nt->t_cookie();
}
for (unsigned pin = 0; pin < src->src_count(); pin += 1) {
const Nexus*nex = src->src_pin(pin).nexus();
if (! nex->t_cookie()) {
cerr << src->get_fileline() << ": internal error: "
<< "No signal connected to pin " << pin
<< " of delay path to " << net->name()
<< "." << endl;
}
assert(nex->t_cookie());
obj->path[ptr].scope = lookup_scope_(src->scope());
obj->path[ptr].src = nex->t_cookie();
obj->path[ptr].condit = path_condit;
obj->path[ptr].conditional = src->is_condit();
obj->path[ptr].posedge = src->is_posedge();
obj->path[ptr].negedge = src->is_negedge();
for (unsigned pe = 0 ; pe < 12 ; pe += 1) {
obj->path[ptr].delay[pe] = src->get_delay(pe);
}
ptr += 1;
}
}
return true;
}
void dll_target::test_version(const char*target_name)
{
dll_ = ivl_dlopen(target_name);
if ((dll_ == 0) && (target_name[0] != '/')) {
size_t len = strlen(basedir) + 1 + strlen(target_name) + 1;
char*tmp = new char[len];
sprintf(tmp, "%s/%s", basedir, target_name);
dll_ = ivl_dlopen(tmp);
delete[]tmp;
}
if (dll_ == 0) {
cout << "\n\nUnable to load " << target_name
<< " for version details." << endl;
return;
}
target_query_f target_query = (target_query_f)ivl_dlsym(dll_, LU "target_query" TU);
if (target_query == 0) {
cerr << "Target " << target_name
<< " has no version hooks." << endl;
return;
}
const char*version_string = (*target_query) ("version");
if (version_string == 0) {
cerr << "Target " << target_name
<< " has no version string" << endl;
return;
}
cout << target_name << ": " << version_string << endl;
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手