[CIR][Codegen][Lowering] Introduce new bitfield layout

clang/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -53,6 +53,18 @@ def CIR_IntType : CIR_Type<"Int", "int",
     std::string getAlias() const {
       return (isSigned() ? 's' : 'u') + std::to_string(getWidth()) + 'i';
     };
+
+    /// Returns a minimum bitwidth of cir::IntType
+    static unsigned minBitwidth() { return 8; }
+    /// Returns a maximum bitwidth of cir::IntType
+    static unsigned maxBitwidth() { return 64; }
+
+    /// Returns true if cir::IntType can be constructed from the provided bitwidth
+    static bool isValidBitwidth(unsigned width) {
+      return width >= minBitwidth()
+        && width <= maxBitwidth()
+        && llvm::isPowerOf2_32(width);
+    }
   }];
   let genVerifyDecl = 1;
 }

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -226,19 +226,15 @@ static bool isAAPCS(const TargetInfo &TargetInfo) {
 
 Address CIRGenFunction::getAddrOfBitFieldStorage(LValue base,
                                                  const FieldDecl *field,
-                                                 unsigned index,
-                                                 unsigned size) {
+                                                 mlir::Type fieldType,
+                                                 unsigned index) {
   if (index == 0)
     return base.getAddress();
-
   auto loc = getLoc(field->getLocation());
-  auto fieldType = builder.getUIntNTy(size);
-
   auto fieldPtr =
       mlir::cir::PointerType::get(getBuilder().getContext(), fieldType);
   auto sea = getBuilder().createGetMember(loc, fieldPtr, base.getPointer(),
                                           field->getName(), index);
-
   return Address(sea, CharUnits::One());
 }
 
@@ -268,14 +264,11 @@ LValue CIRGenFunction::buildLValueForBitField(LValue base,
     llvm_unreachable("NYI");
   }
 
-  const unsigned SS = useVolatile ? info.VolatileStorageSize : info.StorageSize;
-  Address Addr = getAddrOfBitFieldStorage(base, field, Idx, SS);
-  // Get the access type.
-  mlir::Type FieldIntTy = builder.getUIntNTy(SS);
+  Address Addr = getAddrOfBitFieldStorage(base, field, info.StorageType, Idx);
 
   auto loc = getLoc(field->getLocation());
-  if (Addr.getElementType() != FieldIntTy)
-    Addr = builder.createElementBitCast(loc, Addr, FieldIntTy);
+  if (Addr.getElementType() != info.StorageType)
+    Addr = builder.createElementBitCast(loc, Addr, info.StorageType);
 
   QualType fieldType =
       field->getType().withCVRQualifiers(base.getVRQualifiers());

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1468,7 +1468,7 @@ class CIRGenFunction : public CIRGenTypeCache {
   }
 
   Address getAddrOfBitFieldStorage(LValue base, const clang::FieldDecl *field,
-                                   unsigned index, unsigned size);
+                                   mlir::Type fieldType, unsigned index);
 
   /// Given an opaque value expression, return its LValue mapping if it exists,
   /// otherwise create one.

clang/lib/CIR/CodeGen/CIRGenRecordLayout.h

@@ -94,6 +94,9 @@ struct CIRGenBitFieldInfo {
   /// The name of a bitfield
   llvm::StringRef Name;
 
+  // The actual storage type for the bitfield
+  mlir::Type StorageType;
+
   CIRGenBitFieldInfo()
       : Offset(), Size(), IsSigned(), StorageSize(), VolatileOffset(),
         VolatileStorageSize() {}

clang/lib/CIR/CodeGen/CIRRecordLayoutBuilder.cpp

@@ -151,6 +151,20 @@ struct CIRRecordLowering final {
                                            numberOfChars.getQuantity());
   }
 
