Index: lib/Analysis/ModuleSummaryAnalysis.cpp
===================================================================
--- lib/Analysis/ModuleSummaryAnalysis.cpp
+++ lib/Analysis/ModuleSummaryAnalysis.cpp
@@ -85,6 +85,17 @@
   return GV.hasSection() && GV.hasLocalLinkage();
 }
 
+/// ELF linkers generate __start_<secname> and __stop_<secname> symbols
+/// when there is a value in a section <secname> where the name is a valid
+/// C identifier. If dead stripping determines that the values declared
+/// in section <secname> are dead, and we then internalize (and delete)
+/// such a symbol, programs that reference the corresponding start and end
+/// section symbols will get undefined reference linking errors.
+/// We prevent internalization in the backends, but here we mark them as
+/// as live roots so that any values reached by these values are not
+/// detected as dead and internalized.
+static bool isLive(const GlobalValue &GV) { return GV.hasSection(); };
+
 /// Determine whether this call has all constant integer arguments (excluding
 /// "this") and summarize it to VCalls or ConstVCalls as appropriate.
 static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid,
@@ -275,7 +286,7 @@
       // FIXME: refactor this to use the same code that inliner is using.
       F.isVarArg();
   GlobalValueSummary::GVFlags Flags(F.getLinkage(), NotEligibleForImport,
-                                    /* Live = */ false);
+                                    /* Live = */ isLive(F));
   auto FuncSummary = llvm::make_unique<FunctionSummary>(
       Flags, NumInsts, RefEdges.takeVector(), CallGraphEdges.takeVector(),
       TypeTests.takeVector(), TypeTestAssumeVCalls.takeVector(),
@@ -295,7 +306,7 @@
   findRefEdges(Index, &V, RefEdges, Visited);
   bool NonRenamableLocal = isNonRenamableLocal(V);
   GlobalValueSummary::GVFlags Flags(V.getLinkage(), NonRenamableLocal,
-                                    /* Live = */ false);
+                                    /* Live = */ isLive(V));
   auto GVarSummary =
       llvm::make_unique<GlobalVarSummary>(Flags, RefEdges.takeVector());
   if (NonRenamableLocal)
@@ -308,7 +319,7 @@
                     DenseSet<GlobalValue::GUID> &CantBePromoted) {
   bool NonRenamableLocal = isNonRenamableLocal(A);
   GlobalValueSummary::GVFlags Flags(A.getLinkage(), NonRenamableLocal,
-                                    /* Live = */ false);
+                                    /* Live = */ isLive(A));
   auto AS = llvm::make_unique<AliasSummary>(Flags, ArrayRef<ValueInfo>{});
   auto *Aliasee = A.getBaseObject();
   auto *AliaseeSummary = Index.getGlobalValueSummary(*Aliasee);
Index: lib/Transforms/IPO/FunctionImport.cpp
===================================================================
--- lib/Transforms/IPO/FunctionImport.cpp
+++ lib/Transforms/IPO/FunctionImport.cpp
@@ -617,6 +617,15 @@
     if (AsmUndefinedRefs.count(GV.getName()))
       return true;
 
+    // ELF linkers generate __start_<secname> and __stop_<secname> symbols
+    // when there is a value in a section <secname> where the name is a valid
+    // C identifier. If dead stripping determines that the values declared
+    // in section <secname> are dead, and we then internalize (and delete)
+    // such a symbol, programs that reference the corresponding start and end
+    // section symbols will get undefined reference linking errors.
+    if (GV.hasSection())
+      return true;
+
     // Lookup the linkage recorded in the summaries during global analysis.
     auto GS = DefinedGlobals.find(GV.getGUID());
     if (GS == DefinedGlobals.end()) {
Index: test/Bitcode/thinlto-summary-section.ll
===================================================================
--- test/Bitcode/thinlto-summary-section.ll
+++ test/Bitcode/thinlto-summary-section.ll
@@ -4,10 +4,11 @@
 ; 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
-; (0x10) due to local linkage plus having a section.
-; CHECK: <PERMODULE {{.*}} op1=23
-; COMBINED-DAG: <COMBINED {{.*}} op2=23
+; Flags should be 0x37 (55) for local linkage (0x7), not being importable
+; (0x10) due to local linkage plus having a section, and a live root (0x20)
+; due to having a section.
+; CHECK: <PERMODULE {{.*}} op1=55
+; COMBINED-DAG: <COMBINED {{.*}} op2=55
 define internal void @functionWithSection() section "some_section" {
     ret void
 }
Index: test/ThinLTO/X86/Inputs/global_with_section.ll
===================================================================
--- /dev/null
+++ test/ThinLTO/X86/Inputs/global_with_section.ll
@@ -0,0 +1,6 @@
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define void @deadfunc2() {
+  ret void
+}
Index: test/ThinLTO/X86/global_with_section.ll
===================================================================
--- /dev/null
+++ test/ThinLTO/X86/global_with_section.ll
@@ -0,0 +1,46 @@
+; Test to ensure we don't internalize or treat as dead a global value
+; with a section. Otherwise, ELF linker generation of __start_"sectionname"
+; and __stop_"sectionname" symbols would no occur and we can end up
+; with undefined references at link time.
+
+; Do setup work for all below tests: generate bitcode
+; RUN: opt -module-summary %s -o %t.bc
+; RUN: opt -module-summary %p/Inputs/global_with_section.ll -o %t2.bc
+
+; Check results of internalization
+
+; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
+; RUN: llvm-lto -thinlto-action=internalize -exported-symbol=foo %t.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s
+; RUN: llvm-lto -thinlto-action=internalize -exported-symbol=foo %t2.bc -thinlto-index=%t3.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=CHECK2
+
+; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.o -save-temps \
+; RUN:     -r=%t.bc,foo,pxl \
+; RUN:     -r=%t.bc,var_with_section,pl \
+; RUN:     -r=%t.bc,deadfunc,pl \
+; RUN:     -r=%t.bc,deadfunc2,pl \
+; RUN:     -r=%t2.bc,deadfunc2,pl
+; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck %s
+; RUN: llvm-dis < %t.o.1.2.internalize.bc | FileCheck %s --check-prefix=CHECK2
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; We should not internalize @var_with_section due to section
+; CHECK: @var_with_section = global i32 0, section "some_section"
+@var_with_section = global i32 0, section "some_section"
+
+; We should not internalize @deadfunc due to section
+; CHECK: define void @deadfunc() section "some_other_section"
+define void @deadfunc() section "some_other_section" {
+  call void @deadfunc2()
+  ret void
+}
+
+; We should not detect @deadfunc2 as dead (which would cause it to be
+; internalized) since it is reached from a function with a section.
+; CHECK2: define void @deadfunc2
+declare void @deadfunc2()
+
+; Dummy global to provide to -exported-symbol so that llvm-lto is happy and
+; attempts internalization.
+@foo = global i32 0