Handle dependent arguments

Author: grigorypas

clang/include/clang/Basic/Attr.td

@@ -1979,7 +1979,7 @@ def Flatten : InheritableAttr {
 def FlattenDepth : InheritableAttr {
   let Spellings = [Clang<"flatten_depth">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Args = [UnsignedArgument<"DepthHint">];
+  let Args = [ExprArgument<"DepthHint">];
   let Documentation = [FlattenDepthDocs];
 }
 

clang/include/clang/Sema/Sema.h

@@ -4905,6 +4905,10 @@ class Sema final : public SemaBase {
   void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
                          Expr *ParamExpr);
 
+  /// addFlattenDepthAttr - Adds a flatten_depth attribute to a particular
+  /// declaration.
+  void addFlattenDepthAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
+
   bool CheckAttrTarget(const ParsedAttr &CurrAttr);
   bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
 

clang/lib/CodeGen/CodeGenModule.cpp

@@ -2753,9 +2753,11 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
 
   // Handle flatten_depth attribute for depth-based inlining
   if (const FlattenDepthAttr *FDA = D->getAttr<FlattenDepthAttr>()) {
-    // Add the flatten_depth attribute with the max depth value as a typed int
-    // attribute
-    B.addFlattenDepthAttr(FDA->getDepthHint());
+    Expr *DepthExpr = FDA->getDepthHint();
+    Expr::EvalResult Result;
+    if (DepthExpr->EvaluateAsInt(Result, getContext())) {
+      B.addFlattenDepthAttr(Result.Val.getInt().getZExtValue());
+    }
   }
 
   // Track whether we need to add the optnone LLVM attribute,

clang/lib/Sema/SemaDeclAttr.cpp

@@ -3695,20 +3695,28 @@ static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum));
 }
 
-static void handleFlattenDepthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
-  Expr *E = AL.getArgAsExpr(0);
+void Sema::addFlattenDepthAttr(Decl *D, const AttributeCommonInfo &CI,
+                               Expr *E) {
+  // If the expression is template-dependent, defer evaluation until
+  // instantiation
+  if (E->isValueDependent()) {
+    D->addAttr(FlattenDepthAttr::Create(Context, E, CI));
+    return;
+  }
+
+  // For non-dependent expressions, evaluate immediately
   uint32_t depthHint;
-  if (!S.checkUInt32Argument(AL, E, depthHint)) {
+  if (!checkUInt32Argument(CI, E, depthHint)) {
     return;
   }
 
   if (depthHint == 0) {
-    S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
-        << AL << E->getSourceRange();
+    Diag(CI.getLoc(), diag::err_attribute_argument_is_zero)
+        << CI << E->getSourceRange();
     return;
   }
 
-  D->addAttr(FlattenDepthAttr::Create(S.Context, depthHint, AL));
+  D->addAttr(FlattenDepthAttr::Create(Context, E, CI));
 }
 
 ErrorAttr *Sema::mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI,
@@ -7253,7 +7261,7 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
     handleFormatAttr(S, D, AL);
     break;
   case ParsedAttr::AT_FlattenDepth:
-    handleFlattenDepthAttr(S, D, AL);
+    S.addFlattenDepthAttr(D, AL, AL.getArgAsExpr(0));
     break;
   case ParsedAttr::AT_FormatMatches:
     handleFormatMatchesAttr(S, D, AL);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -234,6 +234,21 @@ static void instantiateDependentAnnotationAttr(
   }
 }
 
+static void instantiateDependentFlattenDepthAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const FlattenDepthAttr *Attr, Decl *New) {
+  // The depth expression is a constant expression.
+  EnterExpressionEvaluationContext Unevaluated(
+      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+
+  ExprResult Result = S.SubstExpr(Attr->getDepthHint(), TemplateArgs);
+  if (Result.isInvalid())
+    return;
+
+  Expr *E = Result.getAs<Expr>();
+  S.addFlattenDepthAttr(New, *Attr, E);
+}
+
 template <typename Attr>
 static void sharedInstantiateConstructorDestructorAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const Attr *A,
@@ -912,6 +927,12 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
       continue;
     }
 
+    if (const auto *FlattenDepth = dyn_cast<FlattenDepthAttr>(TmplAttr)) {
+      instantiateDependentFlattenDepthAttr(*this, TemplateArgs, FlattenDepth,
+                                           New);
+      continue;
+    }
+
     if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
       instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
       continue;

clang/test/CodeGenCXX/attr-flatten-depth-template.cpp

@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+
+template<typename T, unsigned I> struct S {
+
+  __attribute__((flatten_depth(I)))
+  void func1(){/*...*/}
+
+  __attribute__((flatten_depth(T::value)))
+  void func2(){/*...*/}
+
+};
+
+struct HasVal { static constexpr int value = 3; };
+
+void foo() {
+  S<HasVal, 2> s;
+  s.func1();
+  s.func2();
+}
+
+// Verify the attribute values are correct
+// CHECK-DAG: flatten_depth=2
+// CHECK-DAG: flatten_depth=3

clang/test/SemaCXX/attr-flatten-depth-template-errors.cpp

@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T>
+struct S {
+  __attribute__((flatten_depth(T::value)))
+  void func() {}
+};
+
+struct HasFloat {
+  static constexpr float value = 3.14f;
+};
+
+struct HasPointer {
+  static constexpr int* value = nullptr;
+};
+
+struct HasString {
+  static constexpr const char* value = "bad";
+};
+
+void test() {
+  S<HasFloat> s1; // expected-note {{in instantiation of template class 'S<HasFloat>' requested here}}
+  S<HasPointer> s2; // expected-note {{in instantiation of template class 'S<HasPointer>' requested here}}
+  S<HasString> s3; // expected-note {{in instantiation of template class 'S<HasString>' requested here}}
+}
+
+// expected-error@5 {{'flatten_depth' attribute requires an integer constant}}
+// expected-error@5 {{'flatten_depth' attribute requires an integer constant}}
+// expected-error@5 {{'flatten_depth' attribute requires an integer constant}}