llvm/llvm/lib/Analysis/AliasSetTracker.cpp

//===- AliasSetTracker.cpp - Alias Sets Tracker implementation-------------===//
//
// 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 implements the AliasSetTracker and AliasSet classes.
//
//===----------------------------------------------------------------------===//

#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/GuardUtils.h"
#include "llvm/Analysis/MemoryLocation.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/IR/Value.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"

usingnamespacellvm;

static cl::opt<unsigned> SaturationThreshold(
    "alias-set-saturation-threshold", cl::Hidden, cl::init(250),
    cl::desc("The maximum total number of memory locations alias "
             "sets may contain before degradation"));

/// mergeSetIn - Merge the specified alias set into this alias set.
void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST,
                          BatchAAResults &BatchAA) { … }

void AliasSetTracker::removeAliasSet(AliasSet *AS) { … }

void AliasSet::removeFromTracker(AliasSetTracker &AST) { … }

void AliasSet::addMemoryLocation(AliasSetTracker &AST,
                                 const MemoryLocation &MemLoc,
                                 bool KnownMustAlias) { … }

void AliasSet::addUnknownInst(Instruction *I, BatchAAResults &AA) { … }

/// aliasesMemoryLocation - If the specified memory location "may" (or must)
/// alias one of the members in the set return the appropriate AliasResult.
/// Otherwise return NoAlias.
///
AliasResult AliasSet::aliasesMemoryLocation(const MemoryLocation &MemLoc,
                                            BatchAAResults &AA) const { … }

ModRefInfo AliasSet::aliasesUnknownInst(const Instruction *Inst,
                                        BatchAAResults &AA) const { … }

AliasSet::PointerVector AliasSet::getPointers() const { … }

void AliasSetTracker::clear() { … }

/// mergeAliasSetsForMemoryLocation - Given a memory location, merge all alias
/// sets that may alias it. Return the unified set, or nullptr if no aliasing
/// set was found. A known existing alias set for the pointer value of the
/// memory location can be passed in (or nullptr if not available). MustAliasAll
/// is updated to true/false if the memory location is found to MustAlias all
/// the sets it merged.
AliasSet *AliasSetTracker::mergeAliasSetsForMemoryLocation(
    const MemoryLocation &MemLoc, AliasSet *PtrAS, bool &MustAliasAll) { … }

AliasSet *AliasSetTracker::findAliasSetForUnknownInst(Instruction *Inst) { … }

AliasSet &AliasSetTracker::getAliasSetFor(const MemoryLocation &MemLoc) { … }

void AliasSetTracker::add(const MemoryLocation &Loc) { … }

void AliasSetTracker::add(LoadInst *LI) { … }

void AliasSetTracker::add(StoreInst *SI) { … }

void AliasSetTracker::add(VAArgInst *VAAI) { … }

void AliasSetTracker::add(AnyMemSetInst *MSI) { … }

void AliasSetTracker::add(AnyMemTransferInst *MTI) { … }

void AliasSetTracker::addUnknown(Instruction *Inst) { … }

void AliasSetTracker::add(Instruction *I) { … }

void AliasSetTracker::add(BasicBlock &BB) { … }

void AliasSetTracker::add(const AliasSetTracker &AST) { … }

AliasSet &AliasSetTracker::mergeAllAliasSets() { … }

AliasSet &AliasSetTracker::addMemoryLocation(MemoryLocation Loc,
                                             AliasSet::AccessLattice E) { … }

//===----------------------------------------------------------------------===//
//               AliasSet/AliasSetTracker Printing Support
//===----------------------------------------------------------------------===//

void AliasSet::print(raw_ostream &OS) const { … }

void AliasSetTracker::print(raw_ostream &OS) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void AliasSet::dump() const { print(dbgs()); }
LLVM_DUMP_METHOD void AliasSetTracker::dump() const { print(dbgs()); }
#endif

//===----------------------------------------------------------------------===//
//                            AliasSetPrinter Pass
//===----------------------------------------------------------------------===//

AliasSetsPrinterPass::AliasSetsPrinterPass(raw_ostream &OS) : … { … }

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