luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SV: queue/darray locator methods (find*, unique*, min/max) 

Add find*, unique*, min/max, and with-predicate locator methods for
queues and dynamic arrays, with VVP runtime support and ivtest.

Split from steveicarus/iverilog#1330 (part 03/6).
This commit is contained in:
mjoekhan 2026-07-01 12:45:16 +05:00
parent 812c1cedcb
commit e3222e77ad
25 changed files with 2555 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
PExpr.cc
View File

@ -284,16 +284,26 @@ PECallFunction::PECallFunction(PExpr* chain_prefix, const pform_name_t &method,
{
}
void PECallFunction::set_with_clause(PExpr* with_expr)
{
delete with_expr_;
with_expr_ = with_expr;
}
PECallFunction::~PECallFunction()
{
delete chain_prefix_;
delete with_expr_;
}
void PECallFunction::declare_implicit_nets(LexicalScope*scope, NetNet::Type type)
{
if (chain_prefix_) {
chain_prefix_->declare_implicit_nets(scope, type);
}
}
if (with_expr_) {
with_expr_->declare_implicit_nets(scope, type);
}
for (const auto &parm : parms_) {
if (parm.parm) {
parm.parm->declare_implicit_nets(scope, type);
@ -305,7 +315,10 @@ bool PECallFunction::has_aa_term(Design*des, NetScope*scope) const
{
if (chain_prefix_ && chain_prefix_->has_aa_term(des, scope)) {
return true;
}
}
if (with_expr_ && with_expr_->has_aa_term(des, scope)) {
return true;
}
for (const auto &parm : parms_) {
if (parm.parm && parm.parm->has_aa_term(des, scope)) {
return true;

5
PExpr.h
View File

@ -926,6 +926,10 @@ class PECallFunction : public PExpr {
explicit PECallFunction(PExpr* chain_prefix, const pform_name_t &method,
const std::list<named_pexpr_t> &parms);
// SystemVerilog: q.find with (expr) — iterator "item"/"index" in expr.
void set_with_clause(PExpr* with_expr);
const PExpr* peek_with_clause(void) const { return with_expr_; }
~PECallFunction() override;
// For chained-call resolution (path is only the final method name).
@ -952,6 +956,7 @@ class PECallFunction : public PExpr {
std::vector<named_pexpr_t> parms_;
// If non-null, this call is prefix().tail_name(...) (SV method chain).
PExpr* chain_prefix_ = nullptr;
PExpr* with_expr_ = nullptr;
// For system functions.
bool is_overridden_;

4
dup_expr.cc
View File

@ -235,7 +235,9 @@ NetESelect* NetESelect::dup_expr() const
NetESFunc* NetESFunc::dup_expr() const
{
NetESFunc*tmp = new NetESFunc(name_, type_, expr_width(), nparms(), is_overridden_);
NetESFunc*tmp = net_type()
? new NetESFunc(name_, net_type(), nparms())
: new NetESFunc(name_, type_, expr_width(), nparms(), is_overridden_);
ivl_assert(*this, tmp);
tmp->cast_signed(has_sign());

1042
elab_expr.cc
View File

File diff suppressed because it is too large Load Diff

48
ivtest/ivltests/sv_darray_find_locators.v Normal file
View File

@ -0,0 +1,48 @@
// Regression: dynamic array locator methods (find* with predicate); results are queues.
module top;
bit failed = 0;
`define CHK(cond) \
if (!(cond)) begin \
$display("FAILED line %0d", `__LINE__); \
failed = 1; \
end
int array[] = '{4, 7, 2, 5, 7, 1, 6, 3, 1};
int res[$];
initial begin
res = array.find() with (item > 3);
`CHK(res.size == 5);
`CHK(res[0] == 4);
`CHK(res[1] == 7);
`CHK(res[2] == 5);
`CHK(res[3] == 7);
`CHK(res[4] == 6);
res = array.find_index() with (item == 4);
`CHK(res.size == 1);
`CHK(res[0] == 0);
res = array.find_first() with (item < 5 && item >= 3);
`CHK(res.size == 1);
`CHK(res[0] == 4);
res = array.find_first_index() with (item > 5);
`CHK(res.size == 1);
`CHK(res[0] == 1);
res = array.find_last() with (item <= 7 && item > 3);
`CHK(res.size == 1);
`CHK(res[0] == 6);
res = array.find_last_index() with (item < 3);
`CHK(res.size == 1);
`CHK(res[0] == 8);
if (!failed)
$display("PASSED");
end
endmodule

60
ivtest/ivltests/sv_queue_find.v Normal file
View File

@ -0,0 +1,60 @@
// Regression: queue find* locator methods (one argument: value matched with ==).
module top;
bit failed = 0;
`define CHK(cond) \
if (!(cond)) begin \
$display("FAILED line %0d", `__LINE__); \
failed = 1; \
end
int q[$];
int f[$];
int ix[$];
int ff[$];
int fi[$];
int lf[$];
int li[$];
initial begin
q.delete();
q.push_back(2);
q.push_back(1);
q.push_back(2);
q.push_back(3);
f = q.find(2);
`CHK(f.size == 2);
`CHK(f[0] == 2);
`CHK(f[1] == 2);
ix = q.find_index(2);
`CHK(ix.size == 2);
`CHK(ix[0] == 0);
`CHK(ix[1] == 2);
ff = q.find_first(3);
`CHK(ff.size == 1);
`CHK(ff[0] == 3);
fi = q.find_first_index(3);
`CHK(fi.size == 1);
`CHK(fi[0] == 3);
lf = q.find_last(2);
`CHK(lf.size == 1);
`CHK(lf[0] == 2);
li = q.find_last_index(2);
`CHK(li.size == 1);
`CHK(li[0] == 2);
ff = q.find_first(99);
`CHK(ff.size == 0);
fi = q.find_first_index(99);
`CHK(fi.size == 0);
if (!failed)
$display("PASSED");
end
endmodule

59
ivtest/ivltests/sv_queue_find_locators_ext.v Normal file
View File

@ -0,0 +1,59 @@
// Regression: queue locator methods with `with` — compound predicates and longer sequences.
module top;
bit failed = 0;
`define CHK(cond) \
if (!(cond)) begin \
$display("FAILED line %0d", `__LINE__); \
failed = 1; \
end
int q[$];
int res[$];
initial begin
q.delete();
q.push_back(4);
q.push_back(7);
q.push_back(2);
q.push_back(5);
q.push_back(7);
q.push_back(1);
q.push_back(6);
q.push_back(3);
q.push_back(1);
res = q.find() with (item > 3);
`CHK(res.size == 5);
`CHK(res[0] == 4);
`CHK(res[1] == 7);
`CHK(res[2] == 5);
`CHK(res[3] == 7);
`CHK(res[4] == 6);
res = q.find_index() with (item == 4);
`CHK(res.size == 1);
`CHK(res[0] == 0);
res = q.find_first() with (item < 5 && item >= 3);
`CHK(res.size == 1);
`CHK(res[0] == 4);
res = q.find_first_index() with (item > 5);
`CHK(res.size == 1);
`CHK(res[0] == 1);
res = q.find_last() with (item <= 7 && item > 3);
`CHK(res.size == 1);
`CHK(res[0] == 6);
res = q.find_last_index() with (item < 3);
`CHK(res.size == 1);
`CHK(res[0] == 8);
if (!failed)
$display("PASSED");
end
endmodule

66
ivtest/ivltests/sv_queue_find_with.v Normal file
View File

@ -0,0 +1,66 @@
// Regression: queue find* locator methods with `with (predicate)` (item, index).
module top;
bit failed = 0;
`define CHK(cond) \
if (!(cond)) begin \
$display("FAILED line %0d", `__LINE__); \
failed = 1; \
end
int q[$];
int f[$];
int ix[$];
int ff[$];
int fi[$];
int lf[$];
int li[$];
initial begin
q.delete();
q.push_back(2);
q.push_back(1);
q.push_back(2);
q.push_back(3);
f = q.find() with (item == 2);
`CHK(f.size == 2);
`CHK(f[0] == 2);
`CHK(f[1] == 2);
ix = q.find_index() with (item == 2);
`CHK(ix.size == 2);
`CHK(ix[0] == 0);
`CHK(ix[1] == 2);
ix = q.find_index() with (index > 0);
`CHK(ix.size == 3);
`CHK(ix[0] == 1);
`CHK(ix[1] == 2);
`CHK(ix[2] == 3);
ff = q.find_first() with (item == 3);
`CHK(ff.size == 1);
`CHK(ff[0] == 3);
fi = q.find_first_index() with (item == 2 && index > 0);
`CHK(fi.size == 1);
`CHK(fi[0] == 2);
lf = q.find_last() with (item < 3);
`CHK(lf.size == 1);
`CHK(lf[0] == 2);
li = q.find_last_index() with (item == 2);
`CHK(li.size == 1);
`CHK(li[0] == 2);
ff = q.find_first() with (item == 99);
`CHK(ff.size == 0);
fi = q.find_first_index() with (item == 99);
`CHK(fi.size == 0);
if (!failed)
$display("PASSED");
end
endmodule

40
ivtest/ivltests/sv_queue_unique.v Normal file
View File

@ -0,0 +1,40 @@
// Regression: queue unique() and unique_index() for integral packed queues.
module top;
bit failed = 0;
`define CHK(cond) \
if (!(cond)) begin \
$display("FAILED line %0d", `__LINE__); \
failed = 1; \
end
int q[$];
int u[$];
int ix[$];
initial begin
q.delete();
q.push_back(1);
q.push_back(2);
q.push_back(1);
q.push_back(3);
q.push_back(2);
u = q.unique();
`CHK(u.size == 3);
`CHK(u[0] == 1);
`CHK(u[1] == 2);
`CHK(u[2] == 3);
ix = q.unique_index();
`CHK(ix.size == 3);
`CHK(ix[0] == 0);
`CHK(ix[1] == 1);
`CHK(ix[2] == 3);
if (!failed)
$display("PASSED");
end
endmodule

5
ivtest/regress-vvp.list
View File

@ -308,6 +308,7 @@ sv_const_fail7 vvp_tests/sv_const_fail7.json
sv_const_fail8 vvp_tests/sv_const_fail8.json
sv_const_fail9 vvp_tests/sv_const_fail9.json
sv_darray_assign_op vvp_tests/sv_darray_assign_op.json
sv_darray_find_locators vvp_tests/sv_darray_find_locators.json
sv_default_port_value1 vvp_tests/sv_default_port_value1.json
sv_default_port_value2 vvp_tests/sv_default_port_value2.json
sv_default_port_value3 vvp_tests/sv_default_port_value3.json
@ -383,12 +384,16 @@ sv_parameter_type vvp_tests/sv_parameter_type.json
sv_partsel_var_negative_packed vvp_tests/sv_partsel_var_negative_packed.json
sv_queue_ap_method vvp_tests/sv_queue_ap_method.json
sv_queue_assign_op vvp_tests/sv_queue_assign_op.json
sv_queue_find vvp_tests/sv_queue_find.json
sv_queue_find_locators_ext vvp_tests/sv_queue_find_locators_ext.json
sv_queue_find_with vvp_tests/sv_queue_find_with.json
sv_queue_method_insert_too_few_arg_fail vvp_tests/sv_queue_method_insert_too_few_arg_fail.json
sv_queue_method_insert_too_many_arg_fail vvp_tests/sv_queue_method_insert_too_many_arg_fail.json
sv_queue_method_push_back_too_few_arg_fail vvp_tests/sv_queue_method_push_back_too_few_arg_fail.json
sv_queue_method_push_back_too_many_arg_fail vvp_tests/sv_queue_method_push_back_too_many_arg_fail.json
sv_queue_method_push_front_too_few_arg_fail vvp_tests/sv_queue_method_push_front_too_few_arg_fail.json
sv_queue_method_push_front_too_many_arg_fail vvp_tests/sv_queue_method_push_front_too_many_arg_fail.json
sv_queue_unique vvp_tests/sv_queue_unique.json
sv_soft_packed_union vvp_tests/sv_soft_packed_union.json
sv_soft_packed_union_fail1 vvp_tests/sv_soft_packed_union_fail1.json
sv_string_method_substr_too_few_arg_fail vvp_tests/sv_string_method_substr_too_few_arg_fail.json

9
ivtest/vvp_tests/sv_darray_find_locators.json Normal file
View File

@ -0,0 +1,9 @@
{
"type" : "normal",
"source" : "sv_darray_find_locators.v",
"iverilog-args" : [ "-g2005-sv" ],
"vlog95" : {
"__comment" : "SystemVerilog dynamic array locator methods",
"type" : "CE"
}
}

9
ivtest/vvp_tests/sv_queue_find.json Normal file
View File

@ -0,0 +1,9 @@
{
"type" : "normal",
"source" : "sv_queue_find.v",
"iverilog-args" : [ "-g2005-sv" ],
"vlog95" : {
"__comment" : "SystemVerilog queues",
"type" : "CE"
}
}

9
ivtest/vvp_tests/sv_queue_find_locators_ext.json Normal file
View File

@ -0,0 +1,9 @@
{
"type" : "normal",
"source" : "sv_queue_find_locators_ext.v",
"iverilog-args" : [ "-g2005-sv" ],
"vlog95" : {
"__comment" : "SystemVerilog queue locator methods",
"type" : "CE"
}
}

9
ivtest/vvp_tests/sv_queue_find_with.json Normal file
View File

@ -0,0 +1,9 @@
{
"type" : "normal",
"source" : "sv_queue_find_with.v",
"iverilog-args" : [ "-g2005-sv" ],
"vlog95" : {
"__comment" : "SystemVerilog queues",
"type" : "CE"
}
}

9
ivtest/vvp_tests/sv_queue_unique.json Normal file
View File

@ -0,0 +1,9 @@
{
"type" : "normal",
"source" : "sv_queue_unique.v",
"iverilog-args" : [ "-g2005-sv" ],
"vlog95" : {
"__comment" : "SystemVerilog queues",
"type" : "CE"
}
}

16
netdarray.cc
View File

@ -39,10 +39,20 @@ ivl_variable_type_t netdarray_t::base_type(void) const
bool netdarray_t::test_equivalence(ivl_type_t that) const
{
// Queues and dynamic arrays are not equivalent, so check for the base
// type to make sure both are either dynamic array or queue.
if (base_type() != that->base_type())
const netdarray_t* that_da = dynamic_cast<const netdarray_t*>(that);
if (!that_da) return false;
/* Queue vs unpacked dynamic array: same element type is assignable
* (e.g. int[$] = array.find_first(...), locator return is a queue). */
if (base_type() != that->base_type()) {
if ((base_type() == IVL_VT_QUEUE &&
that->base_type() == IVL_VT_DARRAY) ||
(base_type() == IVL_VT_DARRAY &&
that->base_type() == IVL_VT_QUEUE)) {
return element_type()->type_equivalent(that_da->element_type());
}
return false;
}
return test_compatibility(that);
}

71
netmisc.cc
View File

@ -899,32 +899,38 @@ NetExpr* elab_and_eval(Design*des, NetScope*scope, PExpr*pe,
if (tmp == 0) return 0;
if ((cast_type != IVL_VT_NO_TYPE) && (cast_type != tmp->expr_type())) {
switch (tmp->expr_type()) {
case IVL_VT_BOOL:
case IVL_VT_LOGIC:
case IVL_VT_REAL:
break;
default:
cerr << tmp->get_fileline() << ": error: "
"The expression '" << *pe << "' cannot be implicitly "
"cast to the target type." << endl;
des->errors += 1;
delete tmp;
return 0;
}
switch (cast_type) {
case IVL_VT_REAL:
tmp = cast_to_real(tmp);
break;
case IVL_VT_BOOL:
tmp = cast_to_int2(tmp, pos_context_width);
break;
case IVL_VT_LOGIC:
tmp = cast_to_int4(tmp, pos_context_width);
break;
default:
break;
}
bool qdar_mix = (cast_type == IVL_VT_QUEUE ||
cast_type == IVL_VT_DARRAY) &&
(tmp->expr_type() == IVL_VT_QUEUE ||
tmp->expr_type() == IVL_VT_DARRAY);
if (!qdar_mix) {
switch (tmp->expr_type()) {
case IVL_VT_BOOL:
case IVL_VT_LOGIC:
case IVL_VT_REAL:
break;
default:
cerr << tmp->get_fileline() << ": error: "
"The expression '" << *pe << "' cannot be implicitly "
"cast to the target type." << endl;
des->errors += 1;
delete tmp;
return 0;
}
switch (cast_type) {
case IVL_VT_REAL:
tmp = cast_to_real(tmp);
break;
case IVL_VT_BOOL:
tmp = cast_to_int2(tmp, pos_context_width);
break;
case IVL_VT_LOGIC:
tmp = cast_to_int4(tmp, pos_context_width);
break;
default:
break;
}
}
}
eval_expr(tmp, context_width);
@ -967,12 +973,25 @@ NetExpr* elab_and_eval(Design*des, NetScope*scope, PExpr*pe,
compatible = lv_net_type->type_compatible(tmp->net_type());
else
compatible = false;
} else if ((cast_type == IVL_VT_QUEUE || cast_type == IVL_VT_DARRAY) &&
(expr_type == IVL_VT_QUEUE || expr_type == IVL_VT_DARRAY)) {
if (tmp->net_type()) {
compatible = lv_net_type->type_compatible(tmp->net_type());
} else {
compatible = cast_type == expr_type;
}
} else if (cast_type == IVL_VT_NO_TYPE) {
compatible = true;
} else {
compatible = cast_type == expr_type;
}
/* R-value may report a coarse expr_type while net_type matches (e.g.
* queue locators); prefer structural compatibility when available. */
if (!compatible && tmp->net_type()) {
compatible = lv_net_type->type_compatible(tmp->net_type());
}
if (!compatible) {
// Catch some special cases.
switch (cast_type) {

39
parse.y
View File

@ -4256,6 +4256,21 @@ call_chain_expr
delete $5;
$$ = tmp;
}
| call_chain_expr K_with '(' expression ')'
{ PECallFunction* cf = dynamic_cast<PECallFunction*>($1);
if (cf == 0) {
if (gn_system_verilog())
yyerror(@2, "Error: `with` clause must follow a method call.");
else
yyerror(@2, "Error: Enable SystemVerilog for `with` clause on method calls.");
delete $1;
delete $4;
$$ = 0;
} else {
cf->set_with_clause($4);
$$ = cf;
}
}
;
expr_primary
@ -4321,6 +4336,15 @@ expr_primary
so `id (` is not reduced as PEIdent + error. */
| call_chain_expr
{ $$ = $1; }
/* SV: q.find with (item == 1) — iterator names item, index */
| hierarchy_identifier K_with '(' expression ')'
{ std::vector<named_pexpr_t> empty;
PECallFunction* tmp = new PECallFunction(*$1, empty);
FILE_NAME(tmp, @1);
tmp->set_with_clause($4);
delete $1;
$$ = tmp;
}
| hierarchy_identifier
{ PEIdent*tmp = pform_new_ident(@1, *$1);
FILE_NAME(tmp, @1);
@ -4344,14 +4368,6 @@ expr_primary
$$ = tmp;
delete nm;
}
| hierarchy_identifier '.' K_unique
{ pform_name_t * nm = $1;
nm->push_back(name_component_t(lex_strings.make("unique")));
PEIdent*tmp = pform_new_ident(@1, *nm);
FILE_NAME(tmp, @1);
$$ = tmp;
delete nm;
}
| hierarchy_identifier '.' K_xor
{ pform_name_t * nm = $1;
nm->push_back(name_component_t(lex_strings.make("xor")));
@ -4360,7 +4376,6 @@ expr_primary
$$ = tmp;
delete nm;
}
| package_scope hierarchy_identifier
{ lex_in_package_scope(0);
$$ = pform_package_ident(@2, $1, $2);
@ -4860,6 +4875,12 @@ hierarchy_identifier
delete[]$3;
$$ = tmp;
}
/* "unique" is a keyword (K_unique) but also a queue/array method name. */
| hierarchy_identifier '.' K_unique
{ pform_name_t * tmp = $1;
tmp->push_back(name_component_t(lex_strings.make("unique")));
$$ = tmp;
}
| hierarchy_identifier '[' expression ']'
{ pform_name_t * tmp = $1;
name_component_t&tail = tmp->back();

3
pform_dump.cc
View File

@ -426,6 +426,9 @@ void PECallFunction::dump(ostream &out) const
out << ".";
}
out << path_ << "(" << parms_ << ")";
if (peek_with_clause()) {
out << " with (" << *peek_with_clause() << ")";
}
}
void PECastSize::dump(ostream &out) const

451
tgt-vvp/eval_object.c
View File

@ -257,6 +257,440 @@ static int eval_object_ufunc(ivl_expr_t ex)
return 0;
}
static unsigned queue_unique_src_elem_wid(ivl_expr_t arg)
{
ivl_type_t src_q = 0;
if (ivl_expr_type(arg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(arg);
unsigned pidx = ivl_expr_property_idx(arg);
src_q = ivl_type_prop_type(ivl_signal_net_type(cl), pidx);
} else if (ivl_expr_type(arg) == IVL_EX_SIGNAL) {
src_q = ivl_signal_net_type(ivl_expr_signal(arg));
} else {
return 0;
}
if (ivl_type_base(src_q) == IVL_VT_QUEUE ||
ivl_type_base(src_q) == IVL_VT_DARRAY) {
return ivl_type_packed_width(ivl_type_element(src_q));
}
return 0;
}
static int eval_queue_method_unique(ivl_expr_t expr)
{
const char*name = ivl_expr_name(expr);
ivl_expr_t arg = ivl_expr_parm(expr, 0);
unsigned elem_wid = queue_unique_src_elem_wid(arg);
if (elem_wid == 0) return 1;
if (strcmp(name, "$ivl_queue_method$unique") == 0) {
if (ivl_expr_type(arg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(arg);
unsigned pidx = ivl_expr_property_idx(arg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/unique/prop/v %u, %u;\n", pidx,
elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(arg);
fprintf(vvp_out, " %%queue/unique/v v%p_0, %u;\n", sig,
elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$unique_index") == 0) {
if (ivl_expr_type(arg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(arg);
unsigned pidx = ivl_expr_property_idx(arg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/unique/index/prop/v %u, %u;\n",
pidx, elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(arg);
fprintf(vvp_out, " %%queue/unique/index/v v%p_0, %u;\n",
sig, elem_wid);
}
return 0;
}
return 1;
}
/*
* Array locator methods with `with (predicate)` — parms:
* 0: queue, 1: predicate, 2: item ivl_signal, 3: index ivl_signal
*/
enum queue_locator_with_mode_e {
QUEUE_WITH_FIND,
QUEUE_WITH_FIND_INDEX,
QUEUE_WITH_FIND_FIRST,
QUEUE_WITH_FIND_FIRST_INDEX,
QUEUE_WITH_FIND_LAST,
QUEUE_WITH_FIND_LAST_INDEX
};
static enum queue_locator_with_mode_e queue_locator_with_mode_from_name(
const char* name)
{
if (strcmp(name, "$ivl_queue_method$find_with") == 0) {
return QUEUE_WITH_FIND;
} else if (strcmp(name, "$ivl_queue_method$find_index_with") == 0) {
return QUEUE_WITH_FIND_INDEX;
} else if (strcmp(name, "$ivl_queue_method$find_first_with") == 0) {
return QUEUE_WITH_FIND_FIRST;
} else if (strcmp(name, "$ivl_queue_method$find_first_index_with") == 0) {
return QUEUE_WITH_FIND_FIRST_INDEX;
} else if (strcmp(name, "$ivl_queue_method$find_last_with") == 0) {
return QUEUE_WITH_FIND_LAST;
} else if (strcmp(name, "$ivl_queue_method$find_last_index_with") == 0) {
return QUEUE_WITH_FIND_LAST_INDEX;
}
return (enum queue_locator_with_mode_e) -1;
}
static int queue_with_reverse(enum queue_locator_with_mode_e mode)
{
return mode == QUEUE_WITH_FIND_LAST ||
mode == QUEUE_WITH_FIND_LAST_INDEX;
}
static int queue_with_multi(enum queue_locator_with_mode_e mode)
{
return mode == QUEUE_WITH_FIND || mode == QUEUE_WITH_FIND_INDEX;
}
static int eval_queue_method_find_with(ivl_expr_t expr)
{
const char* name = ivl_expr_name(expr);
if (ivl_expr_parms(expr) != 4) return 1;
if (strncmp(name, "$ivl_queue_method$",
sizeof("$ivl_queue_method$") - 1) != 0) return 1;
if (strstr(name, "_with") == 0) return 1;
ivl_expr_t qarg = ivl_expr_parm(expr, 0);
ivl_expr_t pred = ivl_expr_parm(expr, 1);
ivl_signal_t item_sig = ivl_expr_signal(ivl_expr_parm(expr, 2));
ivl_signal_t idx_sig = ivl_expr_signal(ivl_expr_parm(expr, 3));
unsigned elem_wid = queue_unique_src_elem_wid(qarg);
if (elem_wid == 0) return 1;
enum queue_locator_with_mode_e mode = queue_locator_with_mode_from_name(name);
if ((int) mode < 0) return 1;
int i_reg = allocate_word();
int n_reg = allocate_word();
unsigned lab_top = local_count++;
unsigned lab_loop_end = local_count++;
unsigned lab_nom = local_count++;
unsigned lab_found = local_count++;
unsigned lab_end = local_count++;
int reverse = queue_with_reverse(mode);
unsigned append_wid = (mode == QUEUE_WITH_FIND_INDEX) ? 32 : elem_wid;
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%prop/queue/size %u;\n", pidx);
fprintf(vvp_out, " %%ix/vec4/s %u;\n", n_reg);
if (queue_with_multi(mode)) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
}
if (!reverse) {
fprintf(vvp_out, " %%ix/load %u, 0, 0;\n", i_reg);
fprintf(vvp_out, " %%flag_set/imm 4, 0;\n");
} else {
fprintf(vvp_out, " %%ix/load %u, 0, 0;\n", i_reg);
fprintf(vvp_out, " %%ix/mov %u, %u;\n", i_reg, n_reg);
fprintf(vvp_out, " %%ix/sub %u, 1, 0;\n", i_reg);
}
fprintf(vvp_out, "T_%u.%u ; queue with loop\n", thread_count, lab_top);
if (!reverse) {
fprintf(vvp_out, " %%cmpix/ltu %u, %u;\n", i_reg, n_reg);
fprintf(vvp_out, " %%jmp/0 T_%u.%u, 4;\n", thread_count,
lab_loop_end);
} else {
fprintf(vvp_out, " %%cmpix/slt0 %u;\n", i_reg);
fprintf(vvp_out, " %%jmp/1 T_%u.%u, 4;\n", thread_count,
lab_loop_end);
}
/* cmpix leaves flag 4 set; %queue/word* uses flag 4 for X push */
fprintf(vvp_out, " %%flag_set/imm 4, 0;\n");
fprintf(vvp_out, " %%queue/word/prop/v %u, %u, %u;\n", pidx,
elem_wid, i_reg);
fprintf(vvp_out, " %%store/vec4 v%p_0, 0, %u;\n", item_sig,
elem_wid);
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%store/vec4 v%p_0, 0, 32;\n", idx_sig);
int pf = draw_eval_condition(pred);
fprintf(vvp_out, " %%jmp/0 T_%u.%u, %d;\n", thread_count, lab_nom,
pf);
clr_flag(pf);
if (mode == QUEUE_WITH_FIND) {
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", append_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_nom);
} else if (mode == QUEUE_WITH_FIND_INDEX) {
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_nom);
} else if (mode == QUEUE_WITH_FIND_FIRST) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", elem_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_found);
} else if (mode == QUEUE_WITH_FIND_FIRST_INDEX) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_found);
} else if (mode == QUEUE_WITH_FIND_LAST) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", elem_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_found);
} else {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_found);
}
fprintf(vvp_out, "T_%u.%u ; nomatch\n", thread_count, lab_nom);
if (!reverse) {
fprintf(vvp_out, " %%ix/add %u, 1, 0;\n", i_reg);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_top);
} else {
fprintf(vvp_out, " %%ix/sub %u, 1, 0;\n", i_reg);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_top);
}
fprintf(vvp_out, "T_%u.%u ; found (queue prop)\n", thread_count,
lab_found);
fprintf(vvp_out, " %%pop/obj 1, 1;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_end);
fprintf(vvp_out, "T_%u.%u ; loop end (prop)\n", thread_count,
lab_loop_end);
if (queue_with_multi(mode)) {
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%pop/obj 1, 1;\n");
}
fprintf(vvp_out, "T_%u.%u ; with end (prop)\n", thread_count, lab_end);
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/size/v v%p_0;\n", sig);
fprintf(vvp_out, " %%ix/vec4/s %u;\n", n_reg);
if (queue_with_multi(mode)) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
}
if (!reverse) {
fprintf(vvp_out, " %%ix/load %u, 0, 0;\n", i_reg);
fprintf(vvp_out, " %%flag_set/imm 4, 0;\n");
} else {
fprintf(vvp_out, " %%ix/load %u, 0, 0;\n", i_reg);
fprintf(vvp_out, " %%ix/mov %u, %u;\n", i_reg, n_reg);
fprintf(vvp_out, " %%ix/sub %u, 1, 0;\n", i_reg);
}
fprintf(vvp_out, "T_%u.%u ; queue with loop (var)\n", thread_count,
lab_top);
if (!reverse) {
fprintf(vvp_out, " %%cmpix/ltu %u, %u;\n", i_reg, n_reg);
fprintf(vvp_out, " %%jmp/0 T_%u.%u, 4;\n", thread_count,
lab_loop_end);
} else {
fprintf(vvp_out, " %%cmpix/slt0 %u;\n", i_reg);
fprintf(vvp_out, " %%jmp/1 T_%u.%u, 4;\n", thread_count,
lab_loop_end);
}
fprintf(vvp_out, " %%flag_set/imm 4, 0;\n");
fprintf(vvp_out, " %%queue/word/v v%p_0, %u, %u;\n", sig, elem_wid,
i_reg);
fprintf(vvp_out, " %%store/vec4 v%p_0, 0, %u;\n", item_sig,
elem_wid);
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%store/vec4 v%p_0, 0, 32;\n", idx_sig);
int pf = draw_eval_condition(pred);
fprintf(vvp_out, " %%jmp/0 T_%u.%u, %d;\n", thread_count, lab_nom,
pf);
clr_flag(pf);
if (mode == QUEUE_WITH_FIND) {
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", append_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_nom);
} else if (mode == QUEUE_WITH_FIND_INDEX) {
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_nom);
} else if (mode == QUEUE_WITH_FIND_FIRST) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", elem_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_end);
} else if (mode == QUEUE_WITH_FIND_FIRST_INDEX) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_end);
} else if (mode == QUEUE_WITH_FIND_LAST) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%load/vec4 v%p_0;\n", item_sig);
fprintf(vvp_out, " %%queue/append_word/v %u;\n", elem_wid);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_end);
} else {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
fprintf(vvp_out, " %%push/ix/vec4 %u, 32, 1;\n", i_reg);
fprintf(vvp_out, " %%queue/append_word/v 32;\n");
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_end);
}
fprintf(vvp_out, "T_%u.%u ; nomatch (var)\n", thread_count, lab_nom);
if (!reverse) {
fprintf(vvp_out, " %%ix/add %u, 1, 0;\n", i_reg);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_top);
} else {
fprintf(vvp_out, " %%ix/sub %u, 1, 0;\n", i_reg);
fprintf(vvp_out, " %%jmp T_%u.%u;\n", thread_count, lab_top);
}
fprintf(vvp_out, "T_%u.%u ; loop end (var)\n", thread_count,
lab_loop_end);
if (mode >= QUEUE_WITH_FIND_FIRST) {
fprintf(vvp_out, " %%queue/new_empty/v;\n");
}
fprintf(vvp_out, "T_%u.%u ; with end (var)\n", thread_count, lab_end);
}
clr_word(i_reg);
clr_word(n_reg);
return 0;
}
static int eval_queue_method_find(ivl_expr_t expr)
{
const char*name = ivl_expr_name(expr);
if (ivl_expr_parms(expr) == 4 &&
strstr(ivl_expr_name(expr), "_with") != 0)
return eval_queue_method_find_with(expr);
ivl_expr_t qarg = ivl_expr_parm(expr, 0);
ivl_expr_t carg = ivl_expr_parm(expr, 1);
unsigned elem_wid = queue_unique_src_elem_wid(qarg);
if (elem_wid == 0) return 1;
draw_eval_vec4(carg);
if (strcmp(name, "$ivl_queue_method$find") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find/prop/v %u, %u;\n", pidx,
elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find/v v%p_0, %u;\n", sig,
elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$find_index") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find/index/prop/v %u, %u;\n",
pidx, elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find/index/v v%p_0, %u;\n",
sig, elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$find_first") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find_first/prop/v %u, %u;\n", pidx,
elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find_first/v v%p_0, %u;\n", sig,
elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$find_first_index") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find_first/index/prop/v %u, %u;\n",
pidx, elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find_first/index/v v%p_0, %u;\n",
sig, elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$find_last") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find_last/prop/v %u, %u;\n", pidx,
elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find_last/v v%p_0, %u;\n", sig,
elem_wid);
}
return 0;
}
if (strcmp(name, "$ivl_queue_method$find_last_index") == 0) {
if (ivl_expr_type(qarg) == IVL_EX_PROPERTY) {
ivl_signal_t cl = ivl_expr_signal(qarg);
unsigned pidx = ivl_expr_property_idx(qarg);
fprintf(vvp_out, " %%load/obj v%p_0;\n", cl);
fprintf(vvp_out, " %%queue/find_last/index/prop/v %u, %u;\n",
pidx, elem_wid);
fprintf(vvp_out, " %%pop/obj 1, 0;\n");
} else {
ivl_signal_t sig = ivl_expr_signal(qarg);
fprintf(vvp_out, " %%queue/find_last/index/v v%p_0, %u;\n",
sig, elem_wid);
}
return 0;
}
return 1;
}
int draw_queue_method_find_sfunc(ivl_expr_t expr)
{
return eval_queue_method_find(expr);
}
int draw_eval_object(ivl_expr_t ex)
{
switch (ivl_expr_type(ex)) {
@ -288,6 +722,23 @@ int draw_eval_object(ivl_expr_t ex)
case IVL_EX_UFUNC:
return eval_object_ufunc(ex);
case IVL_EX_SFUNC:
/* Queue locator `with` may report IVL_VT_DARRAY in ivl; handle by name. */
if (ivl_expr_parms(ex) == 4 &&
strncmp(ivl_expr_name(ex), "$ivl_queue_method$",
sizeof("$ivl_queue_method$") - 1) == 0 &&
strstr(ivl_expr_name(ex), "_with") != 0) {
if (draw_queue_method_find_sfunc(ex) == 0) return 0;
}
if (ivl_expr_value(ex) == IVL_VT_QUEUE ||
ivl_expr_value(ex) == IVL_VT_DARRAY) {
if (eval_queue_method_unique(ex) == 0) return 0;
if (eval_queue_method_find(ex) == 0) return 0;
}
fprintf(vvp_out, "; ERROR: draw_eval_object: unsupported IVL_EX_SFUNC "
"for object context\n");
return 1;
default:
fprintf(vvp_out, "; ERROR: draw_eval_object: Invalid expression type %d\n", ivl_expr_type(ex));
return 1;

8
tgt-vvp/eval_vec4.c
View File

@ -1108,6 +1108,14 @@ static void draw_sfunc_vec4(ivl_expr_t expr)
return;
}
/* find*_with has four parameters and is lowered in eval_object.c */
if (parm_count == 4 &&
strncmp(ivl_expr_name(expr), "$ivl_queue_method$",
sizeof("$ivl_queue_method$") - 1) == 0 &&
strstr(ivl_expr_name(expr), "_with") != 0) {
if (draw_queue_method_find_sfunc(expr) == 0) return;
}
if (strcmp(ivl_expr_name(expr), "$size")==0 && parm_count==1) {
ivl_expr_t arg = ivl_expr_parm(expr, 0);
if (ivl_expr_type(arg) == IVL_EX_PROPERTY) {

6
tgt-vvp/vvp_priv.h
View File

@ -228,6 +228,12 @@ extern void draw_eval_string(ivl_expr_t ex);
*/
extern int draw_eval_object(ivl_expr_t ex);
/*
* Emit vvp for $ivl_queue_method$find* / find*_with when the call appears
* as a vector SFUNC (e.g. find_first with (...) returning int).
*/
extern int draw_queue_method_find_sfunc(ivl_expr_t expr);
extern int show_stmt_assign(ivl_statement_t net);
extern void show_stmt_file_line(ivl_statement_t net, const char*desc);

24
vvp/codes.h
View File

@ -250,6 +250,30 @@ extern bool of_QPOP_PROP_F_REAL(vthread_t thr, vvp_code_t code);
extern bool of_QPOP_PROP_F_STR(vthread_t thr, vvp_code_t code);
extern bool of_QPOP_PROP_F_V(vthread_t thr, vvp_code_t code);
extern bool of_PROP_QUEUE_SIZE(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_APPEND_WORD_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_NEW_EMPTY_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_SIZE_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_WORD_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_WORD_V(vthread_t thr, vvp_code_t code);
extern bool of_CMPIX_LTU(vthread_t thr, vvp_code_t code);
extern bool of_CMPIX_SLT0(vthread_t thr, vvp_code_t code);
extern bool of_PUSH_IX_VEC4(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_INDEX_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_INDEX_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_FIRST_INDEX_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_FIRST_INDEX_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_FIRST_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_FIRST_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_LAST_INDEX_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_LAST_INDEX_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_LAST_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_FIND_LAST_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_UNIQUE_INDEX_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_UNIQUE_INDEX_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_UNIQUE_PROP_V(vthread_t thr, vvp_code_t code);
extern bool of_QUEUE_UNIQUE_V(vthread_t thr, vvp_code_t code);
extern bool of_DELETE_PROP_ELEM(vthread_t thr, vvp_code_t code);
extern bool of_DELETE_PROP_OBJ(vthread_t thr, vvp_code_t code);
extern bool of_STORE_QB_R(vthread_t thr, vvp_code_t code);

24
vvp/compile.cc
View File

@ -139,6 +139,8 @@ static const struct opcode_table_s opcode_table[] = {
{ "%cmpi/ne", of_CMPINE, 3, {OA_BIT1, OA_BIT2, OA_NUMBER} },
{ "%cmpi/s", of_CMPIS, 3, {OA_BIT1, OA_BIT2, OA_NUMBER} },
{ "%cmpi/u", of_CMPIU, 3, {OA_BIT1, OA_BIT2, OA_NUMBER} },
{ "%cmpix/ltu", of_CMPIX_LTU, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%cmpix/slt0", of_CMPIX_SLT0, 1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%concat/str", of_CONCAT_STR, 0,{OA_NONE, OA_NONE, OA_NONE} },
{ "%concat/vec4", of_CONCAT_VEC4, 0,{OA_NONE, OA_NONE, OA_NONE} },
{ "%concati/str", of_CONCATI_STR, 1,{OA_STRING,OA_NONE, OA_NONE} },
@ -253,6 +255,7 @@ static const struct opcode_table_s opcode_table[] = {
{ "%prop/r", of_PROP_R, 1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%prop/str",of_PROP_STR,1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%prop/v", of_PROP_V, 1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%push/ix/vec4", of_PUSH_IX_VEC4, 3, {OA_NUMBER, OA_BIT1, OA_BIT2} },
{ "%pushi/real",of_PUSHI_REAL,2,{OA_BIT1, OA_BIT2, OA_NONE} },
{ "%pushi/str", of_PUSHI_STR, 1,{OA_STRING, OA_NONE, OA_NONE} },
{ "%pushi/vec4",of_PUSHI_VEC4,3,{OA_BIT1, OA_BIT2, OA_NUMBER} },
@ -276,6 +279,27 @@ static const struct opcode_table_s opcode_table[] = {
{ "%qpop/prop/f/r", of_QPOP_PROP_F_REAL, 1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%qpop/prop/f/str", of_QPOP_PROP_F_STR, 1, {OA_NUMBER, OA_NONE, OA_NONE} },
{ "%qpop/prop/f/v", of_QPOP_PROP_F_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/append_word/v", of_QUEUE_APPEND_WORD_V, 1, {OA_BIT1, OA_NONE, OA_NONE} },
{ "%queue/find/index/prop/v", of_QUEUE_FIND_INDEX_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find/index/v", of_QUEUE_FIND_INDEX_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/find/prop/v", of_QUEUE_FIND_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find/v", of_QUEUE_FIND_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/find_first/index/prop/v", of_QUEUE_FIND_FIRST_INDEX_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find_first/index/v", of_QUEUE_FIND_FIRST_INDEX_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/find_first/prop/v", of_QUEUE_FIND_FIRST_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find_first/v", of_QUEUE_FIND_FIRST_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/find_last/index/prop/v", of_QUEUE_FIND_LAST_INDEX_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find_last/index/v", of_QUEUE_FIND_LAST_INDEX_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/find_last/prop/v", of_QUEUE_FIND_LAST_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/find_last/v", of_QUEUE_FIND_LAST_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/new_empty/v", of_QUEUE_NEW_EMPTY_V, 0, {OA_NONE, OA_NONE, OA_NONE} },
{ "%queue/size/v", of_QUEUE_SIZE_V, 1, {OA_FUNC_PTR, OA_NONE, OA_NONE} },
{ "%queue/unique/index/prop/v", of_QUEUE_UNIQUE_INDEX_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/unique/index/v", of_QUEUE_UNIQUE_INDEX_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/unique/prop/v", of_QUEUE_UNIQUE_PROP_V, 2, {OA_NUMBER, OA_BIT1, OA_NONE} },
{ "%queue/unique/v", of_QUEUE_UNIQUE_V, 2, {OA_FUNC_PTR, OA_BIT1, OA_NONE} },
{ "%queue/word/prop/v", of_QUEUE_WORD_PROP_V, 3, {OA_NUMBER, OA_BIT1, OA_BIT2} },
{ "%queue/word/v", of_QUEUE_WORD_V, 3, {OA_FUNC_PTR, OA_BIT1, OA_BIT2} },
{ "%release/net",of_RELEASE_NET,3,{OA_FUNC_PTR,OA_BIT1,OA_BIT2} },
{ "%release/reg",of_RELEASE_REG,3,{OA_FUNC_PTR,OA_BIT1,OA_BIT2} },
{ "%release/wr", of_RELEASE_WR, 2,{OA_FUNC_PTR,OA_BIT1,OA_NONE} },

642
vvp/vthread.cc
View File

@ -504,6 +504,42 @@ template <class VVP_QUEUE> static vvp_queue*get_queue_object(vthread_t thr, vvp_
return queue;
}
/*
* Locator and size/word opcodes use the same VVP net for a queue ($) or a
* dynamic array ([]). Queues are vvp_queue_vec4; dynamic arrays may be
* vvp_darray_vec4, vvp_darray_atom<>, etc. (all vvp_darray, but vvp_queue
* also derives from vvp_darray — test queue vec4 first).
*/
static void get_queue_or_darray_vec4_from_net(vthread_t thr, vvp_net_t* net,
vvp_queue_vec4*& qsrc,
vvp_darray*& dsrc)
{
vvp_fun_signal_object* obj = dynamic_cast<vvp_fun_signal_object*>(net->fun);
assert(obj);
vvp_object_t top = obj->get_object();
qsrc = top.peek<vvp_queue_vec4>();
if (qsrc) {
dsrc = 0;
return;
}
vvp_darray* dany = top.peek<vvp_darray>();
if (dany && dynamic_cast<vvp_queue*>(dany) == 0) {
dsrc = dany;
return;
}
if (top.test_nil()) {
qsrc = new vvp_queue_vec4();
vvp_object_t val(qsrc);
vvp_net_ptr_t ptr(net, 0);
vvp_send_object(ptr, val, thr->wt_context);
dsrc = 0;
return;
}
/* e.g. real/string queue — not vec4 queue or plain darray */
qsrc = 0;
dsrc = 0;
}
/*
* The following are used to allow a common template to be written for
* queue real/string/vec4 operations
@ -6128,6 +6164,449 @@ bool of_QPOP_PROP_F_V(vthread_t thr, vvp_code_t cp)
return qpop_f_prop<vvp_vector4_t, vvp_queue_vec4>(thr, cp, cp->bit_idx[0]);
}
static vvp_vector4_t queue_unique_ulong_to_vec4(unsigned long ul, unsigned bits)
{
vvp_vector4_t val(bits, BIT4_0);
for (unsigned idx = 0; idx < bits && idx < 8 * sizeof(unsigned long); idx += 1) {
if (ul & 1UL) {
val.set_bit(idx, BIT4_1);
} else {
val.set_bit(idx, BIT4_0);
}
ul >>= 1;
}
return val;
}
template <class SRC> static vvp_queue_vec4* queue_run_unique_src(SRC* src,
unsigned wid,
bool as_index)
{
vvp_queue_vec4* dst = new vvp_queue_vec4();
if (!src) return dst;
size_t n = src->get_size();
for (size_t i = 0; i < n; i += 1) {
vvp_vector4_t vi(wid);
src->get_word(i, vi);
bool seen = false;
for (size_t j = 0; j < i; j += 1) {
vvp_vector4_t vj(wid);
src->get_word(j, vj);
if (vi.eeq(vj)) {
seen = true;
break;
}
}
if (seen) continue;
if (as_index) {
dst->push_back(queue_unique_ulong_to_vec4((unsigned long)i, 32), 0);
} else {
dst->push_back(vi, 0);
}
}
return dst;
}
template <class SRC>
static vvp_queue_vec4* queue_run_find_matches_src(SRC* src, unsigned wid,
const vvp_vector4_t& cmp,
bool as_index)
{
vvp_queue_vec4* dst = new vvp_queue_vec4();
if (!src) return dst;
size_t n = src->get_size();
for (size_t i = 0; i < n; i += 1) {
vvp_vector4_t vi(wid);
src->get_word(i, vi);
if (vi.eeq(cmp)) {
if (as_index) {
dst->push_back(queue_unique_ulong_to_vec4((unsigned long)i, 32), 0);
} else {
dst->push_back(vi, 0);
}
}
}
return dst;
}
/* Array/queue locator methods return a queue with 0 or 1 elements (LRM). */
template <class SRC>
static vvp_queue_vec4* queue_find_first_last_to_queue_src(SRC* src,
unsigned wid,
const vvp_vector4_t& cmp,
bool want_first,
bool want_index)
{
vvp_queue_vec4* dst = new vvp_queue_vec4();
if (!src || src->get_size() == 0) return dst;
size_t n = src->get_size();
if (want_first) {
for (size_t i = 0; i < n; i += 1) {
vvp_vector4_t vi(wid);
src->get_word(i, vi);
if (vi.eeq(cmp)) {
if (want_index) {
dst->push_back(
queue_unique_ulong_to_vec4((unsigned long)i, 32),
0);
} else {
dst->push_back(vi, 0);
}
return dst;
}
}
} else {
for (size_t i = n; i > 0; ) {
i -= 1;
vvp_vector4_t vi(wid);
src->get_word(i, vi);
if (vi.eeq(cmp)) {
if (want_index) {
dst->push_back(
queue_unique_ulong_to_vec4((unsigned long)i, 32),
0);
} else {
dst->push_back(vi, 0);
}
return dst;
}
}
}
return dst;
}
bool of_QUEUE_FIND_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_run_find_matches_src(qsrc, wid, cmp, false);
else if (dsrc) dst = queue_run_find_matches_src(dsrc, wid, cmp, false);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_run_find_matches_src(src, wid, cmp, false);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
if (src == 0) {
thr->push_object(vvp_object_t(new vvp_queue_vec4()));
return true;
}
vvp_queue_vec4* dst = queue_run_find_matches_src(src, wid, cmp, false);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_INDEX_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_run_find_matches_src(qsrc, wid, cmp, true);
else if (dsrc) dst = queue_run_find_matches_src(dsrc, wid, cmp, true);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_run_find_matches_src(src, wid, cmp, true);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_INDEX_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
if (src == 0) {
thr->push_object(vvp_object_t(new vvp_queue_vec4()));
return true;
}
vvp_queue_vec4* dst = queue_run_find_matches_src(src, wid, cmp, true);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_FIRST_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_find_first_last_to_queue_src(qsrc, wid, cmp, true, false);
else if (dsrc) dst = queue_find_first_last_to_queue_src(dsrc, wid, cmp, true, false);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_find_first_last_to_queue_src(src, wid, cmp, true, false);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_FIRST_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
vvp_queue_vec4* dst =
queue_find_first_last_to_queue_src(src, wid, cmp, true, false);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_FIRST_INDEX_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_find_first_last_to_queue_src(qsrc, wid, cmp, true, true);
else if (dsrc) dst = queue_find_first_last_to_queue_src(dsrc, wid, cmp, true, true);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_find_first_last_to_queue_src(src, wid, cmp, true, true);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_FIRST_INDEX_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
vvp_queue_vec4* dst =
queue_find_first_last_to_queue_src(src, wid, cmp, true, true);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_LAST_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_find_first_last_to_queue_src(qsrc, wid, cmp, false, false);
else if (dsrc) dst = queue_find_first_last_to_queue_src(dsrc, wid, cmp, false, false);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_find_first_last_to_queue_src(src, wid, cmp, false, false);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_LAST_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
vvp_queue_vec4* dst =
queue_find_first_last_to_queue_src(src, wid, cmp, false, false);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_LAST_INDEX_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_find_first_last_to_queue_src(qsrc, wid, cmp, false, true);
else if (dsrc) dst = queue_find_first_last_to_queue_src(dsrc, wid, cmp, false, true);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_find_first_last_to_queue_src(src, wid, cmp, false, true);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_FIND_LAST_INDEX_PROP_V(vthread_t thr, vvp_code_t cp)
{
vvp_vector4_t cmp = thr->pop_vec4();
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
assert(cmp.size() == wid);
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
vvp_queue_vec4* dst =
queue_find_first_last_to_queue_src(src, wid, cmp, false, true);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_UNIQUE_V(vthread_t thr, vvp_code_t cp)
{
vvp_net_t*net = cp->net;
unsigned wid = cp->bit_idx[0];
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_run_unique_src(qsrc, wid, false);
else if (dsrc) dst = queue_run_unique_src(dsrc, wid, false);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_run_unique_src(src, wid, false);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_UNIQUE_PROP_V(vthread_t thr, vvp_code_t cp)
{
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
if (src == 0) {
thr->push_object(vvp_object_t(new vvp_queue_vec4()));
return true;
}
vvp_queue_vec4* dst = queue_run_unique_src(src, wid, false);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_UNIQUE_INDEX_V(vthread_t thr, vvp_code_t cp)
{
vvp_net_t*net = cp->net;
unsigned wid = cp->bit_idx[0];
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_queue_vec4* dst;
if (qsrc) dst = queue_run_unique_src(qsrc, wid, true);
else if (dsrc) dst = queue_run_unique_src(dsrc, wid, true);
else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
dst = queue_run_unique_src(src, wid, true);
}
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_QUEUE_UNIQUE_INDEX_PROP_V(vthread_t thr, vvp_code_t cp)
{
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
if (src == 0) {
thr->push_object(vvp_object_t(new vvp_queue_vec4()));
return true;
}
vvp_queue_vec4* dst = queue_run_unique_src(src, wid, true);
thr->push_object(vvp_object_t(dst));
return true;
}
bool of_PROP_QUEUE_SIZE(vthread_t thr, vvp_code_t cp)
{
size_t pid = cp->number;
@ -6156,6 +6635,169 @@ bool of_PROP_QUEUE_SIZE(vthread_t thr, vvp_code_t cp)
return true;
}
bool of_QUEUE_SIZE_V(vthread_t thr, vvp_code_t cp)
{
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
size_t sz =
qsrc ? qsrc->get_size() : (dsrc ? dsrc->get_size() : 0);
vvp_vector4_t val(32, BIT4_0);
unsigned long ul = sz;
for (unsigned idx = 0; idx < 32; idx++) {
if (ul & 1UL) {
val.set_bit(idx, BIT4_1);
} else {
val.set_bit(idx, BIT4_0);
}
ul >>= 1;
}
thr->push_vec4(val);
return true;
}
bool of_QUEUE_WORD_V(vthread_t thr, vvp_code_t cp)
{
unsigned wid = cp->bit_idx[0];
unsigned ix_reg = cp->bit_idx[1];
int64_t adr = thr->words[ix_reg].w_int;
if (thr->flags[4] == BIT4_1) {
thr->push_vec4(vvp_vector4_t(wid));
return true;
}
if (adr < 0) {
thr->push_vec4(vvp_vector4_t(wid));
return true;
}
vvp_net_t* net = cp->net;
vvp_queue_vec4* qsrc = 0;
vvp_darray* dsrc = 0;
get_queue_or_darray_vec4_from_net(thr, net, qsrc, dsrc);
vvp_vector4_t out(wid);
if (qsrc) {
if ((size_t)adr >= qsrc->get_size()) {
thr->push_vec4(out);
return true;
}
qsrc->get_word((unsigned)adr, out);
} else if (dsrc) {
if ((size_t)adr >= dsrc->get_size()) {
thr->push_vec4(out);
return true;
}
dsrc->get_word((unsigned)adr, out);
} else {
vvp_queue* src_q = get_queue_object<vvp_queue_vec4>(thr, net);
vvp_queue_vec4* src = dynamic_cast<vvp_queue_vec4*>(src_q);
if (!src || (size_t)adr >= src->get_size()) {
thr->push_vec4(out);
return true;
}
src->get_word((unsigned)adr, out);
}
thr->push_vec4(out);
return true;
}
bool of_QUEUE_WORD_PROP_V(vthread_t thr, vvp_code_t cp)
{
size_t pid = cp->number;
unsigned wid = cp->bit_idx[0];
unsigned ix_reg = cp->bit_idx[1];
int64_t adr = thr->words[ix_reg].w_int;
if (thr->flags[4] == BIT4_1) {
thr->push_vec4(vvp_vector4_t(wid));
return true;
}
if (adr < 0) {
thr->push_vec4(vvp_vector4_t(wid));
return true;
}
vvp_object_t& top = thr->peek_object();
vvp_cobject*cobj = top.peek<vvp_cobject>();
assert(cobj);
vvp_object_t qobj;
cobj->get_object(pid, qobj, 0);
vvp_queue_vec4* src = qobj.peek<vvp_queue_vec4>();
vvp_vector4_t out(wid);
if (src == 0 || (size_t)adr >= src->get_size()) {
thr->push_vec4(out);
return true;
}
src->get_word((unsigned)adr, out);
thr->push_vec4(out);
return true;
}
bool of_CMPIX_LTU(vthread_t thr, vvp_code_t cp)
{
unsigned a = cp->number;
unsigned b = cp->bit_idx[0];
if (thr->words[a].w_uint < thr->words[b].w_uint) {
thr->flags[4] = BIT4_1;
} else {
thr->flags[4] = BIT4_0;
}
return true;
}
bool of_CMPIX_SLT0(vthread_t thr, vvp_code_t cp)
{
unsigned r = cp->number;
thr->flags[4] = (thr->words[r].w_int < 0) ? BIT4_1 : BIT4_0;
return true;
}
bool of_PUSH_IX_VEC4(vthread_t thr, vvp_code_t cp)
{
unsigned ix = cp->number;
unsigned wid = cp->bit_idx[0];
unsigned sgn = cp->bit_idx[1];
uint32_t ubits;
if (sgn) {
int32_t sv = (int32_t)thr->words[ix].w_int;
ubits = (uint32_t)sv;
} else {
ubits = (uint32_t)thr->words[ix].w_uint;
}
if (wid > 32) wid = 32;
vvp_vector4_t tmp(wid, BIT4_0);
for (unsigned idx = 0; idx < wid; idx++) {
if (ubits & 1u) {
tmp.set_bit(idx, BIT4_1);
} else {
tmp.set_bit(idx, BIT4_0);
}
ubits >>= 1;
}
thr->push_vec4(tmp);
return true;
}
bool of_QUEUE_NEW_EMPTY_V(vthread_t thr, vvp_code_t)
{
thr->push_object(vvp_object_t(new vvp_queue_vec4()));
return true;
}
bool of_QUEUE_APPEND_WORD_V(vthread_t thr, vvp_code_t cp)
{
unsigned wid = cp->bit_idx[0];
vvp_vector4_t elem = thr->pop_vec4();
assert(elem.size() == wid);
vvp_object_t qobj;
thr->pop_object(qobj);
vvp_queue_vec4* q = qobj.peek<vvp_queue_vec4>();
assert(q);
q->push_back(elem, 0);
thr->push_object(qobj);
return true;
}
bool of_DELETE_PROP_ELEM(vthread_t thr, vvp_code_t cp)
{
size_t pid = cp->number;