Skip to content

Commit 02f5faa

Browse files
sstricklcommit-bot@chromium.org
sstrickl
authored and
[email protected]
committed
[vm/compiler] Prepare InstantiateTypeArguments for dynamic type args.
Current users of InstantiateTypeArguments have the uninstantiated type arguments available at compile time. After upcoming work on #40813, there are cases where the generated code needs to instantiate type arguments that are only available at runtime. This work changes the uninstantiated type arguments for the InstantiateTypeArguments instruction to a runtime Value pointer instead of a compile time TypeArguments reference. The changes beyond that are limited to only what is needed to get current uses working, with ASSERTs checking that current invariants still hold. The rest of the changes needed for dynamic uninstantiated type arguments will come later. Bug: #40813 Cq-Include-Trybots: luci.dart.try:vm-kernel-linux-release-x64-try,vm-kernel-precomp-linux-product-x64-try,vm-kernel-linux-debug-x64-try,vm-kernel-precomp-linux-release-simarm_x64-try,vm-kernel-linux-release-simarm-try,vm-kernel-linux-release-simarm64-try Change-Id: Iafe836cfd8744d3e835e60112a4f099e631f4782 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/162183 Reviewed-by: Martin Kustermann <[email protected]> Commit-Queue: Tess Strickland <[email protected]>
1 parent e78a7cc commit 02f5faa

File tree

9 files changed

+111
-57
lines changed

9 files changed

+111
-57
lines changed

‎runtime/vm/compiler/backend/constant_propagator.cc

