Rename attribute to flatten_depth and MaxDepth to DepthHint

Author: grigorypas

clang/include/clang/Basic/Attr.td

@@ -1976,11 +1976,11 @@ def Flatten : InheritableAttr {
   let SimpleHandler = 1;
 }
 
-def FlattenDeep : InheritableAttr {
-  let Spellings = [Clang<"flatten_deep">];
+def FlattenDepth : InheritableAttr {
+  let Spellings = [Clang<"flatten_depth">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Args = [UnsignedArgument<"MaxDepth">];
-  let Documentation = [FlattenDeepDocs];
+  let Args = [UnsignedArgument<"DepthHint">];
+  let Documentation = [FlattenDepthDocs];
 }
 
 def Format : InheritableAttr {

clang/include/clang/Basic/AttrDocs.td

@@ -4032,23 +4032,23 @@ callee is unavailable or if the callee has the ``noinline`` attribute.
   }];
 }
 
-def FlattenDeepDocs : Documentation {
+def FlattenDepthDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
-The ``flatten_deep`` attribute causes calls within the attributed function and
+The ``flatten_depth`` attribute causes calls within the attributed function and
 their transitive callees to be inlined up to a specified depth, unless it is
 impossible to do so (for example if the body of the callee is unavailable or if
 the callee has the ``noinline`` attribute).
 
 This attribute takes a single unsigned integer argument representing the maximum
-depth of the call tree to inline. For example, ``__attribute__((flatten_deep(3)))``
+depth of the call tree to inline. For example, ``__attribute__((flatten_depth(3)))``
 will inline all calls within the function, then inline all calls within those
 inlined functions (depth 2), and then inline all calls within those functions
 (depth 3).
 
 .. code-block:: c++
 
-  __attribute__((flatten_deep(3)))
+  __attribute__((flatten_depth(3)))
   void process_data() {
     // All calls up to 3 levels deep in the call tree will be inlined
   }

clang/lib/CodeGen/CodeGenModule.cpp

@@ -2751,12 +2751,12 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
       B.addAttribute("aarch64_new_zt0");
   }
 
-  // Handle flatten_deep attribute for depth-based inlining
+  // Handle flatten_depth attribute for depth-based inlining
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
-    if (const FlattenDeepAttr *FDA = FD->getAttr<FlattenDeepAttr>()) {
-      // Add the flatten_deep attribute with the max depth value as a typed int
+    if (const FlattenDepthAttr *FDA = FD->getAttr<FlattenDepthAttr>()) {
+      // Add the flatten_depth attribute with the max depth value as a typed int
       // attribute
-      B.addRawIntAttr(llvm::Attribute::FlattenDeep, FDA->getMaxDepth());
+      B.addRawIntAttr(llvm::Attribute::FlattenDepth, FDA->getDepthHint());
     }
   }
 

clang/lib/Sema/SemaDeclAttr.cpp

@@ -3695,22 +3695,22 @@ static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum));
 }
 
