From 37b94c6b4e605c522164bcafc58ea1e1afb50cc0 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Wed, 11 Jan 2012 00:13:08 +0000 Subject: [PATCH] If the global variable is removed by the linker, then don't constant merge it with other symbols. An object in the __cfstring section is suppoed to be filled with CFString objects, which have a pointer to ___CFConstantStringClassReference followed by a pointer to a __cstring. If we allow the object in the __cstring section to be merged with another global, then it could end up in any section. Because the linker is going to remove these symbols in the final executable, we shouldn't bother to merge them. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@147899 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/GlobalValue.h | 10 ++++++++ lib/Transforms/IPO/ConstantMerge.cpp | 16 ++++++++----- .../ConstantMerge/linker-private.ll | 23 +++++++++++++++++++ 3 files changed, 43 insertions(+), 6 deletions(-) create mode 100644 test/Transforms/ConstantMerge/linker-private.ll diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h index 81a11a4c925..d43a2fa227c 100644 --- a/include/llvm/GlobalValue.h +++ b/include/llvm/GlobalValue.h @@ -192,6 +192,14 @@ public: Linkage == LinkerPrivateWeakDefAutoLinkage; } + /// mayBeRemovedByLinker - Whether the definition of this global may be + /// removed at link time. + static bool mayBeRemovedByLinker(LinkageTypes Linkage) { + return isLinkerPrivateLinkage(Linkage) || + isLinkerPrivateWeakLinkage(Linkage) || + isLinkerPrivateWeakDefAutoLinkage(Linkage); + } + bool hasExternalLinkage() const { return isExternalLinkage(Linkage); } bool hasAvailableExternallyLinkage() const { return isAvailableExternallyLinkage(Linkage); @@ -225,6 +233,8 @@ public: bool isWeakForLinker() const { return isWeakForLinker(Linkage); } + bool mayBeRemovedByLinker() const { return mayBeRemovedByLinker(Linkage); } + /// copyAttributesFrom - copy all additional attributes (those not needed to /// create a GlobalValue) from the GlobalValue Src to this one. virtual void copyAttributesFrom(const GlobalValue *Src); diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index c3ecb7afff7..268a281aae4 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -140,18 +140,21 @@ bool ConstantMerge::runOnModule(Module &M) { UsedGlobals.count(GV)) continue; + // Ignore any constants which may be removed by the linker. + if (GV->mayBeRemovedByLinker()) + continue; + Constant *Init = GV->getInitializer(); // Check to see if the initializer is already known. PointerIntPair Pair(Init, hasKnownAlignment(GV)); GlobalVariable *&Slot = CMap[Pair]; - // If this is the first constant we find or if the old on is local, - // replace with the current one. It the current is externally visible + // If this is the first constant we find or if the old one is local, + // replace with the current one. If the current is externally visible // it cannot be replace, but can be the canonical constant we merge with. - if (Slot == 0 || IsBetterCannonical(*GV, *Slot)) { + if (Slot == 0 || IsBetterCannonical(*GV, *Slot)) Slot = GV; - } } // Second: identify all globals that can be merged together, filling in @@ -169,8 +172,9 @@ bool ConstantMerge::runOnModule(Module &M) { UsedGlobals.count(GV)) continue; - // We can only replace constant with local linkage. - if (!GV->hasLocalLinkage()) + // We can only replace constants with local linkage and which aren't + // removed by the linker. + if (!GV->hasLocalLinkage() || GV->mayBeRemovedByLinker()) continue; Constant *Init = GV->getInitializer(); diff --git a/test/Transforms/ConstantMerge/linker-private.ll b/test/Transforms/ConstantMerge/linker-private.ll new file mode 100644 index 00000000000..eba7880e8af --- /dev/null +++ b/test/Transforms/ConstantMerge/linker-private.ll @@ -0,0 +1,23 @@ +; RUN: opt < %s -constmerge -S | FileCheck %s +; + +%0 = type opaque +%struct.NSConstantString = type { i32*, i32, i8*, i32 } + +; CHECK: @.str3 = linker_private unnamed_addr constant [1 x i8] zeroinitializer, align 1 + +@isLogVisible = global i8 0, align 1 +@__CFConstantStringClassReference = external global [0 x i32] +@.str3 = linker_private unnamed_addr constant [1 x i8] zeroinitializer, align 1 +@_unnamed_cfstring_4 = private constant %struct.NSConstantString { i32* getelementptr inbounds ([0 x i32]* @__CFConstantStringClassReference, i32 0, i32 0), i32 1992, i8* getelementptr inbounds ([1 x i8]* @.str3, i32 0, i32 0), i32 0 }, section "__DATA,__cfstring" +@null.array = weak_odr constant [1 x i8] zeroinitializer, align 1 + +define linkonce_odr void @bar() nounwind ssp align 2 { +entry: + %stack = alloca i8*, align 4 + %call = call %0* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %0* (i8*, i8*, %0*)*)(i8* null, i8* null, %0* bitcast (%struct.NSConstantString* @_unnamed_cfstring_4 to %0*)) + store i8* getelementptr inbounds ([1 x i8]* @null.array, i32 0, i32 0), i8** %stack, align 4 + ret void +} + +declare i8* @objc_msgSend(i8*, i8*, ...) nonlazybind -- 2.34.1