Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-11 11:08:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

fixups for altered instruction names

Browse source
This commit is contained in:
Vern Paxson 2024-05-31 10:52:13 -07:00
parent 5658af518a
commit c1a7eb39c8
11 changed files with 169 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

2
auxil/gen-zam

@ -1 +1 @@
Subproject commit 1a063a1d142bdd5e3120aca6240be89f2ec31080 Subproject commit 5c18ce8c868e44bddebfd41017df85e82e559863

38
src/script_opt/ZAM/AM-Opt.cc
View file

@ -336,8 +336,8 @@ void ZAMCompiler::ComputeFrameLifetimes() {
// Some special-casing. // Some special-casing.
switch ( inst->op ) { switch ( inst->op ) {
case OP_NEXT_TABLE_ITER_VV: case OP_NEXT_TABLE_ITER_ii:
case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: { case OP_NEXT_TABLE_ITER_VAL_VAR_Vii: {
// These assign to an arbitrary long list of variables. // These assign to an arbitrary long list of variables.
auto& iter_vars = inst->aux->loop_vars; auto& iter_vars = inst->aux->loop_vars;
auto depth = inst->loop_depth; auto depth = inst->loop_depth;
@ -361,21 +361,21 @@ void ZAMCompiler::ComputeFrameLifetimes() {
} }
// No need to check the additional "var" associated // No need to check the additional "var" associated
// with OP_NEXT_TABLE_ITER_VAL_VAR_VVV as that's // with OP_NEXT_TABLE_ITER_VAL_VAR_Vii as that's
// a slot-1 assignment. However, similar to other // a slot-1 assignment. However, similar to other
// loop variables, mark this as a usage. // loop variables, mark this as a usage.
if ( inst->op == OP_NEXT_TABLE_ITER_VAL_VAR_VVV ) if ( inst->op == OP_NEXT_TABLE_ITER_VAL_VAR_Vii )
ExtendLifetime(inst->v1, EndOfLoop(inst, depth)); ExtendLifetime(inst->v1, EndOfLoop(inst, depth));
} break; } break;
case OP_NEXT_TABLE_ITER_NO_VARS_VV: break; case OP_NEXT_TABLE_ITER_NO_VARS_ii: break;
case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_VVV: { case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_Vii: {
auto depth = inst->loop_depth; auto depth = inst->loop_depth;
ExtendLifetime(inst->v1, EndOfLoop(inst, depth)); ExtendLifetime(inst->v1, EndOfLoop(inst, depth));
} break; } break;
case OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV: { case OP_NEXT_VECTOR_ITER_VAL_VAR_VVii: {
CheckSlotAssignment(inst->v2, inst); CheckSlotAssignment(inst->v2, inst);
auto depth = inst->loop_depth; auto depth = inst->loop_depth;
@ -383,13 +383,13 @@ void ZAMCompiler::ComputeFrameLifetimes() {
ExtendLifetime(inst->v2, EndOfLoop(inst, depth)); ExtendLifetime(inst->v2, EndOfLoop(inst, depth));
} break; } break;
case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_VVV: { case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_Vii: {
auto depth = inst->loop_depth; auto depth = inst->loop_depth;
ExtendLifetime(inst->v1, EndOfLoop(inst, depth)); ExtendLifetime(inst->v1, EndOfLoop(inst, depth));
} break; } break;
case OP_NEXT_VECTOR_ITER_VVV: case OP_NEXT_VECTOR_ITER_Vii:
case OP_NEXT_STRING_ITER_VVV: case OP_NEXT_STRING_ITER_Vii:
// Sometimes loops are written that don't actually // Sometimes loops are written that don't actually
// use the iteration variable. However, we still // use the iteration variable. However, we still
// need to mark the variable as having usage // need to mark the variable as having usage
@ -401,12 +401,12 @@ void ZAMCompiler::ComputeFrameLifetimes() {
ExtendLifetime(inst->v1, EndOfLoop(inst, inst->loop_depth)); ExtendLifetime(inst->v1, EndOfLoop(inst, inst->loop_depth));
break; break;
case OP_NEXT_VECTOR_BLANK_ITER_VV: case OP_NEXT_VECTOR_BLANK_ITER_ii:
case OP_NEXT_STRING_BLANK_ITER_VV: break; case OP_NEXT_STRING_BLANK_ITER_ii: break;
case OP_INIT_TABLE_LOOP_VV: case OP_INIT_TABLE_LOOP_Vi:
case OP_INIT_VECTOR_LOOP_VV: case OP_INIT_VECTOR_LOOP_Vi:
case OP_INIT_STRING_LOOP_VV: { case OP_INIT_STRING_LOOP_Vi: {
// For all of these, the scope of the aggregate being // For all of these, the scope of the aggregate being
// looped over is the entire loop, even if it doesn't // looped over is the entire loop, even if it doesn't
// directly appear in it, and not just the initializer. // directly appear in it, and not just the initializer.
@ -423,14 +423,14 @@ void ZAMCompiler::ComputeFrameLifetimes() {
continue; continue;
} }
case OP_STORE_GLOBAL_V: { case OP_STORE_GLOBAL_i: {
// Use of the global goes to here. // Use of the global goes to here.
auto slot = frame_layout1[globalsI[inst->v1].id.get()]; auto slot = frame_layout1[globalsI[inst->v1].id.get()];
ExtendLifetime(slot, EndOfLoop(inst, 1)); ExtendLifetime(slot, EndOfLoop(inst, 1));
break; break;
} }
case OP_LAMBDA_VV: { case OP_LAMBDA_Vi: {
auto aux = inst->aux; auto aux = inst->aux;
int n = aux->n; int n = aux->n;
for ( int i = 0; i < n; ++i ) { for ( int i = 0; i < n; ++i ) {
@ -549,8 +549,8 @@ void ZAMCompiler::ReMapFrame() {
// Handle special cases. // Handle special cases.
switch ( inst->op ) { switch ( inst->op ) {
case OP_NEXT_TABLE_ITER_VV: case OP_NEXT_TABLE_ITER_ii:
case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: { case OP_NEXT_TABLE_ITER_VAL_VAR_Vii: {
// Rewrite iteration variables. // Rewrite iteration variables.
auto& iter_vars = inst->aux->loop_vars; auto& iter_vars = inst->aux->loop_vars;
for ( auto& v : iter_vars ) { for ( auto& v : iter_vars ) {

4
src/script_opt/ZAM/Branches.cc
View file

@ -25,13 +25,13 @@ ZAMStmt ZAMCompiler::GenGoTo(GoToSet& v) {
} }
ZAMStmt ZAMCompiler::GoToStub() { ZAMStmt ZAMCompiler::GoToStub() {
ZInstI z(OP_GOTO_V, 0); ZInstI z(OP_GOTO_i, 0);
z.op_type = OP_V_I1; z.op_type = OP_V_I1;
return AddInst(z); return AddInst(z);
} }
ZAMStmt ZAMCompiler::GoTo(const InstLabel l) { ZAMStmt ZAMCompiler::GoTo(const InstLabel l) {
ZInstI inst(OP_GOTO_V, 0); ZInstI inst(OP_GOTO_i, 0);
inst.target = l; inst.target = l;
inst.target_slot = 1; inst.target_slot = 1;
inst.op_type = OP_V_I1; inst.op_type = OP_V_I1;

54
src/script_opt/ZAM/BuiltIn.cc
View file

@ -434,14 +434,14 @@ SimpleZBI sta_ZBI{"subnet_to_addr", OP_SUBNET_TO_ADDR_VV, 1};
SimpleZBI ttd_ZBI{"time_to_double", OP_TIME_TO_DOUBLE_VV, 1}; SimpleZBI ttd_ZBI{"time_to_double", OP_TIME_TO_DOUBLE_VV, 1};
SimpleZBI tl_ZBI{"to_lower", OP_TO_LOWER_VV, 1}; SimpleZBI tl_ZBI{"to_lower", OP_TO_LOWER_VV, 1};
CondZBI ce_ZBI{"connection_exists", OP_CONN_EXISTS_VV, OP_CONN_EXISTS_COND_VV, 1}; CondZBI ce_ZBI{"connection_exists", OP_CONN_EXISTS_VV, OP_CONN_EXISTS_COND_Vi, 1};
CondZBI iip_ZBI{"is_icmp_port", OP_IS_ICMP_PORT_VV, OP_IS_ICMP_PORT_COND_VV, 1}; CondZBI iip_ZBI{"is_icmp_port", OP_IS_ICMP_PORT_VV, OP_IS_ICMP_PORT_COND_Vi, 1};
CondZBI itp_ZBI{"is_tcp_port", OP_IS_TCP_PORT_VV, OP_IS_TCP_PORT_COND_VV, 1}; CondZBI itp_ZBI{"is_tcp_port", OP_IS_TCP_PORT_VV, OP_IS_TCP_PORT_COND_Vi, 1};
CondZBI iup_ZBI{"is_udp_port", OP_IS_UDP_PORT_VV, OP_IS_UDP_PORT_COND_VV, 1}; CondZBI iup_ZBI{"is_udp_port", OP_IS_UDP_PORT_VV, OP_IS_UDP_PORT_COND_Vi, 1};
CondZBI iv4_ZBI{"is_v4_addr", OP_IS_V4_ADDR_VV, OP_IS_V4_ADDR_COND_VV, 1}; CondZBI iv4_ZBI{"is_v4_addr", OP_IS_V4_ADDR_VV, OP_IS_V4_ADDR_COND_Vi, 1};
CondZBI iv6_ZBI{"is_v6_addr", OP_IS_V6_ADDR_VV, OP_IS_V6_ADDR_COND_VV, 1}; CondZBI iv6_ZBI{"is_v6_addr", OP_IS_V6_ADDR_VV, OP_IS_V6_ADDR_COND_Vi, 1};
CondZBI rlt_ZBI{"reading_live_traffic", OP_READING_LIVE_TRAFFIC_V, OP_READING_LIVE_TRAFFIC_COND_V, 0}; CondZBI rlt_ZBI{"reading_live_traffic", OP_READING_LIVE_TRAFFIC_V, OP_READING_LIVE_TRAFFIC_COND_i, 0};
CondZBI rt_ZBI{"reading_traces", OP_READING_TRACES_V, OP_READING_TRACES_COND_V, 0}; CondZBI rt_ZBI{"reading_traces", OP_READING_TRACES_V, OP_READING_TRACES_COND_i, 0};
// These have a different form to avoid invoking copy constructors. // These have a different form to avoid invoking copy constructors.
auto cat_ZBI = CatZBI(); auto cat_ZBI = CatZBI();
@ -468,48 +468,48 @@ OptAssignZBI rtc_ZBI{ "PacketAnalyzer::TEREDO::remove_teredo_connection",
MultiZBI faa_ZBI{ "Files::__add_analyzer", MultiZBI faa_ZBI{ "Files::__add_analyzer",
{{{VVV}, {OP_FILES_ADD_ANALYZER_VVV, OP_VVV}}, {{{VVV}, {OP_FILES_ADD_ANALYZER_VVV, OP_VVV}},
{{VCV}, {OP_FILES_ADD_ANALYZER_ViV, OP_VVC}}}, {{VCV}, {OP_FILES_ADD_ANALYZER_VCV, OP_VVC}}},
{{{VVV}, {OP_FILES_ADD_ANALYZER_VVVV, OP_VVVV}}, {{{VVV}, {OP_FILES_ADD_ANALYZER_VVVV, OP_VVVV}},
{{VCV}, {OP_FILES_ADD_ANALYZER_VViV, OP_VVVC}}}, {{VCV}, {OP_FILES_ADD_ANALYZER_VVCV, OP_VVVC}}},
1 1
}; };
MultiZBI fra_ZBI{ "Files::__remove_analyzer", MultiZBI fra_ZBI{ "Files::__remove_analyzer",
{{{VVV}, {OP_FILES_REMOVE_ANALYZER_VVV, OP_VVV}}, {{{VVV}, {OP_FILES_REMOVE_ANALYZER_VVV, OP_VVV}},
{{VCV}, {OP_FILES_REMOVE_ANALYZER_ViV, OP_VVC}}}, {{VCV}, {OP_FILES_REMOVE_ANALYZER_VCV, OP_VVC}}},
{{{VVV}, {OP_FILES_REMOVE_ANALYZER_VVVV, OP_VVVV}}, {{{VVV}, {OP_FILES_REMOVE_ANALYZER_VVVV, OP_VVVV}},
{{VCV}, {OP_FILES_REMOVE_ANALYZER_VViV, OP_VVVC}}}, {{VCV}, {OP_FILES_REMOVE_ANALYZER_VVCV, OP_VVVC}}},
1 1
}; };
MultiZBI fsrb_ZBI{ "Files::__set_reassembly_buffer", MultiZBI fsrb_ZBI{ "Files::__set_reassembly_buffer",
{{{VV}, {OP_FILES_SET_REASSEMBLY_BUFFER_VV, OP_VV}}, {{{VV}, {OP_FILES_SET_REASSEMBLY_BUFFER_VV, OP_VV}},
{{VC}, {OP_FILES_SET_REASSEMBLY_BUFFER_VC, OP_VV_I2}}}, {{VC}, {OP_FILES_SET_REASSEMBLY_BUFFER_Vi, OP_VV_I2}}},
{{{VV}, {OP_FILES_SET_REASSEMBLY_BUFFER_VVV, OP_VVV}}, {{{VV}, {OP_FILES_SET_REASSEMBLY_BUFFER_VVV, OP_VVV}},
{{VC}, {OP_FILES_SET_REASSEMBLY_BUFFER_VVC, OP_VVV_I3}}} {{VC}, {OP_FILES_SET_REASSEMBLY_BUFFER_VVi, OP_VVV_I3}}}
}; };
MultiZBI lw_ZBI{ "Log::__write", MultiZBI lw_ZBI{ "Log::__write",
{{{VV}, {OP_LOG_WRITE_VV, OP_VV}}, {{{VV}, {OP_LOG_WRITE_VV, OP_VV}},
{{CV}, {OP_LOG_WRITEC_V, OP_V}}}, {{CV}, {OP_LOG_WRITEC_CV, OP_V}}},
{{{VV}, {OP_LOG_WRITE_VVV, OP_VVV}}, {{{VV}, {OP_LOG_WRITE_VVV, OP_VVV}},
{{CV}, {OP_LOG_WRITEC_VV, OP_VV}}} {{CV}, {OP_LOG_WRITEC_VCV, OP_VV}}}
}; };
MultiZBI gccbt_ZBI{ "get_current_conn_bytes_threshold", true, MultiZBI gccbt_ZBI{ "get_current_conn_bytes_threshold", true,
{{{VV}, {OP_GET_BYTES_THRESH_VVV, OP_VVV}}, {{{VV}, {OP_GET_BYTES_THRESH_VVV, OP_VVV}},
{{VC}, {OP_GET_BYTES_THRESH_VVi, OP_VVC}}} {{VC}, {OP_GET_BYTES_THRESH_VVC, OP_VVC}}}
}; };
MultiZBI sccbt_ZBI{ "set_current_conn_bytes_threshold", MultiZBI sccbt_ZBI{ "set_current_conn_bytes_threshold",
{{{VVV}, {OP_SET_BYTES_THRESH_VVV, OP_VVV}}, {{{VVV}, {OP_SET_BYTES_THRESH_VVV, OP_VVV}},
{{VVC}, {OP_SET_BYTES_THRESH_VVi, OP_VVC}}, {{VVC}, {OP_SET_BYTES_THRESH_VVC, OP_VVC}},
{{VCV}, {OP_SET_BYTES_THRESH_ViV, OP_VVC}}, {{VCV}, {OP_SET_BYTES_THRESH_VCV, OP_VVC}},
{{VCC}, {OP_SET_BYTES_THRESH_Vii, OP_VVC_I2}}}, {{VCC}, {OP_SET_BYTES_THRESH_VCi, OP_VVC_I2}}},
{{{VVV}, {OP_SET_BYTES_THRESH_VVVV, OP_VVVV}}, {{{VVV}, {OP_SET_BYTES_THRESH_VVVV, OP_VVVV}},
{{VVC}, {OP_SET_BYTES_THRESH_VVVi, OP_VVVC}}, {{VVC}, {OP_SET_BYTES_THRESH_VVVC, OP_VVVC}},
{{VCV}, {OP_SET_BYTES_THRESH_VViV, OP_VVVC}}, {{VCV}, {OP_SET_BYTES_THRESH_VVCV, OP_VVVC}},
{{VCC}, {OP_SET_BYTES_THRESH_VVii, OP_VVVC_I3}}} {{VCC}, {OP_SET_BYTES_THRESH_VVCi, OP_VVVC_I3}}}
}; };
MultiZBI sw_ZBI{ "starts_with", true, MultiZBI sw_ZBI{ "starts_with", true,
@ -532,11 +532,11 @@ MultiZBI strstr_ZBI{ "strstr", true,
MultiZBI sb_ZBI{ "sub_bytes", true, MultiZBI sb_ZBI{ "sub_bytes", true,
{{{VVV}, {OP_SUB_BYTES_VVVV, OP_VVVV}}, {{{VVV}, {OP_SUB_BYTES_VVVV, OP_VVVV}},
{{VVC}, {OP_SUB_BYTES_VVVi, OP_VVVC}}, {{VVC}, {OP_SUB_BYTES_VVVC, OP_VVVC}},
{{VCV}, {OP_SUB_BYTES_VViV, OP_VVVC}}, {{VCV}, {OP_SUB_BYTES_VVCV, OP_VVVC}},
{{VCC}, {OP_SUB_BYTES_VVii, OP_VVVC_I3}}, {{VCC}, {OP_SUB_BYTES_VVCi, OP_VVVC_I3}},
{{CVV}, {OP_SUB_BYTES_VVVC, OP_VVVC}}, {{CVV}, {OP_SUB_BYTES_VVVC, OP_VVVC}},
{{CVC}, {OP_SUB_BYTES_VViC, OP_VVVC_I3}}, {{CVC}, {OP_SUB_BYTES_VVCi, OP_VVVC_I3}},
{{CCV}, {OP_SUB_BYTES_ViVC, OP_VVVC_I3}}} {{CCV}, {OP_SUB_BYTES_ViVC, OP_VVVC_I3}}}
}; };

22
src/script_opt/ZAM/Expr.cc
View file

@ -689,7 +689,7 @@ const ZAMStmt ZAMCompiler::CompileIndex(const NameExpr* n1, int n2_slot, const T
z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, n3_slot); z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, n3_slot);
} }
else { else {
auto zop = OP_INDEX_STRINGC_VVV; auto zop = OP_INDEX_STRINGC_VVi;
z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c); z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c);
z.op_type = OP_VVV_I3; z.op_type = OP_VVV_I3;
} }
@ -710,7 +710,7 @@ const ZAMStmt ZAMCompiler::CompileIndex(const NameExpr* n1, int n2_slot, const T
else if ( is_any ) else if ( is_any )
zop = OP_INDEX_ANY_VEC_VVV; zop = OP_INDEX_ANY_VEC_VVV;
else else
zop = OP_INDEX_VEC_VVV; zop = OP_INDEX_VEC_VVi;
z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, n3_slot); z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, n3_slot);
} }
@ -718,11 +718,11 @@ const ZAMStmt ZAMCompiler::CompileIndex(const NameExpr* n1, int n2_slot, const T
ZOp zop; ZOp zop;
if ( in_when ) if ( in_when )
zop = OP_WHEN_INDEX_VECC_VVV; zop = OP_WHEN_INDEX_VECC_VVi;
else if ( is_any ) else if ( is_any )
zop = OP_INDEX_ANY_VECC_VVV; zop = OP_INDEX_ANY_VECC_VVi;
else else
zop = OP_INDEX_VECC_VVV; zop = OP_INDEX_VECC_VVi;
z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c); z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c);
z.op_type = OP_VVV_I3; z.op_type = OP_VVV_I3;
@ -826,7 +826,7 @@ const ZAMStmt ZAMCompiler::BuildLambda(int n_slot, LambdaExpr* le) {
aux->Add(i, FrameSlot(id_i), id_i->GetType()); aux->Add(i, FrameSlot(id_i), id_i->GetType());
} }
auto z = ZInstI(OP_LAMBDA_VV, n_slot, le->PrimaryFunc()->FrameSize()); auto z = ZInstI(OP_LAMBDA_Vi, n_slot, le->PrimaryFunc()->FrameSize());
z.op_type = OP_VV_I2; z.op_type = OP_VV_I2;
z.aux = aux; z.aux = aux;
@ -1057,7 +1057,7 @@ const ZAMStmt ZAMCompiler::DoCall(const CallExpr* c, const NameExpr* n) {
default: default:
if ( in_when ) { if ( in_when ) {
if ( indirect ) if ( indirect )
op = OP_WHENINDCALLN_VV; op = OP_WHENINDCALLN_Vi;
else else
op = OP_WHENCALLN_V; op = OP_WHENCALLN_V;
} }
@ -1151,7 +1151,7 @@ const ZAMStmt ZAMCompiler::ConstructTable(const NameExpr* n, const Expr* e) {
auto tt = cast_intrusive<TableType>(n->GetType()); auto tt = cast_intrusive<TableType>(n->GetType());
auto width = tt->GetIndices()->GetTypes().size(); auto width = tt->GetIndices()->GetTypes().size();
auto z = GenInst(OP_CONSTRUCT_TABLE_VV, n, width); auto z = GenInst(OP_CONSTRUCT_TABLE_V, n, width);
z.aux = InternalBuildVals(con, width + 1); z.aux = InternalBuildVals(con, width + 1);
z.t = tt; z.t = tt;
ASSERT(e->Tag() == EXPR_TABLE_CONSTRUCTOR); ASSERT(e->Tag() == EXPR_TABLE_CONSTRUCTOR);
@ -1190,7 +1190,7 @@ const ZAMStmt ZAMCompiler::ConstructSet(const NameExpr* n, const Expr* e) {
auto tt = n->GetType()->AsTableType(); auto tt = n->GetType()->AsTableType();
auto width = tt->GetIndices()->GetTypes().size(); auto width = tt->GetIndices()->GetTypes().size();
auto z = GenInst(OP_CONSTRUCT_SET_VV, n, width); auto z = GenInst(OP_CONSTRUCT_SET_V, n, width);
z.aux = InternalBuildVals(con, width); z.aux = InternalBuildVals(con, width);
z.t = e->GetType(); z.t = e->GetType();
ASSERT(e->Tag() == EXPR_SET_CONSTRUCTOR); ASSERT(e->Tag() == EXPR_SET_CONSTRUCTOR);
@ -1262,13 +1262,13 @@ const ZAMStmt ZAMCompiler::ConstructRecord(const NameExpr* n, const Expr* e) {
if ( fi->empty() ) { if ( fi->empty() ) {
if ( network_time_index >= 0 ) if ( network_time_index >= 0 )
op = OP_CONSTRUCT_KNOWN_RECORD_WITH_NT_VV; op = OP_CONSTRUCT_KNOWN_RECORD_WITH_NT_Vi;
else else
op = OP_CONSTRUCT_KNOWN_RECORD_V; op = OP_CONSTRUCT_KNOWN_RECORD_V;
} }
else { else {
if ( network_time_index >= 0 ) if ( network_time_index >= 0 )
op = OP_CONSTRUCT_KNOWN_RECORD_WITH_INITS_AND_NT_VV; op = OP_CONSTRUCT_KNOWN_RECORD_WITH_INITS_AND_NT_Vi;
else else
op = OP_CONSTRUCT_KNOWN_RECORD_WITH_INITS_V; op = OP_CONSTRUCT_KNOWN_RECORD_WITH_INITS_V;
aux->field_inits = std::move(fi); aux->field_inits = std::move(fi);

6
src/script_opt/ZAM/Low-Level.cc
View file

@ -125,7 +125,7 @@ const ZAMStmt ZAMCompiler::AddInst(const ZInstI& inst, bool suppress_non_local)
auto gs = pending_global_store; auto gs = pending_global_store;
pending_global_store = -1; pending_global_store = -1;
auto store_inst = ZInstI(OP_STORE_GLOBAL_V, gs); auto store_inst = ZInstI(OP_STORE_GLOBAL_i, gs);
store_inst.op_type = OP_V_I1; store_inst.op_type = OP_V_I1;
store_inst.t = globalsI[gs].id->GetType(); store_inst.t = globalsI[gs].id->GetType();
@ -142,9 +142,9 @@ const ZAMStmt ZAMCompiler::AddInst(const ZInstI& inst, bool suppress_non_local)
ZOp op; ZOp op;
if ( ZVal::IsManagedType(c_id->GetType()) ) if ( ZVal::IsManagedType(c_id->GetType()) )
op = OP_STORE_MANAGED_CAPTURE_VV; op = OP_STORE_MANAGED_CAPTURE_Vi;
else else
op = OP_STORE_CAPTURE_VV; op = OP_STORE_CAPTURE_Vi;
auto store_inst = ZInstI(op, RawSlot(c_id.get()), cs); auto store_inst = ZInstI(op, RawSlot(c_id.get()), cs);
store_inst.op_type = OP_VV_I2; store_inst.op_type = OP_VV_I2;

34
src/script_opt/ZAM/OPs/ZAM.op
View file

@ -386,14 +386,14 @@ op1-read
eval EvalAddPatternToField($$.record_val, $1, $2) eval EvalAddPatternToField($$.record_val, $1, $2)
macro EvalAddPatternToField(r, v, f) macro EvalAddPatternToField(r, v, f)
auto fpat = r->GetField(z.f)->AsPatternVal(); auto fpat = r->GetField(f)->AsPatternVal();
if ( fpat ) if ( fpat )
{ {
v.re_val->AddTo(fpat, false); v.re_val->AddTo(fpat, false);
r->Modified(); r->Modified();
} }
else else
ZAM_run_time_error(z.loc, util::fmt("field value missing: $%s", r->GetType()->AsRecordType()->FieldName(z.f))); ZAM_run_time_error(z.loc, util::fmt("field value missing: $%s", r->GetType()->AsRecordType()->FieldName(f)));
internal-op AddPatternToField internal-op AddPatternToField
type VCi type VCi
@ -1015,11 +1015,11 @@ custom-method return CompileIndex(n, c, l, true);
no-eval no-eval
internal-op Index-Vec internal-op Index-Vec
type VVV type VVi
eval EvalIndexVec($$, $1, $2) eval EvalIndexVec($$, $1, $2)
macro EvalIndexVec(lhs, vec, index) macro EvalIndexVec(lhs, rhs_vec, index)
auto& vv = vec.vector_val->RawVec(); auto& vv = rhs_vec.vector_val->RawVec();
const auto& vec = vv; const auto& vec = vv;
zeek_int_t ind = index; zeek_int_t ind = index;
if ( ind < 0 ) if ( ind < 0 )
@ -1125,13 +1125,13 @@ eval auto args = z.aux->ToListVal(frame);
internal-assignment-op Table-Index1 internal-assignment-op Table-Index1
type VVV type VVV
assign-val v assign-val v
eval EvalTableIndex(frame[z.v3].ToVal(z.t)) eval EvalTableIndex($$, frame[z.v3].ToVal(z.t))
# No AssignV1 needed, as this is an assignment-op # No AssignV1 needed, as this is an assignment-op
internal-assignment-op Table-Index1 internal-assignment-op Table-Index1
type VVC type VVC
assign-val v assign-val v
eval EvalTableIndex(z.c.ToVal(z.t)) eval EvalTableIndex($$, z.c.ToVal(z.t))
# This version is for a variable v3. # This version is for a variable v3.
internal-op Index-String internal-op Index-String
@ -1438,12 +1438,14 @@ set-type $1
eval AssignTarget($$, ZVal($1.ToVal(z.t), ZAM::any_base_type)) eval AssignTarget($$, ZVal($1.ToVal(z.t), ZAM::any_base_type))
unary-expr-op From-Any-Coerce unary-expr-op From-Any-Coerce
no-const
op-type X op-type X
set-type $$ set-type $$
eval auto v = $1.any_val; eval auto v = $1.any_val;
AssignTarget($$, ZVal({NewRef{}, v}, z.t)) AssignTarget($$, ZVal({NewRef{}, v}, z.t))
unary-expr-op From-Any-Vec-Coerce unary-expr-op From-Any-Vec-Coerce
no-const
op-type X op-type X
set-type $$ set-type $$
eval auto vv = $1.vector_val; eval auto vv = $1.vector_val;
@ -1896,13 +1898,13 @@ eval auto vs = $1.string_val->AsString()->Render();
internal-op SwitchA internal-op SwitchA
op1-read op1-read
type VVV type Vii
eval auto v = $1.addr_val->AsAddr().AsString(); eval auto v = $1.addr_val->AsAddr().AsString();
EvalSwitchBody($2, $3, str_cases,) EvalSwitchBody($2, $3, str_cases,)
internal-op SwitchN internal-op SwitchN
op1-read op1-read
type VVV type Vii
eval auto v = $1.subnet_val->AsSubNet().AsString(); eval auto v = $1.subnet_val->AsSubNet().AsString();
EvalSwitchBody($2, $3, str_cases,) EvalSwitchBody($2, $3, str_cases,)
@ -1938,7 +1940,7 @@ internal-op Next-Table-Iter-No-Vars
op1-read op1-read
# v1 = iteration info # v1 = iteration info
# v2 = branch target if loop done # v2 = branch target if loop done
type VV type ii
eval NextTableIterPre($1, $2) eval NextTableIterPre($1, $2)
ti.IterFinished(); ti.IterFinished();
@ -1946,7 +1948,7 @@ internal-op Next-Table-Iter-Val-Var
# v1 = slot of the "ValueVar" # v1 = slot of the "ValueVar"
# v2 = iteration info # v2 = iteration info
# v3 = branch target if loop done # v3 = branch target if loop done
type VVV type Vii
eval NextTableIterPre($1, $2) eval NextTableIterPre($1, $2)
AssignTarget($$, ti.IterValue()); AssignTarget($$, ti.IterValue());
ti.NextIter(frame); ti.NextIter(frame);
@ -1955,7 +1957,7 @@ internal-op Next-Table-Iter-Val-Var-No-Vars
# v1 = slot of the "ValueVar" # v1 = slot of the "ValueVar"
# v2 = iteration info # v2 = iteration info
# v3 = branch target if loop done # v3 = branch target if loop done
type VVV type Vii
eval NextTableIterPre($1, $2) eval NextTableIterPre($1, $2)
AssignTarget($$, ti.IterValue()); AssignTarget($$, ti.IterValue());
ti.IterFinished(); ti.IterFinished();
@ -2244,7 +2246,7 @@ assign-val v
eval auto& v = f->GetElement(z.v2); eval auto& v = f->GetElement(z.v2);
internal-assignment-op Load-Global internal-assignment-op Load-Global
type VV type Vi
assign-val v assign-val v
eval auto& v = globals[z.v2].id->GetVal(); eval auto& v = globals[z.v2].id->GetVal();
if ( ! v ) if ( ! v )
@ -2484,7 +2486,7 @@ eval LogWritePre($1, $2)
### Check that invoked correctly ### Check that invoked correctly
internal-op Log-WriteC internal-op Log-WriteC
side-effects OP_LOG_WRITEC_V OP_V side-effects OP_LOG_WRITEC_CV OP_V
type VCV type VCV
eval LogWritePre($1, $2) eval LogWritePre($1, $2)
LogWriteResPost($$) LogWriteResPost($$)
@ -3006,7 +3008,7 @@ eval FilesRemoveAnalyzer($1, $2, $3)
internal-op Files-Remove-Analyzer internal-op Files-Remove-Analyzer
op1-read op1-read
type ViV type VCV
eval FilesRemoveAnalyzer($1, $2, $3) eval FilesRemoveAnalyzer($1, $2, $3)
internal-op Files-Remove-Analyzer internal-op Files-Remove-Analyzer
@ -3090,7 +3092,7 @@ eval auto f = $1.string_val->CheckString();
internal-op Files-Set-Reassembly-Buffer internal-op Files-Set-Reassembly-Buffer
type VVi type VVi
side-effects OP_FILES_SET_REASSEMBLY_BUFFER_VC OP_VC side-effects OP_FILES_SET_REASSEMBLY_BUFFER_Vi OP_VV
eval auto f = $1.string_val->CheckString(); eval auto f = $1.string_val->CheckString();
$$.int_val = file_mgr->SetReassemblyBuffer(f, zeek_uint_t($2)); $$.int_val = file_mgr->SetReassemblyBuffer(f, zeek_uint_t($2));

132
src/script_opt/ZAM/Stmt.cc
View file

@ -136,7 +136,7 @@ const ZAMStmt ZAMCompiler::IfElse(const Expr* e, const Stmt* s1, const Stmt* s2)
if ( e->Tag() == EXPR_NAME ) { if ( e->Tag() == EXPR_NAME ) {
auto n = e->AsNameExpr(); auto n = e->AsNameExpr();
ZOp op = (s1 && s2) ? OP_IF_ELSE_VV : (s1 ? OP_IF_VV : OP_IF_NOT_VV); ZOp op = (s1 && s2) ? OP_IF_ELSE_Vi : (s1 ? OP_IF_Vi : OP_IF_NOT_Vi);
ZInstI cond(op, FrameSlot(n), 0); ZInstI cond(op, FrameSlot(n), 0);
cond_stmt = AddInst(cond); cond_stmt = AddInst(cond);
@ -170,60 +170,60 @@ const ZAMStmt ZAMCompiler::IfElse(const Expr* e, const Stmt* s1, const Stmt* s2)
auto z = insts1[cond_stmt.stmt_num]; auto z = insts1[cond_stmt.stmt_num];
switch ( z->op ) { switch ( z->op ) {
case OP_IF_ELSE_VV: case OP_IF_ELSE_Vi:
case OP_IF_VV: case OP_IF_Vi:
case OP_IF_NOT_VV: case OP_IF_NOT_Vi:
// These are generated correctly above, no need // These are generated correctly above, no need
// to fix up. // to fix up.
break; break;
case OP_HAS_FIELD_COND_VVV: z->op = OP_NOT_HAS_FIELD_COND_VVV; break; case OP_HAS_FIELD_COND_Vii: z->op = OP_NOT_HAS_FIELD_COND_Vii; break;
case OP_NOT_HAS_FIELD_COND_VVV: z->op = OP_HAS_FIELD_COND_VVV; break; case OP_NOT_HAS_FIELD_COND_Vii: z->op = OP_HAS_FIELD_COND_Vii; break;
case OP_CONN_EXISTS_COND_VV: z->op = OP_NOT_CONN_EXISTS_COND_VV; break; case OP_CONN_EXISTS_COND_Vi: z->op = OP_NOT_CONN_EXISTS_COND_Vi; break;
case OP_NOT_CONN_EXISTS_COND_VV: z->op = OP_CONN_EXISTS_COND_VV; break; case OP_NOT_CONN_EXISTS_COND_Vi: z->op = OP_CONN_EXISTS_COND_Vi; break;
case OP_IS_ICMP_PORT_COND_VV: z->op = OP_NOT_IS_ICMP_PORT_COND_VV; break; case OP_IS_ICMP_PORT_COND_Vi: z->op = OP_NOT_IS_ICMP_PORT_COND_Vi; break;
case OP_NOT_IS_ICMP_PORT_COND_VV: z->op = OP_IS_ICMP_PORT_COND_VV; break; case OP_NOT_IS_ICMP_PORT_COND_Vi: z->op = OP_IS_ICMP_PORT_COND_Vi; break;
case OP_IS_TCP_PORT_COND_VV: z->op = OP_NOT_IS_TCP_PORT_COND_VV; break; case OP_IS_TCP_PORT_COND_Vi: z->op = OP_NOT_IS_TCP_PORT_COND_Vi; break;
case OP_NOT_IS_TCP_PORT_COND_VV: z->op = OP_IS_TCP_PORT_COND_VV; break; case OP_NOT_IS_TCP_PORT_COND_Vi: z->op = OP_IS_TCP_PORT_COND_Vi; break;
case OP_IS_UDP_PORT_COND_VV: z->op = OP_NOT_IS_UDP_PORT_COND_VV; break; case OP_IS_UDP_PORT_COND_Vi: z->op = OP_NOT_IS_UDP_PORT_COND_Vi; break;
case OP_NOT_IS_UDP_PORT_COND_VV: z->op = OP_IS_UDP_PORT_COND_VV; break; case OP_NOT_IS_UDP_PORT_COND_Vi: z->op = OP_IS_UDP_PORT_COND_Vi; break;
case OP_IS_V4_ADDR_COND_VV: z->op = OP_NOT_IS_V4_ADDR_COND_VV; break; case OP_IS_V4_ADDR_COND_Vi: z->op = OP_NOT_IS_V4_ADDR_COND_Vi; break;
case OP_NOT_IS_V4_ADDR_COND_VV: z->op = OP_IS_V4_ADDR_COND_VV; break; case OP_NOT_IS_V4_ADDR_COND_Vi: z->op = OP_IS_V4_ADDR_COND_Vi; break;
case OP_IS_V6_ADDR_COND_VV: z->op = OP_NOT_IS_V6_ADDR_COND_VV; break; case OP_IS_V6_ADDR_COND_Vi: z->op = OP_NOT_IS_V6_ADDR_COND_Vi; break;
case OP_NOT_IS_V6_ADDR_COND_VV: z->op = OP_IS_V6_ADDR_COND_VV; break; case OP_NOT_IS_V6_ADDR_COND_Vi: z->op = OP_IS_V6_ADDR_COND_Vi; break;
case OP_READING_LIVE_TRAFFIC_COND_V: z->op = OP_NOT_READING_LIVE_TRAFFIC_COND_V; break; case OP_READING_LIVE_TRAFFIC_COND_i: z->op = OP_NOT_READING_LIVE_TRAFFIC_COND_i; break;
case OP_NOT_READING_LIVE_TRAFFIC_COND_V: z->op = OP_READING_LIVE_TRAFFIC_COND_V; break; case OP_NOT_READING_LIVE_TRAFFIC_COND_i: z->op = OP_READING_LIVE_TRAFFIC_COND_i; break;
case OP_READING_TRACES_COND_V: z->op = OP_NOT_READING_TRACES_COND_V; break; case OP_READING_TRACES_COND_i: z->op = OP_NOT_READING_TRACES_COND_i; break;
case OP_NOT_READING_TRACES_COND_V: z->op = OP_READING_TRACES_COND_V; break; case OP_NOT_READING_TRACES_COND_i: z->op = OP_READING_TRACES_COND_i; break;
case OP_TABLE_HAS_ELEMENTS_COND_VV: z->op = OP_NOT_TABLE_HAS_ELEMENTS_COND_VV; break; case OP_TABLE_HAS_ELEMENTS_COND_Vi: z->op = OP_NOT_TABLE_HAS_ELEMENTS_COND_Vi; break;
case OP_NOT_TABLE_HAS_ELEMENTS_COND_VV: z->op = OP_TABLE_HAS_ELEMENTS_COND_VV; break; case OP_NOT_TABLE_HAS_ELEMENTS_COND_Vi: z->op = OP_TABLE_HAS_ELEMENTS_COND_Vi; break;
case OP_VECTOR_HAS_ELEMENTS_COND_VV: z->op = OP_NOT_VECTOR_HAS_ELEMENTS_COND_VV; break; case OP_VECTOR_HAS_ELEMENTS_COND_Vi: z->op = OP_NOT_VECTOR_HAS_ELEMENTS_COND_Vi; break;
case OP_NOT_VECTOR_HAS_ELEMENTS_COND_VV: z->op = OP_VECTOR_HAS_ELEMENTS_COND_VV; break; case OP_NOT_VECTOR_HAS_ELEMENTS_COND_Vi: z->op = OP_VECTOR_HAS_ELEMENTS_COND_Vi; break;
case OP_VAL_IS_IN_TABLE_COND_VVV: z->op = OP_VAL_IS_NOT_IN_TABLE_COND_VVV; break; case OP_VAL_IS_IN_TABLE_COND_VVi: z->op = OP_VAL_IS_NOT_IN_TABLE_COND_VVi; break;
case OP_VAL_IS_NOT_IN_TABLE_COND_VVV: z->op = OP_VAL_IS_IN_TABLE_COND_VVV; break; case OP_VAL_IS_NOT_IN_TABLE_COND_VVi: z->op = OP_VAL_IS_IN_TABLE_COND_VVi; break;
case OP_CONST_IS_IN_TABLE_COND_VVC: z->op = OP_CONST_IS_NOT_IN_TABLE_COND_VVC; break; case OP_CONST_IS_IN_TABLE_COND_ViC: z->op = OP_CONST_IS_NOT_IN_TABLE_COND_ViC; break;
case OP_CONST_IS_NOT_IN_TABLE_COND_VVC: z->op = OP_CONST_IS_IN_TABLE_COND_VVC; break; case OP_CONST_IS_NOT_IN_TABLE_COND_ViC: z->op = OP_CONST_IS_IN_TABLE_COND_ViC; break;
case OP_VAL2_IS_IN_TABLE_COND_VVVV: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VVVV; break; case OP_VAL2_IS_IN_TABLE_COND_VVVi: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VVVi; break;
case OP_VAL2_IS_NOT_IN_TABLE_COND_VVVV: z->op = OP_VAL2_IS_IN_TABLE_COND_VVVV; break; case OP_VAL2_IS_NOT_IN_TABLE_COND_VVVi: z->op = OP_VAL2_IS_IN_TABLE_COND_VVVi; break;
case OP_VAL2_IS_IN_TABLE_COND_VVVC: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VVVC; break; case OP_VAL2_IS_IN_TABLE_COND_VViC: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VViC; break;
case OP_VAL2_IS_NOT_IN_TABLE_COND_VVVC: z->op = OP_VAL2_IS_IN_TABLE_COND_VVVC; break; case OP_VAL2_IS_NOT_IN_TABLE_COND_VViC: z->op = OP_VAL2_IS_IN_TABLE_COND_VViC; break;
case OP_VAL2_IS_IN_TABLE_COND_VVCV: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VVCV; break; case OP_VAL2_IS_IN_TABLE_COND_VVCi: z->op = OP_VAL2_IS_NOT_IN_TABLE_COND_VVCi; break;
case OP_VAL2_IS_NOT_IN_TABLE_COND_VVCV: z->op = OP_VAL2_IS_IN_TABLE_COND_VVCV; break; case OP_VAL2_IS_NOT_IN_TABLE_COND_VVCi: z->op = OP_VAL2_IS_IN_TABLE_COND_VVCi; break;
default: reporter->InternalError("inconsistency in ZAMCompiler::IfElse"); default: reporter->InternalError("inconsistency in ZAMCompiler::IfElse");
} }
@ -238,7 +238,7 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) {
if ( e->Tag() == EXPR_HAS_FIELD ) { if ( e->Tag() == EXPR_HAS_FIELD ) {
auto hf = e->AsHasFieldExpr(); auto hf = e->AsHasFieldExpr();
auto z = GenInst(OP_HAS_FIELD_COND_VVV, op1->AsNameExpr(), hf->Field()); auto z = GenInst(OP_HAS_FIELD_COND_Vii, op1->AsNameExpr(), hf->Field());
z.op_type = OP_VVV_I2_I3; z.op_type = OP_VVV_I2_I3;
branch_v = 3; branch_v = 3;
return AddInst(z); return AddInst(z);
@ -255,14 +255,14 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) {
} }
if ( op1->Tag() == EXPR_NAME ) { if ( op1->Tag() == EXPR_NAME ) {
auto z = GenInst(OP_VAL_IS_IN_TABLE_COND_VVV, op1->AsNameExpr(), op2, 0); auto z = GenInst(OP_VAL_IS_IN_TABLE_COND_VVi, op1->AsNameExpr(), op2, 0);
z.t = op1->GetType(); z.t = op1->GetType();
branch_v = 3; branch_v = 3;
return AddInst(z); return AddInst(z);
} }
if ( op1->Tag() == EXPR_CONST ) { if ( op1->Tag() == EXPR_CONST ) {
auto z = GenInst(OP_CONST_IS_IN_TABLE_COND_VVC, op2, op1->AsConstExpr(), 0); auto z = GenInst(OP_CONST_IS_IN_TABLE_COND_ViC, op2, op1->AsConstExpr(), 0);
z.t = op1->GetType(); z.t = op1->GetType();
branch_v = 2; branch_v = 2;
return AddInst(z); return AddInst(z);
@ -290,19 +290,19 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) {
ZInstI z; ZInstI z;
if ( name0 && name1 ) { if ( name0 && name1 ) {
z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VVVV, n0, n1, op2, 0); z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VVVi, n0, n1, op2, 0);
branch_v = 4; branch_v = 4;
z.t2 = n0->GetType(); z.t2 = n0->GetType();
} }
else if ( name0 ) { else if ( name0 ) {
z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VVVC, n0, op2, c1, 0); z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VViC, n0, op2, c1, 0);
branch_v = 3; branch_v = 3;
z.t2 = n0->GetType(); z.t2 = n0->GetType();
} }
else if ( name1 ) { else if ( name1 ) {
z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VVCV, n1, op2, c0, 0); z = GenInst(OP_VAL2_IS_IN_TABLE_COND_VVCi, n1, op2, c0, 0);
branch_v = 3; branch_v = 3;
z.t2 = n1->GetType(); z.t2 = n1->GetType();
} }
@ -310,7 +310,7 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) {
else { // Both are constants, assign first to temporary. else { // Both are constants, assign first to temporary.
auto slot = TempForConst(c0); auto slot = TempForConst(c0);
z = ZInstI(OP_VAL2_IS_IN_TABLE_COND_VVVC, slot, FrameSlot(op2), 0, c1); z = ZInstI(OP_VAL2_IS_IN_TABLE_COND_VViC, slot, FrameSlot(op2), 0, c1);
z.op_type = OP_VVVC_I3; z.op_type = OP_VVVC_I3;
branch_v = 3; branch_v = 3;
z.t2 = c0->GetType(); z.t2 = c0->GetType();
@ -332,9 +332,9 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) {
ZOp op; ZOp op;
if ( aggr->GetType()->Tag() == TYPE_TABLE ) if ( aggr->GetType()->Tag() == TYPE_TABLE )
op = OP_TABLE_HAS_ELEMENTS_COND_VV; op = OP_TABLE_HAS_ELEMENTS_COND_Vi;
else else
op = OP_VECTOR_HAS_ELEMENTS_COND_VV; op = OP_VECTOR_HAS_ELEMENTS_COND_Vi;
branch_v = 2; branch_v = 2;
return AddInst(GenInst(op, aggr, +0)); return AddInst(GenInst(op, aggr, +0));
@ -418,32 +418,32 @@ const ZAMStmt ZAMCompiler::ValueSwitch(const SwitchStmt* sw, const NameExpr* v,
switch ( t->InternalType() ) { switch ( t->InternalType() ) {
case TYPE_INTERNAL_INT: case TYPE_INTERNAL_INT:
op = OP_SWITCHI_VVV; op = OP_SWITCHI_Vii;
tbl = int_casesI.size(); tbl = int_casesI.size();
break; break;
case TYPE_INTERNAL_UNSIGNED: case TYPE_INTERNAL_UNSIGNED:
op = OP_SWITCHU_VVV; op = OP_SWITCHU_Vii;
tbl = uint_casesI.size(); tbl = uint_casesI.size();
break; break;
case TYPE_INTERNAL_DOUBLE: case TYPE_INTERNAL_DOUBLE:
op = OP_SWITCHD_VVV; op = OP_SWITCHD_Vii;
tbl = double_casesI.size(); tbl = double_casesI.size();
break; break;
case TYPE_INTERNAL_STRING: case TYPE_INTERNAL_STRING:
op = OP_SWITCHS_VVV; op = OP_SWITCHS_Vii;
tbl = str_casesI.size(); tbl = str_casesI.size();
break; break;
case TYPE_INTERNAL_ADDR: case TYPE_INTERNAL_ADDR:
op = OP_SWITCHA_VVV; op = OP_SWITCHA_Vii;
tbl = str_casesI.size(); tbl = str_casesI.size();
break; break;
case TYPE_INTERNAL_SUBNET: case TYPE_INTERNAL_SUBNET:
op = OP_SWITCHN_VVV; op = OP_SWITCHN_Vii;
tbl = str_casesI.size(); tbl = str_casesI.size();
break; break;
@ -577,7 +577,7 @@ const ZAMStmt ZAMCompiler::TypeSwitch(const SwitchStmt* sw, const NameExpr* v, c
ZInstI z; ZInstI z;
z = ZInstI(OP_BRANCH_IF_NOT_TYPE_VV, slot, 0); z = ZInstI(OP_BRANCH_IF_NOT_TYPE_Vi, slot, 0);
z.SetType(type); z.SetType(type);
auto case_test = AddInst(z); auto case_test = AddInst(z);
@ -699,7 +699,7 @@ const ZAMStmt ZAMCompiler::While(const Stmt* cond_stmt, const Expr* cond, const
if ( cond->Tag() == EXPR_NAME ) { if ( cond->Tag() == EXPR_NAME ) {
auto n = cond->AsNameExpr(); auto n = cond->AsNameExpr();
cond_IF = AddInst(ZInstI(OP_IF_VV, FrameSlot(n), 0)); cond_IF = AddInst(ZInstI(OP_IF_Vi, FrameSlot(n), 0));
branch_v = 2; branch_v = 2;
} }
else else
@ -777,7 +777,7 @@ const ZAMStmt ZAMCompiler::LoopOverTable(const ForStmt* f, const NameExpr* val)
auto iter_slot = table_iters.size(); auto iter_slot = table_iters.size();
table_iters.emplace_back(); table_iters.emplace_back();
auto z = ZInstI(OP_INIT_TABLE_LOOP_VV, FrameSlot(val), iter_slot); auto z = ZInstI(OP_INIT_TABLE_LOOP_Vi, FrameSlot(val), iter_slot);
z.op_type = OP_VV_I2; z.op_type = OP_VV_I2;
z.SetType(value_var ? value_var->GetType() : nullptr); z.SetType(value_var ? value_var->GetType() : nullptr);
z.aux = aux; z.aux = aux;
@ -786,13 +786,13 @@ const ZAMStmt ZAMCompiler::LoopOverTable(const ForStmt* f, const NameExpr* val)
auto iter_head = StartingBlock(); auto iter_head = StartingBlock();
if ( value_var ) { if ( value_var ) {
ZOp op = no_loop_vars ? OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_VVV : OP_NEXT_TABLE_ITER_VAL_VAR_VVV; ZOp op = no_loop_vars ? OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_Vii : OP_NEXT_TABLE_ITER_VAL_VAR_Vii;
z = ZInstI(op, FrameSlot(value_var), iter_slot, 0); z = ZInstI(op, FrameSlot(value_var), iter_slot, 0);
z.CheckIfManaged(value_var->GetType()); z.CheckIfManaged(value_var->GetType());
z.op_type = OP_VVV_I2_I3; z.op_type = OP_VVV_I2_I3;
} }
else { else {
ZOp op = no_loop_vars ? OP_NEXT_TABLE_ITER_NO_VARS_VV : OP_NEXT_TABLE_ITER_VV; ZOp op = no_loop_vars ? OP_NEXT_TABLE_ITER_NO_VARS_ii : OP_NEXT_TABLE_ITER_ii;
z = ZInstI(op, iter_slot, 0); z = ZInstI(op, iter_slot, 0);
z.op_type = OP_VV_I1_I2; z.op_type = OP_VV_I1_I2;
} }
@ -809,7 +809,7 @@ const ZAMStmt ZAMCompiler::LoopOverVector(const ForStmt* f, const NameExpr* val)
int iter_slot = num_step_iters++; int iter_slot = num_step_iters++;
auto z = ZInstI(OP_INIT_VECTOR_LOOP_VV, FrameSlot(val), iter_slot); auto z = ZInstI(OP_INIT_VECTOR_LOOP_Vi, FrameSlot(val), iter_slot);
z.op_type = OP_VV_I2; z.op_type = OP_VV_I2;
auto init_end = AddInst(z); auto init_end = AddInst(z);
@ -819,11 +819,11 @@ const ZAMStmt ZAMCompiler::LoopOverVector(const ForStmt* f, const NameExpr* val)
if ( value_var ) { if ( value_var ) {
if ( slot >= 0 ) { if ( slot >= 0 ) {
z = ZInstI(OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV, slot, FrameSlot(value_var), iter_slot, 0); z = ZInstI(OP_NEXT_VECTOR_ITER_VAL_VAR_VVii, slot, FrameSlot(value_var), iter_slot, 0);
z.op_type = OP_VVVV_I3_I4; z.op_type = OP_VVVV_I3_I4;
} }
else { else {
z = ZInstI(OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_VVV, FrameSlot(value_var), iter_slot, 0); z = ZInstI(OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_Vii, FrameSlot(value_var), iter_slot, 0);
z.op_type = OP_VVV_I2_I3; z.op_type = OP_VVV_I2_I3;
} }
@ -833,11 +833,11 @@ const ZAMStmt ZAMCompiler::LoopOverVector(const ForStmt* f, const NameExpr* val)
else { else {
if ( slot >= 0 ) { if ( slot >= 0 ) {
z = ZInstI(OP_NEXT_VECTOR_ITER_VVV, slot, iter_slot, 0); z = ZInstI(OP_NEXT_VECTOR_ITER_Vii, slot, iter_slot, 0);
z.op_type = OP_VVV_I2_I3; z.op_type = OP_VVV_I2_I3;
} }
else { else {
z = ZInstI(OP_NEXT_VECTOR_BLANK_ITER_VV, iter_slot, 0); z = ZInstI(OP_NEXT_VECTOR_BLANK_ITER_ii, iter_slot, 0);
z.op_type = OP_VV_I1_I2; z.op_type = OP_VV_I1_I2;
} }
} }
@ -856,12 +856,12 @@ const ZAMStmt ZAMCompiler::LoopOverString(const ForStmt* f, const Expr* e) {
ZInstI z; ZInstI z;
if ( n ) { if ( n ) {
z = ZInstI(OP_INIT_STRING_LOOP_VV, FrameSlot(n), iter_slot); z = ZInstI(OP_INIT_STRING_LOOP_Vi, FrameSlot(n), iter_slot);
z.op_type = OP_VV_I2; z.op_type = OP_VV_I2;
} }
else { else {
ASSERT(c); ASSERT(c);
z = ZInstI(OP_INIT_STRING_LOOP_VC, iter_slot, c); z = ZInstI(OP_INIT_STRING_LOOP_iC, iter_slot, c);
z.op_type = OP_VC_I1; z.op_type = OP_VC_I1;
} }
@ -869,11 +869,11 @@ const ZAMStmt ZAMCompiler::LoopOverString(const ForStmt* f, const Expr* e) {
auto iter_head = StartingBlock(); auto iter_head = StartingBlock();
if ( loop_var->IsBlank() ) { if ( loop_var->IsBlank() ) {
z = ZInstI(OP_NEXT_STRING_BLANK_ITER_VV, iter_slot, 0); z = ZInstI(OP_NEXT_STRING_BLANK_ITER_ii, iter_slot, 0);
z.op_type = OP_VV_I1_I2; z.op_type = OP_VV_I1_I2;
} }
else { else {
z = ZInstI(OP_NEXT_STRING_ITER_VVV, FrameSlot(loop_var), iter_slot, 0); z = ZInstI(OP_NEXT_STRING_ITER_Vii, FrameSlot(loop_var), iter_slot, 0);
z.op_type = OP_VVV_I2_I3; z.op_type = OP_VVV_I2_I3;
z.is_managed = true; z.is_managed = true;
} }
@ -903,7 +903,7 @@ const ZAMStmt ZAMCompiler::FinishLoop(const ZAMStmt iter_head, ZInstI& iter_stmt
// We only need cleanup for looping over tables, but for now we // We only need cleanup for looping over tables, but for now we
// need some sort of placeholder instruction (until the optimizer // need some sort of placeholder instruction (until the optimizer
// can elide it) to resolve loop exits. // can elide it) to resolve loop exits.
ZOp op = is_table ? OP_END_TABLE_LOOP_V : OP_NOP; ZOp op = is_table ? OP_END_TABLE_LOOP_i : OP_NOP;
auto loop_end = GoTo(GoToTarget(iter_head)); auto loop_end = GoTo(GoToTarget(iter_head));
auto z = ZInstI(op, iter_slot); auto z = ZInstI(op, iter_slot);

8
src/script_opt/ZAM/Vars.cc
View file

@ -57,9 +57,9 @@ const ZAMStmt ZAMCompiler::LoadGlobal(const ID* id) {
if ( id->IsType() ) if ( id->IsType() )
// Need a special load for these, as they don't fit // Need a special load for these, as they don't fit
// with the usual template. // with the usual template.
op = OP_LOAD_GLOBAL_TYPE_VV; op = OP_LOAD_GLOBAL_TYPE_Vi;
else else
op = AssignmentFlavor(OP_LOAD_GLOBAL_VV, id->GetType()->Tag()); op = AssignmentFlavor(OP_LOAD_GLOBAL_Vi, id->GetType()->Tag());
auto slot = RawSlot(id); auto slot = RawSlot(id);
@ -78,9 +78,9 @@ const ZAMStmt ZAMCompiler::LoadCapture(const ID* id) {
ZOp op; ZOp op;
if ( ZVal::IsManagedType(id->GetType()) ) if ( ZVal::IsManagedType(id->GetType()) )
op = OP_LOAD_MANAGED_CAPTURE_VV; op = OP_LOAD_MANAGED_CAPTURE_Vi;
else else
op = OP_LOAD_CAPTURE_VV; op = OP_LOAD_CAPTURE_Vi;
auto slot = RawSlot(id); auto slot = RawSlot(id);

32
src/script_opt/ZAM/ZInst.cc
View file

@ -229,16 +229,16 @@ ValPtr ZInst::ConstVal() const {
bool ZInst::IsLoopIterationAdvancement() const { bool ZInst::IsLoopIterationAdvancement() const {
switch ( op ) { switch ( op ) {
case OP_NEXT_TABLE_ITER_VV: case OP_NEXT_TABLE_ITER_ii:
case OP_NEXT_TABLE_ITER_NO_VARS_VV: case OP_NEXT_TABLE_ITER_NO_VARS_ii:
case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: case OP_NEXT_TABLE_ITER_VAL_VAR_Vii:
case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_VVV: case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_Vii:
case OP_NEXT_VECTOR_ITER_VVV: case OP_NEXT_VECTOR_ITER_Vii:
case OP_NEXT_VECTOR_BLANK_ITER_VV: case OP_NEXT_VECTOR_BLANK_ITER_ii:
case OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV: case OP_NEXT_VECTOR_ITER_VAL_VAR_VVii:
case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_VVV: case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_Vii:
case OP_NEXT_STRING_ITER_VVV: case OP_NEXT_STRING_ITER_Vii:
case OP_NEXT_STRING_BLANK_ITER_VV: return true; case OP_NEXT_STRING_BLANK_ITER_ii: return true;
default: return false; default: return false;
} }
@ -281,7 +281,7 @@ bool ZInst::AssignsToSlot1() const {
bool ZInst::AssignsToSlot(int slot) const { bool ZInst::AssignsToSlot(int slot) const {
switch ( op ) { switch ( op ) {
case OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV: return slot == 1 || slot == 2; case OP_NEXT_VECTOR_ITER_VAL_VAR_VVii: return slot == 1 || slot == 2;
default: return slot == 1 && AssignsToSlot1(); default: return slot == 1 && AssignsToSlot1();
} }
@ -358,7 +358,7 @@ string ZInstI::VName(int n, const FrameMap* frame_ids, const FrameReMap* remappi
bool ZInstI::DoesNotContinue() const { bool ZInstI::DoesNotContinue() const {
switch ( op ) { switch ( op ) {
case OP_GOTO_V: case OP_GOTO_i:
case OP_HOOK_BREAK_X: case OP_HOOK_BREAK_X:
case OP_RETURN_C: case OP_RETURN_C:
case OP_RETURN_V: case OP_RETURN_V:
@ -397,7 +397,7 @@ bool ZInstI::IsDirectAssignment() const {
bool ZInstI::HasCaptures() const { bool ZInstI::HasCaptures() const {
switch ( op ) { switch ( op ) {
case OP_LAMBDA_VV: case OP_LAMBDA_Vi:
case OP_WHEN_V: case OP_WHEN_V:
case OP_WHEN_TIMEOUT_VV: case OP_WHEN_TIMEOUT_VV:
case OP_WHEN_TIMEOUT_VC: return true; case OP_WHEN_TIMEOUT_VC: return true;
@ -557,7 +557,7 @@ void ZInstI::UpdateSlots(std::vector<int>& slot_mapping) {
} }
bool ZInstI::IsGlobalLoad() const { bool ZInstI::IsGlobalLoad() const {
if ( op == OP_LOAD_GLOBAL_TYPE_VV ) if ( op == OP_LOAD_GLOBAL_TYPE_Vi )
// These don't have flavors. // These don't have flavors.
return true; return true;
@ -566,7 +566,7 @@ bool ZInstI::IsGlobalLoad() const {
if ( global_ops.empty() ) { // Initialize the set. if ( global_ops.empty() ) { // Initialize the set.
for ( int t = 0; t < NUM_TYPES; ++t ) { for ( int t = 0; t < NUM_TYPES; ++t ) {
TypeTag tag = TypeTag(t); TypeTag tag = TypeTag(t);
ZOp global_op_flavor = AssignmentFlavor(OP_LOAD_GLOBAL_VV, tag, false); ZOp global_op_flavor = AssignmentFlavor(OP_LOAD_GLOBAL_Vi, tag, false);
if ( global_op_flavor != OP_NOP ) if ( global_op_flavor != OP_NOP )
global_ops.insert(global_op_flavor); global_ops.insert(global_op_flavor);
@ -576,7 +576,7 @@ bool ZInstI::IsGlobalLoad() const {
return global_ops.count(op) > 0; return global_ops.count(op) > 0;
} }
bool ZInstI::IsCaptureLoad() const { return op == OP_LOAD_CAPTURE_VV || op == OP_LOAD_MANAGED_CAPTURE_VV; } bool ZInstI::IsCaptureLoad() const { return op == OP_LOAD_CAPTURE_Vi || op == OP_LOAD_MANAGED_CAPTURE_Vi; }
void ZInstI::InitConst(const ConstExpr* ce) { void ZInstI::InitConst(const ConstExpr* ce) {
auto v = ce->ValuePtr(); auto v = ce->ValuePtr();

4
src/script_opt/ZAM/ZInst.h
View file

@ -214,7 +214,7 @@ public:
// True if this instruction always branches elsewhere. Different // True if this instruction always branches elsewhere. Different
// from DoesNotContinue() in that returns & hook breaks do not // from DoesNotContinue() in that returns & hook breaks do not
// continue, but they are not branches. // continue, but they are not branches.
bool IsUnconditionalBranch() const { return op == OP_GOTO_V; } bool IsUnconditionalBranch() const { return op == OP_GOTO_i; }
// True if this instruction is of the form "v1 = v2". // True if this instruction is of the form "v1 = v2".
bool IsDirectAssignment() const; bool IsDirectAssignment() const;
@ -254,7 +254,7 @@ public:
bool IsLoad() const { return op_type == OP_VV_FRAME || IsNonLocalLoad(); } bool IsLoad() const { return op_type == OP_VV_FRAME || IsNonLocalLoad(); }
// True if the instruction corresponds to storing a global. // True if the instruction corresponds to storing a global.
bool IsGlobalStore() const { return op == OP_STORE_GLOBAL_V; } bool IsGlobalStore() const { return op == OP_STORE_GLOBAL_i; }
void CheckIfManaged(const TypePtr& t) { void CheckIfManaged(const TypePtr& t) {
if ( ZVal::IsManagedType(t) ) if ( ZVal::IsManagedType(t) )