llvm/llvm/lib/Analysis/AssumptionCache.cpp

//===- AssumptionCache.cpp - Cache finding @llvm.assume calls -------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains a pass that keeps track of @llvm.assume intrinsics in
// the functions of a module.
//
//===----------------------------------------------------------------------===//

#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Analysis/AssumeBundleQueries.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <utility>

usingnamespacellvm;
usingnamespacellvm::PatternMatch;

static cl::opt<bool>
    VerifyAssumptionCache("verify-assumption-cache", cl::Hidden,
                          cl::desc("Enable verification of assumption cache"),
                          cl::init(false));

SmallVector<AssumptionCache::ResultElem, 1> &
AssumptionCache::getOrInsertAffectedValues(Value *V) { … }

static void
findAffectedValues(CallBase *CI, TargetTransformInfo *TTI,
                   SmallVectorImpl<AssumptionCache::ResultElem> &Affected) { … }

void AssumptionCache::updateAffectedValues(AssumeInst *CI) { … }

void AssumptionCache::unregisterAssumption(AssumeInst *CI) { … }

void AssumptionCache::AffectedValueCallbackVH::deleted() { … }

void AssumptionCache::transferAffectedValuesInCache(Value *OV, Value *NV) { … }

void AssumptionCache::AffectedValueCallbackVH::allUsesReplacedWith(Value *NV) { … }

void AssumptionCache::scanFunction() { … }

void AssumptionCache::registerAssumption(AssumeInst *CI) { … }

AssumptionCache AssumptionAnalysis::run(Function &F,
                                        FunctionAnalysisManager &FAM) { … }

AnalysisKey AssumptionAnalysis::Key;

PreservedAnalyses AssumptionPrinterPass::run(Function &F,
                                             FunctionAnalysisManager &AM) { … }

void AssumptionCacheTracker::FunctionCallbackVH::deleted() { … }

AssumptionCache &AssumptionCacheTracker::getAssumptionCache(Function &F) { … }

AssumptionCache *AssumptionCacheTracker::lookupAssumptionCache(Function &F) { … }

void AssumptionCacheTracker::verifyAnalysis() const { … }

AssumptionCacheTracker::AssumptionCacheTracker() : … { … }

AssumptionCacheTracker::~AssumptionCacheTracker() = default;

char AssumptionCacheTracker::ID = …;

INITIALIZE_PASS(…)