bool AsmJsFunctionDeclaration::CheckAndSetReturnType(Js::AsmJsRetType val)
{
Assert((val != AsmJsRetType::Fixnum && val != AsmJsRetType::Unsigned && val != AsmJsRetType::Floatish) ||
GetSymbolType() == AsmJsSymbol::MathBuiltinFunction ||
GetSymbolType() == AsmJsSymbol::SIMDBuiltinFunction);
if (mReturnTypeKnown)
{
Assert((mReturnType != AsmJsRetType::Fixnum && mReturnType != AsmJsRetType::Unsigned && mReturnType != AsmJsRetType::Floatish) ||
GetSymbolType() == AsmJsSymbol::MathBuiltinFunction ||
GetSymbolType() == AsmJsSymbol::SIMDBuiltinFunction);
return mReturnType.toType().isSubType(val.toType());
}
mReturnType = val;
mReturnTypeKnown = true;
return true;
}
ArgSlot AsmJsFunctionDeclaration::GetArgByteSize(ArgSlot inArgCount) const
{
uint argSize = 0;
if (GetSymbolType() == AsmJsSymbol::ImportFunction)
{
Assert(inArgCount != Constants::InvalidArgSlot);
argSize = inArgCount * MachPtr;
}
#if _M_IX86
else
{
for (ArgSlot i = 0; i < GetArgCount(); i++)
{
if( GetArgType(i).isMaybeDouble() )
{
argSize += sizeof(double);
}
else if (GetArgType(i).isIntish())
{
argSize += sizeof(int);
}
else if (GetArgType(i).isFloatish())
{
argSize += sizeof(float);
}
else if (GetArgType(i).isSIMDType())
{
argSize += sizeof(AsmJsSIMDValue);
}
else
{
Assume(UNREACHED);
}
}
}
#elif _M_X64
else
{
for (ArgSlot i = 0; i < GetArgCount(); i++)
//
// Load persisted scope info.
//
void ScopeInfo::GetScopeInfo(Parser *parser, ByteCodeGenerator* byteCodeGenerator, FuncInfo* funcInfo, Scope* scope)
{
ScriptContext* scriptContext;
ArenaAllocator* alloc;
// Load scope attributes and push onto scope stack.
scope->SetIsDynamic(this->isDynamic);
if (this->isObject)
{
scope->SetIsObject();
}
scope->SetMustInstantiate(this->mustInstantiate);
if (!this->GetCanMergeWithBodyScope())
{
scope->SetCannotMergeWithBodyScope();
}
scope->SetHasOwnLocalInClosure(this->hasLocalInClosure);
if (parser)
{
scriptContext = parser->GetScriptContext();
alloc = parser->GetAllocator();
}
else
{
TRACE_BYTECODE(_u("\nRestore ScopeInfo: %s #symbols: %d %s\n"),
funcInfo->name, symbolCount, isObject ? _u("isObject") : _u(""));
Assert(!this->isCached || scope == funcInfo->GetBodyScope());
funcInfo->SetHasCachedScope(this->isCached);
byteCodeGenerator->PushScope(scope);
// The scope is already populated, so we're done.
return;
}
// Load scope symbols
// On first access to the scopeinfo, replace the ID's with PropertyRecord*'s to save the dictionary lookup
// on later accesses. Replace them all before allocating Symbol's to prevent inconsistency on OOM.
if (!this->areNamesCached && !PHASE_OFF1(Js::CacheScopeInfoNamesPhase))
{
for (int i = 0; i < symbolCount; i++)
{
PropertyId propertyId = GetSymbolId(i);
if (propertyId != 0) // There may be empty slots, e.g. "arguments" may have no slot
{
PropertyRecord const* name = scriptContext->GetPropertyName(propertyId);
this->SetPropertyName(i, name);
}
}
this->areNamesCached = true;
}
for (int i = 0; i < symbolCount; i++)
{
PropertyRecord const* name = nullptr;
if (this->areNamesCached)
{
name = this->GetPropertyName(i);
}
else
{
PropertyId propertyId = GetSymbolId(i);
if (propertyId != 0) // There may be empty slots, e.g. "arguments" may have no slot
{
name = scriptContext->GetPropertyName(propertyId);
}
}
if (name != nullptr)
{
SymbolType symbolType = GetSymbolType(i);
SymbolName symName(name->GetBuffer(), name->GetLength());
Symbol *sym = Anew(alloc, Symbol, symName, nullptr, symbolType);
sym->SetScopeSlot(static_cast<PropertyId>(i));
sym->SetIsBlockVar(GetIsBlockVariable(i));
if (GetHasFuncAssignment(i))
{
sym->RestoreHasFuncAssignment();
}
scope->AddNewSymbol(sym);
if (parser)
{
parser->RestorePidRefForSym(sym);
}
TRACE_BYTECODE(_u("%12s %d\n"), sym->GetName().GetBuffer(), sym->GetScopeSlot());
}
}
this->scope = scope;
DebugOnly(scope->isRestored = true);
}
