C++ BlockState::startTrackingLocation方法代码示例

void DSEContext::processUnknownReadInst(SILInstruction *I, DSEKind Kind) {
    BlockState *S = getBlockState(I);
    // Are we building genset and killset.
    if (isBuildingGenKillSet(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (!S->BBMaxStoreSet.test(i))
                continue;
            if (!AA->mayReadFromMemory(I, LocationVault[i].getBase()))
                continue;
            // Update the genset and kill set.
            S->startTrackingLocation(S->BBKillSet, i);
            S->stopTrackingLocation(S->BBGenSet, i);
        }
        return;
    }

    // Are we performing dead store elimination.
    if (isPerformingDSE(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (!S->isTrackingLSLocation(S->BBWriteSetOut, i))
                continue;
            if (!AA->mayReadFromMemory(I, LocationVault[i].getBase()))
                continue;
            S->stopTrackingLocation(S->BBWriteSetOut, i);
        }
        return;
    }

    llvm_unreachable("Unknown DSE compute kind");
}

void DSEContext::processDebugValueAddrInst(SILInstruction *I, DSEKind Kind) {
    BlockState *S = getBlockState(I);
    SILValue Mem = cast<DebugValueAddrInst>(I)->getOperand();
    // Are we building genset and killset.
    if (isBuildingGenKillSet(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (!S->BBMaxStoreSet.test(i))
                continue;
            if (AA->isNoAlias(Mem, LocationVault[i].getBase()))
                continue;
            S->stopTrackingLocation(S->BBGenSet, i);
            S->startTrackingLocation(S->BBKillSet, i);
        }
        return;
    }

    // Are we performing dead store elimination.
    if (isPerformingDSE(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (!S->isTrackingLSLocation(S->BBWriteSetOut, i))
                continue;
            if (AA->isNoAlias(Mem, LocationVault[i].getBase()))
                continue;
            S->stopTrackingLocation(S->BBWriteSetOut, i);
        }
        return;
    }

    llvm_unreachable("Unknown DSE compute kind");
}

void DSEContext::invalidateLSLocationBase(SILInstruction *I, DSEKind Kind) {
    // If this instruction defines the base of a location, then we need to
    // invalidate any locations with the same base.
    BlockState *S = getBlockState(I);

    // Are we building genset and killset.
    if (isBuildingGenKillSet(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (LocationVault[i].getBase().getDef() != I)
                continue;
            S->startTrackingLocation(S->BBKillSet, i);
            S->stopTrackingLocation(S->BBGenSet, i);
        }
        return;
    }

    // Are we performing dead store elimination.
    if (isPerformingDSE(Kind)) {
        for (unsigned i = 0; i < S->LocationNum; ++i) {
            if (!S->BBWriteSetOut.test(i))
                continue;
            if (LocationVault[i].getBase().getDef() != I)
                continue;
            S->stopTrackingLocation(S->BBWriteSetOut, i);
        }
        return;
    }

    llvm_unreachable("Unknown DSE compute kind");
}

void DSEContext::invalidateLSLocationBaseForGenKillSet(SILInstruction *I) {
    BlockState *S = getBlockState(I);
    for (unsigned i = 0; i < S->LocationNum; ++i) {
        if (LocationVault[i].getBase() != I)
            continue;
        S->startTrackingLocation(S->BBKillSet, i);
        S->stopTrackingLocation(S->BBGenSet, i);
    }
}

void DSEContext::processDebugValueAddrInstForGenKillSet(SILInstruction *I) {
  BlockState *S = getBlockState(I);
  SILValue Mem = cast<DebugValueAddrInst>(I)->getOperand();
  for (unsigned i = 0; i < S->LocationNum; ++i) {
    if (!S->BBMaxStoreSet.test(i))
      continue;
    if (AA->isNoAlias(Mem, LocationVault[i].getBase()))
      continue;
    S->stopTrackingLocation(S->BBGenSet, i);
    S->startTrackingLocation(S->BBKillSet, i);
  }
}

void DSEContext::processUnknownReadInstForGenKillSet(SILInstruction *I) {
  BlockState *S = getBlockState(I);
  for (unsigned i = 0; i < S->LocationNum; ++i) {
    if (!S->BBMaxStoreSet.test(i))
      continue;
    if (!AA->mayReadFromMemory(I, LocationVault[i].getBase()))
      continue;
    // Update the genset and kill set.
    S->startTrackingLocation(S->BBKillSet, i);
    S->stopTrackingLocation(S->BBGenSet, i);
  }
}

void DSEContext::mergeSuccessorStates(SILBasicBlock *BB) {
    // First, clear the BBWriteSetOut for the current basicblock.
    BlockState *C = getBlockState(BB);
    C->BBWriteSetOut.reset();

    // If basic block has no successor, then all local writes can be considered
    // dead for block with no successor.
    if (BB->succ_empty()) {
        if (DisableLocalStoreDSE)
            return;
        for (unsigned i = 0; i < LocationVault.size(); ++i) {
            if (!LocationVault[i].isNonEscapingLocalLSLocation())
                continue;
            C->startTrackingLocation(C->BBWriteSetOut, i);
        }
        return;
    }

    // Use the first successor as the base condition.
    auto Iter = BB->succ_begin();
    C->BBWriteSetOut = getBlockState(*Iter)->BBWriteSetIn;

    /// Merge/intersection is very frequently performed, so it is important to make
    /// it as cheap as possible.
    ///
    /// To do so, we canonicalize LSLocations, i.e. traced back to the underlying
    /// object. Therefore, no need to do a O(N^2) comparison to figure out what is
    /// dead along all successors.
    ///
    /// NOTE: Canonicalization does not solve the problem entirely. i.e. it is
    /// still possible that 2 LSLocations with different bases that happen to be
    /// the same object and field. In such case, we would miss a dead store
    /// opportunity. But this happens less often with canonicalization.
    Iter = std::next(Iter);
    for (auto EndIter = BB->succ_end(); Iter != EndIter; ++Iter) {
        C->BBWriteSetOut &= getBlockState(*Iter)->BBWriteSetIn;
    }
}