[DataLayout] Add byte specification

This patch adds byte specification to data layout string.
The specification is `b:<size>`, where `<size>` is the size of a byte
in bits (later referred to as "byte width").

Limitations:
* The only values allowed for byte width are 8, 16, and 32.
16-bit bytes are popular, and my downstream target has 32-bit bytes.
These are the widths I'm going to add tests for in follow-up patches,
so this restriction only exists because other widths are untested.
* It is assumed that bytes are the same in all address spaces.
Supporting different byte widths in different address spaces would
require adding an address space argument to all DataLayout methods
that query ABI / preferred alignments because they return *byte*
alignments, and those will be different for different address spaces.
This is too much effort, but it can be done in the future if the need
arises, the specification reserves address space number before ':'.

Author: s-barannikov

llvm/include/llvm/IR/DataLayout.h

@@ -91,6 +91,9 @@ class DataLayout {
 private:
   bool BigEndian = false;
 
+  /// The size of a byte in bits.
+  unsigned ByteWidth = 8;
+
   unsigned AllocaAddrSpace = 0;
   unsigned ProgramAddrSpace = 0;
   unsigned DefaultGlobalsAddrSpace = 0;
@@ -155,6 +158,9 @@ class DataLayout {
   /// Internal helper method that returns requested alignment for type.
   Align getAlignment(Type *Ty, bool abi_or_pref) const;
 
+  /// Attempts to parse a byte specification ('b').
+  Error parseByteSpec(StringRef Spec);
+
   /// Attempts to parse primitive specification ('i', 'f', or 'v').
   Error parsePrimitiveSpec(StringRef Spec);
 
@@ -195,6 +201,9 @@ class DataLayout {
   bool isLittleEndian() const { return !BigEndian; }
   bool isBigEndian() const { return BigEndian; }
 
+  /// Returns the size of a byte, in bits.
+  unsigned getByteWidth() const { return ByteWidth; }
+
   /// Returns the string representation of the DataLayout.
   ///
   /// This representation is in the same format accepted by the string
@@ -364,7 +373,7 @@ class DataLayout {
 
   /// Returns the maximum index size over all address spaces.
   unsigned getMaxIndexSizeInBits() const {
-    return getMaxIndexSize() * 8;
+    return getMaxIndexSize() * ByteWidth;
   }
 
   /// Size in bits of index used for address calculation in getelementptr.
@@ -384,7 +393,7 @@ class DataLayout {
   unsigned getIndexTypeSizeInBits(Type *Ty) const;
 
   unsigned getPointerTypeSize(Type *Ty) const {
-    return getPointerTypeSizeInBits(Ty) / 8;
+    return getPointerTypeSizeInBits(Ty) / ByteWidth;
   }
 
   /// Size examples:
@@ -422,7 +431,8 @@ class DataLayout {
   /// For example, returns 5 for i36 and 10 for x86_fp80.
   TypeSize getTypeStoreSize(Type *Ty) const {
     TypeSize BaseSize = getTypeSizeInBits(Ty);
-    return {divideCeil(BaseSize.getKnownMinValue(), 8), BaseSize.isScalable()};
+    return {divideCeil(BaseSize.getKnownMinValue(), ByteWidth),
+            BaseSize.isScalable()};
   }
 
   /// Returns the maximum number of bits that may be overwritten by
@@ -433,7 +443,7 @@ class DataLayout {
   ///
   /// For example, returns 40 for i36 and 80 for x86_fp80.
   TypeSize getTypeStoreSizeInBits(Type *Ty) const {
-    return 8 * getTypeStoreSize(Ty);
+    return getTypeStoreSize(Ty) * ByteWidth;
   }
 
   /// Returns true if no extra padding bits are needed when storing the
@@ -466,7 +476,7 @@ class DataLayout {
   /// This is the amount that alloca reserves for this type. For example,
   /// returns 96 or 128 for x86_fp80, depending on alignment.
   TypeSize getTypeAllocSizeInBits(Type *Ty) const {
-    return 8 * getTypeAllocSize(Ty);
+    return getTypeAllocSize(Ty) * ByteWidth;
   }
 
   /// Returns the minimum ABI-required alignment for the specified type.
@@ -565,13 +575,14 @@ inline LLVMTargetDataRef wrap(const DataLayout *P) {
 class StructLayout final : public TrailingObjects<StructLayout, TypeSize> {
   TypeSize StructSize;
   Align StructAlignment;
+  unsigned ByteWidth;
   unsigned IsPadded : 1;
   unsigned NumElements : 31;
 
 public:
   TypeSize getSizeInBytes() const { return StructSize; }
 
-  TypeSize getSizeInBits() const { return 8 * StructSize; }
+  TypeSize getSizeInBits() const { return StructSize * ByteWidth; }
 
   Align getAlignment() const { return StructAlignment; }
 
@@ -597,7 +608,7 @@ class StructLayout final : public TrailingObjects<StructLayout, TypeSize> {
   }
 
   TypeSize getElementOffsetInBits(unsigned Idx) const {
-    return getElementOffset(Idx) * 8;
+    return getElementOffset(Idx) * ByteWidth;
   }
 
 private:

llvm/lib/IR/DataLayout.cpp

@@ -46,7 +46,7 @@ using namespace llvm;
 //===----------------------------------------------------------------------===//
 
 StructLayout::StructLayout(StructType *ST, const DataLayout &DL)
-    : StructSize(TypeSize::getFixed(0)) {
+    : StructSize(TypeSize::getFixed(0)), ByteWidth(DL.getByteWidth()) {
   assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
   IsPadded = false;
   NumElements = ST->getNumElements();
@@ -225,6 +225,7 @@ DataLayout &DataLayout::operator=(const DataLayout &Other) {
   LayoutMap = nullptr;
   StringRepresentation = Other.StringRepresentation;
   BigEndian = Other.BigEndian;
+  ByteWidth = Other.ByteWidth;
   AllocaAddrSpace = Other.AllocaAddrSpace;
   ProgramAddrSpace = Other.ProgramAddrSpace;
   DefaultGlobalsAddrSpace = Other.DefaultGlobalsAddrSpace;
@@ -246,7 +247,7 @@ DataLayout &DataLayout::operator=(const DataLayout &Other) {
 bool DataLayout::operator==(const DataLayout &Other) const {
   // NOTE: StringRepresentation might differ, it is not canonicalized.
   // FIXME: NonIntegralAddressSpaces isn't compared.
-  return BigEndian == Other.BigEndian &&
+  return BigEndian == Other.BigEndian && ByteWidth == Other.ByteWidth &&
          AllocaAddrSpace == Other.AllocaAddrSpace &&
          ProgramAddrSpace == Other.ProgramAddrSpace &&
          DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace &&
@@ -308,7 +309,7 @@ static Error parseSize(StringRef Str, unsigned &BitWidth,
 /// - the value is not a multiple of the byte width;
 /// - the value converted to byte amount is not not a power of two.
 static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name,
-                            bool AllowZero = false) {
+                            unsigned ByteWidth, bool AllowZero = false) {
   if (Str.empty())
     return createStringError(Name + " alignment component cannot be empty");
 
@@ -323,7 +324,6 @@ static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name,
     return Error::success();
   }
 
-  constexpr unsigned ByteWidth = 8;
   if (Value % ByteWidth || !isPowerOf2_32(Value / ByteWidth))
     return createStringError(
         Name + " alignment must be a power of two times the byte width");
@@ -332,6 +332,36 @@ static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name,
   return Error::success();
 }
 
+Error DataLayout::parseByteSpec(StringRef Spec) {
+  // b:<size>
+  assert(Spec.front() == 'b');
+  StringRef Rest = Spec.drop_front();
+  if (!Rest.consume_front(":") || Rest.empty())
+    return createSpecFormatError("b:<size>");
+
+  if (Error Err = parseSize(Rest, ByteWidth))
+    return Err;
+
+  if (ByteWidth != 8 && ByteWidth != 16 && ByteWidth != 32)
+    return createStringError("unsupported byte width");
+
+  // The default specs are for targets with 8-bit bytes. If the explicitly
+  // specified byte width is different from 8, reset the default values.
+  if (ByteWidth != 8) {
+    // Byte-sized integers must be one byte aligned. It's hard to guess
+    // reasonable defaults for other types, so just don't provide them
+    // and expect the target to do it.
+    IntSpecs.assign({PrimitiveSpec{ByteWidth, Align(1), Align(1)}});
+    FloatSpecs.clear();
+    VectorSpecs.clear();
+    PointerSpecs.clear();
+    StructABIAlignment = Align(1);
+    StructPrefAlignment = Align(1);
+  }
+
+  return Error::success();
+}
+
 Error DataLayout::parsePrimitiveSpec(StringRef Spec) {
   // [ifv]<size>:<abi>[:<pref>]
   SmallVector<StringRef, 3> Components;
@@ -349,7 +379,7 @@ Error DataLayout::parsePrimitiveSpec(StringRef Spec) {
 
   // ABI alignment.
   Align ABIAlign;
-  if (Error Err = parseAlignment(Components[1], ABIAlign, "ABI"))
+  if (Error Err = parseAlignment(Components[1], ABIAlign, "ABI", ByteWidth))
     return Err;
 
   if (Specifier == 'i' && BitWidth == 8 && ABIAlign != 1)
@@ -358,7 +388,8 @@ Error DataLayout::parsePrimitiveSpec(StringRef Spec) {
   // Preferred alignment. Optional, defaults to the ABI alignment.
   Align PrefAlign = ABIAlign;
   if (Components.size() > 2)
-    if (Error Err = parseAlignment(Components[2], PrefAlign, "preferred"))
+    if (Error Err =
+            parseAlignment(Components[2], PrefAlign, "preferred", ByteWidth))
       return Err;
 
   if (PrefAlign < ABIAlign)
@@ -389,14 +420,15 @@ Error DataLayout::parseAggregateSpec(StringRef Spec) {
 
   // ABI alignment. Required. Can be zero, meaning use one byte alignment.
   Align ABIAlign;
-  if (Error Err =
-          parseAlignment(Components[1], ABIAlign, "ABI", /*AllowZero=*/true))
+  if (Error Err = parseAlignment(Components[1], ABIAlign, "ABI", ByteWidth,
+                                 /*AllowZero=*/true))
     return Err;
 
   // Preferred alignment. Optional, defaults to the ABI alignment.
   Align PrefAlign = ABIAlign;
   if (Components.size() > 2)
-    if (Error Err = parseAlignment(Components[2], PrefAlign, "preferred"))
+    if (Error Err =
+            parseAlignment(Components[2], PrefAlign, "preferred", ByteWidth))
       return Err;
 
   if (PrefAlign < ABIAlign)
@@ -430,14 +462,15 @@ Error DataLayout::parsePointerSpec(StringRef Spec) {
 
   // ABI alignment. Required, cannot be zero.
   Align ABIAlign;
-  if (Error Err = parseAlignment(Components[2], ABIAlign, "ABI"))
+  if (Error Err = parseAlignment(Components[2], ABIAlign, "ABI", ByteWidth))
     return Err;
 
   // Preferred alignment. Optional, defaults to the ABI alignment.
   // Cannot be zero.
   Align PrefAlign = ABIAlign;
   if (Components.size() > 3)
-    if (Error Err = parseAlignment(Components[3], PrefAlign, "preferred"))
+    if (Error Err =
+            parseAlignment(Components[3], PrefAlign, "preferred", ByteWidth))
       return Err;
 
   if (PrefAlign < ABIAlign)
@@ -519,7 +552,7 @@ Error DataLayout::parseSpecification(StringRef Spec) {
     if (Rest.empty())
       return createSpecFormatError("S<size>");
     Align Alignment;
-    if (Error Err = parseAlignment(Rest, Alignment, "stack natural"))
+    if (Error Err = parseAlignment(Rest, Alignment, "stack natural", ByteWidth))
       return Err;
     StackNaturalAlign = Alignment;
     break;
@@ -542,7 +575,7 @@ Error DataLayout::parseSpecification(StringRef Spec) {
                                Twine(Type) + "'");
     }
     Align Alignment;
-    if (Error Err = parseAlignment(Rest, Alignment, "ABI"))
+    if (Error Err = parseAlignment(Rest, Alignment, "ABI", ByteWidth))
       return Err;
     FunctionPtrAlign = Alignment;
     break;
@@ -614,9 +647,24 @@ Error DataLayout::parseLayoutString(StringRef LayoutString) {
 
   // Split the data layout string into specifications separated by '-' and
   // parse each specification individually, updating internal data structures.
-  for (StringRef Spec : split(LayoutString, '-')) {
+  SmallVector<StringRef, 16> Specs;
+  LayoutString.split(Specs, '-');
+
+  // On the first pass, diagnose empty specifications and parse the byte
+  // specification if there is one. The latter is necessary because other
+  // specifications may need the byte width for validation and to convert
+  // bit alignments to byte alignments.
+  for (StringRef Spec : Specs) {
     if (Spec.empty())
       return createStringError("empty specification is not allowed");
+    if (Spec.front() == 'b')
+      if (Error Err = parseByteSpec(Spec))
+        return Err;
+  }
+
+  for (StringRef Spec : split(LayoutString, '-')) {
+    if (Spec.front() == 'b')
+      continue;
     if (Error Err = parseSpecification(Spec))
       return Err;
   }
@@ -654,6 +702,7 @@ void DataLayout::setPrimitiveSpec(char Specifier, uint32_t BitWidth,
 
 const DataLayout::PointerSpec &
 DataLayout::getPointerSpec(uint32_t AddrSpace) const {
+  assert(!PointerSpecs.empty() && "No pointer specs are defined");
   if (AddrSpace != 0) {
     auto I = lower_bound(PointerSpecs, AddrSpace, LessPointerAddrSpace());
     if (I != PointerSpecs.end() && I->AddrSpace == AddrSpace)
@@ -723,14 +772,13 @@ Align DataLayout::getPointerPrefAlignment(unsigned AS) const {
 }
 
 unsigned DataLayout::getPointerSize(unsigned AS) const {
-  return divideCeil(getPointerSpec(AS).BitWidth, 8);
+  return divideCeil(getPointerSpec(AS).BitWidth, ByteWidth);
 }
 
 unsigned DataLayout::getMaxIndexSize() const {
   unsigned MaxIndexSize = 0;
   for (const PointerSpec &Spec : PointerSpecs)
-    MaxIndexSize =
-        std::max(MaxIndexSize, (unsigned)divideCeil(Spec.BitWidth, 8));
+    MaxIndexSize = std::max(MaxIndexSize, divideCeil(Spec.BitWidth, ByteWidth));
 
   return MaxIndexSize;
 }
@@ -743,7 +791,7 @@ unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
 }
 
 unsigned DataLayout::getIndexSize(unsigned AS) const {
-  return divideCeil(getPointerSpec(AS).IndexBitWidth, 8);
+  return divideCeil(getPointerSpec(AS).IndexBitWidth, ByteWidth);
 }
 
 unsigned DataLayout::getIndexTypeSizeInBits(Type *Ty) const {
@@ -807,7 +855,7 @@ Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
     // approximation of reality, and if the user wanted something less
     // less conservative, they should have specified it explicitly in the data
     // layout.
-    return Align(PowerOf2Ceil(BitWidth / 8));
+    return Align(PowerOf2Ceil(getTypeStoreSize(Ty).getFixedValue()));
   }
   case Type::FixedVectorTyID:
   case Type::ScalableVectorTyID: {