mirror of
https://github.com/RPCS3/llvm.git
synced 2026-01-31 01:25:19 +01:00
6b547686c5
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@351636 91177308-0d34-0410-b5e6-96231b3b80d8
130 lines
6.3 KiB
C++
130 lines
6.3 KiB
C++
//===- Loads.h - Local load analysis --------------------------------------===//
|
|
//
|
|
// 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 declares simple local analyses for load instructions.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_LOADS_H
|
|
#define LLVM_ANALYSIS_LOADS_H
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
namespace llvm {
|
|
|
|
class DataLayout;
|
|
class MDNode;
|
|
|
|
/// Return true if this is always a dereferenceable pointer. If the context
|
|
/// instruction is specified perform context-sensitive analysis and return true
|
|
/// if the pointer is dereferenceable at the specified instruction.
|
|
bool isDereferenceablePointer(const Value *V, const DataLayout &DL,
|
|
const Instruction *CtxI = nullptr,
|
|
const DominatorTree *DT = nullptr);
|
|
|
|
/// Returns true if V is always a dereferenceable pointer with alignment
|
|
/// greater or equal than requested. If the context instruction is specified
|
|
/// performs context-sensitive analysis and returns true if the pointer is
|
|
/// dereferenceable at the specified instruction.
|
|
bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
|
|
const DataLayout &DL,
|
|
const Instruction *CtxI = nullptr,
|
|
const DominatorTree *DT = nullptr);
|
|
|
|
/// Returns true if V is always dereferenceable for Size byte with alignment
|
|
/// greater or equal than requested. If the context instruction is specified
|
|
/// performs context-sensitive analysis and returns true if the pointer is
|
|
/// dereferenceable at the specified instruction.
|
|
bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
|
|
const APInt &Size, const DataLayout &DL,
|
|
const Instruction *CtxI = nullptr,
|
|
const DominatorTree *DT = nullptr);
|
|
|
|
/// Return true if we know that executing a load from this value cannot trap.
|
|
///
|
|
/// If DT and ScanFrom are specified this method performs context-sensitive
|
|
/// analysis and returns true if it is safe to load immediately before ScanFrom.
|
|
///
|
|
/// If it is not obviously safe to load from the specified pointer, we do a
|
|
/// quick local scan of the basic block containing ScanFrom, to determine if
|
|
/// the address is already accessed.
|
|
bool isSafeToLoadUnconditionally(Value *V, unsigned Align,
|
|
const DataLayout &DL,
|
|
Instruction *ScanFrom = nullptr,
|
|
const DominatorTree *DT = nullptr);
|
|
|
|
/// The default number of maximum instructions to scan in the block, used by
|
|
/// FindAvailableLoadedValue().
|
|
extern cl::opt<unsigned> DefMaxInstsToScan;
|
|
|
|
/// Scan backwards to see if we have the value of the given load available
|
|
/// locally within a small number of instructions.
|
|
///
|
|
/// You can use this function to scan across multiple blocks: after you call
|
|
/// this function, if ScanFrom points at the beginning of the block, it's safe
|
|
/// to continue scanning the predecessors.
|
|
///
|
|
/// Note that performing load CSE requires special care to make sure the
|
|
/// metadata is set appropriately. In particular, aliasing metadata needs
|
|
/// to be merged. (This doesn't matter for store-to-load forwarding because
|
|
/// the only relevant load gets deleted.)
|
|
///
|
|
/// \param Load The load we want to replace.
|
|
/// \param ScanBB The basic block to scan.
|
|
/// \param [in,out] ScanFrom The location to start scanning from. When this
|
|
/// function returns, it points at the last instruction scanned.
|
|
/// \param MaxInstsToScan The maximum number of instructions to scan. If this
|
|
/// is zero, the whole block will be scanned.
|
|
/// \param AA Optional pointer to alias analysis, to make the scan more
|
|
/// precise.
|
|
/// \param [out] IsLoadCSE Whether the returned value is a load from the same
|
|
/// location in memory, as opposed to the value operand of a store.
|
|
///
|
|
/// \returns The found value, or nullptr if no value is found.
|
|
Value *FindAvailableLoadedValue(LoadInst *Load,
|
|
BasicBlock *ScanBB,
|
|
BasicBlock::iterator &ScanFrom,
|
|
unsigned MaxInstsToScan = DefMaxInstsToScan,
|
|
AliasAnalysis *AA = nullptr,
|
|
bool *IsLoadCSE = nullptr,
|
|
unsigned *NumScanedInst = nullptr);
|
|
|
|
/// Scan backwards to see if we have the value of the given pointer available
|
|
/// locally within a small number of instructions.
|
|
///
|
|
/// You can use this function to scan across multiple blocks: after you call
|
|
/// this function, if ScanFrom points at the beginning of the block, it's safe
|
|
/// to continue scanning the predecessors.
|
|
///
|
|
/// \param Ptr The pointer we want the load and store to originate from.
|
|
/// \param AccessTy The access type of the pointer.
|
|
/// \param AtLeastAtomic Are we looking for at-least an atomic load/store ? In
|
|
/// case it is false, we can return an atomic or non-atomic load or store. In
|
|
/// case it is true, we need to return an atomic load or store.
|
|
/// \param ScanBB The basic block to scan.
|
|
/// \param [in,out] ScanFrom The location to start scanning from. When this
|
|
/// function returns, it points at the last instruction scanned.
|
|
/// \param MaxInstsToScan The maximum number of instructions to scan. If this
|
|
/// is zero, the whole block will be scanned.
|
|
/// \param AA Optional pointer to alias analysis, to make the scan more
|
|
/// precise.
|
|
/// \param [out] IsLoad Whether the returned value is a load from the same
|
|
/// location in memory, as opposed to the value operand of a store.
|
|
///
|
|
/// \returns The found value, or nullptr if no value is found.
|
|
Value *FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy, bool AtLeastAtomic,
|
|
BasicBlock *ScanBB,
|
|
BasicBlock::iterator &ScanFrom,
|
|
unsigned MaxInstsToScan, AliasAnalysis *AA,
|
|
bool *IsLoad, unsigned *NumScanedInst);
|
|
}
|
|
|
|
#endif
|