Lines changed: 25 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1034,9 +1034,23 @@ void ConstantPropagator::VisitInstantiateType(InstantiateTypeInstr* instr) {
10341034

10351035
void ConstantPropagator::VisitInstantiateTypeArguments(
10361036
InstantiateTypeArgumentsInstr* instr) {
1037-
TypeArguments& instantiator_type_args = TypeArguments::Handle(Z);
1038-
TypeArguments& function_type_args = TypeArguments::Handle(Z);
1039-
if (!instr->type_arguments().IsInstantiated(kCurrentClass)) {
1037+
const auto& type_arguments_obj =
1038+
instr->type_arguments()->definition()->constant_value();
1039+
if (!IsConstant(type_arguments_obj)) {
1040+
if (IsNonConstant(type_arguments_obj)) {
1041+
SetValue(instr, non_constant_);
1042+
}
1043+
return;
1044+
}
1045+
ASSERT(!type_arguments_obj.IsNull());
1046+
const auto& type_arguments = TypeArguments::Cast(type_arguments_obj);
1047+
if (type_arguments.IsInstantiated()) {
1048+
ASSERT(type_arguments.IsCanonical());
1049+
SetValue(instr, type_arguments);
1050+
return;
1051+
}
1052+
auto& instantiator_type_args = TypeArguments::Handle(Z);
1053+
if (!type_arguments.IsInstantiated(kCurrentClass)) {
10401054
// Type arguments refer to class type parameters.
10411055
const Object& instantiator_type_args_obj =
10421056
instr->instantiator_type_arguments()->definition()->constant_value();
@@ -1046,7 +1060,8 @@ void ConstantPropagator::VisitInstantiateTypeArguments(
10461060
}
10471061
if (IsConstant(instantiator_type_args_obj)) {
10481062
instantiator_type_args ^= instantiator_type_args_obj.raw();
1049-
if (instr->type_arguments().CanShareInstantiatorTypeArguments(
1063+
ASSERT(!instr->instantiator_class().IsNull());
1064+
if (type_arguments.CanShareInstantiatorTypeArguments(
10501065
instr->instantiator_class())) {
10511066
SetValue(instr, instantiator_type_args);
10521067
return;
@@ -1055,7 +1070,8 @@ void ConstantPropagator::VisitInstantiateTypeArguments(
10551070
return;
10561071
}
10571072
}
1058-
if (!instr->type_arguments().IsInstantiated(kFunctions)) {
1073+
auto& function_type_args = TypeArguments::Handle(Z);
1074+
if (!type_arguments.IsInstantiated(kFunctions)) {
10591075
// Type arguments refer to function type parameters.
10601076
const Object& function_type_args_obj =
10611077
instr->function_type_arguments()->definition()->constant_value();
@@ -1065,17 +1081,17 @@ void ConstantPropagator::VisitInstantiateTypeArguments(
10651081
}
10661082
if (IsConstant(function_type_args_obj)) {
10671083
function_type_args ^= function_type_args_obj.raw();
1068-
if (instr->type_arguments().CanShareFunctionTypeArguments(
1069-
instr->function())) {
1084+
ASSERT(!instr->function().IsNull());
1085+
if (type_arguments.CanShareFunctionTypeArguments(instr->function())) {
10701086
SetValue(instr, function_type_args);
10711087
return;
10721088
}
10731089
} else {
10741090
return;
10751091
}
10761092
}
1077-
TypeArguments& result = TypeArguments::Handle(
1078-
Z, instr->type_arguments().InstantiateFrom(
1093+
auto& result = TypeArguments::Handle(
1094+
Z, type_arguments.InstantiateFrom(
10791095
instantiator_type_args, function_type_args, kAllFree, Heap::kOld));
10801096
ASSERT(result.IsInstantiated());
10811097
result = result.Canonicalize();

‎runtime/vm/compiler/backend/il.h

Lines changed: 23 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -6497,32 +6497,38 @@ class InstantiateTypeInstr : public TemplateDefinition<2, Throws> {
64976497
DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
64986498
};
64996499

6500-
class InstantiateTypeArgumentsInstr : public TemplateDefinition<2, Throws> {
6500+
class InstantiateTypeArgumentsInstr : public TemplateDefinition<3, Throws> {
65016501
public:
65026502
InstantiateTypeArgumentsInstr(TokenPosition token_pos,
6503-
const TypeArguments& type_arguments,
6504-
const Class& instantiator_class,
6505-
const Function& function,
65066503
Value* instantiator_type_arguments,
65076504
Value* function_type_arguments,
6505+
Value* type_arguments,
6506+
const Class& instantiator_class,
6507+
const Function& function,
65086508
intptr_t deopt_id)
65096509
: TemplateDefinition(deopt_id),
65106510
token_pos_(token_pos),
6511-
type_arguments_(type_arguments),
65126511
instantiator_class_(instantiator_class),
65136512
function_(function) {
6514-
ASSERT(type_arguments.IsZoneHandle());
6513+
// These asserts hold for current uses.
6514+
ASSERT(type_arguments->BindsToConstant());
6515+
// Note: Non-dynamic uses never provide a null TypeArguments value.
6516+
ASSERT(!type_arguments->BoundConstant().IsNull());
6517+
ASSERT(type_arguments->BoundConstant().IsTypeArguments());
65156518
ASSERT(instantiator_class.IsZoneHandle());
6519+
ASSERT(!instantiator_class.IsNull());
65166520
ASSERT(function.IsZoneHandle());
6521+
ASSERT(!function.IsNull());
65176522
SetInputAt(0, instantiator_type_arguments);
65186523
SetInputAt(1, function_type_arguments);
6524+
SetInputAt(2, type_arguments);
65196525
}
65206526

65216527
DECLARE_INSTRUCTION(InstantiateTypeArguments)
65226528

65236529
Value* instantiator_type_arguments() const { return inputs_[0]; }
65246530
Value* function_type_arguments() const { return inputs_[1]; }
6525-
const TypeArguments& type_arguments() const { return type_arguments_; }
6531+
Value* type_arguments() const { return inputs_[2]; }
65266532
const Class& instantiator_class() const { return instantiator_class_; }
65276533
const Function& function() const { return function_; }
65286534
virtual TokenPosition token_pos() const { return token_pos_; }
@@ -6537,12 +6543,18 @@ class InstantiateTypeArgumentsInstr : public TemplateDefinition<2, Throws> {
65376543

65386544
const Code& GetStub() const {
65396545
bool with_runtime_check;
6540-
if (type_arguments().CanShareInstantiatorTypeArguments(
6541-
instantiator_class(), &with_runtime_check)) {
6546+
ASSERT(!instantiator_class().IsNull());
6547+
ASSERT(!function().IsNull());
6548+
ASSERT(type_arguments()->BindsToConstant());
6549+
ASSERT(type_arguments()->BoundConstant().IsTypeArguments());
6550+
const auto& type_args =
6551+
TypeArguments::Cast(type_arguments()->BoundConstant());
6552+
if (type_args.CanShareInstantiatorTypeArguments(instantiator_class(),
6553+
&with_runtime_check)) {
65426554
ASSERT(with_runtime_check);
65436555
return StubCode::InstantiateTypeArgumentsMayShareInstantiatorTA();
6544-
} else if (type_arguments().CanShareFunctionTypeArguments(
6545-
function(), &with_runtime_check)) {
6556+
} else if (type_args.CanShareFunctionTypeArguments(function(),
6557+
&with_runtime_check)) {
65466558
ASSERT(with_runtime_check);
65476559
return StubCode::InstantiateTypeArgumentsMayShareFunctionTA();
65486560
}
@@ -6553,7 +6565,6 @@ class InstantiateTypeArgumentsInstr : public TemplateDefinition<2, Throws> {
65536565

65546566
private:
65556567
const TokenPosition token_pos_;
6556-
const TypeArguments& type_arguments_;
65576568
const Class& instantiator_class_;
65586569
const Function& function_;
65596570

‎runtime/vm/compiler/backend/il_arm.cc

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3492,14 +3492,16 @@ void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
34923492
LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary(
34933493
Zone* zone,
34943494
bool opt) const {
3495-
const intptr_t kNumInputs = 2;
3495+
const intptr_t kNumInputs = 3;
34963496
const intptr_t kNumTemps = 0;
34973497
LocationSummary* locs = new (zone)
34983498
LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kCall);
34993499
locs->set_in(0, Location::RegisterLocation(
35003500
InstantiationABI::kInstantiatorTypeArgumentsReg));
35013501
locs->set_in(1, Location::RegisterLocation(
35023502
InstantiationABI::kFunctionTypeArgumentsReg));
3503+
locs->set_in(2, Location::RegisterLocation(
3504+
InstantiationABI::kUninstantiatedTypeArgumentsReg));
35033505
locs->set_out(
35043506
0, Location::RegisterLocation(InstantiationABI::kResultTypeArgumentsReg));
35053507
return locs;
@@ -3514,14 +3516,19 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
35143516
// 'instantiator_type_args_reg' is a TypeArguments object (or null).
35153517
// 'function_type_args_reg' is a TypeArguments object (or null).
35163518

3519+
compiler::Label type_arguments_instantiated;
3520+
ASSERT(!instantiator_class().IsNull());
3521+
ASSERT(type_arguments()->BindsToConstant());
3522+
const auto& type_args =
3523+
TypeArguments::Cast(type_arguments()->BoundConstant());
3524+
35173525
// If both the instantiator and function type arguments are null and if the
35183526
// type argument vector instantiated from null becomes a vector of dynamic,
35193527
// then use null as the type arguments.
3520-
compiler::Label type_arguments_instantiated;
35213528
const bool can_function_type_args_be_null =
35223529
function_type_arguments()->CanBe(Object::null_object());
3523-
const intptr_t len = type_arguments().Length();
3524-
if (type_arguments().IsRawWhenInstantiatedFromRaw(len) &&
3530+
const intptr_t len = type_args.Length();
3531+
if (type_args.IsRawWhenInstantiatedFromRaw(len) &&
35253532
can_function_type_args_be_null) {
35263533
ASSERT(result_reg != instantiator_type_args_reg &&
35273534
result_reg != function_type_args_reg);
@@ -3533,8 +3540,6 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
35333540
__ b(&type_arguments_instantiated, EQ);
35343541
}
35353542
// Lookup cache in stub before calling runtime.
3536-
__ LoadObject(InstantiationABI::kUninstantiatedTypeArgumentsReg,
3537-
type_arguments());
35383543
compiler->GenerateStubCall(token_pos(), GetStub(),
35393544
PcDescriptorsLayout::kOther, locs());
35403545
__ Bind(&type_arguments_instantiated);

‎runtime/vm/compiler/backend/il_arm64.cc

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2982,14 +2982,16 @@ void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
29822982
LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary(
29832983
Zone* zone,
29842984
bool opt) const {
2985-
const intptr_t kNumInputs = 2;
2985+
const intptr_t kNumInputs = 3;
29862986
const intptr_t kNumTemps = 0;
29872987
LocationSummary* locs = new (zone)
29882988
LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kCall);
29892989
locs->set_in(0, Location::RegisterLocation(
29902990
InstantiationABI::kInstantiatorTypeArgumentsReg));
29912991
locs->set_in(1, Location::RegisterLocation(
29922992
InstantiationABI::kFunctionTypeArgumentsReg));
2993+
locs->set_in(2, Location::RegisterLocation(
2994+
InstantiationABI::kUninstantiatedTypeArgumentsReg));
29932995
locs->set_out(
29942996
0, Location::RegisterLocation(InstantiationABI::kResultTypeArgumentsReg));
29952997
return locs;
@@ -3001,17 +3003,21 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
30013003
const Register function_type_args_reg = locs()->in(1).reg();
30023004
const Register result_reg = locs()->out(0).reg();
30033005

3006+
compiler::Label type_arguments_instantiated;
3007+
ASSERT(!instantiator_class().IsNull());
3008+
ASSERT(type_arguments()->BindsToConstant());
3009+
const auto& type_args =
3010+
TypeArguments::Cast(type_arguments()->BoundConstant());
30043011
// 'instantiator_type_args_reg' is a TypeArguments object (or null).
30053012
// 'function_type_args_reg' is a TypeArguments object (or null).
30063013

30073014
// If both the instantiator and function type arguments are null and if the
30083015
// type argument vector instantiated from null becomes a vector of dynamic,
30093016
// then use null as the type arguments.
3010-
compiler::Label type_arguments_instantiated;
3011-
const intptr_t len = type_arguments().Length();
3017+
const intptr_t len = type_args.Length();
30123018
const bool can_function_type_args_be_null =
30133019
function_type_arguments()->CanBe(Object::null_object());
3014-
if (type_arguments().IsRawWhenInstantiatedFromRaw(len) &&
3020+
if (type_args.IsRawWhenInstantiatedFromRaw(len) &&
30153021
can_function_type_args_be_null) {
30163022
compiler::Label non_null_type_args;
30173023
ASSERT(result_reg != instantiator_type_args_reg &&
@@ -3026,8 +3032,6 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
30263032
__ Bind(&non_null_type_args);
30273033
}
30283034
// Lookup cache in stub before calling runtime.
3029-
__ LoadObject(InstantiationABI::kUninstantiatedTypeArgumentsReg,
3030-
type_arguments());
30313035
compiler->GenerateStubCall(token_pos(), GetStub(),
30323036
PcDescriptorsLayout::kOther, locs());
30333037
__ Bind(&type_arguments_instantiated);

‎runtime/vm/compiler/backend/il_ia32.cc

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2766,14 +2766,16 @@ void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
27662766
LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary(
27672767
Zone* zone,
27682768
bool opt) const {
2769-
const intptr_t kNumInputs = 2;
2769+
const intptr_t kNumInputs = 3;
27702770
const intptr_t kNumTemps = 0;
27712771
LocationSummary* locs = new (zone)
27722772
LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kCall);
27732773
locs->set_in(0, Location::RegisterLocation(
27742774
InstantiationABI::kInstantiatorTypeArgumentsReg));
27752775
locs->set_in(1, Location::RegisterLocation(
27762776
InstantiationABI::kFunctionTypeArgumentsReg));
2777+
locs->set_in(2, Location::RegisterLocation(
2778+
InstantiationABI::kUninstantiatedTypeArgumentsReg));
27772779
locs->set_out(
27782780
0, Location::RegisterLocation(InstantiationABI::kResultTypeArgumentsReg));
27792781
return locs;
@@ -2785,17 +2787,21 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
27852787
Register function_type_args_reg = locs()->in(1).reg();
27862788
Register result_reg = locs()->out(0).reg();
27872789

2790+
compiler::Label type_arguments_instantiated;
2791+
ASSERT(!instantiator_class().IsNull());
2792+
ASSERT(type_arguments()->BindsToConstant());
2793+
const auto& type_args =
2794+
TypeArguments::Cast(type_arguments()->BoundConstant());
27882795
// 'instantiator_type_args_reg' is a TypeArguments object (or null).
27892796
// 'function_type_args_reg' is a TypeArguments object (or null).
27902797

27912798
// If both the instantiator and function type arguments are null and if the
27922799
// type argument vector instantiated from null becomes a vector of dynamic,
27932800
// then use null as the type arguments.
2794-
compiler::Label type_arguments_instantiated;
2795-
const intptr_t len = type_arguments().Length();
2801+
const intptr_t len = type_args.Length();
27962802
const bool can_function_type_args_be_null =
27972803
function_type_arguments()->CanBe(Object::null_object());
2798-
if (type_arguments().IsRawWhenInstantiatedFromRaw(len) &&
2804+
if (type_args.IsRawWhenInstantiatedFromRaw(len) &&
27992805
can_function_type_args_be_null) {
28002806
compiler::Label non_null_type_args;
28012807
ASSERT(result_reg != instantiator_type_args_reg &&
@@ -2810,8 +2816,6 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
28102816
__ Bind(&non_null_type_args);
28112817
}
28122818
// Lookup cache in stub before calling runtime.
2813-
__ LoadObject(InstantiationABI::kUninstantiatedTypeArgumentsReg,
2814-
type_arguments());
28152819
compiler->GenerateStubCall(token_pos(), GetStub(),
28162820
PcDescriptorsLayout::kOther, locs());
28172821
__ Bind(&type_arguments_instantiated);

‎runtime/vm/compiler/backend/il_printer.cc

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -688,13 +688,15 @@ void InstantiateTypeInstr::PrintOperandsTo(BaseTextBuffer* f) const {
688688
}
689689

690690
void InstantiateTypeArgumentsInstr::PrintOperandsTo(BaseTextBuffer* f) const {
691-
const String& type_args = String::Handle(type_arguments().Name());
692-
f->Printf("%s,", type_args.ToCString());
693-
f->AddString(" instantiator_type_args(");
691+
type_arguments()->PrintTo(f);
692+
f->AddString(", instantiator_type_args(");
694693
instantiator_type_arguments()->PrintTo(f);
695694
f->AddString("), function_type_args(");
696695
function_type_arguments()->PrintTo(f);
697-
f->Printf("), instantiator_class(%s)", instantiator_class().ToCString());
696+
f->Printf(")");
697+
if (!instantiator_class().IsNull()) {
698+
f->Printf(", instantiator_class(%s)", instantiator_class().ToCString());
699+
}
698700
}
699701

700702
void AllocateContextInstr::PrintOperandsTo(BaseTextBuffer* f) const {

‎runtime/vm/compiler/backend/il_x64.cc

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3016,14 +3016,16 @@ void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
30163016
LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary(
30173017
Zone* zone,
30183018
bool opt) const {
3019-
const intptr_t kNumInputs = 2;
3019+
const intptr_t kNumInputs = 3;
30203020
const intptr_t kNumTemps = 0;
30213021
LocationSummary* locs = new (zone)
30223022
LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kCall);
30233023
locs->set_in(0, Location::RegisterLocation(
30243024
InstantiationABI::kInstantiatorTypeArgumentsReg));
30253025
locs->set_in(1, Location::RegisterLocation(
30263026
InstantiationABI::kFunctionTypeArgumentsReg));
3027+
locs->set_in(2, Location::RegisterLocation(
3028+
InstantiationABI::kUninstantiatedTypeArgumentsReg));
30273029
locs->set_out(
30283030
0, Location::RegisterLocation(InstantiationABI::kResultTypeArgumentsReg));
30293031
return locs;
@@ -3035,17 +3037,21 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
30353037
Register function_type_args_reg = locs()->in(1).reg();
30363038
Register result_reg = locs()->out(0).reg();
30373039

3040+
compiler::Label type_arguments_instantiated;
3041+
ASSERT(!instantiator_class().IsNull());
3042+
ASSERT(type_arguments()->BindsToConstant());
3043+
const auto& type_args =
3044+
TypeArguments::Cast(type_arguments()->BoundConstant());
30383045
// 'instantiator_type_args_reg' is a TypeArguments object (or null).
30393046
// 'function_type_args_reg' is a TypeArguments object (or null).
30403047

30413048
// If both the instantiator and function type arguments are null and if the
30423049
// type argument vector instantiated from null becomes a vector of dynamic,
30433050
// then use null as the type arguments.
3044-
compiler::Label type_arguments_instantiated;
3045-
const intptr_t len = type_arguments().Length();
3051+
const intptr_t len = type_args.Length();
30463052
const bool can_function_type_args_be_null =
30473053
function_type_arguments()->CanBe(Object::null_object());
3048-
if (type_arguments().IsRawWhenInstantiatedFromRaw(len) &&
3054+
if (type_args.IsRawWhenInstantiatedFromRaw(len) &&
30493055
can_function_type_args_be_null) {
30503056
compiler::Label non_null_type_args;
30513057
ASSERT(result_reg != instantiator_type_args_reg &&
@@ -3059,8 +3065,7 @@ void InstantiateTypeArgumentsInstr::EmitNativeCode(
30593065
__ j(EQUAL, &type_arguments_instantiated, compiler::Assembler::kNearJump);
30603066
__ Bind(&non_null_type_args);
30613067
}
3062-
__ LoadObject(InstantiationABI::kUninstantiatedTypeArgumentsReg,
3063-
type_arguments());
3068+
// Lookup cache in stub before calling runtime.
30643069
compiler->GenerateStubCall(token_pos(), GetStub(),
30653070
PcDescriptorsLayout::kOther, locs());
30663071
__ Bind(&type_arguments_instantiated);

‎runtime/vm/compiler/frontend/base_flow_graph_builder.cc

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -941,15 +941,20 @@ Fragment BaseFlowGraphBuilder::InstantiateType(const AbstractType& type) {
941941
}
942942

943943
Fragment BaseFlowGraphBuilder::InstantiateTypeArguments(
944-
const TypeArguments& type_arguments) {
944+
const TypeArguments& type_arguments_value) {
945+
Fragment instructions;
946+
instructions += Constant(type_arguments_value);
947+
948+
Value* type_arguments = Pop();
945949
Value* function_type_args = Pop();
946950
Value* instantiator_type_args = Pop();
947951
const Class& instantiator_class = Class::ZoneHandle(Z, function_.Owner());
948952
InstantiateTypeArgumentsInstr* instr = new (Z) InstantiateTypeArgumentsInstr(
949-
TokenPosition::kNoSource, type_arguments, instantiator_class, function_,
950-
instantiator_type_args, function_type_args, GetNextDeoptId());
953+
TokenPosition::kNoSource, instantiator_type_args, function_type_args,
954+
type_arguments, instantiator_class, function_, GetNextDeoptId());
951955
Push(instr);
952-
return Fragment(instr);
956+
instructions += Fragment(instr);
957+
return instructions;
953958
}
954959

955960
Fragment BaseFlowGraphBuilder::LoadClassId() {

0 commit comments

Comments
 (0)