Revert "[CodeGenModule] Set dso_local for Mach-O GlobalValue"

[arphaman]

Summary

This reverts commit 809a1e0ffd7af40ee27270ff8ba2ffc927330e71.

Mach-O doesn't support dso_local and this change broke XNU because of the use of dso_local.

[MaskRay]

Mach-O doesn't support dso_local and this change broke XNU because of the use of dso_local.

Can you elaborate on the unsupportness? For example, the backend can ignore dso_local if it does not want to support it.

The main purpose is to reduce target differences: currently both COFF and ELF can use dso_local. If Mach-O doesn't like dso_local, there is an additional difference.

[davide]

In D98458#2620731, @MaskRay wrote:

Mach-O doesn't support dso_local and this change broke XNU because of the use of dso_local.

Can you elaborate on the unsupportness? For example, the backend can ignore dso_local if it does not want to support it.

The main purpose is to reduce target differences: currently both COFF and ELF can use dso_local. If Mach-O doesn't like dso_local, there is an additional difference.

The model for dso_local is different on Mach-O. While it's a laudable goal to unify the three formats, we might want to consider to not push these changes willy-nilly.
We should consider investigating what's broken but the reality is that this breaks xnu so we need to revert this for the time being.

[davide]

LGTM.

[davide]

+ Lang, who probably has a better understanding of this, for visibility.
I don't think this should be blocked further, but he might have a chance to comment.

clang/lib/CodeGen/CodeGenModule.cpp

