mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
[IR] Fix some Clang-tidy modernize-use-using warnings; other minor fixes (NFC).
llvm-svn: 303119
This commit is contained in:
Eugene Zelenko
parent
cfd3f40830
commit
659a1e517a
@ -16,8 +16,11 @@
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/BitmaskEnum.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
@ -56,10 +59,6 @@
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class DIBuilder;
|
||||
|
||||
template <typename T> class Optional;
|
||||
|
||||
/// Holds a subclass of DINode.
|
||||
///
|
||||
/// FIXME: This class doesn't currently make much sense. Previously it was a
|
||||
@ -94,9 +93,9 @@ public:
|
||||
bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; }
|
||||
};
|
||||
|
||||
typedef TypedDINodeRef<DINode> DINodeRef;
|
||||
typedef TypedDINodeRef<DIScope> DIScopeRef;
|
||||
typedef TypedDINodeRef<DIType> DITypeRef;
|
||||
using DINodeRef = TypedDINodeRef<DINode>;
|
||||
using DIScopeRef = TypedDINodeRef<DIScope>;
|
||||
using DITypeRef = TypedDINodeRef<DIType>;
|
||||
|
||||
class DITypeRefArray {
|
||||
const MDTuple *N = nullptr;
|
||||
@ -240,7 +239,8 @@ public:
|
||||
};
|
||||
|
||||
template <class T> struct simplify_type<const TypedDINodeRef<T>> {
|
||||
typedef Metadata *SimpleType;
|
||||
using SimpleType = Metadata *;
|
||||
|
||||
static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) {
|
||||
return MD;
|
||||
}
|
||||
@ -799,15 +799,18 @@ public:
|
||||
assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
|
||||
return DITypeRef(getExtraData());
|
||||
}
|
||||
|
||||
DIObjCProperty *getObjCProperty() const {
|
||||
return dyn_cast_or_null<DIObjCProperty>(getExtraData());
|
||||
}
|
||||
|
||||
Constant *getStorageOffsetInBits() const {
|
||||
assert(getTag() == dwarf::DW_TAG_member && isBitField());
|
||||
if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
|
||||
return C->getValue();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Constant *getConstant() const {
|
||||
assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
|
||||
if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
|
||||
@ -970,9 +973,11 @@ public:
|
||||
#endif
|
||||
replaceOperandWith(4, Elements.get());
|
||||
}
|
||||
|
||||
void replaceVTableHolder(DITypeRef VTableHolder) {
|
||||
replaceOperandWith(5, VTableHolder);
|
||||
}
|
||||
|
||||
void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
|
||||
replaceOperandWith(6, TemplateParams.get());
|
||||
}
|
||||
@ -1031,6 +1036,7 @@ public:
|
||||
DITypeRefArray getTypeArray() const {
|
||||
return cast_or_null<MDTuple>(getRawTypeArray());
|
||||
}
|
||||
|
||||
Metadata *getRawTypeArray() const { return getOperand(3); }
|
||||
|
||||
static bool classof(const Metadata *MD) {
|
||||
@ -1319,6 +1325,7 @@ public:
|
||||
unsigned getLine() const { return SubclassData32; }
|
||||
unsigned getColumn() const { return SubclassData16; }
|
||||
DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
|
||||
|
||||
DILocation *getInlinedAt() const {
|
||||
return cast_or_null<DILocation>(getRawInlinedAt());
|
||||
}
|
||||
@ -1452,7 +1459,6 @@ public:
|
||||
static bool classof(const Metadata *MD) {
|
||||
return MD->getMetadataID() == DILocationKind;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
/// Subprogram description.
|
||||
@ -2087,6 +2093,7 @@ public:
|
||||
return F->getFilename();
|
||||
return "";
|
||||
}
|
||||
|
||||
StringRef getDirectory() const {
|
||||
if (auto *F = getFile())
|
||||
return F->getDirectory();
|
||||
@ -2143,6 +2150,7 @@ public:
|
||||
ArrayRef<uint64_t> getElements() const { return Elements; }
|
||||
|
||||
unsigned getNumElements() const { return Elements.size(); }
|
||||
|
||||
uint64_t getElement(unsigned I) const {
|
||||
assert(I < Elements.size() && "Index out of range");
|
||||
return Elements[I];
|
||||
@ -2151,7 +2159,8 @@ public:
|
||||
/// Determine whether this represents a standalone constant value.
|
||||
bool isConstant() const;
|
||||
|
||||
typedef ArrayRef<uint64_t>::iterator element_iterator;
|
||||
using element_iterator = ArrayRef<uint64_t>::iterator;
|
||||
|
||||
element_iterator elements_begin() const { return getElements().begin(); }
|
||||
element_iterator elements_end() const { return getElements().end(); }
|
||||
|
||||
@ -2513,6 +2522,7 @@ public:
|
||||
return F->getFilename();
|
||||
return "";
|
||||
}
|
||||
|
||||
StringRef getDirectory() const {
|
||||
if (auto *F = getFile())
|
||||
return F->getDirectory();
|
||||
@ -2613,10 +2623,13 @@ public:
|
||||
TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
|
||||
|
||||
Metadata *getRawVariable() const { return getOperand(0); }
|
||||
|
||||
DIGlobalVariable *getVariable() const {
|
||||
return cast_or_null<DIGlobalVariable>(getRawVariable());
|
||||
}
|
||||
|
||||
Metadata *getRawExpression() const { return getOperand(1); }
|
||||
|
||||
DIExpression *getExpression() const {
|
||||
return cast_or_null<DIExpression>(getRawExpression());
|
||||
}
|
||||
|
||||
@ -15,7 +15,6 @@
|
||||
#ifndef LLVM_IR_DIAGNOSTICINFO_H
|
||||
#define LLVM_IR_DIAGNOSTICINFO_H
|
||||
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
@ -120,18 +119,18 @@ public:
|
||||
virtual void print(DiagnosticPrinter &DP) const = 0;
|
||||
};
|
||||
|
||||
typedef std::function<void(const DiagnosticInfo &)> DiagnosticHandlerFunction;
|
||||
using DiagnosticHandlerFunction = std::function<void(const DiagnosticInfo &)>;
|
||||
|
||||
/// Diagnostic information for inline asm reporting.
|
||||
/// This is basically a message and an optional location.
|
||||
class DiagnosticInfoInlineAsm : public DiagnosticInfo {
|
||||
private:
|
||||
/// Optional line information. 0 if not set.
|
||||
unsigned LocCookie;
|
||||
unsigned LocCookie = 0;
|
||||
/// Message to be reported.
|
||||
const Twine &MsgStr;
|
||||
/// Optional origin of the problem.
|
||||
const Instruction *Instr;
|
||||
const Instruction *Instr = nullptr;
|
||||
|
||||
public:
|
||||
/// \p MsgStr is the message to be reported to the frontend.
|
||||
@ -139,8 +138,7 @@ public:
|
||||
/// for the whole life time of the Diagnostic.
|
||||
DiagnosticInfoInlineAsm(const Twine &MsgStr,
|
||||
DiagnosticSeverity Severity = DS_Error)
|
||||
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
|
||||
Instr(nullptr) {}
|
||||
: DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr) {}
|
||||
|
||||
/// \p LocCookie if non-zero gives the line number for this report.
|
||||
/// \p MsgStr gives the message.
|
||||
@ -149,7 +147,7 @@ public:
|
||||
DiagnosticInfoInlineAsm(unsigned LocCookie, const Twine &MsgStr,
|
||||
DiagnosticSeverity Severity = DS_Error)
|
||||
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(LocCookie),
|
||||
MsgStr(MsgStr), Instr(nullptr) {}
|
||||
MsgStr(MsgStr) {}
|
||||
|
||||
/// \p Instr gives the original instruction that triggered the diagnostic.
|
||||
/// \p MsgStr gives the message.
|
||||
@ -294,10 +292,10 @@ public:
|
||||
DiagnosticInfoSampleProfile(StringRef FileName, const Twine &Msg,
|
||||
DiagnosticSeverity Severity = DS_Error)
|
||||
: DiagnosticInfo(DK_SampleProfile, Severity), FileName(FileName),
|
||||
LineNum(0), Msg(Msg) {}
|
||||
Msg(Msg) {}
|
||||
DiagnosticInfoSampleProfile(const Twine &Msg,
|
||||
DiagnosticSeverity Severity = DS_Error)
|
||||
: DiagnosticInfo(DK_SampleProfile, Severity), LineNum(0), Msg(Msg) {}
|
||||
: DiagnosticInfo(DK_SampleProfile, Severity), Msg(Msg) {}
|
||||
|
||||
/// \see DiagnosticInfo::print.
|
||||
void print(DiagnosticPrinter &DP) const override;
|
||||
@ -316,7 +314,7 @@ private:
|
||||
|
||||
/// Line number where the diagnostic occurred. If 0, no line number will
|
||||
/// be emitted in the message.
|
||||
unsigned LineNum;
|
||||
unsigned LineNum = 0;
|
||||
|
||||
/// Message to report.
|
||||
const Twine &Msg;
|
||||
@ -351,8 +349,9 @@ class DiagnosticLocation {
|
||||
StringRef Filename;
|
||||
unsigned Line = 0;
|
||||
unsigned Column = 0;
|
||||
|
||||
public:
|
||||
DiagnosticLocation() {}
|
||||
DiagnosticLocation() = default;
|
||||
DiagnosticLocation(const DebugLoc &DL);
|
||||
DiagnosticLocation(const DISubprogram *SP);
|
||||
|
||||
@ -796,6 +795,7 @@ private:
|
||||
const Twine &Msg)
|
||||
: OptimizationRemarkAnalysis(DK_OptimizationRemarkAnalysisFPCommute,
|
||||
PassName, Fn, Loc, Msg) {}
|
||||
|
||||
friend void emitOptimizationRemarkAnalysisFPCommute(
|
||||
LLVMContext &Ctx, const char *PassName, const Function &Fn,
|
||||
const DiagnosticLocation &Loc, const Twine &Msg);
|
||||
@ -1012,6 +1012,7 @@ public:
|
||||
|
||||
void print(DiagnosticPrinter &DP) const override;
|
||||
};
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_IR_DIAGNOSTICINFO_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
|
||||
//===- llvm/Instructions.h - Instruction subclass definitions ---*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -17,6 +17,7 @@
|
||||
#define LLVM_IR_INSTRUCTIONS_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/iterator.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
@ -24,21 +25,25 @@
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/ADT/Twine.h"
|
||||
#include "llvm/IR/Attributes.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/CallingConv.h"
|
||||
#include "llvm/IR/Constant.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/InstrTypes.h"
|
||||
#include "llvm/IR/Instruction.h"
|
||||
#include "llvm/IR/OperandTraits.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
#include "llvm/IR/Use.h"
|
||||
#include "llvm/IR/User.h"
|
||||
#include "llvm/IR/Value.h"
|
||||
#include "llvm/Support/AtomicOrdering.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <iterator>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -264,6 +269,7 @@ public:
|
||||
}
|
||||
|
||||
bool isSimple() const { return !isAtomic() && !isVolatile(); }
|
||||
|
||||
bool isUnordered() const {
|
||||
return (getOrdering() == AtomicOrdering::NotAtomic ||
|
||||
getOrdering() == AtomicOrdering::Unordered) &&
|
||||
@ -386,6 +392,7 @@ public:
|
||||
}
|
||||
|
||||
bool isSimple() const { return !isAtomic() && !isVolatile(); }
|
||||
|
||||
bool isUnordered() const {
|
||||
return (getOrdering() == AtomicOrdering::NotAtomic ||
|
||||
getOrdering() == AtomicOrdering::Unordered) &&
|
||||
@ -836,10 +843,7 @@ class GetElementPtrInst : public Instruction {
|
||||
Type *SourceElementType;
|
||||
Type *ResultElementType;
|
||||
|
||||
void anchor() override;
|
||||
|
||||
GetElementPtrInst(const GetElementPtrInst &GEPI);
|
||||
void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
|
||||
|
||||
/// Constructors - Create a getelementptr instruction with a base pointer an
|
||||
/// list of indices. The first ctor can optionally insert before an existing
|
||||
@ -852,6 +856,9 @@ class GetElementPtrInst : public Instruction {
|
||||
ArrayRef<Value *> IdxList, unsigned Values,
|
||||
const Twine &NameStr, BasicBlock *InsertAtEnd);
|
||||
|
||||
void anchor() override;
|
||||
void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
|
||||
|
||||
protected:
|
||||
// Note: Instruction needs to be a friend here to call cloneImpl.
|
||||
friend class Instruction;
|
||||
@ -2301,6 +2308,7 @@ class ExtractValueInst : public UnaryInstruction {
|
||||
SmallVector<unsigned, 4> Indices;
|
||||
|
||||
ExtractValueInst(const ExtractValueInst &EVI);
|
||||
|
||||
/// Constructors - Create a extractvalue instruction with a base aggregate
|
||||
/// value and a list of indices. The first ctor can optionally insert before
|
||||
/// an existing instruction, the second appends the new instruction to the
|
||||
@ -2346,7 +2354,8 @@ public:
|
||||
/// Null is returned if the indices are invalid for the specified type.
|
||||
static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
|
||||
|
||||
typedef const unsigned* idx_iterator;
|
||||
using idx_iterator = const unsigned*;
|
||||
|
||||
inline idx_iterator idx_begin() const { return Indices.begin(); }
|
||||
inline idx_iterator idx_end() const { return Indices.end(); }
|
||||
inline iterator_range<idx_iterator> indices() const {
|
||||
@ -2468,7 +2477,8 @@ public:
|
||||
/// Transparently provide more efficient getOperand methods.
|
||||
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
|
||||
|
||||
typedef const unsigned* idx_iterator;
|
||||
using idx_iterator = const unsigned*;
|
||||
|
||||
inline idx_iterator idx_begin() const { return Indices.begin(); }
|
||||
inline idx_iterator idx_end() const { return Indices.end(); }
|
||||
inline iterator_range<idx_iterator> indices() const {
|
||||
@ -2619,8 +2629,8 @@ public:
|
||||
// Block iterator interface. This provides access to the list of incoming
|
||||
// basic blocks, which parallels the list of incoming values.
|
||||
|
||||
typedef BasicBlock **block_iterator;
|
||||
typedef BasicBlock * const *const_block_iterator;
|
||||
using block_iterator = BasicBlock **;
|
||||
using const_block_iterator = BasicBlock * const *;
|
||||
|
||||
block_iterator block_begin() {
|
||||
Use::UserRef *ref =
|
||||
@ -2669,9 +2679,11 @@ public:
|
||||
"All operands to PHI node must be the same type as the PHI node!");
|
||||
setOperand(i, V);
|
||||
}
|
||||
|
||||
static unsigned getOperandNumForIncomingValue(unsigned i) {
|
||||
return i;
|
||||
}
|
||||
|
||||
static unsigned getIncomingValueNumForOperand(unsigned i) {
|
||||
return i;
|
||||
}
|
||||
@ -2951,6 +2963,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -3062,6 +3075,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -3138,7 +3152,7 @@ public:
|
||||
|
||||
protected:
|
||||
// Expose the switch type we're parameterized with to the iterator.
|
||||
typedef SwitchInstT SwitchInstType;
|
||||
using SwitchInstType = SwitchInstT;
|
||||
|
||||
SwitchInstT *SI;
|
||||
ptrdiff_t Index;
|
||||
@ -3179,8 +3193,8 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
typedef CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>
|
||||
ConstCaseHandle;
|
||||
using ConstCaseHandle =
|
||||
CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;
|
||||
|
||||
class CaseHandle
|
||||
: public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
|
||||
@ -3207,7 +3221,7 @@ public:
|
||||
: public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
|
||||
std::random_access_iterator_tag,
|
||||
CaseHandleT> {
|
||||
typedef typename CaseHandleT::SwitchInstType SwitchInstT;
|
||||
using SwitchInstT = typename CaseHandleT::SwitchInstType;
|
||||
|
||||
CaseHandleT Case;
|
||||
|
||||
@ -3269,8 +3283,8 @@ public:
|
||||
const CaseHandleT &operator*() const { return Case; }
|
||||
};
|
||||
|
||||
typedef CaseIteratorImpl<CaseHandle> CaseIt;
|
||||
typedef CaseIteratorImpl<ConstCaseHandle> ConstCaseIt;
|
||||
using CaseIt = CaseIteratorImpl<CaseHandle>;
|
||||
using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;
|
||||
|
||||
static SwitchInst *Create(Value *Value, BasicBlock *Default,
|
||||
unsigned NumCases,
|
||||
@ -3427,6 +3441,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -3533,6 +3548,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -3656,6 +3672,7 @@ public:
|
||||
return new (Values) InvokeInst(Func, IfNormal, IfException, Args, None,
|
||||
Values, NameStr, InsertAtEnd);
|
||||
}
|
||||
|
||||
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
|
||||
BasicBlock *IfException, ArrayRef<Value *> Args,
|
||||
ArrayRef<OperandBundleDef> Bundles,
|
||||
@ -4014,6 +4031,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -4114,6 +4132,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
@ -4221,13 +4240,14 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
typedef std::pointer_to_unary_function<Value *, BasicBlock *> DerefFnTy;
|
||||
typedef mapped_iterator<op_iterator, DerefFnTy> handler_iterator;
|
||||
typedef iterator_range<handler_iterator> handler_range;
|
||||
typedef std::pointer_to_unary_function<const Value *, const BasicBlock *>
|
||||
ConstDerefFnTy;
|
||||
typedef mapped_iterator<const_op_iterator, ConstDerefFnTy> const_handler_iterator;
|
||||
typedef iterator_range<const_handler_iterator> const_handler_range;
|
||||
using DerefFnTy = std::pointer_to_unary_function<Value *, BasicBlock *>;
|
||||
using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
|
||||
using handler_range = iterator_range<handler_iterator>;
|
||||
using ConstDerefFnTy =
|
||||
std::pointer_to_unary_function<const Value *, const BasicBlock *>;
|
||||
using const_handler_iterator =
|
||||
mapped_iterator<const_op_iterator, ConstDerefFnTy>;
|
||||
using const_handler_range = iterator_range<const_handler_iterator>;
|
||||
|
||||
/// Returns an iterator that points to the first handler in CatchSwitchInst.
|
||||
handler_iterator handler_begin() {
|
||||
@ -4298,6 +4318,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned Idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned Idx, BasicBlock *B);
|
||||
@ -4464,6 +4485,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned Idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned Idx, BasicBlock *B);
|
||||
@ -4553,6 +4575,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned Idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned Idx, BasicBlock *B);
|
||||
@ -4609,6 +4632,7 @@ public:
|
||||
|
||||
private:
|
||||
friend TerminatorInst;
|
||||
|
||||
BasicBlock *getSuccessorV(unsigned idx) const;
|
||||
unsigned getNumSuccessorsV() const;
|
||||
void setSuccessorV(unsigned idx, BasicBlock *B);
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- AttributeImpl.h - Attribute Internals -------------------*- C++ -*-===//
|
||||
//===- AttributeImpl.h - Attribute Internals --------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -21,9 +21,7 @@
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/Attributes.h"
|
||||
#include "llvm/Support/TrailingObjects.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
@ -80,11 +78,13 @@ public:
|
||||
else
|
||||
Profile(ID, getKindAsString(), getValueAsString());
|
||||
}
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
|
||||
uint64_t Val) {
|
||||
ID.AddInteger(Kind);
|
||||
if (Val) ID.AddInteger(Val);
|
||||
}
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, StringRef Kind, StringRef Values) {
|
||||
ID.AddString(Kind);
|
||||
if (!Values.empty()) ID.AddString(Values);
|
||||
@ -114,9 +114,10 @@ public:
|
||||
};
|
||||
|
||||
class IntAttributeImpl : public EnumAttributeImpl {
|
||||
void anchor() override;
|
||||
uint64_t Val;
|
||||
|
||||
void anchor() override;
|
||||
|
||||
public:
|
||||
IntAttributeImpl(Attribute::AttrKind Kind, uint64_t Val)
|
||||
: EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) {
|
||||
@ -188,20 +189,22 @@ public:
|
||||
std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
|
||||
std::string getAsString(bool InAttrGrp) const;
|
||||
|
||||
typedef const Attribute *iterator;
|
||||
using iterator = const Attribute *;
|
||||
|
||||
iterator begin() const { return getTrailingObjects<Attribute>(); }
|
||||
iterator end() const { return begin() + NumAttrs; }
|
||||
|
||||
void Profile(FoldingSetNodeID &ID) const {
|
||||
Profile(ID, makeArrayRef(begin(), end()));
|
||||
}
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, ArrayRef<Attribute> AttrList) {
|
||||
for (const auto &Attr : AttrList)
|
||||
Attr.Profile(ID);
|
||||
}
|
||||
};
|
||||
|
||||
typedef std::pair<unsigned, AttributeSet> IndexAttrPair;
|
||||
using IndexAttrPair = std::pair<unsigned, AttributeSet>;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// \class
|
||||
@ -265,7 +268,8 @@ public:
|
||||
return AvailableFunctionAttrs & ((uint64_t)1) << Kind;
|
||||
}
|
||||
|
||||
typedef AttributeSet::iterator iterator;
|
||||
using iterator = AttributeSet::iterator;
|
||||
|
||||
iterator begin(unsigned Slot) const {
|
||||
return getSlotAttributes(Slot).begin();
|
||||
}
|
||||
|
||||
@ -34,6 +34,8 @@
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
@ -567,11 +569,11 @@ unsigned AttributeSet::getNumAttributes() const {
|
||||
}
|
||||
|
||||
bool AttributeSet::hasAttribute(Attribute::AttrKind Kind) const {
|
||||
return SetNode ? SetNode->hasAttribute(Kind) : 0;
|
||||
return SetNode ? SetNode->hasAttribute(Kind) : false;
|
||||
}
|
||||
|
||||
bool AttributeSet::hasAttribute(StringRef Kind) const {
|
||||
return SetNode ? SetNode->hasAttribute(Kind) : 0;
|
||||
return SetNode ? SetNode->hasAttribute(Kind) : false;
|
||||
}
|
||||
|
||||
Attribute AttributeSet::getAttribute(Attribute::AttrKind Kind) const {
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/Constant.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/InlineAsm.h"
|
||||
@ -387,31 +388,34 @@ struct ConstantExprKeyType;
|
||||
|
||||
template <class ConstantClass> struct ConstantInfo;
|
||||
template <> struct ConstantInfo<ConstantExpr> {
|
||||
typedef ConstantExprKeyType ValType;
|
||||
typedef Type TypeClass;
|
||||
using ValType = ConstantExprKeyType;
|
||||
using TypeClass = Type;
|
||||
};
|
||||
template <> struct ConstantInfo<InlineAsm> {
|
||||
typedef InlineAsmKeyType ValType;
|
||||
typedef PointerType TypeClass;
|
||||
using ValType = InlineAsmKeyType;
|
||||
using TypeClass = PointerType;
|
||||
};
|
||||
template <> struct ConstantInfo<ConstantArray> {
|
||||
typedef ConstantAggrKeyType<ConstantArray> ValType;
|
||||
typedef ArrayType TypeClass;
|
||||
using ValType = ConstantAggrKeyType<ConstantArray>;
|
||||
using TypeClass = ArrayType;
|
||||
};
|
||||
template <> struct ConstantInfo<ConstantStruct> {
|
||||
typedef ConstantAggrKeyType<ConstantStruct> ValType;
|
||||
typedef StructType TypeClass;
|
||||
using ValType = ConstantAggrKeyType<ConstantStruct>;
|
||||
using TypeClass = StructType;
|
||||
};
|
||||
template <> struct ConstantInfo<ConstantVector> {
|
||||
typedef ConstantAggrKeyType<ConstantVector> ValType;
|
||||
typedef VectorType TypeClass;
|
||||
using ValType = ConstantAggrKeyType<ConstantVector>;
|
||||
using TypeClass = VectorType;
|
||||
};
|
||||
|
||||
template <class ConstantClass> struct ConstantAggrKeyType {
|
||||
ArrayRef<Constant *> Operands;
|
||||
|
||||
ConstantAggrKeyType(ArrayRef<Constant *> Operands) : Operands(Operands) {}
|
||||
|
||||
ConstantAggrKeyType(ArrayRef<Constant *> Operands, const ConstantClass *)
|
||||
: Operands(Operands) {}
|
||||
|
||||
ConstantAggrKeyType(const ConstantClass *C,
|
||||
SmallVectorImpl<Constant *> &Storage) {
|
||||
assert(Storage.empty() && "Expected empty storage");
|
||||
@ -437,7 +441,8 @@ template <class ConstantClass> struct ConstantAggrKeyType {
|
||||
return hash_combine_range(Operands.begin(), Operands.end());
|
||||
}
|
||||
|
||||
typedef typename ConstantInfo<ConstantClass>::TypeClass TypeClass;
|
||||
using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
|
||||
|
||||
ConstantClass *create(TypeClass *Ty) const {
|
||||
return new (Operands.size()) ConstantClass(Ty, Operands);
|
||||
}
|
||||
@ -457,6 +462,7 @@ struct InlineAsmKeyType {
|
||||
: AsmString(AsmString), Constraints(Constraints), FTy(FTy),
|
||||
HasSideEffects(HasSideEffects), IsAlignStack(IsAlignStack),
|
||||
AsmDialect(AsmDialect) {}
|
||||
|
||||
InlineAsmKeyType(const InlineAsm *Asm, SmallVectorImpl<Constant *> &)
|
||||
: AsmString(Asm->getAsmString()), Constraints(Asm->getConstraintString()),
|
||||
FTy(Asm->getFunctionType()), HasSideEffects(Asm->hasSideEffects()),
|
||||
@ -483,7 +489,8 @@ struct InlineAsmKeyType {
|
||||
AsmDialect, FTy);
|
||||
}
|
||||
|
||||
typedef ConstantInfo<InlineAsm>::TypeClass TypeClass;
|
||||
using TypeClass = ConstantInfo<InlineAsm>::TypeClass;
|
||||
|
||||
InlineAsm *create(TypeClass *Ty) const {
|
||||
assert(PointerType::getUnqual(FTy) == Ty);
|
||||
return new InlineAsm(FTy, AsmString, Constraints, HasSideEffects,
|
||||
@ -507,11 +514,13 @@ struct ConstantExprKeyType {
|
||||
: Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
|
||||
SubclassData(SubclassData), Ops(Ops), Indexes(Indexes),
|
||||
ExplicitTy(ExplicitTy) {}
|
||||
|
||||
ConstantExprKeyType(ArrayRef<Constant *> Operands, const ConstantExpr *CE)
|
||||
: Opcode(CE->getOpcode()),
|
||||
SubclassOptionalData(CE->getRawSubclassOptionalData()),
|
||||
SubclassData(CE->isCompare() ? CE->getPredicate() : 0), Ops(Operands),
|
||||
Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {}
|
||||
|
||||
ConstantExprKeyType(const ConstantExpr *CE,
|
||||
SmallVectorImpl<Constant *> &Storage)
|
||||
: Opcode(CE->getOpcode()),
|
||||
@ -553,7 +562,8 @@ struct ConstantExprKeyType {
|
||||
hash_combine_range(Indexes.begin(), Indexes.end()));
|
||||
}
|
||||
|
||||
typedef ConstantInfo<ConstantExpr>::TypeClass TypeClass;
|
||||
using TypeClass = ConstantInfo<ConstantExpr>::TypeClass;
|
||||
|
||||
ConstantExpr *create(TypeClass *Ty) const {
|
||||
switch (Opcode) {
|
||||
default:
|
||||
@ -594,16 +604,17 @@ struct ConstantExprKeyType {
|
||||
|
||||
template <class ConstantClass> class ConstantUniqueMap {
|
||||
public:
|
||||
typedef typename ConstantInfo<ConstantClass>::ValType ValType;
|
||||
typedef typename ConstantInfo<ConstantClass>::TypeClass TypeClass;
|
||||
typedef std::pair<TypeClass *, ValType> LookupKey;
|
||||
using ValType = typename ConstantInfo<ConstantClass>::ValType;
|
||||
using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
|
||||
using LookupKey = std::pair<TypeClass *, ValType>;
|
||||
|
||||
/// Key and hash together, so that we compute the hash only once and reuse it.
|
||||
typedef std::pair<unsigned, LookupKey> LookupKeyHashed;
|
||||
using LookupKeyHashed = std::pair<unsigned, LookupKey>;
|
||||
|
||||
private:
|
||||
struct MapInfo {
|
||||
typedef DenseMapInfo<ConstantClass *> ConstantClassInfo;
|
||||
using ConstantClassInfo = DenseMapInfo<ConstantClass *>;
|
||||
|
||||
static inline ConstantClass *getEmptyKey() {
|
||||
return ConstantClassInfo::getEmptyKey();
|
||||
}
|
||||
@ -643,7 +654,7 @@ private:
|
||||
};
|
||||
|
||||
public:
|
||||
typedef DenseSet<ConstantClass *, MapInfo> MapTy;
|
||||
using MapTy = DenseSet<ConstantClass *, MapInfo>;
|
||||
|
||||
private:
|
||||
MapTy Map;
|
||||
|
||||
@ -12,20 +12,31 @@
|
||||
// Diagnostics reporting is still done as part of the LLVMContext.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/IR/DiagnosticInfo.h"
|
||||
#include "LLVMContextImpl.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/ADT/StringExtras.h"
|
||||
#include "llvm/ADT/Twine.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DebugInfo.h"
|
||||
#include "llvm/IR/DebugInfoMetadata.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/DiagnosticInfo.h"
|
||||
#include "llvm/IR/DiagnosticPrinter.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/GlobalValue.h"
|
||||
#include "llvm/IR/Instruction.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
#include "llvm/IR/Value.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/CommandLine.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Support/Regex.h"
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
using namespace llvm;
|
||||
@ -53,6 +64,8 @@ struct PassRemarksOpt {
|
||||
}
|
||||
};
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
static PassRemarksOpt PassRemarksOptLoc;
|
||||
static PassRemarksOpt PassRemarksMissedOptLoc;
|
||||
static PassRemarksOpt PassRemarksAnalysisOptLoc;
|
||||
@ -85,7 +98,6 @@ PassRemarksAnalysis(
|
||||
"the given regular expression"),
|
||||
cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
|
||||
cl::ZeroOrMore);
|
||||
}
|
||||
|
||||
int llvm::getNextAvailablePluginDiagnosticKind() {
|
||||
static std::atomic<int> PluginKindID(DK_FirstPluginKind);
|
||||
@ -97,8 +109,7 @@ const char *OptimizationRemarkAnalysis::AlwaysPrint = "";
|
||||
DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &I,
|
||||
const Twine &MsgStr,
|
||||
DiagnosticSeverity Severity)
|
||||
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
|
||||
Instr(&I) {
|
||||
: DiagnosticInfo(DK_InlineAsm, Severity), MsgStr(MsgStr), Instr(&I) {
|
||||
if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
|
||||
if (SrcLoc->getNumOperands() != 0)
|
||||
if (const auto *CI =
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- Instructions.cpp - Implement the LLVM instructions ----------------===//
|
||||
//===- Instructions.cpp - Implement the LLVM instructions -----------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -12,18 +12,36 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "LLVMContextImpl.h"
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/Twine.h"
|
||||
#include "llvm/IR/Attributes.h"
|
||||
#include "llvm/IR/BasicBlock.h"
|
||||
#include "llvm/IR/CallSite.h"
|
||||
#include "llvm/IR/ConstantRange.h"
|
||||
#include "llvm/IR/Constant.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DataLayout.h"
|
||||
#include "llvm/IR/DerivedTypes.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/InstrTypes.h"
|
||||
#include "llvm/IR/Instruction.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/IR/Operator.h"
|
||||
#include "llvm/IR/Type.h"
|
||||
#include "llvm/IR/Value.h"
|
||||
#include "llvm/Support/AtomicOrdering.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -42,8 +60,7 @@ User::op_iterator CallSite::getCallee() const {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// Out of line virtual method, so the vtable, etc has a home.
|
||||
TerminatorInst::~TerminatorInst() {
|
||||
}
|
||||
TerminatorInst::~TerminatorInst() = default;
|
||||
|
||||
unsigned TerminatorInst::getNumSuccessors() const {
|
||||
switch (getOpcode()) {
|
||||
@ -86,8 +103,7 @@ void TerminatorInst::setSuccessor(unsigned idx, BasicBlock *B) {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// Out of line virtual method, so the vtable, etc has a home.
|
||||
UnaryInstruction::~UnaryInstruction() {
|
||||
}
|
||||
UnaryInstruction::~UnaryInstruction() = default;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SelectInst Class
|
||||
@ -118,7 +134,6 @@ const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// PHINode Class
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -278,8 +293,7 @@ void LandingPadInst::addClause(Constant *Val) {
|
||||
// CallInst Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
CallInst::~CallInst() {
|
||||
}
|
||||
CallInst::~CallInst() = default;
|
||||
|
||||
void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
|
||||
ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
|
||||
@ -577,7 +591,6 @@ Instruction *CallInst::CreateMalloc(Instruction *InsertBefore,
|
||||
ArraySize, OpB, MallocF, Name);
|
||||
}
|
||||
|
||||
|
||||
/// CreateMalloc - Generate the IR for a call to malloc:
|
||||
/// 1. Compute the malloc call's argument as the specified type's size,
|
||||
/// possibly multiplied by the array size if the array size is not
|
||||
@ -728,9 +741,11 @@ InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB,
|
||||
BasicBlock *InvokeInst::getSuccessorV(unsigned idx) const {
|
||||
return getSuccessor(idx);
|
||||
}
|
||||
|
||||
unsigned InvokeInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
|
||||
return setSuccessor(idx, B);
|
||||
}
|
||||
@ -857,6 +872,7 @@ ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore)
|
||||
if (retVal)
|
||||
Op<0>() = retVal;
|
||||
}
|
||||
|
||||
ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd)
|
||||
: TerminatorInst(Type::getVoidTy(C), Instruction::Ret,
|
||||
OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
|
||||
@ -864,6 +880,7 @@ ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd)
|
||||
if (retVal)
|
||||
Op<0>() = retVal;
|
||||
}
|
||||
|
||||
ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
|
||||
: TerminatorInst(Type::getVoidTy(Context), Instruction::Ret,
|
||||
OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {
|
||||
@ -883,8 +900,7 @@ BasicBlock *ReturnInst::getSuccessorV(unsigned idx) const {
|
||||
llvm_unreachable("ReturnInst has no successors!");
|
||||
}
|
||||
|
||||
ReturnInst::~ReturnInst() {
|
||||
}
|
||||
ReturnInst::~ReturnInst() = default;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ResumeInst Implementation
|
||||
@ -966,9 +982,11 @@ BasicBlock *CleanupReturnInst::getSuccessorV(unsigned Idx) const {
|
||||
assert(Idx == 0);
|
||||
return getUnwindDest();
|
||||
}
|
||||
|
||||
unsigned CleanupReturnInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void CleanupReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
|
||||
assert(Idx == 0);
|
||||
setUnwindDest(B);
|
||||
@ -1009,9 +1027,11 @@ BasicBlock *CatchReturnInst::getSuccessorV(unsigned Idx) const {
|
||||
assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
|
||||
return getSuccessor();
|
||||
}
|
||||
|
||||
unsigned CatchReturnInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void CatchReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
|
||||
assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
|
||||
setSuccessor(B);
|
||||
@ -1103,9 +1123,11 @@ void CatchSwitchInst::removeHandler(handler_iterator HI) {
|
||||
BasicBlock *CatchSwitchInst::getSuccessorV(unsigned idx) const {
|
||||
return getSuccessor(idx);
|
||||
}
|
||||
|
||||
unsigned CatchSwitchInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void CatchSwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
|
||||
setSuccessor(idx, B);
|
||||
}
|
||||
@ -1191,6 +1213,7 @@ BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore)
|
||||
assert(IfTrue && "Branch destination may not be null!");
|
||||
Op<-1>() = IfTrue;
|
||||
}
|
||||
|
||||
BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
|
||||
Instruction *InsertBefore)
|
||||
: TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
|
||||
@ -1225,7 +1248,6 @@ BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
BranchInst::BranchInst(const BranchInst &BI) :
|
||||
TerminatorInst(Type::getVoidTy(BI.getContext()), Instruction::Br,
|
||||
OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
|
||||
@ -1252,14 +1274,15 @@ void BranchInst::swapSuccessors() {
|
||||
BasicBlock *BranchInst::getSuccessorV(unsigned idx) const {
|
||||
return getSuccessor(idx);
|
||||
}
|
||||
|
||||
unsigned BranchInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void BranchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
|
||||
setSuccessor(idx, B);
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// AllocaInst Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -1315,8 +1338,7 @@ AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
|
||||
}
|
||||
|
||||
// Out of line virtual method, so the vtable, etc has a home.
|
||||
AllocaInst::~AllocaInst() {
|
||||
}
|
||||
AllocaInst::~AllocaInst() = default;
|
||||
|
||||
void AllocaInst::setAlignment(unsigned Align) {
|
||||
assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
|
||||
@ -1805,14 +1827,12 @@ ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
|
||||
setName(Name);
|
||||
}
|
||||
|
||||
|
||||
bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
|
||||
if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// InsertElementInst Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -1859,7 +1879,6 @@ bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ShuffleVectorInst Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -1972,7 +1991,6 @@ void ShuffleVectorInst::getShuffleMask(Constant *Mask,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// InsertValueInst Class
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -1985,7 +2003,7 @@ void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
|
||||
// (other than weirdness with &*IdxBegin being invalid; see
|
||||
// getelementptr's init routine for example). But there's no
|
||||
// present need to support it.
|
||||
assert(Idxs.size() > 0 && "InsertValueInst must have at least one index");
|
||||
assert(!Idxs.empty() && "InsertValueInst must have at least one index");
|
||||
|
||||
assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) ==
|
||||
Val->getType() && "Inserted value must match indexed type!");
|
||||
@ -2014,7 +2032,7 @@ void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) {
|
||||
|
||||
// There's no fundamental reason why we require at least one index.
|
||||
// But there's no present need to support it.
|
||||
assert(Idxs.size() > 0 && "ExtractValueInst must have at least one index");
|
||||
assert(!Idxs.empty() && "ExtractValueInst must have at least one index");
|
||||
|
||||
Indices.append(Idxs.begin(), Idxs.end());
|
||||
setName(Name);
|
||||
@ -2087,7 +2105,6 @@ BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
|
||||
setName(Name);
|
||||
}
|
||||
|
||||
|
||||
void BinaryOperator::init(BinaryOps iType) {
|
||||
Value *LHS = getOperand(0), *RHS = getOperand(1);
|
||||
(void)LHS; (void)RHS; // Silence warnings.
|
||||
@ -2247,7 +2264,6 @@ BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
|
||||
Op->getType(), Name, InsertAtEnd);
|
||||
}
|
||||
|
||||
|
||||
// isConstantAllOnes - Helper function for several functions below
|
||||
static inline bool isConstantAllOnes(const Value *V) {
|
||||
if (const Constant *C = dyn_cast<Constant>(V))
|
||||
@ -2313,7 +2329,6 @@ const Value *BinaryOperator::getNotArgument(const Value *BinOp) {
|
||||
return getNotArgument(const_cast<Value*>(BinOp));
|
||||
}
|
||||
|
||||
|
||||
// Exchange the two operands to this instruction. This instruction is safe to
|
||||
// use on any binary instruction and does not modify the semantics of the
|
||||
// instruction. If the instruction is order-dependent (SetLT f.e.), the opcode
|
||||
@ -2325,7 +2340,6 @@ bool BinaryOperator::swapOperands() {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// FPMathOperator Class
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -2339,7 +2353,6 @@ float FPMathOperator::getFPAccuracy() const {
|
||||
return Accuracy->getValueAPF().convertToFloat();
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// CastInst Class
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -2601,13 +2614,12 @@ unsigned CastInst::isEliminableCastPair(
|
||||
return Instruction::BitCast;
|
||||
return 0;
|
||||
}
|
||||
case 12: {
|
||||
case 12:
|
||||
// addrspacecast, addrspacecast -> bitcast, if SrcAS == DstAS
|
||||
// addrspacecast, addrspacecast -> addrspacecast, if SrcAS != DstAS
|
||||
if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace())
|
||||
return Instruction::AddrSpaceCast;
|
||||
return Instruction::BitCast;
|
||||
}
|
||||
case 13:
|
||||
// FIXME: this state can be merged with (1), but the following assert
|
||||
// is useful to check the correcteness of the sequence due to semantic
|
||||
@ -2628,7 +2640,6 @@ unsigned CastInst::isEliminableCastPair(
|
||||
DstTy->getScalarType()->getPointerElementType())
|
||||
return Instruction::AddrSpaceCast;
|
||||
return 0;
|
||||
|
||||
case 15:
|
||||
// FIXME: this state can be merged with (1), but the following assert
|
||||
// is useful to check the correcteness of the sequence due to semantic
|
||||
@ -3104,7 +3115,6 @@ CastInst::getCastOpcode(
|
||||
/// of the types involved.
|
||||
bool
|
||||
CastInst::castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
|
||||
|
||||
// Check for type sanity on the arguments
|
||||
Type *SrcTy = S->getType();
|
||||
|
||||
@ -3453,7 +3463,6 @@ bool CmpInst::isEquality() const {
|
||||
return cast<FCmpInst>(this)->isEquality();
|
||||
}
|
||||
|
||||
|
||||
CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) {
|
||||
switch (pred) {
|
||||
default: llvm_unreachable("Unknown cmp predicate!");
|
||||
@ -3777,9 +3786,11 @@ void SwitchInst::growOperands() {
|
||||
BasicBlock *SwitchInst::getSuccessorV(unsigned idx) const {
|
||||
return getSuccessor(idx);
|
||||
}
|
||||
|
||||
unsigned SwitchInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void SwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
|
||||
setSuccessor(idx, B);
|
||||
}
|
||||
@ -3866,9 +3877,11 @@ void IndirectBrInst::removeDestination(unsigned idx) {
|
||||
BasicBlock *IndirectBrInst::getSuccessorV(unsigned idx) const {
|
||||
return getSuccessor(idx);
|
||||
}
|
||||
|
||||
unsigned IndirectBrInst::getNumSuccessorsV() const {
|
||||
return getNumSuccessors();
|
||||
}
|
||||
|
||||
void IndirectBrInst::setSuccessorV(unsigned idx, BasicBlock *B) {
|
||||
setSuccessor(idx, B);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user