diff --git a/auxil/gen-zam b/auxil/gen-zam index 1a063a1d14..5c18ce8c86 160000 --- a/auxil/gen-zam +++ b/auxil/gen-zam @@ -1 +1 @@ -Subproject commit 1a063a1d142bdd5e3120aca6240be89f2ec31080 +Subproject commit 5c18ce8c868e44bddebfd41017df85e82e559863 diff --git a/src/script_opt/ZAM/AM-Opt.cc b/src/script_opt/ZAM/AM-Opt.cc index 852c483c9b..3ee2eb2d19 100644 --- a/src/script_opt/ZAM/AM-Opt.cc +++ b/src/script_opt/ZAM/AM-Opt.cc @@ -336,8 +336,8 @@ void ZAMCompiler::ComputeFrameLifetimes() { // Some special-casing. switch ( inst->op ) { - case OP_NEXT_TABLE_ITER_VV: - case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: { + case OP_NEXT_TABLE_ITER_ii: + case OP_NEXT_TABLE_ITER_VAL_VAR_Vii: { // These assign to an arbitrary long list of variables. auto& iter_vars = inst->aux->loop_vars; auto depth = inst->loop_depth; @@ -361,21 +361,21 @@ void ZAMCompiler::ComputeFrameLifetimes() { } // 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 // 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)); } 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; ExtendLifetime(inst->v1, EndOfLoop(inst, depth)); } break; - case OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV: { + case OP_NEXT_VECTOR_ITER_VAL_VAR_VVii: { CheckSlotAssignment(inst->v2, inst); auto depth = inst->loop_depth; @@ -383,13 +383,13 @@ void ZAMCompiler::ComputeFrameLifetimes() { ExtendLifetime(inst->v2, EndOfLoop(inst, depth)); } break; - case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_VVV: { + case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_Vii: { auto depth = inst->loop_depth; ExtendLifetime(inst->v1, EndOfLoop(inst, depth)); } break; - case OP_NEXT_VECTOR_ITER_VVV: - case OP_NEXT_STRING_ITER_VVV: + case OP_NEXT_VECTOR_ITER_Vii: + case OP_NEXT_STRING_ITER_Vii: // Sometimes loops are written that don't actually // use the iteration variable. However, we still // need to mark the variable as having usage @@ -401,12 +401,12 @@ void ZAMCompiler::ComputeFrameLifetimes() { ExtendLifetime(inst->v1, EndOfLoop(inst, inst->loop_depth)); break; - case OP_NEXT_VECTOR_BLANK_ITER_VV: - case OP_NEXT_STRING_BLANK_ITER_VV: break; + case OP_NEXT_VECTOR_BLANK_ITER_ii: + case OP_NEXT_STRING_BLANK_ITER_ii: break; - case OP_INIT_TABLE_LOOP_VV: - case OP_INIT_VECTOR_LOOP_VV: - case OP_INIT_STRING_LOOP_VV: { + case OP_INIT_TABLE_LOOP_Vi: + case OP_INIT_VECTOR_LOOP_Vi: + case OP_INIT_STRING_LOOP_Vi: { // For all of these, the scope of the aggregate being // looped over is the entire loop, even if it doesn't // directly appear in it, and not just the initializer. @@ -423,14 +423,14 @@ void ZAMCompiler::ComputeFrameLifetimes() { continue; } - case OP_STORE_GLOBAL_V: { + case OP_STORE_GLOBAL_i: { // Use of the global goes to here. auto slot = frame_layout1[globalsI[inst->v1].id.get()]; ExtendLifetime(slot, EndOfLoop(inst, 1)); break; } - case OP_LAMBDA_VV: { + case OP_LAMBDA_Vi: { auto aux = inst->aux; int n = aux->n; for ( int i = 0; i < n; ++i ) { @@ -549,8 +549,8 @@ void ZAMCompiler::ReMapFrame() { // Handle special cases. switch ( inst->op ) { - case OP_NEXT_TABLE_ITER_VV: - case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: { + case OP_NEXT_TABLE_ITER_ii: + case OP_NEXT_TABLE_ITER_VAL_VAR_Vii: { // Rewrite iteration variables. auto& iter_vars = inst->aux->loop_vars; for ( auto& v : iter_vars ) { diff --git a/src/script_opt/ZAM/Branches.cc b/src/script_opt/ZAM/Branches.cc index a06347022d..05504486c9 100644 --- a/src/script_opt/ZAM/Branches.cc +++ b/src/script_opt/ZAM/Branches.cc @@ -25,13 +25,13 @@ ZAMStmt ZAMCompiler::GenGoTo(GoToSet& v) { } ZAMStmt ZAMCompiler::GoToStub() { - ZInstI z(OP_GOTO_V, 0); + ZInstI z(OP_GOTO_i, 0); z.op_type = OP_V_I1; return AddInst(z); } ZAMStmt ZAMCompiler::GoTo(const InstLabel l) { - ZInstI inst(OP_GOTO_V, 0); + ZInstI inst(OP_GOTO_i, 0); inst.target = l; inst.target_slot = 1; inst.op_type = OP_V_I1; diff --git a/src/script_opt/ZAM/BuiltIn.cc b/src/script_opt/ZAM/BuiltIn.cc index 6a6016e813..5f04b7bf3b 100644 --- a/src/script_opt/ZAM/BuiltIn.cc +++ b/src/script_opt/ZAM/BuiltIn.cc @@ -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 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 iip_ZBI{"is_icmp_port", OP_IS_ICMP_PORT_VV, OP_IS_ICMP_PORT_COND_VV, 1}; -CondZBI itp_ZBI{"is_tcp_port", OP_IS_TCP_PORT_VV, OP_IS_TCP_PORT_COND_VV, 1}; -CondZBI iup_ZBI{"is_udp_port", OP_IS_UDP_PORT_VV, OP_IS_UDP_PORT_COND_VV, 1}; -CondZBI iv4_ZBI{"is_v4_addr", OP_IS_V4_ADDR_VV, OP_IS_V4_ADDR_COND_VV, 1}; -CondZBI iv6_ZBI{"is_v6_addr", OP_IS_V6_ADDR_VV, OP_IS_V6_ADDR_COND_VV, 1}; -CondZBI rlt_ZBI{"reading_live_traffic", OP_READING_LIVE_TRAFFIC_V, OP_READING_LIVE_TRAFFIC_COND_V, 0}; -CondZBI rt_ZBI{"reading_traces", OP_READING_TRACES_V, OP_READING_TRACES_COND_V, 0}; +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_Vi, 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_Vi, 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_Vi, 1}; +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_i, 0}; // These have a different form to avoid invoking copy constructors. auto cat_ZBI = CatZBI(); @@ -468,48 +468,48 @@ OptAssignZBI rtc_ZBI{ "PacketAnalyzer::TEREDO::remove_teredo_connection", MultiZBI faa_ZBI{ "Files::__add_analyzer", {{{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}}, - {{VCV}, {OP_FILES_ADD_ANALYZER_VViV, OP_VVVC}}}, + {{VCV}, {OP_FILES_ADD_ANALYZER_VVCV, OP_VVVC}}}, 1 }; MultiZBI fra_ZBI{ "Files::__remove_analyzer", {{{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}}, - {{VCV}, {OP_FILES_REMOVE_ANALYZER_VViV, OP_VVVC}}}, + {{VCV}, {OP_FILES_REMOVE_ANALYZER_VVCV, OP_VVVC}}}, 1 }; MultiZBI fsrb_ZBI{ "Files::__set_reassembly_buffer", {{{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}}, - {{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", {{{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}}, - {{CV}, {OP_LOG_WRITEC_VV, OP_VV}}} + {{CV}, {OP_LOG_WRITEC_VCV, OP_VV}}} }; MultiZBI gccbt_ZBI{ "get_current_conn_bytes_threshold", true, {{{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", {{{VVV}, {OP_SET_BYTES_THRESH_VVV, OP_VVV}}, - {{VVC}, {OP_SET_BYTES_THRESH_VVi, OP_VVC}}, - {{VCV}, {OP_SET_BYTES_THRESH_ViV, OP_VVC}}, - {{VCC}, {OP_SET_BYTES_THRESH_Vii, OP_VVC_I2}}}, + {{VVC}, {OP_SET_BYTES_THRESH_VVC, OP_VVC}}, + {{VCV}, {OP_SET_BYTES_THRESH_VCV, OP_VVC}}, + {{VCC}, {OP_SET_BYTES_THRESH_VCi, OP_VVC_I2}}}, {{{VVV}, {OP_SET_BYTES_THRESH_VVVV, OP_VVVV}}, - {{VVC}, {OP_SET_BYTES_THRESH_VVVi, OP_VVVC}}, - {{VCV}, {OP_SET_BYTES_THRESH_VViV, OP_VVVC}}, - {{VCC}, {OP_SET_BYTES_THRESH_VVii, OP_VVVC_I3}}} + {{VVC}, {OP_SET_BYTES_THRESH_VVVC, OP_VVVC}}, + {{VCV}, {OP_SET_BYTES_THRESH_VVCV, OP_VVVC}}, + {{VCC}, {OP_SET_BYTES_THRESH_VVCi, OP_VVVC_I3}}} }; MultiZBI sw_ZBI{ "starts_with", true, @@ -532,11 +532,11 @@ MultiZBI strstr_ZBI{ "strstr", true, MultiZBI sb_ZBI{ "sub_bytes", true, {{{VVV}, {OP_SUB_BYTES_VVVV, OP_VVVV}}, - {{VVC}, {OP_SUB_BYTES_VVVi, OP_VVVC}}, - {{VCV}, {OP_SUB_BYTES_VViV, OP_VVVC}}, - {{VCC}, {OP_SUB_BYTES_VVii, OP_VVVC_I3}}, + {{VVC}, {OP_SUB_BYTES_VVVC, OP_VVVC}}, + {{VCV}, {OP_SUB_BYTES_VVCV, OP_VVVC}}, + {{VCC}, {OP_SUB_BYTES_VVCi, OP_VVVC_I3}}, {{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}}} }; diff --git a/src/script_opt/ZAM/Expr.cc b/src/script_opt/ZAM/Expr.cc index 42bd16e6ff..e2f5bed55b 100644 --- a/src/script_opt/ZAM/Expr.cc +++ b/src/script_opt/ZAM/Expr.cc @@ -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); } else { - auto zop = OP_INDEX_STRINGC_VVV; + auto zop = OP_INDEX_STRINGC_VVi; z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c); 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 ) zop = OP_INDEX_ANY_VEC_VVV; else - zop = OP_INDEX_VEC_VVV; + zop = OP_INDEX_VEC_VVi; 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; if ( in_when ) - zop = OP_WHEN_INDEX_VECC_VVV; + zop = OP_WHEN_INDEX_VECC_VVi; else if ( is_any ) - zop = OP_INDEX_ANY_VECC_VVV; + zop = OP_INDEX_ANY_VECC_VVi; else - zop = OP_INDEX_VECC_VVV; + zop = OP_INDEX_VECC_VVi; z = ZInstI(zop, Frame1Slot(n1, zop), n2_slot, c); 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()); } - 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.aux = aux; @@ -1057,7 +1057,7 @@ const ZAMStmt ZAMCompiler::DoCall(const CallExpr* c, const NameExpr* n) { default: if ( in_when ) { if ( indirect ) - op = OP_WHENINDCALLN_VV; + op = OP_WHENINDCALLN_Vi; else op = OP_WHENCALLN_V; } @@ -1151,7 +1151,7 @@ const ZAMStmt ZAMCompiler::ConstructTable(const NameExpr* n, const Expr* e) { auto tt = cast_intrusive(n->GetType()); 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.t = tt; 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 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.t = e->GetType(); ASSERT(e->Tag() == EXPR_SET_CONSTRUCTOR); @@ -1262,13 +1262,13 @@ const ZAMStmt ZAMCompiler::ConstructRecord(const NameExpr* n, const Expr* e) { if ( fi->empty() ) { if ( network_time_index >= 0 ) - op = OP_CONSTRUCT_KNOWN_RECORD_WITH_NT_VV; + op = OP_CONSTRUCT_KNOWN_RECORD_WITH_NT_Vi; else op = OP_CONSTRUCT_KNOWN_RECORD_V; } else { 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 op = OP_CONSTRUCT_KNOWN_RECORD_WITH_INITS_V; aux->field_inits = std::move(fi); diff --git a/src/script_opt/ZAM/Low-Level.cc b/src/script_opt/ZAM/Low-Level.cc index fa1048431d..1f310e063f 100644 --- a/src/script_opt/ZAM/Low-Level.cc +++ b/src/script_opt/ZAM/Low-Level.cc @@ -125,7 +125,7 @@ const ZAMStmt ZAMCompiler::AddInst(const ZInstI& inst, bool suppress_non_local) auto gs = pending_global_store; 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.t = globalsI[gs].id->GetType(); @@ -142,9 +142,9 @@ const ZAMStmt ZAMCompiler::AddInst(const ZInstI& inst, bool suppress_non_local) ZOp op; if ( ZVal::IsManagedType(c_id->GetType()) ) - op = OP_STORE_MANAGED_CAPTURE_VV; + op = OP_STORE_MANAGED_CAPTURE_Vi; else - op = OP_STORE_CAPTURE_VV; + op = OP_STORE_CAPTURE_Vi; auto store_inst = ZInstI(op, RawSlot(c_id.get()), cs); store_inst.op_type = OP_VV_I2; diff --git a/src/script_opt/ZAM/OPs/ZAM.op b/src/script_opt/ZAM/OPs/ZAM.op index 6e732b31e5..e3ac9b677b 100644 --- a/src/script_opt/ZAM/OPs/ZAM.op +++ b/src/script_opt/ZAM/OPs/ZAM.op @@ -386,14 +386,14 @@ op1-read eval EvalAddPatternToField($$.record_val, $1, $2) macro EvalAddPatternToField(r, v, f) - auto fpat = r->GetField(z.f)->AsPatternVal(); + auto fpat = r->GetField(f)->AsPatternVal(); if ( fpat ) { v.re_val->AddTo(fpat, false); r->Modified(); } 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 type VCi @@ -1015,11 +1015,11 @@ custom-method return CompileIndex(n, c, l, true); no-eval internal-op Index-Vec -type VVV +type VVi eval EvalIndexVec($$, $1, $2) -macro EvalIndexVec(lhs, vec, index) - auto& vv = vec.vector_val->RawVec(); +macro EvalIndexVec(lhs, rhs_vec, index) + auto& vv = rhs_vec.vector_val->RawVec(); const auto& vec = vv; zeek_int_t ind = index; if ( ind < 0 ) @@ -1125,13 +1125,13 @@ eval auto args = z.aux->ToListVal(frame); internal-assignment-op Table-Index1 type VVV 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 internal-assignment-op Table-Index1 type VVC assign-val v -eval EvalTableIndex(z.c.ToVal(z.t)) +eval EvalTableIndex($$, z.c.ToVal(z.t)) # This version is for a variable v3. internal-op Index-String @@ -1438,12 +1438,14 @@ set-type $1 eval AssignTarget($$, ZVal($1.ToVal(z.t), ZAM::any_base_type)) unary-expr-op From-Any-Coerce +no-const op-type X set-type $$ eval auto v = $1.any_val; AssignTarget($$, ZVal({NewRef{}, v}, z.t)) unary-expr-op From-Any-Vec-Coerce +no-const op-type X set-type $$ eval auto vv = $1.vector_val; @@ -1896,13 +1898,13 @@ eval auto vs = $1.string_val->AsString()->Render(); internal-op SwitchA op1-read -type VVV +type Vii eval auto v = $1.addr_val->AsAddr().AsString(); EvalSwitchBody($2, $3, str_cases,) internal-op SwitchN op1-read -type VVV +type Vii eval auto v = $1.subnet_val->AsSubNet().AsString(); EvalSwitchBody($2, $3, str_cases,) @@ -1938,7 +1940,7 @@ internal-op Next-Table-Iter-No-Vars op1-read # v1 = iteration info # v2 = branch target if loop done -type VV +type ii eval NextTableIterPre($1, $2) ti.IterFinished(); @@ -1946,7 +1948,7 @@ internal-op Next-Table-Iter-Val-Var # v1 = slot of the "ValueVar" # v2 = iteration info # v3 = branch target if loop done -type VVV +type Vii eval NextTableIterPre($1, $2) AssignTarget($$, ti.IterValue()); ti.NextIter(frame); @@ -1955,7 +1957,7 @@ internal-op Next-Table-Iter-Val-Var-No-Vars # v1 = slot of the "ValueVar" # v2 = iteration info # v3 = branch target if loop done -type VVV +type Vii eval NextTableIterPre($1, $2) AssignTarget($$, ti.IterValue()); ti.IterFinished(); @@ -2244,7 +2246,7 @@ assign-val v eval auto& v = f->GetElement(z.v2); internal-assignment-op Load-Global -type VV +type Vi assign-val v eval auto& v = globals[z.v2].id->GetVal(); if ( ! v ) @@ -2484,7 +2486,7 @@ eval LogWritePre($1, $2) ### Check that invoked correctly internal-op Log-WriteC -side-effects OP_LOG_WRITEC_V OP_V +side-effects OP_LOG_WRITEC_CV OP_V type VCV eval LogWritePre($1, $2) LogWriteResPost($$) @@ -3006,7 +3008,7 @@ eval FilesRemoveAnalyzer($1, $2, $3) internal-op Files-Remove-Analyzer op1-read -type ViV +type VCV eval FilesRemoveAnalyzer($1, $2, $3) internal-op Files-Remove-Analyzer @@ -3090,7 +3092,7 @@ eval auto f = $1.string_val->CheckString(); internal-op Files-Set-Reassembly-Buffer 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(); $$.int_val = file_mgr->SetReassemblyBuffer(f, zeek_uint_t($2)); diff --git a/src/script_opt/ZAM/Stmt.cc b/src/script_opt/ZAM/Stmt.cc index 425062157d..65bcafd54d 100644 --- a/src/script_opt/ZAM/Stmt.cc +++ b/src/script_opt/ZAM/Stmt.cc @@ -136,7 +136,7 @@ const ZAMStmt ZAMCompiler::IfElse(const Expr* e, const Stmt* s1, const Stmt* s2) if ( e->Tag() == EXPR_NAME ) { 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); 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]; switch ( z->op ) { - case OP_IF_ELSE_VV: - case OP_IF_VV: - case OP_IF_NOT_VV: + case OP_IF_ELSE_Vi: + case OP_IF_Vi: + case OP_IF_NOT_Vi: // These are generated correctly above, no need // to fix up. break; - case OP_HAS_FIELD_COND_VVV: z->op = OP_NOT_HAS_FIELD_COND_VVV; break; - case OP_NOT_HAS_FIELD_COND_VVV: z->op = OP_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_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_NOT_CONN_EXISTS_COND_VV: z->op = OP_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_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_NOT_IS_ICMP_PORT_COND_VV: z->op = OP_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_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_NOT_IS_TCP_PORT_COND_VV: z->op = OP_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_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_NOT_IS_UDP_PORT_COND_VV: z->op = OP_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_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_NOT_IS_V4_ADDR_COND_VV: z->op = OP_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_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_NOT_IS_V6_ADDR_COND_VV: z->op = OP_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_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_NOT_READING_LIVE_TRAFFIC_COND_V: z->op = OP_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_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_NOT_READING_TRACES_COND_V: z->op = OP_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_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_NOT_TABLE_HAS_ELEMENTS_COND_VV: z->op = OP_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_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_NOT_VECTOR_HAS_ELEMENTS_COND_VV: z->op = OP_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_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_NOT_IN_TABLE_COND_VVV: z->op = OP_VAL_IS_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_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_NOT_IN_TABLE_COND_VVC: z->op = OP_CONST_IS_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_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_NOT_IN_TABLE_COND_VVVV: z->op = OP_VAL2_IS_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_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_NOT_IN_TABLE_COND_VVVC: z->op = OP_VAL2_IS_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_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_NOT_IN_TABLE_COND_VVCV: z->op = OP_VAL2_IS_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_VVCi: z->op = OP_VAL2_IS_IN_TABLE_COND_VVCi; break; 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 ) { 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; branch_v = 3; return AddInst(z); @@ -255,14 +255,14 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) { } 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(); branch_v = 3; return AddInst(z); } 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(); branch_v = 2; return AddInst(z); @@ -290,19 +290,19 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) { ZInstI z; 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; z.t2 = n0->GetType(); } 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; z.t2 = n0->GetType(); } 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; 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. 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; branch_v = 3; z.t2 = c0->GetType(); @@ -332,9 +332,9 @@ const ZAMStmt ZAMCompiler::GenCond(const Expr* e, int& branch_v) { ZOp op; if ( aggr->GetType()->Tag() == TYPE_TABLE ) - op = OP_TABLE_HAS_ELEMENTS_COND_VV; + op = OP_TABLE_HAS_ELEMENTS_COND_Vi; else - op = OP_VECTOR_HAS_ELEMENTS_COND_VV; + op = OP_VECTOR_HAS_ELEMENTS_COND_Vi; branch_v = 2; return AddInst(GenInst(op, aggr, +0)); @@ -418,32 +418,32 @@ const ZAMStmt ZAMCompiler::ValueSwitch(const SwitchStmt* sw, const NameExpr* v, switch ( t->InternalType() ) { case TYPE_INTERNAL_INT: - op = OP_SWITCHI_VVV; + op = OP_SWITCHI_Vii; tbl = int_casesI.size(); break; case TYPE_INTERNAL_UNSIGNED: - op = OP_SWITCHU_VVV; + op = OP_SWITCHU_Vii; tbl = uint_casesI.size(); break; case TYPE_INTERNAL_DOUBLE: - op = OP_SWITCHD_VVV; + op = OP_SWITCHD_Vii; tbl = double_casesI.size(); break; case TYPE_INTERNAL_STRING: - op = OP_SWITCHS_VVV; + op = OP_SWITCHS_Vii; tbl = str_casesI.size(); break; case TYPE_INTERNAL_ADDR: - op = OP_SWITCHA_VVV; + op = OP_SWITCHA_Vii; tbl = str_casesI.size(); break; case TYPE_INTERNAL_SUBNET: - op = OP_SWITCHN_VVV; + op = OP_SWITCHN_Vii; tbl = str_casesI.size(); break; @@ -577,7 +577,7 @@ const ZAMStmt ZAMCompiler::TypeSwitch(const SwitchStmt* sw, const NameExpr* v, c 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); 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 ) { 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; } else @@ -777,7 +777,7 @@ const ZAMStmt ZAMCompiler::LoopOverTable(const ForStmt* f, const NameExpr* val) auto iter_slot = table_iters.size(); 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.SetType(value_var ? value_var->GetType() : nullptr); z.aux = aux; @@ -786,13 +786,13 @@ const ZAMStmt ZAMCompiler::LoopOverTable(const ForStmt* f, const NameExpr* val) auto iter_head = StartingBlock(); 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.CheckIfManaged(value_var->GetType()); z.op_type = OP_VVV_I2_I3; } 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.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++; - 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; auto init_end = AddInst(z); @@ -819,11 +819,11 @@ const ZAMStmt ZAMCompiler::LoopOverVector(const ForStmt* f, const NameExpr* val) if ( value_var ) { 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; } 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; } @@ -833,11 +833,11 @@ const ZAMStmt ZAMCompiler::LoopOverVector(const ForStmt* f, const NameExpr* val) else { 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; } 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; } } @@ -856,12 +856,12 @@ const ZAMStmt ZAMCompiler::LoopOverString(const ForStmt* f, const Expr* e) { ZInstI z; 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; } else { 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; } @@ -869,11 +869,11 @@ const ZAMStmt ZAMCompiler::LoopOverString(const ForStmt* f, const Expr* e) { auto iter_head = StartingBlock(); 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; } 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.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 // need some sort of placeholder instruction (until the optimizer // 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 z = ZInstI(op, iter_slot); diff --git a/src/script_opt/ZAM/Vars.cc b/src/script_opt/ZAM/Vars.cc index 3994c12f2d..fb7aaabaf5 100644 --- a/src/script_opt/ZAM/Vars.cc +++ b/src/script_opt/ZAM/Vars.cc @@ -57,9 +57,9 @@ const ZAMStmt ZAMCompiler::LoadGlobal(const ID* id) { if ( id->IsType() ) // Need a special load for these, as they don't fit // with the usual template. - op = OP_LOAD_GLOBAL_TYPE_VV; + op = OP_LOAD_GLOBAL_TYPE_Vi; else - op = AssignmentFlavor(OP_LOAD_GLOBAL_VV, id->GetType()->Tag()); + op = AssignmentFlavor(OP_LOAD_GLOBAL_Vi, id->GetType()->Tag()); auto slot = RawSlot(id); @@ -78,9 +78,9 @@ const ZAMStmt ZAMCompiler::LoadCapture(const ID* id) { ZOp op; if ( ZVal::IsManagedType(id->GetType()) ) - op = OP_LOAD_MANAGED_CAPTURE_VV; + op = OP_LOAD_MANAGED_CAPTURE_Vi; else - op = OP_LOAD_CAPTURE_VV; + op = OP_LOAD_CAPTURE_Vi; auto slot = RawSlot(id); diff --git a/src/script_opt/ZAM/ZInst.cc b/src/script_opt/ZAM/ZInst.cc index c619e25984..f8f7ba2e26 100644 --- a/src/script_opt/ZAM/ZInst.cc +++ b/src/script_opt/ZAM/ZInst.cc @@ -229,16 +229,16 @@ ValPtr ZInst::ConstVal() const { bool ZInst::IsLoopIterationAdvancement() const { switch ( op ) { - case OP_NEXT_TABLE_ITER_VV: - case OP_NEXT_TABLE_ITER_NO_VARS_VV: - case OP_NEXT_TABLE_ITER_VAL_VAR_VVV: - case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_VVV: - case OP_NEXT_VECTOR_ITER_VVV: - case OP_NEXT_VECTOR_BLANK_ITER_VV: - case OP_NEXT_VECTOR_ITER_VAL_VAR_VVVV: - case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_VVV: - case OP_NEXT_STRING_ITER_VVV: - case OP_NEXT_STRING_BLANK_ITER_VV: return true; + case OP_NEXT_TABLE_ITER_ii: + case OP_NEXT_TABLE_ITER_NO_VARS_ii: + case OP_NEXT_TABLE_ITER_VAL_VAR_Vii: + case OP_NEXT_TABLE_ITER_VAL_VAR_NO_VARS_Vii: + case OP_NEXT_VECTOR_ITER_Vii: + case OP_NEXT_VECTOR_BLANK_ITER_ii: + case OP_NEXT_VECTOR_ITER_VAL_VAR_VVii: + case OP_NEXT_VECTOR_BLANK_ITER_VAL_VAR_Vii: + case OP_NEXT_STRING_ITER_Vii: + case OP_NEXT_STRING_BLANK_ITER_ii: return true; default: return false; } @@ -281,7 +281,7 @@ bool ZInst::AssignsToSlot1() const { bool ZInst::AssignsToSlot(int slot) const { 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(); } @@ -358,7 +358,7 @@ string ZInstI::VName(int n, const FrameMap* frame_ids, const FrameReMap* remappi bool ZInstI::DoesNotContinue() const { switch ( op ) { - case OP_GOTO_V: + case OP_GOTO_i: case OP_HOOK_BREAK_X: case OP_RETURN_C: case OP_RETURN_V: @@ -397,7 +397,7 @@ bool ZInstI::IsDirectAssignment() const { bool ZInstI::HasCaptures() const { switch ( op ) { - case OP_LAMBDA_VV: + case OP_LAMBDA_Vi: case OP_WHEN_V: case OP_WHEN_TIMEOUT_VV: case OP_WHEN_TIMEOUT_VC: return true; @@ -557,7 +557,7 @@ void ZInstI::UpdateSlots(std::vector& slot_mapping) { } bool ZInstI::IsGlobalLoad() const { - if ( op == OP_LOAD_GLOBAL_TYPE_VV ) + if ( op == OP_LOAD_GLOBAL_TYPE_Vi ) // These don't have flavors. return true; @@ -566,7 +566,7 @@ bool ZInstI::IsGlobalLoad() const { if ( global_ops.empty() ) { // Initialize the set. for ( int t = 0; t < NUM_TYPES; ++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 ) global_ops.insert(global_op_flavor); @@ -576,7 +576,7 @@ bool ZInstI::IsGlobalLoad() const { 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) { auto v = ce->ValuePtr(); diff --git a/src/script_opt/ZAM/ZInst.h b/src/script_opt/ZAM/ZInst.h index 8bde9bc571..8de6d58a54 100644 --- a/src/script_opt/ZAM/ZInst.h +++ b/src/script_opt/ZAM/ZInst.h @@ -214,7 +214,7 @@ public: // True if this instruction always branches elsewhere. Different // from DoesNotContinue() in that returns & hook breaks do not // 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". bool IsDirectAssignment() const; @@ -254,7 +254,7 @@ public: bool IsLoad() const { return op_type == OP_VV_FRAME || IsNonLocalLoad(); } // 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) { if ( ZVal::IsManagedType(t) )