--- a/lld/MachO/Symbols.cpp	Mon May 25 11:55:54 2020 +0900
+++ b/lld/MachO/Symbols.cpp	Tue Jun 08 06:07:14 2021 +0900
@@ -8,18 +8,80 @@
 
 #include "Symbols.h"
 #include "InputFiles.h"
-#include "lld/Common/ErrorHandler.h"
-#include "lld/Common/Strings.h"
+#include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
-void LazySymbol::fetchArchiveMember() { file->fetch(sym); }
+// Returns a symbol for an error message.
+static std::string demangle(StringRef symName) {
+  if (config->demangle)
+    return demangleItanium(symName);
+  return std::string(symName);
+}
+
+std::string lld::toString(const Symbol &sym) { return demangle(sym.getName()); }
+
+std::string lld::toMachOString(const object::Archive::Symbol &b) {
+  return demangle(b.getName());
+}
+
+uint64_t Symbol::getStubVA() const { return in.stubs->getVA(stubsIndex); }
+uint64_t Symbol::getGotVA() const { return in.got->getVA(gotIndex); }
+uint64_t Symbol::getTlvVA() const { return in.tlvPointers->getVA(gotIndex); }
+
+bool Symbol::isLive() const {
+  if (isa<DylibSymbol>(this) || isa<Undefined>(this))
+    return used;
+
+  if (auto *d = dyn_cast<Defined>(this)) {
+    // Non-absolute symbols might be alive because their section is
+    // no_dead_strip or live_support. In that case, the section will know
+    // that it's live but `used` might be false. Non-absolute symbols always
+    // have to use the section's `live` bit as source of truth.
+    return d->isAbsolute() ? used : d->isec->live;
+  }
+
+  assert(!isa<CommonSymbol>(this) &&
+         "replaceCommonSymbols() runs before dead code stripping, and isLive() "
+         "should only be called after dead code stripping");
 
-// Returns a symbol for an error message.
-std::string lld::toString(const Symbol &sym) {
-  if (Optional<std::string> s = demangleItanium(sym.getName()))
-    return *s;
-  return std::string(sym.getName());
+  // Assume any other kind of symbol is live.
+  return true;
 }
+
+uint64_t Defined::getVA() const {
+  assert(isLive() && "this should only be called for live symbols");
+
+  if (isAbsolute())
+    return value;
+
+  if (!isec->isFinal) {
+    // A target arch that does not use thunks ought never ask for
+    // the address of a function that has not yet been finalized.
+    assert(target->usesThunks());
+
+    // ConcatOutputSection::finalize() can seek the address of a
+    // function before its address is assigned. The thunking algorithm
+    // knows that unfinalized functions will be out of range, so it is
+    // expedient to return a contrived out-of-range address.
+    return TargetInfo::outOfRangeVA;
+  }
+  return isec->getVA() + value;
+}
+
+uint64_t Defined::getFileOffset() const {
+  if (isAbsolute()) {
+    error("absolute symbol " + toString(*this) +
+          " does not have a file offset");
+    return 0;
+  }
+  return isec->getFileOffset() + value;
+}
+
+uint64_t DylibSymbol::getVA() const {
+  return isInStubs() ? getStubVA() : Symbol::getVA();
+}
+
+void LazySymbol::fetchArchiveMember() { getFile()->fetch(sym); }