[llvm-branch-commits] [llvm] 5b267fb - ADT: Stop peeking inside AlignedCharArrayUnion, NFC
Duncan P. N. Exon Smith via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Dec 4 11:13:02 PST 2020
Author: Duncan P. N. Exon Smith
Date: 2020-12-04T11:07:42-08:00
New Revision: 5b267fb7966157e0d79ea85cbc1d07f92f840d3c
URL: https://github.com/llvm/llvm-project/commit/5b267fb7966157e0d79ea85cbc1d07f92f840d3c
DIFF: https://github.com/llvm/llvm-project/commit/5b267fb7966157e0d79ea85cbc1d07f92f840d3c.diff
LOG: ADT: Stop peeking inside AlignedCharArrayUnion, NFC
Update all the users of `AlignedCharArrayUnion` to stop peeking inside
(to look at `buffer`) so that a follow-up patch can replace it with an
alias to `std::aligned_union_t`.
This was reviewed as part of https://reviews.llvm.org/D92512, but I'm
splitting this bit out to commit first to reduce churn in case the
change to `AlignedCharArrayUnion` needs to be reverted for some
unexpected reason.
Added:
Modified:
clang/include/clang/AST/APValue.h
clang/include/clang/AST/ASTTypeTraits.h
clang/include/clang/AST/ParentMapContext.h
clang/lib/AST/APValue.cpp
clang/lib/AST/ASTImporter.cpp
clang/lib/Frontend/PrecompiledPreamble.cpp
llvm/include/llvm/ADT/DenseMap.h
llvm/include/llvm/ADT/IntervalMap.h
llvm/include/llvm/CodeGen/DIE.h
llvm/include/llvm/Support/Error.h
llvm/include/llvm/Support/ErrorOr.h
llvm/include/llvm/Support/JSON.h
llvm/lib/Support/JSON.cpp
llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/APValue.h b/clang/include/clang/AST/APValue.h
index d921a106b9f1..eded34808ad7 100644
--- a/clang/include/clang/AST/APValue.h
+++ b/clang/include/clang/AST/APValue.h
@@ -402,7 +402,7 @@ class APValue {
APSInt &getInt() {
assert(isInt() && "Invalid accessor");
- return *(APSInt*)(char*)Data.buffer;
+ return *(APSInt *)(char *)&Data;
}
const APSInt &getInt() const {
return const_cast<APValue*>(this)->getInt();
@@ -416,7 +416,7 @@ class APValue {
APFloat &getFloat() {
assert(isFloat() && "Invalid accessor");
- return *(APFloat*)(char*)Data.buffer;
+ return *(APFloat *)(char *)&Data;
}
const APFloat &getFloat() const {
return const_cast<APValue*>(this)->getFloat();
@@ -424,7 +424,7 @@ class APValue {
APFixedPoint &getFixedPoint() {
assert(isFixedPoint() && "Invalid accessor");
- return *(APFixedPoint *)(char *)Data.buffer;
+ return *(APFixedPoint *)(char *)&Data;
}
const APFixedPoint &getFixedPoint() const {
return const_cast<APValue *>(this)->getFixedPoint();
@@ -432,7 +432,7 @@ class APValue {
APSInt &getComplexIntReal() {
assert(isComplexInt() && "Invalid accessor");
- return ((ComplexAPSInt*)(char*)Data.buffer)->Real;
+ return ((ComplexAPSInt *)(char *)&Data)->Real;
}
const APSInt &getComplexIntReal() const {
return const_cast<APValue*>(this)->getComplexIntReal();
@@ -440,7 +440,7 @@ class APValue {
APSInt &getComplexIntImag() {
assert(isComplexInt() && "Invalid accessor");
- return ((ComplexAPSInt*)(char*)Data.buffer)->Imag;
+ return ((ComplexAPSInt *)(char *)&Data)->Imag;
}
const APSInt &getComplexIntImag() const {
return const_cast<APValue*>(this)->getComplexIntImag();
@@ -448,7 +448,7 @@ class APValue {
APFloat &getComplexFloatReal() {
assert(isComplexFloat() && "Invalid accessor");
- return ((ComplexAPFloat*)(char*)Data.buffer)->Real;
+ return ((ComplexAPFloat *)(char *)&Data)->Real;
}
const APFloat &getComplexFloatReal() const {
return const_cast<APValue*>(this)->getComplexFloatReal();
@@ -456,7 +456,7 @@ class APValue {
APFloat &getComplexFloatImag() {
assert(isComplexFloat() && "Invalid accessor");
- return ((ComplexAPFloat*)(char*)Data.buffer)->Imag;
+ return ((ComplexAPFloat *)(char *)&Data)->Imag;
}
const APFloat &getComplexFloatImag() const {
return const_cast<APValue*>(this)->getComplexFloatImag();
@@ -477,20 +477,20 @@ class APValue {
APValue &getVectorElt(unsigned I) {
assert(isVector() && "Invalid accessor");
assert(I < getVectorLength() && "Index out of range");
- return ((Vec*)(char*)Data.buffer)->Elts[I];
+ return ((Vec *)(char *)&Data)->Elts[I];
}
const APValue &getVectorElt(unsigned I) const {
return const_cast<APValue*>(this)->getVectorElt(I);
}
unsigned getVectorLength() const {
assert(isVector() && "Invalid accessor");
- return ((const Vec*)(const void *)Data.buffer)->NumElts;
+ return ((const Vec *)(const void *)&Data)->NumElts;
}
APValue &getArrayInitializedElt(unsigned I) {
assert(isArray() && "Invalid accessor");
assert(I < getArrayInitializedElts() && "Index out of range");
- return ((Arr*)(char*)Data.buffer)->Elts[I];
+ return ((Arr *)(char *)&Data)->Elts[I];
}
const APValue &getArrayInitializedElt(unsigned I) const {
return const_cast<APValue*>(this)->getArrayInitializedElt(I);
@@ -501,35 +501,35 @@ class APValue {
APValue &getArrayFiller() {
assert(isArray() && "Invalid accessor");
assert(hasArrayFiller() && "No array filler");
- return ((Arr*)(char*)Data.buffer)->Elts[getArrayInitializedElts()];
+ return ((Arr *)(char *)&Data)->Elts[getArrayInitializedElts()];
}
const APValue &getArrayFiller() const {
return const_cast<APValue*>(this)->getArrayFiller();
}
unsigned getArrayInitializedElts() const {
assert(isArray() && "Invalid accessor");
- return ((const Arr*)(const void *)Data.buffer)->NumElts;
+ return ((const Arr *)(const void *)&Data)->NumElts;
}
unsigned getArraySize() const {
assert(isArray() && "Invalid accessor");
- return ((const Arr*)(const void *)Data.buffer)->ArrSize;
+ return ((const Arr *)(const void *)&Data)->ArrSize;
}
unsigned getStructNumBases() const {
assert(isStruct() && "Invalid accessor");
- return ((const StructData*)(const char*)Data.buffer)->NumBases;
+ return ((const StructData *)(const char *)&Data)->NumBases;
}
unsigned getStructNumFields() const {
assert(isStruct() && "Invalid accessor");
- return ((const StructData*)(const char*)Data.buffer)->NumFields;
+ return ((const StructData *)(const char *)&Data)->NumFields;
}
APValue &getStructBase(unsigned i) {
assert(isStruct() && "Invalid accessor");
- return ((StructData*)(char*)Data.buffer)->Elts[i];
+ return ((StructData *)(char *)&Data)->Elts[i];
}
APValue &getStructField(unsigned i) {
assert(isStruct() && "Invalid accessor");
- return ((StructData*)(char*)Data.buffer)->Elts[getStructNumBases() + i];
+ return ((StructData *)(char *)&Data)->Elts[getStructNumBases() + i];
}
const APValue &getStructBase(unsigned i) const {
return const_cast<APValue*>(this)->getStructBase(i);
@@ -540,11 +540,11 @@ class APValue {
const FieldDecl *getUnionField() const {
assert(isUnion() && "Invalid accessor");
- return ((const UnionData*)(const char*)Data.buffer)->Field;
+ return ((const UnionData *)(const char *)&Data)->Field;
}
APValue &getUnionValue() {
assert(isUnion() && "Invalid accessor");
- return *((UnionData*)(char*)Data.buffer)->Value;
+ return *((UnionData *)(char *)&Data)->Value;
}
const APValue &getUnionValue() const {
return const_cast<APValue*>(this)->getUnionValue();
@@ -556,24 +556,24 @@ class APValue {
const AddrLabelExpr* getAddrLabelDiffLHS() const {
assert(isAddrLabelDiff() && "Invalid accessor");
- return ((const AddrLabelDiffData*)(const char*)Data.buffer)->LHSExpr;
+ return ((const AddrLabelDiffData *)(const char *)&Data)->LHSExpr;
}
const AddrLabelExpr* getAddrLabelDiffRHS() const {
assert(isAddrLabelDiff() && "Invalid accessor");
- return ((const AddrLabelDiffData*)(const char*)Data.buffer)->RHSExpr;
+ return ((const AddrLabelDiffData *)(const char *)&Data)->RHSExpr;
}
void setInt(APSInt I) {
assert(isInt() && "Invalid accessor");
- *(APSInt *)(char *)Data.buffer = std::move(I);
+ *(APSInt *)(char *)&Data = std::move(I);
}
void setFloat(APFloat F) {
assert(isFloat() && "Invalid accessor");
- *(APFloat *)(char *)Data.buffer = std::move(F);
+ *(APFloat *)(char *)&Data = std::move(F);
}
void setFixedPoint(APFixedPoint FX) {
assert(isFixedPoint() && "Invalid accessor");
- *(APFixedPoint *)(char *)Data.buffer = std::move(FX);
+ *(APFixedPoint *)(char *)&Data = std::move(FX);
}
void setVector(const APValue *E, unsigned N) {
MutableArrayRef<APValue> InternalElts = setVectorUninit(N);
@@ -584,15 +584,15 @@ class APValue {
assert(R.getBitWidth() == I.getBitWidth() &&
"Invalid complex int (type mismatch).");
assert(isComplexInt() && "Invalid accessor");
- ((ComplexAPSInt *)(char *)Data.buffer)->Real = std::move(R);
- ((ComplexAPSInt *)(char *)Data.buffer)->Imag = std::move(I);
+ ((ComplexAPSInt *)(char *)&Data)->Real = std::move(R);
+ ((ComplexAPSInt *)(char *)&Data)->Imag = std::move(I);
}
void setComplexFloat(APFloat R, APFloat I) {
assert(&R.getSemantics() == &I.getSemantics() &&
"Invalid complex float (type mismatch).");
assert(isComplexFloat() && "Invalid accessor");
- ((ComplexAPFloat *)(char *)Data.buffer)->Real = std::move(R);
- ((ComplexAPFloat *)(char *)Data.buffer)->Imag = std::move(I);
+ ((ComplexAPFloat *)(char *)&Data)->Real = std::move(R);
+ ((ComplexAPFloat *)(char *)&Data)->Imag = std::move(I);
}
void setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
bool IsNullPtr);
@@ -602,59 +602,59 @@ class APValue {
void setUnion(const FieldDecl *Field, const APValue &Value);
void setAddrLabelDiff(const AddrLabelExpr* LHSExpr,
const AddrLabelExpr* RHSExpr) {
- ((AddrLabelDiffData*)(char*)Data.buffer)->LHSExpr = LHSExpr;
- ((AddrLabelDiffData*)(char*)Data.buffer)->RHSExpr = RHSExpr;
+ ((AddrLabelDiffData *)(char *)&Data)->LHSExpr = LHSExpr;
+ ((AddrLabelDiffData *)(char *)&Data)->RHSExpr = RHSExpr;
}
private:
void DestroyDataAndMakeUninit();
void MakeInt() {
assert(isAbsent() && "Bad state change");
- new ((void*)Data.buffer) APSInt(1);
+ new ((void *)&Data) APSInt(1);
Kind = Int;
}
void MakeFloat() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) APFloat(0.0);
+ new ((void *)(char *)&Data) APFloat(0.0);
Kind = Float;
}
void MakeFixedPoint(APFixedPoint &&FX) {
assert(isAbsent() && "Bad state change");
- new ((void *)(char *)Data.buffer) APFixedPoint(std::move(FX));
+ new ((void *)(char *)&Data) APFixedPoint(std::move(FX));
Kind = FixedPoint;
}
void MakeVector() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) Vec();
+ new ((void *)(char *)&Data) Vec();
Kind = Vector;
}
void MakeComplexInt() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) ComplexAPSInt();
+ new ((void *)(char *)&Data) ComplexAPSInt();
Kind = ComplexInt;
}
void MakeComplexFloat() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) ComplexAPFloat();
+ new ((void *)(char *)&Data) ComplexAPFloat();
Kind = ComplexFloat;
}
void MakeLValue();
void MakeArray(unsigned InitElts, unsigned Size);
void MakeStruct(unsigned B, unsigned M) {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) StructData(B, M);
+ new ((void *)(char *)&Data) StructData(B, M);
Kind = Struct;
}
void MakeUnion() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) UnionData();
+ new ((void *)(char *)&Data) UnionData();
Kind = Union;
}
void MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
ArrayRef<const CXXRecordDecl*> Path);
void MakeAddrLabelDiff() {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) AddrLabelDiffData();
+ new ((void *)(char *)&Data) AddrLabelDiffData();
Kind = AddrLabelDiff;
}
@@ -664,7 +664,7 @@ class APValue {
/// filled in by those steps.
MutableArrayRef<APValue> setVectorUninit(unsigned N) {
assert(isVector() && "Invalid accessor");
- Vec *V = ((Vec *)(char *)Data.buffer);
+ Vec *V = ((Vec *)(char *)&Data);
V->Elts = new APValue[N];
V->NumElts = N;
return {V->Elts, V->NumElts};
diff --git a/clang/include/clang/AST/ASTTypeTraits.h b/clang/include/clang/AST/ASTTypeTraits.h
index 034260cc8ed3..8791e41b9ac3 100644
--- a/clang/include/clang/AST/ASTTypeTraits.h
+++ b/clang/include/clang/AST/ASTTypeTraits.h
@@ -246,9 +246,8 @@ class DynTypedNode {
/// in the \c DynTypedNode, and the returned pointer points at
/// the storage inside DynTypedNode. For those nodes, do not
/// use the pointer outside the scope of the DynTypedNode.
- template <typename T>
- const T *get() const {
- return BaseConverter<T>::get(NodeKind, Storage.buffer);
+ template <typename T> const T *get() const {
+ return BaseConverter<T>::get(NodeKind, &Storage);
}
/// Retrieve the stored node as type \c T.
@@ -256,7 +255,7 @@ class DynTypedNode {
/// Similar to \c get(), but asserts that the type is what we are expecting.
template <typename T>
const T &getUnchecked() const {
- return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
+ return BaseConverter<T>::getUnchecked(NodeKind, &Storage);
}
ASTNodeKind getNodeKind() const { return NodeKind; }
@@ -268,7 +267,7 @@ class DynTypedNode {
/// method returns NULL.
const void *getMemoizationData() const {
return NodeKind.hasPointerIdentity()
- ? *reinterpret_cast<void *const *>(Storage.buffer)
+ ? *reinterpret_cast<void *const *>(&Storage)
: nullptr;
}
@@ -390,12 +389,12 @@ class DynTypedNode {
/// Converter that uses dyn_cast<T> from a stored BaseT*.
template <typename T, typename BaseT> struct DynCastPtrConverter {
- static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T *get(ASTNodeKind NodeKind, const void *Storage) {
if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
return &getUnchecked(NodeKind, Storage);
return nullptr;
}
- static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
assert(ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind));
return *cast<T>(static_cast<const BaseT *>(
*reinterpret_cast<const void *const *>(Storage)));
@@ -403,19 +402,19 @@ class DynTypedNode {
static DynTypedNode create(const BaseT &Node) {
DynTypedNode Result;
Result.NodeKind = ASTNodeKind::getFromNode(Node);
- new (Result.Storage.buffer) const void *(&Node);
+ new (&Result.Storage) const void *(&Node);
return Result;
}
};
/// Converter that stores T* (by pointer).
template <typename T> struct PtrConverter {
- static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T *get(ASTNodeKind NodeKind, const void *Storage) {
if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
return &getUnchecked(NodeKind, Storage);
return nullptr;
}
- static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
return *static_cast<const T *>(
*reinterpret_cast<const void *const *>(Storage));
@@ -423,26 +422,26 @@ class DynTypedNode {
static DynTypedNode create(const T &Node) {
DynTypedNode Result;
Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
- new (Result.Storage.buffer) const void *(&Node);
+ new (&Result.Storage) const void *(&Node);
return Result;
}
};
/// Converter that stores T (by value).
template <typename T> struct ValueConverter {
- static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T *get(ASTNodeKind NodeKind, const void *Storage) {
if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
return reinterpret_cast<const T *>(Storage);
return nullptr;
}
- static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
+ static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
return *reinterpret_cast<const T *>(Storage);
}
static DynTypedNode create(const T &Node) {
DynTypedNode Result;
Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
- new (Result.Storage.buffer) T(Node);
+ new (&Result.Storage) T(Node);
return Result;
}
};
diff --git a/clang/include/clang/AST/ParentMapContext.h b/clang/include/clang/AST/ParentMapContext.h
index be4d75df7b99..a0412380a864 100644
--- a/clang/include/clang/AST/ParentMapContext.h
+++ b/clang/include/clang/AST/ParentMapContext.h
@@ -94,25 +94,24 @@ class DynTypedNodeList {
public:
DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) {
- new (Storage.buffer) DynTypedNode(N);
+ new (&Storage) DynTypedNode(N);
}
DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) {
- new (Storage.buffer) ArrayRef<DynTypedNode>(A);
+ new (&Storage) ArrayRef<DynTypedNode>(A);
}
const DynTypedNode *begin() const {
if (!IsSingleNode)
- return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
+ return reinterpret_cast<const ArrayRef<DynTypedNode> *>(&Storage)
->begin();
- return reinterpret_cast<const DynTypedNode *>(Storage.buffer);
+ return reinterpret_cast<const DynTypedNode *>(&Storage);
}
const DynTypedNode *end() const {
if (!IsSingleNode)
- return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
- ->end();
- return reinterpret_cast<const DynTypedNode *>(Storage.buffer) + 1;
+ return reinterpret_cast<const ArrayRef<DynTypedNode> *>(&Storage)->end();
+ return reinterpret_cast<const DynTypedNode *>(&Storage) + 1;
}
size_t size() const { return end() - begin(); }
diff --git a/clang/lib/AST/APValue.cpp b/clang/lib/AST/APValue.cpp
index c249e778db48..5b340e6e85bd 100644
--- a/clang/lib/AST/APValue.cpp
+++ b/clang/lib/AST/APValue.cpp
@@ -321,7 +321,7 @@ APValue::APValue(const APValue &RHS) : Kind(None) {
}
case Vector:
MakeVector();
- setVector(((const Vec *)(const char *)RHS.Data.buffer)->Elts,
+ setVector(((const Vec *)(const char *)&RHS.Data)->Elts,
RHS.getVectorLength());
break;
case ComplexInt:
@@ -392,29 +392,29 @@ APValue &APValue::operator=(APValue &&RHS) {
void APValue::DestroyDataAndMakeUninit() {
if (Kind == Int)
- ((APSInt*)(char*)Data.buffer)->~APSInt();
+ ((APSInt *)(char *)&Data)->~APSInt();
else if (Kind == Float)
- ((APFloat*)(char*)Data.buffer)->~APFloat();
+ ((APFloat *)(char *)&Data)->~APFloat();
else if (Kind == FixedPoint)
- ((APFixedPoint *)(char *)Data.buffer)->~APFixedPoint();
+ ((APFixedPoint *)(char *)&Data)->~APFixedPoint();
else if (Kind == Vector)
- ((Vec*)(char*)Data.buffer)->~Vec();
+ ((Vec *)(char *)&Data)->~Vec();
else if (Kind == ComplexInt)
- ((ComplexAPSInt*)(char*)Data.buffer)->~ComplexAPSInt();
+ ((ComplexAPSInt *)(char *)&Data)->~ComplexAPSInt();
else if (Kind == ComplexFloat)
- ((ComplexAPFloat*)(char*)Data.buffer)->~ComplexAPFloat();
+ ((ComplexAPFloat *)(char *)&Data)->~ComplexAPFloat();
else if (Kind == LValue)
- ((LV*)(char*)Data.buffer)->~LV();
+ ((LV *)(char *)&Data)->~LV();
else if (Kind == Array)
- ((Arr*)(char*)Data.buffer)->~Arr();
+ ((Arr *)(char *)&Data)->~Arr();
else if (Kind == Struct)
- ((StructData*)(char*)Data.buffer)->~StructData();
+ ((StructData *)(char *)&Data)->~StructData();
else if (Kind == Union)
- ((UnionData*)(char*)Data.buffer)->~UnionData();
+ ((UnionData *)(char *)&Data)->~UnionData();
else if (Kind == MemberPointer)
- ((MemberPointerData*)(char*)Data.buffer)->~MemberPointerData();
+ ((MemberPointerData *)(char *)&Data)->~MemberPointerData();
else if (Kind == AddrLabelDiff)
- ((AddrLabelDiffData*)(char*)Data.buffer)->~AddrLabelDiffData();
+ ((AddrLabelDiffData *)(char *)&Data)->~AddrLabelDiffData();
Kind = None;
}
@@ -448,10 +448,9 @@ bool APValue::needsCleanup() const {
"same size.");
return getComplexIntReal().needsCleanup();
case LValue:
- return reinterpret_cast<const LV *>(Data.buffer)->hasPathPtr();
+ return reinterpret_cast<const LV *>(&Data)->hasPathPtr();
case MemberPointer:
- return reinterpret_cast<const MemberPointerData *>(Data.buffer)
- ->hasPathPtr();
+ return reinterpret_cast<const MemberPointerData *>(&Data)->hasPathPtr();
}
llvm_unreachable("Unknown APValue kind!");
}
@@ -885,49 +884,49 @@ bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
const APValue::LValueBase APValue::getLValueBase() const {
assert(isLValue() && "Invalid accessor");
- return ((const LV*)(const void*)Data.buffer)->Base;
+ return ((const LV *)(const void *)&Data)->Base;
}
bool APValue::isLValueOnePastTheEnd() const {
assert(isLValue() && "Invalid accessor");
- return ((const LV*)(const void*)Data.buffer)->IsOnePastTheEnd;
+ return ((const LV *)(const void *)&Data)->IsOnePastTheEnd;
}
CharUnits &APValue::getLValueOffset() {
assert(isLValue() && "Invalid accessor");
- return ((LV*)(void*)Data.buffer)->Offset;
+ return ((LV *)(void *)&Data)->Offset;
}
bool APValue::hasLValuePath() const {
assert(isLValue() && "Invalid accessor");
- return ((const LV*)(const char*)Data.buffer)->hasPath();
+ return ((const LV *)(const char *)&Data)->hasPath();
}
ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const {
assert(isLValue() && hasLValuePath() && "Invalid accessor");
- const LV &LVal = *((const LV*)(const char*)Data.buffer);
+ const LV &LVal = *((const LV *)(const char *)&Data);
return llvm::makeArrayRef(LVal.getPath(), LVal.PathLength);
}
unsigned APValue::getLValueCallIndex() const {
assert(isLValue() && "Invalid accessor");
- return ((const LV*)(const char*)Data.buffer)->Base.getCallIndex();
+ return ((const LV *)(const char *)&Data)->Base.getCallIndex();
}
unsigned APValue::getLValueVersion() const {
assert(isLValue() && "Invalid accessor");
- return ((const LV*)(const char*)Data.buffer)->Base.getVersion();
+ return ((const LV *)(const char *)&Data)->Base.getVersion();
}
bool APValue::isNullPointer() const {
assert(isLValue() && "Invalid usage");
- return ((const LV*)(const char*)Data.buffer)->IsNullPtr;
+ return ((const LV *)(const char *)&Data)->IsNullPtr;
}
void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
bool IsNullPtr) {
assert(isLValue() && "Invalid accessor");
- LV &LVal = *((LV*)(char*)Data.buffer);
+ LV &LVal = *((LV *)(char *)&Data);
LVal.Base = B;
LVal.IsOnePastTheEnd = false;
LVal.Offset = O;
@@ -939,7 +938,7 @@ MutableArrayRef<APValue::LValuePathEntry>
APValue::setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size,
bool IsOnePastTheEnd, bool IsNullPtr) {
assert(isLValue() && "Invalid accessor");
- LV &LVal = *((LV *)(char *)Data.buffer);
+ LV &LVal = *((LV *)(char *)&Data);
LVal.Base = B;
LVal.IsOnePastTheEnd = IsOnePastTheEnd;
LVal.Offset = O;
@@ -959,42 +958,42 @@ void APValue::setLValue(LValueBase B, const CharUnits &O,
void APValue::setUnion(const FieldDecl *Field, const APValue &Value) {
assert(isUnion() && "Invalid accessor");
- ((UnionData *)(char *)Data.buffer)->Field =
+ ((UnionData *)(char *)&Data)->Field =
Field ? Field->getCanonicalDecl() : nullptr;
- *((UnionData*)(char*)Data.buffer)->Value = Value;
+ *((UnionData *)(char *)&Data)->Value = Value;
}
const ValueDecl *APValue::getMemberPointerDecl() const {
assert(isMemberPointer() && "Invalid accessor");
const MemberPointerData &MPD =
- *((const MemberPointerData *)(const char *)Data.buffer);
+ *((const MemberPointerData *)(const char *)&Data);
return MPD.MemberAndIsDerivedMember.getPointer();
}
bool APValue::isMemberPointerToDerivedMember() const {
assert(isMemberPointer() && "Invalid accessor");
const MemberPointerData &MPD =
- *((const MemberPointerData *)(const char *)Data.buffer);
+ *((const MemberPointerData *)(const char *)&Data);
return MPD.MemberAndIsDerivedMember.getInt();
}
ArrayRef<const CXXRecordDecl*> APValue::getMemberPointerPath() const {
assert(isMemberPointer() && "Invalid accessor");
const MemberPointerData &MPD =
- *((const MemberPointerData *)(const char *)Data.buffer);
+ *((const MemberPointerData *)(const char *)&Data);
return llvm::makeArrayRef(MPD.getPath(), MPD.PathLength);
}
void APValue::MakeLValue() {
assert(isAbsent() && "Bad state change");
static_assert(sizeof(LV) <= DataSize, "LV too big");
- new ((void*)(char*)Data.buffer) LV();
+ new ((void *)(char *)&Data) LV();
Kind = LValue;
}
void APValue::MakeArray(unsigned InitElts, unsigned Size) {
assert(isAbsent() && "Bad state change");
- new ((void*)(char*)Data.buffer) Arr(InitElts, Size);
+ new ((void *)(char *)&Data) Arr(InitElts, Size);
Kind = Array;
}
@@ -1006,7 +1005,7 @@ MutableArrayRef<const CXXRecordDecl *>
APValue::setMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember,
unsigned Size) {
assert(isAbsent() && "Bad state change");
- MemberPointerData *MPD = new ((void *)(char *)Data.buffer) MemberPointerData;
+ MemberPointerData *MPD = new ((void *)(char *)&Data) MemberPointerData;
Kind = MemberPointer;
MPD->MemberAndIsDerivedMember.setPointer(
Member ? cast<ValueDecl>(Member->getCanonicalDecl()) : nullptr);
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 7a1415b658b8..a74e316f688e 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -9000,26 +9000,23 @@ ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
Result.MakeVector();
MutableArrayRef<APValue> Elts =
Result.setVectorUninit(FromValue.getVectorLength());
- ImportLoop(
- ((const APValue::Vec *)(const char *)FromValue.Data.buffer)->Elts,
- Elts.data(), FromValue.getVectorLength());
+ ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
+ Elts.data(), FromValue.getVectorLength());
break;
}
case APValue::Array:
Result.MakeArray(FromValue.getArrayInitializedElts(),
FromValue.getArraySize());
- ImportLoop(
- ((const APValue::Arr *)(const char *)FromValue.Data.buffer)->Elts,
- ((const APValue::Arr *)(const char *)Result.Data.buffer)->Elts,
- FromValue.getArrayInitializedElts());
+ ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
+ ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
+ FromValue.getArrayInitializedElts());
break;
case APValue::Struct:
Result.MakeStruct(FromValue.getStructNumBases(),
FromValue.getStructNumFields());
ImportLoop(
- ((const APValue::StructData *)(const char *)FromValue.Data.buffer)
- ->Elts,
- ((const APValue::StructData *)(const char *)Result.Data.buffer)->Elts,
+ ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
+ ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
FromValue.getStructNumBases() + FromValue.getStructNumFields());
break;
case APValue::Union: {
diff --git a/clang/lib/Frontend/PrecompiledPreamble.cpp b/clang/lib/Frontend/PrecompiledPreamble.cpp
index 0f4259900ec2..49aab8132cc3 100644
--- a/clang/lib/Frontend/PrecompiledPreamble.cpp
+++ b/clang/lib/Frontend/PrecompiledPreamble.cpp
@@ -735,7 +735,7 @@ PrecompiledPreamble::PCHStorage::getKind() const {
PrecompiledPreamble::TempPCHFile &PrecompiledPreamble::PCHStorage::asFile() {
assert(getKind() == Kind::TempFile);
- return *reinterpret_cast<TempPCHFile *>(Storage.buffer);
+ return *reinterpret_cast<TempPCHFile *>(&Storage);
}
const PrecompiledPreamble::TempPCHFile &
@@ -746,7 +746,7 @@ PrecompiledPreamble::PCHStorage::asFile() const {
PrecompiledPreamble::InMemoryPreamble &
PrecompiledPreamble::PCHStorage::asMemory() {
assert(getKind() == Kind::InMemory);
- return *reinterpret_cast<InMemoryPreamble *>(Storage.buffer);
+ return *reinterpret_cast<InMemoryPreamble *>(&Storage);
}
const PrecompiledPreamble::InMemoryPreamble &
diff --git a/llvm/include/llvm/ADT/DenseMap.h b/llvm/include/llvm/ADT/DenseMap.h
index 7f7a4593ae36..c9bf762a2406 100644
--- a/llvm/include/llvm/ADT/DenseMap.h
+++ b/llvm/include/llvm/ADT/DenseMap.h
@@ -1042,7 +1042,7 @@ class SmallDenseMap
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
- BucketT *TmpBegin = reinterpret_cast<BucketT *>(TmpStorage.buffer);
+ BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
BucketT *TmpEnd = TmpBegin;
// Loop over the buckets, moving non-empty, non-tombstones into the
@@ -1132,8 +1132,8 @@ class SmallDenseMap
assert(Small);
// Note that this cast does not violate aliasing rules as we assert that
// the memory's dynamic type is the small, inline bucket buffer, and the
- // 'storage.buffer' static type is 'char *'.
- return reinterpret_cast<const BucketT *>(storage.buffer);
+ // 'storage' is a POD containing a char buffer.
+ return reinterpret_cast<const BucketT *>(&storage);
}
BucketT *getInlineBuckets() {
@@ -1144,7 +1144,7 @@ class SmallDenseMap
const LargeRep *getLargeRep() const {
assert(!Small);
// Note, same rule about aliasing as with getInlineBuckets.
- return reinterpret_cast<const LargeRep *>(storage.buffer);
+ return reinterpret_cast<const LargeRep *>(&storage);
}
LargeRep *getLargeRep() {
diff --git a/llvm/include/llvm/ADT/IntervalMap.h b/llvm/include/llvm/ADT/IntervalMap.h
index b6c9fc79108c..0b6c7d667807 100644
--- a/llvm/include/llvm/ADT/IntervalMap.h
+++ b/llvm/include/llvm/ADT/IntervalMap.h
@@ -978,10 +978,7 @@ class IntervalMap {
Allocator &allocator;
/// Represent data as a node type without breaking aliasing rules.
- template <typename T>
- T &dataAs() const {
- return *bit_cast<T *>(const_cast<char *>(data.buffer));
- }
+ template <typename T> T &dataAs() const { return *bit_cast<T *>(&data); }
const RootLeaf &rootLeaf() const {
assert(!branched() && "Cannot acces leaf data in branched root");
@@ -1039,7 +1036,7 @@ class IntervalMap {
public:
explicit IntervalMap(Allocator &a) : height(0), rootSize(0), allocator(a) {
- assert((uintptr_t(data.buffer) & (alignof(RootLeaf) - 1)) == 0 &&
+ assert((uintptr_t(&data) & (alignof(RootLeaf) - 1)) == 0 &&
"Insufficient alignment");
new(&rootLeaf()) RootLeaf();
}
diff --git a/llvm/include/llvm/CodeGen/DIE.h b/llvm/include/llvm/CodeGen/DIE.h
index eaa700f9e1e2..1667cf8cd06d 100644
--- a/llvm/include/llvm/CodeGen/DIE.h
+++ b/llvm/include/llvm/CodeGen/DIE.h
@@ -383,12 +383,12 @@ class DIEValue {
static_assert(std::is_standard_layout<T>::value ||
std::is_pointer<T>::value,
"Expected standard layout or pointer");
- new (reinterpret_cast<void *>(Val.buffer)) T(V);
+ new (reinterpret_cast<void *>(&Val)) T(V);
}
- template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
+ template <class T> T *get() { return reinterpret_cast<T *>(&Val); }
template <class T> const T *get() const {
- return reinterpret_cast<const T *>(Val.buffer);
+ return reinterpret_cast<const T *>(&Val);
}
template <class T> void destruct() { get<T>()->~T(); }
diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h
index 9dd1bb7cb96d..c0f7c10aefb4 100644
--- a/llvm/include/llvm/Support/Error.h
+++ b/llvm/include/llvm/Support/Error.h
@@ -629,22 +629,22 @@ template <class T> class LLVM_NODISCARD Expected {
storage_type *getStorage() {
assert(!HasError && "Cannot get value when an error exists!");
- return reinterpret_cast<storage_type *>(TStorage.buffer);
+ return reinterpret_cast<storage_type *>(&TStorage);
}
const storage_type *getStorage() const {
assert(!HasError && "Cannot get value when an error exists!");
- return reinterpret_cast<const storage_type *>(TStorage.buffer);
+ return reinterpret_cast<const storage_type *>(&TStorage);
}
error_type *getErrorStorage() {
assert(HasError && "Cannot get error when a value exists!");
- return reinterpret_cast<error_type *>(ErrorStorage.buffer);
+ return reinterpret_cast<error_type *>(&ErrorStorage);
}
const error_type *getErrorStorage() const {
assert(HasError && "Cannot get error when a value exists!");
- return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
+ return reinterpret_cast<const error_type *>(&ErrorStorage);
}
// Used by ExpectedAsOutParameter to reset the checked flag.
diff --git a/llvm/include/llvm/Support/ErrorOr.h b/llvm/include/llvm/Support/ErrorOr.h
index 1fbccc1d1e26..b654c9c9c43b 100644
--- a/llvm/include/llvm/Support/ErrorOr.h
+++ b/llvm/include/llvm/Support/ErrorOr.h
@@ -235,17 +235,17 @@ class ErrorOr {
storage_type *getStorage() {
assert(!HasError && "Cannot get value when an error exists!");
- return reinterpret_cast<storage_type*>(TStorage.buffer);
+ return reinterpret_cast<storage_type *>(&TStorage);
}
const storage_type *getStorage() const {
assert(!HasError && "Cannot get value when an error exists!");
- return reinterpret_cast<const storage_type*>(TStorage.buffer);
+ return reinterpret_cast<const storage_type *>(&TStorage);
}
std::error_code *getErrorStorage() {
assert(HasError && "Cannot get error when a value exists!");
- return reinterpret_cast<std::error_code *>(ErrorStorage.buffer);
+ return reinterpret_cast<std::error_code *>(&ErrorStorage);
}
const std::error_code *getErrorStorage() const {
diff --git a/llvm/include/llvm/Support/JSON.h b/llvm/include/llvm/Support/JSON.h
index 9a8f915eeef7..c753cee60ec1 100644
--- a/llvm/include/llvm/Support/JSON.h
+++ b/llvm/include/llvm/Support/JSON.h
@@ -456,12 +456,12 @@ class Value {
friend class Object;
template <typename T, typename... U> void create(U &&... V) {
- new (reinterpret_cast<T *>(Union.buffer)) T(std::forward<U>(V)...);
+ new (reinterpret_cast<T *>(&Union)) T(std::forward<U>(V)...);
}
template <typename T> T &as() const {
// Using this two-step static_cast via void * instead of reinterpret_cast
// silences a -Wstrict-aliasing false positive from GCC6 and earlier.
- void *Storage = static_cast<void *>(Union.buffer);
+ void *Storage = static_cast<void *>(&Union);
return *static_cast<T *>(Storage);
}
diff --git a/llvm/lib/Support/JSON.cpp b/llvm/lib/Support/JSON.cpp
index 8471e5818cbb..dbfd673553f4 100644
--- a/llvm/lib/Support/JSON.cpp
+++ b/llvm/lib/Support/JSON.cpp
@@ -109,7 +109,7 @@ void Value::copyFrom(const Value &M) {
case T_Boolean:
case T_Double:
case T_Integer:
- memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer));
+ memcpy(&Union, &M.Union, sizeof(Union));
break;
case T_StringRef:
create<StringRef>(M.as<StringRef>());
@@ -133,7 +133,7 @@ void Value::moveFrom(const Value &&M) {
case T_Boolean:
case T_Double:
case T_Integer:
- memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer));
+ memcpy(&Union, &M.Union, sizeof(Union));
break;
case T_StringRef:
create<StringRef>(M.as<StringRef>());
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
index bf356d0de94b..74ba23d343a0 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
@@ -82,11 +82,11 @@ namespace {
private:
bool insaneIntVal(int V) { return V > 4 || V < -4; }
- APFloat *getFpValPtr()
- { return reinterpret_cast<APFloat *>(&FpValBuf.buffer[0]); }
+ APFloat *getFpValPtr() { return reinterpret_cast<APFloat *>(&FpValBuf); }
- const APFloat *getFpValPtr() const
- { return reinterpret_cast<const APFloat *>(&FpValBuf.buffer[0]); }
+ const APFloat *getFpValPtr() const {
+ return reinterpret_cast<const APFloat *>(&FpValBuf);
+ }
const APFloat &getFpVal() const {
assert(IsFp && BufHasFpVal && "Incorret state");
More information about the llvm-branch-commits
mailing list