[Clang] Change AnonStructIds in MangleContext to per-function based

[xur]

Summary

Clang is generating different mangled names for the same lambda function in build that are
slightly different (like from non-related source/Macro change). This is due to the fact that clang uses a
cross-translation-unit sequential string "$_<n>" in lambda's mangled name. Here, "n" is the
AnonStructIds field in MangleContext.

Different mangled names for unchanged function is undesirable: it makes perf comparison harder,
and can cause some unnecessary profile mismatch in SampleFDO.

This patch changes AnonStructIds to a per-function based seq number if the
DeclContext is a function.

I hold the change for Microsoft mangling and only change Itanium mangling.

[rsmith]

Looks good to me.

clang/include/clang/AST/Mangle.h

97

[xur]

clang/include/clang/AST/Mangle.h

97

Fixed. Thanks!

clang/include/clang/AST/Mangle.h

private:
   const ManglerKind Kind;
   /// For aux target. If true, uses mangling number for aux target from
   /// ASTContext.
   bool IsAux = false;
 
   llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds;
   llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds;
   llvm::DenseMap<const NamedDecl*, uint64_t> AnonStructIds;
+  llvm::DenseMap<const FunctionDecl*, unsigned> FuncAnonStructSize;
 
 public:
   ManglerKind getKind() const { return Kind; }
 
   bool isAux() const { return IsAux; }
 
   explicit MangleContext(ASTContext &Context, DiagnosticsEngine &Diags,
                          ManglerKind Kind, bool IsAux = false)
public:
   unsigned getBlockId(const BlockDecl *BD, bool Local) {
     llvm::DenseMap<const BlockDecl *, unsigned> &BlockIds
       = Local? LocalBlockIds : GlobalBlockIds;
     std::pair<llvm::DenseMap<const BlockDecl *, unsigned>::iterator, bool>
       Result = BlockIds.insert(std::make_pair(BD, BlockIds.size()));
     return Result.first->second;
   }
 
