[clang][ExprConstant] fix __builtin_object_size for compound literal

[nickdesaulniers]

Summary

Fixup to D150892.

[efriedma]

clang/lib/AST/ExprConstant.cpp

11737

For the second call to CheckHandleSizeof (line 11791), is the type of consistent with the type of the variable? If Ty refers to a field, I'm not sure it makes sense to call getFlexibleArrayInitChars(). Something along the lines of "struct Z { struct A { int x, y[]; } z; int a; };"

11740

I think I'd like to check isa<VarDecl> here to be on the safe side, even if I don't have a specific example where it would break.

[nickdesaulniers]

• more dyn_cast

clang/lib/AST/ExprConstant.cpp

11737

Can such an object even be initialized?

cat /tmp/x.c
struct Z { struct A { int x, y[]; } z; int a; };

static struct Z my_z = {
  .z = {
    .x = 42,
    .y = {
      0, 1, 2,
    },
  },
  .a = 42,
};

unsigned long foo (void) {
  return __builtin_object_size(&my_z, 1);
}
$ clang -O2 /tmp/x.c -S -o -
/tmp/x.c:1:37: warning: field 'z' with variable sized type 'struct A' not at the end of a struct or class is a GNU extension [-Wgnu-variable-sized-type-not-at-end]
struct Z { struct A { int x, y[]; } z; int a; };
                                    ^
/tmp/x.c:6:10: error: initialization of flexible array member is not allowed
    .y = {
         ^
/tmp/x.c:1:30: note: initialized flexible array member 'y' is here
struct Z { struct A { int x, y[]; } z; int a; };
                             ^
1 warning and 1 error generated.

or did you have something else in mind?

[efriedma]

clang/lib/AST/ExprConstant.cpp

11737

I was thinking something more along the lines of

struct Z { struct A { int x, y[]; } z; int a; int b[]; };

static struct Z my_z = { .b = {1,2,3} };

unsigned long foo (void) {
  return __builtin_object_size(&my_z.z, 1);
}

The idea being that you're adding the length of the flexible member even though the caller isn't trying to ask about it.

[nickdesaulniers]

Merged into https://reviews.llvm.org/D150892.

clang/lib/AST/ExprConstant.cpp

11737

Ah, thanks! You're right, I didn't understand what was meant by "most derived type."

I've fixed this up in the re-opened https://reviews.llvm.org/D150892. PTAL.

clang/lib/AST/ExprConstant.cpp

static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
                                unsigned Type, const LValue &LVal,
                                CharUnits &EndOffset) {
   bool DetermineForCompleteObject = refersToCompleteObject(LVal);
 
   auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
     if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
       return false;
     bool Ret = HandleSizeof(Info, ExprLoc, Ty, Result);
     if (Ty->isStructureType() &&
         Ty->getAsStructureType()->getDecl()->hasFlexibleArrayMember()) {
-      const auto *VD =
-          cast<VarDecl>(LVal.getLValueBase().get<const ValueDecl *>());
+      if (const auto *V = LVal.getLValueBase().dyn_cast<const ValueDecl *>())
+        if (const auto *VD = dyn_cast<VarDecl>(V))
           Result += VD->getFlexibleArrayInitChars(Info.Ctx);
     }
     return Ret;
   };
 
   // We want to evaluate the size of the entire object. This is a valid fallback
   // for when Type=1 and the designator is invalid, because we're asked for an
   // upper-bound.
   if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {

clang/test/CodeGen/object-size.c

 // CHECK-LABEL: @test34
 static struct DynStructVar D34 = {
   .fst = {},
 };
 unsigned long test34(void) {
   // CHECK: ret i64 16
   return OBJECT_SIZE_BUILTIN(&D34, 1);
 }
+unsigned long test35(void) {
+  // CHECK: ret i64 16
+  return OBJECT_SIZE_BUILTIN(&(struct DynStructVar){}, 1);
+}
 
 // CHECK-LABEL: @PR30346
 void PR30346(void) {
   struct sa_family_t {};
   struct sockaddr {
     struct sa_family_t sa_family;
     char sa_data[14];
   };