aboutsummaryrefslogtreecommitdiffstats
path: root/lib/IR
diff options
context:
space:
mode:
Diffstat (limited to 'lib/IR')
-rw-r--r--lib/IR/AsmWriter.cpp975
-rw-r--r--lib/IR/AsmWriter.h129
-rw-r--r--lib/IR/AutoUpgrade.cpp152
-rw-r--r--lib/IR/BasicBlock.cpp24
-rw-r--r--lib/IR/ConstantFold.cpp59
-rw-r--r--lib/IR/ConstantRange.cpp45
-rw-r--r--lib/IR/Constants.cpp25
-rw-r--r--lib/IR/Core.cpp2
-rw-r--r--lib/IR/DIBuilder.cpp707
-rw-r--r--lib/IR/DataLayout.cpp134
-rw-r--r--lib/IR/DebugInfo.cpp833
-rw-r--r--lib/IR/DiagnosticInfo.cpp2
-rw-r--r--lib/IR/GCOV.cpp7
-rw-r--r--lib/IR/Globals.cpp4
-rw-r--r--lib/IR/InlineAsm.cpp2
-rw-r--r--lib/IR/Instruction.cpp8
-rw-r--r--lib/IR/Instructions.cpp253
-rw-r--r--lib/IR/LLVMContextImpl.h6
-rw-r--r--lib/IR/LegacyPassManager.cpp2
-rw-r--r--lib/IR/Mangler.cpp6
-rw-r--r--lib/IR/Module.cpp30
-rw-r--r--lib/IR/TypeFinder.cpp2
-rw-r--r--lib/IR/Value.cpp46
-rw-r--r--lib/IR/Verifier.cpp2012
24 files changed, 2140 insertions, 3325 deletions
diff --git a/lib/IR/AsmWriter.cpp b/lib/IR/AsmWriter.cpp
index de0e614..ae0beba 100644
--- a/lib/IR/AsmWriter.cpp
+++ b/lib/IR/AsmWriter.cpp
@@ -14,9 +14,9 @@
//
//===----------------------------------------------------------------------===//
-#include "AsmWriter.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/AssemblyAnnotationWriter.h"
@@ -32,12 +32,14 @@
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/TypeFinder.h"
+#include "llvm/IR/UseListOrder.h"
#include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cctype>
using namespace llvm;
@@ -275,6 +277,15 @@ static const Module *getModuleFromVal(const Value *V) {
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
return GV->getParent();
+
+ if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
+ for (const User *U : MAV->users())
+ if (isa<Instruction>(U))
+ if (const Module *M = getModuleFromVal(U))
+ return M;
+ return nullptr;
+ }
+
return nullptr;
}
@@ -378,7 +389,29 @@ static void PrintLLVMName(raw_ostream &OS, const Value *V) {
}
-namespace llvm {
+namespace {
+class TypePrinting {
+ TypePrinting(const TypePrinting &) = delete;
+ void operator=(const TypePrinting&) = delete;
+public:
+
+ /// NamedTypes - The named types that are used by the current module.
+ TypeFinder NamedTypes;
+
+ /// NumberedTypes - The numbered types, along with their value.
+ DenseMap<StructType*, unsigned> NumberedTypes;
+
+
+ TypePrinting() {}
+ ~TypePrinting() {}
+
+ void incorporateTypes(const Module &M);
+
+ void print(Type *Ty, raw_ostream &OS);
+
+ void printStructBody(StructType *Ty, raw_ostream &OS);
+};
+} // namespace
void TypePrinting::incorporateTypes(const Module &M) {
NamedTypes.run(M, false);
@@ -508,6 +541,7 @@ void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
OS << '>';
}
+namespace {
//===----------------------------------------------------------------------===//
// SlotTracker Class: Enumerate slot numbers for unnamed values
//===----------------------------------------------------------------------===//
@@ -525,6 +559,7 @@ private:
/// TheFunction - The function for which we are holding slot numbers.
const Function* TheFunction;
bool FunctionProcessed;
+ bool ShouldInitializeAllMetadata;
/// mMap - The slot map for the module level data.
ValueMap mMap;
@@ -542,10 +577,20 @@ private:
DenseMap<AttributeSet, unsigned> asMap;
unsigned asNext;
public:
- /// Construct from a module
- explicit SlotTracker(const Module *M);
+ /// Construct from a module.
+ ///
+ /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
+ /// functions, giving correct numbering for metadata referenced only from
+ /// within a function (even if no functions have been initialized).
+ explicit SlotTracker(const Module *M,
+ bool ShouldInitializeAllMetadata = false);
/// Construct from a function, starting out in incorp state.
- explicit SlotTracker(const Function *F);
+ ///
+ /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
+ /// functions, giving correct numbering for metadata referenced only from
+ /// within a function (even if no functions have been initialized).
+ explicit SlotTracker(const Function *F,
+ bool ShouldInitializeAllMetadata = false);
/// Return the slot number of the specified value in it's type
/// plane. If something is not in the SlotTracker, return -1.
@@ -606,11 +651,18 @@ private:
/// Add all of the functions arguments, basic blocks, and instructions.
void processFunction();
+ /// Add all of the metadata from a function.
+ void processFunctionMetadata(const Function &F);
+
+ /// Add all of the metadata from an instruction.
+ void processInstructionMetadata(const Instruction &I);
+
SlotTracker(const SlotTracker &) = delete;
void operator=(const SlotTracker &) = delete;
};
+} // namespace
-SlotTracker *createSlotTracker(const Module *M) {
+static SlotTracker *createSlotTracker(const Module *M) {
return new SlotTracker(M);
}
@@ -645,15 +697,18 @@ static SlotTracker *createSlotTracker(const Value *V) {
// Module level constructor. Causes the contents of the Module (sans functions)
// to be added to the slot table.
-SlotTracker::SlotTracker(const Module *M)
- : TheModule(M), TheFunction(nullptr), FunctionProcessed(false), mNext(0),
+SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
+ : TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
+ ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
fNext(0), mdnNext(0), asNext(0) {}
// Function level constructor. Causes the contents of the Module and the one
// function provided to be added to the slot table.
-SlotTracker::SlotTracker(const Function *F)
+SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
: TheModule(F ? F->getParent() : nullptr), TheFunction(F),
- FunctionProcessed(false), mNext(0), fNext(0), mdnNext(0), asNext(0) {}
+ FunctionProcessed(false),
+ ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
+ fNext(0), mdnNext(0), asNext(0) {}
inline void SlotTracker::initialize() {
if (TheModule) {
@@ -692,6 +747,9 @@ void SlotTracker::processModule() {
// Add all the unnamed functions to the table.
CreateModuleSlot(I);
+ if (ShouldInitializeAllMetadata)
+ processFunctionMetadata(*I);
+
// Add all the function attributes to the table.
// FIXME: Add attributes of other objects?
AttributeSet FnAttrs = I->getAttributes().getFnAttributes();
@@ -715,46 +773,30 @@ void SlotTracker::processFunction() {
ST_DEBUG("Inserting Instructions:\n");
- SmallVector<std::pair<unsigned, MDNode *>, 4> MDForInst;
-
// Add all of the basic blocks and instructions with no names.
- for (Function::const_iterator BB = TheFunction->begin(),
- E = TheFunction->end(); BB != E; ++BB) {
- if (!BB->hasName())
- CreateFunctionSlot(BB);
-
- for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E;
- ++I) {
- if (!I->getType()->isVoidTy() && !I->hasName())
- CreateFunctionSlot(I);
-
- // Intrinsics can directly use metadata. We allow direct calls to any
- // llvm.foo function here, because the target may not be linked into the
- // optimizer.
- if (const CallInst *CI = dyn_cast<CallInst>(I)) {
- if (Function *F = CI->getCalledFunction())
- if (F->isIntrinsic())
- for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
- if (auto *V = dyn_cast_or_null<MetadataAsValue>(I->getOperand(i)))
- if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
- CreateMetadataSlot(N);
+ for (auto &BB : *TheFunction) {
+ if (!BB.hasName())
+ CreateFunctionSlot(&BB);
+
+ for (auto &I : BB) {
+ if (!I.getType()->isVoidTy() && !I.hasName())
+ CreateFunctionSlot(&I);
+
+ processInstructionMetadata(I);
+ // We allow direct calls to any llvm.foo function here, because the
+ // target may not be linked into the optimizer.
+ if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
// Add all the call attributes to the table.
AttributeSet Attrs = CI->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
CreateAttributeSetSlot(Attrs);
- } else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) {
+ } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
// Add all the call attributes to the table.
AttributeSet Attrs = II->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
CreateAttributeSetSlot(Attrs);
}
-
- // Process metadata attached with this instruction.
- I->getAllMetadata(MDForInst);
- for (unsigned i = 0, e = MDForInst.size(); i != e; ++i)
- CreateMetadataSlot(MDForInst[i].second);
- MDForInst.clear();
}
}
@@ -763,6 +805,29 @@ void SlotTracker::processFunction() {
ST_DEBUG("end processFunction!\n");
}
+void SlotTracker::processFunctionMetadata(const Function &F) {
+ for (auto &BB : F)
+ for (auto &I : BB)
+ processInstructionMetadata(I);
+}
+
+void SlotTracker::processInstructionMetadata(const Instruction &I) {
+ // Process metadata used directly by intrinsics.
+ if (const CallInst *CI = dyn_cast<CallInst>(&I))
+ if (Function *F = CI->getCalledFunction())
+ if (F->isIntrinsic())
+ for (auto &Op : I.operands())
+ if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
+ if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
+ CreateMetadataSlot(N);
+
+ // Process metadata attached to this instruction.
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
+ I.getAllMetadata(MDs);
+ for (auto &MD : MDs)
+ CreateMetadataSlot(MD.second);
+}
+
/// Clean up after incorporating a function. This is the only way to get out of
/// the function incorporation state that affects get*Slot/Create*Slot. Function
/// incorporation state is indicated by TheFunction != 0.
@@ -1010,7 +1075,7 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
(StrVal[1] >= '0' && StrVal[1] <= '9'))) {
// Reparse stringized version!
if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) {
- Out << StrVal.str();
+ Out << StrVal;
return;
}
}
@@ -1223,6 +1288,14 @@ static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
Out << ' ' << getPredicateText(CE->getPredicate());
Out << " (";
+ if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
+ TypePrinter.print(
+ cast<PointerType>(GEP->getPointerOperandType()->getScalarType())
+ ->getElementType(),
+ Out);
+ Out << ", ";
+ }
+
for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
TypePrinter.print((*OI)->getType(), Out);
Out << ' ';
@@ -1285,8 +1358,52 @@ raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
}
return OS << FS.Sep;
}
+struct MDFieldPrinter {
+ raw_ostream &Out;
+ FieldSeparator FS;
+ TypePrinting *TypePrinter;
+ SlotTracker *Machine;
+ const Module *Context;
+
+ explicit MDFieldPrinter(raw_ostream &Out)
+ : Out(Out), TypePrinter(nullptr), Machine(nullptr), Context(nullptr) {}
+ MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
+ SlotTracker *Machine, const Module *Context)
+ : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
+ }
+ void printTag(const DebugNode *N);
+ void printString(StringRef Name, StringRef Value,
+ bool ShouldSkipEmpty = true);
+ void printMetadata(StringRef Name, const Metadata *MD,
+ bool ShouldSkipNull = true);
+ template <class IntTy>
+ void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
+ void printBool(StringRef Name, bool Value);
+ void printDIFlags(StringRef Name, unsigned Flags);
+ template <class IntTy, class Stringifier>
+ void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
+ bool ShouldSkipZero = true);
+};
} // end namespace
+void MDFieldPrinter::printTag(const DebugNode *N) {
+ Out << FS << "tag: ";
+ if (const char *Tag = dwarf::TagString(N->getTag()))
+ Out << Tag;
+ else
+ Out << N->getTag();
+}
+
+void MDFieldPrinter::printString(StringRef Name, StringRef Value,
+ bool ShouldSkipEmpty) {
+ if (ShouldSkipEmpty && Value.empty())
+ return;
+
+ Out << FS << Name << ": \"";
+ PrintEscapedString(Value, Out);
+ Out << "\"";
+}
+
static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
TypePrinting *TypePrinter,
SlotTracker *Machine,
@@ -1298,27 +1415,68 @@ static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
}
-static void writeTag(raw_ostream &Out, FieldSeparator &FS, const DebugNode *N) {
- Out << FS << "tag: ";
- if (const char *Tag = dwarf::TagString(N->getTag()))
- Out << Tag;
+void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
+ bool ShouldSkipNull) {
+ if (ShouldSkipNull && !MD)
+ return;
+
+ Out << FS << Name << ": ";
+ writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
+}
+
+template <class IntTy>
+void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
+ if (ShouldSkipZero && !Int)
+ return;
+
+ Out << FS << Name << ": " << Int;
+}
+
+void MDFieldPrinter::printBool(StringRef Name, bool Value) {
+ Out << FS << Name << ": " << (Value ? "true" : "false");
+}
+
+void MDFieldPrinter::printDIFlags(StringRef Name, unsigned Flags) {
+ if (!Flags)
+ return;
+
+ Out << FS << Name << ": ";
+
+ SmallVector<unsigned, 8> SplitFlags;
+ unsigned Extra = DIDescriptor::splitFlags(Flags, SplitFlags);
+
+ FieldSeparator FlagsFS(" | ");
+ for (unsigned F : SplitFlags) {
+ const char *StringF = DIDescriptor::getFlagString(F);
+ assert(StringF && "Expected valid flag");
+ Out << FlagsFS << StringF;
+ }
+ if (Extra || SplitFlags.empty())
+ Out << FlagsFS << Extra;
+}
+
+template <class IntTy, class Stringifier>
+void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
+ Stringifier toString, bool ShouldSkipZero) {
+ if (!Value)
+ return;
+
+ Out << FS << Name << ": ";
+ if (const char *S = toString(Value))
+ Out << S;
else
- Out << N->getTag();
+ Out << Value;
}
static void writeGenericDebugNode(raw_ostream &Out, const GenericDebugNode *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!GenericDebugNode(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- if (!N->getHeader().empty()) {
- Out << FS << "header: \"";
- PrintEscapedString(N->getHeader(), Out);
- Out << "\"";
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printTag(N);
+ Printer.printString("header", N->getHeader());
if (N->getNumDwarfOperands()) {
- Out << FS << "operands: {";
+ Out << Printer.FS << "operands: {";
FieldSeparator IFS;
for (auto &I : N->dwarf_operands()) {
Out << IFS;
@@ -1333,111 +1491,64 @@ static void writeMDLocation(raw_ostream &Out, const MDLocation *DL,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDLocation(";
- FieldSeparator FS;
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
// Always output the line, since 0 is a relevant and important value for it.
- Out << FS << "line: " << DL->getLine();
- if (DL->getColumn())
- Out << FS << "column: " << DL->getColumn();
- Out << FS << "scope: ";
- WriteAsOperandInternal(Out, DL->getScope(), TypePrinter, Machine, Context);
- if (DL->getInlinedAt()) {
- Out << FS << "inlinedAt: ";
- WriteAsOperandInternal(Out, DL->getInlinedAt(), TypePrinter, Machine,
- Context);
- }
+ Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
+ Printer.printInt("column", DL->getColumn());
+ Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
Out << ")";
}
static void writeMDSubrange(raw_ostream &Out, const MDSubrange *N,
TypePrinting *, SlotTracker *, const Module *) {
Out << "!MDSubrange(";
- FieldSeparator FS;
- Out << FS << "count: " << N->getCount();
- if (N->getLo())
- Out << FS << "lowerBound: " << N->getLo();
+ MDFieldPrinter Printer(Out);
+ Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
+ Printer.printInt("lowerBound", N->getLo());
Out << ")";
}
static void writeMDEnumerator(raw_ostream &Out, const MDEnumerator *N,
TypePrinting *, SlotTracker *, const Module *) {
Out << "!MDEnumerator(";
- FieldSeparator FS;
- Out << FS << "name: \"" << N->getName() << "\"";
- Out << FS << "value: " << N->getValue();
+ MDFieldPrinter Printer(Out);
+ Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
+ Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
Out << ")";
}
static void writeMDBasicType(raw_ostream &Out, const MDBasicType *N,
TypePrinting *, SlotTracker *, const Module *) {
Out << "!MDBasicType(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- if (!N->getName().empty())
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getSizeInBits())
- Out << FS << "size: " << N->getSizeInBits();
- if (N->getAlignInBits())
- Out << FS << "align: " << N->getAlignInBits();
- if (unsigned Encoding = N->getEncoding()) {
- Out << FS << "encoding: ";
- if (const char *S = dwarf::AttributeEncodingString(Encoding))
- Out << S;
- else
- Out << Encoding;
- }
+ MDFieldPrinter Printer(Out);
+ if (N->getTag() != dwarf::DW_TAG_base_type)
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printInt("size", N->getSizeInBits());
+ Printer.printInt("align", N->getAlignInBits());
+ Printer.printDwarfEnum("encoding", N->getEncoding(),
+ dwarf::AttributeEncodingString);
Out << ")";
}
-static void writeDIFlags(raw_ostream &Out, unsigned Flags) {
- SmallVector<unsigned, 8> SplitFlags;
- unsigned Extra = DIDescriptor::splitFlags(Flags, SplitFlags);
-
- FieldSeparator FS(" | ");
- for (unsigned F : SplitFlags) {
- const char *StringF = DIDescriptor::getFlagString(F);
- assert(StringF && "Expected valid flag");
- Out << FS << StringF;
- }
- if (Extra || SplitFlags.empty())
- Out << FS << Extra;
-}
-
static void writeMDDerivedType(raw_ostream &Out, const MDDerivedType *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDDerivedType(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- if (!N->getName().empty())
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getScope()) {
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- }
- Out << FS << "baseType: ";
- writeMetadataAsOperand(Out, N->getBaseType(), TypePrinter, Machine, Context);
- if (N->getSizeInBits())
- Out << FS << "size: " << N->getSizeInBits();
- if (N->getAlignInBits())
- Out << FS << "align: " << N->getAlignInBits();
- if (N->getOffsetInBits())
- Out << FS << "offset: " << N->getOffsetInBits();
- if (auto Flags = N->getFlags()) {
- Out << FS << "flags: ";
- writeDIFlags(Out, Flags);
- }
- if (N->getExtraData()) {
- Out << FS << "extraData: ";
- writeMetadataAsOperand(Out, N->getExtraData(), TypePrinter, Machine,
- Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("scope", N->getScope());
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printMetadata("baseType", N->getBaseType(),
+ /* ShouldSkipNull */ false);
+ Printer.printInt("size", N->getSizeInBits());
+ Printer.printInt("align", N->getAlignInBits());
+ Printer.printInt("offset", N->getOffsetInBits());
+ Printer.printDIFlags("flags", N->getFlags());
+ Printer.printMetadata("extraData", N->getExtraData());
Out << ")";
}
@@ -1445,61 +1556,23 @@ static void writeMDCompositeType(raw_ostream &Out, const MDCompositeType *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!MDCompositeType(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- if (!N->getName().empty())
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getScope()) {
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- }
- if (N->getBaseType()) {
- Out << FS << "baseType: ";
- writeMetadataAsOperand(Out, N->getBaseType(), TypePrinter, Machine,
- Context);
- }
- if (N->getSizeInBits())
- Out << FS << "size: " << N->getSizeInBits();
- if (N->getAlignInBits())
- Out << FS << "align: " << N->getAlignInBits();
- if (N->getOffsetInBits())
- Out << FS << "offset: " << N->getOffsetInBits();
- if (auto Flags = N->getFlags()) {
- Out << FS << "flags: ";
- writeDIFlags(Out, Flags);
- }
- if (N->getElements()) {
- Out << FS << "elements: ";
- writeMetadataAsOperand(Out, N->getElements(), TypePrinter, Machine,
- Context);
- }
- if (unsigned Lang = N->getRuntimeLang()) {
- Out << FS << "runtimeLang: ";
- if (const char *S = dwarf::LanguageString(Lang))
- Out << S;
- else
- Out << Lang;
- }
-
- if (N->getVTableHolder()) {
- Out << FS << "vtableHolder: ";
- writeMetadataAsOperand(Out, N->getVTableHolder(), TypePrinter, Machine,
- Context);
- }
- if (N->getTemplateParams()) {
- Out << FS << "templateParams: ";
- writeMetadataAsOperand(Out, N->getTemplateParams(), TypePrinter, Machine,
- Context);
- }
- if (!N->getIdentifier().empty())
- Out << FS << "identifier: \"" << N->getIdentifier() << "\"";
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("scope", N->getScope());
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printMetadata("baseType", N->getBaseType());
+ Printer.printInt("size", N->getSizeInBits());
+ Printer.printInt("align", N->getAlignInBits());
+ Printer.printInt("offset", N->getOffsetInBits());
+ Printer.printDIFlags("flags", N->getFlags());
+ Printer.printMetadata("elements", N->getElements());
+ Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
+ dwarf::LanguageString);
+ Printer.printMetadata("vtableHolder", N->getVTableHolder());
+ Printer.printMetadata("templateParams", N->getTemplateParams());
+ Printer.printString("identifier", N->getIdentifier());
Out << ")";
}
@@ -1507,22 +1580,20 @@ static void writeMDSubroutineType(raw_ostream &Out, const MDSubroutineType *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!MDSubroutineType(";
- FieldSeparator FS;
- if (auto Flags = N->getFlags()) {
- Out << FS << "flags: ";
- writeDIFlags(Out, Flags);
- }
- Out << FS << "types: ";
- writeMetadataAsOperand(Out, N->getTypeArray(), TypePrinter, Machine, Context);
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printDIFlags("flags", N->getFlags());
+ Printer.printMetadata("types", N->getTypeArray(), /* ShouldSkipNull */ false);
Out << ")";
}
static void writeMDFile(raw_ostream &Out, const MDFile *N, TypePrinting *,
SlotTracker *, const Module *) {
Out << "!MDFile(";
- FieldSeparator FS;
- Out << FS << "filename: \"" << N->getFilename() << "\"";
- Out << FS << "directory: \"" << N->getDirectory() << "\"";
+ MDFieldPrinter Printer(Out);
+ Printer.printString("filename", N->getFilename(),
+ /* ShouldSkipEmpty */ false);
+ Printer.printString("directory", N->getDirectory(),
+ /* ShouldSkipEmpty */ false);
Out << ")";
}
@@ -1530,48 +1601,23 @@ static void writeMDCompileUnit(raw_ostream &Out, const MDCompileUnit *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDCompileUnit(";
- FieldSeparator FS;
- Out << FS << "language: ";
- if (const char *Lang = dwarf::LanguageString(N->getSourceLanguage()))
- Out << Lang;
- else
- Out << N->getSourceLanguage();
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine, Context);
- if (!N->getProducer().empty())
- Out << FS << "producer: \"" << N->getProducer() << "\"";
- Out << FS << "isOptimized: " << (N->isOptimized() ? "true" : "false");
- if (!N->getFlags().empty())
- Out << FS << "flags: \"" << N->getFlags() << "\"";
- Out << FS << "runtimeVersion: " << N->getRuntimeVersion();
- if (!N->getSplitDebugFilename().empty())
- Out << FS << "splitDebugFilename: \"" << N->getSplitDebugFilename() << "\"";
- Out << FS << "emissionKind: " << N->getEmissionKind();
- if (N->getEnumTypes()) {
- Out << FS << "enums: ";
- writeMetadataAsOperand(Out, N->getEnumTypes(), TypePrinter, Machine,
- Context);
- }
- if (N->getRetainedTypes()) {
- Out << FS << "retainedTypes: ";
- writeMetadataAsOperand(Out, N->getRetainedTypes(), TypePrinter, Machine,
- Context);
- }
- if (N->getSubprograms()) {
- Out << FS << "subprograms: ";
- writeMetadataAsOperand(Out, N->getSubprograms(), TypePrinter, Machine,
- Context);
- }
- if (N->getGlobalVariables()) {
- Out << FS << "globals: ";
- writeMetadataAsOperand(Out, N->getGlobalVariables(), TypePrinter, Machine,
- Context);
- }
- if (N->getImportedEntities()) {
- Out << FS << "imports: ";
- writeMetadataAsOperand(Out, N->getImportedEntities(), TypePrinter, Machine,
- Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printDwarfEnum("language", N->getSourceLanguage(),
+ dwarf::LanguageString, /* ShouldSkipZero */ false);
+ Printer.printMetadata("file", N->getFile(), /* ShouldSkipNull */ false);
+ Printer.printString("producer", N->getProducer());
+ Printer.printBool("isOptimized", N->isOptimized());
+ Printer.printString("flags", N->getFlags());
+ Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
+ /* ShouldSkipZero */ false);
+ Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
+ Printer.printInt("emissionKind", N->getEmissionKind(),
+ /* ShouldSkipZero */ false);
+ Printer.printMetadata("enums", N->getEnumTypes());
+ Printer.printMetadata("retainedTypes", N->getRetainedTypes());
+ Printer.printMetadata("subprograms", N->getSubprograms());
+ Printer.printMetadata("globals", N->getGlobalVariables());
+ Printer.printMetadata("imports", N->getImportedEntities());
Out << ")";
}
@@ -1579,67 +1625,26 @@ static void writeMDSubprogram(raw_ostream &Out, const MDSubprogram *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDSubprogram(";
- FieldSeparator FS;
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- Out << FS << "name: \"" << N->getName() << "\"";
- if (!N->getLinkageName().empty())
- Out << FS << "linkageName: \"" << N->getLinkageName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getType()) {
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine,
- Context);
- }
- Out << FS << "isLocal: " << (N->isLocalToUnit() ? "true" : "false");
- Out << FS << "isDefinition: " << (N->isDefinition() ? "true" : "false");
- if (N->getScopeLine())
- Out << FS << "scopeLine: " << N->getScopeLine();
- if (N->getContainingType()) {
- Out << FS << "containingType: ";
- writeMetadataAsOperand(Out, N->getContainingType(), TypePrinter, Machine,
- Context);
- }
- if (unsigned V = N->getVirtuality()) {
- Out << FS << "virtuality: ";
- if (const char *S = dwarf::VirtualityString(V))
- Out << S;
- else
- Out << V;
- }
- if (N->getVirtualIndex())
- Out << FS << "virtualIndex: " << N->getVirtualIndex();
- if (auto Flags = N->getFlags()) {
- Out << FS << "flags: ";
- writeDIFlags(Out, Flags);
- }
- Out << FS << "isOptimized: " << (N->isOptimized() ? "true" : "false");
- if (N->getFunction()) {
- Out << FS << "function: ";
- writeMetadataAsOperand(Out, N->getFunction(), TypePrinter, Machine,
- Context);
- }
- if (N->getTemplateParams()) {
- Out << FS << "templateParams: ";
- writeMetadataAsOperand(Out, N->getTemplateParams(), TypePrinter, Machine,
- Context);
- }
- if (N->getDeclaration()) {
- Out << FS << "declaration: ";
- writeMetadataAsOperand(Out, N->getDeclaration(), TypePrinter, Machine,
- Context);
- }
- if (N->getVariables()) {
- Out << FS << "variables: ";
- writeMetadataAsOperand(Out, N->getVariables(), TypePrinter, Machine,
- Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printString("name", N->getName());
+ Printer.printString("linkageName", N->getLinkageName());
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printMetadata("type", N->getType());
+ Printer.printBool("isLocal", N->isLocalToUnit());
+ Printer.printBool("isDefinition", N->isDefinition());
+ Printer.printInt("scopeLine", N->getScopeLine());
+ Printer.printMetadata("containingType", N->getContainingType());
+ Printer.printDwarfEnum("virtuality", N->getVirtuality(),
+ dwarf::VirtualityString);
+ Printer.printInt("virtualIndex", N->getVirtualIndex());
+ Printer.printDIFlags("flags", N->getFlags());
+ Printer.printBool("isOptimized", N->isOptimized());
+ Printer.printMetadata("function", N->getFunction());
+ Printer.printMetadata("templateParams", N->getTemplateParams());
+ Printer.printMetadata("declaration", N->getDeclaration());
+ Printer.printMetadata("variables", N->getVariables());
Out << ")";
}
@@ -1647,18 +1652,11 @@ static void writeMDLexicalBlock(raw_ostream &Out, const MDLexicalBlock *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDLexicalBlock(";
- FieldSeparator FS;
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getColumn())
- Out << FS << "column: " << N->getColumn();
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printInt("column", N->getColumn());
Out << ")";
}
@@ -1668,15 +1666,11 @@ static void writeMDLexicalBlockFile(raw_ostream &Out,
SlotTracker *Machine,
const Module *Context) {
Out << "!MDLexicalBlockFile(";
- FieldSeparator FS;
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- Out << FS << "discriminator: " << N->getDiscriminator();
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("discriminator", N->getDiscriminator(),
+ /* ShouldSkipZero */ false);
Out << ")";
}
@@ -1684,17 +1678,11 @@ static void writeMDNamespace(raw_ostream &Out, const MDNamespace *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDNamespace(";
- FieldSeparator FS;
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine, Context);
- }
- if (!N->getName().empty())
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
Out << ")";
}
@@ -1704,10 +1692,9 @@ static void writeMDTemplateTypeParameter(raw_ostream &Out,
SlotTracker *Machine,
const Module *Context) {
Out << "!MDTemplateTypeParameter(";
- FieldSeparator FS;
- Out << FS << "name: \"" << N->getName() << "\"";
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine, Context);
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("type", N->getType(), /* ShouldSkipNull */ false);
Out << ")";
}
@@ -1717,13 +1704,12 @@ static void writeMDTemplateValueParameter(raw_ostream &Out,
SlotTracker *Machine,
const Module *Context) {
Out << "!MDTemplateValueParameter(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- Out << FS << "name: \"" << N->getName() << "\"";
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine, Context);
- Out << FS << "value: ";
- writeMetadataAsOperand(Out, N->getValue(), TypePrinter, Machine, Context);
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("type", N->getType());
+ Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
Out << ")";
}
@@ -1731,36 +1717,17 @@ static void writeMDGlobalVariable(raw_ostream &Out, const MDGlobalVariable *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!MDGlobalVariable(";
- FieldSeparator FS;
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- Out << FS << "name: \"" << N->getName() << "\"";
- if (!N->getLinkageName().empty())
- Out << FS << "linkageName: \"" << N->getLinkageName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getType()) {
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine,
- Context);
- }
- Out << FS << "isLocal: " << (N->isLocalToUnit() ? "true" : "false");
- Out << FS << "isDefinition: " << (N->isDefinition() ? "true" : "false");
- if (N->getVariable()) {
- Out << FS << "variable: ";
- writeMetadataAsOperand(Out, N->getVariable(), TypePrinter, Machine,
- Context);
- }
- if (N->getStaticDataMemberDeclaration()) {
- Out << FS << "declaration: ";
- writeMetadataAsOperand(Out, N->getStaticDataMemberDeclaration(),
- TypePrinter, Machine, Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printString("name", N->getName());
+ Printer.printString("linkageName", N->getLinkageName());
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printMetadata("type", N->getType());
+ Printer.printBool("isLocal", N->isLocalToUnit());
+ Printer.printBool("isDefinition", N->isDefinition());
+ Printer.printMetadata("variable", N->getVariable());
+ Printer.printMetadata("declaration", N->getStaticDataMemberDeclaration());
Out << ")";
}
@@ -1768,34 +1735,18 @@ static void writeMDLocalVariable(raw_ostream &Out, const MDLocalVariable *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!MDLocalVariable(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine,
- Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (N->getType()) {
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine,
- Context);
- }
- if (N->getTag() == dwarf::DW_TAG_arg_variable || N->getArg())
- Out << FS << "arg: " << N->getArg();
- if (auto Flags = N->getFlags()) {
- Out << FS << "flags: ";
- writeDIFlags(Out, Flags);
- }
- if (N->getInlinedAt()) {
- Out << FS << "inlinedAt: ";
- writeMetadataAsOperand(Out, N->getInlinedAt(), TypePrinter, Machine,
- Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printInt("arg", N->getArg(),
+ /* ShouldSkipZero */
+ N->getTag() == dwarf::DW_TAG_auto_variable);
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printMetadata("type", N->getType());
+ Printer.printDIFlags("flags", N->getFlags());
+ Printer.printMetadata("inlinedAt", N->getInlinedAt());
Out << ")";
}
@@ -1824,24 +1775,14 @@ static void writeMDObjCProperty(raw_ostream &Out, const MDObjCProperty *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
Out << "!MDObjCProperty(";
- FieldSeparator FS;
- Out << FS << "name: \"" << N->getName() << "\"";
- if (N->getFile()) {
- Out << FS << "file: ";
- writeMetadataAsOperand(Out, N->getFile(), TypePrinter, Machine, Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- if (!N->getSetterName().empty())
- Out << FS << "setter: \"" << N->getSetterName() << "\"";
- if (!N->getGetterName().empty())
- Out << FS << "getter: \"" << N->getGetterName() << "\"";
- if (N->getAttributes())
- Out << FS << "attributes: " << N->getAttributes();
- if (N->getType()) {
- Out << FS << "type: ";
- writeMetadataAsOperand(Out, N->getType(), TypePrinter, Machine, Context);
- }
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("file", N->getFile());
+ Printer.printInt("line", N->getLine());
+ Printer.printString("setter", N->getSetterName());
+ Printer.printString("getter", N->getGetterName());
+ Printer.printInt("attributes", N->getAttributes());
+ Printer.printMetadata("type", N->getType());
Out << ")";
}
@@ -1849,17 +1790,12 @@ static void writeMDImportedEntity(raw_ostream &Out, const MDImportedEntity *N,
TypePrinting *TypePrinter,
SlotTracker *Machine, const Module *Context) {
Out << "!MDImportedEntity(";
- FieldSeparator FS;
- writeTag(Out, FS, N);
- Out << FS << "scope: ";
- writeMetadataAsOperand(Out, N->getScope(), TypePrinter, Machine, Context);
- if (N->getEntity()) {
- Out << FS << "entity: ";
- writeMetadataAsOperand(Out, N->getEntity(), TypePrinter, Machine, Context);
- }
- if (N->getLine())
- Out << FS << "line: " << N->getLine();
- Out << FS << "name: \"" << N->getName() << "\"";
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printTag(N);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("scope", N->getScope(), /* ShouldSkipNull */ false);
+ Printer.printMetadata("entity", N->getEntity());
+ Printer.printInt("line", N->getLine());
Out << ")";
}
@@ -1868,10 +1804,10 @@ static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
TypePrinting *TypePrinter,
SlotTracker *Machine,
const Module *Context) {
- assert(!Node->isTemporary() && "Unexpected forward declaration");
-
if (Node->isDistinct())
Out << "distinct ";
+ else if (Node->isTemporary())
+ Out << "<temporary!> "; // Handle broken code.
switch (Node->getMetadataID()) {
default:
@@ -1998,6 +1934,64 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
}
+namespace {
+class AssemblyWriter {
+ formatted_raw_ostream &Out;
+ const Module *TheModule;
+ std::unique_ptr<SlotTracker> ModuleSlotTracker;
+ SlotTracker &Machine;
+ TypePrinting TypePrinter;
+ AssemblyAnnotationWriter *AnnotationWriter;
+ SetVector<const Comdat *> Comdats;
+ UseListOrderStack UseListOrders;
+
+public:
+ /// Construct an AssemblyWriter with an external SlotTracker
+ AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
+ const Module *M, AssemblyAnnotationWriter *AAW);
+
+ /// Construct an AssemblyWriter with an internally allocated SlotTracker
+ AssemblyWriter(formatted_raw_ostream &o, const Module *M,
+ AssemblyAnnotationWriter *AAW);
+
+ void printMDNodeBody(const MDNode *MD);
+ void printNamedMDNode(const NamedMDNode *NMD);
+
+ void printModule(const Module *M);
+
+ void writeOperand(const Value *Op, bool PrintType);
+ void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx);
+ void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope);
+ void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
+ AtomicOrdering FailureOrdering,
+ SynchronizationScope SynchScope);
+
+ void writeAllMDNodes();
+ void writeMDNode(unsigned Slot, const MDNode *Node);
+ void writeAllAttributeGroups();
+
+ void printTypeIdentities();
+ void printGlobal(const GlobalVariable *GV);
+ void printAlias(const GlobalAlias *GV);
+ void printComdat(const Comdat *C);
+ void printFunction(const Function *F);
+ void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx);
+ void printBasicBlock(const BasicBlock *BB);
+ void printInstructionLine(const Instruction &I);
+ void printInstruction(const Instruction &I);
+
+ void printUseListOrder(const UseListOrder &Order);
+ void printUseLists(const Function *F);
+
+private:
+ void init();
+
+ // printInfoComment - Print a little comment after the instruction indicating
+ // which slot it occupies.
+ void printInfoComment(const Value &V);
+};
+} // namespace
+
void AssemblyWriter::init() {
if (!TheModule)
return;
@@ -2025,8 +2019,6 @@ AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, const Module *M,
init();
}
-AssemblyWriter::~AssemblyWriter() { }
-
void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
if (!Operand) {
Out << "<null operand!>";
@@ -2876,7 +2868,13 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
if (AI->isUsedWithInAlloca())
Out << "inalloca ";
TypePrinter.print(AI->getAllocatedType(), Out);
- if (!AI->getArraySize() || AI->isArrayAllocation()) {
+
+ // Explicitly write the array size if the code is broken, if it's an array
+ // allocation, or if the type is not canonical for scalar allocations. The
+ // latter case prevents the type from mutating when round-tripping through
+ // assembly.
+ if (!AI->getArraySize() || AI->isArrayAllocation() ||
+ !AI->getArraySize()->getType()->isIntegerTy(32)) {
Out << ", ";
writeOperand(AI->getArraySize(), true);
}
@@ -2898,6 +2896,15 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
Out << ", ";
TypePrinter.print(I.getType(), Out);
} else if (Operand) { // Print the normal way.
+ if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
+ Out << ' ';
+ TypePrinter.print(GEP->getSourceElementType(), Out);
+ Out << ',';
+ } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
+ Out << ' ';
+ TypePrinter.print(LI->getType(), Out);
+ Out << ',';
+ }
// PrintAllTypes - Instructions who have operands of all the same type
// omit the type from all but the first operand. If the instruction has
@@ -2974,29 +2981,6 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
printInfoComment(I);
}
-static void WriteMDNodeComment(const MDNode *Node,
- formatted_raw_ostream &Out) {
- if (Node->getNumOperands() < 1)
- return;
-
- Metadata *Op = Node->getOperand(0);
- if (!Op || !isa<MDString>(Op))
- return;
-
- DIDescriptor Desc(Node);
- if (!Desc.Verify())
- return;
-
- unsigned Tag = Desc.getTag();
- Out.PadToColumn(50);
- if (dwarf::TagString(Tag)) {
- Out << "; ";
- Desc.print(Out);
- } else if (Tag == dwarf::DW_TAG_user_base) {
- Out << "; [ DW_TAG_user_base ]";
- }
-}
-
void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
Out << '!' << Slot << " = ";
printMDNodeBody(Node);
@@ -3017,7 +3001,6 @@ void AssemblyWriter::writeAllMDNodes() {
void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
- WriteMDNodeComment(Node, Out);
}
void AssemblyWriter::writeAllAttributeGroups() {
@@ -3034,8 +3017,6 @@ void AssemblyWriter::writeAllAttributeGroups() {
<< I->first.getAsString(AttributeSet::FunctionIndex, true) << " }\n";
}
-} // namespace llvm
-
void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
bool IsInFunction = Machine.getFunction();
if (IsInFunction)
@@ -3130,11 +3111,24 @@ void Type::print(raw_ostream &OS) const {
}
}
+static bool isReferencingMDNode(const Instruction &I) {
+ if (const auto *CI = dyn_cast<CallInst>(&I))
+ if (Function *F = CI->getCalledFunction())
+ if (F->isIntrinsic())
+ for (auto &Op : I.operands())
+ if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
+ if (isa<MDNode>(V->getMetadata()))
+ return true;
+ return false;
+}
+
void Value::print(raw_ostream &ROS) const {
formatted_raw_ostream OS(ROS);
if (const Instruction *I = dyn_cast<Instruction>(this)) {
const Function *F = I->getParent() ? I->getParent()->getParent() : nullptr;
- SlotTracker SlotTable(F);
+ SlotTracker SlotTable(
+ F,
+ /* ShouldInitializeAllMetadata */ isReferencingMDNode(*I));
AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr);
W.printInstruction(*I);
} else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
@@ -3142,7 +3136,8 @@ void Value::print(raw_ostream &ROS) const {
AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr);
W.printBasicBlock(BB);
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
- SlotTracker SlotTable(GV->getParent());
+ SlotTracker SlotTable(GV->getParent(),
+ /* ShouldInitializeAllMetadata */ isa<Function>(GV));
AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr);
if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
W.printGlobal(V);
@@ -3151,7 +3146,7 @@ void Value::print(raw_ostream &ROS) const {
else
W.printAlias(cast<GlobalAlias>(GV));
} else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
- V->getMetadata()->print(ROS);
+ V->getMetadata()->print(ROS, getModuleFromVal(V));
} else if (const Constant *C = dyn_cast<Constant>(this)) {
TypePrinting TypePrinter;
TypePrinter.print(C->getType(), OS);
@@ -3167,8 +3162,9 @@ void Value::print(raw_ostream &ROS) const {
void Value::printAsOperand(raw_ostream &O, bool PrintType, const Module *M) const {
// Fast path: Don't construct and populate a TypePrinting object if we
// won't be needing any types printed.
- if (!PrintType && ((!isa<Constant>(this) && !isa<MetadataAsValue>(this)) ||
- hasName() || isa<GlobalValue>(this))) {
+ bool IsMetadata = isa<MetadataAsValue>(this);
+ if (!PrintType && ((!isa<Constant>(this) && !IsMetadata) || hasName() ||
+ isa<GlobalValue>(this))) {
WriteAsOperandInternal(O, this, nullptr, nullptr, M);
return;
}
@@ -3184,33 +3180,35 @@ void Value::printAsOperand(raw_ostream &O, bool PrintType, const Module *M) cons
O << ' ';
}
- WriteAsOperandInternal(O, this, &TypePrinter, nullptr, M);
+ SlotTracker Machine(M, /* ShouldInitializeAllMetadata */ IsMetadata);
+ WriteAsOperandInternal(O, this, &TypePrinter, &Machine, M);
}
-void Metadata::print(raw_ostream &ROS) const {
+static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
+ const Module *M, bool OnlyAsOperand) {
formatted_raw_ostream OS(ROS);
- if (auto *N = dyn_cast<MDNode>(this)) {
- SlotTracker SlotTable(static_cast<Function *>(nullptr));
- AssemblyWriter W(OS, SlotTable, nullptr, nullptr);
- W.printMDNodeBody(N);
+ auto *N = dyn_cast<MDNode>(&MD);
+ TypePrinting TypePrinter;
+ SlotTracker Machine(M, /* ShouldInitializeAllMetadata */ N);
+ if (M)
+ TypePrinter.incorporateTypes(*M);
+
+ WriteAsOperandInternal(OS, &MD, &TypePrinter, &Machine, M,
+ /* FromValue */ true);
+ if (OnlyAsOperand || !N)
return;
- }
- printAsOperand(OS);
+
+ OS << " = ";
+ WriteMDNodeBodyInternal(OS, N, &TypePrinter, &Machine, M);
}
-void Metadata::printAsOperand(raw_ostream &ROS, bool PrintType,
- const Module *M) const {
- formatted_raw_ostream OS(ROS);
+void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
+ printMetadataImpl(OS, *this, M, /* OnlyAsOperand */ true);
+}
- std::unique_ptr<TypePrinting> TypePrinter;
- if (PrintType) {
- TypePrinter.reset(new TypePrinting);
- if (M)
- TypePrinter->incorporateTypes(*M);
- }
- WriteAsOperandInternal(OS, this, TypePrinter.get(), nullptr, M,
- /* FromValue */ true);
+void Metadata::print(raw_ostream &OS, const Module *M) const {
+ printMetadataImpl(OS, *this, M, /* OnlyAsOperand */ false);
}
// Value::dump - allow easy printing of Values from the debugger.
@@ -3234,7 +3232,10 @@ LLVM_DUMP_METHOD
void NamedMDNode::dump() const { print(dbgs()); }
LLVM_DUMP_METHOD
-void Metadata::dump() const {
- print(dbgs());
+void Metadata::dump() const { dump(nullptr); }
+
+LLVM_DUMP_METHOD
+void Metadata::dump(const Module *M) const {
+ print(dbgs(), M);
dbgs() << '\n';
}
diff --git a/lib/IR/AsmWriter.h b/lib/IR/AsmWriter.h
deleted file mode 100644
index 7716fa6..0000000
--- a/lib/IR/AsmWriter.h
+++ /dev/null
@@ -1,129 +0,0 @@
-//===-- llvm/IR/AsmWriter.h - Printing LLVM IR as an assembly file - C++ --===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This files defines the interface for the AssemblyWriter class used to print
-// LLVM IR and various helper classes that are used in printing.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIB_IR_ASMWRITER_H
-#define LLVM_LIB_IR_ASMWRITER_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/IR/Attributes.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/TypeFinder.h"
-#include "llvm/IR/UseListOrder.h"
-#include "llvm/Support/FormattedStream.h"
-
-namespace llvm {
-
-class BasicBlock;
-class Function;
-class GlobalValue;
-class Comdat;
-class Module;
-class NamedMDNode;
-class Value;
-class SlotTracker;
-
-/// Create a new SlotTracker for a Module
-SlotTracker *createSlotTracker(const Module *M);
-
-//===----------------------------------------------------------------------===//
-// TypePrinting Class: Type printing machinery
-//===----------------------------------------------------------------------===//
-
-class TypePrinting {
- TypePrinting(const TypePrinting &) = delete;
- void operator=(const TypePrinting&) = delete;
-public:
-
- /// NamedTypes - The named types that are used by the current module.
- TypeFinder NamedTypes;
-
- /// NumberedTypes - The numbered types, along with their value.
- DenseMap<StructType*, unsigned> NumberedTypes;
-
-
- TypePrinting() {}
- ~TypePrinting() {}
-
- void incorporateTypes(const Module &M);
-
- void print(Type *Ty, raw_ostream &OS);
-
- void printStructBody(StructType *Ty, raw_ostream &OS);
-};
-
-class AssemblyWriter {
-protected:
- formatted_raw_ostream &Out;
- const Module *TheModule;
-
-private:
- std::unique_ptr<SlotTracker> ModuleSlotTracker;
- SlotTracker &Machine;
- TypePrinting TypePrinter;
- AssemblyAnnotationWriter *AnnotationWriter;
- SetVector<const Comdat *> Comdats;
- UseListOrderStack UseListOrders;
-
-public:
- /// Construct an AssemblyWriter with an external SlotTracker
- AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
- const Module *M, AssemblyAnnotationWriter *AAW);
-
- /// Construct an AssemblyWriter with an internally allocated SlotTracker
- AssemblyWriter(formatted_raw_ostream &o, const Module *M,
- AssemblyAnnotationWriter *AAW);
-
- virtual ~AssemblyWriter();
-
- void printMDNodeBody(const MDNode *MD);
- void printNamedMDNode(const NamedMDNode *NMD);
-
- void printModule(const Module *M);
-
- void writeOperand(const Value *Op, bool PrintType);
- void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx);
- void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope);
- void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
- AtomicOrdering FailureOrdering,
- SynchronizationScope SynchScope);
-
- void writeAllMDNodes();
- void writeMDNode(unsigned Slot, const MDNode *Node);
- void writeAllAttributeGroups();
-
- void printTypeIdentities();
- void printGlobal(const GlobalVariable *GV);
- void printAlias(const GlobalAlias *GV);
- void printComdat(const Comdat *C);
- void printFunction(const Function *F);
- void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx);
- void printBasicBlock(const BasicBlock *BB);
- void printInstructionLine(const Instruction &I);
- void printInstruction(const Instruction &I);
-
- void printUseListOrder(const UseListOrder &Order);
- void printUseLists(const Function *F);
-
-private:
- void init();
-
- // printInfoComment - Print a little comment after the instruction indicating
- // which slot it occupies.
- void printInfoComment(const Value &V);
-};
-
-} // namespace llvm
-
-#endif
diff --git a/lib/IR/AutoUpgrade.cpp b/lib/IR/AutoUpgrade.cpp
index 0da7784..d2dfeaa 100644
--- a/lib/IR/AutoUpgrade.cpp
+++ b/lib/IR/AutoUpgrade.cpp
@@ -7,7 +7,9 @@
//
//===----------------------------------------------------------------------===//
//
-// This file implements the auto-upgrade helper functions
+// This file implements the auto-upgrade helper functions.
+// This is where deprecated IR intrinsics and other IR features are updated to
+// current specifications.
//
//===----------------------------------------------------------------------===//
@@ -156,6 +158,14 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
Name.startswith("x86.avx2.pcmpeq.") ||
Name.startswith("x86.avx2.pcmpgt.") ||
Name.startswith("x86.avx.vpermil.") ||
+ Name == "x86.avx.vinsertf128.pd.256" ||
+ Name == "x86.avx.vinsertf128.ps.256" ||
+ Name == "x86.avx.vinsertf128.si.256" ||
+ Name == "x86.avx2.vinserti128" ||
+ Name == "x86.avx.vextractf128.pd.256" ||
+ Name == "x86.avx.vextractf128.ps.256" ||
+ Name == "x86.avx.vextractf128.si.256" ||
+ Name == "x86.avx2.vextracti128" ||
Name == "x86.avx.movnt.dq.256" ||
Name == "x86.avx.movnt.pd.256" ||
Name == "x86.avx.movnt.ps.256" ||
@@ -171,6 +181,15 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
Name == "x86.sse2.psrl.dq.bs" ||
Name == "x86.avx2.psll.dq.bs" ||
Name == "x86.avx2.psrl.dq.bs" ||
+ Name == "x86.sse41.pblendw" ||
+ Name == "x86.sse41.blendpd" ||
+ Name == "x86.sse41.blendps" ||
+ Name == "x86.avx.blend.pd.256" ||
+ Name == "x86.avx.blend.ps.256" ||
+ Name == "x86.avx2.pblendw" ||
+ Name == "x86.avx2.pblendd.128" ||
+ Name == "x86.avx2.pblendd.256" ||
+ Name == "x86.avx2.vbroadcasti128" ||
(Name.startswith("x86.xop.vpcom") && F->arg_size() == 2)) {
NewFn = nullptr;
return true;
@@ -184,17 +203,8 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
if (Name == "x86.sse41.ptestnzc")
return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestnzc, NewFn);
}
- // Several blend and other instructions with maskes used the wrong number of
+ // Several blend and other instructions with masks used the wrong number of
// bits.
- if (Name == "x86.sse41.pblendw")
- return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_pblendw,
- NewFn);
- if (Name == "x86.sse41.blendpd")
- return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_blendpd,
- NewFn);
- if (Name == "x86.sse41.blendps")
- return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_blendps,
- NewFn);
if (Name == "x86.sse41.insertps")
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_insertps,
NewFn);
@@ -207,24 +217,9 @@ static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
if (Name == "x86.sse41.mpsadbw")
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_mpsadbw,
NewFn);
- if (Name == "x86.avx.blend.pd.256")
- return UpgradeX86IntrinsicsWith8BitMask(
- F, Intrinsic::x86_avx_blend_pd_256, NewFn);
- if (Name == "x86.avx.blend.ps.256")
- return UpgradeX86IntrinsicsWith8BitMask(
- F, Intrinsic::x86_avx_blend_ps_256, NewFn);
if (Name == "x86.avx.dp.ps.256")
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx_dp_ps_256,
NewFn);
- if (Name == "x86.avx2.pblendw")
- return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx2_pblendw,
- NewFn);
- if (Name == "x86.avx2.pblendd.128")
- return UpgradeX86IntrinsicsWith8BitMask(
- F, Intrinsic::x86_avx2_pblendd_128, NewFn);
- if (Name == "x86.avx2.pblendd.256")
- return UpgradeX86IntrinsicsWith8BitMask(
- F, Intrinsic::x86_avx2_pblendd_256, NewFn);
if (Name == "x86.avx2.mpsadbw")
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx2_mpsadbw,
NewFn);
@@ -569,6 +564,15 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
for (unsigned I = 0; I < EltNum; ++I)
Rep = Builder.CreateInsertElement(Rep, Load,
ConstantInt::get(I32Ty, I));
+ } else if (Name == "llvm.x86.avx2.vbroadcasti128") {
+ // Replace vbroadcasts with a vector shuffle.
+ Value *Op = Builder.CreatePointerCast(
+ CI->getArgOperand(0),
+ PointerType::getUnqual(VectorType::get(Type::getInt64Ty(C), 2)));
+ Value *Load = Builder.CreateLoad(Op);
+ const int Idxs[4] = { 0, 1, 0, 1 };
+ Rep = Builder.CreateShuffleVector(Load, UndefValue::get(Load->getType()),
+ Idxs);
} else if (Name == "llvm.x86.sse2.psll.dq") {
// 128-bit shift left specified in bits.
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
@@ -609,6 +613,94 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
Rep = UpgradeX86PSRLDQIntrinsics(Builder, C, CI->getArgOperand(0), 2,
Shift);
+ } else if (Name == "llvm.x86.sse41.pblendw" ||
+ Name == "llvm.x86.sse41.blendpd" ||
+ Name == "llvm.x86.sse41.blendps" ||
+ Name == "llvm.x86.avx.blend.pd.256" ||
+ Name == "llvm.x86.avx.blend.ps.256" ||
+ Name == "llvm.x86.avx2.pblendw" ||
+ Name == "llvm.x86.avx2.pblendd.128" ||
+ Name == "llvm.x86.avx2.pblendd.256") {
+ Value *Op0 = CI->getArgOperand(0);
+ Value *Op1 = CI->getArgOperand(1);
+ unsigned Imm = cast <ConstantInt>(CI->getArgOperand(2))->getZExtValue();
+ VectorType *VecTy = cast<VectorType>(CI->getType());
+ unsigned NumElts = VecTy->getNumElements();
+
+ SmallVector<Constant*, 16> Idxs;
+ for (unsigned i = 0; i != NumElts; ++i) {
+ unsigned Idx = ((Imm >> (i%8)) & 1) ? i + NumElts : i;
+ Idxs.push_back(Builder.getInt32(Idx));
+ }
+
+ Rep = Builder.CreateShuffleVector(Op0, Op1, ConstantVector::get(Idxs));
+ } else if (Name == "llvm.x86.avx.vinsertf128.pd.256" ||
+ Name == "llvm.x86.avx.vinsertf128.ps.256" ||
+ Name == "llvm.x86.avx.vinsertf128.si.256" ||
+ Name == "llvm.x86.avx2.vinserti128") {
+ Value *Op0 = CI->getArgOperand(0);
+ Value *Op1 = CI->getArgOperand(1);
+ unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
+ VectorType *VecTy = cast<VectorType>(CI->getType());
+ unsigned NumElts = VecTy->getNumElements();
+
+ // Mask off the high bits of the immediate value; hardware ignores those.
+ Imm = Imm & 1;
+
+ // Extend the second operand into a vector that is twice as big.
+ Value *UndefV = UndefValue::get(Op1->getType());
+ SmallVector<Constant*, 8> Idxs;
+ for (unsigned i = 0; i != NumElts; ++i) {
+ Idxs.push_back(Builder.getInt32(i));
+ }
+ Rep = Builder.CreateShuffleVector(Op1, UndefV, ConstantVector::get(Idxs));
+
+ // Insert the second operand into the first operand.
+
+ // Note that there is no guarantee that instruction lowering will actually
+ // produce a vinsertf128 instruction for the created shuffles. In
+ // particular, the 0 immediate case involves no lane changes, so it can
+ // be handled as a blend.
+
+ // Example of shuffle mask for 32-bit elements:
+ // Imm = 1 <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
+ // Imm = 0 <i32 8, i32 9, i32 10, i32 11, i32 4, i32 5, i32 6, i32 7 >
+
+ SmallVector<Constant*, 8> Idxs2;
+ // The low half of the result is either the low half of the 1st operand
+ // or the low half of the 2nd operand (the inserted vector).
+ for (unsigned i = 0; i != NumElts / 2; ++i) {
+ unsigned Idx = Imm ? i : (i + NumElts);
+ Idxs2.push_back(Builder.getInt32(Idx));
+ }
+ // The high half of the result is either the low half of the 2nd operand
+ // (the inserted vector) or the high half of the 1st operand.
+ for (unsigned i = NumElts / 2; i != NumElts; ++i) {
+ unsigned Idx = Imm ? (i + NumElts / 2) : i;
+ Idxs2.push_back(Builder.getInt32(Idx));
+ }
+ Rep = Builder.CreateShuffleVector(Op0, Rep, ConstantVector::get(Idxs2));
+ } else if (Name == "llvm.x86.avx.vextractf128.pd.256" ||
+ Name == "llvm.x86.avx.vextractf128.ps.256" ||
+ Name == "llvm.x86.avx.vextractf128.si.256" ||
+ Name == "llvm.x86.avx2.vextracti128") {
+ Value *Op0 = CI->getArgOperand(0);
+ unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
+ VectorType *VecTy = cast<VectorType>(CI->getType());
+ unsigned NumElts = VecTy->getNumElements();
+
+ // Mask off the high bits of the immediate value; hardware ignores those.
+ Imm = Imm & 1;
+
+ // Get indexes for either the high half or low half of the input vector.
+ SmallVector<Constant*, 4> Idxs(NumElts);
+ for (unsigned i = 0; i != NumElts; ++i) {
+ unsigned Idx = Imm ? (i + NumElts) : i;
+ Idxs[i] = Builder.getInt32(Idx);
+ }
+
+ Value *UndefV = UndefValue::get(Op0->getType());
+ Rep = Builder.CreateShuffleVector(Op0, UndefV, ConstantVector::get(Idxs));
} else {
bool PD128 = false, PD256 = false, PS128 = false, PS256 = false;
if (Name == "llvm.x86.avx.vpermil.pd.256")
@@ -739,19 +831,11 @@ void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
return;
}
- case Intrinsic::x86_sse41_pblendw:
- case Intrinsic::x86_sse41_blendpd:
- case Intrinsic::x86_sse41_blendps:
case Intrinsic::x86_sse41_insertps:
case Intrinsic::x86_sse41_dppd:
case Intrinsic::x86_sse41_dpps:
case Intrinsic::x86_sse41_mpsadbw:
- case Intrinsic::x86_avx_blend_pd_256:
- case Intrinsic::x86_avx_blend_ps_256:
case Intrinsic::x86_avx_dp_ps_256:
- case Intrinsic::x86_avx2_pblendw:
- case Intrinsic::x86_avx2_pblendd_128:
- case Intrinsic::x86_avx2_pblendd_256:
case Intrinsic::x86_avx2_mpsadbw: {
// Need to truncate the last argument from i32 to i8 -- this argument models
// an inherently 8-bit immediate operand to these x86 instructions.
diff --git a/lib/IR/BasicBlock.cpp b/lib/IR/BasicBlock.cpp
index b3b3cbf..fe38385 100644
--- a/lib/IR/BasicBlock.cpp
+++ b/lib/IR/BasicBlock.cpp
@@ -29,10 +29,6 @@ ValueSymbolTable *BasicBlock::getValueSymbolTable() {
return nullptr;
}
-const DataLayout *BasicBlock::getDataLayout() const {
- return getParent()->getDataLayout();
-}
-
LLVMContext &BasicBlock::getContext() const {
return getType()->getContext();
}
@@ -102,14 +98,14 @@ void BasicBlock::eraseFromParent() {
getParent()->getBasicBlockList().erase(this);
}
-/// moveBefore - Unlink this basic block from its current function and
+/// Unlink this basic block from its current function and
/// insert it into the function that MovePos lives in, right before MovePos.
void BasicBlock::moveBefore(BasicBlock *MovePos) {
MovePos->getParent()->getBasicBlockList().splice(MovePos,
getParent()->getBasicBlockList(), this);
}
-/// moveAfter - Unlink this basic block from its current function and
+/// Unlink this basic block from its current function and
/// insert it into the function that MovePos lives in, right after MovePos.
void BasicBlock::moveAfter(BasicBlock *MovePos) {
Function::iterator I = MovePos;
@@ -117,6 +113,9 @@ void BasicBlock::moveAfter(BasicBlock *MovePos) {
getParent()->getBasicBlockList(), this);
}
+const Module *BasicBlock::getModule() const {
+ return getParent()->getParent();
+}
TerminatorInst *BasicBlock::getTerminator() {
if (InstList.empty()) return nullptr;
@@ -210,7 +209,7 @@ void BasicBlock::dropAllReferences() {
I->dropAllReferences();
}
-/// getSinglePredecessor - If this basic block has a single predecessor block,
+/// If this basic block has a single predecessor block,
/// return the block, otherwise return a null pointer.
BasicBlock *BasicBlock::getSinglePredecessor() {
pred_iterator PI = pred_begin(this), E = pred_end(this);
@@ -220,7 +219,7 @@ BasicBlock *BasicBlock::getSinglePredecessor() {
return (PI == E) ? ThePred : nullptr /*multiple preds*/;
}
-/// getUniquePredecessor - If this basic block has a unique predecessor block,
+/// If this basic block has a unique predecessor block,
/// return the block, otherwise return a null pointer.
/// Note that unique predecessor doesn't mean single edge, there can be
/// multiple edges from the unique predecessor to this block (for example
@@ -253,7 +252,7 @@ BasicBlock *BasicBlock::getUniqueSuccessor() {
return SuccBB;
}
-/// removePredecessor - This method is used to notify a BasicBlock that the
+/// This method is used to notify a BasicBlock that the
/// specified Predecessor of the block is no longer able to reach it. This is
/// actually not used to update the Predecessor list, but is actually used to
/// update the PHI nodes that reside in the block. Note that this should be
@@ -330,7 +329,7 @@ void BasicBlock::removePredecessor(BasicBlock *Pred,
}
-/// splitBasicBlock - This splits a basic block into two at the specified
+/// This splits a basic block into two at the specified
/// instruction. Note that all instructions BEFORE the specified iterator stay
/// as part of the original basic block, an unconditional branch is added to
/// the new BB, and the rest of the instructions in the BB are moved to the new
@@ -401,14 +400,13 @@ void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *New) {
}
}
-/// isLandingPad - Return true if this basic block is a landing pad. I.e., it's
+/// Return true if this basic block is a landing pad. I.e., it's
/// the destination of the 'unwind' edge of an invoke instruction.
bool BasicBlock::isLandingPad() const {
return isa<LandingPadInst>(getFirstNonPHI());
}
-/// getLandingPadInst() - Return the landingpad instruction associated with
-/// the landing pad.
+/// Return the landingpad instruction associated with the landing pad.
LandingPadInst *BasicBlock::getLandingPadInst() {
return dyn_cast<LandingPadInst>(getFirstNonPHI());
}
diff --git a/lib/IR/ConstantFold.cpp b/lib/IR/ConstantFold.cpp
index a915d28..d97d2c4 100644
--- a/lib/IR/ConstantFold.cpp
+++ b/lib/IR/ConstantFold.cpp
@@ -1120,27 +1120,18 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
return ConstantInt::get(CI1->getContext(), C1V | C2V);
case Instruction::Xor:
return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
- case Instruction::Shl: {
- uint32_t shiftAmt = C2V.getZExtValue();
- if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(CI1->getContext(), C1V.shl(shiftAmt));
- else
- return UndefValue::get(C1->getType()); // too big shift is undef
- }
- case Instruction::LShr: {
- uint32_t shiftAmt = C2V.getZExtValue();
- if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(CI1->getContext(), C1V.lshr(shiftAmt));
- else
- return UndefValue::get(C1->getType()); // too big shift is undef
- }
- case Instruction::AShr: {
- uint32_t shiftAmt = C2V.getZExtValue();
- if (shiftAmt < C1V.getBitWidth())
- return ConstantInt::get(CI1->getContext(), C1V.ashr(shiftAmt));
- else
- return UndefValue::get(C1->getType()); // too big shift is undef
- }
+ case Instruction::Shl:
+ if (C2V.ult(C1V.getBitWidth()))
+ return ConstantInt::get(CI1->getContext(), C1V.shl(C2V));
+ return UndefValue::get(C1->getType()); // too big shift is undef
+ case Instruction::LShr:
+ if (C2V.ult(C1V.getBitWidth()))
+ return ConstantInt::get(CI1->getContext(), C1V.lshr(C2V));
+ return UndefValue::get(C1->getType()); // too big shift is undef
+ case Instruction::AShr:
+ if (C2V.ult(C1V.getBitWidth()))
+ return ConstantInt::get(CI1->getContext(), C1V.ashr(C2V));
+ return UndefValue::get(C1->getType()); // too big shift is undef
}
}
@@ -1327,7 +1318,7 @@ static FCmpInst::Predicate evaluateFCmpRelation(Constant *V1, Constant *V2) {
if (!isa<ConstantExpr>(V1)) {
if (!isa<ConstantExpr>(V2)) {
- // We distilled thisUse the standard constant folder for a few cases
+ // Simple case, use the standard constant folder.
ConstantInt *R = nullptr;
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, V1, V2));
@@ -1665,15 +1656,22 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
// Handle some degenerate cases first
if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
+ CmpInst::Predicate Predicate = CmpInst::Predicate(pred);
+ bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
// For EQ and NE, we can always pick a value for the undef to make the
// predicate pass or fail, so we can return undef.
- // Also, if both operands are undef, we can return undef.
- if (ICmpInst::isEquality(ICmpInst::Predicate(pred)) ||
- (isa<UndefValue>(C1) && isa<UndefValue>(C2)))
+ // Also, if both operands are undef, we can return undef for int comparison.
+ if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
return UndefValue::get(ResultTy);
- // Otherwise, pick the same value as the non-undef operand, and fold
- // it to true or false.
- return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(pred));
+
+ // Otherwise, for integer compare, pick the same value as the non-undef
+ // operand, and fold it to true or false.
+ if (isIntegerPredicate)
+ return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(pred));
+
+ // Choosing NaN for the undef will always make unordered comparison succeed
+ // and ordered comparison fails.
+ return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
}
// icmp eq/ne(null,GV) -> false/true
@@ -1789,7 +1787,10 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
return ConstantVector::get(ResElts);
}
- if (C1->getType()->isFloatingPointTy()) {
+ if (C1->getType()->isFloatingPointTy() &&
+ // Only call evaluateFCmpRelation if we have a constant expr to avoid
+ // infinite recursive loop
+ (isa<ConstantExpr>(C1) || isa<ConstantExpr>(C2))) {
int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
switch (evaluateFCmpRelation(C1, C2)) {
default: llvm_unreachable("Unknown relation!");
diff --git a/lib/IR/ConstantRange.cpp b/lib/IR/ConstantRange.cpp
index f8e9ba4..91095cf 100644
--- a/lib/IR/ConstantRange.cpp
+++ b/lib/IR/ConstantRange.cpp
@@ -49,14 +49,15 @@ ConstantRange::ConstantRange(APIntMoveTy L, APIntMoveTy U)
"Lower == Upper, but they aren't min or max value!");
}
-ConstantRange ConstantRange::makeICmpRegion(unsigned Pred,
- const ConstantRange &CR) {
+ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred,
+ const ConstantRange &CR) {
if (CR.isEmptySet())
return CR;
uint32_t W = CR.getBitWidth();
switch (Pred) {
- default: llvm_unreachable("Invalid ICmp predicate to makeICmpRegion()");
+ default:
+ llvm_unreachable("Invalid ICmp predicate to makeAllowedICmpRegion()");
case CmpInst::ICMP_EQ:
return CR;
case CmpInst::ICMP_NE:
@@ -114,6 +115,16 @@ ConstantRange ConstantRange::makeICmpRegion(unsigned Pred,
}
}
+ConstantRange ConstantRange::makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
+ const ConstantRange &CR) {
+ // Follows from De-Morgan's laws:
+ //
+ // ~(~A union ~B) == A intersect B.
+ //
+ return makeAllowedICmpRegion(CmpInst::getInversePredicate(Pred), CR)
+ .inverse();
+}
+
/// isFullSet - Return true if this set contains all of the elements possible
/// for this data-type
bool ConstantRange::isFullSet() const {
@@ -587,6 +598,13 @@ ConstantRange::multiply(const ConstantRange &Other) const {
if (isEmptySet() || Other.isEmptySet())
return ConstantRange(getBitWidth(), /*isFullSet=*/false);
+ // Multiplication is signedness-independent. However different ranges can be
+ // obtained depending on how the input ranges are treated. These different
+ // ranges are all conservatively correct, but one might be better than the
+ // other. We calculate two ranges; one treating the inputs as unsigned
+ // and the other signed, then return the smallest of these ranges.
+
+ // Unsigned range first.
APInt this_min = getUnsignedMin().zext(getBitWidth() * 2);
APInt this_max = getUnsignedMax().zext(getBitWidth() * 2);
APInt Other_min = Other.getUnsignedMin().zext(getBitWidth() * 2);
@@ -594,7 +612,26 @@ ConstantRange::multiply(const ConstantRange &Other) const {
ConstantRange Result_zext = ConstantRange(this_min * Other_min,
this_max * Other_max + 1);
- return Result_zext.truncate(getBitWidth());
+ ConstantRange UR = Result_zext.truncate(getBitWidth());
+
+ // Now the signed range. Because we could be dealing with negative numbers
+ // here, the lower bound is the smallest of the cartesian product of the
+ // lower and upper ranges; for example:
+ // [-1,4) * [-2,3) = min(-1*-2, -1*2, 3*-2, 3*2) = -6.
+ // Similarly for the upper bound, swapping min for max.
+
+ this_min = getSignedMin().sext(getBitWidth() * 2);
+ this_max = getSignedMax().sext(getBitWidth() * 2);
+ Other_min = Other.getSignedMin().sext(getBitWidth() * 2);
+ Other_max = Other.getSignedMax().sext(getBitWidth() * 2);
+
+ auto L = {this_min * Other_min, this_min * Other_max,
+ this_max * Other_min, this_max * Other_max};
+ auto Compare = [](const APInt &A, const APInt &B) { return A.slt(B); };
+ ConstantRange Result_sext(std::min(L, Compare), std::max(L, Compare) + 1);
+ ConstantRange SR = Result_sext.truncate(getBitWidth());
+
+ return UR.getSetSize().ult(SR.getSetSize()) ? UR : SR;
}
ConstantRange
diff --git a/lib/IR/Constants.cpp b/lib/IR/Constants.cpp
index 0bf61a7..e51a396 100644
--- a/lib/IR/Constants.cpp
+++ b/lib/IR/Constants.cpp
@@ -1215,11 +1215,9 @@ ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
bool OnlyIfReduced) const {
assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
- bool AnyChange = Ty != getType();
- for (unsigned i = 0; i != Ops.size(); ++i)
- AnyChange |= Ops[i] != getOperand(i);
- if (!AnyChange) // No operands changed, return self.
+ // If no operands changed return self.
+ if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
return const_cast<ConstantExpr*>(this);
Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
@@ -2971,10 +2969,7 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV,
}
Instruction *ConstantExpr::getAsInstruction() {
- SmallVector<Value*,4> ValueOperands;
- for (op_iterator I = op_begin(), E = op_end(); I != E; ++I)
- ValueOperands.push_back(cast<Value>(I));
-
+ SmallVector<Value *, 4> ValueOperands(op_begin(), op_end());
ArrayRef<Value*> Ops(ValueOperands);
switch (getOpcode()) {
@@ -3006,12 +3001,14 @@ Instruction *ConstantExpr::getAsInstruction() {
case Instruction::ShuffleVector:
return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]);
- case Instruction::GetElementPtr:
- if (cast<GEPOperator>(this)->isInBounds())
- return GetElementPtrInst::CreateInBounds(Ops[0], Ops.slice(1));
- else
- return GetElementPtrInst::Create(Ops[0], Ops.slice(1));
-
+ case Instruction::GetElementPtr: {
+ const auto *GO = cast<GEPOperator>(this);
+ if (GO->isInBounds())
+ return GetElementPtrInst::CreateInBounds(GO->getSourceElementType(),
+ Ops[0], Ops.slice(1));
+ return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
+ Ops.slice(1));
+ }
case Instruction::ICmp:
case Instruction::FCmp:
return CmpInst::Create((Instruction::OtherOps)getOpcode(),
diff --git a/lib/IR/Core.cpp b/lib/IR/Core.cpp
index f007616..613147e 100644
--- a/lib/IR/Core.cpp
+++ b/lib/IR/Core.cpp
@@ -2506,7 +2506,7 @@ LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
LLVMValueRef *Indices, unsigned NumIndices,
const char *Name) {
ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
- return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), IdxList, Name));
+ return wrap(unwrap(B)->CreateGEP(nullptr, unwrap(Pointer), IdxList, Name));
}
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
diff --git a/lib/IR/DIBuilder.cpp b/lib/IR/DIBuilder.cpp
index 2cb27ca..9677de4 100644
--- a/lib/IR/DIBuilder.cpp
+++ b/lib/IR/DIBuilder.cpp
@@ -121,18 +121,10 @@ void DIBuilder::finalize() {
}
/// If N is compile unit return NULL otherwise return N.
-static MDNode *getNonCompileUnitScope(MDNode *N) {
- if (DIDescriptor(N).isCompileUnit())
+static MDScope *getNonCompileUnitScope(MDNode *N) {
+ if (!N || isa<MDCompileUnit>(N))
return nullptr;
- return N;
-}
-
-static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
- StringRef Directory) {
- assert(!Filename.empty() && "Unable to create file without name");
- Metadata *Pair[] = {MDString::get(VMContext, Filename),
- MDString::get(VMContext, Directory)};
- return MDNode::get(VMContext, Pair);
+ return cast<MDScope>(N);
}
DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
@@ -157,22 +149,12 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
TempGVs = MDTuple::getTemporary(VMContext, None).release();
TempImportedModules = MDTuple::getTemporary(VMContext, None).release();
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
- .concat(Lang)
- .concat(Producer)
- .concat(isOptimized)
- .concat(Flags)
- .concat(RunTimeVer)
- .concat(SplitName)
- .concat(Kind)
- .get(VMContext),
- createFilePathPair(VMContext, Filename, Directory),
- TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
- TempImportedModules};
-
// TODO: Switch to getDistinct(). We never want to merge compile units based
// on contents.
- MDNode *CUNode = MDNode::get(VMContext, Elts);
+ MDNode *CUNode = MDCompileUnit::get(
+ VMContext, Lang, MDFile::get(VMContext, Filename, Directory), Producer,
+ isOptimized, Flags, RunTimeVer, SplitName, Kind, TempEnumTypes,
+ TempRetainTypes, TempSubprograms, TempGVs, TempImportedModules);
// Create a named metadata so that it is easier to find cu in a module.
// Note that we only generate this when the caller wants to actually
@@ -192,11 +174,7 @@ static DIImportedEntity
createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
Metadata *NS, unsigned Line, StringRef Name,
SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
- const MDNode *R;
- Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
- Context, NS};
- R = MDNode::get(C, Elts);
- DIImportedEntity M(R);
+ DIImportedEntity M = MDImportedEntity::get(C, Tag, Context, NS, Line, Name);
assert(M.Verify() && "Imported module should be valid");
AllImportedModules.emplace_back(M.get());
return M;
@@ -236,39 +214,17 @@ DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
}
DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
- createFilePathPair(VMContext, Filename, Directory)};
- return DIFile(MDNode::get(VMContext, Elts));
+ return MDFile::get(VMContext, Filename, Directory);
}
DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
assert(!Name.empty() && "Unable to create enumerator without name");
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
- .concat(Name)
- .concat(Val)
- .get(VMContext)};
- return DIEnumerator(MDNode::get(VMContext, Elts));
+ return MDEnumerator::get(VMContext, Val, Name);
}
DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
assert(!Name.empty() && "Unable to create type without name");
- // Unspecified types are encoded in DIBasicType format. Line number, filename,
- // size, alignment, offset and flags are always empty here.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
- .concat(Name)
- .concat(0)
- .concat(0)
- .concat(0)
- .concat(0)
- .concat(0)
- .concat(0)
- .get(VMContext),
- nullptr, // Filename
- nullptr // Unused
- };
- return DIBasicType(MDNode::get(VMContext, Elts));
+ return MDBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
}
DIBasicType DIBuilder::createNullPtrType() {
@@ -279,142 +235,61 @@ DIBasicType
DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
uint64_t AlignInBits, unsigned Encoding) {
assert(!Name.empty() && "Unable to create type without name");
- // Basic types are encoded in DIBasicType format. Line number, filename,
- // offset and flags are always empty here.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_base_type)
- .concat(Name)
- .concat(0) // Line
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(0) // Flags
- .concat(Encoding)
- .get(VMContext),
- nullptr, // Filename
- nullptr // Unused
- };
- return DIBasicType(MDNode::get(VMContext, Elts));
+ return MDBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
+ AlignInBits, Encoding);
}
DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
- // Qualified types are encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(Tag)
- .concat(StringRef()) // Name
- .concat(0) // Line
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- nullptr, // Filename
- nullptr, // Unused
- FromTy.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
+ FromTy.getRef(), 0, 0, 0, 0);
}
DIDerivedType
DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
uint64_t AlignInBits, StringRef Name) {
- // Pointer types are encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
- .concat(Name)
- .concat(0) // Line
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- nullptr, // Filename
- nullptr, // Unused
- PointeeTy.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ // FIXME: Why is there a name here?
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
+ nullptr, 0, nullptr, PointeeTy.getRef(), SizeInBits,
+ AlignInBits, 0, 0);
}
DIDerivedType
DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
uint64_t SizeInBits, uint64_t AlignInBits) {
- // Pointer types are encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
- .concat(StringRef())
- .concat(0) // Line
- .concat(SizeInBits) // Size
- .concat(AlignInBits) // Align
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- nullptr, // Filename
- nullptr, // Unused
- PointeeTy.getRef(), Base.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
+ nullptr, 0, nullptr, PointeeTy.getRef(), SizeInBits,
+ AlignInBits, 0, 0, Base.getRef());
}
DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
assert(RTy.isType() && "Unable to create reference type");
- // References are encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(Tag)
- .concat(StringRef()) // Name
- .concat(0) // Line
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- nullptr, // Filename
- nullptr, // TheCU,
- RTy.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
+ RTy.getRef(), 0, 0, 0, 0);
}
DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
unsigned LineNo, DIDescriptor Context) {
- // typedefs are encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
- .concat(Name)
- .concat(LineNo)
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- File.getFileNode(),
- DIScope(getNonCompileUnitScope(Context)).getRef(),
- Ty.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name,
+ File.getFileNode(), LineNo,
+ DIScope(getNonCompileUnitScope(Context)).getRef(),
+ Ty.getRef(), 0, 0, 0, 0);
}
DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
// typedefs are encoded in DIDerivedType format.
assert(Ty.isType() && "Invalid type!");
assert(FriendTy.isType() && "Invalid friend type!");
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
- .concat(StringRef()) // Name
- .concat(0) // Line
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(0) // Flags
- .get(VMContext),
- nullptr, Ty.getRef(), FriendTy.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
+ Ty.getRef(), FriendTy.getRef(), 0, 0, 0, 0);
}
DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
uint64_t BaseOffset,
unsigned Flags) {
assert(Ty.isType() && "Unable to create inheritance");
- // TAG_inheritance is encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
- .concat(StringRef()) // Name
- .concat(0) // Line
- .concat(0) // Size
- .concat(0) // Align
- .concat(BaseOffset)
- .concat(Flags)
- .get(VMContext),
- nullptr, Ty.getRef(), BaseTy.getRef()};
- auto R = DIDerivedType(MDNode::get(VMContext, Elts));
- return R;
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
+ 0, Ty.getRef(), BaseTy.getRef(), 0, 0, BaseOffset,
+ Flags);
}
DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
@@ -423,22 +298,13 @@ DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
DIType Ty) {
- // TAG_member is encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(OffsetInBits)
- .concat(Flags)
- .get(VMContext),
- File.getFileNode(),
- DIScope(getNonCompileUnitScope(Scope)).getRef(),
- Ty.getRef()};
- return DIDerivedType(MDNode::get(VMContext, Elts));
-}
-
-static Metadata *getConstantOrNull(Constant *C) {
+ return MDDerivedType::get(
+ VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), Ty.getRef(), SizeInBits,
+ AlignInBits, OffsetInBits, Flags);
+}
+
+static ConstantAsMetadata *getConstantOrNull(Constant *C) {
if (C)
return ConstantAsMetadata::get(C);
return nullptr;
@@ -451,18 +317,10 @@ DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
llvm::Constant *Val) {
// TAG_member is encoded in DIDerivedType format.
Flags |= DIDescriptor::FlagStaticMember;
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
- .concat(Name)
- .concat(LineNumber)
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(Flags)
- .get(VMContext),
- File.getFileNode(),
- DIScope(getNonCompileUnitScope(Scope)).getRef(),
- Ty.getRef(), getConstantOrNull(Val)};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(
+ VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), Ty.getRef(), 0, 0, 0,
+ Flags, getConstantOrNull(Val));
}
DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
@@ -471,33 +329,18 @@ DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
uint64_t AlignInBits,
uint64_t OffsetInBits, unsigned Flags,
DIType Ty, MDNode *PropertyNode) {
- // TAG_member is encoded in DIDerivedType format.
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(OffsetInBits)
- .concat(Flags)
- .get(VMContext),
- File.getFileNode(), getNonCompileUnitScope(File), Ty,
- PropertyNode};
- return DIDerivedType(MDNode::get(VMContext, Elts));
+ return MDDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
+ LineNumber, getNonCompileUnitScope(File),
+ Ty.getRef(), SizeInBits, AlignInBits, OffsetInBits,
+ Flags, PropertyNode);
}
DIObjCProperty
DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
StringRef GetterName, StringRef SetterName,
unsigned PropertyAttributes, DIType Ty) {
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
- .concat(Name)
- .concat(LineNumber)
- .concat(GetterName)
- .concat(SetterName)
- .concat(PropertyAttributes)
- .get(VMContext),
- File, Ty};
- return DIObjCProperty(MDNode::get(VMContext, Elts));
+ return MDObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
+ SetterName, PropertyAttributes, Ty);
}
DITemplateTypeParameter
@@ -505,13 +348,7 @@ DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
DIType Ty) {
assert(!DIScope(getNonCompileUnitScope(Context)).getRef() &&
"Expected compile unit");
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
- .concat(Name)
- .concat(0)
- .concat(0)
- .get(VMContext),
- nullptr, Ty.getRef(), nullptr};
- return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
+ return MDTemplateTypeParameter::get(VMContext, Name, Ty.getRef());
}
static DITemplateValueParameter
@@ -520,10 +357,7 @@ createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
DIType Ty, Metadata *MD) {
assert(!DIScope(getNonCompileUnitScope(Context)).getRef() &&
"Expected compile unit");
- Metadata *Elts[] = {
- HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
- nullptr, Ty.getRef(), MD, nullptr};
- return DITemplateValueParameter(MDNode::get(VMContext, Elts));
+ return MDTemplateValueParameter::get(VMContext, Tag, Name, Ty.getRef(), MD);
}
DITemplateValueParameter
@@ -563,23 +397,11 @@ DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
assert((!Context || Context.isScope() || Context.isType()) &&
"createClassType should be called with a valid Context");
// TAG_class_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_class_type)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(OffsetInBits)
- .concat(Flags)
- .concat(0)
- .get(VMContext),
- File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
- DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- DICompositeType R(MDNode::get(VMContext, Elts));
- assert(R.isCompositeType() &&
- "createClassType should return a DICompositeType");
+ DICompositeType R = MDCompositeType::get(
+ VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Context)).getRef(), DerivedFrom.getRef(),
+ SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, 0,
+ VTableHolder.getRef(), TemplateParams, UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(R);
trackIfUnresolved(R);
@@ -596,24 +418,11 @@ DICompositeType DIBuilder::createStructType(DIDescriptor Context,
unsigned RunTimeLang,
DIType VTableHolder,
StringRef UniqueIdentifier) {
- // TAG_structure_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_structure_type)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0)
- .concat(Flags)
- .concat(RunTimeLang)
- .get(VMContext),
- File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
- DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- DICompositeType R(MDNode::get(VMContext, Elts));
- assert(R.isCompositeType() &&
- "createStructType should return a DICompositeType");
+ DICompositeType R = MDCompositeType::get(
+ VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Context)).getRef(), DerivedFrom.getRef(),
+ SizeInBits, AlignInBits, 0, Flags, Elements, RunTimeLang,
+ VTableHolder.getRef(), nullptr, UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(R);
trackIfUnresolved(R);
@@ -627,22 +436,11 @@ DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
DIArray Elements,
unsigned RunTimeLang,
StringRef UniqueIdentifier) {
- // TAG_union_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_union_type)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(Flags)
- .concat(RunTimeLang)
- .get(VMContext),
- File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
- nullptr, Elements, nullptr, nullptr,
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- DICompositeType R(MDNode::get(VMContext, Elts));
+ DICompositeType R = MDCompositeType::get(
+ VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr, SizeInBits,
+ AlignInBits, 0, Flags, Elements, RunTimeLang, nullptr, nullptr,
+ UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(R);
trackIfUnresolved(R);
@@ -652,43 +450,18 @@ DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
DISubroutineType DIBuilder::createSubroutineType(DIFile File,
DITypeArray ParameterTypes,
unsigned Flags) {
- // TAG_subroutine_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
- .concat(StringRef())
- .concat(0) // Line
- .concat(0) // Size
- .concat(0) // Align
- .concat(0) // Offset
- .concat(Flags) // Flags
- .concat(0)
- .get(VMContext),
- nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
- nullptr // Type Identifer
- };
- return DISubroutineType(MDNode::get(VMContext, Elts));
+ return MDSubroutineType::get(VMContext, Flags, ParameterTypes);
}
DICompositeType DIBuilder::createEnumerationType(
DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
DIType UnderlyingType, StringRef UniqueIdentifier) {
- // TAG_enumeration_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
- .concat(Name)
- .concat(LineNumber)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(0) // Flags
- .concat(0)
- .get(VMContext),
- File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
- UnderlyingType.getRef(), Elements, nullptr, nullptr,
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- DICompositeType CTy(MDNode::get(VMContext, Elts));
+ DICompositeType CTy = MDCompositeType::get(
+ VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), UnderlyingType.getRef(),
+ SizeInBits, AlignInBits, 0, 0, Elements, 0, nullptr, nullptr,
+ UniqueIdentifier);
AllEnumTypes.push_back(CTy);
if (!UniqueIdentifier.empty())
retainType(CTy);
@@ -698,85 +471,38 @@ DICompositeType DIBuilder::createEnumerationType(
DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts) {
- // TAG_array_type is encoded in DICompositeType format.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_array_type)
- .concat(StringRef())
- .concat(0) // Line
- .concat(Size)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(0) // Flags
- .concat(0)
- .get(VMContext),
- nullptr, // Filename/Directory,
- nullptr, // Unused
- Ty.getRef(), Subscripts, nullptr, nullptr,
- nullptr // Type Identifer
- };
- DICompositeType R(MDNode::get(VMContext, Elts));
+ auto *R = MDCompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
+ nullptr, 0, nullptr, Ty.getRef(), Size,
+ AlignInBits, 0, 0, Subscripts, 0, nullptr);
trackIfUnresolved(R);
return R;
}
DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
DIType Ty, DIArray Subscripts) {
- // A vector is an array type with the FlagVector flag applied.
- Metadata *Elts[] = {
- HeaderBuilder::get(dwarf::DW_TAG_array_type)
- .concat("")
- .concat(0) // Line
- .concat(Size)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(DIType::FlagVector)
- .concat(0)
- .get(VMContext),
- nullptr, // Filename/Directory,
- nullptr, // Unused
- Ty.getRef(), Subscripts, nullptr, nullptr,
- nullptr // Type Identifer
- };
- DICompositeType R(MDNode::get(VMContext, Elts));
+ auto *R = MDCompositeType::get(
+ VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0, nullptr, Ty.getRef(),
+ Size, AlignInBits, 0, DIType::FlagVector, Subscripts, 0, nullptr);
trackIfUnresolved(R);
return R;
}
-static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
- unsigned FlagsToSet) {
- DIHeaderFieldIterator I(Header);
- std::advance(I, 6);
-
- unsigned Flags;
- if (I->getAsInteger(0, Flags))
- Flags = 0;
- Flags |= FlagsToSet;
-
- return HeaderBuilder()
- .concat(I.getPrefix())
- .concat(Flags)
- .concat(I.getSuffix());
-}
-
static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
unsigned FlagsToSet) {
- SmallVector<Metadata *, 9> Elts;
- MDNode *N = Ty;
- assert(N && "Unexpected input DIType!");
- // Update header field.
- Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
- Elts.append(N->op_begin() + 1, N->op_end());
-
- return DIType(MDNode::get(Context, Elts));
+ TempMDType NewTy = cast<MDType>(static_cast<MDNode *>(Ty))->clone();
+ NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
+ return MDNode::replaceWithUniqued(std::move(NewTy));
}
DIType DIBuilder::createArtificialType(DIType Ty) {
+ // FIXME: Restrict this to the nodes where it's valid.
if (Ty.isArtificial())
return Ty;
return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
}
DIType DIBuilder::createObjectPointerType(DIType Ty) {
+ // FIXME: Restrict this to the nodes where it's valid.
if (Ty.isObjectPointer())
return Ty;
unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
@@ -794,26 +520,13 @@ DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
DIFile F, unsigned Line, unsigned RuntimeLang,
uint64_t SizeInBits, uint64_t AlignInBits,
StringRef UniqueIdentifier) {
- // Create a temporary MDNode.
- Metadata *Elts[] = {
- HeaderBuilder::get(Tag)
- .concat(Name)
- .concat(Line)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(DIDescriptor::FlagFwdDecl)
- .concat(RuntimeLang)
- .get(VMContext),
- F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
- DIArray(), nullptr,
- nullptr, // TemplateParams
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- MDNode *Node = MDNode::get(VMContext, Elts);
- DICompositeType RetTy(Node);
- assert(RetTy.isCompositeType() &&
- "createForwardDecl result should be a DIType");
+ // FIXME: Define in terms of createReplaceableForwardDecl() by calling
+ // replaceWithUniqued().
+ DICompositeType RetTy = MDCompositeType::get(
+ VMContext, Tag, Name, F.getFileNode(), Line,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr, SizeInBits,
+ AlignInBits, 0, DIDescriptor::FlagFwdDecl, nullptr, RuntimeLang, nullptr,
+ nullptr, UniqueIdentifier);
if (!UniqueIdentifier.empty())
retainType(RetTy);
trackIfUnresolved(RetTy);
@@ -824,25 +537,12 @@ DICompositeType DIBuilder::createReplaceableCompositeType(
unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
unsigned Flags, StringRef UniqueIdentifier) {
- // Create a temporary MDNode.
- Metadata *Elts[] = {
- HeaderBuilder::get(Tag)
- .concat(Name)
- .concat(Line)
- .concat(SizeInBits)
- .concat(AlignInBits)
- .concat(0) // Offset
- .concat(Flags)
- .concat(RuntimeLang)
- .get(VMContext),
- F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
- DIArray(), nullptr,
- nullptr, // TemplateParams
- UniqueIdentifier.empty() ? nullptr
- : MDString::get(VMContext, UniqueIdentifier)};
- DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
- assert(RetTy.isCompositeType() &&
- "createReplaceableForwardDecl result should be a DIType");
+ DICompositeType RetTy =
+ MDCompositeType::getTemporary(
+ VMContext, Tag, Name, F.getFileNode(), Line,
+ DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr, SizeInBits,
+ AlignInBits, 0, Flags, nullptr, RuntimeLang,
+ nullptr, nullptr, UniqueIdentifier).release();
if (!UniqueIdentifier.empty())
retainType(RetTy);
trackIfUnresolved(RetTy);
@@ -865,62 +565,39 @@ DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
}
DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
- .concat(Lo)
- .concat(Count)
- .get(VMContext)};
-
- return DISubrange(MDNode::get(VMContext, Elts));
+ return MDSubrange::get(VMContext, Count, Lo);
}
-static DIGlobalVariable createGlobalVariableHelper(
- LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
- StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
- bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
- std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
-
+static void checkGlobalVariableScope(DIDescriptor Context) {
MDNode *TheCtx = getNonCompileUnitScope(Context);
if (DIScope(TheCtx).isCompositeType()) {
assert(!DICompositeType(TheCtx).getIdentifier() &&
"Context of a global variable should not be a type with identifier");
}
-
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
- .concat(Name)
- .concat(Name)
- .concat(LinkageName)
- .concat(LineNumber)
- .concat(isLocalToUnit)
- .concat(isDefinition)
- .get(VMContext),
- TheCtx, F, Ty, getConstantOrNull(Val),
- DIDescriptor(Decl)};
-
- return DIGlobalVariable(CreateFunc(Elts));
}
DIGlobalVariable DIBuilder::createGlobalVariable(
DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
MDNode *Decl) {
- return createGlobalVariableHelper(
- VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
- Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
- MDNode *Node = MDNode::get(VMContext, Elts);
- AllGVs.push_back(Node);
- return Node;
- });
+ checkGlobalVariableScope(Context);
+
+ auto *N = MDGlobalVariable::get(VMContext, Context, Name, LinkageName, F,
+ LineNumber, Ty, isLocalToUnit, true,
+ getConstantOrNull(Val), Decl);
+ AllGVs.push_back(N);
+ return N;
}
DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
MDNode *Decl) {
- return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
- LineNumber, Ty, isLocalToUnit, Val, Decl,
- false, [&](ArrayRef<Metadata *> Elts) {
- return MDNode::getTemporary(VMContext, Elts).release();
- });
+ checkGlobalVariableScope(Context);
+
+ return MDGlobalVariable::getTemporary(VMContext, Context, Name, LinkageName,
+ F, LineNumber, Ty, isLocalToUnit, false,
+ getConstantOrNull(Val), Decl).release();
}
DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
@@ -928,16 +605,17 @@ DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
unsigned LineNo, DITypeRef Ty,
bool AlwaysPreserve, unsigned Flags,
unsigned ArgNo) {
+ // FIXME: Why getNonCompileUnitScope()?
+ // FIXME: Why is "!Context" okay here?
+ // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
+ // the only valid scopes)?
DIDescriptor Context(getNonCompileUnitScope(Scope));
assert((!Context || Context.isScope()) &&
"createLocalVariable should be called with a valid Context");
- Metadata *Elts[] = {HeaderBuilder::get(Tag)
- .concat(Name)
- .concat(LineNo | (ArgNo << 24))
- .concat(Flags)
- .get(VMContext),
- getNonCompileUnitScope(Scope), File, Ty};
- MDNode *Node = MDNode::get(VMContext, Elts);
+
+ auto *Node =
+ MDLocalVariable::get(VMContext, Tag, getNonCompileUnitScope(Scope), Name,
+ File, LineNo, Ty, ArgNo, Flags);
if (AlwaysPreserve) {
// The optimizer may remove local variable. If there is an interest
// to preserve variable info in such situation then stash it in a
@@ -946,18 +624,11 @@ DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
assert(Fn && "Missing subprogram for local variable");
PreservedVariables[Fn].emplace_back(Node);
}
- DIVariable RetVar(Node);
- assert(RetVar.isVariable() &&
- "createLocalVariable should return a valid DIVariable");
- return RetVar;
+ return Node;
}
DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
- auto Header = HeaderBuilder::get(DW_TAG_expression);
- for (uint64_t I : Addr)
- Header.concat(I);
- Metadata *Elts[] = {Header.get(VMContext)};
- return DIExpression(MDNode::get(VMContext, Elts));
+ return MDExpression::get(VMContext, Addr);
}
DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
@@ -966,10 +637,10 @@ DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
return createExpression(Addr);
}
-DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
- unsigned SizeInBits) {
- int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
- return createExpression(Addr);
+DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
+ unsigned SizeInBytes) {
+ uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
+ return MDExpression::get(VMContext, Addr);
}
DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
@@ -987,38 +658,6 @@ DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
Flags, isOptimized, Fn, TParams, Decl);
}
-static DISubprogram createFunctionHelper(
- LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
- StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
- bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
- bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
- std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
- assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
- "function types should be subroutines");
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
- .concat(Name)
- .concat(Name)
- .concat(LinkageName)
- .concat(LineNo)
- .concat(isLocalToUnit)
- .concat(isDefinition)
- .concat(0)
- .concat(0)
- .concat(Flags)
- .concat(isOptimized)
- .concat(ScopeLine)
- .get(VMContext),
- File.getFileNode(),
- DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
- nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
-
- DISubprogram S(CreateFunc(Elts));
- assert(S.isSubprogram() &&
- "createFunction should return a valid DISubprogram");
- return S;
-}
-
-
DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
StringRef LinkageName, DIFile File,
unsigned LineNo, DICompositeType Ty,
@@ -1026,19 +665,18 @@ DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
unsigned ScopeLine, unsigned Flags,
bool isOptimized, Function *Fn,
MDNode *TParams, MDNode *Decl) {
- return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
- LineNo, Ty, isLocalToUnit, isDefinition,
- ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
- MDNode::getTemporary(VMContext, None).release(),
- [&](ArrayRef<Metadata *> Elts) -> MDNode *{
- MDNode *Node = MDNode::get(VMContext, Elts);
- // Create a named metadata so that we
- // do not lose this mdnode.
- if (isDefinition)
- AllSubprograms.push_back(Node);
- trackIfUnresolved(Node);
- return Node;
- });
+ assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
+ "function types should be subroutines");
+ auto *Node = MDSubprogram::get(
+ VMContext, DIScope(getNonCompileUnitScope(Context)).getRef(), Name,
+ LinkageName, File.getFileNode(), LineNo, Ty, isLocalToUnit, isDefinition,
+ ScopeLine, nullptr, 0, 0, Flags, isOptimized, getConstantOrNull(Fn),
+ TParams, Decl, MDNode::getTemporary(VMContext, None).release());
+
+ if (isDefinition)
+ AllSubprograms.push_back(Node);
+ trackIfUnresolved(Node);
+ return Node;
}
DISubprogram
@@ -1049,12 +687,11 @@ DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
unsigned ScopeLine, unsigned Flags,
bool isOptimized, Function *Fn,
MDNode *TParams, MDNode *Decl) {
- return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
- LineNo, Ty, isLocalToUnit, isDefinition,
- ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
- nullptr, [&](ArrayRef<Metadata *> Elts) {
- return MDNode::getTemporary(VMContext, Elts).release();
- });
+ return MDSubprogram::getTemporary(
+ VMContext, DIScope(getNonCompileUnitScope(Context)).getRef(), Name,
+ LinkageName, File.getFileNode(), LineNo, Ty, isLocalToUnit,
+ isDefinition, ScopeLine, nullptr, 0, 0, Flags, isOptimized,
+ getConstantOrNull(Fn), TParams, Decl, nullptr).release();
}
DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
@@ -1070,24 +707,13 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
assert(getNonCompileUnitScope(Context) &&
"Methods should have both a Context and a context that isn't "
"the compile unit.");
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
- .concat(Name)
- .concat(Name)
- .concat(LinkageName)
- .concat(LineNo)
- .concat(isLocalToUnit)
- .concat(isDefinition)
- .concat(VK)
- .concat(VIndex)
- .concat(Flags)
- .concat(isOptimized)
- .concat(LineNo)
- // FIXME: Do we want to use different scope/lines?
- .get(VMContext),
- F.getFileNode(), DIScope(Context).getRef(), Ty,
- VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
- nullptr, nullptr};
- MDNode *Node = MDNode::get(VMContext, Elts);
+ // FIXME: Do we want to use different scope/lines?
+ auto *Node = MDSubprogram::get(
+ VMContext, DIScope(Context).getRef(), Name, LinkageName, F.getFileNode(),
+ LineNo, Ty, isLocalToUnit, isDefinition, LineNo, VTableHolder.getRef(),
+ VK, VIndex, Flags, isOptimized, getConstantOrNull(Fn), TParam, nullptr,
+ nullptr);
+
if (isDefinition)
AllSubprograms.push_back(Node);
DISubprogram S(Node);
@@ -1098,12 +724,8 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
DIFile File, unsigned LineNo) {
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
- .concat(Name)
- .concat(LineNo)
- .get(VMContext),
- File.getFileNode(), getNonCompileUnitScope(Scope)};
- DINameSpace R(MDNode::get(VMContext, Elts));
+ DINameSpace R = MDNamespace::get(VMContext, getNonCompileUnitScope(Scope),
+ File.getFileNode(), Name, LineNo);
assert(R.Verify() &&
"createNameSpace should return a verifiable DINameSpace");
return R;
@@ -1112,11 +734,8 @@ DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
DIFile File,
unsigned Discriminator) {
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
- .concat(Discriminator)
- .get(VMContext),
- File.getFileNode(), Scope};
- DILexicalBlockFile R(MDNode::get(VMContext, Elts));
+ DILexicalBlockFile R = MDLexicalBlockFile::get(
+ VMContext, Scope, File.getFileNode(), Discriminator);
assert(
R.Verify() &&
"createLexicalBlockFile should return a verifiable DILexicalBlockFile");
@@ -1125,22 +744,10 @@ DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
unsigned Line, unsigned Col) {
- // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
- // I believe the right way is to have a self-referential element in the node.
- // Also: why do we bother with line/column - they're not used and the
- // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
- // for uniquing, yet then we have this other solution (because line/col were
- // inadequate) anyway. Remove all 3 and replace them with a self-reference.
-
- // Defeat MDNode uniquing for lexical blocks by using unique id.
- static unsigned int unique_id = 0;
- Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
- .concat(Line)
- .concat(Col)
- .concat(unique_id++)
- .get(VMContext),
- File.getFileNode(), getNonCompileUnitScope(Scope)};
- DILexicalBlock R(MDNode::get(VMContext, Elts));
+ // Make these distinct, to avoid merging two lexical blocks on the same
+ // file/line/column.
+ DILexicalBlock R = MDLexicalBlock::getDistinct(
+ VMContext, getNonCompileUnitScope(Scope), File.getFileNode(), Line, Col);
assert(R.Verify() &&
"createLexicalBlock should return a verifiable DILexicalBlock");
return R;
diff --git a/lib/IR/DataLayout.cpp b/lib/IR/DataLayout.cpp
index 9c1dee0..4d867ef 100644
--- a/lib/IR/DataLayout.cpp
+++ b/lib/IR/DataLayout.cpp
@@ -33,11 +33,6 @@
#include <cstdlib>
using namespace llvm;
-// Handle the Pass registration stuff necessary to use DataLayout's.
-
-INITIALIZE_PASS(DataLayoutPass, "datalayout", "Data Layout", false, true)
-char DataLayoutPass::ID = 0;
-
//===----------------------------------------------------------------------===//
// Support for StructLayout
//===----------------------------------------------------------------------===//
@@ -155,8 +150,8 @@ DataLayout::InvalidPointerElem = { 0U, 0U, 0U, ~0U };
const char *DataLayout::getManglingComponent(const Triple &T) {
if (T.isOSBinFormatMachO())
return "-m:o";
- if (T.isOSWindows() && T.getArch() == Triple::x86 && T.isOSBinFormatCOFF())
- return "-m:w";
+ if (T.isOSWindows() && T.isOSBinFormatCOFF())
+ return T.getArch() == Triple::x86 ? "-m:x" : "-m:w";
return "-m:e";
}
@@ -221,6 +216,7 @@ static unsigned inBytes(unsigned Bits) {
}
void DataLayout::parseSpecifier(StringRef Desc) {
+ StringRepresentation = Desc;
while (!Desc.empty()) {
// Split at '-'.
std::pair<StringRef, StringRef> Split = split(Desc, '-');
@@ -259,6 +255,8 @@ void DataLayout::parseSpecifier(StringRef Desc) {
"Missing size specification for pointer in datalayout string");
Split = split(Rest, ':');
unsigned PointerMemSize = inBytes(getInt(Tok));
+ if (!PointerMemSize)
+ report_fatal_error("Invalid pointer size of 0 bytes");
// ABI alignment.
if (Rest.empty())
@@ -266,12 +264,18 @@ void DataLayout::parseSpecifier(StringRef Desc) {
"Missing alignment specification for pointer in datalayout string");
Split = split(Rest, ':');
unsigned PointerABIAlign = inBytes(getInt(Tok));
+ if (!isPowerOf2_64(PointerABIAlign))
+ report_fatal_error(
+ "Pointer ABI alignment must be a power of 2");
// Preferred alignment.
unsigned PointerPrefAlign = PointerABIAlign;
if (!Rest.empty()) {
Split = split(Rest, ':');
PointerPrefAlign = inBytes(getInt(Tok));
+ if (!isPowerOf2_64(PointerPrefAlign))
+ report_fatal_error(
+ "Pointer preferred alignment must be a power of 2");
}
setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
@@ -304,6 +308,9 @@ void DataLayout::parseSpecifier(StringRef Desc) {
"Missing alignment specification in datalayout string");
Split = split(Rest, ':');
unsigned ABIAlign = inBytes(getInt(Tok));
+ if (AlignType != AGGREGATE_ALIGN && !ABIAlign)
+ report_fatal_error(
+ "ABI alignment specification must be >0 for non-aggregate types");
// Preferred alignment.
unsigned PrefAlign = ABIAlign;
@@ -352,7 +359,10 @@ void DataLayout::parseSpecifier(StringRef Desc) {
ManglingMode = MM_Mips;
break;
case 'w':
- ManglingMode = MM_WINCOFF;
+ ManglingMode = MM_WinCOFF;
+ break;
+ case 'x':
+ ManglingMode = MM_WinCOFFX86;
break;
}
break;
@@ -367,13 +377,7 @@ DataLayout::DataLayout(const Module *M) : LayoutMap(nullptr) {
init(M);
}
-void DataLayout::init(const Module *M) {
- const DataLayout *Other = M->getDataLayout();
- if (Other)
- *this = *Other;
- else
- reset("");
-}
+void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
bool DataLayout::operator==(const DataLayout &Other) const {
bool Ret = BigEndian == Other.BigEndian &&
@@ -381,7 +385,7 @@ bool DataLayout::operator==(const DataLayout &Other) const {
ManglingMode == Other.ManglingMode &&
LegalIntWidths == Other.LegalIntWidths &&
Alignments == Other.Alignments && Pointers == Other.Pointers;
- assert(Ret == (getStringRepresentation() == Other.getStringRepresentation()));
+ // Note: getStringRepresentation() might differs, it is not canonicalized
return Ret;
}
@@ -394,6 +398,10 @@ DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
report_fatal_error("Invalid ABI alignment, must be a 16bit integer");
if (!isUInt<16>(pref_align))
report_fatal_error("Invalid preferred alignment, must be a 16bit integer");
+ if (abi_align != 0 && !isPowerOf2_64(abi_align))
+ report_fatal_error("Invalid ABI alignment, must be a power of 2");
+ if (pref_align != 0 && !isPowerOf2_64(pref_align))
+ report_fatal_error("Invalid preferred alignment, must be a power of 2");
if (pref_align < abi_align)
report_fatal_error(
@@ -474,9 +482,7 @@ unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
// If we didn't find an integer alignment, fall back on most conservative.
if (AlignType == INTEGER_ALIGN) {
BestMatchIdx = LargestInt;
- } else {
- assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
-
+ } else if (AlignType == VECTOR_ALIGN) {
// By default, use natural alignment for vector types. This is consistent
// with what clang and llvm-gcc do.
unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
@@ -489,6 +495,19 @@ unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
}
}
+ // If we still couldn't find a reasonable default alignment, fall back
+ // to a simple heuristic that the alignment is the first power of two
+ // greater-or-equal to the store size of the type. This is a reasonable
+ // approximation of reality, and if the user wanted something less
+ // less conservative, they should have specified it explicitly in the data
+ // layout.
+ if (BestMatchIdx == -1) {
+ unsigned Align = getTypeStoreSize(Ty);
+ if (Align & (Align-1))
+ Align = NextPowerOf2(Align);
+ return Align;
+ }
+
// Since we got a "best match" index, just return it.
return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
: Alignments[BestMatchIdx].PrefAlign;
@@ -552,68 +571,6 @@ const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
return L;
}
-std::string DataLayout::getStringRepresentation() const {
- std::string Result;
- raw_string_ostream OS(Result);
-
- OS << (BigEndian ? "E" : "e");
-
- switch (ManglingMode) {
- case MM_None:
- break;
- case MM_ELF:
- OS << "-m:e";
- break;
- case MM_MachO:
- OS << "-m:o";
- break;
- case MM_WINCOFF:
- OS << "-m:w";
- break;
- case MM_Mips:
- OS << "-m:m";
- break;
- }
-
- for (const PointerAlignElem &PI : Pointers) {
- // Skip default.
- if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
- PI.TypeByteWidth == 8)
- continue;
-
- OS << "-p";
- if (PI.AddressSpace) {
- OS << PI.AddressSpace;
- }
- OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
- if (PI.PrefAlign != PI.ABIAlign)
- OS << ':' << PI.PrefAlign*8;
- }
-
- for (const LayoutAlignElem &AI : Alignments) {
- if (std::find(std::begin(DefaultAlignments), std::end(DefaultAlignments),
- AI) != std::end(DefaultAlignments))
- continue;
- OS << '-' << (char)AI.AlignType;
- if (AI.TypeBitWidth)
- OS << AI.TypeBitWidth;
- OS << ':' << AI.ABIAlign*8;
- if (AI.ABIAlign != AI.PrefAlign)
- OS << ':' << AI.PrefAlign*8;
- }
-
- if (!LegalIntWidths.empty()) {
- OS << "-n" << (unsigned)LegalIntWidths[0];
-
- for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
- OS << ':' << (unsigned)LegalIntWidths[i];
- }
-
- if (StackNaturalAlign)
- OS << "-S" << StackNaturalAlign*8;
-
- return OS.str();
-}
unsigned DataLayout::getPointerABIAlignment(unsigned AS) const {
PointersTy::const_iterator I = findPointerLowerBound(AS);
@@ -829,18 +786,3 @@ unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
return Log2_32(getPreferredAlignment(GV));
}
-DataLayoutPass::DataLayoutPass() : ImmutablePass(ID), DL("") {
- initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
-}
-
-DataLayoutPass::~DataLayoutPass() {}
-
-bool DataLayoutPass::doInitialization(Module &M) {
- DL.init(&M);
- return false;
-}
-
-bool DataLayoutPass::doFinalization(Module &M) {
- DL.reset("");
- return false;
-}
diff --git a/lib/IR/DebugInfo.cpp b/lib/IR/DebugInfo.cpp
index 6590661..9a6b953 100644
--- a/lib/IR/DebugInfo.cpp
+++ b/lib/IR/DebugInfo.cpp
@@ -92,7 +92,7 @@ bool DIDescriptor::Verify() const {
DIObjCProperty(DbgNode).Verify() ||
DITemplateTypeParameter(DbgNode).Verify() ||
DITemplateValueParameter(DbgNode).Verify() ||
- DIImportedEntity(DbgNode).Verify() || DIExpression(DbgNode).Verify());
+ DIImportedEntity(DbgNode).Verify());
}
static Metadata *getField(const MDNode *DbgNode, unsigned Elt) {
@@ -155,21 +155,6 @@ Function *DIDescriptor::getFunctionField(unsigned Elt) const {
return dyn_cast_or_null<Function>(getConstantField(Elt));
}
-void DIDescriptor::replaceFunctionField(unsigned Elt, Function *F) {
- if (!DbgNode)
- return;
-
- if (Elt < DbgNode->getNumOperands()) {
- MDNode *Node = const_cast<MDNode *>(DbgNode);
- Node->replaceOperandWith(Elt, F ? ConstantAsMetadata::get(F) : nullptr);
- }
-}
-
-static unsigned DIVariableInlinedAtIndex = 4;
-MDNode *DIVariable::getInlinedAt() const {
- return getNodeField(DbgNode, DIVariableInlinedAtIndex);
-}
-
/// \brief Return the size reported by the variable's type.
unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) {
DIType Ty = getType().resolve(Map);
@@ -183,13 +168,6 @@ unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) {
return Ty.getSizeInBits();
}
-uint64_t DIExpression::getElement(unsigned Idx) const {
- unsigned I = Idx + 1;
- assert(I < getNumHeaderFields() &&
- "non-existing complex address element requested");
- return getHeaderFieldAs<int64_t>(I);
-}
-
bool DIExpression::isBitPiece() const {
unsigned N = getNumElements();
return N >=3 && getElement(N-3) == dwarf::DW_OP_bit_piece;
@@ -205,206 +183,40 @@ uint64_t DIExpression::getBitPieceSize() const {
return getElement(getNumElements()-1);
}
-DIExpression::iterator DIExpression::begin() const {
- return DIExpression::iterator(*this);
-}
-
-DIExpression::iterator DIExpression::end() const {
- return DIExpression::iterator();
-}
-
-DIExpression::Operand DIExpression::Operand::getNext() const {
+DIExpression::iterator DIExpression::Operand::getNext() const {
iterator it(I);
- return *(++it);
-}
-
-//===----------------------------------------------------------------------===//
-// Predicates
-//===----------------------------------------------------------------------===//
-
-bool DIDescriptor::isSubroutineType() const {
- return DbgNode && getTag() == dwarf::DW_TAG_subroutine_type;
-}
-
-bool DIDescriptor::isBasicType() const {
- if (!DbgNode)
- return false;
- switch (getTag()) {
- case dwarf::DW_TAG_base_type:
- case dwarf::DW_TAG_unspecified_type:
- return true;
- default:
- return false;
- }
-}
-
-bool DIDescriptor::isDerivedType() const {
- if (!DbgNode)
- return false;
- switch (getTag()) {
- case dwarf::DW_TAG_typedef:
- case dwarf::DW_TAG_pointer_type:
- case dwarf::DW_TAG_ptr_to_member_type:
- case dwarf::DW_TAG_reference_type:
- case dwarf::DW_TAG_rvalue_reference_type:
- case dwarf::DW_TAG_const_type:
- case dwarf::DW_TAG_volatile_type:
- case dwarf::DW_TAG_restrict_type:
- case dwarf::DW_TAG_member:
- case dwarf::DW_TAG_inheritance:
- case dwarf::DW_TAG_friend:
- return true;
- default:
- // CompositeTypes are currently modelled as DerivedTypes.
- return isCompositeType();
- }
-}
-
-bool DIDescriptor::isCompositeType() const {
- if (!DbgNode)
- return false;
- switch (getTag()) {
- case dwarf::DW_TAG_array_type:
- case dwarf::DW_TAG_structure_type:
- case dwarf::DW_TAG_union_type:
- case dwarf::DW_TAG_enumeration_type:
- case dwarf::DW_TAG_subroutine_type:
- case dwarf::DW_TAG_class_type:
- return true;
- default:
- return false;
- }
-}
-
-bool DIDescriptor::isVariable() const {
- if (!DbgNode)
- return false;
- switch (getTag()) {
- case dwarf::DW_TAG_auto_variable:
- case dwarf::DW_TAG_arg_variable:
- return true;
- default:
- return false;
- }
-}
-
-bool DIDescriptor::isType() const {
- return isBasicType() || isCompositeType() || isDerivedType();
-}
-
-bool DIDescriptor::isSubprogram() const {
- return DbgNode && getTag() == dwarf::DW_TAG_subprogram;
-}
-
-bool DIDescriptor::isGlobalVariable() const {
- return DbgNode && getTag() == dwarf::DW_TAG_variable;
-}
-
-bool DIDescriptor::isScope() const {
- if (!DbgNode)
- return false;
- switch (getTag()) {
- case dwarf::DW_TAG_compile_unit:
- case dwarf::DW_TAG_lexical_block:
- case dwarf::DW_TAG_subprogram:
- case dwarf::DW_TAG_namespace:
- case dwarf::DW_TAG_file_type:
- return true;
- default:
- break;
- }
- return isType();
-}
-
-bool DIDescriptor::isTemplateTypeParameter() const {
- return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter;
-}
-
-bool DIDescriptor::isTemplateValueParameter() const {
- return DbgNode && (getTag() == dwarf::DW_TAG_template_value_parameter ||
- getTag() == dwarf::DW_TAG_GNU_template_template_param ||
- getTag() == dwarf::DW_TAG_GNU_template_parameter_pack);
-}
-
-bool DIDescriptor::isCompileUnit() const {
- return DbgNode && getTag() == dwarf::DW_TAG_compile_unit;
-}
-
-bool DIDescriptor::isFile() const {
- return DbgNode && getTag() == dwarf::DW_TAG_file_type;
-}
-
-bool DIDescriptor::isNameSpace() const {
- return DbgNode && getTag() == dwarf::DW_TAG_namespace;
-}
-
-bool DIDescriptor::isLexicalBlockFile() const {
- return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
- DbgNode->getNumOperands() == 3 && getNumHeaderFields() == 2;
-}
-
-bool DIDescriptor::isLexicalBlock() const {
- // FIXME: There are always exactly 4 header fields in DILexicalBlock, but
- // something relies on this returning true for DILexicalBlockFile.
- return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
- DbgNode->getNumOperands() == 3 &&
- (getNumHeaderFields() == 2 || getNumHeaderFields() == 4);
-}
-
-bool DIDescriptor::isSubrange() const {
- return DbgNode && getTag() == dwarf::DW_TAG_subrange_type;
-}
-
-bool DIDescriptor::isEnumerator() const {
- return DbgNode && getTag() == dwarf::DW_TAG_enumerator;
-}
-
-bool DIDescriptor::isObjCProperty() const {
- return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property;
-}
-
-bool DIDescriptor::isImportedEntity() const {
- return DbgNode && (getTag() == dwarf::DW_TAG_imported_module ||
- getTag() == dwarf::DW_TAG_imported_declaration);
-}
-
-bool DIDescriptor::isExpression() const {
- return DbgNode && (getTag() == dwarf::DW_TAG_expression);
+ return ++it;
}
//===----------------------------------------------------------------------===//
// Simple Descriptor Constructors and other Methods
//===----------------------------------------------------------------------===//
-void DIDescriptor::replaceAllUsesWith(LLVMContext &VMContext, DIDescriptor D) {
-
+void DIDescriptor::replaceAllUsesWith(LLVMContext &, DIDescriptor D) {
assert(DbgNode && "Trying to replace an unverified type!");
+ assert(DbgNode->isTemporary() && "Expected temporary node");
+ TempMDNode Temp(get());
// Since we use a TrackingVH for the node, its easy for clients to manufacture
// legitimate situations where they want to replaceAllUsesWith() on something
// which, due to uniquing, has merged with the source. We shield clients from
// this detail by allowing a value to be replaced with replaceAllUsesWith()
// itself.
- const MDNode *DN = D;
- if (DbgNode == DN) {
- SmallVector<Metadata *, 10> Ops(DbgNode->op_begin(), DbgNode->op_end());
- DN = MDNode::get(VMContext, Ops);
+ if (Temp.get() == D.get()) {
+ DbgNode = MDNode::replaceWithUniqued(std::move(Temp));
+ return;
}
- assert(DbgNode->isTemporary() && "Expected temporary node");
- auto *Node = const_cast<MDNode *>(DbgNode);
- Node->replaceAllUsesWith(const_cast<MDNode *>(DN));
- MDNode::deleteTemporary(Node);
- DbgNode = DN;
+ Temp->replaceAllUsesWith(D.get());
+ DbgNode = D.get();
}
void DIDescriptor::replaceAllUsesWith(MDNode *D) {
assert(DbgNode && "Trying to replace an unverified type!");
assert(DbgNode != D && "This replacement should always happen");
assert(DbgNode->isTemporary() && "Expected temporary node");
- auto *Node = const_cast<MDNode *>(DbgNode);
+ TempMDNode Node(get());
Node->replaceAllUsesWith(D);
- MDNode::deleteTemporary(Node);
}
bool DICompileUnit::Verify() const {
@@ -413,31 +225,10 @@ bool DICompileUnit::Verify() const {
// Don't bother verifying the compilation directory or producer string
// as those could be empty.
- if (getFilename().empty())
- return false;
-
- return DbgNode->getNumOperands() == 7 && getNumHeaderFields() == 8;
-}
-
-bool DIObjCProperty::Verify() const {
- if (!isObjCProperty())
- return false;
-
- // Don't worry about the rest of the strings for now.
- return DbgNode->getNumOperands() == 3 && getNumHeaderFields() == 6;
-}
-
-/// \brief Check if a field at position Elt of a MDNode is a MDNode.
-static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) {
- Metadata *Fld = getField(DbgNode, Elt);
- return !Fld || isa<MDNode>(Fld);
+ return !getFilename().empty();
}
-/// \brief Check if a field at position Elt of a MDNode is a MDString.
-static bool fieldIsMDString(const MDNode *DbgNode, unsigned Elt) {
- Metadata *Fld = getField(DbgNode, Elt);
- return !Fld || isa<MDString>(Fld);
-}
+bool DIObjCProperty::Verify() const { return isObjCProperty(); }
/// \brief Check if a value can be a reference to a type.
static bool isTypeRef(const Metadata *MD) {
@@ -445,14 +236,7 @@ static bool isTypeRef(const Metadata *MD) {
return true;
if (auto *S = dyn_cast<MDString>(MD))
return !S->getString().empty();
- if (auto *N = dyn_cast<MDNode>(MD))
- return DIType(N).isType();
- return false;
-}
-
-/// \brief Check if referenced field might be a type.
-static bool fieldIsTypeRef(const MDNode *DbgNode, unsigned Elt) {
- return isTypeRef(dyn_cast_or_null<Metadata>(getField(DbgNode, Elt)));
+ return isa<MDType>(MD);
}
/// \brief Check if a value can be a ScopeRef.
@@ -461,14 +245,7 @@ static bool isScopeRef(const Metadata *MD) {
return true;
if (auto *S = dyn_cast<MDString>(MD))
return !S->getString().empty();
- if (auto *N = dyn_cast<MDNode>(MD))
- return DIScope(N).isScope();
- return false;
-}
-
-/// \brief Check if a field at position Elt of a MDNode can be a ScopeRef.
-static bool fieldIsScopeRef(const MDNode *DbgNode, unsigned Elt) {
- return isScopeRef(dyn_cast_or_null<Metadata>(getField(DbgNode, Elt)));
+ return isa<MDScope>(MD);
}
#ifndef NDEBUG
@@ -483,92 +260,81 @@ static bool isDescriptorRef(const Metadata *MD) {
#endif
bool DIType::Verify() const {
- if (!isType())
+ auto *N = dyn_cast_or_null<MDType>(DbgNode);
+ if (!N)
return false;
- // Make sure Context @ field 2 is MDNode.
- if (!fieldIsScopeRef(DbgNode, 2))
- return false;
-
- // FIXME: Sink this into the various subclass verifies.
- uint16_t Tag = getTag();
- if (!isBasicType() && Tag != dwarf::DW_TAG_const_type &&
- Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type &&
- Tag != dwarf::DW_TAG_ptr_to_member_type &&
- Tag != dwarf::DW_TAG_reference_type &&
- Tag != dwarf::DW_TAG_rvalue_reference_type &&
- Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type &&
- Tag != dwarf::DW_TAG_enumeration_type &&
- Tag != dwarf::DW_TAG_subroutine_type &&
- Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend &&
- getFilename().empty())
+ if (!isScopeRef(N->getScope()))
return false;
// DIType is abstract, it should be a BasicType, a DerivedType or
// a CompositeType.
if (isBasicType())
return DIBasicType(DbgNode).Verify();
- else if (isCompositeType())
+
+ // FIXME: Sink this into the various subclass verifies.
+ if (getFilename().empty()) {
+ // Check whether the filename is allowed to be empty.
+ uint16_t Tag = getTag();
+ if (Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
+ Tag != dwarf::DW_TAG_pointer_type &&
+ Tag != dwarf::DW_TAG_ptr_to_member_type &&
+ Tag != dwarf::DW_TAG_reference_type &&
+ Tag != dwarf::DW_TAG_rvalue_reference_type &&
+ Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type &&
+ Tag != dwarf::DW_TAG_enumeration_type &&
+ Tag != dwarf::DW_TAG_subroutine_type &&
+ Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend &&
+ Tag != dwarf::DW_TAG_structure_type && Tag != dwarf::DW_TAG_member &&
+ Tag != dwarf::DW_TAG_typedef)
+ return false;
+ }
+
+ if (isCompositeType())
return DICompositeType(DbgNode).Verify();
- else if (isDerivedType())
+ if (isDerivedType())
return DIDerivedType(DbgNode).Verify();
- else
- return false;
+ return false;
}
bool DIBasicType::Verify() const {
- return isBasicType() && DbgNode->getNumOperands() == 3 &&
- getNumHeaderFields() == 8;
+ return dyn_cast_or_null<MDBasicType>(DbgNode);
}
bool DIDerivedType::Verify() const {
- // Make sure DerivedFrom @ field 3 is TypeRef.
- if (!fieldIsTypeRef(DbgNode, 3))
+ auto *N = dyn_cast_or_null<MDDerivedTypeBase>(DbgNode);
+ if (!N)
return false;
- if (getTag() == dwarf::DW_TAG_ptr_to_member_type)
- // Make sure ClassType @ field 4 is a TypeRef.
- if (!fieldIsTypeRef(DbgNode, 4))
+ if (getTag() == dwarf::DW_TAG_ptr_to_member_type) {
+ auto *D = dyn_cast<MDDerivedType>(N);
+ if (!D)
return false;
-
- return isDerivedType() && DbgNode->getNumOperands() >= 4 &&
- DbgNode->getNumOperands() <= 8 && getNumHeaderFields() >= 7 &&
- getNumHeaderFields() <= 8;
+ if (!isTypeRef(D->getExtraData()))
+ return false;
+ }
+ return isTypeRef(N->getBaseType());
}
bool DICompositeType::Verify() const {
- if (!isCompositeType())
- return false;
-
- // Make sure DerivedFrom @ field 3 and ContainingType @ field 5 are TypeRef.
- if (!fieldIsTypeRef(DbgNode, 3))
- return false;
- if (!fieldIsTypeRef(DbgNode, 5))
- return false;
-
- // Make sure the type identifier at field 7 is MDString, it can be null.
- if (!fieldIsMDString(DbgNode, 7))
- return false;
-
- // A subroutine type can't be both & and &&.
- if (isLValueReference() && isRValueReference())
- return false;
-
- return DbgNode->getNumOperands() == 8 && getNumHeaderFields() == 8;
+ auto *N = dyn_cast_or_null<MDCompositeTypeBase>(DbgNode);
+ return N && isTypeRef(N->getBaseType()) && isTypeRef(N->getVTableHolder()) &&
+ !(isLValueReference() && isRValueReference());
}
bool DISubprogram::Verify() const {
- if (!isSubprogram())
+ auto *N = dyn_cast_or_null<MDSubprogram>(DbgNode);
+ if (!N)
return false;
- // Make sure context @ field 2 is a ScopeRef and type @ field 3 is a MDNode.
- if (!fieldIsScopeRef(DbgNode, 2))
+ if (!isScopeRef(N->getScope()))
return false;
- if (!fieldIsMDNode(DbgNode, 3))
- return false;
- // Containing type @ field 4.
- if (!fieldIsTypeRef(DbgNode, 4))
+
+ if (auto *Op = N->getType())
+ if (!isa<MDNode>(Op))
+ return false;
+
+ if (!isTypeRef(getContainingType()))
return false;
- // A subprogram can't be both & and &&.
if (isLValueReference() && isRValueReference())
return false;
@@ -603,164 +369,78 @@ bool DISubprogram::Verify() const {
}
}
}
- return DbgNode->getNumOperands() == 9 && getNumHeaderFields() == 12;
+
+ return true;
}
bool DIGlobalVariable::Verify() const {
- if (!isGlobalVariable())
- return false;
+ auto *N = dyn_cast_or_null<MDGlobalVariable>(DbgNode);
- if (getDisplayName().empty())
- return false;
- // Make sure context @ field 1 is an MDNode.
- if (!fieldIsMDNode(DbgNode, 1))
- return false;
- // Make sure that type @ field 3 is a DITypeRef.
- if (!fieldIsTypeRef(DbgNode, 3))
- return false;
- // Make sure StaticDataMemberDeclaration @ field 5 is MDNode.
- if (!fieldIsMDNode(DbgNode, 5))
- return false;
-
- return DbgNode->getNumOperands() == 6 && getNumHeaderFields() == 7;
-}
-
-bool DIVariable::Verify() const {
- if (!isVariable())
+ if (!N)
return false;
- // Make sure context @ field 1 is an MDNode.
- if (!fieldIsMDNode(DbgNode, 1))
- return false;
- // Make sure that type @ field 3 is a DITypeRef.
- if (!fieldIsTypeRef(DbgNode, 3))
+ if (N->getDisplayName().empty())
return false;
- // Check the number of header fields, which is common between complex and
- // simple variables.
- if (getNumHeaderFields() != 4)
- return false;
+ if (auto *Op = N->getScope())
+ if (!isa<MDNode>(Op))
+ return false;
- // Variable without an inline location.
- if (DbgNode->getNumOperands() == 4)
- return true;
+ if (auto *Op = N->getStaticDataMemberDeclaration())
+ if (!isa<MDNode>(Op))
+ return false;
- // Variable with an inline location.
- return getInlinedAt() != nullptr && DbgNode->getNumOperands() == 5;
+ return isTypeRef(N->getType());
}
-bool DIExpression::Verify() const {
- // Empty DIExpressions may be represented as a nullptr.
- if (!DbgNode)
- return true;
+bool DIVariable::Verify() const {
+ auto *N = dyn_cast_or_null<MDLocalVariable>(DbgNode);
- if (!(isExpression() && DbgNode->getNumOperands() == 1))
+ if (!N)
return false;
- for (auto Op : *this)
- switch (Op) {
- case DW_OP_bit_piece:
- // Must be the last element of the expression.
- return std::distance(Op.getBase(), DIHeaderFieldIterator()) == 3;
- case DW_OP_plus:
- if (std::distance(Op.getBase(), DIHeaderFieldIterator()) < 2)
- return false;
- break;
- case DW_OP_deref:
- break;
- default:
- // Other operators are not yet supported by the backend.
+ if (auto *Op = N->getScope())
+ if (!isa<MDNode>(Op))
return false;
- }
- return true;
+
+ return isTypeRef(N->getType());
}
bool DILocation::Verify() const {
- return DbgNode && isa<MDLocation>(DbgNode);
+ return dyn_cast_or_null<MDLocation>(DbgNode);
}
-
bool DINameSpace::Verify() const {
- if (!isNameSpace())
- return false;
- return DbgNode->getNumOperands() == 3 && getNumHeaderFields() == 3;
-}
-
-MDNode *DIFile::getFileNode() const { return getNodeField(DbgNode, 1); }
-
-bool DIFile::Verify() const {
- return isFile() && DbgNode->getNumOperands() == 2;
+ return dyn_cast_or_null<MDNamespace>(DbgNode);
}
-
+bool DIFile::Verify() const { return dyn_cast_or_null<MDFile>(DbgNode); }
bool DIEnumerator::Verify() const {
- return isEnumerator() && DbgNode->getNumOperands() == 1 &&
- getNumHeaderFields() == 3;
+ return dyn_cast_or_null<MDEnumerator>(DbgNode);
}
-
bool DISubrange::Verify() const {
- return isSubrange() && DbgNode->getNumOperands() == 1 &&
- getNumHeaderFields() == 3;
+ return dyn_cast_or_null<MDSubrange>(DbgNode);
}
-
bool DILexicalBlock::Verify() const {
- return isLexicalBlock() && DbgNode->getNumOperands() == 3 &&
- getNumHeaderFields() == 4;
+ return dyn_cast_or_null<MDLexicalBlock>(DbgNode);
}
-
bool DILexicalBlockFile::Verify() const {
- return isLexicalBlockFile() && DbgNode->getNumOperands() == 3 &&
- getNumHeaderFields() == 2;
+ return dyn_cast_or_null<MDLexicalBlockFile>(DbgNode);
}
-
bool DITemplateTypeParameter::Verify() const {
- return isTemplateTypeParameter() && DbgNode->getNumOperands() == 4 &&
- getNumHeaderFields() == 4;
+ return dyn_cast_or_null<MDTemplateTypeParameter>(DbgNode);
}
-
bool DITemplateValueParameter::Verify() const {
- return isTemplateValueParameter() && DbgNode->getNumOperands() == 5 &&
- getNumHeaderFields() == 4;
+ return dyn_cast_or_null<MDTemplateValueParameter>(DbgNode);
}
-
bool DIImportedEntity::Verify() const {
- return isImportedEntity() && DbgNode->getNumOperands() == 3 &&
- getNumHeaderFields() == 3;
-}
-
-MDNode *DIDerivedType::getObjCProperty() const {
- return getNodeField(DbgNode, 4);
+ return dyn_cast_or_null<MDImportedEntity>(DbgNode);
}
-MDString *DICompositeType::getIdentifier() const {
- return cast_or_null<MDString>(getField(DbgNode, 7));
-}
-
-#ifndef NDEBUG
-static void VerifySubsetOf(const MDNode *LHS, const MDNode *RHS) {
- for (unsigned i = 0; i != LHS->getNumOperands(); ++i) {
- // Skip the 'empty' list (that's a single i32 0, rather than truly empty).
- if (i == 0 && mdconst::hasa<ConstantInt>(LHS->getOperand(i)))
- continue;
- const MDNode *E = cast<MDNode>(LHS->getOperand(i));
- bool found = false;
- for (unsigned j = 0; !found && j != RHS->getNumOperands(); ++j)
- found = (E == cast<MDNode>(RHS->getOperand(j)));
- assert(found && "Losing a member during member list replacement");
- }
-}
-#endif
-
void DICompositeType::setArraysHelper(MDNode *Elements, MDNode *TParams) {
- TrackingMDNodeRef N(*this);
- if (Elements) {
-#ifndef NDEBUG
- // Check that the new list of members contains all the old members as well.
- if (const MDNode *El = cast_or_null<MDNode>(N->getOperand(4)))
- VerifySubsetOf(El, Elements);
-#endif
- N->replaceOperandWith(4, Elements);
- }
+ TypedTrackingMDRef<MDCompositeTypeBase> N(get());
+ if (Elements)
+ N->replaceElements(cast<MDTuple>(Elements));
if (TParams)
- N->replaceOperandWith(6, TParams);
+ N->replaceTemplateParams(cast<MDTuple>(TParams));
DbgNode = N;
}
@@ -774,8 +454,8 @@ DIScopeRef DIScope::getRef() const {
}
void DICompositeType::setContainingType(DICompositeType ContainingType) {
- TrackingMDNodeRef N(*this);
- N->replaceOperandWith(5, ContainingType.getRef());
+ TypedTrackingMDRef<MDCompositeTypeBase> N(get());
+ N->replaceVTableHolder(ContainingType.getRef());
DbgNode = N;
}
@@ -788,6 +468,13 @@ bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
return !DISubprogram(getContext()).describes(CurFn);
}
+Function *DISubprogram::getFunction() const {
+ if (auto *N = get())
+ if (auto *C = dyn_cast_or_null<ConstantAsMetadata>(N->getFunction()))
+ return dyn_cast<Function>(C->getValue());
+ return nullptr;
+}
+
bool DISubprogram::describes(const Function *F) {
assert(F && "Invalid function");
if (F == getFunction())
@@ -800,16 +487,8 @@ bool DISubprogram::describes(const Function *F) {
return false;
}
-MDNode *DISubprogram::getVariablesNodes() const {
- return getNodeField(DbgNode, 8);
-}
-
-DIArray DISubprogram::getVariables() const {
- return DIArray(getNodeField(DbgNode, 8));
-}
-
-Metadata *DITemplateValueParameter::getValue() const {
- return DbgNode->getOperand(3);
+GlobalVariable *DIGlobalVariable::getGlobal() const {
+ return dyn_cast_or_null<GlobalVariable>(getConstant());
}
DIScopeRef DIScope::getContext() const {
@@ -847,66 +526,25 @@ StringRef DIScope::getName() const {
}
StringRef DIScope::getFilename() const {
- if (!DbgNode)
- return StringRef();
- return ::getStringField(getNodeField(DbgNode, 1), 0);
+ if (auto *N = get())
+ return ::getStringField(dyn_cast_or_null<MDNode>(N->getFile()), 0);
+ return "";
}
StringRef DIScope::getDirectory() const {
- if (!DbgNode)
- return StringRef();
- return ::getStringField(getNodeField(DbgNode, 1), 1);
-}
-
-DIArray DICompileUnit::getEnumTypes() const {
- if (!DbgNode || DbgNode->getNumOperands() < 7)
- return DIArray();
-
- return DIArray(getNodeField(DbgNode, 2));
-}
-
-DIArray DICompileUnit::getRetainedTypes() const {
- if (!DbgNode || DbgNode->getNumOperands() < 7)
- return DIArray();
-
- return DIArray(getNodeField(DbgNode, 3));
-}
-
-DIArray DICompileUnit::getSubprograms() const {
- if (!DbgNode || DbgNode->getNumOperands() < 7)
- return DIArray();
-
- return DIArray(getNodeField(DbgNode, 4));
-}
-
-DIArray DICompileUnit::getGlobalVariables() const {
- if (!DbgNode || DbgNode->getNumOperands() < 7)
- return DIArray();
-
- return DIArray(getNodeField(DbgNode, 5));
-}
-
-DIArray DICompileUnit::getImportedEntities() const {
- if (!DbgNode || DbgNode->getNumOperands() < 7)
- return DIArray();
-
- return DIArray(getNodeField(DbgNode, 6));
+ if (auto *N = get())
+ return ::getStringField(dyn_cast_or_null<MDNode>(N->getFile()), 1);
+ return "";
}
void DICompileUnit::replaceSubprograms(DIArray Subprograms) {
assert(Verify() && "Expected compile unit");
- if (Subprograms == getSubprograms())
- return;
-
- const_cast<MDNode *>(DbgNode)->replaceOperandWith(4, Subprograms);
+ get()->replaceSubprograms(cast_or_null<MDTuple>(Subprograms.get()));
}
void DICompileUnit::replaceGlobalVariables(DIArray GlobalVariables) {
assert(Verify() && "Expected compile unit");
- if (GlobalVariables == getGlobalVariables())
- return;
-
- const_cast<MDNode *>(DbgNode)->replaceOperandWith(5, GlobalVariables);
+ get()->replaceGlobalVariables(cast_or_null<MDTuple>(GlobalVariables.get()));
}
DILocation DILocation::copyWithNewScope(LLVMContext &Ctx,
@@ -927,31 +565,13 @@ unsigned DILocation::computeNewDiscriminator(LLVMContext &Ctx) {
DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
LLVMContext &VMContext) {
assert(DIVariable(DV).Verify() && "Expected a DIVariable");
- if (!InlinedScope)
- return cleanseInlinedVariable(DV, VMContext);
-
- // Insert inlined scope.
- SmallVector<Metadata *, 8> Elts(DV->op_begin(),
- DV->op_begin() + DIVariableInlinedAtIndex);
- Elts.push_back(InlinedScope);
-
- DIVariable Inlined(MDNode::get(VMContext, Elts));
- assert(Inlined.Verify() && "Expected to create a DIVariable");
- return Inlined;
+ return cast<MDLocalVariable>(DV)
+ ->withInline(cast_or_null<MDLocation>(InlinedScope));
}
DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
assert(DIVariable(DV).Verify() && "Expected a DIVariable");
- if (!DIVariable(DV).getInlinedAt())
- return DIVariable(DV);
-
- // Remove inlined scope.
- SmallVector<Metadata *, 8> Elts(DV->op_begin(),
- DV->op_begin() + DIVariableInlinedAtIndex);
-
- DIVariable Cleansed(MDNode::get(VMContext, Elts));
- assert(Cleansed.Verify() && "Expected to create a DIVariable");
- return Cleansed;
+ return cast<MDLocalVariable>(DV)->withoutInline();
}
DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
@@ -1075,6 +695,8 @@ void DebugInfoFinder::processModule(const Module &M) {
DIArray Imports = CU.getImportedEntities();
for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) {
DIImportedEntity Import = DIImportedEntity(Imports.getElement(i));
+ if (!Import)
+ continue;
DIDescriptor Entity = Import.getEntity().resolve(TypeIdentifierMap);
if (Entity.isType())
processType(DIType(Entity));
@@ -1267,220 +889,9 @@ void DIDescriptor::dump() const {
}
void DIDescriptor::print(raw_ostream &OS) const {
- if (!DbgNode)
- return;
-
- if (const char *Tag = dwarf::TagString(getTag()))
- OS << "[ " << Tag << " ]";
-
- if (this->isSubrange()) {
- DISubrange(DbgNode).printInternal(OS);
- } else if (this->isCompileUnit()) {
- DICompileUnit(DbgNode).printInternal(OS);
- } else if (this->isFile()) {
- DIFile(DbgNode).printInternal(OS);
- } else if (this->isEnumerator()) {
- DIEnumerator(DbgNode).printInternal(OS);
- } else if (this->isBasicType()) {
- DIType(DbgNode).printInternal(OS);
- } else if (this->isDerivedType()) {
- DIDerivedType(DbgNode).printInternal(OS);
- } else if (this->isCompositeType()) {
- DICompositeType(DbgNode).printInternal(OS);
- } else if (this->isSubprogram()) {
- DISubprogram(DbgNode).printInternal(OS);
- } else if (this->isGlobalVariable()) {
- DIGlobalVariable(DbgNode).printInternal(OS);
- } else if (this->isVariable()) {
- DIVariable(DbgNode).printInternal(OS);
- } else if (this->isObjCProperty()) {
- DIObjCProperty(DbgNode).printInternal(OS);
- } else if (this->isNameSpace()) {
- DINameSpace(DbgNode).printInternal(OS);
- } else if (this->isScope()) {
- DIScope(DbgNode).printInternal(OS);
- } else if (this->isExpression()) {
- DIExpression(DbgNode).printInternal(OS);
- }
-}
-
-void DISubrange::printInternal(raw_ostream &OS) const {
- int64_t Count = getCount();
- if (Count != -1)
- OS << " [" << getLo() << ", " << Count - 1 << ']';
- else
- OS << " [unbounded]";
-}
-
-void DIScope::printInternal(raw_ostream &OS) const {
- OS << " [" << getDirectory() << "/" << getFilename() << ']';
-}
-
-void DICompileUnit::printInternal(raw_ostream &OS) const {
- DIScope::printInternal(OS);
- OS << " [";
- unsigned Lang = getLanguage();
- if (const char *LangStr = dwarf::LanguageString(Lang))
- OS << LangStr;
- else
- (OS << "lang 0x").write_hex(Lang);
- OS << ']';
-}
-
-void DIEnumerator::printInternal(raw_ostream &OS) const {
- OS << " [" << getName() << " :: " << getEnumValue() << ']';
-}
-
-void DIType::printInternal(raw_ostream &OS) const {
- if (!DbgNode)
+ if (!get())
return;
-
- StringRef Res = getName();
- if (!Res.empty())
- OS << " [" << Res << "]";
-
- // TODO: Print context?
-
- OS << " [line " << getLineNumber() << ", size " << getSizeInBits()
- << ", align " << getAlignInBits() << ", offset " << getOffsetInBits();
- if (isBasicType())
- if (const char *Enc =
- dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding()))
- OS << ", enc " << Enc;
- OS << "]";
-
- if (isPrivate())
- OS << " [private]";
- else if (isProtected())
- OS << " [protected]";
- else if (isPublic())
- OS << " [public]";
-
- if (isArtificial())
- OS << " [artificial]";
-
- if (isForwardDecl())
- OS << " [decl]";
- else if (getTag() == dwarf::DW_TAG_structure_type ||
- getTag() == dwarf::DW_TAG_union_type ||
- getTag() == dwarf::DW_TAG_enumeration_type ||
- getTag() == dwarf::DW_TAG_class_type)
- OS << " [def]";
- if (isVector())
- OS << " [vector]";
- if (isStaticMember())
- OS << " [static]";
-
- if (isLValueReference())
- OS << " [reference]";
-
- if (isRValueReference())
- OS << " [rvalue reference]";
-}
-
-void DIDerivedType::printInternal(raw_ostream &OS) const {
- DIType::printInternal(OS);
- OS << " [from " << getTypeDerivedFrom().getName() << ']';
-}
-
-void DICompositeType::printInternal(raw_ostream &OS) const {
- DIType::printInternal(OS);
- DIArray A = getElements();
- OS << " [" << A.getNumElements() << " elements]";
-}
-
-void DINameSpace::printInternal(raw_ostream &OS) const {
- StringRef Name = getName();
- if (!Name.empty())
- OS << " [" << Name << ']';
-
- OS << " [line " << getLineNumber() << ']';
-}
-
-void DISubprogram::printInternal(raw_ostream &OS) const {
- // TODO : Print context
- OS << " [line " << getLineNumber() << ']';
-
- if (isLocalToUnit())
- OS << " [local]";
-
- if (isDefinition())
- OS << " [def]";
-
- if (getScopeLineNumber() != getLineNumber())
- OS << " [scope " << getScopeLineNumber() << "]";
-
- if (isPrivate())
- OS << " [private]";
- else if (isProtected())
- OS << " [protected]";
- else if (isPublic())
- OS << " [public]";
-
- if (isLValueReference())
- OS << " [reference]";
-
- if (isRValueReference())
- OS << " [rvalue reference]";
-
- StringRef Res = getName();
- if (!Res.empty())
- OS << " [" << Res << ']';
-}
-
-void DIGlobalVariable::printInternal(raw_ostream &OS) const {
- StringRef Res = getName();
- if (!Res.empty())
- OS << " [" << Res << ']';
-
- OS << " [line " << getLineNumber() << ']';
-
- // TODO : Print context
-
- if (isLocalToUnit())
- OS << " [local]";
-
- if (isDefinition())
- OS << " [def]";
-}
-
-void DIVariable::printInternal(raw_ostream &OS) const {
- StringRef Res = getName();
- if (!Res.empty())
- OS << " [" << Res << ']';
-
- OS << " [line " << getLineNumber() << ']';
-}
-
-void DIExpression::printInternal(raw_ostream &OS) const {
- for (auto Op : *this) {
- OS << " [" << OperationEncodingString(Op);
- switch (Op) {
- case DW_OP_plus: {
- OS << " " << Op.getArg(1);
- break;
- }
- case DW_OP_bit_piece: {
- OS << " offset=" << Op.getArg(1) << ", size=" << Op.getArg(2);
- break;
- }
- case DW_OP_deref:
- // No arguments.
- break;
- default:
- llvm_unreachable("unhandled operation");
- }
- OS << "]";
- }
-}
-
-void DIObjCProperty::printInternal(raw_ostream &OS) const {
- StringRef Name = getObjCPropertyName();
- if (!Name.empty())
- OS << " [" << Name << ']';
-
- OS << " [line " << getLineNumber() << ", properties " << getUnsignedField(6)
- << ']';
+ get()->print(OS);
}
static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
diff --git a/lib/IR/DiagnosticInfo.cpp b/lib/IR/DiagnosticInfo.cpp
index cfb699a..5608589 100644
--- a/lib/IR/DiagnosticInfo.cpp
+++ b/lib/IR/DiagnosticInfo.cpp
@@ -129,7 +129,7 @@ void DiagnosticInfoSampleProfile::print(DiagnosticPrinter &DP) const {
}
bool DiagnosticInfoOptimizationBase::isLocationAvailable() const {
- return getDebugLoc().isUnknown() == false;
+ return !getDebugLoc().isUnknown();
}
void DiagnosticInfoOptimizationBase::getLocation(StringRef *Filename,
diff --git a/lib/IR/GCOV.cpp b/lib/IR/GCOV.cpp
index 08f44e0..7010ceb 100644
--- a/lib/IR/GCOV.cpp
+++ b/lib/IR/GCOV.cpp
@@ -19,6 +19,7 @@
#include "llvm/Support/Format.h"
#include "llvm/Support/MemoryObject.h"
#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <system_error>
using namespace llvm;
@@ -302,10 +303,12 @@ bool GCOVFunction::readGCDA(GCOVBuffer &Buff, GCOV::GCOVVersion Version) {
// required to combine the edge counts that are contained in the GCDA file.
for (uint32_t BlockNo = 0; Count > 0; ++BlockNo) {
// The last block is always reserved for exit block
- if (BlockNo >= Blocks.size() - 1) {
+ if (BlockNo >= Blocks.size()) {
errs() << "Unexpected number of edges (in " << Name << ").\n";
return false;
}
+ if (BlockNo == Blocks.size() - 1)
+ errs() << "(" << Name << ") has arcs from exit block.\n";
GCOVBlock &Block = *Blocks[BlockNo];
for (size_t EdgeNo = 0, End = Block.getNumDstEdges(); EdgeNo < End;
++EdgeNo) {
@@ -443,6 +446,7 @@ static uint32_t branchDiv(uint64_t Numerator, uint64_t Divisor) {
return Res;
}
+namespace {
struct formatBranchInfo {
formatBranchInfo(const GCOVOptions &Options, uint64_t Count, uint64_t Total)
: Options(Options), Count(Count), Total(Total) {}
@@ -466,7 +470,6 @@ static raw_ostream &operator<<(raw_ostream &OS, const formatBranchInfo &FBI) {
return OS;
}
-namespace {
class LineConsumer {
std::unique_ptr<MemoryBuffer> Buffer;
StringRef Remaining;
diff --git a/lib/IR/Globals.cpp b/lib/IR/Globals.cpp
index 54197d9..5a6adb3 100644
--- a/lib/IR/Globals.cpp
+++ b/lib/IR/Globals.cpp
@@ -42,10 +42,6 @@ void GlobalValue::Dematerialize() {
getParent()->Dematerialize(this);
}
-const DataLayout *GlobalValue::getDataLayout() const {
- return getParent()->getDataLayout();
-}
-
/// Override destroyConstant to make sure it doesn't get called on
/// GlobalValue's because they shouldn't be treated like other constants.
void GlobalValue::destroyConstant() {
diff --git a/lib/IR/InlineAsm.cpp b/lib/IR/InlineAsm.cpp
index 5b73561..b456d9f 100644
--- a/lib/IR/InlineAsm.cpp
+++ b/lib/IR/InlineAsm.cpp
@@ -75,7 +75,7 @@ bool InlineAsm::ConstraintInfo::Parse(StringRef Str,
ConstraintCodeVector *pCodes = &Codes;
// Initialize
- isMultipleAlternative = (multipleAlternativeCount > 1 ? true : false);
+ isMultipleAlternative = multipleAlternativeCount > 1;
if (isMultipleAlternative) {
multipleAlternatives.resize(multipleAlternativeCount);
pCodes = &multipleAlternatives[0].Codes;
diff --git a/lib/IR/Instruction.cpp b/lib/IR/Instruction.cpp
index 92c6e9f..7d9bd7e 100644
--- a/lib/IR/Instruction.cpp
+++ b/lib/IR/Instruction.cpp
@@ -32,10 +32,6 @@ Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
}
}
-const DataLayout *Instruction::getDataLayout() const {
- return getParent()->getDataLayout();
-}
-
Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
BasicBlock *InsertAtEnd)
: User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
@@ -58,6 +54,10 @@ void Instruction::setParent(BasicBlock *P) {
Parent = P;
}
+const Module *Instruction::getModule() const {
+ return getParent()->getModule();
+}
+
void Instruction::removeFromParent() {
getParent()->getInstList().remove(this);
}
diff --git a/lib/IR/Instructions.cpp b/lib/IR/Instructions.cpp
index 7136923..af2aeb9 100644
--- a/lib/IR/Instructions.cpp
+++ b/lib/IR/Instructions.cpp
@@ -841,41 +841,19 @@ static Value *getAISize(LLVMContext &Context, Value *Amt) {
return Amt;
}
-AllocaInst::AllocaInst(Type *Ty, Value *ArraySize,
- const Twine &Name, Instruction *InsertBefore)
- : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
- getAISize(Ty->getContext(), ArraySize), InsertBefore) {
- setAlignment(0);
- assert(!Ty->isVoidTy() && "Cannot allocate void!");
- setName(Name);
-}
+AllocaInst::AllocaInst(Type *Ty, const Twine &Name, Instruction *InsertBefore)
+ : AllocaInst(Ty, /*ArraySize=*/nullptr, Name, InsertBefore) {}
-AllocaInst::AllocaInst(Type *Ty, Value *ArraySize,
- const Twine &Name, BasicBlock *InsertAtEnd)
- : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
- getAISize(Ty->getContext(), ArraySize), InsertAtEnd) {
- setAlignment(0);
- assert(!Ty->isVoidTy() && "Cannot allocate void!");
- setName(Name);
-}
+AllocaInst::AllocaInst(Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd)
+ : AllocaInst(Ty, /*ArraySize=*/nullptr, Name, InsertAtEnd) {}
-AllocaInst::AllocaInst(Type *Ty, const Twine &Name,
+AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, const Twine &Name,
Instruction *InsertBefore)
- : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
- getAISize(Ty->getContext(), nullptr), InsertBefore) {
- setAlignment(0);
- assert(!Ty->isVoidTy() && "Cannot allocate void!");
- setName(Name);
-}
+ : AllocaInst(Ty, ArraySize, /*Align=*/0, Name, InsertBefore) {}
-AllocaInst::AllocaInst(Type *Ty, const Twine &Name,
+AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, const Twine &Name,
BasicBlock *InsertAtEnd)
- : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
- getAISize(Ty->getContext(), nullptr), InsertAtEnd) {
- setAlignment(0);
- assert(!Ty->isVoidTy() && "Cannot allocate void!");
- setName(Name);
-}
+ : AllocaInst(Ty, ArraySize, /*Align=*/0, Name, InsertAtEnd) {}
AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
const Twine &Name, Instruction *InsertBefore)
@@ -942,67 +920,27 @@ void LoadInst::AssertOK() {
}
LoadInst::LoadInst(Value *Ptr, const Twine &Name, Instruction *InsertBef)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertBef) {
- setVolatile(false);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
-}
+ : LoadInst(Ptr, Name, /*isVolatile=*/false, InsertBef) {}
LoadInst::LoadInst(Value *Ptr, const Twine &Name, BasicBlock *InsertAE)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertAE) {
- setVolatile(false);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
-}
+ : LoadInst(Ptr, Name, /*isVolatile=*/false, InsertAE) {}
LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
Instruction *InsertBef)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertBef) {
- setVolatile(isVolatile);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
-}
+ : LoadInst(Ptr, Name, isVolatile, /*Align=*/0, InsertBef) {}
LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
BasicBlock *InsertAE)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertAE) {
- setVolatile(isVolatile);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
-}
+ : LoadInst(Ptr, Name, isVolatile, /*Align=*/0, InsertAE) {}
-LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
+LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, Instruction *InsertBef)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertBef) {
- setVolatile(isVolatile);
- setAlignment(Align);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
-}
+ : LoadInst(Ptr, Name, isVolatile, Align, NotAtomic, CrossThread,
+ InsertBef) {}
-LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
+LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, BasicBlock *InsertAE)
- : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
- Load, Ptr, InsertAE) {
- setVolatile(isVolatile);
- setAlignment(Align);
- setAtomic(NotAtomic);
- AssertOK();
- setName(Name);
+ : LoadInst(Ptr, Name, isVolatile, Align, NotAtomic, CrossThread, InsertAE) {
}
LoadInst::LoadInst(Value *Ptr, const Twine &Name, bool isVolatile,
@@ -1097,60 +1035,29 @@ void StoreInst::AssertOK() {
"Alignment required for atomic store");
}
-
StoreInst::StoreInst(Value *val, Value *addr, Instruction *InsertBefore)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertBefore) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(false);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
-}
+ : StoreInst(val, addr, /*isVolatile=*/false, InsertBefore) {}
StoreInst::StoreInst(Value *val, Value *addr, BasicBlock *InsertAtEnd)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertAtEnd) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(false);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
-}
+ : StoreInst(val, addr, /*isVolatile=*/false, InsertAtEnd) {}
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
Instruction *InsertBefore)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertBefore) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(isVolatile);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
-}
+ : StoreInst(val, addr, isVolatile, /*Align=*/0, InsertBefore) {}
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
- unsigned Align, Instruction *InsertBefore)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertBefore) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(isVolatile);
- setAlignment(Align);
- setAtomic(NotAtomic);
- AssertOK();
-}
+ BasicBlock *InsertAtEnd)
+ : StoreInst(val, addr, isVolatile, /*Align=*/0, InsertAtEnd) {}
+
+StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, unsigned Align,
+ Instruction *InsertBefore)
+ : StoreInst(val, addr, isVolatile, Align, NotAtomic, CrossThread,
+ InsertBefore) {}
+
+StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, unsigned Align,
+ BasicBlock *InsertAtEnd)
+ : StoreInst(val, addr, isVolatile, Align, NotAtomic, CrossThread,
+ InsertAtEnd) {}
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
unsigned Align, AtomicOrdering Order,
@@ -1169,34 +1076,6 @@ StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
}
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
- BasicBlock *InsertAtEnd)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertAtEnd) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(isVolatile);
- setAlignment(0);
- setAtomic(NotAtomic);
- AssertOK();
-}
-
-StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
- unsigned Align, BasicBlock *InsertAtEnd)
- : Instruction(Type::getVoidTy(val->getContext()), Store,
- OperandTraits<StoreInst>::op_begin(this),
- OperandTraits<StoreInst>::operands(this),
- InsertAtEnd) {
- Op<0>() = val;
- Op<1>() = addr;
- setVolatile(isVolatile);
- setAlignment(Align);
- setAtomic(NotAtomic);
- AssertOK();
-}
-
-StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile,
unsigned Align, AtomicOrdering Order,
SynchronizationScope SynchScope,
BasicBlock *InsertAtEnd)
@@ -2169,21 +2048,15 @@ bool CastInst::isNoopCast(Type *IntPtrTy) const {
return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
}
-bool CastInst::isNoopCast(const DataLayout *DL) const {
- if (!DL) {
- // Assume maximum pointer size.
- return isNoopCast(Type::getInt64Ty(getContext()));
- }
-
+bool CastInst::isNoopCast(const DataLayout &DL) const {
Type *PtrOpTy = nullptr;
if (getOpcode() == Instruction::PtrToInt)
PtrOpTy = getOperand(0)->getType();
else if (getOpcode() == Instruction::IntToPtr)
PtrOpTy = getType();
- Type *IntPtrTy = PtrOpTy
- ? DL->getIntPtrType(PtrOpTy)
- : DL->getIntPtrType(getContext(), 0);
+ Type *IntPtrTy =
+ PtrOpTy ? DL.getIntPtrType(PtrOpTy) : DL.getIntPtrType(getContext(), 0);
return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
}
@@ -2656,44 +2529,38 @@ bool CastInst::isCastable(Type *SrcTy, Type *DestTy) {
// Run through the possibilities ...
if (DestTy->isIntegerTy()) { // Casting to integral
- if (SrcTy->isIntegerTy()) { // Casting from integral
+ if (SrcTy->isIntegerTy()) // Casting from integral
return true;
- } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
+ if (SrcTy->isFloatingPointTy()) // Casting from floating pt
return true;
- } else if (SrcTy->isVectorTy()) { // Casting from vector
+ if (SrcTy->isVectorTy()) // Casting from vector
return DestBits == SrcBits;
- } else { // Casting from something else
- return SrcTy->isPointerTy();
- }
- } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt
- if (SrcTy->isIntegerTy()) { // Casting from integral
+ // Casting from something else
+ return SrcTy->isPointerTy();
+ }
+ if (DestTy->isFloatingPointTy()) { // Casting to floating pt
+ if (SrcTy->isIntegerTy()) // Casting from integral
return true;
- } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
+ if (SrcTy->isFloatingPointTy()) // Casting from floating pt
return true;
- } else if (SrcTy->isVectorTy()) { // Casting from vector
+ if (SrcTy->isVectorTy()) // Casting from vector
return DestBits == SrcBits;
- } else { // Casting from something else
- return false;
- }
- } else if (DestTy->isVectorTy()) { // Casting to vector
+ // Casting from something else
+ return false;
+ }
+ if (DestTy->isVectorTy()) // Casting to vector
return DestBits == SrcBits;
- } else if (DestTy->isPointerTy()) { // Casting to pointer
- if (SrcTy->isPointerTy()) { // Casting from pointer
+ if (DestTy->isPointerTy()) { // Casting to pointer
+ if (SrcTy->isPointerTy()) // Casting from pointer
return true;
- } else if (SrcTy->isIntegerTy()) { // Casting from integral
- return true;
- } else { // Casting from something else
- return false;
- }
- } else if (DestTy->isX86_MMXTy()) {
- if (SrcTy->isVectorTy()) {
+ return SrcTy->isIntegerTy(); // Casting from integral
+ }
+ if (DestTy->isX86_MMXTy()) {
+ if (SrcTy->isVectorTy())
return DestBits == SrcBits; // 64-bit vector to MMX
- } else {
- return false;
- }
- } else { // Casting to something else
return false;
- }
+ } // Casting to something else
+ return false;
}
bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
@@ -2737,13 +2604,13 @@ bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
}
bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
- const DataLayout *DL) {
+ const DataLayout &DL) {
if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
- return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy);
+ return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
if (auto *IntTy = dyn_cast<IntegerType>(SrcTy))
- return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy);
+ return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
return isBitCastable(SrcTy, DestTy);
}
diff --git a/lib/IR/LLVMContextImpl.h b/lib/IR/LLVMContextImpl.h
index 4631246..e380665 100644
--- a/lib/IR/LLVMContextImpl.h
+++ b/lib/IR/LLVMContextImpl.h
@@ -240,12 +240,12 @@ template <> struct MDNodeKeyImpl<MDLocation> {
: Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
MDNodeKeyImpl(const MDLocation *L)
- : Line(L->getLine()), Column(L->getColumn()), Scope(L->getScope()),
- InlinedAt(L->getInlinedAt()) {}
+ : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
+ InlinedAt(L->getRawInlinedAt()) {}
bool isKeyOf(const MDLocation *RHS) const {
return Line == RHS->getLine() && Column == RHS->getColumn() &&
- Scope == RHS->getScope() && InlinedAt == RHS->getInlinedAt();
+ Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt();
}
unsigned getHashValue() const {
return hash_combine(Line, Column, Scope, InlinedAt);
diff --git a/lib/IR/LegacyPassManager.cpp b/lib/IR/LegacyPassManager.cpp
index fa8d50e..9a365d1 100644
--- a/lib/IR/LegacyPassManager.cpp
+++ b/lib/IR/LegacyPassManager.cpp
@@ -652,7 +652,7 @@ void PMTopLevelManager::schedulePass(Pass *P) {
// are already checked are still available.
checkAnalysis = true;
} else
- // Do not schedule this analysis. Lower level analsyis
+ // Do not schedule this analysis. Lower level analysis
// passes are run on the fly.
delete AnalysisPass;
}
diff --git a/lib/IR/Mangler.cpp b/lib/IR/Mangler.cpp
index 5eeb797..a0e1b25 100644
--- a/lib/IR/Mangler.cpp
+++ b/lib/IR/Mangler.cpp
@@ -73,7 +73,7 @@ static bool hasByteCountSuffix(CallingConv::ID CC) {
/// Microsoft fastcall and stdcall functions require a suffix on their name
/// indicating the number of words of arguments they take.
static void addByteCountSuffix(raw_ostream &OS, const Function *F,
- const DataLayout &TD) {
+ const DataLayout &DL) {
// Calculate arguments size total.
unsigned ArgWords = 0;
for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
@@ -83,8 +83,8 @@ static void addByteCountSuffix(raw_ostream &OS, const Function *F,
if (AI->hasByValOrInAllocaAttr())
Ty = cast<PointerType>(Ty)->getElementType();
// Size should be aligned to pointer size.
- unsigned PtrSize = TD.getPointerSize();
- ArgWords += RoundUpToAlignment(TD.getTypeAllocSize(Ty), PtrSize);
+ unsigned PtrSize = DL.getPointerSize();
+ ArgWords += RoundUpToAlignment(DL.getTypeAllocSize(Ty), PtrSize);
}
OS << '@' << ArgWords;
diff --git a/lib/IR/Module.cpp b/lib/IR/Module.cpp
index b0abe8c..3e8f91f 100644
--- a/lib/IR/Module.cpp
+++ b/lib/IR/Module.cpp
@@ -365,31 +365,11 @@ void Module::addModuleFlag(MDNode *Node) {
void Module::setDataLayout(StringRef Desc) {
DL.reset(Desc);
-
- if (Desc.empty()) {
- DataLayoutStr = "";
- } else {
- DataLayoutStr = DL.getStringRepresentation();
- // DataLayoutStr is now equivalent to Desc, but since the representation
- // is not unique, they may not be identical.
- }
}
-void Module::setDataLayout(const DataLayout *Other) {
- if (!Other) {
- DataLayoutStr = "";
- DL.reset("");
- } else {
- DL = *Other;
- DataLayoutStr = DL.getStringRepresentation();
- }
-}
+void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
-const DataLayout *Module::getDataLayout() const {
- if (DataLayoutStr.empty())
- return nullptr;
- return &DL;
-}
+const DataLayout &Module::getDataLayout() const { return DL; }
//===----------------------------------------------------------------------===//
// Methods to control the materialization of GlobalValues in the Module.
@@ -433,6 +413,12 @@ std::error_code Module::materializeAllPermanently() {
return std::error_code();
}
+std::error_code Module::materializeMetadata() {
+ if (!Materializer)
+ return std::error_code();
+ return Materializer->materializeMetadata();
+}
+
//===----------------------------------------------------------------------===//
// Other module related stuff.
//
diff --git a/lib/IR/TypeFinder.cpp b/lib/IR/TypeFinder.cpp
index e2fb8f8..1d2b808 100644
--- a/lib/IR/TypeFinder.cpp
+++ b/lib/IR/TypeFinder.cpp
@@ -68,7 +68,7 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
// instructions with this loop.)
for (User::const_op_iterator OI = I.op_begin(), OE = I.op_end();
OI != OE; ++OI)
- if (!isa<Instruction>(OI))
+ if (*OI && !isa<Instruction>(OI))
incorporateValue(*OI);
// Incorporate types hiding in metadata.
diff --git a/lib/IR/Value.cpp b/lib/IR/Value.cpp
index 7d205f9..78bfca4 100644
--- a/lib/IR/Value.cpp
+++ b/lib/IR/Value.cpp
@@ -32,6 +32,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace llvm;
@@ -69,15 +70,13 @@ Value::~Value() {
#ifndef NDEBUG // Only in -g mode...
// Check to make sure that there are no uses of this value that are still
// around when the value is destroyed. If there are, then we have a dangling
- // reference and something is wrong. This code is here to print out what is
- // still being referenced. The value in question should be printed as
- // a <badref>
+ // reference and something is wrong. This code is here to print out where
+ // the value is still being referenced.
//
if (!use_empty()) {
dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n";
- for (use_iterator I = use_begin(), E = use_end(); I != E; ++I)
- dbgs() << "Use still stuck around after Def is destroyed:"
- << **I << "\n";
+ for (auto *U : users())
+ dbgs() << "Use still stuck around after Def is destroyed:" << *U << "\n";
}
#endif
assert(use_empty() && "Uses remain when a value is destroyed!");
@@ -482,7 +481,7 @@ Value *Value::stripInBoundsOffsets() {
///
/// Test if V is always a pointer to allocated and suitably aligned memory for
/// a simple load or store.
-static bool isDereferenceablePointer(const Value *V, const DataLayout *DL,
+static bool isDereferenceablePointer(const Value *V, const DataLayout &DL,
SmallPtrSetImpl<const Value *> &Visited) {
// Note that it is not safe to speculate into a malloc'd region because
// malloc may return null.
@@ -497,17 +496,14 @@ static bool isDereferenceablePointer(const Value *V, const DataLayout *DL,
// to a type of smaller size (or the same size), and the alignment
// is at least as large as for the resulting pointer type, then
// we can look through the bitcast.
- if (DL)
- if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V)) {
- Type *STy = BC->getSrcTy()->getPointerElementType(),
- *DTy = BC->getDestTy()->getPointerElementType();
- if (STy->isSized() && DTy->isSized() &&
- (DL->getTypeStoreSize(STy) >=
- DL->getTypeStoreSize(DTy)) &&
- (DL->getABITypeAlignment(STy) >=
- DL->getABITypeAlignment(DTy)))
- return isDereferenceablePointer(BC->getOperand(0), DL, Visited);
- }
+ if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V)) {
+ Type *STy = BC->getSrcTy()->getPointerElementType(),
+ *DTy = BC->getDestTy()->getPointerElementType();
+ if (STy->isSized() && DTy->isSized() &&
+ (DL.getTypeStoreSize(STy) >= DL.getTypeStoreSize(DTy)) &&
+ (DL.getABITypeAlignment(STy) >= DL.getABITypeAlignment(DTy)))
+ return isDereferenceablePointer(BC->getOperand(0), DL, Visited);
+ }
// Global variables which can't collapse to null are ok.
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
@@ -520,7 +516,7 @@ static bool isDereferenceablePointer(const Value *V, const DataLayout *DL,
return true;
else if (uint64_t Bytes = A->getDereferenceableBytes()) {
Type *Ty = V->getType()->getPointerElementType();
- if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes)
+ if (Ty->isSized() && DL.getTypeStoreSize(Ty) <= Bytes)
return true;
}
@@ -532,7 +528,7 @@ static bool isDereferenceablePointer(const Value *V, const DataLayout *DL,
if (ImmutableCallSite CS = V) {
if (uint64_t Bytes = CS.getDereferenceableBytes(0)) {
Type *Ty = V->getType()->getPointerElementType();
- if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes)
+ if (Ty->isSized() && DL.getTypeStoreSize(Ty) <= Bytes)
return true;
}
}
@@ -586,15 +582,15 @@ static bool isDereferenceablePointer(const Value *V, const DataLayout *DL,
return false;
}
-bool Value::isDereferenceablePointer(const DataLayout *DL) const {
+bool Value::isDereferenceablePointer(const DataLayout &DL) const {
// When dereferenceability information is provided by a dereferenceable
// attribute, we know exactly how many bytes are dereferenceable. If we can
// determine the exact offset to the attributed variable, we can use that
// information here.
Type *Ty = getType()->getPointerElementType();
- if (Ty->isSized() && DL) {
- APInt Offset(DL->getTypeStoreSizeInBits(getType()), 0);
- const Value *BV = stripAndAccumulateInBoundsConstantOffsets(*DL, Offset);
+ if (Ty->isSized()) {
+ APInt Offset(DL.getTypeStoreSizeInBits(getType()), 0);
+ const Value *BV = stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
APInt DerefBytes(Offset.getBitWidth(), 0);
if (const Argument *A = dyn_cast<Argument>(BV))
@@ -603,7 +599,7 @@ bool Value::isDereferenceablePointer(const DataLayout *DL) const {
DerefBytes = CS.getDereferenceableBytes(0);
if (DerefBytes.getBoolValue() && Offset.isNonNegative()) {
- if (DerefBytes.uge(Offset + DL->getTypeStoreSize(Ty)))
+ if (DerefBytes.uge(Offset + DL.getTypeStoreSize(Ty)))
return true;
}
}
diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp
index d01e138..fcf48c4 100644
--- a/lib/IR/Verifier.cpp
+++ b/lib/IR/Verifier.cpp
@@ -78,7 +78,7 @@
#include <cstdarg>
using namespace llvm;
-static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(false));
+static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true));
namespace {
struct VerifierSupport {
@@ -87,11 +87,13 @@ struct VerifierSupport {
/// \brief Track the brokenness of the module while recursively visiting.
bool Broken;
+ bool EverBroken;
explicit VerifierSupport(raw_ostream &OS)
- : OS(OS), M(nullptr), Broken(false) {}
+ : OS(OS), M(nullptr), Broken(false), EverBroken(false) {}
- void WriteValue(const Value *V) {
+private:
+ void Write(const Value *V) {
if (!V)
return;
if (isa<Instruction>(V)) {
@@ -102,81 +104,61 @@ struct VerifierSupport {
}
}
- void WriteMetadata(const Metadata *MD) {
+ void Write(const Metadata *MD) {
if (!MD)
return;
- MD->printAsOperand(OS, true, M);
+ MD->print(OS, M);
+ OS << '\n';
+ }
+
+ void Write(const NamedMDNode *NMD) {
+ if (!NMD)
+ return;
+ NMD->print(OS);
OS << '\n';
}
- void WriteType(Type *T) {
+ void Write(Type *T) {
if (!T)
return;
OS << ' ' << *T;
}
- void WriteComdat(const Comdat *C) {
+ void Write(const Comdat *C) {
if (!C)
return;
OS << *C;
}
- // CheckFailed - A check failed, so print out the condition and the message
- // that failed. This provides a nice place to put a breakpoint if you want
- // to see why something is not correct.
- void CheckFailed(const Twine &Message, const Value *V1 = nullptr,
- const Value *V2 = nullptr, const Value *V3 = nullptr,
- const Value *V4 = nullptr) {
- OS << Message.str() << "\n";
- WriteValue(V1);
- WriteValue(V2);
- WriteValue(V3);
- WriteValue(V4);
- Broken = true;
- }
-
- void CheckFailed(const Twine &Message, const Metadata *V1, const Metadata *V2,
- const Metadata *V3 = nullptr, const Metadata *V4 = nullptr) {
- OS << Message.str() << "\n";
- WriteMetadata(V1);
- WriteMetadata(V2);
- WriteMetadata(V3);
- WriteMetadata(V4);
- Broken = true;
- }
-
- void CheckFailed(const Twine &Message, const Metadata *V1,
- const Value *V2 = nullptr) {
- OS << Message.str() << "\n";
- WriteMetadata(V1);
- WriteValue(V2);
- Broken = true;
- }
-
- void CheckFailed(const Twine &Message, const Value *V1, Type *T2,
- const Value *V3 = nullptr) {
- OS << Message.str() << "\n";
- WriteValue(V1);
- WriteType(T2);
- WriteValue(V3);
- Broken = true;
- }
-
- void CheckFailed(const Twine &Message, Type *T1, Type *T2 = nullptr,
- Type *T3 = nullptr) {
- OS << Message.str() << "\n";
- WriteType(T1);
- WriteType(T2);
- WriteType(T3);
- Broken = true;
- }
-
- void CheckFailed(const Twine &Message, const Comdat *C) {
- OS << Message.str() << "\n";
- WriteComdat(C);
- Broken = true;
+ template <typename T1, typename... Ts>
+ void WriteTs(const T1 &V1, const Ts &... Vs) {
+ Write(V1);
+ WriteTs(Vs...);
+ }
+
+ template <typename... Ts> void WriteTs() {}
+
+public:
+ /// \brief A check failed, so printout out the condition and the message.
+ ///
+ /// This provides a nice place to put a breakpoint if you want to see why
+ /// something is not correct.
+ void CheckFailed(const Twine &Message) {
+ OS << Message << '\n';
+ EverBroken = Broken = true;
+ }
+
+ /// \brief A check failed (with values to print).
+ ///
+ /// This calls the Message-only version so that the above is easier to set a
+ /// breakpoint on.
+ template <typename T1, typename... Ts>
+ void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) {
+ CheckFailed(Message);
+ WriteTs(V1, Vs...);
}
};
+
class Verifier : public InstVisitor<Verifier>, VerifierSupport {
friend class InstVisitor<Verifier>;
@@ -198,14 +180,18 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
/// personality function.
const Value *PersonalityFn;
- /// \brief Whether we've seen a call to @llvm.frameallocate in this function
+ /// \brief Whether we've seen a call to @llvm.frameescape in this function
/// already.
- bool SawFrameAllocate;
+ bool SawFrameEscape;
+
+ /// Stores the count of how many objects were passed to llvm.frameescape for a
+ /// given function and the largest index passed to llvm.framerecover.
+ DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
public:
- explicit Verifier(raw_ostream &OS = dbgs())
+ explicit Verifier(raw_ostream &OS)
: VerifierSupport(OS), Context(nullptr), PersonalityFn(nullptr),
- SawFrameAllocate(false) {}
+ SawFrameEscape(false) {}
bool verify(const Function &F) {
M = F.getParent();
@@ -240,7 +226,7 @@ public:
visit(const_cast<Function &>(F));
InstsInThisBlock.clear();
PersonalityFn = nullptr;
- SawFrameAllocate = false;
+ SawFrameEscape = false;
return !Broken;
}
@@ -259,6 +245,10 @@ public:
visitFunction(*I);
}
+ // Now that we've visited every function, verify that we never asked to
+ // recover a frame index that wasn't escaped.
+ verifyFrameRecoverIndices();
+
for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
I != E; ++I)
visitGlobalVariable(*I);
@@ -278,6 +268,9 @@ public:
visitModuleFlags(M);
visitModuleIdents(M);
+ // Verify debug info last.
+ verifyDebugInfo();
+
return !Broken;
}
@@ -347,6 +340,8 @@ private:
void visitUserOp1(Instruction &I);
void visitUserOp2(Instruction &I) { visitUserOp1(I); }
void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
+ template <class DbgIntrinsicTy>
+ void visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII);
void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
void visitAtomicRMWInst(AtomicRMWInst &RMWI);
void visitFenceInst(FenceInst &FI);
@@ -373,18 +368,9 @@ private:
void VerifyConstantExprBitcastType(const ConstantExpr *CE);
void VerifyStatepoint(ImmutableCallSite CS);
-};
-class DebugInfoVerifier : public VerifierSupport {
-public:
- explicit DebugInfoVerifier(raw_ostream &OS = dbgs()) : VerifierSupport(OS) {}
+ void verifyFrameRecoverIndices();
- bool verify(const Module &M) {
- this->M = &M;
- verifyDebugInfo();
- return !Broken;
- }
-
-private:
+ // Module-level debug info verification...
void verifyDebugInfo();
void processInstructions(DebugInfoFinder &Finder);
void processCallInst(DebugInfoFinder &Finder, const CallInst &CI);
@@ -392,66 +378,58 @@ private:
} // End anonymous namespace
// Assert - We know that cond should be true, if not print an error message.
-#define Assert(C, M) \
- do { if (!(C)) { CheckFailed(M); return; } } while (0)
-#define Assert1(C, M, V1) \
- do { if (!(C)) { CheckFailed(M, V1); return; } } while (0)
-#define Assert2(C, M, V1, V2) \
- do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0)
-#define Assert3(C, M, V1, V2, V3) \
- do { if (!(C)) { CheckFailed(M, V1, V2, V3); return; } } while (0)
-#define Assert4(C, M, V1, V2, V3, V4) \
- do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0)
+#define Assert(C, ...) \
+ do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (0)
void Verifier::visit(Instruction &I) {
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
- Assert1(I.getOperand(i) != nullptr, "Operand is null", &I);
+ Assert(I.getOperand(i) != nullptr, "Operand is null", &I);
InstVisitor<Verifier>::visit(I);
}
void Verifier::visitGlobalValue(const GlobalValue &GV) {
- Assert1(!GV.isDeclaration() || GV.hasExternalLinkage() ||
- GV.hasExternalWeakLinkage(),
- "Global is external, but doesn't have external or weak linkage!",
- &GV);
+ Assert(!GV.isDeclaration() || GV.hasExternalLinkage() ||
+ GV.hasExternalWeakLinkage(),
+ "Global is external, but doesn't have external or weak linkage!", &GV);
- Assert1(GV.getAlignment() <= Value::MaximumAlignment,
- "huge alignment values are unsupported", &GV);
- Assert1(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
- "Only global variables can have appending linkage!", &GV);
+ Assert(GV.getAlignment() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &GV);
+ Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
+ "Only global variables can have appending linkage!", &GV);
if (GV.hasAppendingLinkage()) {
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
- Assert1(GVar && GVar->getType()->getElementType()->isArrayTy(),
- "Only global arrays can have appending linkage!", GVar);
+ Assert(GVar && GVar->getType()->getElementType()->isArrayTy(),
+ "Only global arrays can have appending linkage!", GVar);
}
}
void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
if (GV.hasInitializer()) {
- Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(),
- "Global variable initializer type does not match global "
- "variable type!", &GV);
+ Assert(GV.getInitializer()->getType() == GV.getType()->getElementType(),
+ "Global variable initializer type does not match global "
+ "variable type!",
+ &GV);
// If the global has common linkage, it must have a zero initializer and
// cannot be constant.
if (GV.hasCommonLinkage()) {
- Assert1(GV.getInitializer()->isNullValue(),
- "'common' global must have a zero initializer!", &GV);
- Assert1(!GV.isConstant(), "'common' global may not be marked constant!",
- &GV);
- Assert1(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
+ Assert(GV.getInitializer()->isNullValue(),
+ "'common' global must have a zero initializer!", &GV);
+ Assert(!GV.isConstant(), "'common' global may not be marked constant!",
+ &GV);
+ Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
}
} else {
- Assert1(GV.hasExternalLinkage() || GV.hasExternalWeakLinkage(),
- "invalid linkage type for global declaration", &GV);
+ Assert(GV.hasExternalLinkage() || GV.hasExternalWeakLinkage(),
+ "invalid linkage type for global declaration", &GV);
}
if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
GV.getName() == "llvm.global_dtors")) {
- Assert1(!GV.hasInitializer() || GV.hasAppendingLinkage(),
- "invalid linkage for intrinsic global variable", &GV);
+ Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
+ "invalid linkage for intrinsic global variable", &GV);
// Don't worry about emitting an error for it not being an array,
// visitGlobalValue will complain on appending non-array.
if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getType()->getElementType())) {
@@ -459,48 +437,48 @@ void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
PointerType *FuncPtrTy =
FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo();
// FIXME: Reject the 2-field form in LLVM 4.0.
- Assert1(STy && (STy->getNumElements() == 2 ||
- STy->getNumElements() == 3) &&
- STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
- STy->getTypeAtIndex(1) == FuncPtrTy,
- "wrong type for intrinsic global variable", &GV);
+ Assert(STy &&
+ (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
+ STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
+ STy->getTypeAtIndex(1) == FuncPtrTy,
+ "wrong type for intrinsic global variable", &GV);
if (STy->getNumElements() == 3) {
Type *ETy = STy->getTypeAtIndex(2);
- Assert1(ETy->isPointerTy() &&
- cast<PointerType>(ETy)->getElementType()->isIntegerTy(8),
- "wrong type for intrinsic global variable", &GV);
+ Assert(ETy->isPointerTy() &&
+ cast<PointerType>(ETy)->getElementType()->isIntegerTy(8),
+ "wrong type for intrinsic global variable", &GV);
}
}
}
if (GV.hasName() && (GV.getName() == "llvm.used" ||
GV.getName() == "llvm.compiler.used")) {
- Assert1(!GV.hasInitializer() || GV.hasAppendingLinkage(),
- "invalid linkage for intrinsic global variable", &GV);
+ Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
+ "invalid linkage for intrinsic global variable", &GV);
Type *GVType = GV.getType()->getElementType();
if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
- Assert1(PTy, "wrong type for intrinsic global variable", &GV);
+ Assert(PTy, "wrong type for intrinsic global variable", &GV);
if (GV.hasInitializer()) {
const Constant *Init = GV.getInitializer();
const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
- Assert1(InitArray, "wrong initalizer for intrinsic global variable",
- Init);
+ Assert(InitArray, "wrong initalizer for intrinsic global variable",
+ Init);
for (unsigned i = 0, e = InitArray->getNumOperands(); i != e; ++i) {
Value *V = Init->getOperand(i)->stripPointerCastsNoFollowAliases();
- Assert1(
- isa<GlobalVariable>(V) || isa<Function>(V) || isa<GlobalAlias>(V),
- "invalid llvm.used member", V);
- Assert1(V->hasName(), "members of llvm.used must be named", V);
+ Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
+ isa<GlobalAlias>(V),
+ "invalid llvm.used member", V);
+ Assert(V->hasName(), "members of llvm.used must be named", V);
}
}
}
}
- Assert1(!GV.hasDLLImportStorageClass() ||
- (GV.isDeclaration() && GV.hasExternalLinkage()) ||
- GV.hasAvailableExternallyLinkage(),
- "Global is marked as dllimport, but not external", &GV);
+ Assert(!GV.hasDLLImportStorageClass() ||
+ (GV.isDeclaration() && GV.hasExternalLinkage()) ||
+ GV.hasAvailableExternallyLinkage(),
+ "Global is marked as dllimport, but not external", &GV);
if (!GV.hasInitializer()) {
visitGlobalValue(GV);
@@ -540,13 +518,13 @@ void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
const GlobalAlias &GA, const Constant &C) {
if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
- Assert1(!GV->isDeclaration(), "Alias must point to a definition", &GA);
+ Assert(!GV->isDeclaration(), "Alias must point to a definition", &GA);
if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
- Assert1(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
+ Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
- Assert1(!GA2->mayBeOverridden(), "Alias cannot point to a weak alias",
- &GA);
+ Assert(!GA2->mayBeOverridden(), "Alias cannot point to a weak alias",
+ &GA);
} else {
// Only continue verifying subexpressions of GlobalAliases.
// Do not recurse into global initializers.
@@ -567,19 +545,18 @@ void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
}
void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
- Assert1(!GA.getName().empty(),
- "Alias name cannot be empty!", &GA);
- Assert1(GlobalAlias::isValidLinkage(GA.getLinkage()),
- "Alias should have private, internal, linkonce, weak, linkonce_odr, "
- "weak_odr, or external linkage!",
- &GA);
+ Assert(!GA.getName().empty(), "Alias name cannot be empty!", &GA);
+ Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),
+ "Alias should have private, internal, linkonce, weak, linkonce_odr, "
+ "weak_odr, or external linkage!",
+ &GA);
const Constant *Aliasee = GA.getAliasee();
- Assert1(Aliasee, "Aliasee cannot be NULL!", &GA);
- Assert1(GA.getType() == Aliasee->getType(),
- "Alias and aliasee types should match!", &GA);
+ Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
+ Assert(GA.getType() == Aliasee->getType(),
+ "Alias and aliasee types should match!", &GA);
- Assert1(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
- "Aliasee should be either GlobalValue or ConstantExpr", &GA);
+ Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
+ "Aliasee should be either GlobalValue or ConstantExpr", &GA);
visitAliaseeSubExpr(GA, *Aliasee);
@@ -592,6 +569,10 @@ void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
if (!MD)
continue;
+ if (NMD.getName() == "llvm.dbg.cu") {
+ Assert(isa<MDCompileUnit>(MD), "invalid compile unit", &NMD, MD);
+ }
+
visitMDNode(*MD);
}
}
@@ -618,8 +599,8 @@ void Verifier::visitMDNode(const MDNode &MD) {
Metadata *Op = MD.getOperand(i);
if (!Op)
continue;
- Assert2(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
- &MD, Op);
+ Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
+ &MD, Op);
if (auto *N = dyn_cast<MDNode>(Op)) {
visitMDNode(*N);
continue;
@@ -631,26 +612,26 @@ void Verifier::visitMDNode(const MDNode &MD) {
}
// Check these last, so we diagnose problems in operands first.
- Assert1(!MD.isTemporary(), "Expected no forward declarations!", &MD);
- Assert1(MD.isResolved(), "All nodes should be resolved!", &MD);
+ Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD);
+ Assert(MD.isResolved(), "All nodes should be resolved!", &MD);
}
void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
- Assert1(MD.getValue(), "Expected valid value", &MD);
- Assert2(!MD.getValue()->getType()->isMetadataTy(),
- "Unexpected metadata round-trip through values", &MD, MD.getValue());
+ Assert(MD.getValue(), "Expected valid value", &MD);
+ Assert(!MD.getValue()->getType()->isMetadataTy(),
+ "Unexpected metadata round-trip through values", &MD, MD.getValue());
auto *L = dyn_cast<LocalAsMetadata>(&MD);
if (!L)
return;
- Assert1(F, "function-local metadata used outside a function", L);
+ Assert(F, "function-local metadata used outside a function", L);
// If this was an instruction, bb, or argument, verify that it is in the
// function that we expect.
Function *ActualF = nullptr;
if (Instruction *I = dyn_cast<Instruction>(L->getValue())) {
- Assert2(I->getParent(), "function-local metadata not in basic block", L, I);
+ Assert(I->getParent(), "function-local metadata not in basic block", L, I);
ActualF = I->getParent()->getParent();
} else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue()))
ActualF = BB->getParent();
@@ -658,7 +639,7 @@ void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
ActualF = A->getParent();
assert(ActualF && "Unimplemented function local metadata case!");
- Assert1(ActualF == F, "function-local metadata used in wrong function", L);
+ Assert(ActualF == F, "function-local metadata used in wrong function", L);
}
void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
@@ -678,126 +659,126 @@ void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
}
void Verifier::visitMDLocation(const MDLocation &N) {
- Assert1(N.getScope(), "location requires a valid scope", &N);
- if (auto *IA = N.getInlinedAt())
- Assert2(isa<MDLocation>(IA), "inlined-at should be a location", &N, IA);
+ Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()),
+ "location requires a valid scope", &N, N.getRawScope());
+ if (auto *IA = N.getRawInlinedAt())
+ Assert(isa<MDLocation>(IA), "inlined-at should be a location", &N, IA);
}
void Verifier::visitGenericDebugNode(const GenericDebugNode &N) {
- Assert1(N.getTag(), "invalid tag", &N);
+ Assert(N.getTag(), "invalid tag", &N);
}
void Verifier::visitMDSubrange(const MDSubrange &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
}
void Verifier::visitMDEnumerator(const MDEnumerator &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
}
void Verifier::visitMDBasicType(const MDBasicType &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_base_type ||
- N.getTag() == dwarf::DW_TAG_unspecified_type,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_base_type ||
+ N.getTag() == dwarf::DW_TAG_unspecified_type,
+ "invalid tag", &N);
}
void Verifier::visitMDDerivedType(const MDDerivedType &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_typedef ||
- N.getTag() == dwarf::DW_TAG_pointer_type ||
- N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
- N.getTag() == dwarf::DW_TAG_reference_type ||
- N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
- N.getTag() == dwarf::DW_TAG_const_type ||
- N.getTag() == dwarf::DW_TAG_volatile_type ||
- N.getTag() == dwarf::DW_TAG_restrict_type ||
- N.getTag() == dwarf::DW_TAG_member ||
- N.getTag() == dwarf::DW_TAG_inheritance ||
- N.getTag() == dwarf::DW_TAG_friend,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_typedef ||
+ N.getTag() == dwarf::DW_TAG_pointer_type ||
+ N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
+ N.getTag() == dwarf::DW_TAG_reference_type ||
+ N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
+ N.getTag() == dwarf::DW_TAG_const_type ||
+ N.getTag() == dwarf::DW_TAG_volatile_type ||
+ N.getTag() == dwarf::DW_TAG_restrict_type ||
+ N.getTag() == dwarf::DW_TAG_member ||
+ N.getTag() == dwarf::DW_TAG_inheritance ||
+ N.getTag() == dwarf::DW_TAG_friend,
+ "invalid tag", &N);
}
void Verifier::visitMDCompositeType(const MDCompositeType &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_array_type ||
- N.getTag() == dwarf::DW_TAG_structure_type ||
- N.getTag() == dwarf::DW_TAG_union_type ||
- N.getTag() == dwarf::DW_TAG_enumeration_type ||
- N.getTag() == dwarf::DW_TAG_subroutine_type ||
- N.getTag() == dwarf::DW_TAG_class_type,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_array_type ||
+ N.getTag() == dwarf::DW_TAG_structure_type ||
+ N.getTag() == dwarf::DW_TAG_union_type ||
+ N.getTag() == dwarf::DW_TAG_enumeration_type ||
+ N.getTag() == dwarf::DW_TAG_subroutine_type ||
+ N.getTag() == dwarf::DW_TAG_class_type,
+ "invalid tag", &N);
}
void Verifier::visitMDSubroutineType(const MDSubroutineType &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
}
void Verifier::visitMDFile(const MDFile &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
}
void Verifier::visitMDCompileUnit(const MDCompileUnit &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
}
void Verifier::visitMDSubprogram(const MDSubprogram &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
}
void Verifier::visitMDLexicalBlock(const MDLexicalBlock &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
}
void Verifier::visitMDLexicalBlockFile(const MDLexicalBlockFile &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
}
void Verifier::visitMDNamespace(const MDNamespace &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
}
void Verifier::visitMDTemplateTypeParameter(const MDTemplateTypeParameter &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
- &N);
+ Assert(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
+ &N);
}
void Verifier::visitMDTemplateValueParameter(
const MDTemplateValueParameter &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
- N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
- N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
+ N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
+ N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
+ "invalid tag", &N);
}
void Verifier::visitMDGlobalVariable(const MDGlobalVariable &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
}
void Verifier::visitMDLocalVariable(const MDLocalVariable &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_auto_variable ||
- N.getTag() == dwarf::DW_TAG_arg_variable,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_auto_variable ||
+ N.getTag() == dwarf::DW_TAG_arg_variable,
+ "invalid tag", &N);
}
void Verifier::visitMDExpression(const MDExpression &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_expression, "invalid tag", &N);
- Assert1(N.isValid(), "invalid expression", &N);
+ Assert(N.isValid(), "invalid expression", &N);
}
void Verifier::visitMDObjCProperty(const MDObjCProperty &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
}
void Verifier::visitMDImportedEntity(const MDImportedEntity &N) {
- Assert1(N.getTag() == dwarf::DW_TAG_imported_module ||
- N.getTag() == dwarf::DW_TAG_imported_declaration,
- "invalid tag", &N);
+ Assert(N.getTag() == dwarf::DW_TAG_imported_module ||
+ N.getTag() == dwarf::DW_TAG_imported_declaration,
+ "invalid tag", &N);
}
void Verifier::visitComdat(const Comdat &C) {
// The Module is invalid if the GlobalValue has private linkage. Entities
// with private linkage don't have entries in the symbol table.
if (const GlobalValue *GV = M->getNamedValue(C.getName()))
- Assert1(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
- GV);
+ Assert(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
+ GV);
}
void Verifier::visitModuleIdents(const Module &M) {
@@ -809,12 +790,12 @@ void Verifier::visitModuleIdents(const Module &M) {
// Scan each llvm.ident entry and make sure that this requirement is met.
for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) {
const MDNode *N = Idents->getOperand(i);
- Assert1(N->getNumOperands() == 1,
- "incorrect number of operands in llvm.ident metadata", N);
- Assert1(dyn_cast_or_null<MDString>(N->getOperand(0)),
- ("invalid value for llvm.ident metadata entry operand"
- "(the operand should be a string)"),
- N->getOperand(0));
+ Assert(N->getNumOperands() == 1,
+ "incorrect number of operands in llvm.ident metadata", N);
+ Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
+ ("invalid value for llvm.ident metadata entry operand"
+ "(the operand should be a string)"),
+ N->getOperand(0));
}
}
@@ -857,22 +838,21 @@ Verifier::visitModuleFlag(const MDNode *Op,
SmallVectorImpl<const MDNode *> &Requirements) {
// Each module flag should have three arguments, the merge behavior (a
// constant int), the flag ID (an MDString), and the value.
- Assert1(Op->getNumOperands() == 3,
- "incorrect number of operands in module flag", Op);
+ Assert(Op->getNumOperands() == 3,
+ "incorrect number of operands in module flag", Op);
Module::ModFlagBehavior MFB;
if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
- Assert1(
+ Assert(
mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
"invalid behavior operand in module flag (expected constant integer)",
Op->getOperand(0));
- Assert1(false,
- "invalid behavior operand in module flag (unexpected constant)",
- Op->getOperand(0));
+ Assert(false,
+ "invalid behavior operand in module flag (unexpected constant)",
+ Op->getOperand(0));
}
MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
- Assert1(ID,
- "invalid ID operand in module flag (expected metadata string)",
- Op->getOperand(1));
+ Assert(ID, "invalid ID operand in module flag (expected metadata string)",
+ Op->getOperand(1));
// Sanity check the values for behaviors with additional requirements.
switch (MFB) {
@@ -886,13 +866,13 @@ Verifier::visitModuleFlag(const MDNode *Op,
// The value should itself be an MDNode with two operands, a flag ID (an
// MDString), and a value.
MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
- Assert1(Value && Value->getNumOperands() == 2,
- "invalid value for 'require' module flag (expected metadata pair)",
- Op->getOperand(2));
- Assert1(isa<MDString>(Value->getOperand(0)),
- ("invalid value for 'require' module flag "
- "(first value operand should be a string)"),
- Value->getOperand(0));
+ Assert(Value && Value->getNumOperands() == 2,
+ "invalid value for 'require' module flag (expected metadata pair)",
+ Op->getOperand(2));
+ Assert(isa<MDString>(Value->getOperand(0)),
+ ("invalid value for 'require' module flag "
+ "(first value operand should be a string)"),
+ Value->getOperand(0));
// Append it to the list of requirements, to check once all module flags are
// scanned.
@@ -903,9 +883,10 @@ Verifier::visitModuleFlag(const MDNode *Op,
case Module::Append:
case Module::AppendUnique: {
// These behavior types require the operand be an MDNode.
- Assert1(isa<MDNode>(Op->getOperand(2)),
- "invalid value for 'append'-type module flag "
- "(expected a metadata node)", Op->getOperand(2));
+ Assert(isa<MDNode>(Op->getOperand(2)),
+ "invalid value for 'append'-type module flag "
+ "(expected a metadata node)",
+ Op->getOperand(2));
break;
}
}
@@ -913,9 +894,8 @@ Verifier::visitModuleFlag(const MDNode *Op,
// Unless this is a "requires" flag, check the ID is unique.
if (MFB != Module::Require) {
bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
- Assert1(Inserted,
- "module flag identifiers must be unique (or of 'require' type)",
- ID);
+ Assert(Inserted,
+ "module flag identifiers must be unique (or of 'require' type)", ID);
}
}
@@ -991,14 +971,15 @@ void Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
VerifyAttributeTypes(Attrs, Idx, false, V);
if (isReturnValue)
- Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
- !Attrs.hasAttribute(Idx, Attribute::Nest) &&
- !Attrs.hasAttribute(Idx, Attribute::StructRet) &&
- !Attrs.hasAttribute(Idx, Attribute::NoCapture) &&
- !Attrs.hasAttribute(Idx, Attribute::Returned) &&
- !Attrs.hasAttribute(Idx, Attribute::InAlloca),
- "Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', and "
- "'returned' do not apply to return values!", V);
+ Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
+ !Attrs.hasAttribute(Idx, Attribute::Nest) &&
+ !Attrs.hasAttribute(Idx, Attribute::StructRet) &&
+ !Attrs.hasAttribute(Idx, Attribute::NoCapture) &&
+ !Attrs.hasAttribute(Idx, Attribute::Returned) &&
+ !Attrs.hasAttribute(Idx, Attribute::InAlloca),
+ "Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', and "
+ "'returned' do not apply to return values!",
+ V);
// Check for mutually incompatible attributes. Only inreg is compatible with
// sret.
@@ -1008,45 +989,58 @@ void Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
AttrCount += Attrs.hasAttribute(Idx, Attribute::StructRet) ||
Attrs.hasAttribute(Idx, Attribute::InReg);
AttrCount += Attrs.hasAttribute(Idx, Attribute::Nest);
- Assert1(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', "
- "and 'sret' are incompatible!", V);
-
- Assert1(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) &&
- Attrs.hasAttribute(Idx, Attribute::ReadOnly)), "Attributes "
- "'inalloca and readonly' are incompatible!", V);
-
- Assert1(!(Attrs.hasAttribute(Idx, Attribute::StructRet) &&
- Attrs.hasAttribute(Idx, Attribute::Returned)), "Attributes "
- "'sret and returned' are incompatible!", V);
-
- Assert1(!(Attrs.hasAttribute(Idx, Attribute::ZExt) &&
- Attrs.hasAttribute(Idx, Attribute::SExt)), "Attributes "
- "'zeroext and signext' are incompatible!", V);
-
- Assert1(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) &&
- Attrs.hasAttribute(Idx, Attribute::ReadOnly)), "Attributes "
- "'readnone and readonly' are incompatible!", V);
-
- Assert1(!(Attrs.hasAttribute(Idx, Attribute::NoInline) &&
- Attrs.hasAttribute(Idx, Attribute::AlwaysInline)), "Attributes "
- "'noinline and alwaysinline' are incompatible!", V);
-
- Assert1(!AttrBuilder(Attrs, Idx).
- hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx),
- "Wrong types for attribute: " +
- AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx), V);
+ Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', "
+ "and 'sret' are incompatible!",
+ V);
+
+ Assert(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) &&
+ Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
+ "Attributes "
+ "'inalloca and readonly' are incompatible!",
+ V);
+
+ Assert(!(Attrs.hasAttribute(Idx, Attribute::StructRet) &&
+ Attrs.hasAttribute(Idx, Attribute::Returned)),
+ "Attributes "
+ "'sret and returned' are incompatible!",
+ V);
+
+ Assert(!(Attrs.hasAttribute(Idx, Attribute::ZExt) &&
+ Attrs.hasAttribute(Idx, Attribute::SExt)),
+ "Attributes "
+ "'zeroext and signext' are incompatible!",
+ V);
+
+ Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) &&
+ Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
+ "Attributes "
+ "'readnone and readonly' are incompatible!",
+ V);
+
+ Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) &&
+ Attrs.hasAttribute(Idx, Attribute::AlwaysInline)),
+ "Attributes "
+ "'noinline and alwaysinline' are incompatible!",
+ V);
+
+ Assert(!AttrBuilder(Attrs, Idx)
+ .hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx),
+ "Wrong types for attribute: " +
+ AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx),
+ V);
if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
- if (!PTy->getElementType()->isSized()) {
- Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
- !Attrs.hasAttribute(Idx, Attribute::InAlloca),
- "Attributes 'byval' and 'inalloca' do not support unsized types!",
- V);
+ SmallPtrSet<const Type*, 4> Visited;
+ if (!PTy->getElementType()->isSized(&Visited)) {
+ Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
+ !Attrs.hasAttribute(Idx, Attribute::InAlloca),
+ "Attributes 'byval' and 'inalloca' do not support unsized types!",
+ V);
}
} else {
- Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal),
- "Attribute 'byval' only applies to parameters with pointer type!",
- V);
+ Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal),
+ "Attribute 'byval' only applies to parameters with pointer type!",
+ V);
}
}
@@ -1078,28 +1072,30 @@ void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
continue;
if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
- Assert1(!SawNest, "More than one parameter has attribute nest!", V);
+ Assert(!SawNest, "More than one parameter has attribute nest!", V);
SawNest = true;
}
if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
- Assert1(!SawReturned, "More than one parameter has attribute returned!",
- V);
- Assert1(Ty->canLosslesslyBitCastTo(FT->getReturnType()), "Incompatible "
- "argument and return types for 'returned' attribute", V);
+ Assert(!SawReturned, "More than one parameter has attribute returned!",
+ V);
+ Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
+ "Incompatible "
+ "argument and return types for 'returned' attribute",
+ V);
SawReturned = true;
}
if (Attrs.hasAttribute(Idx, Attribute::StructRet)) {
- Assert1(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
- Assert1(Idx == 1 || Idx == 2,
- "Attribute 'sret' is not on first or second parameter!", V);
+ Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
+ Assert(Idx == 1 || Idx == 2,
+ "Attribute 'sret' is not on first or second parameter!", V);
SawSRet = true;
}
if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) {
- Assert1(Idx == FT->getNumParams(),
- "inalloca isn't on the last parameter!", V);
+ Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!",
+ V);
}
}
@@ -1108,39 +1104,35 @@ void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V);
- Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::ReadNone) &&
- Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::ReadOnly)),
- "Attributes 'readnone and readonly' are incompatible!", V);
+ Assert(
+ !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
+ Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)),
+ "Attributes 'readnone and readonly' are incompatible!", V);
- Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::NoInline) &&
- Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::AlwaysInline)),
- "Attributes 'noinline and alwaysinline' are incompatible!", V);
+ Assert(
+ !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) &&
+ Attrs.hasAttribute(AttributeSet::FunctionIndex,
+ Attribute::AlwaysInline)),
+ "Attributes 'noinline and alwaysinline' are incompatible!", V);
if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
Attribute::OptimizeNone)) {
- Assert1(Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::NoInline),
- "Attribute 'optnone' requires 'noinline'!", V);
+ Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline),
+ "Attribute 'optnone' requires 'noinline'!", V);
- Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::OptimizeForSize),
- "Attributes 'optsize and optnone' are incompatible!", V);
+ Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
+ Attribute::OptimizeForSize),
+ "Attributes 'optsize and optnone' are incompatible!", V);
- Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::MinSize),
- "Attributes 'minsize and optnone' are incompatible!", V);
+ Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize),
+ "Attributes 'minsize and optnone' are incompatible!", V);
}
if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
Attribute::JumpTable)) {
const GlobalValue *GV = cast<GlobalValue>(V);
- Assert1(GV->hasUnnamedAddr(),
- "Attribute 'jumptable' requires 'unnamed_addr'", V);
-
+ Assert(GV->hasUnnamedAddr(),
+ "Attribute 'jumptable' requires 'unnamed_addr'", V);
}
}
@@ -1148,9 +1140,9 @@ void Verifier::VerifyConstantExprBitcastType(const ConstantExpr *CE) {
if (CE->getOpcode() != Instruction::BitCast)
return;
- Assert1(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
- CE->getType()),
- "Invalid bitcast", CE);
+ Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
+ CE->getType()),
+ "Invalid bitcast", CE);
}
bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {
@@ -1175,84 +1167,86 @@ void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
const Instruction &CI = *CS.getInstruction();
- Assert1(!CS.doesNotAccessMemory() &&
- !CS.onlyReadsMemory(),
- "gc.statepoint must read and write memory to preserve "
- "reordering restrictions required by safepoint semantics", &CI);
-
+ Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(),
+ "gc.statepoint must read and write memory to preserve "
+ "reordering restrictions required by safepoint semantics",
+ &CI);
+
const Value *Target = CS.getArgument(0);
const PointerType *PT = dyn_cast<PointerType>(Target->getType());
- Assert2(PT && PT->getElementType()->isFunctionTy(),
- "gc.statepoint callee must be of function pointer type",
- &CI, Target);
+ Assert(PT && PT->getElementType()->isFunctionTy(),
+ "gc.statepoint callee must be of function pointer type", &CI, Target);
FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
const Value *NumCallArgsV = CS.getArgument(1);
- Assert1(isa<ConstantInt>(NumCallArgsV),
- "gc.statepoint number of arguments to underlying call "
- "must be constant integer", &CI);
+ Assert(isa<ConstantInt>(NumCallArgsV),
+ "gc.statepoint number of arguments to underlying call "
+ "must be constant integer",
+ &CI);
const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();
- Assert1(NumCallArgs >= 0,
- "gc.statepoint number of arguments to underlying call "
- "must be positive", &CI);
+ Assert(NumCallArgs >= 0,
+ "gc.statepoint number of arguments to underlying call "
+ "must be positive",
+ &CI);
const int NumParams = (int)TargetFuncType->getNumParams();
if (TargetFuncType->isVarArg()) {
- Assert1(NumCallArgs >= NumParams,
- "gc.statepoint mismatch in number of vararg call args", &CI);
+ Assert(NumCallArgs >= NumParams,
+ "gc.statepoint mismatch in number of vararg call args", &CI);
// TODO: Remove this limitation
- Assert1(TargetFuncType->getReturnType()->isVoidTy(),
- "gc.statepoint doesn't support wrapping non-void "
- "vararg functions yet", &CI);
+ Assert(TargetFuncType->getReturnType()->isVoidTy(),
+ "gc.statepoint doesn't support wrapping non-void "
+ "vararg functions yet",
+ &CI);
} else
- Assert1(NumCallArgs == NumParams,
- "gc.statepoint mismatch in number of call args", &CI);
+ Assert(NumCallArgs == NumParams,
+ "gc.statepoint mismatch in number of call args", &CI);
const Value *Unused = CS.getArgument(2);
- Assert1(isa<ConstantInt>(Unused) &&
- cast<ConstantInt>(Unused)->isNullValue(),
- "gc.statepoint parameter #3 must be zero", &CI);
+ Assert(isa<ConstantInt>(Unused) && cast<ConstantInt>(Unused)->isNullValue(),
+ "gc.statepoint parameter #3 must be zero", &CI);
// Verify that the types of the call parameter arguments match
// the type of the wrapped callee.
for (int i = 0; i < NumParams; i++) {
Type *ParamType = TargetFuncType->getParamType(i);
Type *ArgType = CS.getArgument(3+i)->getType();
- Assert1(ArgType == ParamType,
- "gc.statepoint call argument does not match wrapped "
- "function type", &CI);
+ Assert(ArgType == ParamType,
+ "gc.statepoint call argument does not match wrapped "
+ "function type",
+ &CI);
}
const int EndCallArgsInx = 2+NumCallArgs;
const Value *NumDeoptArgsV = CS.getArgument(EndCallArgsInx+1);
- Assert1(isa<ConstantInt>(NumDeoptArgsV),
- "gc.statepoint number of deoptimization arguments "
- "must be constant integer", &CI);
+ Assert(isa<ConstantInt>(NumDeoptArgsV),
+ "gc.statepoint number of deoptimization arguments "
+ "must be constant integer",
+ &CI);
const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
- Assert1(NumDeoptArgs >= 0,
- "gc.statepoint number of deoptimization arguments "
- "must be positive", &CI);
+ Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments "
+ "must be positive",
+ &CI);
+
+ Assert(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(),
+ "gc.statepoint too few arguments according to length fields", &CI);
- Assert1(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(),
- "gc.statepoint too few arguments according to length fields", &CI);
-
// Check that the only uses of this gc.statepoint are gc.result or
// gc.relocate calls which are tied to this statepoint and thus part
// of the same statepoint sequence
for (const User *U : CI.users()) {
const CallInst *Call = dyn_cast<const CallInst>(U);
- Assert2(Call, "illegal use of statepoint token", &CI, U);
+ Assert(Call, "illegal use of statepoint token", &CI, U);
if (!Call) continue;
- Assert2(isGCRelocate(Call) || isGCResult(Call),
- "gc.result or gc.relocate are the only value uses"
- "of a gc.statepoint", &CI, U);
+ Assert(isGCRelocate(Call) || isGCResult(Call),
+ "gc.result or gc.relocate are the only value uses"
+ "of a gc.statepoint",
+ &CI, U);
if (isGCResult(Call)) {
- Assert2(Call->getArgOperand(0) == &CI,
- "gc.result connected to wrong gc.statepoint",
- &CI, Call);
+ Assert(Call->getArgOperand(0) == &CI,
+ "gc.result connected to wrong gc.statepoint", &CI, Call);
} else if (isGCRelocate(Call)) {
- Assert2(Call->getArgOperand(0) == &CI,
- "gc.relocate connected to wrong gc.statepoint",
- &CI, Call);
+ Assert(Call->getArgOperand(0) == &CI,
+ "gc.relocate connected to wrong gc.statepoint", &CI, Call);
}
}
@@ -1266,6 +1260,19 @@ void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
// about. See example statepoint.ll in the verifier subdirectory
}
+void Verifier::verifyFrameRecoverIndices() {
+ for (auto &Counts : FrameEscapeInfo) {
+ Function *F = Counts.first;
+ unsigned EscapedObjectCount = Counts.second.first;
+ unsigned MaxRecoveredIndex = Counts.second.second;
+ Assert(MaxRecoveredIndex <= EscapedObjectCount,
+ "all indices passed to llvm.framerecover must be less than the "
+ "number of arguments passed ot llvm.frameescape in the parent "
+ "function",
+ F);
+ }
+}
+
// visitFunction - Verify that a function is ok.
//
void Verifier::visitFunction(const Function &F) {
@@ -1273,25 +1280,24 @@ void Verifier::visitFunction(const Function &F) {
FunctionType *FT = F.getFunctionType();
unsigned NumArgs = F.arg_size();
- Assert1(Context == &F.getContext(),
- "Function context does not match Module context!", &F);
+ Assert(Context == &F.getContext(),
+ "Function context does not match Module context!", &F);
- Assert1(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
- Assert2(FT->getNumParams() == NumArgs,
- "# formal arguments must match # of arguments for function type!",
- &F, FT);
- Assert1(F.getReturnType()->isFirstClassType() ||
- F.getReturnType()->isVoidTy() ||
- F.getReturnType()->isStructTy(),
- "Functions cannot return aggregate values!", &F);
+ Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
+ Assert(FT->getNumParams() == NumArgs,
+ "# formal arguments must match # of arguments for function type!", &F,
+ FT);
+ Assert(F.getReturnType()->isFirstClassType() ||
+ F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
+ "Functions cannot return aggregate values!", &F);
- Assert1(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
- "Invalid struct return type!", &F);
+ Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
+ "Invalid struct return type!", &F);
AttributeSet Attrs = F.getAttributes();
- Assert1(VerifyAttributeCount(Attrs, FT->getNumParams()),
- "Attribute after last parameter!", &F);
+ Assert(VerifyAttributeCount(Attrs, FT->getNumParams()),
+ "Attribute after last parameter!", &F);
// Check function attributes.
VerifyFunctionAttrs(FT, Attrs, &F);
@@ -1299,9 +1305,8 @@ void Verifier::visitFunction(const Function &F) {
// On function declarations/definitions, we do not support the builtin
// attribute. We do not check this in VerifyFunctionAttrs since that is
// checking for Attributes that can/can not ever be on functions.
- Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
- Attribute::Builtin),
- "Attribute 'builtin' can only be applied to a callsite.", &F);
+ Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin),
+ "Attribute 'builtin' can only be applied to a callsite.", &F);
// Check that this function meets the restrictions on this calling convention.
// Sometimes varargs is used for perfectly forwarding thunks, so some of these
@@ -1315,8 +1320,9 @@ void Verifier::visitFunction(const Function &F) {
case CallingConv::Intel_OCL_BI:
case CallingConv::PTX_Kernel:
case CallingConv::PTX_Device:
- Assert1(!F.isVarArg(), "Calling convention does not support varargs or "
- "perfect forwarding!", &F);
+ Assert(!F.isVarArg(), "Calling convention does not support varargs or "
+ "perfect forwarding!",
+ &F);
break;
}
@@ -1327,35 +1333,35 @@ void Verifier::visitFunction(const Function &F) {
unsigned i = 0;
for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E;
++I, ++i) {
- Assert2(I->getType() == FT->getParamType(i),
- "Argument value does not match function argument type!",
- I, FT->getParamType(i));
- Assert1(I->getType()->isFirstClassType(),
- "Function arguments must have first-class types!", I);
+ Assert(I->getType() == FT->getParamType(i),
+ "Argument value does not match function argument type!", I,
+ FT->getParamType(i));
+ Assert(I->getType()->isFirstClassType(),
+ "Function arguments must have first-class types!", I);
if (!isLLVMdotName)
- Assert2(!I->getType()->isMetadataTy(),
- "Function takes metadata but isn't an intrinsic", I, &F);
+ Assert(!I->getType()->isMetadataTy(),
+ "Function takes metadata but isn't an intrinsic", I, &F);
}
if (F.isMaterializable()) {
// Function has a body somewhere we can't see.
} else if (F.isDeclaration()) {
- Assert1(F.hasExternalLinkage() || F.hasExternalWeakLinkage(),
- "invalid linkage type for function declaration", &F);
+ Assert(F.hasExternalLinkage() || F.hasExternalWeakLinkage(),
+ "invalid linkage type for function declaration", &F);
} else {
// Verify that this function (which has a body) is not named "llvm.*". It
// is not legal to define intrinsics.
- Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
+ Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
// Check the entry node
const BasicBlock *Entry = &F.getEntryBlock();
- Assert1(pred_empty(Entry),
- "Entry block to function must not have predecessors!", Entry);
+ Assert(pred_empty(Entry),
+ "Entry block to function must not have predecessors!", Entry);
// The address of the entry block cannot be taken, unless it is dead.
if (Entry->hasAddressTaken()) {
- Assert1(!BlockAddress::lookup(Entry)->isConstantUsed(),
- "blockaddress may not be used with the entry block!", Entry);
+ Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),
+ "blockaddress may not be used with the entry block!", Entry);
}
}
@@ -1364,13 +1370,13 @@ void Verifier::visitFunction(const Function &F) {
if (F.getIntrinsicID()) {
const User *U;
if (F.hasAddressTaken(&U))
- Assert1(0, "Invalid user of intrinsic instruction!", U);
+ Assert(0, "Invalid user of intrinsic instruction!", U);
}
- Assert1(!F.hasDLLImportStorageClass() ||
- (F.isDeclaration() && F.hasExternalLinkage()) ||
- F.hasAvailableExternallyLinkage(),
- "Function is marked as dllimport, but not external.", &F);
+ Assert(!F.hasDLLImportStorageClass() ||
+ (F.isDeclaration() && F.hasExternalLinkage()) ||
+ F.hasAvailableExternallyLinkage(),
+ "Function is marked as dllimport, but not external.", &F);
}
// verifyBasicBlock - Verify that a basic block is well formed...
@@ -1379,7 +1385,7 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
InstsInThisBlock.clear();
// Ensure that basic blocks have terminators!
- Assert1(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
+ Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
// Check constraints that this basic block imposes on all of the PHI nodes in
// it.
@@ -1390,12 +1396,14 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
PHINode *PN;
for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) {
// Ensure that PHI nodes have at least one entry!
- Assert1(PN->getNumIncomingValues() != 0,
- "PHI nodes must have at least one entry. If the block is dead, "
- "the PHI should be removed!", PN);
- Assert1(PN->getNumIncomingValues() == Preds.size(),
- "PHINode should have one entry for each predecessor of its "
- "parent basic block!", PN);
+ Assert(PN->getNumIncomingValues() != 0,
+ "PHI nodes must have at least one entry. If the block is dead, "
+ "the PHI should be removed!",
+ PN);
+ Assert(PN->getNumIncomingValues() == Preds.size(),
+ "PHINode should have one entry for each predecessor of its "
+ "parent basic block!",
+ PN);
// Get and sort all incoming values in the PHI node...
Values.clear();
@@ -1410,17 +1418,17 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
// particular basic block in this PHI node, that the incoming values are
// all identical.
//
- Assert4(i == 0 || Values[i].first != Values[i-1].first ||
- Values[i].second == Values[i-1].second,
- "PHI node has multiple entries for the same basic block with "
- "different incoming values!", PN, Values[i].first,
- Values[i].second, Values[i-1].second);
+ Assert(i == 0 || Values[i].first != Values[i - 1].first ||
+ Values[i].second == Values[i - 1].second,
+ "PHI node has multiple entries for the same basic block with "
+ "different incoming values!",
+ PN, Values[i].first, Values[i].second, Values[i - 1].second);
// Check to make sure that the predecessors and PHI node entries are
// matched up.
- Assert3(Values[i].first == Preds[i],
- "PHI node entries do not match predecessors!", PN,
- Values[i].first, Preds[i]);
+ Assert(Values[i].first == Preds[i],
+ "PHI node entries do not match predecessors!", PN,
+ Values[i].first, Preds[i]);
}
}
}
@@ -1434,15 +1442,15 @@ void Verifier::visitBasicBlock(BasicBlock &BB) {
void Verifier::visitTerminatorInst(TerminatorInst &I) {
// Ensure that terminators only exist at the end of the basic block.
- Assert1(&I == I.getParent()->getTerminator(),
- "Terminator found in the middle of a basic block!", I.getParent());
+ Assert(&I == I.getParent()->getTerminator(),
+ "Terminator found in the middle of a basic block!", I.getParent());
visitInstruction(I);
}
void Verifier::visitBranchInst(BranchInst &BI) {
if (BI.isConditional()) {
- Assert2(BI.getCondition()->getType()->isIntegerTy(1),
- "Branch condition is not 'i1' type!", &BI, BI.getCondition());
+ Assert(BI.getCondition()->getType()->isIntegerTy(1),
+ "Branch condition is not 'i1' type!", &BI, BI.getCondition());
}
visitTerminatorInst(BI);
}
@@ -1451,13 +1459,15 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
Function *F = RI.getParent()->getParent();
unsigned N = RI.getNumOperands();
if (F->getReturnType()->isVoidTy())
- Assert2(N == 0,
- "Found return instr that returns non-void in Function of void "
- "return type!", &RI, F->getReturnType());
+ Assert(N == 0,
+ "Found return instr that returns non-void in Function of void "
+ "return type!",
+ &RI, F->getReturnType());
else
- Assert2(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
- "Function return type does not match operand "
- "type of return inst!", &RI, F->getReturnType());
+ Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
+ "Function return type does not match operand "
+ "type of return inst!",
+ &RI, F->getReturnType());
// Check to make sure that the return value has necessary properties for
// terminators...
@@ -1470,32 +1480,32 @@ void Verifier::visitSwitchInst(SwitchInst &SI) {
Type *SwitchTy = SI.getCondition()->getType();
SmallPtrSet<ConstantInt*, 32> Constants;
for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) {
- Assert1(i.getCaseValue()->getType() == SwitchTy,
- "Switch constants must all be same type as switch value!", &SI);
- Assert2(Constants.insert(i.getCaseValue()).second,
- "Duplicate integer as switch case", &SI, i.getCaseValue());
+ Assert(i.getCaseValue()->getType() == SwitchTy,
+ "Switch constants must all be same type as switch value!", &SI);
+ Assert(Constants.insert(i.getCaseValue()).second,
+ "Duplicate integer as switch case", &SI, i.getCaseValue());
}
visitTerminatorInst(SI);
}
void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
- Assert1(BI.getAddress()->getType()->isPointerTy(),
- "Indirectbr operand must have pointer type!", &BI);
+ Assert(BI.getAddress()->getType()->isPointerTy(),
+ "Indirectbr operand must have pointer type!", &BI);
for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
- Assert1(BI.getDestination(i)->getType()->isLabelTy(),
- "Indirectbr destinations must all have pointer type!", &BI);
+ Assert(BI.getDestination(i)->getType()->isLabelTy(),
+ "Indirectbr destinations must all have pointer type!", &BI);
visitTerminatorInst(BI);
}
void Verifier::visitSelectInst(SelectInst &SI) {
- Assert1(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
- SI.getOperand(2)),
- "Invalid operands for select instruction!", &SI);
+ Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
+ SI.getOperand(2)),
+ "Invalid operands for select instruction!", &SI);
- Assert1(SI.getTrueValue()->getType() == SI.getType(),
- "Select values must have same type as select instruction!", &SI);
+ Assert(SI.getTrueValue()->getType() == SI.getType(),
+ "Select values must have same type as select instruction!", &SI);
visitInstruction(SI);
}
@@ -1503,7 +1513,7 @@ void Verifier::visitSelectInst(SelectInst &SI) {
/// a pass, if any exist, it's an error.
///
void Verifier::visitUserOp1(Instruction &I) {
- Assert1(0, "User-defined operators should not live outside of a pass!", &I);
+ Assert(0, "User-defined operators should not live outside of a pass!", &I);
}
void Verifier::visitTruncInst(TruncInst &I) {
@@ -1515,11 +1525,11 @@ void Verifier::visitTruncInst(TruncInst &I) {
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
unsigned DestBitSize = DestTy->getScalarSizeInBits();
- Assert1(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
- Assert1(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "trunc source and destination must both be a vector or neither", &I);
- Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I);
+ Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
+ Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+ "trunc source and destination must both be a vector or neither", &I);
+ Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
visitInstruction(I);
}
@@ -1530,14 +1540,14 @@ void Verifier::visitZExtInst(ZExtInst &I) {
Type *DestTy = I.getType();
// Get the size of the types in bits, we'll need this later
- Assert1(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
- Assert1(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "zext source and destination must both be a vector or neither", &I);
+ Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
+ Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+ "zext source and destination must both be a vector or neither", &I);
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
unsigned DestBitSize = DestTy->getScalarSizeInBits();
- Assert1(SrcBitSize < DestBitSize,"Type too small for ZExt", &I);
+ Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
visitInstruction(I);
}
@@ -1551,11 +1561,11 @@ void Verifier::visitSExtInst(SExtInst &I) {
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
unsigned DestBitSize = DestTy->getScalarSizeInBits();
- Assert1(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
- Assert1(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "sext source and destination must both be a vector or neither", &I);
- Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I);
+ Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
+ Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+ "sext source and destination must both be a vector or neither", &I);
+ Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
visitInstruction(I);
}
@@ -1568,11 +1578,11 @@ void Verifier::visitFPTruncInst(FPTruncInst &I) {
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
unsigned DestBitSize = DestTy->getScalarSizeInBits();
- Assert1(SrcTy->isFPOrFPVectorTy(),"FPTrunc only operates on FP", &I);
- Assert1(DestTy->isFPOrFPVectorTy(),"FPTrunc only produces an FP", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "fptrunc source and destination must both be a vector or neither",&I);
- Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I);
+ Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
+ Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+ "fptrunc source and destination must both be a vector or neither", &I);
+ Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
visitInstruction(I);
}
@@ -1586,11 +1596,11 @@ void Verifier::visitFPExtInst(FPExtInst &I) {
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
unsigned DestBitSize = DestTy->getScalarSizeInBits();
- Assert1(SrcTy->isFPOrFPVectorTy(),"FPExt only operates on FP", &I);
- Assert1(DestTy->isFPOrFPVectorTy(),"FPExt only produces an FP", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "fpext source and destination must both be a vector or neither", &I);
- Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I);
+ Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
+ Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+ "fpext source and destination must both be a vector or neither", &I);
+ Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
visitInstruction(I);
}
@@ -1603,17 +1613,17 @@ void Verifier::visitUIToFPInst(UIToFPInst &I) {
bool SrcVec = SrcTy->isVectorTy();
bool DstVec = DestTy->isVectorTy();
- Assert1(SrcVec == DstVec,
- "UIToFP source and dest must both be vector or scalar", &I);
- Assert1(SrcTy->isIntOrIntVectorTy(),
- "UIToFP source must be integer or integer vector", &I);
- Assert1(DestTy->isFPOrFPVectorTy(),
- "UIToFP result must be FP or FP vector", &I);
+ Assert(SrcVec == DstVec,
+ "UIToFP source and dest must both be vector or scalar", &I);
+ Assert(SrcTy->isIntOrIntVectorTy(),
+ "UIToFP source must be integer or integer vector", &I);
+ Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
+ &I);
if (SrcVec && DstVec)
- Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
- cast<VectorType>(DestTy)->getNumElements(),
- "UIToFP source and dest vector length mismatch", &I);
+ Assert(cast<VectorType>(SrcTy)->getNumElements() ==
+ cast<VectorType>(DestTy)->getNumElements(),
+ "UIToFP source and dest vector length mismatch", &I);
visitInstruction(I);
}
@@ -1626,17 +1636,17 @@ void Verifier::visitSIToFPInst(SIToFPInst &I) {
bool SrcVec = SrcTy->isVectorTy();
bool DstVec = DestTy->isVectorTy();
- Assert1(SrcVec == DstVec,
- "SIToFP source and dest must both be vector or scalar", &I);
- Assert1(SrcTy->isIntOrIntVectorTy(),
- "SIToFP source must be integer or integer vector", &I);
- Assert1(DestTy->isFPOrFPVectorTy(),
- "SIToFP result must be FP or FP vector", &I);
+ Assert(SrcVec == DstVec,
+ "SIToFP source and dest must both be vector or scalar", &I);
+ Assert(SrcTy->isIntOrIntVectorTy(),
+ "SIToFP source must be integer or integer vector", &I);
+ Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
+ &I);
if (SrcVec && DstVec)
- Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
- cast<VectorType>(DestTy)->getNumElements(),
- "SIToFP source and dest vector length mismatch", &I);
+ Assert(cast<VectorType>(SrcTy)->getNumElements() ==
+ cast<VectorType>(DestTy)->getNumElements(),
+ "SIToFP source and dest vector length mismatch", &I);
visitInstruction(I);
}
@@ -1649,17 +1659,17 @@ void Verifier::visitFPToUIInst(FPToUIInst &I) {
bool SrcVec = SrcTy->isVectorTy();
bool DstVec = DestTy->isVectorTy();
- Assert1(SrcVec == DstVec,
- "FPToUI source and dest must both be vector or scalar", &I);
- Assert1(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
- &I);
- Assert1(DestTy->isIntOrIntVectorTy(),
- "FPToUI result must be integer or integer vector", &I);
+ Assert(SrcVec == DstVec,
+ "FPToUI source and dest must both be vector or scalar", &I);
+ Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
+ &I);
+ Assert(DestTy->isIntOrIntVectorTy(),
+ "FPToUI result must be integer or integer vector", &I);
if (SrcVec && DstVec)
- Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
- cast<VectorType>(DestTy)->getNumElements(),
- "FPToUI source and dest vector length mismatch", &I);
+ Assert(cast<VectorType>(SrcTy)->getNumElements() ==
+ cast<VectorType>(DestTy)->getNumElements(),
+ "FPToUI source and dest vector length mismatch", &I);
visitInstruction(I);
}
@@ -1672,17 +1682,17 @@ void Verifier::visitFPToSIInst(FPToSIInst &I) {
bool SrcVec = SrcTy->isVectorTy();
bool DstVec = DestTy->isVectorTy();
- Assert1(SrcVec == DstVec,
- "FPToSI source and dest must both be vector or scalar", &I);
- Assert1(SrcTy->isFPOrFPVectorTy(),
- "FPToSI source must be FP or FP vector", &I);
- Assert1(DestTy->isIntOrIntVectorTy(),
- "FPToSI result must be integer or integer vector", &I);
+ Assert(SrcVec == DstVec,
+ "FPToSI source and dest must both be vector or scalar", &I);
+ Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",
+ &I);
+ Assert(DestTy->isIntOrIntVectorTy(),
+ "FPToSI result must be integer or integer vector", &I);
if (SrcVec && DstVec)
- Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
- cast<VectorType>(DestTy)->getNumElements(),
- "FPToSI source and dest vector length mismatch", &I);
+ Assert(cast<VectorType>(SrcTy)->getNumElements() ==
+ cast<VectorType>(DestTy)->getNumElements(),
+ "FPToSI source and dest vector length mismatch", &I);
visitInstruction(I);
}
@@ -1692,18 +1702,18 @@ void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
Type *SrcTy = I.getOperand(0)->getType();
Type *DestTy = I.getType();
- Assert1(SrcTy->getScalarType()->isPointerTy(),
- "PtrToInt source must be pointer", &I);
- Assert1(DestTy->getScalarType()->isIntegerTy(),
- "PtrToInt result must be integral", &I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "PtrToInt type mismatch", &I);
+ Assert(SrcTy->getScalarType()->isPointerTy(),
+ "PtrToInt source must be pointer", &I);
+ Assert(DestTy->getScalarType()->isIntegerTy(),
+ "PtrToInt result must be integral", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
+ &I);
if (SrcTy->isVectorTy()) {
VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
VectorType *VDest = dyn_cast<VectorType>(DestTy);
- Assert1(VSrc->getNumElements() == VDest->getNumElements(),
- "PtrToInt Vector width mismatch", &I);
+ Assert(VSrc->getNumElements() == VDest->getNumElements(),
+ "PtrToInt Vector width mismatch", &I);
}
visitInstruction(I);
@@ -1714,23 +1724,23 @@ void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
Type *SrcTy = I.getOperand(0)->getType();
Type *DestTy = I.getType();
- Assert1(SrcTy->getScalarType()->isIntegerTy(),
- "IntToPtr source must be an integral", &I);
- Assert1(DestTy->getScalarType()->isPointerTy(),
- "IntToPtr result must be a pointer",&I);
- Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
- "IntToPtr type mismatch", &I);
+ Assert(SrcTy->getScalarType()->isIntegerTy(),
+ "IntToPtr source must be an integral", &I);
+ Assert(DestTy->getScalarType()->isPointerTy(),
+ "IntToPtr result must be a pointer", &I);
+ Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
+ &I);
if (SrcTy->isVectorTy()) {
VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
VectorType *VDest = dyn_cast<VectorType>(DestTy);
- Assert1(VSrc->getNumElements() == VDest->getNumElements(),
- "IntToPtr Vector width mismatch", &I);
+ Assert(VSrc->getNumElements() == VDest->getNumElements(),
+ "IntToPtr Vector width mismatch", &I);
}
visitInstruction(I);
}
void Verifier::visitBitCastInst(BitCastInst &I) {
- Assert1(
+ Assert(
CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
"Invalid bitcast", &I);
visitInstruction(I);
@@ -1740,15 +1750,15 @@ void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
Type *SrcTy = I.getOperand(0)->getType();
Type *DestTy = I.getType();
- Assert1(SrcTy->isPtrOrPtrVectorTy(),
- "AddrSpaceCast source must be a pointer", &I);
- Assert1(DestTy->isPtrOrPtrVectorTy(),
- "AddrSpaceCast result must be a pointer", &I);
- Assert1(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
- "AddrSpaceCast must be between different address spaces", &I);
+ Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
+ &I);
+ Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
+ &I);
+ Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
+ "AddrSpaceCast must be between different address spaces", &I);
if (SrcTy->isVectorTy())
- Assert1(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(),
- "AddrSpaceCast vector pointer number of elements mismatch", &I);
+ Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(),
+ "AddrSpaceCast vector pointer number of elements mismatch", &I);
visitInstruction(I);
}
@@ -1759,16 +1769,15 @@ void Verifier::visitPHINode(PHINode &PN) {
// This can be tested by checking whether the instruction before this is
// either nonexistent (because this is begin()) or is a PHI node. If not,
// then there is some other instruction before a PHI.
- Assert2(&PN == &PN.getParent()->front() ||
- isa<PHINode>(--BasicBlock::iterator(&PN)),
- "PHI nodes not grouped at top of basic block!",
- &PN, PN.getParent());
+ Assert(&PN == &PN.getParent()->front() ||
+ isa<PHINode>(--BasicBlock::iterator(&PN)),
+ "PHI nodes not grouped at top of basic block!", &PN, PN.getParent());
// Check that all of the values of the PHI node have the same type as the
// result, and that the incoming blocks are really basic blocks.
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
- Assert1(PN.getType() == PN.getIncomingValue(i)->getType(),
- "PHI node operands are not the same type as the result!", &PN);
+ Assert(PN.getType() == PN.getIncomingValue(i)->getType(),
+ "PHI node operands are not the same type as the result!", &PN);
}
// All other PHI node constraints are checked in the visitBasicBlock method.
@@ -1779,32 +1788,32 @@ void Verifier::visitPHINode(PHINode &PN) {
void Verifier::VerifyCallSite(CallSite CS) {
Instruction *I = CS.getInstruction();
- Assert1(CS.getCalledValue()->getType()->isPointerTy(),
- "Called function must be a pointer!", I);
+ Assert(CS.getCalledValue()->getType()->isPointerTy(),
+ "Called function must be a pointer!", I);
PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType());
- Assert1(FPTy->getElementType()->isFunctionTy(),
- "Called function is not pointer to function type!", I);
+ Assert(FPTy->getElementType()->isFunctionTy(),
+ "Called function is not pointer to function type!", I);
FunctionType *FTy = cast<FunctionType>(FPTy->getElementType());
// Verify that the correct number of arguments are being passed
if (FTy->isVarArg())
- Assert1(CS.arg_size() >= FTy->getNumParams(),
- "Called function requires more parameters than were provided!",I);
+ Assert(CS.arg_size() >= FTy->getNumParams(),
+ "Called function requires more parameters than were provided!", I);
else
- Assert1(CS.arg_size() == FTy->getNumParams(),
- "Incorrect number of arguments passed to called function!", I);
+ Assert(CS.arg_size() == FTy->getNumParams(),
+ "Incorrect number of arguments passed to called function!", I);
// Verify that all arguments to the call match the function type.
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
- Assert3(CS.getArgument(i)->getType() == FTy->getParamType(i),
- "Call parameter type does not match function signature!",
- CS.getArgument(i), FTy->getParamType(i), I);
+ Assert(CS.getArgument(i)->getType() == FTy->getParamType(i),
+ "Call parameter type does not match function signature!",
+ CS.getArgument(i), FTy->getParamType(i), I);
AttributeSet Attrs = CS.getAttributes();
- Assert1(VerifyAttributeCount(Attrs, CS.arg_size()),
- "Attribute after last parameter!", I);
+ Assert(VerifyAttributeCount(Attrs, CS.arg_size()),
+ "Attribute after last parameter!", I);
// Verify call attributes.
VerifyFunctionAttrs(FTy, Attrs, I);
@@ -1815,8 +1824,8 @@ void Verifier::VerifyCallSite(CallSite CS) {
if (CS.hasInAllocaArgument()) {
Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1);
if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
- Assert2(AI->isUsedWithInAlloca(),
- "inalloca argument for call has mismatched alloca", AI, I);
+ Assert(AI->isUsedWithInAlloca(),
+ "inalloca argument for call has mismatched alloca", AI, I);
}
if (FTy->isVarArg()) {
@@ -1837,25 +1846,25 @@ void Verifier::VerifyCallSite(CallSite CS) {
VerifyParameterAttrs(Attrs, Idx, Ty, false, I);
if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
- Assert1(!SawNest, "More than one parameter has attribute nest!", I);
+ Assert(!SawNest, "More than one parameter has attribute nest!", I);
SawNest = true;
}
if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
- Assert1(!SawReturned, "More than one parameter has attribute returned!",
- I);
- Assert1(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
- "Incompatible argument and return types for 'returned' "
- "attribute", I);
+ Assert(!SawReturned, "More than one parameter has attribute returned!",
+ I);
+ Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
+ "Incompatible argument and return types for 'returned' "
+ "attribute",
+ I);
SawReturned = true;
}
- Assert1(!Attrs.hasAttribute(Idx, Attribute::StructRet),
- "Attribute 'sret' cannot be used for vararg call arguments!", I);
+ Assert(!Attrs.hasAttribute(Idx, Attribute::StructRet),
+ "Attribute 'sret' cannot be used for vararg call arguments!", I);
if (Attrs.hasAttribute(Idx, Attribute::InAlloca))
- Assert1(Idx == CS.arg_size(), "inalloca isn't on the last argument!",
- I);
+ Assert(Idx == CS.arg_size(), "inalloca isn't on the last argument!", I);
}
}
@@ -1864,8 +1873,8 @@ void Verifier::VerifyCallSite(CallSite CS) {
!CS.getCalledFunction()->getName().startswith("llvm.")) {
for (FunctionType::param_iterator PI = FTy->param_begin(),
PE = FTy->param_end(); PI != PE; ++PI)
- Assert1(!(*PI)->isMetadataTy(),
- "Function has metadata parameter but isn't an intrinsic", I);
+ Assert(!(*PI)->isMetadataTy(),
+ "Function has metadata parameter but isn't an intrinsic", I);
}
visitInstruction(*I);
@@ -1898,7 +1907,7 @@ static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs) {
}
void Verifier::verifyMustTailCall(CallInst &CI) {
- Assert1(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
+ Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
// - The caller and callee prototypes must match. Pointer types of
// parameters or return types may differ in pointee type, but not
@@ -1910,21 +1919,21 @@ void Verifier::verifyMustTailCall(CallInst &CI) {
};
FunctionType *CallerTy = GetFnTy(F);
FunctionType *CalleeTy = GetFnTy(CI.getCalledValue());
- Assert1(CallerTy->getNumParams() == CalleeTy->getNumParams(),
- "cannot guarantee tail call due to mismatched parameter counts", &CI);
- Assert1(CallerTy->isVarArg() == CalleeTy->isVarArg(),
- "cannot guarantee tail call due to mismatched varargs", &CI);
- Assert1(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
- "cannot guarantee tail call due to mismatched return types", &CI);
+ Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
+ "cannot guarantee tail call due to mismatched parameter counts", &CI);
+ Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),
+ "cannot guarantee tail call due to mismatched varargs", &CI);
+ Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
+ "cannot guarantee tail call due to mismatched return types", &CI);
for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
- Assert1(
+ Assert(
isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),
"cannot guarantee tail call due to mismatched parameter types", &CI);
}
// - The calling conventions of the caller and callee must match.
- Assert1(F->getCallingConv() == CI.getCallingConv(),
- "cannot guarantee tail call due to mismatched calling conv", &CI);
+ Assert(F->getCallingConv() == CI.getCallingConv(),
+ "cannot guarantee tail call due to mismatched calling conv", &CI);
// - All ABI-impacting function attributes, such as sret, byval, inreg,
// returned, and inalloca, must match.
@@ -1933,9 +1942,10 @@ void Verifier::verifyMustTailCall(CallInst &CI) {
for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
- Assert2(CallerABIAttrs == CalleeABIAttrs,
- "cannot guarantee tail call due to mismatched ABI impacting "
- "function attributes", &CI, CI.getOperand(I));
+ Assert(CallerABIAttrs == CalleeABIAttrs,
+ "cannot guarantee tail call due to mismatched ABI impacting "
+ "function attributes",
+ &CI, CI.getOperand(I));
}
// - The call must immediately precede a :ref:`ret <i_ret>` instruction,
@@ -1947,18 +1957,18 @@ void Verifier::verifyMustTailCall(CallInst &CI) {
// Handle the optional bitcast.
if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
- Assert1(BI->getOperand(0) == RetVal,
- "bitcast following musttail call must use the call", BI);
+ Assert(BI->getOperand(0) == RetVal,
+ "bitcast following musttail call must use the call", BI);
RetVal = BI;
Next = BI->getNextNode();
}
// Check the return.
ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
- Assert1(Ret, "musttail call must be precede a ret with an optional bitcast",
- &CI);
- Assert1(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal,
- "musttail call result must be returned", Ret);
+ Assert(Ret, "musttail call must be precede a ret with an optional bitcast",
+ &CI);
+ Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal,
+ "musttail call result must be returned", Ret);
}
void Verifier::visitCallInst(CallInst &CI) {
@@ -1977,8 +1987,8 @@ void Verifier::visitInvokeInst(InvokeInst &II) {
// Verify that there is a landingpad instruction as the first non-PHI
// instruction of the 'unwind' destination.
- Assert1(II.getUnwindDest()->isLandingPad(),
- "The unwind destination does not have a landingpad instruction!",&II);
+ Assert(II.getUnwindDest()->isLandingPad(),
+ "The unwind destination does not have a landingpad instruction!", &II);
if (Function *F = II.getCalledFunction())
// TODO: Ideally we should use visitIntrinsicFunction here. But it uses
@@ -1994,8 +2004,8 @@ void Verifier::visitInvokeInst(InvokeInst &II) {
/// of the same type!
///
void Verifier::visitBinaryOperator(BinaryOperator &B) {
- Assert1(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
- "Both operands to a binary operator are not of the same type!", &B);
+ Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
+ "Both operands to a binary operator are not of the same type!", &B);
switch (B.getOpcode()) {
// Check that integer arithmetic operators are only used with
@@ -2007,11 +2017,12 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) {
case Instruction::UDiv:
case Instruction::SRem:
case Instruction::URem:
- Assert1(B.getType()->isIntOrIntVectorTy(),
- "Integer arithmetic operators only work with integral types!", &B);
- Assert1(B.getType() == B.getOperand(0)->getType(),
- "Integer arithmetic operators must have same type "
- "for operands and result!", &B);
+ Assert(B.getType()->isIntOrIntVectorTy(),
+ "Integer arithmetic operators only work with integral types!", &B);
+ Assert(B.getType() == B.getOperand(0)->getType(),
+ "Integer arithmetic operators must have same type "
+ "for operands and result!",
+ &B);
break;
// Check that floating-point arithmetic operators are only used with
// floating-point operands.
@@ -2020,30 +2031,32 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) {
case Instruction::FMul:
case Instruction::FDiv:
case Instruction::FRem:
- Assert1(B.getType()->isFPOrFPVectorTy(),
- "Floating-point arithmetic operators only work with "
- "floating-point types!", &B);
- Assert1(B.getType() == B.getOperand(0)->getType(),
- "Floating-point arithmetic operators must have same type "
- "for operands and result!", &B);
+ Assert(B.getType()->isFPOrFPVectorTy(),
+ "Floating-point arithmetic operators only work with "
+ "floating-point types!",
+ &B);
+ Assert(B.getType() == B.getOperand(0)->getType(),
+ "Floating-point arithmetic operators must have same type "
+ "for operands and result!",
+ &B);
break;
// Check that logical operators are only used with integral operands.
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
- Assert1(B.getType()->isIntOrIntVectorTy(),
- "Logical operators only work with integral types!", &B);
- Assert1(B.getType() == B.getOperand(0)->getType(),
- "Logical operators must have same type for operands and result!",
- &B);
+ Assert(B.getType()->isIntOrIntVectorTy(),
+ "Logical operators only work with integral types!", &B);
+ Assert(B.getType() == B.getOperand(0)->getType(),
+ "Logical operators must have same type for operands and result!",
+ &B);
break;
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:
- Assert1(B.getType()->isIntOrIntVectorTy(),
- "Shifts only work with integral types!", &B);
- Assert1(B.getType() == B.getOperand(0)->getType(),
- "Shift return type must be same as operands!", &B);
+ Assert(B.getType()->isIntOrIntVectorTy(),
+ "Shifts only work with integral types!", &B);
+ Assert(B.getType() == B.getOperand(0)->getType(),
+ "Shift return type must be same as operands!", &B);
break;
default:
llvm_unreachable("Unknown BinaryOperator opcode!");
@@ -2056,15 +2069,15 @@ void Verifier::visitICmpInst(ICmpInst &IC) {
// Check that the operands are the same type
Type *Op0Ty = IC.getOperand(0)->getType();
Type *Op1Ty = IC.getOperand(1)->getType();
- Assert1(Op0Ty == Op1Ty,
- "Both operands to ICmp instruction are not of the same type!", &IC);
+ Assert(Op0Ty == Op1Ty,
+ "Both operands to ICmp instruction are not of the same type!", &IC);
// Check that the operands are the right type
- Assert1(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(),
- "Invalid operand types for ICmp instruction", &IC);
+ Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(),
+ "Invalid operand types for ICmp instruction", &IC);
// Check that the predicate is valid.
- Assert1(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
- IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE,
- "Invalid predicate in ICmp instruction!", &IC);
+ Assert(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
+ IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE,
+ "Invalid predicate in ICmp instruction!", &IC);
visitInstruction(IC);
}
@@ -2073,72 +2086,72 @@ void Verifier::visitFCmpInst(FCmpInst &FC) {
// Check that the operands are the same type
Type *Op0Ty = FC.getOperand(0)->getType();
Type *Op1Ty = FC.getOperand(1)->getType();
- Assert1(Op0Ty == Op1Ty,
- "Both operands to FCmp instruction are not of the same type!", &FC);
+ Assert(Op0Ty == Op1Ty,
+ "Both operands to FCmp instruction are not of the same type!", &FC);
// Check that the operands are the right type
- Assert1(Op0Ty->isFPOrFPVectorTy(),
- "Invalid operand types for FCmp instruction", &FC);
+ Assert(Op0Ty->isFPOrFPVectorTy(),
+ "Invalid operand types for FCmp instruction", &FC);
// Check that the predicate is valid.
- Assert1(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE &&
- FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE,
- "Invalid predicate in FCmp instruction!", &FC);
+ Assert(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE &&
+ FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE,
+ "Invalid predicate in FCmp instruction!", &FC);
visitInstruction(FC);
}
void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
- Assert1(ExtractElementInst::isValidOperands(EI.getOperand(0),
- EI.getOperand(1)),
- "Invalid extractelement operands!", &EI);
+ Assert(
+ ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
+ "Invalid extractelement operands!", &EI);
visitInstruction(EI);
}
void Verifier::visitInsertElementInst(InsertElementInst &IE) {
- Assert1(InsertElementInst::isValidOperands(IE.getOperand(0),
- IE.getOperand(1),
- IE.getOperand(2)),
- "Invalid insertelement operands!", &IE);
+ Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
+ IE.getOperand(2)),
+ "Invalid insertelement operands!", &IE);
visitInstruction(IE);
}
void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
- Assert1(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
- SV.getOperand(2)),
- "Invalid shufflevector operands!", &SV);
+ Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
+ SV.getOperand(2)),
+ "Invalid shufflevector operands!", &SV);
visitInstruction(SV);
}
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
- Assert1(isa<PointerType>(TargetTy),
- "GEP base pointer is not a vector or a vector of pointers", &GEP);
- Assert1(cast<PointerType>(TargetTy)->getElementType()->isSized(),
- "GEP into unsized type!", &GEP);
- Assert1(GEP.getPointerOperandType()->isVectorTy() ==
- GEP.getType()->isVectorTy(), "Vector GEP must return a vector value",
- &GEP);
+ Assert(isa<PointerType>(TargetTy),
+ "GEP base pointer is not a vector or a vector of pointers", &GEP);
+ Assert(cast<PointerType>(TargetTy)->getElementType()->isSized(),
+ "GEP into unsized type!", &GEP);
+ Assert(GEP.getPointerOperandType()->isVectorTy() ==
+ GEP.getType()->isVectorTy(),
+ "Vector GEP must return a vector value", &GEP);
SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
Type *ElTy =
GetElementPtrInst::getIndexedType(GEP.getPointerOperandType(), Idxs);
- Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
+ Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP);
- Assert2(GEP.getType()->getScalarType()->isPointerTy() &&
- cast<PointerType>(GEP.getType()->getScalarType())->getElementType()
- == ElTy, "GEP is not of right type for indices!", &GEP, ElTy);
+ Assert(GEP.getType()->getScalarType()->isPointerTy() &&
+ cast<PointerType>(GEP.getType()->getScalarType())
+ ->getElementType() == ElTy,
+ "GEP is not of right type for indices!", &GEP, ElTy);
if (GEP.getPointerOperandType()->isVectorTy()) {
// Additional checks for vector GEPs.
unsigned GepWidth = GEP.getPointerOperandType()->getVectorNumElements();
- Assert1(GepWidth == GEP.getType()->getVectorNumElements(),
- "Vector GEP result width doesn't match operand's", &GEP);
+ Assert(GepWidth == GEP.getType()->getVectorNumElements(),
+ "Vector GEP result width doesn't match operand's", &GEP);
for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
Type *IndexTy = Idxs[i]->getType();
- Assert1(IndexTy->isVectorTy(),
- "Vector GEP must have vector indices!", &GEP);
+ Assert(IndexTy->isVectorTy(), "Vector GEP must have vector indices!",
+ &GEP);
unsigned IndexWidth = IndexTy->getVectorNumElements();
- Assert1(IndexWidth == GepWidth, "Invalid GEP index vector width", &GEP);
+ Assert(IndexWidth == GepWidth, "Invalid GEP index vector width", &GEP);
}
}
visitInstruction(GEP);
@@ -2155,34 +2168,33 @@ void Verifier::visitRangeMetadata(Instruction& I,
"precondition violation");
unsigned NumOperands = Range->getNumOperands();
- Assert1(NumOperands % 2 == 0, "Unfinished range!", Range);
+ Assert(NumOperands % 2 == 0, "Unfinished range!", Range);
unsigned NumRanges = NumOperands / 2;
- Assert1(NumRanges >= 1, "It should have at least one range!", Range);
-
+ Assert(NumRanges >= 1, "It should have at least one range!", Range);
+
ConstantRange LastRange(1); // Dummy initial value
for (unsigned i = 0; i < NumRanges; ++i) {
ConstantInt *Low =
mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
- Assert1(Low, "The lower limit must be an integer!", Low);
+ Assert(Low, "The lower limit must be an integer!", Low);
ConstantInt *High =
mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
- Assert1(High, "The upper limit must be an integer!", High);
- Assert1(High->getType() == Low->getType() &&
- High->getType() == Ty, "Range types must match instruction type!",
- &I);
-
+ Assert(High, "The upper limit must be an integer!", High);
+ Assert(High->getType() == Low->getType() && High->getType() == Ty,
+ "Range types must match instruction type!", &I);
+
APInt HighV = High->getValue();
APInt LowV = Low->getValue();
ConstantRange CurRange(LowV, HighV);
- Assert1(!CurRange.isEmptySet() && !CurRange.isFullSet(),
- "Range must not be empty!", Range);
+ Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),
+ "Range must not be empty!", Range);
if (i != 0) {
- Assert1(CurRange.intersectWith(LastRange).isEmptySet(),
- "Intervals are overlapping", Range);
- Assert1(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
- Range);
- Assert1(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
- Range);
+ Assert(CurRange.intersectWith(LastRange).isEmptySet(),
+ "Intervals are overlapping", Range);
+ Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
+ Range);
+ Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
+ Range);
}
LastRange = ConstantRange(LowV, HighV);
}
@@ -2192,38 +2204,37 @@ void Verifier::visitRangeMetadata(Instruction& I,
APInt FirstHigh =
mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
ConstantRange FirstRange(FirstLow, FirstHigh);
- Assert1(FirstRange.intersectWith(LastRange).isEmptySet(),
- "Intervals are overlapping", Range);
- Assert1(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
- Range);
+ Assert(FirstRange.intersectWith(LastRange).isEmptySet(),
+ "Intervals are overlapping", Range);
+ Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
+ Range);
}
}
void Verifier::visitLoadInst(LoadInst &LI) {
PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
- Assert1(PTy, "Load operand must be a pointer.", &LI);
+ Assert(PTy, "Load operand must be a pointer.", &LI);
Type *ElTy = PTy->getElementType();
- Assert2(ElTy == LI.getType(),
- "Load result type does not match pointer operand type!", &LI, ElTy);
- Assert1(LI.getAlignment() <= Value::MaximumAlignment,
- "huge alignment values are unsupported", &LI);
+ Assert(ElTy == LI.getType(),
+ "Load result type does not match pointer operand type!", &LI, ElTy);
+ Assert(LI.getAlignment() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &LI);
if (LI.isAtomic()) {
- Assert1(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease,
- "Load cannot have Release ordering", &LI);
- Assert1(LI.getAlignment() != 0,
- "Atomic load must specify explicit alignment", &LI);
+ Assert(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease,
+ "Load cannot have Release ordering", &LI);
+ Assert(LI.getAlignment() != 0,
+ "Atomic load must specify explicit alignment", &LI);
if (!ElTy->isPointerTy()) {
- Assert2(ElTy->isIntegerTy(),
- "atomic load operand must have integer type!",
- &LI, ElTy);
+ Assert(ElTy->isIntegerTy(), "atomic load operand must have integer type!",
+ &LI, ElTy);
unsigned Size = ElTy->getPrimitiveSizeInBits();
- Assert2(Size >= 8 && !(Size & (Size - 1)),
- "atomic load operand must be power-of-two byte-sized integer",
- &LI, ElTy);
+ Assert(Size >= 8 && !(Size & (Size - 1)),
+ "atomic load operand must be power-of-two byte-sized integer", &LI,
+ ElTy);
}
} else {
- Assert1(LI.getSynchScope() == CrossThread,
- "Non-atomic load cannot have SynchronizationScope specified", &LI);
+ Assert(LI.getSynchScope() == CrossThread,
+ "Non-atomic load cannot have SynchronizationScope specified", &LI);
}
visitInstruction(LI);
@@ -2231,30 +2242,28 @@ void Verifier::visitLoadInst(LoadInst &LI) {
void Verifier::visitStoreInst(StoreInst &SI) {
PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
- Assert1(PTy, "Store operand must be a pointer.", &SI);
+ Assert(PTy, "Store operand must be a pointer.", &SI);
Type *ElTy = PTy->getElementType();
- Assert2(ElTy == SI.getOperand(0)->getType(),
- "Stored value type does not match pointer operand type!",
- &SI, ElTy);
- Assert1(SI.getAlignment() <= Value::MaximumAlignment,
- "huge alignment values are unsupported", &SI);
+ Assert(ElTy == SI.getOperand(0)->getType(),
+ "Stored value type does not match pointer operand type!", &SI, ElTy);
+ Assert(SI.getAlignment() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &SI);
if (SI.isAtomic()) {
- Assert1(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease,
- "Store cannot have Acquire ordering", &SI);
- Assert1(SI.getAlignment() != 0,
- "Atomic store must specify explicit alignment", &SI);
+ Assert(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease,
+ "Store cannot have Acquire ordering", &SI);
+ Assert(SI.getAlignment() != 0,
+ "Atomic store must specify explicit alignment", &SI);
if (!ElTy->isPointerTy()) {
- Assert2(ElTy->isIntegerTy(),
- "atomic store operand must have integer type!",
- &SI, ElTy);
+ Assert(ElTy->isIntegerTy(),
+ "atomic store operand must have integer type!", &SI, ElTy);
unsigned Size = ElTy->getPrimitiveSizeInBits();
- Assert2(Size >= 8 && !(Size & (Size - 1)),
- "atomic store operand must be power-of-two byte-sized integer",
- &SI, ElTy);
+ Assert(Size >= 8 && !(Size & (Size - 1)),
+ "atomic store operand must be power-of-two byte-sized integer",
+ &SI, ElTy);
}
} else {
- Assert1(SI.getSynchScope() == CrossThread,
- "Non-atomic store cannot have SynchronizationScope specified", &SI);
+ Assert(SI.getSynchScope() == CrossThread,
+ "Non-atomic store cannot have SynchronizationScope specified", &SI);
}
visitInstruction(SI);
}
@@ -2262,15 +2271,15 @@ void Verifier::visitStoreInst(StoreInst &SI) {
void Verifier::visitAllocaInst(AllocaInst &AI) {
SmallPtrSet<const Type*, 4> Visited;
PointerType *PTy = AI.getType();
- Assert1(PTy->getAddressSpace() == 0,
- "Allocation instruction pointer not in the generic address space!",
- &AI);
- Assert1(PTy->getElementType()->isSized(&Visited), "Cannot allocate unsized type",
- &AI);
- Assert1(AI.getArraySize()->getType()->isIntegerTy(),
- "Alloca array size must have integer type", &AI);
- Assert1(AI.getAlignment() <= Value::MaximumAlignment,
- "huge alignment values are unsupported", &AI);
+ Assert(PTy->getAddressSpace() == 0,
+ "Allocation instruction pointer not in the generic address space!",
+ &AI);
+ Assert(PTy->getElementType()->isSized(&Visited),
+ "Cannot allocate unsized type", &AI);
+ Assert(AI.getArraySize()->getType()->isIntegerTy(),
+ "Alloca array size must have integer type", &AI);
+ Assert(AI.getAlignment() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &AI);
visitInstruction(AI);
}
@@ -2278,87 +2287,83 @@ void Verifier::visitAllocaInst(AllocaInst &AI) {
void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
// FIXME: more conditions???
- Assert1(CXI.getSuccessOrdering() != NotAtomic,
- "cmpxchg instructions must be atomic.", &CXI);
- Assert1(CXI.getFailureOrdering() != NotAtomic,
- "cmpxchg instructions must be atomic.", &CXI);
- Assert1(CXI.getSuccessOrdering() != Unordered,
- "cmpxchg instructions cannot be unordered.", &CXI);
- Assert1(CXI.getFailureOrdering() != Unordered,
- "cmpxchg instructions cannot be unordered.", &CXI);
- Assert1(CXI.getSuccessOrdering() >= CXI.getFailureOrdering(),
- "cmpxchg instructions be at least as constrained on success as fail",
- &CXI);
- Assert1(CXI.getFailureOrdering() != Release &&
- CXI.getFailureOrdering() != AcquireRelease,
- "cmpxchg failure ordering cannot include release semantics", &CXI);
+ Assert(CXI.getSuccessOrdering() != NotAtomic,
+ "cmpxchg instructions must be atomic.", &CXI);
+ Assert(CXI.getFailureOrdering() != NotAtomic,
+ "cmpxchg instructions must be atomic.", &CXI);
+ Assert(CXI.getSuccessOrdering() != Unordered,
+ "cmpxchg instructions cannot be unordered.", &CXI);
+ Assert(CXI.getFailureOrdering() != Unordered,
+ "cmpxchg instructions cannot be unordered.", &CXI);
+ Assert(CXI.getSuccessOrdering() >= CXI.getFailureOrdering(),
+ "cmpxchg instructions be at least as constrained on success as fail",
+ &CXI);
+ Assert(CXI.getFailureOrdering() != Release &&
+ CXI.getFailureOrdering() != AcquireRelease,
+ "cmpxchg failure ordering cannot include release semantics", &CXI);
PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
- Assert1(PTy, "First cmpxchg operand must be a pointer.", &CXI);
+ Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI);
Type *ElTy = PTy->getElementType();
- Assert2(ElTy->isIntegerTy(),
- "cmpxchg operand must have integer type!",
- &CXI, ElTy);
+ Assert(ElTy->isIntegerTy(), "cmpxchg operand must have integer type!", &CXI,
+ ElTy);
unsigned Size = ElTy->getPrimitiveSizeInBits();
- Assert2(Size >= 8 && !(Size & (Size - 1)),
- "cmpxchg operand must be power-of-two byte-sized integer",
- &CXI, ElTy);
- Assert2(ElTy == CXI.getOperand(1)->getType(),
- "Expected value type does not match pointer operand type!",
- &CXI, ElTy);
- Assert2(ElTy == CXI.getOperand(2)->getType(),
- "Stored value type does not match pointer operand type!",
- &CXI, ElTy);
+ Assert(Size >= 8 && !(Size & (Size - 1)),
+ "cmpxchg operand must be power-of-two byte-sized integer", &CXI, ElTy);
+ Assert(ElTy == CXI.getOperand(1)->getType(),
+ "Expected value type does not match pointer operand type!", &CXI,
+ ElTy);
+ Assert(ElTy == CXI.getOperand(2)->getType(),
+ "Stored value type does not match pointer operand type!", &CXI, ElTy);
visitInstruction(CXI);
}
void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
- Assert1(RMWI.getOrdering() != NotAtomic,
- "atomicrmw instructions must be atomic.", &RMWI);
- Assert1(RMWI.getOrdering() != Unordered,
- "atomicrmw instructions cannot be unordered.", &RMWI);
+ Assert(RMWI.getOrdering() != NotAtomic,
+ "atomicrmw instructions must be atomic.", &RMWI);
+ Assert(RMWI.getOrdering() != Unordered,
+ "atomicrmw instructions cannot be unordered.", &RMWI);
PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
- Assert1(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
+ Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
Type *ElTy = PTy->getElementType();
- Assert2(ElTy->isIntegerTy(),
- "atomicrmw operand must have integer type!",
- &RMWI, ElTy);
+ Assert(ElTy->isIntegerTy(), "atomicrmw operand must have integer type!",
+ &RMWI, ElTy);
unsigned Size = ElTy->getPrimitiveSizeInBits();
- Assert2(Size >= 8 && !(Size & (Size - 1)),
- "atomicrmw operand must be power-of-two byte-sized integer",
- &RMWI, ElTy);
- Assert2(ElTy == RMWI.getOperand(1)->getType(),
- "Argument value type does not match pointer operand type!",
- &RMWI, ElTy);
- Assert1(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() &&
- RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP,
- "Invalid binary operation!", &RMWI);
+ Assert(Size >= 8 && !(Size & (Size - 1)),
+ "atomicrmw operand must be power-of-two byte-sized integer", &RMWI,
+ ElTy);
+ Assert(ElTy == RMWI.getOperand(1)->getType(),
+ "Argument value type does not match pointer operand type!", &RMWI,
+ ElTy);
+ Assert(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() &&
+ RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP,
+ "Invalid binary operation!", &RMWI);
visitInstruction(RMWI);
}
void Verifier::visitFenceInst(FenceInst &FI) {
const AtomicOrdering Ordering = FI.getOrdering();
- Assert1(Ordering == Acquire || Ordering == Release ||
- Ordering == AcquireRelease || Ordering == SequentiallyConsistent,
- "fence instructions may only have "
- "acquire, release, acq_rel, or seq_cst ordering.", &FI);
+ Assert(Ordering == Acquire || Ordering == Release ||
+ Ordering == AcquireRelease || Ordering == SequentiallyConsistent,
+ "fence instructions may only have "
+ "acquire, release, acq_rel, or seq_cst ordering.",
+ &FI);
visitInstruction(FI);
}
void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
- Assert1(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
- EVI.getIndices()) ==
- EVI.getType(),
- "Invalid ExtractValueInst operands!", &EVI);
+ Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
+ EVI.getIndices()) == EVI.getType(),
+ "Invalid ExtractValueInst operands!", &EVI);
visitInstruction(EVI);
}
void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
- Assert1(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
- IVI.getIndices()) ==
- IVI.getOperand(1)->getType(),
- "Invalid InsertValueInst operands!", &IVI);
+ Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
+ IVI.getIndices()) ==
+ IVI.getOperand(1)->getType(),
+ "Invalid InsertValueInst operands!", &IVI);
visitInstruction(IVI);
}
@@ -2368,43 +2373,44 @@ void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
// The landingpad instruction is ill-formed if it doesn't have any clauses and
// isn't a cleanup.
- Assert1(LPI.getNumClauses() > 0 || LPI.isCleanup(),
- "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
+ Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
+ "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
// The landingpad instruction defines its parent as a landing pad block. The
// landing pad block may be branched to only by the unwind edge of an invoke.
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator());
- Assert1(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
- "Block containing LandingPadInst must be jumped to "
- "only by the unwind edge of an invoke.", &LPI);
+ Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
+ "Block containing LandingPadInst must be jumped to "
+ "only by the unwind edge of an invoke.",
+ &LPI);
}
// The landingpad instruction must be the first non-PHI instruction in the
// block.
- Assert1(LPI.getParent()->getLandingPadInst() == &LPI,
- "LandingPadInst not the first non-PHI instruction in the block.",
- &LPI);
+ Assert(LPI.getParent()->getLandingPadInst() == &LPI,
+ "LandingPadInst not the first non-PHI instruction in the block.",
+ &LPI);
// The personality functions for all landingpad instructions within the same
// function should match.
if (PersonalityFn)
- Assert1(LPI.getPersonalityFn() == PersonalityFn,
- "Personality function doesn't match others in function", &LPI);
+ Assert(LPI.getPersonalityFn() == PersonalityFn,
+ "Personality function doesn't match others in function", &LPI);
PersonalityFn = LPI.getPersonalityFn();
// All operands must be constants.
- Assert1(isa<Constant>(PersonalityFn), "Personality function is not constant!",
- &LPI);
+ Assert(isa<Constant>(PersonalityFn), "Personality function is not constant!",
+ &LPI);
for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
Constant *Clause = LPI.getClause(i);
if (LPI.isCatch(i)) {
- Assert1(isa<PointerType>(Clause->getType()),
- "Catch operand does not have pointer type!", &LPI);
+ Assert(isa<PointerType>(Clause->getType()),
+ "Catch operand does not have pointer type!", &LPI);
} else {
- Assert1(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
- Assert1(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
- "Filter operand is not an array of constants!", &LPI);
+ Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
+ Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
+ "Filter operand is not an array of constants!", &LPI);
}
}
@@ -2422,46 +2428,46 @@ void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
}
const Use &U = I.getOperandUse(i);
- Assert2(InstsInThisBlock.count(Op) || DT.dominates(Op, U),
- "Instruction does not dominate all uses!", Op, &I);
+ Assert(InstsInThisBlock.count(Op) || DT.dominates(Op, U),
+ "Instruction does not dominate all uses!", Op, &I);
}
/// verifyInstruction - Verify that an instruction is well formed.
///
void Verifier::visitInstruction(Instruction &I) {
BasicBlock *BB = I.getParent();
- Assert1(BB, "Instruction not embedded in basic block!", &I);
+ Assert(BB, "Instruction not embedded in basic block!", &I);
if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential
for (User *U : I.users()) {
- Assert1(U != (User*)&I || !DT.isReachableFromEntry(BB),
- "Only PHI nodes may reference their own value!", &I);
+ Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
+ "Only PHI nodes may reference their own value!", &I);
}
}
// Check that void typed values don't have names
- Assert1(!I.getType()->isVoidTy() || !I.hasName(),
- "Instruction has a name, but provides a void value!", &I);
+ Assert(!I.getType()->isVoidTy() || !I.hasName(),
+ "Instruction has a name, but provides a void value!", &I);
// Check that the return value of the instruction is either void or a legal
// value type.
- Assert1(I.getType()->isVoidTy() ||
- I.getType()->isFirstClassType(),
- "Instruction returns a non-scalar type!", &I);
+ Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
+ "Instruction returns a non-scalar type!", &I);
// Check that the instruction doesn't produce metadata. Calls are already
// checked against the callee type.
- Assert1(!I.getType()->isMetadataTy() ||
- isa<CallInst>(I) || isa<InvokeInst>(I),
- "Invalid use of metadata!", &I);
+ Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
+ "Invalid use of metadata!", &I);
// Check that all uses of the instruction, if they are instructions
// themselves, actually have parent basic blocks. If the use is not an
// instruction, it is an error!
for (Use &U : I.uses()) {
if (Instruction *Used = dyn_cast<Instruction>(U.getUser()))
- Assert2(Used->getParent() != nullptr, "Instruction referencing"
- " instruction not embedded in a basic block!", &I, Used);
+ Assert(Used->getParent() != nullptr,
+ "Instruction referencing"
+ " instruction not embedded in a basic block!",
+ &I, Used);
else {
CheckFailed("Use of instruction is not an instruction!", U);
return;
@@ -2469,44 +2475,46 @@ void Verifier::visitInstruction(Instruction &I) {
}
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
- Assert1(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
+ Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
// Check to make sure that only first-class-values are operands to
// instructions.
if (!I.getOperand(i)->getType()->isFirstClassType()) {
- Assert1(0, "Instruction operands must be first-class values!", &I);
+ Assert(0, "Instruction operands must be first-class values!", &I);
}
if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
// Check to make sure that the "address of" an intrinsic function is never
// taken.
- Assert1(!F->isIntrinsic() || i == (isa<CallInst>(I) ? e-1 :
- isa<InvokeInst>(I) ? e-3 : 0),
- "Cannot take the address of an intrinsic!", &I);
- Assert1(!F->isIntrinsic() || isa<CallInst>(I) ||
+ Assert(
+ !F->isIntrinsic() ||
+ i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0),
+ "Cannot take the address of an intrinsic!", &I);
+ Assert(
+ !F->isIntrinsic() || isa<CallInst>(I) ||
F->getIntrinsicID() == Intrinsic::donothing ||
F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
- "Cannot invoke an intrinsinc other than"
- " donothing or patchpoint", &I);
- Assert1(F->getParent() == M, "Referencing function in another module!",
- &I);
+ "Cannot invoke an intrinsinc other than"
+ " donothing or patchpoint",
+ &I);
+ Assert(F->getParent() == M, "Referencing function in another module!",
+ &I);
} else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
- Assert1(OpBB->getParent() == BB->getParent(),
- "Referring to a basic block in another function!", &I);
+ Assert(OpBB->getParent() == BB->getParent(),
+ "Referring to a basic block in another function!", &I);
} else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
- Assert1(OpArg->getParent() == BB->getParent(),
- "Referring to an argument in another function!", &I);
+ Assert(OpArg->getParent() == BB->getParent(),
+ "Referring to an argument in another function!", &I);
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
- Assert1(GV->getParent() == M, "Referencing global in another module!",
- &I);
+ Assert(GV->getParent() == M, "Referencing global in another module!", &I);
} else if (isa<Instruction>(I.getOperand(i))) {
verifyDominatesUse(I, i);
} else if (isa<InlineAsm>(I.getOperand(i))) {
- Assert1((i + 1 == e && isa<CallInst>(I)) ||
- (i + 3 == e && isa<InvokeInst>(I)),
- "Cannot take the address of an inline asm!", &I);
+ Assert((i + 1 == e && isa<CallInst>(I)) ||
+ (i + 3 == e && isa<InvokeInst>(I)),
+ "Cannot take the address of an inline asm!", &I);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
if (CE->getType()->isPtrOrPtrVectorTy()) {
// If we have a ConstantExpr pointer, we need to see if it came from an
@@ -2532,31 +2540,37 @@ void Verifier::visitInstruction(Instruction &I) {
}
if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
- Assert1(I.getType()->isFPOrFPVectorTy(),
- "fpmath requires a floating point result!", &I);
- Assert1(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
+ Assert(I.getType()->isFPOrFPVectorTy(),
+ "fpmath requires a floating point result!", &I);
+ Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
if (ConstantFP *CFP0 =
mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) {
APFloat Accuracy = CFP0->getValueAPF();
- Assert1(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
- "fpmath accuracy not a positive number!", &I);
+ Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
+ "fpmath accuracy not a positive number!", &I);
} else {
- Assert1(false, "invalid fpmath accuracy!", &I);
+ Assert(false, "invalid fpmath accuracy!", &I);
}
}
if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
- Assert1(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
- "Ranges are only for loads, calls and invokes!", &I);
+ Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
+ "Ranges are only for loads, calls and invokes!", &I);
visitRangeMetadata(I, Range, I.getType());
}
if (I.getMetadata(LLVMContext::MD_nonnull)) {
- Assert1(I.getType()->isPointerTy(),
- "nonnull applies only to pointer types", &I);
- Assert1(isa<LoadInst>(I),
- "nonnull applies only to load instructions, use attributes"
- " for calls or invokes", &I);
+ Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
+ &I);
+ Assert(isa<LoadInst>(I),
+ "nonnull applies only to load instructions, use attributes"
+ " for calls or invokes",
+ &I);
+ }
+
+ if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
+ Assert(isa<MDLocation>(N), "invalid !dbg metadata attachment", &I, N);
+ visitMDNode(*N);
}
InstsInThisBlock.insert(&I);
@@ -2717,7 +2731,7 @@ Verifier::VerifyIntrinsicIsVarArg(bool isVarArg,
// If there are no descriptors left, then it can't be a vararg.
if (Infos.empty())
- return isVarArg ? true : false;
+ return isVarArg;
// There should be only one descriptor remaining at this point.
if (Infos.size() != 1)
@@ -2727,7 +2741,7 @@ Verifier::VerifyIntrinsicIsVarArg(bool isVarArg,
IITDescriptor D = Infos.front();
Infos = Infos.slice(1);
if (D.Kind == IITDescriptor::VarArg)
- return isVarArg ? false : true;
+ return !isVarArg;
return true;
}
@@ -2736,8 +2750,8 @@ Verifier::VerifyIntrinsicIsVarArg(bool isVarArg,
///
void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
Function *IF = CI.getCalledFunction();
- Assert1(IF->isDeclaration(), "Intrinsic functions should never be defined!",
- IF);
+ Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!",
+ IF);
// Verify that the intrinsic prototype lines up with what the .td files
// describe.
@@ -2749,31 +2763,33 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
SmallVector<Type *, 4> ArgTys;
- Assert1(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys),
- "Intrinsic has incorrect return type!", IF);
+ Assert(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys),
+ "Intrinsic has incorrect return type!", IF);
for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i)
- Assert1(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys),
- "Intrinsic has incorrect argument type!", IF);
+ Assert(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys),
+ "Intrinsic has incorrect argument type!", IF);
// Verify if the intrinsic call matches the vararg property.
if (IsVarArg)
- Assert1(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
- "Intrinsic was not defined with variable arguments!", IF);
+ Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
+ "Intrinsic was not defined with variable arguments!", IF);
else
- Assert1(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
- "Callsite was not defined with variable arguments!", IF);
+ Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
+ "Callsite was not defined with variable arguments!", IF);
// All descriptors should be absorbed by now.
- Assert1(TableRef.empty(), "Intrinsic has too few arguments!", IF);
+ Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
// Now that we have the intrinsic ID and the actual argument types (and we
// know they are legal for the intrinsic!) get the intrinsic name through the
// usual means. This allows us to verify the mangling of argument types into
// the name.
const std::string ExpectedName = Intrinsic::getName(ID, ArgTys);
- Assert1(ExpectedName == IF->getName(),
- "Intrinsic name not mangled correctly for type arguments! "
- "Should be: " + ExpectedName, IF);
+ Assert(ExpectedName == IF->getName(),
+ "Intrinsic name not mangled correctly for type arguments! "
+ "Should be: " +
+ ExpectedName,
+ IF);
// If the intrinsic takes MDNode arguments, verify that they are either global
// or are local to *this* function.
@@ -2786,95 +2802,123 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
break;
case Intrinsic::ctlz: // llvm.ctlz
case Intrinsic::cttz: // llvm.cttz
- Assert1(isa<ConstantInt>(CI.getArgOperand(1)),
- "is_zero_undef argument of bit counting intrinsics must be a "
- "constant int", &CI);
+ Assert(isa<ConstantInt>(CI.getArgOperand(1)),
+ "is_zero_undef argument of bit counting intrinsics must be a "
+ "constant int",
+ &CI);
+ break;
+ case Intrinsic::dbg_declare: // llvm.dbg.declare
+ Assert(isa<MetadataAsValue>(CI.getArgOperand(0)),
+ "invalid llvm.dbg.declare intrinsic call 1", &CI);
+ visitDbgIntrinsic("declare", cast<DbgDeclareInst>(CI));
+ break;
+ case Intrinsic::dbg_value: // llvm.dbg.value
+ visitDbgIntrinsic("value", cast<DbgValueInst>(CI));
break;
- case Intrinsic::dbg_declare: { // llvm.dbg.declare
- Assert1(CI.getArgOperand(0) && isa<MetadataAsValue>(CI.getArgOperand(0)),
- "invalid llvm.dbg.declare intrinsic call 1", &CI);
- } break;
case Intrinsic::memcpy:
case Intrinsic::memmove:
- case Intrinsic::memset:
- Assert1(isa<ConstantInt>(CI.getArgOperand(3)),
- "alignment argument of memory intrinsics must be a constant int",
- &CI);
- Assert1(isa<ConstantInt>(CI.getArgOperand(4)),
- "isvolatile argument of memory intrinsics must be a constant int",
- &CI);
+ case Intrinsic::memset: {
+ ConstantInt *AlignCI = dyn_cast<ConstantInt>(CI.getArgOperand(3));
+ Assert(AlignCI,
+ "alignment argument of memory intrinsics must be a constant int",
+ &CI);
+ const APInt &AlignVal = AlignCI->getValue();
+ Assert(AlignCI->isZero() || AlignVal.isPowerOf2(),
+ "alignment argument of memory intrinsics must be a power of 2", &CI);
+ Assert(isa<ConstantInt>(CI.getArgOperand(4)),
+ "isvolatile argument of memory intrinsics must be a constant int",
+ &CI);
break;
+ }
case Intrinsic::gcroot:
case Intrinsic::gcwrite:
case Intrinsic::gcread:
if (ID == Intrinsic::gcroot) {
AllocaInst *AI =
dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts());
- Assert1(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI);
- Assert1(isa<Constant>(CI.getArgOperand(1)),
- "llvm.gcroot parameter #2 must be a constant.", &CI);
+ Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI);
+ Assert(isa<Constant>(CI.getArgOperand(1)),
+ "llvm.gcroot parameter #2 must be a constant.", &CI);
if (!AI->getType()->getElementType()->isPointerTy()) {
- Assert1(!isa<ConstantPointerNull>(CI.getArgOperand(1)),
- "llvm.gcroot parameter #1 must either be a pointer alloca, "
- "or argument #2 must be a non-null constant.", &CI);
+ Assert(!isa<ConstantPointerNull>(CI.getArgOperand(1)),
+ "llvm.gcroot parameter #1 must either be a pointer alloca, "
+ "or argument #2 must be a non-null constant.",
+ &CI);
}
}
- Assert1(CI.getParent()->getParent()->hasGC(),
- "Enclosing function does not use GC.", &CI);
+ Assert(CI.getParent()->getParent()->hasGC(),
+ "Enclosing function does not use GC.", &CI);
break;
case Intrinsic::init_trampoline:
- Assert1(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()),
- "llvm.init_trampoline parameter #2 must resolve to a function.",
- &CI);
+ Assert(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()),
+ "llvm.init_trampoline parameter #2 must resolve to a function.",
+ &CI);
break;
case Intrinsic::prefetch:
- Assert1(isa<ConstantInt>(CI.getArgOperand(1)) &&
- isa<ConstantInt>(CI.getArgOperand(2)) &&
- cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 &&
- cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4,
- "invalid arguments to llvm.prefetch",
- &CI);
+ Assert(isa<ConstantInt>(CI.getArgOperand(1)) &&
+ isa<ConstantInt>(CI.getArgOperand(2)) &&
+ cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 &&
+ cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4,
+ "invalid arguments to llvm.prefetch", &CI);
break;
case Intrinsic::stackprotector:
- Assert1(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()),
- "llvm.stackprotector parameter #2 must resolve to an alloca.",
- &CI);
+ Assert(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()),
+ "llvm.stackprotector parameter #2 must resolve to an alloca.", &CI);
break;
case Intrinsic::lifetime_start:
case Intrinsic::lifetime_end:
case Intrinsic::invariant_start:
- Assert1(isa<ConstantInt>(CI.getArgOperand(0)),
- "size argument of memory use markers must be a constant integer",
- &CI);
+ Assert(isa<ConstantInt>(CI.getArgOperand(0)),
+ "size argument of memory use markers must be a constant integer",
+ &CI);
break;
case Intrinsic::invariant_end:
- Assert1(isa<ConstantInt>(CI.getArgOperand(1)),
- "llvm.invariant.end parameter #2 must be a constant integer", &CI);
+ Assert(isa<ConstantInt>(CI.getArgOperand(1)),
+ "llvm.invariant.end parameter #2 must be a constant integer", &CI);
break;
- case Intrinsic::frameallocate: {
+ case Intrinsic::frameescape: {
BasicBlock *BB = CI.getParent();
- Assert1(BB == &BB->getParent()->front(),
- "llvm.frameallocate used outside of entry block", &CI);
- Assert1(!SawFrameAllocate,
- "multiple calls to llvm.frameallocate in one function", &CI);
- SawFrameAllocate = true;
- Assert1(isa<ConstantInt>(CI.getArgOperand(0)),
- "llvm.frameallocate argument must be constant integer size", &CI);
+ Assert(BB == &BB->getParent()->front(),
+ "llvm.frameescape used outside of entry block", &CI);
+ Assert(!SawFrameEscape,
+ "multiple calls to llvm.frameescape in one function", &CI);
+ for (Value *Arg : CI.arg_operands()) {
+ auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
+ Assert(AI && AI->isStaticAlloca(),
+ "llvm.frameescape only accepts static allocas", &CI);
+ }
+ FrameEscapeInfo[BB->getParent()].first = CI.getNumArgOperands();
+ SawFrameEscape = true;
break;
}
case Intrinsic::framerecover: {
Value *FnArg = CI.getArgOperand(0)->stripPointerCasts();
Function *Fn = dyn_cast<Function>(FnArg);
- Assert1(Fn && !Fn->isDeclaration(), "llvm.framerecover first "
- "argument must be function defined in this module", &CI);
+ Assert(Fn && !Fn->isDeclaration(),
+ "llvm.framerecover first "
+ "argument must be function defined in this module",
+ &CI);
+ auto *IdxArg = dyn_cast<ConstantInt>(CI.getArgOperand(2));
+ Assert(IdxArg, "idx argument of llvm.framerecover must be a constant int",
+ &CI);
+ auto &Entry = FrameEscapeInfo[Fn];
+ Entry.second = unsigned(
+ std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));
+ break;
+ }
+
+ case Intrinsic::eh_unwindhelp: {
+ auto *AI = dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts());
+ Assert(AI && AI->isStaticAlloca(),
+ "llvm.eh.unwindhelp requires a static alloca", &CI);
break;
}
case Intrinsic::experimental_gc_statepoint:
- Assert1(!CI.isInlineAsm(),
- "gc.statepoint support for inline assembly unimplemented", &CI);
+ Assert(!CI.isInlineAsm(),
+ "gc.statepoint support for inline assembly unimplemented", &CI);
VerifyStatepoint(ImmutableCallSite(&CI));
break;
@@ -2886,56 +2930,52 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
CallSite StatepointCS(CI.getArgOperand(0));
const Function *StatepointFn =
StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr;
- Assert2(StatepointFn && StatepointFn->isDeclaration() &&
- StatepointFn->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
- "gc.result operand #1 must be from a statepoint",
- &CI, CI.getArgOperand(0));
+ Assert(StatepointFn && StatepointFn->isDeclaration() &&
+ StatepointFn->getIntrinsicID() ==
+ Intrinsic::experimental_gc_statepoint,
+ "gc.result operand #1 must be from a statepoint", &CI,
+ CI.getArgOperand(0));
// Assert that result type matches wrapped callee.
const Value *Target = StatepointCS.getArgument(0);
const PointerType *PT = cast<PointerType>(Target->getType());
const FunctionType *TargetFuncType =
cast<FunctionType>(PT->getElementType());
- Assert1(CI.getType() == TargetFuncType->getReturnType(),
- "gc.result result type does not match wrapped callee",
- &CI);
+ Assert(CI.getType() == TargetFuncType->getReturnType(),
+ "gc.result result type does not match wrapped callee", &CI);
break;
}
case Intrinsic::experimental_gc_relocate: {
- Assert1(CI.getNumArgOperands() == 3, "wrong number of arguments", &CI);
+ Assert(CI.getNumArgOperands() == 3, "wrong number of arguments", &CI);
// Check that this relocate is correctly tied to the statepoint
// This is case for relocate on the unwinding path of an invoke statepoint
if (ExtractValueInst *ExtractValue =
dyn_cast<ExtractValueInst>(CI.getArgOperand(0))) {
- Assert1(isa<LandingPadInst>(ExtractValue->getAggregateOperand()),
- "gc relocate on unwind path incorrectly linked to the statepoint",
- &CI);
+ Assert(isa<LandingPadInst>(ExtractValue->getAggregateOperand()),
+ "gc relocate on unwind path incorrectly linked to the statepoint",
+ &CI);
const BasicBlock *invokeBB =
ExtractValue->getParent()->getUniquePredecessor();
// Landingpad relocates should have only one predecessor with invoke
// statepoint terminator
- Assert1(invokeBB,
- "safepoints should have unique landingpads",
- ExtractValue->getParent());
- Assert1(invokeBB->getTerminator(),
- "safepoint block should be well formed",
- invokeBB);
- Assert1(isStatepoint(invokeBB->getTerminator()),
- "gc relocate should be linked to a statepoint",
- invokeBB);
+ Assert(invokeBB, "safepoints should have unique landingpads",
+ ExtractValue->getParent());
+ Assert(invokeBB->getTerminator(), "safepoint block should be well formed",
+ invokeBB);
+ Assert(isStatepoint(invokeBB->getTerminator()),
+ "gc relocate should be linked to a statepoint", invokeBB);
}
else {
// In all other cases relocate should be tied to the statepoint directly.
// This covers relocates on a normal return path of invoke statepoint and
// relocates of a call statepoint
auto Token = CI.getArgOperand(0);
- Assert2(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)),
- "gc relocate is incorrectly tied to the statepoint",
- &CI, Token);
+ Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)),
+ "gc relocate is incorrectly tied to the statepoint", &CI, Token);
}
// Verify rest of the relocate arguments
@@ -2945,53 +2985,74 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
// Both the base and derived must be piped through the safepoint
Value* Base = CI.getArgOperand(1);
- Assert1(isa<ConstantInt>(Base),
- "gc.relocate operand #2 must be integer offset", &CI);
-
+ Assert(isa<ConstantInt>(Base),
+ "gc.relocate operand #2 must be integer offset", &CI);
+
Value* Derived = CI.getArgOperand(2);
- Assert1(isa<ConstantInt>(Derived),
- "gc.relocate operand #3 must be integer offset", &CI);
+ Assert(isa<ConstantInt>(Derived),
+ "gc.relocate operand #3 must be integer offset", &CI);
const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue();
const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
// Check the bounds
- Assert1(0 <= BaseIndex &&
- BaseIndex < (int)StatepointCS.arg_size(),
- "gc.relocate: statepoint base index out of bounds", &CI);
- Assert1(0 <= DerivedIndex &&
- DerivedIndex < (int)StatepointCS.arg_size(),
- "gc.relocate: statepoint derived index out of bounds", &CI);
+ Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(),
+ "gc.relocate: statepoint base index out of bounds", &CI);
+ Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(),
+ "gc.relocate: statepoint derived index out of bounds", &CI);
// Check that BaseIndex and DerivedIndex fall within the 'gc parameters'
// section of the statepoint's argument
- const int NumCallArgs =
+ Assert(StatepointCS.arg_size() > 0,
+ "gc.statepoint: insufficient arguments");
+ Assert(isa<ConstantInt>(StatepointCS.getArgument(1)),
+ "gc.statement: number of call arguments must be constant integer");
+ const unsigned NumCallArgs =
cast<ConstantInt>(StatepointCS.getArgument(1))->getZExtValue();
+ Assert(StatepointCS.arg_size() > NumCallArgs+3,
+ "gc.statepoint: mismatch in number of call arguments");
+ Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs+3)),
+ "gc.statepoint: number of deoptimization arguments must be "
+ "a constant integer");
const int NumDeoptArgs =
cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 3))->getZExtValue();
const int GCParamArgsStart = NumCallArgs + NumDeoptArgs + 4;
const int GCParamArgsEnd = StatepointCS.arg_size();
- Assert1(GCParamArgsStart <= BaseIndex &&
- BaseIndex < GCParamArgsEnd,
- "gc.relocate: statepoint base index doesn't fall within the "
- "'gc parameters' section of the statepoint call", &CI);
- Assert1(GCParamArgsStart <= DerivedIndex &&
- DerivedIndex < GCParamArgsEnd,
- "gc.relocate: statepoint derived index doesn't fall within the "
- "'gc parameters' section of the statepoint call", &CI);
-
+ Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,
+ "gc.relocate: statepoint base index doesn't fall within the "
+ "'gc parameters' section of the statepoint call",
+ &CI);
+ Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd,
+ "gc.relocate: statepoint derived index doesn't fall within the "
+ "'gc parameters' section of the statepoint call",
+ &CI);
// Assert that the result type matches the type of the relocated pointer
GCRelocateOperands Operands(&CI);
- Assert1(Operands.derivedPtr()->getType() == CI.getType(),
- "gc.relocate: relocating a pointer shouldn't change its type",
- &CI);
+ Assert(Operands.derivedPtr()->getType() == CI.getType(),
+ "gc.relocate: relocating a pointer shouldn't change its type", &CI);
break;
}
};
}
-void DebugInfoVerifier::verifyDebugInfo() {
- if (!VerifyDebugInfo)
+template <class DbgIntrinsicTy>
+void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) {
+ auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata();
+ Assert(isa<ValueAsMetadata>(MD) ||
+ (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
+ "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
+ Assert(isa<MDLocalVariable>(DII.getRawVariable()),
+ "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
+ DII.getRawVariable());
+ Assert(isa<MDExpression>(DII.getRawExpression()),
+ "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
+ DII.getRawExpression());
+}
+
+void Verifier::verifyDebugInfo() {
+ // Run the debug info verifier only if the regular verifier succeeds, since
+ // sometimes checks that have already failed will cause crashes here.
+ if (EverBroken || !VerifyDebugInfo)
return;
DebugInfoFinder Finder;
@@ -3002,23 +3063,23 @@ void DebugInfoVerifier::verifyDebugInfo() {
//
// NOTE: The loud braces are necessary for MSVC compatibility.
for (DICompileUnit CU : Finder.compile_units()) {
- Assert1(CU.Verify(), "DICompileUnit does not Verify!", CU);
+ Assert(CU.Verify(), "DICompileUnit does not Verify!", CU);
}
for (DISubprogram S : Finder.subprograms()) {
- Assert1(S.Verify(), "DISubprogram does not Verify!", S);
+ Assert(S.Verify(), "DISubprogram does not Verify!", S);
}
for (DIGlobalVariable GV : Finder.global_variables()) {
- Assert1(GV.Verify(), "DIGlobalVariable does not Verify!", GV);
+ Assert(GV.Verify(), "DIGlobalVariable does not Verify!", GV);
}
for (DIType T : Finder.types()) {
- Assert1(T.Verify(), "DIType does not Verify!", T);
+ Assert(T.Verify(), "DIType does not Verify!", T);
}
for (DIScope S : Finder.scopes()) {
- Assert1(S.Verify(), "DIScope does not Verify!", S);
+ Assert(S.Verify(), "DIScope does not Verify!", S);
}
}
-void DebugInfoVerifier::processInstructions(DebugInfoFinder &Finder) {
+void Verifier::processInstructions(DebugInfoFinder &Finder) {
for (const Function &F : *M)
for (auto I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
if (MDNode *MD = I->getMetadata(LLVMContext::MD_dbg))
@@ -3028,25 +3089,16 @@ void DebugInfoVerifier::processInstructions(DebugInfoFinder &Finder) {
}
}
-void DebugInfoVerifier::processCallInst(DebugInfoFinder &Finder,
- const CallInst &CI) {
+void Verifier::processCallInst(DebugInfoFinder &Finder, const CallInst &CI) {
if (Function *F = CI.getCalledFunction())
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
switch (ID) {
- case Intrinsic::dbg_declare: {
- auto *DDI = cast<DbgDeclareInst>(&CI);
- Finder.processDeclare(*M, DDI);
- if (auto E = DDI->getExpression())
- Assert1(DIExpression(E).Verify(), "DIExpression does not Verify!", E);
+ case Intrinsic::dbg_declare:
+ Finder.processDeclare(*M, cast<DbgDeclareInst>(&CI));
break;
- }
- case Intrinsic::dbg_value: {
- auto *DVI = cast<DbgValueInst>(&CI);
- Finder.processValue(*M, DVI);
- if (auto E = DVI->getExpression())
- Assert1(DIExpression(E).Verify(), "DIExpression does not Verify!", E);
+ case Intrinsic::dbg_value:
+ Finder.processValue(*M, cast<DbgValueInst>(&CI));
break;
- }
default:
break;
}
@@ -3079,8 +3131,7 @@ bool llvm::verifyModule(const Module &M, raw_ostream *OS) {
// Note that this function's return value is inverted from what you would
// expect of a function called "verify".
- DebugInfoVerifier DIV(OS ? *OS : NullStr);
- return !V.verify(M) || !DIV.verify(M) || Broken;
+ return !V.verify(M) || Broken;
}
namespace {
@@ -3090,7 +3141,7 @@ struct VerifierLegacyPass : public FunctionPass {
Verifier V;
bool FatalErrors;
- VerifierLegacyPass() : FunctionPass(ID), FatalErrors(true) {
+ VerifierLegacyPass() : FunctionPass(ID), V(dbgs()), FatalErrors(true) {
initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry());
}
explicit VerifierLegacyPass(bool FatalErrors)
@@ -3116,48 +3167,15 @@ struct VerifierLegacyPass : public FunctionPass {
AU.setPreservesAll();
}
};
-struct DebugInfoVerifierLegacyPass : public ModulePass {
- static char ID;
-
- DebugInfoVerifier V;
- bool FatalErrors;
-
- DebugInfoVerifierLegacyPass() : ModulePass(ID), FatalErrors(true) {
- initializeDebugInfoVerifierLegacyPassPass(*PassRegistry::getPassRegistry());
- }
- explicit DebugInfoVerifierLegacyPass(bool FatalErrors)
- : ModulePass(ID), V(dbgs()), FatalErrors(FatalErrors) {
- initializeDebugInfoVerifierLegacyPassPass(*PassRegistry::getPassRegistry());
- }
-
- bool runOnModule(Module &M) override {
- if (!V.verify(M) && FatalErrors)
- report_fatal_error("Broken debug info found, compilation aborted!");
-
- return false;
- }
-
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.setPreservesAll();
- }
-};
}
char VerifierLegacyPass::ID = 0;
INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
-char DebugInfoVerifierLegacyPass::ID = 0;
-INITIALIZE_PASS(DebugInfoVerifierLegacyPass, "verify-di", "Debug Info Verifier",
- false, false)
-
FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
return new VerifierLegacyPass(FatalErrors);
}
-ModulePass *llvm::createDebugInfoVerifierPass(bool FatalErrors) {
- return new DebugInfoVerifierLegacyPass(FatalErrors);
-}
-
PreservedAnalyses VerifierPass::run(Module &M) {
if (verifyModule(M, &dbgs()) && FatalErrors)
report_fatal_error("Broken module found, compilation aborted!");
generated by cgit v1.1 at 2024-12-22 15:41:53 +0000