-  uint64_t getAnonymousStructId(const NamedDecl *D) {
+  uint64_t getAnonymousStructId(const NamedDecl *D,
+                                const FunctionDecl *FD = nullptr) {
+    auto FindResult = AnonStructIds.find(D);
+    if (FindResult != AnonStructIds.end())
+      return FindResult->second;
+
+    // If FunctionDecl is passed in, the anonymous structID will be per-function
+    // based.
+    unsigned Id = FD ? FuncAnonStructSize[FD]++ : AnonStructIds.size();
     std::pair<llvm::DenseMap<const NamedDecl *, uint64_t>::iterator, bool>
-        Result = AnonStructIds.insert(std::make_pair(D, AnonStructIds.size()));
+        Result = AnonStructIds.insert(std::make_pair(D, Id));
     return Result.first->second;
   }
 
   uint64_t getAnonymousStructIdForDebugInfo(const NamedDecl *D) {
     llvm::DenseMap<const NamedDecl *, uint64_t>::iterator Result =
         AnonStructIds.find(D);
     // The decl should already be inserted, but return 0 in case it is not.
     if (Result == AnonStructIds.end())

clang/lib/AST/ItaniumMangle.cpp

if (TD->isExternallyVisible()) {
         Out << UnnamedMangle - 2;
       Out << '_';
       writeAbiTags(TD, AdditionalAbiTags);
       break;
     }
 
     // Get a unique id for the anonymous struct. If it is not a real output
     // ID doesn't matter so use fake one.
-    unsigned AnonStructId = NullOut ? 0 : Context.getAnonymousStructId(TD);
+    unsigned AnonStructId =
+        NullOut ? 0
+                : Context.getAnonymousStructId(TD, dyn_cast<FunctionDecl>(DC));
 
     // Mangle it as a source name in the form
     // [n] $_<id>
     // where n is the length of the string.
     SmallString<8> Str;
     Str += "$_";
     Str += llvm::utostr(AnonStructId);
 

clang/test/CodeGen/attr-function-return.cpp

 
 int foo(void) {
   // CHECK: @"_ZZ3foovENK3$_0clEv"({{.*}}) [[NOATTR:#[0-9]+]]
   return []() {
     return 42;
   }();
 }
 int bar(void) {
-  // CHECK: @"_ZZ3barvENK3$_1clEv"({{.*}}) [[EXTERN:#[0-9]+]]
+  // CHECK: @"_ZZ3barvENK3$_0clEv"({{.*}}) [[EXTERN:#[0-9]+]]
   return []() __attribute__((function_return("thunk-extern"))) {
     return 42;
   }
   ();
 }
 int baz(void) {
-  // CHECK: @"_ZZ3bazvENK3$_2clEv"({{.*}}) [[KEEP:#[0-9]+]]
+  // CHECK: @"_ZZ3bazvENK3$_0clEv"({{.*}}) [[KEEP:#[0-9]+]]
   return []() __attribute__((function_return("keep"))) {
     return 42;
   }
   ();
 }
 
 class Foo {
 public:

clang/test/CodeGenCXX/catch-undef-behavior.cpp

void test5() {
     S5 s51;
     callee5(s51);
     S5 s52;
     s52 = s51;
   }
 }
 
 void ThisAlign::this_align_lambda_2() {
-  // CHECK-LABEL: define internal void @"_ZZN9ThisAlign19this_align_lambda_2EvENK3$_1clEv"
+  // CHECK-LABEL: define internal void @"_ZZN9ThisAlign19this_align_lambda_2EvENK3$_0clEv"
   // CHECK-SAME: (%{{.*}}* {{[^,]*}} %[[this:[^)]*]])
   // CHECK: %[[this_addr:.*]] = alloca
   // CHECK: store %{{.*}}* %[[this]], %{{.*}}** %[[this_addr]],
   // CHECK: %[[this_inner:.*]] = load %{{.*}}*, %{{.*}}** %[[this_addr]],
   //
   // Do not perform a null check on the 'this' pointer if the function might be
   // called from a static invoker.
   // CHECK-NOT: icmp ne %{{.*}}* %[[this_inner]], null
   auto *p = +[] {};
   p();
 }
 
 // CHECK: attributes [[NR_NUW]] = { noreturn nounwind }
 
 // CHECK-FUNCSAN: ![[FUNCSAN]] = !{i32 846595819, i8** [[PROXY]]}

clang/test/CodeGenCXX/cxx1y-init-captures-eh.cpp

void h(bool b1, bool b2) {
   // CHECK: store i1 false, ptr %[[S_ISACTIVE]], align 1
   // CHECK: br i1
 
   // throw 2
   // CHECK: invoke void @__cxa_throw
 
   // end of full-expression
   // CHECK: call void @_Z1xv(
-  // CHECK: call void @"_ZZ1hbbEN3$_2D1Ev"(
+  // CHECK: call void @"_ZZ1hbbEN3$_0D1Ev"(
   // CHECK: call void @_ZN1TD1Ev(
   // CHECK: call void @_Z1yv(
   // CHECK: ret void
 
   // cleanups for throw 1
   // CHECK: landingpad
-  // CHECK-NOT: @"_ZZ1hbbEN3$_2D1Ev"(
+  // CHECK-NOT: @"_ZZ1hbbEN3$_0D1Ev"(
   // CHECK: br
 
   // cleanups for throw 2
   // CHECK: landingpad
-  // CHECK: call void @"_ZZ1hbbEN3$_2D1Ev"(
+  // CHECK: call void @"_ZZ1hbbEN3$_0D1Ev"(
   // CHECK: br
 
   // common cleanup code
   // CHECK: call void @_ZN1TD1Ev(
   // CHECK: load i1, ptr %[[S_ISACTIVE]],
   // CHECK: br i1
 
   // CHECK: call void @_ZN1SD1Ev(
   // CHECK: br
 
   // CHECK: resume
   [s = S(), t = T().n, u = (b1 ? throw 1 : 42)] {}, (b2 ? throw 2 : 0), x();
   y();
 
   // CHECK: }
 }

clang/test/CodeGenCXX/cxx1y-init-captures.cpp

void g() {
   [a(1), b(2)] { return a + b; } ();
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z1gv(
 // CHECK: getelementptr inbounds {{.*}}, i32 0, i32 0
 // CHECK: store i32 1, ptr
 // CHECK: getelementptr inbounds {{.*}}, i32 0, i32 1
 // CHECK: store i32 2, ptr
-// CHECK: call noundef i32 @"_ZZ1gvENK3$_1clEv"(
+// CHECK: call noundef i32 @"_ZZ1gvENK3$_0clEv"(
 
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1gvENK3$_1clEv"(
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1gvENK3$_0clEv"(
 // CHECK: getelementptr inbounds {{.*}}, i32 0, i32 0
 // CHECK: load i32, ptr
 // CHECK: getelementptr inbounds {{.*}}, i32 0, i32 1
 // CHECK: load i32, ptr
 
 // CHECK: add nsw i32
 
 // CHECK-LABEL: define{{.*}} void @_Z18init_capture_dtorsv
int h(int a) {
   // CHECK: getelementptr inbounds {{.*}}, ptr %[[OUTER]], i32 0, i32 0
   // CHECK: store ptr %[[A_ADDR]], ptr {{.*}},
   //
   // Initialize init-capture 'c(a)' by copy.
   // CHECK: getelementptr inbounds {{.*}}, ptr %[[OUTER]], i32 0, i32 1
   // CHECK: load i32, ptr %[[A_ADDR]],
   // CHECK: store i32
   //
-  // CHECK: call noundef i32 @"_ZZ1hiENK3$_2clEv"(ptr {{[^,]*}} %[[OUTER]])
+  // CHECK: call noundef i32 @"_ZZ1hiENK3$_0clEv"(ptr {{[^,]*}} %[[OUTER]])
   return [&b(a), c(a)] {
-    // CHECK-LABEL: define internal noundef i32 @"_ZZ1hiENK3$_2clEv"(
+    // CHECK-LABEL: define internal noundef i32 @"_ZZ1hiENK3$_0clEv"(
     // CHECK: %[[OUTER_ADDR:.*]] = alloca
     // CHECK: %[[INNER:.*]] = alloca
     // CHECK: store {{.*}}, ptr %[[OUTER_ADDR]],
     //
     // Capture outer 'c' by reference.
     // CHECK: %[[OUTER:.*]] = load ptr, ptr %[[OUTER_ADDR]]
     // CHECK: getelementptr inbounds {{.*}}, ptr %[[INNER]], i32 0, i32 0
     // CHECK-NEXT: getelementptr inbounds {{.*}}, ptr %[[OUTER]], i32 0, i32 1
     // CHECK-NEXT: store ptr %
     //
     // Capture outer 'b' by copy.
     // CHECK: getelementptr inbounds {{.*}}, ptr %[[INNER]], i32 0, i32 1
     // CHECK-NEXT: getelementptr inbounds {{.*}}, ptr %[[OUTER]], i32 0, i32 0
     // CHECK-NEXT: load ptr, ptr %
     // CHECK-NEXT: load i32, ptr %
     // CHECK-NEXT: store i32
     //
-    // CHECK: call noundef i32 @"_ZZZ1hiENK3$_2clEvENKUlvE_clEv"(ptr {{[^,]*}} %[[INNER]])
+    // CHECK: call noundef i32 @"_ZZZ1hiENK3$_0clEvENKUlvE_clEv"(ptr {{[^,]*}} %[[INNER]])
     return [=, &c] {
       // CHECK-LABEL: define internal void @"_ZZ1fvEN3$_0D2Ev"(
       // CHECK: call void @_ZN1SD1Ev(
 
-      // CHECK-LABEL: define internal noundef i32 @"_ZZZ1hiENK3$_2clEvENKUlvE_clEv"(
+      // CHECK-LABEL: define internal noundef i32 @"_ZZZ1hiENK3$_0clEvENKUlvE_clEv"(
       // CHECK: %[[INNER_ADDR:.*]] = alloca
       // CHECK: store {{.*}}, ptr %[[INNER_ADDR]],
       // CHECK: %[[INNER:.*]] = load ptr, ptr %[[INNER_ADDR]]
       //
       // Load capture of 'b'
       // CHECK: getelementptr inbounds {{.*}}, ptr %[[INNER]], i32 0, i32 1
       // CHECK: load i32, ptr %
       //

clang/test/CodeGenCXX/lambda-expressions-nested-linkage.cpp

auto L = [](int a) {
     };
   };
   L(3)('a');
 }
 int use = foo();
 }
 
 #if __cplusplus >= 201402L
-// CXX14-LABEL: define internal void @"_ZZZN32lambda_capture_in_generic_lambda3fooIiEEDavENKUlT_E_clIZNS_L1fEvE3$_1EEDaS1_ENKUlvE_clEv"
+// CXX14-LABEL: define internal void @"_ZZZN32lambda_capture_in_generic_lambda3fooIiEEDavENKUlT_E_clIZNS_L1fEvE3$_0EEDaS1_ENKUlvE_clEv"
 namespace lambda_capture_in_generic_lambda {
 template <typename T> auto foo() {
   return [](auto func) {
     [func] { func(); }();
   };
 }
 static void f() {
   foo<int>()([] { });
 }
 void f1() { f(); }
 }
 #endif

clang/test/CodeGenCXX/lambda-expressions.cpp

return [&]() -> int {
     }();
   }();
 }
 
 // CHECK-LABEL: define internal noundef i32 @"_ZZ9ARBSizeOfiENK3$_0clEv"
 
 int a() { return []{ return 1; }(); }
 // CHECK-LABEL: define{{.*}} i32 @_Z1av
-// CHECK: call noundef i32 @"_ZZ1avENK3$_1clEv"
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1avENK3$_1clEv"
+// CHECK: call noundef i32 @"_ZZ1avENK3$_0clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1avENK3$_0clEv"
 // CHECK: ret i32 1
 
 int b(int x) { return [x]{return x;}(); }
 // CHECK-LABEL: define{{.*}} i32 @_Z1bi
 // CHECK: store i32
 // CHECK: load i32, ptr
 // CHECK: store i32
-// CHECK: call noundef i32 @"_ZZ1biENK3$_2clEv"
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1biENK3$_2clEv"
+// CHECK: call noundef i32 @"_ZZ1biENK3$_0clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1biENK3$_0clEv"
 // CHECK: load i32, ptr
 // CHECK: ret i32
 
 int c(int x) { return [&x]{return x;}(); }
 // CHECK-LABEL: define{{.*}} i32 @_Z1ci
 // CHECK: store i32
 // CHECK: store ptr
-// CHECK: call noundef i32 @"_ZZ1ciENK3$_3clEv"
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1ciENK3$_3clEv"
+// CHECK: call noundef i32 @"_ZZ1ciENK3$_0clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1ciENK3$_0clEv"
 // CHECK: load ptr, ptr
 // CHECK: load i32, ptr
 // CHECK: ret i32
 
 struct D { D(); D(const D&); int x; };
 int d(int x) { D y[10]; return [x,y] { return y[x].x; }(); }
 
 // CHECK-LABEL: define{{.*}} i32 @_Z1di
 // CHECK: call void @_ZN1DC1Ev
 // CHECK: br label
 // CHECK: call void @_ZN1DC1ERKS_
 // CHECK: icmp eq i64 %{{.*}}, 10
 // CHECK: br i1
-// CHECK: call noundef i32 @"_ZZ1diENK3$_4clEv"
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1diENK3$_4clEv"
+// CHECK: call noundef i32 @"_ZZ1diENK3$_0clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1diENK3$_0clEv"
 // CHECK: load i32, ptr
 // CHECK: load i32, ptr
 // CHECK: ret i32
 
 struct E { E(); E(const E&); ~E(); int x; };
 int e(E a, E b, bool cond) { return [a,b,cond](){ return (cond ? a : b).x; }(); }
 // CHECK-LABEL: define{{.*}} i32 @_Z1e1ES_b
 // CHECK: call void @_ZN1EC1ERKS_
 // CHECK: invoke void @_ZN1EC1ERKS_
-// CHECK: invoke noundef i32 @"_ZZ1e1ES_bENK3$_5clEv"
-// CHECK: call void @"_ZZ1e1ES_bEN3$_5D1Ev"
-// CHECK: call void @"_ZZ1e1ES_bEN3$_5D1Ev"
+// CHECK: invoke noundef i32 @"_ZZ1e1ES_bENK3$_0clEv"
+// CHECK: call void @"_ZZ1e1ES_bEN3$_0D1Ev"
+// CHECK: call void @"_ZZ1e1ES_bEN3$_0D1Ev"
 
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1e1ES_bENK3$_5clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1e1ES_bENK3$_0clEv"
 // CHECK: trunc i8
 // CHECK: load i32, ptr
 // CHECK: ret i32
 
 void f() {
   // CHECK-LABEL: define{{.*}} void @_Z1fv()
-  // CHECK: @"_ZZ1fvENK3$_6cvPFiiiEEv"
+  // CHECK: @"_ZZ1fvENK3$_0cvPFiiiEEv"
   // CHECK-NEXT: store ptr
   // CHECK-NEXT: ret void
   int (*fp)(int, int) = [](int x, int y){ return x + y; };
 }
 
 static int k;
 int g() {
   int &r = k;
-  // CHECK-LABEL: define internal noundef i32 @"_ZZ1gvENK3$_7clEv"(
+  // CHECK-LABEL: define internal noundef i32 @"_ZZ1gvENK3$_0clEv"(
   // CHECK-NOT: }
   // CHECK: load i32, ptr @_ZL1k,
   return [] { return r; } ();
 };
 
 // PR14773
 // CHECK: [[ARRVAL:%[0-9a-zA-Z]*]] = load i32, ptr @_ZZ14staticarrayrefvE5array, align 4
 // CHECK-NEXT: store i32 [[ARRVAL]]
 void staticarrayref(){
   static int array[] = {};
   (void)[](){
     int (&xxx)[0] = array;
     int y = xxx[0];
   }();
 }
 
-// CHECK-LABEL: define internal noundef ptr @"_ZZ11PR22071_funvENK3$_9clEv"
+// CHECK-LABEL: define internal noundef ptr @"_ZZ11PR22071_funvENK3$_0clEv"
 // CHECK: ret ptr @PR22071_var
 int PR22071_var;
 int *PR22071_fun() {
   constexpr int &y = PR22071_var;
   return [&] { return &y; }();
 }
 
 namespace pr28595 {
void test() {
     // CHECK: %[[T0:.*]] = phi ptr
     // CHECK: %[[T1:.*]] = getelementptr inbounds %[[A]], ptr %[[T0]], i64 -1
     // CHECK: call void @_ZN7pr285951AD1Ev(ptr {{[^,]*}} %[[T1]])
     // CHECK: icmp eq ptr %[[T1]], %[[DST_0]]
     (void) [array]{};
   }
 }
 
-// CHECK-LABEL: define internal void @"_ZZ1e1ES_bEN3$_5D2Ev"
+// CHECK-LABEL: define internal void @"_ZZ1e1ES_bEN3$_0D2Ev"
 
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1fvEN3$_68__invokeEii"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1fvEN3$_08__invokeEii"
 // CHECK: store i32
 // CHECK-NEXT: store i32
 // CHECK-NEXT: load i32, ptr
 // CHECK-NEXT: load i32, ptr
-// CHECK-NEXT: call noundef i32 @"_ZZ1fvENK3$_6clEii"
+// CHECK-NEXT: call noundef i32 @"_ZZ1fvENK3$_0clEii"
 // CHECK-NEXT: ret i32
 
-// CHECK-LABEL: define internal void @"_ZZ1hvEN4$_118__invokeEv"(ptr noalias sret(%struct.A) align 1 %agg.result) {{.*}} {
-// CHECK: call void @"_ZZ1hvENK4$_11clEv"(ptr sret(%struct.A) align 1 %agg.result,
+// CHECK-LABEL: define internal void @"_ZZ1hvEN3$_08__invokeEv"(ptr noalias sret(%struct.A) align 1 %agg.result) {{.*}} {
+// CHECK: call void @"_ZZ1hvENK3$_0clEv"(ptr sret(%struct.A) align 1 %agg.result,
 // CHECK-NEXT: ret void
 struct A { ~A(); };
 void h() {
   A (*h)() = [] { return A(); };
 }
 
 // <rdar://problem/12778708>
 struct XXX {};

clang/test/CodeGenCXX/mangle-lambdas.cpp

 // CHECK: ret i32 42
 template<> double StaticMembers<double>::z = []{return 42; }();
 
 template<typename T>
 void func_template(T = []{ return T(); }());
 
 // CHECK-LABEL: define{{.*}} void @_Z17use_func_templatev()
 void use_func_template() {
-  // CHECK: call noundef i32 @"_ZZ13func_templateIiEvT_ENK3$_3clEv"
+  // CHECK: call noundef i32 @"_ZZ13func_templateIiEvT_ENK3$_0clEv"
   func_template<int>();
 }
 
 namespace std {
   struct type_info {
     bool before(const type_info &) const noexcept;
   };
 }

 int k = testVarargsLambdaNumbering();
 
 
 template<typename = int>
 void ft1(int = [](int p = [] { return 42; } ()) {
                  return p;
                } ());
 void test_ft1() {
-  // CHECK: call noundef i32 @"_ZZZ3ft1IiEviENK3$_4clEiEd_NKUlvE_clEv"
-  // CHECK: call noundef i32 @"_ZZ3ft1IiEviENK3$_4clEi"
+  // CHECK: call noundef i32 @"_ZZZ3ft1IiEviENK3$_0clEiEd_NKUlvE_clEv"
+  // CHECK: call noundef i32 @"_ZZ3ft1IiEviENK3$_0clEi"
   ft1();
 }
-// CHECK-LABEL: define internal noundef i32 @"_ZZ3ft1IiEviENK3$_4clEi"
-// CHECK-LABEL: define internal noundef i32 @"_ZZZ3ft1IiEviENK3$_4clEiEd_NKUlvE_clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ3ft1IiEviENK3$_0clEi"
+// CHECK-LABEL: define internal noundef i32 @"_ZZZ3ft1IiEviENK3$_0clEiEd_NKUlvE_clEv"
 
 struct c1 {
   template<typename = int>
   void mft1(int = [](int p = [] { return 42; } ()) {
                     return p;
                   } ());
 };
 void test_c1_mft1() {

 // CHECK-LABEL: define linkonce_odr noundef i32 @_ZZZ3ft2IiEvvENKUliE_clEiEd_NKUlvE_clEv
 
 template<typename>
 void ft3() {
   void f(int = []{ return 0; }());
   f();
 }
 template void ft3<int>();
-// CHECK: call noundef i32 @"_ZZ1fiENK3$_5clEv"
-// CHECK-LABEL: define internal noundef i32 @"_ZZ1fiENK3$_5clEv"
+// CHECK: call noundef i32 @"_ZZ1fiENK3$_0clEv"
+// CHECK-LABEL: define internal noundef i32 @"_ZZ1fiENK3$_0clEv"
 
 template<typename>
 void ft4() {
   struct lc {
     void mf(int = []{ return 0; }()) {}
   };
   lc().mf();
 }

clang/test/CodeGenCXX/nrvo.cpp

 // CHECK-EH-11-NEXT:    [[REF_TMP:%.*]] = alloca [[CLASS_ANON_0:%.*]], align 4
 // CHECK-EH-11-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 4
 // CHECK-EH-11-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
 // CHECK-EH-11-NEXT:    store ptr [[AGG_RESULT:%.*]], ptr [[RESULT_PTR]], align 4
 // CHECK-EH-11-NEXT:    store i1 false, ptr [[NRVO]], align 1
 // CHECK-EH-11-NEXT:    call void @_ZN1XC1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[AGG_RESULT]])
 // CHECK-EH-11-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[CLASS_ANON_0]], ptr [[REF_TMP]], i32 0, i32 0
 // CHECK-EH-11-NEXT:    store ptr [[AGG_RESULT]], ptr [[TMP1]], align 4
-// CHECK-EH-11-NEXT:    invoke void @"_ZZ6test19vENK3$_1clEv"(ptr sret([[CLASS_X]]) align 1 [[L]], ptr noundef nonnull align 4 dereferenceable(4) [[REF_TMP]])
+// CHECK-EH-11-NEXT:    invoke void @"_ZZ6test19vENK3$_0clEv"(ptr sret([[CLASS_X]]) align 1 [[L]], ptr noundef nonnull align 4 dereferenceable(4) [[REF_TMP]])
 // CHECK-EH-11-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
 // CHECK-EH-11:       invoke.cont:
 // CHECK-EH-11-NEXT:    store i1 true, ptr [[NRVO]], align 1
 // CHECK-EH-11-NEXT:    call void @_ZN1XD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[L]]) #[[ATTR6]]
 // CHECK-EH-11-NEXT:    [[NRVO_VAL:%.*]] = load i1, ptr [[NRVO]], align 1
 // CHECK-EH-11-NEXT:    br i1 [[NRVO_VAL]], label [[NRVO_SKIPDTOR:%.*]], label [[NRVO_UNUSED:%.*]]
 // CHECK-EH-11:       lpad:
 // CHECK-EH-11-NEXT:    [[TMP2:%.*]] = landingpad { ptr, i32 }

clang/test/CodeGenObjCXX/arc-forwarded-lambda-call.mm

 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-macosx10.12.0 -emit-llvm -disable-llvm-passes -O3 -fblocks -fobjc-arc -fobjc-runtime-has-weak -std=c++11 -o - %s | FileCheck %s
 
 void test0(id x) {
   extern void test0_helper(id (^)(void));
   test0_helper([=]() { return x; });
   // CHECK-LABEL: define internal noundef i8* @___Z5test0P11objc_object_block_invoke
   // CHECK: [[T0:%.*]] = call noundef i8* @"_ZZ5test0P11objc_objectENK3$_0clEv"{{.*}} [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T0]])
   // CHECK-NEXT: ret i8* [[T2]]
 }
 
 // Check that the delegating block invoke function doesn't destruct the Weak
 // object that is passed.
 
 // CHECK-LABEL: define internal void @___Z8testWeakv_block_invoke(
-// CHECK: call void @"_ZZ8testWeakvENK3$_2clE4Weak"(
+// CHECK: call void @"_ZZ8testWeakvENK3$_0clE4Weak"(
 // CHECK-NEXT: ret void
 
-// CHECK-LABEL: define internal void @"_ZZ8testWeakvENK3$_2clE4Weak"(
+// CHECK-LABEL: define internal void @"_ZZ8testWeakvENK3$_0clE4Weak"(
 // CHECK: call void @_ZN4WeakD1Ev(
 // CHECK-NEXT: ret void
 
 id test1_rv;
 
 void test1() {
   extern void test1_helper(id (*)(void));
   test1_helper([](){ return test1_rv; });
-  // CHECK-LABEL: define internal noundef i8* @"_ZZ5test1vEN3$_18__invokeEv"
-  // CHECK: [[T0:%.*]] = call noundef i8* @"_ZZ5test1vENK3$_1clEv"{{.*}} [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
+  // CHECK-LABEL: define internal noundef i8* @"_ZZ5test1vEN3$_08__invokeEv"
+  // CHECK: [[T0:%.*]] = call noundef i8* @"_ZZ5test1vENK3$_0clEv"{{.*}} [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
   // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T0]])
   // CHECK-NEXT: ret i8* [[T2]]
 }
 
 struct Weak {
   __weak id x;
 };
 
 void testWeak() {
   extern void testWeak_helper(void (^)(Weak));
   testWeak_helper([](Weak){});
 }

clang/test/CodeGenObjCXX/block-nested-in-lambda.mm

 
 id getObj();
 void use(id);
 
 // Block copy/dispose helpers aren't needed because 'a' is captured by
 // reference.
 
 // CHECK-LABEL: define{{.*}} void @_ZN18CaptureByReference5test0Ev(
-// CHECK-LABEL: define internal void @"_ZZN18CaptureByReference5test0EvENK3$_3clEv"(
+// CHECK-LABEL: define internal void @"_ZZN18CaptureByReference5test0EvENK3$_0clEv"(
 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8** }>* %{{.*}}, i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i64 }* @"__block_descriptor_40_e5_v8\01?0ls32l8" to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 
 void test0() {
   id a = getObj();
   [&]{ ^{ a = 0; }(); }();
 }
 
 // Block copy/dispose helpers shouldn't have to retain/release 'a' because it
 // is captured by reference.
 
 // CHECK-LABEL: define{{.*}} void @_ZN18CaptureByReference5test1Ev(
-// CHECK-LABEL: define internal void @"_ZZN18CaptureByReference5test1EvENK3$_4clEv"(
+// CHECK-LABEL: define internal void @"_ZZN18CaptureByReference5test1EvENK3$_0clEv"(
 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8** }>* %{{.*}}, i32 0, i32 4
 // CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @"__block_descriptor_56_8_32s40s_e5_v8\01?0l" to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8
 
 void test1() {
   id a = getObj(), b = getObj(), c = getObj();
   [&a, b, c]{ ^{ a = 0; use(b); use(c); }(); }();
 }
 
 struct S {
   int val() const;
   int a;
   S();
   S(const S&);
   S &operator=(const S&);
   S(S&&);
   S &operator=(S&&);
 };
 
 S getS();
 
