[CodeGen] Merge identical block descriptor global variables

[ahatanak]

Summary

Currently, clang generates a new block descriptor global variable for each block literal. This patch merges block descriptors that are identical inside and across translation units using the same approach taken in r339438.

To enable merging identical block descriptors, the information of each member of a block descriptor is encoded into the block descriptor name. Also, the linkage of the block descriptor is linkonce_odr unless the copy or dispose helper is internal.

[ahatanak]

A few points I forgot to mention:

• This optimization kicks in only in NonGC mode. I don't think we need to care much about GC anymore, so I think that's OK.

• There is a lot of redundancy among the copy/dispose helper function strings and the block layout string in the block descriptor name (they all encode the information about the captures), which can make the descriptor name long. If that becomes a problem, it's possible to encode the information in a way that shortens the descriptor name, but that would probably make the function that generates the name more complex.

[rjmccall]

In D50783#1200868, @ahatanak wrote:

A few points I forgot to mention:

• This optimization kicks in only in NonGC mode. I don't think we need to care much about GC anymore, so I think that's OK.

Yes, that's fine.

• There is a lot of redundancy among the copy/dispose helper function strings and the block layout string in the block descriptor name (they all encode the information about the captures), which can make the descriptor name long. If that becomes a problem, it's possible to encode the information in a way that shortens the descriptor name, but that would probably make the function that generates the name more complex.

It should be straightforward to at least get merge the copy/dispose helper function names, right? Those make basically the same pass over the captures and just check for slightly different things; the block-descriptor summary just has to include a little of both.

To unique the block layout string as well, we'd just have to cover the captures for which we haven't added any other description. If you want to punt on that, I think that's fine.

[ahatanak]

Try harder to shorten the names of block descriptor global variables.

The strings extracted from the names of the copy and dispose helpers are merged whenever it is possible to do so. The block layout string doesn't include information about __strong, __weak, or byref captures unless the copy/dispose helpers are missing.

[rjmccall]

Okay.

[rsmith]

lib/CodeGen/CGBlocks.cpp

239–245

Would it make sense to also mark this constant as unnamed_addr?

[ahatanak]

lib/CodeGen/CGBlocks.cpp

239–245

Yes. I don't think there is any harm in marking it as unnamed_addr. However, unfortunately it looks like ld64 doesn't try to merge unnamed_addr global variables.

[ahatanak]

Mark the block descriptor global variable as unnamed_addr.

[theraven]

This revision broke blocks on all ELF targets. The block descriptors' symbol names can now include the @ character, which is reserved on ELF platforms as a separator between symbol name and symbol version. As a result, nothing containing a block that has an Objective-C object argument will link. Please add mangling similar to that in the GNUstep runtime to avoid this.

lib/CodeGen/CGBlocks.cpp

163

Specifically, this line. It is unsafe to use an Objective-C encoding directly as a symbol name on ELF.

[ahatanak]

The GNUstep documentation I found replaces '@' with '\1'. Would that fix the problem?

https://github.com/gnustep/libobjc2/blob/master/ABIDoc/abi.tex

[theraven]

In D50783#1221147, @ahatanak wrote:

The GNUstep documentation I found replaces '@' with '\1'. Would that fix the problem?

https://github.com/gnustep/libobjc2/blob/master/ABIDoc/abi.tex

Yup. If this mangling is needed outside of CGObjCGNU, it would be good to take the code that does this mangling and move it somewhere that can be reused. I don't know if there are any characters that are valid in Objective-C type encoding but aren't valid in Windows PE/COFF symbols, but having a hook to fix them in a single place sounds like a good idea.

lib/CodeGen/CGBlocks.cpp

 }
 
 /// Build the helper function to dispose of a block.
 static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
                                           const CGBlockInfo &blockInfo) {
   return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
 }
 
