[clang] [CodeGen] Revamp counted_by calculations (PR #70606)

[Yeoul Na via cfe-commits]

================
@@ -859,53 +859,60 @@ CodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
   }
 
   if (IsDynamic) {
-    LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel =
-        getLangOpts().getStrictFlexArraysLevel();
-    const Expr *Base = E->IgnoreParenImpCasts();
-
-    if (FieldDecl *FD = FindCountedByField(Base, StrictFlexArraysLevel)) {
-      const auto *ME = dyn_cast<MemberExpr>(Base);
-      llvm::Value *ObjectSize = nullptr;
-
-      if (!ME) {
-        const auto *DRE = dyn_cast<DeclRefExpr>(Base);
-        ValueDecl *VD = nullptr;
-
-        ObjectSize = ConstantInt::get(
-            ResType,
-            getContext().getTypeSize(DRE->getType()->getPointeeType()) / 8,
-            true);
-
-        if (auto *RD = DRE->getType()->getPointeeType()->getAsRecordDecl())
-          VD = RD->getLastField();
-
-        Expr *ICE = ImplicitCastExpr::Create(
-            getContext(), DRE->getType(), CK_LValueToRValue,
-            const_cast<Expr *>(cast<Expr>(DRE)), nullptr, VK_PRValue,
-            FPOptionsOverride());
-        ME = MemberExpr::CreateImplicit(getContext(), ICE, true, VD,
-                                        VD->getType(), VK_LValue, OK_Ordinary);
-      }
-
-      // At this point, we know that \p ME is a flexible array member.
-      const auto *ArrayTy = getContext().getAsArrayType(ME->getType());
+    // The code generated here calculates the size of a struct with a flexible
+    // array member that uses the counted_by attribute. There are two instances
+    // we handle:
+    //
+    //       struct s {
+    //         unsigned long flags;
+    //         int count;
+    //         int array[] __attribute__((counted_by(count)));
+    //       }
+    //
+    //   1) bdos of the flexible array itself:
+    //
+    //     __builtin_dynamic_object_size(p->array, 1) ==
+    //         p->count * sizeof(*p->array)
+    //
+    //   2) bdos of the whole struct, including the flexible array:
+    //
+    //     __builtin_dynamic_object_size(p, 1) ==
+    //        sizeof(*p) + p->count * sizeof(*p->array)
----------------
rapidsna wrote:

> Note: sizeof(*p) + p->count * sizeof(*p->array) returning 23 is exactly what I want here. :-) At least with regard to __builtin_dynamic_object_size().

hmm, I see. So, that's not what `-fbounds-safety` is meant to work: `__counted_by` on fam in -fbounds-safety is to exactly add `count` trailing elements from `&s->fam[0]`. So I think this semantic difference between two modes going to be a problem (e.g., accessing the offset 22 of the object, for example, will be considered OOB in -fbounds-safety).

Is there a reason you want it to be this way? I know people tends to do `malloc(sizeof(struct s) + p->count * sizeof(int));` to allocate an object with fam. But people also use `offsetof` and in such cases, `__builtin_dynamic_object_size` can be bigger than what it should be.

```
struct flex {
  double dummy;
  char c;
  char fam [__counted_by(7)];
};
```

 If `__builtin_dynamic_object_size` does `sizeof(*p) + p->count * sizeof(*p->array)`, it's like effectively considering `&s->fam[13]` as part of the object.

https://github.com/llvm/llvm-project/pull/70606