From f82121cb8c10c0b1361822a4db5ec43a9551e51b Mon Sep 17 00:00:00 2001 From: Igor Oberman Date: Tue, 26 Sep 2023 16:36:42 +0300 Subject: [PATCH] Implementing constructors for instructions Signed-off-by: Igor Oberman --- compiler/inline_intrinsics_ecmascript.cpp | 291 ++++++------------ compiler/intrinsics_inline_ecmascript.inl.h | 2 +- .../ir_builder/ecmascript_inst_builder.cpp | 95 ++---- .../ir_builder/ecmascript_inst_templates.yaml | 23 +- .../optimizer/optimizations/ecma_inlining.cpp | 37 +-- .../optimizations/inline_call_intrinsics.cpp | 22 +- irtoc_scripts/common.irt | 2 +- runtime/builtins/templates/builtins.rb | 4 +- .../builtins_inline_intrinsics_gen.inl.erb | 30 +- 9 files changed, 155 insertions(+), 351 deletions(-) diff --git a/compiler/inline_intrinsics_ecmascript.cpp b/compiler/inline_intrinsics_ecmascript.cpp index 7c18e893f..f9ac928e2 100644 --- a/compiler/inline_intrinsics_ecmascript.cpp +++ b/compiler/inline_intrinsics_ecmascript.cpp @@ -28,10 +28,8 @@ bool InlineLdConstant(IntrinsicInst *intrinsic, AnyBaseType any_type, T value) auto graph = current_block->GetGraph(); auto cnst = graph->FindOrCreateConstant(value); - auto cast_to_any_inst = graph->CreateInstCastValueToAnyType(DataType::ANY, intrinsic->GetPc()); + auto cast_to_any_inst = graph->CreateInstCastValueToAnyType(intrinsic->GetPc(), any_type, cnst); current_block->InsertAfter(cast_to_any_inst, intrinsic); - cast_to_any_inst->SetAnyType(any_type); - cast_to_any_inst->SetInput(0, cnst); intrinsic->ReplaceUsers(cast_to_any_inst); current_block->RemoveInst(intrinsic); @@ -98,8 +96,7 @@ bool InlineIntrinsics::InlineTypeOf(IntrinsicInst *intrinsic) if (type == AnyBaseType::UNDEFINED_TYPE) { return false; } - auto any_name = GetGraph()->CreateInstGetAnyTypeName(DataType::ANY, intrinsic->GetPc()); - any_name->SetAnyType(type); + auto any_name = GetGraph()->CreateInstGetAnyTypeName(intrinsic->GetPc(), type); intrinsic->InsertAfter(any_name); intrinsic->ReplaceUsers(any_name); return true; @@ -109,13 +106,9 @@ void InlineIntrinsics::CreateCompareClass(uint32_t pc, Inst *get_cls_inst, Runti BasicBlock *load_bb) { auto load_cls_inst = GetGraph()->CreateInstLoadImmediate(DataType::REFERENCE, pc, receiver); - auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_EQ); - auto if_inst = GetGraph()->CreateInstIfImm(DataType::BOOL, pc, ConditionCode::CC_NE, 0); - cmp_inst->SetInput(0, load_cls_inst); - cmp_inst->SetInput(1, get_cls_inst); - cmp_inst->SetOperandsType(DataType::REFERENCE); - if_inst->SetInput(0, cmp_inst); - if_inst->SetOperandsType(DataType::BOOL); + auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, load_cls_inst, get_cls_inst, DataType::REFERENCE, + ConditionCode::CC_EQ); + auto if_inst = GetGraph()->CreateInstIfImm(DataType::BOOL, pc, cmp_inst, 0, DataType::BOOL, ConditionCode::CC_NE); // We insert LoadImmediate in Dominate blockm because VN can be applied get_cls_inst->InsertAfter(load_cls_inst); load_bb->AppendInst(cmp_inst); @@ -126,14 +119,10 @@ Inst *InlineIntrinsics::CreateCompareClassWithDeopt(uint32_t pc, Inst *get_cls_i RuntimeInterface::ClassPtr receiver, Inst *save_state) { auto load_cls_inst = GetGraph()->CreateInstLoadImmediate(DataType::REFERENCE, pc, receiver); - auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_NE); - cmp_inst->SetInput(0, get_cls_inst); - cmp_inst->SetInput(1, load_cls_inst); - cmp_inst->SetOperandsType(DataType::REFERENCE); - auto deopt_inst = GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_IC); - deopt_inst->SetInput(0, cmp_inst); - deopt_inst->SetSaveState(save_state); + auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, get_cls_inst, load_cls_inst, DataType::REFERENCE, + ConditionCode::CC_NE); + auto deopt_inst = + GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, cmp_inst, save_state, DeoptimizeType::INLINE_IC); get_cls_inst->InsertAfter(deopt_inst); get_cls_inst->InsertAfter(cmp_inst); get_cls_inst->InsertAfter(load_cls_inst); @@ -144,11 +133,8 @@ Inst *InsertLoadObject(Inst *input, uint32_t type_id, RuntimeInterface::MethodPt RuntimeInterface::FieldPtr field, ObjectType obj_type, Inst *insert_after, DataType::Type data_type) { - auto load_object = input->GetBasicBlock()->GetGraph()->CreateInstLoadObject(data_type, pc); - load_object->SetInput(0, input); - load_object->SetTypeId(type_id); - load_object->SetMethod(method); - load_object->SetObjField(field); + auto load_object = + input->GetBasicBlock()->GetGraph()->CreateInstLoadObject(data_type, pc, input, type_id, method, field); load_object->SetObjectType(obj_type); insert_after->InsertAfter(load_object); return load_object; @@ -163,13 +149,8 @@ void InsertCheckJSArrayLength(Inst *obj, Inst *index, Inst *insert_after, Runtim auto length = InsertLoadObject(obj, TypeIdMixin::MEM_DYN_ARRAY_LENGTH_ID, method, pc, nullptr, ObjectType::MEM_DYN_ARRAY_LENGTH, insert_after, DataType::INT32); - auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_LT); - auto if_inst = graph->CreateInstIfImm(DataType::BOOL, pc, ConditionCode::CC_NE, 0); - cmp_inst->SetInput(0, index); - cmp_inst->SetInput(1, length); - cmp_inst->SetOperandsType(DataType::INT32); - if_inst->SetInput(0, cmp_inst); - if_inst->SetOperandsType(DataType::BOOL); + auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, pc, index, length, DataType::INT32, ConditionCode::CC_LT); + auto if_inst = graph->CreateInstIfImm(DataType::BOOL, pc, cmp_inst, 0, DataType::BOOL, ConditionCode::CC_NE); length->InsertAfter(cmp_inst); cmp_inst->InsertAfter(if_inst); // Split block by call instruction @@ -179,18 +160,11 @@ void InsertCheckJSArrayLength(Inst *obj, Inst *index, Inst *insert_after, Runtim curr_bb->AddSucc(store_bb); store_bb->AddSucc(curr_cont_bb); // calculate new length - auto add = graph->CreateInstAdd(DataType::INT32, pc); - add->SetInput(0, index); - add->SetInput(1, graph->FindOrCreateConstant(1)); + auto add = graph->CreateInstAdd(DataType::INT32, pc, index, graph->FindOrCreateConstant(1)); // Store new length - auto store_length = graph->CreateInstStoreObject(DataType::INT32, pc); - store_length->SetMethod(method); - store_length->SetObjField(nullptr); - store_length->SetTypeId(TypeIdMixin::MEM_DYN_ARRAY_LENGTH_ID); + auto store_length = graph->CreateInstStoreObject(DataType::INT32, pc, obj, add, + TypeIdMixin::MEM_DYN_ARRAY_LENGTH_ID, method, nullptr); store_length->SetObjectType(ObjectType::MEM_DYN_ARRAY_LENGTH); - store_length->SetInput(0, obj); - store_length->SetInput(1, add); - store_length->SetNeedBarrier(false); store_bb->AppendInst(add); add->InsertAfter(store_length); } @@ -206,14 +180,9 @@ Inst *InsertMemFromFieldInlined(IntrinsicInst *intrinsic, Inst *obj_inst, Inst * ObjectType::MEM_DYN_INLINED, insert_after, DataType::ANY); return load_object; } else { - auto store_object = graph->CreateInstStoreObject(DataType::ANY, pc); - store_object->SetInput(0, obj_inst); - store_object->SetInput(1, intrinsic->GetInput(2).GetInst()); - store_object->SetTypeId(offset); - store_object->SetMethod(save_state->GetMethod()); - store_object->SetObjField(nullptr); + auto store_object = graph->CreateInstStoreObject(DataType::ANY, pc, obj_inst, intrinsic->GetInput(2).GetInst(), + offset, save_state->GetMethod(), nullptr, false, true); store_object->SetObjectType(ObjectType::MEM_DYN_INLINED); - store_object->SetNeedBarrier(true); insert_after->InsertAfter(store_object); return store_object; @@ -223,14 +192,10 @@ Inst *InsertMemFromFieldInlined(IntrinsicInst *intrinsic, Inst *obj_inst, Inst * Inst *InsertBoundsCheck(Inst *array, Inst *index, Inst *save_state, uint32_t pc, Inst *insert_after) { auto graph = array->GetBasicBlock()->GetGraph(); - auto array_length = graph->CreateInstLenArray(DataType::INT32, pc); - array_length->SetInput(0, array); + auto array_length = graph->CreateInstLenArray(DataType::INT32, pc, array); // Create BoundCheck instruction - auto bounds_check = graph->CreateInstBoundsCheck(DataType::INT32, pc); - bounds_check->SetInput(0, array_length); - bounds_check->SetInput(2U, save_state); - bounds_check->SetInput(1, index); + auto bounds_check = graph->CreateInstBoundsCheck(DataType::INT32, pc, array_length, index, save_state); bounds_check->SetFlag(inst_flags::CAN_DEOPTIMIZE); insert_after->InsertAfter(bounds_check); insert_after->InsertAfter(array_length); @@ -257,16 +222,11 @@ Inst *InsertMemFromField(IntrinsicInst *intrinsic, Inst *obj_inst, Inst *insert_ Inst *array = nullptr; if constexpr (IS_LOAD) { - auto load_array = graph->CreateInstLoadArray(DataType::ANY, pc); - load_array->SetInput(0, load_object); - load_array->SetInput(1, index); + auto load_array = graph->CreateInstLoadArray(DataType::ANY, pc, load_object, index); array = load_array; } else { - auto store_array = graph->CreateInstStoreArray(DataType::ANY, pc); - store_array->SetInput(0, load_object); - store_array->SetInput(1, index); - store_array->SetInput(2, intrinsic->GetInput(2).GetInst()); - store_array->SetNeedBarrier(true); + auto store_array = + graph->CreateInstStoreArray(DataType::ANY, pc, load_object, index, intrinsic->GetInput(2).GetInst(), true); array = store_array; } insert_after->InsertAfter(array); @@ -280,14 +240,10 @@ Inst *InsertChangeClassInst(IntrinsicInst *intrinsic, Inst *obj_inst, Inst *inse auto pc = obj_inst->GetPc(); auto klass = reinterpret_cast(klass_addr); auto load_cls_inst = graph->CreateInstLoadImmediate(DataType::REFERENCE, pc, klass); - auto store_class = graph->CreateInstStoreObject(DataType::REFERENCE, pc); - store_class->SetMethod(intrinsic->GetSaveState()->GetMethod()); - store_class->SetObjField(nullptr); - store_class->SetTypeId(TypeIdMixin::MEM_DYN_CLASS_ID); + auto store_class = + graph->CreateInstStoreObject(DataType::REFERENCE, pc, obj_inst, load_cls_inst, TypeIdMixin::MEM_DYN_CLASS_ID, + intrinsic->GetSaveState()->GetMethod(), nullptr, false, true); store_class->SetObjectType(ObjectType::MEM_DYN_CLASS); - store_class->SetInput(0, obj_inst); - store_class->SetInput(1, load_cls_inst); - store_class->SetNeedBarrier(true); insert_after->InsertAfter(store_class); insert_after->InsertAfter(load_cls_inst); return store_class; @@ -315,10 +271,8 @@ Inst *InsertPrototypeCheckInst(IntrinsicInst *intrinsic, uintptr_t proto_mem, In auto is_change = InsertLoadObject(prototype_marker, TypeIdMixin::MEM_DYN_CHANGE_FIELD_ID, save_state->GetMethod(), pc, nullptr, ObjectType::MEM_DYN_CHANGE_FIELD, prototype_marker, DataType::BOOL); - auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_IC); - deopt_inst->SetInput(0, is_change); - deopt_inst->SetSaveState(save_state); + auto deopt_inst = + graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, is_change, save_state, DeoptimizeType::INLINE_IC); is_change->InsertAfter(deopt_inst); @@ -378,10 +332,7 @@ void InsertDeoptimizeInst(uint32_t pc, SaveStateInst *ss, BasicBlock *load_bb) ASSERT(compare_inst != nullptr && compare_inst->GetCc() == ConditionCode::CC_EQ); compare_inst->SetCc(ConditionCode::CC_NE); - auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_IC); - deopt_inst->SetInput(0, compare_inst); - deopt_inst->SetSaveState(ss); + auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, compare_inst, ss, DeoptimizeType::INLINE_IC); load_bb->RemoveInst(if_inst); load_bb->AppendInst(deopt_inst); @@ -450,16 +401,12 @@ Inst *InlineIntrinsics::InsertCheckAndCastInstructions(IntrinsicInst *intrinsic) auto save_state = intrinsic->GetSaveState(); auto obj_inst = intrinsic->GetInput(BY_NAME ? 1 : 0).GetInst(); - auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, pc); - any_check->SetInput(0, obj_inst); - any_check->SetInput(1, save_state); - any_check->SetAnyType(AnyBaseType::ECMASCRIPT_HEAP_OBJECT_TYPE); + auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, pc, obj_inst, save_state, + AnyBaseType::ECMASCRIPT_HEAP_OBJECT_TYPE); intrinsic->InsertBefore(any_check); - auto cast_value = GetGraph()->CreateInstCastAnyTypeValue(DataType::REFERENCE, pc); - cast_value->SetInput(0, any_check); + auto cast_value = GetGraph()->CreateInstCastAnyTypeValue(pc, any_check, AnyBaseType::ECMASCRIPT_HEAP_OBJECT_TYPE); // NOLINTNEXTLINE(readability-magic-numbers) - cast_value->SetAnyType(AnyBaseType::ECMASCRIPT_HEAP_OBJECT_TYPE); cast_value->SetFlag(inst_flags::NO_HOIST); any_check->InsertAfter(cast_value); @@ -550,14 +497,10 @@ void InsertCheckKeyInstructions(IntrinsicInst *intrinsic, uintptr_t key_mem) auto pc = intrinsic->GetPc(); auto save_state = intrinsic->GetSaveState(); auto key_ic = graph->CreateInstLoadObjFromConst(DataType::ANY, pc, key_mem); - auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_NE); - cmp_inst->SetInput(0, key_ic); - cmp_inst->SetInput(1, intrinsic->GetInput(1).GetInst()); - cmp_inst->SetOperandsType(DataType::ANY); - auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_IC); - deopt_inst->SetInput(0, cmp_inst); - deopt_inst->SetSaveState(save_state); + auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, pc, key_ic, intrinsic->GetInput(1).GetInst(), + DataType::ANY, ConditionCode::CC_NE); + auto deopt_inst = + graph->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, cmp_inst, save_state, DeoptimizeType::INLINE_IC); intrinsic->InsertBefore(key_ic); intrinsic->InsertBefore(cmp_inst); intrinsic->InsertBefore(deopt_inst); @@ -605,10 +548,8 @@ void InlineIntrinsics::InlineObjByValueFromElements(IntrinsicInst *intrinsic) // check objects classes with first class from IC auto load_cls_inst = GetGraph()->CreateInstLoadImmediate(DataType::REFERENCE, pc, named_access_profile_[0].klass); - auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_NE); - cmp_inst->SetInput(0, get_cls_inst); - cmp_inst->SetInput(1, load_cls_inst); - cmp_inst->SetOperandsType(DataType::REFERENCE); + auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, get_cls_inst, load_cls_inst, DataType::REFERENCE, + ConditionCode::CC_NE); get_cls_inst->InsertAfter(load_cls_inst); load_cls_inst->InsertAfter(cmp_inst); Inst *deopt_input = cmp_inst; @@ -616,36 +557,26 @@ void InlineIntrinsics::InlineObjByValueFromElements(IntrinsicInst *intrinsic) // check objects classes with second class from IC auto load_cls_inst_1 = GetGraph()->CreateInstLoadImmediate(DataType::REFERENCE, pc, named_access_profile_[1].klass); - auto cmp_inst_1 = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_NE); - cmp_inst_1->SetInput(0, get_cls_inst); - cmp_inst_1->SetInput(1, load_cls_inst_1); - cmp_inst_1->SetOperandsType(DataType::REFERENCE); - auto and_inst = GetGraph()->CreateInstAnd(DataType::BOOL, pc); - and_inst->SetInput(0, cmp_inst); - and_inst->SetInput(1, cmp_inst_1); + auto cmp_inst_1 = GetGraph()->CreateInstCompare(DataType::BOOL, pc, get_cls_inst, load_cls_inst_1, + DataType::REFERENCE, ConditionCode::CC_NE); + auto and_inst = GetGraph()->CreateInstAnd(DataType::BOOL, pc, cmp_inst, cmp_inst_1); deopt_input = and_inst; cmp_inst->InsertAfter(load_cls_inst_1); load_cls_inst_1->InsertAfter(cmp_inst_1); cmp_inst_1->InsertAfter(and_inst); } // Insert deoptimize - auto deopt_inst = GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_IC); - deopt_inst->SetInput(0, deopt_input); - deopt_inst->SetSaveState(save_state); + auto deopt_inst = + GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, deopt_input, save_state, DeoptimizeType::INLINE_IC); deopt_input->InsertAfter(deopt_inst); auto key = intrinsic->GetInput(1).GetInst(); - auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, pc); - any_check->SetInput(0, key); - any_check->SetInput(1, save_state); - any_check->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); + auto any_check = + GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, pc, key, save_state, AnyBaseType::ECMASCRIPT_INT_TYPE); intrinsic->InsertBefore(any_check); - auto cast_value_int = GetGraph()->CreateInstCastAnyTypeValue(DataType::INT32, pc); - cast_value_int->SetInput(0, any_check); + auto cast_value_int = GetGraph()->CreateInstCastAnyTypeValue(pc, any_check, AnyBaseType::ECMASCRIPT_INT_TYPE); // NOLINTNEXTLINE(readability-magic-numbers) - cast_value_int->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); cast_value_int->SetFlag(inst_flags::NO_HOIST); any_check->InsertAfter(cast_value_int); @@ -657,31 +588,23 @@ void InlineIntrinsics::InlineObjByValueFromElements(IntrinsicInst *intrinsic) auto bounds_check = InsertBoundsCheck(load_object, cast_value_int, save_state, pc, load_object); if constexpr (IS_LOAD) { - auto load_array = GetGraph()->CreateInstLoadArray(DataType::ANY, pc); + auto load_array = GetGraph()->CreateInstLoadArray(DataType::ANY, pc, load_object, bounds_check); - load_array->SetInput(0, load_object); - load_array->SetInput(1, bounds_check); intrinsic->ReplaceUsers(load_array); bounds_check->InsertAfter(load_array); - auto cmp_hole_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_EQ); - cmp_hole_inst->SetInput(0, load_array); - cmp_hole_inst->SetInput( - 1, GetGraph()->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE))); - cmp_hole_inst->SetOperandsType(DataType::ANY); + auto cmp_hole_inst = GetGraph()->CreateInstCompare( + DataType::BOOL, pc, load_array, + GetGraph()->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE)), DataType::ANY, + ConditionCode::CC_EQ); load_array->InsertAfter(cmp_hole_inst); - auto deopt_hole_inst = GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_hole_inst->SetDeoptimizeType(DeoptimizeType::HOLE); - deopt_hole_inst->SetInput(0, cmp_hole_inst); - deopt_hole_inst->SetSaveState(save_state); + auto deopt_hole_inst = + GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, cmp_hole_inst, save_state, DeoptimizeType::HOLE); cmp_hole_inst->InsertAfter(deopt_hole_inst); } else { - auto store_array = GetGraph()->CreateInstStoreArray(DataType::ANY, pc); + auto store_array = GetGraph()->CreateInstStoreArray(DataType::ANY, pc, load_object, bounds_check, + intrinsic->GetInput(2).GetInst(), true); - store_array->SetInput(0, load_object); - store_array->SetInput(1, bounds_check); - store_array->SetInput(2, intrinsic->GetInput(2).GetInst()); - store_array->SetNeedBarrier(true); bounds_check->InsertAfter(store_array); if (named_access_profile_[0].type == RuntimeInterface::NamedAccessProfileType::ARRAY_ELEMENT) { InsertCheckJSArrayLength(cast_value, cast_value_int, bounds_check, save_state->GetMethod(), pc); @@ -866,16 +789,12 @@ bool InlineIntrinsics::InlineLdLexDyn(IntrinsicInst *intrinsic) auto pc = intrinsic->GetPc(); auto *hole = GetGraph()->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE)); - auto *compare = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_EQ); - compare->SetOperandsType(DataType::ANY); - compare->SetInput(0U, load_lex_var); - compare->SetInput(1U, hole); + auto *compare = + GetGraph()->CreateInstCompare(DataType::BOOL, pc, load_lex_var, hole, DataType::ANY, ConditionCode::CC_EQ); appender.Append(compare); - auto *deopt_if = GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_if->SetDeoptimizeType(DeoptimizeType::HOLE); - deopt_if->SetInput(0, compare); - deopt_if->SetSaveState(save_state); + auto *deopt_if = + GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, compare, save_state, DeoptimizeType::HOLE); appender.Append(deopt_if); InlineLdLexVarDyn(load_lex_var); @@ -886,13 +805,12 @@ Inst *InlineIntrinsics::GetParentLexEnv(InstAppender *appender, Inst *current_le { auto *runtime = GetGraph()->GetRuntime(); for (; level > 0U; --level) { - auto *load_parent = GetGraph()->CreateInstLoadArray(DataType::ANY, pc); - load_parent->SetInput(0U, current_lex_env); - load_parent->SetInput(1U, GetGraph()->FindOrCreateConstant(runtime->GetLexicalEnvParentEnvIndex())); + auto *load_parent = + GetGraph()->CreateInstLoadArray(DataType::ANY, pc, current_lex_env, + GetGraph()->FindOrCreateConstant(runtime->GetLexicalEnvParentEnvIndex())); appender->Append(load_parent); - auto *parent_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); - parent_ref->SetInput(0U, load_parent); + auto *parent_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, load_parent, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); parent_ref->SetFlag(inst_flags::NO_HOIST); appender->Append(parent_ref); current_lex_env = parent_ref; @@ -919,8 +837,7 @@ bool InlineIntrinsics::InlineStLexDyn(IntrinsicInst *intrinsic) InstAppender appender(intrinsic->GetBasicBlock(), intrinsic); auto pc = intrinsic->GetPc(); - auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); - env_ref->SetInput(0U, store_lex_env); + auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, store_lex_env, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); env_ref->SetFlag(inst_flags::NO_HOIST); appender.Append(env_ref); @@ -933,29 +850,21 @@ bool InlineIntrinsics::InlineStLexDyn(IntrinsicInst *intrinsic) auto save_state = intrinsic->GetSaveState(); ASSERT(save_state != nullptr); - auto *get_prop = GetGraph()->CreateInstLoadArray(DataType::ANY, pc); - get_prop->SetInput(0U, current_lex_env); - get_prop->SetInput(1U, GetGraph()->FindOrCreateConstant(elem_offset)); + auto *get_prop = GetGraph()->CreateInstLoadArray(DataType::ANY, pc, current_lex_env, + GetGraph()->FindOrCreateConstant(elem_offset)); appender.Append(get_prop); auto *hole = GetGraph()->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE)); - auto *compare = GetGraph()->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_EQ); - compare->SetOperandsType(DataType::ANY); - compare->SetInput(0U, get_prop); - compare->SetInput(1U, hole); + auto *compare = + GetGraph()->CreateInstCompare(DataType::BOOL, pc, get_prop, hole, DataType::ANY, ConditionCode::CC_EQ); appender.Append(compare); - auto *deopt_if = GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_if->SetDeoptimizeType(DeoptimizeType::HOLE); - deopt_if->SetInput(0, compare); - deopt_if->SetSaveState(save_state); + auto *deopt_if = + GetGraph()->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, compare, save_state, DeoptimizeType::HOLE); appender.Append(deopt_if); - auto *store_lex_var = GetGraph()->CreateInstStoreArray(DataType::ANY, pc); - store_lex_var->SetNeedBarrier(true); - store_lex_var->SetInput(0U, current_lex_env); - store_lex_var->SetInput(1U, GetGraph()->FindOrCreateConstant(elem_offset)); - store_lex_var->SetInput(2U, store_acc_val); + auto *store_lex_var = GetGraph()->CreateInstStoreArray( + DataType::ANY, pc, current_lex_env, GetGraph()->FindOrCreateConstant(elem_offset), store_acc_val, true); appender.Append(store_lex_var); if (intrinsic->HasUsers()) { @@ -979,8 +888,7 @@ bool InlineIntrinsics::InlineLdLexVarDyn(IntrinsicInst *intrinsic) InstAppender appender(intrinsic->GetBasicBlock(), intrinsic); auto pc = intrinsic->GetPc(); - auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); - env_ref->SetInput(0U, load_lex_env); + auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, load_lex_env, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); env_ref->SetFlag(inst_flags::NO_HOIST); appender.Append(env_ref); @@ -989,9 +897,8 @@ bool InlineIntrinsics::InlineLdLexVarDyn(IntrinsicInst *intrinsic) auto start = GetGraph()->GetRuntime()->GetLexicalEnvStartDataIndex(); auto elem_offset = start + slot; - auto *load_lex_var = GetGraph()->CreateInstLoadArray(DataType::ANY, pc); - load_lex_var->SetInput(0U, current_lex_env); - load_lex_var->SetInput(1U, GetGraph()->FindOrCreateConstant(elem_offset)); + auto *load_lex_var = GetGraph()->CreateInstLoadArray(DataType::ANY, pc, current_lex_env, + GetGraph()->FindOrCreateConstant(elem_offset)); appender.Append(load_lex_var); intrinsic->ReplaceUsers(load_lex_var); @@ -1002,9 +909,7 @@ bool InlineIntrinsics::InlineLdLexVarDyn(IntrinsicInst *intrinsic) bool InlineIntrinsics::InlineLdlexenvDyn([[maybe_unused]] IntrinsicInst *intrinsic) { auto pc = intrinsic->GetPc(); - auto load_lexical_env = GetGraph()->CreateInstLoadLexicalEnv(DataType::ANY, pc); - auto func_obj = intrinsic->GetInput(0).GetInst(); - load_lexical_env->SetInput(0, func_obj); + auto load_lexical_env = GetGraph()->CreateInstLoadLexicalEnv(DataType::ANY, pc, intrinsic->GetInput(0).GetInst()); intrinsic->InsertBefore(load_lexical_env); intrinsic->ReplaceUsers(load_lexical_env); intrinsic->GetBasicBlock()->RemoveInst(intrinsic); @@ -1026,8 +931,7 @@ bool InlineIntrinsics::InlineStLexVarDyn(IntrinsicInst *intrinsic) InstAppender appender(intrinsic->GetBasicBlock(), intrinsic); auto pc = intrinsic->GetPc(); - auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); - env_ref->SetInput(0U, store_lex_env); + auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, store_lex_env, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); env_ref->SetFlag(inst_flags::NO_HOIST); appender.Append(env_ref); @@ -1037,11 +941,8 @@ bool InlineIntrinsics::InlineStLexVarDyn(IntrinsicInst *intrinsic) auto start = GetGraph()->GetRuntime()->GetLexicalEnvStartDataIndex(); auto elem_offset = start + slot; - auto *store_lex_var = GetGraph()->CreateInstStoreArray(DataType::ANY, pc); - store_lex_var->SetNeedBarrier(true); - store_lex_var->SetInput(0U, current_lex_env); - store_lex_var->SetInput(1U, GetGraph()->FindOrCreateConstant(elem_offset)); - store_lex_var->SetInput(2U, store_acc_val); + auto *store_lex_var = GetGraph()->CreateInstStoreArray( + DataType::ANY, pc, current_lex_env, GetGraph()->FindOrCreateConstant(elem_offset), store_acc_val, true); appender.Append(store_lex_var); if (intrinsic->HasUsers()) { @@ -1056,15 +957,14 @@ bool InlineIntrinsics::InlinePopLexenvDyn(IntrinsicInst *intrinsic) InstAppender appender(intrinsic->GetBasicBlock(), intrinsic); auto pc = intrinsic->GetPc(); - auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, AnyBaseType::ECMASCRIPT_ARRAY_TYPE); - env_ref->SetInput(0U, intrinsic->GetInput(0).GetInst()); + auto *env_ref = GetGraph()->CreateInstCastAnyTypeValue(pc, intrinsic->GetInput(0).GetInst(), + AnyBaseType::ECMASCRIPT_ARRAY_TYPE); env_ref->SetFlag(inst_flags::NO_HOIST); appender.Append(env_ref); - auto *load_parent = GetGraph()->CreateInstLoadArray(DataType::ANY, pc); - load_parent->SetInput(0U, env_ref); - load_parent->SetInput(1U, - GetGraph()->FindOrCreateConstant(GetGraph()->GetRuntime()->GetLexicalEnvParentEnvIndex())); + auto *load_parent = GetGraph()->CreateInstLoadArray( + DataType::ANY, pc, env_ref, + GetGraph()->FindOrCreateConstant(GetGraph()->GetRuntime()->GetLexicalEnvParentEnvIndex())); appender.Append(load_parent); intrinsic->ReplaceUsers(load_parent); @@ -1121,29 +1021,18 @@ void InlineIntrinsics::InlineTryLdGlobalField(IntrinsicInst *inst, uint32_t type auto pc = inst->GetPc(); auto save_state = inst->GetSaveState(); - auto get_address = GetGraph()->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc, address); - get_address->SetTypeId(type_id); - get_address->SetMethod(GetGraph()->GetMethod()); - get_address->SetInput(0, inst->GetInput(2).GetInst()); - get_address->SetInput(1, save_state); + auto get_address = GetGraph()->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc, inst->GetInput(2).GetInst(), + save_state, type_id, GetGraph()->GetMethod(), address); inst->InsertBefore(get_address); - auto load_object = GetGraph()->CreateInstLoadObject(DataType::ANY, pc); - load_object->SetTypeId(TypeIdMixin::MEM_DYN_GLOBAL_ID); - load_object->SetMethod(GetGraph()->GetMethod()); - load_object->SetObjField(nullptr); + auto load_object = GetGraph()->CreateInstLoadObject(DataType::ANY, pc, get_address, TypeIdMixin::MEM_DYN_GLOBAL_ID, + GetGraph()->GetMethod(), nullptr); load_object->SetObjectType(ObjectType::MEM_DYN_GLOBAL); - load_object->SetInput(0, get_address); inst->InsertBefore(load_object); if constexpr (NEED_GUARD) { - auto cmp = GetGraph()->CreateInstCompareAnyType(DataType::BOOL, pc); - cmp->SetAnyType(AnyBaseType::ECMASCRIPT_HOLE_TYPE); - cmp->SetInput(0, load_object); - auto deopt = GetGraph()->CreateInstDeoptimizeIf(DataType::BOOL, pc); - deopt->SetInput(0, cmp); - deopt->SetInput(1, save_state); - deopt->SetDeoptimizeType(DeoptimizeType::INLINE_IC); + auto cmp = GetGraph()->CreateInstCompareAnyType(pc, load_object, AnyBaseType::ECMASCRIPT_HOLE_TYPE); + auto deopt = GetGraph()->CreateInstDeoptimizeIf(DataType::BOOL, pc, cmp, save_state, DeoptimizeType::INLINE_IC); inst->InsertBefore(cmp); inst->InsertBefore(deopt); } diff --git a/compiler/intrinsics_inline_ecmascript.inl.h b/compiler/intrinsics_inline_ecmascript.inl.h index 17d80f298..294a66fca 100644 --- a/compiler/intrinsics_inline_ecmascript.inl.h +++ b/compiler/intrinsics_inline_ecmascript.inl.h @@ -83,4 +83,4 @@ bool InlineTryLdGlobalByName(IntrinsicInst *inst); template void InlineTryLdGlobalField(IntrinsicInst *inst, uint32_t type_id, uintptr_t address); -#endif // PLUGINS_ECMASCRIPT_COMPILER_INLINE_INTRINSICS_ECMASCRIPT_INL_H \ No newline at end of file +#endif // PLUGINS_ECMASCRIPT_COMPILER_INLINE_INTRINSICS_ECMASCRIPT_INL_H diff --git a/compiler/optimizer/ir_builder/ecmascript_inst_builder.cpp b/compiler/optimizer/ir_builder/ecmascript_inst_builder.cpp index e4ece81b6..7ef89696e 100644 --- a/compiler/optimizer/ir_builder/ecmascript_inst_builder.cpp +++ b/compiler/optimizer/ir_builder/ecmascript_inst_builder.cpp @@ -57,26 +57,18 @@ void InstBuilder::BuildEcmaFnCall(const BytecodeInstruction *bc_inst, bool is_ra callee = type_check; { // Load class (it is movable object in js) - auto load_class = GetGraph()->CreateInstLoadObject(DataType::REFERENCE, bc_pc); - load_class->SetMethod(GetGraph()->GetMethod()); - load_class->SetObjField(nullptr); - load_class->SetTypeId(TypeIdMixin::MEM_DYN_CLASS_ID); + auto load_class = GetGraph()->CreateInstLoadObject( + DataType::REFERENCE, bc_pc, callee, TypeIdMixin::MEM_DYN_CLASS_ID, GetGraph()->GetMethod(), nullptr); load_class->SetObjectType(ObjectType::MEM_DYN_CLASS); - load_class->SetInput(0, callee); AddInstruction(load_class); // Load Jshclass - auto load_hclass = GetGraph()->CreateInstLoadObject(DataType::REFERENCE, bc_pc); - load_hclass->SetMethod(GetGraph()->GetMethod()); - load_hclass->SetObjField(nullptr); - load_hclass->SetTypeId(TypeIdMixin::MEM_DYN_HCLASS_ID); + auto load_hclass = GetGraph()->CreateInstLoadObject( + DataType::REFERENCE, bc_pc, load_class, TypeIdMixin::MEM_DYN_HCLASS_ID, GetGraph()->GetMethod(), nullptr); load_hclass->SetObjectType(ObjectType::MEM_DYN_HCLASS); - load_hclass->SetInput(0, load_class); AddInstruction(load_hclass); - auto hclass_check = GetGraph()->CreateInstHclassCheck(DataType::NO_TYPE, bc_pc); - hclass_check->SetInput(0, load_hclass); - hclass_check->SetInput(1, save_state); + auto hclass_check = GetGraph()->CreateInstHclassCheck(DataType::NO_TYPE, bc_pc, load_hclass, save_state); hclass_check->SetCheckIsFunction(true); hclass_check->SetCheckFunctionIsNotClassConstructor(true); AddInstruction(hclass_check); @@ -143,8 +135,8 @@ void InstBuilder::BuildEcmaNewobjdynrange(const BytecodeInstruction *bc_inst) auto bc_pc = GetPc(bc_inst->GetAddress()); auto start_reg = bc_inst->GetVReg(0); - auto inst = graph->CreateInstIntrinsic(DataType::ANY, bc_pc); - inst->SetIntrinsicId(RuntimeInterface::IntrinsicId::INTRINSIC_NEWOBJ_DYNRANGE_HANDLED); + auto inst = graph->CreateInstIntrinsic(DataType::ANY, bc_pc, + RuntimeInterface::IntrinsicId::INTRINSIC_NEWOBJ_DYNRANGE_HANDLED); AdjustFlags(inst->GetIntrinsicId(), inst); inst->SetFlag(inst_flags::CAN_THROW); @@ -202,8 +194,8 @@ void InstBuilder::BuildEcmaGetunmappedargs(const BytecodeInstruction *bc_inst) curr_inst = curr_inst->GetPrev(); } auto bc_pc = GetPc(bc_inst->GetAddress()); - auto inst = graph->CreateInstIntrinsic(DataType::ANY, bc_pc); - inst->SetIntrinsicId(RuntimeInterface::IntrinsicId::INTRINSIC_GET_UNMAPPED_ARGS); + auto inst = + graph->CreateInstIntrinsic(DataType::ANY, bc_pc, RuntimeInterface::IntrinsicId::INTRINSIC_GET_UNMAPPED_ARGS); AdjustFlags(inst->GetIntrinsicId(), inst); inst->SetFlag(inst_flags::CAN_THROW); @@ -237,20 +229,13 @@ void InstBuilder::BuildStGlobalVar(const BytecodeInstruction *bc_inst, size_t ty { auto pc = GetPc(bc_inst->GetAddress()); auto save_state = CreateSaveState(Opcode::SaveState, pc); - auto get_address = graph_->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc); - - get_address->SetTypeId(type_id); - get_address->SetMethod(GetGraph()->GetMethod()); - get_address->SetInput(0, GetEnvDefinition(CONST_POOL_IDX)); - get_address->SetInput(1, save_state); - - auto store_object = graph_->CreateInstStoreObject(DataType::ANY, pc); - store_object->SetTypeId(TypeIdMixin::MEM_DYN_GLOBAL_ID); - store_object->SetMethod(GetGraph()->GetMethod()); - store_object->SetObjField(nullptr); - store_object->SetNeedBarrier(true); + auto get_address = graph_->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc, GetEnvDefinition(CONST_POOL_IDX), + save_state, type_id, GetGraph()->GetMethod(), 0); + + auto store_object = + graph_->CreateInstStoreObject(DataType::ANY, pc, get_address, nullptr, TypeIdMixin::MEM_DYN_GLOBAL_ID, + GetGraph()->GetMethod(), nullptr, false, true); store_object->SetObjectType(ObjectType::MEM_DYN_GLOBAL); - store_object->SetInput(0, get_address); Inst *store_val = nullptr; if constexpr (IS_ACC_READ) { store_val = GetDefinitionAcc(); @@ -269,19 +254,12 @@ void InstBuilder::BuildLdGlobalVar(const BytecodeInstruction *bc_inst, size_t ty { auto pc = GetPc(bc_inst->GetAddress()); auto save_state = CreateSaveState(Opcode::SaveState, pc); - auto get_address = graph_->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc); - - get_address->SetTypeId(type_id); - get_address->SetMethod(GetGraph()->GetMethod()); - get_address->SetInput(0, GetEnvDefinition(CONST_POOL_IDX)); - get_address->SetInput(1, save_state); + auto get_address = graph_->CreateInstGetGlobalVarAddress(DataType::REFERENCE, pc, GetEnvDefinition(CONST_POOL_IDX), + save_state, type_id, GetGraph()->GetMethod(), 0); - auto load_object = graph_->CreateInstLoadObject(DataType::ANY, pc); - load_object->SetTypeId(TypeIdMixin::MEM_DYN_GLOBAL_ID); - load_object->SetMethod(GetGraph()->GetMethod()); - load_object->SetObjField(nullptr); + auto load_object = graph_->CreateInstLoadObject(DataType::ANY, pc, get_address, TypeIdMixin::MEM_DYN_GLOBAL_ID, + GetGraph()->GetMethod(), nullptr); load_object->SetObjectType(ObjectType::MEM_DYN_GLOBAL); - load_object->SetInput(0, get_address); AddInstruction(save_state); AddInstruction(get_address); AddInstruction(load_object); @@ -316,16 +294,11 @@ void InstBuilder::BuildLdObjByIndex(const BytecodeInstruction *bc_inst, uint64_t void InstBuilder::BuildLdStObjByIndex(const BytecodeInstruction *bc_inst, Inst *obj_inst, uint64_t imm, Inst *store_def) { auto pc = GetPc(bc_inst->GetAddress()); - auto check_obj = graph_->CreateInstObjByIndexCheck(DataType::ANY, pc); + auto check_obj = graph_->CreateInstObjByIndexCheck(DataType::ANY, pc, obj_inst, nullptr); - check_obj->SetInput(0, obj_inst); - - auto load_object = graph_->CreateInstLoadObject(DataType::REFERENCE, pc); - load_object->SetMethod(GetGraph()->GetMethod()); - load_object->SetObjField(nullptr); - load_object->SetTypeId(TypeIdMixin::MEM_DYN_ELEMENTS_ID); + auto load_object = graph_->CreateInstLoadObject(DataType::REFERENCE, pc, check_obj, + TypeIdMixin::MEM_DYN_ELEMENTS_ID, GetGraph()->GetMethod(), nullptr); load_object->SetObjectType(ObjectType::MEM_DYN_ELEMENTS); - load_object->SetInput(0, check_obj); Inst *save_state = nullptr; Inst *null_check = nullptr; @@ -337,30 +310,20 @@ void InstBuilder::BuildLdStObjByIndex(const BytecodeInstruction *bc_inst, Inst * check_obj->SetInput(1, save_state); // Create instruction - auto inst = graph_->CreateInstLoadArray(DataType::ANY, pc); + auto inst = graph_->CreateInstLoadArray(DataType::ANY, pc, null_check, bounds_check); bounds_check->SetInput(1, FindOrCreateConstant(imm)); bounds_check->SetFlag(inst_flags::CAN_DEOPTIMIZE); - inst->SetInput(0, null_check); - inst->SetInput(1, bounds_check); - - auto cmp_inst = graph_->CreateInstCompare(DataType::BOOL, pc, ConditionCode::CC_EQ); - cmp_inst->SetInput(0, inst); - cmp_inst->SetInput(1, graph_->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE))); - cmp_inst->SetOperandsType(DataType::ANY); - auto deopt_inst = graph_->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc); - deopt_inst->SetDeoptimizeType(DeoptimizeType::HOLE); - deopt_inst->SetInput(0, cmp_inst); - deopt_inst->SetSaveState(save_state); + auto cmp_inst = graph_->CreateInstCompare( + DataType::BOOL, pc, inst, + graph_->FindOrCreateConstant(DataType::Any(panda::coretypes::TaggedValue::VALUE_HOLE)), DataType::ANY, + ConditionCode::CC_EQ); + auto deopt_inst = graph_->CreateInstDeoptimizeIf(DataType::NO_TYPE, pc, cmp_inst, save_state, DeoptimizeType::HOLE); AddInstruction(save_state, check_obj, load_object, array_length, bounds_check, inst, cmp_inst, deopt_inst); if (store_def != nullptr) { - auto store = graph_->CreateInstStoreArray(DataType::ANY, pc); - store->SetInput(0, load_object); - store->SetInput(1, bounds_check); - store->SetInput(2U, store_def); - store->SetNeedBarrier(true); + auto store = graph_->CreateInstStoreArray(DataType::ANY, pc, load_object, bounds_check, store_def, true); AddInstruction(store); } else { UpdateDefinitionAcc(inst); diff --git a/compiler/optimizer/ir_builder/ecmascript_inst_templates.yaml b/compiler/optimizer/ir_builder/ecmascript_inst_templates.yaml index 46c3dba2e..b15dbbd2c 100644 --- a/compiler/optimizer/ir_builder/ecmascript_inst_templates.yaml +++ b/compiler/optimizer/ir_builder/ecmascript_inst_templates.yaml @@ -4,31 +4,20 @@ % when "RETURNUNDEFINED" auto cvat_input = FindOrCreateConstant(0); cvat_input->SetType(DataType::Type::INT64); - auto cvat = graph_->CreateInstCastValueToAnyType(0); - cvat->SetAnyType(panda::compiler::AnyBaseType::ECMASCRIPT_UNDEFINED_TYPE); - cvat->SetInput(0, cvat_input); - auto inst = graph_->CreateInstReturn(DataType::ANY, GetPc(instruction->GetAddress())); - inst->SetInput(0, cvat); + auto cvat = graph_->CreateInstCastValueToAnyType(0, panda::compiler::AnyBaseType::ECMASCRIPT_UNDEFINED_TYPE, cvat_input); + auto inst = graph_->CreateInstReturn(DataType::ANY, GetPc(instruction->GetAddress()), cvat); AddInstruction(cvat); AddInstruction(inst); % when "RETURN" - auto inst = graph_->CreateInstReturn(DataType::ANY, GetPc(instruction->GetAddress())); - inst->SetInput(0, GetDefinitionAcc()); + auto inst = graph_->CreateInstReturn(DataType::ANY, GetPc(instruction->GetAddress()), GetDefinitionAcc()); AddInstruction(inst); % when "JFALSE", "JTRUE" % cmp_imm = name == "JFALSE" ? 0 : 1 auto cvat_input = FindOrCreateConstant(<%= cmp_imm %>); cvat_input->SetType(DataType::INT64); - auto cvat = graph_->CreateInstCastValueToAnyType(0); - cvat->SetAnyType(panda::compiler::AnyBaseType::ECMASCRIPT_BOOLEAN_TYPE); - cvat->SetInput(0, cvat_input); - auto cmp_inst = graph_->CreateInstCompare(DataType::BOOL, GetPc(instruction->GetAddress()), ConditionCode::CC_EQ); - cmp_inst->SetOperandsType(DataType::ANY); - cmp_inst->SetInput(0, GetDefinitionAcc()); - cmp_inst->SetInput(1, cvat); - auto jmp_inst = graph_->CreateInstIfImm(DataType::NO_TYPE, GetPc(instruction->GetAddress()), ConditionCode::CC_NE, 0); - jmp_inst->SetOperandsType(DataType::BOOL); - jmp_inst->SetInput(0, cmp_inst); + auto cvat = graph_->CreateInstCastValueToAnyType(0, panda::compiler::AnyBaseType::ECMASCRIPT_BOOLEAN_TYPE, cvat_input); + auto cmp_inst = graph_->CreateInstCompare(DataType::BOOL, GetPc(instruction->GetAddress()), GetDefinitionAcc(), cvat, DataType::ANY, ConditionCode::CC_EQ); + auto jmp_inst = graph_->CreateInstIfImm(DataType::NO_TYPE, GetPc(instruction->GetAddress()), cmp_inst, 0, DataType::BOOL, ConditionCode::CC_NE); AddInstruction(cvat); AddInstruction(cmp_inst); AddInstruction(jmp_inst); diff --git a/compiler/optimizer/optimizations/ecma_inlining.cpp b/compiler/optimizer/optimizations/ecma_inlining.cpp index 593cec8e4..1f892fc78 100644 --- a/compiler/optimizer/optimizations/ecma_inlining.cpp +++ b/compiler/optimizer/optimizations/ecma_inlining.cpp @@ -155,19 +155,14 @@ void EcmaInlining::BuildGuard(CallInst *call_inst, RuntimeInterface::MethodPtr m auto graph = call_inst->GetBasicBlock()->GetGraph(); auto method_cnst = graph->CreateInstLoadImmediate(DataType::POINTER, call_inst->GetPc(), method_ptr, LoadImmediateInst::ObjectType::METHOD); - auto load_method = graph->CreateInstLoadObject(DataType::POINTER, call_inst->GetPc()); + auto load_method = + graph->CreateInstLoadObject(DataType::POINTER, call_inst->GetPc(), call_inst->GetInput(0).GetInst(), + TypeIdMixin::MEM_DYN_METHOD_ID, nullptr, nullptr); load_method->SetObjectType(ObjectType::MEM_DYN_METHOD); - load_method->SetTypeId(TypeIdMixin::MEM_DYN_METHOD_ID); - load_method->SetInput(0, call_inst->GetInput(0).GetInst()); - auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, call_inst->GetPc()); - auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::BOOL, call_inst->GetPc()); - cmp_inst->SetCc(ConditionCode::CC_NE); - cmp_inst->SetInput(0, load_method); - cmp_inst->SetInput(1, method_cnst); - cmp_inst->SetOperandsType(DataType::POINTER); - deopt_inst->SetInput(0, cmp_inst); - deopt_inst->SetInput(1, call_inst->GetSaveState()); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_DYN); + auto cmp_inst = graph->CreateInstCompare(DataType::BOOL, call_inst->GetPc(), load_method, method_cnst, + DataType::POINTER, ConditionCode::CC_NE); + auto deopt_inst = graph->CreateInstDeoptimizeIf(DataType::BOOL, call_inst->GetPc(), cmp_inst, + call_inst->GetSaveState(), DeoptimizeType::INLINE_DYN); call_inst->InsertBefore(method_cnst); call_inst->InsertBefore(load_method); call_inst->InsertBefore(cmp_inst); @@ -243,18 +238,14 @@ void EcmaInlining::CreateCompareFunctions(CallInst *call_inst, RuntimeInterface: { auto method_cnst = GetGraph()->CreateInstLoadImmediate(DataType::POINTER, call_inst->GetPc(), method_ptr, LoadImmediateInst::ObjectType::METHOD); - auto load_method = GetGraph()->CreateInstLoadObject(DataType::POINTER, call_inst->GetPc()); + auto load_method = + GetGraph()->CreateInstLoadObject(DataType::POINTER, call_inst->GetPc(), call_inst->GetInput(0).GetInst(), + TypeIdMixin::MEM_DYN_METHOD_ID, nullptr, nullptr); load_method->SetObjectType(ObjectType::MEM_DYN_METHOD); - load_method->SetTypeId(TypeIdMixin::MEM_DYN_METHOD_ID); - load_method->SetInput(0, call_inst->GetInput(0).GetInst()); - auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, call_inst->GetPc()); - auto if_inst = GetGraph()->CreateInstIfImm(DataType::BOOL, call_inst->GetPc(), ConditionCode::CC_NE, 0); - cmp_inst->SetCc(ConditionCode::CC_EQ); - cmp_inst->SetInput(0, load_method); - cmp_inst->SetInput(1, method_cnst); - cmp_inst->SetOperandsType(DataType::POINTER); - if_inst->SetInput(0, cmp_inst); - if_inst->SetOperandsType(DataType::BOOL); + auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, call_inst->GetPc(), load_method, method_cnst, + DataType::POINTER, ConditionCode::CC_EQ); + auto if_inst = GetGraph()->CreateInstIfImm(DataType::BOOL, call_inst->GetPc(), cmp_inst, 0, DataType::BOOL, + ConditionCode::CC_NE); call_bb->AppendInst(method_cnst); call_bb->AppendInst(load_method); call_bb->AppendInst(cmp_inst); diff --git a/compiler/optimizer/optimizations/inline_call_intrinsics.cpp b/compiler/optimizer/optimizations/inline_call_intrinsics.cpp index e3f114469..bfdc1f08f 100644 --- a/compiler/optimizer/optimizations/inline_call_intrinsics.cpp +++ b/compiler/optimizer/optimizations/inline_call_intrinsics.cpp @@ -89,14 +89,9 @@ Inst *InlineCallIntrinsics::NewObjCreateConstructorCall(Inst *orig_call, Inst *a void InlineCallIntrinsics::NewObjFillCurrBlock(InstAppender *appender, Inst *alloc_obj, uint32_t pc) { - auto cmp = GetGraph()->CreateInstCompareAnyType(DataType::BOOL, pc); - cmp->SetAnyType(AnyBaseType::ECMASCRIPT_NULL_TYPE); - cmp->SetInput(0, alloc_obj); + auto cmp = GetGraph()->CreateInstCompareAnyType(pc, alloc_obj, AnyBaseType::ECMASCRIPT_NULL_TYPE); // if alloc returned null -> jump into a slow path - auto ifimm = GetGraph()->CreateInstIfImm(DataType::BOOL, pc, ConditionCode::CC_NE, 0); - ifimm->SetOperandsType(DataType::BOOL); - ifimm->SetInput(0, cmp); - + auto ifimm = GetGraph()->CreateInstIfImm(DataType::BOOL, pc, cmp, 0, DataType::BOOL, ConditionCode::CC_NE); appender->Append({cmp, ifimm}); } @@ -301,15 +296,10 @@ void InlineCallIntrinsics::BuildGuard(Inst *inst, uintptr_t target) { auto pc = inst->GetPc(); auto load_function = GetGraph()->CreateInstFunctionImmediate(DataType::ANY, pc, target); - auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc); - auto deopt_inst = GetGraph()->CreateInstDeoptimizeIf(DataType::BOOL, pc); - cmp_inst->SetCc(ConditionCode::CC_NE); - cmp_inst->SetInput(0, load_function); - cmp_inst->SetInput(1, inst->GetInput(1).GetInst()); - cmp_inst->SetOperandsType(DataType::ANY); - deopt_inst->SetInput(0, cmp_inst); - deopt_inst->SetInput(1, inst->GetSaveState()); - deopt_inst->SetDeoptimizeType(DeoptimizeType::INLINE_DYN); + auto cmp_inst = GetGraph()->CreateInstCompare(DataType::BOOL, pc, load_function, inst->GetInput(1).GetInst(), + DataType::ANY, ConditionCode::CC_NE); + auto deopt_inst = GetGraph()->CreateInstDeoptimizeIf(DataType::BOOL, pc, cmp_inst, inst->GetSaveState(), + DeoptimizeType::INLINE_DYN); auto save_state = inst->GetSaveState(); ASSERT(save_state); diff --git a/irtoc_scripts/common.irt b/irtoc_scripts/common.irt index c71086cc5..511b1ad23 100644 --- a/irtoc_scripts/common.irt +++ b/irtoc_scripts/common.irt @@ -275,4 +275,4 @@ end macro(:cmpanycallable) do |arg| CompareAnyType(arg).AnyType("AnyBaseType::ECMASCRIPT_CALLABLE_TYPE").b -end \ No newline at end of file +end diff --git a/runtime/builtins/templates/builtins.rb b/runtime/builtins/templates/builtins.rb index c6aa9ce48..c329ca755 100644 --- a/runtime/builtins/templates/builtins.rb +++ b/runtime/builtins/templates/builtins.rb @@ -230,9 +230,7 @@ class InlinableDescr str += " call_inst->InsertAfter(inlined); - auto cast_to_any_inst = GetGraph()->CreateInstCastValueToAnyType(DataType::ANY, call_inst->GetPc()); - cast_to_any_inst->SetAnyType(AnyBaseType::#{@res_type}); - cast_to_any_inst->SetInput(0, inlined); + auto cast_to_any_inst = GetGraph()->CreateInstCastValueToAnyType(call_inst->GetPc(), AnyBaseType::#{@res_type}, inlined); call_inst->ReplaceUsers(cast_to_any_inst); inlined->InsertAfter(cast_to_any_inst); call_inst->GetBasicBlock()->RemoveInst(call_inst); diff --git a/runtime/builtins/templates/builtins_inline_intrinsics_gen.inl.erb b/runtime/builtins/templates/builtins_inline_intrinsics_gen.inl.erb index c61128023..fc020053f 100644 --- a/runtime/builtins/templates/builtins_inline_intrinsics_gen.inl.erb +++ b/runtime/builtins/templates/builtins_inline_intrinsics_gen.inl.erb @@ -49,35 +49,24 @@ void InlineIntrinsics::ResolveInputs(AnyBaseType type, CallInst *call_inst) if (type == AnyBaseType::ECMASCRIPT_DOUBLE_TYPE) { for (size_t i = 0; i < types_.size(); i++) { if (types_[i] == AnyBaseType::ECMASCRIPT_INT_TYPE) { - auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc()); - any_check->SetInput(0, saved_inputs_[i]); - any_check->SetInput(1, call_inst->GetSaveState()); - any_check->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); + auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc(), saved_inputs_[i], call_inst->GetSaveState(), AnyBaseType::ECMASCRIPT_INT_TYPE); call_inst->InsertBefore(any_check); - auto cati = GetGraph()->CreateInstCastAnyTypeValue(AnyBaseTypeToDataType(AnyBaseType::ECMASCRIPT_INT_TYPE), call_inst->GetPc()); - cati->SetInput(0, any_check); - cati->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); + auto cati = GetGraph()->CreateInstCastAnyTypeValue(call_inst->GetPc(), any_check, AnyBaseType::ECMASCRIPT_INT_TYPE); call_inst->InsertBefore(cati); - auto cast = GetGraph()->CreateInstCast(AnyBaseTypeToDataType(AnyBaseType::ECMASCRIPT_DOUBLE_TYPE), call_inst->GetPc()); - cast->SetInput(0, cati); + auto cast = GetGraph()->CreateInstCast(AnyBaseTypeToDataType(AnyBaseType::ECMASCRIPT_DOUBLE_TYPE), call_inst->GetPc(), cati, DataType::NO_TYPE); call_inst->InsertBefore(cast); saved_inputs_[i] = cast; } else if ((types_[i] == AnyBaseType::ECMASCRIPT_DOUBLE_TYPE) || (types_[i] == AnyBaseType::UNDEFINED_TYPE)) { - auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc()); - any_check->SetInput(0, saved_inputs_[i]); - any_check->SetInput(1, call_inst->GetSaveState()); - any_check->SetAnyType(AnyBaseType::ECMASCRIPT_DOUBLE_TYPE); + auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc(), saved_inputs_[i], call_inst->GetSaveState(), AnyBaseType::ECMASCRIPT_DOUBLE_TYPE); if (saved_inputs_[i]->GetOpcode() == Opcode::AnyTypeCheck) { any_check->SetAllowedInputType(saved_inputs_[i]->CastToAnyTypeCheck()->GetAllowedInputType()); any_check->SetIsIntegerWasSeen(saved_inputs_[i]->CastToAnyTypeCheck()->IsIntegerWasSeen()); } call_inst->InsertBefore(any_check); - auto cati = GetGraph()->CreateInstCastAnyTypeValue(AnyBaseTypeToDataType(AnyBaseType::ECMASCRIPT_DOUBLE_TYPE), call_inst->GetPc()); - cati->SetInput(0, any_check); - cati->SetAnyType(AnyBaseType::ECMASCRIPT_DOUBLE_TYPE); + auto cati = GetGraph()->CreateInstCastAnyTypeValue(call_inst->GetPc(), any_check, AnyBaseType::ECMASCRIPT_DOUBLE_TYPE); call_inst->InsertBefore(cati); saved_inputs_[i] = cati; } else { @@ -87,15 +76,10 @@ void InlineIntrinsics::ResolveInputs(AnyBaseType type, CallInst *call_inst) } else if (type == AnyBaseType::ECMASCRIPT_INT_TYPE) { for (size_t i = 0; i < types_.size(); i++) { if ((types_[i] == AnyBaseType::ECMASCRIPT_INT_TYPE) || (types_[i] == AnyBaseType::UNDEFINED_TYPE)) { - auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc()); - any_check->SetInput(0, saved_inputs_[i]); - any_check->SetInput(1, call_inst->GetSaveState()); - any_check->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); + auto any_check = GetGraph()->CreateInstAnyTypeCheck(DataType::ANY, call_inst->GetPc(), saved_inputs_[i], call_inst->GetSaveState(), AnyBaseType::ECMASCRIPT_INT_TYPE); call_inst->InsertBefore(any_check); - auto cati = GetGraph()->CreateInstCastAnyTypeValue(AnyBaseTypeToDataType(AnyBaseType::ECMASCRIPT_INT_TYPE), call_inst->GetPc()); - cati->SetInput(0, any_check); - cati->SetAnyType(AnyBaseType::ECMASCRIPT_INT_TYPE); + auto cati = GetGraph()->CreateInstCastAnyTypeValue(call_inst->GetPc(), any_check, AnyBaseType::ECMASCRIPT_INT_TYPE); call_inst->InsertBefore(cati); saved_inputs_[i] = cati; } else { -- Gitee