-// CHECK: define internal noundef i32 @"_ZZN18CaptureByReference5test2EvENK3$_1clIiEEDaT_"(%[[CLASS_ANON_2]]* {{[^,]*}} %{{.*}}, i32 noundef %{{.*}})
+// CHECK: define internal noundef i32 @"_ZZN18CaptureByReference5test2EvENK3$_0clIiEEDaT_"(%[[CLASS_ANON_2]]* {{[^,]*}} %{{.*}}, i32 noundef %{{.*}})
 // CHECK: %[[BLOCK:.*]] = alloca <{ i8*, i32, i32, i8*, %{{.*}}, %[[S]]* }>, align 8
 // CHECK: %[[BLOCK_CAPTURED:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %{{.*}}, %[[S]]* }>, <{ i8*, i32, i32, i8*, %{{.*}}, %[[S]]* }>* %[[BLOCK]], i32 0, i32 5
 // CHECK: %[[V0:.*]] = getelementptr inbounds %[[CLASS_ANON_2]], %[[CLASS_ANON_2]]* %{{.*}}, i32 0, i32 0
 // CHECK: %[[V1:.*]] = load %[[S]]*, %[[S]]** %[[V0]], align 8
 // CHECK: store %[[S]]* %[[V1]], %[[S]]** %[[BLOCK_CAPTURED]], align 8
 
 int test2() {
   S s;
   auto fn = [&](const auto a){
     return ^{
       return s.val();
     }();
   };
   return fn(123);
 }
 
