Use off-heap data for class check instructions

runtime/vm/intermediate_language.cc

Index: runtime/vm/intermediate_language.cc
diff --git a/runtime/vm/intermediate_language.cc b/runtime/vm/intermediate_language.cc
index 79e5100a6b77a1d780817340c9e4f3bd93e64e7a..98e2d5fc3de48dabf7297e0071eb79b1ff3c2f7e 100644
--- a/runtime/vm/intermediate_language.cc
+++ b/runtime/vm/intermediate_language.cc
@@ -142,63 +142,51 @@ bool Value::Equals(Value* other) const {
 }
 
 
-static int LowestFirst(const intptr_t* a, const intptr_t* b) {
-  return *a - *b;
-}
-
-
 CheckClassInstr::CheckClassInstr(Value* value,
                                  intptr_t deopt_id,
-                                 const ICData& unary_checks,
+                                 const Cids& cids,
                                  TokenPosition token_pos)
     : TemplateInstruction(deopt_id),
-      unary_checks_(unary_checks),
-      cids_(unary_checks.NumberOfChecks()),
+      cids_(cids),
       licm_hoisted_(false),
-      is_dense_switch_(IsDenseCidRange(unary_checks)),
+      is_bit_test_(IsCompactCidRange(cids)),
       token_pos_(token_pos) {
-  ASSERT(unary_checks.IsZoneHandle());
   // Expected useful check data.
-  ASSERT(!unary_checks_.IsNull());
-  const intptr_t number_of_checks = unary_checks_.NumberOfChecks();
+  const intptr_t number_of_checks = cids.length();
   ASSERT(number_of_checks > 0);
-  ASSERT(unary_checks_.NumArgsTested() == 1);
   SetInputAt(0, value);
   // Otherwise use CheckSmiInstr.
-  ASSERT(number_of_checks != 1 ||
-         (unary_checks_.GetReceiverClassIdAt(0) != kSmiCid));
-  for (intptr_t i = 0; i < number_of_checks; ++i) {
-    cids_.Add(unary_checks.GetReceiverClassIdAt(i));
-  }
-  cids_.Sort(LowestFirst);
+  ASSERT(number_of_checks != 1 || cids[0].cid_start != cids[0].cid_end ||
+         cids[0].cid_start != kSmiCid);
 }
 
 
 bool CheckClassInstr::AttributesEqual(Instruction* other) const {
   CheckClassInstr* other_check = other->AsCheckClass();
   ASSERT(other_check != NULL);
-  const intptr_t number_of_checks = unary_checks_.NumberOfChecks();
-  if (number_of_checks != other_check->unary_checks().NumberOfChecks()) {
-    return false;
-  }
-  for (intptr_t i = 0; i < number_of_checks; ++i) {
-    // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
-    if (unary_checks().GetReceiverClassIdAt(i) !=
-        other_check->unary_checks().GetReceiverClassIdAt(i)) {
-      return false;
+  return cids().Equals(other_check->cids());
+}
+
+
+bool Cids::ContainsExternalizableCids() const {

[Vyacheslav Egorov (Google), 2017/05/09 21:07:27]

How about moving Cids methods all together instead of interspersing them with
methods of other classes?

[erikcorry, 2017/05/10 08:47:43]

Done.

+  for (intptr_t i = 0; i < length(); i++) {
+    for (intptr_t cid = cid_ranges_[i]->cid_start;
+         cid <= cid_ranges_[i]->cid_end; cid++) {
+      if (Field::IsExternalizableCid(cid)) {
+        return true;
+      }
     }
   }
-  return true;
+  return false;
 }
 
 
-static bool AreAllChecksImmutable(const ICData& checks) {
-  const intptr_t len = checks.NumberOfChecks();
-  for (intptr_t i = 0; i < len; i++) {
-    if (checks.IsUsedAt(i)) {
-      if (Field::IsExternalizableCid(checks.GetReceiverClassIdAt(i))) {
-        return false;
-      }
+bool Cids::Equals(const Cids& other) const {
+  if (length() != other.length()) return false;
+  for (int i = 0; i < length(); i++) {
+    if (cid_ranges_[i]->cid_start != other.cid_ranges_[i]->cid_start ||
+        cid_ranges_[i]->cid_end != other.cid_ranges_[i]->cid_end) {
+      return false;
     }
   }
   return true;
@@ -207,8 +195,8 @@ static bool AreAllChecksImmutable(const ICData& checks) {
 
 EffectSet CheckClassInstr::Dependencies() const {
   // Externalization of strings via the API can change the class-id.
-  return !AreAllChecksImmutable(unary_checks()) ? EffectSet::Externalization()
-                                                : EffectSet::None();
+  return cids_.ContainsExternalizableCids() ? EffectSet::Externalization()
+                                            : EffectSet::None();
 }
 
 
@@ -219,12 +207,12 @@ EffectSet CheckClassIdInstr::Dependencies() const {
 }
 
 
-bool CheckClassInstr::DeoptIfNull() const {
-  if (!unary_checks().NumberOfChecksIs(1)) {
+bool CheckClassInstr::IsDeoptIfNull() const {
+  if (!cids().IsMonomorphic()) {
     return false;
   }
   CompileType* in_type = value()->Type();
-  const intptr_t cid = unary_checks().GetCidAt(0);
+  const intptr_t cid = cids().MonomorphicReceiverCid();
   // Performance check: use CheckSmiInstr instead.
   ASSERT(cid != kSmiCid);
   return in_type->is_nullable() && (in_type->ToNullableCid() == cid);
@@ -234,54 +222,72 @@ bool CheckClassInstr::DeoptIfNull() const {
 // Null object is a singleton of null-class (except for some sentinel,
 // transitional temporaries). Instead of checking against the null class only
 // we can check against null instance instead.
-bool CheckClassInstr::DeoptIfNotNull() const {
-  if (!unary_checks().NumberOfChecksIs(1)) {
+bool CheckClassInstr::IsDeoptIfNotNull() const {
+  if (!cids().IsMonomorphic()) {
     return false;
   }
-  const intptr_t cid = unary_checks().GetCidAt(0);
+  const intptr_t cid = cids().MonomorphicReceiverCid();
   return cid == kNullCid;
 }
 
 
-bool CheckClassInstr::IsDenseCidRange(const ICData& unary_checks) {
-  ASSERT(unary_checks.NumArgsTested() == 1);
-  // TODO(fschneider): Support smis in dense cid checks.
-  if (unary_checks.GetReceiverClassIdAt(0) == kSmiCid) return false;
-  const intptr_t number_of_checks = unary_checks.NumberOfChecks();
+bool CheckClassInstr::IsCompactCidRange(const Cids& cids) {
+  const intptr_t number_of_checks = cids.length();
+  // If there are only two checks, the extra register pressure needed for the
+  // dense-cid-range code is not justified.
   if (number_of_checks <= 2) return false;
-  intptr_t max = 0;
+
+  // TODO(fschneider): Support smis in dense cid checks.
+  if (cids.HasClassId(kSmiCid)) return false;
+
+  intptr_t min = cids.ComputeLowestCid();
+  intptr_t max = cids.ComputeHighestCid();
+  return (max - min) < kBitsPerWord;
+}
+
+
+bool CheckClassInstr::IsBitTest() const {
+  return is_bit_test_;
+}
+
+
+intptr_t Cids::ComputeLowestCid() const {
   intptr_t min = kIntptrMax;
-  for (intptr_t i = 0; i < number_of_checks; ++i) {
-    intptr_t cid = unary_checks.GetCidAt(i);
-    if (cid < min) min = cid;
-    if (cid > max) max = cid;
+  for (intptr_t i = 0; i < cid_ranges_.length(); ++i) {
+    min = Utils::Minimum(min, cid_ranges_[i]->cid_start);
   }
-  return (max - min) < kBitsPerWord;
+  return min;
 }
 
 
-bool CheckClassInstr::IsDenseSwitch() const {
-  return is_dense_switch_;
+intptr_t Cids::ComputeHighestCid() const {
+  intptr_t max = -1;
+  for (intptr_t i = 0; i < cid_ranges_.length(); ++i) {
+    max = Utils::Maximum(max, cid_ranges_[i]->cid_end);
+  }
+  return max;
 }
 
 
 intptr_t CheckClassInstr::ComputeCidMask() const {
-  ASSERT(IsDenseSwitch());
+  ASSERT(IsBitTest());
+  intptr_t min = cids_.ComputeLowestCid();
   intptr_t mask = 0;
   for (intptr_t i = 0; i < cids_.length(); ++i) {
-    mask |= static_cast<intptr_t>(1) << (cids_[i] - cids_[0]);
+    intptr_t cid_start = cids_[i].cid_start;
+    intptr_t cid_end = cids_[i].cid_end;
+    intptr_t run;
+    if (1ul + cid_end - cid_start >= sizeof(intptr_t) * 8) {

[Vyacheslav Egorov (Google), 2017/05/09 21:07:27]

there is kBitsPerWord

make a variable for cid_end - cid_start + 1 and use it here and below.

[erikcorry, 2017/05/10 08:47:43]

Done.

+      run = -1;
+    } else {
+      run = (1 << (1 + cid_end - cid_start)) - 1;
+    }
+    mask |= run << (cid_start - min);
   }
   return mask;
 }
 
 
-bool CheckClassInstr::IsDenseMask(intptr_t mask) {
-  // Returns true if the mask is a continuous sequence of ones in its binary
-  // representation (i.e. no holes)
-  return mask == -1 || Utils::IsPowerOfTwo(mask + 1);
-}
-
-
 bool LoadFieldInstr::IsUnboxedLoad() const {
   return FLAG_unbox_numeric_fields && (field() != NULL) &&
          FlowGraphCompiler::IsUnboxedField(*field());
@@ -2566,13 +2572,23 @@ Definition* StrictCompareInstr::Canonicalize(FlowGraph* flow_graph) {
 }
 
 
+bool Cids::HasClassId(intptr_t cid) const {
+  for (int i = 0; i < length(); i++) {
+    if (cid_ranges_[i]->cid_start <= cid && cid <= cid_ranges_[i]->cid_end) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
 Instruction* CheckClassInstr::Canonicalize(FlowGraph* flow_graph) {
   const intptr_t value_cid = value()->Type()->ToCid();
   if (value_cid == kDynamicCid) {
     return this;
   }
 
-  return unary_checks().HasReceiverClassId(value_cid) ? NULL : this;
+  return cids().HasClassId(value_cid) ? NULL : this;
 }
 
 
@@ -2741,23 +2757,69 @@ bool UnboxInstr::CanConvertSmi() const {
 }
 
 
-static int OrderById(const CidRangeTarget* a, const CidRangeTarget* b) {
+static int OrderById(CidRange* const* a, CidRange* const* b) {
   // Negative if 'a' should sort before 'b'.
-  ASSERT(a->cid_start == a->cid_end);
-  ASSERT(b->cid_start == b->cid_end);
-  return a->cid_start - b->cid_start;
+  ASSERT((*a)->cid_start == (*a)->cid_end);
+  ASSERT((*b)->cid_start == (*b)->cid_end);
+  return (*a)->cid_start - (*b)->cid_start;
 }
 
 
-static int OrderByFrequency(const CidRangeTarget* a, const CidRangeTarget* b) {
+static int OrderByFrequency(CidRange* const* a, CidRange* const* b) {
+  const TargetInfo* target_info_a = reinterpret_cast<const TargetInfo*>(*a);

[Vyacheslav Egorov (Google), 2017/05/09 21:07:27]

static_cast instead.

[erikcorry, 2017/05/10 08:47:43]

Done.

+  const TargetInfo* target_info_b = reinterpret_cast<const TargetInfo*>(*b);
   // Negative if 'a' should sort before 'b'.
-  return b->count - a->count;
+  return target_info_b->count - target_info_a->count;
 }
 
 
 CallTargets* CallTargets::Create(Zone* zone, const ICData& ic_data) {
-  CallTargets* targets = new (zone) CallTargets();
-  if (ic_data.NumberOfChecks() == 0) return targets;
+  CallTargets* targets = new (zone) CallTargets(zone);
+  targets->CreateHelper(zone, ic_data, /* argument_number = */ 0,
+                        /* include_targets = */ true);
+  targets->Sort(OrderById);
+  targets->MergeIntoRanges();
+  return targets;
+}
+
+
+Cids* Cids::CreateMonomorphic(Zone* zone, intptr_t cid) {
+  Cids* cids = new (zone) Cids(zone);
+  cids->Add(new (zone) CidRange(cid, cid));
+  return cids;
+}
+
+
+Cids* Cids::Create(Zone* zone, const ICData& ic_data, int argument_number) {
+  Cids* cids = new (zone) Cids(zone);
+  cids->CreateHelper(zone, ic_data, argument_number,
+                     /* include_targets = */ false);
+  cids->Sort(OrderById);
+
+  // Merge adjacent class id ranges.
+  int dest = 0;
+  for (int src = 1; src < cids->length(); src++) {
+    if (cids->cid_ranges_[dest]->cid_end + 1 >=
+        cids->cid_ranges_[src]->cid_start) {
+      cids->cid_ranges_[dest]->cid_end = cids->cid_ranges_[src]->cid_end;
+    } else {
+      dest++;
+      if (src != dest) cids->cid_ranges_[dest] = cids->cid_ranges_[src];
+    }
+  }
+  cids->SetLength(dest + 1);
+
+  return cids;
+}
+
+
+void Cids::CreateHelper(Zone* zone,
+                        const ICData& ic_data,
+                        int argument_number,
+                        bool include_targets) {
+  ASSERT(argument_number < ic_data.NumArgsTested());
+
+  if (ic_data.NumberOfChecks() == 0) return;
 
   Function& dummy = Function::Handle(zone);
 
@@ -2765,22 +2827,31 @@ CallTargets* CallTargets::Create(Zone* zone, const ICData& ic_data) {
 
   int checks = ic_data.NumberOfChecks();
   for (int i = 0; i < checks; i++) {
+    if (ic_data.GetCountAt(i) == 0) continue;
     intptr_t id = 0;
     if (check_one_arg) {
       ic_data.GetOneClassCheckAt(i, &id, &dummy);
     } else {
-      // The API works for multi dispatch ICs that check more than one
-      // argument, but we know we will only check one arg here, so only the 0th
-      // element of id will be used.
       GrowableArray<intptr_t> arg_ids;
       ic_data.GetCheckAt(i, &arg_ids, &dummy);
-      id = arg_ids[0];
+      id = arg_ids[argument_number];
+    }
+    if (include_targets) {
+      Function& function = Function::ZoneHandle(zone, ic_data.GetTargetAt(i));
+      cid_ranges_.Add(new (zone)
+                          TargetInfo(id, id, &function, ic_data.GetCountAt(i)));
+    } else {
+      cid_ranges_.Add(new (zone) CidRange(id, id));
     }
-    Function& function = Function::ZoneHandle(zone, ic_data.GetTargetAt(i));
-    targets->Add(CidRangeTarget(id, id, &function, ic_data.GetCountAt(i)));
   }
+}
 
-  targets->Sort(OrderById);
+
+CallTargets* CallTargets::CreateAndExpand(Zone* zone, const ICData& ic_data) {
+  CallTargets& targets = *new (zone) CallTargets(zone);
+  targets.CreateHelper(zone, ic_data, /* argument_number = */ 0,
+                       /* include_targets = */ true);
+  targets.Sort(OrderById);
 
   Array& args_desc_array = Array::Handle(zone, ic_data.arguments_descriptor());
   ArgumentsDescriptor args_desc(args_desc_array);
@@ -2788,19 +2859,17 @@ CallTargets* CallTargets::Create(Zone* zone, const ICData& ic_data) {
 
   Function& fn = Function::Handle(zone);
 
-  intptr_t length = targets->length();
+  intptr_t length = targets.length();
 
   // Spread class-ids to preceding classes where a lookup yields the same
   // method.
   for (int idx = 0; idx < length; idx++) {
-    int lower_limit_cid = (idx == 0) ? -1 : targets->At(idx - 1).cid_end;
-    const Function& target = *targets->At(idx).target;
-    for (int i = targets->At(idx).cid_start - 1; i > lower_limit_cid; i--) {
+    int lower_limit_cid = (idx == 0) ? -1 : targets[idx - 1].cid_end;
+    const Function& target = *targets.TargetAt(idx)->target;
+    for (int i = targets[idx].cid_start - 1; i > lower_limit_cid; i--) {
       if (FlowGraphCompiler::LookupMethodFor(i, name, args_desc, &fn) &&
           fn.raw() == target.raw()) {
-        CidRangeTarget t = targets->At(idx);
-        t.cid_start = i;
-        (*targets)[idx] = t;
+        targets[idx].cid_start = i;
       } else {
         break;
       }
@@ -2810,32 +2879,39 @@ CallTargets* CallTargets::Create(Zone* zone, const ICData& ic_data) {
   // method.
   for (int idx = 0; idx < length; idx++) {
     int upper_limit_cid =
-        (idx == length - 1) ? 1000000000 : targets->At(idx + 1).cid_start;
-    const Function& target = *targets->At(idx).target;
-    for (int i = targets->At(idx).cid_end + 1; i < upper_limit_cid; i++) {
+        (idx == length - 1) ? 1000000000 : targets[idx + 1].cid_start;
+    const Function& target = *targets.TargetAt(idx)->target;
+    for (int i = targets[idx].cid_end + 1; i < upper_limit_cid; i++) {
       if (FlowGraphCompiler::LookupMethodFor(i, name, args_desc, &fn) &&
           fn.raw() == target.raw()) {
-        (*targets)[idx].cid_end = i;
+        targets[idx].cid_end = i;
       } else {
         break;
       }
     }
   }
+  targets.MergeIntoRanges();
+  return &targets;
+}
+
+
+void CallTargets::MergeIntoRanges() {
   // Merge adjacent class id ranges.
   int dest = 0;
-  for (int src = 1; src < length; src++) {
-    if (targets->At(dest).cid_end + 1 == targets->At(src).cid_start &&
-        targets->At(dest).target->raw() == targets->At(src).target->raw()) {
-      (*targets)[dest].cid_end = targets->At(src).cid_end;
-      (*targets)[dest].count += targets->At(src).count;
+  for (int src = 1; src < length(); src++) {
+    if (cid_ranges_[dest]->cid_end + 1 >= cid_ranges_[src]->cid_start &&

[Vyacheslav Egorov (Google), 2017/05/09 21:07:27]

for uniformity use TargetAt(x) instead of cid_ranges_[x] consistently in this
function.

[erikcorry, 2017/05/10 08:47:43]

Done, but the assignment in the else clause needs to use cid_ranges_... to work.

+        TargetAt(dest)->target->raw() == TargetAt(src)->target->raw()) {
+      cid_ranges_[dest]->cid_end = cid_ranges_[src]->cid_end;
+      TargetAt(dest)->count += TargetAt(src)->count;
     } else {
       dest++;
-      if (src != dest) (*targets)[dest] = targets->At(src);
+      if (src != dest) {
+        cid_ranges_[dest] = cid_ranges_[src];
+      }
     }
   }
-  targets->SetLength(dest + 1);
-  targets->Sort(OrderByFrequency);
-  return targets;
+  SetLength(dest + 1);
+  Sort(OrderByFrequency);
 }
 
 
@@ -3277,46 +3353,45 @@ bool CallTargets::HasSingleRecognizedTarget() const {
 bool CallTargets::HasSingleTarget() const {
   ASSERT(length() != 0);
   for (int i = 0; i < length(); i++) {
-    if (cid_ranges_[i].target->raw() != cid_ranges_[0].target->raw())
-      return false;
+    if (TargetAt(i)->target->raw() != TargetAt(0)->target->raw()) return false;
   }
   return true;
 }
 
 
-bool CallTargets::IsMonomorphic() const {
+bool Cids::IsMonomorphic() const {
   if (length() != 1) return false;
-  return cid_ranges_[0].cid_start == cid_ranges_[0].cid_end;
+  return cid_ranges_[0]->cid_start == cid_ranges_[0]->cid_end;
 }
 
 
-intptr_t CallTargets::MonomorphicReceiverCid() const {
+intptr_t Cids::MonomorphicReceiverCid() const {
   ASSERT(IsMonomorphic());
-  return cid_ranges_[0].cid_start;
+  return cid_ranges_[0]->cid_start;
 }
 
 
-Function& CallTargets::FirstTarget() const {
+const Function& CallTargets::FirstTarget() const {
   ASSERT(length() != 0);
-  ASSERT(cid_ranges_[0].target->IsZoneHandle());
-  return *cid_ranges_[0].target;
+  ASSERT(TargetAt(0)->target->IsZoneHandle());
+  return *TargetAt(0)->target;
 }
 
 
-Function& CallTargets::MostPopularTarget() const {
+const Function& CallTargets::MostPopularTarget() const {
   ASSERT(length() != 0);
-  ASSERT(cid_ranges_[0].target->IsZoneHandle());
+  ASSERT(TargetAt(0)->target->IsZoneHandle());
   for (int i = 1; i < length(); i++) {
-    ASSERT(cid_ranges_[i].count <= cid_ranges_[0].count);
+    ASSERT(TargetAt(i)->count <= TargetAt(0)->count);
   }
-  return *cid_ranges_[0].target;
+  return *TargetAt(0)->target;
 }
 
 
 intptr_t CallTargets::AggregateCallCount() const {
   intptr_t sum = 0;
   for (int i = 0; i < length(); i++) {
-    sum += cid_ranges_[i].count;
+    sum += TargetAt(i)->count;
   }
   return sum;
 }
@@ -3327,7 +3402,7 @@ bool PolymorphicInstanceCallInstr::HasOnlyDispatcherOrImplicitAccessorTargets()
   const intptr_t len = targets_.length();
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < len; i++) {
-    target ^= targets_[i].target->raw();
+    target ^= targets_.TargetAt(i)->target->raw();
     if (!target.IsDispatcherOrImplicitAccessor()) {
       return false;
     }
@@ -3371,7 +3446,8 @@ RawType* PolymorphicInstanceCallInstr::ComputeRuntimeType(
 
   const intptr_t num_checks = targets.length();
   for (intptr_t i = 0; i < num_checks; i++) {
-    ASSERT(targets[i].target->raw() == targets[0].target->raw());
+    ASSERT(targets.TargetAt(i)->target->raw() ==
+           targets.TargetAt(0)->target->raw());
     const intptr_t start = targets[i].cid_start;
     const intptr_t end = targets[i].cid_end;
     for (intptr_t cid = start; cid <= end; cid++) {
@@ -3553,6 +3629,53 @@ void DeoptimizeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 }
 
 
+#if !defined(TARGET_ARCH_DBC)
+void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass,
+                                        licm_hoisted_ ? ICData::kHoisted : 0);
+  if (IsNullCheck()) {
+    EmitNullCheck(compiler, deopt);
+    return;
+  }
+
+  ASSERT(!cids_.IsMonomorphic() || !cids_.HasClassId(kSmiCid));
+  Register value = locs()->in(0).reg();
+  Register temp = locs()->temp(0).reg();
+  Label is_ok;
+
+  __ BranchIfSmi(value, cids_.HasClassId(kSmiCid) ? &is_ok : deopt);
+
+  __ LoadClassId(temp, value);
+
+  if (IsBitTest()) {
+    intptr_t min = cids_.ComputeLowestCid();
+    intptr_t max = cids_.ComputeHighestCid();
+    EmitBitTest(compiler, min, max, ComputeCidMask(), deopt);
+  } else {
+    const intptr_t num_checks = cids_.length();
+    const bool use_near_jump = num_checks < 5;
+    int bias = 0;
+    for (intptr_t i = 0; i < num_checks; i++) {
+      intptr_t cid_start = cids_[i].cid_start;
+      intptr_t cid_end = cids_[i].cid_end;
+      if (cid_start == kSmiCid && cid_end == kSmiCid) {
+        continue;  // We already handled Smi above.
+      }
+      if (cid_start == kSmiCid) cid_start++;
+      if (cid_end == kSmiCid) cid_end--;
+      const bool is_last =
+          (i == num_checks - 1) ||
+          (i == num_checks - 2 && cids_[i + 1].cid_start == kSmiCid &&
+           cids_[i + 1].cid_end == kSmiCid);
+      bias = EmitCheckCid(compiler, bias, cid_start, cid_end, is_last, &is_ok,
+                          deopt, use_near_jump);
+    }
+  }
+  __ Bind(&is_ok);
+}
+#endif
+
+
 Environment* Environment::From(Zone* zone,
                                const GrowableArray<Definition*>& definitions,
                                intptr_t fixed_parameter_count,