lld/lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp - toolchain/llvm-project - Gitiles

 //===- lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp -------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "Atoms.h"
 #include "EdataPass.h"
 #include "GroupedSectionsPass.h"
 #include "IdataPass.h"
 #include "LinkerGeneratedSymbolFile.h"
 #include "LoadConfigPass.h"
 #include "SetSubsystemPass.h"

 #include "lld/Core/PassManager.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripNativePass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Path.h"

 #include <bitset>
 #include <climits>
 #include <set>

 namespace lld {

 bool PECOFFLinkingContext::validateImpl(raw_ostream &diagnostics) {
   if (_stackReserve < _stackCommit) {
     diagnostics << "Invalid stack size: reserve size must be equal to or "
                 << "greater than commit size, but got " << _stackCommit
                 << " and " << _stackReserve << ".\n";
     return false;
   }

   if (_heapReserve < _heapCommit) {
     diagnostics << "Invalid heap size: reserve size must be equal to or "
                 << "greater than commit size, but got " << _heapCommit
                 << " and " << _heapReserve << ".\n";
     return false;
   }

   // It's an error if the base address is not multiple of 64K.
   if (getBaseAddress() & 0xffff) {
     diagnostics << "Base address have to be multiple of 64K, but got "
                 << getBaseAddress() << "\n";
     return false;
   }

   // Check for duplicate export ordinals.
   std::set<int> exports;
   for (const PECOFFLinkingContext::ExportDesc &desc : getDllExports()) {
     if (desc.ordinal == -1)
       continue;
     if (exports.count(desc.ordinal) == 1) {
       diagnostics << "Duplicate export ordinals: " << desc.ordinal << "\n";
       return false;
     }
     exports.insert(desc.ordinal);
   }

   // Check for /align.
   std::bitset<64> alignment(_sectionDefaultAlignment);
   if (alignment.count() != 1) {
     diagnostics << "Section alignment must be a power of 2, but got "
                 << _sectionDefaultAlignment << "\n";
     return false;
   }

   // /safeseh is only valid for x86.
   if (getMachineType() != llvm::COFF::IMAGE_FILE_MACHINE_I386 && noSEH()) {
     diagnostics << "/SAFESEH:NO is only valid for x86.\n";
     return false;
   }

   // Architectures other than x86/x64 is not supported yet.
   if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386 &&
       _machineType != llvm::COFF::IMAGE_FILE_MACHINE_AMD64) {
     diagnostics << "Machine type other than x86/x64 is not supported.\n";
     return false;
   }

   _writer = createWriterPECOFF(*this);
   return true;
 }

 std::unique_ptr<File> PECOFFLinkingContext::createEntrySymbolFile() const {
   return LinkingContext::createEntrySymbolFile("<command line option /entry>");
 }

 std::unique_ptr<File> PECOFFLinkingContext::createUndefinedSymbolFile() const {
   return LinkingContext::createUndefinedSymbolFile(
       "<command line option /include>");
 }

 bool PECOFFLinkingContext::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &) const {
   std::unique_ptr<SimpleFileNode> fileNode(
       new SimpleFileNode("Implicit Files"));
   std::unique_ptr<File> linkerGeneratedSymFile(
       new pecoff::LinkerGeneratedSymbolFile(*this));
   fileNode->appendInputFile(std::move(linkerGeneratedSymFile));
   getInputGraph().insertElementAt(std::move(fileNode),
                                   InputGraph::Position::END);

   std::unique_ptr<SimpleFileNode> impFileNode(new SimpleFileNode("imp"));
   impFileNode->appendInputFile(
       std::unique_ptr<File>(new pecoff::LocallyImportedSymbolFile(*this)));
   getInputGraph().insertElementAt(std::move(impFileNode),
                                   InputGraph::Position::END);
   return true;
 }

 /// Returns the section name in the resulting executable.
 ///
 /// Sections in object files are usually output to the executable with the same
 /// name, but you can rename by command line option. /merge:from=to makes the
 /// linker to combine "from" section contents to "to" section in the
 /// executable. We have a mapping for the renaming. This method looks up the
 /// table and returns a new section name if renamed.
 StringRef
 PECOFFLinkingContext::getOutputSectionName(StringRef sectionName) const {
   auto it = _renamedSections.find(sectionName);
   if (it == _renamedSections.end())
     return sectionName;
   return getOutputSectionName(it->second);
 }

 /// Adds a mapping to the section renaming table. This method will be used for
 /// /merge command line option.
 bool PECOFFLinkingContext::addSectionRenaming(raw_ostream &diagnostics,
                                               StringRef from, StringRef to) {
   auto it = _renamedSections.find(from);
   if (it != _renamedSections.end()) {
     if (it->second == to)
       // There's already the same mapping.
       return true;
     diagnostics << "Section \"" << from << "\" is already mapped to \""
                 << it->second << ", so it cannot be mapped to \"" << to << "\".";
     return true;
   }

   // Add a mapping, and check if there's no cycle in the renaming mapping. The
   // cycle detection algorithm we use here is naive, but that's OK because the
   // number of mapping is usually less than 10.
   _renamedSections[from] = to;
   for (auto elem : _renamedSections) {
     StringRef sectionName = elem.first;
     std::set<StringRef> visited;
     visited.insert(sectionName);
     for (;;) {
       auto pos = _renamedSections.find(sectionName);
       if (pos == _renamedSections.end())
         break;
       if (visited.count(pos->second)) {
         diagnostics << "/merge:" << from << "=" << to << " makes a cycle";
         return false;
       }
       sectionName = pos->second;
       visited.insert(sectionName);
     }
   }
   return true;
 }

 StringRef PECOFFLinkingContext::getAlternateName(StringRef def) const {
   auto it = _alternateNames.find(def);
   if (it == _alternateNames.end())
     return "";
   return it->second;
 }

 void PECOFFLinkingContext::setAlternateName(StringRef weak, StringRef def) {
   _alternateNames[def] = weak;
 }

 /// Try to find the input library file from the search paths and append it to
 /// the input file list. Returns true if the library file is found.
 StringRef PECOFFLinkingContext::searchLibraryFile(StringRef filename) const {
   // Current directory always takes precedence over the search paths.
   if (llvm::sys::path::is_absolute(filename) || llvm::sys::fs::exists(filename))
     return filename;
   // Iterate over the search paths.
   for (StringRef dir : _inputSearchPaths) {
     SmallString<128> path = dir;
     llvm::sys::path::append(path, filename);
     if (llvm::sys::fs::exists(path.str()))
       return allocate(path.str());
   }
   return filename;
 }

 /// Returns the decorated name of the given symbol name. On 32-bit x86, it
 /// adds "_" at the beginning of the string. On other architectures, the
 /// return value is the same as the argument.
 StringRef PECOFFLinkingContext::decorateSymbol(StringRef name) const {
   if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386)
     return name;
   std::string str = "_";
   str.append(name);
   return allocate(str);
 }

 StringRef PECOFFLinkingContext::undecorateSymbol(StringRef name) const {
   if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386)
     return name;
   if (!name.startswith("_"))
     return name;
   return name.substr(1);
 }

 uint64_t PECOFFLinkingContext::getBaseAddress() const {
   if (_baseAddress == invalidBaseAddress)
     return is64Bit() ? pe32PlusDefaultBaseAddress : pe32DefaultBaseAddress;
   return _baseAddress;
 }

 Writer &PECOFFLinkingContext::writer() const { return *_writer; }

 void PECOFFLinkingContext::setSectionSetMask(StringRef sectionName,
                                              uint32_t newFlags) {
   _sectionSetMask[sectionName] |= newFlags;
   _sectionClearMask[sectionName] &= ~newFlags;
   const uint32_t rwx = (llvm::COFF::IMAGE_SCN_MEM_READ |
                         llvm::COFF::IMAGE_SCN_MEM_WRITE |
                         llvm::COFF::IMAGE_SCN_MEM_EXECUTE);
   if (newFlags & rwx)
     _sectionClearMask[sectionName] |= ~_sectionSetMask[sectionName] & rwx;
   assert((_sectionSetMask[sectionName] & _sectionClearMask[sectionName]) == 0);
 }

 void PECOFFLinkingContext::setSectionClearMask(StringRef sectionName,
                                                uint32_t newFlags) {
   _sectionClearMask[sectionName] |= newFlags;
   _sectionSetMask[sectionName] &= ~newFlags;
   assert((_sectionSetMask[sectionName] & _sectionClearMask[sectionName]) == 0);
 }

 uint32_t PECOFFLinkingContext::getSectionAttributes(StringRef sectionName,
                                                     uint32_t flags) const {
   auto si = _sectionSetMask.find(sectionName);
   uint32_t setMask = (si == _sectionSetMask.end()) ? 0 : si->second;
   auto ci = _sectionClearMask.find(sectionName);
   uint32_t clearMask = (ci == _sectionClearMask.end()) ? 0 : ci->second;
   return (flags | setMask) & ~clearMask;
 }

 // Returns true if two export descriptors have conflicting contents,
 // e.g. different export ordinals.
 static bool exportConflicts(const PECOFFLinkingContext::ExportDesc &a,
                             const PECOFFLinkingContext::ExportDesc &b) {
   return (a.ordinal > 0 && b.ordinal > 0 && a.ordinal != b.ordinal) ||
          a.noname != b.noname || a.isData != b.isData;
 }

 void PECOFFLinkingContext::addDllExport(ExportDesc &desc) {
   auto existing = _dllExports.insert(desc);
   if (existing.second)
     return;
   if (!exportConflicts(*existing.first, desc)) {
     _dllExports.erase(existing.first);
     _dllExports.insert(desc);
     return;
   }
   llvm::errs() << "Export symbol '" << desc.name
                << "' specified more than once.\n";
 }

 std::string PECOFFLinkingContext::getOutputImportLibraryPath() const {
   if (!_implib.empty())
     return _implib;
   SmallString<128> path = outputPath();
   llvm::sys::path::replace_extension(path, ".lib");
   return path.str();
 }

 void PECOFFLinkingContext::addPasses(PassManager &pm) {
   pm.add(std::unique_ptr<Pass>(new pecoff::SetSubsystemPass(*this)));
   pm.add(std::unique_ptr<Pass>(new pecoff::EdataPass(*this)));
   pm.add(std::unique_ptr<Pass>(new pecoff::IdataPass(*this)));
   pm.add(std::unique_ptr<Pass>(new LayoutPass(registry())));
   pm.add(std::unique_ptr<Pass>(new pecoff::LoadConfigPass(*this)));
   pm.add(std::unique_ptr<Pass>(new pecoff::GroupedSectionsPass()));
 }

 } // end namespace lld
	//===- lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp -------------------===//
	//
	// The LLVM Linker
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "Atoms.h"
	#include "EdataPass.h"
	#include "GroupedSectionsPass.h"
	#include "IdataPass.h"
	#include "LinkerGeneratedSymbolFile.h"
	#include "LoadConfigPass.h"
	#include "SetSubsystemPass.h"

	#include "lld/Core/PassManager.h"
	#include "lld/Passes/LayoutPass.h"
	#include "lld/Passes/RoundTripNativePass.h"
	#include "lld/Passes/RoundTripYAMLPass.h"
	#include "lld/ReaderWriter/PECOFFLinkingContext.h"
	#include "lld/ReaderWriter/Reader.h"
	#include "lld/ReaderWriter/Simple.h"
	#include "lld/ReaderWriter/Writer.h"
	#include "llvm/ADT/SmallString.h"
	#include "llvm/Support/Allocator.h"
	#include "llvm/Support/Path.h"

	#include <bitset>
	#include <climits>
	#include <set>

	namespace lld {

	bool PECOFFLinkingContext::validateImpl(raw_ostream &diagnostics) {
	if (_stackReserve < _stackCommit) {
	diagnostics << "Invalid stack size: reserve size must be equal to or "
	<< "greater than commit size, but got " << _stackCommit
	<< " and " << _stackReserve << ".\n";
	return false;
	}

	if (_heapReserve < _heapCommit) {
	diagnostics << "Invalid heap size: reserve size must be equal to or "
	<< "greater than commit size, but got " << _heapCommit
	<< " and " << _heapReserve << ".\n";
	return false;
	}

	// It's an error if the base address is not multiple of 64K.
	if (getBaseAddress() & 0xffff) {
	diagnostics << "Base address have to be multiple of 64K, but got "
	<< getBaseAddress() << "\n";
	return false;
	}

	// Check for duplicate export ordinals.
	std::set<int> exports;
	for (const PECOFFLinkingContext::ExportDesc &desc : getDllExports()) {
	if (desc.ordinal == -1)
	continue;
	if (exports.count(desc.ordinal) == 1) {
	diagnostics << "Duplicate export ordinals: " << desc.ordinal << "\n";
	return false;
	}
	exports.insert(desc.ordinal);
	}

	// Check for /align.
	std::bitset<64> alignment(_sectionDefaultAlignment);
	if (alignment.count() != 1) {
	diagnostics << "Section alignment must be a power of 2, but got "
	<< _sectionDefaultAlignment << "\n";
	return false;
	}

	// /safeseh is only valid for x86.
	if (getMachineType() != llvm::COFF::IMAGE_FILE_MACHINE_I386 && noSEH()) {
	diagnostics << "/SAFESEH:NO is only valid for x86.\n";
	return false;
	}

	// Architectures other than x86/x64 is not supported yet.
	if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386 &&
	_machineType != llvm::COFF::IMAGE_FILE_MACHINE_AMD64) {
	diagnostics << "Machine type other than x86/x64 is not supported.\n";
	return false;
	}

	_writer = createWriterPECOFF(*this);
	return true;
	}

	std::unique_ptr<File> PECOFFLinkingContext::createEntrySymbolFile() const {
	return LinkingContext::createEntrySymbolFile("<command line option /entry>");
	}

	std::unique_ptr<File> PECOFFLinkingContext::createUndefinedSymbolFile() const {
	return LinkingContext::createUndefinedSymbolFile(
	"<command line option /include>");
	}

	bool PECOFFLinkingContext::createImplicitFiles(
	std::vector<std::unique_ptr<File> > &) const {
	std::unique_ptr<SimpleFileNode> fileNode(
	new SimpleFileNode("Implicit Files"));
	std::unique_ptr<File> linkerGeneratedSymFile(
	new pecoff::LinkerGeneratedSymbolFile(*this));
	fileNode->appendInputFile(std::move(linkerGeneratedSymFile));
	getInputGraph().insertElementAt(std::move(fileNode),
	InputGraph::Position::END);

	std::unique_ptr<SimpleFileNode> impFileNode(new SimpleFileNode("imp"));
	impFileNode->appendInputFile(
	std::unique_ptr<File>(new pecoff::LocallyImportedSymbolFile(*this)));
	getInputGraph().insertElementAt(std::move(impFileNode),
	InputGraph::Position::END);
	return true;
	}

	/// Returns the section name in the resulting executable.
	///
	/// Sections in object files are usually output to the executable with the same
	/// name, but you can rename by command line option. /merge:from=to makes the
	/// linker to combine "from" section contents to "to" section in the
	/// executable. We have a mapping for the renaming. This method looks up the
	/// table and returns a new section name if renamed.
	StringRef
	PECOFFLinkingContext::getOutputSectionName(StringRef sectionName) const {
	auto it = _renamedSections.find(sectionName);
	if (it == _renamedSections.end())
	return sectionName;
	return getOutputSectionName(it->second);
	}

	/// Adds a mapping to the section renaming table. This method will be used for
	/// /merge command line option.
	bool PECOFFLinkingContext::addSectionRenaming(raw_ostream &diagnostics,
	StringRef from, StringRef to) {
	auto it = _renamedSections.find(from);
	if (it != _renamedSections.end()) {
	if (it->second == to)
	// There's already the same mapping.
	return true;
	diagnostics << "Section \"" << from << "\" is already mapped to \""
	<< it->second << ", so it cannot be mapped to \"" << to << "\".";
	return true;
	}

	// Add a mapping, and check if there's no cycle in the renaming mapping. The
	// cycle detection algorithm we use here is naive, but that's OK because the
	// number of mapping is usually less than 10.
	_renamedSections[from] = to;
	for (auto elem : _renamedSections) {
	StringRef sectionName = elem.first;
	std::set<StringRef> visited;
	visited.insert(sectionName);
	for (;;) {
	auto pos = _renamedSections.find(sectionName);
	if (pos == _renamedSections.end())
	break;
	if (visited.count(pos->second)) {
	diagnostics << "/merge:" << from << "=" << to << " makes a cycle";
	return false;
	}
	sectionName = pos->second;
	visited.insert(sectionName);
	}
	}
	return true;
	}

	StringRef PECOFFLinkingContext::getAlternateName(StringRef def) const {
	auto it = _alternateNames.find(def);
	if (it == _alternateNames.end())
	return "";
	return it->second;
	}

	void PECOFFLinkingContext::setAlternateName(StringRef weak, StringRef def) {
	_alternateNames[def] = weak;
	}

	/// Try to find the input library file from the search paths and append it to
	/// the input file list. Returns true if the library file is found.
	StringRef PECOFFLinkingContext::searchLibraryFile(StringRef filename) const {
	// Current directory always takes precedence over the search paths.
	if (llvm::sys::path::is_absolute(filename) \|\| llvm::sys::fs::exists(filename))
	return filename;
	// Iterate over the search paths.
	for (StringRef dir : _inputSearchPaths) {
	SmallString<128> path = dir;
	llvm::sys::path::append(path, filename);
	if (llvm::sys::fs::exists(path.str()))
	return allocate(path.str());
	}
	return filename;
	}

	/// Returns the decorated name of the given symbol name. On 32-bit x86, it
	/// adds "_" at the beginning of the string. On other architectures, the
	/// return value is the same as the argument.
	StringRef PECOFFLinkingContext::decorateSymbol(StringRef name) const {
	if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386)
	return name;
	std::string str = "_";
	str.append(name);
	return allocate(str);
	}

	StringRef PECOFFLinkingContext::undecorateSymbol(StringRef name) const {
	if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386)
	return name;
	if (!name.startswith("_"))
	return name;
	return name.substr(1);
	}

	uint64_t PECOFFLinkingContext::getBaseAddress() const {
	if (_baseAddress == invalidBaseAddress)
	return is64Bit() ? pe32PlusDefaultBaseAddress : pe32DefaultBaseAddress;
	return _baseAddress;
	}

	Writer &PECOFFLinkingContext::writer() const { return *_writer; }

	void PECOFFLinkingContext::setSectionSetMask(StringRef sectionName,
	uint32_t newFlags) {
	_sectionSetMask[sectionName] \|= newFlags;
	_sectionClearMask[sectionName] &= ~newFlags;
	const uint32_t rwx = (llvm::COFF::IMAGE_SCN_MEM_READ \|
	llvm::COFF::IMAGE_SCN_MEM_WRITE \|
	llvm::COFF::IMAGE_SCN_MEM_EXECUTE);
	if (newFlags & rwx)
	_sectionClearMask[sectionName] \|= ~_sectionSetMask[sectionName] & rwx;
	assert((_sectionSetMask[sectionName] & _sectionClearMask[sectionName]) == 0);
	}

	void PECOFFLinkingContext::setSectionClearMask(StringRef sectionName,
	uint32_t newFlags) {
	_sectionClearMask[sectionName] \|= newFlags;
	_sectionSetMask[sectionName] &= ~newFlags;
	assert((_sectionSetMask[sectionName] & _sectionClearMask[sectionName]) == 0);
	}

	uint32_t PECOFFLinkingContext::getSectionAttributes(StringRef sectionName,
	uint32_t flags) const {
	auto si = _sectionSetMask.find(sectionName);
	uint32_t setMask = (si == _sectionSetMask.end()) ? 0 : si->second;
	auto ci = _sectionClearMask.find(sectionName);
	uint32_t clearMask = (ci == _sectionClearMask.end()) ? 0 : ci->second;
	return (flags \| setMask) & ~clearMask;
	}

	// Returns true if two export descriptors have conflicting contents,
	// e.g. different export ordinals.
	static bool exportConflicts(const PECOFFLinkingContext::ExportDesc &a,
	const PECOFFLinkingContext::ExportDesc &b) {
	return (a.ordinal > 0 && b.ordinal > 0 && a.ordinal != b.ordinal) \|\|
	a.noname != b.noname \|\| a.isData != b.isData;
	}

	void PECOFFLinkingContext::addDllExport(ExportDesc &desc) {
	auto existing = _dllExports.insert(desc);
	if (existing.second)
	return;
	if (!exportConflicts(*existing.first, desc)) {
	_dllExports.erase(existing.first);
	_dllExports.insert(desc);
	return;
	}
	llvm::errs() << "Export symbol '" << desc.name
	<< "' specified more than once.\n";
	}

	std::string PECOFFLinkingContext::getOutputImportLibraryPath() const {
	if (!_implib.empty())
	return _implib;
	SmallString<128> path = outputPath();
	llvm::sys::path::replace_extension(path, ".lib");
	return path.str();
	}

	void PECOFFLinkingContext::addPasses(PassManager &pm) {
	pm.add(std::unique_ptr<Pass>(new pecoff::SetSubsystemPass(*this)));
	pm.add(std::unique_ptr<Pass>(new pecoff::EdataPass(*this)));
	pm.add(std::unique_ptr<Pass>(new pecoff::IdataPass(*this)));
	pm.add(std::unique_ptr<Pass>(new LayoutPass(registry())));
	pm.add(std::unique_ptr<Pass>(new pecoff::LoadConfigPass(*this)));
	pm.add(std::unique_ptr<Pass>(new pecoff::GroupedSectionsPass()));
	}

	} // end namespace lld