+namespace {
+
+// A struct containing the information needed to generate a block descriptor
+// global variable and its name.
+struct BlockDescriptorInfo {
+  // Size of the block.
+  unsigned Size;
+
+  // Block copy and dispose helper functions.
+  llvm::Constant *CopyHelper = nullptr, *DisposeHelper = nullptr;
+
+  // Type-encoding string.
+  std::string TypeAtEncoding;
+
+  // Block layout string. Note that we cannot use the block layout's C literal
+  // string since it may contain a null byte, which is not allowed in function
+  // names.
+  std::string BlockLayoutStr;
+
+  // The global variable that has the block layout information.
+  llvm::Constant *LayoutInfo;
+};
+
+const char CopyHelperPrefix[] = "__copy_helper_block_";
+const char DisposeHelperPrefix[] = "__destroy_helper_block_";
+
+}
+
+static std::string getBlockDescriptorName(const BlockDescriptorInfo &DescInfo) {
+  std::string Name = "__block_descriptor";
+  Name += llvm::to_string(DescInfo.Size);
+
+  if (DescInfo.CopyHelper) {
+    // The name of the copy helper with the prefix removed.
+    StringRef CopyHelperStr =
+        DescInfo.CopyHelper->getOperand(0)->getName().substr(
+            StringRef(CopyHelperPrefix).size());
+    Name +=
+        "c" + llvm::to_string(CopyHelperStr.size()) + "_" + CopyHelperStr.str();
+    // The name of the dispose helper with the prefix removed.
+    StringRef DisposeHelperStr =
+        DescInfo.DisposeHelper->getOperand(0)->getName().substr(
+            StringRef(DisposeHelperPrefix).size());
+    Name += "d" + llvm::to_string(DisposeHelperStr.size()) + "_" +
+            DisposeHelperStr.str();
+  }
+
+  Name += "e" + llvm::to_string(DescInfo.TypeAtEncoding.size()) + "_" +
+          DescInfo.TypeAtEncoding;
+  Name += "l" + DescInfo.BlockLayoutStr;
+  return Name;
+}
+
 /// buildBlockDescriptor - Build the block descriptor meta-data for a block.
 /// buildBlockDescriptor is accessed from 5th field of the Block_literal
 /// meta-data and contains stationary information about the block literal.
 /// Its definition will have 4 (or optionally 6) words.
 /// \code
 /// struct Block_descriptor {
 ///   unsigned long reserved;
 ///   unsigned long size;  // size of Block_literal metadata in bytes.
 ///   void *copy_func_helper_decl;  // optional copy helper.
 ///   void *destroy_func_decl; // optioanl destructor helper.
 ///   void *block_method_encoding_address; // @encode for block literal signature.
 ///   void *block_layout_info; // encoding of captured block variables.
 /// };
 /// \endcode
 static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM,
                                             const CGBlockInfo &blockInfo) {
   ASTContext &C = CGM.getContext();
+  BlockDescriptorInfo descInfo;
 
   llvm::IntegerType *ulong =
       cast<llvm::IntegerType>(CGM.getTypes().ConvertType(C.UnsignedLongTy));
   llvm::PointerType *i8p = nullptr;
   if (CGM.getLangOpts().OpenCL)
-    i8p =
-      llvm::Type::getInt8PtrTy(
-           CGM.getLLVMContext(), C.getTargetAddressSpace(LangAS::opencl_constant));
+    i8p = llvm::Type::getInt8PtrTy(
   else
     i8p = CGM.VoidPtrTy;
 
+  descInfo.Size = blockInfo.BlockSize.getQuantity();
+
+  // Optional copy/dispose helpers.
+  if (blockInfo.needsCopyDisposeHelpers()) {
+    // copy_func_helper_decl
+    descInfo.CopyHelper = buildCopyHelper(CGM, blockInfo);
+
+    // destroy_func_decl
+    descInfo.DisposeHelper = buildDisposeHelper(CGM, blockInfo);
+  }
+
+  descInfo.TypeAtEncoding =
+      CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr());
+
+  std::string descName;
+
+  // GC layout.
+  if (C.getLangOpts().ObjC1) {
+    if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
+      descInfo.LayoutInfo =
+          CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo);
+    else {
+      descInfo.LayoutInfo =
+          CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo,
+                                                  descInfo.BlockLayoutStr);
+
+      // Get the encoded block descriptor name.
+      descName = getBlockDescriptorName(descInfo);
+
+      // If the block descriptor already exists, return it.
+      if (llvm::GlobalValue *desc = CGM.getModule().getNamedValue(descName))
+        return llvm::ConstantExpr::getBitCast(desc,
+                                              CGM.getBlockDescriptorType());
+    }
+  } else
+    descInfo.LayoutInfo = llvm::ConstantPointerNull::get(i8p);
+
+  // Create a new block descriptor global variable.
   ConstantInitBuilder builder(CGM);
   auto elements = builder.beginStruct();
 
   // reserved
   elements.addInt(ulong, 0);
 
   // Size
   // FIXME: What is the right way to say this doesn't fit?  We should give
   // a user diagnostic in that case.  Better fix would be to change the
   // API to size_t.