-// CHECK: define internal noundef i32 @"_ZZN18CaptureByReference5test3EvENK3$_2clIiEEDaT_"(%[[CLASS_ANON_3]]* {{[^,]*}} %{{.*}}, i32 noundef %{{.*}})
+// CHECK: define internal noundef i32 @"_ZZN18CaptureByReference5test3EvENK3$_0clIiEEDaT_"(%[[CLASS_ANON_3]]* {{[^,]*}} %{{.*}}, i32 noundef %{{.*}})
 // CHECK: %[[BLOCK:.*]] = alloca <{ i8*, i32, i32, i8*, %{{.*}}*, %[[S]] }>, align 8
 // CHECK: %[[BLOCK_CAPTURED:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %{{.*}}*, %[[S]] }>, <{ i8*, i32, i32, i8*, %{{.*}}*, %[[S]] }>* %[[BLOCK]], i32 0, i32 5
 // CHECK: %[[V0:.*]] = getelementptr inbounds %[[CLASS_ANON_3]], %[[CLASS_ANON_3]]* %{{.*}}, i32 0, i32 0
 // CHECK: call void @_ZN18CaptureByReference1SC1ERKS0_(%[[S]]* {{[^,]*}} %[[BLOCK_CAPTURED]], %[[S]]* {{.*}} %[[V0]])
 
 int test3() {
   const S &s = getS();
   auto fn = [=](const auto a){

clang/test/CodeGenObjCXX/lambda-expressions.mm

 // MRC: ret void
 // ("global" contains a dangling pointer after this function runs.)
 
 // ARC: define{{.*}} void @_Z2f2v() [[NUW:#[0-9]+]] {
 // ARC: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke to i8*),
 // ARC: call i8* @llvm.objc.retainBlock
 // ARC: call void @llvm.objc.release
 // ARC-LABEL: define internal noundef i32 @___Z2f2v_block_invoke
-// ARC: call noundef i32 @"_ZZ2f2vENK3$_1clEv
+// ARC: call noundef i32 @"_ZZ2f2vENK3$_0clEv
 
 template <class T> void take_lambda(T &&lambda) { lambda(); }
 void take_block(void (^block)()) { block(); }
 
 // rdar://13800041
 @interface A
 - (void) test;
 @end
- (void) test {
    });
 }
 @end
 
 // ARC: define{{.*}} void @_ZN13LambdaCapture4foo1ERi(i32* noundef nonnull align 4 dereferenceable(4) %{{.*}})
 // ARC:   %[[CAPTURE0:.*]] = getelementptr inbounds %[[LAMBDACLASS]], %[[LAMBDACLASS]]* %{{.*}}, i32 0, i32 0
 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE0]]
 
