Viewing file:  ModRef.h (8.79 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
//===--- ModRef.h - Memory effect modelling ---------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Definitions of ModRefInfo and MemoryEffects, which are used to
// describe the memory effects of instructions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_MODREF_H
#define LLVM_SUPPORT_MODREF_H
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/Support/raw_ostream.h"
namespace llvm {
/// Flags indicating whether a memory access modifies or references memory.
///
/// This is no access at all, a modification, a reference, or both
/// a modification and a reference.
enum class ModRefInfo : uint8_t {
/// The access neither references nor modifies the value stored in memory.
NoModRef = 0,
/// The access may reference the value stored in memory.
Ref = 1,
/// The access may modify the value stored in memory.
Mod = 2,
/// The access may reference and may modify the value stored in memory.
ModRef = Ref | Mod,
LLVM_MARK_AS_BITMASK_ENUM(ModRef),
};
[[nodiscard]] inline bool isNoModRef(const ModRefInfo MRI) {
return MRI == ModRefInfo::NoModRef;
}
[[nodiscard]] inline bool isModOrRefSet(const ModRefInfo MRI) {
return MRI != ModRefInfo::NoModRef;
}
[[nodiscard]] inline bool isModAndRefSet(const ModRefInfo MRI) {
return MRI == ModRefInfo::ModRef;
}
[[nodiscard]] inline bool isModSet(const ModRefInfo MRI) {
return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod);
}
[[nodiscard]] inline bool isRefSet(const ModRefInfo MRI) {
return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
}
/// Debug print ModRefInfo.
raw_ostream &operator<<(raw_ostream &OS, ModRefInfo MR);
/// The locations at which a function might access memory.
enum class IRMemLocation {
/// Access to memory via argument pointers.
ArgMem = 0,
/// Memory that is inaccessible via LLVM IR.
InaccessibleMem = 1,
/// Any other memory.
Other = 2,
/// Helpers to iterate all locations in the MemoryEffectsBase class.
First = ArgMem,
Last = Other,
};
template <typename LocationEnum> class MemoryEffectsBase {
public:
using Location = LocationEnum;
private:
uint32_t Data = 0;
static constexpr uint32_t BitsPerLoc = 2;
static constexpr uint32_t LocMask = (1 << BitsPerLoc) - 1;
static uint32_t getLocationPos(Location Loc) {
return (uint32_t)Loc * BitsPerLoc;
}
MemoryEffectsBase(uint32_t Data) : Data(Data) {}
void setModRef(Location Loc, ModRefInfo MR) {
Data &= ~(LocMask << getLocationPos(Loc));
Data |= static_cast<uint32_t>(MR) << getLocationPos(Loc);
}
public:
/// Returns iterator over all supported location kinds.
static auto locations() {
return enum_seq_inclusive(Location::First, Location::Last,
force_iteration_on_noniterable_enum);
}
/// Create MemoryEffectsBase that can access only the given location with the
/// given ModRefInfo.
MemoryEffectsBase(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
/// Create MemoryEffectsBase that can access any location with the given
/// ModRefInfo.
explicit MemoryEffectsBase(ModRefInfo MR) {
for (Location Loc : locations())
setModRef(Loc, MR);
}
/// Create MemoryEffectsBase that can read and write any memory.
static MemoryEffectsBase unknown() {
return MemoryEffectsBase(ModRefInfo::ModRef);
}
/// Create MemoryEffectsBase that cannot read or write any memory.
static MemoryEffectsBase none() {
return MemoryEffectsBase(ModRefInfo::NoModRef);
}
/// Create MemoryEffectsBase that can read any memory.
static MemoryEffectsBase readOnly() {
return MemoryEffectsBase(ModRefInfo::Ref);
}
/// Create MemoryEffectsBase that can write any memory.
static MemoryEffectsBase writeOnly() {
return MemoryEffectsBase(ModRefInfo::Mod);
}
/// Create MemoryEffectsBase that can only access argument memory.
static MemoryEffectsBase argMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
return MemoryEffectsBase(Location::ArgMem, MR);
}
/// Create MemoryEffectsBase that can only access inaccessible memory.
static MemoryEffectsBase
inaccessibleMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
return MemoryEffectsBase(Location::InaccessibleMem, MR);
}
/// Create MemoryEffectsBase that can only access inaccessible or argument
/// memory.
static MemoryEffectsBase
inaccessibleOrArgMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
MemoryEffectsBase FRMB = none();
FRMB.setModRef(Location::ArgMem, MR);
FRMB.setModRef(Location::InaccessibleMem, MR);
return FRMB;
}
/// Create MemoryEffectsBase from an encoded integer value (used by memory
/// attribute).
static MemoryEffectsBase createFromIntValue(uint32_t Data) {
return MemoryEffectsBase(Data);
}
/// Convert MemoryEffectsBase into an encoded integer value (used by memory
/// attribute).
uint32_t toIntValue() const {
return Data;
}
/// Get ModRefInfo for the given Location.
ModRefInfo getModRef(Location Loc) const {
return ModRefInfo((Data >> getLocationPos(Loc)) & LocMask);
}
/// Get new MemoryEffectsBase with modified ModRefInfo for Loc.
MemoryEffectsBase getWithModRef(Location Loc, ModRefInfo MR) const {
MemoryEffectsBase ME = *this;
ME.setModRef(Loc, MR);
return ME;
}
/// Get new MemoryEffectsBase with NoModRef on the given Loc.
MemoryEffectsBase getWithoutLoc(Location Loc) const {
MemoryEffectsBase ME = *this;
ME.setModRef(Loc, ModRefInfo::NoModRef);
return ME;
}
/// Get ModRefInfo for any location.
ModRefInfo getModRef() const {
ModRefInfo MR = ModRefInfo::NoModRef;
for (Location Loc : locations())
MR |= getModRef(Loc);
return MR;
}
/// Whether this function accesses no memory.
bool doesNotAccessMemory() const { return Data == 0; }
/// Whether this function only (at most) reads memory.
bool onlyReadsMemory() const { return !isModSet(getModRef()); }
/// Whether this function only (at most) writes memory.
bool onlyWritesMemory() const { return !isRefSet(getModRef()); }
/// Whether this function only (at most) accesses argument memory.
bool onlyAccessesArgPointees() const {
return getWithoutLoc(Location::ArgMem).doesNotAccessMemory();
}
/// Whether this function may access argument memory.
bool doesAccessArgPointees() const {
return isModOrRefSet(getModRef(Location::ArgMem));
}
/// Whether this function only (at most) accesses inaccessible memory.
bool onlyAccessesInaccessibleMem() const {
return getWithoutLoc(Location::InaccessibleMem).doesNotAccessMemory();
}
/// Whether this function only (at most) accesses argument and inaccessible
/// memory.
bool onlyAccessesInaccessibleOrArgMem() const {
return getWithoutLoc(Location::InaccessibleMem)
.getWithoutLoc(Location::ArgMem)
.doesNotAccessMemory();
}
/// Intersect with other MemoryEffectsBase.
MemoryEffectsBase operator&(MemoryEffectsBase Other) const {
return MemoryEffectsBase(Data & Other.Data);
}
/// Intersect (in-place) with other MemoryEffectsBase.
MemoryEffectsBase &operator&=(MemoryEffectsBase Other) {
Data &= Other.Data;
return *this;
}
/// Union with other MemoryEffectsBase.
MemoryEffectsBase operator|(MemoryEffectsBase Other) const {
return MemoryEffectsBase(Data | Other.Data);
}
/// Union (in-place) with other MemoryEffectsBase.
MemoryEffectsBase &operator|=(MemoryEffectsBase Other) {
Data |= Other.Data;
return *this;
}
/// Subtract other MemoryEffectsBase.
MemoryEffectsBase operator-(MemoryEffectsBase Other) const {
return MemoryEffectsBase(Data & ~Other.Data);
}
/// Subtract (in-place) with other MemoryEffectsBase.
MemoryEffectsBase &operator-=(MemoryEffectsBase Other) {
Data &= ~Other.Data;
return *this;
}
/// Check whether this is the same as other MemoryEffectsBase.
bool operator==(MemoryEffectsBase Other) const { return Data == Other.Data; }
/// Check whether this is different from other MemoryEffectsBase.
bool operator!=(MemoryEffectsBase Other) const { return !operator==(Other); }
};
/// Summary of how a function affects memory in the program.
///
/// Loads from constant globals are not considered memory accesses for this
/// interface. Also, functions may freely modify stack space local to their
/// invocation without having to report it through these interfaces.
using MemoryEffects = MemoryEffectsBase<IRMemLocation>;
/// Debug print MemoryEffects.
raw_ostream &operator<<(raw_ostream &OS, MemoryEffects RMRB);
// Legacy alias.
using FunctionModRefBehavior = MemoryEffects;
} // namespace llvm
#endif
|