Index: include/lld/Core/LinkingContext.h
===================================================================
--- include/lld/Core/LinkingContext.h
+++ include/lld/Core/LinkingContext.h
@@ -30,6 +30,7 @@
 class Writer;
 class InputGraph;
 class InputElement;
+class Resolver;
 class SharedLibraryFile;
 
 /// \brief The LinkingContext class encapsulates "what and how" to link.
@@ -244,6 +245,8 @@
   /// the actual input files.
   virtual void createInternalFiles(std::vector<std::unique_ptr<File> > &) const;
 
+  virtual std::unique_ptr<Resolver> getResolver();
+
   /// Return the list of undefined symbols that are specified in the
   /// linker command line, using the -u option.
   range<const StringRef *> initialUndefinedSymbols() const {
Index: include/lld/Core/Resolver.h
===================================================================
--- include/lld/Core/Resolver.h
+++ include/lld/Core/Resolver.h
@@ -30,7 +30,9 @@
 class Resolver {
 public:
   Resolver(LinkingContext &context)
-      : _context(context), _symbolTable(context), _result(new MergedFile()) {}
+      : _symbolTable(context), _context(context), _result(new MergedFile()) {}
+
+  virtual ~Resolver() {}
 
   // InputFiles::Handler methods
   void doDefinedAtom(const DefinedAtom&);
@@ -53,6 +55,12 @@
 
   std::unique_ptr<MutableFile> resultFile() { return std::move(_result); }
 
+protected:
+  std::vector<const Atom *> _atoms;
+  SymbolTable _symbolTable;
+
+  virtual bool checkUndefines();
+
 private:
   typedef std::function<void(StringRef, bool)> UndefCallback;
 
@@ -63,7 +71,6 @@
   bool resolveUndefines();
   void updateReferences();
   void deadStripOptimize();
-  bool checkUndefines();
   void removeCoalescedAwayAtoms();
   void checkDylibSymbolCollisions();
   void forEachUndefines(bool searchForOverrides, UndefCallback callback);
@@ -101,8 +108,6 @@
   };
 
   LinkingContext &_context;
-  SymbolTable _symbolTable;
-  std::vector<const Atom *>     _atoms;
   std::set<const Atom *>        _deadStripRoots;
   llvm::DenseSet<const Atom *>  _liveAtoms;
   llvm::DenseSet<const Atom *>  _deadAtoms;
Index: include/lld/ReaderWriter/ELFLinkingContext.h
===================================================================
--- include/lld/ReaderWriter/ELFLinkingContext.h
+++ include/lld/ReaderWriter/ELFLinkingContext.h
@@ -44,6 +44,8 @@
   virtual std::unique_ptr<Reader> getDSOReader(bool) = 0;
 
   virtual std::unique_ptr<Writer> getWriter() = 0;
+
+  virtual std::unique_ptr<Resolver> getResolver() = 0;
 };
 
 class ELFLinkingContext : public LinkingContext {
@@ -155,6 +157,8 @@
 
   void createInternalFiles(std::vector<std::unique_ptr<File>> &) const override;
 
+  std::unique_ptr<Resolver> getResolver() override;
+
   /// \brief Set the dynamic linker path
   void setInterpreter(StringRef dynamicLinker) {
     _dynamicLinkerArg = true;
Index: lib/Core/LinkingContext.cpp
===================================================================
--- lib/Core/LinkingContext.cpp
+++ lib/Core/LinkingContext.cpp
@@ -99,6 +99,10 @@
     result.push_back(std::move(file));
 }
 
+std::unique_ptr<Resolver> LinkingContext::getResolver() {
+  return llvm::make_unique<Resolver>(*this);
+}
+
 void LinkingContext::addPasses(PassManager &pm) {}
 
 } // end namespace lld
Index: lib/Driver/Driver.cpp
===================================================================
--- lib/Driver/Driver.cpp
+++ lib/Driver/Driver.cpp
@@ -105,10 +105,10 @@
 
   // Do core linking.
   ScopedTask resolveTask(getDefaultDomain(), "Resolve");
-  Resolver resolver(context);
-  if (!resolver.resolve())
+  auto resolver = context.getResolver();
+  if (!resolver->resolve())
     return false;
-  std::unique_ptr<MutableFile> merged = resolver.resultFile();
+  std::unique_ptr<MutableFile> merged = resolver->resultFile();
   resolveTask.end();
 
   // Run passes on linked atoms.
Index: lib/ReaderWriter/ELF/Atoms.h
===================================================================
--- lib/ReaderWriter/ELF/Atoms.h
+++ lib/ReaderWriter/ELF/Atoms.h
@@ -157,6 +157,7 @@
                  std::vector<ELFReference<ELFT> *> &referenceList)
       : _owningFile(file), _symbolName(symbolName), _sectionName(sectionName),
         _symbol(symbol), _section(section), _contentData(contentData),
+        _dynamicExport(dynamicExportNormal),
         _referenceStartIndex(referenceStart), _referenceEndIndex(referenceEnd),
         _referenceList(referenceList), _contentType(typeUnknown),
         _permissions(permUnknown) {}
@@ -283,6 +284,8 @@
     return _contentType = ret;
   }
 
+  DynamicExport dynamicExport() const override { return _dynamicExport; }
+
   Alignment alignment() const override {
     // Unallocated common symbols specify their alignment constraints in
     // st_value.
@@ -413,6 +416,8 @@
     _referenceEndIndex = _referenceList.size();
   }
 
+  void forceDynamicExport() { _dynamicExport = dynamicExportAlways; }
+
   virtual void setOrdinal(uint64_t ord) { _ordinal = ord; }
 
 protected:
@@ -423,6 +428,7 @@
   const Elf_Shdr *_section;
   /// \brief Holds the bits that make up the atom.
   ArrayRef<uint8_t> _contentData;
+  DynamicExport _dynamicExport;
 
   uint64_t _ordinal;
   unsigned int _referenceStartIndex;
Index: lib/ReaderWriter/ELF/DefaultTargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/DefaultTargetHandler.h
+++ lib/ReaderWriter/ELF/DefaultTargetHandler.h
@@ -13,6 +13,7 @@
 #include "DefaultLayout.h"
 #include "TargetHandler.h"
 #include "ELFReader.h"
+#include "ELFResolver.h"
 #include "DynamicLibraryWriter.h"
 #include "ExecutableWriter.h"
 
@@ -42,6 +43,10 @@
   }
 
   virtual std::unique_ptr<Writer> getWriter() = 0;
+
+  virtual std::unique_ptr<Resolver> getResolver() {
+    return llvm::make_unique<ELFResolver<ELFT>>(this->_context);
+  }
 };
 
 } // end namespace elf
Index: lib/ReaderWriter/ELF/ELFLinkingContext.cpp
===================================================================
--- lib/ReaderWriter/ELF/ELFLinkingContext.cpp
+++ lib/ReaderWriter/ELF/ELFLinkingContext.cpp
@@ -225,6 +225,10 @@
   LinkingContext::createInternalFiles(files);
 }
 
+std::unique_ptr<Resolver> ELFLinkingContext::getResolver() {
+  return _targetHandler->getResolver();
+}
+
 std::unique_ptr<File> ELFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
Index: lib/ReaderWriter/ELF/ELFResolver.h
===================================================================
--- /dev/null
+++ lib/ReaderWriter/ELF/ELFResolver.h
@@ -0,0 +1,53 @@
+//===- lib/ReaderWriter/ELF/Resolver.h - Resolves Atom References ---------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_RESOLVER_H
+#define LLD_READER_WRITER_ELF_RESOLVER_H
+
+#include "Atoms.h"
+
+#include "lld/Core/Resolver.h"
+
+namespace lld {
+namespace elf {
+
+template <class ELFT> class ELFResolver : public Resolver {
+public:
+  ELFResolver(LinkingContext &context) : Resolver(context) {}
+
+protected:
+  bool checkUndefines() override;
+};
+
+template <class ELFT>
+bool ELFResolver<ELFT>::checkUndefines() {
+  if (Resolver::checkUndefines())
+    return true;
+
+  for (const Atom *a : _atoms) {
+    auto *ua = dyn_cast<ELFUndefinedAtom<ELFT>>(a);
+    // Skip non-weak symbols.
+    if (!ua || ua->canBeNull() == UndefinedAtom::canBeNullNever)
+      continue;
+    // Skip weak symbols from non-shared libraries.
+    if (!isa<SharedLibraryFile>(ua->file()))
+      continue;
+    // Request dynamic export for coalesced symbols replaced
+    // by strong defined atoms.
+    if (auto *da = dyn_cast<ELFDefinedAtom<ELFT>>(_symbolTable.replacement(ua)))
+      const_cast<ELFDefinedAtom<ELFT> *>(da)->forceDynamicExport();
+  }
+
+  return false;
+}
+
+} // namespace elf
+} // namespace lld
+
+#endif // LLD_READER_WRITER_ELF_RESOLVER_H
Index: lib/ReaderWriter/ELF/TargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/TargetHandler.h
+++ lib/ReaderWriter/ELF/TargetHandler.h
@@ -73,7 +73,7 @@
   /// How does the target deal with writing ELF output.
   virtual std::unique_ptr<Writer> getWriter() = 0;
 