-static void handleFlattenDeepAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+static void handleFlattenDepthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   Expr *E = AL.getArgAsExpr(0);
-  uint32_t maxDepth;
-  if (!S.checkUInt32Argument(AL, E, maxDepth)) {
+  uint32_t depthHint;
+  if (!S.checkUInt32Argument(AL, E, depthHint)) {
     AL.setInvalid();
     return;
   }
 
-  if (maxDepth == 0) {
+  if (depthHint == 0) {
     S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
         << AL << E->getSourceRange();
     AL.setInvalid();
     return;
   }
 
-  D->addAttr(::new (S.Context) FlattenDeepAttr(S.Context, AL, maxDepth));
+  D->addAttr(::new (S.Context) FlattenDepthAttr(S.Context, AL, depthHint));
 }
 
 ErrorAttr *Sema::mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI,
@@ -7254,8 +7254,8 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_Format:
     handleFormatAttr(S, D, AL);
     break;
-  case ParsedAttr::AT_FlattenDeep:
-    handleFlattenDeepAttr(S, D, AL);
+  case ParsedAttr::AT_FlattenDepth:
+    handleFlattenDepthAttr(S, D, AL);
     break;
   case ParsedAttr::AT_FormatMatches:
     handleFormatMatchesAttr(S, D, AL);

clang/test/CodeGen/attr-flatten-deep-cg.c

@@ -2,9 +2,9 @@
 
 // CHECK-LABEL: define {{.*}} @test1
 // CHECK-SAME: #[[ATTR1:[0-9]+]]
-__attribute__((flatten_deep(3)))
+__attribute__((flatten_depth(3)))
 void test1() {
 }
 
 // Verify the attribute is present in the attribute groups
-// CHECK-DAG: attributes #[[ATTR1]] = { {{.*}}flatten_deep=3{{.*}} }
+// CHECK-DAG: attributes #[[ATTR1]] = { {{.*}}flatten_depth=3{{.*}} }

clang/test/Misc/pragma-attribute-supported-attributes-list.test

@@ -86,7 +86,7 @@
 // CHECK-NEXT: ExternalSourceSymbol ((SubjectMatchRule_record, SubjectMatchRule_enum, SubjectMatchRule_enum_constant, SubjectMatchRule_field, SubjectMatchRule_function, SubjectMatchRule_namespace, SubjectMatchRule_objc_category, SubjectMatchRule_objc_implementation, SubjectMatchRule_objc_interface, SubjectMatchRule_objc_method, SubjectMatchRule_objc_property, SubjectMatchRule_objc_protocol, SubjectMatchRule_record, SubjectMatchRule_type_alias, SubjectMatchRule_variable))
 // CHECK-NEXT: FlagEnum (SubjectMatchRule_enum)
 // CHECK-NEXT: Flatten (SubjectMatchRule_function)
-// CHECK-NEXT: FlattenDeep (SubjectMatchRule_function)
+// CHECK-NEXT: FlattenDepth (SubjectMatchRule_function)
 // CHECK-NEXT: FunctionReturnThunks (SubjectMatchRule_function)
 // CHECK-NEXT: GNUInline (SubjectMatchRule_function)
 // CHECK-NEXT: HIPManaged (SubjectMatchRule_variable)

clang/test/Sema/attr-flatten-deep.c

@@ -1,14 +1,14 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Test basic usage - valid
-__attribute__((flatten_deep(3)))
+__attribute__((flatten_depth(3)))
 void test_valid() {
 }
 
 // Test attribute on non-function - should error
-__attribute__((flatten_deep(3))) int x; // expected-error {{'flatten_deep' attribute only applies to functions}}
+__attribute__((flatten_depth(3))) int x; // expected-error {{'flatten_depth' attribute only applies to functions}}
 
 // Test depth = 0 - should error (depth must be >= 1)
-__attribute__((flatten_deep(0))) // expected-error {{'flatten_deep' attribute must be greater than 0}}
+__attribute__((flatten_depth(0))) // expected-error {{'flatten_depth' attribute must be greater than 0}}
 void test_depth_zero() {
 }

llvm/include/llvm/AsmParser/LLParser.h

@@ -320,7 +320,8 @@ namespace llvm {
                                 bool AllowParens = false);
     bool parseOptionalCodeModel(CodeModel::Model &model);
     bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
-    bool parseOptionalFlattenDeepDepth(lltok::Kind AttrKind, uint64_t &Depth);
+    bool parseOptionalFlattenDepthDepthHint(lltok::Kind AttrKind,
+                                            uint64_t &Depth);
     bool parseOptionalUWTableKind(UWTableKind &Kind);
     bool parseAllocKind(AllocFnKind &Kind);
     std::optional<MemoryEffects> parseMemoryAttr();

llvm/include/llvm/Bitcode/LLVMBitCodes.h

@@ -802,7 +802,7 @@ enum AttributeKindCodes {
   ATTR_KIND_DEAD_ON_RETURN = 103,
   ATTR_KIND_SANITIZE_ALLOC_TOKEN = 104,
   ATTR_KIND_NO_CREATE_UNDEF_OR_POISON = 105,
-  ATTR_KIND_FLATTEN_DEEP = 106,
+  ATTR_KIND_FLATTEN_DEPTH = 106,
 };
 
 enum ComdatSelectionKindCodes {

llvm/include/llvm/IR/Attributes.h

@@ -1246,9 +1246,9 @@ class AttrBuilder {
   /// form used internally in Attribute.
   LLVM_ABI AttrBuilder &addDereferenceableOrNullAttr(uint64_t Bytes);
 
-  /// This turns the flatten_deep depth into the form used internally in
+  /// This turns the flatten_depth depth into the form used internally in
   /// Attribute.
-  LLVM_ABI AttrBuilder &addFlattenDeepAttr(uint64_t Depth);
+  LLVM_ABI AttrBuilder &addFlattenDepthAttr(uint64_t Depth);
 
   /// This turns one (or two) ints into the form used internally in Attribute.
   LLVM_ABI AttrBuilder &