-  elements.addInt(ulong, blockInfo.BlockSize.getQuantity());
+  elements.addInt(ulong, descInfo.Size);
 
   // Optional copy/dispose helpers.
+  assert(((descInfo.CopyHelper && descInfo.DisposeHelper) ||
+          (!descInfo.CopyHelper && !descInfo.DisposeHelper)) &&
+         "both helpers exist or neither helpers exist");
   if (blockInfo.needsCopyDisposeHelpers()) {
-    // copy_func_helper_decl
-    elements.add(buildCopyHelper(CGM, blockInfo));
-
-    // destroy_func_decl
-    elements.add(buildDisposeHelper(CGM, blockInfo));
+    assert(descInfo.CopyHelper && "no copy helper");
+    elements.add(descInfo.CopyHelper);
+    elements.add(descInfo.DisposeHelper);
   }
 
   // Signature.  Mandatory ObjC-style method descriptor @encode sequence.
-  std::string typeAtEncoding =
-    CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr());
   elements.add(llvm::ConstantExpr::getBitCast(
-    CGM.GetAddrOfConstantCString(typeAtEncoding).getPointer(), i8p));
+      CGM.GetAddrOfConstantCString(descInfo.TypeAtEncoding).getPointer(), i8p));
 
-  // GC layout.
-  if (C.getLangOpts().ObjC1) {
-    if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
-      elements.add(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo));
-    else
-      elements.add(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo));
-  }
-  else
-    elements.addNullPointer(i8p);
+  elements.add(descInfo.LayoutInfo);
 
   unsigned AddrSpace = 0;
   if (C.getLangOpts().OpenCL)
     AddrSpace = C.getTargetAddressSpace(LangAS::opencl_constant);
 
+  llvm::GlobalValue::LinkageTypes linkage;
+  if (descName.empty()) {
+    linkage = llvm::GlobalValue::InternalLinkage;
+    descName = "__block_descriptor_tmp";
+  } else if (descInfo.CopyHelper) {
+    const auto *CopyHelper =
+        cast<llvm::Function>(descInfo.CopyHelper->getOperand(0));
+    const auto *DisposeHelper =
+        cast<llvm::Function>(descInfo.DisposeHelper->getOperand(0));
+    // If either the copy helper or the dispose helper has internal linkage,
+    // the block descriptor must have internal linkage too.
+    if (CopyHelper->getLinkage() == llvm::GlobalValue::InternalLinkage ||
+        DisposeHelper->getLinkage() == llvm::GlobalValue::InternalLinkage)
+      linkage = llvm::GlobalValue::InternalLinkage;
+    else
+      linkage = llvm::GlobalValue::LinkOnceODRLinkage;
+  } else {
+    linkage = llvm::GlobalValue::LinkOnceODRLinkage;
+  }
+
   llvm::GlobalVariable *global =
