Make internal/private GVs implicitly dso_local

[• espindola]

Summary

While updating the tests for https://reviews.llvm.org/D41318 I noticed that:

• There are *a lot* of tests to update.
• Many of the updates are redundant.

They are redundant because a GV is "obviously dso_local". This patch starts formalizing that a bit by requiring that internal and private GVs be dso_local too. Since they all are, we don't have to print dso_local to the textual representation, making it a bit more compact and easier to read.

[• espindola]

Rebased. Remove a case that is now redundant from TargetMachine::shouldAssumeDSOLocal.

[sfertile]

This is a really good idea, LGTM.

llvm/lib/AsmParser/LLParser.cpp

829

We should probably add a short comment explaining why we only set this when its true now, since from here its not obvious that setting the linkage may have already set it to local.

llvm/test/Bitcode/thinlto-summary-section.ll

7

This should say `Flags should be 0x57 (87) for ...,

[• espindola]

r322317 and r322318.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::emitTargetOutlinedFunctionHelper(
   // device, the ID has to be the function address so that it can retrieved from
   // the offloading entry and launched by the runtime library. We also mark the
   // outlined function to have external linkage in case we are emitting code for
   // the device, because these functions will be entry points to the device.
 
   if (CGM.getLangOpts().OpenMPIsDevice) {
     OutlinedFnID = llvm::ConstantExpr::getBitCast(OutlinedFn, CGM.Int8PtrTy);
     OutlinedFn->setLinkage(llvm::GlobalValue::ExternalLinkage);
+    OutlinedFn->setDSOLocal(false);
   } else
     OutlinedFnID = new llvm::GlobalVariable(
         CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
         llvm::GlobalValue::PrivateLinkage,
         llvm::Constant::getNullValue(CGM.Int8Ty), ".omp_offload.region_id");
 
   // Register the information for the entry associated with this target region.
   OffloadEntriesInfoManager.registerTargetRegionEntryInfo(

clang/test/CodeGenCXX/microsoft-abi-static-initializers.cpp

 // CHECK: define internal void @"\01??__Fs@@YAXXZ"()
 // CHECK: call x86_thiscallcc void @"\01??1S@@QAE@XZ"
 // CHECK: ret void
 
 // These globals should have initializers comdat associative with the global.
 // See @llvm.global_ctors above.
 __declspec(selectany) S selectany1;
 __declspec(selectany) S selectany2;
-// CHECK: define linkonce_odr void @"\01??__Eselectany1@@YAXXZ"() {{.*}} comdat
+// CHECK: define linkonce_odr dso_local void @"\01??__Eselectany1@@YAXXZ"() {{.*}} comdat
 // CHECK-NOT: @"\01??_Bselectany1
 // CHECK: call x86_thiscallcc %struct.S* @"\01??0S@@QAE@XZ"
 // CHECK: ret void
-// CHECK: define linkonce_odr void @"\01??__Eselectany2@@YAXXZ"() {{.*}} comdat
+// CHECK: define linkonce_odr dso_local void @"\01??__Eselectany2@@YAXXZ"() {{.*}} comdat
 // CHECK-NOT: @"\01??_Bselectany2
 // CHECK: call x86_thiscallcc %struct.S* @"\01??0S@@QAE@XZ"
 // CHECK: ret void
 
 // The implicitly instantiated static data member should have initializer
 // comdat associative with the global.
 template <typename T> struct __declspec(dllexport) ExportedTemplate {
   static S s;
void force_usage() {
   (void)B<int>::foo;  // (void) - force usage
   enum_in_function();
   (void)&T::enum_in_struct;
   switch_test(1);
   switch_test2();
   DynamicDLLImportInitVSMangling::switch_test3();
 }
 
-// CHECK: define linkonce_odr void @"\01??__Efoo@?$B@H@@2VA@@A@YAXXZ"() {{.*}} comdat
+// CHECK: define linkonce_odr dso_local void @"\01??__Efoo@?$B@H@@2VA@@A@YAXXZ"() {{.*}} comdat
 // CHECK-NOT: and
 // CHECK-NOT: ?_Bfoo@
 // CHECK: call x86_thiscallcc %class.A* @"\01??0A@@QAE@XZ"
 // CHECK: call i32 @atexit(void ()* @"\01??__Ffoo@?$B@H@@2VA@@A@YAXXZ")
 // CHECK: ret void
 
 // CHECK: define linkonce_odr x86_thiscallcc %class.A* @"\01??0A@@QAE@XZ"({{.*}}) {{.*}} comdat
 

clang/test/OpenMP/target_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_parallel_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_parallel_for_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_parallel_for_simd_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_simd_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_teams_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_teams_distribute_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

clang/test/OpenMP/target_teams_distribute_simd_codegen_registration.cpp

 // Check registration and unregistration
 
 //CHECK:     define internal void @[[UNREGFN:.+]](i8*)
 //CHECK-SAME: comdat($[[REGFN]]) {
 //CHECK:     call i32 @__tgt_unregister_lib([[DSCTY]]* [[DESC]])
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_unregister_lib([[DSCTY]]*)
 
-//CHECK:     define linkonce hidden void @[[REGFN]](i8*)
+//CHECK:     define linkonce dso_local hidden void @[[REGFN]](i8*)
 //CHECK-SAME: comdat {
 //CHECK:     call i32 @__tgt_register_lib([[DSCTY]]* [[DESC]])
 //CHECK:     call i32 @__cxa_atexit(void (i8*)* @[[UNREGFN]], i8* bitcast ([[DSCTY]]* [[DESC]] to i8*),
 //CHECK:     ret void
 //CHECK:     declare i32 @__tgt_register_lib([[DSCTY]]*)
 
 static __attribute__((init_priority(500))) SA a1;
 SA a2;

llvm/include/llvm/IR/GlobalValue.h

enum DLLStorageClassTypes {
     DLLImportStorageClass = 1, ///< Function to be imported from DLL
     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
   };
 
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
-        ValueType(Ty), Linkage(Linkage), Visibility(DefaultVisibility),
+        ValueType(Ty), Visibility(DefaultVisibility),
         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IsDSOLocal(false),
-        IntID((Intrinsic::ID)0U), Parent(nullptr) {
+        HasLLVMReservedName(false), IsDSOLocal(false), IntID((Intrinsic::ID)0U),
+        Parent(nullptr) {
+    setLinkage(Linkage);
     setName(Name);
   }
 
   Type *ValueType;
 
   static const unsigned GlobalValueSubClassDataBits = 17;
 
   // All bitfields use unsigned as the underlying type so that MSVC will pack
bool hasExternalWeakLinkage() const {
     return isExternalWeakLinkage(getLinkage());
   }
   bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
   bool hasValidDeclarationLinkage() const {
     return isValidDeclarationLinkage(getLinkage());
   }
 
   void setLinkage(LinkageTypes LT) {
-    if (isLocalLinkage(LT))
+    if (isLocalLinkage(LT)) {
       Visibility = DefaultVisibility;
+      if (getValueID() != Value::GlobalIFuncVal)
+        setDSOLocal(true);
+    }
     Linkage = LT;
   }
   LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
 
   bool isDiscardableIfUnused() const {
     return isDiscardableIfUnused(getLinkage());
   }
 

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   else
     GA.reset(GlobalIFunc::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GA->setUnnamedAddr(UnnamedAddr);
-  GA->setDSOLocal(DSOLocal);
+  if (DSOLocal)
+    GA->setDSOLocal(true);
 
   if (Name.empty())
     NumberedVals.push_back(GA.get());
 
   if (GVal) {
     // Verify that types agree.
     if (GVal->getType() != GA->getType())
       return Error(
bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
   if (Name.empty())
     NumberedVals.push_back(GV);
 
   // Set the parsed properties on the global.
   if (Init)
     GV->setInitializer(Init);
   GV->setConstant(IsConstant);
   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
-  GV->setDSOLocal(DSOLocal);
+  if (DSOLocal)
+    GV->setDSOLocal(true);
   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GV->setExternallyInitialized(IsExternallyInitialized);
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
 
   // Parse attributes on the global.
   while (Lex.getKind() == lltok::comma) {
if (!Fn)
     Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
   else // Move the forward-reference to the correct spot in the module.
     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
 
   if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
-  Fn->setDSOLocal(DSOLocal);
+  if (DSOLocal)
+    Fn->setDSOLocal(true);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
   Fn->setComdat(C);

llvm/lib/IR/AsmWriter.cpp

static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
                             formatted_raw_ostream &Out) {
   switch (Vis) {
   case GlobalValue::DefaultVisibility: break;
   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
   }
 }
 
-static void PrintDSOLocation(bool IsDSOLocal, formatted_raw_ostream &Out){
-  if (IsDSOLocal)
+static void PrintDSOLocation(const GlobalValue &GV,
+                             formatted_raw_ostream &Out) {
+  // GVs with local linkage are implicitly dso_local, so we don't print it.
+  if (GV.isDSOLocal() && !GV.hasLocalLinkage())
     Out << "dso_local ";
 }
 
 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
                                  formatted_raw_ostream &Out) {
   switch (SCT) {
   case GlobalValue::DefaultStorageClass: break;
   case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
 
   WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
   Out << " = ";
 
   if (!GV->hasInitializer() && GV->hasExternalLinkage())
     Out << "external ";
 
   Out << getLinkagePrintName(GV->getLinkage());
-  PrintDSOLocation(GV->isDSOLocal(), Out);
+  PrintDSOLocation(*GV, Out);
   PrintVisibility(GV->getVisibility(), Out);
   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
   StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
   if (!UA.empty())
       Out << UA << ' ';
 
   if (unsigned AddressSpace = GV->getType()->getAddressSpace())

 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
   if (GIS->isMaterializable())
     Out << "; Materializable\n";
 
   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
   Out << " = ";
 
   Out << getLinkagePrintName(GIS->getLinkage());
-  PrintDSOLocation(GIS->isDSOLocal(), Out);
+  PrintDSOLocation(*GIS, Out);
   PrintVisibility(GIS->getVisibility(), Out);
   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
   StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
   if (!UA.empty())
       Out << UA << ' ';
 
   if (isa<GlobalAlias>(GIS))
if (F->isDeclaration()) {
     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
     F->getAllMetadata(MDs);
     printMetadataAttachments(MDs, " ");
     Out << ' ';
   } else
     Out << "define ";
 
   Out << getLinkagePrintName(F->getLinkage());
-  PrintDSOLocation(F->isDSOLocal(), Out);
+  PrintDSOLocation(*F, Out);
   PrintVisibility(F->getVisibility(), Out);
   PrintDLLStorageClass(F->getDLLStorageClass(), Out);
 
   // Print the calling convention.
   if (F->getCallingConv() != CallingConv::C) {
     PrintCallingConv(F->getCallingConv(), Out);
     Out << " ";
   }

llvm/lib/IR/Verifier.cpp

void Verifier::visitGlobalValue(const GlobalValue &GV) {
 
   if (GV.isDeclarationForLinker())
     Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
 
   if (GV.hasDLLImportStorageClass())
     Assert(!GV.isDSOLocal(),
            "GlobalValue with DLLImport Storage is dso_local!", &GV);
 
+  if (GV.hasLocalLinkage())
+    Assert(GV.isDSOLocal(),
+           "GlobalValue with private or internal linkage must be dso_local!",
+           &GV);
+
   forEachUser(&GV, GlobalValueVisited, [&](const Value *V) -> bool {
     if (const Instruction *I = dyn_cast<Instruction>(V)) {
       if (!I->getParent() || !I->getParent()->getParent())
         CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
                     I);
       else if (I->getParent()->getParent()->getParent() != &M)
         CheckFailed("Global is referenced in a different module!", &GV, &M, I,
                     I->getParent()->getParent(),

llvm/lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
   // produce a 0 if it turns out the symbol is undefined. While this
   // is ABI and relocation depended, it seems worth it to handle it
   // here.
   // FIXME: this is probably not ELF specific.
   if (GV && isPositionIndependent() && TT.isOSBinFormatELF() &&
       GV->hasExternalWeakLinkage())
     return false;
 
-  if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
+  if (GV && !GV->hasDefaultVisibility())
     return true;
 
   if (TT.isOSBinFormatMachO()) {
     if (RM == Reloc::Static)
       return true;
     return GV && GV->isStrongDefinitionForLinker();
   }
 

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

static Function *createClone(Function &F, Twine Suffix, coro::Shape &Shape,
   // rewritten access to the args that occurs after suspend points with loads
   // and stores to/from the coroutine frame.
   for (Argument &A : F.args())
     VMap[&A] = UndefValue::get(A.getType());
 
   SmallVector<ReturnInst *, 4> Returns;
 
   CloneFunctionInto(NewF, &F, VMap, /*ModuleLevelChanges=*/true, Returns);
+  NewF->setDSOLocal(true);
 
   // Remove old returns.
   for (ReturnInst *Return : Returns)
     changeToUnreachable(Return, /*UseLLVMTrap=*/false);
 
   // Remove old return attributes.
   NewF->removeAttributes(
       AttributeList::ReturnIndex,

llvm/lib/Transforms/IPO/GlobalOpt.cpp

for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
     J->replaceAllUsesWith(ConstantExpr::getBitCast(Aliasee, J->getType()));
     ++NumAliasesResolved;
     Changed = true;
 
     if (RenameTarget) {
       // Give the aliasee the name, linkage and other attributes of the alias.
       Target->takeName(&*J);
       Target->setLinkage(J->getLinkage());
+      Target->setDSOLocal(J->isDSOLocal());
       Target->setVisibility(J->getVisibility());
       Target->setDLLStorageClass(J->getDLLStorageClass());
 
       if (Used.usedErase(&*J))
         Used.usedInsert(Target);
 
       if (Used.compilerUsedErase(&*J))
         Used.compilerUsedInsert(Target);

llvm/test/Bitcode/thinlto-function-summary-refgraph.ll

 ; Function X contains call to foo, as well as address reference to foo
 ; which is in the same instruction as the call:
 ; op0=X op4=foo op5=foo
 ; CHECK-DAG:    <PERMODULE {{.*}} op0=7 op1=1 {{.*}} op4=1 op5=4 op6=4/>
 ; Function Y contains call to func2, and ensures we don't incorrectly add
 ; a reference to it when reached while earlier analyzing the phi using its
 ; return value:
 ; op0=Y op4=func2
-; CHECK-DAG:    <PERMODULE {{.*}} op0=8 op1=8 {{.*}} op4=0 op5=3/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=8 op1=72 {{.*}} op4=0 op5=3/>
 ; Function Z contains call to func2, and ensures we don't incorrectly add
 ; a reference to it when reached while analyzing subsequent use of its return
 ; value:
 ; op0=Z op4=func2
 ; CHECK-DAG:    <PERMODULE {{.*}} op0=9 op1=3 {{.*}} op4=0 op5=3/>
 ; Variable bar initialization contains address reference to func:
 ; op0=bar op2=func
 ; CHECK-DAG:    <PERMODULE_GLOBALVAR_INIT_REFS {{.*}} op0=0 op1=0 op2=2/>

llvm/test/Bitcode/thinlto-summary-linkage-types.ll

 ; Check the linkage types in both the per-module and combined summaries.
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
 ; RUN: llvm-lto -thinlto -o %t2 %t.o
 ; RUN: llvm-bcanalyzer -dump %t2.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
 define private void @private()
-; CHECK: <PERMODULE {{.*}} op1=8
-; COMBINED-DAG: <COMBINED {{.*}} op2=8
+; CHECK: <PERMODULE {{.*}} op1=72
+; COMBINED-DAG: <COMBINED {{.*}} op2=72
 {
   ret void
 }
 
 define internal void @internal()
 ; CHECK: <PERMODULE {{.*}} op1=7
 ; COMBINED-DAG: <COMBINED {{.*}} op2=7
 {

llvm/test/Bitcode/thinlto-summary-section.ll

 ; Check the linkage types in both the per-module and combined summaries.
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
 ; RUN: llvm-lto -thinlto -o %t2 %t.o
 ; RUN: llvm-bcanalyzer -dump %t2.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
-; Flags should be 0x17 (23) for local linkage (0x3) and not being importable
+; Flags should be 0x17 (87) for local linkage (0x3), dso_local (0x40) and not being importable
 ; (0x10) due to local linkage plus having a section.
-; CHECK: <PERMODULE {{.*}} op1=23
-; COMBINED-DAG: <COMBINED {{.*}} op2=23
+; CHECK: <PERMODULE {{.*}} op1=87
+; COMBINED-DAG: <COMBINED {{.*}} op2=87
 define internal void @functionWithSection() section "some_section" {
     ret void
 }

llvm/test/CodeGen/AMDGPU/enqueue-kernel.ll

entry:
   store i64 %d, i64* %block.captured10, align 8
   %tmp6 = bitcast <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }>* %block2 to void ()*
   %tmp7 = bitcast void ()* %tmp6 to i8*
   %tmp8 = addrspacecast i8* %tmp7 to i8 addrspace(4)*
   %tmp9 = call i32 @__enqueue_kernel_basic(%opencl.queue_t addrspace(1)* undef, i32 0, %struct.ndrange_t* byval nonnull %tmp3, i8 addrspace(4)* nonnull %tmp8) #2
   ret void
 }
 
-; CHECK: define amdgpu_kernel void @__test_block_invoke_kernel({{.*}}) #[[AT1:[0-9]+]]
+; CHECK: define dso_local amdgpu_kernel void @__test_block_invoke_kernel({{.*}}) #[[AT1:[0-9]+]]
 define internal amdgpu_kernel void @__test_block_invoke_kernel(<{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i8 }> %arg) #0
   !kernel_arg_addr_space !14 !kernel_arg_access_qual !15 !kernel_arg_type !16 !kernel_arg_base_type !16 !kernel_arg_type_qual !17 {
 entry:
   %.fca.3.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i8 }> %arg, 3
   %.fca.4.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i8 }> %arg, 4
   store i8 %.fca.4.extract, i8 addrspace(1)* %.fca.3.extract, align 1
   ret void
 }
 
 declare i32 @__enqueue_kernel_basic(%opencl.queue_t addrspace(1)*, i32, %struct.ndrange_t*, i8 addrspace(4)*) local_unnamed_addr
 
-; CHECK: define amdgpu_kernel void @__test_block_invoke_2_kernel({{.*}}) #[[AT2:[0-9]+]]
+; CHECK: define dso_local amdgpu_kernel void @__test_block_invoke_2_kernel({{.*}}) #[[AT2:[0-9]+]]
 define internal amdgpu_kernel void @__test_block_invoke_2_kernel(<{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*,
   i64 addrspace(1)*, i64, i8 }> %arg) #0 !kernel_arg_addr_space !14 !kernel_arg_access_qual !15
   !kernel_arg_type !16 !kernel_arg_base_type !16 !kernel_arg_type_qual !17 {
 entry:
   %.fca.3.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %arg, 3
   %.fca.4.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %arg, 4
   %.fca.5.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %arg, 5
   %.fca.6.extract = extractvalue <{ i32, i32, i8 addrspace(4)*, i8 addrspace(1)*, i64 addrspace(1)*, i64, i8 }> %arg, 6

llvm/test/LTO/Resolution/X86/comdat.ll

 
 ; CHECK:      define weak_odr dso_local i32 @f1(i8*) comdat($c1) {
 ; CHECK-NEXT: bb10:
 ; CHECK-NEXT:   br label %bb11{{$}}
 ; CHECK:      bb11:
 ; CHECK-NEXT:   ret i32 42
 ; CHECK-NEXT: }
 
-; CHECK:      define internal dso_local i32 @f1.2(i8* %this) comdat($c2) {
+; CHECK:      define internal i32 @f1.2(i8* %this) comdat($c2) {
 ; CHECK-NEXT: bb20:
 ; CHECK-NEXT:   store i8* %this, i8** null
 ; CHECK-NEXT:   br label %bb21
 ; CHECK:      bb21:
 ; CHECK-NEXT:   ret i32 41
 ; CHECK-NEXT: }

llvm/test/Linker/funcimport.ll

 ; First ensure that the ThinLTO handling in llvm-link and llvm-lto handles
 ; bitcode without summary sections gracefully.
 ; RUN: opt %s -o %t.bc
 ; RUN: opt %p/Inputs/funcimport.ll -o %t2.bc
 ; RUN: llvm-link %t.bc -summary-index=%t.bc -S
 ; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
 
 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
 
 ; Ensure statics are promoted/renamed correctly from this file (all but
 ; constant variable need promotion).
 ; RUN: llvm-link %t.bc -summary-index=%t3.thinlto.bc -S | FileCheck %s --check-prefix=EXPORTSTATIC
-; EXPORTSTATIC-DAG: @staticvar.llvm.{{.*}} = hidden global
+; EXPORTSTATIC-DAG: @staticvar.llvm.{{.*}} = dso_local hidden global
 ; Eventually @staticconstvar can be exported as a copy and not promoted
-; EXPORTSTATIC-DAG: @staticconstvar.llvm.0 = hidden unnamed_addr constant
-; EXPORTSTATIC-DAG: @P.llvm.{{.*}} = hidden global void ()* null
-; EXPORTSTATIC-DAG: define hidden i32 @staticfunc.llvm.
-; EXPORTSTATIC-DAG: define hidden void @staticfunc2.llvm.
+; EXPORTSTATIC-DAG: @staticconstvar.llvm.0 = dso_local hidden unnamed_addr constant
+; EXPORTSTATIC-DAG: @P.llvm.{{.*}} = dso_local hidden global void ()* null
+; EXPORTSTATIC-DAG: define dso_local hidden i32 @staticfunc.llvm.
+; EXPORTSTATIC-DAG: define dso_local hidden void @staticfunc2.llvm.
 
 ; Ensure that both weak alias to an imported function and strong alias to a
 ; non-imported function are correctly turned into declarations.
 ; Also ensures that alias to a linkonce function is turned into a declaration
 ; and that the associated linkonce function is not in the output, as it is
 ; lazily linked and never referenced/materialized.
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=globalfunc1:%t.bc -S | FileCheck %s --check-prefix=IMPORTGLOB1
 ; IMPORTGLOB1-DAG: define available_externally void @globalfunc1

 ; An alias is never imported.
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=linkoncefunc:%t.bc -S | FileCheck %s --check-prefix=IMPORTGLOB5
 ; IMPORTGLOB5-NOT: @linkoncealias
 ; IMPORTGLOB5-DAG: define available_externally void @linkoncefunc()
 
 ; Ensure that imported static variable and function references are correctly
 ; promoted and renamed (including static constant variable).
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=referencestatics:%t.bc -S | FileCheck %s --check-prefix=IMPORTSTATIC
-; IMPORTSTATIC-DAG: @staticvar.llvm.{{.*}} = external hidden global
+; IMPORTSTATIC-DAG: @staticvar.llvm.{{.*}} = external dso_local hidden global
 ; Eventually @staticconstvar can be imported as a copy
-; IMPORTSTATIC-DAG: @staticconstvar.llvm.{{.*}} = external hidden unnamed_addr constant
+; IMPORTSTATIC-DAG: @staticconstvar.llvm.{{.*}} = external dso_local hidden unnamed_addr constant
 ; IMPORTSTATIC-DAG: define available_externally i32 @referencestatics
 ; IMPORTSTATIC-DAG: %call = call i32 @staticfunc.llvm.
 ; IMPORTSTATIC-DAG: %0 = load i32, i32* @staticvar.llvm.
-; IMPORTSTATIC-DAG: declare hidden i32 @staticfunc.llvm.
+; IMPORTSTATIC-DAG: declare dso_local hidden i32 @staticfunc.llvm.
 
 ; Ensure that imported global (external) function and variable references
 ; are handled correctly (including referenced variable imported as
 ; available_externally definition)
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=referenceglobals:%t.bc -S | FileCheck %s --check-prefix=IMPORTGLOBALS
 ; IMPORTGLOBALS-DAG: @globalvar = external global
 ; IMPORTGLOBALS-DAG: declare void @globalfunc1()
 ; IMPORTGLOBALS-DAG: define available_externally i32 @referenceglobals
 
 ; Ensure that common variable correctly imported as common defition.
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=referencecommon:%t.bc -S | FileCheck %s --check-prefix=IMPORTCOMMON
 ; IMPORTCOMMON-DAG: @commonvar = external global
 ; IMPORTCOMMON-DAG: define available_externally i32 @referencecommon
 
 ; Ensure that imported static function pointer correctly promoted and renamed.
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=callfuncptr:%t.bc -S | FileCheck %s --check-prefix=IMPORTFUNCPTR
-; IMPORTFUNCPTR-DAG: @P.llvm.{{.*}} = external hidden global void ()*
+; IMPORTFUNCPTR-DAG: @P.llvm.{{.*}} = external dso_local hidden global void ()*
 ; IMPORTFUNCPTR-DAG: define available_externally void @callfuncptr
 ; IMPORTFUNCPTR-DAG: %0 = load void ()*, void ()** @P.llvm.
 
 ; Ensure that imported weak function reference/definition handled properly.
 ; Imported weak_any definition should be skipped with warning, and imported
 ; reference should turned into an external_weak declaration.
 ; RUN: llvm-link %t2.bc -summary-index=%t3.thinlto.bc -import=callweakfunc:%t.bc -import=weakfunc:%t.bc -S 2>&1 | FileCheck %s --check-prefix=IMPORTWEAKFUNC
 ; IMPORTWEAKFUNC-DAG: Ignoring import request for weak-any function weakfunc

llvm/test/Other/extract.ll

 ; RUN: llvm-extract -func foo -S < %s | FileCheck %s
 ; RUN: llvm-extract -delete -func foo -S < %s | FileCheck --check-prefix=DELETE %s
 ; RUN: llvm-as < %s > %t
 ; RUN: llvm-extract -func foo -S %t | FileCheck %s
 ; RUN: llvm-extract -delete -func foo -S %t | FileCheck --check-prefix=DELETE %s
 
 ; llvm-extract uses lazy bitcode loading, so make sure it correctly reads
 ; from bitcode files in addition to assembly files.
 
-; CHECK: define hidden void @foo() comdat($x) {
+; CHECK: define dso_local hidden void @foo() comdat($x) {
 ; CHECK:   ret void
 ; CHECK: }
 
 ; The private linkage for foo() should be changed to external linkage and
 ; hidden visibility added.
-; DELETE: declare hidden void @foo()
+; DELETE: declare dso_local hidden void @foo()
 ; DELETE-NOT: comdat
 ; DELETE: define void @bar() {
 ; DELETE:   call void @foo()
 ; DELETE:   ret void
 ; DELETE: }
 
 $x = comdat any
 
 define private void @foo() comdat($x) {
   ret void
 }
 define void @bar() {
   call void @foo()
   ret void
 }

llvm/test/ThinLTO/X86/alias_import.ll

 ; IMPORT-DAG: define available_externally void @linkonceODRfuncAlias
 ; IMPORT-DAG: define available_externally void @linkonceODRfuncWeakODRAlias
 ; IMPORT-DAG: define available_externally void @linkonceODRfuncLinkonceODRAlias
 ; IMPORT-DAG: define available_externally void @globalfuncAlias()
 ; IMPORT-DAG: declare void @globalfuncWeakAlias()
 ; IMPORT-DAG: declare void @globalfuncLinkonceAlias()
 ; IMPORT-DAG: define available_externally void @globalfuncWeakODRAlias()
 ; IMPORT-DAG: define available_externally void @globalfuncLinkonceODRAlias()
-; IMPORT-DAG: define available_externally void @internalfuncAlias()
+; IMPORT-DAG: define available_externally dso_local void @internalfuncAlias()
 ; IMPORT-DAG: declare void @internalfuncWeakAlias()
 ; IMPORT-DAG: declare void @internalfuncLinkonceAlias()
-; IMPORT-DAG: define available_externally void @internalfuncWeakODRAlias()
-; IMPORT-DAG: define available_externally void @internalfuncLinkonceODRAlias()
+; IMPORT-DAG: define available_externally dso_local void @internalfuncWeakODRAlias()
+; IMPORT-DAG: define available_externally dso_local void @internalfuncLinkonceODRAlias()
 ; IMPORT-DAG: define available_externally void @weakODRfuncAlias()
 ; IMPORT-DAG: declare void @weakODRfuncWeakAlias()
 ; IMPORT-DAG: declare void @weakODRfuncLinkonceAlias()
 ; IMPORT-DAG: define available_externally void @weakODRfuncWeakODRAlias()
 ; IMPORT-DAG: define available_externally void @weakODRfuncLinkonceODRAlias()
 ; IMPORT-DAG: define available_externally void @linkoncefuncAlias()
 ; IMPORT-DAG: declare void @linkoncefuncWeakAlias()
 ; IMPORT-DAG: declare void @linkoncefuncLinkonceAlias()

llvm/test/ThinLTO/X86/deadstrip.ll

 ; RUN:   -r %t2.bc,_boo,pl \
 ; RUN:   -r %t2.bc,_dead_func,l \
 ; RUN:   -r %t2.bc,_another_dead_func,pl
 ; RUN: llvm-dis < %t.out.1.3.import.bc | FileCheck %s --check-prefix=LTO2
 ; RUN: llvm-dis < %t.out.2.3.import.bc | FileCheck %s --check-prefix=LTO2-CHECK2
 ; RUN: llvm-nm %t.out.1 | FileCheck %s --check-prefix=CHECK2-NM
 
 ; RUN: llvm-bcanalyzer -dump %t.out.index.bc | FileCheck %s --check-prefix=COMBINED
-; Live, NotEligibleForImport, Internal
-; COMBINED-DAG: <COMBINED {{.*}} op2=55
-; Live, Internal
-; COMBINED-DAG: <COMBINED {{.*}} op2=39
+; Live, NotEligibleForImport, dso_local, Internal
+; COMBINED-DAG: <COMBINED {{.*}} op2=119
+; Live, dso_local, Internal
+; COMBINED-DAG: <COMBINED {{.*}} op2=103
 ; Live, Local, External
 ; COMBINED-DAG: <COMBINED {{.*}} op2=96
 ; COMBINED-DAG: <COMBINED {{.*}} op2=96
 ; COMBINED-DAG: <COMBINED {{.*}} op2=96
 ; Local, (Dead)
 ; COMBINED-DAG: <COMBINED {{.*}} op2=64
 ; COMBINED-DAG: <COMBINED {{.*}} op2=64
 ; COMBINED-DAG: <COMBINED {{.*}} op2=64
 
 ; Dead-stripping on the index allows to internalize these,
 ; and limit the import of @baz thanks to early pruning.
 ; CHECK-NOT: available_externally {{.*}} @baz()
 ; CHECK: @llvm.global_ctors =
 ; CHECK: define internal void @_GLOBAL__I_a()
 ; CHECK: define internal void @bar() {
 ; CHECK: define internal void @bar_internal()
 ; CHECK: define internal void @dead_func() {
 ; CHECK-NOT: available_externally {{.*}} @baz()
 ; LTO2-NOT: available_externally {{.*}} @baz()
 ; LTO2: @llvm.global_ctors =
 ; LTO2: define internal void @_GLOBAL__I_a()
-; LTO2: define internal dso_local void @bar() {
+; LTO2: define internal void @bar() {
 ; LTO2: define internal void @bar_internal()
-; LTO2: define internal dso_local void @dead_func() {
+; LTO2: define internal void @dead_func() {
 ; LTO2-NOT: available_externally {{.*}} @baz()
 
 ; Make sure we didn't internalize @boo, which is reachable via
 ; llvm.global_ctors
 ; CHECK2: define void @boo()
 ; LTO2-CHECK2: define dso_local void @boo()
 ; We should have eventually removed @baz since it was internalized and unused
 ; CHECK2-NM-NOT: _baz

llvm/test/ThinLTO/X86/export.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/export.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t1.bc %t2.bc
 
 ; Ensure statics are promoted/renamed correctly from this file.
 ; RUN: llvm-lto -thinlto-action=promote %t1.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
-; CHECK-DAG: @staticvar.llvm.0 = hidden global
-; CHECK-DAG: define hidden void @staticfunc.llvm.0
+; CHECK-DAG: @staticvar.llvm.0 = dso_local hidden global
+; CHECK-DAG: define dso_local hidden void @staticfunc.llvm.0
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 @staticvar = internal global i32 1, align 4
 
 define void @callstaticfunc() #0 {
 entry:

llvm/test/ThinLTO/X86/funcimport.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; RUN: llvm-lto -thinlto-index-stats %t3.bc | FileCheck %s -check-prefix=STATS
 ; STATS: Index {{.*}} contains 24 nodes (13 functions, 3 alias, 8 globals) and 19 edges (8 refs and 11 calls)
 
 ; Ensure statics are promoted/renamed correctly from this file (all but
 ; constant variable need promotion).
 ; RUN: llvm-lto -thinlto-action=promote %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTSTATIC
-; EXPORTSTATIC-DAG: @staticvar.llvm.0 = hidden global
+; EXPORTSTATIC-DAG: @staticvar.llvm.0 = dso_local hidden global
 ; Eventually @staticconstvar can be exported as a copy and not promoted
-; EXPORTSTATIC-DAG: @staticconstvar.llvm.0 = hidden unnamed_addr constant
-; EXPORTSTATIC-DAG: @P.llvm.0 = hidden global void ()* null
-; EXPORTSTATIC-DAG: define hidden i32 @staticfunc.llvm.0
-; EXPORTSTATIC-DAG: define hidden void @staticfunc2.llvm.0
+; EXPORTSTATIC-DAG: @staticconstvar.llvm.0 = dso_local hidden unnamed_addr constant
+; EXPORTSTATIC-DAG: @P.llvm.0 = dso_local hidden global void ()* null
+; EXPORTSTATIC-DAG: define dso_local hidden i32 @staticfunc.llvm.0
+; EXPORTSTATIC-DAG: define dso_local hidden void @staticfunc2.llvm.0
 
 ; Ensure that weak alias to an imported function is correctly turned into
 ; a declaration.
 ; Also ensures that alias to a linkonce function is turned into a declaration
 ; and that the associated linkonce function is not in the output, as it is
 ; lazily linked and never referenced/materialized.
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORTGLOB1
 ; IMPORTGLOB1-DAG: define available_externally void @globalfunc1

llvm/test/ThinLTO/X86/internalize.ll

 
 ; REGULAR: define void @foo
 ; REGULAR: define void @bar
 ; REGULAR: define linkonce void @linkonce_func()
 ; INTERNALIZE: define void @foo
 ; INTERNALIZE: define internal void @bar
 ; INTERNALIZE: define internal void @linkonce_func()
 ; INTERNALIZE2: define dso_local void @foo
-; INTERNALIZE2: define internal dso_local void @bar
-; INTERNALIZE2: define internal dso_local void @linkonce_func()
+; INTERNALIZE2: define internal void @bar
+; INTERNALIZE2: define internal void @linkonce_func()
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @foo() {
     ret void
 }
 define void @bar() {
     call void @linkonce_func()
   ret void
 }
 define linkonce void @linkonce_func() {
     ret void
 }

llvm/test/ThinLTO/X86/local_name_conflict.ll

 ; Test handling when two files with the same source file name contain
 ; static functions with the same name (which will have the same GUID
 ; in the combined index.
 
 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary -module-hash %s -o %t.bc
 ; RUN: opt -module-summary -module-hash %p/Inputs/local_name_conflict1.ll -o %t2.bc
 ; RUN: opt -module-summary -module-hash %p/Inputs/local_name_conflict2.ll -o %t3.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t4.bc %t.bc %t2.bc %t3.bc
 
 ; This module will import b() which should cause the copy of foo from
 ; that module (%t3.bc) to be imported. Check that the imported reference's
 ; promoted name matches the imported copy.
 ; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=IMPORT
 ; IMPORT: call i32 @foo.llvm.[[HASH:[0-9]+]]
-; IMPORT: define available_externally hidden i32 @foo.llvm.[[HASH]]()
+; IMPORT: define available_externally dso_local hidden i32 @foo.llvm.[[HASH]]()
 
 ; The copy in %t2.bc should not be exported/promoted/renamed
 ; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=NOEXPORTSTATIC
 ; NOEXPORTSTATIC: define internal i32 @foo()
 
 ; Make sure foo is promoted and renamed without complaint in %t3.bc.
 ; RUN: llvm-lto -thinlto-action=promote %t3.bc -thinlto-index=%t4.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTSTATIC
-; EXPORTSTATIC: define hidden i32 @foo.llvm.
+; EXPORTSTATIC: define dso_local hidden i32 @foo.llvm.
 
 ; ModuleID = 'local_name_conflict_main.o'
 source_filename = "local_name_conflict_main.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: noinline nounwind uwtable
 define i32 @main() {
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval, align 4
   %call = call i32 (...) @b()
   ret i32 %call
 }
 
 declare i32 @b(...)

llvm/test/ThinLTO/X86/referenced_by_constant.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/referenced_by_constant.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 
 ; Check the import side: we currently only import bar() (with a future
 ; enhancement to identify constants in the summary, we should mark
 ; @someglobal/@someglobal2 for import as a local copy, which would
 ; cause @referencedbyglobal and @localreferencedbyglobal to be exported
 ; and promoted).
 ; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o -   | FileCheck %s --check-prefix=IMPORT
-; IMPORT: @someglobal.llvm.0 = external hidden unnamed_addr constant
-; IMPORT: @someglobal2.llvm.0 = external hidden unnamed_addr constant
+; IMPORT: @someglobal.llvm.0 = external dso_local hidden unnamed_addr constant
+; IMPORT: @someglobal2.llvm.0 = external dso_local hidden unnamed_addr constant
 ; IMPORT: define available_externally void @bar()
 
 ; Check the export side: we currently only export bar(), which causes
 ; @someglobal and @someglobal2 to be promoted (see above).
 ; RUN: llvm-lto -thinlto-action=promote %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o -   | FileCheck %s --check-prefix=EXPORT
-; EXPORT: @someglobal.llvm.0 = hidden unnamed_addr constant
-; EXPORT: @someglobal2.llvm.0 = hidden unnamed_addr constant
+; EXPORT: @someglobal.llvm.0 = dso_local hidden unnamed_addr constant
+; EXPORT: @someglobal2.llvm.0 = dso_local hidden unnamed_addr constant
 ; EXPORT: define void @referencedbyglobal()
 ; EXPORT: define internal void @localreferencedbyglobal()
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @bar()
 
 define void @foo() {
     call void @bar()
     ret void
 }

llvm/test/Transforms/FunctionImport/funcimport.ll

 ; INSTLIM5-DAG: declare i32 @referencestatics(...)
 declare i32 @referencestatics(...) #1
 
 ; The import of referencestatics will expose call to staticfunc that
 ; should in turn be imported as a promoted/renamed and hidden function.
 ; Ensure that the call is to the properly-renamed function.
 ; INSTLIMDEF-DAG: Import staticfunc
 ; INSTLIMDEF-DAG: %call = call i32 @staticfunc.llvm.
-; INSTLIMDEF-DAG: define available_externally hidden i32 @staticfunc.llvm.{{.*}} !thinlto_src_module !0 {
+; INSTLIMDEF-DAG: define available_externally dso_local hidden i32 @staticfunc.llvm.{{.*}} !thinlto_src_module !0 {
 
 ; INSTLIMDEF-DAG: Import referenceglobals
 ; CHECK-DAG: define available_externally i32 @referenceglobals(i32 %i) !thinlto_src_module !0 {
 declare i32 @referenceglobals(...) #1
 
 ; The import of referenceglobals will expose call to globalfunc1 that
 ; should in turn be imported.
 ; INSTLIMDEF-DAG: Import globalfunc1
 ; CHECK-DAG: define available_externally void @globalfunc1() !thinlto_src_module !0
 
 ; INSTLIMDEF-DAG: Import referencecommon
 ; CHECK-DAG: define available_externally i32 @referencecommon(i32 %i) !thinlto_src_module !0 {
 declare i32 @referencecommon(...) #1
 
 ; INSTLIMDEF-DAG: Import setfuncptr
 ; CHECK-DAG: define available_externally void @setfuncptr() !thinlto_src_module !0 {
 declare void @setfuncptr(...) #1
 
 ; INSTLIMDEF-DAG: Import callfuncptr
 ; CHECK-DAG: define available_externally void @callfuncptr() !thinlto_src_module !0 {
 declare void @callfuncptr(...) #1
 
 ; Ensure that all uses of local variable @P which has used in setfuncptr
 ; and callfuncptr are to the same promoted/renamed global.
-; CHECK-DAG: @P.llvm.{{.*}} = external hidden global void ()*
+; CHECK-DAG: @P.llvm.{{.*}} = external dso_local hidden global void ()*
 ; CHECK-DAG: %0 = load void ()*, void ()** @P.llvm.
 ; CHECK-DAG: store void ()* @staticfunc2.llvm.{{.*}}, void ()** @P.llvm.
 
 ; Ensure that @referencelargelinkonce definition is pulled in, but later we
 ; also check that the linkonceodr function is not.
 ; CHECK-DAG: define available_externally void @referencelargelinkonce() !thinlto_src_module !0 {
 ; INSTLIM5-DAG: declare void @linkonceodr()
 declare void @referencelargelinkonce(...)
 
 ; Won't import weak func
 ; CHECK-DAG: declare void @weakfunc(...)
 declare void @weakfunc(...) #1
 
 ; Won't import linkonce func
 ; CHECK-DAG: declare void @linkoncefunc2(...)
 declare void @linkoncefunc2(...) #1
 
 ; INSTLIMDEF-DAG: Import funcwithpersonality
-; INSTLIMDEF-DAG: define available_externally hidden void @funcwithpersonality.llvm.{{.*}}() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !thinlto_src_module !0 {
-; INSTLIM5-DAG: declare hidden void @funcwithpersonality.llvm.{{.*}}()
+; INSTLIMDEF-DAG: define available_externally dso_local hidden void @funcwithpersonality.llvm.{{.*}}() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !thinlto_src_module !0 {
+; INSTLIM5-DAG: declare dso_local hidden void @funcwithpersonality.llvm.{{.*}}()
 
 ; CHECK-DAG: declare void @variadic(...)
 declare void @variadic(...)
 
 ; INSTLIMDEF-DAG: Import globalfunc2
 ; INSTLIMDEF-DAG: 13 function-import - Number of functions imported
 ; CHECK-DAG: !0 = !{!"{{.*}}/Inputs/funcimport.ll"}
 

llvm/test/Transforms/ThinLTOBitcodeWriter/comdat.ll

 ; the ThinLTO module and no renaming needs to take place.
 ; THIN: $nt = comdat any
 $nt = comdat any
 
 ; MERGED: @lwt_aliasee = private unnamed_addr global
 ; MERGED-SAME: comdat(${{"?lwt[^ ]+}})
 @lwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($lwt), !type !0
 
-; MERGED: {{@"?lwt_nl[^ ]+}} = hidden unnamed_addr global
+; MERGED: {{@"?lwt_nl[^ ]+}} = dso_local hidden unnamed_addr global
 ; MERGED-SAME: comdat(${{"?lwt[^ ]+}})
-; THIN: {{@"?lwt_nl[^ ]+}} = external hidden
+; THIN: {{@"?lwt_nl[^ ]+}} = external dso_local hidden
 @lwt_nl = internal unnamed_addr global i32 0, comdat($lwt)
 
 ; MERGED: @nlwt_aliasee = private unnamed_addr global
 ; MERGED-SAME: comdat($nlwt)
 @nlwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($nlwt), !type !0
 
 ; MERGED: @nlwt = unnamed_addr global
 ; MERGED-SAME: comdat
 ; THIN: @nlwt = external
 @nlwt = unnamed_addr global i32 0, comdat
 
 ; THIN: @nt = internal
 ; THIN-SAME: comdat
 @nt = internal unnamed_addr global [1 x i8*] [i8* null], comdat
 
 ; THIN: @nt_nl = internal
 ; THIN-SAME: comdat($nt)
 @nt_nl = internal unnamed_addr global i32 0, comdat($nt)
 
-; MERGED: {{@"?lwt[^ ]+}} = hidden unnamed_addr alias
+; MERGED: {{@"?lwt[^ ]+}} = dso_local hidden unnamed_addr alias
 ; THIN: {{@"?lwt[^ ]+}} = external hidden
 @lwt = internal unnamed_addr alias [1 x i8*], [1 x i8*]* @lwt_aliasee
 
-; MERGED: {{@"?nlwt_nl[^ ]+}} = hidden unnamed_addr alias
+; MERGED: {{@"?nlwt_nl[^ ]+}} = dso_local hidden unnamed_addr alias
 ; THIN: {{@"?nlwt_nl[^ ]+}} = external hidden
 @nlwt_nl = internal unnamed_addr alias [1 x i8*], [1 x i8*]* @nlwt_aliasee
 
 ; The functions below exist just to make sure the globals are used.
 define i8* @lwt_fun() {
   %1 = load i32, i32* @lwt_nl
   %2 = getelementptr inbounds [1 x i8*], [1 x i8*]* @lwt, i32 0, i32 %1
   %3 = load i8*, i8** %2

llvm/test/Transforms/ThinLTOBitcodeWriter/split-internal1.ll

 ; RUN: opt -thinlto-bc -o %t %s
 ; RUN: llvm-modextract -b -n 0 -o %t0 %t
 ; RUN: llvm-modextract -b -n 1 -o %t1 %t
 ; RUN: not llvm-modextract -b -n 2 -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=M0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=M1 %s
 ; RUN: llvm-bcanalyzer -dump %t0 | FileCheck --check-prefix=BCA0 %s
 ; RUN: llvm-bcanalyzer -dump %t1 | FileCheck --check-prefix=BCA1 %s
 
 ; ERROR: llvm-modextract: error: module index out of range; bitcode file contains 2 module(s)
 
 ; BCA0: <GLOBALVAL_SUMMARY_BLOCK
 ; BCA1-NOT: <GLOBALVAL_SUMMARY_BLOCK
 
-; M0: @"g$581d7631532fa146ba4061179da39272" = external hidden global i8{{$}}
-; M1: @"g$581d7631532fa146ba4061179da39272" = hidden global i8 42, !type !0
+; M0: @"g$581d7631532fa146ba4061179da39272" = external dso_local hidden global i8{{$}}
+; M1: @"g$581d7631532fa146ba4061179da39272" = dso_local hidden global i8 42, !type !0
 @g = internal global i8 42, !type !0
 
 ; M0: define i8* @f()
 ; M1-NOT: @f()
 define i8* @f() {
   ; M0: ret i8* @"g$581d7631532fa146ba4061179da39272"
   ret i8* @g
 }
 
 ; M1: !0 = !{i32 0, !"typeid"}
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-internal2.ll

 
 ; BCA0: <GLOBALVAL_SUMMARY_BLOCK
 ; BCA1-NOT: <GLOBALVAL_SUMMARY_BLOCK
 
 ; M0: @g = external global void ()*{{$}}
 ; M1: @g = global void ()* @"f$13757e0fb71915e385efa4dc9d1e08fd", !type !0
 @g = global void ()* @f, !type !0
 
-; M0: define hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
-; M1: declare hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
+; M0: define dso_local hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
+; M1: declare dso_local hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
 define internal void @f() {
   call void @f2()
   ret void
 }
 
 ; M0: define internal void @f2()
 define internal void @f2() {
   ret void
 }
 
 ; M1: !0 = !{i32 0, !"typeid"}
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-vfunc-internal.ll

 ; RUN: opt -thinlto-bc -o %t %s
 ; RUN: llvm-modextract -b -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=M0 %s
 ; RUN: llvm-modextract -b -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=M1 %s
 
 define [1 x i8*]* @source() {
   ret [1 x i8*]* @g
 }
 
-; M0: @"g$84f59439b469192440047efc8de357fb" = external hidden constant [1 x i8*]{{$}}
-; M1: @"g$84f59439b469192440047efc8de357fb" = hidden constant [1 x i8*] [i8* bitcast (i64 (i8*)* @"ok$84f59439b469192440047efc8de357fb" to i8*)]
+; M0: @"g$84f59439b469192440047efc8de357fb" = external dso_local hidden constant [1 x i8*]{{$}}
+; M1: @"g$84f59439b469192440047efc8de357fb" = dso_local hidden constant [1 x i8*] [i8* bitcast (i64 (i8*)* @"ok$84f59439b469192440047efc8de357fb" to i8*)]
 @g = internal constant [1 x i8*] [
   i8* bitcast (i64 (i8*)* @ok to i8*)
 ], !type !0
 
-; M0: define hidden i64 @"ok$84f59439b469192440047efc8de357fb"
-; M1: define available_externally hidden i64 @"ok$84f59439b469192440047efc8de357fb"
+; M0: define dso_local hidden i64 @"ok$84f59439b469192440047efc8de357fb"
+; M1: define available_externally dso_local hidden i64 @"ok$84f59439b469192440047efc8de357fb"
 define internal i64 @ok(i8* %this) {
   ret i64 42
 }
 
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/WholeProgramDevirt/export-single-impl.ll

 ; CHECK: declare void @vf1(i8*)
 declare void @vf1(i8*)
 
 ; CHECK: define void @vf2(i8*)
 define void @vf2(i8*) {
   ret void
 }
 
-; CHECK: define hidden void @"vf3$merged"(i8*) {
+; CHECK: define dso_local hidden void @"vf3$merged"(i8*) {
 define internal void @vf3(i8*) {
   ret void
 }
 
-; CHECK: define hidden void @"vf4$merged"(i8*) comdat {
+; CHECK: define dso_local hidden void @"vf4$merged"(i8*) comdat {
 define internal void @vf4(i8*) comdat {
   ret void
 }
 
 declare void @vf5(i8*)
 
 !0 = !{i32 0, !"typeid1"}
 !1 = !{i32 0, !"typeid2"}
 !2 = !{i32 0, !"typeid3"}
 !3 = !{i32 0, !"typeid4"}
 !4 = !{i32 0, !5}
 !5 = distinct !{}

llvm/test/tools/gold/X86/coff.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold%shlibext -plugin-opt=emit-llvm \
 ; RUN:    -shared %t.o -o %t2.o
 ; RUN: llvm-dis %t2.o -o - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target datalayout = "m:w"
 
 ; CHECK: define void @f() {
 define void @f() {
   ret void
 }
 
-; CHECK: define internal dso_local void @g() {
+; CHECK: define internal void @g() {
 define hidden void @g() {
   ret void
 }
 
 ; CHECK: define internal void @h() {
 define linkonce_odr void @h() local_unnamed_addr {
   ret void
 }

llvm/test/tools/gold/X86/emit-llvm.ll

 ; CHECK-DAG: @g6 = internal unnamed_addr global i32 32
 @g6 = linkonce_odr unnamed_addr global i32 32
 
 @g7 = extern_weak global i32
 ; CHECK-DAG: @g7 = extern_weak global i32
 
 @g8 = external global i32
 
-; CHECK-DAG: define internal dso_local void @f1()
+; CHECK-DAG: define internal void @f1()
 ; OPT2-NOT: @f1
 define hidden void @f1() {
   ret void
 }
 
 ; CHECK-DAG: define dso_local hidden void @f2()
 ; OPT-DAG: define dso_local hidden void @f2()
 define hidden void @f2() {

llvm/test/tools/gold/X86/global_with_section.ll

 target triple = "x86_64-unknown-linux-gnu"
 
 ; We should not internalize @var_with_section due to section
 ; CHECK-DAG: @var_with_section = dso_local global i32 0, section "some_section"
 @var_with_section = global i32 0, section "some_section"
 
 ; Confirm via a variable with a non-C identifier section that we are getting
 ; the expected internalization.
-; CHECK-DAG: @var_with_nonC_section = internal dso_local global i32 0, section ".nonCsection"
+; CHECK-DAG: @var_with_nonC_section = internal global i32 0, section ".nonCsection"
 @var_with_nonC_section = global i32 0, section ".nonCsection"
 
 ; We should not internalize @deadfunc_with_section due to section
 ; CHECK-DAG: define dso_local void @deadfunc_with_section() section "some_other_section"
 define void @deadfunc_with_section() section "some_other_section" {
   call void @deadfunc2_called_from_section()
   ret void
 }
 
 ; Confirm via a function with a non-C identifier section that we are getting
 ; the expected internalization.
-; CHECK-DAG: define internal dso_local void @deadfunc_with_nonC_section() section ".nonCsection"
+; CHECK-DAG: define internal void @deadfunc_with_nonC_section() section ".nonCsection"
 define void @deadfunc_with_nonC_section() section ".nonCsection" {
   call void @deadfunc2_called_from_nonC_section()
   ret void
 }
 
 ; In RegularLTO mode, where we have combined all the IR,
 ; @deadfunc2_called_from_section can be internalized.
-; CHECK2-REGULARLTO: define internal dso_local void @deadfunc2_called_from_section
+; CHECK2-REGULARLTO: define internal void @deadfunc2_called_from_section
 ; In ThinLTO mode, we can't internalize it as it needs to be preserved
 ; (due to the access from @deadfunc_with_section which must be preserved), and
 ; can't be internalized since the reference is from a different module.
 ; CHECK2-THINLTO: define dso_local void @deadfunc2_called_from_section
 declare void @deadfunc2_called_from_section()
 
 ; Confirm when called from a function with a non-C identifier section that we
 ; are getting the expected internalization.
-; CHECK2-REGULARLTO: define internal dso_local void @deadfunc2_called_from_nonC_section
-; CHECK2-THINLTO: define internal dso_local void @deadfunc2_called_from_nonC_section
+; CHECK2-REGULARLTO: define internal void @deadfunc2_called_from_nonC_section
+; CHECK2-THINLTO: define internal void @deadfunc2_called_from_nonC_section
 declare void @deadfunc2_called_from_nonC_section()

llvm/test/tools/llvm-split/internal.ll

 ; RUN: llvm-split -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK1 %s
 
-; CHECK0: define hidden void @foo()
-; CHECK1: declare hidden void @foo()
+; CHECK0: define dso_local hidden void @foo()
+; CHECK1: declare dso_local hidden void @foo()
 define internal void @foo() {
   call void @bar()
   ret void
 }
 
 ; CHECK0: declare void @bar()
 ; CHECK1: define void @bar()
 define void @bar() {
   call void @foo()
   ret void
 }

llvm/test/tools/llvm-split/preserve-locals.ll

 ; RUN: llvm-split -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK1 %s
 
 ; The local_var and local_func must not be separated.
 ; CHECK0: @local_var
 ; CHECK0: define internal fastcc void @local_func
 ; The main and a must not be separated.
 ; The main and local_func must not be together.
 ; CHECK1: @a
 ; CHECK1: define i32 @main
-; CHECK1: declare fastcc void @local_func
+; CHECK1: declare dso_local fastcc void @local_func
 
 @a = internal global i32 0, align 4
 @global_storage = common global i32 0, align 4
 @local_var = internal global i32 0, align 4
 
 ; Function Attrs: nounwind
 define i32 @main(i32 %x) {
 entry:

llvm/test/tools/llvm-split/scc-alias.ll

 ; All of the functions in this module must end up
 ; in the same partition without change of scope.
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare i32 @funInternal
+; CHECK0: declare dso_local i32 @funInternal
 ; CHECK0: declare i32 @funExternal
-; CHECK0: declare i32 @funInternal2
+; CHECK0: declare dso_local i32 @funInternal2
 ; CHECK0: declare i32 @funExternal2
 
 ; All functions are in the same file.
 ; Local functions are still local.
 ; CHECK1: define internal i32 @funInternal
 ; CHECK1: define i32 @funExternal
 ; CHECK1: define internal i32 @funInternal2
 ; CHECK1: define i32 @funExternal2

llvm/test/tools/llvm-split/scc-callchain.ll

 ; All of the functions in this module must end up
 ; in the same partition.
 
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare i32 @funInternal0
-; CHECK0: declare i32 @funInternal1
-; CHECK0: declare i32 @funInternal2
+; CHECK0: declare dso_local i32 @funInternal0
+; CHECK0: declare dso_local i32 @funInternal1
+; CHECK0: declare dso_local i32 @funInternal2
 ; CHECK0: declare i32 @funExternal
 
 ; All functions are in the same file.
 ; Local functions are still local.
 ; CHECK1: define internal i32 @funInternal0
 ; CHECK1: define internal i32 @funInternal1
 ; CHECK1: define internal i32 @funInternal2
 ; CHECK1: define i32 @funExternal

llvm/test/tools/llvm-split/scc-comdat.ll

 ; All functions in the same comdat group must
 ; be in the same module
 
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare i32 @fun1
-; CHECK0: declare i32 @fun2
+; CHECK0: declare dso_local i32 @fun1
+; CHECK0: declare dso_local i32 @fun2
 ; CHECK0: declare i32 @fun3
 
 ; CHECK1: define internal i32 @fun1
 ; CHECK1: define internal i32 @fun2
 ; CHECK1: define i32 @fun3
 
 $fun = comdat any
 

llvm/test/tools/llvm-split/scc-constants.ll

 ; All of the functions in this module must end up
 ; in the same partition.
 
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare i32 @foo
-; CHECK0: declare i32 @baz
+; CHECK0: declare dso_local i32 @foo
+; CHECK0: declare dso_local i32 @baz
 ; CHECK0: declare i32 @bar
 ; CHECK0: declare i32 @bar2
 
 ; CHECK1: @bla
 ; CHECK1: @bla2
 ; CHECK1: define internal i32 @foo
 ; CHECK1: define internal i32 @baz
 ; CHECK1: define i32 @bar

llvm/test/tools/llvm-split/scc-cycle.ll

 ; All of the functions in this module must end up
 ; in the same partition.
 
 ; Mutually recursive calls
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare i32 @funInternal0
-; CHECK0: declare i32 @funInternal1
+; CHECK0: declare dso_local i32 @funInternal0
+; CHECK0: declare dso_local i32 @funInternal1
 ; CHECK0: declare i32 @funExternal0
 ; CHECK0: declare i32 @funExternal1
 
 ; CHECK1: define internal i32 @funInternal0
 ; CHECK1: define internal i32 @funInternal1
 ; CHECK1: define i32 @funExternal0
 ; CHECK1: define i32 @funExternal1
 

llvm/test/tools/llvm-split/scc-global2global.ll

 ; All of the functions and globals in this module must end up
 ; in the same partition.
 
 ; RUN: llvm-split -j=2 -preserve-locals -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK0 %s
 
-; CHECK0: declare %struct.anon* @local0
-; CHECK0: declare i8** @local1
+; CHECK0: declare dso_local %struct.anon* @local0
+; CHECK0: declare dso_local i8** @local1
 
 ; CHECK1: @bla
 ; CHECK1: @ptr
 ; CHECK1: define internal %struct.anon* @local0
 ; CHECK1: define internal i8** @local1
 
 %struct.anon = type { i64, i64 }
 

llvm/test/tools/llvm-split/unnamed.ll

 ; RUN: llvm-split -o %t %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=CHECK0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=CHECK1 %s
 
-; CHECK0: declare hidden void @__llvmsplit_unnamed()
-; CHECK1: define hidden void @__llvmsplit_unnamed()
+; CHECK0: declare dso_local hidden void @__llvmsplit_unnamed()
+; CHECK1: define dso_local hidden void @__llvmsplit_unnamed()
 define internal void @0() {
   ; CHECK1: call void @foo()
   call void @foo()
   ret void
 }
 
-; CHECK0: declare hidden void @__llvmsplit_unnamed.1()
-; CHECK1: define hidden void @__llvmsplit_unnamed.1()
+; CHECK0: declare dso_local hidden void @__llvmsplit_unnamed.1()
+; CHECK1: define dso_local hidden void @__llvmsplit_unnamed.1()
 define internal void @1() {
   ; CHECK1: call void @foo()
   ; CHECK1: call void @foo()
   call void @foo()
   call void @foo()
   ret void
 }