bool DynamicTypeHandler::TryUseFixedAccessor(PropertyRecord const* propertyRecord, Var * pAccessor, FixedPropertyKind propertyType, bool getter, ScriptContext * requestContext)
{
if (PHASE_VERBOSE_TRACE1(Js::FixedMethodsPhase) || PHASE_VERBOSE_TESTTRACE1(Js::FixedMethodsPhase) ||
PHASE_VERBOSE_TRACE1(Js::UseFixedDataPropsPhase) || PHASE_VERBOSE_TESTTRACE1(Js::UseFixedDataPropsPhase))
{
Output::Print(_u("FixedFields: attempt to use fixed accessor %s from DynamicTypeHandler returned false.\n"), propertyRecord->GetBuffer());
if (this->HasSingletonInstance() && this->GetSingletonInstance()->Get()->GetScriptContext() != requestContext)
{
Output::Print(_u("FixedFields: Cross Site Script Context is used for property %s. \n"), propertyRecord->GetBuffer());
}
Output::Flush();
}
return false;
}
PolymorphicInlineCache * PropertyString::CreateBiggerPolymorphicInlineCache(bool isLdElem)
{
PolymorphicInlineCache * polymorphicInlineCache = isLdElem ? GetLdElemInlineCache() : GetStElemInlineCache();
Assert(polymorphicInlineCache && polymorphicInlineCache->CanAllocateBigger());
uint16 polymorphicInlineCacheSize = polymorphicInlineCache->GetSize();
uint16 newPolymorphicInlineCacheSize = PolymorphicInlineCache::GetNextSize(polymorphicInlineCacheSize);
Assert(newPolymorphicInlineCacheSize > polymorphicInlineCacheSize);
PolymorphicInlineCache * newPolymorphicInlineCache = ScriptContextPolymorphicInlineCache::New(newPolymorphicInlineCacheSize, GetLibrary());
polymorphicInlineCache->CopyTo(this->propertyRecord->GetPropertyId(), GetScriptContext(), newPolymorphicInlineCache);
if (isLdElem)
{
this->ldElemInlineCache = newPolymorphicInlineCache;
}
else
{
this->stElemInlineCache = newPolymorphicInlineCache;
}
#ifdef ENABLE_DEBUG_CONFIG_OPTIONS
if (PHASE_VERBOSE_TRACE1(Js::PolymorphicInlineCachePhase) || PHASE_TRACE1(PropertyStringCachePhase))
{
Output::Print(_u("PropertyString '%s' : Bigger PIC, oldSize = %d, newSize = %d\n"), GetString(), polymorphicInlineCacheSize, newPolymorphicInlineCacheSize);
}
#endif
return newPolymorphicInlineCache;
}
void DynamicTypeHandler::TraceUseFixedProperty(PropertyRecord const * propertyRecord, Var * pProperty, bool result, LPCWSTR typeHandlerName, ScriptContext * requestContext)
{
LPCWSTR fixedPropertyResultType = nullptr;
bool log = false;
if (pProperty && *pProperty && ((Js::JavascriptFunction::Is(*pProperty) && (PHASE_VERBOSE_TRACE1(Js::FixedMethodsPhase) || PHASE_VERBOSE_TESTTRACE1(Js::FixedMethodsPhase))) ||
((PHASE_VERBOSE_TRACE1(Js::UseFixedDataPropsPhase) || PHASE_VERBOSE_TESTTRACE1(Js::UseFixedDataPropsPhase))) ))
{
if(*pProperty == nullptr)
{
fixedPropertyResultType = _u("null");
}
else if (Js::JavascriptFunction::Is(*pProperty))
{
fixedPropertyResultType = _u("function");
}
else if (TaggedInt::Is(*pProperty))
{
fixedPropertyResultType = _u("int constant");
}
else
{
fixedPropertyResultType = _u("Var");
}
log = true;
}
if(log)
{
Output::Print(_u("FixedFields: attempt to use fixed property %s, which is a %s, from %s returned %s.\n"),
propertyRecord->GetBuffer(), fixedPropertyResultType, typeHandlerName, IsTrueOrFalse(result));
if (this->HasSingletonInstance() && this->GetSingletonInstance()->Get()->GetScriptContext() != requestContext)
{
Output::Print(_u("FixedFields: Cross Site Script Context is used for property %s. \n"), propertyRecord->GetBuffer());
}
Output::Flush();
}
}
TypePath * TypePath::Branch(Recycler * recycler, int pathLength, bool couldSeeProto)
{
AssertMsg(pathLength < this->GetPathLength(), "Why are we branching at the tip of the type path?");
// Ensure there is at least one free entry in the new path, so we can extend it.
// TypePath::New will take care of aligning this appropriately.
TypePath * branchedPath = TypePath::New(recycler, pathLength + 1);
for (PropertyIndex i = 0; i < pathLength; i++)
{
branchedPath->AddInternal(assignments[i]);
#ifdef SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
if (couldSeeProto)
{
if (this->GetData()->usedFixedFields.Test(i))
{
// We must conservatively copy all used as fixed bits if some prototype instance could also take
// this transition. See comment in PathTypeHandlerBase::ConvertToSimpleDictionaryType.
// Yes, we could devise a more efficient way of copying bits 1 through pathLength, if performance of this
// code path proves important enough.
branchedPath->GetData()->usedFixedFields.Set(i);
}
else if (this->GetData()->fixedFields.Test(i))
{
// We must clear any fixed fields that are not also used as fixed if some prototype instance could also take
// this transition. See comment in PathTypeHandlerBase::ConvertToSimpleDictionaryType.
this->GetData()->fixedFields.Clear(i);
}
}
#endif
}
#ifdef SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
// When branching, we must ensure that fixed field values on the prefix shared by the two branches are always
// consistent. Hence, we can't leave any of them uninitialized, because they could later get initialized to
// different values, by two different instances (one on the old branch and one on the new branch). If that happened
// and the instance from the old branch later switched to the new branch, it would magically gain a different set
// of fixed properties!
if (this->GetMaxInitializedLength() < pathLength)
{
this->SetMaxInitializedLength(pathLength);
}
branchedPath->SetMaxInitializedLength(pathLength);
#endif
#ifdef SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
if (PHASE_VERBOSE_TRACE1(FixMethodPropsPhase))
{
Output::Print(_u("FixedFields: TypePath::Branch: singleton: 0x%p(0x%p)\n"), PointerValue(this->singletonInstance), this->singletonInstance->Get());
Output::Print(_u(" fixed fields:"));
for (PropertyIndex i = 0; i < GetPathLength(); i++)
{
Output::Print(_u(" %s %d%d%d,"), GetPropertyId(i)->GetBuffer(),
i < GetMaxInitializedLength() ? 1 : 0,
GetIsFixedFieldAt(i, GetPathLength()) ? 1 : 0,
GetIsUsedFixedFieldAt(i, GetPathLength()) ? 1 : 0);
}
Output::Print(_u("\n"));
}
#endif
return branchedPath;
}