-    elements.finishAndCreateGlobal("__block_descriptor_tmp",
-                                   CGM.getPointerAlign(),
-                                   /*constant*/ true,
-                                   llvm::GlobalValue::InternalLinkage,
-                                   AddrSpace);
+      elements.finishAndCreateGlobal(descName, CGM.getPointerAlign(),
+                                     /*constant*/ true, linkage, AddrSpace);
+
+  if (linkage == llvm::GlobalValue::LinkOnceODRLinkage)
+    global->setVisibility(llvm::GlobalValue::HiddenVisibility);
 
   return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType());
 }
 
 /*
   Purely notional variadic template describing the layout of a block.
 
   template <class _ResultType, class... _ParamTypes, class... _CaptureTypes>
   struct Block_literal {

 static std::string getCopyDestroyHelperFuncName(
     const SmallVectorImpl<BlockCaptureManagedEntity> &Captures,
     CharUnits BlockAlignment, bool IsCopyHelper, CodeGenModule &CGM) {
   ASTContext &Ctx = CGM.getContext();
   std::unique_ptr<ItaniumMangleContext> MC(
       ItaniumMangleContext::create(Ctx, Ctx.getDiagnostics()));
 
   std::string Name =
-      IsCopyHelper ? "__copy_helper_block_" : "__destroy_helper_block_";
+      IsCopyHelper ? CopyHelperPrefix : DisposeHelperPrefix;
   if (CGM.getLangOpts().Exceptions)
     Name += "e";
   if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
     Name += "a";
   Name += llvm::to_string(BlockAlignment.getQuantity()) + "_";
 
   for (const BlockCaptureManagedEntity &E : Captures) {
     const BlockDecl::Capture &CI = *E.CI;

lib/CodeGen/CGObjCGNU.cpp

llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
                               const ObjCInterfaceDecl *Interface,
                               const ObjCIvarDecl *Ivar) override;
   llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
   llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
                                      const CGBlockInfo &blockInfo) override {
     return NULLPtr;
   }
   llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
-                                     const CGBlockInfo &blockInfo) override {
+                                     const CGBlockInfo &blockInfo,
+                                     std::string &layoutStr) override {
     return NULLPtr;
   }
 
   llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
     return NULLPtr;
   }
 };
 

lib/CodeGen/CGObjCMac.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 
 using namespace clang;
 using namespace CodeGen;
 
 namespace {
 
public:
   /// definition is seen. The return value has type ProtocolPtrTy.
   virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
 
   virtual llvm::Constant *getNSConstantStringClassRef() = 0;
 
   llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
                                      const CGBlockInfo &blockInfo) override;
   llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
-                                     const CGBlockInfo &blockInfo) override;
+                                     const CGBlockInfo &blockInfo,
+                                     std::string &layoutStr) override;
 
   llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                    QualType T) override;
 };
 
 namespace {
 
 enum class MethodListType {
llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
   }
 
   auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
                                      /*ForceNonFragileABI=*/true,
                                      /*NullTerminate=*/false);
   return getConstantGEP(VMContext, Entry, 0, 0);
 }
 
+static std::string getBlockLayoutInfoString(
+    const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars) {
+  std::string Str;
+
+  for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
+    Str += llvm::to_string(R.block_var_bytepos.getQuantity());
+    Str += "s" + llvm::to_string(R.block_var_size.getQuantity());
+    switch (R.opcode) {
+    case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
+      Str += "s";
+      break;
+    case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
+      Str += "r";
+      break;
+    case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
+      Str += "w";
+      break;
+    case CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED:
+      Str += "u";
+      break;
+    default:
+      break;
+    }
+  }
+
+  return Str;
+}
+
 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
-                                                    const CGBlockInfo &blockInfo) {
+                                                    const CGBlockInfo &blockInfo,
+                                                    std::string &layoutStr) {
   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
 
   RunSkipBlockVars.clear();
   bool hasUnion = false;
 
   unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
   unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
for (const auto &CI : blockDecl->captures()) {
     CharUnits fieldSize;
     if (CI.isByRef())
       fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
     else
       fieldSize = CGM.getContext().getTypeSizeInChars(type);
     UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
                            fieldOffset, fieldSize);
   }
