[CIR][CIRGen][TBAA] Add CIR_TBAAStructAttr (#1365)

This patch introduces `CIR_TBAAStructAttr`, which encodes the type and
offset of each field in a struct, although it may lead to some
duplication in `CIR`. If we manage `cir::TBAAStructAttr` by adding a new
method to `ASTRecordDeclInterface`, it will also introduce duplication
between `CIRGen` and LLVM lowering.

Author: PikachuHyA

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

@@ -50,9 +50,82 @@ def CIR_TBAATagAttr : CIR_Attr<"TBAATag", "tbaa_tag", [], "TBAAAttr"> {
   let assemblyFormat = "`<` struct(params) `>`";
 }
 
+def CIR_TBAAMemberAttr : CIR_Attr<"TBAAMember", "tbaa_member", []> {
+  let summary = "Attribute representing a member of a TBAA structured type.";
+  let parameters = (ins "TBAAAttr":$type_desc,
+                        "int64_t":$offset);
+  let description = [{
+    Define a TBAA struct attribute.
+
+    Example:
+    ```mlir
+    !ty_StructS = !cir.struct<struct "StructS" {!u16i, !u32i} #cir.record.decl.ast>
+    #tbaa_scalar = #cir.tbaa_scalar<id = "int", type = !s32i>
+    #tbaa_scalar1 = #cir.tbaa_scalar<id = "short", type = !s16i>
+    #tbaa_struct = #cir.tbaa_struct<id = "_ZTS7StructS", members = {<#tbaa_scalar1, 0>, <#tbaa_scalar, 4>}>
+    ```
+
+    See the following link for more details:
+    https://llvm.org/docs/LangRef.html#tbaa-metadata
+  }];
+
+  let assemblyFormat = "`<` params `>`";
+}
+
+def CIR_TBAAMemberAttrArray : ArrayRefParameter<"TBAAMemberAttr"> {
+  let summary = "Array of TBAAMemberAttr attributes.";
+  let printer = [{
+    $_printer << '{';
+    llvm::interleaveComma($_self, $_printer, [&](TBAAMemberAttr attr) {
+        $_printer.printStrippedAttrOrType(attr);
+    });
+    $_printer << '}';
+  }];
+  let parser = [{
+    [&]() -> llvm::FailureOr<llvm::SmallVector<TBAAMemberAttr>> {
+        using Result = llvm::SmallVector<TBAAMemberAttr>;
+        if ($_parser.parseLBrace())
+            return mlir::failure();
+        llvm::FailureOr<Result> result = mlir::FieldParser<Result>::parse($_parser);
+        if (failed(result))
+            return mlir::failure();
+        if ($_parser.parseRBrace())
+            return mlir::failure();
+        return result;
+    }()
+  }];
+}
+
+def CIR_TBAAStructAttr : CIR_Attr<"TBAAStruct",
+                                  "tbaa_struct", [], "TBAAAttr"> {
+  let summary = "Describes a struct type in TBAA";
+
+  let parameters = (ins StringRefParameter<> : $id,
+                        CIR_TBAAMemberAttrArray:$members);
+
+  let description = [{
+    Define a TBAA struct attribute.
+
+    Example:
+    ```mlir
+    !ty_StructS = !cir.struct<struct "StructS" {!u16i, !u32i} #cir.record.decl.ast>
+    #tbaa_scalar = #cir.tbaa_scalar<id = "int", type = !s32i>
+    #tbaa_scalar1 = #cir.tbaa_scalar<id = "short", type = !s16i>
+    // CIR_TBAAStructAttr
+    #tbaa_struct = #cir.tbaa_struct<id = "_ZTS7StructS", members = {<#tbaa_scalar1, 0>, <#tbaa_scalar, 4>}>
+    ```
+
+    See the following link for more details:
+    https://llvm.org/docs/LangRef.html#tbaa-metadata
+  }];
+
+  let assemblyFormat = "`<` struct(params) `>`";
+}
+
 def CIR_AnyTBAAAttr : AnyAttrOf<[
   CIR_TBAAAttr, 
   CIR_TBAAOmnipotentChar, 
-  CIR_TBAAScalarAttr, 
+  CIR_TBAAScalarAttr,
+  CIR_TBAAStructAttr,
   CIR_TBAATagAttr
 ]>;

clang/lib/CIR/CodeGen/CIRGenTBAA.cpp

@@ -1,4 +1,5 @@
 #include "CIRGenTBAA.h"
+#include "CIRGenCXXABI.h"
 #include "CIRGenTypes.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/MLIRContext.h"
@@ -204,7 +205,7 @@ cir::TBAAAttr CIRGenTBAA::getTypeInfo(clang::QualType qty) {
   // function.
   if (isValidBaseType(qty)) {
     assert(!cir::MissingFeatures::tbaaTagForStruct());
-    return tbaa_NYI(mlirContext);
+    return getValidBaseTypeInfo(qty);
   }
 
   const clang::Type *ty = astContext.getCanonicalType(qty).getTypePtr();
@@ -248,9 +249,101 @@ mlir::ArrayAttr CIRGenTBAA::getTBAAStructInfo(clang::QualType qty) {
 }
 
 cir::TBAAAttr CIRGenTBAA::getBaseTypeInfo(clang::QualType qty) {
-  return tbaa_NYI(mlirContext);
+  return isValidBaseType(qty) ? getValidBaseTypeInfo(qty) : nullptr;
+}
+
+cir::TBAAAttr CIRGenTBAA::getValidBaseTypeInfo(clang::QualType qty) {
+  assert(isValidBaseType(qty) && "Must be a valid base type");
+
+  const clang::Type *ty = astContext.getCanonicalType(qty).getTypePtr();
+
+  // nullptr is a valid value in the cache, so use find rather than []
+  auto iter = baseTypeMetadataCache.find(ty);
+  if (iter != baseTypeMetadataCache.end())
+    return iter->second;
+
+  // First calculate the metadata, before recomputinyg the insertion point, as
+  // the helper can recursively call us.
+  auto typeNode = getBaseTypeInfoHelper(ty);
+  LLVM_ATTRIBUTE_UNUSED auto inserted =
+      baseTypeMetadataCache.insert({ty, typeNode});
+  assert(inserted.second && "BaseType metadata was already inserted");
+
+  return typeNode;
 }
+cir::TBAAAttr CIRGenTBAA::getBaseTypeInfoHelper(const clang::Type *ty) {
+  using namespace clang;
+  if (auto *tty = mlir::dyn_cast<clang::RecordType>(ty)) {
+    const clang::RecordDecl *rd = tty->getDecl()->getDefinition();
+    const ASTRecordLayout &layout = astContext.getASTRecordLayout(rd);
+    SmallVector<cir::TBAAMemberAttr, 4> fields;
+    if (const CXXRecordDecl *cxxrd = dyn_cast<CXXRecordDecl>(rd)) {
+      // Handle C++ base classes. Non-virtual bases can treated a kind of
+      // field. Virtual bases are more complex and omitted, but avoid an
+      // incomplete view for NewStructPathTBAA.
+      if (codeGenOpts.NewStructPathTBAA && cxxrd->getNumVBases() != 0)
+        return nullptr;
+      for (const CXXBaseSpecifier &cxxBaseSpecifier : cxxrd->bases()) {
+        if (cxxBaseSpecifier.isVirtual())
+          continue;
+        QualType baseQTy = cxxBaseSpecifier.getType();
+        const CXXRecordDecl *baseRD = baseQTy->getAsCXXRecordDecl();
+        if (baseRD->isEmpty())
+          continue;
+        auto typeNode = isValidBaseType(baseQTy) ? getValidBaseTypeInfo(baseQTy)
+                                                 : getTypeInfo(baseQTy);
+        if (!typeNode)
+          return nullptr;
+        uint64_t offset = layout.getBaseClassOffset(baseRD).getQuantity();
+        [[maybe_unused]] uint64_t size =
+            astContext.getASTRecordLayout(baseRD).getDataSize().getQuantity();
+        fields.push_back(
+            cir::TBAAMemberAttr::get(mlirContext, typeNode, offset));
+      }
+      // The order in which base class subobjects are allocated is
+      // unspecified, so may differ from declaration order. In particular,
+      // Itanium ABI will allocate a primary base first. Since we exclude
+      // empty subobjects, the objects are not overlapping and their offsets
+      // are unique.
+      llvm::sort(fields, [](const cir::TBAAMemberAttr &lhs,
+                            const cir::TBAAMemberAttr &rhs) {
+        return lhs.getOffset() < rhs.getOffset();
+      });
+    }
+    for (FieldDecl *field : rd->fields()) {
+      if (field->isZeroSize(astContext) || field->isUnnamedBitField())
+        continue;
+      QualType fieldQTy = field->getType();
+      auto typeNode = isValidBaseType(fieldQTy) ? getValidBaseTypeInfo(fieldQTy)
+                                                : getTypeInfo(fieldQTy);
+      if (!typeNode)
+        return nullptr;
+
+      uint64_t bitOffset = layout.getFieldOffset(field->getFieldIndex());
+      uint64_t offset = astContext.toCharUnitsFromBits(bitOffset).getQuantity();
+      [[maybe_unused]] uint64_t size =
+          astContext.getTypeSizeInChars(fieldQTy).getQuantity();
+      fields.push_back(cir::TBAAMemberAttr::get(mlirContext, typeNode, offset));
+    }
+
+    SmallString<256> outName;
+    if (features.CPlusPlus) {
+      // Don't use the mangler for C code.
+      llvm::raw_svector_ostream out(outName);
+      types.getCXXABI().getMangleContext().mangleCanonicalTypeName(
+          QualType(ty, 0), out);
+    } else {
+      outName = rd->getName();
+    }
 
+    if (codeGenOpts.NewStructPathTBAA) {
+      assert(!cir::MissingFeatures::tbaaNewStructPath());
+      return nullptr;
+    }
+    return cir::TBAAStructAttr::get(mlirContext, outName, fields);
+  }
+  return nullptr;
+}
 cir::TBAAAttr CIRGenTBAA::getAccessTagInfo(TBAAAccessInfo tbaaInfo) {
   assert(!tbaaInfo.isIncomplete() &&
          "Access to an object of an incomplete type!");

clang/lib/CIR/CodeGen/CIRGenTBAA.h

@@ -105,6 +105,7 @@ class CIRGenTBAA {
   [[maybe_unused]] const clang::LangOptions &features;
 
   llvm::DenseMap<const Type *, cir::TBAAAttr> metadataCache;
+  llvm::DenseMap<const Type *, cir::TBAAAttr> baseTypeMetadataCache;
 
   cir::TBAAAttr getChar();
 
@@ -113,6 +114,9 @@ class CIRGenTBAA {
   cir::TBAAAttr getTypeInfoHelper(clang::QualType qty);
   cir::TBAAAttr getScalarTypeInfo(clang::QualType qty);
 
+  cir::TBAAAttr getValidBaseTypeInfo(clang::QualType qty);
+  cir::TBAAAttr getBaseTypeInfoHelper(const clang::Type *ty);
+
 public:
   CIRGenTBAA(mlir::MLIRContext *mlirContext, clang::ASTContext &astContext,
              CIRGenTypes &types, mlir::ModuleOp moduleOp,

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

@@ -109,7 +109,7 @@ struct CIROpAsmDialectInterface : public OpAsmDialectInterface {
     }
     return TypeSwitch<Attribute, AliasResult>(attr)
         .Case<cir::TBAAAttr, cir::TBAAOmnipotentCharAttr, cir::TBAAScalarAttr,
-              cir::TBAATagAttr>([&](auto attr) {
+              cir::TBAAStructAttr, cir::TBAATagAttr>([&](auto attr) {
           os << decltype(attr)::getMnemonic();
           return AliasResult::OverridableAlias;
         })