| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| #include "Backend.h" |
| |
| /* =================================================================================== |
| * TempTracker runs the mark temp algorithm. The template parameter provides information |
| * what are valid temp use, temp transfer, or temp producing operations and what bit to |
| * set once a symbol def can be marked temp. |
| * |
| * NumberTemp mark temp JavascriptNumber creation for math operations, run during deadstore |
| * |
| * ObjectTemp mark temp object allocations, run during backward pass so that it can provide |
| * information to the globopt to install pre op bailout on implicit call while during stack |
| * allocation objects. |
| * |
| * ObjectTempVerify runs a similar mark temp during deadstore in debug mode to assert |
| * that globopt have install the pre op necessary and a marked temp def is still valid |
| * as a mark temp |
| * |
| * The basic of the mark temp algorithm is very simple: we keep track if we have seen |
| * any use of a symbol that is not a valid mark temp (the nonTempSyms bitvector) |
| * and on definition of the symbol, if the all the use allow temp object (not in nonTempSyms |
| * bitvector) then it is mark them able. |
| * |
| * However, the complication comes when the stack object is transferred to another symbol |
| * and we are in a loop. We need to make sure that the stack object isn't still referred |
| * by another symbol when we allocate the number/object in the next iteration |
| * |
| * For example: |
| * Loop top: |
| * s1 = NewScObject |
| * = s6 |
| * s6 = s1 |
| * Goto Loop top |
| * |
| * We cannot mark them this case because when s1 is created, the object might still be |
| * referred to by s6 from previous iteration, and thus if we mark them we would have |
| * change the content of s6 as well. |
| * |
| * To detect this dependency, we conservatively collect "all" transfers in the pre pass |
| * of the loop. We have to be conservative to detect reverse dependencies without |
| * iterating more than 2 times for the loop. |
| * =================================================================================== */ |
| |
| JitArenaAllocator * |
| TempTrackerBase::GetAllocator() const |
| { |
| return nonTempSyms.GetAllocator(); |
| } |
| |
| TempTrackerBase::TempTrackerBase(JitArenaAllocator * alloc, bool inLoop) |
| : nonTempSyms(alloc), tempTransferredSyms(alloc) |
| { |
| if (inLoop) |
| { |
| tempTransferDependencies = HashTable<BVSparse<JitArenaAllocator> *>::New(alloc, 16); |
| } |
| else |
| { |
| tempTransferDependencies = nullptr; |
| } |
| } |
| |
| TempTrackerBase::~TempTrackerBase() |
| { |
| if (this->tempTransferDependencies != nullptr) |
| { |
| JitArenaAllocator * alloc = this->GetAllocator(); |
| FOREACH_HASHTABLE_ENTRY(BVSparse<JitArenaAllocator> *, bucket, this->tempTransferDependencies) |
| { |
| JitAdelete(alloc, bucket.element); |
| } |
| NEXT_HASHTABLE_ENTRY; |
| this->tempTransferDependencies->Delete(); |
| } |
| } |
| void |
| TempTrackerBase::MergeData(TempTrackerBase * fromData, bool deleteData) |
| { |
| nonTempSyms.Or(&fromData->nonTempSyms); |
| tempTransferredSyms.Or(&fromData->tempTransferredSyms); |
| MergeDependencies(tempTransferDependencies, fromData->tempTransferDependencies, deleteData); |
| } |
| |
| void |
| TempTrackerBase::AddTransferDependencies(int sourceId, SymID dstSymID, HashTable<BVSparse<JitArenaAllocator> *> * dependencies) |
| { |
| // Add to the transfer dependencies set |
| BVSparse<JitArenaAllocator> ** pBVSparse = dependencies->FindOrInsertNew(sourceId); |
| if (*pBVSparse == nullptr) |
| { |
| *pBVSparse = JitAnew(this->GetAllocator(), BVSparse<JitArenaAllocator>, this->GetAllocator()); |
| } |
| AddTransferDependencies(*pBVSparse, dstSymID); |
| } |
| |
| void |
| TempTrackerBase::AddTransferDependencies(BVSparse<JitArenaAllocator> * bv, SymID dstSymID) |
| { |
| bv->Set(dstSymID); |
| |
| // Add the indirect transfers (always from tempTransferDependencies) |
| BVSparse<JitArenaAllocator> *dstBVSparse = this->tempTransferDependencies->GetAndClear(dstSymID); |
| if (dstBVSparse != nullptr) |
| { |
| bv->Or(dstBVSparse); |
| JitAdelete(this->GetAllocator(), dstBVSparse); |
| } |
| } |
| |
| template <typename T> |
| TempTracker<T>::TempTracker(JitArenaAllocator * alloc, bool inLoop): |
| T(alloc, inLoop) |
| { |
| } |
| |
| template <typename T> |
| void |
| TempTracker<T>::MergeData(TempTracker<T> * fromData, bool deleteData) |
| { |
| TempTrackerBase::MergeData(fromData, deleteData); |
| T::MergeData(fromData, deleteData); |
| |
| if (deleteData) |
| { |
| JitAdelete(this->GetAllocator(), fromData); |
| } |
| } |
| |
| void |
| TempTrackerBase::OrHashTableOfBitVector(HashTable<BVSparse<JitArenaAllocator> *> * toData, HashTable<BVSparse<JitArenaAllocator> *> *& fromData, bool deleteData) |
| { |
| Assert(toData != nullptr); |
| Assert(fromData != nullptr); |
| toData->Or(fromData, |
| [=](BVSparse<JitArenaAllocator> * bv1, BVSparse<JitArenaAllocator> * bv2) -> BVSparse<JitArenaAllocator> * |
| { |
| if (bv1 == nullptr) |
| { |
| if (deleteData) |
| { |
| return bv2; |
| } |
| return bv2->CopyNew(this->GetAllocator()); |
| } |
| bv1->Or(bv2); |
| if (deleteData) |
| { |
| JitAdelete(this->GetAllocator(), bv2); |
| } |
| return bv1; |
| }); |
| |
| if (deleteData) |
| { |
| fromData->Delete(); |
| fromData = nullptr; |
| } |
| } |
| |
| void |
| TempTrackerBase::MergeDependencies(HashTable<BVSparse<JitArenaAllocator> *> * toData, HashTable<BVSparse<JitArenaAllocator> *> *& fromData, bool deleteData) |
| { |
| if (fromData != nullptr) |
| { |
| if (toData != nullptr) |
| { |
| OrHashTableOfBitVector(toData, fromData, deleteData); |
| } |
| else if (deleteData) |
| { |
| FOREACH_HASHTABLE_ENTRY(BVSparse<JitArenaAllocator> *, bucket, fromData) |
| { |
| JitAdelete(this->GetAllocator(), bucket.element); |
| } |
| NEXT_HASHTABLE_ENTRY; |
| fromData->Delete(); |
| fromData = nullptr; |
| } |
| } |
| } |
| |
| #if DBG_DUMP |
| void |
| TempTrackerBase::Dump(char16 const * traceName) |
| { |
| Output::Print(_u("%s: Non temp syms:"), traceName); |
| this->nonTempSyms.Dump(); |
| Output::Print(_u("%s: Temp transferred syms:"), traceName); |
| this->tempTransferredSyms.Dump(); |
| if (this->tempTransferDependencies != nullptr) |
| { |
| Output::Print(_u("%s: Temp transfer dependencies:\n"), traceName); |
| this->tempTransferDependencies->Dump(); |
| } |
| } |
| #endif |
| |
| template <typename T> |
| void |
| TempTracker<T>::ProcessUse(StackSym * sym, BackwardPass * backwardPass) |
| { |
| // Don't care about type specialized syms |
| if (!sym->IsVar()) |
| { |
| return; |
| } |
| IR::Instr * instr = backwardPass->currentInstr; |
| SymID usedSymID = sym->m_id; |
| bool isTempPropertyTransferStore = T::IsTempPropertyTransferStore(instr, backwardPass); |
| bool isTempUse = isTempPropertyTransferStore || T::IsTempUse(instr, sym, backwardPass); |
| if (!isTempUse) |
| { |
| this->nonTempSyms.Set(usedSymID); |
| } |
| #if DBG |
| if (T::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s%4sTemp Use (s%-3d): "), T::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), isTempUse ? _u("") : _u("Non "), usedSymID); |
| instr->DumpSimple(); |
| Output::Flush(); |
| } |
| #endif |
| if (T::IsTempTransfer(instr)) |
| { |
| this->tempTransferredSyms.Set(usedSymID); |
| |
| // Track dependencies if we are in loop only |
| if (this->tempTransferDependencies != nullptr) |
| { |
| IR::Opnd * dstOpnd = instr->GetDst(); |
| if (dstOpnd->IsRegOpnd()) |
| { |
| SymID dstSymID = dstOpnd->AsRegOpnd()->m_sym->m_id; |
| |
| if (dstSymID != usedSymID) |
| { |
| // Record that the usedSymID may propagate to dstSymID and all the symbols |
| // that it may propagate to as well |
| this->AddTransferDependencies(usedSymID, dstSymID, this->tempTransferDependencies); |
| #if DBG_DUMP |
| if (T::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s s%d -> s%d: "), T::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), dstSymID, usedSymID); |
| (*this->tempTransferDependencies->Get(usedSymID))->Dump(); |
| } |
| #endif |
| } |
| } |
| } |
| } |
| |
| if (isTempPropertyTransferStore) |
| { |
| this->tempTransferredSyms.Set(usedSymID); |
| PropertySym * propertySym = instr->GetDst()->AsSymOpnd()->m_sym->AsPropertySym(); |
| this->PropagateTempPropertyTransferStoreDependencies(usedSymID, propertySym, backwardPass); |
| |
| #if DBG_DUMP |
| if (T::DoTrace(backwardPass) && this->tempTransferDependencies) |
| { |
| Output::Print(_u("%s: %8s (PropId:%d)+[] -> s%d: "), T::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), propertySym->m_propertyId, usedSymID); |
| BVSparse<JitArenaAllocator> ** transferDependencies = this->tempTransferDependencies->Get(usedSymID); |
| if (transferDependencies) |
| { |
| (*transferDependencies)->Dump(); |
| } |
| else |
| { |
| Output::Print(_u("[]\n")); |
| } |
| } |
| #endif |
| } |
| }; |
| |
| template <typename T> |
| void |
| TempTracker<T>::MarkTemp(StackSym * sym, BackwardPass * backwardPass) |
| { |
| // Don't care about type specialized syms |
| Assert(sym->IsVar()); |
| |
| IR::Instr * instr = backwardPass->currentInstr; |
| BOOLEAN nonTemp = this->nonTempSyms.TestAndClear(sym->m_id); |
| BOOLEAN isTempTransferred; |
| BVSparse<JitArenaAllocator> * bvTempTransferDependencies = nullptr; |
| |
| bool const isTransferOperation = |
| T::IsTempTransfer(instr) |
| || T::IsTempPropertyTransferLoad(instr, backwardPass) |
| || T::IsTempIndirTransferLoad(instr, backwardPass); |
| |
| if (this->tempTransferDependencies != nullptr) |
| { |
| // Since we don't iterate "while (!changed)" in loops, we don't have complete accurate dataflow |
| // for loop carried dependencies. So don't clear the dependency transfer info. WOOB:1121525 |
| |
| // Check if this dst is transferred (assigned) to another symbol |
| if (isTransferOperation) |
| { |
| isTempTransferred = this->tempTransferredSyms.Test(sym->m_id); |
| } |
| else |
| { |
| isTempTransferred = this->tempTransferredSyms.TestAndClear(sym->m_id); |
| } |
| |
| // We only need to look at the dependencies if we are in a loop because of the back edge |
| // Also we don't need to if we are in pre pass |
| if (isTempTransferred) |
| { |
| if (!backwardPass->IsPrePass()) |
| { |
| if (isTransferOperation) |
| { |
| // Transfer operation, load but not clear the information |
| BVSparse<JitArenaAllocator> **pBv = this->tempTransferDependencies->Get(sym->m_id); |
| if (pBv) |
| { |
| bvTempTransferDependencies = *pBv; |
| } |
| } |
| else |
| { |
| // Non transfer operation, load and clear the information and the dst value is replaced |
| bvTempTransferDependencies = this->tempTransferDependencies->GetAndClear(sym->m_id); |
| } |
| } |
| else if (!isTransferOperation) |
| { |
| // In pre pass, and not a transfer operation (just an assign). We can clear the dependency info |
| // and not look at it. |
| this->tempTransferDependencies->Clear(sym->m_id); |
| } |
| } |
| } |
| else |
| { |
| isTempTransferred = this->tempTransferredSyms.TestAndClear(sym->m_id); |
| } |
| |
| // Reset the dst is temp bit (we set it optimistically on the loop pre pass) |
| bool dstIsTemp = false; |
| bool dstIsTempTransferred = false; |
| |
| if (nonTemp) |
| { |
| #if DBG_DUMP |
| if (T::DoTrace(backwardPass) && !backwardPass->IsPrePass() && T::CanMarkTemp(instr, backwardPass)) |
| { |
| Output::Print(_u("%s: Not temp (s%-03d):"), T::GetTraceName(), sym->m_id); |
| instr->DumpSimple(); |
| } |
| #endif |
| } |
| else if (backwardPass->IsPrePass()) |
| { |
| // On pre pass, we don't have complete information about whether it is tempable or |
| // not from the back edge. If we already discovered that it is not a temp (above), then |
| // we don't mark it, other wise, assume that it is okay to be tempable and have the |
| // second pass set the bit correctly. The only works on dependency chain that is in order |
| // e.g. |
| // s1 = Add |
| // s2 = s1 |
| // s3 = s2 |
| // The dependencies tracking to catch the case whether the dependency chain is out of order |
| // e.g |
| // s1 = Add |
| // s3 = s2 |
| // s2 = s3 |
| |
| Assert(isTransferOperation == T::IsTempTransfer(instr) |
| || T::IsTempPropertyTransferLoad(instr, backwardPass) |
| || T::IsTempIndirTransferLoad(instr, backwardPass)); |
| if (isTransferOperation) |
| { |
| dstIsTemp = true; |
| } |
| } |
| else if (T::CanMarkTemp(instr, backwardPass)) |
| { |
| dstIsTemp = true; |
| |
| if (isTempTransferred) |
| { |
| // Track whether the dst is transferred or not, and allocate separate stack slot for them |
| // so that another dst will not overrides the value |
| dstIsTempTransferred = true; |
| |
| // The temp is aliased, need to trace if there is another use of the set of aliased |
| // sym that is still live so that we won't mark them this symbol and destroy the value |
| |
| if (bvTempTransferDependencies != nullptr) |
| { |
| // Inside a loop we need to track if any of the reg that we transferred to is still live |
| // s1 = Add |
| // = s2 |
| // s2 = s1 |
| // Since s2 is still live on the next iteration when we reassign s1, making s1 a temp |
| // will cause the value of s2 to change before it's use. |
| |
| // The upwardExposedUses are the live regs, check if it intersect with the set |
| // of dependency or not. |
| |
| #if DBG_DUMP |
| if (T::DoTrace(backwardPass) && Js::Configuration::Global.flags.Verbose) |
| { |
| Output::Print(_u("%s: Loop mark temp check instr:\n"), T::GetTraceName()); |
| instr->DumpSimple(); |
| Output::Print(_u("Transfer dependencies: ")); |
| bvTempTransferDependencies->Dump(); |
| Output::Print(_u("Upward exposed Uses : ")); |
| backwardPass->currentBlock->upwardExposedUses->Dump(); |
| Output::Print(_u("\n")); |
| } |
| #endif |
| |
| BVSparse<JitArenaAllocator> * upwardExposedUses = backwardPass->currentBlock->upwardExposedUses; |
| bool hasExposedDependencies = bvTempTransferDependencies->Test(upwardExposedUses) |
| || T::HasExposedFieldDependencies(bvTempTransferDependencies, backwardPass); |
| if (hasExposedDependencies) |
| { |
| #if DBG_DUMP |
| if (T::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: Not temp (s%-03d): "), T::GetTraceName(), sym->m_id); |
| instr->DumpSimple(); |
| Output::Print(_u(" Transferred exposed uses: ")); |
| JitArenaAllocator tempAllocator(_u("temp"), this->GetAllocator()->GetPageAllocator(), Js::Throw::OutOfMemory); |
| bvTempTransferDependencies->AndNew(upwardExposedUses, &tempAllocator)->Dump(); |
| } |
| #endif |
| |
| dstIsTemp = false; |
| dstIsTempTransferred = false; |
| #if DBG |
| if (IsObjectTempVerify<T>()) |
| { |
| dstIsTemp = ObjectTempVerify::DependencyCheck(instr, bvTempTransferDependencies, backwardPass); |
| } |
| #endif |
| // Only ObjectTmepVerify would do the do anything here. All other returns false |
| } |
| } |
| } |
| } |
| |
| T::SetDstIsTemp(dstIsTemp, dstIsTempTransferred, instr, backwardPass); |
| } |
| |
| NumberTemp::NumberTemp(JitArenaAllocator * alloc, bool inLoop) |
| : TempTrackerBase(alloc, inLoop), elemLoadDependencies(alloc), nonTempElemLoad(false), |
| upwardExposedMarkTempObjectLiveFields(alloc), upwardExposedMarkTempObjectSymsProperties(nullptr) |
| { |
| propertyIdsTempTransferDependencies = inLoop ? HashTable<BVSparse<JitArenaAllocator> *>::New(alloc, 16) : nullptr; |
| } |
| |
| void |
| NumberTemp::MergeData(NumberTemp * fromData, bool deleteData) |
| { |
| nonTempElemLoad = nonTempElemLoad || fromData->nonTempElemLoad; |
| if (!nonTempElemLoad) // Don't bother merging other data if we already have a nonTempElemLoad |
| { |
| if (IsInLoop()) |
| { |
| // in loop |
| elemLoadDependencies.Or(&fromData->elemLoadDependencies); |
| } |
| MergeDependencies(propertyIdsTempTransferDependencies, fromData->propertyIdsTempTransferDependencies, deleteData); |
| |
| if (fromData->upwardExposedMarkTempObjectSymsProperties) |
| { |
| if (upwardExposedMarkTempObjectSymsProperties) |
| { |
| OrHashTableOfBitVector(upwardExposedMarkTempObjectSymsProperties, fromData->upwardExposedMarkTempObjectSymsProperties, deleteData); |
| } |
| else if (deleteData) |
| { |
| upwardExposedMarkTempObjectSymsProperties = fromData->upwardExposedMarkTempObjectSymsProperties; |
| fromData->upwardExposedMarkTempObjectSymsProperties = nullptr; |
| } |
| else |
| { |
| upwardExposedMarkTempObjectSymsProperties = HashTable<BVSparse<JitArenaAllocator> *>::New(this->GetAllocator(), 16); |
| OrHashTableOfBitVector(upwardExposedMarkTempObjectSymsProperties, fromData->upwardExposedMarkTempObjectSymsProperties, deleteData); |
| } |
| } |
| |
| upwardExposedMarkTempObjectLiveFields.Or(&fromData->upwardExposedMarkTempObjectLiveFields); |
| } |
| } |
| |
| bool |
| NumberTemp::IsTempUse(IR::Instr * instr, Sym * sym, BackwardPass * backwardPass) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| if (OpCodeAttr::NonTempNumberSources(opcode) |
| || (OpCodeAttr::TempNumberTransfer(opcode) && !instr->dstIsTempNumber)) |
| { |
| // For TypedArray stores, we don't store the Var object, so MarkTemp is valid |
| if (opcode != Js::OpCode::StElemI_A |
| || !instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->GetValueType().IsLikelyOptimizedTypedArray()) |
| { |
| // Mark the symbol as non-tempable if the instruction doesn't allow temp sources, |
| // or it is transferred to a non-temp dst |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool |
| NumberTemp::IsTempTransfer(IR::Instr * instr) |
| { |
| return OpCodeAttr::TempNumberTransfer(instr->m_opcode); |
| } |
| |
| bool |
| NumberTemp::IsTempProducing(IR::Instr * instr) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| if (OpCodeAttr::TempNumberProducing(opcode)) |
| { |
| return true; |
| } |
| |
| // Loads from float typedArrays usually require a conversion to Var, which we can MarkTemp. |
| if (opcode == Js::OpCode::LdElemI_A) |
| { |
| const ValueType baseValueType(instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()->GetValueType()); |
| if (baseValueType.IsLikelyObject() |
| && (baseValueType.GetObjectType() == ObjectType::Float32Array |
| || baseValueType.GetObjectType() == ObjectType::Float64Array)) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool |
| NumberTemp::CanMarkTemp(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| if (IsTempTransfer(instr) || IsTempProducing(instr)) |
| { |
| return true; |
| } |
| |
| // REVIEW: this is added a long time ago, and I am not sure what this is for any more. |
| if (OpCodeAttr::InlineCallInstr(instr->m_opcode)) |
| { |
| return true; |
| } |
| |
| if (NumberTemp::IsTempIndirTransferLoad(instr, backwardPass) |
| || NumberTemp::IsTempPropertyTransferLoad(instr, backwardPass)) |
| { |
| return true; |
| } |
| |
| // the opcode is not temp producing or a transfer, this is not a tmp |
| // Also mark calls which may get inlined. |
| return false; |
| } |
| |
| void |
| NumberTemp::ProcessInstr(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| #if DBG |
| if (instr->m_opcode == Js::OpCode::BailOnNoProfile) |
| { |
| // If we see BailOnNoProfile, we shouldn't have any successor to have any non temp syms |
| Assert(!this->nonTempElemLoad); |
| Assert(this->nonTempSyms.IsEmpty()); |
| Assert(this->tempTransferredSyms.IsEmpty()); |
| Assert(this->elemLoadDependencies.IsEmpty()); |
| Assert(this->upwardExposedMarkTempObjectLiveFields.IsEmpty()); |
| } |
| #endif |
| |
| // We don't get to process all dst in MarkTemp. Do it here for the upwardExposedMarkTempObjectLiveFields |
| if (!this->DoMarkTempNumbersOnTempObjects(backwardPass)) |
| { |
| return; |
| } |
| |
| IR::Opnd * dst = instr->GetDst(); |
| if (dst == nullptr || !dst->IsRegOpnd()) |
| { |
| return; |
| } |
| StackSym * dstSym = dst->AsRegOpnd()->m_sym; |
| if (!dstSym->IsVar()) |
| { |
| dstSym = dstSym->GetVarEquivSym(nullptr); |
| if (dstSym == nullptr) |
| { |
| return; |
| } |
| } |
| |
| SymID dstSymId = dstSym->m_id; |
| if (this->upwardExposedMarkTempObjectSymsProperties) |
| { |
| // We are assigning to dstSym, it no longer has upward exposed use, get the information and clear it from the hash table |
| BVSparse<JitArenaAllocator> * dstBv = this->upwardExposedMarkTempObjectSymsProperties->GetAndClear(dstSymId); |
| if (dstBv) |
| { |
| // Clear the upward exposed live fields of all the property sym id associated to dstSym |
| this->upwardExposedMarkTempObjectLiveFields.Minus(dstBv); |
| if (ObjectTemp::IsTempTransfer(instr) && instr->GetSrc1()->IsRegOpnd()) |
| { |
| // If it is transfer, copy the dst info to the src |
| SymID srcStackSymId = instr->GetSrc1()->AsRegOpnd()->m_sym->AsStackSym()->m_id; |
| |
| SymTable * symTable = backwardPass->func->m_symTable; |
| FOREACH_BITSET_IN_SPARSEBV(index, dstBv) |
| { |
| PropertySym * propertySym = symTable->FindPropertySym(srcStackSymId, index); |
| if (propertySym) |
| { |
| this->upwardExposedMarkTempObjectLiveFields.Set(propertySym->m_id); |
| } |
| } |
| NEXT_BITSET_IN_SPARSEBV; |
| |
| BVSparse<JitArenaAllocator> ** srcBv = this->upwardExposedMarkTempObjectSymsProperties->FindOrInsert(dstBv, srcStackSymId); |
| if (srcBv) |
| { |
| (*srcBv)->Or(dstBv); |
| JitAdelete(this->GetAllocator(), dstBv); |
| } |
| } |
| else |
| { |
| JitAdelete(this->GetAllocator(), dstBv); |
| } |
| } |
| } |
| } |
| |
| void |
| NumberTemp::SetDstIsTemp(bool dstIsTemp, bool dstIsTempTransferred, IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| Assert(dstIsTemp || !dstIsTempTransferred); |
| Assert(!instr->dstIsTempNumberTransferred); |
| instr->dstIsTempNumber = dstIsTemp; |
| instr->dstIsTempNumberTransferred = dstIsTempTransferred; |
| #if DBG_DUMP |
| if (!backwardPass->IsPrePass() && IsTempProducing(instr)) |
| { |
| backwardPass->numMarkTempNumber += dstIsTemp; |
| backwardPass->numMarkTempNumberTransferred += dstIsTempTransferred; |
| } |
| #endif |
| } |
| |
| bool |
| NumberTemp::IsTempPropertyTransferLoad(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| if (DoMarkTempNumbersOnTempObjects(backwardPass)) |
| { |
| switch (instr->m_opcode) |
| { |
| case Js::OpCode::LdFld: |
| case Js::OpCode::LdFldForTypeOf: |
| case Js::OpCode::LdMethodFld: |
| case Js::OpCode::LdFldForCallApplyTarget: |
| case Js::OpCode::LdMethodFromFlags: |
| { |
| // Only care about load from possible stack allocated object. |
| return instr->GetSrc1()->CanStoreTemp(); |
| } |
| }; |
| |
| // All other opcode shouldn't have sym opnd that can store temp, See ObjectTemp::IsTempUseOpCodeSym. |
| Assert(instr->GetSrc1() == nullptr |
| || instr->GetDst() == nullptr // this isn't a value loading instruction |
| || instr->GetSrc1()->IsIndirOpnd() // this is detected in IsTempIndirTransferLoad |
| || !instr->GetSrc1()->CanStoreTemp()); |
| } |
| return false; |
| } |
| |
| bool |
| NumberTemp::IsTempPropertyTransferStore(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| if (DoMarkTempNumbersOnTempObjects(backwardPass)) |
| { |
| switch (instr->m_opcode) |
| { |
| case Js::OpCode::InitFld: |
| case Js::OpCode::StFld: |
| case Js::OpCode::StFldStrict: |
| { |
| IR::Opnd * dst = instr->GetDst(); |
| Assert(dst->IsSymOpnd()); |
| if (!dst->CanStoreTemp()) |
| { |
| return false; |
| } |
| // We don't mark temp store of numeric properties (e.g. object literal { 86: foo }); |
| // This should only happen for InitFld, as StFld should have changed to StElem |
| PropertySym *propertySym = dst->AsSymOpnd()->m_sym->AsPropertySym(); |
| SymID propertySymId = this->GetRepresentativePropertySymId(propertySym, backwardPass); |
| return !this->nonTempSyms.Test(propertySymId) && |
| !instr->m_func->GetThreadContextInfo()->IsNumericProperty(propertySym->m_propertyId); |
| } |
| }; |
| |
| // All other opcode shouldn't have sym opnd that can store temp, see ObjectTemp::IsTempUseOpCodeSym. |
| // We also never mark the dst indir as can store temp for StElemI_A because we don't know what property |
| // it is storing in (or it could be an array index). |
| Assert(instr->GetDst() == nullptr || !instr->GetDst()->CanStoreTemp()); |
| } |
| return false; |
| } |
| |
| bool |
| NumberTemp::IsTempIndirTransferLoad(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| if (DoMarkTempNumbersOnTempObjects(backwardPass)) |
| { |
| if (instr->m_opcode == Js::OpCode::LdElemI_A) |
| { |
| // If the index is an int, then we don't care about the non-temp use |
| IR::Opnd * src1Opnd = instr->GetSrc1(); |
| IR::RegOpnd * indexOpnd = src1Opnd->AsIndirOpnd()->GetIndexOpnd(); |
| if (indexOpnd && (indexOpnd->m_sym->m_isNotInt || !indexOpnd->GetValueType().IsInt())) |
| { |
| return src1Opnd->CanStoreTemp(); |
| } |
| } |
| else |
| { |
| // All other opcode shouldn't have sym opnd that can store temp, See ObjectTemp::IsTempUseOpCodeSym. |
| Assert(instr->GetSrc1() == nullptr || instr->GetSrc1()->IsSymOpnd() |
| || !instr->GetSrc1()->CanStoreTemp()); |
| } |
| } |
| return false; |
| } |
| void |
| NumberTemp::PropagateTempPropertyTransferStoreDependencies(SymID usedSymID, PropertySym * propertySym, BackwardPass * backwardPass) |
| { |
| Assert(!this->nonTempElemLoad); |
| upwardExposedMarkTempObjectLiveFields.Clear(propertySym->m_id); |
| |
| if (!this->IsInLoop()) |
| { |
| // Don't need to track dependencies outside of loop, as we already marked the |
| // use as temp transfer already and we won't have a case where the "dst" is reused again (outside of loop) |
| return; |
| } |
| |
| Assert(this->tempTransferDependencies != nullptr); |
| SymID dstSymID = this->GetRepresentativePropertySymId(propertySym, backwardPass); |
| AddTransferDependencies(usedSymID, dstSymID, this->tempTransferDependencies); |
| |
| Js::PropertyId storedPropertyId = propertySym->m_propertyId; |
| // The symbol this properties are transferred to |
| BVSparse<JitArenaAllocator> ** pPropertyTransferDependencies = this->propertyIdsTempTransferDependencies->Get(storedPropertyId); |
| BVSparse<JitArenaAllocator> * transferDependencies = nullptr; |
| if (pPropertyTransferDependencies == nullptr) |
| { |
| if (elemLoadDependencies.IsEmpty()) |
| { |
| // No dependencies to transfer |
| return; |
| } |
| |
| transferDependencies = &elemLoadDependencies; |
| } |
| else |
| { |
| transferDependencies = *pPropertyTransferDependencies; |
| } |
| |
| BVSparse<JitArenaAllocator> ** pBVSparse = this->tempTransferDependencies->FindOrInsertNew(usedSymID); |
| if (*pBVSparse == nullptr) |
| { |
| *pBVSparse = transferDependencies->CopyNew(this->GetAllocator()); |
| } |
| else |
| { |
| (*pBVSparse)->Or(transferDependencies); |
| } |
| |
| if (transferDependencies != &elemLoadDependencies) |
| { |
| // Always include the element load dependencies as well |
| (*pBVSparse)->Or(&elemLoadDependencies); |
| } |
| |
| // Track the propertySym as well for the case where the dependence is not carried by the use |
| // Loop1 |
| // o.x = e |
| // Loop2 |
| // f = o.x |
| // = f |
| // e = e + blah |
| // Here, although we can detect that e and f has dependent relationship, f's life time doesn't cross with e's. |
| // But o.x will keep the value of e alive, so e can't be mark temp because o.x is still in use (not f) |
| // We will add the property sym int he dependency set and check with the upward exposed mark temp object live fields |
| // that we keep track of in NumberTemp |
| (*pBVSparse)->Set(propertySym->m_id); |
| } |
| |
| SymID |
| NumberTemp::GetRepresentativePropertySymId(PropertySym * propertySym, BackwardPass * backwardPass) |
| { |
| // Since we don't track alias with objects, all property accesses are all grouped together. |
| // Use a single property sym id to represent a propertyId to track dependencies. |
| SymID symId; |
| Js::PropertyId propertyId = propertySym->m_propertyId; |
| if (!backwardPass->numberTempRepresentativePropertySym->TryGetValue(propertyId, &symId)) |
| { |
| symId = propertySym->m_id; |
| backwardPass->numberTempRepresentativePropertySym->Add(propertyId, symId); |
| } |
| return symId; |
| } |
| |
| void |
| NumberTemp::ProcessIndirUse(IR::IndirOpnd * indirOpnd, IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| Assert(backwardPass->DoMarkTempNumbersOnTempObjects()); |
| if (!NumberTemp::IsTempIndirTransferLoad(instr, backwardPass)) |
| { |
| return; |
| } |
| |
| bool isTempUse = instr->dstIsTempNumber; |
| if (!isTempUse) |
| { |
| nonTempElemLoad = true; |
| } |
| else if (this->IsInLoop()) |
| { |
| // We didn't already detect non temp use of this property id. so we should track the dependencies in loops |
| IR::Opnd * dstOpnd = instr->GetDst(); |
| Assert(dstOpnd->IsRegOpnd()); |
| SymID dstSymID = dstOpnd->AsRegOpnd()->m_sym->m_id; |
| |
| // Use the no property id as a place holder for elem dependencies |
| AddTransferDependencies(&elemLoadDependencies, dstSymID); |
| #if DBG_DUMP |
| if (NumberTemp::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s s%d -> []: "), NumberTemp::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), dstSymID); |
| elemLoadDependencies.Dump(); |
| } |
| #endif |
| } |
| |
| #if DBG_DUMP |
| if (NumberTemp::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s%4sTemp Use ([] )"), NumberTemp::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), isTempUse ? _u("") : _u("Non ")); |
| instr->DumpSimple(); |
| } |
| #endif |
| } |
| |
| void |
| NumberTemp::ProcessPropertySymUse(IR::SymOpnd * symOpnd, IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| Assert(backwardPass->DoMarkTempNumbersOnTempObjects()); |
| |
| // We only care about instruction that may transfer the property value |
| if (!NumberTemp::IsTempPropertyTransferLoad(instr, backwardPass)) |
| { |
| return; |
| } |
| |
| PropertySym * propertySym = symOpnd->m_sym->AsPropertySym(); |
| upwardExposedMarkTempObjectLiveFields.Set(propertySym->m_id); |
| if (upwardExposedMarkTempObjectSymsProperties == nullptr) |
| { |
| upwardExposedMarkTempObjectSymsProperties = HashTable<BVSparse<JitArenaAllocator> *>::New(this->GetAllocator(), 16); |
| } |
| BVSparse<JitArenaAllocator> ** bv = upwardExposedMarkTempObjectSymsProperties->FindOrInsertNew(propertySym->m_stackSym->m_id); |
| if (*bv == nullptr) |
| { |
| *bv = JitAnew(this->GetAllocator(), BVSparse<JitArenaAllocator>, this->GetAllocator()); |
| } |
| (*bv)->Set(propertySym->m_propertyId); |
| |
| SymID propertySymId = this->GetRepresentativePropertySymId(propertySym, backwardPass); |
| bool isTempUse = instr->dstIsTempNumber; |
| if (!isTempUse) |
| { |
| // Use of the value is non temp, track the property ID's property representative sym so we don't mark temp |
| // assignment to this property on stack objects. |
| this->nonTempSyms.Set(propertySymId); |
| } |
| else if (this->IsInLoop() && !this->nonTempSyms.Test(propertySymId)) |
| { |
| // We didn't already detect non temp use of this property id. so we should track the dependencies in loops |
| IR::Opnd * dstOpnd = instr->GetDst(); |
| Assert(dstOpnd->IsRegOpnd()); |
| SymID dstSymID = dstOpnd->AsRegOpnd()->m_sym->m_id; |
| AddTransferDependencies(propertySym->m_propertyId, dstSymID, this->propertyIdsTempTransferDependencies); |
| #if DBG_DUMP |
| if (NumberTemp::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s s%d -> PropId:%d: "), NumberTemp::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), dstSymID, propertySym->m_propertyId); |
| (*this->propertyIdsTempTransferDependencies->Get(propertySym->m_propertyId))->Dump(); |
| } |
| #endif |
| } |
| |
| #if DBG_DUMP |
| if (NumberTemp::DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: %8s%4sTemp Use (PropId:%d)"), NumberTemp::GetTraceName(), |
| backwardPass->IsPrePass() ? _u("Prepass ") : _u(""), isTempUse ? _u("") : _u("Non "), propertySym->m_propertyId); |
| instr->DumpSimple(); |
| } |
| #endif |
| } |
| |
| |
| bool |
| NumberTemp::HasExposedFieldDependencies(BVSparse<JitArenaAllocator> * bvTempTransferDependencies, BackwardPass * backwardPass) |
| { |
| if (!DoMarkTempNumbersOnTempObjects(backwardPass)) |
| { |
| return false; |
| } |
| return bvTempTransferDependencies->Test(&upwardExposedMarkTempObjectLiveFields); |
| } |
| |
| bool |
| NumberTemp::DoMarkTempNumbersOnTempObjects(BackwardPass * backwardPass) const |
| { |
| return backwardPass->DoMarkTempNumbersOnTempObjects() && !this->nonTempElemLoad; |
| } |
| |
| #if DBG |
| void |
| NumberTemp::Dump(char16 const * traceName) |
| { |
| if (nonTempElemLoad) |
| { |
| Output::Print(_u("%s: Has Non Temp Elem Load\n"), traceName); |
| } |
| else |
| { |
| Output::Print(_u("%s: Non Temp Syms"), traceName); |
| this->nonTempSyms.Dump(); |
| if (this->propertyIdsTempTransferDependencies != nullptr) |
| { |
| Output::Print(_u("%s: Temp transfer propertyId dependencies:\n"), traceName); |
| this->propertyIdsTempTransferDependencies->Dump(); |
| } |
| } |
| } |
| #endif |
| //================================================================================================= |
| // ObjectTemp |
| //================================================================================================= |
| bool |
| ObjectTemp::IsTempUse(IR::Instr * instr, Sym * sym, BackwardPass * backwardPass) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| |
| // If the opcode has implicit call and the profile say we have implicit call, then it is not a temp use |
| // TODO: More precise implicit call tracking |
| if (instr->HasAnyImplicitCalls() |
| && |
| ((backwardPass->currentBlock->loop != nullptr ? |
| !GlobOpt::ImplicitCallFlagsAllowOpts(backwardPass->currentBlock->loop) : |
| !GlobOpt::ImplicitCallFlagsAllowOpts(backwardPass->func)) |
| || instr->CallsAccessor()) |
| ) |
| { |
| return false; |
| } |
| |
| return IsTempUseOpCodeSym(instr, opcode, sym); |
| } |
| |
| bool |
| ObjectTemp::IsTempUseOpCodeSym(IR::Instr * instr, Js::OpCode opcode, Sym * sym) |
| { |
| // Special case ArgOut_A which communicate information about CallDirect |
| switch (opcode) |
| { |
| case Js::OpCode::LdLen_A: |
| return instr->GetSrc1()->AsRegOpnd()->GetStackSym() == sym; |
| case Js::OpCode::ArgOut_A: |
| return instr->dstIsTempObject; |
| case Js::OpCode::LdFld: |
| case Js::OpCode::LdFldForTypeOf: |
| case Js::OpCode::LdMethodFld: |
| case Js::OpCode::LdFldForCallApplyTarget: |
| case Js::OpCode::LdMethodFromFlags: |
| return instr->GetSrc1()->AsPropertySymOpnd()->GetObjectSym() == sym; |
| case Js::OpCode::InitFld: |
| if (Js::PropertyRecord::DefaultAttributesForPropertyId( |
| instr->GetDst()->AsPropertySymOpnd()->GetPropertySym()->m_propertyId, true) & PropertyDeleted) |
| { |
| // If the property record is marked PropertyDeleted, the InitFld will cause a type handler conversion, |
| // which may result in creation of a weak reference to the object itself. |
| return false; |
| } |
| // Fall through |
| case Js::OpCode::StFld: |
| case Js::OpCode::StFldStrict: |
| return |
| !(instr->GetSrc1() && instr->GetSrc1()->GetStackSym() == sym) && |
| !(instr->GetSrc2() && instr->GetSrc2()->GetStackSym() == sym) && |
| instr->GetDst()->AsPropertySymOpnd()->GetObjectSym() == sym; |
| case Js::OpCode::LdElemI_A: |
| return instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()->m_sym == sym; |
| case Js::OpCode::StElemI_A: |
| case Js::OpCode::StElemI_A_Strict: |
| return instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->m_sym == sym; |
| case Js::OpCode::Memset: |
| return instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->m_sym == sym || (instr->GetSrc1()->IsRegOpnd() && instr->GetSrc1()->AsRegOpnd()->m_sym == sym); |
| case Js::OpCode::Memcopy: |
| return instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->m_sym == sym || instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()->m_sym == sym; |
| |
| // Special case FromVar for now until we can allow CallsValueOf opcode to be accept temp use |
| case Js::OpCode::FromVar: |
| return true; |
| } |
| |
| // TODO: Currently, when we disable implicit call, we still don't allow valueOf/toString that has no side effects |
| // So we shouldn't mark them if we have use of the sym on opcode that does OpndHasImplicitCall yet. |
| if (OpCodeAttr::OpndHasImplicitCall(opcode)) |
| { |
| return false; |
| } |
| |
| // Mark the symbol as non-tempable if the instruction doesn't allow temp sources, |
| // or it is transferred to a non-temp dst |
| return (OpCodeAttr::TempObjectSources(opcode) |
| && (!OpCodeAttr::TempObjectTransfer(opcode) || instr->dstIsTempObject)); |
| } |
| |
| bool |
| ObjectTemp::IsTempTransfer(IR::Instr * instr) |
| { |
| return OpCodeAttr::TempObjectTransfer(instr->m_opcode); |
| } |
| |
| bool |
| ObjectTemp::IsTempProducing(IR::Instr * instr) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| if (OpCodeAttr::TempObjectProducing(opcode)) |
| { |
| return true; |
| } |
| |
| // TODO: Process NewScObject and CallI with isCtorCall when the ctor is fixed |
| return false; |
| } |
| |
| bool |
| ObjectTemp::CanStoreTemp(IR::Instr * instr) |
| { |
| // In order to allow storing temp number on temp objects, |
| // We have to make sure that if the instr is marked as dstIsTempObject |
| // we will always generate the code to allocate the object on the stack (so no helper call). |
| // Currently, we only do this for NewRegEx, NewScObjectSimple, NewScObjectLiteral and |
| // NewScObjectNoCtor (where the ctor is inlined). |
| |
| // CONSIDER: review lowering of other TempObjectProducing opcode and see if we can always allocate on the stack |
| // (for example, NewScArray should be able to, but plain NewScObject can't because the size depends on the |
| // number inline slots) |
| Js::OpCode opcode = instr->m_opcode; |
| if (OpCodeAttr::TempObjectCanStoreTemp(opcode)) |
| { |
| // Special cases where stack allocation doesn't happen |
| #if ENABLE_REGEX_CONFIG_OPTIONS |
| if (opcode == Js::OpCode::NewRegEx && REGEX_CONFIG_FLAG(RegexTracing)) |
| { |
| return false; |
| } |
| #endif |
| if (opcode == Js::OpCode::NewScObjectNoCtor) |
| { |
| if (PHASE_OFF(Js::FixedNewObjPhase, instr->m_func) && PHASE_OFF(Js::ObjTypeSpecNewObjPhase, instr->m_func->GetTopFunc())) |
| { |
| return false; |
| } |
| |
| // Only if we have BailOutFailedCtorGuardCheck would we generate a stack object. |
| // Otherwise we will call the helper, which will not generate stack object. |
| return instr->HasBailOutInfo(); |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| ObjectTemp::CanMarkTemp(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| // We mark the ArgOut with the call in ProcessInstr, no need to do it here |
| return IsTempProducing(instr) || IsTempTransfer(instr); |
| } |
| |
| void |
| ObjectTemp::ProcessBailOnNoProfile(IR::Instr * instr) |
| { |
| Assert(instr->m_opcode == Js::OpCode::BailOnNoProfile); |
| |
| // ObjectTemp is done during Backward pass, which hasn't change all succ to BailOnNoProfile |
| // to dead yet, so we need to manually clear all the information |
| this->nonTempSyms.ClearAll(); |
| this->tempTransferredSyms.ClearAll(); |
| if (this->tempTransferDependencies) |
| { |
| this->tempTransferDependencies->ClearAll(); |
| } |
| } |
| |
| void |
| ObjectTemp::ProcessInstr(IR::Instr * instr) |
| { |
| if (instr->m_opcode != Js::OpCode::CallDirect) |
| { |
| return; |
| } |
| |
| IR::HelperCallOpnd * helper = instr->GetSrc1()->AsHelperCallOpnd(); |
| switch (helper->m_fnHelper) |
| { |
| case IR::JnHelperMethod::HelperString_Match: |
| case IR::JnHelperMethod::HelperString_Replace: |
| { |
| // First (non-this) parameter is either a regexp or search string. |
| // It doesn't escape. |
| IR::Instr * instrArgDef; |
| instr->FindCallArgumentOpnd(2, &instrArgDef); |
| instrArgDef->dstIsTempObject = true; |
| break; |
| } |
| |
| case IR::JnHelperMethod::HelperRegExp_Exec: |
| { |
| IR::Instr * instrArgDef; |
| instr->FindCallArgumentOpnd(1, &instrArgDef); |
| instrArgDef->dstIsTempObject = true; |
| break; |
| } |
| }; |
| } |
| |
| |
| void |
| ObjectTemp::SetDstIsTemp(bool dstIsTemp, bool dstIsTempTransferred, IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| Assert(dstIsTemp || !dstIsTempTransferred); |
| |
| // ArgOut_A are marked by CallDirect and don't need to be set |
| if (instr->m_opcode == Js::OpCode::ArgOut_A) |
| { |
| return; |
| } |
| instr->dstIsTempObject = dstIsTemp; |
| |
| if (!backwardPass->IsPrePass()) |
| { |
| if (OpCodeAttr::TempObjectProducing(instr->m_opcode)) |
| { |
| backwardPass->func->SetHasMarkTempObjects(); |
| #if DBG_DUMP |
| backwardPass->numMarkTempObject += dstIsTemp; |
| #endif |
| } |
| } |
| } |
| |
| StackSym * |
| ObjectTemp::GetStackSym(IR::Opnd * opnd, IR::PropertySymOpnd ** pPropertySymOpnd) |
| { |
| StackSym * stackSym = nullptr; |
| switch (opnd->GetKind()) |
| { |
| case IR::OpndKindReg: |
| stackSym = opnd->AsRegOpnd()->m_sym; |
| break; |
| case IR::OpndKindSym: |
| { |
| IR::SymOpnd * symOpnd = opnd->AsSymOpnd(); |
| if (symOpnd->IsPropertySymOpnd()) |
| { |
| IR::PropertySymOpnd * propertySymOpnd = symOpnd->AsPropertySymOpnd(); |
| *pPropertySymOpnd = propertySymOpnd; |
| stackSym = propertySymOpnd->GetObjectSym(); |
| } |
| else if (symOpnd->m_sym->IsPropertySym()) |
| { |
| stackSym = symOpnd->m_sym->AsPropertySym()->m_stackSym; |
| } |
| break; |
| } |
| case IR::OpndKindIndir: |
| stackSym = opnd->AsIndirOpnd()->GetBaseOpnd()->m_sym; |
| break; |
| }; |
| return stackSym; |
| } |
| |
| #if DBG |
| //================================================================================================= |
| // ObjectTempVerify |
| //================================================================================================= |
| ObjectTempVerify::ObjectTempVerify(JitArenaAllocator * alloc, bool inLoop) |
| : TempTrackerBase(alloc, inLoop), removedUpwardExposedUse(alloc) |
| { |
| } |
| |
| |
| bool |
| ObjectTempVerify::IsTempUse(IR::Instr * instr, Sym * sym, BackwardPass * backwardPass) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| |
| // If the opcode has implicit call and the profile say we have implicit call, then it is not a temp use. |
| // TODO: More precise implicit call tracking |
| bool isLandingPad = backwardPass->currentBlock->IsLandingPad(); |
| if (OpCodeAttr::HasImplicitCall(opcode) && !isLandingPad |
| && |
| ((backwardPass->currentBlock->loop != nullptr ? |
| !GlobOpt::ImplicitCallFlagsAllowOpts(backwardPass->currentBlock->loop) : |
| !GlobOpt::ImplicitCallFlagsAllowOpts(backwardPass->func)) |
| || instr->CallsAccessor()) |
| ) |
| { |
| return false; |
| } |
| |
| if (!ObjectTemp::IsTempUseOpCodeSym(instr, opcode, sym)) |
| { |
| // the opcode and sym is not a temp use, just return |
| return false; |
| } |
| |
| // In the backward pass, this would have been a temp use already. Continue to verify |
| // if we have install sufficient bailout on implicit call |
| |
| if (isLandingPad || !GlobOpt::MayNeedBailOnImplicitCall(instr, nullptr, nullptr)) |
| { |
| // Implicit call would not happen, or we are in the landing pad where implicit call is disabled. |
| return true; |
| } |
| |
| if (instr->HasBailOutInfo()) |
| { |
| // make sure we have mark the bailout for mark temp object, |
| // so that we won't optimize it away in DeadStoreImplicitCalls |
| return ((instr->GetBailOutKind() & IR::BailOutMarkTempObject) != 0); |
| } |
| |
| // Review (ObjTypeSpec): This is a bit conservative now that we don't revert from obj type specialized operations to live cache |
| // access even if the operation is isolated. Once we decide a given instruction is an object type spec candidate, we know it |
| // will never need an implicit call, so we could basically do opnd->IsObjTypeSpecOptimized() here, instead. |
| if (GlobOpt::IsTypeCheckProtected(instr)) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool |
| ObjectTempVerify::IsTempTransfer(IR::Instr * instr) |
| { |
| if (ObjectTemp::IsTempTransfer(instr) |
| // Add the Ld_I4, and LdC_A_I4 as the forward pass might have changed Ld_A to these |
| || instr->m_opcode == Js::OpCode::Ld_I4 |
| || instr->m_opcode == Js::OpCode::LdC_A_I4) |
| { |
| if (!instr->dstIsTempObject && instr->GetDst() && instr->GetDst()->IsRegOpnd() |
| && instr->GetDst()->AsRegOpnd()->GetValueType().IsNotObject()) |
| { |
| // Globopt has proved that dst is not an object, so this is not really an object transfer. |
| // This prevents the case where glob opt turned a Conv_Num to Ld_A and expose additional |
| // transfer. |
| return false; |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| ObjectTempVerify::CanMarkTemp(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| // We mark the ArgOut with the call in ProcessInstr, no need to do it here |
| return ObjectTemp::IsTempProducing(instr) |
| || IsTempTransfer(instr); |
| } |
| |
| void |
| ObjectTempVerify::ProcessInstr(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| if (instr->m_opcode == Js::OpCode::InlineThrow) |
| { |
| // We cannot accurately track mark temp for any upward exposed symbol here |
| this->removedUpwardExposedUse.Or(backwardPass->currentBlock->byteCodeUpwardExposedUsed); |
| return; |
| } |
| |
| if (instr->m_opcode != Js::OpCode::CallDirect) |
| { |
| return; |
| } |
| |
| IR::HelperCallOpnd * helper = instr->GetSrc1()->AsHelperCallOpnd(); |
| switch (helper->m_fnHelper) |
| { |
| case IR::JnHelperMethod::HelperString_Match: |
| case IR::JnHelperMethod::HelperString_Replace: |
| { |
| // First (non-this) parameter is either a regexp or search string |
| // It doesn't escape |
| IR::Instr * instrArgDef; |
| instr->FindCallArgumentOpnd(2, &instrArgDef); |
| Assert(instrArgDef->dstIsTempObject); |
| break; |
| } |
| |
| case IR::JnHelperMethod::HelperRegExp_Exec: |
| { |
| IR::Instr * instrArgDef; |
| instr->FindCallArgumentOpnd(1, &instrArgDef); |
| Assert(instrArgDef->dstIsTempObject); |
| break; |
| } |
| }; |
| } |
| |
| |
| void |
| ObjectTempVerify::SetDstIsTemp(bool dstIsTemp, bool dstIsTempTransferred, IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| Assert(dstIsTemp || !dstIsTempTransferred); |
| |
| // ArgOut_A are marked by CallDirect and don't need to be set |
| if (instr->m_opcode == Js::OpCode::ArgOut_A) |
| { |
| return; |
| } |
| |
| if (OpCodeAttr::TempObjectProducing(instr->m_opcode)) |
| { |
| if (!backwardPass->IsPrePass()) |
| { |
| if (dstIsTemp) |
| { |
| // Don't assert if we have detected a removed upward exposed use that could |
| // expose a new mark temp object. Don't assert if it is set in removedUpwardExposedUse |
| bool isBailOnNoProfileUpwardExposedUse = |
| !!this->removedUpwardExposedUse.Test(instr->GetDst()->AsRegOpnd()->m_sym->m_id); |
| #if DBG |
| if (DoTrace(backwardPass) && !instr->dstIsTempObject && !isBailOnNoProfileUpwardExposedUse) |
| { |
| Output::Print(_u("%s: Missed Mark Temp Object: "), GetTraceName()); |
| instr->DumpSimple(); |
| Output::Flush(); |
| } |
| #endif |
| // TODO: Unfortunately we still hit this a lot as we are not accounting for some of the globopt changes |
| // to the IR. It is just reporting that we have missed mark temp object opportunity, so it doesn't |
| // indicate a functional failure. Disable for now. |
| // Assert(instr->dstIsTempObject || isBailOnNoProfileUpwardExposedUse); |
| } |
| else |
| { |
| // If we have marked the dst is temp in the backward pass, the globopt |
| // should have maintained it, and it will be wrong to have detect that it is not |
| // temp now in the deadstore pass (whether there is BailOnNoProfile or not) |
| #if DBG |
| if (DoTrace(backwardPass) && instr->dstIsTempObject) |
| { |
| Output::Print(_u("%s: Invalid Mark Temp Object: "), GetTraceName()); |
| instr->DumpSimple(); |
| Output::Flush(); |
| } |
| #endif |
| Assert(!instr->dstIsTempObject); |
| } |
| } |
| } |
| else if (IsTempTransfer(instr)) |
| { |
| // Only set the transfer |
| instr->dstIsTempObject = dstIsTemp; |
| } |
| else |
| { |
| Assert(!dstIsTemp); |
| Assert(!instr->dstIsTempObject); |
| } |
| |
| // clear or transfer the bailOnNoProfile upward exposed use |
| if (this->removedUpwardExposedUse.TestAndClear(instr->GetDst()->AsRegOpnd()->m_sym->m_id) |
| && IsTempTransfer(instr) && instr->GetSrc1()->IsRegOpnd()) |
| { |
| this->removedUpwardExposedUse.Set(instr->GetSrc1()->AsRegOpnd()->m_sym->m_id); |
| } |
| } |
| |
| void |
| ObjectTempVerify::MergeData(ObjectTempVerify * fromData, bool deleteData) |
| { |
| this->removedUpwardExposedUse.Or(&fromData->removedUpwardExposedUse); |
| } |
| |
| void |
| ObjectTempVerify::MergeDeadData(BasicBlock * block) |
| { |
| MergeData(block->tempObjectVerifyTracker, false); |
| if (!block->isDead) |
| { |
| // If there was dead flow to a block that is not dead, it might expose |
| // new mark temp object, so all its current used (upwardExposedUsed) and optimized |
| // use (byteCodeupwardExposedUsed) might not be trace for "missed" mark temp object |
| this->removedUpwardExposedUse.Or(block->upwardExposedUses); |
| if (block->byteCodeUpwardExposedUsed) |
| { |
| this->removedUpwardExposedUse.Or(block->byteCodeUpwardExposedUsed); |
| } |
| } |
| } |
| |
| void |
| ObjectTempVerify::NotifyBailOutRemoval(IR:: Instr * instr, BackwardPass * backwardPass) |
| { |
| Js::OpCode opcode = instr->m_opcode; |
| switch (opcode) |
| { |
| case Js::OpCode::LdFld: |
| case Js::OpCode::LdFldForTypeOf: |
| case Js::OpCode::LdMethodFld: |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(instr->GetSrc1()->AsPropertySymOpnd()->GetObjectSym(), backwardPass); |
| break; |
| case Js::OpCode::InitFld: |
| case Js::OpCode::StFld: |
| case Js::OpCode::StFldStrict: |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(instr->GetDst()->AsPropertySymOpnd()->GetObjectSym(), backwardPass); |
| break; |
| case Js::OpCode::LdElemI_A: |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(instr->GetSrc1()->AsIndirOpnd()->GetBaseOpnd()->m_sym, backwardPass); |
| break; |
| case Js::OpCode::StElemI_A: |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(instr->GetDst()->AsIndirOpnd()->GetBaseOpnd()->m_sym, backwardPass); |
| break; |
| } |
| } |
| |
| void |
| ObjectTempVerify::NotifyReverseCopyProp(IR::Instr * instr) |
| { |
| Assert(instr->GetDst()); |
| SymID symId = instr->GetDst()->AsRegOpnd()->m_sym->m_id; |
| this->removedUpwardExposedUse.Clear(symId); |
| this->nonTempSyms.Clear(symId); |
| } |
| |
| void |
| ObjectTempVerify::NotifyDeadStore(IR::Instr * instr, BackwardPass * backwardPass) |
| { |
| // Even if we dead store, simulate the uses |
| IR::Opnd * src1 = instr->GetSrc1(); |
| if (src1) |
| { |
| IR::PropertySymOpnd * propertySymOpnd; |
| StackSym * stackSym = ObjectTemp::GetStackSym(src1, &propertySymOpnd); |
| if (stackSym) |
| { |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(stackSym, backwardPass); |
| } |
| |
| IR::Opnd * src2 = instr->GetSrc2(); |
| if (src2) |
| { |
| stackSym = ObjectTemp::GetStackSym(src2, &propertySymOpnd); |
| if (stackSym) |
| { |
| ((TempTracker<ObjectTempVerify> *)this)->ProcessUse(stackSym, backwardPass); |
| } |
| } |
| } |
| } |
| |
| void |
| ObjectTempVerify::NotifyDeadByteCodeUses(IR::Instr * instr) |
| { |
| if (instr->GetDst()) |
| { |
| SymID symId = instr->GetDst()->AsRegOpnd()->m_sym->m_id; |
| this->removedUpwardExposedUse.Clear(symId); |
| this->nonTempSyms.Clear(symId); |
| } |
| |
| IR::ByteCodeUsesInstr *byteCodeUsesInstr = instr->AsByteCodeUsesInstr(); |
| const BVSparse<JitArenaAllocator> * byteCodeUpwardExposedUsed = byteCodeUsesInstr->GetByteCodeUpwardExposedUsed(); |
| if (byteCodeUpwardExposedUsed != nullptr) |
| { |
| this->removedUpwardExposedUse.Or(byteCodeUpwardExposedUsed); |
| } |
| } |
| |
| bool |
| ObjectTempVerify::DependencyCheck(IR::Instr * instr, BVSparse<JitArenaAllocator> * bvTempTransferDependencies, BackwardPass * backwardPass) |
| { |
| if (!instr->dstIsTempObject) |
| { |
| // The instruction is not marked as temp object anyway, no need to do extra check |
| return false; |
| } |
| |
| // Since our algorithm is conservative, there are cases where even though two defs are unrelated, the use will still |
| // seem like overlapping and not mark-temp-able |
| // For example: |
| // = s6.blah |
| // s1 = LdRootFld |
| // s6 = s1 |
| // s1 = NewScObject // s1 is dependent of s6, and s6 is upward exposed. |
| // = s6.blah |
| // s6 = s1 |
| // Here, although s1 is mark temp able because the s6.blah use is not related, we only know that s1 is dependent of s6 |
| // so it looks like s1 may overlap through the iterations. The backward pass will be able to catch that and not mark temp them |
| |
| // However, the globopt may create situation like the above while it wasn't there in the backward phase |
| // For example: |
| // = s6.blah |
| // s1 = LdRootFld g |
| // s6 = s1 |
| // s1 = NewScObject |
| // s7 = LdRootFld g |
| // = s7.blah // Globopt copy prop s7 -> s6, creating the example above. |
| // s6 = s1 |
| // This make it impossible to verify whether we did the right thing using the conservative algorithm. |
| |
| // Luckily, this case is very rare (ExprGen didn't hit it with > 100K test cases) |
| // So we can use this rather expensive algorithm to find out if any of upward exposed used that we think overlaps |
| // really get their value from the marked temp sym or not. |
| |
| // See unittest\Object\stackobject_dependency.js (with -maxinterpretcount:1 -off:inline) |
| |
| BasicBlock * currentBlock = backwardPass->currentBlock; |
| BVSparse<JitArenaAllocator> * upwardExposedUses = currentBlock->upwardExposedUses; |
| JitArenaAllocator tempAllocator(_u("temp"), instr->m_func->m_alloc->GetPageAllocator(), Js::Throw::OutOfMemory); |
| BVSparse<JitArenaAllocator> * dependentSyms = bvTempTransferDependencies->AndNew(upwardExposedUses, &tempAllocator); |
| BVSparse<JitArenaAllocator> * initialDependentSyms = dependentSyms->CopyNew(); |
| Assert(!dependentSyms->IsEmpty()); |
| struct BlockRecord |
| { |
| BasicBlock * block; |
| BVSparse<JitArenaAllocator> * dependentSyms; |
| }; |
| SList<BlockRecord> blockStack(&tempAllocator); |
| JsUtil::BaseDictionary<BasicBlock *, BVSparse<JitArenaAllocator> *, JitArenaAllocator> processedSyms(&tempAllocator); |
| |
| IR::Instr * currentInstr = instr; |
| Assert(instr->GetDst()->AsRegOpnd()->m_sym->IsVar()); |
| SymID markTempSymId = instr->GetDst()->AsRegOpnd()->m_sym->m_id; |
| bool initial = true; |
| while (true) |
| { |
| while (currentInstr != currentBlock->GetFirstInstr()) |
| { |
| if (initial) |
| { |
| initial = false; |
| } |
| else if (currentInstr == instr) |
| { |
| if (dependentSyms->Test(markTempSymId)) |
| { |
| // One of the dependent sym from the original set get it's value from the current marked temp dst. |
| // The dst definitely cannot be temp because it's lifetime overlaps across iterations. |
| return false; |
| } |
| |
| // If we have already check the same dependent sym, no need to do it again. |
| // It will produce the same result anyway. |
| dependentSyms->Minus(initialDependentSyms); |
| if (dependentSyms->IsEmpty()) |
| { |
| break; |
| } |
| // Add in newly discovered dependentSym so we won't do it again when it come back here. |
| initialDependentSyms->Or(dependentSyms); |
| } |
| |
| if (currentInstr->GetDst() && currentInstr->GetDst()->IsRegOpnd()) |
| { |
| // Clear the def and mark the src if it is transferred. |
| |
| // If the dst sym is a type specialized sym, clear the var sym instead. |
| StackSym * dstSym = currentInstr->GetDst()->AsRegOpnd()->m_sym; |
| if (!dstSym->IsVar()) |
| { |
| dstSym = dstSym->GetVarEquivSym(nullptr); |
| } |
| if (dstSym && dependentSyms->TestAndClear(dstSym->m_id) && |
| IsTempTransfer(currentInstr) && currentInstr->GetSrc1()->IsRegOpnd()) |
| { |
| // We only really care about var syms uses for object temp. |
| StackSym * srcSym = currentInstr->GetSrc1()->AsRegOpnd()->m_sym; |
| if (srcSym->IsVar()) |
| { |
| dependentSyms->Set(srcSym->m_id); |
| } |
| } |
| |
| if (dependentSyms->IsEmpty()) |
| { |
| // No more dependent sym, we found the def of all of them we can move on to the next block. |
| break; |
| } |
| } |
| currentInstr = currentInstr->m_prev; |
| } |
| |
| if (currentBlock->isLoopHeader && !dependentSyms->IsEmpty()) |
| { |
| Assert(currentInstr == currentBlock->GetFirstInstr()); |
| // If we have try to propagate the symbol through the loop before, we don't need to propagate it again. |
| BVSparse<JitArenaAllocator> * currentLoopProcessedSyms = processedSyms.Lookup(currentBlock, nullptr); |
| if (currentLoopProcessedSyms == nullptr) |
| { |
| processedSyms.Add(currentBlock, dependentSyms->CopyNew()); |
| } |
| else |
| { |
| dependentSyms->Minus(currentLoopProcessedSyms); |
| currentLoopProcessedSyms->Or(dependentSyms); |
| } |
| } |
| |
| if (!dependentSyms->IsEmpty()) |
| { |
| Assert(currentInstr == currentBlock->GetFirstInstr()); |
| |
| FOREACH_PREDECESSOR_BLOCK(predBlock, currentBlock) |
| { |
| if (predBlock->loop == nullptr) |
| { |
| // No need to track outside of loops. |
| continue; |
| } |
| BlockRecord record; |
| record.block = predBlock; |
| record.dependentSyms = dependentSyms->CopyNew(); |
| blockStack.Prepend(record); |
| } |
| NEXT_PREDECESSOR_BLOCK; |
| } |
| JitAdelete(&tempAllocator, dependentSyms); |
| |
| if (blockStack.Empty()) |
| { |
| // No more blocks. We are done. |
| break; |
| } |
| |
| currentBlock = blockStack.Head().block; |
| dependentSyms = blockStack.Head().dependentSyms; |
| blockStack.RemoveHead(); |
| currentInstr = currentBlock->GetLastInstr(); |
| } |
| |
| // All the dependent sym doesn't get their value from the marked temp def, so it can really be marked temp. |
| #if DBG |
| if (DoTrace(backwardPass)) |
| { |
| Output::Print(_u("%s: Unrelated overlap mark temp (s%-3d): "), GetTraceName(), markTempSymId); |
| instr->DumpSimple(); |
| Output::Flush(); |
| } |
| #endif |
| return true; |
| } |
| #endif |
| |
| |
| #if DBG |
| bool |
| NumberTemp::DoTrace(BackwardPass * backwardPass) |
| { |
| return PHASE_TRACE(Js::MarkTempNumberPhase, backwardPass->func); |
| } |
| |
| bool |
| ObjectTemp::DoTrace(BackwardPass * backwardPass) |
| { |
| return PHASE_TRACE(Js::MarkTempObjectPhase, backwardPass->func); |
| } |
| |
| bool |
| ObjectTempVerify::DoTrace(BackwardPass * backwardPass) |
| { |
| return PHASE_TRACE(Js::MarkTempObjectPhase, backwardPass->func); |
| } |
| #endif |
| |
| // explicit instantiation |
| template class TempTracker<NumberTemp>; |
| template class TempTracker<ObjectTemp>; |
| |
| #if DBG |
| template class TempTracker<ObjectTempVerify>; |
| #endif |
