This revision was automatically updated to reflect the committed changes.
Closed by commit rG944691f0b7fa: [NFC][FE] Replace TypeSize with
StorageUnitSize (authored by Xiangling_L).
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D88260/new/
https://reviews.llvm.org/D88260
Files:
clang/lib/AST/RecordLayoutBuilder.cpp
Index: clang/lib/AST/RecordLayoutBuilder.cpp
===================================================================
--- clang/lib/AST/RecordLayoutBuilder.cpp
+++ clang/lib/AST/RecordLayoutBuilder.cpp
@@ -622,9 +622,10 @@
/// an adjacent bitfield if necessary. The unit in question is usually
/// a byte, but larger units are used if IsMsStruct.
unsigned char UnfilledBitsInLastUnit;
- /// LastBitfieldTypeSize - If IsMsStruct, represents the size of the type
- /// of the previous field if it was a bitfield.
- unsigned char LastBitfieldTypeSize;
+
+ /// LastBitfieldStorageUnitSize - If IsMsStruct, represents the size of the
+ /// storage unit of the previous field if it was a bitfield.
+ unsigned char LastBitfieldStorageUnitSize;
/// MaxFieldAlignment - The maximum allowed field alignment. This is set by
/// #pragma pack.
@@ -693,7 +694,7 @@
UnadjustedAlignment(CharUnits::One()), UseExternalLayout(false),
InferAlignment(false), Packed(false), IsUnion(false),
IsMac68kAlign(false), IsMsStruct(false), UnfilledBitsInLastUnit(0),
- LastBitfieldTypeSize(0), MaxFieldAlignment(CharUnits::Zero()),
+ LastBitfieldStorageUnitSize(0), MaxFieldAlignment(CharUnits::Zero()),
DataSize(0), NonVirtualSize(CharUnits::Zero()),
NonVirtualAlignment(CharUnits::One()),
PreferredNVAlignment(CharUnits::One()),
@@ -708,7 +709,7 @@
void LayoutFields(const RecordDecl *D);
void LayoutField(const FieldDecl *D, bool InsertExtraPadding);
- void LayoutWideBitField(uint64_t FieldSize, uint64_t TypeSize,
+ void LayoutWideBitField(uint64_t FieldSize, uint64_t StorageUnitSize,
bool FieldPacked, const FieldDecl *D);
void LayoutBitField(const FieldDecl *D);
@@ -1451,7 +1452,7 @@
}
void ItaniumRecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize,
- uint64_t TypeSize,
+ uint64_t StorageUnitSize,
bool FieldPacked,
const FieldDecl *D) {
assert(Context.getLangOpts().CPlusPlus &&
@@ -1481,7 +1482,7 @@
// We're not going to use any of the unfilled bits in the last byte.
UnfilledBitsInLastUnit = 0;
- LastBitfieldTypeSize = 0;
+ LastBitfieldStorageUnitSize = 0;
uint64_t FieldOffset;
uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;
@@ -1520,7 +1521,7 @@
bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
uint64_t FieldSize = D->getBitWidthValue(Context);
TypeInfo FieldInfo = Context.getTypeInfo(D->getType());
- uint64_t TypeSize = FieldInfo.Width;
+ uint64_t StorageUnitSize = FieldInfo.Width;
unsigned FieldAlign = FieldInfo.Align;
// UnfilledBitsInLastUnit is the difference between the end of the
@@ -1529,7 +1530,7 @@
// first bit offset available for non-bitfields). The current data
// size in bits is always a multiple of the char size; additionally,
// for ms_struct records it's also a multiple of the
- // LastBitfieldTypeSize (if set).
+ // LastBitfieldStorageUnitSize (if set).
// The struct-layout algorithm is dictated by the platform ABI,
// which in principle could use almost any rules it likes. In
@@ -1583,26 +1584,26 @@
// First, some simple bookkeeping to perform for ms_struct structs.
if (IsMsStruct) {
// The field alignment for integer types is always the size.
- FieldAlign = TypeSize;
+ FieldAlign = StorageUnitSize;
// If the previous field was not a bitfield, or was a bitfield
// with a different storage unit size, or if this field doesn't fit into
// the current storage unit, we're done with that storage unit.
- if (LastBitfieldTypeSize != TypeSize ||
+ if (LastBitfieldStorageUnitSize != StorageUnitSize ||
UnfilledBitsInLastUnit < FieldSize) {
// Also, ignore zero-length bitfields after non-bitfields.
- if (!LastBitfieldTypeSize && !FieldSize)
+ if (!LastBitfieldStorageUnitSize && !FieldSize)
FieldAlign = 1;
UnfilledBitsInLastUnit = 0;
- LastBitfieldTypeSize = 0;
+ LastBitfieldStorageUnitSize = 0;
}
}
// If the field is wider than its declared type, it follows
// different rules in all cases.
- if (FieldSize > TypeSize) {
- LayoutWideBitField(FieldSize, TypeSize, FieldPacked, D);
+ if (FieldSize > StorageUnitSize) {
+ LayoutWideBitField(FieldSize, StorageUnitSize, FieldPacked, D);
return;
}
@@ -1686,7 +1687,7 @@
// Compute the real offset.
if (FieldSize == 0 ||
(AllowPadding &&
- (FieldOffset & (FieldAlign-1)) + FieldSize > TypeSize)) {
+ (FieldOffset & (FieldAlign - 1)) + FieldSize > StorageUnitSize)) {
FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);
} else if (ExplicitFieldAlign &&
(MaxFieldAlignmentInBits == 0 ||
@@ -1700,7 +1701,8 @@
// Repeat the computation for diagnostic purposes.
if (FieldSize == 0 ||
(AllowPadding &&
- (UnpackedFieldOffset & (UnpackedFieldAlign-1)) + FieldSize > TypeSize))
+ (UnpackedFieldOffset & (UnpackedFieldAlign - 1)) + FieldSize >
+ StorageUnitSize))
UnpackedFieldOffset =
llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);
else if (ExplicitFieldAlign &&
@@ -1741,11 +1743,11 @@
// is a zero-width bitfield, in which case just use a size of 1.
uint64_t RoundedFieldSize;
if (IsMsStruct) {
- RoundedFieldSize =
- (FieldSize ? TypeSize : Context.getTargetInfo().getCharWidth());
+ RoundedFieldSize = (FieldSize ? StorageUnitSize
+ : Context.getTargetInfo().getCharWidth());
- // Otherwise, allocate just the number of bytes required to store
- // the bitfield.
+ // Otherwise, allocate just the number of bytes required to store
+ // the bitfield.
} else {
RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize, Context);
}
@@ -1757,15 +1759,15 @@
// We should have cleared UnfilledBitsInLastUnit in every case
// where we changed storage units.
if (!UnfilledBitsInLastUnit) {
- setDataSize(FieldOffset + TypeSize);
- UnfilledBitsInLastUnit = TypeSize;
+ setDataSize(FieldOffset + StorageUnitSize);
+ UnfilledBitsInLastUnit = StorageUnitSize;
}
UnfilledBitsInLastUnit -= FieldSize;
- LastBitfieldTypeSize = TypeSize;
+ LastBitfieldStorageUnitSize = StorageUnitSize;
- // Otherwise, bump the data size up to include the bitfield,
- // including padding up to char alignment, and then remember how
- // bits we didn't use.
+ // Otherwise, bump the data size up to include the bitfield,
+ // including padding up to char alignment, and then remember how
+ // bits we didn't use.
} else {
uint64_t NewSizeInBits = FieldOffset + FieldSize;
uint64_t CharAlignment = Context.getTargetInfo().getCharAlign();
@@ -1775,7 +1777,7 @@
// The only time we can get here for an ms_struct is if this is a
// zero-width bitfield, which doesn't count as anything for the
// purposes of unfilled bits.
- LastBitfieldTypeSize = 0;
+ LastBitfieldStorageUnitSize = 0;
}
// Update the size.
@@ -1825,7 +1827,7 @@
uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;
// Reset the unfilled bits.
UnfilledBitsInLastUnit = 0;
- LastBitfieldTypeSize = 0;
+ LastBitfieldStorageUnitSize = 0;
bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
