[vm, compiler] Remove dead stub ICCallThroughFunction.

This was needed in the past when AOT code was executed in the compiler to implement loading and evaluate constants.

Change-Id: I66633acfc61676bce10b0a0abb7955e4e45be54c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/104100
Reviewed-by: Aart Bik <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/vm/compiler/aot/precompiler.cc

@@ -337,7 +337,7 @@ void Precompiler::DoCompileAll() {
     DropLibraries();
 
     BindStaticCalls();
-    SwitchICCalls();
+    DedupUnlinkedCalls();
     Obfuscate();
 
     ProgramVisitor::Dedup();
@@ -612,16 +612,15 @@ void Precompiler::AddCalleesOf(const Function& function, intptr_t gop_offset) {
 void Precompiler::AddCalleesOfHelper(const Object& entry,
                                      String* temp_selector,
                                      Class* temp_cls) {
-  if (entry.IsICData()) {
-    const auto& call_site = ICData::Cast(entry);
+  if (entry.IsUnlinkedCall()) {
+    const auto& call_site = UnlinkedCall::Cast(entry);
     // A dynamic call.
-    ASSERT(!call_site.is_static_call());
     *temp_selector = call_site.target_name();
     AddSelector(*temp_selector);
     if (temp_selector->raw() == Symbols::Call().raw()) {
       // Potential closure call.
       const Array& arguments_descriptor =
-          Array::Handle(Z, call_site.arguments_descriptor());
+          Array::Handle(Z, call_site.args_descriptor());
       AddClosureCall(arguments_descriptor);
     }
   } else if (entry.IsMegamorphicCache()) {
@@ -1986,49 +1985,27 @@ void Precompiler::BindStaticCalls() {
   }
 }
 
-void Precompiler::SwitchICCalls() {
+void Precompiler::DedupUnlinkedCalls() {
   ASSERT(!I->compilation_allowed());
 #if !defined(TARGET_ARCH_DBC)
-  // Now that all functions have been compiled, we can switch to an instance
-  // call sequence that loads the Code object and entry point directly from
-  // the ic data array instead indirectly through a Function in the ic data
-  // array. Iterate all the object pools and rewrite the ic data from
-  // (cid, target function, count) to (cid, target code, entry point), and
-  // replace the ICCallThroughFunction stub with ICCallThroughCode.
-  class ICCallSwitcher {
+  class UnlinkedCallDeduper {
    public:
-    explicit ICCallSwitcher(Zone* zone)
+    explicit UnlinkedCallDeduper(Zone* zone)
         : zone_(zone),
           entry_(Object::Handle(zone)),
-          ic_(ICData::Handle(zone)),
-          target_name_(String::Handle(zone)),
-          args_descriptor_(Array::Handle(zone)),
           unlinked_(UnlinkedCall::Handle(zone)),
-          target_code_(Code::Handle(zone)),
           canonical_unlinked_calls_() {}
 
-    void SwitchPool(const ObjectPool& pool) {
+    void DedupPool(const ObjectPool& pool) {
       for (intptr_t i = 0; i < pool.Length(); i++) {
         if (pool.TypeAt(i) != ObjectPool::EntryType::kTaggedObject) {
           continue;
         }
         entry_ = pool.ObjectAt(i);
-        if (entry_.IsICData()) {
-          // The only IC calls generated by precompilation are for switchable
-          // calls.
-          ic_ ^= entry_.raw();
-          ic_.ResetSwitchable(zone_);
-
-          unlinked_ = UnlinkedCall::New();
-          target_name_ = ic_.target_name();
-          unlinked_.set_target_name(target_name_);
-          args_descriptor_ = ic_.arguments_descriptor();
-          unlinked_.set_args_descriptor(args_descriptor_);
+        if (entry_.IsUnlinkedCall()) {
+          unlinked_ ^= entry_.raw();
           unlinked_ = DedupUnlinkedCall(unlinked_);
           pool.SetObjectAt(i, unlinked_);
-        } else if (entry_.raw() == StubCode::ICCallThroughFunction().raw()) {
-          target_code_ = StubCode::UnlinkedCall().raw();
-          pool.SetObjectAt(i, target_code_);
         }
       }
     }
@@ -2048,18 +2025,14 @@ void Precompiler::SwitchICCalls() {
    private:
     Zone* zone_;
     Object& entry_;
-    ICData& ic_;
-    String& target_name_;
-    Array& args_descriptor_;
     UnlinkedCall& unlinked_;
-    Code& target_code_;
     UnlinkedCallSet canonical_unlinked_calls_;
   };
 
-  class SwitchICCallsVisitor : public FunctionVisitor {
+  class DedupUnlinkedCallsVisitor : public FunctionVisitor {
    public:
-    SwitchICCallsVisitor(ICCallSwitcher* ic_call_switcher, Zone* zone)
-        : ic_call_switcher_(*ic_call_switcher),
+    DedupUnlinkedCallsVisitor(UnlinkedCallDeduper* deduper, Zone* zone)
+        : deduper_(*deduper),
           code_(Code::Handle(zone)),
           pool_(ObjectPool::Handle(zone)) {}
 
@@ -2069,22 +2042,22 @@ void Precompiler::SwitchICCalls() {
       }
       code_ = function.CurrentCode();
       pool_ = code_.object_pool();
-      ic_call_switcher_.SwitchPool(pool_);
+      deduper_.DedupPool(pool_);
     }
 
    private:
-    ICCallSwitcher& ic_call_switcher_;
+    UnlinkedCallDeduper& deduper_;
     Code& code_;
     ObjectPool& pool_;
   };
 
-  ICCallSwitcher switcher(Z);
+  UnlinkedCallDeduper deduper(Z);
   auto& gop = ObjectPool::Handle(I->object_store()->global_object_pool());
   ASSERT(gop.IsNull() != FLAG_use_bare_instructions);
   if (FLAG_use_bare_instructions) {
-    switcher.SwitchPool(gop);
+    deduper.DedupPool(gop);
   } else {
-    SwitchICCallsVisitor visitor(&switcher, Z);
+    DedupUnlinkedCallsVisitor visitor(&deduper, Z);
 
     // We need both iterations to ensure we visit all the functions that might
     // end up in the snapshot. The ProgramVisitor will miss closures from

runtime/vm/compiler/aot/precompiler.h

@@ -279,8 +279,13 @@ class Precompiler : public ValueObject {
   void DropClasses();
   void DropLibraries();
 
+  // Remove the indirection of the CallStaticFunction stub from all static call
+  // sites now that Code is available for all call targets. Allows for dropping
+  // the static call table from each Code object.
   void BindStaticCalls();
-  void SwitchICCalls();
+  // Deduplicate the UnlinkedCall objects in all ObjectPools to reduce snapshot
+  // size.
+  void DedupUnlinkedCalls();
 
   void Obfuscate();
 

runtime/vm/compiler/backend/flow_graph_compiler_arm.cc

@@ -1147,7 +1147,9 @@ void FlowGraphCompiler::EmitInstanceCallAOT(const ICData& ic_data,
   ASSERT(entry_kind == Code::EntryKind::kNormal ||
          entry_kind == Code::EntryKind::kUnchecked);
   ASSERT(ic_data.NumArgsTested() == 1);
-  const Code& initial_stub = StubCode::ICCallThroughFunction();
+  const Code& initial_stub = StubCode::UnlinkedCall();
+  const UnlinkedCall& data =
+      UnlinkedCall::ZoneHandle(zone(), ic_data.AsUnlinkedCall());
 
   __ Comment("InstanceCallAOT");
   __ LoadFromOffset(
@@ -1167,7 +1169,7 @@ void FlowGraphCompiler::EmitInstanceCallAOT(const ICData& ic_data,
                   Code::EntryKind::kMonomorphicUnchecked);
     __ ldr(LR, FieldAddress(CODE_REG, entry_point_offset));
   }
-  __ LoadUniqueObject(R9, ic_data);
+  __ LoadUniqueObject(R9, data);
   __ blx(LR);
 
   EmitCallsiteMetadata(token_pos, DeoptId::kNone, RawPcDescriptors::kOther,

runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc

@@ -1113,27 +1113,29 @@ void FlowGraphCompiler::EmitInstanceCallAOT(const ICData& ic_data,
                                             Code::EntryKind entry_kind) {
   // TODO(34162): Support multiple entry-points on ARM64.
   ASSERT(ic_data.NumArgsTested() == 1);
-  const Code& initial_stub = StubCode::ICCallThroughFunction();
+  const Code& initial_stub = StubCode::UnlinkedCall();
+  const UnlinkedCall& data =
+      UnlinkedCall::ZoneHandle(zone(), ic_data.AsUnlinkedCall());
 
   ObjectPoolBuilder& op = __ object_pool_builder();
 
   __ Comment("InstanceCallAOT");
   __ LoadFromOffset(R0, SP, (ic_data.CountWithoutTypeArgs() - 1) * kWordSize);
 
-  const intptr_t ic_data_index =
-      op.AddObject(ic_data, ObjectPool::Patchability::kPatchable);
+  const intptr_t data_index =
+      op.AddObject(data, ObjectPool::Patchability::kPatchable);
   const intptr_t initial_stub_index =
       op.AddObject(initial_stub, ObjectPool::Patchability::kPatchable);
-  ASSERT((ic_data_index + 1) == initial_stub_index);
+  ASSERT((data_index + 1) == initial_stub_index);
 
   if (FLAG_precompiled_mode && FLAG_use_bare_instructions) {
     // The AOT runtime will replace the slot in the object pool with the
     // entrypoint address - see clustered_snapshot.cc.
     __ LoadDoubleWordFromPoolOffset(R5, LR,
-                                    ObjectPool::element_offset(ic_data_index));
+                                    ObjectPool::element_offset(data_index));
   } else {
     __ LoadDoubleWordFromPoolOffset(R5, CODE_REG,
-                                    ObjectPool::element_offset(ic_data_index));
+                                    ObjectPool::element_offset(data_index));
     __ ldr(LR, FieldAddress(CODE_REG, Code::entry_point_offset(
                                           Code::EntryKind::kMonomorphic)));
   }

runtime/vm/compiler/backend/flow_graph_compiler_x64.cc

@@ -1123,7 +1123,9 @@ void FlowGraphCompiler::EmitInstanceCallAOT(const ICData& ic_data,
   ASSERT(entry_kind == Code::EntryKind::kNormal ||
          entry_kind == Code::EntryKind::kUnchecked);
   ASSERT(ic_data.NumArgsTested() == 1);
-  const Code& initial_stub = StubCode::ICCallThroughFunction();
+  const Code& initial_stub = StubCode::UnlinkedCall();
+  const UnlinkedCall& data =
+      UnlinkedCall::ZoneHandle(zone(), ic_data.AsUnlinkedCall());
 
   __ Comment("InstanceCallAOT");
   __ movq(RDX, Address(RSP, (ic_data.CountWithoutTypeArgs() - 1) * kWordSize));
@@ -1139,7 +1141,7 @@ void FlowGraphCompiler::EmitInstanceCallAOT(const ICData& ic_data,
     __ LoadUniqueObject(CODE_REG, initial_stub);
     __ movq(RCX, FieldAddress(CODE_REG, entry_point_offset));
   }
-  __ LoadUniqueObject(RBX, ic_data);
+  __ LoadUniqueObject(RBX, data);
   __ call(RCX);
 
   EmitCallsiteMetadata(token_pos, deopt_id, RawPcDescriptors::kOther, locs);

runtime/vm/compiler/stub_code_compiler_arm.cc

@@ -3149,48 +3149,6 @@ void StubCodeCompiler::GenerateMegamorphicCallStub(Assembler* assembler) {
   __ b(&loop);
 }
 
-// Called from switchable IC calls.
-//  R0: receiver
-//  R9: ICData (preserved)
-// Passed to target:
-//  CODE_REG: target Code object
-//  R4: arguments descriptor
-void StubCodeCompiler::GenerateICCallThroughFunctionStub(Assembler* assembler) {
-  Label loop, found, miss;
-  __ ldr(ARGS_DESC_REG,
-         FieldAddress(R9, target::ICData::arguments_descriptor_offset()));
-  __ ldr(R8, FieldAddress(R9, target::ICData::entries_offset()));
-  __ AddImmediate(R8, target::Array::data_offset() - kHeapObjectTag);
-  // R8: first IC entry
-  __ LoadTaggedClassIdMayBeSmi(R1, R0);
-  // R1: receiver cid as Smi
-
-  __ Bind(&loop);
-  __ ldr(R2, Address(R8, 0));
-  __ cmp(R1, Operand(R2));
-  __ b(&found, EQ);
-  __ CompareImmediate(R2, target::ToRawSmi(kIllegalCid));
-  __ b(&miss, EQ);
-
-  const intptr_t entry_length =
-      target::ICData::TestEntryLengthFor(1, /*tracking_exactness=*/false) *
-      target::kWordSize;
-  __ AddImmediate(R8, entry_length);  // Next entry.
-  __ b(&loop);
-
-  __ Bind(&found);
-  const intptr_t target_offset =
-      target::ICData::TargetIndexFor(1) * target::kWordSize;
-  __ LoadFromOffset(kWord, R0, R8, target_offset);
-  __ ldr(CODE_REG, FieldAddress(R0, target::Function::code_offset()));
-  __ Branch(FieldAddress(R0, target::Function::entry_point_offset()));
-
-  __ Bind(&miss);
-  __ LoadIsolate(R2);
-  __ ldr(CODE_REG, Address(R2, target::Isolate::ic_miss_code_offset()));
-  __ Branch(FieldAddress(CODE_REG, target::Code::entry_point_offset()));
-}
-
 void StubCodeCompiler::GenerateICCallThroughCodeStub(Assembler* assembler) {
   Label loop, found, miss;
   __ ldr(R8, FieldAddress(R9, target::ICData::entries_offset()));

runtime/vm/compiler/stub_code_compiler_arm64.cc

@@ -3229,50 +3229,6 @@ void StubCodeCompiler::GenerateMegamorphicCallStub(Assembler* assembler) {
   __ b(&cid_loaded);
 }
 
-// Called from switchable IC calls.
-//  R0: receiver
-//  R5: ICData (preserved)
-// Passed to target:
-//  CODE_REG: target Code object
-//  R4: arguments descriptor
-void StubCodeCompiler::GenerateICCallThroughFunctionStub(Assembler* assembler) {
-  Label loop, found, miss;
-  __ ldr(ARGS_DESC_REG,
-         FieldAddress(R5, target::ICData::arguments_descriptor_offset()));
-  __ ldr(R8, FieldAddress(R5, target::ICData::entries_offset()));
-  __ AddImmediate(R8, target::Array::data_offset() - kHeapObjectTag);
-  // R8: first IC entry
-  __ LoadTaggedClassIdMayBeSmi(R1, R0);
-  // R1: receiver cid as Smi
-
-  __ Bind(&loop);
-  __ ldr(R2, Address(R8, 0));
-  __ cmp(R1, Operand(R2));
-  __ b(&found, EQ);
-  __ CompareImmediate(R2, target::ToRawSmi(kIllegalCid));
-  __ b(&miss, EQ);
-
-  const intptr_t entry_length =
-      target::ICData::TestEntryLengthFor(1, /*tracking_exactness=*/false) *
-      target::kWordSize;
-  __ AddImmediate(R8, entry_length);  // Next entry.
-  __ b(&loop);
-
-  __ Bind(&found);
-  const intptr_t target_offset =
-      target::ICData::TargetIndexFor(1) * target::kWordSize;
-  __ ldr(R0, Address(R8, target_offset));
-  __ ldr(R1, FieldAddress(R0, target::Function::entry_point_offset()));
-  __ ldr(CODE_REG, FieldAddress(R0, target::Function::code_offset()));
-  __ br(R1);
-
-  __ Bind(&miss);
-  __ LoadIsolate(R2);
-  __ ldr(CODE_REG, Address(R2, target::Isolate::ic_miss_code_offset()));
-  __ ldr(R1, FieldAddress(CODE_REG, target::Code::entry_point_offset()));
-  __ br(R1);
-}
-
 void StubCodeCompiler::GenerateICCallThroughCodeStub(Assembler* assembler) {
   Label loop, found, miss;
   __ ldr(R8, FieldAddress(R5, target::ICData::entries_offset()));

runtime/vm/compiler/stub_code_compiler_ia32.cc

@@ -2674,15 +2674,6 @@ void StubCodeCompiler::GenerateMegamorphicCallStub(Assembler* assembler) {
   __ jmp(&cid_loaded);
 }
 
-// Called from switchable IC calls.
-//  EBX: receiver
-//  ECX: ICData (preserved)
-// Passed to target:
-//  EDX: arguments descriptor
-void StubCodeCompiler::GenerateICCallThroughFunctionStub(Assembler* assembler) {
-  __ int3();  // AOT only.
-}
-
 void StubCodeCompiler::GenerateICCallThroughCodeStub(Assembler* assembler) {
   __ int3();  // AOT only.
 }

runtime/vm/compiler/stub_code_compiler_x64.cc

@@ -3234,52 +3234,6 @@ void StubCodeCompiler::GenerateMegamorphicCallStub(Assembler* assembler) {
   __ jmp(&cid_loaded);
 }
 
-// Called from switchable IC calls.
-//  RDX: receiver
-//  RBX: ICData (preserved)
-// Passed to target:
-//  CODE_REG: target Code object
-//  R10: arguments descriptor
-void StubCodeCompiler::GenerateICCallThroughFunctionStub(Assembler* assembler) {
-  Label loop, found, miss;
-  __ movq(R13, FieldAddress(RBX, target::ICData::entries_offset()));
-  __ movq(R10,
-          FieldAddress(RBX, target::ICData::arguments_descriptor_offset()));
-  __ leaq(R13, FieldAddress(R13, target::Array::data_offset()));
-  // R13: first IC entry
-  __ LoadTaggedClassIdMayBeSmi(RAX, RDX);
-  // RAX: receiver cid as Smi
-
-  __ Bind(&loop);
-  __ movq(R9, Address(R13, 0));
-  __ cmpq(RAX, R9);
-  __ j(EQUAL, &found, Assembler::kNearJump);
-
-  ASSERT(target::ToRawSmi(kIllegalCid) == 0);
-  __ testq(R9, R9);
-  __ j(ZERO, &miss, Assembler::kNearJump);
-
-  const intptr_t entry_length =
-      target::ICData::TestEntryLengthFor(1, /*tracking_exactness=*/false) *
-      target::kWordSize;
-  __ addq(R13, Immediate(entry_length));  // Next entry.
-  __ jmp(&loop);
-
-  __ Bind(&found);
-  const intptr_t target_offset =
-      target::ICData::TargetIndexFor(1) * target::kWordSize;
-  __ movq(RAX, Address(R13, target_offset));
-  __ movq(RCX, FieldAddress(RAX, target::Function::entry_point_offset()));
-  __ movq(CODE_REG, FieldAddress(RAX, target::Function::code_offset()));
-  __ jmp(RCX);
-
-  __ Bind(&miss);
-  __ LoadIsolate(RAX);
-  __ movq(CODE_REG, Address(RAX, target::Isolate::ic_miss_code_offset()));
-  __ movq(RCX, FieldAddress(CODE_REG, target::Code::entry_point_offset()));
-  __ jmp(RCX);
-}
-
 void StubCodeCompiler::GenerateICCallThroughCodeStub(Assembler* assembler) {
   Label loop, found, miss;
   __ movq(R13, FieldAddress(RBX, target::ICData::entries_offset()));