static bool shouldAssumeDSOLocal(const CodeGenModule &CGM,
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmware builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   // FIXME: even thread local variables?
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 
-  const auto &CGOpts = CGM.getCodeGenOpts();
-  llvm::Reloc::Model RM = CGOpts.RelocationModel;
-  const auto &LOpts = CGM.getLangOpts();
-
-  if (TT.isOSBinFormatMachO()) {
-    if (RM == llvm::Reloc::Static)
-      return true;
-    return GV->isStrongDefinitionForLinker();
-  }
-
   // Only handle COFF and ELF for now.
   if (!TT.isOSBinFormatELF())
     return false;
 
+  // If this is not an executable, don't assume anything is local.
+  const auto &CGOpts = CGM.getCodeGenOpts();
+  llvm::Reloc::Model RM = CGOpts.RelocationModel;
+  const auto &LOpts = CGM.getLangOpts();
   if (RM != llvm::Reloc::Static && !LOpts.PIE) {
     // On ELF, if -fno-semantic-interposition is specified and the target
     // supports local aliases, there will be neither CC1
     // -fsemantic-interposition nor -fhalf-no-semantic-interposition. Set
     // dso_local if using a local alias is preferable (can avoid GOT
     // indirection).
     if (!GV->canBenefitFromLocalAlias())
       return false;

clang/test/CodeGenCXX/const-init.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -std=c++98 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -std=c++11 -o - %s | FileCheck %s
 
-// CHECK: @a = dso_local global i32 10
+// CHECK: @a = global i32 10
 int a = 10;
-// CHECK: @ar = dso_local constant i32* @a
+// CHECK: @ar = constant i32* @a
 int &ar = a;
 
 void f();
-// CHECK: @fr = dso_local constant void ()* @_Z1fv
+// CHECK: @fr = constant void ()* @_Z1fv
 void (&fr)() = f;
 
 struct S { int& a; };
-// CHECK: @s = dso_local global %struct.S { i32* @a }
+// CHECK: @s = global %struct.S { i32* @a }
 S s = { a };
 
 // PR5581
 namespace PR5581 {
 class C {
 public:
   enum { e0, e1 };
   unsigned f;
 };
 
-// CHECK: @_ZN6PR55812g0E = dso_local global %"class.PR5581::C" { i32 1 }
+// CHECK: @_ZN6PR55812g0E = global %"class.PR5581::C" { i32 1 }
 C g0 = { C::e1 };
 }
 
 namespace test2 {
   struct A {
 #if __cplusplus <= 199711L
     static const double d = 1.0;
     static const float f = d / 2;
 #else
     static constexpr double d = 1.0;
     static constexpr float f = d / 2;
 #endif
     static int g();
   } a;
 
-  // CHECK: @_ZN5test22t0E = dso_local global double {{1\.0+e\+0+}}, align 8
-  // CHECK: @_ZN5test22t1E = dso_local global [2 x double] [double {{1\.0+e\+0+}}, double {{5\.0+e-0*}}1], align 16
-  // CHECK: @_ZN5test22t2E = dso_local global double* @_ZN5test21A1d
-  // CHECK: @_ZN5test22t3E = dso_local global {{.*}} @_ZN5test21A1g
+  // CHECK: @_ZN5test22t0E = global double {{1\.0+e\+0+}}, align 8
+  // CHECK: @_ZN5test22t1E = global [2 x double] [double {{1\.0+e\+0+}}, double {{5\.0+e-0*}}1], align 16
+  // CHECK: @_ZN5test22t2E = global double* @_ZN5test21A1d
+  // CHECK: @_ZN5test22t3E = global {{.*}} @_ZN5test21A1g
   double t0 = A::d;
   double t1[] = { A::d, A::f };
   const double *t2 = &a.d;
   int (*t3)() = &a.g;
 }
 
 // We don't expect to fold this in the frontend, but make sure it doesn't crash.
-// CHECK: @PR9558 = dso_local global float 0.000000e+0
+// CHECK: @PR9558 = global float 0.000000e+0
 float PR9558 = reinterpret_cast<const float&>("asd");
 
 // An initialized const automatic variable cannot be promoted to a constant
 // global if it has a mutable member.
 struct MutableMember {
   mutable int n;
 };
 int writeToMutable() {
   // CHECK-NOT: {{.*}}MM{{.*}} = {{.*}}constant
   const MutableMember MM = { 0 };
   return ++MM.n;
 }
 
 // Make sure we don't try to fold this in the frontend; the backend can't
 // handle it.
-// CHECK: @PR11705 = dso_local global i128 0
+// CHECK: @PR11705 = global i128 0
 __int128_t PR11705 = (__int128_t)&PR11705;
 
 // Make sure we don't try to fold this either.
 // CHECK: @_ZZ23UnfoldableAddrLabelDiffvE1x = internal global i128 0
 void UnfoldableAddrLabelDiff() { static __int128_t x = (long)&&a-(long)&&b; a:b:return;}
 
 // But make sure we do fold this.
 // CHECK: @_ZZ21FoldableAddrLabelDiffvE1x = internal global i64 sub (i64 ptrtoint (i8* blockaddress(@_Z21FoldableAddrLabelDiffv
 void FoldableAddrLabelDiff() { static long x = (long)&&a-(long)&&b; a:b:return;}
 
-// CHECK: @i = dso_local constant i32* bitcast (float* @PR9558 to i32*)
+// CHECK: @i = constant i32* bitcast (float* @PR9558 to i32*)
 int &i = reinterpret_cast<int&>(PR9558);
 
 int arr[2];
-// CHECK: @pastEnd = dso_local constant i32* bitcast (i8* getelementptr (i8, i8* bitcast ([2 x i32]* @arr to i8*), i64 8) to i32*)
+// CHECK: @pastEnd = constant i32* bitcast (i8* getelementptr (i8, i8* bitcast ([2 x i32]* @arr to i8*), i64 8) to i32*)
 int &pastEnd = arr[2];
 
 struct X {
   long n : 8;
 };
 long k;
 X x = {(long)&k};
 // CHECK: store i8 ptrtoint (i64* @k to i8), i8* getelementptr inbounds (%struct.X, %struct.X* @x, i32 0, i32 0)

clang/test/CodeGenCXX/linkage.cpp

namespace test17 {
   template int *foo<42>();
 }
 
 // PR18408
 namespace test18 {
   template<template<typename> class> struct A {};
   struct B { template<typename> struct C; };
   void f(A<B::C>) {}
-  // CHECK-DAG: define dso_local void @_ZN6test181fENS_1AINS_1B1CEEE(
+  // CHECK-DAG: define void @_ZN6test181fENS_1AINS_1B1CEEE(
 }

clang/test/CodeGenCXX/type_visibility.cpp

 }
 
 namespace type0 {
   struct TYPE_DEFAULT A {
     virtual void foo();
   };
 
   void A::foo() {}
-  // FUNS-LABEL:        define{{.*}} void @_ZN5type01A3fooEv(
-  // VARS:        @_ZTVN5type01AE = dso_local unnamed_addr constant
-  // VARS:        @_ZTSN5type01AE = dso_local constant
-  // VARS:        @_ZTIN5type01AE = dso_local constant
+  // FUNS-LABEL:        define void @_ZN5type01A3fooEv(
+  // VARS:        @_ZTVN5type01AE = unnamed_addr constant
+  // VARS:        @_ZTSN5type01AE = constant
+  // VARS:        @_ZTIN5type01AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type01A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type01AE = dso_local unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type01AE = dso_local constant
-  // VARS-HIDDEN: @_ZTIN5type01AE = dso_local constant
+  // VARS-HIDDEN: @_ZTVN5type01AE = unnamed_addr constant
+  // VARS-HIDDEN: @_ZTSN5type01AE = constant
+  // VARS-HIDDEN: @_ZTIN5type01AE = constant
 }
 
 namespace type1 {
   struct HIDDEN TYPE_DEFAULT A {
     virtual void foo();
   };
 
   void A::foo() {}
   // FUNS-LABEL:        define hidden void @_ZN5type11A3fooEv(
-  // VARS:        @_ZTVN5type11AE = dso_local unnamed_addr constant
-  // VARS:        @_ZTSN5type11AE = dso_local constant
-  // VARS:        @_ZTIN5type11AE = dso_local constant
+  // VARS:        @_ZTVN5type11AE = unnamed_addr constant
+  // VARS:        @_ZTSN5type11AE = constant
+  // VARS:        @_ZTIN5type11AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type11A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type11AE = dso_local unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type11AE = dso_local constant
-  // VARS-HIDDEN: @_ZTIN5type11AE = dso_local constant
+  // VARS-HIDDEN: @_ZTVN5type11AE = unnamed_addr constant
+  // VARS-HIDDEN: @_ZTSN5type11AE = constant
+  // VARS-HIDDEN: @_ZTIN5type11AE = constant
 }
 
 namespace type2 {
   struct TYPE_HIDDEN A {
     virtual void foo();
   };
 
   void A::foo() {}
-  // FUNS-LABEL:        define dso_local void @_ZN5type21A3fooEv(
+  // FUNS-LABEL:        define void @_ZN5type21A3fooEv(
   // VARS:        @_ZTVN5type21AE = hidden unnamed_addr constant
   // VARS:        @_ZTSN5type21AE = hidden constant
   // VARS:        @_ZTIN5type21AE = hidden constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type21A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type21AE = hidden unnamed_addr constant
   // VARS-HIDDEN: @_ZTSN5type21AE = hidden constant
   // VARS-HIDDEN: @_ZTIN5type21AE = hidden constant
 }
 
 namespace type3 {
   struct DEFAULT TYPE_HIDDEN A {
     virtual void foo();
   };
 
   void A::foo() {}
-  // FUNS-LABEL:        define dso_local void @_ZN5type31A3fooEv(
+  // FUNS-LABEL:        define void @_ZN5type31A3fooEv(
   // VARS:        @_ZTVN5type31AE = hidden unnamed_addr constant
   // VARS:        @_ZTSN5type31AE = hidden constant
   // VARS:        @_ZTIN5type31AE = hidden constant
-  // FUNS-HIDDEN-LABEL: define dso_local void @_ZN5type31A3fooEv(
+  // FUNS-HIDDEN-LABEL: define void @_ZN5type31A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type31AE = hidden unnamed_addr constant
   // VARS-HIDDEN: @_ZTSN5type31AE = hidden constant
   // VARS-HIDDEN: @_ZTIN5type31AE = hidden constant
 }
 

clang/test/CodeGenCXX/visibility.cpp

namespace test30 {
   // is not.
   struct H {
   };
   template<H *T>
   struct X {
   };
   H DEFAULT a;
   X<&a> b;
-  // CHECK: _ZN6test301bE = dso_local global
+  // CHECK: _ZN6test301bE = global
   // CHECK-HIDDEN: _ZN6test301bE = hidden global
 }
 
 namespace test25 {
   template<typename T>
   struct X {
     template<typename U>
     struct definition {
     };
   };
 
   class DEFAULT A { };
 
   X<int>::definition<A> a;
-  // CHECK: @_ZN6test251aE = dso_local global
+  // CHECK: @_ZN6test251aE = global
   // CHECK-HIDDEN: @_ZN6test251aE = hidden global
 }
 
 namespace test28 {
   class DEFAULT foo {
   };
   foo myvec;
-  // CHECK: @_ZN6test285myvecE = dso_local global
+  // CHECK: @_ZN6test285myvecE = global
   // CHECK-HIDDEN: @_ZN6test285myvecE = hidden global
 }
 
 namespace test29 {
 #pragma GCC visibility push(hidden)
   struct RECT {
     int top;
   };
   DEFAULT extern RECT data_rect;
   RECT data_rect = { -1};
 #pragma GCC visibility pop
-  // CHECK: @_ZN6test299data_rectE = dso_local global
-  // CHECK-HIDDEN: @_ZN6test299data_rectE = dso_local global
+  // CHECK: @_ZN6test299data_rectE = global
+  // CHECK-HIDDEN: @_ZN6test299data_rectE = global
 }
 
 namespace test40 {
   template<typename T>
   struct foo {
     DEFAULT static int bar;
   };
   template<typename T>
namespace test48 {
 
   bar::zed<&x> y;
   // CHECK: _ZN6test481yE = hidden global
   // CHECK-HIDDEN: _ZN6test481yE = hidden global
 }
 
 // CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10
 // CHECK: @_ZN5Test71aE = hidden global
-// CHECK: @_ZN5Test71bE = dso_local global
-// CHECK: @test9_var = dso_local global
-// CHECK-HIDDEN: @test9_var = dso_local global
+// CHECK: @_ZN5Test71bE = global
+// CHECK: @test9_var = global
+// CHECK-HIDDEN: @test9_var = global
 // CHECK: @_ZN6Test121A6hiddenE = external hidden global
 // CHECK: @_ZN6Test121A7visibleE = external global
 // CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global
 // CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global
 // CHECK: @_ZN6Test131B1aE = hidden global
-// CHECK: @_ZN6Test131C1aE = dso_local global
+// CHECK: @_ZN6Test131C1aE = global
 // CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global
-// CHECK-HIDDEN: @_ZN6Test131C1aE = dso_local global
+// CHECK-HIDDEN: @_ZN6Test131C1aE = global
 // CHECK: @_ZN6Test143varE = external global
 // CHECK-HIDDEN: @_ZN6Test143varE = external global
 // CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
 // CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
 
 namespace test27 {
   template<typename T>
   class C {
     class DEFAULT D {
       void f();
     };
   };
 
   template<>
   class C<int>::D {
     virtual void g();
   };
 
   void C<int>::D::g() {
   }
-  // CHECK: _ZTVN6test271CIiE1DE = dso_local unnamed_addr constant
-  // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = dso_local unnamed_addr constant
+  // CHECK: _ZTVN6test271CIiE1DE = unnamed_addr constant
+  // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = unnamed_addr constant
 }
 
 // CHECK: @_ZTVN5Test63fooE = linkonce_odr hidden unnamed_addr constant
 
 // CHECK-HIDDEN: @_ZTVN6Test161AIcEE = external unnamed_addr constant
 // CHECK-HIDDEN: @_ZTTN6Test161AIcEE = external unnamed_addr constant
 
 // CHECK: @_ZZN6test681fC1EvE4test = linkonce_odr global
namespace Test4 HIDDEN {
   // CHECK-LABEL: define hidden void @_ZN5Test41gEv
   void g() { } 
   
   struct DEFAULT A {
     void f();
   };
   
   // A has default visibility.
-  // CHECK-LABEL: define dso_local void @_ZN5Test41A1fEv
+  // CHECK-LABEL: define void @_ZN5Test41A1fEv
   void A::f() { } 
 }
 
 namespace Test5 {
 
   namespace NS HIDDEN {
     // f is in NS which is hidden.
     // CHECK-LABEL: define hidden void @_ZN5Test52NS1fEv()
     void f() { }
   }
   
   namespace NS {
     // g is in NS, but this NS decl is not hidden.
-    // CHECK-LABEL: define dso_local void @_ZN5Test52NS1gEv
+    // CHECK-LABEL: define void @_ZN5Test52NS1gEv
     void g() { }
   }
 }
 
 // <rdar://problem/8091955>
 namespace Test6 {
   struct HIDDEN foo {
     foo() { }

 
 // PR8457
 namespace Test9 {
   extern "C" {
     struct A { int field; };
     void DEFAULT test9_fun(struct A *a) { }
     struct A DEFAULT test9_var; // above
   }
-  // CHECK-LABEL: define dso_local void @test9_fun(
-  // CHECK-HIDDEN-LABEL: define dso_local void @test9_fun(
+  // CHECK-LABEL: define void @test9_fun(
+  // CHECK-HIDDEN-LABEL: define void @test9_fun(
 
   void test() {
     A a = test9_var;
     test9_fun(&a);
   }
 }
 
 // PR8478
 namespace Test10 {
   struct A;
 
   class DEFAULT B {
     void foo(A*);
   };
 
-  // CHECK-LABEL: define dso_local void @_ZN6Test101B3fooEPNS_1AE(
-  // CHECK-HIDDEN-LABEL: define dso_local void @_ZN6Test101B3fooEPNS_1AE(
+  // CHECK-LABEL: define void @_ZN6Test101B3fooEPNS_1AE(
+  // CHECK-HIDDEN-LABEL: define void @_ZN6Test101B3fooEPNS_1AE(
   void B::foo(A*) {}
 }
 
 // PR8492
 namespace Test11 {
   struct A {
     void foo() {}
     void DEFAULT bar() {}
namespace Test20 {
   }
 
   // ...unless that's explicitly overridden.
   template <> struct DEFAULT A<1> {
     static void test2();
     static void test3();
   };
 
-  // CHECK-LABEL: define dso_local void @_ZN6Test201AILj1EE5test2Ev()
+  // CHECK-LABEL: define void @_ZN6Test201AILj1EE5test2Ev()
   void A<1>::test2() {}
 
   // CHECK: declare void @_ZN6Test201AILj1EE5test3Ev()
   void test3() {
     A<1>::test3();
   }
 
   // <rdar://problem/8778497>
namespace test26 {
   template<typename T>
   class C {
     DEFAULT  void f();
   };
 
   template<>
   void C<int>::f() { }
 
-  // CHECK-LABEL: define dso_local void @_ZN6test261CIiE1fEv
-  // CHECK-HIDDEN-LABEL: define dso_local void @_ZN6test261CIiE1fEv
+  // CHECK-LABEL: define void @_ZN6test261CIiE1fEv
+  // CHECK-HIDDEN-LABEL: define void @_ZN6test261CIiE1fEv
 }
 
 namespace test31 {
   struct A {
     struct HIDDEN B {
       static void DEFAULT baz();
     };
   };
   void f() {
     A::B::baz();
   }
   // CHECK: declare void @_ZN6test311A1B3bazEv()
   // CHECK-HIDDEN: declare void @_ZN6test311A1B3bazEv()
 }
 
 namespace test32 {
   struct HIDDEN A {
     struct DEFAULT B {
       void DEFAULT baz();
     };
   };
   void A::B::baz() {
   }
-  // CHECK-LABEL: define dso_local void @_ZN6test321A1B3bazEv
-  // CHECK-HIDDEN-LABEL: define dso_local void @_ZN6test321A1B3bazEv
+  // CHECK-LABEL: define void @_ZN6test321A1B3bazEv
+  // CHECK-HIDDEN-LABEL: define void @_ZN6test321A1B3bazEv
 }
 
 namespace test33 {
   template<typename T>
   class foo {
     void bar() {}
   };
   struct HIDDEN zed {
namespace test42 {
   struct bar {
   };
   template <>
   struct HIDDEN bar<foo> {
     DEFAULT static void zed();
   };
   void bar<foo>::zed() {
   }
-  // CHECK-LABEL: define dso_local void @_ZN6test423barINS_3fooEE3zedEv
-  // CHECK-HIDDEN-LABEL: define dso_local void @_ZN6test423barINS_3fooEE3zedEv
+  // CHECK-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv
+  // CHECK-HIDDEN-LABEL: define void @_ZN6test423barINS_3fooEE3zedEv
 }
 
 namespace test43 {
   struct HIDDEN foo {
   };
   template <class P>
   void bar() {
   }
   template <>
   DEFAULT void bar<foo>() {
   }
-  // CHECK-LABEL: define dso_local void @_ZN6test433barINS_3fooEEEvv
-  // CHECK-HIDDEN-LABEL: define dso_local void @_ZN6test433barINS_3fooEEEvv
+  // CHECK-LABEL: define void @_ZN6test433barINS_3fooEEEvv
+  // CHECK-HIDDEN-LABEL: define void @_ZN6test433barINS_3fooEEEvv
 }
 
 namespace test44 {
   template <typename T>
   struct foo {
     foo() {}
   };
   namespace {
template <class T> struct B {
     template <class U> static void funcT2();
     class Inner {};
     template <class U> class InnerT {};
   };
   template <template <class T> class Temp> struct C {
     static void foo() {}
   };
 
-  // CHECK-LABEL: define dso_local void @_ZN6test651BINS_1AEE4funcEv()
+  // CHECK-LABEL: define void @_ZN6test651BINS_1AEE4funcEv()
   template <> DEFAULT void B<A>::func() {}
 
-  // CHECK-LABEL: define dso_local void @_ZN6test651BINS_1AEE6funcT2IS1_EEvv()
+  // CHECK-LABEL: define void @_ZN6test651BINS_1AEE6funcT2IS1_EEvv()
   template <> template <> DEFAULT void B<A>::funcT2<A>() {}
 
   // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE6funcT1IiEEvv()
   // CHECK-LABEL: define linkonce_odr hidden void @_ZN6test651BINS_1AEE6funcT1IS1_EEvv()
   template <> template <class T> DEFAULT void B<A>::funcT1() {}
 
   // CHECK-LABEL: define linkonce_odr void @_ZN6test651BINS_1AEE5Inner3fooEv()
   template <> struct DEFAULT B<A>::Inner {
namespace test69 {
   namespace foo {
     void f();
   }
   namespace foo {
     void f() {};
   }
   namespace foo __attribute__((visibility("hidden"))) {
   }
-  // CHECK-LABEL: define dso_local void @_ZN6test693foo1fEv
+  // CHECK-LABEL: define void @_ZN6test693foo1fEv
   // CHECK-HIDDEN-LABEL: define hidden void @_ZN6test693foo1fEv
 }