Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/IR/Operator.h b/linux-x64/clang/include/llvm/IR/Operator.h
index 8199c65..acfacbd 100644
--- a/linux-x64/clang/include/llvm/IR/Operator.h
+++ b/linux-x64/clang/include/llvm/IR/Operator.h
@@ -66,6 +66,7 @@
class OverflowingBinaryOperator : public Operator {
public:
enum {
+ AnyWrap = 0,
NoUnsignedWrap = (1 << 0),
NoSignedWrap = (1 << 1)
};
@@ -379,16 +380,29 @@
return false;
switch (Opcode) {
+ case Instruction::FNeg:
+ case Instruction::FAdd:
+ case Instruction::FSub:
+ case Instruction::FMul:
+ case Instruction::FDiv:
+ case Instruction::FRem:
+ // FIXME: To clean up and correct the semantics of fast-math-flags, FCmp
+ // should not be treated as a math op, but the other opcodes should.
+ // This would make things consistent with Select/PHI (FP value type
+ // determines whether they are math ops and, therefore, capable of
+ // having fast-math-flags).
case Instruction::FCmp:
return true;
- // non math FP Operators (no FMF)
- case Instruction::ExtractElement:
- case Instruction::ShuffleVector:
- case Instruction::InsertElement:
case Instruction::PHI:
- return false;
+ case Instruction::Select:
+ case Instruction::Call: {
+ Type *Ty = V->getType();
+ while (ArrayType *ArrTy = dyn_cast<ArrayType>(Ty))
+ Ty = ArrTy->getElementType();
+ return Ty->isFPOrFPVectorTy();
+ }
default:
- return V->getType()->isFPOrFPVectorTy();
+ return false;
}
}
};
@@ -531,15 +545,29 @@
});
}
+ /// Compute the maximum alignment that this GEP is garranteed to preserve.
+ Align getMaxPreservedAlignment(const DataLayout &DL) const;
+
/// Accumulate the constant address offset of this GEP if possible.
///
- /// This routine accepts an APInt into which it will accumulate the constant
- /// offset of this GEP if the GEP is in fact constant. If the GEP is not
- /// all-constant, it returns false and the value of the offset APInt is
- /// undefined (it is *not* preserved!). The APInt passed into this routine
- /// must be at exactly as wide as the IntPtr type for the address space of the
- /// base GEP pointer.
- bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
+ /// This routine accepts an APInt into which it will try to accumulate the
+ /// constant offset of this GEP.
+ ///
+ /// If \p ExternalAnalysis is provided it will be used to calculate a offset
+ /// when a operand of GEP is not constant.
+ /// For example, for a value \p ExternalAnalysis might try to calculate a
+ /// lower bound. If \p ExternalAnalysis is successful, it should return true.
+ ///
+ /// If the \p ExternalAnalysis returns false or the value returned by \p
+ /// ExternalAnalysis results in a overflow/underflow, this routine returns
+ /// false and the value of the offset APInt is undefined (it is *not*
+ /// preserved!).
+ ///
+ /// The APInt passed into this routine must be at exactly as wide as the
+ /// IntPtr type for the address space of the base GEP pointer.
+ bool accumulateConstantOffset(
+ const DataLayout &DL, APInt &Offset,
+ function_ref<bool(Value &, APInt &)> ExternalAnalysis = nullptr) const;
};
class PtrToIntOperator
@@ -585,6 +613,25 @@
}
};
+class AddrSpaceCastOperator
+ : public ConcreteOperator<Operator, Instruction::AddrSpaceCast> {
+ friend class AddrSpaceCastInst;
+ friend class ConstantExpr;
+
+public:
+ Value *getPointerOperand() { return getOperand(0); }
+
+ const Value *getPointerOperand() const { return getOperand(0); }
+
+ unsigned getSrcAddressSpace() const {
+ return getPointerOperand()->getType()->getPointerAddressSpace();
+ }
+
+ unsigned getDestAddressSpace() const {
+ return getType()->getPointerAddressSpace();
+ }
+};
+
} // end namespace llvm
#endif // LLVM_IR_OPERATOR_H