Fix PR36268

[• espindola]

Summary

The issue is that clang was first creating a extern_weak hidden GV and then changing the linkage to external.

Once we know it is not extern_weak we know it must be dso_local.

This patch refactors the code that sets the implicit dso_local to a helper private function that is used every time we change the linkage or visibility.

[hans]

llvm/include/llvm/IR/GlobalValue.h

118

Can this flip back and forth? That is, if setDSOLocal(true) was set before, do we need to handle the else-branch here and do setDSOLocal(false)?

[• espindola]

lgtm in the list

[• espindola]

324551 and 324552

clang/test/CodeGenObjC/availability-dso-local.m

+// RUN: %clang_cc1 -triple thumbv7-apple-ios10.0.0 -emit-llvm -fvisibility hidden -w %s -o - | FileCheck %s
+
+// CHECK: @"OBJC_CLASS_$_a" = hidden global %struct._class_t
+
+__attribute__((availability(ios, introduced = 11.0))) @interface a @end
+    @implementation a @end

llvm/include/llvm/IR/GlobalValue.h

protected:
 
   /// If true then there is a definition within the same linkage unit and that
   /// definition cannot be runtime preempted.
   unsigned IsDSOLocal : 1;
 
 private:
   friend class Constant;
 
+  void maybeSetDsoLocal() {
+    if (hasLocalLinkage() ||
+        (!hasDefaultVisibility() && !hasExternalWeakLinkage()))
+      setDSOLocal(true);
+  }
+
   // Give subclasses access to what otherwise would be wasted padding.
   // (17 + 4 + 2 + 2 + 2 + 3 + 1 + 1) == 32.
   unsigned SubClassData : GlobalValueSubClassDataBits;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
public:
   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
   bool hasProtectedVisibility() const {
     return Visibility == ProtectedVisibility;
   }
   void setVisibility(VisibilityTypes V) {
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
            "local linkage requires default visibility");
     Visibility = V;
-    if (!hasExternalWeakLinkage() && V != DefaultVisibility)
-      setDSOLocal(true);
+    maybeSetDsoLocal();
   }
 
   /// If the value is "Thread Local", its value isn't shared by the threads.
   bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; }
   void setThreadLocal(bool Val) {
     setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal);
   }
   void setThreadLocalMode(ThreadLocalMode Val) {
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;
-      setDSOLocal(true);
-    }
     Linkage = LT;
+    maybeSetDsoLocal();
   }
   LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
 
   bool isDiscardableIfUnused() const {
     return isDiscardableIfUnused(getLinkage());
   }
 
   bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }