Function block naming - add hash of parameter type to end of block name

[alexbdv]

Summary

Function blocks don't have a name specified in source code. Currently their symbol name is based on the parent function's name and an index.
Ex: _ZN1Parent_Funciton_block_invoke_1
One issue that happens with the current naming scheme is that in subsequent builds, the name of the function block can change even if the function block or the parent function has changed. This presents issues for tools that use symbol names to identify changes in source code / tracking of binary metrics.

The proposed solution here is to change the incremental number to a hash of the block parameter types.
Ex: _ZN1Parent_Funciton_block_invoke_38172 (38172 is the hash of the parameters)
Therefore, the function block name will only change if its parameters or the parent function name changes. And will now remain stable regardless if new function blocks are added.

[vsk]

At a high level the idea sounds good to me. For out OSes, symbol name instability results in serious performance regressions as this invalidates text/data orderfiles. Why shouldn’t this be on by default?

Also, could you add tests to cover this change?

[alexbdv]

@vsk - sure will add tests when removing from RFC.
As for making it default - would rather have this under a flag as hashing the block contents does have some overhead and I imagine this feature wouldn't be beneficial in most scenarios. Also, unexpectedly (by default) changing the name of the function blocks might have a negative impact on some existing workflows.

[vsk]

In D74813#1883241, @alexbdv wrote:

As for making it default - would rather have this under a flag as hashing the block contents does have some overhead and I imagine this feature wouldn't be beneficial in most scenarios. Also, unexpectedly (by default) changing the name of the function blocks might have a negative impact on some existing workflows.

I agree there is a non-zero compile-time overhead, but I expect it to be very small. Istm the relative cost of adding a flag would be much higher, in terms of added complexity and adoption time.

What kind of workflow would this change break? Part of the motivation seems to be that workflows that rely on blocks having stable names are brittle. This seems like it makes things strictly less brittle.

[dexonsmith]

Thanks for working on this, I agree it's a really important problem.

I'm as optimistic as Vedant that this is the right approach though.

• On compile time, I do think there's reason to be concerned, since dumping IR was fairly expensive last I checked due to numbering metadata. Have you tried measuring a the time for a bootstrap of Clang?
• On stability, I'm skeptical this will be an improvement in the general case. Metadata numbering is unstable, and having that as an input isn't great. It could even change between compiler versions.
• I'm also worried that the hash will change any time someone touches the body of the block. That could even cause a change if other code changes a typedef which is used inside the block.

Is the current numbering per-module? Can we change that somehow to per-function? Then blocks would be numbered by order within a function, which seems fairly stable.

[alexbdv]

@vsk - about breaking existing workflows - I was referring only to if / when this gets shipped out as the default - all the names for the function blocks will change and this might cause issue with tooling that relies on symbol names being consistent across builds.

@dexonsmith

• Just to make sure - this isn't dumping LLVM IR but a textual representation of the AST. Does this have the same issues with metadata / metadata numbering that LLVM IR has, or you were referring to the AST text dump, not llvm IR ? Also I don't think that clang would be a good test case here - it doesn't have many block functions.
• Stability wise - I'm still not sure if this has the metadata numbering issue (since it's AST text representation), perhaps you can tell me how to check.
• Correct, the hash might change if the block contents changes - this is kind of the intended use for this. As the flag mentions, it is hash-based.

Moving to a per-function index-based approach seems like the correct default approach. I would still like to have the hash version under a flag though. Moving to per-function index-based should be as simple as not adding the discriminator at all. Since function blocks contain the parent's function's name and given that llvm auto-renames duplicate symbols by adding an incremental number - the end result is that function blocks will be incrementally named based on the order that they have in the parent function.

[alexbdv]

@dexonsmith I did a benchmark with the worst case example I can come up with - 1000 regular functions and 1000 blocks : https://paste.ofcode.org/CFU6b46nuAA6ymxUEpkzka
I didn't manage to measure any performance decrease (the performance decrease was within the noise of repeated runs) - so seems the hashing is insignificant compile-time-wise even in worst case scenario (where most of the code is in function blocks).
And here is the actual text that is being hashed - the textual representation of the AST - this is not llvm IR with metadata: https://paste.ofcode.org/bfMzhbvHz9HRT7mVMe48Mx

[alexbdv]

@vsk / @dexonsmith - I've added some more info in latest comments. Let me know if I can provide more info / context on this to be able to reach a conclusion. Or if you think it is clear at this point that the hash-based approach is a no-go.

[manmanren]

There are a few concerns about the approach:
1> Compile time: dumping AST as string then hashing the string. Alex measured it on a synthetic benchmark, it shows insignificant impact.
2> Stability: from my understanding, the main goal of this patch is to increase stability of the symbol name so it will not change if the relevant code for the block is not changing. It may not be as stable when the compiler version changes.
Using per-function ID improves the stability compared to per-module ID. @alexbdv do you have rough ideas on how much better the proposed approach is in terms of stability, comparing to per-function ID?
3> Using a compiler flag may slow down the adoption.

@dexonsmith: How can we move this forward? Do you have any other suggestion?

Thanks!
Manman

clang/lib/AST/Mangle.cpp

52

Should it be AST instead of IR in the comment here?

56

Is this needed to have deterministic behavior?

[alexbdv]

clang/lib/AST/Mangle.cpp

56

Correct.

[alexbdv]

@dexonsmith - any suggestions to move forward on this ?

[erik.pilkington]

What do you think about using the block type instead of a hash? That should be stable across compiler versions, changes to the block body, and changes to referenced declarations. You'd still have to number blocks of the same type within the same function, but that should be a much smaller problem. It'd also allow demanglers to provide more information about the symbol, e.g. a demangler could print:

block invocation function for block of type void (^)(int) in main

As opposed to what it prints today, which doesn't really tell you much about which block you're looking at:

block invocation function for block in main.

[alexbdv]

@erik.pilkington / @vsk / @dexonsmith - how block name = hash(parent_function_name + block_type) ?
So any blocks that are inside the same parent function + have the same type will get an incremental number to de-duplicate names.

[dexonsmith]

In D74813#1982089, @alexbdv wrote:

@erik.pilkington / @vsk / @dexonsmith - how block name = hash(parent_function_name + block_type) ?
So any blocks that are inside the same parent function + have the same type will get an incremental number to de-duplicate names.

Do these need to be behind a hash, or can we just put that directly in the block name? The name is currently __<mangled-function-name>_block_invoke followed by an optional integer discriminator. We could call it __<mangled-function-name>_block_invoke_<mangled-block-type> followed by an optional discriminator. WDYT?

clang/lib/AST/Mangle.cpp

86–87

Seems like this patch is addressing this FIXME. Can it be removed?

[alexbdv]

@dexonsmith - I think that should work - like this ?

[dexonsmith]

Yes, I like the look of that. Can you also update the demangler to reverse this nicely? @erik.pilkington can help there. There are two copies. Usually you modify the copy in libcxxabi/ and then run a script to copy the changes into llvm/.

[alexbdv]

@dexonsmith, @erik.pilkington - how about this ?

____Z7my_mainv_block_invoke_ZTSi_ZTSj_ZTSPVK3sss

demangled as:
invocation function for block with params '(int, unsigned int, sss const volatile*)' in my_main()

previously was:
invocation function for block in my_main()

[erik.pilkington]

The demangler changes should also be made in libcxxabi/src/demangle, as there is a copy of the demangler there. This change also needs tests, there should be demangler tests (in libcxxabi/test/test_demangle.cpp), and IRGen tests (in clang/test/CodeGen) that check the mangled name. Finally, can you please add full contexts to your diffs? (by running e.g. git show -U99999).

clang/lib/AST/Mangle.cpp

39–50

We should also probably do this for global blocks, which are handled separately below.

42

Might be cleaner as a range-for: for (ParmVarDecl *PVD : BD->parameters)

46

I'm not sure why Out2 exists.

llvm/include/llvm/Demangle/ItaniumDemangle.h

5537 ↗

(On Diff #259181)

Can you make a special BlockInvocationFunction AST node that stores the parameter types as AST nodes (rather than strings) in a NodeArray? Right now it looks like this code is leaking, since initializeOutputStream allocates a buffer that it expects the user of OutputStream to manage (the ownership is a bit awkward, but its meant to accommodate the API of __cxa_demangle).

[alexbdv]

For tests - the existing block tests should be enough, just need to update them.
I updated a few - want to make sure changes are final before updating all the tests to not have to update tests again.

llvm/include/llvm/Demangle/ItaniumDemangle.h

5537 ↗

(On Diff #259181)

Resolved with better memory management.

[jhenderson]

llvm/test/tools/llvm-cxxfilt/invalid.test

1 ↗

(On Diff #259487)

I'm not sure this test needs updating with an additional case?

This test is just to show what llvm-cxxfilt prints when an input is not a valid mangled name (I think). I think the existing block_invoke example is there merely to show triple underscores can be handled, but I actually am doubtful that it really belongs here, as that sounds more like belonging in the demangler testing.

NB. I haven't actually looked at the history of this test or the source code to verify anything I just said.

[erik.pilkington]

clang/lib/AST/Mangle.cpp

41

In D74813#1996143, @alexbdv wrote:

@dexonsmith, @erik.pilkington - how about this ?

____Z7my_mainv_block_invoke_ZTSi_ZTSj_ZTSPVK3sss

That doesn't look quite right, _ZTSi means the typeinfo symbol for int, but we really should just be printing the type, i. I think we should add a new member on MangleContext (in Mangle.h) for mangling block invocation functions, then implement it in ItaniumMangle.cpp to call CXXNameMangler::mangleType for each parameter (the MS mangling can probably just be left as-is, I don't think it matters all that much for blocks).

llvm/include/llvm/Demangle/ItaniumDemangle.h

5537 ↗

(On Diff #259181)

Okay, but now this is just leaking in the buffer you allocate in DescOS. There isn't any way for this approach to work, because you need the temporary buffer you're allocating to live until after the SpecialName is printed, and the AST nodes do not get destroyed. Can you please do what I said above, and create a BlockInvocationFunction node that has a NodeArray of parameters? You can look at e.g. FunctionType above for an example of this.

[alexbdv]

@erik.pilkington How about just adding numeric hash of block parameters for now ? This way we don't have to change the mangling / demangling scheme at all.
The mangling / demangling changes bring me into parts of LLVM that I'm not familiar with.
(PS - I still have to update tests).

[alexbdv]

@erik.pilkington would the hash-based numbering be OK for now ?

[erik.pilkington]

In D74813#2010767, @alexbdv wrote:

@erik.pilkington would the hash-based numbering be OK for now ?

Feel free to drop the demangler changes for now, but I would prefer including the output of the mangled type in the symbol rather than it's hash.

[dexonsmith]

In D74813#2010859, @erik.pilkington wrote:

In D74813#2010767, @alexbdv wrote:

@erik.pilkington would the hash-based numbering be OK for now ?

Feel free to drop the demangler changes for now, but I would prefer including the output of the mangled type in the symbol rather than it's hash.

Dropping the demangler changes will introduce a regression for demangling blocks... I don't think we should do that.

[alexbdv]

@dexonsmith what regression are you referring to ?
What this change is effectively doing now is changing the numbering of the blocks from incremental to hash-based.
So the demangler functionality remains the same (i think) - I saw that it is ignoring the (currently incrememntal) number, so changing it shouldn't make a difference.
Did I miss anything ?

[dexonsmith]

In D74813#2011083, @alexbdv wrote:

@dexonsmith what regression are you referring to ?
What this change is effectively doing now is changing the numbering of the blocks from incremental to hash-based.
So the demangler functionality remains the same (i think) - I saw that it is ignoring the (currently incrememntal) number, so changing it shouldn't make a difference.
Did I miss anything ?

I think you missed @erik.pilkington's comment, which I was replying to.

[alexbdv]

Updating tests.

[alexbdv]

@dexonsmith @erik.pilkington The change is final now, could we get this in ?

[alexbdv]

Could I please get a review on this ? Thanks :) !

[erik.pilkington]

In D74813#2035051, @alexbdv wrote:

Could I please get a review on this ? Thanks :) !

I still think it makes more sense to directly encode the type instead of hashing it. I'm happy to make the demangler changes for whatever we land on, so feel free to ignore that part of it.

[alexbdv]

@dexonsmith - Are you OK with that ?

[dexonsmith]

In D74813#2036966, @alexbdv wrote:

@dexonsmith - Are you OK with that ?

SGTM. I suggest @erik.pilkington lands the demangler patch before landing this so there isn't a window where we mangle something that can't be demangled.

[dexonsmith]

I'll let @erik.pilkington and @Bigcheese finish this review.

clang/lib/AST/Mangle.cpp

                                 StringRef Outer,
                                 const BlockDecl *BD,
                                 raw_ostream &Out) {
-  unsigned discriminator = Context.getBlockId(BD, true);
-  if (discriminator == 0)
-    Out << "__" << Outer << "_block_invoke";
-  else
-    Out << "__" << Outer << "_block_invoke_" << discriminator+1;
+  SmallString<256> ParamBuff;
+  llvm::raw_svector_ostream ParamTypes(ParamBuff);
+  for (ParmVarDecl *PVD : BD->parameters()) {
+    Context.mangleTypeName(PVD->getType(), ParamTypes);
+  }
+
+  llvm::MD5 Hash;
+  llvm::MD5::MD5Result Result;
+  Hash.update(ParamTypes.str());
+  Hash.final(Result);
+
+  Out << "__" << Outer << "_block_invoke_" << *(unsigned short *)&Result;
 }
 
 void MangleContext::anchor() { }

