Delete dead code

[• espindola]

Summary

While support for explicit preemption in the llvm IR would use something like this, it can be a long time before such support is added. Before that happens this is dead code and should probably be deleted.

[mehdi_amini]

We should be able to skip the GOT/PLT for such symbols in the codegen right now, wouldn't we?

[tejohnson]

I tend to agree to remove it, since it isn't being used at all yet. But I think some llvm-lto2 tests need to be updated (that's the only way this could get set now). E.g. test/ThinLTO/X86/internalize.ll

[• rafael]

Exit with error on unknown character.

[pcc]

I guess this can be abandoned now, right?

[• espindola]

Yes, dso_local exists and is getting more common.

include/llvm/LTO/LTO.h

private:
   Error runThinLTO(AddOutputFn AddOutput);
 
   mutable bool CalledGetMaxTasks = false;
 };
 
 /// The resolution for a symbol. The linker must provide a SymbolResolution for
 /// each global symbol based on its internal resolution of that symbol.
 struct SymbolResolution {
-  SymbolResolution()
-      : Prevailing(0), FinalDefinitionInLinkageUnit(0), VisibleToRegularObj(0) {
-  }
+  SymbolResolution() : Prevailing(0), VisibleToRegularObj(0) {}
   /// The linker has chosen this definition of the symbol.
   unsigned Prevailing : 1;
 
-  /// The definition of this symbol is unpreemptable at runtime and is known to
-  /// be in this linkage unit.
-  unsigned FinalDefinitionInLinkageUnit : 1;
-
   /// The definition of this symbol is visible outside of the LTO unit.
   unsigned VisibleToRegularObj : 1;
 };
 
 } // namespace lto
 } // namespace llvm
 
 #endif

lib/LTO/LTO.cpp

static void writeToResolutionFile(raw_ostream &OS, InputFile *Input,
   auto ResI = Res.begin();
   for (const InputFile::Symbol &Sym : Input->symbols()) {
     assert(ResI != Res.end());
     SymbolResolution Res = *ResI++;
 
     OS << "-r=" << Path << ',' << Sym.getName() << ',';
     if (Res.Prevailing)
       OS << 'p';
-    if (Res.FinalDefinitionInLinkageUnit)
-      OS << 'l';
     if (Res.VisibleToRegularObj)
       OS << 'x';
     OS << '\n';
   }
   assert(ResI == Res.end());
 }
 
 Error LTO::add(std::unique_ptr<InputFile> Input,
for (const InputFile::Symbol &Sym :
     // Common resolution: collect the maximum size/alignment.
     // FIXME: right now we ignore the prevailing information, it is not clear
     // what is the "right" behavior here.
     if (Sym.getFlags() & object::BasicSymbolRef::SF_Common) {
       auto &CommonRes = RegularLTO.Commons[Sym.getIRName()];
       CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
       CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment());
     }
-
-    // FIXME: use proposed local attribute for FinalDefinitionInLinkageUnit.
   }
   assert(ResI == Res.end());
 
   return RegularLTO.Mover->move(Obj->takeModule(), Keep,
                                 [](GlobalValue &, IRMover::ValueAdder) {});
 }
 
 // Add a ThinLTO object to the link.

test/LTO/Resolution/X86/comdat.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/comdat.ll -o %t2.o
 ; RUN: llvm-lto2 -save-temps -o %t3.o %t.o %t2.o \
-; RUN:  -r=%t.o,f1,plx \
+; RUN:  -r=%t.o,f1,px \
 ; RUN:  -r=%t.o,v1,px \
 ; RUN:  -r=%t.o,r11,px \
 ; RUN:  -r=%t.o,r12,px \
 ; RUN:  -r=%t.o,a11,px \
 ; RUN:  -r=%t.o,a12,px \
 ; RUN:  -r=%t.o,a13,px \
 ; RUN:  -r=%t.o,a14,px \
 ; RUN:  -r=%t.o,a15,px \
