Page MenuHomePhabricator
Differential D14003 Diff 38212 lib/IR/InvariantInfo.cpp

Changeset View

Standalone View

View Options

lib/IR/InvariantInfo.cpp

  • This file was added.
//===---------- InvariantInfo.cpp - invariant_start/end info ----*- C++ -*-===//
nlewyckyUnsubmitted
Not Done
ReplyInline Actions

Remove the "-*- C++ -*-" part, that's only for .h files.

nlewycky: Remove the "-*- C++ -*-" part, that's only for .h files.
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines properties for handling invariant_start/end instructions
// for purposes of load elimination.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/InvariantInfo.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Instructions.h"
using namespace llvm;
IntrinsicInst *InvariantInfo::GetStartInstruction(const Value *Addr) const {
if (!Addr) return nullptr;
// Only global variables and alloca instructions are marked.
if (!isa<GlobalVariable>(Addr) && !isa<AllocaInst>(Addr)) return nullptr;
// constant globals are also not marked.
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Addr)) {
if (GV->isConstant()) return nullptr;
}
// Retrieve the value from the markers map.
auto EntryIter = InvariantMarkers.find(const_cast<Value *>(Addr));
if (EntryIter != InvariantMarkers.end()) return EntryIter->second;
return nullptr;
}
void InvariantInfo::SetStartInstruction(Value *Addr, IntrinsicInst *IStart) {
if (!Addr) return;
// Only mark either global variables or alloca instructions.
if (!isa<GlobalVariable>(Addr) && !isa<AllocaInst>(Addr)) return;
assert((!IStart || IStart->getIntrinsicID() == Intrinsic::invariant_start) &&
"Given intrinsic instruction is not invariant_start");
if (IStart && isa<AllocaInst>(Addr))
assert(IStart->getParent() == cast<AllocaInst>(Addr)->getParent() &&
"Invariant_start calls on a given alloca instruction must have"
"the same parent the alloca instruction.");
// Erase the current entry to ensure that the new value is inserted into
// the markers map.
InvariantMarkers.erase(Addr);
// Actually insert the value into the map. This operation must be successful.
// Note: A request to insert a nullptr value is a request to erase the entry.
// So, do not insert nullptr values.
if (IStart) {
bool Inserted = InvariantMarkers.insert(std::make_pair(Addr, IStart)).second;
assert(Inserted && "Setting new marker failed.");
}
}
void llvm::PreserveInvariantInfo::CheckPreservedInfo() const {
assert(Preserved.II->getIntrinsicID() == Intrinsic::invariant_start &&
"Preserved instruction must be an invariant_start intrinsic");
assert(Preserved.LoadedAddr &&
"Can't preserve an intrinsic instruction for no load.");
}
PreserveInvariantInfo::PreserveInvariantInfo(PreservedInvariantInfo Info)
: Preserved(Info) {
if (Preserved.II) CheckPreservedInfo();
}
PreserveInvariantInfo::~PreserveInvariantInfo() {
if (Preserved.II)
Preserved.InvInfo.SetStartInstruction(Preserved.LoadedAddr, Preserved.II);
}
/// Before scanning instructions backward from a given query instruction,
/// preserve information processed from invariant intrinsics, if the query is
/// is a load from writeonce memory.
llvm::PreservedInvariantInfo::PreservedInvariantInfo(Value *QueryInst,
const DataLayout &DL,
InvariantInfo &InvInfo)
: II(nullptr), LoadedAddr(nullptr), InvInfo(InvInfo) {
if (LoadInst *LI = dyn_cast_or_null<LoadInst>(QueryInst)) {
Value *Addr = GetUnderlyingObject(LI->getPointerOperand(), DL);
if (IntrinsicInst *QueryII = InvInfo.GetStartInstruction(Addr)) {
II = QueryII;
LoadedAddr = Addr;
}
}
}
/// If the given intrinsic instruction is an invariant_start, then mark its
/// corresponding address as "written" 'writeonce', and thus treatable as not
/// pointing to constant memory. If the intrinsic instruction is an
/// invariant_end instead, then mark the address as no longer "written"
/// and thus writeable again (i.e. no longer pointing to constant memory).
bool llvm::processInvariantIntrinsic(IntrinsicInst *II,
InvariantInfo &InvInfo) {
assert(II && "Can't mark a null instruction.");
if (II->getIntrinsicID() == Intrinsic::invariant_start) {
llvm::Value *Addr = II->getArgOperand(1)->stripPointerCasts();
InvInfo.SetStartInstruction(Addr, II);
return true;
} else if (II->getIntrinsicID() == Intrinsic::invariant_end) {
llvm::Value *Addr = II->getArgOperand(2)->stripPointerCasts();
if (InvInfo.GetStartInstruction(Addr))
InvInfo.SetStartInstruction(Addr, nullptr);
return true;
}
return false;
}
/// If the query is a load that is within an invariant_start/end pair, and
/// if we encounter its associated invariant_start instruction, then start
/// treating the memory location that it loads from as not pointing to
/// constant memory.
///
/// This function returns true if the given instrinsic instruction is an
/// invariant_start/end.
bool llvm::BackwardScanInvariantIntrinsic(const IntrinsicInst *II,
const PreservedInvariantInfo &Preserved,
InvariantInfo &InvInfo) {
if (II->getIntrinsicID() == Intrinsic::invariant_start) {
if (II == Preserved.II)
InvInfo.SetStartInstruction(Preserved.LoadedAddr, nullptr);
return true;
} else if (II->getIntrinsicID() == Intrinsic::invariant_end) {
llvm::Value *IStart = II->getArgOperand(0)->stripPointerCasts();
assert(Preserved.II != dyn_cast<IntrinsicInst>(IStart) &&
"This invariant_end's start instruction could not match the "
"preserved invariant_start, if preserved.");
return true;
}
return false;
}