+
+  layoutStr = getBlockLayoutInfoString(RunSkipBlockVars);
   return getBitmapBlockLayout(false);
 }
 
 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                                   QualType T) {
   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
   assert(!T->isArrayType() && "__block array variable should not be caught");
   CharUnits fieldOffset;

lib/CodeGen/CGObjCRuntime.h

virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
                                       const ObjCIvarDecl *Ivar) = 0;
   virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
                                         Address DestPtr,
                                         Address SrcPtr,
                                         llvm::Value *Size) = 0;
   virtual llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
                                   const CodeGen::CGBlockInfo &blockInfo) = 0;
   virtual llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
-                                  const CodeGen::CGBlockInfo &blockInfo) = 0;
+                                  const CodeGen::CGBlockInfo &blockInfo,
+                                  std::string &layoutStr) = 0;
 
   /// Returns an i8* which points to the byref layout information.
   virtual llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
                                            QualType T) = 0;
 
   struct MessageSendInfo {
     const CGFunctionInfo &CallInfo;
     llvm::PointerType *MessengerType;

test/CodeGenCXX/blocks.cpp

 // RUN: %clang_cc1 %s -fblocks -triple x86_64-apple-darwin -emit-llvm -o - | FileCheck %s
 
+// CHECK: %[[STRUCT_BLOCK_DESCRIPTOR:.*]] = type { i64, i64 }
+// 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; }; };
   }
 }
