Update clang to r339409b.
Change-Id: Ied8a188bb072c40035320acedc86164b66d920af
diff --git a/linux-x64/clang/include/llvm/IR/Instructions.h b/linux-x64/clang/include/llvm/IR/Instructions.h
index 9be8bd1..8bdc935 100644
--- a/linux-x64/clang/include/llvm/IR/Instructions.h
+++ b/linux-x64/clang/include/llvm/IR/Instructions.h
@@ -735,6 +735,8 @@
return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
}
+ static StringRef getOperationName(BinOp Op);
+
void setOperation(BinOp Operation) {
unsigned short SubclassData = getSubclassDataFromInstruction();
setInstructionSubclassData((SubclassData & 31) |
@@ -2456,14 +2458,24 @@
}
/// Return true if this shuffle returns a vector with a different number of
- /// elements than its source elements.
- /// Example: shufflevector <4 x n> A, <4 x n> B, <1,2>
+ /// elements than its source vectors.
+ /// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
+ /// shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
bool changesLength() const {
unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
return NumSourceElts != NumMaskElts;
}
+ /// Return true if this shuffle returns a vector with a greater number of
+ /// elements than its source vectors.
+ /// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
+ bool increasesLength() const {
+ unsigned NumSourceElts = Op<0>()->getType()->getVectorNumElements();
+ unsigned NumMaskElts = getMask()->getType()->getVectorNumElements();
+ return NumSourceElts < NumMaskElts;
+ }
+
/// Return true if this shuffle mask chooses elements from exactly one source
/// vector.
/// Example: <7,5,undef,7>
@@ -2497,15 +2509,27 @@
return isIdentityMask(MaskAsInts);
}
- /// Return true if this shuffle mask chooses elements from exactly one source
+ /// Return true if this shuffle chooses elements from exactly one source
/// vector without lane crossings and does not change the number of elements
/// from its input vectors.
/// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
- /// TODO: Optionally allow length-changing shuffles.
bool isIdentity() const {
return !changesLength() && isIdentityMask(getShuffleMask());
}
+ /// Return true if this shuffle lengthens exactly one source vector with
+ /// undefs in the high elements.
+ bool isIdentityWithPadding() const;
+
+ /// Return true if this shuffle extracts the first N elements of exactly one
+ /// source vector.
+ bool isIdentityWithExtract() const;
+
+ /// Return true if this shuffle concatenates its 2 source vectors. This
+ /// returns false if either input is undefined. In that case, the shuffle is
+ /// is better classified as an identity with padding operation.
+ bool isConcat() const;
+
/// Return true if this shuffle mask chooses elements from its source vectors
/// without lane crossings. A shuffle using this mask would be
/// equivalent to a vector select with a constant condition operand.
@@ -3354,6 +3378,33 @@
BranchInst *cloneImpl() const;
public:
+ /// Iterator type that casts an operand to a basic block.
+ ///
+ /// This only makes sense because the successors are stored as adjacent
+ /// operands for branch instructions.
+ struct succ_op_iterator
+ : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
+ std::random_access_iterator_tag, BasicBlock *,
+ ptrdiff_t, BasicBlock *, BasicBlock *> {
+ explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}
+
+ BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
+ BasicBlock *operator->() const { return operator*(); }
+ };
+
+ /// The const version of `succ_op_iterator`.
+ struct const_succ_op_iterator
+ : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
+ std::random_access_iterator_tag,
+ const BasicBlock *, ptrdiff_t, const BasicBlock *,
+ const BasicBlock *> {
+ explicit const_succ_op_iterator(const_value_op_iterator I)
+ : iterator_adaptor_base(I) {}
+
+ const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
+ const BasicBlock *operator->() const { return operator*(); }
+ };
+
static BranchInst *Create(BasicBlock *IfTrue,
Instruction *InsertBefore = nullptr) {
return new(1) BranchInst(IfTrue, InsertBefore);
@@ -3408,6 +3459,18 @@
/// continues to map correctly to each operand.
void swapSuccessors();
+ iterator_range<succ_op_iterator> successors() {
+ return make_range(
+ succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
+ succ_op_iterator(value_op_end()));
+ }
+
+ iterator_range<const_succ_op_iterator> successors() const {
+ return make_range(const_succ_op_iterator(
+ std::next(value_op_begin(), isConditional() ? 1 : 0)),
+ const_succ_op_iterator(value_op_end()));
+ }
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
return (I->getOpcode() == Instruction::Br);
@@ -3821,6 +3884,33 @@
IndirectBrInst *cloneImpl() const;
public:
+ /// Iterator type that casts an operand to a basic block.
+ ///
+ /// This only makes sense because the successors are stored as adjacent
+ /// operands for indirectbr instructions.
+ struct succ_op_iterator
+ : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
+ std::random_access_iterator_tag, BasicBlock *,
+ ptrdiff_t, BasicBlock *, BasicBlock *> {
+ explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}
+
+ BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
+ BasicBlock *operator->() const { return operator*(); }
+ };
+
+ /// The const version of `succ_op_iterator`.
+ struct const_succ_op_iterator
+ : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
+ std::random_access_iterator_tag,
+ const BasicBlock *, ptrdiff_t, const BasicBlock *,
+ const BasicBlock *> {
+ explicit const_succ_op_iterator(const_value_op_iterator I)
+ : iterator_adaptor_base(I) {}
+
+ const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
+ const BasicBlock *operator->() const { return operator*(); }
+ };
+
static IndirectBrInst *Create(Value *Address, unsigned NumDests,
Instruction *InsertBefore = nullptr) {
return new IndirectBrInst(Address, NumDests, InsertBefore);
@@ -3863,6 +3953,16 @@
setOperand(i + 1, NewSucc);
}
+ iterator_range<succ_op_iterator> successors() {
+ return make_range(succ_op_iterator(std::next(value_op_begin())),
+ succ_op_iterator(value_op_end()));
+ }
+
+ iterator_range<const_succ_op_iterator> successors() const {
+ return make_range(const_succ_op_iterator(std::next(value_op_begin())),
+ const_succ_op_iterator(value_op_end()));
+ }
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::IndirectBr;
@@ -5248,6 +5348,25 @@
return nullptr;
}
+/// A helper function that returns the alignment of load or store instruction.
+inline unsigned getLoadStoreAlignment(Value *I) {
+ assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
+ "Expected Load or Store instruction");
+ if (auto *LI = dyn_cast<LoadInst>(I))
+ return LI->getAlignment();
+ return cast<StoreInst>(I)->getAlignment();
+}
+
+/// A helper function that returns the address space of the pointer operand of
+/// load or store instruction.
+inline unsigned getLoadStoreAddressSpace(Value *I) {
+ assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
+ "Expected Load or Store instruction");
+ if (auto *LI = dyn_cast<LoadInst>(I))
+ return LI->getPointerAddressSpace();
+ return cast<StoreInst>(I)->getPointerAddressSpace();
+}
+
} // end namespace llvm
#endif // LLVM_IR_INSTRUCTIONS_H