clang/test/CXX/expr/expr.prim/expr.prim.lambda/blocks-irgen.mm

 namespace PR12746 {
   // CHECK: define zeroext i1 @_ZN7PR127462f1EPi
   bool f1(int *x) {
-    // CHECK: store i8* bitcast (i1 (i8*)* @___ZN7PR127462f1EPi_block_invoke to i8*)
+    // CHECK: store i8* bitcast (i1 (i8*)* @___ZN7PR127462f1EPi_block_invoke_7636 to i8*)
     bool (^outer)() = ^ {
       auto inner = [&]() -> bool {
   return x == 0;

clang/test/CodeGen/block-with-perdefinedexpr.cpp

 // RUN: %clang_cc1 %s -emit-llvm -o - -fblocks -triple x86_64-apple-darwin10 -std=c++11 | FileCheck %s
 
 void bar() {
-  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke = private unnamed_addr constant [17 x i8] c"bar_block_invoke\00", align 1
+  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke_7636 = private unnamed_addr constant [17 x i8] c"bar_block_invoke\00", align 1
   const char * (^block1)() = ^() {
     return __FUNCTION__;
   };
-  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke_2 = private unnamed_addr constant [19 x i8] c"bar_block_invoke_2\00", align 1
+  // CHECK-DAG: @__FUNCTION__.___Z3barv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [19 x i8] c"bar_block_invoke_2\00", align 1
   const char * (^block2)() = ^() {
     return __FUNCTION__;
   };
 }
 
 void baz() {
-  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke = private unnamed_addr constant [24 x i8] c"void baz()_block_invoke\00", align 1
+  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke_7636 = private unnamed_addr constant [24 x i8] c"void baz()_block_invoke\00", align 1
   const char * (^block1)() = ^() {
     return __PRETTY_FUNCTION__;
   };
-  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke_2 = private unnamed_addr constant [26 x i8] c"void baz()_block_invoke_2\00", align 1
+  // CHECK-DAG: @__PRETTY_FUNCTION__.___Z3bazv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"void baz()_block_invoke_2\00", align 1
   const char * (^block2)() = ^() {
     return __PRETTY_FUNCTION__;
   };

 class Foo {
 public:
   Foo() {
-    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke = private unnamed_addr constant [38 x i8] c"foonamespace::Foo::Foo()_block_invoke\00", align 1
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke_7636 = private unnamed_addr constant [38 x i8] c"foonamespace::Foo::Foo()_block_invoke\00", align 1
     const char * (^block1)() = ^() {
       return __PRETTY_FUNCTION__;
     };
-    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke_2 = private unnamed_addr constant [40 x i8] c"foonamespace::Foo::Foo()_block_invoke_2\00", align 1
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooC2Ev_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [40 x i8] c"foonamespace::Foo::Foo()_block_invoke_2\00", align 1
     const char * (^block2)() = ^() {
       return __PRETTY_FUNCTION__;
     };
-    // CHECK-DAG: @__func__.___ZN12foonamespace3FooC2Ev_block_invoke_3 = private unnamed_addr constant [19 x i8] c"Foo_block_invoke_3\00", align 1
+    // CHECK-DAG: @__func__.___ZN12foonamespace3FooC2Ev_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [19 x i8] c"Foo_block_invoke_3\00", align 1
     const char * (^block3)() = ^() {
       return __func__;
     };

     inside_lambda();
   }
   ~Foo() {
-    // CHECK-DAG: @__func__.___ZN12foonamespace3FooD2Ev_block_invoke = private unnamed_addr constant [18 x i8] c"~Foo_block_invoke\00", align 1
+    // CHECK-DAG: @__func__.___ZN12foonamespace3FooD2Ev_block_invoke_7636 = private unnamed_addr constant [18 x i8] c"~Foo_block_invoke\00", align 1
     const char * (^block1)() = ^() {
       return __func__;
     };
-    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooD2Ev_block_invoke_2 = private unnamed_addr constant [41 x i8] c"foonamespace::Foo::~Foo()_block_invoke_2\00", align 1
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3FooD2Ev_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [41 x i8] c"foonamespace::Foo::~Foo()_block_invoke_2\00", align 1
     const char * (^block2)() = ^() {
       return __PRETTY_FUNCTION__;
     };
   }
   void bar() {
-    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke = private unnamed_addr constant [43 x i8] c"void foonamespace::Foo::bar()_block_invoke\00", align 1
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke_7636 = private unnamed_addr constant [43 x i8] c"void foonamespace::Foo::bar()_block_invoke\00", align 1
     const char * (^block1)() = ^() {
       return __PRETTY_FUNCTION__;
     };
-    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke_2 = private unnamed_addr constant [45 x i8] c"void foonamespace::Foo::bar()_block_invoke_2\00", align 1
+    // CHECK-DAG: @__PRETTY_FUNCTION__.___ZN12foonamespace3Foo3barEv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [45 x i8] c"void foonamespace::Foo::bar()_block_invoke_2\00", align 1
     const char * (^block2)() = ^() {
       return __PRETTY_FUNCTION__;
     };
-    // CHECK-DAG: @__func__.___ZN12foonamespace3Foo3barEv_block_invoke_3 = private unnamed_addr constant [19 x i8] c"bar_block_invoke_3\00", align 1
+    // CHECK-DAG: @__func__.___ZN12foonamespace3Foo3barEv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [19 x i8] c"bar_block_invoke_3\00", align 1
     const char * (^block3)() = ^() {
       return __func__;
     };
   }
   void inside_lambda() {
     auto lambda = []() {
-      // CHECK-DAG: @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke = private unnamed_addr constant [92 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke\00", align 1
+      // CHECK-DAG: @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_7636 = private unnamed_addr constant [92 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke\00", align 1
       const char * (^block1)() = ^() {
         return __PRETTY_FUNCTION__;
       };
-      // CHECK-DAG:     @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_2 = private unnamed_addr constant [94 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke_2\00", align 1
+      // CHECK-DAG:     @__PRETTY_FUNCTION__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [94 x i8] c"auto foonamespace::Foo::inside_lambda()::(anonymous class)::operator()() const_block_invoke_2\00", align 1
       const char * (^block2)() = ^() {
         return __PRETTY_FUNCTION__;
       };
-      // CHECK-DAG: @__func__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_3 = private unnamed_addr constant [26 x i8] c"operator()_block_invoke_3\00", align 1
+      // CHECK-DAG: @__func__.___ZZN12foonamespace3Foo13inside_lambdaEvENKUlvE_clEv_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"operator()_block_invoke_3\00", align 1
       const char * (^block3)() = ^() {
         return __func__;
       };

clang/test/CodeGen/blocks.c

   int a[64];
 };
 
-// CHECK: define internal void @__f2_block_invoke(%struct.s0* noalias sret align 4 {{%.*}}, i8* {{%.*}}, %struct.s0* byval(%struct.s0) align 4 {{.*}})
+// CHECK: define internal void @__f2_block_invoke_42498(%struct.s0* noalias sret align 4 {{%.*}}, i8* {{%.*}}, %struct.s0* byval(%struct.s0) align 4 {{.*}})
 struct s0 f2(struct s0 a0) {
   return ^(struct s0 a1){ return a1; }(a0);
 }

clang/test/CodeGen/debug-info-block-vars.c

 // RUN:   -triple x86_64-apple-darwin -o - %s \
 // RUN:   | FileCheck --check-prefix=CHECK-OPT %s
 
-// CHECK: define internal void @__f_block_invoke(i8* %.block_descriptor)
+// CHECK: define internal void @__f_block_invoke_7636(i8* %.block_descriptor)
 // CHECK: %.block_descriptor.addr = alloca i8*, align 8
 // CHECK: %block.addr = alloca <{ i8*, i32, i32, i8*, %struct.__block_descriptor* }>*, align 8
 // CHECK: store i8* %.block_descriptor, i8** %.block_descriptor.addr, align 8

clang/test/CodeGen/func-in-block.c

     return 0; // not reached
 }
 
-// CHECK: @__func__.__main_block_invoke = private unnamed_addr constant [18 x i8] c"main_block_invoke\00"
+// CHECK: @__func__.__main_block_invoke_7636 = private unnamed_addr constant [18 x i8] c"main_block_invoke\00"
 // CHECK: call void @PRINTF({{.*}}@__func__.__main_block_invoke

clang/test/CodeGen/mangle-blocks.c

   };
 }
 
-// CHECK: @__func__.__mangle_block_invoke_2 = private unnamed_addr constant [22 x i8] c"mangle_block_invoke_2\00", align 1
+// CHECK: @__func__.__mangle_block_invoke_7636.{{[0-9]+}} = private unnamed_addr constant [20 x i8] c"mangle_block_invoke\00", align 1
 // CHECK: @.str{{.*}} = private unnamed_addr constant {{.*}}, align 1
 // CHECK: @.str[[STR1:.*]] = private unnamed_addr constant [7 x i8] c"mangle\00", align 1
 
-// CHECK: define internal void @__mangle_block_invoke(i8* %.block_descriptor)
+// CHECK: define internal void @__mangle_block_invoke_7636(i8* %.block_descriptor)
 
-// CHECK: define internal void @__mangle_block_invoke_2(i8* %.block_descriptor){{.*}}{
-// CHECK:   call void @__assert_rtn(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @__func__.__mangle_block_invoke_2, i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 9, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str[[STR1]], i32 0, i32 0))
+// CHECK: define internal void @__mangle_block_invoke_7636.{{[0-9]+}}(i8* %.block_descriptor){{.*}}{
+// CHECK:   call void @__assert_rtn(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @__func__.__mangle_block_invoke_7636.{{[0-9]+}}, i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 9, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str[[STR1]], i32 0, i32 0))
 // CHECK: }
-

clang/test/CodeGenCXX/block-byref.cpp

 
 // CHECK: @b = global i32 0,
 
-// CHECK: define {{.*}}void @{{.*}}test{{.*}}_block_invoke(
+// CHECK: define {{.*}}void @{{.*}}test{{.*}}_block_invoke_7636(
 // CHECK: store i32 2, i32* @b,
 // CHECK: ret void
 

clang/test/CodeGenCXX/blocks.cpp

 // CHECK: @[[BLOCK_DESCRIPTOR22:.*]] = internal constant { i64, i64, i8*, i8*, i8*, i8* } { i64 0, i64 36, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32c22_ZTSN12_GLOBAL__N_11BE to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32c22_ZTSN12_GLOBAL__N_11BE to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i8* null }, align 8
 
 namespace test0 {
-  // CHECK-LABEL: define void @_ZN5test04testEi(
-  // CHECK: define internal void @___ZN5test04testEi_block_invoke{{.*}}(
-  // CHECK: define internal void @___ZN5test04testEi_block_invoke_2{{.*}}(
-  void test(int x) {
-    ^{ ^{ (void) x; }; };
-  }
+// CHECK: define internal void @___ZN5test04testEi_block_invoke_7636{{.*}}(
+// CHECK: define internal void @___ZN5test04testEi_block_invoke_7636{{.*}}(
+  ^{
+    ^{
+      (void)x;
+    };
+  };
+}
 }
 
 extern void (^out)();

clang/test/CodeGenCXX/debug-info-block-invocation-linkage-name.cpp

 // RUN: %clang_cc1 -emit-llvm -debug-info-kind=standalone -fblocks -triple %itanium_abi_triple %s -o - | FileCheck %s
 
-// CHECK: !DISubprogram(name: "___Z1fU13block_pointerFviE_block_invoke", linkageName: "___Z1fU13block_pointerFviE_block_invoke"
+// CHECK: !DISubprogram(name: "___Z1fU13block_pointerFviE_block_invoke_2456", linkageName: "___Z1fU13block_pointerFviE_block_invoke_2456"
 void g(void (^call)(int));
 
 void f(void (^callback)(int)) {

clang/test/CodeGenCXX/predefined-expr-cxx14.cpp

 // CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [26 x i8] c"topLevelNamespaceFunction\00"
 // CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [60 x i8] c"auto *ClassInTopLevelNamespace::topLevelNamespaceFunction()\00"
 
-// CHECK-DAG: @__func__.___ZN16ClassBlockConstrD2Ev_block_invoke = private unnamed_addr constant [31 x i8] c"~ClassBlockConstr_block_invoke\00"
-// CHECK-DAG: @__func__.___ZN16ClassBlockConstrC2Ev_block_invoke = private unnamed_addr constant [30 x i8] c"ClassBlockConstr_block_invoke\00"
+// CHECK-DAG: @__func__.___ZN16ClassBlockConstrD2Ev_block_invoke_7636 = private unnamed_addr constant [31 x i8] c"~ClassBlockConstr_block_invoke\00"
+// CHECK-DAG: @__func__.___ZN16ClassBlockConstrC2Ev_block_invoke_7636 = private unnamed_addr constant [30 x i8] c"ClassBlockConstr_block_invoke\00"
 
 // CHECK-DAG: private unnamed_addr constant [32 x i8] c"const char *ConstexprPrettyFn()\00"
 

clang/test/CodeGenObjC/blocks-2.m

 // RUN: %clang_cc1 %s -emit-llvm -o - -fobjc-gc -fblocks -fexceptions -triple i386-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 | FileCheck %s
 // RUN: %clang_cc1 %s -emit-llvm -o - -fobjc-gc -fblocks -fexceptions -triple i386-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -x objective-c++ | FileCheck %s
 
-
 // CHECK: define i8* @{{.*}}test0
-// CHECK: define internal void @{{.*}}_block_invoke(
+// CHECK: define internal void @{{.*}}_block_invoke_7636(
 // CHECK:      call i8* @objc_assign_strongCast(
 // CHECK-NEXT: ret void
 id test0(id x) {

clang/test/CodeGenObjC/blocks.m

 -(void) im0;
 @end
 
-// CHECK: define internal i32 @"__8-[A im0]_block_invoke"(
+// CHECK: define internal i32 @"__8-[A im0]_block_invoke_7636"(
 @implementation A
 -(void) im0 {
   (void) ^{ return 1; }();

 // rdar://problem/9124263
 // In the test above, check that the use in the invocation function
 // doesn't require a read barrier.
-// CHECK-LABEL:    define internal void @__test2_block_invoke
+// CHECK-LABEL:    define internal void @__test2_block_invoke_7636
 // CHECK:      [[BLOCK:%.*]] = bitcast i8* {{%.*}} to [[BLOCK_T]]*
 // CHECK-NOT:  bitcast
 // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5

clang/test/CodeGenObjC/debug-info-block-line.m

 {
     NSString    *mapID = nil;
     TMap       *map = [TMap mapForID:mapID];
     // Make sure we do not map code generated for the block to the above line.
-// CHECK: define internal void @"__39-[TServer serverConnection:getCommand:]_block_invoke"
+    // CHECK: define internal void @"__39-[TServer serverConnection:getCommand:]_block_invoke_17504"
     // CHECK: call void @llvm.objc.storeStrong(i8** [[ZERO:%.*]], i8* [[ONE:%.*]]) [[NUW:#[0-9]+]]
     // CHECK: call void @llvm.objc.storeStrong(i8** [[TWO:%.*]], i8* [[THREE:%.*]]) [[NUW]]
     // CHECK: call {{.*}}@objc_msgSend{{.*}}, !dbg ![[LINE_ABOVE:[0-9]+]]
     // CHECK: getelementptr
     // CHECK-NOT: !dbg, ![[LINE_ABOVE]]
     // CHECK: bitcast %5** [[TMP:%.*]] to i8**
     // CHECK-NOT: !dbg, ![[LINE_ABOVE]]
     // CHECK: call void @llvm.objc.storeStrong(i8** [[VAL1:%.*]], i8* null) [[NUW]]
     // CHECK-NEXT: bitcast %4** [[TMP:%.*]] to i8**
     // CHECK-NEXT: call void @llvm.objc.storeStrong(i8** [[VAL2:%.*]], i8* null) [[NUW]]
     // CHECK-NEXT: ret
     // CHECK: attributes [[NUW]] = { nounwind }
     [map dataWithCompletionBlock:^(NSData *data, NSError *error) {
         if (data) {
             NSString    *encoded = [[data compressedData] encodedString:18];

clang/test/CodeGenObjC/debug-info-nested-blocks.m

 // Verify that debug info for BlockPointerDbgLoc is emitted for the
 // innermost block.
 //
-// CHECK: define {{.*}}void @__bar_block_invoke_3(i8* %.block_descriptor)
+// CHECK: define {{.*}}void @__bar_block_invoke_7636(i8* %.block_descriptor)
 // CHECK: %[[BLOCKADDR:.*]] = alloca <{{.*}}>*, align
 // CHECK: call void @llvm.dbg.declare(metadata {{.*}}%[[BLOCKADDR]]

clang/test/CodeGenObjC/mangle-blocks.m

 }
 @end
 
-// CHECK: @"__func__.__14-[Test mangle]_block_invoke_2" = private unnamed_addr constant [30 x i8] c"-[Test mangle]_block_invoke_2\00", align 1
+// CHECK: @"__func__.__14-[Test mangle]_block_invoke_7636.{{[0-9]+}}" = private unnamed_addr constant [28 x i8] c"-[Test mangle]_block_invoke\00", align 1
 // CHECK: @.str{{.*}} = private unnamed_addr constant {{.*}}, align 1
 // CHECK: @.str[[STR1:.*]] = private unnamed_addr constant [7 x i8] c"mangle\00", align 1
 
-// CHECK: define internal void @"__14-[Test mangle]_block_invoke"(i8* %.block_descriptor)
+// CHECK: define internal void @"__14-[Test mangle]_block_invoke_7636"(i8* %.block_descriptor)
 
-// CHECK: define internal void @"__14-[Test mangle]_block_invoke_2"(i8* %.block_descriptor){{.*}}{
-// CHECK: call void @__assert_rtn(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @"__func__.__14-[Test mangle]_block_invoke_2", i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 14, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str[[STR1]], i32 0, i32 0))
+// CHECK: define internal void @"__14-[Test mangle]_block_invoke_7636.{{[0-9]+}}"(i8* %.block_descriptor){{.*}}{
+// CHECK: call void @__assert_rtn(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @"__func__.__14-[Test mangle]_block_invoke_7636.{{[0-9]+}}", i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 14, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str[[STR1]], i32 0, i32 0))
 // CHECK: }

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

 void test0(id x) {
   extern void test0_helper(id (^)(void));
   test0_helper([=]() { return x; });
-  // CHECK-LABEL: define internal i8* @___Z5test0P11objc_object_block_invoke
+  // CHECK-LABEL: define internal i8* @___Z5test0P11objc_object_block_invoke_7636
   // CHECK: [[T0:%.*]] = call i8* @"_ZZ5test0P11objc_objectENK3$_0clEv"
   // CHECK-NEXT: [[T1:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T0]])
   // CHECK-NEXT: [[T2:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T1]])

 // 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-LABEL: define internal void @___Z8testWeakv_block_invoke_40178(
 // CHECK: call void @"_ZZ8testWeakvENK3$_2clE4Weak"(
 // CHECK-NEXT: ret void
 

clang/test/CodeGenObjCXX/block-default-arg.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -std=c++11 -fblocks -fobjc-arc | FileCheck  %s
 
-// CHECK: define internal void @___Z16test_default_argi_block_invoke(i8* %[[BLOCK_DESCRIPTOR:.*]])
+// CHECK: define internal void @___Z16test_default_argi_block_invoke_7636(i8* %[[BLOCK_DESCRIPTOR:.*]])
 // CHECK: %[[BLOCK:.*]] = bitcast i8* %[[BLOCK_DESCRIPTOR]] to <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>*
 // CHECK: %[[BLOCK_CAPTURE_ADDR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>, <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i32 }>* %[[BLOCK]], i32 0, i32 5
 // CHECK: %[[V0:.*]] = load i32, i32* %[[BLOCK_CAPTURE_ADDR]]

clang/test/CodeGenObjCXX/lambda-expressions.mm

 // MRC-LABEL: define i32 ()* @_Z1fv(
 // MRC-LABEL: define internal i32 ()* @"_ZZ1fvENK3$_0cvU13block_pointerFivEEv"
 // MRC: store i8* bitcast (i8** @_NSConcreteStackBlock to i8*)
-// MRC: store i8* bitcast (i32 (i8*)* @"___ZZ1fvENK3$_0cvU13block_pointerFivEEv_block_invoke" to i8*)
+// MRC: store i8* bitcast (i32 (i8*)* @"___ZZ1fvENK3$_0cvU13block_pointerFivEEv_block_invoke_7636" to i8*)
 // MRC: call i32 ()* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 ()* (i8*, i8*)*)
 // MRC: call i32 ()* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 ()* (i8*, i8*)*)
 // MRC: ret i32 ()*

 // ARC-LABEL: define i32 ()* @_Z1fv(
 // ARC-LABEL: define internal i32 ()* @"_ZZ1fvENK3$_0cvU13block_pointerFivEEv"
 // ARC: store i8* bitcast (i8** @_NSConcreteStackBlock to i8*)
-// ARC: store i8* bitcast (i32 (i8*)* @"___ZZ1fvENK3$_0cvU13block_pointerFivEEv_block_invoke" to i8*)
+// ARC: store i8* bitcast (i32 (i8*)* @"___ZZ1fvENK3$_0cvU13block_pointerFivEEv_block_invoke_7636" to i8*)
 // ARC: call i8* @llvm.objc.retainBlock
 // ARC: call i8* @llvm.objc.autoreleaseReturnValue
 

 void f2() { global = []{ return 3; }; }
 
 // MRC: define void @_Z2f2v() [[NUW:#[0-9]+]] {
-// MRC: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke to i8*),
+// MRC: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke_7636 to i8*),
 // MRC-NOT: call
 // 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: store i8* bitcast (i32 (i8*)* @___Z2f2v_block_invoke_7636 to i8*),
 // ARC: call i8* @llvm.objc.retainBlock
 // ARC: call void @llvm.objc.release
-// ARC-LABEL: define internal i32 @___Z2f2v_block_invoke
+// ARC-LABEL: define internal i32 @___Z2f2v_block_invoke_7636
 // ARC: call i32 @"_ZZ2f2vENK3$_1clEv
 
 template <class T> void take_lambda(T &&lambda) { lambda(); }

 // ARC-NOT: @llvm.objc.storeStrong(
 // ARC: ret void
 
-// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke"
+// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke_7636"
 // 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* %{{.*}})
+// ARC: define internal void @"___ZZN13LambdaCapture4foo1ERiENK3$_3clEv_block_invoke_7636.{{[0-9]+}}"(i8* %{{.*}})
 // 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

clang/test/CodeGenObjCXX/mangle-blocks.mm

 int f();
 
 void foo() {
-  // CHECK-LABEL: define internal i32 @___Z3foov_block_invoke
+  // CHECK-LABEL: define internal i32 @___Z3foov_block_invoke_2456
   // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZZ3foovEUb_E5value
   (void)^(int x) { 
     static int value = f();

   };
 }
 
-// CHECK-LABEL: define internal i32 @i_block_invoke
+// CHECK-LABEL: define internal i32 @i_block_invoke_2
 int i = ^(int x) { return x;}(i);
 
 @interface A

 @end
 
 @implementation A
-- (void)method { 
-  // CHECK: define internal signext i8 @"__11-[A method]_block_invoke"
+- (void)method {
+  // CHECK: define internal signext i8 @"__11-[A method]_block_invoke_2456"
   (void)^(int x) {
     // CHECK: @"_ZZZ11-[A method]EUb1_E4name"
     static const char *name = "hello";

 }
 
 namespace N {
-  // CHECK-LABEL: define internal signext i8 @___Z3fooi_block_invoke
-  void bar() {
-    (void)^(int x) { 
-      // CHECK: @_ZZZN1N3barEvEUb3_E4name
-      static const char *name = "hello";
-      return name[x];
-    };
-  }
+// CHECK-LABEL: define internal signext i8 @___Z3fooi_block_invoke_2456
+  (void)^(int x) {
 }
 
 class C {

clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl

   enqueue_kernel(default_queue, flags, ndrange, block);
 }
 
-// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i8 }> %0)
+// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_7636_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i8 }> %0)
 // CHECK-SAME: #[[ATTR:[0-9]+]] !kernel_arg_addr_space !{{.*}} !kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type !{{.*}} !kernel_arg_type_qual !{{.*}}
 // CHECK: entry:
 // CHECK:  %1 = alloca <{ i32, i32, i8*, i8 addrspace(1)*, i8 }>, align 8, addrspace(5)
 // CHECK:  store <{ i32, i32, i8*, i8 addrspace(1)*, i8 }> %0, <{ i32, i32, i8*, i8 addrspace(1)*, i8 }> addrspace(5)* %1, align 8
 // CHECK:  %2 = addrspacecast <{ i32, i32, i8*, i8 addrspace(1)*, i8 }> addrspace(5)* %1 to i8*
-// CHECK:  call void @__test_block_invoke(i8* %2)
+// CHECK:  call void @__test_block_invoke_7636(i8* %2)
 // CHECK:  ret void
 // CHECK:}
 
-// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_2_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %0)
+// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_7636.{{[0-9]+}}_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %0)
 // CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} !kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type !{{.*}} !kernel_arg_type_qual !{{.*}}
 
-// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_3_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %0, i8 addrspace(3)* %1)
+// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_24705_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %0, i8 addrspace(3)* %1)
 // CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} !kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type !{{.*}} !kernel_arg_type_qual !{{.*}}
 
-// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_4_kernel(<{ i32, i32, i8*, i64, i64 addrspace(1)* }> %0)
+// CHECK-LABEL: define internal amdgpu_kernel void @__test_block_invoke_7636.{{[0-9]+}}_kernel(<{ i32, i32, i8*, i64, i64 addrspace(1)* }> %0)
 // CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} !kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type !{{.*}} !kernel_arg_type_qual !{{.*}}
 
 // CHECK: attributes #[[ATTR]] = { nounwind "enqueued-block" }

clang/test/CodeGenOpenCL/blocks.cl

 
 // SPIR: %struct.__opencl_block_literal_generic = type { i32, i32, i8 addrspace(4)* }
 // AMDGCN: %struct.__opencl_block_literal_generic = type { i32, i32, i8* }
-// SPIR: @__block_literal_global = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 12, i32 4, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* @block_A_block_invoke to i8*) to i8 addrspace(4)*) }
-// AMDGCN: @__block_literal_global = internal addrspace(1) constant { i32, i32, i8* } { i32 16, i32 8, i8* bitcast (void (i8*, i8 addrspace(3)*)* @block_A_block_invoke to i8*) }
+// SPIR: @__block_literal_global = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 12, i32 4, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* @block_A_block_invoke{{.*}} to i8*) to i8 addrspace(4)*) }
+// AMDGCN: @__block_literal_global = internal addrspace(1) constant { i32, i32, i8* } { i32 16, i32 8, i8* bitcast (void (i8*, i8 addrspace(3)*)* @block_A_block_invoke{{.*}} to i8*) }
 // COMMON-NOT: .str
 
 // SPIR-LABEL: define internal {{.*}}void @block_A_block_invoke(i8 addrspace(4)* %.block_descriptor, i8 addrspace(3)* %a)

   // SPIR: store i32 4, i32* %[[block_align]]
   // AMDGCN: store i32 8, i32 addrspace(5)* %[[block_align]]
   // SPIR: %[[block_invoke:.*]] = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 }>, <{ i32, i32, i8 addrspace(4)*, i32 }>* %[[block:.*]], i32 0, i32 2
-  // SPIR: store i8 addrspace(4)* addrspacecast (i8* bitcast (i32 (i8 addrspace(4)*)* @__foo_block_invoke to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %[[block_invoke]]
+  // SPIR: store i8 addrspace(4)* addrspacecast (i8* bitcast (i32 (i8 addrspace(4)*)* @__foo_block_invoke_7636 to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %[[block_invoke]]
   // SPIR: %[[block_captured:.*]] = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 }>, <{ i32, i32, i8 addrspace(4)*, i32 }>* %[[block]], i32 0, i32 3
   // SPIR: %[[i_value:.*]] = load i32, i32* %i
   // SPIR: store i32 %[[i_value]], i32* %[[block_captured]],

   // SPIR: store %struct.__opencl_block_literal_generic addrspace(4)* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B:.*]],
   // SPIR: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic addrspace(4)*, %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B]]
   // SPIR: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic addrspace(4)* %[[block_literal]] to i8 addrspace(4)*
-  // SPIR: call {{.*}}i32 @__foo_block_invoke(i8 addrspace(4)* %[[blk_gen_ptr]])
+  // SPIR: call {{.*}}i32 @__foo_block_invoke_7636(i8 addrspace(4)* %[[blk_gen_ptr]])
   // AMDGCN: %[[block_invoke:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block:.*]], i32 0, i32 2
-  // AMDGCN: store i8* bitcast (i32 (i8*)* @__foo_block_invoke to i8*), i8* addrspace(5)* %[[block_invoke]]
+  // AMDGCN: store i8* bitcast (i32 (i8*)* @__foo_block_invoke_7636 to i8*), i8* addrspace(5)* %[[block_invoke]]
   // AMDGCN: %[[block_captured:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block]], i32 0, i32 3
   // AMDGCN: %[[i_value:.*]] = load i32, i32 addrspace(5)* %i
   // AMDGCN: store i32 %[[i_value]], i32 addrspace(5)* %[[block_captured]],

   // AMDGCN: store %struct.__opencl_block_literal_generic* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B:.*]],
   // AMDGCN: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic*, %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B]]
   // AMDGCN: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic* %[[block_literal]] to i8*
-  // AMDGCN: call {{.*}}i32 @__foo_block_invoke(i8* %[[blk_gen_ptr]])
+  // AMDGCN: call {{.*}}i32 @__foo_block_invoke_7636(i8* %[[blk_gen_ptr]])
 
   int (^ block_B)(void) = ^{
     return i;

   block_B();
 }
 
-// SPIR-LABEL: define internal {{.*}}i32 @__foo_block_invoke(i8 addrspace(4)* %.block_descriptor)
+// SPIR-LABEL: define internal {{.*}}i32 @__foo_block_invoke_7636(i8 addrspace(4)* %.block_descriptor)
 // SPIR:  %[[block:.*]] = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)*, i32 }> addrspace(4)*
 // SPIR:  %[[block_capture_addr:.*]] = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 }>, <{ i32, i32, i8 addrspace(4)*, i32 }> addrspace(4)* %[[block]], i32 0, i32 3
 // SPIR:  %[[block_capture:.*]] = load i32, i32 addrspace(4)* %[[block_capture_addr]]
-// AMDGCN-LABEL: define internal {{.*}}i32 @__foo_block_invoke(i8* %.block_descriptor)
+// AMDGCN-LABEL: define internal {{.*}}i32 @__foo_block_invoke_7636(i8* %.block_descriptor)
 // AMDGCN:  %[[block:.*]] = bitcast i8* %.block_descriptor to <{ i32, i32, i8*, i32 }>*
 // AMDGCN:  %[[block_capture_addr:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }>* %[[block]], i32 0, i32 3
 // AMDGCN:  %[[block_capture:.*]] = load i32, i32* %[[block_capture_addr]]
 
-// COMMON-NOT: define{{.*}}@__foo_block_invoke_kernel
+// COMMON-NOT: define{{.*}}@__foo_block_invoke_7636_kernel
 
 // Test that we support block arguments.
 // COMMON-LABEL: define {{.*}} @blockArgFunc

 }
 
 // COMMON-LABEL: define {{.*}} @get21
-// COMMON: define {{.*}} @__get21_block_invoke
+// COMMON: define {{.*}} @__get21_block_invoke_7636
 // COMMON: ret i32 21
 int get21() {
   return blockArgFunc(^{return 21;});
 }
 
 // COMMON-LABEL: define {{.*}} @get42
-// COMMON: define {{.*}} @__get42_block_invoke
+// COMMON: define {{.*}} @__get42_block_invoke_7636
 // COMMON: ret i32 42
 int get42() {
   return blockArgFunc(^{return 42;});
 }
 
 // COMMON-LABEL: define {{.*}}@call_block
-// call {{.*}}@__call_block_block_invoke
+// call {{.*}}@__call_block_block_invoke_7636
 int call_block() {
   return ^int(int num) { return num; } (11);
 }

clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl

   };
 
   // Uses global block literal [[BLG8]] and invoke function [[INVG8]].
-  // COMMON: call spir_func void @__device_side_enqueue_block_invoke_11(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
+  // COMMON: call spir_func void @__device_side_enqueue_block_invoke_7636.{{[0-9]+}}(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
   block_A();
 
   // Emits global block literal [[BLG8]] and block kernel [[INVGK8]]. [[INVGK8]] calls [[INVG8]].

   unsigned size = get_kernel_work_group_size(block_A);
 
   // Uses global block literal [[BLG8]] and invoke function [[INVG8]]. Make sure no redundant block literal and invoke functions are emitted.
-  // COMMON: call spir_func void @__device_side_enqueue_block_invoke_11(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
+  // COMMON: call spir_func void @__device_side_enqueue_block_invoke_7636.{{[0-9]+}}(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
   block_A();
 
   // Make sure that block invoke function is resolved correctly after sequence of assignements.

 
 // COMMON: define internal spir_kernel void [[INVLK1]](i8 addrspace(4)* %0) #{{[0-9]+}} {
 // COMMON: entry:
-// COMMON:  call void @__device_side_enqueue_block_invoke(i8 addrspace(4)* %0)
+// COMMON:  call void @__device_side_enqueue_block_invoke_7636(i8 addrspace(4)* %0)
 // COMMON:  ret void
 // COMMON: }
 // COMMON: define internal spir_kernel void [[INVLK2]](i8 addrspace(4)*{{.*}})

 // COMMON: define internal spir_kernel void [[INVGK5]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
 // COMMON: define internal spir_kernel void [[INVGK6]](i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3) #{{[0-9]+}} {
 // COMMON: entry:
-// COMMON:  call void @__device_side_enqueue_block_invoke_9(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3)
+// COMMON:  call void @__device_side_enqueue_block_invoke_{{[0-9.]+}}(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3)
 // COMMON:  ret void
 // COMMON: }
 // COMMON: define internal spir_kernel void [[INVGK7]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})

clang/test/PCH/block-helpers.cpp

 // CHECK: %[[V1:.*]] = bitcast %[[STRUCT_BLOCK_BYREF_Y]]* %[[Y]] to i8*
 // CHECK: store i8* %[[V1]], i8** %[[BLOCK_CAPTURED10]], align 8
 
-// CHECK-LABEL: define internal void @___ZN1S1mEv_block_invoke(
+// CHECK-LABEL: define internal void @___ZN1S1mEv_block_invoke_7636(
 
 // The second call to block_object_assign should be an invoke.
 

clang/test/PCH/no-escaping-block-tail-calls.cpp

 // Check that -fno-escaping-block-tail-calls doesn't disable tail-call
 // optimization if the block is non-escaping.
 
-// CHECK-LABEL: define internal i32 @___ZN1S1mEv_block_invoke(
+// CHECK-LABEL: define internal i32 @___ZN1S1mEv_block_invoke_7636(
 // CHECK: %[[CALL:.*]] = tail call i32 @_ZN1S3fooER2S0(
 // CHECK-NEXT: ret i32 %[[CALL]]
 

clang/test/Profile/Inputs/objc-general.proftext

-objc-general.m:__13+[A foreach:]_block_invoke
+objc-general.m:__13+[A foreach:]_block_invoke_7636
 42129
 2
 2

clang/test/Profile/objc-general.m

 #endif
 
 // PGOGEN: @[[FRC:"__profc_objc_general.m_\+\[A foreach_\]"]] = private global [2 x i64] zeroinitializer
-// PGOGEN: @[[BLC:"__profc_objc_general.m___13\+\[A foreach_\]_block_invoke"]] = private global [2 x i64] zeroinitializer
+// PGOGEN: @[[BLC:"__profc_objc_general.m___13\+\[A foreach_\]_block_invoke_7636"]] = private global [2 x i64] zeroinitializer
 // PGOGEN: @[[MAC:__profc_main]] = private global [1 x i64] zeroinitializer
 
 @interface A : NSObject

   // PGOUSE: br {{.*}} !prof ![[FR1:[0-9]+]]
   // PGOUSE: br {{.*}} !prof ![[FR2:[0-9]+]]
   for (id x in array) {
-    // PGOGEN: define {{.*}}_block_invoke
-    // PGOUSE: define {{.*}}_block_invoke
+    // PGOGEN: define {{.*}}_block_invoke_7636
+    // PGOUSE: define {{.*}}_block_invoke_7636
     // PGOGEN: store {{.*}} @[[BLC]], i64 0, i64 0
     ^{ static int init = 0;
       // PGOGEN: store {{.*}} @[[BLC]], i64 0, i64 1