namespace test4 {
   void test() {
     extern void consume(void(^)());
     consume(^{ return foo(A()); });
   }
   // CHECK-LABEL: define void @_ZN5test44testEv()
   // CHECK-LABEL: define internal void @___ZN5test44testEv_block_invoke
   // CHECK: [[TMP:%.*]] = alloca [[A:%.*]], align 1
   // CHECK-NEXT: store i8* [[BLOCKDESC:%.*]], i8** {{.*}}, align 8
-  // CHECK-NEXT: bitcast i8* [[BLOCKDESC]] to <{ i8*, i32, i32, i8*, %struct.__block_descriptor* }>*
+  // CHECK-NEXT: bitcast i8* [[BLOCKDESC]] to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]* }>*
   // CHECK:      call void @_ZN5test41AC1Ev([[A]]* [[TMP]])
   // CHECK-NEXT: call void @_ZN5test43fooENS_1AE([[A]]* [[TMP]])
   // CHECK-NEXT: call void @_ZN5test41AD1Ev([[A]]* [[TMP]])
   // CHECK-NEXT: ret void
 }
 
 namespace test5 {
   struct A {
namespace test10 {
   };
 
   void test() {
     volatile B x;
     ^{ (void)x; };
   }
 }
 
-// Copy/dispose helper functions that capture objects of non-external types
-// should have internal linkage.
+// Copy/dispose helper functions and block descriptors of blocks that capture
+// objects that are non-external and non-trivial have internal linkage.
+
+// CHECK-LABEL: define internal void @_ZN12_GLOBAL__N_14testEv(
+// CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i8* }* @[[BLOCK_DESCRIPTOR22]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %{{.*}}, align 8
 
 // CHECK-LABEL: define internal void @__copy_helper_block_8_32c22_ZTSN12_GLOBAL__N_11BE(
 // CHECK-LABEL: define internal void @__destroy_helper_block_8_32c22_ZTSN12_GLOBAL__N_11BE(
 
 namespace {
   struct B {
     int a;
     B();

test/CodeGenObjC/arc-blocks.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck -check-prefix=CHECK -check-prefix=CHECK-COMMON %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=CHECK-UNOPT -check-prefix=CHECK-COMMON %s
 
 // CHECK-COMMON: %[[STRUCT_BLOCK_DESCRIPTOR:.*]] = type { i64, i64 }
-// CHECK-COMMON: @{{.*}} = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32r to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32r to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 16 }, align 8
-// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP9:.*]] = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32r to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32r to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 16 }, align 8
-// CHECK-COMMON: @{{.*}} = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
-// CHECK-COMMON: @{{.*}} = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
-// CHECK-COMMON: @{{.*}} = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
-// CHECK-COMMON: @{{.*}} = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
-// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP44:.*]] = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
-// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP46:.*]] = internal constant { i64, i64, i8*, i8*, i8*, i8* } { i64 0, i64 48, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @{{.*}}, i32 0, i32 0) }, align 8
-// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP48:.*]] = internal constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32b to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.47, i32 0, i32 0), i64 256 }, align 8
+// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP44:.*]] = linkonce_odr hidden constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
+// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP9:.*]] = linkonce_odr hidden constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32r to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32r to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 16 }, align 8
+// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP46:.*]] = linkonce_odr hidden constant { i64, i64, i8*, i8*, i8*, i8* } { i64 0, i64 48, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @{{.*}}, i32 0, i32 0) }, align 8
+// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP48:.*]] = linkonce_odr hidden constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32b to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
 
 // This shouldn't crash.
 void test0(id (^maker)(void)) {
   maker();
 }
 
 int (^test1(int x))(void) {
   // CHECK-LABEL:    define i32 ()* @test1(

test/CodeGenObjC/fragile-arc.m

 //    'T' == 0x54, '7' == 0x37
 // GLOBALS: @OBJC_CLASS_NAME_{{.*}} = private unnamed_addr constant [3 x i8] c"T7\00"
 //  Weak layout: skip nine, scan three
 // GLOBALS: @OBJC_CLASS_NAME_{{.*}} = private unnamed_addr constant [2 x i8] c"\93\00"
 
 extern void useBlock(void (^block)(void));
 
 //  256 == 0x100 == starts with 1 strong
-// GLOBALS: @__block_descriptor_tmp{{.*}} = internal constant {{.*}}, i32 256 }
+// GLOBALS: @"__block_descriptor{{.*}} = linkonce_odr hidden {{.*}}, i32 256 }
 void testBlockLayoutStrong(id x) {
   useBlock(^{ (void) x; });
 }
 
 //  1   == 0x001 == starts with 1 weak
-// GLOBALS: @__block_descriptor_tmp{{.*}} = internal constant {{.*}}, i32 1 }
+// GLOBALS: @"__block_descriptor{{.*}} = linkonce_odr hidden {{.*}}, i32 1 }
 void testBlockLayoutWeak(__weak id x) {
   useBlock(^{ (void) x; });
 }
 
 // CHECK-LABEL: define void @testCatch()
 // CHECK: [[X:%.*]] = alloca [[A:%.*]]*, align 4
 // CHECK: [[Y:%.*]] = alloca i8*, align 4
 // CHECK: call void @objc_exception_try_enter

test/CodeGenObjC/noescape.m

 void noescapeFunc1(__attribute__((noescape)) int *);
 void noescapeFunc2(__attribute__((noescape)) id);
 void noescapeFunc3(__attribute__((noescape)) union U);
 
 // Block descriptors of non-escaping blocks don't need pointers to copy/dispose
 // helper functions.
 
 // CHECK: %[[STRUCT_BLOCK_DESCRIPTOR:.*]] = type { i64, i64 }
-// CHECK: @[[BLOCK_DESCIPTOR_TMP_2:.*]] = internal constant { i64, i64, i8*, i64 } { i64 0, i64 40, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
+// CHECK: @[[BLOCK_DESCIPTOR_TMP_2:.*]] = linkonce_odr hidden constant { i64, i64, i8*, i64 } { i64 0, i64 40, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8
 
 // CHECK-LABEL: define void @test0(
 // CHECK: call void @noescapeFunc0({{.*}}, {{.*}} nocapture {{.*}})
 // CHECK: declare void @noescapeFunc0(i8*, {{.*}} nocapture)
 void test0(BlockTy b) {
   noescapeFunc0(0, b);
 }