-; RUN:  -r=%t2.o,f1,l \
+; RUN:  -r=%t2.o,f1, \
 ; RUN:  -r=%t2.o,will_be_undefined, \
 ; RUN:  -r=%t2.o,v1, \
 ; RUN:  -r=%t2.o,r21,px \
 ; RUN:  -r=%t2.o,r22,px \
 ; RUN:  -r=%t2.o,a21,px \
 ; RUN:  -r=%t2.o,a22,px \
 ; RUN:  -r=%t2.o,a23,px \
 ; RUN:  -r=%t2.o,a24,px \

test/ThinLTO/X86/cache.ll

 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/cache.ll -o %t2.bc
 
 ; Verify that enabling caching is working
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: llvm-lto -thinlto-action=run -exported-symbol=globalfunc %t2.bc  %t.bc -thinlto-cache-dir %t.cache
 ; RUN: ls %t.cache/llvmcache.timestamp
 ; RUN: ls %t.cache | count 3
 
 ; Verify that enabling caching is working with llvm-lto2
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; RUN: llvm-lto2 -o %t.o %t2.bc  %t.bc -cache-dir %t.cache \
-; RUN:  -r=%t2.bc,_main,plx \
-; RUN:  -r=%t2.bc,_globalfunc,lx \
-; RUN:  -r=%t.bc,_globalfunc,plx
+; RUN:  -r=%t2.bc,_main,px \
+; RUN:  -r=%t2.bc,_globalfunc,x \
+; RUN:  -r=%t.bc,_globalfunc,px
 ; RUN: ls %t.cache | count 2
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }

test/ThinLTO/X86/dicompositetype-unique.ll

 ; RUN: opt -module-summary -o %t1.bc %s
 ; RUN: opt -module-summary -o %t2.bc %S/Inputs/dicompositetype-unique.ll
 
 ; RUN: llvm-lto2 %t1.bc %t2.bc -o %t --save-temps \
-; RUN:    -r %t1.bc,_foo,lx \
-; RUN:    -r %t1.bc,_main,plx \
-; RUN:    -r %t2.bc,_foo,plx
+; RUN:    -r %t1.bc,_foo,x \
+; RUN:    -r %t1.bc,_main,px \
+; RUN:    -r %t2.bc,_foo,px
 ; RUN: llvm-dis %t.0.3.import.bc -o - | FileCheck %s
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @foo()
 define i32 @main() {

test/ThinLTO/X86/internalize.ll

 ;; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=REGULAR
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o -  --exported-symbol=foo | llvm-dis -o - | FileCheck %s --check-prefix=INTERNALIZE
 
 ; RUN: llvm-lto2 %t1.bc -o %t.o -save-temps \
-; RUN:     -r=%t1.bc,_foo,pxl \
-; RUN:     -r=%t1.bc,_bar,pl \
-; RUN:     -r=%t1.bc,_linkonce_func,pl
+; RUN:     -r=%t1.bc,_foo,px \
+; RUN:     -r=%t1.bc,_bar,p \
+; RUN:     -r=%t1.bc,_linkonce_func,p
 ; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s --check-prefix=INTERNALIZE
 
+; RUN: not llvm-lto2 %t1.bc -o %t.o -r=%t1.bc,_foo,pu 2>&1 | FileCheck --check-prefix=ERROR %s
+
 
 ; 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()
 
+; ERROR: invalid character u in resolution
+
 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
-}
+}
 

tools/llvm-lto2/llvm-lto2.cpp

if (Rest.empty()) {
       llvm::errs() << "invalid resolution: " << R << '\n';
       return 1;
     }
     std::tie(SymbolName, Rest) = Rest.split(',');
     SymbolResolution Res;
     for (char C : Rest) {
       if (C == 'p')
         Res.Prevailing = true;
-      else if (C == 'l')
-        Res.FinalDefinitionInLinkageUnit = true;
       else if (C == 'x')
         Res.VisibleToRegularObj = true;
-      else
+      else {
         llvm::errs() << "invalid character " << C << " in resolution: " << R
                      << '\n';
+        exit(1);
+      }
     }
     CommandLineResolutions[{FileName, SymbolName}] = Res;
   }
 
   std::vector<std::unique_ptr<MemoryBuffer>> MBs;
 
   Config Conf;
   Conf.DiagHandler = [](const DiagnosticInfo &) {