-private:
+protected:
   ELFLinkingContext &_context;
 };
 } // end namespace elf
Index: test/elf/X86_64/dynsym-weak.test
===================================================================
--- /dev/null
+++ test/elf/X86_64/dynsym-weak.test
@@ -0,0 +1,118 @@
+# Check that a symbol declared as a week in a shared library gets a dynamic
+# symbol table record in an executable file if this executabe file declares the
+# symbol as strong.
+
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t.foo.o
+# RUN: lld -flavor gnu -target x86_64 -shared -o %t.so %t.foo.o
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t.main.o
+#
+# Link executable file with strong symbol. Weak symbol is in the shared lib.
+# RUN: lld -flavor gnu -target x86_64 -e main -o %t.exe %t.main.o %t.so
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck -check-prefix=EXE %s
+#
+# Link executable file. Strong and weak symbol come from different object files.
+# RUN: lld -flavor gnu -target x86_64 -e main -o %t.exe %t.main.o %t.foo.o
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck -check-prefix=OBJ %s
+#
+# Link shared library. Weak symbol is in the another shared lib.
+# RUN: lld -flavor gnu -target x86_64 -shared -o %t.res.so %t.main.o %t.so
+# RUN: llvm-readobj -dyn-symbols %t.res.so | FileCheck -check-prefix=SO %s
+
+# EXE:      Symbol {
+# EXE:        Name: flag@ ({{[0-9]+}})
+# EXE-NEXT:   Value: 0x{{[0-9A-F]+}}
+# EXE-NEXT:   Size: 4
+# EXE-NEXT:   Binding: Global (0x1)
+# EXE-NEXT:   Type: Object (0x1)
+# EXE-NEXT:   Other: 0
+# EXE-NEXT:   Section: .data (0x{{[0-9A-F]+}})
+# EXE-NEXT: }
+
+# OBJ-NOT:  Name: flag@ ({{[0-9]+}})
+
+# SO:      Symbol {
+# SO:        Name: flag@ ({{[0-9]+}})
+# SO-NEXT:   Value: 0x{{[0-9A-F]+}}
+# SO-NEXT:   Size: 4
+# SO-NEXT:   Binding: Global (0x1)
+# SO-NEXT:   Type: Object (0x1)
+# SO-NEXT:   Other: 0
+# SO-NEXT:   Section: .data (0x{{[0-9A-F]+}})
+# SO-NEXT: }
+
+# foo.o
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x04
+    Size:            0x08
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x08
+    Info:            .text
+    Relocations:
+      - Offset:          0x00
+        Symbol:          flag
+        Type:            R_X86_64_GOTPCREL
+        Addend:          -4
+
+Symbols:
+  Global:
+    - Name:            foo
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x08
+  Weak:
+    - Name:            flag
+
+# main.o
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x04
+    Size:            0x08
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x08
+    Info:            .text
+    Relocations:
+      - Offset:          0x00
+        Symbol:          foo
+        Type:            R_X86_64_PLT32
+        Addend:          -4
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x04
+    Size:            0x04
+
+Symbols:
+  Global:
+    - Name:            flag
+      Type:            STT_OBJECT
+      Section:         .data
+      Size:            0x04
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x08
+    - Name:            foo
+...