#include "SymbolTableListTraitsImpl.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringMap.h"
+#include "llvm/IR/ConstantRange.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/LeakDetector.h"
#include "llvm/IR/Module.h"
-#include "llvm/Support/ConstantRange.h"
-#include "llvm/Support/LeakDetector.h"
-#include "llvm/Support/ValueHandle.h"
+#include "llvm/IR/ValueHandle.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
this->setAsFirstOperand(IsFirst);
}
- /// setAsFirstOperand - Accessor method to mark the operand as the first in
- /// the list.
+ /// \brief Accessor method to mark the operand as the first in the list.
void setAsFirstOperand(unsigned V) { this->setValPtrInt(V); }
- virtual void deleted();
- virtual void allUsesReplacedWith(Value *NV);
+ void deleted() override;
+ void allUsesReplacedWith(Value *NV) override;
};
} // end namespace llvm.
+// Provide out-of-line definition to prevent weak vtable.
MDNodeOperand::~MDNodeOperand() {}
-
void MDNodeOperand::deleted() {
- getParent()->replaceOperand(this, 0);
+ getParent()->replaceOperand(this, nullptr);
}
void MDNodeOperand::allUsesReplacedWith(Value *NV) {
// MDNode implementation.
//
-/// getOperandPtr - Helper function to get the MDNodeOperand's coallocated on
-/// the end of the MDNode.
+/// \brief Get the MDNodeOperand's coallocated on the end of the MDNode.
static MDNodeOperand *getOperandPtr(MDNode *N, unsigned Op) {
// Use <= instead of < to permit a one-past-the-end address.
assert(Op <= N->getNumOperands() && "Invalid operand number");
}
static const Function *getFunctionForValue(Value *V) {
- if (!V) return NULL;
+ if (!V) return nullptr;
if (Instruction *I = dyn_cast<Instruction>(V)) {
BasicBlock *BB = I->getParent();
- return BB ? BB->getParent() : 0;
+ return BB ? BB->getParent() : nullptr;
}
if (Argument *A = dyn_cast<Argument>(V))
return A->getParent();
return BB->getParent();
if (MDNode *MD = dyn_cast<MDNode>(V))
return MD->getFunction();
- return NULL;
+ return nullptr;
}
#ifndef NDEBUG
static const Function *assertLocalFunction(const MDNode *N) {
- if (!N->isFunctionLocal()) return 0;
+ if (!N->isFunctionLocal()) return nullptr;
// FIXME: This does not handle cyclic function local metadata.
- const Function *F = 0, *NewF = 0;
+ const Function *F = nullptr, *NewF = nullptr;
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
if (Value *V = N->getOperand(i)) {
if (MDNode *MD = dyn_cast<MDNode>(V))
else
NewF = getFunctionForValue(V);
}
- if (F == 0)
+ if (!F)
F = NewF;
- else
- assert((NewF == 0 || F == NewF) &&"inconsistent function-local metadata");
+ else
+ assert((NewF == nullptr || F == NewF) &&
+ "inconsistent function-local metadata");
}
return F;
}
#ifndef NDEBUG
return assertLocalFunction(this);
#else
- if (!isFunctionLocal()) return NULL;
+ if (!isFunctionLocal()) return nullptr;
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
if (const Function *F = getFunctionForValue(getOperand(i)))
return F;
- return NULL;
+ return nullptr;
#endif
}
free(this);
}
-/// isFunctionLocalValue - Return true if this is a value that would require a
-/// function-local MDNode.
+/// \brief Check if the Value would require a function-local MDNode.
static bool isFunctionLocalValue(Value *V) {
return isa<Instruction>(V) || isa<Argument>(V) || isa<BasicBlock>(V) ||
(isa<MDNode>(V) && cast<MDNode>(V)->isFunctionLocal());
// Note that if the operands are later nulled out, the node will be
// removed from the uniquing map.
FoldingSetNodeID ID;
- for (unsigned i = 0; i != Vals.size(); ++i)
- ID.AddPointer(Vals[i]);
+ for (Value *V : Vals)
+ ID.AddPointer(V);
void *InsertPoint;
MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint);
bool isFunctionLocal = false;
switch (FL) {
case FL_Unknown:
- for (unsigned i = 0; i != Vals.size(); ++i) {
- Value *V = Vals[i];
+ for (Value *V : Vals) {
if (!V) continue;
if (isFunctionLocalValue(V)) {
isFunctionLocal = true;
N->destroy();
}
-/// getOperand - Return specified operand.
+/// \brief Return specified operand.
Value *MDNode::getOperand(unsigned i) const {
assert(i < getNumOperands() && "Invalid operand number");
return *getOperandPtr(const_cast<MDNode*>(this), i);
// Likewise if the MDNode is function-local but for a different function.
if (To && isFunctionLocalValue(To)) {
if (!isFunctionLocal())
- To = 0;
+ To = nullptr;
else {
const Function *F = getFunction();
const Function *FV = getFunctionForValue(To);
// Metadata can be function-local without having an associated function.
// So only consider functions to have changed if non-null.
if (F && FV && F != FV)
- To = 0;
+ To = nullptr;
}
}
// anymore. This commonly occurs during destruction, and uniquing these
// brings little reuse. Also, this means we don't need to include
// isFunctionLocal bits in FoldingSetNodeIDs for MDNodes.
- if (To == 0) {
+ if (!To) {
setIsNotUniqued();
return;
}
}
}
+MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
+ if (!A)
+ return B;
+ if (!B)
+ return A;
+
+ SmallVector<Value *, 4> Vals(A->getNumOperands() +
+ B->getNumOperands());
+
+ unsigned j = 0;
+ for (unsigned i = 0, ie = A->getNumOperands(); i != ie; ++i)
+ Vals[j++] = A->getOperand(i);
+ for (unsigned i = 0, ie = B->getNumOperands(); i != ie; ++i)
+ Vals[j++] = B->getOperand(i);
+
+ return MDNode::get(A->getContext(), Vals);
+}
+
+MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
+ if (!A || !B)
+ return nullptr;
+
+ SmallVector<Value *, 4> Vals;
+ for (unsigned i = 0, ie = A->getNumOperands(); i != ie; ++i) {
+ Value *V = A->getOperand(i);
+ for (unsigned j = 0, je = B->getNumOperands(); j != je; ++j)
+ if (V == B->getOperand(j)) {
+ Vals.push_back(V);
+ break;
+ }
+ }
+
+ return MDNode::get(A->getContext(), Vals);
+}
+
MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
if (!A || !B)
- return NULL;
+ return nullptr;
APFloat AVal = cast<ConstantFP>(A->getOperand(0))->getValueAPF();
APFloat BVal = cast<ConstantFP>(B->getOperand(0))->getValueAPF();
// the ones that overlap.
if (!A || !B)
- return NULL;
+ return nullptr;
if (A == B)
return A;
ConstantRange Range(cast<ConstantInt>(EndPoints[0])->getValue(),
cast<ConstantInt>(EndPoints[1])->getValue());
if (Range.isFullSet())
- return NULL;
+ return nullptr;
}
return MDNode::get(A->getContext(), EndPoints);
}
NamedMDNode::NamedMDNode(const Twine &N)
- : Name(N.str()), Parent(0),
+ : Name(N.str()), Parent(nullptr),
Operands(new SmallVector<TrackingVH<MDNode>, 4>()) {
}
delete &getNMDOps(Operands);
}
-/// getNumOperands - Return number of NamedMDNode operands.
unsigned NamedMDNode::getNumOperands() const {
return (unsigned)getNMDOps(Operands).size();
}
-/// getOperand - Return specified operand.
MDNode *NamedMDNode::getOperand(unsigned i) const {
assert(i < getNumOperands() && "Invalid Operand number!");
return dyn_cast<MDNode>(&*getNMDOps(Operands)[i]);
}
-/// addOperand - Add metadata Operand.
void NamedMDNode::addOperand(MDNode *M) {
assert(!M->isFunctionLocal() &&
"NamedMDNode operands must not be function-local!");
getNMDOps(Operands).push_back(TrackingVH<MDNode>(M));
}
-/// eraseFromParent - Drop all references and remove the node from parent
-/// module.
void NamedMDNode::eraseFromParent() {
getParent()->eraseNamedMetadata(this);
}
-/// dropAllReferences - Remove all uses and clear node vector.
void NamedMDNode::dropAllReferences() {
getNMDOps(Operands).clear();
}
-/// getName - Return a constant reference to this named metadata's name.
StringRef NamedMDNode::getName() const {
return StringRef(Name);
}
// Instruction Metadata method implementations.
//
-void Instruction::setMetadata(StringRef Kind, MDNode *Node) {
- if (Node == 0 && !hasMetadata()) return;
- setMetadata(getContext().getMDKindID(Kind), Node);
+void Instruction::setMetadata(StringRef Kind, Value *MD) {
+ if (!MD && !hasMetadata()) return;
+ setMetadata(getContext().getMDKindID(Kind), MD);
}
MDNode *Instruction::getMetadataImpl(StringRef Kind) const {
return getMetadataImpl(getContext().getMDKindID(Kind));
}
+MDNode *Instruction::getMDNodeImpl(unsigned KindID) const {
+ return getMetadataImpl(KindID);
+}
+
+MDNode *Instruction::getMDNodeImpl(StringRef Kind) const {
+ return getMetadataImpl(Kind);
+}
+
+void Instruction::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
+ SmallSet<unsigned, 5> KnownSet;
+ KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
+
+ // Drop debug if needed
+ if (KnownSet.erase(LLVMContext::MD_dbg))
+ DbgLoc = DebugLoc();
+
+ if (!hasMetadataHashEntry())
+ return; // Nothing to remove!
+
+ DenseMap<const Instruction *, LLVMContextImpl::MDMapTy> &MetadataStore =
+ getContext().pImpl->MetadataStore;
+
+ if (KnownSet.empty()) {
+ // Just drop our entry at the store.
+ MetadataStore.erase(this);
+ setHasMetadataHashEntry(false);
+ return;
+ }
+
+ LLVMContextImpl::MDMapTy &Info = MetadataStore[this];
+ unsigned I;
+ unsigned E;
+ // Walk the array and drop any metadata we don't know.
+ for (I = 0, E = Info.size(); I != E;) {
+ if (KnownSet.count(Info[I].first)) {
+ ++I;
+ continue;
+ }
+
+ Info[I] = Info.back();
+ Info.pop_back();
+ --E;
+ }
+ assert(E == Info.size());
+
+ if (E == 0) {
+ // Drop our entry at the store.
+ MetadataStore.erase(this);
+ setHasMetadataHashEntry(false);
+ }
+}
+
/// setMetadata - Set the metadata of of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
-/// Node is null.
-void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
- if (Node == 0 && !hasMetadata()) return;
+/// MD is null.
+void Instruction::setMetadata(unsigned KindID, Value *MD) {
+ if (!MD && !hasMetadata()) return;
+
+ // For now, we only expect MDNodes here.
+ MDNode *Node = cast_or_null<MDNode>(MD);
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg) {
setHasMetadataHashEntry(true);
} else {
// Handle replacement of an existing value.
- for (unsigned i = 0, e = Info.size(); i != e; ++i)
- if (Info[i].first == KindID) {
- Info[i].second = Node;
+ for (auto &P : Info)
+ if (P.first == KindID) {
+ P.second = Node;
return;
}
}
// Otherwise, we're removing metadata from an instruction.
assert((hasMetadataHashEntry() ==
- getContext().pImpl->MetadataStore.count(this)) &&
+ (getContext().pImpl->MetadataStore.count(this) > 0)) &&
"HasMetadata bit out of date!");
if (!hasMetadataHashEntry())
return; // Nothing to remove!
// Otherwise, removing an entry that doesn't exist on the instruction.
}
+void Instruction::setAAMetadata(const AAMDNodes &N) {
+ setMetadata(LLVMContext::MD_tbaa, N.TBAA);
+ setMetadata(LLVMContext::MD_alias_scope, N.Scope);
+ setMetadata(LLVMContext::MD_noalias, N.NoAlias);
+}
+
MDNode *Instruction::getMetadataImpl(unsigned KindID) const {
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg)
return DbgLoc.getAsMDNode(getContext());
- if (!hasMetadataHashEntry()) return 0;
+ if (!hasMetadataHashEntry()) return nullptr;
LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this];
assert(!Info.empty() && "bit out of sync with hash table");
- for (LLVMContextImpl::MDMapTy::iterator I = Info.begin(), E = Info.end();
- I != E; ++I)
- if (I->first == KindID)
- return I->second;
- return 0;
+ for (const auto &I : Info)
+ if (I.first == KindID)
+ return I.second;
+ return nullptr;
}
void Instruction::getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned,
projects / oota-llvm.git / blobdiff