-// ARC: define internal void @"_ZZN13LambdaCapture4foo1ERiENK3$_3clEv"(%[[LAMBDACLASS]]* {{[^,]*}} %{{.*}})
+// ARC: define internal void @"_ZZN13LambdaCapture4foo1ERiENK3$_0clEv"(%[[LAMBDACLASS]]* {{[^,]*}} %{{.*}})
 // ARC:   %[[BLOCK:.*]] = alloca <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>
 // ARC:   %[[CAPTURE1:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %[[BLOCK]], i32 0, i32 5
 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE1]]
 
 // ARC-LABEL: define internal void @"_ZZ10-[Foo foo]ENK3$_4clEv"(
 // ARC-NOT: @llvm.objc.storeStrong(
 // ARC: ret void
 
-// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke"
+// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_0clEv_block_invoke"
 // ARC:   %[[CAPTURE2:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %{{.*}}, i32 0, i32 5
 // ARC:   store i32 %{{.*}}, i32* %[[CAPTURE2]]
 
-// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke_2"(i8* noundef %{{.*}})
+// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_0clEv_block_invoke_2"(i8* noundef %{{.*}})
 // ARC:   %[[CAPTURE3:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %{{.*}}, i32 0, i32 5
 // ARC:   %[[V1:.*]] = load i32, i32* %[[CAPTURE3]]
 // ARC:   store i32 %[[V1]], i32* @_ZN13LambdaCapture1iE
 
 namespace LambdaCapture {
   int i;
   void foo1(int &a) {
     auto lambda = [a]{
[&] {
     ^{ (void)self; }();
   }();
 }
 @end
 
 // Check that the delegating invoke function doesn't destruct the Weak object
 // that is passed.
 
-// ARC-LABEL: define internal void @"_ZZN14LambdaDelegate4testEvEN3$_58__invokeENS_4WeakE"(
-// ARC: call void @"_ZZN14LambdaDelegate4testEvENK3$_5clENS_4WeakE"(
+// ARC-LABEL: define internal void @"_ZZN14LambdaDelegate4testEvEN3$_08__invokeENS_4WeakE"(
+// ARC: call void @"_ZZN14LambdaDelegate4testEvENK3$_0clENS_4WeakE"(
 // ARC-NEXT: ret void
 
-// ARC-LABEL: define internal void @"_ZZN14LambdaDelegate4testEvENK3$_5clENS_4WeakE"(
+// ARC-LABEL: define internal void @"_ZZN14LambdaDelegate4testEvENK3$_0clENS_4WeakE"(
 // ARC: call void @_ZN14LambdaDelegate4WeakD1Ev(
 
 #ifdef WEAK_SUPPORTED
 
 namespace LambdaDelegate {
 
 struct Weak {
   __weak id x;

clang/test/CodeGenObjCXX/property-lvalue-lambda.mm

 // CHECK-LABEL: define{{.*}} void @_Z2t2P1X
 void t2(X *x) {
   // Test the case when the lambda isn't unique. (see OpaqueValueExpr::isUnique)
   // FIXME: This asserts if the lambda isn't trivially copy/movable.
 
   // [x setBlk: operator+([x blk], [] {})]
 
   // CHECK: call void{{.*}}@objc_msgSend{{.*}}
-  // CHECK: [[PLUS:%.*]] = call void ()* @"_ZplIZ2t2P1XE3$_2EU13block_pointerFvvES4_T_"
+  // CHECK: [[PLUS:%.*]] = call void ()* @"_ZplIZ2t2P1XE3$_0EU13block_pointerFvvES4_T_"
   // CHECK: call void{{.*}}@objc_msgSend{{.*}}({{.*}} [[PLUS]])
   x.blk += [] {};
 
   // CHECK: call void{{.*}}@objc_msgSend{{.*}}
-  // CHECK: [[PLUS:%.*]] = call void ()* @"_ZplIZ2t2P1XE3$_3EPFvvES4_T_"
+  // CHECK: [[PLUS:%.*]] = call void ()* @"_ZplIZ2t2P1XE3$_1EPFvvES4_T_"
   // CHECK: call void{{.*}}@objc_msgSend{{.*}}({{.*}} [[PLUS]])
   x.fnptr += [] {};
 }