+  // This is different from LLVM traditional codegen because CIRGen uses arrays
+  // of bytes instead of arbitrary-sized integers. This is important for packed
+  // structures support.
+  mlir::Type getBitfieldStorageType(unsigned numBits) {
+    unsigned alignedBits = llvm::alignTo(numBits, astContext.getCharWidth());
+    if (mlir::cir::IntType::isValidBitwidth(alignedBits)) {
+      return builder.getUIntNTy(alignedBits);
+    } else {
+      mlir::Type type = getCharType();
+      return mlir::cir::ArrayType::get(type.getContext(), type,
+                                       alignedBits / astContext.getCharWidth());
+    }
+  }
+
   // Gets the llvm Basesubobject type from a CXXRecordDecl.
   mlir::Type getStorageType(const CXXRecordDecl *RD) {
     return cirGenTypes.getCIRGenRecordLayout(RD).getBaseSubobjectCIRType();
@@ -228,6 +242,7 @@ void CIRRecordLowering::setBitFieldInfo(const FieldDecl *FD,
   Info.Size = FD->getBitWidthValue(astContext);
   Info.StorageSize = getSizeInBits(StorageType).getQuantity();
   Info.StorageOffset = StartOffset;
+  Info.StorageType = StorageType;
   Info.Name = FD->getName();
 
   if (Info.Size > Info.StorageSize)
@@ -502,12 +517,6 @@ void CIRRecordLowering::accumulateBitFields(
   auto IsBetterAsSingleFieldRun = [&](uint64_t OffsetInRecord,
                                       uint64_t StartBitOffset,
                                       uint64_t nextTail = 0) {
-    if (OffsetInRecord >= 64 ||
-        (nextTail > StartBitOffset &&
-         nextTail - StartBitOffset >= 64)) { // See IntType::verify
-      return true;
-    }
-
     if (!cirGenTypes.getModule().getCodeGenOpts().FineGrainedBitfieldAccesses)
       return false;
     llvm_unreachable("NYI");
@@ -567,7 +576,8 @@ void CIRRecordLowering::accumulateBitFields(
     }
 
     // We've hit a break-point in the run and need to emit a storage field.
-    auto Type = getUIntNType(Tail - StartBitOffset);
+    auto Type = getBitfieldStorageType(Tail - StartBitOffset);
+
     // Add the storage member to the record and set the bitfield info for all of
     // the bitfields in the run. Bitfields get the offset of their storage but
     // come afterward and remain there after a stable sort.

clang/lib/CIR/Dialect/IR/CIRTypes.cpp

@@ -642,8 +642,9 @@ mlir::LogicalResult
 IntType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                 unsigned width, bool isSigned) {
 
-  if (width < 8 || width > 64) {
-    emitError() << "IntType only supports widths from 8 up to 64";
+  if (width < IntType::minBitwidth() || width > IntType::maxBitwidth()) {
+    emitError() << "IntType only supports widths from "
+                << IntType::minBitwidth() << "up to " << IntType::maxBitwidth();
     return mlir::failure();
   }
   if (width % 8 != 0) {

clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp

@@ -66,8 +66,6 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
 
   void runOnOp(Operation *op);
   void lowerGlobalOp(GlobalOp op);
-  void lowerGetBitfieldOp(GetBitfieldOp op);
-  void lowerSetBitfieldOp(SetBitfieldOp op);
   void lowerStdFindOp(StdFindOp op);
   void lowerIterBeginOp(IterBeginOp op);
   void lowerIterEndOp(IterEndOp op);
@@ -303,109 +301,6 @@ void LoweringPreparePass::buildCXXGlobalInitFunc() {
   builder.create<ReturnOp>(f.getLoc());
 }
 
-void LoweringPreparePass::lowerGetBitfieldOp(GetBitfieldOp op) {
-  CIRBaseBuilderTy builder(getContext());
-  builder.setInsertionPointAfter(op.getOperation());
-
-  auto info = op.getBitfieldInfo();
-  auto size = info.getSize();
-  auto storageType = info.getStorageType();
-  auto storageSize = storageType.cast<IntType>().getWidth();
-  auto offset = info.getOffset();
-  auto resultTy = op.getType();
-  auto addr = op.getAddr();
-  auto loc = addr.getLoc();
-  mlir::Value val = builder.create<mlir::cir::LoadOp>(
-      loc, storageType, op.getAddr(), /* deref */ false, op.getIsVolatile());
-  auto valWidth = val.getType().cast<IntType>().getWidth();
-
-  if (info.getIsSigned()) {
-    assert(static_cast<unsigned>(offset + size) <= storageSize);
-    mlir::Type typ =
-        mlir::cir::IntType::get(builder.getContext(), valWidth, true);
-
-    val = builder.createIntCast(val, typ);
-
-    unsigned highBits = storageSize - offset - size;
-    if (highBits)
-      val = builder.createShiftLeft(val, highBits);
-    if (offset + highBits)
-      val = builder.createShiftRight(val, offset + highBits);
-  } else {
-    if (offset)
-      val = builder.createShiftRight(val, offset);
-
-    if (static_cast<unsigned>(offset) + size < storageSize)
-      val = builder.createAnd(val, llvm::APInt::getLowBitsSet(valWidth, size));
-  }
-  val = builder.createIntCast(val, resultTy);
-
-  op.replaceAllUsesWith(val);
-  op.erase();
-}
-
-void LoweringPreparePass::lowerSetBitfieldOp(SetBitfieldOp op) {
-  CIRBaseBuilderTy builder(getContext());
-  builder.setInsertionPointAfter(op.getOperation());
-
-  auto srcVal = op.getSrc();
-  auto addr = op.getDst();
-  auto info = op.getBitfieldInfo();
-  auto size = info.getSize();
-  auto storageType = info.getStorageType();
-  auto storageSize = storageType.cast<IntType>().getWidth();
-  auto offset = info.getOffset();
-  auto resultTy = op.getType();
-  auto loc = addr.getLoc();
-
-  // Get the source value, truncated to the width of the bit-field.
-  srcVal = builder.createIntCast(op.getSrc(), storageType);
-  auto srcWidth = srcVal.getType().cast<IntType>().getWidth();
-
-  mlir::Value maskedVal = srcVal;
-
-  if (storageSize != size) {
-    assert(storageSize > size && "Invalid bitfield size.");
-
-    mlir::Value val = builder.create<mlir::cir::LoadOp>(loc, storageType, addr);
-
-    srcVal =
-        builder.createAnd(srcVal, llvm::APInt::getLowBitsSet(srcWidth, size));
-
-    maskedVal = srcVal;
-    if (offset)
-      srcVal = builder.createShiftLeft(srcVal, offset);
-
-    // Mask out the original value.
-    val = builder.createAnd(
-        val, ~llvm::APInt::getBitsSet(srcWidth, offset, offset + size));
-
-    // Or together the unchanged values and the source value.
-    srcVal = builder.createOr(val, srcVal);
-  }
-
-  builder.create<mlir::cir::StoreOp>(loc, srcVal, addr, op.getIsVolatile());
-
-  if (!op->getUses().empty()) {
-    mlir::Value resultVal = maskedVal;
-    resultVal = builder.createIntCast(resultVal, resultTy);
-
-    if (info.getIsSigned()) {
-      assert(size <= storageSize);
-      unsigned highBits = storageSize - size;
-
-      if (highBits) {
-        resultVal = builder.createShiftLeft(resultVal, highBits);
-        resultVal = builder.createShiftRight(resultVal, highBits);
-      }
-    }
-
-    op.replaceAllUsesWith(resultVal);
-  }
-
-  op.erase();
-}
-
 void LoweringPreparePass::lowerStdFindOp(StdFindOp op) {
   CIRBaseBuilderTy builder(getContext());
   builder.setInsertionPointAfter(op.getOperation());
@@ -442,10 +337,6 @@ void LoweringPreparePass::lowerIterEndOp(IterEndOp op) {
 void LoweringPreparePass::runOnOp(Operation *op) {
   if (auto getGlobal = dyn_cast<GlobalOp>(op)) {
     lowerGlobalOp(getGlobal);
-  } else if (auto getBitfield = dyn_cast<GetBitfieldOp>(op)) {
-    lowerGetBitfieldOp(getBitfield);
-  } else if (auto setBitfield = dyn_cast<SetBitfieldOp>(op)) {
-    lowerSetBitfieldOp(setBitfield);
   } else if (auto stdFind = dyn_cast<StdFindOp>(op)) {
     lowerStdFindOp(stdFind);
   } else if (auto iterBegin = dyn_cast<IterBeginOp>(op)) {
@@ -464,8 +355,7 @@ void LoweringPreparePass::runOnOperation() {
 
   SmallVector<Operation *> opsToTransform;
   op->walk([&](Operation *op) {
-    if (isa<GlobalOp, GetBitfieldOp, SetBitfieldOp, StdFindOp, IterBeginOp,
-            IterEndOp>(op))
+    if (isa<GlobalOp, StdFindOp, IterBeginOp, IterEndOp>(op))
       opsToTransform.push_back(op);
   });