Index: vendor/lld/dist-release_80/COFF/PDB.cpp
===================================================================
--- vendor/lld/dist-release_80/COFF/PDB.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/COFF/PDB.cpp	(revision 344173)
@@ -1,1765 +1,1771 @@
 //===- PDB.cpp ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PDB.h"
 #include "Chunks.h"
 #include "Config.h"
 #include "Driver.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Timer.h"
 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/CVDebugRecord.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JamCRC.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <memory>
 
 using namespace lld;
 using namespace lld::coff;
 using namespace llvm;
 using namespace llvm::codeview;
 
 using llvm::object::coff_section;
 
 static ExitOnError ExitOnErr;
 
 static Timer TotalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
 
 static Timer AddObjectsTimer("Add Objects", TotalPdbLinkTimer);
 static Timer TypeMergingTimer("Type Merging", AddObjectsTimer);
 static Timer SymbolMergingTimer("Symbol Merging", AddObjectsTimer);
 static Timer GlobalsLayoutTimer("Globals Stream Layout", TotalPdbLinkTimer);
 static Timer TpiStreamLayoutTimer("TPI Stream Layout", TotalPdbLinkTimer);
 static Timer DiskCommitTimer("Commit to Disk", TotalPdbLinkTimer);
 
 namespace {
 /// Map from type index and item index in a type server PDB to the
 /// corresponding index in the destination PDB.
 struct CVIndexMap {
   SmallVector<TypeIndex, 0> TPIMap;
   SmallVector<TypeIndex, 0> IPIMap;
   bool IsTypeServerMap = false;
   bool IsPrecompiledTypeMap = false;
 };
 
 class DebugSHandler;
 
 class PDBLinker {
   friend DebugSHandler;
 
 public:
   PDBLinker(SymbolTable *Symtab)
       : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
         IDTable(Alloc), GlobalTypeTable(Alloc), GlobalIDTable(Alloc) {
     // This isn't strictly necessary, but link.exe usually puts an empty string
     // as the first "valid" string in the string table, so we do the same in
     // order to maintain as much byte-for-byte compatibility as possible.
     PDBStrTab.insert("");
   }
 
   /// Emit the basic PDB structure: initial streams, headers, etc.
   void initialize(llvm::codeview::DebugInfo *BuildId);
 
   /// Add natvis files specified on the command line.
   void addNatvisFiles();
 
   /// Link CodeView from each object file in the symbol table into the PDB.
   void addObjectsToPDB();
 
   /// Link CodeView from a single object file into the target (output) PDB.
   /// When a precompiled headers object is linked, its TPI map might be provided
   /// externally.
   void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr);
 
   /// Produce a mapping from the type and item indices used in the object
   /// file to those in the destination PDB.
   ///
   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
   /// and IPI from the type server PDB and return a map for it. Each unique type
   /// server PDB is merged at most once, so this may return an existing index
   /// mapping.
   ///
   /// If the object does not use a type server PDB (compiled with /Z7), we merge
   /// all the type and item records from the .debug$S stream and fill in the
   /// caller-provided ObjectIndexMap.
   Expected<const CVIndexMap &> mergeDebugT(ObjFile *File,
                                            CVIndexMap *ObjectIndexMap);
 
   /// Reads and makes available a PDB.
   Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *File,
                                                        const CVType &FirstType);
 
   /// Merges a precompiled headers TPI map into the current TPI map. The
   /// precompiled headers object will also be loaded and remapped in the
   /// process.
   Expected<const CVIndexMap &>
   mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
                           CVIndexMap *ObjectIndexMap);
 
   /// Reads and makes available a precompiled headers object.
   ///
   /// This is a requirement for objects compiled with cl.exe /Yu. In that
   /// case, the referenced object (which was compiled with /Yc) has to be loaded
   /// first. This is mainly because the current object's TPI stream has external
   /// references to the precompiled headers object.
   ///
   /// If the precompiled headers object was already loaded, this function will
   /// simply return its (remapped) TPI map.
   Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *File,
                                                 PrecompRecord Precomp);
 
   /// Adds a precompiled headers object signature -> TPI mapping.
   std::pair<CVIndexMap &, bool /*already there*/>
   registerPrecompiledHeaders(uint32_t Signature);
 
   void mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
                           std::vector<ulittle32_t *> &StringTableRefs,
                           BinaryStreamRef SymData);
 
   /// Add the section map and section contributions to the PDB.
   void addSections(ArrayRef<OutputSection *> OutputSections,
                    ArrayRef<uint8_t> SectionTable);
 
   /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
   TypeCollection &getTypeTable() {
     if (Config->DebugGHashes)
       return GlobalTypeTable;
     return TypeTable;
   }
 
   /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
   TypeCollection &getIDTable() {
     if (Config->DebugGHashes)
       return GlobalIDTable;
     return IDTable;
   }
 
   /// Write the PDB to disk and store the Guid generated for it in *Guid.
   void commit(codeview::GUID *Guid);
 
 private:
   BumpPtrAllocator Alloc;
 
   SymbolTable *Symtab;
 
   pdb::PDBFileBuilder Builder;
 
   /// Type records that will go into the PDB TPI stream.
   MergingTypeTableBuilder TypeTable;
 
   /// Item records that will go into the PDB IPI stream.
   MergingTypeTableBuilder IDTable;
 
   /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
   GlobalTypeTableBuilder GlobalTypeTable;
 
   /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
   GlobalTypeTableBuilder GlobalIDTable;
 
   /// PDBs use a single global string table for filenames in the file checksum
   /// table.
   DebugStringTableSubsection PDBStrTab;
 
   llvm::SmallString<128> NativePath;
 
   /// A list of other PDBs which are loaded during the linking process and which
   /// we need to keep around since the linking operation may reference pointers
   /// inside of these PDBs.
   llvm::SmallVector<std::unique_ptr<pdb::NativeSession>, 2> LoadedPDBs;
 
   std::vector<pdb::SecMapEntry> SectionMap;
 
   /// Type index mappings of type server PDBs that we've loaded so far.
   std::map<codeview::GUID, CVIndexMap> TypeServerIndexMappings;
 
   /// Type index mappings of precompiled objects type map that we've loaded so
   /// far.
   std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings;
 
   /// List of TypeServer PDBs which cannot be loaded.
   /// Cached to prevent repeated load attempts.
   std::map<codeview::GUID, std::string> MissingTypeServerPDBs;
 };
 
 class DebugSHandler {
   PDBLinker &Linker;
 
   /// The object file whose .debug$S sections we're processing.
   ObjFile &File;
 
   /// The result of merging type indices.
   const CVIndexMap &IndexMap;
 
   /// The DEBUG_S_STRINGTABLE subsection.  These strings are referred to by
   /// index from other records in the .debug$S section.  All of these strings
   /// need to be added to the global PDB string table, and all references to
   /// these strings need to have their indices re-written to refer to the
   /// global PDB string table.
   DebugStringTableSubsectionRef CVStrTab;
 
   /// The DEBUG_S_FILECHKSMS subsection.  As above, these are referred to
   /// by other records in the .debug$S section and need to be merged into the
   /// PDB.
   DebugChecksumsSubsectionRef Checksums;
 
   /// The DEBUG_S_FRAMEDATA subsection(s).  There can be more than one of
   /// these and they need not appear in any specific order.  However, they
   /// contain string table references which need to be re-written, so we
   /// collect them all here and re-write them after all subsections have been
   /// discovered and processed.
   std::vector<DebugFrameDataSubsectionRef> NewFpoFrames;
 
   /// Pointers to raw memory that we determine have string table references
   /// that need to be re-written.  We first process all .debug$S subsections
   /// to ensure that we can handle subsections written in any order, building
   /// up this list as we go.  At the end, we use the string table (which must
   /// have been discovered by now else it is an error) to re-write these
   /// references.
   std::vector<ulittle32_t *> StringTableReferences;
 
 public:
   DebugSHandler(PDBLinker &Linker, ObjFile &File, const CVIndexMap &IndexMap)
       : Linker(Linker), File(File), IndexMap(IndexMap) {}
 
   void handleDebugS(lld::coff::SectionChunk &DebugS);
   void finish();
 };
 }
 
 // Visual Studio's debugger requires absolute paths in various places in the
 // PDB to work without additional configuration:
 // https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box
 static void pdbMakeAbsolute(SmallVectorImpl<char> &FileName) {
   // The default behavior is to produce paths that are valid within the context
   // of the machine that you perform the link on.  If the linker is running on
   // a POSIX system, we will output absolute POSIX paths.  If the linker is
   // running on a Windows system, we will output absolute Windows paths.  If the
   // user desires any other kind of behavior, they should explicitly pass
   // /pdbsourcepath, in which case we will treat the exact string the user
   // passed in as the gospel and not normalize, canonicalize it.
   if (sys::path::is_absolute(FileName, sys::path::Style::windows) ||
       sys::path::is_absolute(FileName, sys::path::Style::posix))
     return;
 
   // It's not absolute in any path syntax.  Relative paths necessarily refer to
   // the local file system, so we can make it native without ending up with a
   // nonsensical path.
-  sys::path::native(FileName);
   if (Config->PDBSourcePath.empty()) {
+    sys::path::native(FileName);
     sys::fs::make_absolute(FileName);
     return;
   }
-  // Only apply native and dot removal to the relative file path.  We want to
-  // leave the path the user specified untouched since we assume they specified
-  // it for a reason.
-  sys::path::remove_dots(FileName, /*remove_dot_dots=*/true);
 
+  // Try to guess whether /PDBSOURCEPATH is a unix path or a windows path.
+  // Since PDB's are more of a Windows thing, we make this conservative and only
+  // decide that it's a unix path if we're fairly certain.  Specifically, if
+  // it starts with a forward slash.
   SmallString<128> AbsoluteFileName = Config->PDBSourcePath;
-  sys::path::append(AbsoluteFileName, FileName);
+  sys::path::Style GuessedStyle = AbsoluteFileName.startswith("/")
+                                      ? sys::path::Style::posix
+                                      : sys::path::Style::windows;
+  sys::path::append(AbsoluteFileName, GuessedStyle, FileName);
+  sys::path::native(AbsoluteFileName, GuessedStyle);
+  sys::path::remove_dots(AbsoluteFileName, true, GuessedStyle);
+
   FileName = std::move(AbsoluteFileName);
 }
 
 static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
                                 StringRef Name) {
   for (SectionChunk *C : Sections)
     if (C->getSectionName() == Name)
       return C;
   return nullptr;
 }
 
 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
                                            StringRef SecName) {
   // First 4 bytes are section magic.
   if (Data.size() < 4)
     fatal(SecName + " too short");
   if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
     fatal(SecName + " has an invalid magic");
   return Data.slice(4);
 }
 
 static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
   if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
     return consumeDebugMagic(Sec->getContents(), SecName);
   return {};
 }
 
 // A COFF .debug$H section is currently a clang extension.  This function checks
 // if a .debug$H section is in a format that we expect / understand, so that we
 // can ignore any sections which are coincidentally also named .debug$H but do
 // not contain a format we recognize.
 static bool canUseDebugH(ArrayRef<uint8_t> DebugH) {
   if (DebugH.size() < sizeof(object::debug_h_header))
     return false;
   auto *Header =
       reinterpret_cast<const object::debug_h_header *>(DebugH.data());
   DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
   return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
          Header->Version == 0 &&
          Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
          (DebugH.size() % 8 == 0);
 }
 
 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
   SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
   if (!Sec)
     return llvm::None;
   ArrayRef<uint8_t> Contents = Sec->getContents();
   if (!canUseDebugH(Contents))
     return None;
   return Contents;
 }
 
 static ArrayRef<GloballyHashedType>
 getHashesFromDebugH(ArrayRef<uint8_t> DebugH) {
   assert(canUseDebugH(DebugH));
 
   DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
   uint32_t Count = DebugH.size() / sizeof(GloballyHashedType);
   return {reinterpret_cast<const GloballyHashedType *>(DebugH.data()), Count};
 }
 
 static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
                         TypeCollection &TypeTable) {
   // Start the TPI or IPI stream header.
   TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
 
   // Flatten the in memory type table and hash each type.
   TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
     auto Hash = pdb::hashTypeRecord(Type);
     if (auto E = Hash.takeError())
       fatal("type hashing error");
     TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
   });
 }
 
 // OBJs usually start their symbol stream with a S_OBJNAME record. This record
 // also contains the signature/key of the current PCH session. The signature
 // must be same for all objects which depend on the precompiled object.
 // Recompiling the precompiled headers will generate a new PCH key and thus
 // invalidate all the dependent objects.
 static uint32_t extractPCHSignature(ObjFile *File) {
   auto DbgIt = find_if(File->getDebugChunks(), [](SectionChunk *C) {
     return C->getSectionName() == ".debug$S";
   });
   if (!DbgIt)
     return 0;
 
   ArrayRef<uint8_t> Contents =
       consumeDebugMagic((*DbgIt)->getContents(), ".debug$S");
   DebugSubsectionArray Subsections;
   BinaryStreamReader Reader(Contents, support::little);
   ExitOnErr(Reader.readArray(Subsections, Contents.size()));
 
   for (const DebugSubsectionRecord &SS : Subsections) {
     if (SS.kind() != DebugSubsectionKind::Symbols)
       continue;
 
     // If it's there, the S_OBJNAME record shall come first in the stream.
     Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), 0);
     if (!Sym) {
       consumeError(Sym.takeError());
       continue;
     }
     if (auto ObjName = SymbolDeserializer::deserializeAs<ObjNameSym>(Sym.get()))
       return ObjName->Signature;
   }
   return 0;
 }
 
 Expected<const CVIndexMap &>
 PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
   ScopedTimer T(TypeMergingTimer);
 
   bool IsPrecompiledHeader = false;
 
   ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
   if (Data.empty()) {
     // Try again, Microsoft precompiled headers use .debug$P instead of
     // .debug$T
     Data = getDebugSection(File, ".debug$P");
     IsPrecompiledHeader = true;
   }
   if (Data.empty())
     return *ObjectIndexMap; // no debug info
 
   // Precompiled headers objects need to save the index map for further
   // reference by other objects which use the precompiled headers.
   if (IsPrecompiledHeader) {
     uint32_t PCHSignature = extractPCHSignature(File);
     if (PCHSignature == 0)
       fatal("No signature found for the precompiled headers OBJ (" +
             File->getName() + ")");
 
     // When a precompiled headers object comes first on the command-line, we
     // update the mapping here. Otherwise, if an object referencing the
     // precompiled headers object comes first, the mapping is created in
     // aquirePrecompObj(), thus we would skip this block.
     if (!ObjectIndexMap->IsPrecompiledTypeMap) {
       auto R = registerPrecompiledHeaders(PCHSignature);
       if (R.second)
         fatal(
             "A precompiled headers OBJ with the same signature was already "
             "provided! (" +
             File->getName() + ")");
 
       ObjectIndexMap = &R.first;
     }
   }
 
   BinaryByteStream Stream(Data, support::little);
   CVTypeArray Types;
   BinaryStreamReader Reader(Stream);
   if (auto EC = Reader.readArray(Types, Reader.getLength()))
     fatal("Reader::readArray failed: " + toString(std::move(EC)));
 
   auto FirstType = Types.begin();
   if (FirstType == Types.end())
     return *ObjectIndexMap;
 
   if (FirstType->kind() == LF_TYPESERVER2) {
     // Look through type servers. If we've already seen this type server,
     // don't merge any type information.
     return maybeMergeTypeServerPDB(File, *FirstType);
   } else if (FirstType->kind() == LF_PRECOMP) {
     // This object was compiled with /Yu, so process the corresponding
     // precompiled headers object (/Yc) first. Some type indices in the current
     // object are referencing data in the precompiled headers object, so we need
     // both to be loaded.
     auto E = mergeInPrecompHeaderObj(File, *FirstType, ObjectIndexMap);
     if (!E)
       return E.takeError();
 
     // Drop LF_PRECOMP record from the input stream, as it needs to be replaced
     // with the precompiled headers object type stream.
     // Note that we can't just call Types.drop_front(), as we explicitly want to
     // rebase the stream.
     Types.setUnderlyingStream(
         Types.getUnderlyingStream().drop_front(FirstType->RecordData.size()));
   }
 
   // Fill in the temporary, caller-provided ObjectIndexMap.
   if (Config->DebugGHashes) {
     ArrayRef<GloballyHashedType> Hashes;
     std::vector<GloballyHashedType> OwnedHashes;
     if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
       Hashes = getHashesFromDebugH(*DebugH);
     else {
       OwnedHashes = GloballyHashedType::hashTypes(Types);
       Hashes = OwnedHashes;
     }
 
     if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
                                          ObjectIndexMap->TPIMap, Types, Hashes,
                                          File->PCHSignature))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   } else {
     if (auto Err =
             mergeTypeAndIdRecords(IDTable, TypeTable, ObjectIndexMap->TPIMap,
                                   Types, File->PCHSignature))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   }
   return *ObjectIndexMap;
 }
 
 static Expected<std::unique_ptr<pdb::NativeSession>>
 tryToLoadPDB(const codeview::GUID &GuidFromObj, StringRef TSPath) {
   // Ensure the file exists before anything else. We want to return ENOENT,
   // "file not found", even if the path points to a removable device (in which
   // case the return message would be EAGAIN, "resource unavailable try again")
   if (!llvm::sys::fs::exists(TSPath))
     return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
       TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
   if (!MBOrErr)
     return errorCodeToError(MBOrErr.getError());
 
   std::unique_ptr<pdb::IPDBSession> ThisSession;
   if (auto EC = pdb::NativeSession::createFromPdb(
           MemoryBuffer::getMemBuffer(Driver->takeBuffer(std::move(*MBOrErr)),
                                      /*RequiresNullTerminator=*/false),
           ThisSession))
     return std::move(EC);
 
   std::unique_ptr<pdb::NativeSession> NS(
       static_cast<pdb::NativeSession *>(ThisSession.release()));
   pdb::PDBFile &File = NS->getPDBFile();
   auto ExpectedInfo = File.getPDBInfoStream();
   // All PDB Files should have an Info stream.
   if (!ExpectedInfo)
     return ExpectedInfo.takeError();
 
   // Just because a file with a matching name was found and it was an actual
   // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
   // must match the GUID specified in the TypeServer2 record.
   if (ExpectedInfo->getGuid() != GuidFromObj)
     return make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date);
 
   return std::move(NS);
 }
 
 Expected<const CVIndexMap &>
 PDBLinker::maybeMergeTypeServerPDB(ObjFile *File, const CVType &FirstType) {
   TypeServer2Record TS;
   if (auto EC =
           TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType), TS))
     fatal("error reading record: " + toString(std::move(EC)));
 
   const codeview::GUID &TSId = TS.getGuid();
   StringRef TSPath = TS.getName();
 
   // First, check if the PDB has previously failed to load.
   auto PrevErr = MissingTypeServerPDBs.find(TSId);
   if (PrevErr != MissingTypeServerPDBs.end())
     return createFileError(
         TSPath,
         make_error<StringError>(PrevErr->second, inconvertibleErrorCode()));
 
   // Second, check if we already loaded a PDB with this GUID. Return the type
   // index mapping if we have it.
   auto Insertion = TypeServerIndexMappings.insert({TSId, CVIndexMap()});
   CVIndexMap &IndexMap = Insertion.first->second;
   if (!Insertion.second)
     return IndexMap;
 
   // Mark this map as a type server map.
   IndexMap.IsTypeServerMap = true;
 
   // Check for a PDB at:
   // 1. The given file path
   // 2. Next to the object file or archive file
   auto ExpectedSession = handleExpected(
       tryToLoadPDB(TSId, TSPath),
       [&]() {
         StringRef LocalPath =
             !File->ParentName.empty() ? File->ParentName : File->getName();
         SmallString<128> Path = sys::path::parent_path(LocalPath);
         // Currently, type server PDBs are only created by cl, which only runs
         // on Windows, so we can assume type server paths are Windows style.
         sys::path::append(
             Path, sys::path::filename(TSPath, sys::path::Style::windows));
         return tryToLoadPDB(TSId, Path);
       },
       [&](std::unique_ptr<ECError> EC) -> Error {
         auto SysErr = EC->convertToErrorCode();
         // Only re-try loading if the previous error was "No such file or
         // directory"
         if (SysErr.category() == std::generic_category() &&
             SysErr.value() == ENOENT)
           return Error::success();
         return Error(std::move(EC));
       });
 
   if (auto E = ExpectedSession.takeError()) {
     TypeServerIndexMappings.erase(TSId);
 
     // Flatten the error to a string, for later display, if the error occurs
     // again on the same PDB.
     std::string ErrMsg;
     raw_string_ostream S(ErrMsg);
     S << E;
     MissingTypeServerPDBs.emplace(TSId, S.str());
 
     return createFileError(TSPath, std::move(E));
   }
 
   pdb::NativeSession *Session = ExpectedSession->get();
 
   // Keep a strong reference to this PDB, so that it's safe to hold pointers
   // into the file.
   LoadedPDBs.push_back(std::move(*ExpectedSession));
 
   auto ExpectedTpi = Session->getPDBFile().getPDBTpiStream();
   if (auto E = ExpectedTpi.takeError())
     fatal("Type server does not have TPI stream: " + toString(std::move(E)));
   auto ExpectedIpi = Session->getPDBFile().getPDBIpiStream();
   if (auto E = ExpectedIpi.takeError())
     fatal("Type server does not have TPI stream: " + toString(std::move(E)));
 
   if (Config->DebugGHashes) {
     // PDBs do not actually store global hashes, so when merging a type server
     // PDB we have to synthesize global hashes.  To do this, we first synthesize
     // global hashes for the TPI stream, since it is independent, then we
     // synthesize hashes for the IPI stream, using the hashes for the TPI stream
     // as inputs.
     auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
     auto IpiHashes =
         GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
 
     Optional<uint32_t> EndPrecomp;
     // Merge TPI first, because the IPI stream will reference type indices.
     if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
                                     ExpectedTpi->typeArray(), TpiHashes, EndPrecomp))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
     if (auto Err =
             mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
                            ExpectedIpi->typeArray(), IpiHashes))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   } else {
     // Merge TPI first, because the IPI stream will reference type indices.
     if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
                                     ExpectedTpi->typeArray()))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
     if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
                                   ExpectedIpi->typeArray()))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   }
 
   return IndexMap;
 }
 
 Expected<const CVIndexMap &>
 PDBLinker::mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
                                    CVIndexMap *ObjectIndexMap) {
   PrecompRecord Precomp;
   if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType),
                                                 Precomp))
     fatal("error reading record: " + toString(std::move(EC)));
 
   auto E = aquirePrecompObj(File, Precomp);
   if (!E)
     return E.takeError();
 
   const CVIndexMap &PrecompIndexMap = *E;
   assert(PrecompIndexMap.IsPrecompiledTypeMap);
 
   if (PrecompIndexMap.TPIMap.empty())
     return PrecompIndexMap;
 
   assert(Precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex);
   assert(Precomp.getTypesCount() <= PrecompIndexMap.TPIMap.size());
   // Use the previously remapped index map from the precompiled headers.
   ObjectIndexMap->TPIMap.append(PrecompIndexMap.TPIMap.begin(),
                                 PrecompIndexMap.TPIMap.begin() +
                                     Precomp.getTypesCount());
   return *ObjectIndexMap;
 }
 
 static bool equals_path(StringRef path1, StringRef path2) {
 #if defined(_WIN32)
   return path1.equals_lower(path2);
 #else
   return path1.equals(path2);
 #endif
 }
 
 // Find by name an OBJ provided on the command line
 static ObjFile *findObjByName(StringRef FileNameOnly) {
   SmallString<128> CurrentPath;
 
   for (ObjFile *F : ObjFile::Instances) {
     StringRef CurrentFileName = sys::path::filename(F->getName());
 
     // Compare based solely on the file name (link.exe behavior)
     if (equals_path(CurrentFileName, FileNameOnly))
       return F;
   }
   return nullptr;
 }
 
 std::pair<CVIndexMap &, bool /*already there*/>
 PDBLinker::registerPrecompiledHeaders(uint32_t Signature) {
   auto Insertion = PrecompTypeIndexMappings.insert({Signature, CVIndexMap()});
   CVIndexMap &IndexMap = Insertion.first->second;
   if (!Insertion.second)
     return {IndexMap, true};
   // Mark this map as a precompiled types map.
   IndexMap.IsPrecompiledTypeMap = true;
   return {IndexMap, false};
 }
 
 Expected<const CVIndexMap &>
 PDBLinker::aquirePrecompObj(ObjFile *File, PrecompRecord Precomp) {
   // First, check if we already loaded the precompiled headers object with this
   // signature. Return the type index mapping if we've already seen it.
   auto R = registerPrecompiledHeaders(Precomp.getSignature());
   if (R.second)
     return R.first;
 
   CVIndexMap &IndexMap = R.first;
 
   // Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
   // records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
   // the paths embedded in the OBJs are in the Windows format.
   SmallString<128> PrecompFileName = sys::path::filename(
       Precomp.getPrecompFilePath(), sys::path::Style::windows);
 
   // link.exe requires that a precompiled headers object must always be provided
   // on the command-line, even if that's not necessary.
   auto PrecompFile = findObjByName(PrecompFileName);
   if (!PrecompFile)
     return createFileError(
         PrecompFileName.str(),
         make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref));
 
   addObjFile(PrecompFile, &IndexMap);
 
   if (!PrecompFile->PCHSignature)
     fatal(PrecompFile->getName() + " is not a precompiled headers object");
 
   if (Precomp.getSignature() != PrecompFile->PCHSignature.getValueOr(0))
     return createFileError(
         Precomp.getPrecompFilePath().str(),
         make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
 
   return IndexMap;
 }
 
 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
   if (TI.isSimple())
     return true;
   if (TI.toArrayIndex() >= TypeIndexMap.size())
     return false;
   TI = TypeIndexMap[TI.toArrayIndex()];
   return true;
 }
 
 static void remapTypesInSymbolRecord(ObjFile *File, SymbolKind SymKind,
                                      MutableArrayRef<uint8_t> RecordBytes,
                                      const CVIndexMap &IndexMap,
                                      ArrayRef<TiReference> TypeRefs) {
   MutableArrayRef<uint8_t> Contents =
       RecordBytes.drop_front(sizeof(RecordPrefix));
   for (const TiReference &Ref : TypeRefs) {
     unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
     if (Contents.size() < Ref.Offset + ByteSize)
       fatal("symbol record too short");
 
     // This can be an item index or a type index. Choose the appropriate map.
     ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
     bool IsItemIndex = Ref.Kind == TiRefKind::IndexRef;
     if (IsItemIndex && IndexMap.IsTypeServerMap)
       TypeOrItemMap = IndexMap.IPIMap;
 
     MutableArrayRef<TypeIndex> TIs(
         reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
     for (TypeIndex &TI : TIs) {
       if (!remapTypeIndex(TI, TypeOrItemMap)) {
         log("ignoring symbol record of kind 0x" + utohexstr(SymKind) + " in " +
             File->getName() + " with bad " + (IsItemIndex ? "item" : "type") +
             " index 0x" + utohexstr(TI.getIndex()));
         TI = TypeIndex(SimpleTypeKind::NotTranslated);
         continue;
       }
     }
   }
 }
 
 static void
 recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> Contents,
                                    uint32_t Offset,
                                    std::vector<ulittle32_t *> &StrTableRefs) {
   Contents =
       Contents.drop_front(Offset).take_front(sizeof(support::ulittle32_t));
   ulittle32_t *Index = reinterpret_cast<ulittle32_t *>(Contents.data());
   StrTableRefs.push_back(Index);
 }
 
 static void
 recordStringTableReferences(SymbolKind Kind, MutableArrayRef<uint8_t> Contents,
                             std::vector<ulittle32_t *> &StrTableRefs) {
   // For now we only handle S_FILESTATIC, but we may need the same logic for
   // S_DEFRANGE and S_DEFRANGE_SUBFIELD.  However, I cannot seem to generate any
   // PDBs that contain these types of records, so because of the uncertainty
   // they are omitted here until we can prove that it's necessary.
   switch (Kind) {
   case SymbolKind::S_FILESTATIC:
     // FileStaticSym::ModFileOffset
     recordStringTableReferenceAtOffset(Contents, 8, StrTableRefs);
     break;
   case SymbolKind::S_DEFRANGE:
   case SymbolKind::S_DEFRANGE_SUBFIELD:
     log("Not fixing up string table reference in S_DEFRANGE / "
         "S_DEFRANGE_SUBFIELD record");
     break;
   default:
     break;
   }
 }
 
 static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) {
   const RecordPrefix *Prefix =
       reinterpret_cast<const RecordPrefix *>(RecordData.data());
   return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind));
 }
 
 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
 static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData,
                                TypeCollection &IDTable) {
   RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data());
 
   SymbolKind Kind = symbolKind(RecordData);
 
   if (Kind == SymbolKind::S_PROC_ID_END) {
     Prefix->RecordKind = SymbolKind::S_END;
     return;
   }
 
   // In an object file, GPROC32_ID has an embedded reference which refers to the
   // single object file type index namespace.  This has already been translated
   // to the PDB file's ID stream index space, but we need to convert this to a
   // symbol that refers to the type stream index space.  So we remap again from
   // ID index space to type index space.
   if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) {
     SmallVector<TiReference, 1> Refs;
     auto Content = RecordData.drop_front(sizeof(RecordPrefix));
     CVSymbol Sym(Kind, RecordData);
     discoverTypeIndicesInSymbol(Sym, Refs);
     assert(Refs.size() == 1);
     assert(Refs.front().Count == 1);
 
     TypeIndex *TI =
         reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset);
     // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
     // the IPI stream, whose `FunctionType` member refers to the TPI stream.
     // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
     // in both cases we just need the second type index.
     if (!TI->isSimple() && !TI->isNoneType()) {
       CVType FuncIdData = IDTable.getType(*TI);
       SmallVector<TypeIndex, 2> Indices;
       discoverTypeIndices(FuncIdData, Indices);
       assert(Indices.size() == 2);
       *TI = Indices[1];
     }
 
     Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
                                               : SymbolKind::S_LPROC32;
     Prefix->RecordKind = uint16_t(Kind);
   }
 }
 
 /// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
 /// The object file may not be aligned.
 static MutableArrayRef<uint8_t>
 copyAndAlignSymbol(const CVSymbol &Sym, MutableArrayRef<uint8_t> &AlignedMem) {
   size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
   assert(Size >= 4 && "record too short");
   assert(Size <= MaxRecordLength && "record too long");
   assert(AlignedMem.size() >= Size && "didn't preallocate enough");
 
   // Copy the symbol record and zero out any padding bytes.
   MutableArrayRef<uint8_t> NewData = AlignedMem.take_front(Size);
   AlignedMem = AlignedMem.drop_front(Size);
   memcpy(NewData.data(), Sym.data().data(), Sym.length());
   memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
 
   // Update the record prefix length. It should point to the beginning of the
   // next record.
   auto *Prefix = reinterpret_cast<RecordPrefix *>(NewData.data());
   Prefix->RecordLen = Size - 2;
   return NewData;
 }
 
 struct ScopeRecord {
   ulittle32_t PtrParent;
   ulittle32_t PtrEnd;
 };
 
 struct SymbolScope {
   ScopeRecord *OpeningRecord;
   uint32_t ScopeOffset;
 };
 
 static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
                            uint32_t CurOffset, CVSymbol &Sym) {
   assert(symbolOpensScope(Sym.kind()));
   SymbolScope S;
   S.ScopeOffset = CurOffset;
   S.OpeningRecord = const_cast<ScopeRecord *>(
       reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
   S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
   Stack.push_back(S);
 }
 
 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
                             uint32_t CurOffset, ObjFile *File) {
   if (Stack.empty()) {
     warn("symbol scopes are not balanced in " + File->getName());
     return;
   }
   SymbolScope S = Stack.pop_back_val();
   S.OpeningRecord->PtrEnd = CurOffset;
 }
 
 static bool symbolGoesInModuleStream(const CVSymbol &Sym, bool IsGlobalScope) {
   switch (Sym.kind()) {
   case SymbolKind::S_GDATA32:
   case SymbolKind::S_CONSTANT:
   // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
   // since they are synthesized by the linker in response to S_GPROC32 and
   // S_LPROC32, but if we do see them, don't put them in the module stream I
   // guess.
   case SymbolKind::S_PROCREF:
   case SymbolKind::S_LPROCREF:
     return false;
   // S_UDT records go in the module stream if it is not a global S_UDT.
   case SymbolKind::S_UDT:
     return !IsGlobalScope;
   // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
   case SymbolKind::S_LDATA32:
   default:
     return true;
   }
 }
 
 static bool symbolGoesInGlobalsStream(const CVSymbol &Sym, bool IsGlobalScope) {
   switch (Sym.kind()) {
   case SymbolKind::S_CONSTANT:
   case SymbolKind::S_GDATA32:
   // S_LDATA32 goes in both the module stream and the globals stream.
   case SymbolKind::S_LDATA32:
   case SymbolKind::S_GPROC32:
   case SymbolKind::S_LPROC32:
   // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
   // since they are synthesized by the linker in response to S_GPROC32 and
   // S_LPROC32, but if we do see them, copy them straight through.
   case SymbolKind::S_PROCREF:
   case SymbolKind::S_LPROCREF:
     return true;
   // S_UDT records go in the globals stream if it is a global S_UDT.
   case SymbolKind::S_UDT:
     return IsGlobalScope;
   default:
     return false;
   }
 }
 
 static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, uint16_t ModIndex,
                             unsigned SymOffset, const CVSymbol &Sym) {
   switch (Sym.kind()) {
   case SymbolKind::S_CONSTANT:
   case SymbolKind::S_UDT:
   case SymbolKind::S_GDATA32:
   case SymbolKind::S_LDATA32:
   case SymbolKind::S_PROCREF:
   case SymbolKind::S_LPROCREF:
     Builder.addGlobalSymbol(Sym);
     break;
   case SymbolKind::S_GPROC32:
   case SymbolKind::S_LPROC32: {
     SymbolRecordKind K = SymbolRecordKind::ProcRefSym;
     if (Sym.kind() == SymbolKind::S_LPROC32)
       K = SymbolRecordKind::LocalProcRef;
     ProcRefSym PS(K);
     PS.Module = ModIndex;
     // For some reason, MSVC seems to add one to this value.
     ++PS.Module;
     PS.Name = getSymbolName(Sym);
     PS.SumName = 0;
     PS.SymOffset = SymOffset;
     Builder.addGlobalSymbol(PS);
     break;
   }
   default:
     llvm_unreachable("Invalid symbol kind!");
   }
 }
 
 void PDBLinker::mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
                                    std::vector<ulittle32_t *> &StringTableRefs,
                                    BinaryStreamRef SymData) {
   ArrayRef<uint8_t> SymsBuffer;
   cantFail(SymData.readBytes(0, SymData.getLength(), SymsBuffer));
   SmallVector<SymbolScope, 4> Scopes;
 
   // Iterate every symbol to check if any need to be realigned, and if so, how
   // much space we need to allocate for them.
   bool NeedsRealignment = false;
   unsigned TotalRealignedSize = 0;
   auto EC = forEachCodeViewRecord<CVSymbol>(
       SymsBuffer, [&](CVSymbol Sym) -> llvm::Error {
         unsigned RealignedSize =
             alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
         NeedsRealignment |= RealignedSize != Sym.length();
         TotalRealignedSize += RealignedSize;
         return Error::success();
       });
 
   // If any of the symbol record lengths was corrupt, ignore them all, warn
   // about it, and move on.
   if (EC) {
     warn("corrupt symbol records in " + File->getName());
     consumeError(std::move(EC));
     return;
   }
 
   // If any symbol needed realignment, allocate enough contiguous memory for
   // them all. Typically symbol subsections are small enough that this will not
   // cause fragmentation.
   MutableArrayRef<uint8_t> AlignedSymbolMem;
   if (NeedsRealignment) {
     void *AlignedData =
         Alloc.Allocate(TotalRealignedSize, alignOf(CodeViewContainer::Pdb));
     AlignedSymbolMem = makeMutableArrayRef(
         reinterpret_cast<uint8_t *>(AlignedData), TotalRealignedSize);
   }
 
   // Iterate again, this time doing the real work.
   unsigned CurSymOffset = File->ModuleDBI->getNextSymbolOffset();
   ArrayRef<uint8_t> BulkSymbols;
   cantFail(forEachCodeViewRecord<CVSymbol>(
       SymsBuffer, [&](CVSymbol Sym) -> llvm::Error {
         // Align the record if required.
         MutableArrayRef<uint8_t> RecordBytes;
         if (NeedsRealignment) {
           RecordBytes = copyAndAlignSymbol(Sym, AlignedSymbolMem);
           Sym = CVSymbol(Sym.kind(), RecordBytes);
         } else {
           // Otherwise, we can actually mutate the symbol directly, since we
           // copied it to apply relocations.
           RecordBytes = makeMutableArrayRef(
               const_cast<uint8_t *>(Sym.data().data()), Sym.length());
         }
 
         // Discover type index references in the record. Skip it if we don't
         // know where they are.
         SmallVector<TiReference, 32> TypeRefs;
         if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) {
           log("ignoring unknown symbol record with kind 0x" +
               utohexstr(Sym.kind()));
           return Error::success();
         }
 
         // Re-map all the type index references.
         remapTypesInSymbolRecord(File, Sym.kind(), RecordBytes, IndexMap,
                                  TypeRefs);
 
         // An object file may have S_xxx_ID symbols, but these get converted to
         // "real" symbols in a PDB.
         translateIdSymbols(RecordBytes, getIDTable());
         Sym = CVSymbol(symbolKind(RecordBytes), RecordBytes);
 
         // If this record refers to an offset in the object file's string table,
         // add that item to the global PDB string table and re-write the index.
         recordStringTableReferences(Sym.kind(), RecordBytes, StringTableRefs);
 
         // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
         if (symbolOpensScope(Sym.kind()))
           scopeStackOpen(Scopes, CurSymOffset, Sym);
         else if (symbolEndsScope(Sym.kind()))
           scopeStackClose(Scopes, CurSymOffset, File);
 
         // Add the symbol to the globals stream if necessary.  Do this before
         // adding the symbol to the module since we may need to get the next
         // symbol offset, and writing to the module's symbol stream will update
         // that offset.
         if (symbolGoesInGlobalsStream(Sym, Scopes.empty()))
           addGlobalSymbol(Builder.getGsiBuilder(),
                           File->ModuleDBI->getModuleIndex(), CurSymOffset, Sym);
 
         if (symbolGoesInModuleStream(Sym, Scopes.empty())) {
           // Add symbols to the module in bulk. If this symbol is contiguous
           // with the previous run of symbols to add, combine the ranges. If
           // not, close the previous range of symbols and start a new one.
           if (Sym.data().data() == BulkSymbols.end()) {
             BulkSymbols = makeArrayRef(BulkSymbols.data(),
                                        BulkSymbols.size() + Sym.length());
           } else {
             File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
             BulkSymbols = RecordBytes;
           }
           CurSymOffset += Sym.length();
         }
         return Error::success();
       }));
 
   // Add any remaining symbols we've accumulated.
   File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
 }
 
 // Allocate memory for a .debug$S / .debug$F section and relocate it.
 static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
                                             SectionChunk &DebugChunk) {
   uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk.getSize());
   assert(DebugChunk.OutputSectionOff == 0 &&
          "debug sections should not be in output sections");
   DebugChunk.readRelocTargets();
   DebugChunk.writeTo(Buffer);
   return makeArrayRef(Buffer, DebugChunk.getSize());
 }
 
 static pdb::SectionContrib createSectionContrib(const Chunk *C, uint32_t Modi) {
   OutputSection *OS = C->getOutputSection();
   pdb::SectionContrib SC;
   memset(&SC, 0, sizeof(SC));
   SC.ISect = OS->SectionIndex;
   SC.Off = C->getRVA() - OS->getRVA();
   SC.Size = C->getSize();
   if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
     SC.Characteristics = SecChunk->Header->Characteristics;
     SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
     ArrayRef<uint8_t> Contents = SecChunk->getContents();
     JamCRC CRC(0);
     ArrayRef<char> CharContents = makeArrayRef(
         reinterpret_cast<const char *>(Contents.data()), Contents.size());
     CRC.update(CharContents);
     SC.DataCrc = CRC.getCRC();
   } else {
     SC.Characteristics = OS->Header.Characteristics;
     // FIXME: When we start creating DBI for import libraries, use those here.
     SC.Imod = Modi;
   }
   SC.RelocCrc = 0; // FIXME
 
   return SC;
 }
 
 static uint32_t
 translateStringTableIndex(uint32_t ObjIndex,
                           const DebugStringTableSubsectionRef &ObjStrTable,
                           DebugStringTableSubsection &PdbStrTable) {
   auto ExpectedString = ObjStrTable.getString(ObjIndex);
   if (!ExpectedString) {
     warn("Invalid string table reference");
     consumeError(ExpectedString.takeError());
     return 0;
   }
 
   return PdbStrTable.insert(*ExpectedString);
 }
 
 void DebugSHandler::handleDebugS(lld::coff::SectionChunk &DebugS) {
   DebugSubsectionArray Subsections;
 
   ArrayRef<uint8_t> RelocatedDebugContents = consumeDebugMagic(
       relocateDebugChunk(Linker.Alloc, DebugS), DebugS.getSectionName());
 
   BinaryStreamReader Reader(RelocatedDebugContents, support::little);
   ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
 
   for (const DebugSubsectionRecord &SS : Subsections) {
     switch (SS.kind()) {
     case DebugSubsectionKind::StringTable: {
       assert(!CVStrTab.valid() &&
              "Encountered multiple string table subsections!");
       ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
       break;
     }
     case DebugSubsectionKind::FileChecksums:
       assert(!Checksums.valid() &&
              "Encountered multiple checksum subsections!");
       ExitOnErr(Checksums.initialize(SS.getRecordData()));
       break;
     case DebugSubsectionKind::Lines:
       // We can add the relocated line table directly to the PDB without
       // modification because the file checksum offsets will stay the same.
       File.ModuleDBI->addDebugSubsection(SS);
       break;
     case DebugSubsectionKind::FrameData: {
       // We need to re-write string table indices here, so save off all
       // frame data subsections until we've processed the entire list of
       // subsections so that we can be sure we have the string table.
       DebugFrameDataSubsectionRef FDS;
       ExitOnErr(FDS.initialize(SS.getRecordData()));
       NewFpoFrames.push_back(std::move(FDS));
       break;
     }
     case DebugSubsectionKind::Symbols: {
       Linker.mergeSymbolRecords(&File, IndexMap, StringTableReferences,
                                 SS.getRecordData());
       break;
     }
     default:
       // FIXME: Process the rest of the subsections.
       break;
     }
   }
 }
 
 void DebugSHandler::finish() {
   pdb::DbiStreamBuilder &DbiBuilder = Linker.Builder.getDbiBuilder();
 
   // We should have seen all debug subsections across the entire object file now
   // which means that if a StringTable subsection and Checksums subsection were
   // present, now is the time to handle them.
   if (!CVStrTab.valid()) {
     if (Checksums.valid())
       fatal(".debug$S sections with a checksums subsection must also contain a "
             "string table subsection");
 
     if (!StringTableReferences.empty())
       warn("No StringTable subsection was encountered, but there are string "
            "table references");
     return;
   }
 
   // Rewrite string table indices in the Fpo Data and symbol records to refer to
   // the global PDB string table instead of the object file string table.
   for (DebugFrameDataSubsectionRef &FDS : NewFpoFrames) {
     const ulittle32_t *Reloc = FDS.getRelocPtr();
     for (codeview::FrameData FD : FDS) {
       FD.RvaStart += *Reloc;
       FD.FrameFunc =
           translateStringTableIndex(FD.FrameFunc, CVStrTab, Linker.PDBStrTab);
       DbiBuilder.addNewFpoData(FD);
     }
   }
 
   for (ulittle32_t *Ref : StringTableReferences)
     *Ref = translateStringTableIndex(*Ref, CVStrTab, Linker.PDBStrTab);
 
   // Make a new file checksum table that refers to offsets in the PDB-wide
   // string table. Generally the string table subsection appears after the
   // checksum table, so we have to do this after looping over all the
   // subsections.
   auto NewChecksums = make_unique<DebugChecksumsSubsection>(Linker.PDBStrTab);
   for (FileChecksumEntry &FC : Checksums) {
     SmallString<128> FileName =
         ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
     pdbMakeAbsolute(FileName);
     ExitOnErr(Linker.Builder.getDbiBuilder().addModuleSourceFile(
         *File.ModuleDBI, FileName));
     NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
   }
   File.ModuleDBI->addDebugSubsection(std::move(NewChecksums));
 }
 
 void PDBLinker::addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap) {
   if (File->wasProcessedForPDB())
     return;
   // Add a module descriptor for every object file. We need to put an absolute
   // path to the object into the PDB. If this is a plain object, we make its
   // path absolute. If it's an object in an archive, we make the archive path
   // absolute.
   bool InArchive = !File->ParentName.empty();
   SmallString<128> Path = InArchive ? File->ParentName : File->getName();
   pdbMakeAbsolute(Path);
   StringRef Name = InArchive ? File->getName() : StringRef(Path);
 
   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   File->ModuleDBI = &ExitOnErr(DbiBuilder.addModuleInfo(Name));
   File->ModuleDBI->setObjFileName(Path);
 
   auto Chunks = File->getChunks();
   uint32_t Modi = File->ModuleDBI->getModuleIndex();
   for (Chunk *C : Chunks) {
     auto *SecChunk = dyn_cast<SectionChunk>(C);
     if (!SecChunk || !SecChunk->Live)
       continue;
     pdb::SectionContrib SC = createSectionContrib(SecChunk, Modi);
     File->ModuleDBI->setFirstSectionContrib(SC);
     break;
   }
 
   // Before we can process symbol substreams from .debug$S, we need to process
   // type information, file checksums, and the string table.  Add type info to
   // the PDB first, so that we can get the map from object file type and item
   // indices to PDB type and item indices.
   CVIndexMap ObjectIndexMap;
   auto IndexMapResult =
       mergeDebugT(File, ExternIndexMap ? ExternIndexMap : &ObjectIndexMap);
 
   // If the .debug$T sections fail to merge, assume there is no debug info.
   if (!IndexMapResult) {
     if (!Config->WarnDebugInfoUnusable) {
       consumeError(IndexMapResult.takeError());
       return;
     }
     StringRef FileName = sys::path::filename(Path);
     warn("Cannot use debug info for '" + FileName + "' [LNK4099]\n" +
          ">>> failed to load reference " +
          StringRef(toString(IndexMapResult.takeError())));
     return;
   }
 
   ScopedTimer T(SymbolMergingTimer);
 
   DebugSHandler DSH(*this, *File, *IndexMapResult);
   // Now do all live .debug$S and .debug$F sections.
   for (SectionChunk *DebugChunk : File->getDebugChunks()) {
     if (!DebugChunk->Live || DebugChunk->getSize() == 0)
       continue;
 
     if (DebugChunk->getSectionName() == ".debug$S") {
       DSH.handleDebugS(*DebugChunk);
       continue;
     }
 
     if (DebugChunk->getSectionName() == ".debug$F") {
       ArrayRef<uint8_t> RelocatedDebugContents =
           relocateDebugChunk(Alloc, *DebugChunk);
 
       FixedStreamArray<object::FpoData> FpoRecords;
       BinaryStreamReader Reader(RelocatedDebugContents, support::little);
       uint32_t Count = RelocatedDebugContents.size() / sizeof(object::FpoData);
       ExitOnErr(Reader.readArray(FpoRecords, Count));
 
       // These are already relocated and don't refer to the string table, so we
       // can just copy it.
       for (const object::FpoData &FD : FpoRecords)
         DbiBuilder.addOldFpoData(FD);
       continue;
     }
   }
 
   // Do any post-processing now that all .debug$S sections have been processed.
   DSH.finish();
 }
 
 static PublicSym32 createPublic(Defined *Def) {
   PublicSym32 Pub(SymbolKind::S_PUB32);
   Pub.Name = Def->getName();
   if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
     if (D->getCOFFSymbol().isFunctionDefinition())
       Pub.Flags = PublicSymFlags::Function;
   } else if (isa<DefinedImportThunk>(Def)) {
     Pub.Flags = PublicSymFlags::Function;
   }
 
   OutputSection *OS = Def->getChunk()->getOutputSection();
   assert(OS && "all publics should be in final image");
   Pub.Offset = Def->getRVA() - OS->getRVA();
   Pub.Segment = OS->SectionIndex;
   return Pub;
 }
 
 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
 // TpiData.
 void PDBLinker::addObjectsToPDB() {
   ScopedTimer T1(AddObjectsTimer);
   for (ObjFile *File : ObjFile::Instances)
     addObjFile(File);
 
   Builder.getStringTableBuilder().setStrings(PDBStrTab);
   T1.stop();
 
   // Construct TPI and IPI stream contents.
   ScopedTimer T2(TpiStreamLayoutTimer);
   addTypeInfo(Builder.getTpiBuilder(), getTypeTable());
   addTypeInfo(Builder.getIpiBuilder(), getIDTable());
   T2.stop();
 
   ScopedTimer T3(GlobalsLayoutTimer);
   // Compute the public and global symbols.
   auto &GsiBuilder = Builder.getGsiBuilder();
   std::vector<PublicSym32> Publics;
   Symtab->forEachSymbol([&Publics](Symbol *S) {
     // Only emit defined, live symbols that have a chunk.
     auto *Def = dyn_cast<Defined>(S);
     if (Def && Def->isLive() && Def->getChunk())
       Publics.push_back(createPublic(Def));
   });
 
   if (!Publics.empty()) {
     // Sort the public symbols and add them to the stream.
     sort(parallel::par, Publics.begin(), Publics.end(),
          [](const PublicSym32 &L, const PublicSym32 &R) {
            return L.Name < R.Name;
          });
     for (const PublicSym32 &Pub : Publics)
       GsiBuilder.addPublicSymbol(Pub);
   }
 }
 
 void PDBLinker::addNatvisFiles() {
   for (StringRef File : Config->NatvisFiles) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> DataOrErr =
         MemoryBuffer::getFile(File);
     if (!DataOrErr) {
       warn("Cannot open input file: " + File);
       continue;
     }
     Builder.addInjectedSource(File, std::move(*DataOrErr));
   }
 }
 
 static codeview::CPUType toCodeViewMachine(COFF::MachineTypes Machine) {
   switch (Machine) {
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return codeview::CPUType::X64;
   case COFF::IMAGE_FILE_MACHINE_ARM:
     return codeview::CPUType::ARM7;
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return codeview::CPUType::ARM64;
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return codeview::CPUType::ARMNT;
   case COFF::IMAGE_FILE_MACHINE_I386:
     return codeview::CPUType::Intel80386;
   default:
     llvm_unreachable("Unsupported CPU Type");
   }
 }
 
 // Mimic MSVC which surrounds arguments containing whitespace with quotes.
 // Double double-quotes are handled, so that the resulting string can be
 // executed again on the cmd-line.
 static std::string quote(ArrayRef<StringRef> Args) {
   std::string R;
   R.reserve(256);
   for (StringRef A : Args) {
     if (!R.empty())
       R.push_back(' ');
     bool HasWS = A.find(' ') != StringRef::npos;
     bool HasQ = A.find('"') != StringRef::npos;
     if (HasWS || HasQ)
       R.push_back('"');
     if (HasQ) {
       SmallVector<StringRef, 4> S;
       A.split(S, '"');
       R.append(join(S, "\"\""));
     } else {
       R.append(A);
     }
     if (HasWS || HasQ)
       R.push_back('"');
   }
   return R;
 }
 
 static void addCommonLinkerModuleSymbols(StringRef Path,
                                          pdb::DbiModuleDescriptorBuilder &Mod,
                                          BumpPtrAllocator &Allocator) {
   ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
   Compile3Sym CS(SymbolRecordKind::Compile3Sym);
   EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
 
   ONS.Name = "* Linker *";
   ONS.Signature = 0;
 
   CS.Machine = toCodeViewMachine(Config->Machine);
   // Interestingly, if we set the string to 0.0.0.0, then when trying to view
   // local variables WinDbg emits an error that private symbols are not present.
   // By setting this to a valid MSVC linker version string, local variables are
   // displayed properly.   As such, even though it is not representative of
   // LLVM's version information, we need this for compatibility.
   CS.Flags = CompileSym3Flags::None;
   CS.VersionBackendBuild = 25019;
   CS.VersionBackendMajor = 14;
   CS.VersionBackendMinor = 10;
   CS.VersionBackendQFE = 0;
 
   // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
   // linker module (which is by definition a backend), so we don't need to do
   // anything here.  Also, it seems we can use "LLVM Linker" for the linker name
   // without any problems.  Only the backend version has to be hardcoded to a
   // magic number.
   CS.VersionFrontendBuild = 0;
   CS.VersionFrontendMajor = 0;
   CS.VersionFrontendMinor = 0;
   CS.VersionFrontendQFE = 0;
   CS.Version = "LLVM Linker";
   CS.setLanguage(SourceLanguage::Link);
 
   ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
   std::string ArgStr = quote(Args);
   EBS.Fields.push_back("cwd");
   SmallString<64> cwd;
   if (Config->PDBSourcePath.empty())
     sys::fs::current_path(cwd);
   else
     cwd = Config->PDBSourcePath;
   EBS.Fields.push_back(cwd);
   EBS.Fields.push_back("exe");
   SmallString<64> exe = Config->Argv[0];
   pdbMakeAbsolute(exe);
   EBS.Fields.push_back(exe);
   EBS.Fields.push_back("pdb");
   EBS.Fields.push_back(Path);
   EBS.Fields.push_back("cmd");
   EBS.Fields.push_back(ArgStr);
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       ONS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       CS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       EBS, Allocator, CodeViewContainer::Pdb));
 }
 
 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
                                          OutputSection &OS,
                                          BumpPtrAllocator &Allocator) {
   SectionSym Sym(SymbolRecordKind::SectionSym);
   Sym.Alignment = 12; // 2^12 = 4KB
   Sym.Characteristics = OS.Header.Characteristics;
   Sym.Length = OS.getVirtualSize();
   Sym.Name = OS.Name;
   Sym.Rva = OS.getRVA();
   Sym.SectionNumber = OS.SectionIndex;
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       Sym, Allocator, CodeViewContainer::Pdb));
 }
 
 // Creates a PDB file.
 void coff::createPDB(SymbolTable *Symtab,
                      ArrayRef<OutputSection *> OutputSections,
                      ArrayRef<uint8_t> SectionTable,
                      llvm::codeview::DebugInfo *BuildId) {
   ScopedTimer T1(TotalPdbLinkTimer);
   PDBLinker PDB(Symtab);
 
   PDB.initialize(BuildId);
   PDB.addObjectsToPDB();
   PDB.addSections(OutputSections, SectionTable);
   PDB.addNatvisFiles();
 
   ScopedTimer T2(DiskCommitTimer);
   codeview::GUID Guid;
   PDB.commit(&Guid);
   memcpy(&BuildId->PDB70.Signature, &Guid, 16);
 }
 
 void PDBLinker::initialize(llvm::codeview::DebugInfo *BuildId) {
   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
 
   BuildId->Signature.CVSignature = OMF::Signature::PDB70;
   // Signature is set to a hash of the PDB contents when the PDB is done.
   memset(BuildId->PDB70.Signature, 0, 16);
   BuildId->PDB70.Age = 1;
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.
   for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 
   // Add an Info stream.
   auto &InfoBuilder = Builder.getInfoBuilder();
   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
   InfoBuilder.setHashPDBContentsToGUID(true);
 
   // Add an empty DBI stream.
   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   DbiBuilder.setAge(BuildId->PDB70.Age);
   DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
   DbiBuilder.setMachineType(Config->Machine);
   // Technically we are not link.exe 14.11, but there are known cases where
   // debugging tools on Windows expect Microsoft-specific version numbers or
   // they fail to work at all.  Since we know we produce PDBs that are
   // compatible with LINK 14.11, we set that version number here.
   DbiBuilder.setBuildNumber(14, 11);
 }
 
 void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
                             ArrayRef<uint8_t> SectionTable) {
   // It's not entirely clear what this is, but the * Linker * module uses it.
   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   NativePath = Config->PDBPath;
   pdbMakeAbsolute(NativePath);
   uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
   auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
   LinkerModule.setPdbFilePathNI(PdbFilePathNI);
   addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
 
   // Add section contributions. They must be ordered by ascending RVA.
   for (OutputSection *OS : OutputSections) {
     addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc);
     for (Chunk *C : OS->Chunks) {
       pdb::SectionContrib SC =
           createSectionContrib(C, LinkerModule.getModuleIndex());
       Builder.getDbiBuilder().addSectionContrib(SC);
     }
   }
 
   // Add Section Map stream.
   ArrayRef<object::coff_section> Sections = {
       (const object::coff_section *)SectionTable.data(),
       SectionTable.size() / sizeof(object::coff_section)};
   SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
   DbiBuilder.setSectionMap(SectionMap);
 
   // Add COFF section header stream.
   ExitOnErr(
       DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
 }
 
 void PDBLinker::commit(codeview::GUID *Guid) {
   // Write to a file.
   ExitOnErr(Builder.commit(Config->PDBPath, Guid));
 }
 
 static Expected<StringRef>
 getFileName(const DebugStringTableSubsectionRef &Strings,
             const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) {
   auto Iter = Checksums.getArray().at(FileID);
   if (Iter == Checksums.getArray().end())
     return make_error<CodeViewError>(cv_error_code::no_records);
   uint32_t Offset = Iter->FileNameOffset;
   return Strings.getString(Offset);
 }
 
 static uint32_t getSecrelReloc() {
   switch (Config->Machine) {
   case AMD64:
     return COFF::IMAGE_REL_AMD64_SECREL;
   case I386:
     return COFF::IMAGE_REL_I386_SECREL;
   case ARMNT:
     return COFF::IMAGE_REL_ARM_SECREL;
   case ARM64:
     return COFF::IMAGE_REL_ARM64_SECREL;
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
 // Try to find a line table for the given offset Addr into the given chunk C.
 // If a line table was found, the line table, the string and checksum tables
 // that are used to interpret the line table, and the offset of Addr in the line
 // table are stored in the output arguments. Returns whether a line table was
 // found.
 static bool findLineTable(const SectionChunk *C, uint32_t Addr,
                           DebugStringTableSubsectionRef &CVStrTab,
                           DebugChecksumsSubsectionRef &Checksums,
                           DebugLinesSubsectionRef &Lines,
                           uint32_t &OffsetInLinetable) {
   ExitOnError ExitOnErr;
   uint32_t SecrelReloc = getSecrelReloc();
 
   for (SectionChunk *DbgC : C->File->getDebugChunks()) {
     if (DbgC->getSectionName() != ".debug$S")
       continue;
 
     // Build a mapping of SECREL relocations in DbgC that refer to C.
     DenseMap<uint32_t, uint32_t> Secrels;
     for (const coff_relocation &R : DbgC->Relocs) {
       if (R.Type != SecrelReloc)
         continue;
 
       if (auto *S = dyn_cast_or_null<DefinedRegular>(
               C->File->getSymbols()[R.SymbolTableIndex]))
         if (S->getChunk() == C)
           Secrels[R.VirtualAddress] = S->getValue();
     }
 
     ArrayRef<uint8_t> Contents =
         consumeDebugMagic(DbgC->getContents(), ".debug$S");
     DebugSubsectionArray Subsections;
     BinaryStreamReader Reader(Contents, support::little);
     ExitOnErr(Reader.readArray(Subsections, Contents.size()));
 
     for (const DebugSubsectionRecord &SS : Subsections) {
       switch (SS.kind()) {
       case DebugSubsectionKind::StringTable: {
         assert(!CVStrTab.valid() &&
                "Encountered multiple string table subsections!");
         ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
         break;
       }
       case DebugSubsectionKind::FileChecksums:
         assert(!Checksums.valid() &&
                "Encountered multiple checksum subsections!");
         ExitOnErr(Checksums.initialize(SS.getRecordData()));
         break;
       case DebugSubsectionKind::Lines: {
         ArrayRef<uint8_t> Bytes;
         auto Ref = SS.getRecordData();
         ExitOnErr(Ref.readLongestContiguousChunk(0, Bytes));
         size_t OffsetInDbgC = Bytes.data() - DbgC->getContents().data();
 
         // Check whether this line table refers to C.
         auto I = Secrels.find(OffsetInDbgC);
         if (I == Secrels.end())
           break;
 
         // Check whether this line table covers Addr in C.
         DebugLinesSubsectionRef LinesTmp;
         ExitOnErr(LinesTmp.initialize(BinaryStreamReader(Ref)));
         uint32_t OffsetInC = I->second + LinesTmp.header()->RelocOffset;
         if (Addr < OffsetInC || Addr >= OffsetInC + LinesTmp.header()->CodeSize)
           break;
 
         assert(!Lines.header() &&
                "Encountered multiple line tables for function!");
         ExitOnErr(Lines.initialize(BinaryStreamReader(Ref)));
         OffsetInLinetable = Addr - OffsetInC;
         break;
       }
       default:
         break;
       }
 
       if (CVStrTab.valid() && Checksums.valid() && Lines.header())
         return true;
     }
   }
 
   return false;
 }
 
 // Use CodeView line tables to resolve a file and line number for the given
 // offset into the given chunk and return them, or {"", 0} if a line table was
 // not found.
 std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *C,
                                                  uint32_t Addr) {
   ExitOnError ExitOnErr;
 
   DebugStringTableSubsectionRef CVStrTab;
   DebugChecksumsSubsectionRef Checksums;
   DebugLinesSubsectionRef Lines;
   uint32_t OffsetInLinetable;
 
   if (!findLineTable(C, Addr, CVStrTab, Checksums, Lines, OffsetInLinetable))
     return {"", 0};
 
   Optional<uint32_t> NameIndex;
   Optional<uint32_t> LineNumber;
   for (LineColumnEntry &Entry : Lines) {
     for (const LineNumberEntry &LN : Entry.LineNumbers) {
       LineInfo LI(LN.Flags);
       if (LN.Offset > OffsetInLinetable) {
         if (!NameIndex) {
           NameIndex = Entry.NameIndex;
           LineNumber = LI.getStartLine();
         }
         StringRef Filename =
             ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
         return {Filename, *LineNumber};
       }
       NameIndex = Entry.NameIndex;
       LineNumber = LI.getStartLine();
     }
   }
   if (!NameIndex)
     return {"", 0};
   StringRef Filename = ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
   return {Filename, *LineNumber};
 }
Index: vendor/lld/dist-release_80/ELF/Driver.cpp
===================================================================
--- vendor/lld/dist-release_80/ELF/Driver.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/ELF/Driver.cpp	(revision 344173)
@@ -1,1649 +1,1649 @@
 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // The driver drives the entire linking process. It is responsible for
 // parsing command line options and doing whatever it is instructed to do.
 //
 // One notable thing in the LLD's driver when compared to other linkers is
 // that the LLD's driver is agnostic on the host operating system.
 // Other linkers usually have implicit default values (such as a dynamic
 // linker path or library paths) for each host OS.
 //
 // I don't think implicit default values are useful because they are
 // usually explicitly specified by the compiler driver. They can even
 // be harmful when you are doing cross-linking. Therefore, in LLD, we
 // simply trust the compiler driver to pass all required options and
 // don't try to make effort on our side.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "Filesystem.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "MarkLive.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::support;
 
 using namespace lld;
 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
 static void setConfigs(opt::InputArgList &Args);
 
 bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
                raw_ostream &Error) {
   errorHandler().LogName = args::getFilenameWithoutExe(Args[0]);
   errorHandler().ErrorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
   errorHandler().ErrorOS = &Error;
   errorHandler().ExitEarly = CanExitEarly;
   errorHandler().ColorDiagnostics = Error.has_colors();
 
   InputSections.clear();
   OutputSections.clear();
   BinaryFiles.clear();
   BitcodeFiles.clear();
   ObjectFiles.clear();
   SharedFiles.clear();
 
   Config = make<Configuration>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
 
   Tar = nullptr;
   memset(&In, 0, sizeof(In));
 
   Config->ProgName = Args[0];
 
   Driver->main(Args);
 
   // Exit immediately if we don't need to return to the caller.
   // This saves time because the overhead of calling destructors
   // for all globally-allocated objects is not negligible.
   if (CanExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   freeArena();
   return !errorCount();
 }
 
 // Parses a linker -m option.
 static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef Emul) {
   uint8_t OSABI = 0;
   StringRef S = Emul;
   if (S.endswith("_fbsd")) {
     S = S.drop_back(5);
     OSABI = ELFOSABI_FREEBSD;
   }
 
   std::pair<ELFKind, uint16_t> Ret =
       StringSwitch<std::pair<ELFKind, uint16_t>>(S)
           .Cases("aarch64elf", "aarch64linux", "aarch64_elf64_le_vec",
                  {ELF64LEKind, EM_AARCH64})
           .Cases("armelf", "armelf_linux_eabi", {ELF32LEKind, EM_ARM})
           .Case("elf32_x86_64", {ELF32LEKind, EM_X86_64})
           .Cases("elf32btsmip", "elf32btsmipn32", {ELF32BEKind, EM_MIPS})
           .Cases("elf32ltsmip", "elf32ltsmipn32", {ELF32LEKind, EM_MIPS})
           .Case("elf32lriscv", {ELF32LEKind, EM_RISCV})
-          .Case("elf32ppc", {ELF32BEKind, EM_PPC})
+          .Cases("elf32ppc", "elf32ppclinux", {ELF32BEKind, EM_PPC})
           .Case("elf64btsmip", {ELF64BEKind, EM_MIPS})
           .Case("elf64ltsmip", {ELF64LEKind, EM_MIPS})
           .Case("elf64lriscv", {ELF64LEKind, EM_RISCV})
           .Case("elf64ppc", {ELF64BEKind, EM_PPC64})
           .Case("elf64lppc", {ELF64LEKind, EM_PPC64})
           .Cases("elf_amd64", "elf_x86_64", {ELF64LEKind, EM_X86_64})
           .Case("elf_i386", {ELF32LEKind, EM_386})
           .Case("elf_iamcu", {ELF32LEKind, EM_IAMCU})
           .Default({ELFNoneKind, EM_NONE});
 
   if (Ret.first == ELFNoneKind)
     error("unknown emulation: " + Emul);
   return std::make_tuple(Ret.first, Ret.second, OSABI);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
     MemoryBufferRef MB) {
   std::unique_ptr<Archive> File =
       CHECK(Archive::create(MB),
             MB.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<std::pair<MemoryBufferRef, uint64_t>> V;
   Error Err = Error::success();
   bool AddToTar = File->isThin() && Tar;
   for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) {
     Archive::Child C =
         CHECK(COrErr, MB.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef MBRef =
         CHECK(C.getMemoryBufferRef(),
               MB.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
     if (AddToTar)
       Tar->append(relativeToRoot(check(C.getFullName())), MBRef.getBuffer());
     V.push_back(std::make_pair(MBRef, C.getChildOffset()));
   }
   if (Err)
     fatal(MB.getBufferIdentifier() + ": Archive::children failed: " +
           toString(std::move(Err)));
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &MB : File->takeThinBuffers())
     make<std::unique_ptr<MemoryBuffer>>(std::move(MB));
 
   return V;
 }
 
 // Opens a file and create a file object. Path has to be resolved already.
 void LinkerDriver::addFile(StringRef Path, bool WithLOption) {
   using namespace sys::fs;
 
   Optional<MemoryBufferRef> Buffer = readFile(Path);
   if (!Buffer.hasValue())
     return;
   MemoryBufferRef MBRef = *Buffer;
 
   if (Config->FormatBinary) {
     Files.push_back(make<BinaryFile>(MBRef));
     return;
   }
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(MBRef);
     return;
   case file_magic::archive: {
     // Handle -whole-archive.
     if (InWholeArchive) {
       for (const auto &P : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(P.first, Path, P.second));
       return;
     }
 
     std::unique_ptr<Archive> File =
         CHECK(Archive::create(MBRef), Path + ": failed to parse archive");
 
     // If an archive file has no symbol table, it is likely that a user
     // is attempting LTO and using a default ar command that doesn't
     // understand the LLVM bitcode file. It is a pretty common error, so
     // we'll handle it as if it had a symbol table.
     if (!File->isEmpty() && !File->hasSymbolTable()) {
       for (const auto &P : getArchiveMembers(MBRef))
         Files.push_back(make<LazyObjFile>(P.first, Path, P.second));
       return;
     }
 
     // Handle the regular case.
     Files.push_back(make<ArchiveFile>(std::move(File)));
     return;
   }
   case file_magic::elf_shared_object:
     if (Config->Static || Config->Relocatable) {
       error("attempted static link of dynamic object " + Path);
       return;
     }
 
     // DSOs usually have DT_SONAME tags in their ELF headers, and the
     // sonames are used to identify DSOs. But if they are missing,
     // they are identified by filenames. We don't know whether the new
     // file has a DT_SONAME or not because we haven't parsed it yet.
     // Here, we set the default soname for the file because we might
     // need it later.
     //
     // If a file was specified by -lfoo, the directory part is not
     // significant, as a user did not specify it. This behavior is
     // compatible with GNU.
     Files.push_back(
         createSharedFile(MBRef, WithLOption ? path::filename(Path) : Path));
     return;
   case file_magic::bitcode:
   case file_magic::elf_relocatable:
     if (InLib)
       Files.push_back(make<LazyObjFile>(MBRef, "", 0));
     else
       Files.push_back(createObjectFile(MBRef));
     break;
   default:
     error(Path + ": unknown file type");
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   if (Optional<std::string> Path = searchLibrary(Name))
     addFile(*Path, /*WithLOption=*/true);
   else
     error("unable to find library -l" + Name);
 }
 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.
 static void initLLVM() {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions() {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
     error("the .gnu.hash section is not compatible with the MIPS target");
 
   if (Config->FixCortexA53Errata843419 && Config->EMachine != EM_AARCH64)
     error("--fix-cortex-a53-843419 is only supported on AArch64 targets");
 
   if (Config->TocOptimize && Config->EMachine != EM_PPC64)
     error("--toc-optimize is only supported on the PowerPC64 target");
 
   if (Config->Pie && Config->Shared)
     error("-shared and -pie may not be used together");
 
   if (!Config->Shared && !Config->FilterList.empty())
     error("-F may not be used without -shared");
 
   if (!Config->Shared && !Config->AuxiliaryList.empty())
     error("-f may not be used without -shared");
 
   if (!Config->Relocatable && !Config->DefineCommon)
     error("-no-define-common not supported in non relocatable output");
 
   if (Config->Relocatable) {
     if (Config->Shared)
       error("-r and -shared may not be used together");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Config->GdbIndex)
       error("-r and --gdb-index may not be used together");
     if (Config->ICF != ICFLevel::None)
       error("-r and --icf may not be used together");
     if (Config->Pie)
       error("-r and -pie may not be used together");
   }
 
   if (Config->ExecuteOnly) {
     if (Config->EMachine != EM_AARCH64)
       error("-execute-only is only supported on AArch64 targets");
 
     if (Config->SingleRoRx && !Script->HasSectionsCommand)
       error("-execute-only and -no-rosegment cannot be used together");
   }
 }
 
 static const char *getReproduceOption(opt::InputArgList &Args) {
   if (auto *Arg = Args.getLastArg(OPT_reproduce))
     return Arg->getValue();
   return getenv("LLD_REPRODUCE");
 }
 
 static bool hasZOption(opt::InputArgList &Args, StringRef Key) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (Key == Arg->getValue())
       return true;
   return false;
 }
 
 static bool getZFlag(opt::InputArgList &Args, StringRef K1, StringRef K2,
                      bool Default) {
   for (auto *Arg : Args.filtered_reverse(OPT_z)) {
     if (K1 == Arg->getValue())
       return true;
     if (K2 == Arg->getValue())
       return false;
   }
   return Default;
 }
 
 static bool isKnownZFlag(StringRef S) {
   return S == "combreloc" || S == "copyreloc" || S == "defs" ||
          S == "execstack" || S == "global" || S == "hazardplt" ||
          S == "initfirst" || S == "interpose" ||
          S == "keep-text-section-prefix" || S == "lazy" || S == "muldefs" ||
          S == "nocombreloc" || S == "nocopyreloc" || S == "nodefaultlib" ||
          S == "nodelete" || S == "nodlopen" || S == "noexecstack" ||
          S == "nokeep-text-section-prefix" || S == "norelro" || S == "notext" ||
          S == "now" || S == "origin" || S == "relro" || S == "retpolineplt" ||
          S == "rodynamic" || S == "text" || S == "wxneeded" ||
          S.startswith("max-page-size=") || S.startswith("stack-size=");
 }
 
 // Report an error for an unknown -z option.
 static void checkZOptions(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (!isKnownZFlag(Arg->getValue()))
       error("unknown -z value: " + StringRef(Arg->getValue()));
 }
 
 void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Interpret this flag early because error() depends on them.
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   // Handle -help
   if (Args.hasArg(OPT_help)) {
     printHelp();
     return;
   }
 
   // Handle -v or -version.
   //
   // A note about "compatible with GNU linkers" message: this is a hack for
   // scripts generated by GNU Libtool 2.4.6 (released in February 2014 and
   // still the newest version in March 2017) or earlier to recognize LLD as
   // a GNU compatible linker. As long as an output for the -v option
   // contains "GNU" or "with BFD", they recognize us as GNU-compatible.
   //
   // This is somewhat ugly hack, but in reality, we had no choice other
   // than doing this. Considering the very long release cycle of Libtool,
   // it is not easy to improve it to recognize LLD as a GNU compatible
   // linker in a timely manner. Even if we can make it, there are still a
   // lot of "configure" scripts out there that are generated by old version
   // of Libtool. We cannot convince every software developer to migrate to
   // the latest version and re-generate scripts. So we have this hack.
   if (Args.hasArg(OPT_v) || Args.hasArg(OPT_version))
     message(getLLDVersion() + " (compatible with GNU linkers)");
 
   if (const char *Path = getReproduceOption(Args)) {
     // Note that --reproduce is a debug option so you can ignore it
     // if you are trying to understand the whole picture of the code.
     Expected<std::unique_ptr<TarWriter>> ErrOrWriter =
         TarWriter::create(Path, path::stem(Path));
     if (ErrOrWriter) {
       Tar = std::move(*ErrOrWriter);
       Tar->append("response.txt", createResponseFile(Args));
       Tar->append("version.txt", getLLDVersion() + "\n");
     } else {
       error("--reproduce: " + toString(ErrOrWriter.takeError()));
     }
   }
 
   readConfigs(Args);
   checkZOptions(Args);
 
   // The behavior of -v or --version is a bit strange, but this is
   // needed for compatibility with GNU linkers.
   if (Args.hasArg(OPT_v) && !Args.hasArg(OPT_INPUT))
     return;
   if (Args.hasArg(OPT_version))
     return;
 
   initLLVM();
   createFiles(Args);
   if (errorCount())
     return;
 
   inferMachineType();
   setConfigs(Args);
   checkOptions();
   if (errorCount())
     return;
 
   switch (Config->EKind) {
   case ELF32LEKind:
     link<ELF32LE>(Args);
     return;
   case ELF32BEKind:
     link<ELF32BE>(Args);
     return;
   case ELF64LEKind:
     link<ELF64LE>(Args);
     return;
   case ELF64BEKind:
     link<ELF64BE>(Args);
     return;
   default:
     llvm_unreachable("unknown Config->EKind");
   }
 }
 
 static std::string getRpath(opt::InputArgList &Args) {
   std::vector<StringRef> V = args::getStrings(Args, OPT_rpath);
   return llvm::join(V.begin(), V.end(), ":");
 }
 
 // Determines what we should do if there are remaining unresolved
 // symbols after the name resolution.
 static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &Args) {
   UnresolvedPolicy ErrorOrWarn = Args.hasFlag(OPT_error_unresolved_symbols,
                                               OPT_warn_unresolved_symbols, true)
                                      ? UnresolvedPolicy::ReportError
                                      : UnresolvedPolicy::Warn;
 
   // Process the last of -unresolved-symbols, -no-undefined or -z defs.
   for (auto *Arg : llvm::reverse(Args)) {
     switch (Arg->getOption().getID()) {
     case OPT_unresolved_symbols: {
       StringRef S = Arg->getValue();
       if (S == "ignore-all" || S == "ignore-in-object-files")
         return UnresolvedPolicy::Ignore;
       if (S == "ignore-in-shared-libs" || S == "report-all")
         return ErrorOrWarn;
       error("unknown --unresolved-symbols value: " + S);
       continue;
     }
     case OPT_no_undefined:
       return ErrorOrWarn;
     case OPT_z:
       if (StringRef(Arg->getValue()) == "defs")
         return ErrorOrWarn;
       continue;
     }
   }
 
   // -shared implies -unresolved-symbols=ignore-all because missing
   // symbols are likely to be resolved at runtime using other DSOs.
   if (Config->Shared)
     return UnresolvedPolicy::Ignore;
   return ErrorOrWarn;
 }
 
 static Target2Policy getTarget2(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_target2, "got-rel");
   if (S == "rel")
     return Target2Policy::Rel;
   if (S == "abs")
     return Target2Policy::Abs;
   if (S == "got-rel")
     return Target2Policy::GotRel;
   error("unknown --target2 option: " + S);
   return Target2Policy::GotRel;
 }
 
 static bool isOutputFormatBinary(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_oformat, "elf");
   if (S == "binary")
     return true;
   if (!S.startswith("elf"))
     error("unknown --oformat value: " + S);
   return false;
 }
 
 static DiscardPolicy getDiscard(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_relocatable))
     return DiscardPolicy::None;
 
   auto *Arg =
       Args.getLastArg(OPT_discard_all, OPT_discard_locals, OPT_discard_none);
   if (!Arg)
     return DiscardPolicy::Default;
   if (Arg->getOption().getID() == OPT_discard_all)
     return DiscardPolicy::All;
   if (Arg->getOption().getID() == OPT_discard_locals)
     return DiscardPolicy::Locals;
   return DiscardPolicy::None;
 }
 
 static StringRef getDynamicLinker(opt::InputArgList &Args) {
   auto *Arg = Args.getLastArg(OPT_dynamic_linker, OPT_no_dynamic_linker);
   if (!Arg || Arg->getOption().getID() == OPT_no_dynamic_linker)
     return "";
   return Arg->getValue();
 }
 
 static ICFLevel getICF(opt::InputArgList &Args) {
   auto *Arg = Args.getLastArg(OPT_icf_none, OPT_icf_safe, OPT_icf_all);
   if (!Arg || Arg->getOption().getID() == OPT_icf_none)
     return ICFLevel::None;
   if (Arg->getOption().getID() == OPT_icf_safe)
     return ICFLevel::Safe;
   return ICFLevel::All;
 }
 
 static StripPolicy getStrip(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_relocatable))
     return StripPolicy::None;
 
   auto *Arg = Args.getLastArg(OPT_strip_all, OPT_strip_debug);
   if (!Arg)
     return StripPolicy::None;
   if (Arg->getOption().getID() == OPT_strip_all)
     return StripPolicy::All;
   return StripPolicy::Debug;
 }
 
 static uint64_t parseSectionAddress(StringRef S, const opt::Arg &Arg) {
   uint64_t VA = 0;
   if (S.startswith("0x"))
     S = S.drop_front(2);
   if (!to_integer(S, VA, 16))
     error("invalid argument: " + toString(Arg));
   return VA;
 }
 
 static StringMap<uint64_t> getSectionStartMap(opt::InputArgList &Args) {
   StringMap<uint64_t> Ret;
   for (auto *Arg : Args.filtered(OPT_section_start)) {
     StringRef Name;
     StringRef Addr;
     std::tie(Name, Addr) = StringRef(Arg->getValue()).split('=');
     Ret[Name] = parseSectionAddress(Addr, *Arg);
   }
 
   if (auto *Arg = Args.getLastArg(OPT_Ttext))
     Ret[".text"] = parseSectionAddress(Arg->getValue(), *Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tdata))
     Ret[".data"] = parseSectionAddress(Arg->getValue(), *Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tbss))
     Ret[".bss"] = parseSectionAddress(Arg->getValue(), *Arg);
   return Ret;
 }
 
 static SortSectionPolicy getSortSection(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_sort_section);
   if (S == "alignment")
     return SortSectionPolicy::Alignment;
   if (S == "name")
     return SortSectionPolicy::Name;
   if (!S.empty())
     error("unknown --sort-section rule: " + S);
   return SortSectionPolicy::Default;
 }
 
 static OrphanHandlingPolicy getOrphanHandling(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_orphan_handling, "place");
   if (S == "warn")
     return OrphanHandlingPolicy::Warn;
   if (S == "error")
     return OrphanHandlingPolicy::Error;
   if (S != "place")
     error("unknown --orphan-handling mode: " + S);
   return OrphanHandlingPolicy::Place;
 }
 
 // Parse --build-id or --build-id=<style>. We handle "tree" as a
 // synonym for "sha1" because all our hash functions including
 // -build-id=sha1 are actually tree hashes for performance reasons.
 static std::pair<BuildIdKind, std::vector<uint8_t>>
 getBuildId(opt::InputArgList &Args) {
   auto *Arg = Args.getLastArg(OPT_build_id, OPT_build_id_eq);
   if (!Arg)
     return {BuildIdKind::None, {}};
 
   if (Arg->getOption().getID() == OPT_build_id)
     return {BuildIdKind::Fast, {}};
 
   StringRef S = Arg->getValue();
   if (S == "fast")
     return {BuildIdKind::Fast, {}};
   if (S == "md5")
     return {BuildIdKind::Md5, {}};
   if (S == "sha1" || S == "tree")
     return {BuildIdKind::Sha1, {}};
   if (S == "uuid")
     return {BuildIdKind::Uuid, {}};
   if (S.startswith("0x"))
     return {BuildIdKind::Hexstring, parseHex(S.substr(2))};
 
   if (S != "none")
     error("unknown --build-id style: " + S);
   return {BuildIdKind::None, {}};
 }
 
 static std::pair<bool, bool> getPackDynRelocs(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_pack_dyn_relocs, "none");
   if (S == "android")
     return {true, false};
   if (S == "relr")
     return {false, true};
   if (S == "android+relr")
     return {true, true};
 
   if (S != "none")
     error("unknown -pack-dyn-relocs format: " + S);
   return {false, false};
 }
 
 static void readCallGraph(MemoryBufferRef MB) {
   // Build a map from symbol name to section
   DenseMap<StringRef, Symbol *> Map;
   for (InputFile *File : ObjectFiles)
     for (Symbol *Sym : File->getSymbols())
       Map[Sym->getName()] = Sym;
 
   auto FindSection = [&](StringRef Name) -> InputSectionBase * {
     Symbol *Sym = Map.lookup(Name);
     if (!Sym) {
       if (Config->WarnSymbolOrdering)
         warn(MB.getBufferIdentifier() + ": no such symbol: " + Name);
       return nullptr;
     }
     maybeWarnUnorderableSymbol(Sym);
 
     if (Defined *DR = dyn_cast_or_null<Defined>(Sym))
       return dyn_cast_or_null<InputSectionBase>(DR->Section);
     return nullptr;
   };
 
   for (StringRef Line : args::getLines(MB)) {
     SmallVector<StringRef, 3> Fields;
     Line.split(Fields, ' ');
     uint64_t Count;
 
     if (Fields.size() != 3 || !to_integer(Fields[2], Count)) {
       error(MB.getBufferIdentifier() + ": parse error");
       return;
     }
 
     if (InputSectionBase *From = FindSection(Fields[0]))
       if (InputSectionBase *To = FindSection(Fields[1]))
         Config->CallGraphProfile[std::make_pair(From, To)] += Count;
   }
 }
 
 template <class ELFT> static void readCallGraphsFromObjectFiles() {
   for (auto File : ObjectFiles) {
     auto *Obj = cast<ObjFile<ELFT>>(File);
 
     for (const Elf_CGProfile_Impl<ELFT> &CGPE : Obj->CGProfile) {
       auto *FromSym = dyn_cast<Defined>(&Obj->getSymbol(CGPE.cgp_from));
       auto *ToSym = dyn_cast<Defined>(&Obj->getSymbol(CGPE.cgp_to));
       if (!FromSym || !ToSym)
         continue;
 
       auto *From = dyn_cast_or_null<InputSectionBase>(FromSym->Section);
       auto *To = dyn_cast_or_null<InputSectionBase>(ToSym->Section);
       if (From && To)
         Config->CallGraphProfile[{From, To}] += CGPE.cgp_weight;
     }
   }
 }
 
 static bool getCompressDebugSections(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_compress_debug_sections, "none");
   if (S == "none")
     return false;
   if (S != "zlib")
     error("unknown --compress-debug-sections value: " + S);
   if (!zlib::isAvailable())
     error("--compress-debug-sections: zlib is not available");
   return true;
 }
 
 static std::pair<StringRef, StringRef> getOldNewOptions(opt::InputArgList &Args,
                                                         unsigned Id) {
   auto *Arg = Args.getLastArg(Id);
   if (!Arg)
     return {"", ""};
 
   StringRef S = Arg->getValue();
   std::pair<StringRef, StringRef> Ret = S.split(';');
   if (Ret.second.empty())
     error(Arg->getSpelling() + " expects 'old;new' format, but got " + S);
   return Ret;
 }
 
 // Parse the symbol ordering file and warn for any duplicate entries.
 static std::vector<StringRef> getSymbolOrderingFile(MemoryBufferRef MB) {
   SetVector<StringRef> Names;
   for (StringRef S : args::getLines(MB))
     if (!Names.insert(S) && Config->WarnSymbolOrdering)
       warn(MB.getBufferIdentifier() + ": duplicate ordered symbol: " + S);
 
   return Names.takeVector();
 }
 
 static void parseClangOption(StringRef Opt, const Twine &Msg) {
   std::string Err;
   raw_string_ostream OS(Err);
 
   const char *Argv[] = {Config->ProgName.data(), Opt.data()};
   if (cl::ParseCommandLineOptions(2, Argv, "", &OS))
     return;
   OS.flush();
   error(Msg + ": " + StringRef(Err).trim());
 }
 
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   errorHandler().Verbose = Args.hasArg(OPT_verbose);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   Config->AllowMultipleDefinition =
       Args.hasFlag(OPT_allow_multiple_definition,
                    OPT_no_allow_multiple_definition, false) ||
       hasZOption(Args, "muldefs");
   Config->AuxiliaryList = args::getStrings(Args, OPT_auxiliary);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->CheckSections =
       Args.hasFlag(OPT_check_sections, OPT_no_check_sections, true);
   Config->Chroot = Args.getLastArgValue(OPT_chroot);
   Config->CompressDebugSections = getCompressDebugSections(Args);
   Config->Cref = Args.hasFlag(OPT_cref, OPT_no_cref, false);
   Config->DefineCommon = Args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !Args.hasArg(OPT_relocatable));
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Discard = getDiscard(Args);
   Config->DwoDir = Args.getLastArgValue(OPT_plugin_opt_dwo_dir_eq);
   Config->DynamicLinker = getDynamicLinker(Args);
   Config->EhFrameHdr =
       Args.hasFlag(OPT_eh_frame_hdr, OPT_no_eh_frame_hdr, false);
   Config->EmitLLVM = Args.hasArg(OPT_plugin_opt_emit_llvm, false);
   Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->CallGraphProfileSort = Args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   Config->EnableNewDtags =
       Args.hasFlag(OPT_enable_new_dtags, OPT_disable_new_dtags, true);
   Config->Entry = Args.getLastArgValue(OPT_entry);
   Config->ExecuteOnly =
       Args.hasFlag(OPT_execute_only, OPT_no_execute_only, false);
   Config->ExportDynamic =
       Args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, false);
   Config->FilterList = args::getStrings(Args, OPT_filter);
   Config->Fini = Args.getLastArgValue(OPT_fini, "_fini");
   Config->FixCortexA53Errata843419 = Args.hasArg(OPT_fix_cortex_a53_843419);
   Config->GcSections = Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false);
   Config->GnuUnique = Args.hasFlag(OPT_gnu_unique, OPT_no_gnu_unique, true);
   Config->GdbIndex = Args.hasFlag(OPT_gdb_index, OPT_no_gdb_index, false);
   Config->ICF = getICF(Args);
   Config->IgnoreDataAddressEquality =
       Args.hasArg(OPT_ignore_data_address_equality);
   Config->IgnoreFunctionAddressEquality =
       Args.hasArg(OPT_ignore_function_address_equality);
   Config->Init = Args.getLastArgValue(OPT_init, "_init");
   Config->LTOAAPipeline = Args.getLastArgValue(OPT_lto_aa_pipeline);
   Config->LTODebugPassManager = Args.hasArg(OPT_lto_debug_pass_manager);
   Config->LTONewPassManager = Args.hasArg(OPT_lto_new_pass_manager);
   Config->LTONewPmPasses = Args.getLastArgValue(OPT_lto_newpm_passes);
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOObjPath = Args.getLastArgValue(OPT_plugin_opt_obj_path_eq);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->LTOSampleProfile = Args.getLastArgValue(OPT_lto_sample_profile);
   Config->MapFile = Args.getLastArgValue(OPT_Map);
   Config->MipsGotSize = args::getInteger(Args, OPT_mips_got_size, 0xfff0);
   Config->MergeArmExidx =
       Args.hasFlag(OPT_merge_exidx_entries, OPT_no_merge_exidx_entries, true);
   Config->NoinhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->Nostdlib = Args.hasArg(OPT_nostdlib);
   Config->OFormatBinary = isOutputFormatBinary(Args);
   Config->Omagic = Args.hasFlag(OPT_omagic, OPT_no_omagic, false);
   Config->OptRemarksFilename = Args.getLastArgValue(OPT_opt_remarks_filename);
   Config->OptRemarksWithHotness = Args.hasArg(OPT_opt_remarks_with_hotness);
   Config->Optimize = args::getInteger(Args, OPT_O, 1);
   Config->OrphanHandling = getOrphanHandling(Args);
   Config->OutputFile = Args.getLastArgValue(OPT_o);
   Config->Pie = Args.hasFlag(OPT_pie, OPT_no_pie, false);
   Config->PrintIcfSections =
       Args.hasFlag(OPT_print_icf_sections, OPT_no_print_icf_sections, false);
   Config->PrintGcSections =
       Args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
   Config->Rpath = getRpath(Args);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->SearchPaths = args::getStrings(Args, OPT_library_path);
   Config->SectionStartMap = getSectionStartMap(Args);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->SingleRoRx = Args.hasArg(OPT_no_rosegment);
   Config->SoName = Args.getLastArgValue(OPT_soname);
   Config->SortSection = getSortSection(Args);
   Config->SplitStackAdjustSize = args::getInteger(Args, OPT_split_stack_adjust_size, 16384);
   Config->Strip = getStrip(Args);
   Config->Sysroot = Args.getLastArgValue(OPT_sysroot);
   Config->Target1Rel = Args.hasFlag(OPT_target1_rel, OPT_target1_abs, false);
   Config->Target2 = getTarget2(Args);
   Config->ThinLTOCacheDir = Args.getLastArgValue(OPT_thinlto_cache_dir);
   Config->ThinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   Config->ThinLTOEmitImportsFiles =
       Args.hasArg(OPT_plugin_opt_thinlto_emit_imports_files);
   Config->ThinLTOIndexOnly = Args.hasArg(OPT_plugin_opt_thinlto_index_only) ||
                              Args.hasArg(OPT_plugin_opt_thinlto_index_only_eq);
   Config->ThinLTOIndexOnlyArg =
       Args.getLastArgValue(OPT_plugin_opt_thinlto_index_only_eq);
   Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u);
   Config->ThinLTOObjectSuffixReplace =
       getOldNewOptions(Args, OPT_plugin_opt_thinlto_object_suffix_replace_eq);
   Config->ThinLTOPrefixReplace =
       getOldNewOptions(Args, OPT_plugin_opt_thinlto_prefix_replace_eq);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Undefined = args::getStrings(Args, OPT_undefined);
   Config->UndefinedVersion =
       Args.hasFlag(OPT_undefined_version, OPT_no_undefined_version, true);
   Config->UseAndroidRelrTags = Args.hasFlag(
       OPT_use_android_relr_tags, OPT_no_use_android_relr_tags, false);
   Config->UnresolvedSymbols = getUnresolvedSymbolPolicy(Args);
   Config->WarnBackrefs =
       Args.hasFlag(OPT_warn_backrefs, OPT_no_warn_backrefs, false);
   Config->WarnCommon = Args.hasFlag(OPT_warn_common, OPT_no_warn_common, false);
   Config->WarnIfuncTextrel =
       Args.hasFlag(OPT_warn_ifunc_textrel, OPT_no_warn_ifunc_textrel, false);
   Config->WarnSymbolOrdering =
       Args.hasFlag(OPT_warn_symbol_ordering, OPT_no_warn_symbol_ordering, true);
   Config->ZCombreloc = getZFlag(Args, "combreloc", "nocombreloc", true);
   Config->ZCopyreloc = getZFlag(Args, "copyreloc", "nocopyreloc", true);
   Config->ZExecstack = getZFlag(Args, "execstack", "noexecstack", false);
   Config->ZGlobal = hasZOption(Args, "global");
   Config->ZHazardplt = hasZOption(Args, "hazardplt");
   Config->ZInitfirst = hasZOption(Args, "initfirst");
   Config->ZInterpose = hasZOption(Args, "interpose");
   Config->ZKeepTextSectionPrefix = getZFlag(
       Args, "keep-text-section-prefix", "nokeep-text-section-prefix", false);
   Config->ZNodefaultlib = hasZOption(Args, "nodefaultlib");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNodlopen = hasZOption(Args, "nodlopen");
   Config->ZNow = getZFlag(Args, "now", "lazy", false);
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = getZFlag(Args, "relro", "norelro", true);
   Config->ZRetpolineplt = hasZOption(Args, "retpolineplt");
   Config->ZRodynamic = hasZOption(Args, "rodynamic");
   Config->ZStackSize = args::getZOptionValue(Args, OPT_z, "stack-size", 0);
   Config->ZText = getZFlag(Args, "text", "notext", true);
   Config->ZWxneeded = hasZOption(Args, "wxneeded");
 
   // Parse LTO options.
   if (auto *Arg = Args.getLastArg(OPT_plugin_opt_mcpu_eq))
     parseClangOption(Saver.save("-mcpu=" + StringRef(Arg->getValue())),
                      Arg->getSpelling());
 
   for (auto *Arg : Args.filtered(OPT_plugin_opt))
     parseClangOption(Arg->getValue(), Arg->getSpelling());
 
   // Parse -mllvm options.
   for (auto *Arg : Args.filtered(OPT_mllvm))
     parseClangOption(Arg->getValue(), Arg->getSpelling());
 
   if (Config->LTOO > 3)
     error("invalid optimization level for LTO: " + Twine(Config->LTOO));
   if (Config->LTOPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (Config->ThinLTOJobs == 0)
     error("--thinlto-jobs: number of threads must be > 0");
 
   if (Config->SplitStackAdjustSize < 0)
     error("--split-stack-adjust-size: size must be >= 0");
 
   // Parse ELF{32,64}{LE,BE} and CPU type.
   if (auto *Arg = Args.getLastArg(OPT_m)) {
     StringRef S = Arg->getValue();
     std::tie(Config->EKind, Config->EMachine, Config->OSABI) =
         parseEmulation(S);
     Config->MipsN32Abi = (S == "elf32btsmipn32" || S == "elf32ltsmipn32");
     Config->Emulation = S;
   }
 
   // Parse -hash-style={sysv,gnu,both}.
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {
     StringRef S = Arg->getValue();
     if (S == "sysv")
       Config->SysvHash = true;
     else if (S == "gnu")
       Config->GnuHash = true;
     else if (S == "both")
       Config->SysvHash = Config->GnuHash = true;
     else
       error("unknown -hash-style: " + S);
   }
 
   if (Args.hasArg(OPT_print_map))
     Config->MapFile = "-";
 
   // --omagic is an option to create old-fashioned executables in which
   // .text segments are writable. Today, the option is still in use to
   // create special-purpose programs such as boot loaders. It doesn't
   // make sense to create PT_GNU_RELRO for such executables.
   if (Config->Omagic)
     Config->ZRelro = false;
 
   std::tie(Config->BuildId, Config->BuildIdVector) = getBuildId(Args);
 
   std::tie(Config->AndroidPackDynRelocs, Config->RelrPackDynRelocs) =
       getPackDynRelocs(Args);
 
   if (auto *Arg = Args.getLastArg(OPT_symbol_ordering_file))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       Config->SymbolOrderingFile = getSymbolOrderingFile(*Buffer);
 
   // If --retain-symbol-file is used, we'll keep only the symbols listed in
   // the file and discard all others.
   if (auto *Arg = Args.getLastArg(OPT_retain_symbols_file)) {
     Config->DefaultSymbolVersion = VER_NDX_LOCAL;
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       for (StringRef S : args::getLines(*Buffer))
         Config->VersionScriptGlobals.push_back(
             {S, /*IsExternCpp*/ false, /*HasWildcard*/ false});
   }
 
   bool HasExportDynamic =
       Args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, false);
 
   // Parses -dynamic-list and -export-dynamic-symbol. They make some
   // symbols private. Note that -export-dynamic takes precedence over them
   // as it says all symbols should be exported.
   if (!HasExportDynamic) {
     for (auto *Arg : Args.filtered(OPT_dynamic_list))
       if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
         readDynamicList(*Buffer);
 
     for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
       Config->DynamicList.push_back(
           {Arg->getValue(), /*IsExternCpp*/ false, /*HasWildcard*/ false});
   }
 
   // If --export-dynamic-symbol=foo is given and symbol foo is defined in
   // an object file in an archive file, that object file should be pulled
   // out and linked. (It doesn't have to behave like that from technical
   // point of view, but this is needed for compatibility with GNU.)
   for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
     Config->Undefined.push_back(Arg->getValue());
 
   for (auto *Arg : Args.filtered(OPT_version_script))
     if (Optional<std::string> Path = searchScript(Arg->getValue())) {
       if (Optional<MemoryBufferRef> Buffer = readFile(*Path))
         readVersionScript(*Buffer);
     } else {
       error(Twine("cannot find version script ") + Arg->getValue());
     }
 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &Args) {
   ELFKind K = Config->EKind;
   uint16_t M = Config->EMachine;
 
   Config->CopyRelocs = (Config->Relocatable || Config->EmitRelocs);
   Config->Is64 = (K == ELF64LEKind || K == ELF64BEKind);
   Config->IsLE = (K == ELF32LEKind || K == ELF64LEKind);
   Config->Endianness = Config->IsLE ? endianness::little : endianness::big;
   Config->IsMips64EL = (K == ELF64LEKind && M == EM_MIPS);
   Config->Pic = Config->Pie || Config->Shared;
   Config->PicThunk = Args.hasArg(OPT_pic_veneer, Config->Pic);
   Config->Wordsize = Config->Is64 ? 8 : 4;
 
   // ELF defines two different ways to store relocation addends as shown below:
   //
   //  Rel:  Addends are stored to the location where relocations are applied.
   //  Rela: Addends are stored as part of relocation entry.
   //
   // In other words, Rela makes it easy to read addends at the price of extra
   // 4 or 8 byte for each relocation entry. We don't know why ELF defined two
   // different mechanisms in the first place, but this is how the spec is
   // defined.
   //
   // You cannot choose which one, Rel or Rela, you want to use. Instead each
   // ABI defines which one you need to use. The following expression expresses
   // that.
   Config->IsRela = M == EM_AARCH64 || M == EM_AMDGPU || M == EM_HEXAGON ||
                    M == EM_PPC || M == EM_PPC64 || M == EM_RISCV ||
                    M == EM_X86_64;
 
   // If the output uses REL relocations we must store the dynamic relocation
   // addends to the output sections. We also store addends for RELA relocations
   // if --apply-dynamic-relocs is used.
   // We default to not writing the addends when using RELA relocations since
   // any standard conforming tool can find it in r_addend.
   Config->WriteAddends = Args.hasFlag(OPT_apply_dynamic_relocs,
                                       OPT_no_apply_dynamic_relocs, false) ||
                          !Config->IsRela;
 
   Config->TocOptimize =
       Args.hasFlag(OPT_toc_optimize, OPT_no_toc_optimize, M == EM_PPC64);
 }
 
 // Returns a value of "-format" option.
 static bool isFormatBinary(StringRef S) {
   if (S == "binary")
     return true;
   if (S == "elf" || S == "default")
     return false;
   error("unknown -format value: " + S +
         " (supported formats: elf, default, binary)");
   return false;
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   // For --{push,pop}-state.
   std::vector<std::tuple<bool, bool, bool>> Stack;
 
   // Iterate over argv to process input files and positional arguments.
   for (auto *Arg : Args) {
     switch (Arg->getOption().getUnaliasedOption().getID()) {
     case OPT_library:
       addLibrary(Arg->getValue());
       break;
     case OPT_INPUT:
       addFile(Arg->getValue(), /*WithLOption=*/false);
       break;
     case OPT_defsym: {
       StringRef From;
       StringRef To;
       std::tie(From, To) = StringRef(Arg->getValue()).split('=');
       if (From.empty() || To.empty())
         error("-defsym: syntax error: " + StringRef(Arg->getValue()));
       else
         readDefsym(From, MemoryBufferRef(To, "-defsym"));
       break;
     }
     case OPT_script:
       if (Optional<std::string> Path = searchScript(Arg->getValue())) {
         if (Optional<MemoryBufferRef> MB = readFile(*Path))
           readLinkerScript(*MB);
         break;
       }
       error(Twine("cannot find linker script ") + Arg->getValue());
       break;
     case OPT_as_needed:
       Config->AsNeeded = true;
       break;
     case OPT_format:
       Config->FormatBinary = isFormatBinary(Arg->getValue());
       break;
     case OPT_no_as_needed:
       Config->AsNeeded = false;
       break;
     case OPT_Bstatic:
       Config->Static = true;
       break;
     case OPT_Bdynamic:
       Config->Static = false;
       break;
     case OPT_whole_archive:
       InWholeArchive = true;
       break;
     case OPT_no_whole_archive:
       InWholeArchive = false;
       break;
     case OPT_just_symbols:
       if (Optional<MemoryBufferRef> MB = readFile(Arg->getValue())) {
         Files.push_back(createObjectFile(*MB));
         Files.back()->JustSymbols = true;
       }
       break;
     case OPT_start_group:
       if (InputFile::IsInGroup)
         error("nested --start-group");
       InputFile::IsInGroup = true;
       break;
     case OPT_end_group:
       if (!InputFile::IsInGroup)
         error("stray --end-group");
       InputFile::IsInGroup = false;
       ++InputFile::NextGroupId;
       break;
     case OPT_start_lib:
       if (InLib)
         error("nested --start-lib");
       if (InputFile::IsInGroup)
         error("may not nest --start-lib in --start-group");
       InLib = true;
       InputFile::IsInGroup = true;
       break;
     case OPT_end_lib:
       if (!InLib)
         error("stray --end-lib");
       InLib = false;
       InputFile::IsInGroup = false;
       ++InputFile::NextGroupId;
       break;
     case OPT_push_state:
       Stack.emplace_back(Config->AsNeeded, Config->Static, InWholeArchive);
       break;
     case OPT_pop_state:
       if (Stack.empty()) {
         error("unbalanced --push-state/--pop-state");
         break;
       }
       std::tie(Config->AsNeeded, Config->Static, InWholeArchive) = Stack.back();
       Stack.pop_back();
       break;
     }
   }
 
   if (Files.empty() && errorCount() == 0)
     error("no input files");
 }
 
 // If -m <machine_type> was not given, infer it from object files.
 void LinkerDriver::inferMachineType() {
   if (Config->EKind != ELFNoneKind)
     return;
 
   for (InputFile *F : Files) {
     if (F->EKind == ELFNoneKind)
       continue;
     Config->EKind = F->EKind;
     Config->EMachine = F->EMachine;
     Config->OSABI = F->OSABI;
     Config->MipsN32Abi = Config->EMachine == EM_MIPS && isMipsN32Abi(F);
     return;
   }
   error("target emulation unknown: -m or at least one .o file required");
 }
 
 // Parse -z max-page-size=<value>. The default value is defined by
 // each target.
 static uint64_t getMaxPageSize(opt::InputArgList &Args) {
   uint64_t Val = args::getZOptionValue(Args, OPT_z, "max-page-size",
                                        Target->DefaultMaxPageSize);
   if (!isPowerOf2_64(Val))
     error("max-page-size: value isn't a power of 2");
   return Val;
 }
 
 // Parses -image-base option.
 static Optional<uint64_t> getImageBase(opt::InputArgList &Args) {
   // Because we are using "Config->MaxPageSize" here, this function has to be
   // called after the variable is initialized.
   auto *Arg = Args.getLastArg(OPT_image_base);
   if (!Arg)
     return None;
 
   StringRef S = Arg->getValue();
   uint64_t V;
   if (!to_integer(S, V)) {
     error("-image-base: number expected, but got " + S);
     return 0;
   }
   if ((V % Config->MaxPageSize) != 0)
     warn("-image-base: address isn't multiple of page size: " + S);
   return V;
 }
 
 // Parses `--exclude-libs=lib,lib,...`.
 // The library names may be delimited by commas or colons.
 static DenseSet<StringRef> getExcludeLibs(opt::InputArgList &Args) {
   DenseSet<StringRef> Ret;
   for (auto *Arg : Args.filtered(OPT_exclude_libs)) {
     StringRef S = Arg->getValue();
     for (;;) {
       size_t Pos = S.find_first_of(",:");
       if (Pos == StringRef::npos)
         break;
       Ret.insert(S.substr(0, Pos));
       S = S.substr(Pos + 1);
     }
     Ret.insert(S);
   }
   return Ret;
 }
 
 // Handles the -exclude-libs option. If a static library file is specified
 // by the -exclude-libs option, all public symbols from the archive become
 // private unless otherwise specified by version scripts or something.
 // A special library name "ALL" means all archive files.
 //
 // This is not a popular option, but some programs such as bionic libc use it.
 template <class ELFT>
 static void excludeLibs(opt::InputArgList &Args) {
   DenseSet<StringRef> Libs = getExcludeLibs(Args);
   bool All = Libs.count("ALL");
 
   auto Visit = [&](InputFile *File) {
     if (!File->ArchiveName.empty())
       if (All || Libs.count(path::filename(File->ArchiveName)))
         for (Symbol *Sym : File->getSymbols())
           if (!Sym->isLocal() && Sym->File == File)
             Sym->VersionId = VER_NDX_LOCAL;
   };
 
   for (InputFile *File : ObjectFiles)
     Visit(File);
 
   for (BitcodeFile *File : BitcodeFiles)
     Visit(File);
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.
 template <class ELFT> static void handleUndefined(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym)
     return;
 
   // Since symbol S may not be used inside the program, LTO may
   // eliminate it. Mark the symbol as "used" to prevent it.
   Sym->IsUsedInRegularObj = true;
 
   if (Sym->isLazy())
     Symtab->fetchLazy<ELFT>(Sym);
 }
 
 template <class ELFT> static void handleLibcall(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym || !Sym->isLazy())
     return;
 
   MemoryBufferRef MB;
   if (auto *LO = dyn_cast<LazyObject>(Sym))
     MB = LO->File->MB;
   else
     MB = cast<LazyArchive>(Sym)->getMemberBuffer();
 
   if (isBitcode(MB))
     Symtab->fetchLazy<ELFT>(Sym);
 }
 
 // If all references to a DSO happen to be weak, the DSO is not added
 // to DT_NEEDED. If that happens, we need to eliminate shared symbols
 // created from the DSO. Otherwise, they become dangling references
 // that point to a non-existent DSO.
 template <class ELFT> static void demoteSharedSymbols() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (auto *S = dyn_cast<SharedSymbol>(Sym)) {
       if (!S->getFile<ELFT>().IsNeeded) {
         bool Used = S->Used;
         replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_WEAK, S->StOther,
                                  S->Type);
         S->Used = Used;
       }
     }
   }
 }
 
 // The section referred to by S is considered address-significant. Set the
 // KeepUnique flag on the section if appropriate.
 static void markAddrsig(Symbol *S) {
   if (auto *D = dyn_cast_or_null<Defined>(S))
     if (D->Section)
       // We don't need to keep text sections unique under --icf=all even if they
       // are address-significant.
       if (Config->ICF == ICFLevel::Safe || !(D->Section->Flags & SHF_EXECINSTR))
         D->Section->KeepUnique = true;
 }
 
 // Record sections that define symbols mentioned in --keep-unique <symbol>
 // and symbols referred to by address-significance tables. These sections are
 // ineligible for ICF.
 template <class ELFT>
 static void findKeepUniqueSections(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_keep_unique)) {
     StringRef Name = Arg->getValue();
     auto *D = dyn_cast_or_null<Defined>(Symtab->find(Name));
     if (!D || !D->Section) {
       warn("could not find symbol " + Name + " to keep unique");
       continue;
     }
     D->Section->KeepUnique = true;
   }
 
   // --icf=all --ignore-data-address-equality means that we can ignore
   // the dynsym and address-significance tables entirely.
   if (Config->ICF == ICFLevel::All && Config->IgnoreDataAddressEquality)
     return;
 
   // Symbols in the dynsym could be address-significant in other executables
   // or DSOs, so we conservatively mark them as address-significant.
   for (Symbol *S : Symtab->getSymbols())
     if (S->includeInDynsym())
       markAddrsig(S);
 
   // Visit the address-significance table in each object file and mark each
   // referenced symbol as address-significant.
   for (InputFile *F : ObjectFiles) {
     auto *Obj = cast<ObjFile<ELFT>>(F);
     ArrayRef<Symbol *> Syms = Obj->getSymbols();
     if (Obj->AddrsigSec) {
       ArrayRef<uint8_t> Contents =
           check(Obj->getObj().getSectionContents(Obj->AddrsigSec));
       const uint8_t *Cur = Contents.begin();
       while (Cur != Contents.end()) {
         unsigned Size;
         const char *Err;
         uint64_t SymIndex = decodeULEB128(Cur, &Size, Contents.end(), &Err);
         if (Err)
           fatal(toString(F) + ": could not decode addrsig section: " + Err);
         markAddrsig(Syms[SymIndex]);
         Cur += Size;
       }
     } else {
       // If an object file does not have an address-significance table,
       // conservatively mark all of its symbols as address-significant.
       for (Symbol *S : Syms)
         markAddrsig(S);
     }
   }
 }
 
 template <class ELFT> static Symbol *addUndefined(StringRef Name) {
   return Symtab->addUndefined<ELFT>(Name, STB_GLOBAL, STV_DEFAULT, 0, false,
                                     nullptr);
 }
 
 // The --wrap option is a feature to rename symbols so that you can write
 // wrappers for existing functions. If you pass `-wrap=foo`, all
 // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
 // expected to write `wrap_foo` function as a wrapper). The original
 // symbol becomes accessible as `real_foo`, so you can call that from your
 // wrapper.
 //
 // This data structure is instantiated for each -wrap option.
 struct WrappedSymbol {
   Symbol *Sym;
   Symbol *Real;
   Symbol *Wrap;
 };
 
 // Handles -wrap option.
 //
 // This function instantiates wrapper symbols. At this point, they seem
 // like they are not being used at all, so we explicitly set some flags so
 // that LTO won't eliminate them.
 template <class ELFT>
 static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &Args) {
   std::vector<WrappedSymbol> V;
   DenseSet<StringRef> Seen;
 
   for (auto *Arg : Args.filtered(OPT_wrap)) {
     StringRef Name = Arg->getValue();
     if (!Seen.insert(Name).second)
       continue;
 
     Symbol *Sym = Symtab->find(Name);
     if (!Sym)
       continue;
 
     Symbol *Real = addUndefined<ELFT>(Saver.save("__real_" + Name));
     Symbol *Wrap = addUndefined<ELFT>(Saver.save("__wrap_" + Name));
     V.push_back({Sym, Real, Wrap});
 
     // We want to tell LTO not to inline symbols to be overwritten
     // because LTO doesn't know the final symbol contents after renaming.
     Real->CanInline = false;
     Sym->CanInline = false;
 
     // Tell LTO not to eliminate these symbols.
     Sym->IsUsedInRegularObj = true;
     Wrap->IsUsedInRegularObj = true;
   }
   return V;
 }
 
 // Do renaming for -wrap by updating pointers to symbols.
 //
 // When this function is executed, only InputFiles and symbol table
 // contain pointers to symbol objects. We visit them to replace pointers,
 // so that wrapped symbols are swapped as instructed by the command line.
 template <class ELFT> static void wrapSymbols(ArrayRef<WrappedSymbol> Wrapped) {
   DenseMap<Symbol *, Symbol *> Map;
   for (const WrappedSymbol &W : Wrapped) {
     Map[W.Sym] = W.Wrap;
     Map[W.Real] = W.Sym;
   }
 
   // Update pointers in input files.
   parallelForEach(ObjectFiles, [&](InputFile *File) {
     std::vector<Symbol *> &Syms = File->getMutableSymbols();
     for (size_t I = 0, E = Syms.size(); I != E; ++I)
       if (Symbol *S = Map.lookup(Syms[I]))
         Syms[I] = S;
   });
 
   // Update pointers in the symbol table.
   for (const WrappedSymbol &W : Wrapped)
     Symtab->wrap(W.Sym, W.Real, W.Wrap);
 }
 
 static const char *LibcallRoutineNames[] = {
 #define HANDLE_LIBCALL(code, name) name,
 #include "llvm/IR/RuntimeLibcalls.def"
 #undef HANDLE_LIBCALL
 };
 
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   Target = getTarget();
   InX<ELFT>::VerSym = nullptr;
   InX<ELFT>::VerNeed = nullptr;
 
   Config->MaxPageSize = getMaxPageSize(Args);
   Config->ImageBase = getImageBase(Args);
 
   // If a -hash-style option was not given, set to a default value,
   // which varies depending on the target.
   if (!Args.hasArg(OPT_hash_style)) {
     if (Config->EMachine == EM_MIPS)
       Config->SysvHash = true;
     else
       Config->SysvHash = Config->GnuHash = true;
   }
 
   // Default output filename is "a.out" by the Unix tradition.
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
   // Fail early if the output file or map file is not writable. If a user has a
   // long link, e.g. due to a large LTO link, they do not wish to run it and
   // find that it failed because there was a mistake in their command-line.
   if (auto E = tryCreateFile(Config->OutputFile))
     error("cannot open output file " + Config->OutputFile + ": " + E.message());
   if (auto E = tryCreateFile(Config->MapFile))
     error("cannot open map file " + Config->MapFile + ": " + E.message());
   if (errorCount())
     return;
 
   // Use default entry point name if no name was given via the command
   // line nor linker scripts. For some reason, MIPS entry point name is
   // different from others.
   Config->WarnMissingEntry =
       (!Config->Entry.empty() || (!Config->Shared && !Config->Relocatable));
   if (Config->Entry.empty() && !Config->Relocatable)
     Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
 
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     Symtab->trace(Arg->getValue());
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
     Symtab->addFile<ELFT>(F);
 
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
   // We need one if we were asked to export dynamic symbols or if we are
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   Config->HasDynSymTab =
       !SharedFiles.empty() || Config->Pic || Config->ExportDynamic;
 
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
   for (StringRef Name : Script->ReferencedSymbols)
     addUndefined<ELFT>(Name);
 
   // Handle the `--undefined <sym>` options.
   for (StringRef S : Config->Undefined)
     handleUndefined<ELFT>(S);
 
   // If an entry symbol is in a static archive, pull out that file now.
   handleUndefined<ELFT>(Config->Entry);
 
   // If any of our inputs are bitcode files, the LTO code generator may create
   // references to certain library functions that might not be explicit in the
   // bitcode file's symbol table. If any of those library functions are defined
   // in a bitcode file in an archive member, we need to arrange to use LTO to
   // compile those archive members by adding them to the link beforehand.
   //
   // However, adding all libcall symbols to the link can have undesired
   // consequences. For example, the libgcc implementation of
   // __sync_val_compare_and_swap_8 on 32-bit ARM pulls in an .init_array entry
   // that aborts the program if the Linux kernel does not support 64-bit
   // atomics, which would prevent the program from running even if it does not
   // use 64-bit atomics.
   //
   // Therefore, we only add libcall symbols to the link before LTO if we have
   // to, i.e. if the symbol's definition is in bitcode. Any other required
   // libcall symbols will be added to the link after LTO when we add the LTO
   // object file to the link.
   if (!BitcodeFiles.empty())
     for (const char *S : LibcallRoutineNames)
       handleLibcall<ELFT>(S);
 
   // Return if there were name resolution errors.
   if (errorCount())
     return;
 
   // Now when we read all script files, we want to finalize order of linker
   // script commands, which can be not yet final because of INSERT commands.
   Script->processInsertCommands();
 
   // We want to declare linker script's symbols early,
   // so that we can version them.
   // They also might be exported if referenced by DSOs.
   Script->declareSymbols();
 
   // Handle the -exclude-libs option.
   if (Args.hasArg(OPT_exclude_libs))
     excludeLibs<ELFT>(Args);
 
   // Create ElfHeader early. We need a dummy section in
   // addReservedSymbols to mark the created symbols as not absolute.
   Out::ElfHeader = make<OutputSection>("", 0, SHF_ALLOC);
   Out::ElfHeader->Size = sizeof(typename ELFT::Ehdr);
 
   // Create wrapped symbols for -wrap option.
   std::vector<WrappedSymbol> Wrapped = addWrappedSymbols<ELFT>(Args);
 
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
   // Apply version scripts.
   //
   // For a relocatable output, version scripts don't make sense, and
   // parsing a symbol version string (e.g. dropping "@ver1" from a symbol
   // name "foo@ver1") rather do harm, so we don't call this if -r is given.
   if (!Config->Relocatable)
     Symtab->scanVersionScript();
 
   // Do link-time optimization if given files are LLVM bitcode files.
   // This compiles bitcode files into real object files.
   //
   // With this the symbol table should be complete. After this, no new names
   // except a few linker-synthesized ones will be added to the symbol table.
   Symtab->addCombinedLTOObject<ELFT>();
   if (errorCount())
     return;
 
   // If -thinlto-index-only is given, we should create only "index
   // files" and not object files. Index file creation is already done
   // in addCombinedLTOObject, so we are done if that's the case.
   if (Config->ThinLTOIndexOnly)
     return;
 
   // Likewise, --plugin-opt=emit-llvm is an option to make LTO create
   // an output file in bitcode and exit, so that you can just get a
   // combined bitcode file.
   if (Config->EmitLLVM)
     return;
 
   // Apply symbol renames for -wrap.
   if (!Wrapped.empty())
     wrapSymbols<ELFT>(Wrapped);
 
   // Now that we have a complete list of input files.
   // Beyond this point, no new files are added.
   // Aggregate all input sections into one place.
   for (InputFile *F : ObjectFiles)
     for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection::Discarded)
         InputSections.push_back(S);
   for (BinaryFile *F : BinaryFiles)
     for (InputSectionBase *S : F->getSections())
       InputSections.push_back(cast<InputSection>(S));
 
   // We do not want to emit debug sections if --strip-all
   // or -strip-debug are given.
   if (Config->Strip != StripPolicy::None)
     llvm::erase_if(InputSections, [](InputSectionBase *S) {
       return S->Name.startswith(".debug") || S->Name.startswith(".zdebug");
     });
 
   Config->EFlags = Target->calcEFlags();
 
   if (Config->EMachine == EM_ARM) {
     // FIXME: These warnings can be removed when lld only uses these features
     // when the input objects have been compiled with an architecture that
     // supports them.
     if (Config->ARMHasBlx == false)
       warn("lld uses blx instruction, no object with architecture supporting "
            "feature detected");
   }
 
   // This adds a .comment section containing a version string. We have to add it
   // before mergeSections because the .comment section is a mergeable section.
   if (!Config->Relocatable)
     InputSections.push_back(createCommentSection());
 
   // Do size optimizations: garbage collection, merging of SHF_MERGE sections
   // and identical code folding.
   splitSections<ELFT>();
   markLive<ELFT>();
   demoteSharedSymbols<ELFT>();
   mergeSections();
   if (Config->ICF != ICFLevel::None) {
     findKeepUniqueSections<ELFT>(Args);
     doIcf<ELFT>();
   }
 
   // Read the callgraph now that we know what was gced or icfed
   if (Config->CallGraphProfileSort) {
     if (auto *Arg = Args.getLastArg(OPT_call_graph_ordering_file))
       if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
         readCallGraph(*Buffer);
     readCallGraphsFromObjectFiles<ELFT>();
   }
 
   // Write the result to the file.
   writeResult<ELFT>();
 }
Index: vendor/lld/dist-release_80/ELF/ScriptParser.cpp
===================================================================
--- vendor/lld/dist-release_80/ELF/ScriptParser.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/ELF/ScriptParser.cpp	(revision 344173)
@@ -1,1544 +1,1545 @@
 //===- ScriptParser.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a recursive-descendent parser for linker scripts.
 // Parsed results are stored to Config and Script global objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ScriptParser.h"
 #include "Config.h"
 #include "Driver.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "ScriptLexer.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include <cassert>
 #include <limits>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
 static bool isUnderSysroot(StringRef Path);
 
 namespace {
 class ScriptParser final : ScriptLexer {
 public:
   ScriptParser(MemoryBufferRef MB)
       : ScriptLexer(MB),
         IsUnderSysroot(isUnderSysroot(MB.getBufferIdentifier())) {}
 
   void readLinkerScript();
   void readVersionScript();
   void readDynamicList();
   void readDefsym(StringRef Name);
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
   void readInput();
   void readMemory();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readPhdrs();
   void readRegionAlias();
   void readSearchDir();
   void readSections();
   void readTarget();
   void readVersion();
   void readVersionScriptCommand();
 
   SymbolAssignment *readSymbolAssignment(StringRef Name);
   ByteCommand *readByteCommand(StringRef Tok);
   std::array<uint8_t, 4> readFill();
   std::array<uint8_t, 4> parseFill(StringRef Tok);
   bool readSectionDirective(OutputSection *Cmd, StringRef Tok1, StringRef Tok2);
   void readSectionAddressType(OutputSection *Cmd);
   OutputSection *readOverlaySectionDescription();
   OutputSection *readOutputSectionDescription(StringRef OutSec);
   std::vector<BaseCommand *> readOverlay();
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   StringMatcher readFilePatterns();
   std::vector<SectionPattern> readInputSectionsList();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortSectionPolicy readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readAssignment(StringRef Tok);
   void readSort();
   Expr readAssert();
   Expr readConstant();
   Expr getPageSize();
 
   uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
   std::pair<uint32_t, uint32_t> readMemoryAttributes();
 
   Expr combine(StringRef Op, Expr L, Expr R);
   Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
   StringRef readParenLiteral();
   Expr readPrimary();
   Expr readTernary(Expr Cond);
   Expr readParenExpr();
 
   // For parsing version script.
   std::vector<SymbolVersion> readVersionExtern();
   void readAnonymousDeclaration();
   void readVersionDeclaration(StringRef VerStr);
 
   std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
   readSymbols();
 
   // True if a script being read is in a subdirectory specified by -sysroot.
   bool IsUnderSysroot;
 
   // A set to detect an INCLUDE() cycle.
   StringSet<> Seen;
 };
 } // namespace
 
 static StringRef unquote(StringRef S) {
   if (S.startswith("\""))
     return S.substr(1, S.size() - 2);
   return S;
 }
 
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }
 
 // Some operations only support one non absolute value. Move the
 // absolute one to the right hand side for convenience.
 static void moveAbsRight(ExprValue &A, ExprValue &B) {
   if (A.Sec == nullptr || (A.ForceAbsolute && !B.isAbsolute()))
     std::swap(A, B);
   if (!B.isAbsolute())
     error(A.Loc + ": at least one side of the expression must be absolute");
 }
 
 static ExprValue add(ExprValue A, ExprValue B) {
   moveAbsRight(A, B);
   return {A.Sec, A.ForceAbsolute, A.getSectionOffset() + B.getValue(), A.Loc};
 }
 
 static ExprValue sub(ExprValue A, ExprValue B) {
   // The distance between two symbols in sections is absolute.
   if (!A.isAbsolute() && !B.isAbsolute())
     return A.getValue() - B.getValue();
   return {A.Sec, false, A.getSectionOffset() - B.getValue(), A.Loc};
 }
 
 static ExprValue bitAnd(ExprValue A, ExprValue B) {
   moveAbsRight(A, B);
   return {A.Sec, A.ForceAbsolute,
           (A.getValue() & B.getValue()) - A.getSecAddr(), A.Loc};
 }
 
 static ExprValue bitOr(ExprValue A, ExprValue B) {
   moveAbsRight(A, B);
   return {A.Sec, A.ForceAbsolute,
           (A.getValue() | B.getValue()) - A.getSecAddr(), A.Loc};
 }
 
 void ScriptParser::readDynamicList() {
   Config->HasDynamicList = true;
   expect("{");
   std::vector<SymbolVersion> Locals;
   std::vector<SymbolVersion> Globals;
   std::tie(Locals, Globals) = readSymbols();
   expect(";");
 
   if (!atEOF()) {
     setError("EOF expected, but got " + next());
     return;
   }
   if (!Locals.empty()) {
     setError("\"local:\" scope not supported in --dynamic-list");
     return;
   }
 
   for (SymbolVersion V : Globals)
     Config->DynamicList.push_back(V);
 }
 
 void ScriptParser::readVersionScript() {
   readVersionScriptCommand();
   if (!atEOF())
     setError("EOF expected, but got " + next());
 }
 
 void ScriptParser::readVersionScriptCommand() {
   if (consume("{")) {
     readAnonymousDeclaration();
     return;
   }
 
   while (!atEOF() && !errorCount() && peek() != "}") {
     StringRef VerStr = next();
     if (VerStr == "{") {
       setError("anonymous version definition is used in "
                "combination with other version definitions");
       return;
     }
     expect("{");
     readVersionDeclaration(VerStr);
   }
 }
 
 void ScriptParser::readVersion() {
   expect("{");
   readVersionScriptCommand();
   expect("}");
 }
 
 void ScriptParser::readLinkerScript() {
   while (!atEOF()) {
     StringRef Tok = next();
     if (Tok == ";")
       continue;
 
     if (Tok == "ENTRY") {
       readEntry();
     } else if (Tok == "EXTERN") {
       readExtern();
     } else if (Tok == "GROUP") {
       readGroup();
     } else if (Tok == "INCLUDE") {
       readInclude();
     } else if (Tok == "INPUT") {
       readInput();
     } else if (Tok == "MEMORY") {
       readMemory();
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
     } else if (Tok == "PHDRS") {
       readPhdrs();
     } else if (Tok == "REGION_ALIAS") {
       readRegionAlias();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
     } else if (Tok == "SECTIONS") {
       readSections();
     } else if (Tok == "TARGET") {
       readTarget();
     } else if (Tok == "VERSION") {
       readVersion();
     } else if (SymbolAssignment *Cmd = readAssignment(Tok)) {
       Script->SectionCommands.push_back(Cmd);
     } else {
       setError("unknown directive: " + Tok);
     }
   }
 }
 
 void ScriptParser::readDefsym(StringRef Name) {
   if (errorCount())
     return;
   Expr E = readExpr();
   if (!atEOF())
     setError("EOF expected, but got " + next());
   SymbolAssignment *Cmd = make<SymbolAssignment>(Name, E, getCurrentLocation());
   Script->SectionCommands.push_back(Cmd);
 }
 
 void ScriptParser::addFile(StringRef S) {
   if (IsUnderSysroot && S.startswith("/")) {
     SmallString<128> PathData;
     StringRef Path = (Config->Sysroot + S).toStringRef(PathData);
     if (sys::fs::exists(Path)) {
       Driver->addFile(Saver.save(Path), /*WithLOption=*/false);
       return;
     }
   }
 
   if (S.startswith("/")) {
     Driver->addFile(S, /*WithLOption=*/false);
   } else if (S.startswith("=")) {
     if (Config->Sysroot.empty())
       Driver->addFile(S.substr(1), /*WithLOption=*/false);
     else
       Driver->addFile(Saver.save(Config->Sysroot + "/" + S.substr(1)),
                       /*WithLOption=*/false);
   } else if (S.startswith("-l")) {
     Driver->addLibrary(S.substr(2));
   } else if (sys::fs::exists(S)) {
     Driver->addFile(S, /*WithLOption=*/false);
   } else {
     if (Optional<std::string> Path = findFromSearchPaths(S))
       Driver->addFile(Saver.save(*Path), /*WithLOption=*/true);
     else
       setError("unable to find " + S);
   }
 }
 
 void ScriptParser::readAsNeeded() {
   expect("(");
   bool Orig = Config->AsNeeded;
   Config->AsNeeded = true;
   while (!errorCount() && !consume(")"))
     addFile(unquote(next()));
   Config->AsNeeded = Orig;
 }
 
 void ScriptParser::readEntry() {
   // -e <symbol> takes predecence over ENTRY(<symbol>).
   expect("(");
   StringRef Tok = next();
   if (Config->Entry.empty())
     Config->Entry = Tok;
   expect(")");
 }
 
 void ScriptParser::readExtern() {
   expect("(");
   while (!errorCount() && !consume(")"))
     Config->Undefined.push_back(next());
 }
 
 void ScriptParser::readGroup() {
   bool Orig = InputFile::IsInGroup;
   InputFile::IsInGroup = true;
   readInput();
   InputFile::IsInGroup = Orig;
   if (!Orig)
     ++InputFile::NextGroupId;
 }
 
 void ScriptParser::readInclude() {
   StringRef Tok = unquote(next());
 
   if (!Seen.insert(Tok).second) {
     setError("there is a cycle in linker script INCLUDEs");
     return;
   }
 
   if (Optional<std::string> Path = searchScript(Tok)) {
     if (Optional<MemoryBufferRef> MB = readFile(*Path))
       tokenize(*MB);
     return;
   }
   setError("cannot find linker script " + Tok);
 }
 
 void ScriptParser::readInput() {
   expect("(");
   while (!errorCount() && !consume(")")) {
     if (consume("AS_NEEDED"))
       readAsNeeded();
     else
       addFile(unquote(next()));
   }
 }
 
 void ScriptParser::readOutput() {
   // -o <file> takes predecence over OUTPUT(<file>).
   expect("(");
   StringRef Tok = next();
   if (Config->OutputFile.empty())
     Config->OutputFile = unquote(Tok);
   expect(")");
 }
 
 void ScriptParser::readOutputArch() {
   // OUTPUT_ARCH is ignored for now.
   expect("(");
   while (!errorCount() && !consume(")"))
     skip();
 }
 
 static std::pair<ELFKind, uint16_t> parseBfdName(StringRef S) {
   return StringSwitch<std::pair<ELFKind, uint16_t>>(S)
       .Case("elf32-i386", {ELF32LEKind, EM_386})
       .Case("elf32-iamcu", {ELF32LEKind, EM_IAMCU})
       .Case("elf32-littlearm", {ELF32LEKind, EM_ARM})
       .Case("elf32-x86-64", {ELF32LEKind, EM_X86_64})
       .Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64})
       .Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64})
+      .Case("elf32-powerpc", {ELF32BEKind, EM_PPC})
       .Case("elf64-powerpc", {ELF64BEKind, EM_PPC64})
       .Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64})
       .Case("elf64-x86-64", {ELF64LEKind, EM_X86_64})
-      .Case("elf32-tradbigmips", {ELF32BEKind, EM_MIPS})
+      .Cases("elf32-tradbigmips", "elf32-bigmips", {ELF32BEKind, EM_MIPS})
       .Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS})
       .Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS})
       .Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS})
       .Case("elf64-tradbigmips", {ELF64BEKind, EM_MIPS})
       .Case("elf64-tradlittlemips", {ELF64LEKind, EM_MIPS})
       .Default({ELFNoneKind, EM_NONE});
 }
 
 // Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(bfdname, big, little).
 // Currently we ignore big and little parameters.
 void ScriptParser::readOutputFormat() {
   expect("(");
 
   StringRef Name = unquote(next());
   StringRef S = Name;
   if (S.consume_back("-freebsd"))
     Config->OSABI = ELFOSABI_FREEBSD;
 
   std::tie(Config->EKind, Config->EMachine) = parseBfdName(S);
   if (Config->EMachine == EM_NONE)
     setError("unknown output format name: " + Name);
   if (S == "elf32-ntradlittlemips" || S == "elf32-ntradbigmips")
     Config->MipsN32Abi = true;
 
   if (consume(")"))
     return;
   expect(",");
   skip();
   expect(",");
   skip();
   expect(")");
 }
 
 void ScriptParser::readPhdrs() {
   expect("{");
 
   while (!errorCount() && !consume("}")) {
     PhdrsCommand Cmd;
     Cmd.Name = next();
     Cmd.Type = readPhdrType();
 
     while (!errorCount() && !consume(";")) {
       if (consume("FILEHDR"))
         Cmd.HasFilehdr = true;
       else if (consume("PHDRS"))
         Cmd.HasPhdrs = true;
       else if (consume("AT"))
         Cmd.LMAExpr = readParenExpr();
       else if (consume("FLAGS"))
         Cmd.Flags = readParenExpr()().getValue();
       else
         setError("unexpected header attribute: " + next());
     }
 
     Script->PhdrsCommands.push_back(Cmd);
   }
 }
 
 void ScriptParser::readRegionAlias() {
   expect("(");
   StringRef Alias = unquote(next());
   expect(",");
   StringRef Name = next();
   expect(")");
 
   if (Script->MemoryRegions.count(Alias))
     setError("redefinition of memory region '" + Alias + "'");
   if (!Script->MemoryRegions.count(Name))
     setError("memory region '" + Name + "' is not defined");
   Script->MemoryRegions.insert({Alias, Script->MemoryRegions[Name]});
 }
 
 void ScriptParser::readSearchDir() {
   expect("(");
   StringRef Tok = next();
   if (!Config->Nostdlib)
     Config->SearchPaths.push_back(unquote(Tok));
   expect(")");
 }
 
 // This reads an overlay description. Overlays are used to describe output
 // sections that use the same virtual memory range and normally would trigger
 // linker's sections sanity check failures.
 // https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description
 std::vector<BaseCommand *> ScriptParser::readOverlay() {
   // VA and LMA expressions are optional, though for simplicity of
   // implementation we assume they are not. That is what OVERLAY was designed
   // for first of all: to allow sections with overlapping VAs at different LMAs.
   Expr AddrExpr = readExpr();
   expect(":");
   expect("AT");
   Expr LMAExpr = readParenExpr();
   expect("{");
 
   std::vector<BaseCommand *> V;
   OutputSection *Prev = nullptr;
   while (!errorCount() && !consume("}")) {
     // VA is the same for all sections. The LMAs are consecutive in memory
     // starting from the base load address specified.
     OutputSection *OS = readOverlaySectionDescription();
     OS->AddrExpr = AddrExpr;
     if (Prev)
       OS->LMAExpr = [=] { return Prev->getLMA() + Prev->Size; };
     else
       OS->LMAExpr = LMAExpr;
     V.push_back(OS);
     Prev = OS;
   }
 
   // According to the specification, at the end of the overlay, the location
   // counter should be equal to the overlay base address plus size of the
   // largest section seen in the overlay.
   // Here we want to create the Dot assignment command to achieve that.
   Expr MoveDot = [=] {
     uint64_t Max = 0;
     for (BaseCommand *Cmd : V)
       Max = std::max(Max, cast<OutputSection>(Cmd)->Size);
     return AddrExpr().getValue() + Max;
   };
   V.push_back(make<SymbolAssignment>(".", MoveDot, getCurrentLocation()));
   return V;
 }
 
 void ScriptParser::readSections() {
   Script->HasSectionsCommand = true;
 
   // -no-rosegment is used to avoid placing read only non-executable sections in
   // their own segment. We do the same if SECTIONS command is present in linker
   // script. See comment for computeFlags().
   Config->SingleRoRx = true;
 
   expect("{");
   std::vector<BaseCommand *> V;
   while (!errorCount() && !consume("}")) {
     StringRef Tok = next();
     if (Tok == "OVERLAY") {
       for (BaseCommand *Cmd : readOverlay())
         V.push_back(Cmd);
       continue;
     } else if (Tok == "INCLUDE") {
       readInclude();
       continue;
     }
 
     if (BaseCommand *Cmd = readAssignment(Tok))
       V.push_back(Cmd);
     else
       V.push_back(readOutputSectionDescription(Tok));
   }
 
   if (!atEOF() && consume("INSERT")) {
     std::vector<BaseCommand *> *Dest = nullptr;
     if (consume("AFTER"))
       Dest = &Script->InsertAfterCommands[next()];
     else if (consume("BEFORE"))
       Dest = &Script->InsertBeforeCommands[next()];
     else
       setError("expected AFTER/BEFORE, but got '" + next() + "'");
     if (Dest)
       Dest->insert(Dest->end(), V.begin(), V.end());
     return;
   }
 
   Script->SectionCommands.insert(Script->SectionCommands.end(), V.begin(),
                                  V.end());
 }
 
 void ScriptParser::readTarget() {
   // TARGET(foo) is an alias for "--format foo". Unlike GNU linkers,
   // we accept only a limited set of BFD names (i.e. "elf" or "binary")
   // for --format. We recognize only /^elf/ and "binary" in the linker
   // script as well.
   expect("(");
   StringRef Tok = next();
   expect(")");
 
   if (Tok.startswith("elf"))
     Config->FormatBinary = false;
   else if (Tok == "binary")
     Config->FormatBinary = true;
   else
     setError("unknown target: " + Tok);
 }
 
 static int precedence(StringRef Op) {
   return StringSwitch<int>(Op)
       .Cases("*", "/", "%", 8)
       .Cases("+", "-", 7)
       .Cases("<<", ">>", 6)
       .Cases("<", "<=", ">", ">=", "==", "!=", 5)
       .Case("&", 4)
       .Case("|", 3)
       .Case("&&", 2)
       .Case("||", 1)
       .Default(-1);
 }
 
 StringMatcher ScriptParser::readFilePatterns() {
   std::vector<StringRef> V;
   while (!errorCount() && !consume(")"))
     V.push_back(next());
   return StringMatcher(V);
 }
 
 SortSectionPolicy ScriptParser::readSortKind() {
   if (consume("SORT") || consume("SORT_BY_NAME"))
     return SortSectionPolicy::Name;
   if (consume("SORT_BY_ALIGNMENT"))
     return SortSectionPolicy::Alignment;
   if (consume("SORT_BY_INIT_PRIORITY"))
     return SortSectionPolicy::Priority;
   if (consume("SORT_NONE"))
     return SortSectionPolicy::None;
   return SortSectionPolicy::Default;
 }
 
 // Reads SECTIONS command contents in the following form:
 //
 // <contents> ::= <elem>*
 // <elem>     ::= <exclude>? <glob-pattern>
 // <exclude>  ::= "EXCLUDE_FILE" "(" <glob-pattern>+ ")"
 //
 // For example,
 //
 // *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
 //
 // is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
 // The semantics of that is section .foo in any file, section .bar in
 // any file but a.o, and section .baz in any file but b.o.
 std::vector<SectionPattern> ScriptParser::readInputSectionsList() {
   std::vector<SectionPattern> Ret;
   while (!errorCount() && peek() != ")") {
     StringMatcher ExcludeFilePat;
     if (consume("EXCLUDE_FILE")) {
       expect("(");
       ExcludeFilePat = readFilePatterns();
     }
 
     std::vector<StringRef> V;
     while (!errorCount() && peek() != ")" && peek() != "EXCLUDE_FILE")
       V.push_back(next());
 
     if (!V.empty())
       Ret.push_back({std::move(ExcludeFilePat), StringMatcher(V)});
     else
       setError("section pattern is expected");
   }
   return Ret;
 }
 
 // Reads contents of "SECTIONS" directive. That directive contains a
 // list of glob patterns for input sections. The grammar is as follows.
 //
 // <patterns> ::= <section-list>
 //              | <sort> "(" <section-list> ")"
 //              | <sort> "(" <sort> "(" <section-list> ")" ")"
 //
 // <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
 //              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
 //
 // <section-list> is parsed by readInputSectionsList().
 InputSectionDescription *
 ScriptParser::readInputSectionRules(StringRef FilePattern) {
   auto *Cmd = make<InputSectionDescription>(FilePattern);
   expect("(");
 
   while (!errorCount() && !consume(")")) {
     SortSectionPolicy Outer = readSortKind();
     SortSectionPolicy Inner = SortSectionPolicy::Default;
     std::vector<SectionPattern> V;
     if (Outer != SortSectionPolicy::Default) {
       expect("(");
       Inner = readSortKind();
       if (Inner != SortSectionPolicy::Default) {
         expect("(");
         V = readInputSectionsList();
         expect(")");
       } else {
         V = readInputSectionsList();
       }
       expect(")");
     } else {
       V = readInputSectionsList();
     }
 
     for (SectionPattern &Pat : V) {
       Pat.SortInner = Inner;
       Pat.SortOuter = Outer;
     }
 
     std::move(V.begin(), V.end(), std::back_inserter(Cmd->SectionPatterns));
   }
   return Cmd;
 }
 
 InputSectionDescription *
 ScriptParser::readInputSectionDescription(StringRef Tok) {
   // Input section wildcard can be surrounded by KEEP.
   // https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
   if (Tok == "KEEP") {
     expect("(");
     StringRef FilePattern = next();
     InputSectionDescription *Cmd = readInputSectionRules(FilePattern);
     expect(")");
     Script->KeptSections.push_back(Cmd);
     return Cmd;
   }
   return readInputSectionRules(Tok);
 }
 
 void ScriptParser::readSort() {
   expect("(");
   expect("CONSTRUCTORS");
   expect(")");
 }
 
 Expr ScriptParser::readAssert() {
   expect("(");
   Expr E = readExpr();
   expect(",");
   StringRef Msg = unquote(next());
   expect(")");
 
   return [=] {
     if (!E().getValue())
       error(Msg);
     return Script->getDot();
   };
 }
 
 // Reads a FILL(expr) command. We handle the FILL command as an
 // alias for =fillexp section attribute, which is different from
 // what GNU linkers do.
 // https://sourceware.org/binutils/docs/ld/Output-Section-Data.html
 std::array<uint8_t, 4> ScriptParser::readFill() {
   expect("(");
   std::array<uint8_t, 4> V = parseFill(next());
   expect(")");
   return V;
 }
 
 // Tries to read the special directive for an output section definition which
 // can be one of following: "(NOLOAD)", "(COPY)", "(INFO)" or "(OVERLAY)".
 // Tok1 and Tok2 are next 2 tokens peeked. See comment for readSectionAddressType below.
 bool ScriptParser::readSectionDirective(OutputSection *Cmd, StringRef Tok1, StringRef Tok2) {
   if (Tok1 != "(")
     return false;
   if (Tok2 != "NOLOAD" && Tok2 != "COPY" && Tok2 != "INFO" && Tok2 != "OVERLAY")
     return false;
 
   expect("(");
   if (consume("NOLOAD")) {
     Cmd->Noload = true;
   } else {
     skip(); // This is "COPY", "INFO" or "OVERLAY".
     Cmd->NonAlloc = true;
   }
   expect(")");
   return true;
 }
 
 // Reads an expression and/or the special directive for an output
 // section definition. Directive is one of following: "(NOLOAD)",
 // "(COPY)", "(INFO)" or "(OVERLAY)".
 //
 // An output section name can be followed by an address expression
 // and/or directive. This grammar is not LL(1) because "(" can be
 // interpreted as either the beginning of some expression or beginning
 // of directive.
 //
 // https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
 // https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
 void ScriptParser::readSectionAddressType(OutputSection *Cmd) {
   if (readSectionDirective(Cmd, peek(), peek2()))
     return;
 
   Cmd->AddrExpr = readExpr();
   if (peek() == "(" && !readSectionDirective(Cmd, "(", peek2()))
     setError("unknown section directive: " + peek2());
 }
 
 static Expr checkAlignment(Expr E, std::string &Loc) {
   return [=] {
     uint64_t Alignment = std::max((uint64_t)1, E().getValue());
     if (!isPowerOf2_64(Alignment)) {
       error(Loc + ": alignment must be power of 2");
       return (uint64_t)1; // Return a dummy value.
     }
     return Alignment;
   };
 }
 
 OutputSection *ScriptParser::readOverlaySectionDescription() {
   OutputSection *Cmd =
       Script->createOutputSection(next(), getCurrentLocation());
   Cmd->InOverlay = true;
   expect("{");
   while (!errorCount() && !consume("}"))
     Cmd->SectionCommands.push_back(readInputSectionRules(next()));
   Cmd->Phdrs = readOutputSectionPhdrs();
   return Cmd;
 }
 
 OutputSection *ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   OutputSection *Cmd =
       Script->createOutputSection(OutSec, getCurrentLocation());
 
   size_t SymbolsReferenced = Script->ReferencedSymbols.size();
 
   if (peek() != ":")
     readSectionAddressType(Cmd);
   expect(":");
 
   std::string Location = getCurrentLocation();
   if (consume("AT"))
     Cmd->LMAExpr = readParenExpr();
   if (consume("ALIGN"))
     Cmd->AlignExpr = checkAlignment(readParenExpr(), Location);
   if (consume("SUBALIGN"))
     Cmd->SubalignExpr = checkAlignment(readParenExpr(), Location);
 
   // Parse constraints.
   if (consume("ONLY_IF_RO"))
     Cmd->Constraint = ConstraintKind::ReadOnly;
   if (consume("ONLY_IF_RW"))
     Cmd->Constraint = ConstraintKind::ReadWrite;
   expect("{");
 
   while (!errorCount() && !consume("}")) {
     StringRef Tok = next();
     if (Tok == ";") {
       // Empty commands are allowed. Do nothing here.
     } else if (SymbolAssignment *Assign = readAssignment(Tok)) {
       Cmd->SectionCommands.push_back(Assign);
     } else if (ByteCommand *Data = readByteCommand(Tok)) {
       Cmd->SectionCommands.push_back(Data);
     } else if (Tok == "CONSTRUCTORS") {
       // CONSTRUCTORS is a keyword to make the linker recognize C++ ctors/dtors
       // by name. This is for very old file formats such as ECOFF/XCOFF.
       // For ELF, we should ignore.
     } else if (Tok == "FILL") {
       Cmd->Filler = readFill();
     } else if (Tok == "SORT") {
       readSort();
     } else if (Tok == "INCLUDE") {
       readInclude();
     } else if (peek() == "(") {
       Cmd->SectionCommands.push_back(readInputSectionDescription(Tok));
     } else {
       // We have a file name and no input sections description. It is not a
       // commonly used syntax, but still acceptable. In that case, all sections
       // from the file will be included.
       auto *ISD = make<InputSectionDescription>(Tok);
       ISD->SectionPatterns.push_back({{}, StringMatcher({"*"})});
       Cmd->SectionCommands.push_back(ISD);
     }
   }
 
   if (consume(">"))
     Cmd->MemoryRegionName = next();
 
   if (consume("AT")) {
     expect(">");
     Cmd->LMARegionName = next();
   }
 
   if (Cmd->LMAExpr && !Cmd->LMARegionName.empty())
     error("section can't have both LMA and a load region");
 
   Cmd->Phdrs = readOutputSectionPhdrs();
 
   if (consume("="))
     Cmd->Filler = parseFill(next());
   else if (peek().startswith("="))
     Cmd->Filler = parseFill(next().drop_front());
 
   // Consume optional comma following output section command.
   consume(",");
 
   if (Script->ReferencedSymbols.size() > SymbolsReferenced)
     Cmd->ExpressionsUseSymbols = true;
   return Cmd;
 }
 
 // Parses a given string as a octal/decimal/hexadecimal number and
 // returns it as a big-endian number. Used for `=<fillexp>`.
 // https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
 //
 // When reading a hexstring, ld.bfd handles it as a blob of arbitrary
 // size, while ld.gold always handles it as a 32-bit big-endian number.
 // We are compatible with ld.gold because it's easier to implement.
 std::array<uint8_t, 4> ScriptParser::parseFill(StringRef Tok) {
   uint32_t V = 0;
   if (!to_integer(Tok, V))
     setError("invalid filler expression: " + Tok);
 
   std::array<uint8_t, 4> Buf;
   write32be(Buf.data(), V);
   return Buf;
 }
 
 SymbolAssignment *ScriptParser::readProvideHidden(bool Provide, bool Hidden) {
   expect("(");
   SymbolAssignment *Cmd = readSymbolAssignment(next());
   Cmd->Provide = Provide;
   Cmd->Hidden = Hidden;
   expect(")");
   return Cmd;
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Tok) {
   // Assert expression returns Dot, so this is equal to ".=."
   if (Tok == "ASSERT")
     return make<SymbolAssignment>(".", readAssert(), getCurrentLocation());
 
   size_t OldPos = Pos;
   SymbolAssignment *Cmd = nullptr;
   if (peek() == "=" || peek() == "+=")
     Cmd = readSymbolAssignment(Tok);
   else if (Tok == "PROVIDE")
     Cmd = readProvideHidden(true, false);
   else if (Tok == "HIDDEN")
     Cmd = readProvideHidden(false, true);
   else if (Tok == "PROVIDE_HIDDEN")
     Cmd = readProvideHidden(true, true);
 
   if (Cmd) {
     Cmd->CommandString =
         Tok.str() + " " +
         llvm::join(Tokens.begin() + OldPos, Tokens.begin() + Pos, " ");
     expect(";");
   }
   return Cmd;
 }
 
 SymbolAssignment *ScriptParser::readSymbolAssignment(StringRef Name) {
   StringRef Op = next();
   assert(Op == "=" || Op == "+=");
   Expr E = readExpr();
   if (Op == "+=") {
     std::string Loc = getCurrentLocation();
     E = [=] { return add(Script->getSymbolValue(Name, Loc), E()); };
   }
   return make<SymbolAssignment>(Name, E, getCurrentLocation());
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() {
   // Our lexer is context-aware. Set the in-expression bit so that
   // they apply different tokenization rules.
   bool Orig = InExpr;
   InExpr = true;
   Expr E = readExpr1(readPrimary(), 0);
   InExpr = Orig;
   return E;
 }
 
 Expr ScriptParser::combine(StringRef Op, Expr L, Expr R) {
   if (Op == "+")
     return [=] { return add(L(), R()); };
   if (Op == "-")
     return [=] { return sub(L(), R()); };
   if (Op == "*")
     return [=] { return L().getValue() * R().getValue(); };
   if (Op == "/") {
     std::string Loc = getCurrentLocation();
     return [=]() -> uint64_t {
       if (uint64_t RV = R().getValue())
         return L().getValue() / RV;
       error(Loc + ": division by zero");
       return 0;
     };
   }
   if (Op == "%") {
     std::string Loc = getCurrentLocation();
     return [=]() -> uint64_t {
       if (uint64_t RV = R().getValue())
         return L().getValue() % RV;
       error(Loc + ": modulo by zero");
       return 0;
     };
   }
   if (Op == "<<")
     return [=] { return L().getValue() << R().getValue(); };
   if (Op == ">>")
     return [=] { return L().getValue() >> R().getValue(); };
   if (Op == "<")
     return [=] { return L().getValue() < R().getValue(); };
   if (Op == ">")
     return [=] { return L().getValue() > R().getValue(); };
   if (Op == ">=")
     return [=] { return L().getValue() >= R().getValue(); };
   if (Op == "<=")
     return [=] { return L().getValue() <= R().getValue(); };
   if (Op == "==")
     return [=] { return L().getValue() == R().getValue(); };
   if (Op == "!=")
     return [=] { return L().getValue() != R().getValue(); };
   if (Op == "||")
     return [=] { return L().getValue() || R().getValue(); };
   if (Op == "&&")
     return [=] { return L().getValue() && R().getValue(); };
   if (Op == "&")
     return [=] { return bitAnd(L(), R()); };
   if (Op == "|")
     return [=] { return bitOr(L(), R()); };
   llvm_unreachable("invalid operator");
 }
 
 // This is a part of the operator-precedence parser. This function
 // assumes that the remaining token stream starts with an operator.
 Expr ScriptParser::readExpr1(Expr Lhs, int MinPrec) {
   while (!atEOF() && !errorCount()) {
     // Read an operator and an expression.
     if (consume("?"))
       return readTernary(Lhs);
     StringRef Op1 = peek();
     if (precedence(Op1) < MinPrec)
       break;
     skip();
     Expr Rhs = readPrimary();
 
     // Evaluate the remaining part of the expression first if the
     // next operator has greater precedence than the previous one.
     // For example, if we have read "+" and "3", and if the next
     // operator is "*", then we'll evaluate 3 * ... part first.
     while (!atEOF()) {
       StringRef Op2 = peek();
       if (precedence(Op2) <= precedence(Op1))
         break;
       Rhs = readExpr1(Rhs, precedence(Op2));
     }
 
     Lhs = combine(Op1, Lhs, Rhs);
   }
   return Lhs;
 }
 
 Expr ScriptParser::getPageSize() {
   std::string Location = getCurrentLocation();
   return [=]() -> uint64_t {
     if (Target)
       return Target->PageSize;
     error(Location + ": unable to calculate page size");
     return 4096; // Return a dummy value.
   };
 }
 
 Expr ScriptParser::readConstant() {
   StringRef S = readParenLiteral();
   if (S == "COMMONPAGESIZE")
     return getPageSize();
   if (S == "MAXPAGESIZE")
     return [] { return Config->MaxPageSize; };
   setError("unknown constant: " + S);
   return [] { return 0; };
 }
 
 // Parses Tok as an integer. It recognizes hexadecimal (prefixed with
 // "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
 // have "K" (Ki) or "M" (Mi) suffixes.
 static Optional<uint64_t> parseInt(StringRef Tok) {
   // Hexadecimal
   uint64_t Val;
   if (Tok.startswith_lower("0x")) {
     if (!to_integer(Tok.substr(2), Val, 16))
       return None;
     return Val;
   }
   if (Tok.endswith_lower("H")) {
     if (!to_integer(Tok.drop_back(), Val, 16))
       return None;
     return Val;
   }
 
   // Decimal
   if (Tok.endswith_lower("K")) {
     if (!to_integer(Tok.drop_back(), Val, 10))
       return None;
     return Val * 1024;
   }
   if (Tok.endswith_lower("M")) {
     if (!to_integer(Tok.drop_back(), Val, 10))
       return None;
     return Val * 1024 * 1024;
   }
   if (!to_integer(Tok, Val, 10))
     return None;
   return Val;
 }
 
 ByteCommand *ScriptParser::readByteCommand(StringRef Tok) {
   int Size = StringSwitch<int>(Tok)
                  .Case("BYTE", 1)
                  .Case("SHORT", 2)
                  .Case("LONG", 4)
                  .Case("QUAD", 8)
                  .Default(-1);
   if (Size == -1)
     return nullptr;
 
   size_t OldPos = Pos;
   Expr E = readParenExpr();
   std::string CommandString =
       Tok.str() + " " +
       llvm::join(Tokens.begin() + OldPos, Tokens.begin() + Pos, " ");
   return make<ByteCommand>(E, Size, CommandString);
 }
 
 StringRef ScriptParser::readParenLiteral() {
   expect("(");
   bool Orig = InExpr;
   InExpr = false;
   StringRef Tok = next();
   InExpr = Orig;
   expect(")");
   return Tok;
 }
 
 static void checkIfExists(OutputSection *Cmd, StringRef Location) {
   if (Cmd->Location.empty() && Script->ErrorOnMissingSection)
     error(Location + ": undefined section " + Cmd->Name);
 }
 
 Expr ScriptParser::readPrimary() {
   if (peek() == "(")
     return readParenExpr();
 
   if (consume("~")) {
     Expr E = readPrimary();
     return [=] { return ~E().getValue(); };
   }
   if (consume("!")) {
     Expr E = readPrimary();
     return [=] { return !E().getValue(); };
   }
   if (consume("-")) {
     Expr E = readPrimary();
     return [=] { return -E().getValue(); };
   }
 
   StringRef Tok = next();
   std::string Location = getCurrentLocation();
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ABSOLUTE") {
     Expr Inner = readParenExpr();
     return [=] {
       ExprValue I = Inner();
       I.ForceAbsolute = true;
       return I;
     };
   }
   if (Tok == "ADDR") {
     StringRef Name = readParenLiteral();
     OutputSection *Sec = Script->getOrCreateOutputSection(Name);
     return [=]() -> ExprValue {
       checkIfExists(Sec, Location);
       return {Sec, false, 0, Location};
     };
   }
   if (Tok == "ALIGN") {
     expect("(");
     Expr E = readExpr();
     if (consume(")")) {
       E = checkAlignment(E, Location);
       return [=] { return alignTo(Script->getDot(), E().getValue()); };
     }
     expect(",");
     Expr E2 = checkAlignment(readExpr(), Location);
     expect(")");
     return [=] {
       ExprValue V = E();
       V.Alignment = E2().getValue();
       return V;
     };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
     return [=] {
       checkIfExists(Cmd, Location);
       return Cmd->Alignment;
     };
   }
   if (Tok == "ASSERT")
     return readAssert();
   if (Tok == "CONSTANT")
     return readConstant();
   if (Tok == "DATA_SEGMENT_ALIGN") {
     expect("(");
     Expr E = readExpr();
     expect(",");
     readExpr();
     expect(")");
     return [=] {
       return alignTo(Script->getDot(), std::max((uint64_t)1, E().getValue()));
     };
   }
   if (Tok == "DATA_SEGMENT_END") {
     expect("(");
     expect(".");
     expect(")");
     return [] { return Script->getDot(); };
   }
   if (Tok == "DATA_SEGMENT_RELRO_END") {
     // GNU linkers implements more complicated logic to handle
     // DATA_SEGMENT_RELRO_END. We instead ignore the arguments and
     // just align to the next page boundary for simplicity.
     expect("(");
     readExpr();
     expect(",");
     readExpr();
     expect(")");
     Expr E = getPageSize();
     return [=] { return alignTo(Script->getDot(), E().getValue()); };
   }
   if (Tok == "DEFINED") {
     StringRef Name = readParenLiteral();
     return [=] { return Symtab->find(Name) ? 1 : 0; };
   }
   if (Tok == "LENGTH") {
     StringRef Name = readParenLiteral();
     if (Script->MemoryRegions.count(Name) == 0) {
       setError("memory region not defined: " + Name);
       return [] { return 0; };
     }
     return [=] { return Script->MemoryRegions[Name]->Length; };
   }
   if (Tok == "LOADADDR") {
     StringRef Name = readParenLiteral();
     OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
     return [=] {
       checkIfExists(Cmd, Location);
       return Cmd->getLMA();
     };
   }
   if (Tok == "MAX" || Tok == "MIN") {
     expect("(");
     Expr A = readExpr();
     expect(",");
     Expr B = readExpr();
     expect(")");
     if (Tok == "MIN")
       return [=] { return std::min(A().getValue(), B().getValue()); };
     return [=] { return std::max(A().getValue(), B().getValue()); };
   }
   if (Tok == "ORIGIN") {
     StringRef Name = readParenLiteral();
     if (Script->MemoryRegions.count(Name) == 0) {
       setError("memory region not defined: " + Name);
       return [] { return 0; };
     }
     return [=] { return Script->MemoryRegions[Name]->Origin; };
   }
   if (Tok == "SEGMENT_START") {
     expect("(");
     skip();
     expect(",");
     Expr E = readExpr();
     expect(")");
     return [=] { return E(); };
   }
   if (Tok == "SIZEOF") {
     StringRef Name = readParenLiteral();
     OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
     // Linker script does not create an output section if its content is empty.
     // We want to allow SIZEOF(.foo) where .foo is a section which happened to
     // be empty.
     return [=] { return Cmd->Size; };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=] { return elf::getHeaderSize(); };
 
   // Tok is the dot.
   if (Tok == ".")
     return [=] { return Script->getSymbolValue(Tok, Location); };
 
   // Tok is a literal number.
   if (Optional<uint64_t> Val = parseInt(Tok))
     return [=] { return *Val; };
 
   // Tok is a symbol name.
   if (!isValidCIdentifier(Tok))
     setError("malformed number: " + Tok);
   Script->ReferencedSymbols.push_back(Tok);
   return [=] { return Script->getSymbolValue(Tok, Location); };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();
   return [=] { return Cond().getValue() ? L() : R(); };
 }
 
 Expr ScriptParser::readParenExpr() {
   expect("(");
   Expr E = readExpr();
   expect(")");
   return E;
 }
 
 std::vector<StringRef> ScriptParser::readOutputSectionPhdrs() {
   std::vector<StringRef> Phdrs;
   while (!errorCount() && peek().startswith(":")) {
     StringRef Tok = next();
     Phdrs.push_back((Tok.size() == 1) ? next() : Tok.substr(1));
   }
   return Phdrs;
 }
 
 // Read a program header type name. The next token must be a
 // name of a program header type or a constant (e.g. "0x3").
 unsigned ScriptParser::readPhdrType() {
   StringRef Tok = next();
   if (Optional<uint64_t> Val = parseInt(Tok))
     return *Val;
 
   unsigned Ret = StringSwitch<unsigned>(Tok)
                      .Case("PT_NULL", PT_NULL)
                      .Case("PT_LOAD", PT_LOAD)
                      .Case("PT_DYNAMIC", PT_DYNAMIC)
                      .Case("PT_INTERP", PT_INTERP)
                      .Case("PT_NOTE", PT_NOTE)
                      .Case("PT_SHLIB", PT_SHLIB)
                      .Case("PT_PHDR", PT_PHDR)
                      .Case("PT_TLS", PT_TLS)
                      .Case("PT_GNU_EH_FRAME", PT_GNU_EH_FRAME)
                      .Case("PT_GNU_STACK", PT_GNU_STACK)
                      .Case("PT_GNU_RELRO", PT_GNU_RELRO)
                      .Case("PT_OPENBSD_RANDOMIZE", PT_OPENBSD_RANDOMIZE)
                      .Case("PT_OPENBSD_WXNEEDED", PT_OPENBSD_WXNEEDED)
                      .Case("PT_OPENBSD_BOOTDATA", PT_OPENBSD_BOOTDATA)
                      .Default(-1);
 
   if (Ret == (unsigned)-1) {
     setError("invalid program header type: " + Tok);
     return PT_NULL;
   }
   return Ret;
 }
 
 // Reads an anonymous version declaration.
 void ScriptParser::readAnonymousDeclaration() {
   std::vector<SymbolVersion> Locals;
   std::vector<SymbolVersion> Globals;
   std::tie(Locals, Globals) = readSymbols();
 
   for (SymbolVersion V : Locals) {
     if (V.Name == "*")
       Config->DefaultSymbolVersion = VER_NDX_LOCAL;
     else
       Config->VersionScriptLocals.push_back(V);
   }
 
   for (SymbolVersion V : Globals)
     Config->VersionScriptGlobals.push_back(V);
 
   expect(";");
 }
 
 // Reads a non-anonymous version definition,
 // e.g. "VerStr { global: foo; bar; local: *; };".
 void ScriptParser::readVersionDeclaration(StringRef VerStr) {
   // Read a symbol list.
   std::vector<SymbolVersion> Locals;
   std::vector<SymbolVersion> Globals;
   std::tie(Locals, Globals) = readSymbols();
 
   for (SymbolVersion V : Locals) {
     if (V.Name == "*")
       Config->DefaultSymbolVersion = VER_NDX_LOCAL;
     else
       Config->VersionScriptLocals.push_back(V);
   }
 
   // Create a new version definition and add that to the global symbols.
   VersionDefinition Ver;
   Ver.Name = VerStr;
   Ver.Globals = Globals;
 
   // User-defined version number starts from 2 because 0 and 1 are
   // reserved for VER_NDX_LOCAL and VER_NDX_GLOBAL, respectively.
   Ver.Id = Config->VersionDefinitions.size() + 2;
   Config->VersionDefinitions.push_back(Ver);
 
   // Each version may have a parent version. For example, "Ver2"
   // defined as "Ver2 { global: foo; local: *; } Ver1;" has "Ver1"
   // as a parent. This version hierarchy is, probably against your
   // instinct, purely for hint; the runtime doesn't care about it
   // at all. In LLD, we simply ignore it.
   if (peek() != ";")
     skip();
   expect(";");
 }
 
 static bool hasWildcard(StringRef S) {
   return S.find_first_of("?*[") != StringRef::npos;
 }
 
 // Reads a list of symbols, e.g. "{ global: foo; bar; local: *; };".
 std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
 ScriptParser::readSymbols() {
   std::vector<SymbolVersion> Locals;
   std::vector<SymbolVersion> Globals;
   std::vector<SymbolVersion> *V = &Globals;
 
   while (!errorCount()) {
     if (consume("}"))
       break;
     if (consumeLabel("local")) {
       V = &Locals;
       continue;
     }
     if (consumeLabel("global")) {
       V = &Globals;
       continue;
     }
 
     if (consume("extern")) {
       std::vector<SymbolVersion> Ext = readVersionExtern();
       V->insert(V->end(), Ext.begin(), Ext.end());
     } else {
       StringRef Tok = next();
       V->push_back({unquote(Tok), false, hasWildcard(Tok)});
     }
     expect(";");
   }
   return {Locals, Globals};
 }
 
 // Reads an "extern C++" directive, e.g.,
 // "extern "C++" { ns::*; "f(int, double)"; };"
 //
 // The last semicolon is optional. E.g. this is OK:
 // "extern "C++" { ns::*; "f(int, double)" };"
 std::vector<SymbolVersion> ScriptParser::readVersionExtern() {
   StringRef Tok = next();
   bool IsCXX = Tok == "\"C++\"";
   if (!IsCXX && Tok != "\"C\"")
     setError("Unknown language");
   expect("{");
 
   std::vector<SymbolVersion> Ret;
   while (!errorCount() && peek() != "}") {
     StringRef Tok = next();
     bool HasWildcard = !Tok.startswith("\"") && hasWildcard(Tok);
     Ret.push_back({unquote(Tok), IsCXX, HasWildcard});
     if (consume("}"))
       return Ret;
     expect(";");
   }
 
   expect("}");
   return Ret;
 }
 
 uint64_t ScriptParser::readMemoryAssignment(StringRef S1, StringRef S2,
                                             StringRef S3) {
   if (!consume(S1) && !consume(S2) && !consume(S3)) {
     setError("expected one of: " + S1 + ", " + S2 + ", or " + S3);
     return 0;
   }
   expect("=");
   return readExpr()().getValue();
 }
 
 // Parse the MEMORY command as specified in:
 // https://sourceware.org/binutils/docs/ld/MEMORY.html
 //
 // MEMORY { name [(attr)] : ORIGIN = origin, LENGTH = len ... }
 void ScriptParser::readMemory() {
   expect("{");
   while (!errorCount() && !consume("}")) {
     StringRef Tok = next();
     if (Tok == "INCLUDE") {
       readInclude();
       continue;
     }
 
     uint32_t Flags = 0;
     uint32_t NegFlags = 0;
     if (consume("(")) {
       std::tie(Flags, NegFlags) = readMemoryAttributes();
       expect(")");
     }
     expect(":");
 
     uint64_t Origin = readMemoryAssignment("ORIGIN", "org", "o");
     expect(",");
     uint64_t Length = readMemoryAssignment("LENGTH", "len", "l");
 
     // Add the memory region to the region map.
     MemoryRegion *MR = make<MemoryRegion>(Tok, Origin, Length, Flags, NegFlags);
     if (!Script->MemoryRegions.insert({Tok, MR}).second)
       setError("region '" + Tok + "' already defined");
   }
 }
 
 // This function parses the attributes used to match against section
 // flags when placing output sections in a memory region. These flags
 // are only used when an explicit memory region name is not used.
 std::pair<uint32_t, uint32_t> ScriptParser::readMemoryAttributes() {
   uint32_t Flags = 0;
   uint32_t NegFlags = 0;
   bool Invert = false;
 
   for (char C : next().lower()) {
     uint32_t Flag = 0;
     if (C == '!')
       Invert = !Invert;
     else if (C == 'w')
       Flag = SHF_WRITE;
     else if (C == 'x')
       Flag = SHF_EXECINSTR;
     else if (C == 'a')
       Flag = SHF_ALLOC;
     else if (C != 'r')
       setError("invalid memory region attribute");
 
     if (Invert)
       NegFlags |= Flag;
     else
       Flags |= Flag;
   }
   return {Flags, NegFlags};
 }
 
 void elf::readLinkerScript(MemoryBufferRef MB) {
   ScriptParser(MB).readLinkerScript();
 }
 
 void elf::readVersionScript(MemoryBufferRef MB) {
   ScriptParser(MB).readVersionScript();
 }
 
 void elf::readDynamicList(MemoryBufferRef MB) {
   ScriptParser(MB).readDynamicList();
 }
 
 void elf::readDefsym(StringRef Name, MemoryBufferRef MB) {
   ScriptParser(MB).readDefsym(Name);
 }
Index: vendor/lld/dist-release_80/docs/ReleaseNotes.rst
===================================================================
--- vendor/lld/dist-release_80/docs/ReleaseNotes.rst	(revision 344172)
+++ vendor/lld/dist-release_80/docs/ReleaseNotes.rst	(revision 344173)
@@ -1,90 +1,126 @@
 =======================
 lld 8.0.0 Release Notes
 =======================
 
 .. contents::
     :local:
 
 .. warning::
    These are in-progress notes for the upcoming LLVM 8.0.0 release.
    Release notes for previous releases can be found on
    `the Download Page <https://releases.llvm.org/download.html>`_.
 
 Introduction
 ============
 
-This document contains the release notes for the lld linker, release 8.0.0.
-Here we describe the status of lld, including major improvements
-from the previous release. All lld releases may be downloaded
-from the `LLVM releases web site <https://llvm.org/releases/>`_.
+lld is a high-performance linker that supports ELF (Unix), COFF (Windows),
+Mach-O (macOS), MinGW and WebAssembly. lld is command-line-compatible with
+GNU linkers and Microsoft link.exe and is significantly faster than the
+system default linkers.
 
+nlld 8.0.0 has lots of feature improvements and bug fixes.
+
 Non-comprehensive list of changes in this release
 =================================================
 
 ELF Improvements
 ----------------
 
 * lld now supports RISC-V. (`r339364
   <https://reviews.llvm.org/rL339364>`_)
 
 * Default image base address has changed from 65536 to 2 MiB for i386
   and 4 MiB for AArch64 to make lld-generated executables work better
   with automatic superpage promotion. FreeBSD can promote contiguous
   non-superpages to a superpage if they are aligned to the superpage
   size. (`r342746 <https://reviews.llvm.org/rL342746>`_)
 
+* lld now attempts to place a ``.note`` segment in the first page of a
+  generated file, so that you can find some important information
+  (``.note.gnu.build-id`` in particular) in a core file even if a core
+  file is truncated by ulimit.
+  (`r349524 <https://reviews.llvm.org/rL349524>`_)
+
+* lld now reports an error if ``_GLOBAL_OFFSET_TABLE_`` symbol is
+  defined by an input object file, as the symbol is supposed to be
+  synthesized by the linker.
+  (`r347854 <https://reviews.llvm.org/rL347854>`_)
+
 * lld/Hexagon can now link Linux kernel and musl libc for Qualcomm
   Hexagon ISA.
 
 * Initial MSP430 ISA support has landed.
 
-* The following flags have been added: ``-z interpose``, ``-z global``
-
 * lld now uses the ``sigrie`` instruction as a trap instruction for
   MIPS targets.
 
+* lld now creates a TLS segment for AArch64 with a slightly larger
+  alignment requirement, so that the loader makes a few bytes room
+  before each TLS segment at runtime. The aim of this change is to
+  make room to accomodate nonstandard Android TLS slots while keeping
+  the compatibility with the standard AArch64 ABI.
+  (`r350681 <https://reviews.llvm.org/rL350681>`_)
+
+* The following flags have been added: ``--call-graph-profile``,
+  ``--no-call-graph-profile``, ``--warn-ifunc-textrel``,
+  ``-z interpose``, ``-z global``, ``-z nodefaultlib``
+
 COFF Improvements
 -----------------
 
 * PDB GUID is set to hash of PDB contents instead to a random byte
   sequence for build reproducibility.
 
+* ``/pdbsourcepath:`` is now also used to make ``"cwd"``, ``"exe"``, ``"pdb"``
+  in the env block of PDB outputs absolute if they are relative, and to make
+  paths to obj files referenced in PDB outputs absolute if they are relative.
+  Together with the previous item, this makes it possible to generate
+  executables and PDBs that are fully deterministic and independent of the
+  absolute path to the build directory, so that different machines building
+  the same code in different directories can produce exactly the same output.
+
 * The following flags have been added: ``/force:multiple``
 
 * lld now can link against import libraries produced by GNU tools.
 
-* lld can create thunks for ARM, to allow linking images over 16 MB.
+* lld can create thunks for ARM and ARM64, to allow linking larger images
+  (over 16 MB for ARM and over 128 MB for ARM64)
 
+* Several speed and memory usage improvements.
+
+* lld now creates debug info for typedefs.
+
+* lld can now link obj files produced by ``cl.exe /Z7 /Yc``.
+
+* lld now understands ``%_PDB%`` and ``%_EXT%`` in ``/pdbaltpath:``.
+
+* Undefined symbols are now printed in demangled form in addition to raw form.
+
 MinGW Improvements
 ------------------
 
 * lld can now automatically import data variables from DLLs without the
   use of the dllimport attribute.
 
 * lld can now use existing normal MinGW sysroots with import libraries and
   CRT startup object files for GNU binutils. lld can handle most object
   files produced by GCC, and thus works as a drop-in replacement for
   ld.bfd in such environments. (There are known issues with linking crtend.o
   from GCC in setups with DWARF exceptions though, where object files are
   linked in a different order than with GNU ld, inserting a DWARF exception
   table terminator too early.)
 
 * lld now supports COFF embedded directives for linking to nondefault
   libraries, just like for the normal COFF target.
 
 * Actually generate a codeview build id signature, even if not creating a PDB.
   Previously, the ``--build-id`` option did not actually generate a build id
   unless ``--pdb`` was specified.
-
-MachO Improvements
-------------------
-
-* Item 1.
 
 WebAssembly Improvements
 ------------------------
 
 * Add initial support for creating shared libraries (-shared).
   Note: The shared library format is still under active development and may
   undergo significant changes in future versions.
   See: https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
Index: vendor/lld/dist-release_80/docs/index.rst
===================================================================
--- vendor/lld/dist-release_80/docs/index.rst	(revision 344172)
+++ vendor/lld/dist-release_80/docs/index.rst	(revision 344173)
@@ -1,176 +1,177 @@
 LLD - The LLVM Linker
 =====================
 
 LLD is a linker from the LLVM project that is a drop-in replacement
 for system linkers and runs much faster than them. It also provides
 features that are useful for toolchain developers.
 
 The linker supports ELF (Unix), PE/COFF (Windows), Mach-O (macOS) and
 WebAssembly in descending order of completeness. Internally, LLD consists of
 several different linkers. The ELF port is the one that will be described in
 this document. The PE/COFF port is complete, including
 Windows debug info (PDB) support. The WebAssembly port is still a work in
 progress (See :doc:`WebAssembly`).  The Mach-O port is built based on a
 different architecture than the others. For the details about Mach-O, please
 read :doc:`AtomLLD`.
 
 Features
 --------
 
 - LLD is a drop-in replacement for the GNU linkers that accepts the
   same command line arguments and linker scripts as GNU.
 
   We are currently working closely with the FreeBSD project to make
   LLD default system linker in future versions of the operating
   system, so we are serious about addressing compatibility issues. As
   of February 2017, LLD is able to link the entire FreeBSD/amd64 base
   system including the kernel. With a few work-in-progress patches it
   can link approximately 95% of the ports collection on AMD64. For the
   details, see `FreeBSD quarterly status report
   <https://www.freebsd.org/news/status/report-2016-10-2016-12.html#Using-LLVM%27s-LLD-Linker-as-FreeBSD%27s-System-Linker>`_.
 
 - LLD is very fast. When you link a large program on a multicore
   machine, you can expect that LLD runs more than twice as fast as the GNU
   gold linker. Your milage may vary, though.
 
 - It supports various CPUs/ABIs including x86-64, x86, x32, AArch64,
   ARM, MIPS 32/64 big/little-endian, PowerPC, PowerPC 64 and AMDGPU.
   Among these, x86-64, AArch64, and ARM (>= v6) are production quality.
   MIPS seems decent too. x86 should be OK but is not well tested yet.
 
 - It is always a cross-linker, meaning that it always supports all the
   above targets however it was built. In fact, we don't provide a
   build-time option to enable/disable each target. This should make it
   easy to use our linker as part of a cross-compile toolchain.
 
 - You can embed LLD in your program to eliminate dependencies on
   external linkers. All you have to do is to construct object files
   and command line arguments just like you would do to invoke an
   external linker and then call the linker's main function,
   ``lld::elf::link``, from your code.
 
 - It is small. We are using LLVM libObject library to read from object
   files, so it is not a completely fair comparison, but as of February
   2017, LLD/ELF consists only of 21k lines of C++ code while GNU gold
   consists of 198k lines of C++ code.
 
 - Link-time optimization (LTO) is supported by default. Essentially,
   all you have to do to do LTO is to pass the ``-flto`` option to clang.
   Then clang creates object files not in the native object file format
   but in LLVM bitcode format. LLD reads bitcode object files, compile
   them using LLVM and emit an output file. Because in this way LLD can
   see the entire program, it can do the whole program optimization.
 
 - Some very old features for ancient Unix systems (pre-90s or even
   before that) have been removed. Some default settings have been
   tuned for the 21st century. For example, the stack is marked as
   non-executable by default to tighten security.
 
 Performance
 -----------
 
 This is a link time comparison on a 2-socket 20-core 40-thread Xeon
 E5-2680 2.80 GHz machine with an SSD drive. We ran gold and lld with
 or without multi-threading support. To disable multi-threading, we
 added ``-no-threads`` to the command lines.
 
 ============  ===========  ============  ====================  ==================  ===============  =============
 Program       Output size  GNU ld        GNU gold w/o threads  GNU gold w/threads  lld w/o threads  lld w/threads
 ffmpeg dbg    92 MiB       1.72s         1.16s                 1.01s               0.60s            0.35s
 mysqld dbg    154 MiB      8.50s         2.96s                 2.68s               1.06s            0.68s
 clang dbg     1.67 GiB     104.03s       34.18s                23.49s              14.82s           5.28s
 chromium dbg  1.14 GiB     209.05s [1]_  64.70s                60.82s              27.60s           16.70s
 ============  ===========  ============  ====================  ==================  ===============  =============
 
 As you can see, lld is significantly faster than GNU linkers.
 Note that this is just a benchmark result of our environment.
 Depending on number of available cores, available amount of memory or
 disk latency/throughput, your results may vary.
 
 .. [1] Since GNU ld doesn't support the ``-icf=all`` and
        ``-gdb-index`` options, we removed them from the command line
        for GNU ld. GNU ld would have been slower than this if it had
        these options.
 
 Build
 -----
 
 If you have already checked out LLVM using SVN, you can check out LLD
 under ``tools`` directory just like you probably did for clang. For the
 details, see `Getting Started with the LLVM System
 <http://llvm.org/docs/GettingStarted.html>`_.
 
 If you haven't checked out LLVM, the easiest way to build LLD is to
 check out the entire LLVM projects/sub-projects from a git mirror and
 build that tree. You need `cmake` and of course a C++ compiler.
 
 .. code-block:: console
 
   $ git clone https://github.com/llvm-project/llvm-project-20170507 llvm-project
   $ mkdir build
   $ cd build
   $ cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS=lld -DCMAKE_INSTALL_PREFIX=/usr/local ../llvm-project/llvm
   $ make install
 
 Using LLD
 ---------
 
 LLD is installed as ``ld.lld``. On Unix, linkers are invoked by
 compiler drivers, so you are not expected to use that command
 directly. There are a few ways to tell compiler drivers to use ld.lld
 instead of the default linker.
 
 The easiest way to do that is to overwrite the default linker. After
 installing LLD to somewhere on your disk, you can create a symbolic
 link by doing ``ln -s /path/to/ld.lld /usr/bin/ld`` so that
 ``/usr/bin/ld`` is resolved to LLD.
 
 If you don't want to change the system setting, you can use clang's
 ``-fuse-ld`` option. In this way, you want to set ``-fuse-ld=lld`` to
 LDFLAGS when building your programs.
 
 LLD leaves its name and version number to a ``.comment`` section in an
 output. If you are in doubt whether you are successfully using LLD or
 not, run ``readelf --string-dump .comment <output-file>`` and examine the
 output. If the string "Linker: LLD" is included in the output, you are
 using LLD.
 
 History
 -------
 
 Here is a brief project history of the ELF and COFF ports.
 
 - May 2015: We decided to rewrite the COFF linker and did that.
   Noticed that the new linker is much faster than the MSVC linker.
 
 - July 2015: The new ELF port was developed based on the COFF linker
   architecture.
 
 - September 2015: The first patches to support MIPS and AArch64 landed.
 
 - October 2015: Succeeded to self-host the ELF port. We have noticed
   that the linker was faster than the GNU linkers, but we weren't sure
   at the time if we would be able to keep the gap as we would add more
   features to the linker.
 
 - July 2016: Started working on improving the linker script support.
 
 - December 2016: Succeeded to build the entire FreeBSD base system
   including the kernel. We had widen the performance gap against the
   GNU linkers.
 
 Internals
 ---------
 
 For the internals of the linker, please read :doc:`NewLLD`. It is a bit
 outdated but the fundamental concepts remain valid. We'll update the
 document soon.
 
 .. toctree::
    :maxdepth: 1
 
    NewLLD
    AtomLLD
    WebAssembly
    windows_support
+   missingkeyfunction
    ReleaseNotes
Index: vendor/lld/dist-release_80/docs/missingkeyfunction.rst
===================================================================
--- vendor/lld/dist-release_80/docs/missingkeyfunction.rst	(revision 344172)
+++ vendor/lld/dist-release_80/docs/missingkeyfunction.rst	(revision 344173)
@@ -1,84 +1,84 @@
-Missing Key Method
-==================
+Missing Key Function
+====================
 
 If your build failed with a linker error something like this::
 
   foo.cc:28: error: undefined reference to 'vtable for C'
   the vtable symbol may be undefined because the class is missing its key function (see https://lld.llvm.org/missingkeyfunction)
 
 it's likely that your class C has a key function (defined by the ABI as the first
 non-pure, non-inline, virtual method), but you haven't actually defined it.
 
 When a class has a key function, the compiler emits the vtable (and some other
 things as well) only in the translation unit that defines that key function. Thus,
 if you're missing the key function, you'll also be missing the vtable. If no other
 function calls your missing method, you won't see any undefined reference errors
 for it, but you will see undefined references to the vtable symbol.
 
 When a class has no non-pure, non-inline, virtual methods, there is no key
 method, and the compiler is forced to emit the vtable in every translation unit
 that references the class. In this case, it is emitted in a COMDAT section,
 which allows the linker to eliminate all duplicate copies. This is still
 wasteful in terms of object file size and link time, so it's always advisable to
 ensure there is at least one eligible method that can serve as the key function.
 
 Here are the most common mistakes that lead to this error:
 
 Failing to define a virtual destructor
 --------------------------------------
 
 Say you have a base class declared in a header file::
 
   class B {
   public:
     B();
     virtual ~B();
     ...
   };
 
 Here, ``~B`` is the first non-pure, non-inline, virtual method, so it is the key
 method. If you forget to define ``B::~B`` in your source file, the compiler will
 not emit the vtable for ``B``, and you'll get an undefined reference to "vtable
 for B".
 
 This is just an example of the more general mistake of forgetting to define the
 key function, but it's quite common because virtual destructors are likely to be
 the first eligible key function and it's easy to forget to implement them. It's
 also more likely that you won't have any direct references to the destructor, so
 you won't see any undefined reference errors that point directly to the problem.
 
 The solution in this case is to implement the missing method.
 
 Forgetting to declare a virtual method in an abstract class as pure
 -------------------------------------------------------------------
 
 Say you have an abstract base class declared in a header file::
 
   class A {
   public:
     A();
     virtual ~A() {}
     virtual int foo() = 0;
     ...
     virtual int bar();
     ...
   };
 
 This base class is intended to be abstract, but you forgot to mark one of the
 methods pure. Here, ``A::bar``, being non-pure, is nominated as the key function,
 and as a result, the vtable for ``A`` is not emitted, because the compiler is
 waiting for a translation unit that defines ``A::bar``.
 
 The solution in this case is to add the missing ``= 0`` to the declaration of
 ``A::bar``.
 
 Key method is defined, but the linker doesn't see it
 ----------------------------------------------------
 
 It's also possible that you have defined the key function somewhere, but the
 object file containing the definition of that method isn't being linked into
 your application.
 
 The solution in this case is to check your dependencies to make sure that
 the object file or the library file containing the key function is given to
 the linker.
Index: vendor/lld/dist-release_80/test/COFF/pdb-relative-source-lines.test
===================================================================
--- vendor/lld/dist-release_80/test/COFF/pdb-relative-source-lines.test	(revision 344172)
+++ vendor/lld/dist-release_80/test/COFF/pdb-relative-source-lines.test	(revision 344173)
@@ -1,105 +1,105 @@
 Test the linker line tables on roughly the following example:
 
 ==> foo.h <==
 void bar(void);
 inline void foo(void) {
   bar();
 }
 ==> pdb_lines_1.c <==
 #include "foo.h"
 int main(void) {
   foo();
   return 42;
 }
 ==> pdb_lines_2.c <==
 void bar(void) {
 }
 
 $ clang-cl -Xclang -fdebug-compilation-dir -Xclang . -c -Z7 pdb_lines*.c
 
 /pdbsourcepath: only sets the directory that relative paths are considered
 relative to, so this test needs to pass relative paths to lld-link for:
 1. The input obj files
 2. The /pdb: switch
 3. The lld-link invocation itself
 To achieve this, put all inputs of the lld-link invocation (including lld-link
 itself) in a temp directory that's cwd and then make sure to only use relative
 arguments when calling ./lld-link below.
 RUN: rm -rf %t
 RUN: mkdir %t
 RUN: cp lld-link %t/lld-link
 RUN: cd %t
 
 RUN: yaml2obj %S/Inputs/pdb_lines_1_relative.yaml -o %t/pdb_lines_1_relative.obj
 RUN: yaml2obj %S/Inputs/pdb_lines_2_relative.yaml -o %t/pdb_lines_2_relative.obj
 RUN: ./lld-link -debug "-pdbsourcepath:c:\src" -entry:main -nodefaultlib -out:out.exe -pdb:out.pdb pdb_lines_1_relative.obj pdb_lines_2_relative.obj
 RUN: llvm-pdbutil pdb2yaml -modules -module-files -module-syms -subsections=lines,fc %t/out.pdb | FileCheck %s
 RUN: ./lld-link -debug "-pdbsourcepath:/usr/src" -entry:main -nodefaultlib -out:out.exe -pdb:out.pdb pdb_lines_1_relative.obj pdb_lines_2_relative.obj
 RUN: llvm-pdbutil pdb2yaml -modules -module-files -module-syms -subsections=lines,fc %t/out.pdb | FileCheck --check-prefix=POSIX %s
 
-CHECK-LABEL:  - Module:          'c:\src{{[\\/]}}pdb_lines_1_relative.obj'
-CHECK-NEXT:     ObjFile:         'c:\src{{[\\/]}}pdb_lines_1_relative.obj'
+CHECK-LABEL:  - Module:          'c:\src\pdb_lines_1_relative.obj'
+CHECK-NEXT:     ObjFile:         'c:\src\pdb_lines_1_relative.obj'
 CHECK:          SourceFiles:
-CHECK-NEXT:       - 'c:\src{{[\\/]}}pdb_lines_1.c'
-CHECK-NEXT:       - 'c:\src{{[\\/]}}foo.h'
+CHECK-NEXT:       - 'c:\src\pdb_lines_1.c'
+CHECK-NEXT:       - 'c:\src\foo.h'
 CHECK:          Subsections:
-CHECK:                - FileName:        'c:\src{{[\\/]}}pdb_lines_1.c'
-CHECK:                - FileName:        'c:\src{{[\\/]}}foo.h'
+CHECK:                - FileName:        'c:\src\pdb_lines_1.c'
+CHECK:                - FileName:        'c:\src\foo.h'
 CHECK:            - !FileChecksums
-CHECK:                - FileName:        'c:\src{{[\\/]}}pdb_lines_1.c'
-CHECK:                - FileName:        'c:\src{{[\\/]}}foo.h'
+CHECK:                - FileName:        'c:\src\pdb_lines_1.c'
+CHECK:                - FileName:        'c:\src\foo.h'
 
-CHECK-LABEL:  - Module:          'c:\src{{[\\/]}}pdb_lines_2_relative.obj'
-CHECK-NEXT:     ObjFile:         'c:\src{{[\\/]}}pdb_lines_2_relative.obj'
+CHECK-LABEL:  - Module:          'c:\src\pdb_lines_2_relative.obj'
+CHECK-NEXT:     ObjFile:         'c:\src\pdb_lines_2_relative.obj'
 CHECK:          SourceFiles:
-CHECK-NEXT:       - 'c:\src{{[\\/]}}pdb_lines_2.c'
+CHECK-NEXT:       - 'c:\src\pdb_lines_2.c'
 CHECK:          Subsections:
-CHECK:                - FileName:        'c:\src{{[\\/]}}pdb_lines_2.c'
+CHECK:                - FileName:        'c:\src\pdb_lines_2.c'
 CHECK:            - !FileChecksums
-CHECK:                - FileName:        'c:\src{{[\\/]}}pdb_lines_2.c'
+CHECK:                - FileName:        'c:\src\pdb_lines_2.c'
 
 CHECK-LABEL:  - Kind:            S_ENVBLOCK
 CHECK-NEXT:     EnvBlockSym:     
 CHECK-NEXT:       Entries:     
 CHECK-NEXT:         - cwd
 CHECK-NEXT:         - 'c:\src'
 CHECK-NEXT:         - exe
-CHECK-NEXT:         - 'c:\src{{[\\/]}}lld-link'
+CHECK-NEXT:         - 'c:\src\lld-link'
 CHECK-NEXT:         - pdb 
-CHECK-NEXT:         - 'c:\src{{[\\/]}}out.pdb'
+CHECK-NEXT:         - 'c:\src\out.pdb'
 CHECK-NEXT:         - cmd
 CHECK-NEXT:         - '-debug -pdbsourcepath:c:\src -entry:main -nodefaultlib -out:out.exe -pdb:out.pdb pdb_lines_1_relative.obj pdb_lines_2_relative.obj'
 
 
-POSIX-LABEL:  - Module:          '/usr/src{{[\\/]}}pdb_lines_1_relative.obj'
-POSIX-NEXT:     ObjFile:         '/usr/src{{[\\/]}}pdb_lines_1_relative.obj'
+POSIX-LABEL:  - Module:          '/usr/src/pdb_lines_1_relative.obj'
+POSIX-NEXT:     ObjFile:         '/usr/src/pdb_lines_1_relative.obj'
 POSIX:          SourceFiles:
-POSIX-NEXT:       - '/usr/src{{[\\/]}}pdb_lines_1.c'
-POSIX-NEXT:       - '/usr/src{{[\\/]}}foo.h'
+POSIX-NEXT:       - '/usr/src/pdb_lines_1.c'
+POSIX-NEXT:       - '/usr/src/foo.h'
 POSIX:          Subsections:
-POSIX:                - FileName:        '/usr/src{{[\\/]}}pdb_lines_1.c'
-POSIX:                - FileName:        '/usr/src{{[\\/]}}foo.h'
+POSIX:                - FileName:        '/usr/src/pdb_lines_1.c'
+POSIX:                - FileName:        '/usr/src/foo.h'
 POSIX:            - !FileChecksums
-POSIX:                - FileName:        '/usr/src{{[\\/]}}pdb_lines_1.c'
-POSIX:                - FileName:        '/usr/src{{[\\/]}}foo.h'
+POSIX:                - FileName:        '/usr/src/pdb_lines_1.c'
+POSIX:                - FileName:        '/usr/src/foo.h'
 
-POSIX-LABEL:  - Module:          '/usr/src{{[\\/]}}pdb_lines_2_relative.obj'
-POSIX-NEXT:     ObjFile:         '/usr/src{{[\\/]}}pdb_lines_2_relative.obj'
+POSIX-LABEL:  - Module:          '/usr/src/pdb_lines_2_relative.obj'
+POSIX-NEXT:     ObjFile:         '/usr/src/pdb_lines_2_relative.obj'
 POSIX:          SourceFiles:
-POSIX-NEXT:       - '/usr/src{{[\\/]}}pdb_lines_2.c'
+POSIX-NEXT:       - '/usr/src/pdb_lines_2.c'
 POSIX:          Subsections:
-POSIX:                - FileName:        '/usr/src{{[\\/]}}pdb_lines_2.c'
+POSIX:                - FileName:        '/usr/src/pdb_lines_2.c'
 POSIX:            - !FileChecksums
-POSIX:                - FileName:        '/usr/src{{[\\/]}}pdb_lines_2.c'
+POSIX:                - FileName:        '/usr/src/pdb_lines_2.c'
 
 POSIX-LABEL:  - Kind:            S_ENVBLOCK
 POSIX-NEXT:     EnvBlockSym:     
 POSIX-NEXT:       Entries:     
 POSIX-NEXT:         - cwd
 POSIX-NEXT:         - '/usr/src'
 POSIX-NEXT:         - exe
-POSIX-NEXT:         - '/usr/src{{[\\/]}}lld-link'
+POSIX-NEXT:         - '/usr/src/lld-link'
 POSIX-NEXT:         - pdb 
-POSIX-NEXT:         - '/usr/src{{[\\/]}}out.pdb'
+POSIX-NEXT:         - '/usr/src/out.pdb'
 POSIX-NEXT:         - cmd
 POSIX-NEXT:         - '-debug -pdbsourcepath:/usr/src -entry:main -nodefaultlib -out:out.exe -pdb:out.pdb pdb_lines_1_relative.obj pdb_lines_2_relative.obj'
Index: vendor/lld/dist-release_80/test/ELF/emulation-mips.s
===================================================================
--- vendor/lld/dist-release_80/test/ELF/emulation-mips.s	(revision 344172)
+++ vendor/lld/dist-release_80/test/ELF/emulation-mips.s	(revision 344173)
@@ -1,189 +1,192 @@
 # REQUIRES: mips
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %tmips
 # RUN: ld.lld -m elf32btsmip -e _start %tmips -o %t2mips
 # RUN: llvm-readobj -file-headers %t2mips | FileCheck --check-prefix=MIPS %s
 # RUN: ld.lld %tmips -e _start -o %t3mips
 # RUN: llvm-readobj -file-headers %t3mips | FileCheck --check-prefix=MIPS %s
 # RUN: echo 'OUTPUT_FORMAT(elf32-tradbigmips)' > %tmips.script
 # RUN: ld.lld %tmips.script -e _start %tmips -o %t4mips
 # RUN: llvm-readobj -file-headers %t4mips | FileCheck --check-prefix=MIPS %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-bigmips)' > %tmips2.script
+# RUN: ld.lld %tmips2.script -e _start %tmips -o %t5mips
+# RUN: llvm-readobj -file-headers %t5mips | FileCheck --check-prefix=MIPS %s
 # MIPS:      ElfHeader {
 # MIPS-NEXT:   Ident {
 # MIPS-NEXT:     Magic: (7F 45 4C 46)
 # MIPS-NEXT:     Class: 32-bit (0x1)
 # MIPS-NEXT:     DataEncoding: BigEndian (0x2)
 # MIPS-NEXT:     FileVersion: 1
 # MIPS-NEXT:     OS/ABI: SystemV (0x0)
 # MIPS-NEXT:     ABIVersion: 1
 # MIPS-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPS-NEXT:   }
 # MIPS-NEXT:   Type: Executable (0x2)
 # MIPS-NEXT:   Machine: EM_MIPS (0x8)
 # MIPS-NEXT:   Version: 1
 # MIPS-NEXT:   Entry:
 # MIPS-NEXT:   ProgramHeaderOffset: 0x34
 # MIPS-NEXT:   SectionHeaderOffset:
 # MIPS-NEXT:   Flags [
 # MIPS-NEXT:     EF_MIPS_ABI_O32
 # MIPS-NEXT:     EF_MIPS_ARCH_32
 # MIPS-NEXT:     EF_MIPS_CPIC
 # MIPS-NEXT:   ]
 
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux %s -o %tmipsel
 # RUN: ld.lld -m elf32ltsmip -e _start %tmipsel -o %t2mipsel
 # RUN: llvm-readobj -file-headers %t2mipsel | FileCheck --check-prefix=MIPSEL %s
 # RUN: ld.lld -melf32ltsmip -e _start %tmipsel -o %t2mipsel
 # RUN: llvm-readobj -file-headers %t2mipsel | FileCheck --check-prefix=MIPSEL %s
 # RUN: ld.lld %tmipsel -e _start -o %t3mipsel
 # RUN: llvm-readobj -file-headers %t3mipsel | FileCheck --check-prefix=MIPSEL %s
 # RUN: echo 'OUTPUT_FORMAT(elf32-tradlittlemips)' > %tmipsel.script
 # RUN: ld.lld %tmipsel.script -e _start %tmipsel -o %t4mipsel
 # RUN: llvm-readobj -file-headers %t4mipsel | FileCheck --check-prefix=MIPSEL %s
 # MIPSEL:      ElfHeader {
 # MIPSEL-NEXT:   Ident {
 # MIPSEL-NEXT:     Magic: (7F 45 4C 46)
 # MIPSEL-NEXT:     Class: 32-bit (0x1)
 # MIPSEL-NEXT:     DataEncoding: LittleEndian (0x1)
 # MIPSEL-NEXT:     FileVersion: 1
 # MIPSEL-NEXT:     OS/ABI: SystemV (0x0)
 # MIPSEL-NEXT:     ABIVersion: 1
 # MIPSEL-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPSEL-NEXT:   }
 # MIPSEL-NEXT:   Type: Executable (0x2)
 # MIPSEL-NEXT:   Machine: EM_MIPS (0x8)
 # MIPSEL-NEXT:   Version: 1
 # MIPSEL-NEXT:   Entry:
 # MIPSEL-NEXT:   ProgramHeaderOffset: 0x34
 # MIPSEL-NEXT:   SectionHeaderOffset:
 # MIPSEL-NEXT:   Flags [
 # MIPSEL-NEXT:     EF_MIPS_ABI_O32
 # MIPSEL-NEXT:     EF_MIPS_ARCH_32
 # MIPSEL-NEXT:     EF_MIPS_CPIC
 # MIPSEL-NEXT:   ]
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux-gnuabin32 %s -o %tmipsn32
 # RUN: ld.lld -m elf32btsmipn32 -e _start %tmipsn32 -o %t2mipsn32
 # RUN: llvm-readobj -file-headers %t2mipsn32 | FileCheck --check-prefix=MIPSN32 %s
 # RUN: ld.lld %tmipsn32 -e _start -o %t3mipsn32
 # RUN: llvm-readobj -file-headers %t3mipsn32 | FileCheck --check-prefix=MIPSN32 %s
 # RUN: echo 'OUTPUT_FORMAT(elf32-ntradbigmips)' > %tmipsn32.script
 # RUN: ld.lld %tmipsn32.script -e _start %tmipsn32 -o %t4mipsn32
 # RUN: llvm-readobj -file-headers %t4mipsn32 | FileCheck --check-prefix=MIPSN32 %s
 # MIPSN32:      ElfHeader {
 # MIPSN32-NEXT:   Ident {
 # MIPSN32-NEXT:     Magic: (7F 45 4C 46)
 # MIPSN32-NEXT:     Class: 32-bit (0x1)
 # MIPSN32-NEXT:     DataEncoding: BigEndian (0x2)
 # MIPSN32-NEXT:     FileVersion: 1
 # MIPSN32-NEXT:     OS/ABI: SystemV (0x0)
 # MIPSN32-NEXT:     ABIVersion: 1
 # MIPSN32-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPSN32-NEXT:   }
 # MIPSN32-NEXT:   Type: Executable (0x2)
 # MIPSN32-NEXT:   Machine: EM_MIPS (0x8)
 # MIPSN32-NEXT:   Version: 1
 # MIPSN32-NEXT:   Entry:
 # MIPSN32-NEXT:   ProgramHeaderOffset: 0x34
 # MIPSN32-NEXT:   SectionHeaderOffset:
 # MIPSN32-NEXT:   Flags [
 # MIPSN32-NEXT:     EF_MIPS_ABI2
 # MIPSN32-NEXT:     EF_MIPS_ARCH_64
 # MIPSN32-NEXT:     EF_MIPS_CPIC
 # MIPSN32-NEXT:   ]
 
 # RUN: llvm-mc -filetype=obj -triple=mips64el-unknown-linux-gnuabin32 %s -o %tmipsn32el
 # RUN: ld.lld -m elf32ltsmipn32 -e _start %tmipsn32el -o %t2mipsn32el
 # RUN: llvm-readobj -file-headers %t2mipsn32el | FileCheck --check-prefix=MIPSN32EL %s
 # RUN: ld.lld -melf32ltsmipn32 -e _start %tmipsn32el -o %t2mipsn32el
 # RUN: llvm-readobj -file-headers %t2mipsn32el | FileCheck --check-prefix=MIPSN32EL %s
 # RUN: ld.lld %tmipsn32el -e _start -o %t3mipsn32el
 # RUN: llvm-readobj -file-headers %t3mipsn32el | FileCheck --check-prefix=MIPSN32EL %s
 # RUN: echo 'OUTPUT_FORMAT(elf32-ntradlittlemips)' > %tmipsn32el.script
 # RUN: ld.lld %tmipsn32el.script -e _start %tmipsn32el -o %t4mipsn32el
 # RUN: llvm-readobj -file-headers %t4mipsn32el | FileCheck --check-prefix=MIPSN32EL %s
 # MIPSN32EL:      ElfHeader {
 # MIPSN32EL-NEXT:   Ident {
 # MIPSN32EL-NEXT:     Magic: (7F 45 4C 46)
 # MIPSN32EL-NEXT:     Class: 32-bit (0x1)
 # MIPSN32EL-NEXT:     DataEncoding: LittleEndian (0x1)
 # MIPSN32EL-NEXT:     FileVersion: 1
 # MIPSN32EL-NEXT:     OS/ABI: SystemV (0x0)
 # MIPSN32EL-NEXT:     ABIVersion: 1
 # MIPSN32EL-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPSN32EL-NEXT:   }
 # MIPSN32EL-NEXT:   Type: Executable (0x2)
 # MIPSN32EL-NEXT:   Machine: EM_MIPS (0x8)
 # MIPSN32EL-NEXT:   Version: 1
 # MIPSN32EL-NEXT:   Entry:
 # MIPSN32EL-NEXT:   ProgramHeaderOffset: 0x34
 # MIPSN32EL-NEXT:   SectionHeaderOffset:
 # MIPSN32EL-NEXT:   Flags [
 # MIPSN32EL-NEXT:     EF_MIPS_ABI2
 # MIPSN32EL-NEXT:     EF_MIPS_ARCH_64
 # MIPSN32EL-NEXT:     EF_MIPS_CPIC
 # MIPSN32EL-NEXT:   ]
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux -position-independent \
 # RUN:         %s -o %tmips64
 # RUN: ld.lld -m elf64btsmip -e _start %tmips64 -o %t2mips64
 # RUN: llvm-readobj -file-headers %t2mips64 | FileCheck --check-prefix=MIPS64 %s
 # RUN: ld.lld %tmips64 -e _start -o %t3mips64
 # RUN: llvm-readobj -file-headers %t3mips64 | FileCheck --check-prefix=MIPS64 %s
 # RUN: echo 'OUTPUT_FORMAT(elf64-tradbigmips)' > %tmips64.script
 # RUN: ld.lld %tmips64.script -e _start %tmips64 -o %t4mips64
 # RUN: llvm-readobj -file-headers %t4mips64 | FileCheck --check-prefix=MIPS64 %s
 # MIPS64:      ElfHeader {
 # MIPS64-NEXT:   Ident {
 # MIPS64-NEXT:     Magic: (7F 45 4C 46)
 # MIPS64-NEXT:     Class: 64-bit (0x2)
 # MIPS64-NEXT:     DataEncoding: BigEndian (0x2)
 # MIPS64-NEXT:     FileVersion: 1
 # MIPS64-NEXT:     OS/ABI: SystemV (0x0)
 # MIPS64-NEXT:     ABIVersion: 0
 # MIPS64-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPS64-NEXT:   }
 # MIPS64-NEXT:   Type: Executable (0x2)
 # MIPS64-NEXT:   Machine: EM_MIPS (0x8)
 # MIPS64-NEXT:   Version: 1
 # MIPS64-NEXT:   Entry:
 # MIPS64-NEXT:   ProgramHeaderOffset: 0x40
 # MIPS64-NEXT:   SectionHeaderOffset:
 # MIPS64-NEXT:   Flags [
 # MIPS64-NEXT:     EF_MIPS_ARCH_64
 # MIPS64-NEXT:     EF_MIPS_CPIC
 # MIPS64-NEXT:     EF_MIPS_PIC
 # MIPS64-NEXT:   ]
 
 # RUN: llvm-mc -filetype=obj -triple=mips64el-unknown-linux \
 # RUN:         -position-independent %s -o %tmips64el
 # RUN: ld.lld -m elf64ltsmip -e _start %tmips64el -o %t2mips64el
 # RUN: llvm-readobj -file-headers %t2mips64el | FileCheck --check-prefix=MIPS64EL %s
 # RUN: ld.lld %tmips64el -e _start -o %t3mips64el
 # RUN: llvm-readobj -file-headers %t3mips64el | FileCheck --check-prefix=MIPS64EL %s
 # RUN: echo 'OUTPUT_FORMAT(elf64-tradlittlemips)' > %tmips64el.script
 # RUN: ld.lld %tmips64el.script -e _start %tmips64el -o %t4mips64el
 # RUN: llvm-readobj -file-headers %t4mips64el | FileCheck --check-prefix=MIPS64EL %s
 # MIPS64EL:      ElfHeader {
 # MIPS64EL-NEXT:   Ident {
 # MIPS64EL-NEXT:     Magic: (7F 45 4C 46)
 # MIPS64EL-NEXT:     Class: 64-bit (0x2)
 # MIPS64EL-NEXT:     DataEncoding: LittleEndian (0x1)
 # MIPS64EL-NEXT:     FileVersion: 1
 # MIPS64EL-NEXT:     OS/ABI: SystemV (0x0)
 # MIPS64EL-NEXT:     ABIVersion: 0
 # MIPS64EL-NEXT:     Unused: (00 00 00 00 00 00 00)
 # MIPS64EL-NEXT:   }
 # MIPS64EL-NEXT:   Type: Executable (0x2)
 # MIPS64EL-NEXT:   Machine: EM_MIPS (0x8)
 # MIPS64EL-NEXT:   Version: 1
 # MIPS64EL-NEXT:   Entry:
 # MIPS64EL-NEXT:   ProgramHeaderOffset: 0x40
 # MIPS64EL-NEXT:   SectionHeaderOffset:
 # MIPS64EL-NEXT:   Flags [
 # MIPS64EL-NEXT:     EF_MIPS_ARCH_64
 # MIPS64EL-NEXT:     EF_MIPS_CPIC
 # MIPS64EL-NEXT:     EF_MIPS_PIC
 # MIPS64EL-NEXT:   ]
 
 .globl _start
 _start:
Index: vendor/lld/dist-release_80/test/ELF/emulation-ppc.s
===================================================================
--- vendor/lld/dist-release_80/test/ELF/emulation-ppc.s	(revision 344172)
+++ vendor/lld/dist-release_80/test/ELF/emulation-ppc.s	(revision 344173)
@@ -1,107 +1,144 @@
 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %tppc64
 # RUN: ld.lld -m elf64ppc %tppc64 -o %t2ppc64
 # RUN: llvm-readobj -file-headers %t2ppc64 | FileCheck --check-prefix=PPC64 %s
 # RUN: ld.lld %tppc64 -o %t3ppc64
 # RUN: llvm-readobj -file-headers %t3ppc64 | FileCheck --check-prefix=PPC64 %s
 # RUN: echo 'OUTPUT_FORMAT(elf64-powerpc)' > %tppc64.script
 # RUN: ld.lld %tppc64.script  %tppc64 -o %t4ppc64
 # RUN: llvm-readobj -file-headers %t4ppc64 | FileCheck --check-prefix=PPC64 %s
 
 # PPC64:      ElfHeader {
 # PPC64-NEXT:   Ident {
 # PPC64-NEXT:     Magic: (7F 45 4C 46)
 # PPC64-NEXT:     Class: 64-bit (0x2)
 # PPC64-NEXT:     DataEncoding: BigEndian (0x2)
 # PPC64-NEXT:     FileVersion: 1
 # PPC64-NEXT:     OS/ABI: SystemV (0x0)
 # PPC64-NEXT:     ABIVersion: 0
 # PPC64-NEXT:     Unused: (00 00 00 00 00 00 00)
 # PPC64-NEXT:   }
 # PPC64-NEXT:   Type: Executable (0x2)
 # PPC64-NEXT:   Machine: EM_PPC64 (0x15)
 # PPC64-NEXT:   Version: 1
 # PPC64-NEXT:   Entry:
 # PPC64-NEXT:   ProgramHeaderOffset: 0x40
 # PPC64-NEXT:   SectionHeaderOffset:
 # PPC64-NEXT:   Flags [ (0x2)
 # PPC64-NEXT:     0x2
 # PPC64-NEXT:   ]
 # PPC64-NEXT:   HeaderSize: 64
 # PPC64-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64-NEXT:   ProgramHeaderCount:
 # PPC64-NEXT:   SectionHeaderEntrySize: 64
 # PPC64-NEXT:   SectionHeaderCount:
 # PPC64-NEXT:   StringTableSectionIndex:
 # PPC64-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-freebsd %s -o %tppc64fbsd
 # RUN: echo 'OUTPUT_FORMAT(elf64-powerpc-freebsd)' > %tppc64fbsd.script
 # RUN: ld.lld %tppc64fbsd.script  %tppc64fbsd -o %t2ppc64fbsd
 # RUN: llvm-readobj -file-headers %t2ppc64fbsd | FileCheck --check-prefix=PPC64-FBSD %s
 
 # PPC64-FBSD:      ElfHeader {
 # PPC64-FBSD-NEXT:   Ident {
 # PPC64-FBSD-NEXT:     Magic: (7F 45 4C 46)
 # PPC64-FBSD-NEXT:     Class: 64-bit (0x2)
 # PPC64-FBSD-NEXT:     DataEncoding: BigEndian (0x2)
 # PPC64-FBSD-NEXT:     FileVersion: 1
 # PPC64-FBSD-NEXT:     OS/ABI: FreeBSD (0x9)
 # PPC64-FBSD-NEXT:     ABIVersion: 0
 # PPC64-FBSD-NEXT:     Unused: (00 00 00 00 00 00 00)
 # PPC64-FBSD-NEXT:   }
 # PPC64-FBSD-NEXT:   Type: Executable (0x2)
 # PPC64-FBSD-NEXT:   Machine: EM_PPC64 (0x15)
 # PPC64-FBSD-NEXT:   Version: 1
 # PPC64-FBSD-NEXT:   Entry:
 # PPC64-FBSD-NEXT:   ProgramHeaderOffset: 0x40
 # PPC64-FBSD-NEXT:   SectionHeaderOffset:
 # PPC64-FBSD-NEXT:   Flags [ (0x2)
 # PPC64-FBSD-NEXT:     0x2
 # PPC64-FBSD-NEXT:   ]
 # PPC64-FBSD-NEXT:   HeaderSize: 64
 # PPC64-FBSD-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64-FBSD-NEXT:   ProgramHeaderCount:
 # PPC64-FBSD-NEXT:   SectionHeaderEntrySize: 64
 # PPC64-FBSD-NEXT:   SectionHeaderCount:
 # PPC64-FBSD-NEXT:   StringTableSectionIndex:
 # PPC64-FBSD-NEXT: }
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %tppc64le
 # RUN: ld.lld -m elf64lppc %tppc64le -o %t2ppc64le
 # RUN: llvm-readobj -file-headers %t2ppc64le | FileCheck --check-prefix=PPC64LE %s
 # RUN: ld.lld %tppc64le -o %t3ppc64le
 # RUN: llvm-readobj -file-headers %t3ppc64le | FileCheck --check-prefix=PPC64LE %s
 # RUN: echo 'OUTPUT_FORMAT(elf64-powerpcle)' > %tppc64le.script
 # RUN: ld.lld %tppc64le.script  %tppc64le -o %t4ppc64le
 # RUN: llvm-readobj -file-headers %t4ppc64le | FileCheck --check-prefix=PPC64LE %s
 
 # PPC64LE:      ElfHeader {
 # PPC64LE-NEXT:   Ident {
 # PPC64LE-NEXT:     Magic: (7F 45 4C 46)
 # PPC64LE-NEXT:     Class: 64-bit (0x2)
 # PPC64LE-NEXT:     DataEncoding: LittleEndian (0x1)
 # PPC64LE-NEXT:     FileVersion: 1
 # PPC64LE-NEXT:     OS/ABI: SystemV (0x0)
 # PPC64LE-NEXT:     ABIVersion: 0
 # PPC64LE-NEXT:     Unused: (00 00 00 00 00 00 00)
 # PPC64LE-NEXT:   }
 # PPC64LE-NEXT:   Type: Executable (0x2)
 # PPC64LE-NEXT:   Machine: EM_PPC64 (0x15)
 # PPC64LE-NEXT:   Version: 1
 # PPC64LE-NEXT:   Entry:
 # PPC64LE-NEXT:   ProgramHeaderOffset: 0x40
 # PPC64LE-NEXT:   SectionHeaderOffset:
 # PPC64LE-NEXT:   Flags [ (0x2)
 # PPC64LE-NEXT:     0x2
 # PPC64LE-NEXT:   ]
 # PPC64LE-NEXT:   HeaderSize: 64
 # PPC64LE-NEXT:   ProgramHeaderEntrySize: 56
 # PPC64LE-NEXT:   ProgramHeaderCount:
 # PPC64LE-NEXT:   SectionHeaderEntrySize: 64
 # PPC64LE-NEXT:   SectionHeaderCount:
 # PPC64LE-NEXT:   StringTableSectionIndex:
 # PPC64LE-NEXT: }
 
+# RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-linux %s -o %tppc32
+# RUN: ld.lld -m elf32ppc %tppc32 -o %t2ppc32
+# RUN: llvm-readobj -file-headers %t2ppc32 | FileCheck --check-prefix=PPC32 %s
+# RUN: ld.lld %tppc32 -o %t3ppc32
+# RUN: llvm-readobj -file-headers %t3ppc32 | FileCheck --check-prefix=PPC32 %s
+# RUN: echo 'OUTPUT_FORMAT(elf32-powerpc)' > %tppc32.script
+# RUN: ld.lld %tppc32.script  %tppc32 -o %t4ppc32
+# RUN: llvm-readobj -file-headers %t4ppc32 | FileCheck --check-prefix=PPC32 %s
+# RUN: ld.lld -m elf32ppclinux %tppc32 -o %t5ppc32
+# RUN: llvm-readobj -file-headers %t5ppc32 | FileCheck --check-prefix=PPC32 %s
+
+# PPC32:      ElfHeader {
+# PPC32-NEXT:   Ident {
+# PPC32-NEXT:     Magic: (7F 45 4C 46)
+# PPC32-NEXT:     Class: 32-bit (0x1)
+# PPC32-NEXT:     DataEncoding: BigEndian (0x2)
+# PPC32-NEXT:     FileVersion: 1
+# PPC32-NEXT:     OS/ABI: SystemV (0x0)
+# PPC32-NEXT:     ABIVersion: 0
+# PPC32-NEXT:     Unused: (00 00 00 00 00 00 00)
+# PPC32-NEXT:   }
+# PPC32-NEXT:   Type: Executable (0x2)
+# PPC32-NEXT:   Machine: EM_PPC (0x14)
+# PPC32-NEXT:   Version: 1
+# PPC32-NEXT:   Entry:
+# PPC32-NEXT:   ProgramHeaderOffset: 0x34
+# PPC32-NEXT:   SectionHeaderOffset:
+# PPC32-NEXT:   Flags [ (0x0)
+# PPC32-NEXT:   ]
+# PPC32-NEXT:   HeaderSize: 52
+# PPC32-NEXT:   ProgramHeaderEntrySize: 32
+# PPC32-NEXT:   ProgramHeaderCount:
+# PPC32-NEXT:   SectionHeaderEntrySize: 40
+# PPC32-NEXT:   SectionHeaderCount:
+# PPC32-NEXT:   StringTableSectionIndex:
+# PPC32-NEXT: }
+
 .globl _start
 _start:
Index: vendor/lld/dist-release_80/test/wasm/data-layout.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/data-layout.ll	(revision 344172)
+++ vendor/lld/dist-release_80/test/wasm/data-layout.ll	(revision 344173)
@@ -1,156 +1,156 @@
 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown"
 
 @foo = hidden global i32 1, align 4
 @aligned_bar = hidden global i32 3, align 16
 
 @hello_str = external global i8*
 @external_ref = global i8** @hello_str, align 8
 
 %struct.s = type { i32, i32 }
 @local_struct = hidden global %struct.s zeroinitializer, align 4
 @local_struct_internal_ptr = hidden local_unnamed_addr global i32* getelementptr inbounds (%struct.s, %struct.s* @local_struct, i32 0, i32 1), align 4
 
 ; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry -o %t.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
 
 ; CHECK:         - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '0100000000000000000000000000000003000000000000002804000024040000'
 ; CHECK-NEXT:       - SectionOffset:   45
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1056
 ; CHECK-NEXT:         Content:         '0000000000000000'
 ; CHECK-NEXT:       - SectionOffset:   59
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1064
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 ; CHECK-NEXT:    - Type:            CUSTOM
 
 
 ; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry \
 ; RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t.o \
 ; RUN:     %t.hello.o
 ; RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-MAX
 
 ; CHECK-MAX:        - Type:            MEMORY
 ; CHECK-MAX-NEXT:     Memories:
 ; CHECK-MAX-NEXT:       - Flags:           [ HAS_MAX ]
 ; CHECK-MAX-NEXT:         Initial:         0x00000002
 ; CHECK-MAX-NEXT:         Maximum:         0x00000002
 
 ; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry --shared-memory \
 ; RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t.o \
 ; RUN:     %t.hello.o
 ; RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-SHARED
 
 ; CHECK-SHARED:        - Type:            MEMORY
 ; CHECK-SHARED-NEXT:     Memories:
 ; CHECK-SHARED-NEXT:       - Flags:           [ HAS_MAX, IS_SHARED ]
 ; CHECK-SHARED-NEXT:         Initial:         0x00000002
 ; CHECK-SHARED-NEXT:         Maximum:         0x00000002
 
 ; RUN: wasm-ld --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:       - Type:            DATA
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; RELOC-NEXT:         Index:           6
+; RELOC-NEXT:         Index:           3
 ; RELOC-NEXT:         Offset:          0x00000018
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; RELOC-NEXT:         Index:           3
+; RELOC-NEXT:         Index:           4
 ; RELOC-NEXT:         Offset:          0x0000002E
 ; RELOC-NEXT:         Addend:          4
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '01000000'
 ; RELOC-NEXT:       - SectionOffset:   15
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '03000000'
 ; RELOC-NEXT:       - SectionOffset:   24
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           24
 ; RELOC-NEXT:         Content:         '28000000'
 ; RELOC-NEXT:       - SectionOffset:   33
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:          
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           28
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   46
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:          
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           36
 ; RELOC-NEXT:         Content:         '20000000'
 ; RELOC-NEXT:       - SectionOffset:   55
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           40
 ; RELOC-NEXT:         Content:         68656C6C6F0A00
 
 ; RELOC:          SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            foo
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Segment:         0
 ; RELOC-NEXT:         Size:            4
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            aligned_bar
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Segment:         1
 ; RELOC-NEXT:         Size:            4
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            external_ref
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         2
 ; RELOC-NEXT:         Size:            4
-; RELOC:            - Index:           6
+; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            hello_str
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         5
 ; RELOC-NEXT:         Size:            7
Index: vendor/lld/dist-release_80/test/wasm/import-module.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/import-module.ll	(nonexistent)
+++ vendor/lld/dist-release_80/test/wasm/import-module.ll	(revision 344173)
@@ -0,0 +1,21 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target triple = "wasm32-unknown-unknown-wasm"
+
+define void @_start() {
+  call void @foo();
+  ret void
+}
+
+declare void @foo() #0
+
+attributes #0 = { "wasm-import-module"="bar" }
+
+; CHECK:        - Type:            IMPORT
+; CHECK-NEXT:     Imports:         
+; CHECK-NEXT:       - Module:          bar
+; CHECK-NEXT:         Field:           foo
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         SigIndex:        0
Index: vendor/lld/dist-release_80/test/wasm/import-names.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/import-names.ll	(nonexistent)
+++ vendor/lld/dist-release_80/test/wasm/import-names.ll	(revision 344173)
@@ -0,0 +1,27 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+declare void @f0() #0
+
+define void @_start() {
+    call void @f0()
+    ret void
+}
+
+attributes #0 = { "wasm-import-module"="somewhere" "wasm-import-name"="something" }
+
+; CHECK:        - Type:            IMPORT
+; CHECK-NEXT:     Imports:
+; CHECK-NEXT:       - Module:          somewhere
+; CHECK-NEXT:         Field:           something
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         SigIndex:        0
+
+; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            f0
Index: vendor/lld/dist-release_80/test/wasm/init-fini.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/init-fini.ll	(revision 344172)
+++ vendor/lld/dist-release_80/test/wasm/init-fini.ll	(revision 344173)
@@ -1,328 +1,328 @@
 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
 
 target triple = "wasm32-unknown-unknown"
 
 define hidden void @func1() {
 entry:
   ret void
 }
 
 define hidden void @func2() {
 entry:
   ret void
 }
 
 define hidden void @func3() {
 entry:
   ret void
 }
 
 define hidden void @func4() {
 entry:
   ret void
 }
 
 declare hidden void @externCtor()
 declare hidden void @externDtor()
 
 define i32 @__cxa_atexit(i32 %func, i32 %arg, i32 %dso_handle) {
   ret i32 0
 }
 
 define hidden void @_start() {
 entry:
   ret void
 }
 
 @llvm.global_ctors = appending global [4 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1001, void ()* @func1, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func1, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func2, i8* null },
   { i32, void ()*, i8* } { i32 4000, void ()* @externCtor, i8* null }
 ]
 
 @llvm.global_dtors = appending global [4 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1001, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func4, i8* null },
   { i32, void ()*, i8* } { i32 4000, void ()* @externDtor, i8* null }
 ]
 
 ; RUN: wasm-ld --allow-undefined %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           externDtor
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           externCtor
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 9, 11, 13, 17, 19, 21 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            10031004100A100F1012100F10141003100C100F10161001100E0B
 ; CHECK:            - Index:           22
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            024041868080800041004180888080001087808080000D000F0B00000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            externDtor
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            externCtor
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            func1
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            func2
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            func3
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            func4
 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            __cxa_atexit
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           9
 ; CHECK-NEXT:         Name:            .Lcall_dtors.101
 ; CHECK-NEXT:       - Index:           10
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
 ; CHECK-NEXT:       - Index:           11
 ; CHECK-NEXT:         Name:            .Lcall_dtors.1001
 ; CHECK-NEXT:       - Index:           12
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.1001
 ; CHECK-NEXT:       - Index:           13
 ; CHECK-NEXT:         Name:            .Lcall_dtors.4000
 ; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.4000
 ; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Name:            myctor
 ; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Name:            mydtor
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            .Lcall_dtors.101
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
 ; CHECK-NEXT:       - Index:           19
 ; CHECK-NEXT:         Name:            .Lcall_dtors.202
 ; CHECK-NEXT:       - Index:           20
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
 ; CHECK-NEXT:       - Index:           21
 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           22
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
 ; CHECK-NEXT: ...
 
 
 ; RUN: wasm-ld -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        2
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        3
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        4
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        5
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            __cxa_atexit
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        6
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        7
 ; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            __dso_handle
+; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN, UNDEFINED ]
+; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            externDtor
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN, UNDEFINED ]
+; RELOC-NEXT:         Function:        0
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            externCtor
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN, UNDEFINED ]
+; RELOC-NEXT:         Function:        1
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            myctor
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Function:        14
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            mydtor
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Function:        15
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Kind:            GLOBAL
+; RELOC-NEXT:         Name:            __stack_pointer
+; RELOC-NEXT:         Flags:           [ UNDEFINED ]
+; RELOC-NEXT:         Global:          0
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        8
-; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        9
-; RELOC-NEXT:       - Index:           8
-; RELOC-NEXT:         Kind:            DATA
-; RELOC-NEXT:         Name:            __dso_handle
-; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN, UNDEFINED ]
-; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        10
-; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        11
-; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.4000
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        12
-; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            externDtor
-; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN, UNDEFINED ]
-; RELOC-NEXT:         Function:        0
-; RELOC-NEXT:       - Index:           13
-; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.4000
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        13
-; RELOC-NEXT:       - Index:           14
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            externCtor
-; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN, UNDEFINED ]
-; RELOC-NEXT:         Function:        1
-; RELOC-NEXT:       - Index:           15
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            myctor
-; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:         Function:        14
-; RELOC-NEXT:       - Index:           16
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            mydtor
-; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:         Function:        15
-; RELOC-NEXT:       - Index:           17
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Name:            __stack_pointer
-; RELOC-NEXT:         Flags:           [ UNDEFINED ]
-; RELOC-NEXT:         Global:          0
 ; RELOC-NEXT:       - Index:           18
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        16
 ; RELOC-NEXT:       - Index:           19
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        17
 ; RELOC-NEXT:       - Index:           20
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        18
 ; RELOC-NEXT:       - Index:           21
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        19
 ; RELOC-NEXT:       - Index:           22
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lcall_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        20
 ; RELOC-NEXT:       - Index:           23
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        21
-; RELOC-NEXT:     InitFunctions:
+; RELOC-NEXT:     InitFunctions:   
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          0
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          7
+; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          15
+; RELOC-NEXT:         Symbol:          9
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          19
 ; RELOC-NEXT:       - Priority:        202
-; RELOC-NEXT:         Symbol:          15
+; RELOC-NEXT:         Symbol:          9
 ; RELOC-NEXT:       - Priority:        202
 ; RELOC-NEXT:         Symbol:          21
 ; RELOC-NEXT:       - Priority:        1001
 ; RELOC-NEXT:         Symbol:          0
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         Symbol:          10
-; RELOC-NEXT:       - Priority:        2002
 ; RELOC-NEXT:         Symbol:          15
 ; RELOC-NEXT:       - Priority:        2002
+; RELOC-NEXT:         Symbol:          9
+; RELOC-NEXT:       - Priority:        2002
 ; RELOC-NEXT:         Symbol:          23
 ; RELOC-NEXT:       - Priority:        4000
-; RELOC-NEXT:         Symbol:          14
+; RELOC-NEXT:         Symbol:          8
 ; RELOC-NEXT:       - Priority:        4000
-; RELOC-NEXT:         Symbol:          13
+; RELOC-NEXT:         Symbol:          17
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
-; RELOC-NEXT:     FunctionNames:
+; RELOC-NEXT:     FunctionNames:   
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            externDtor
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            externCtor
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Name:            __cxa_atexit
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
 ; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Name:            .Lcall_dtors.4000
 ; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.4000
 ; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Name:            myctor
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Name:            mydtor
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:       - Index:           18
 ; RELOC-NEXT:         Name:            .Lcall_dtors.202
 ; RELOC-NEXT:       - Index:           19
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
 ; RELOC-NEXT:       - Index:           20
 ; RELOC-NEXT:         Name:            .Lcall_dtors.2002
 ; RELOC-NEXT:       - Index:           21
 ; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT: ...
Index: vendor/lld/dist-release_80/test/wasm/locals-duplicate.test
===================================================================
--- vendor/lld/dist-release_80/test/wasm/locals-duplicate.test	(revision 344172)
+++ vendor/lld/dist-release_80/test/wasm/locals-duplicate.test	(revision 344173)
@@ -1,568 +1,568 @@
 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate2.ll -o %t2.o
 ; RUN: wasm-ld --export-dynamic --no-entry -o %t.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 ; CHECK-NEXT:                        1, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000007
 ; CHECK-NEXT:           Maximum:         0x00000007
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66592
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66592
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1048
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1028
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1036
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            colliding_func2
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            get_global1A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:       - Name:            get_global2A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:       - Name:            colliding_global2
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            get_global3A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:       - Name:            get_func1A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           7
 ; CHECK-NEXT:       - Name:            get_func2A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:       - Name:            get_func3A
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           9
 ; CHECK-NEXT:       - Name:            colliding_func1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           10
 ; CHECK-NEXT:       - Name:            get_global1B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           13
 ; CHECK-NEXT:       - Name:            colliding_global1
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:       - Name:            get_global2B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           14
 ; CHECK-NEXT:       - Name:            get_global3B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           15
 ; CHECK-NEXT:       - Name:            get_func1B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           16
 ; CHECK-NEXT:       - Name:            get_func2B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           17
 ; CHECK-NEXT:       - Name:            get_func3B
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           18
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 1, 2, 3, 10, 11, 12 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180888080000B
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4184888080000B
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4188888080000B
 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4182808080000B
 ; CHECK-NEXT:       - Index:           9
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4183808080000B
 ; CHECK-NEXT:       - Index:           10
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           11
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           12
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           13
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            418C888080000B
 ; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4190888080000B
 ; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4194888080000B
 ; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4184808080000B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4185808080000B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4186808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '000000000000000000000000000000000000000000000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            colliding_func1
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            colliding_func2
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            colliding_func3
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            get_global1A
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            get_global2A
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            get_global3A
 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            get_func1A
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Name:            get_func2A
 ; CHECK-NEXT:       - Index:           9
 ; CHECK-NEXT:         Name:            get_func3A
 ; CHECK-NEXT:       - Index:           10
 ; CHECK-NEXT:         Name:            colliding_func1
 ; CHECK-NEXT:       - Index:           11
 ; CHECK-NEXT:         Name:            colliding_func2
 ; CHECK-NEXT:       - Index:           12
 ; CHECK-NEXT:         Name:            colliding_func3
 ; CHECK-NEXT:       - Index:           13
 ; CHECK-NEXT:         Name:            get_global1B
 ; CHECK-NEXT:       - Index:           14
 ; CHECK-NEXT:         Name:            get_global2B
 ; CHECK-NEXT:       - Index:           15
 ; CHECK-NEXT:         Name:            get_global3B
 ; CHECK-NEXT:       - Index:           16
 ; CHECK-NEXT:         Name:            get_func1B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func2B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            get_func3B
 ; CHECK-NEXT: ...
 
 
 ; RUN: wasm-ld -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         ReturnType:      I32
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 ; RELOC-NEXT:                        0, 0 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:
 ; RELOC-NEXT:       - ElemType:        FUNCREF
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000007
 ; RELOC-NEXT:           Maximum:         0x00000007
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000001
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           18
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           6
+; RELOC-NEXT:         Index:           3
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           8
+; RELOC-NEXT:         Index:           19
 ; RELOC-NEXT:         Offset:          0x00000025
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           16
 ; RELOC-NEXT:         Offset:          0x0000002E
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           0
 ; RELOC-NEXT:         Offset:          0x00000037
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           2
+; RELOC-NEXT:         Index:           17
 ; RELOC-NEXT:         Offset:          0x00000040
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           16
+; RELOC-NEXT:         Index:           10
 ; RELOC-NEXT:         Offset:          0x00000058
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           18
+; RELOC-NEXT:         Index:           22
 ; RELOC-NEXT:         Offset:          0x00000061
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           20
+; RELOC-NEXT:         Index:           23
 ; RELOC-NEXT:         Offset:          0x0000006A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           12
+; RELOC-NEXT:         Index:           8
 ; RELOC-NEXT:         Offset:          0x00000073
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           13
+; RELOC-NEXT:         Index:           20
 ; RELOC-NEXT:         Offset:          0x0000007C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           14
+; RELOC-NEXT:         Index:           21
 ; RELOC-NEXT:         Offset:          0x00000085
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            4180808080000B
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            4188808080000B
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            4190808080000B
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4181808080000B
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4182808080000B
 ; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4183808080000B
 ; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            4184808080000B
 ; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            418C808080000B
 ; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            4194808080000B
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4184808080000B
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4185808080000B
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Locals:          
 ; RELOC-NEXT:         Body:            4186808080000B
 ; RELOC-NEXT:   - Type:            DATA
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   19
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           8
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:       - SectionOffset:   32
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     Version:         2
 ; RELOC-NEXT:     SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            colliding_func1
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        0
-; RELOC-NEXT:       - Index:           1
-; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        1
-; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            colliding_func3
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        2
-; RELOC-NEXT:       - Index:           3
-; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global1A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        3
-; RELOC-NEXT:       - Index:           4
-; RELOC-NEXT:         Kind:            DATA
-; RELOC-NEXT:         Name:            colliding_global1
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Segment:         0
-; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global2A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        4
-; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global2
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         1
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global3A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        5
-; RELOC-NEXT:       - Index:           8
-; RELOC-NEXT:         Kind:            DATA
-; RELOC-NEXT:         Name:            colliding_global3
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Segment:         2
-; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func1A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        6
-; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func2A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        7
-; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func3A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        8
-; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        9
-; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            colliding_func2
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        10
-; RELOC-NEXT:       - Index:           14
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            colliding_func3
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Function:        11
-; RELOC-NEXT:       - Index:           15
-; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global1B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        12
-; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global1
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         0
 ; RELOC-NEXT:         Offset:          4
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global2B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        13
-; RELOC-NEXT:       - Index:           18
-; RELOC-NEXT:         Kind:            DATA
-; RELOC-NEXT:         Name:            colliding_global2
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Segment:         1
-; RELOC-NEXT:         Offset:          4
-; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global3B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        14
-; RELOC-NEXT:       - Index:           20
-; RELOC-NEXT:         Kind:            DATA
-; RELOC-NEXT:         Name:            colliding_global3
-; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:         Segment:         2
-; RELOC-NEXT:         Offset:          4
-; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           21
+; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func1B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        15
-; RELOC-NEXT:       - Index:           22
+; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func2B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        16
-; RELOC-NEXT:       - Index:           23
+; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func3B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        17
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func1
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Function:        0
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Function:        2
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global1
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Segment:         0
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Segment:         2
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func2
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Function:        10
+; RELOC-NEXT:       - Index:           21
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Function:        11
+; RELOC-NEXT:       - Index:           22
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global2
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Segment:         1
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           23
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
+; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         Segment:         2
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
 ; RELOC-NEXT:     SegmentInfo:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            .bss.colliding_global1
 ; RELOC-NEXT:         Alignment:       2
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            .bss.colliding_global2
 ; RELOC-NEXT:         Alignment:       2
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            .bss.colliding_global3
 ; RELOC-NEXT:         Alignment:       2
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            get_global1A
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            get_global2A
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            get_global3A
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Name:            get_func1A
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Name:            get_func2A
 ; RELOC-NEXT:       - Index:           8
 ; RELOC-NEXT:         Name:            get_func3A
 ; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Name:            get_global1B
 ; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Name:            get_global2B
 ; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Name:            get_global3B
 ; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Name:            get_func1B
 ; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Name:            get_func2B
 ; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Name:            get_func3B
 ; RELOC-NEXT: ...
Index: vendor/lld/dist-release_80/test/wasm/lto/relocatable-undefined.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/lto/relocatable-undefined.ll	(nonexistent)
+++ vendor/lld/dist-release_80/test/wasm/lto/relocatable-undefined.ll	(revision 344173)
@@ -0,0 +1,36 @@
+; RUN: llvm-as %s -o %t.o
+; RUN: wasm-ld -r -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@missing_data = external global i32
+declare i32 @missing_func() local_unnamed_addr
+
+define i32 @foo() {
+entry:
+  %0 = call i32 @missing_func()
+  %1 = load i32, i32* @missing_data, align 4
+  ret i32 %1
+}
+
+
+; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     Version:         2
+; CHECK-NEXT:     SymbolTable:     
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            missing_func
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         Function:        0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         Function:        1
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            missing_data
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
Index: vendor/lld/dist-release_80/test/wasm/weak-alias.ll
===================================================================
--- vendor/lld/dist-release_80/test/wasm/weak-alias.ll	(revision 344172)
+++ vendor/lld/dist-release_80/test/wasm/weak-alias.ll	(revision 344173)
@@ -1,310 +1,310 @@
 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
 ; RUN: wasm-ld --export-dynamic %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that weak aliases (alias_fn is a weak alias of direct_fn) are linked correctly
 
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @alias_fn() local_unnamed_addr #1
 
 ; Function Attrs: nounwind uwtable
 define void @_start() local_unnamed_addr #1 {
 entry:
   %call = tail call i32 @alias_fn() #2
   ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1, 1, 1, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        FUNCREF
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000002
 ; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            alias_fn
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            direct_fn
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            call_direct
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:       - Name:            call_alias_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:       - Name:            call_direct_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1082808080001A0B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1082808080000B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1082808080000B
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081082808080002101200041106A24808080800020010B
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081082808080002101200041106A24808080800020010B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            direct_fn
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT: ...
 
 ; RUN: wasm-ld --relocatable %t.o %t2.o -o %t.reloc.o
 ; RUN: obj2yaml %t.reloc.o | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         ReturnType:      NORESULT
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         ReturnType:      I32
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:   - Type:            IMPORT
 ; RELOC-NEXT:     Imports:
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __stack_pointer
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         GlobalType:      I32
 ; RELOC-NEXT:         GlobalMutable:   true
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:
 ; RELOC-NEXT:       - ElemType:        FUNCREF
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000002
 ; RELOC-NEXT:           Maximum:         0x00000002
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000000
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 1 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000004
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000027
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000032
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x0000003A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000043
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000050
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x0000005D
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000068
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000070
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000079
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000086
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080001A0B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41000B
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080000B
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080000B
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:           - Type:            I32
 ; RELOC-NEXT:             Count:           2
 ; RELOC-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:           - Type:            I32
 ; RELOC-NEXT:             Count:           2
 ; RELOC-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     Version:         2
 ; RELOC-NEXT:     SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        0
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            alias_fn
+; RELOC-NEXT:         Flags:           [ BINDING_WEAK ]
+; RELOC-NEXT:         Function:        1
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            direct_fn
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        1
-; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        2
-; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        3
-; RELOC-NEXT:       - Index:           4
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Name:            alias_fn
-; RELOC-NEXT:         Flags:           [ BINDING_WEAK ]
-; RELOC-NEXT:         Function:        1
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        4
 ; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         Name:            __stack_pointer
 ; RELOC-NEXT:         Flags:           [ UNDEFINED ]
 ; RELOC-NEXT:         Global:          0
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_direct_ptr
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        5
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            direct_fn
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            call_direct_ptr
 ; RELOC-NEXT: ...
Index: vendor/lld/dist-release_80/wasm/Driver.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/Driver.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/Driver.cpp	(revision 344173)
@@ -1,619 +1,621 @@
 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputGlobal.h"
 #include "MarkLive.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::wasm;
 
 using namespace lld;
 using namespace lld::wasm;
 
 Configuration *lld::wasm::Config;
 
 namespace {
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.
 static void initLLVM() {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
 class LinkerDriver {
 public:
   void link(ArrayRef<const char *> ArgsArr);
 
 private:
   void createFiles(opt::InputArgList &Args);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
 
   // True if we are in --whole-archive and --no-whole-archive.
   bool InWholeArchive = false;
 
   std::vector<InputFile *> Files;
 };
 } // anonymous namespace
 
 bool lld::wasm::link(ArrayRef<const char *> Args, bool CanExitEarly,
                      raw_ostream &Error) {
   errorHandler().LogName = args::getFilenameWithoutExe(Args[0]);
   errorHandler().ErrorOS = &Error;
   errorHandler().ColorDiagnostics = Error.has_colors();
   errorHandler().ErrorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
 
   Config = make<Configuration>();
   Symtab = make<SymbolTable>();
 
   initLLVM();
   LinkerDriver().link(Args);
 
   // Exit immediately if we don't need to return to the caller.
   // This saves time because the overhead of calling destructors
   // for all globally-allocated objects is not negligible.
   if (CanExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   freeArena();
   return !errorCount();
 }
 
 // Create prefix string literals used in Options.td
 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
 #include "Options.inc"
 #undef PREFIX
 
 // Create table mapping all options defined in Options.td
 static const opt::OptTable::Info OptInfo[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
 namespace {
 class WasmOptTable : public llvm::opt::OptTable {
 public:
   WasmOptTable() : OptTable(OptInfo) {}
   opt::InputArgList parse(ArrayRef<const char *> Argv);
 };
 } // namespace
 
 // Set color diagnostics according to -color-diagnostics={auto,always,never}
 // or -no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &Args) {
   auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);
   if (!Arg)
     return;
   if (Arg->getOption().getID() == OPT_color_diagnostics) {
     errorHandler().ColorDiagnostics = true;
   } else if (Arg->getOption().getID() == OPT_no_color_diagnostics) {
     errorHandler().ColorDiagnostics = false;
   } else {
     StringRef S = Arg->getValue();
     if (S == "always")
       errorHandler().ColorDiagnostics = true;
     else if (S == "never")
       errorHandler().ColorDiagnostics = false;
     else if (S != "auto")
       error("unknown option: --color-diagnostics=" + S);
   }
 }
 
 // Find a file by concatenating given paths.
 static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
   SmallString<128> S;
   path::append(S, Path1, Path2);
   if (fs::exists(S))
     return S.str().str();
   return None;
 }
 
 opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) {
   SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
 
   unsigned MissingIndex;
   unsigned MissingCount;
 
   // Expand response files (arguments in the form of @<filename>)
   cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Vec);
 
   opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
 
   handleColorDiagnostics(Args);
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + Arg->getSpelling());
   return Args;
 }
 
 // Currently we allow a ".imports" to live alongside a library. This can
 // be used to specify a list of symbols which can be undefined at link
 // time (imported from the environment.  For example libc.a include an
 // import file that lists the syscall functions it relies on at runtime.
 // In the long run this information would be better stored as a symbol
 // attribute/flag in the object file itself.
 // See: https://github.com/WebAssembly/tool-conventions/issues/35
 static void readImportFile(StringRef Filename) {
   if (Optional<MemoryBufferRef> Buf = readFile(Filename))
     for (StringRef Sym : args::getLines(*Buf))
       Config->AllowUndefinedSymbols.insert(Sym);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef MB) {
   std::unique_ptr<Archive> File =
       CHECK(Archive::create(MB),
             MB.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<MemoryBufferRef> V;
   Error Err = Error::success();
   for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) {
     Archive::Child C =
         CHECK(COrErr, MB.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef MBRef =
         CHECK(C.getMemoryBufferRef(),
               MB.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
     V.push_back(MBRef);
   }
   if (Err)
     fatal(MB.getBufferIdentifier() +
           ": Archive::children failed: " + toString(std::move(Err)));
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &MB : File->takeThinBuffers())
     make<std::unique_ptr<MemoryBuffer>>(std::move(MB));
 
   return V;
 }
 
 void LinkerDriver::addFile(StringRef Path) {
   Optional<MemoryBufferRef> Buffer = readFile(Path);
   if (!Buffer.hasValue())
     return;
   MemoryBufferRef MBRef = *Buffer;
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::archive: {
     // Handle -whole-archive.
     if (InWholeArchive) {
       for (MemoryBufferRef &M : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(M));
       return;
     }
 
     SmallString<128> ImportFile = Path;
     path::replace_extension(ImportFile, ".imports");
     if (fs::exists(ImportFile))
       readImportFile(ImportFile.str());
 
     Files.push_back(make<ArchiveFile>(MBRef));
     return;
   }
   case file_magic::bitcode:
   case file_magic::wasm_object:
     Files.push_back(createObjectFile(MBRef));
     break;
   default:
     error("unknown file type: " + MBRef.getBufferIdentifier());
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   for (StringRef Dir : Config->SearchPaths) {
     if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".a")) {
       addFile(*S);
       return;
     }
   }
 
   error("unable to find library -l" + Name);
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getUnaliasedOption().getID()) {
     case OPT_l:
       addLibrary(Arg->getValue());
       break;
     case OPT_INPUT:
       addFile(Arg->getValue());
       break;
     case OPT_whole_archive:
       InWholeArchive = true;
       break;
     case OPT_no_whole_archive:
       InWholeArchive = false;
       break;
     }
   }
 }
 
 static StringRef getEntry(opt::InputArgList &Args, StringRef Default) {
   auto *Arg = Args.getLastArg(OPT_entry, OPT_no_entry);
   if (!Arg)
     return Default;
   if (Arg->getOption().getID() == OPT_no_entry)
     return "";
   return Arg->getValue();
 }
 
 static const uint8_t UnreachableFn[] = {
     0x03 /* ULEB length */, 0x00 /* ULEB num locals */,
     0x00 /* opcode unreachable */, 0x0b /* opcode end */
 };
 
 // For weak undefined functions, there may be "call" instructions that reference
 // the symbol. In this case, we need to synthesise a dummy/stub function that
 // will abort at runtime, so that relocations can still provided an operand to
 // the call instruction that passes Wasm validation.
 static void handleWeakUndefines() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isUndefined() || !Sym->isWeak())
       continue;
     auto *FuncSym = dyn_cast<FunctionSymbol>(Sym);
     if (!FuncSym)
       continue;
 
     // It is possible for undefined functions not to have a signature (eg. if
     // added via "--undefined"), but weak undefined ones do have a signature.
     assert(FuncSym->Signature);
     const WasmSignature &Sig = *FuncSym->Signature;
 
     // Add a synthetic dummy for weak undefined functions.  These dummies will
     // be GC'd if not used as the target of any "call" instructions.
     std::string SymName = toString(*Sym);
     StringRef DebugName = Saver.save("undefined function " + SymName);
     auto *Func = make<SyntheticFunction>(Sig, Sym->getName(), DebugName);
     Func->setBody(UnreachableFn);
     // Ensure it compares equal to the null pointer, and so that table relocs
     // don't pull in the stub body (only call-operand relocs should do that).
     Func->setTableIndex(0);
     Symtab->SyntheticFunctions.emplace_back(Func);
     // Hide our dummy to prevent export.
     uint32_t Flags = WASM_SYMBOL_VISIBILITY_HIDDEN;
     replaceSymbol<DefinedFunction>(Sym, Sym->getName(), Flags, nullptr, Func);
   }
 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &Args) {
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
   Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
   Config->ExportAll = Args.hasArg(OPT_export_all);
   Config->ExportDynamic = Args.hasFlag(OPT_export_dynamic,
       OPT_no_export_dynamic, false);
   Config->ExportTable = Args.hasArg(OPT_export_table);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
   Config->SharedMemory = Args.hasArg(OPT_shared_memory);
   Config->ImportTable = Args.hasArg(OPT_import_table);
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->Optimize = args::getInteger(Args, OPT_O, 0);
   Config->OutputFile = Args.getLastArgValue(OPT_o);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->GcSections =
       Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !Config->Relocatable);
   Config->MergeDataSegments =
       Args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
                    !Config->Relocatable);
   Config->Pie = Args.hasFlag(OPT_pie, OPT_no_pie, false);
   Config->PrintGcSections =
       Args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->SearchPaths = args::getStrings(Args, OPT_L);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->StripDebug = Args.hasArg(OPT_strip_debug);
   Config->StackFirst = Args.hasArg(OPT_stack_first);
   Config->ThinLTOCacheDir = Args.getLastArgValue(OPT_thinlto_cache_dir);
   Config->ThinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(Args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   Config->ThinLTOJobs = args::getInteger(Args, OPT_thinlto_jobs, -1u);
   errorHandler().Verbose = Args.hasArg(OPT_verbose);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   Config->InitialMemory = args::getInteger(Args, OPT_initial_memory, 0);
   Config->GlobalBase = args::getInteger(Args, OPT_global_base, 1024);
   Config->MaxMemory = args::getInteger(Args, OPT_max_memory, 0);
   Config->ZStackSize =
       args::getZOptionValue(Args, OPT_z, "stack-size", WasmPageSize);
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
   if (!Config->StripDebug && !Config->StripAll && Config->CompressRelocations)
     error("--compress-relocations is incompatible with output debug"
           " information. Please pass --strip-debug or --strip-all");
 
   if (Config->LTOO > 3)
     error("invalid optimization level for LTO: " + Twine(Config->LTOO));
   if (Config->LTOPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (Config->ThinLTOJobs == 0)
     error("--thinlto-jobs: number of threads must be > 0");
 
   if (Config->Pie && Config->Shared)
     error("-shared and -pie may not be used together");
 
   if (Config->OutputFile.empty())
     error("no output file specified");
 
   if (Config->ImportTable && Config->ExportTable)
     error("--import-table and --export-table may not be used together");
 
   if (Config->Relocatable) {
     if (!Config->Entry.empty())
       error("entry point specified for relocatable output file");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Config->CompressRelocations)
       error("-r -and --compress-relocations may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
     if (Config->Pie)
       error("-r and -pie may not be used together");
   }
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.
 static Symbol *handleUndefined(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym)
     return nullptr;
 
   // Since symbol S may not be used inside the program, LTO may
   // eliminate it. Mark the symbol as "used" to prevent it.
   Sym->IsUsedInRegularObj = true;
 
   if (auto *LazySym = dyn_cast<LazySymbol>(Sym))
     LazySym->fetch();
 
   return Sym;
 }
 
 static UndefinedGlobal *
 createUndefinedGlobal(StringRef Name, llvm::wasm::WasmGlobalType *Type) {
   auto *Sym =
-      cast<UndefinedGlobal>(Symtab->addUndefinedGlobal(Name, 0, nullptr, Type));
+      cast<UndefinedGlobal>(Symtab->addUndefinedGlobal(Name, Name,
+                                                       DefaultModule, 0,
+                                                       nullptr, Type));
   Config->AllowUndefinedSymbols.insert(Sym->getName());
   Sym->IsUsedInRegularObj = true;
   return Sym;
 }
 
 // Create ABI-defined synthetic symbols
 static void createSyntheticSymbols() {
   static WasmSignature NullSignature = {{}, {}};
   static llvm::wasm::WasmGlobalType GlobalTypeI32 = {WASM_TYPE_I32, false};
   static llvm::wasm::WasmGlobalType MutableGlobalTypeI32 = {WASM_TYPE_I32,
                                                             true};
 
   if (!Config->Relocatable)
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
 
   // The __stack_pointer is imported in the shared library case, and exported
   // in the non-shared (executable) case.
   if (Config->Shared) {
     WasmSym::StackPointer =
         createUndefinedGlobal("__stack_pointer", &MutableGlobalTypeI32);
   } else {
     llvm::wasm::WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, true};
     Global.InitExpr.Value.Int32 = 0;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.SymbolName = "__stack_pointer";
     auto *StackPointer = make<InputGlobal>(Global, nullptr);
     StackPointer->Live = true;
     // For non-PIC code
     // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
     // spec proposal is implemented in all major browsers.
     // See: https://github.com/WebAssembly/mutable-global
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end", 0);
 
     // These two synthetic symbols exist purely for the embedder so we always
     // want to export them.
     WasmSym::HeapBase->ForceExport = true;
     WasmSym::DataEnd->ForceExport = true;
   }
 
   if (Config->Pic) {
     // For PIC code, we import two global variables (__memory_base and
     // __table_base) from the environment and use these as the offset at
     // which to load our static data and function table.
     // See:
     // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
     WasmSym::MemoryBase =
         createUndefinedGlobal("__memory_base", &GlobalTypeI32);
     WasmSym::TableBase = createUndefinedGlobal("__table_base", &GlobalTypeI32);
     WasmSym::MemoryBase->markLive();
     WasmSym::TableBase->markLive();
   }
 
   WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
       "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
 }
 
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   WasmOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Handle --help
   if (Args.hasArg(OPT_help)) {
     Parser.PrintHelp(outs(),
                      (std::string(ArgsArr[0]) + " [options] file...").c_str(),
                      "LLVM Linker", false);
     return;
   }
 
   // Handle --version
   if (Args.hasArg(OPT_version) || Args.hasArg(OPT_v)) {
     outs() << getLLDVersion() << "\n";
     return;
   }
 
   // Parse and evaluate -mllvm options.
   std::vector<const char *> V;
   V.push_back("wasm-ld (LLVM option parsing)");
   for (auto *Arg : Args.filtered(OPT_mllvm))
     V.push_back(Arg->getValue());
   cl::ParseCommandLineOptions(V.size(), V.data());
 
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   setConfigs(Args);
   checkOptions(Args);
 
   if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file))
     readImportFile(Arg->getValue());
 
   if (!Args.hasArg(OPT_INPUT)) {
     error("no input files");
     return;
   }
 
   Config->Pic = Config->Pie || Config->Shared;
 
   if (Config->Pic) {
     if (Config->ExportTable)
       error("-shared/-pie is incompatible with --export-table");
     Config->ImportTable = true;
   }
 
   if (Config->Shared) {
     Config->ExportDynamic = true;
     Config->AllowUndefined = true;
   }
 
   if (!Config->Relocatable)
     createSyntheticSymbols();
 
   createFiles(Args);
   if (errorCount())
     return;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
     Symtab->addFile(F);
   if (errorCount())
     return;
 
   // Handle the `--undefined <sym>` options.
   for (auto *Arg : Args.filtered(OPT_undefined))
     handleUndefined(Arg->getValue());
 
   // Handle the `--export <sym>` options
   // This works like --undefined but also exports the symbol if its found
   for (auto *Arg : Args.filtered(OPT_export)) {
     Symbol *Sym = handleUndefined(Arg->getValue());
     if (Sym && Sym->isDefined())
       Sym->ForceExport = true;
     else if (!Config->AllowUndefined)
       error(Twine("symbol exported via --export not found: ") +
             Arg->getValue());
   }
 
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
     // Add synthetic dummies for weak undefined functions.
     handleWeakUndefines();
 
     if (!Config->Shared && !Config->Entry.empty()) {
       EntrySym = handleUndefined(Config->Entry);
       if (EntrySym && EntrySym->isDefined())
         EntrySym->ForceExport = true;
       else
         error("entry symbol not defined (pass --no-entry to supress): " +
               Config->Entry);
     }
 
     // Make sure we have resolved all symbols.
     if (!Config->AllowUndefined)
       Symtab->reportRemainingUndefines();
   }
 
   if (errorCount())
     return;
 
   // Do link-time optimization if given files are LLVM bitcode files.
   // This compiles bitcode files into real object files.
   Symtab->addCombinedLTOObject();
   if (errorCount())
     return;
 
   if (EntrySym)
     EntrySym->setHidden(false);
 
   if (errorCount())
     return;
 
   // Do size optimizations: garbage collection
   markLive();
 
   // Write the result to the file.
   writeResult();
 }
Index: vendor/lld/dist-release_80/wasm/InputChunks.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/InputChunks.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/InputChunks.cpp	(revision 344173)
@@ -1,292 +1,292 @@
 //===- InputChunks.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputChunks.h"
 #include "Config.h"
 #include "OutputSegment.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::wasm;
 
-static StringRef ReloctTypeToString(uint8_t RelocType) {
+static StringRef reloctTypeToString(uint8_t RelocType) {
   switch (RelocType) {
 #define WASM_RELOC(NAME, REL)                                                  \
   case REL:                                                                    \
     return #NAME;
 #include "llvm/BinaryFormat/WasmRelocs.def"
 #undef WASM_RELOC
   }
   llvm_unreachable("unknown reloc type");
 }
 
 std::string lld::toString(const InputChunk *C) {
   return (toString(C->File) + ":(" + C->getName() + ")").str();
 }
 
 StringRef InputChunk::getComdatName() const {
   uint32_t Index = getComdat();
   if (Index == UINT32_MAX)
     return StringRef();
   return File->getWasmObj()->linkingData().Comdats[Index];
 }
 
 void InputChunk::verifyRelocTargets() const {
   for (const WasmRelocation &Rel : Relocations) {
     uint32_t ExistingValue;
     unsigned BytesRead = 0;
     uint32_t Offset = Rel.Offset - getInputSectionOffset();
     const uint8_t *Loc = data().data() + Offset;
     switch (Rel.Type) {
     case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case R_WEBASSEMBLY_EVENT_INDEX_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       ExistingValue = decodeULEB128(Loc, &BytesRead);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       ExistingValue = static_cast<uint32_t>(decodeSLEB128(Loc, &BytesRead));
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       ExistingValue = static_cast<uint32_t>(read32le(Loc));
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
     if (BytesRead && BytesRead != 5)
       warn("expected LEB at relocation site be 5-byte padded");
     uint32_t ExpectedValue = File->calcExpectedValue(Rel);
     if (ExpectedValue != ExistingValue)
-      warn("unexpected existing value for " + ReloctTypeToString(Rel.Type) +
+      warn("unexpected existing value for " + reloctTypeToString(Rel.Type) +
            ": existing=" + Twine(ExistingValue) +
            " expected=" + Twine(ExpectedValue));
   }
 }
 
 // Copy this input chunk to an mmap'ed output file and apply relocations.
 void InputChunk::writeTo(uint8_t *Buf) const {
   // Copy contents
   memcpy(Buf + OutputOffset, data().data(), data().size());
 
   // Apply relocations
   if (Relocations.empty())
     return;
 
 #ifndef NDEBUG
   verifyRelocTargets();
 #endif
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << getName()
                     << " count=" << Relocations.size() << "\n");
   int32_t Off = OutputOffset - getInputSectionOffset();
 
   for (const WasmRelocation &Rel : Relocations) {
     uint8_t *Loc = Buf + Rel.Offset + Off;
     uint32_t Value = File->calcNewValue(Rel);
-    LLVM_DEBUG(dbgs() << "apply reloc: type=" << ReloctTypeToString(Rel.Type)
+    LLVM_DEBUG(dbgs() << "apply reloc: type=" << reloctTypeToString(Rel.Type)
                       << " addend=" << Rel.Addend << " index=" << Rel.Index
                       << " value=" << Value << " offset=" << Rel.Offset
                       << "\n");
 
     switch (Rel.Type) {
     case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case R_WEBASSEMBLY_EVENT_INDEX_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       encodeULEB128(Value, Loc, 5);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       encodeSLEB128(static_cast<int32_t>(Value), Loc, 5);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       write32le(Loc, Value);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
   }
 }
 
 // Copy relocation entries to a given output stream.
 // This function is used only when a user passes "-r". For a regular link,
 // we consume relocations instead of copying them to an output file.
 void InputChunk::writeRelocations(raw_ostream &OS) const {
   if (Relocations.empty())
     return;
 
   int32_t Off = OutputOffset - getInputSectionOffset();
   LLVM_DEBUG(dbgs() << "writeRelocations: " << File->getName()
                     << " offset=" << Twine(Off) << "\n");
 
   for (const WasmRelocation &Rel : Relocations) {
     writeUleb128(OS, Rel.Type, "reloc type");
     writeUleb128(OS, Rel.Offset + Off, "reloc offset");
     writeUleb128(OS, File->calcNewIndex(Rel), "reloc index");
 
     switch (Rel.Type) {
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     case R_WEBASSEMBLY_SECTION_OFFSET_I32:
       writeSleb128(OS, File->calcNewAddend(Rel), "reloc addend");
       break;
     }
   }
 }
 
 void InputFunction::setFunctionIndex(uint32_t Index) {
   LLVM_DEBUG(dbgs() << "InputFunction::setFunctionIndex: " << getName()
                     << " -> " << Index << "\n");
   assert(!hasFunctionIndex());
   FunctionIndex = Index;
 }
 
 void InputFunction::setTableIndex(uint32_t Index) {
   LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
                     << Index << "\n");
   assert(!hasTableIndex());
   TableIndex = Index;
 }
 
 // Write a relocation value without padding and return the number of bytes
 // witten.
 static unsigned writeCompressedReloc(uint8_t *Buf, const WasmRelocation &Rel,
                                      uint32_t Value) {
   switch (Rel.Type) {
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case R_WEBASSEMBLY_EVENT_INDEX_LEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     return encodeULEB128(Value, Buf);
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     return encodeSLEB128(static_cast<int32_t>(Value), Buf);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidthPadded(const WasmRelocation &Rel) {
   switch (Rel.Type) {
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case R_WEBASSEMBLY_EVENT_INDEX_LEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     return 5;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidth(const WasmRelocation &Rel, uint32_t Value) {
   uint8_t Buf[5];
   return writeCompressedReloc(Buf, Rel, Value);
 }
 
 // Relocations of type LEB and SLEB in the code section are padded to 5 bytes
 // so that a fast linker can blindly overwrite them without needing to worry
 // about the number of bytes needed to encode the values.
 // However, for optimal output the code section can be compressed to remove
 // the padding then outputting non-relocatable files.
 // In this case we need to perform a size calculation based on the value at each
 // relocation.  At best we end up saving 4 bytes for each relocation entry.
 //
 // This function only computes the final output size.  It must be called
 // before getSize() is used to calculate of layout of the code section.
 void InputFunction::calculateSize() {
   if (!File || !Config->CompressRelocations)
     return;
 
   LLVM_DEBUG(dbgs() << "calculateSize: " << getName() << "\n");
 
   const uint8_t *SecStart = File->CodeSection->Content.data();
   const uint8_t *FuncStart = SecStart + getInputSectionOffset();
   uint32_t FunctionSizeLength;
   decodeULEB128(FuncStart, &FunctionSizeLength);
 
   uint32_t Start = getInputSectionOffset();
   uint32_t End = Start + Function->Size;
 
   uint32_t LastRelocEnd = Start + FunctionSizeLength;
   for (const WasmRelocation &Rel : Relocations) {
     LLVM_DEBUG(dbgs() << "  region: " << (Rel.Offset - LastRelocEnd) << "\n");
     CompressedFuncSize += Rel.Offset - LastRelocEnd;
     CompressedFuncSize += getRelocWidth(Rel, File->calcNewValue(Rel));
     LastRelocEnd = Rel.Offset + getRelocWidthPadded(Rel);
   }
   LLVM_DEBUG(dbgs() << "  final region: " << (End - LastRelocEnd) << "\n");
   CompressedFuncSize += End - LastRelocEnd;
 
   // Now we know how long the resulting function is we can add the encoding
   // of its length
   uint8_t Buf[5];
   CompressedSize = CompressedFuncSize + encodeULEB128(CompressedFuncSize, Buf);
 
   LLVM_DEBUG(dbgs() << "  calculateSize orig: " << Function->Size << "\n");
   LLVM_DEBUG(dbgs() << "  calculateSize  new: " << CompressedSize << "\n");
 }
 
 // Override the default writeTo method so that we can (optionally) write the
 // compressed version of the function.
 void InputFunction::writeTo(uint8_t *Buf) const {
   if (!File || !Config->CompressRelocations)
     return InputChunk::writeTo(Buf);
 
   Buf += OutputOffset;
   uint8_t *Orig = Buf;
   (void)Orig;
 
   const uint8_t *SecStart = File->CodeSection->Content.data();
   const uint8_t *FuncStart = SecStart + getInputSectionOffset();
   const uint8_t *End = FuncStart + Function->Size;
   uint32_t Count;
   decodeULEB128(FuncStart, &Count);
   FuncStart += Count;
 
   LLVM_DEBUG(dbgs() << "write func: " << getName() << "\n");
   Buf += encodeULEB128(CompressedFuncSize, Buf);
   const uint8_t *LastRelocEnd = FuncStart;
   for (const WasmRelocation &Rel : Relocations) {
     unsigned ChunkSize = (SecStart + Rel.Offset) - LastRelocEnd;
     LLVM_DEBUG(dbgs() << "  write chunk: " << ChunkSize << "\n");
     memcpy(Buf, LastRelocEnd, ChunkSize);
     Buf += ChunkSize;
     Buf += writeCompressedReloc(Buf, Rel, File->calcNewValue(Rel));
     LastRelocEnd = SecStart + Rel.Offset + getRelocWidthPadded(Rel);
   }
 
   unsigned ChunkSize = End - LastRelocEnd;
   LLVM_DEBUG(dbgs() << "  write final chunk: " << ChunkSize << "\n");
   memcpy(Buf, LastRelocEnd, ChunkSize);
   LLVM_DEBUG(dbgs() << "  total: " << (Buf + ChunkSize - Orig) << "\n");
 }
Index: vendor/lld/dist-release_80/wasm/InputFiles.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/InputFiles.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/InputFiles.cpp	(revision 344173)
@@ -1,479 +1,484 @@
 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace lld;
 using namespace lld::wasm;
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::wasm;
 
 Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   log("Loading: " + Path);
 
   auto MBOrErr = MemoryBuffer::getFile(Path);
   if (auto EC = MBOrErr.getError()) {
     error("cannot open " + Path + ": " + EC.message());
     return None;
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
 InputFile *lld::wasm::createObjectFile(MemoryBufferRef MB) {
   file_magic Magic = identify_magic(MB.getBuffer());
   if (Magic == file_magic::wasm_object)
     return make<ObjFile>(MB);
 
   if (Magic == file_magic::bitcode)
     return make<BitcodeFile>(MB);
 
   fatal("unknown file type: " + MB.getBufferIdentifier());
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() +
       "\n              Symbols : " + Twine(Symbols.size()) +
       "\n     Function Imports : " + Twine(WasmObj->getNumImportedFunctions()) +
       "\n       Global Imports : " + Twine(WasmObj->getNumImportedGlobals()) +
       "\n        Event Imports : " + Twine(WasmObj->getNumImportedEvents()));
 }
 
 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // symbol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
   if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
     assert(TypeIsUsed[Reloc.Index]);
     return TypeMap[Reloc.Index];
   }
   return Symbols[Reloc.Index]->getOutputSymbolIndex();
 }
 
 // Relocations can contain addend for combined sections. This function takes a
 // relocation and returns updated addend by offset in the output section.
 uint32_t ObjFile::calcNewAddend(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     return Reloc.Addend;
   case R_WEBASSEMBLY_SECTION_OFFSET_I32:
     return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 // Calculate the value we expect to find at the relocation location.
 // This is used as a sanity check before applying a relocation to a given
 // location.  It is useful for catching bugs in the compiler and linker.
 uint32_t ObjFile::calcExpectedValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
     const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     return TableEntries[Sym.Info.ElementIndex];
   }
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB: {
     const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     if (Sym.isUndefined())
       return 0;
     const WasmSegment &Segment =
         WasmObj->dataSegments()[Sym.Info.DataRef.Segment];
     return Segment.Data.Offset.Value.Int32 + Sym.Info.DataRef.Offset +
            Reloc.Addend;
   }
   case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
       return Sym->Function->getFunctionInputOffset() +
              Sym->Function->getFunctionCodeOffset() + Reloc.Addend;
     }
     return 0;
   case R_WEBASSEMBLY_SECTION_OFFSET_I32:
     return Reloc.Addend;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return Reloc.Index;
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case R_WEBASSEMBLY_EVENT_INDEX_LEB: {
     const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     return Sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 // Translate from the relocation's index into the final linked output value.
 uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     return getFunctionSymbol(Reloc.Index)->getTableIndex();
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     if (auto *Sym = dyn_cast<DefinedData>(getDataSymbol(Reloc.Index)))
       if (Sym->isLive())
         return Sym->getVirtualAddress() + Reloc.Addend;
     return 0;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return TypeMap[Reloc.Index];
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(Reloc.Index)->getFunctionIndex();
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     return getGlobalSymbol(Reloc.Index)->getGlobalIndex();
   case R_WEBASSEMBLY_EVENT_INDEX_LEB:
     return getEventSymbol(Reloc.Index)->getEventIndex();
   case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
       if (Sym->isLive())
         return Sym->Function->OutputOffset +
                Sym->Function->getFunctionCodeOffset() + Reloc.Addend;
     }
     return 0;
   case R_WEBASSEMBLY_SECTION_OFFSET_I32:
     return getSectionSymbol(Reloc.Index)->Section->OutputOffset + Reloc.Addend;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 template <class T>
 static void setRelocs(const std::vector<T *> &Chunks,
                       const WasmSection *Section) {
   if (!Section)
     return;
 
   ArrayRef<WasmRelocation> Relocs = Section->Relocations;
   assert(std::is_sorted(Relocs.begin(), Relocs.end(),
                         [](const WasmRelocation &R1, const WasmRelocation &R2) {
                           return R1.Offset < R2.Offset;
                         }));
   assert(std::is_sorted(
       Chunks.begin(), Chunks.end(), [](InputChunk *C1, InputChunk *C2) {
         return C1->getInputSectionOffset() < C2->getInputSectionOffset();
       }));
 
   auto RelocsNext = Relocs.begin();
   auto RelocsEnd = Relocs.end();
   auto RelocLess = [](const WasmRelocation &R, uint32_t Val) {
     return R.Offset < Val;
   };
   for (InputChunk *C : Chunks) {
     auto RelocsStart = std::lower_bound(RelocsNext, RelocsEnd,
                                         C->getInputSectionOffset(), RelocLess);
     RelocsNext = std::lower_bound(
         RelocsStart, RelocsEnd, C->getInputSectionOffset() + C->getInputSize(),
         RelocLess);
     C->setRelocations(ArrayRef<WasmRelocation>(RelocsStart, RelocsNext));
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
 
   auto *Obj = dyn_cast<WasmObjectFile>(Bin.get());
   if (!Obj)
     fatal(toString(this) + ": not a wasm file");
   if (!Obj->isRelocatableObject())
     fatal(toString(this) + ": not a relocatable wasm file");
 
   Bin.release();
   WasmObj.reset(Obj);
 
   // Build up a map of function indices to table indices for use when
   // verifying the existing table index relocations
   uint32_t TotalFunctions =
       WasmObj->getNumImportedFunctions() + WasmObj->functions().size();
   TableEntries.resize(TotalFunctions);
   for (const WasmElemSegment &Seg : WasmObj->elements()) {
     if (Seg.Offset.Opcode != WASM_OPCODE_I32_CONST)
       fatal(toString(this) + ": invalid table elements");
     uint32_t Offset = Seg.Offset.Value.Int32;
     for (uint32_t Index = 0; Index < Seg.Functions.size(); Index++) {
 
       uint32_t FunctionIndex = Seg.Functions[Index];
       TableEntries[FunctionIndex] = Offset + Index;
     }
   }
 
   // Find the code and data sections.  Wasm objects can have at most one code
   // and one data section.
   uint32_t SectionIndex = 0;
   for (const SectionRef &Sec : WasmObj->sections()) {
     const WasmSection &Section = WasmObj->getWasmSection(Sec);
     if (Section.Type == WASM_SEC_CODE) {
       CodeSection = &Section;
     } else if (Section.Type == WASM_SEC_DATA) {
       DataSection = &Section;
     } else if (Section.Type == WASM_SEC_CUSTOM) {
       CustomSections.emplace_back(make<InputSection>(Section, this));
       CustomSections.back()->setRelocations(Section.Relocations);
       CustomSectionsByIndex[SectionIndex] = CustomSections.back();
     }
     SectionIndex++;
   }
 
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;
   UsedComdats.resize(Comdats.size());
   for (unsigned I = 0; I < Comdats.size(); ++I)
     UsedComdats[I] = Symtab->addComdat(Comdats[I]);
 
   // Populate `Segments`.
   for (const WasmSegment &S : WasmObj->dataSegments())
     Segments.emplace_back(make<InputSegment>(S, this));
   setRelocs(Segments, DataSection);
 
   // Populate `Functions`.
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
   ArrayRef<WasmSignature> Types = WasmObj->types();
   Functions.reserve(Funcs.size());
 
   for (size_t I = 0, E = Funcs.size(); I != E; ++I)
     Functions.emplace_back(
         make<InputFunction>(Types[FuncTypes[I]], &Funcs[I], this));
   setRelocs(Functions, CodeSection);
 
   // Populate `Globals`.
   for (const WasmGlobal &G : WasmObj->globals())
     Globals.emplace_back(make<InputGlobal>(G, this));
 
   // Populate `Events`.
   for (const WasmEvent &E : WasmObj->events())
     Events.emplace_back(make<InputEvent>(Types[E.Type.SigIndex], E, this));
 
   // Populate `Symbols` based on the WasmSymbols in the object.
   Symbols.reserve(WasmObj->getNumberOfSymbols());
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     if (Symbol *Sym = createDefined(WasmSym))
       Symbols.push_back(Sym);
     else
       Symbols.push_back(createUndefined(WasmSym));
   }
 }
 
 bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const {
   uint32_t C = Chunk->getComdat();
   if (C == UINT32_MAX)
     return false;
   return !UsedComdats[C];
 }
 
 FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   return cast<FunctionSymbol>(Symbols[Index]);
 }
 
 GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
   return cast<GlobalSymbol>(Symbols[Index]);
 }
 
 EventSymbol *ObjFile::getEventSymbol(uint32_t Index) const {
   return cast<EventSymbol>(Symbols[Index]);
 }
 
 SectionSymbol *ObjFile::getSectionSymbol(uint32_t Index) const {
   return cast<SectionSymbol>(Symbols[Index]);
 }
 
 DataSymbol *ObjFile::getDataSymbol(uint32_t Index) const {
   return cast<DataSymbol>(Symbols[Index]);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym) {
   if (!Sym.isDefined())
     return nullptr;
 
   StringRef Name = Sym.Info.Name;
   uint32_t Flags = Sym.Info.Flags;
 
   switch (Sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION: {
     InputFunction *Func =
         Functions[Sym.Info.ElementIndex - WasmObj->getNumImportedFunctions()];
     if (isExcludedByComdat(Func)) {
       Func->Live = false;
       return nullptr;
     }
 
     if (Sym.isBindingLocal())
       return make<DefinedFunction>(Name, Flags, this, Func);
     return Symtab->addDefinedFunction(Name, Flags, this, Func);
   }
   case WASM_SYMBOL_TYPE_DATA: {
     InputSegment *Seg = Segments[Sym.Info.DataRef.Segment];
     if (isExcludedByComdat(Seg)) {
       Seg->Live = false;
       return nullptr;
     }
 
     uint32_t Offset = Sym.Info.DataRef.Offset;
     uint32_t Size = Sym.Info.DataRef.Size;
 
     if (Sym.isBindingLocal())
       return make<DefinedData>(Name, Flags, this, Seg, Offset, Size);
     return Symtab->addDefinedData(Name, Flags, this, Seg, Offset, Size);
   }
   case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *Global =
         Globals[Sym.Info.ElementIndex - WasmObj->getNumImportedGlobals()];
     if (Sym.isBindingLocal())
       return make<DefinedGlobal>(Name, Flags, this, Global);
     return Symtab->addDefinedGlobal(Name, Flags, this, Global);
   }
   case WASM_SYMBOL_TYPE_SECTION: {
     InputSection *Section = CustomSectionsByIndex[Sym.Info.ElementIndex];
     assert(Sym.isBindingLocal());
     return make<SectionSymbol>(Name, Flags, Section, this);
   }
   case WASM_SYMBOL_TYPE_EVENT: {
     InputEvent *Event =
         Events[Sym.Info.ElementIndex - WasmObj->getNumImportedEvents()];
     if (Sym.isBindingLocal())
       return make<DefinedEvent>(Name, Flags, this, Event);
     return Symtab->addDefinedEvent(Name, Flags, this, Event);
   }
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   StringRef Name = Sym.Info.Name;
   uint32_t Flags = Sym.Info.Flags;
 
   switch (Sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION:
-    return Symtab->addUndefinedFunction(Name, Flags, this, Sym.Signature);
+    return Symtab->addUndefinedFunction(Name, Sym.Info.ImportName,
+                                        Sym.Info.ImportModule, Flags, this,
+                                        Sym.Signature);
   case WASM_SYMBOL_TYPE_DATA:
     return Symtab->addUndefinedData(Name, Flags, this);
   case WASM_SYMBOL_TYPE_GLOBAL:
-    return Symtab->addUndefinedGlobal(Name, Flags, this, Sym.GlobalType);
+    return Symtab->addUndefinedGlobal(Name, Sym.Info.ImportName,
+                                      Sym.Info.ImportModule, Flags, this,
+                                      Sym.GlobalType);
   case WASM_SYMBOL_TYPE_SECTION:
     llvm_unreachable("section symbols cannot be undefined");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   LLVM_DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.
   int Count = 0;
   for (const Archive::Symbol &Sym : File->symbols()) {
     Symtab->addLazy(this, &Sym);
     ++Count;
   }
   LLVM_DEBUG(dbgs() << "Read " << Count << " symbols\n");
 }
 
 void ArchiveFile::addMember(const Archive::Symbol *Sym) {
   const Archive::Child &C =
       CHECK(Sym->getMember(),
             "could not get the member for symbol " + Sym->getName());
 
   // Don't try to load the same member twice (this can happen when members
   // mutually reference each other).
   if (!Seen.insert(C.getChildOffset()).second)
     return;
 
   LLVM_DEBUG(dbgs() << "loading lazy: " << Sym->getName() << "\n");
   LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
 
   MemoryBufferRef MB =
       CHECK(C.getMemoryBufferRef(),
             "could not get the buffer for the member defining symbol " +
                 Sym->getName());
 
   InputFile *Obj = createObjectFile(MB);
   Obj->ArchiveName = getName();
   Symtab->addFile(Obj);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes GvVisibility) {
   switch (GvVisibility) {
   case GlobalValue::DefaultVisibility:
     return WASM_SYMBOL_VISIBILITY_DEFAULT;
   case GlobalValue::HiddenVisibility:
   case GlobalValue::ProtectedVisibility:
     return WASM_SYMBOL_VISIBILITY_HIDDEN;
   }
   llvm_unreachable("unknown visibility");
 }
 
 static Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &ObjSym,
                                    BitcodeFile &F) {
   StringRef Name = Saver.save(ObjSym.getName());
 
   uint32_t Flags = ObjSym.isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0;
   Flags |= mapVisibility(ObjSym.getVisibility());
 
   if (ObjSym.isUndefined()) {
     if (ObjSym.isExecutable())
-      return Symtab->addUndefinedFunction(Name, Flags, &F, nullptr);
+      return Symtab->addUndefinedFunction(Name, Name, DefaultModule, Flags, &F,
+                                          nullptr);
     return Symtab->addUndefinedData(Name, Flags, &F);
   }
 
   if (ObjSym.isExecutable())
     return Symtab->addDefinedFunction(Name, Flags, &F, nullptr);
   return Symtab->addDefinedData(Name, Flags, &F, nullptr, 0, 0);
 }
 
 void BitcodeFile::parse() {
   Obj = check(lto::InputFile::create(MemoryBufferRef(
       MB.getBuffer(), Saver.save(ArchiveName + MB.getBufferIdentifier()))));
   Triple T(Obj->getTargetTriple());
   if (T.getArch() != Triple::wasm32) {
     error(toString(MB.getBufferIdentifier()) + ": machine type must be wasm32");
     return;
   }
 
   for (const lto::InputFile::Symbol &ObjSym : Obj->symbols())
     Symbols.push_back(createBitcodeSymbol(ObjSym, *this));
 }
 
 // Returns a string in the format of "foo.o" or "foo.a(bar.o)".
 std::string lld::toString(const wasm::InputFile *File) {
   if (!File)
     return "<internal>";
 
   if (File->ArchiveName.empty())
     return File->getName();
 
   return (File->ArchiveName + "(" + File->getName() + ")").str();
 }
Index: vendor/lld/dist-release_80/wasm/LTO.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/LTO.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/LTO.cpp	(revision 344173)
@@ -1,162 +1,163 @@
 //===- LTO.cpp ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LTO.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/LTO/Caching.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstddef>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::wasm;
 
 static std::unique_ptr<lto::LTO> createLTO() {
   lto::Config C;
   C.Options = InitTargetOptionsFromCodeGenFlags();
 
   // Always emit a section per function/data with LTO.
   C.Options.FunctionSections = true;
   C.Options.DataSections = true;
 
   // Wasm currently only supports ThreadModel::Single
   C.Options.ThreadModel = ThreadModel::Single;
 
   C.DisableVerify = Config->DisableVerify;
   C.DiagHandler = diagnosticHandler;
   C.OptLevel = Config->LTOO;
   C.MAttrs = GetMAttrs();
 
   if (Config->Relocatable)
     C.RelocModel = None;
   else if (Config->Pic)
     C.RelocModel = Reloc::PIC_;
   else
     C.RelocModel = Reloc::Static;
 
   if (Config->SaveTemps)
     checkError(C.addSaveTemps(Config->OutputFile.str() + ".",
                               /*UseInputModulePath*/ true));
 
   lto::ThinBackend Backend;
   if (Config->ThinLTOJobs != -1U)
     Backend = lto::createInProcessThinBackend(Config->ThinLTOJobs);
   return llvm::make_unique<lto::LTO>(std::move(C), Backend,
                                      Config->LTOPartitions);
 }
 
 BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
 static void undefine(Symbol *S) {
   if (auto F = dyn_cast<DefinedFunction>(S))
-    replaceSymbol<UndefinedFunction>(F, F->getName(), 0, F->getFile(),
-                                     F->Signature);
+    replaceSymbol<UndefinedFunction>(F, F->getName(), F->getName(),
+                                     DefaultModule, 0,
+                                     F->getFile(), F->Signature);
   else if (isa<DefinedData>(S))
     replaceSymbol<UndefinedData>(S, S->getName(), 0, S->getFile());
   else
     llvm_unreachable("unexpected symbol kind");
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
   ArrayRef<Symbol *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     Symbol *Sym = Syms[SymNum];
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F;
     R.VisibleToRegularObj = Config->Relocatable || Sym->IsUsedInRegularObj ||
                             (R.Prevailing && Sym->isExported());
     if (R.Prevailing)
       undefine(Sym);
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting objects.
 std::vector<StringRef> BitcodeCompiler::compile() {
   unsigned MaxTasks = LTOObj->getMaxTasks();
   Buf.resize(MaxTasks);
   Files.resize(MaxTasks);
 
   // The --thinlto-cache-dir option specifies the path to a directory in which
   // to cache native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache Cache;
   if (!Config->ThinLTOCacheDir.empty())
     Cache = check(
         lto::localCache(Config->ThinLTOCacheDir,
                         [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
                           Files[Task] = std::move(MB);
                         }));
 
   checkError(LTOObj->run(
       [&](size_t Task) {
         return llvm::make_unique<lto::NativeObjectStream>(
             llvm::make_unique<raw_svector_ostream>(Buf[Task]));
       },
       Cache));
 
   if (!Config->ThinLTOCacheDir.empty())
     pruneCache(Config->ThinLTOCacheDir, Config->ThinLTOCachePolicy);
 
   std::vector<StringRef> Ret;
   for (unsigned I = 0; I != MaxTasks; ++I) {
     if (Buf[I].empty())
       continue;
     if (Config->SaveTemps) {
       if (I == 0)
         saveBuffer(Buf[I], Config->OutputFile + ".lto.o");
       else
         saveBuffer(Buf[I], Config->OutputFile + Twine(I) + ".lto.o");
     }
     Ret.emplace_back(Buf[I].data(), Buf[I].size());
   }
 
   for (std::unique_ptr<MemoryBuffer> &File : Files)
     if (File)
       Ret.push_back(File->getBuffer());
 
   return Ret;
 }
Index: vendor/lld/dist-release_80/wasm/LTO.h
===================================================================
--- vendor/lld/dist-release_80/wasm/LTO.h	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/LTO.h	(revision 344173)
@@ -1,57 +1,58 @@
 //===- LTO.h ----------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides a way to combine bitcode files into one wasm
 // file by compiling them using LLVM.
 //
 // If LTO is in use, your input files are not in regular wasm files
 // but instead LLVM bitcode files. In that case, the linker has to
 // convert bitcode files into the native format so that we can create
 // a wasm file that contains native code. This file provides that
 // functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_LTO_H
 #define LLD_WASM_LTO_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/SmallString.h"
+#include "Writer.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class LTO;
 }
 } // namespace llvm
 
 namespace lld {
 namespace wasm {
 
 class BitcodeFile;
 class InputFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
   void add(BitcodeFile &F);
   std::vector<StringRef> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buf;
   std::vector<std::unique_ptr<MemoryBuffer>> Files;
 };
 } // namespace wasm
 } // namespace lld
 
 #endif
Index: vendor/lld/dist-release_80/wasm/MarkLive.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/MarkLive.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/MarkLive.cpp	(revision 344173)
@@ -1,120 +1,120 @@
 //===- MarkLive.cpp -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements --gc-sections, which is a feature to remove unused
 // chunks from the output. Unused chunks are those that are not reachable from
 // known root symbols or chunks. This feature is implemented as a mark-sweep
 // garbage collector.
 //
 // Here's how it works. Each InputChunk has a "Live" bit. The bit is off by
 // default. Starting with the GC-roots, visit all reachable chunks and set their
 // Live bits. The Writer will then ignore chunks whose Live bits are off, so
 // that such chunk are not appear in the output.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MarkLive.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 void lld::wasm::markLive() {
   if (!Config->GcSections)
     return;
 
   LLVM_DEBUG(dbgs() << "markLive\n");
   SmallVector<InputChunk *, 256> Q;
 
   auto Enqueue = [&](Symbol *Sym) {
     if (!Sym || Sym->isLive())
       return;
     LLVM_DEBUG(dbgs() << "markLive: " << Sym->getName() << "\n");
     Sym->markLive();
     if (InputChunk *Chunk = Sym->getChunk())
       Q.push_back(Chunk);
   };
 
   // Add GC root symbols.
   if (!Config->Entry.empty())
     Enqueue(Symtab->find(Config->Entry));
   Enqueue(WasmSym::CallCtors);
 
   // We need to preserve any exported symbol
   for (Symbol *Sym : Symtab->getSymbols())
     if (Sym->isExported())
       Enqueue(Sym);
 
   // The ctor functions are all used in the synthetic __wasm_call_ctors
   // function, but since this function is created in-place it doesn't contain
   // relocations which mean we have to manually mark the ctors.
   for (const ObjFile *Obj : Symtab->ObjectFiles) {
     const WasmLinkingData &L = Obj->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions)
       Enqueue(Obj->getFunctionSymbol(F.Symbol));
   }
 
   // Follow relocations to mark all reachable chunks.
   while (!Q.empty()) {
     InputChunk *C = Q.pop_back_val();
 
     for (const WasmRelocation Reloc : C->getRelocations()) {
       if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB)
         continue;
       Symbol *Sym = C->File->getSymbol(Reloc.Index);
 
       // If the function has been assigned the special index zero in the table,
       // the relocation doesn't pull in the function body, since the function
       // won't actually go in the table (the runtime will trap attempts to call
       // that index, since we don't use it).  A function with a table index of
       // zero is only reachable via "call", not via "call_indirect".  The stub
       // functions used for weak-undefined symbols have this behaviour (compare
       // equal to null pointer, only reachable via direct call).
       if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB ||
           Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32) {
-        FunctionSymbol *FuncSym = cast<FunctionSymbol>(Sym);
+        auto *FuncSym = cast<FunctionSymbol>(Sym);
         if (FuncSym->hasTableIndex() && FuncSym->getTableIndex() == 0)
           continue;
       }
 
       Enqueue(Sym);
     }
   }
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections) {
     for (const ObjFile *Obj : Symtab->ObjectFiles) {
       for (InputChunk *C : Obj->Functions)
         if (!C->Live)
           message("removing unused section " + toString(C));
       for (InputChunk *C : Obj->Segments)
         if (!C->Live)
           message("removing unused section " + toString(C));
       for (InputGlobal *G : Obj->Globals)
         if (!G->Live)
           message("removing unused section " + toString(G));
       for (InputEvent *E : Obj->Events)
         if (!E->Live)
           message("removing unused section " + toString(E));
     }
     for (InputChunk *C : Symtab->SyntheticFunctions)
       if (!C->Live)
         message("removing unused section " + toString(C));
     for (InputGlobal *G : Symtab->SyntheticGlobals)
       if (!G->Live)
         message("removing unused section " + toString(G));
   }
 }
Index: vendor/lld/dist-release_80/wasm/SymbolTable.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/SymbolTable.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/SymbolTable.cpp	(revision 344173)
@@ -1,394 +1,398 @@
 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::wasm;
 
 SymbolTable *lld::wasm::Symtab;
 
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   File->parse();
 
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File))
     BitcodeFiles.push_back(F);
   else if (auto *F = dyn_cast<ObjFile>(File))
     ObjectFiles.push_back(F);
 }
 
 // This function is where all the optimizations of link-time
 // optimization happens. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that the program consists of are passed
 // to the compiler at once, it can do whole-program optimization.
 void SymbolTable::addCombinedLTOObject() {
   if (BitcodeFiles.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFiles)
     LTO->add(*F);
 
   for (StringRef Filename : LTO->compile()) {
     auto *Obj = make<ObjFile>(MemoryBufferRef(Filename, "lto.tmp"));
     Obj->parse();
     ObjectFiles.push_back(Obj);
   }
 }
 
 void SymbolTable::reportRemainingUndefines() {
   for (Symbol *Sym : SymVector) {
     if (!Sym->isUndefined() || Sym->isWeak())
       continue;
     if (Config->AllowUndefinedSymbols.count(Sym->getName()) != 0)
       continue;
     if (!Sym->IsUsedInRegularObj)
       continue;
     error(toString(Sym->getFile()) + ": undefined symbol: " + toString(*Sym));
   }
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   return SymMap.lookup(CachedHashStringRef(Name));
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, InputFile *File) {
   bool Inserted = false;
   Symbol *&Sym = SymMap[CachedHashStringRef(Name)];
   if (!Sym) {
     Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
     Sym->IsUsedInRegularObj = false;
     SymVector.emplace_back(Sym);
     Inserted = true;
   }
   if (!File || File->kind() == InputFile::ObjectKind)
     Sym->IsUsedInRegularObj = true;
   return {Sym, Inserted};
 }
 
 static void reportTypeError(const Symbol *Existing, const InputFile *File,
                             llvm::wasm::WasmSymbolType Type) {
   error("symbol type mismatch: " + toString(*Existing) + "\n>>> defined as " +
         toString(Existing->getWasmType()) + " in " +
         toString(Existing->getFile()) + "\n>>> defined as " + toString(Type) +
         " in " + toString(File));
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkFunctionType(Symbol *Existing, const InputFile *File,
                               const WasmSignature *NewSig) {
   auto ExistingFunction = dyn_cast<FunctionSymbol>(Existing);
   if (!ExistingFunction) {
     reportTypeError(Existing, File, WASM_SYMBOL_TYPE_FUNCTION);
     return;
   }
 
   if (!NewSig)
     return;
 
   const WasmSignature *OldSig = ExistingFunction->Signature;
   if (!OldSig) {
     ExistingFunction->Signature = NewSig;
     return;
   }
 
   if (*NewSig != *OldSig)
     warn("function signature mismatch: " + Existing->getName() +
          "\n>>> defined as " + toString(*OldSig) + " in " +
          toString(Existing->getFile()) + "\n>>> defined as " +
          toString(*NewSig) + " in " + toString(File));
 }
 
 static void checkGlobalType(const Symbol *Existing, const InputFile *File,
                             const WasmGlobalType *NewType) {
   if (!isa<GlobalSymbol>(Existing)) {
     reportTypeError(Existing, File, WASM_SYMBOL_TYPE_GLOBAL);
     return;
   }
 
   const WasmGlobalType *OldType = cast<GlobalSymbol>(Existing)->getGlobalType();
   if (*NewType != *OldType) {
     error("Global type mismatch: " + Existing->getName() + "\n>>> defined as " +
           toString(*OldType) + " in " + toString(Existing->getFile()) +
           "\n>>> defined as " + toString(*NewType) + " in " + toString(File));
   }
 }
 
 static void checkEventType(const Symbol *Existing, const InputFile *File,
                            const WasmEventType *NewType,
                            const WasmSignature *NewSig) {
   auto ExistingEvent = dyn_cast<EventSymbol>(Existing);
   if (!isa<EventSymbol>(Existing)) {
     reportTypeError(Existing, File, WASM_SYMBOL_TYPE_EVENT);
     return;
   }
 
   const WasmEventType *OldType = cast<EventSymbol>(Existing)->getEventType();
   const WasmSignature *OldSig = ExistingEvent->Signature;
   if (NewType->Attribute != OldType->Attribute)
     error("Event type mismatch: " + Existing->getName() + "\n>>> defined as " +
           toString(*OldType) + " in " + toString(Existing->getFile()) +
           "\n>>> defined as " + toString(*NewType) + " in " + toString(File));
   if (*NewSig != *OldSig)
     warn("Event signature mismatch: " + Existing->getName() +
          "\n>>> defined as " + toString(*OldSig) + " in " +
          toString(Existing->getFile()) + "\n>>> defined as " +
          toString(*NewSig) + " in " + toString(File));
 }
 
 static void checkDataType(const Symbol *Existing, const InputFile *File) {
   if (!isa<DataSymbol>(Existing))
     reportTypeError(Existing, File, WASM_SYMBOL_TYPE_DATA);
 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    uint32_t Flags,
                                                    InputFunction *Function) {
   LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   assert(!find(Name));
   SyntheticFunctions.emplace_back(Function);
   return replaceSymbol<DefinedFunction>(insert(Name, nullptr).first, Name,
                                         Flags, nullptr, Function);
 }
 
 DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
                                                  uint32_t Flags) {
   LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   assert(!find(Name));
   return replaceSymbol<DefinedData>(insert(Name, nullptr).first, Name, Flags);
 }
 
 DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                                InputGlobal *Global) {
   LLVM_DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global
                     << "\n");
   assert(!find(Name));
   SyntheticGlobals.emplace_back(Global);
   return replaceSymbol<DefinedGlobal>(insert(Name, nullptr).first, Name, Flags,
                                       nullptr, Global);
 }
 
 static bool shouldReplace(const Symbol *Existing, InputFile *NewFile,
                           uint32_t NewFlags) {
   // If existing symbol is undefined, replace it.
   if (!Existing->isDefined()) {
     LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: "
                       << Existing->getName() << "\n");
     return true;
   }
 
   // Now we have two defined symbols. If the new one is weak, we can ignore it.
   if ((NewFlags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
     LLVM_DEBUG(dbgs() << "existing symbol takes precedence\n");
     return false;
   }
 
   // If the existing symbol is weak, we should replace it.
   if (Existing->isWeak()) {
     LLVM_DEBUG(dbgs() << "replacing existing weak symbol\n");
     return true;
   }
 
   // Neither symbol is week. They conflict.
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
   return true;
 }
 
 Symbol *SymbolTable::addDefinedFunction(StringRef Name, uint32_t Flags,
                                         InputFile *File,
                                         InputFunction *Function) {
   LLVM_DEBUG(dbgs() << "addDefinedFunction: " << Name << " ["
                     << (Function ? toString(Function->Signature) : "none")
                     << "]\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedFunction>(S, Name, Flags, File, Function);
     return S;
   }
 
   if (Function)
     checkFunctionType(S, File, &Function->Signature);
 
   if (shouldReplace(S, File, Flags)) {
     // If the new defined function doesn't have signture (i.e. bitcode
     // functions) but the old symbols does then preserve the old signature
     const WasmSignature *OldSig = nullptr;
     if (auto* F = dyn_cast<FunctionSymbol>(S))
       OldSig = F->Signature;
     auto NewSym = replaceSymbol<DefinedFunction>(S, Name, Flags, File, Function);
     if (!NewSym->Signature)
       NewSym->Signature = OldSig;
   }
   return S;
 }
 
 Symbol *SymbolTable::addDefinedData(StringRef Name, uint32_t Flags,
                                     InputFile *File, InputSegment *Segment,
                                     uint32_t Address, uint32_t Size) {
   LLVM_DEBUG(dbgs() << "addDefinedData:" << Name << " addr:" << Address
                     << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedData>(S, Name, Flags, File, Segment, Address, Size);
     return S;
   }
 
   checkDataType(S, File);
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedData>(S, Name, Flags, File, Segment, Address, Size);
   return S;
 }
 
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Flags,
                                       InputFile *File, InputGlobal *Global) {
   LLVM_DEBUG(dbgs() << "addDefinedGlobal:" << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global);
     return S;
   }
 
   checkGlobalType(S, File, &Global->getType());
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedGlobal>(S, Name, Flags, File, Global);
   return S;
 }
 
 Symbol *SymbolTable::addDefinedEvent(StringRef Name, uint32_t Flags,
                                      InputFile *File, InputEvent *Event) {
   LLVM_DEBUG(dbgs() << "addDefinedEvent:" << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted || S->isLazy()) {
     replaceSymbol<DefinedEvent>(S, Name, Flags, File, Event);
     return S;
   }
 
   checkEventType(S, File, &Event->getType(), &Event->Signature);
 
   if (shouldReplace(S, File, Flags))
     replaceSymbol<DefinedEvent>(S, Name, Flags, File, Event);
   return S;
 }
 
-Symbol *SymbolTable::addUndefinedFunction(StringRef Name, uint32_t Flags,
-                                          InputFile *File,
+Symbol *SymbolTable::addUndefinedFunction(StringRef Name, StringRef ImportName,
+                                          StringRef ImportModule,
+                                          uint32_t Flags, InputFile *File,
                                           const WasmSignature *Sig) {
   LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name <<
              " [" << (Sig ? toString(*Sig) : "none") << "]\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted)
-    replaceSymbol<UndefinedFunction>(S, Name, Flags, File, Sig);
+    replaceSymbol<UndefinedFunction>(S, Name, ImportName, ImportModule, Flags,
+                                     File, Sig);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else
     checkFunctionType(S, File, Sig);
 
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedData(StringRef Name, uint32_t Flags,
                                       InputFile *File) {
   LLVM_DEBUG(dbgs() << "addUndefinedData: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted)
     replaceSymbol<UndefinedData>(S, Name, Flags, File);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkDataType(S, File);
   return S;
 }
 
-Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, uint32_t Flags,
+Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, StringRef ImportName,
+                                        StringRef ImportModule, uint32_t Flags,
                                         InputFile *File,
                                         const WasmGlobalType *Type) {
   LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
 
   if (WasInserted)
-    replaceSymbol<UndefinedGlobal>(S, Name, Flags, File, Type);
+    replaceSymbol<UndefinedGlobal>(S, Name, ImportName, ImportModule, Flags,
+                                   File, Type);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkGlobalType(S, File, Type);
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *File, const Archive::Symbol *Sym) {
   LLVM_DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, nullptr);
 
   if (WasInserted) {
     replaceSymbol<LazySymbol>(S, Name, File, *Sym);
     return;
   }
 
   // If there is an existing undefined symbol, load a new one from the archive.
   if (S->isUndefined()) {
     LLVM_DEBUG(dbgs() << "replacing existing undefined\n");
     File->addMember(Sym);
   }
 }
 
 bool SymbolTable::addComdat(StringRef Name) {
   return Comdats.insert(CachedHashStringRef(Name)).second;
 }
Index: vendor/lld/dist-release_80/wasm/SymbolTable.h
===================================================================
--- vendor/lld/dist-release_80/wasm/SymbolTable.h	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/SymbolTable.h	(revision 344173)
@@ -1,95 +1,97 @@
 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_SYMBOL_TABLE_H
 #define LLD_WASM_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "LTO.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
 // SymbolTable selects the "best" symbols if there are name
 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in the
 // add*() functions, which are called by input files as they are parsed.
 // There is one add* function per symbol type.
 class SymbolTable {
 public:
   void addFile(InputFile *File);
   void addCombinedLTOObject();
 
   std::vector<ObjFile *> ObjectFiles;
   std::vector<BitcodeFile *> BitcodeFiles;
   std::vector<InputFunction *> SyntheticFunctions;
   std::vector<InputGlobal *> SyntheticGlobals;
 
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
 
   Symbol *addDefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
                              InputFunction *Function);
   Symbol *addDefinedData(StringRef Name, uint32_t Flags, InputFile *File,
                          InputSegment *Segment, uint32_t Address,
                          uint32_t Size);
   Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                            InputGlobal *G);
   Symbol *addDefinedEvent(StringRef Name, uint32_t Flags, InputFile *File,
                           InputEvent *E);
 
-  Symbol *addUndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
-                               const WasmSignature *Signature);
+  Symbol *addUndefinedFunction(StringRef Name, StringRef ImportName,
+                               StringRef ImportModule, uint32_t Flags,
+                               InputFile *File, const WasmSignature *Signature);
   Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File);
-  Symbol *addUndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
-                             const WasmGlobalType *Type);
+  Symbol *addUndefinedGlobal(StringRef Name, StringRef ImportName,
+                             StringRef ImportModule,  uint32_t Flags,
+                             InputFile *File, const WasmGlobalType *Type);
 
   void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym);
 
   bool addComdat(StringRef Name);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags);
   DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                     InputGlobal *Global);
   DefinedFunction *addSyntheticFunction(StringRef Name, uint32_t Flags,
                                         InputFunction *Function);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name, InputFile *File);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
   std::vector<Symbol *> SymVector;
 
   llvm::DenseSet<llvm::CachedHashStringRef> Comdats;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif
Index: vendor/lld/dist-release_80/wasm/Symbols.h
===================================================================
--- vendor/lld/dist-release_80/wasm/Symbols.h	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/Symbols.h	(revision 344173)
@@ -1,406 +1,417 @@
 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 using llvm::wasm::WasmSymbolType;
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
 class InputEvent;
 class InputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
     DefinedEventKind,
     SectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
     LazyKind,
   };
 
   Kind kind() const { return SymbolKind; }
 
   bool isDefined() const {
     return SymbolKind == DefinedFunctionKind || SymbolKind == DefinedDataKind ||
            SymbolKind == DefinedGlobalKind || SymbolKind == DefinedEventKind ||
            SymbolKind == SectionKind;
   }
 
   bool isUndefined() const {
     return SymbolKind == UndefinedFunctionKind ||
            SymbolKind == UndefinedDataKind || SymbolKind == UndefinedGlobalKind;
   }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
 
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
 
   InputChunk *getChunk() const;
 
   // Indicates that the section or import for this symbol will be included in
   // the final image.
   bool isLive() const;
 
   // Marks the symbol's InputChunk as Live, so that it will be included in the
   // final image.
   void markLive();
 
   void setHidden(bool IsHidden);
 
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
   WasmSymbolType getWasmType() const;
   bool isExported() const;
 
   // True if this symbol was referenced by a regular (non-bitcode) object.
   unsigned IsUsedInRegularObj : 1;
   unsigned ForceExport : 1;
 
 protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
       : IsUsedInRegularObj(false), ForceExport(false), Name(Name),
         SymbolKind(K), Flags(Flags), File(F), Referenced(!Config->GcSections) {}
 
   StringRef Name;
   Kind SymbolKind;
   uint32_t Flags;
   InputFile *File;
   uint32_t OutputSymbolIndex = INVALID_INDEX;
   bool Referenced;
 };
 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }
 
   // Get/set the table index
   void setTableIndex(uint32_t Index);
   uint32_t getTableIndex() const;
   bool hasTableIndex() const;
 
   // Get/set the function index
   uint32_t getFunctionIndex() const;
   void setFunctionIndex(uint32_t Index);
   bool hasFunctionIndex() const;
 
   const WasmSignature *Signature;
 
 protected:
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
                  const WasmSignature *Sig)
       : Symbol(Name, K, Flags, F), Signature(Sig) {}
 
   uint32_t TableIndex = INVALID_INDEX;
   uint32_t FunctionIndex = INVALID_INDEX;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
                   InputFunction *Function);
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
 
   InputFunction *Function;
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
-  UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
+  UndefinedFunction(StringRef Name, StringRef ImportName,
+                    StringRef ImportModule, uint32_t Flags,
+                    InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
-      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
+      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type),
+        ImportName(ImportName), ImportModule(ImportModule) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
+
+  StringRef ImportName;
+  StringRef ImportModule;
 };
 
 class SectionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == SectionKind; }
 
   SectionSymbol(StringRef Name, uint32_t Flags, const InputSection *S,
                 InputFile *F = nullptr)
       : Symbol(Name, SectionKind, Flags, F), Section(S) {}
 
   const InputSection *Section;
 
   uint32_t getOutputSectionIndex() const;
   void setOutputSectionIndex(uint32_t Index);
 
 protected:
   uint32_t OutputSectionIndex = INVALID_INDEX;
 };
 
 class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind;
   }
 
 protected:
   DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
       : Symbol(Name, K, Flags, F) {}
 };
 
 class DefinedData : public DataSymbol {
 public:
   // Constructor for regular data symbols originating from input files.
   DefinedData(StringRef Name, uint32_t Flags, InputFile *F,
               InputSegment *Segment, uint32_t Offset, uint32_t Size)
       : DataSymbol(Name, DefinedDataKind, Flags, F), Segment(Segment),
         Offset(Offset), Size(Size) {}
 
   // Constructor for linker synthetic data symbols.
   DefinedData(StringRef Name, uint32_t Flags)
       : DataSymbol(Name, DefinedDataKind, Flags, nullptr) {}
 
   static bool classof(const Symbol *S) { return S->kind() == DefinedDataKind; }
 
   // Returns the output virtual address of a defined data symbol.
   uint32_t getVirtualAddress() const;
   void setVirtualAddress(uint32_t VA);
 
   // Returns the offset of a defined data symbol within its OutputSegment.
   uint32_t getOutputSegmentOffset() const;
   uint32_t getOutputSegmentIndex() const;
   uint32_t getSize() const { return Size; }
 
   InputSegment *Segment = nullptr;
 
 protected:
   uint32_t Offset = 0;
   uint32_t Size = 0;
 };
 
 class UndefinedData : public DataSymbol {
 public:
   UndefinedData(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
       : DataSymbol(Name, UndefinedDataKind, Flags, File) {}
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedDataKind;
   }
 };
 
 class GlobalSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
   }
 
   const WasmGlobalType *getGlobalType() const { return GlobalType; }
 
   // Get/set the global index
   uint32_t getGlobalIndex() const;
   void setGlobalIndex(uint32_t Index);
   bool hasGlobalIndex() const;
 
 protected:
   GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
                const WasmGlobalType *GlobalType)
       : Symbol(Name, K, Flags, F), GlobalType(GlobalType) {}
 
   const WasmGlobalType *GlobalType;
   uint32_t GlobalIndex = INVALID_INDEX;
 };
 
 class DefinedGlobal : public GlobalSymbol {
 public:
   DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                 InputGlobal *Global);
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind;
   }
 
   InputGlobal *Global;
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
-  UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
+  UndefinedGlobal(StringRef Name, StringRef ImportName, StringRef ImportModule,
+                  uint32_t Flags, InputFile *File = nullptr,
                   const WasmGlobalType *Type = nullptr)
-      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type) {}
+      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type),
+        ImportName(ImportName), ImportModule(ImportModule) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
+
+  StringRef ImportName;
+  StringRef ImportModule;
 };
 
 // Wasm events are features that suspend the current execution and transfer the
 // control flow to a corresponding handler. Currently the only supported event
 // kind is exceptions.
 //
 // Event tags are values to distinguish different events. For exceptions, they
 // can be used to distinguish different language's exceptions, i.e., all C++
 // exceptions have the same tag. Wasm can generate code capable of doing
 // different handling actions based on the tag of caught exceptions.
 //
 // A single EventSymbol object represents a single tag. C++ exception event
 // symbol is a weak symbol generated in every object file in which exceptions
 // are used, and has name '__cpp_exception' for linking.
 class EventSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == DefinedEventKind; }
 
   const WasmEventType *getEventType() const { return EventType; }
 
   // Get/set the event index
   uint32_t getEventIndex() const;
   void setEventIndex(uint32_t Index);
   bool hasEventIndex() const;
 
   const WasmSignature *Signature;
 
 protected:
   EventSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
               const WasmEventType *EventType, const WasmSignature *Sig)
       : Symbol(Name, K, Flags, F), Signature(Sig), EventType(EventType) {}
 
   const WasmEventType *EventType;
   uint32_t EventIndex = INVALID_INDEX;
 };
 
 class DefinedEvent : public EventSymbol {
 public:
   DefinedEvent(StringRef Name, uint32_t Flags, InputFile *File,
                InputEvent *Event);
 
   static bool classof(const Symbol *S) { return S->kind() == DefinedEventKind; }
 
   InputEvent *Event;
 };
 
 class LazySymbol : public Symbol {
 public:
   LazySymbol(StringRef Name, InputFile *File,
              const llvm::object::Archive::Symbol &Sym)
       : Symbol(Name, LazyKind, 0, File), ArchiveSymbol(Sym) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyKind; }
   void fetch();
 
 private:
   llvm::object::Archive::Symbol ArchiveSymbol;
 };
 
 // linker-generated symbols
 struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
   static GlobalSymbol *StackPointer;
 
   // __data_end
   // Symbol marking the end of the data and bss.
   static DefinedData *DataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.
   static DefinedData *HeapBase;
 
   // __wasm_call_ctors
   // Function that directly calls all ctors in priority order.
   static DefinedFunction *CallCtors;
 
   // __dso_handle
   // Symbol used in calls to __cxa_atexit to determine current DLL
   static DefinedData *DsoHandle;
 
   // __table_base
   // Used in PIC code for offset of indirect function table
   static UndefinedGlobal *TableBase;
 
   // __memory_base
   // Used in PIC code for offset of global data
   static UndefinedGlobal *MemoryBase;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
   alignas(DefinedData) char B[sizeof(DefinedData)];
   alignas(DefinedGlobal) char C[sizeof(DefinedGlobal)];
   alignas(DefinedEvent) char D[sizeof(DefinedEvent)];
   alignas(LazySymbol) char E[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char F[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char G[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char H[sizeof(UndefinedGlobal)];
   alignas(SectionSymbol) char I[sizeof(SectionSymbol)];
 };
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
 
   Symbol SymCopy = *S;
 
   T *S2 = new (S) T(std::forward<ArgT>(Arg)...);
   S2->IsUsedInRegularObj = SymCopy.IsUsedInRegularObj;
   S2->ForceExport = SymCopy.ForceExport;
   return S2;
 }
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
 std::string maybeDemangleSymbol(StringRef Name);
 
 } // namespace lld
 
 #endif
Index: vendor/lld/dist-release_80/wasm/Writer.cpp
===================================================================
--- vendor/lld/dist-release_80/wasm/Writer.cpp	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/Writer.cpp	(revision 344173)
@@ -1,1201 +1,1223 @@
 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/WasmTraits.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
 
 #include <cstdarg>
 #include <map>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
-static constexpr int kStackAlignment = 16;
-static constexpr const char *kFunctionTableName = "__indirect_function_table";
+static constexpr int StackAlignment = 16;
+static constexpr const char *FunctionTableName = "__indirect_function_table";
+const char *lld::wasm::DefaultModule = "env";
 
 namespace {
 
 // An init entry to be written to either the synthetic init func or the
 // linking metadata.
 struct WasmInitEntry {
   const FunctionSymbol *Sym;
   uint32_t Priority;
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   void run();
 
 private:
   void openFile();
 
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
 
   void createCtorFunction();
   void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateExports();
   void calculateCustomSections();
   void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type, StringRef Name = "");
 
   // Builtin sections
   void createTypeSection();
   void createFunctionSection();
   void createTableSection();
   void createGlobalSection();
   void createEventSection();
   void createExportSection();
   void createImportSection();
   void createMemorySection();
   void createElemSection();
   void createCodeSection();
   void createDataSection();
   void createCustomSections();
 
   // Custom sections
   void createDylinkSection();
   void createRelocSections();
   void createLinkingSection();
   void createNameSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t TableBase = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t MaxMemoryPages = 0;
   // Memory size and aligment. Written to the "dylink" section
   // when build with -shared or -pie.
   uint32_t MemAlign = 0;
   uint32_t MemSize = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t> TypeIndices;
   std::vector<const Symbol *> ImportedSymbols;
   unsigned NumImportedFunctions = 0;
   unsigned NumImportedGlobals = 0;
   unsigned NumImportedEvents = 0;
   std::vector<WasmExport> Exports;
   std::vector<const DefinedData *> DefinedFakeGlobals;
   std::vector<InputGlobal *> InputGlobals;
   std::vector<InputFunction *> InputFunctions;
   std::vector<InputEvent *> InputEvents;
   std::vector<const FunctionSymbol *> IndirectFunctions;
   std::vector<const Symbol *> SymtabEntries;
   std::vector<WasmInitEntry> InitFunctions;
 
   llvm::StringMap<std::vector<InputSection *>> CustomSectionMapping;
   llvm::StringMap<SectionSymbol *> CustomSectionSymbols;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
 };
 
 } // anonymous namespace
 
 void Writer::createImportSection() {
   uint32_t NumImports = ImportedSymbols.size();
   if (Config->ImportMemory)
     ++NumImports;
   if (Config->ImportTable)
     ++NumImports;
 
   if (NumImports == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_IMPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumImports, "import count");
 
   if (Config->ImportMemory) {
     WasmImport Import;
-    Import.Module = "env";
+    Import.Module = DefaultModule;
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
     Import.Memory.Flags = 0;
     Import.Memory.Initial = NumMemoryPages;
     if (MaxMemoryPages != 0) {
       Import.Memory.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
       Import.Memory.Maximum = MaxMemoryPages;
     }
     if (Config->SharedMemory)
       Import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED;
     writeImport(OS, Import);
   }
 
   if (Config->ImportTable) {
     uint32_t TableSize = TableBase + IndirectFunctions.size();
     WasmImport Import;
-    Import.Module = "env";
-    Import.Field = kFunctionTableName;
+    Import.Module = DefaultModule;
+    Import.Field = FunctionTableName;
     Import.Kind = WASM_EXTERNAL_TABLE;
     Import.Table.ElemType = WASM_TYPE_FUNCREF;
     Import.Table.Limits = {0, TableSize, 0};
     writeImport(OS, Import);
   }
 
   for (const Symbol *Sym : ImportedSymbols) {
     WasmImport Import;
-    Import.Module = "env";
-    Import.Field = Sym->getName();
+    if (auto *F = dyn_cast<UndefinedFunction>(Sym)) {
+      Import.Field = F->ImportName;
+      Import.Module = F->ImportModule;
+    } else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) {
+      Import.Field = G->ImportName;
+      Import.Module = G->ImportModule;
+    } else {
+      Import.Field = Sym->getName();
+      Import.Module = DefaultModule;
+    }
+
     if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) {
       Import.Kind = WASM_EXTERNAL_FUNCTION;
       Import.SigIndex = lookupType(*FunctionSym->Signature);
     } else if (auto *GlobalSym = dyn_cast<GlobalSymbol>(Sym)) {
       Import.Kind = WASM_EXTERNAL_GLOBAL;
       Import.Global = *GlobalSym->getGlobalType();
     } else {
       auto *EventSym = cast<EventSymbol>(Sym);
       Import.Kind = WASM_EXTERNAL_EVENT;
       Import.Event.Attribute = EventSym->getEventType()->Attribute;
       Import.Event.SigIndex = lookupType(*EventSym->Signature);
     }
     writeImport(OS, Import);
   }
 }
 
 void Writer::createTypeSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE);
   raw_ostream &OS = Section->getStream();
   writeUleb128(OS, Types.size(), "type count");
   for (const WasmSignature *Sig : Types)
     writeSig(OS, *Sig);
 }
 
 void Writer::createFunctionSection() {
   if (InputFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_FUNCTION);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, InputFunctions.size(), "function count");
   for (const InputFunction *Func : InputFunctions)
     writeUleb128(OS, lookupType(Func->Signature), "sig index");
 }
 
 void Writer::createMemorySection() {
   if (Config->ImportMemory)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_MEMORY);
   raw_ostream &OS = Section->getStream();
 
   bool HasMax = MaxMemoryPages != 0;
   writeUleb128(OS, 1, "memory count");
   unsigned Flags = 0;
   if (HasMax)
     Flags |= WASM_LIMITS_FLAG_HAS_MAX;
   if (Config->SharedMemory)
     Flags |= WASM_LIMITS_FLAG_IS_SHARED;
   writeUleb128(OS, Flags, "memory limits flags");
   writeUleb128(OS, NumMemoryPages, "initial pages");
   if (HasMax)
     writeUleb128(OS, MaxMemoryPages, "max pages");
 }
 
 void Writer::createGlobalSection() {
   unsigned NumGlobals = InputGlobals.size() + DefinedFakeGlobals.size();
   if (NumGlobals == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumGlobals, "global count");
   for (const InputGlobal *G : InputGlobals)
     writeGlobal(OS, G->Global);
   for (const DefinedData *Sym : DefinedFakeGlobals) {
     WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, false};
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 // The event section contains a list of declared wasm events associated with the
 // module. Currently the only supported event kind is exceptions. A single event
 // entry represents a single event with an event tag. All C++ exceptions are
 // represented by a single event. An event entry in this section contains
 // information on what kind of event it is (e.g. exception) and the type of
 // values contained in a single event object. (In wasm, an event can contain
 // multiple values of primitive types. But for C++ exceptions, we just throw a
 // pointer which is an i32 value (for wasm32 architecture), so the signature of
 // C++ exception is (i32)->(void), because all event types are assumed to have
 // void return type to share WasmSignature with functions.)
 void Writer::createEventSection() {
   unsigned NumEvents = InputEvents.size();
   if (NumEvents == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_EVENT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumEvents, "event count");
   for (InputEvent *E : InputEvents) {
     E->Event.Type.SigIndex = lookupType(E->Signature);
     writeEvent(OS, E->Event);
   }
 }
 
 void Writer::createTableSection() {
   if (Config->ImportTable)
     return;
 
   // Always output a table section (or table import), even if there are no
   // indirect calls.  There are two reasons for this:
   //  1. For executables it is useful to have an empty table slot at 0
   //     which can be filled with a null function call handler.
   //  2. If we don't do this, any program that contains a call_indirect but
   //     no address-taken function will fail at validation time since it is
   //     a validation error to include a call_indirect instruction if there
   //     is not table.
   uint32_t TableSize = TableBase + IndirectFunctions.size();
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TABLE);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "table count");
   WasmLimits Limits = {WASM_LIMITS_FLAG_HAS_MAX, TableSize, TableSize};
   writeTableType(OS, WasmTable{WASM_TYPE_FUNCREF, Limits});
 }
 
 void Writer::createExportSection() {
   if (!Exports.size())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_EXPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, Exports.size(), "export count");
   for (const WasmExport &Export : Exports)
     writeExport(OS, Export);
 }
 
 void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool StripDebug = Config->StripDebug || Config->StripAll;
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSection *Section : File->CustomSections) {
       StringRef Name = Section->getName();
       // These custom sections are known the linker and synthesized rather than
       // blindly copied
       if (Name == "linking" || Name == "name" || Name.startswith("reloc."))
         continue;
       // .. or it is a debug section
       if (StripDebug && Name.startswith(".debug_"))
         continue;
       CustomSectionMapping[Name].push_back(Section);
     }
   }
 }
 
 void Writer::createCustomSections() {
   log("createCustomSections");
   for (auto &Pair : CustomSectionMapping) {
     StringRef Name = Pair.first();
 
     auto P = CustomSectionSymbols.find(Name);
     if (P != CustomSectionSymbols.end()) {
       uint32_t SectionIndex = OutputSections.size();
       P->second->setOutputSectionIndex(SectionIndex);
     }
 
     LLVM_DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
     OutputSections.push_back(make<CustomSection>(Name, Pair.second));
   }
 }
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_ELEM);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "segment count");
   writeUleb128(OS, 0, "table index");
   WasmInitExpr InitExpr;
   if (Config->Pic) {
     InitExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
     InitExpr.Value.Global = WasmSym::TableBase->getGlobalIndex();
   } else {
     InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     InitExpr.Value.Int32 = TableBase;
   }
   writeInitExpr(OS, InitExpr);
   writeUleb128(OS, IndirectFunctions.size(), "elem count");
 
   uint32_t TableIndex = TableBase;
   for (const FunctionSymbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getFunctionIndex(), "function index");
     ++TableIndex;
   }
 }
 
 void Writer::createCodeSection() {
   if (InputFunctions.empty())
     return;
 
   log("createCodeSection");
 
   auto Section = make<CodeSection>(InputFunctions);
   OutputSections.push_back(Section);
 }
 
 void Writer::createDataSection() {
   if (!Segments.size())
     return;
 
   log("createDataSection");
   auto Section = make<DataSection>(Segments);
   OutputSections.push_back(Section);
 }
 
 // Create relocations sections in the final output.
 // These are only created when relocatable output is requested.
 void Writer::createRelocSections() {
   log("createRelocSections");
   // Don't use iterator here since we are adding to OutputSection
   size_t OrigSize = OutputSections.size();
   for (size_t I = 0; I < OrigSize; I++) {
     OutputSection *OSec = OutputSections[I];
     uint32_t Count = OSec->numRelocations();
     if (!Count)
       continue;
 
     StringRef Name;
     if (OSec->Type == WASM_SEC_DATA)
       Name = "reloc.DATA";
     else if (OSec->Type == WASM_SEC_CODE)
       Name = "reloc.CODE";
     else if (OSec->Type == WASM_SEC_CUSTOM)
       Name = Saver.save("reloc." + OSec->Name);
     else
       llvm_unreachable(
           "relocations only supported for code, data, or custom sections");
 
     SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, Name);
     raw_ostream &OS = Section->getStream();
     writeUleb128(OS, I, "reloc section");
     writeUleb128(OS, Count, "reloc count");
     OSec->writeRelocations(OS);
   }
 }
 
 static uint32_t getWasmFlags(const Symbol *Sym) {
   uint32_t Flags = 0;
   if (Sym->isLocal())
     Flags |= WASM_SYMBOL_BINDING_LOCAL;
   if (Sym->isWeak())
     Flags |= WASM_SYMBOL_BINDING_WEAK;
   if (Sym->isHidden())
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   if (Sym->isUndefined())
     Flags |= WASM_SYMBOL_UNDEFINED;
+  if (auto *F = dyn_cast<UndefinedFunction>(Sym)) {
+    if (F->getName() != F->ImportName)
+      Flags |= WASM_SYMBOL_EXPLICIT_NAME;
+  } else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) {
+    if (G->getName() != G->ImportName)
+      Flags |= WASM_SYMBOL_EXPLICIT_NAME;
+  }
   return Flags;
 }
 
 // Some synthetic sections (e.g. "name" and "linking") have subsections.
 // Just like the synthetic sections themselves these need to be created before
 // they can be written out (since they are preceded by their length). This
 // class is used to create subsections and then write them into the stream
 // of the parent section.
 class SubSection {
 public:
   explicit SubSection(uint32_t Type) : Type(Type) {}
 
   void writeTo(raw_ostream &To) {
     OS.flush();
     writeUleb128(To, Type, "subsection type");
     writeUleb128(To, Body.size(), "subsection size");
     To.write(Body.data(), Body.size());
   }
 
 private:
   uint32_t Type;
   std::string Body;
 
 public:
   raw_string_ostream OS{Body};
 };
 
 // Create the custom "dylink" section containing information for the dynamic
 // linker.
 // See
 // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
 void Writer::createDylinkSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "dylink");
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, MemSize, "MemSize");
   writeUleb128(OS, MemAlign, "MemAlign");
   writeUleb128(OS, IndirectFunctions.size(), "TableSize");
   writeUleb128(OS, 0, "TableAlign");
   writeUleb128(OS, 0, "Needed");  // TODO: Support "needed" shared libraries
 }
 
 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, WasmMetadataVersion, "Version");
 
   if (!SymtabEntries.empty()) {
     SubSection Sub(WASM_SYMBOL_TABLE);
     writeUleb128(Sub.OS, SymtabEntries.size(), "num symbols");
 
     for (const Symbol *Sym : SymtabEntries) {
       assert(Sym->isDefined() || Sym->isUndefined());
       WasmSymbolType Kind = Sym->getWasmType();
       uint32_t Flags = getWasmFlags(Sym);
 
       writeU8(Sub.OS, Kind, "sym kind");
       writeUleb128(Sub.OS, Flags, "sym flags");
 
       if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
         writeUleb128(Sub.OS, F->getFunctionIndex(), "index");
-        if (Sym->isDefined())
+        if (Sym->isDefined() ||
+            (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(Sub.OS, Sym->getName(), "sym name");
       } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
         writeUleb128(Sub.OS, G->getGlobalIndex(), "index");
-        if (Sym->isDefined())
+        if (Sym->isDefined() ||
+            (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(Sub.OS, Sym->getName(), "sym name");
       } else if (auto *E = dyn_cast<EventSymbol>(Sym)) {
         writeUleb128(Sub.OS, E->getEventIndex(), "index");
-        if (Sym->isDefined())
+        if (Sym->isDefined() ||
+            (Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(Sub.OS, Sym->getName(), "sym name");
       } else if (isa<DataSymbol>(Sym)) {
         writeStr(Sub.OS, Sym->getName(), "sym name");
         if (auto *DataSym = dyn_cast<DefinedData>(Sym)) {
           writeUleb128(Sub.OS, DataSym->getOutputSegmentIndex(), "index");
           writeUleb128(Sub.OS, DataSym->getOutputSegmentOffset(),
                        "data offset");
           writeUleb128(Sub.OS, DataSym->getSize(), "data size");
         }
       } else {
         auto *S = cast<SectionSymbol>(Sym);
         writeUleb128(Sub.OS, S->getOutputSectionIndex(), "sym section index");
       }
     }
 
     Sub.writeTo(OS);
   }
 
   if (Segments.size()) {
     SubSection Sub(WASM_SEGMENT_INFO);
     writeUleb128(Sub.OS, Segments.size(), "num data segments");
     for (const OutputSegment *S : Segments) {
       writeStr(Sub.OS, S->Name, "segment name");
       writeUleb128(Sub.OS, S->Alignment, "alignment");
       writeUleb128(Sub.OS, 0, "flags");
     }
     Sub.writeTo(OS);
   }
 
   if (!InitFunctions.empty()) {
     SubSection Sub(WASM_INIT_FUNCS);
     writeUleb128(Sub.OS, InitFunctions.size(), "num init functions");
     for (const WasmInitEntry &F : InitFunctions) {
       writeUleb128(Sub.OS, F.Priority, "priority");
       writeUleb128(Sub.OS, F.Sym->getOutputSymbolIndex(), "function index");
     }
     Sub.writeTo(OS);
   }
 
   struct ComdatEntry {
     unsigned Kind;
     uint32_t Index;
   };
   std::map<StringRef, std::vector<ComdatEntry>> Comdats;
 
   for (const InputFunction *F : InputFunctions) {
     StringRef Comdat = F->getComdatName();
     if (!Comdat.empty())
       Comdats[Comdat].emplace_back(
           ComdatEntry{WASM_COMDAT_FUNCTION, F->getFunctionIndex()});
   }
   for (uint32_t I = 0; I < Segments.size(); ++I) {
     const auto &InputSegments = Segments[I]->InputSegments;
     if (InputSegments.empty())
       continue;
     StringRef Comdat = InputSegments[0]->getComdatName();
 #ifndef NDEBUG
     for (const InputSegment *IS : InputSegments)
       assert(IS->getComdatName() == Comdat);
 #endif
     if (!Comdat.empty())
       Comdats[Comdat].emplace_back(ComdatEntry{WASM_COMDAT_DATA, I});
   }
 
   if (!Comdats.empty()) {
     SubSection Sub(WASM_COMDAT_INFO);
     writeUleb128(Sub.OS, Comdats.size(), "num comdats");
     for (const auto &C : Comdats) {
       writeStr(Sub.OS, C.first, "comdat name");
       writeUleb128(Sub.OS, 0, "comdat flags"); // flags for future use
       writeUleb128(Sub.OS, C.second.size(), "num entries");
       for (const ComdatEntry &Entry : C.second) {
         writeU8(Sub.OS, Entry.Kind, "entry kind");
         writeUleb128(Sub.OS, Entry.Index, "entry index");
       }
     }
     Sub.writeTo(OS);
   }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
   unsigned NumNames = NumImportedFunctions;
   for (const InputFunction *F : InputFunctions)
     if (!F->getName().empty() || !F->getDebugName().empty())
       ++NumNames;
 
   if (NumNames == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "name");
 
   SubSection Sub(WASM_NAMES_FUNCTION);
   writeUleb128(Sub.OS, NumNames, "name count");
 
   // Names must appear in function index order.  As it happens ImportedSymbols
   // and InputFunctions are numbered in order with imported functions coming
   // first.
   for (const Symbol *S : ImportedSymbols) {
     if (auto *F = dyn_cast<FunctionSymbol>(S)) {
       writeUleb128(Sub.OS, F->getFunctionIndex(), "func index");
       writeStr(Sub.OS, toString(*S), "symbol name");
     }
   }
   for (const InputFunction *F : InputFunctions) {
     if (!F->getName().empty()) {
       writeUleb128(Sub.OS, F->getFunctionIndex(), "func index");
       if (!F->getDebugName().empty()) {
         writeStr(Sub.OS, F->getDebugName(), "symbol name");
       } else {
         writeStr(Sub.OS, maybeDemangleSymbol(F->getName()), "symbol name");
       }
     }
   }
 
   Sub.writeTo(Section->getStream());
 }
 
 void Writer::writeHeader() {
   memcpy(Buffer->getBufferStart(), Header.data(), Header.size());
 }
 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   parallelForEach(OutputSections, [Buf](OutputSection *S) { S->writeTo(Buf); });
 }
 
 // Fix the memory layout of the output binary.  This assigns memory offsets
 // to each of the input data sections as well as the explicit stack region.
 // The default memory layout is as follows, from low to high.
 //
 //  - initialized data (starting at Config->GlobalBase)
 //  - BSS data (not currently implemented in llvm)
 //  - explicit stack (Config->ZStackSize)
 //  - heap start / unallocated
 //
 // The --stack-first option means that stack is placed before any static data.
 // This can be useful since it means that stack overflow traps immediately
 // rather than overwriting global data, but also increases code size since all
 // static data loads and stores requires larger offsets.
 void Writer::layoutMemory() {
   createOutputSegments();
 
   uint32_t MemoryPtr = 0;
 
   auto PlaceStack = [&]() {
     if (Config->Relocatable || Config->Shared)
       return;
-    MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
-    if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
-      error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
+    MemoryPtr = alignTo(MemoryPtr, StackAlignment);
+    if (Config->ZStackSize != alignTo(Config->ZStackSize, StackAlignment))
+      error("stack size must be " + Twine(StackAlignment) + "-byte aligned");
     log("mem: stack size  = " + Twine(Config->ZStackSize));
     log("mem: stack base  = " + Twine(MemoryPtr));
     MemoryPtr += Config->ZStackSize;
     auto *SP = cast<DefinedGlobal>(WasmSym::StackPointer);
     SP->Global->Global.InitExpr.Value.Int32 = MemoryPtr;
     log("mem: stack top   = " + Twine(MemoryPtr));
   };
 
   if (Config->StackFirst) {
     PlaceStack();
   } else {
     MemoryPtr = Config->GlobalBase;
     log("mem: global base = " + Twine(Config->GlobalBase));
   }
 
   uint32_t DataStart = MemoryPtr;
 
   // Arbitrarily set __dso_handle handle to point to the start of the data
   // segments.
   if (WasmSym::DsoHandle)
     WasmSym::DsoHandle->setVirtualAddress(DataStart);
 
   MemAlign = 0;
   for (OutputSegment *Seg : Segments) {
     MemAlign = std::max(MemAlign, Seg->Alignment);
     MemoryPtr = alignTo(MemoryPtr, 1 << Seg->Alignment);
     Seg->StartVA = MemoryPtr;
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", Seg->Name,
                 MemoryPtr, Seg->Size, Seg->Alignment));
     MemoryPtr += Seg->Size;
   }
 
   // TODO: Add .bss space here.
   if (WasmSym::DataEnd)
     WasmSym::DataEnd->setVirtualAddress(MemoryPtr);
 
   log("mem: static data = " + Twine(MemoryPtr - DataStart));
 
   if (Config->Shared) {
     MemSize = MemoryPtr;
     return;
   }
 
   if (!Config->StackFirst)
     PlaceStack();
 
   // Set `__heap_base` to directly follow the end of the stack or global data.
   // The fact that this comes last means that a malloc/brk implementation
   // can grow the heap at runtime.
   if (!Config->Relocatable) {
     WasmSym::HeapBase->setVirtualAddress(MemoryPtr);
     log("mem: heap base   = " + Twine(MemoryPtr));
   }
 
   if (Config->InitialMemory != 0) {
     if (Config->InitialMemory != alignTo(Config->InitialMemory, WasmPageSize))
       error("initial memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (MemoryPtr > Config->InitialMemory)
       error("initial memory too small, " + Twine(MemoryPtr) + " bytes needed");
     else
       MemoryPtr = Config->InitialMemory;
   }
   MemSize = MemoryPtr;
   NumMemoryPages = alignTo(MemoryPtr, WasmPageSize) / WasmPageSize;
   log("mem: total pages = " + Twine(NumMemoryPages));
 
   if (Config->MaxMemory != 0) {
     if (Config->MaxMemory != alignTo(Config->MaxMemory, WasmPageSize))
       error("maximum memory must be " + Twine(WasmPageSize) + "-byte aligned");
     if (MemoryPtr > Config->MaxMemory)
       error("maximum memory too small, " + Twine(MemoryPtr) + " bytes needed");
     MaxMemoryPages = Config->MaxMemory / WasmPageSize;
     log("mem: max pages   = " + Twine(MaxMemoryPages));
   }
 }
 
 SyntheticSection *Writer::createSyntheticSection(uint32_t Type,
                                                  StringRef Name) {
   auto Sec = make<SyntheticSection>(Type, Name);
   log("createSection: " + toString(*Sec));
   OutputSections.push_back(Sec);
   return Sec;
 }
 
 void Writer::createSections() {
   // Known sections
   if (Config->Pic)
     createDylinkSection();
   createTypeSection();
   createImportSection();
   createFunctionSection();
   createTableSection();
   createMemorySection();
   createGlobalSection();
   createEventSection();
   createExportSection();
   createElemSection();
   createCodeSection();
   createDataSection();
   createCustomSections();
 
   // Custom sections
   if (Config->Relocatable) {
     createLinkingSection();
     createRelocSections();
   }
   if (!Config->StripDebug && !Config->StripAll)
     createNameSection();
 
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isUndefined())
       continue;
     if (isa<DataSymbol>(Sym))
       continue;
     if (Sym->isWeak() && !Config->Relocatable)
       continue;
     if (!Sym->isLive())
       continue;
     if (!Sym->IsUsedInRegularObj)
       continue;
 
     LLVM_DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
     ImportedSymbols.emplace_back(Sym);
     if (auto *F = dyn_cast<FunctionSymbol>(Sym))
       F->setFunctionIndex(NumImportedFunctions++);
     else if (auto *G = dyn_cast<GlobalSymbol>(Sym))
       G->setGlobalIndex(NumImportedGlobals++);
     else
       cast<EventSymbol>(Sym)->setEventIndex(NumImportedEvents++);
   }
 }
 
 void Writer::calculateExports() {
   if (Config->Relocatable)
     return;
 
   if (!Config->Relocatable && !Config->ImportMemory)
     Exports.push_back(WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
 
   if (!Config->Relocatable && Config->ExportTable)
-    Exports.push_back(WasmExport{kFunctionTableName, WASM_EXTERNAL_TABLE, 0});
+    Exports.push_back(WasmExport{FunctionTableName, WASM_EXTERNAL_TABLE, 0});
 
   unsigned FakeGlobalIndex = NumImportedGlobals + InputGlobals.size();
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isExported())
       continue;
     if (!Sym->isLive())
       continue;
 
     StringRef Name = Sym->getName();
     WasmExport Export;
     if (auto *F = dyn_cast<DefinedFunction>(Sym)) {
       Export = {Name, WASM_EXTERNAL_FUNCTION, F->getFunctionIndex()};
     } else if (auto *G = dyn_cast<DefinedGlobal>(Sym)) {
       // TODO(sbc): Remove this check once to mutable global proposal is
       // implement in all major browsers.
       // See: https://github.com/WebAssembly/mutable-global
       if (G->getGlobalType()->Mutable) {
         // Only the __stack_pointer should ever be create as mutable.
         assert(G == WasmSym::StackPointer);
         continue;
       }
       Export = {Name, WASM_EXTERNAL_GLOBAL, G->getGlobalIndex()};
     } else if (auto *E = dyn_cast<DefinedEvent>(Sym)) {
       Export = {Name, WASM_EXTERNAL_EVENT, E->getEventIndex()};
     } else {
       auto *D = cast<DefinedData>(Sym);
       DefinedFakeGlobals.emplace_back(D);
       Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++};
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << Name << "\n");
     Exports.push_back(Export);
   }
 }
 
 void Writer::assignSymtab() {
   if (!Config->Relocatable)
     return;
 
   StringMap<uint32_t> SectionSymbolIndices;
 
   unsigned SymbolIndex = SymtabEntries.size();
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    LLVM_DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
-    for (Symbol *Sym : File->getSymbols()) {
-      if (Sym->getFile() != File)
-        continue;
 
-      if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
-        StringRef Name = S->getName();
-        if (CustomSectionMapping.count(Name) == 0)
-          continue;
+  auto AddSymbol = [&](Symbol *Sym) {
+    if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
+      StringRef Name = S->getName();
+      if (CustomSectionMapping.count(Name) == 0)
+        return;
 
-        auto SSI = SectionSymbolIndices.find(Name);
-        if (SSI != SectionSymbolIndices.end()) {
-          Sym->setOutputSymbolIndex(SSI->second);
-          continue;
-        }
-
-        SectionSymbolIndices[Name] = SymbolIndex;
-        CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
-
-        Sym->markLive();
+      auto SSI = SectionSymbolIndices.find(Name);
+      if (SSI != SectionSymbolIndices.end()) {
+        Sym->setOutputSymbolIndex(SSI->second);
+        return;
       }
 
-      // (Since this is relocatable output, GC is not performed so symbols must
-      // be live.)
-      assert(Sym->isLive());
-      Sym->setOutputSymbolIndex(SymbolIndex++);
-      SymtabEntries.emplace_back(Sym);
+      SectionSymbolIndices[Name] = SymbolIndex;
+      CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
+
+      Sym->markLive();
     }
-  }
 
-  // For the moment, relocatable output doesn't contain any synthetic functions,
-  // so no need to look through the Symtab for symbols not referenced by
-  // Symtab->ObjectFiles.
+    // (Since this is relocatable output, GC is not performed so symbols must
+    // be live.)
+    assert(Sym->isLive());
+    Sym->setOutputSymbolIndex(SymbolIndex++);
+    SymtabEntries.emplace_back(Sym);
+  };
+
+  for (Symbol *Sym : Symtab->getSymbols())
+    if (!Sym->isLazy())
+      AddSymbol(Sym);
+
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    LLVM_DEBUG(dbgs() << "Local symtab entries: " << File->getName() << "\n");
+    for (Symbol *Sym : File->getSymbols())
+      if (Sym->isLocal())
+        AddSymbol(Sym);
+  }
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {
     error("type not found: " + toString(Sig));
     return 0;
   }
   return It->second;
 }
 
 uint32_t Writer::registerType(const WasmSignature &Sig) {
   auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
   if (Pair.second) {
     LLVM_DEBUG(dbgs() << "type " << toString(Sig) << "\n");
     Types.push_back(&Sig);
   }
   return Pair.first->second;
 }
 
 void Writer::calculateTypes() {
   // The output type section is the union of the following sets:
   // 1. Any signature used in the TYPE relocation
   // 2. The signatures of all imported functions
   // 3. The signatures of all defined functions
   // 4. The signatures of all imported events
   // 5. The signatures of all defined events
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
     for (uint32_t I = 0; I < Types.size(); I++)
       if (File->TypeIsUsed[I])
         File->TypeMap[I] = registerType(Types[I]);
   }
 
   for (const Symbol *Sym : ImportedSymbols) {
     if (auto *F = dyn_cast<FunctionSymbol>(Sym))
       registerType(*F->Signature);
     else if (auto *E = dyn_cast<EventSymbol>(Sym))
       registerType(*E->Signature);
   }
 
   for (const InputFunction *F : InputFunctions)
     registerType(F->Signature);
 
   for (const InputEvent *E : InputEvents)
     registerType(E->Signature);
 }
 
 void Writer::assignIndexes() {
   assert(InputFunctions.empty());
   uint32_t FunctionIndex = NumImportedFunctions;
   auto AddDefinedFunction = [&](InputFunction *Func) {
     if (!Func->Live)
       return;
     InputFunctions.emplace_back(Func);
     Func->setFunctionIndex(FunctionIndex++);
   };
 
   for (InputFunction *Func : Symtab->SyntheticFunctions)
     AddDefinedFunction(Func);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions)
       AddDefinedFunction(Func);
   }
 
   uint32_t TableIndex = TableBase;
   auto HandleRelocs = [&](InputChunk *Chunk) {
     if (!Chunk->Live)
       return;
     ObjFile *File = Chunk->File;
     ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
     for (const WasmRelocation &Reloc : Chunk->getRelocations()) {
       if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32 ||
           Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB) {
         FunctionSymbol *Sym = File->getFunctionSymbol(Reloc.Index);
         if (Sym->hasTableIndex() || !Sym->hasFunctionIndex())
           continue;
         Sym->setTableIndex(TableIndex++);
         IndirectFunctions.emplace_back(Sym);
       } else if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
         // Mark target type as live
         File->TypeMap[Reloc.Index] = registerType(Types[Reloc.Index]);
         File->TypeIsUsed[Reloc.Index] = true;
       }
     }
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     for (InputChunk *Chunk : File->Functions)
       HandleRelocs(Chunk);
     for (InputChunk *Chunk : File->Segments)
       HandleRelocs(Chunk);
     for (auto &P : File->CustomSections)
       HandleRelocs(P);
   }
 
   assert(InputGlobals.empty());
   uint32_t GlobalIndex = NumImportedGlobals;
   auto AddDefinedGlobal = [&](InputGlobal *Global) {
     if (Global->Live) {
       LLVM_DEBUG(dbgs() << "AddDefinedGlobal: " << GlobalIndex << "\n");
       Global->setGlobalIndex(GlobalIndex++);
       InputGlobals.push_back(Global);
     }
   };
 
   for (InputGlobal *Global : Symtab->SyntheticGlobals)
     AddDefinedGlobal(Global);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
     for (InputGlobal *Global : File->Globals)
       AddDefinedGlobal(Global);
   }
 
   assert(InputEvents.empty());
   uint32_t EventIndex = NumImportedEvents;
   auto AddDefinedEvent = [&](InputEvent *Event) {
     if (Event->Live) {
       LLVM_DEBUG(dbgs() << "AddDefinedEvent: " << EventIndex << "\n");
       Event->setEventIndex(EventIndex++);
       InputEvents.push_back(Event);
     }
   };
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Events: " << File->getName() << "\n");
     for (InputEvent *Event : File->Events)
       AddDefinedEvent(Event);
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   // With PIC code we currently only support a single data segment since
   // we only have a single __memory_base to use as our base address.
   if (Config->Pic)
     return "data";
   if (!Config->MergeDataSegments)
     return Name;
   if (Name.startswith(".text."))
     return ".text";
   if (Name.startswith(".data."))
     return ".data";
   if (Name.startswith(".bss."))
     return ".bss";
   if (Name.startswith(".rodata."))
     return ".rodata";
   return Name;
 }
 
 void Writer::createOutputSegments() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSegment *Segment : File->Segments) {
       if (!Segment->Live)
         continue;
       StringRef Name = getOutputDataSegmentName(Segment->getName());
       OutputSegment *&S = SegmentMap[Name];
       if (S == nullptr) {
         LLVM_DEBUG(dbgs() << "new segment: " << Name << "\n");
         S = make<OutputSegment>(Name, Segments.size());
         Segments.push_back(S);
       }
       S->addInputSegment(Segment);
       LLVM_DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
     }
   }
 }
 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCtorFunction() {
   // First write the body's contents to a string.
   std::string BodyContent;
   {
     raw_string_ostream OS(BodyContent);
     writeUleb128(OS, 0, "num locals");
     for (const WasmInitEntry &F : InitFunctions) {
       writeU8(OS, OPCODE_CALL, "CALL");
       writeUleb128(OS, F.Sym->getFunctionIndex(), "function index");
     }
     writeU8(OS, OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
   std::string FunctionBody;
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, BodyContent.size(), "function size");
     OS << BodyContent;
   }
 
   ArrayRef<uint8_t> Body = arrayRefFromStringRef(Saver.save(FunctionBody));
   cast<SyntheticFunction>(WasmSym::CallCtors->Function)->setBody(Body);
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions) {
       FunctionSymbol *Sym = File->getFunctionSymbol(F.Symbol);
       if (*Sym->Signature != WasmSignature{{}, {}})
         error("invalid signature for init func: " + toString(*Sym));
       InitFunctions.emplace_back(WasmInitEntry{Sym, F.Priority});
     }
   }
 
   // Sort in order of priority (lowest first) so that they are called
   // in the correct order.
   std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
                    [](const WasmInitEntry &L, const WasmInitEntry &R) {
                      return L.Priority < R.Priority;
                    });
 }
 
 void Writer::run() {
   if (Config->Relocatable || Config->Pic)
     Config->GlobalBase = 0;
 
   // For PIC code the table base is assigned dynamically by the loader.
   // For non-PIC, we start at 1 so that accessing table index 0 always traps.
   if (!Config->Pic)
     TableBase = 1;
 
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
   log("-- layoutMemory");
   layoutMemory();
   log("-- calculateExports");
   calculateExports();
   log("-- calculateCustomSections");
   calculateCustomSections();
   log("-- assignSymtab");
   assignSymtab();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(InputFunctions.size()));
     log("Defined Globals  : " + Twine(InputGlobals.size()));
     log("Defined Events   : " + Twine(InputEvents.size()));
     log("Function Imports : " + Twine(NumImportedFunctions));
     log("Global Imports   : " + Twine(NumImportedGlobals));
     log("Event Imports    : " + Twine(NumImportedEvents));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
   createHeader();
   log("-- createSections");
   createSections();
 
   log("-- openFile");
   openFile();
   if (errorCount())
     return;
 
   writeHeader();
 
   log("-- writeSections");
   writeSections();
   if (errorCount())
     return;
 
   if (Error E = Buffer->commit())
     fatal("failed to write the output file: " + toString(std::move(E)));
 }
 
 // Open a result file.
 void Writer::openFile() {
   log("writing: " + Config->OutputFile);
 
   Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(Config->OutputFile, FileSize,
                                FileOutputBuffer::F_executable);
 
   if (!BufferOrErr)
     error("failed to open " + Config->OutputFile + ": " +
           toString(BufferOrErr.takeError()));
   else
     Buffer = std::move(*BufferOrErr);
 }
 
 void Writer::createHeader() {
   raw_string_ostream OS(Header);
   writeBytes(OS, WasmMagic, sizeof(WasmMagic), "wasm magic");
   writeU32(OS, WasmVersion, "wasm version");
   OS.flush();
   FileSize += Header.size();
 }
 
 void lld::wasm::writeResult() { Writer().run(); }
Index: vendor/lld/dist-release_80/wasm/Writer.h
===================================================================
--- vendor/lld/dist-release_80/wasm/Writer.h	(revision 344172)
+++ vendor/lld/dist-release_80/wasm/Writer.h	(revision 344173)
@@ -1,21 +1,23 @@
 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_WRITER_H
 #define LLD_WASM_WRITER_H
 
 namespace lld {
 namespace wasm {
 
 void writeResult();
 
+extern const char *DefaultModule;
+
 } // namespace wasm
 } // namespace lld
 
 #endif