maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Switch external cvtres.exe for llvm's own resource library. 

In this patch, I flip the switch in DriverUtils from using the external
cvtres.exe tool to using the Windows Resource library in llvm.

I also fixed a bug where .rsrc sections were marked as discardable
memory and therefore were placed in the wrong order in the final PE.

Furthermore, I modified WindowsResource to write the coff directly to a
memory buffer instead of to file, also had it use the machine types
already declared in COFF.h instead creating my own enum.

Finally, I flipped the switch to allow all unit tests that had
previously run only on windows due to a winres dependency to run
cross-platform.

Reviewers: zturner, ruiu

Subscribers: llvm-commits, hiraditya

Differential Revision: https://reviews.llvm.org/D34265

llvm-svn: 305592
This commit is contained in:
Eric Beckmann 2017-06-16 21:13:24 +00:00
parent 6bc14c65ad
commit d135e8c039
12 changed files with 65 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
lld/COFF/DriverUtils.cpp
View File

@ -21,6 +21,7 @@
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/WindowsResource.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Option/Option.h"
@ -592,40 +593,23 @@ void checkFailIfMismatch(StringRef Arg) {
// using cvtres.exe.
std::unique_ptr<MemoryBuffer>
convertResToCOFF(const std::vector<MemoryBufferRef> &MBs) {
// Create an output file path.
TemporaryFile File("resource-file", "obj");
object::WindowsResourceParser Parser;
// Execute cvtres.exe.
Executor E("cvtres.exe");
E.add("/machine:" + machineToStr(Config->Machine));
E.add("/readonly");
E.add("/nologo");
E.add("/out:" + Twine(File.Path));
// We must create new files because the memory buffers we have may have no
// underlying file still existing on the disk.
// It happens if it was created from a TemporaryFile, which usually delete
// the file just after creating the MemoryBuffer.
std::vector<TemporaryFile> ResFiles;
ResFiles.reserve(MBs.size());
for (MemoryBufferRef MB : MBs) {
// We store the temporary file in a vector to avoid deletion
// before running cvtres
ResFiles.emplace_back("resource-file", "res");
TemporaryFile& ResFile = ResFiles.back();
// Write the content of the resource in a temporary file
std::error_code EC;
raw_fd_ostream OS(ResFile.Path, EC, sys::fs::F_None);
if (EC)
fatal(EC, "failed to open " + ResFile.Path);
OS << MB.getBuffer();
OS.close();
E.add(ResFile.Path);
std::unique_ptr<object::Binary> Bin = check(object::createBinary(MB));
object::WindowsResource *RF = dyn_cast<object::WindowsResource>(Bin.get());
if (!RF)
fatal("cannot compile non-resource file as resource");
if (auto EC = Parser.parse(RF))
fatal(EC, "failed to parse .res file");
}
E.run();
return File.getMemoryBuffer();
std::unique_ptr<MemoryBuffer> MB;
if (auto EC =
llvm::object::writeWindowsResourceCOFF(MB, Config->Machine, Parser))
fatal(EC, "failed to write resources to buffer");
return MB;
}
// Run MSVC link.exe for given in-memory object files.

2
lld/test/COFF/def-name.test
View File

@ -1,5 +1,3 @@
# REQUIRES: winres
# RUN: rm -rf %t
# RUN: mkdir -p %t
# RUN: cd %t

2
lld/test/COFF/dll.test
View File

@ -1,5 +1,3 @@
# REQUIRES: winres
# RUN: yaml2obj < %p/Inputs/export.yaml > %t.obj
# RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2 \
# RUN: /export:mangled

2
lld/test/COFF/dllimport-gc.test
View File

@ -1,5 +1,3 @@
# REQUIRES: winres
# RUN: yaml2obj < %p/Inputs/export.yaml > %t-lib.obj
# RUN: lld-link /out:%t.dll /dll %t-lib.obj /implib:%t.lib /export:exportfn1

2
lld/test/COFF/manifestinput.test
View File

@ -1,4 +1,4 @@
# REQUIRES: winres
# REQUIRES: win_mt
# RUN: yaml2obj %p/Inputs/ret42.yaml > %t.obj
# RUN: lld-link /out:%t.exe /entry:main \

2
lld/test/COFF/noentry.test
View File

@ -1,5 +1,3 @@
# REQUIRES: winres
# RUN: yaml2obj < %p/Inputs/export.yaml > %t.obj
# RUN: lld-link /out:%t.dll /dll %t.obj
# RUN: llvm-readobj -file-headers %t.dll | FileCheck -check-prefix=ENTRY %s

1
lld/test/COFF/out.test
View File

@ -1,4 +1,3 @@
# REQUIRES: winres
# RUN: yaml2obj < %p/Inputs/ret42.yaml > %t.obj
# RUN: mkdir -p %T/out/tmp

2
lld/test/COFF/resource.test
View File

@ -1,5 +1,3 @@
# REQUIRES: winres
# RUN: yaml2obj < %p/Inputs/ret42.yaml > %t.obj
# RUN: lld-link /out:%t.exe /entry:main %t.obj %p/Inputs/resource.res

8
lld/test/lit.cfg
View File

@ -262,8 +262,6 @@ llvm_config_cmd.wait()
# Set a fake constant version so that we get consitent output.
config.environment['LLD_VERSION'] = 'LLD 1.0'
# Check if Windows resource file compiler exists.
cvtres = lit.util.which('cvtres', config.environment['PATH'])
rc = lit.util.which('rc', config.environment['PATH'])
if cvtres and rc:
config.available_features.add('winres')
# Check if the mt.exe Microsoft utility exists.
if lit.util.which('mt.exe', config.environment['PATH']):
config.available_features.add('win_mt')

7
llvm/include/llvm/Object/WindowsResource.h
View File

@ -45,14 +45,10 @@
namespace llvm {
class FileOutputBuffer;
namespace object {
class WindowsResource;
enum class Machine { UNKNOWN, ARM, X64, X86 };
class ResourceEntryRef {
public:
Error moveNext(bool &End);
@ -185,7 +181,8 @@ private:
std::vector<std::vector<UTF16>> StringTable;
};
Error writeWindowsResourceCOFF(StringRef OutputFile, Machine MachineType,
Error writeWindowsResourceCOFF(std::unique_ptr<MemoryBuffer> &OutputBuffer,
llvm::COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser);
} // namespace object

53
llvm/lib/Object/WindowsResource.cpp
View File

@ -21,6 +21,8 @@
#include <sstream>
#include <system_error>
using namespace llvm;
namespace llvm {
namespace object {
@ -305,7 +307,8 @@ uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
class WindowsResourceCOFFWriter {
public:
WindowsResourceCOFFWriter(StringRef OutputFile, Machine MachineType,
WindowsResourceCOFFWriter(std::unique_ptr<MemoryBuffer> &OutputBuffer,
COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser, Error &E);
Error write();
@ -323,10 +326,10 @@ private:
void writeDirectoryTree();
void writeDirectoryStringTable();
void writeFirstSectionRelocations();
std::unique_ptr<FileOutputBuffer> Buffer;
uint8_t *BufferStart;
std::unique_ptr<MemoryBuffer> &OutputBuffer;
char *BufferStart;
uint64_t CurrentOffset = 0;
Machine MachineType;
COFF::MachineTypes MachineType;
const WindowsResourceParser::TreeNode &Resources;
const ArrayRef<std::vector<uint8_t>> Data;
uint64_t FileSize;
@ -343,20 +346,14 @@ private:
};
WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
StringRef OutputFile, Machine MachineType,
std::unique_ptr<MemoryBuffer> &OutputBuffer, COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser, Error &E)
: MachineType(MachineType), Resources(Parser.getTree()),
Data(Parser.getData()), StringTable(Parser.getStringTable()) {
: OutputBuffer(OutputBuffer), MachineType(MachineType),
Resources(Parser.getTree()), Data(Parser.getData()),
StringTable(Parser.getStringTable()) {
performFileLayout();
ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
FileOutputBuffer::create(OutputFile, FileSize);
if (!BufferOrErr) {
E = errorCodeToError(BufferOrErr.getError());
return;
}
Buffer = std::move(*BufferOrErr);
OutputBuffer = std::move(MemoryBuffer::getNewMemBuffer(FileSize));
}
void WindowsResourceCOFFWriter::performFileLayout() {
@ -421,7 +418,7 @@ static std::time_t getTime() {
}
Error WindowsResourceCOFFWriter::write() {
BufferStart = Buffer->getBufferStart();
BufferStart = const_cast<char *>(OutputBuffer->getBufferStart());
writeCOFFHeader();
writeFirstSectionHeader();
@ -431,10 +428,6 @@ Error WindowsResourceCOFFWriter::write() {
writeSymbolTable();
writeStringTable();
if (auto EC = Buffer->commit()) {
return errorCodeToError(EC);
}
return Error::success();
}
@ -443,13 +436,13 @@ void WindowsResourceCOFFWriter::writeCOFFHeader() {
auto *Header =
reinterpret_cast<llvm::object::coff_file_header *>(BufferStart);
switch (MachineType) {
case Machine::ARM:
case COFF::IMAGE_FILE_MACHINE_ARMNT:
Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
break;
case Machine::X64:
case COFF::IMAGE_FILE_MACHINE_AMD64:
Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
break;
case Machine::X86:
case COFF::IMAGE_FILE_MACHINE_I386:
Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_I386;
break;
default:
@ -481,7 +474,8 @@ void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
SectionOneHeader->Characteristics = llvm::COFF::IMAGE_SCN_ALIGN_1BYTES;
SectionOneHeader->Characteristics +=
llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
SectionOneHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_DISCARDABLE;
SectionOneHeader->Characteristics +=
llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
SectionOneHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_READ;
}
@ -715,13 +709,13 @@ void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
Reloc->VirtualAddress = RelocationAddresses[i];
Reloc->SymbolTableIndex = NextSymbolIndex++;
switch (MachineType) {
case Machine::ARM:
case COFF::IMAGE_FILE_MACHINE_ARMNT:
Reloc->Type = llvm::COFF::IMAGE_REL_ARM_ADDR32NB;
break;
case Machine::X64:
case COFF::IMAGE_FILE_MACHINE_AMD64:
Reloc->Type = llvm::COFF::IMAGE_REL_AMD64_ADDR32NB;
break;
case Machine::X86:
case COFF::IMAGE_FILE_MACHINE_I386:
Reloc->Type = llvm::COFF::IMAGE_REL_I386_DIR32NB;
break;
default:
@ -731,10 +725,11 @@ void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
}
}
Error writeWindowsResourceCOFF(StringRef OutputFile, Machine MachineType,
Error writeWindowsResourceCOFF(std::unique_ptr<MemoryBuffer> &OutputBuffer,
COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser) {
Error E = Error::success();
WindowsResourceCOFFWriter Writer(OutputFile, MachineType, Parser, E);
WindowsResourceCOFFWriter Writer(OutputBuffer, MachineType, Parser, E);
if (E)
return E;
return Writer.write();

33
llvm/tools/llvm-cvtres/llvm-cvtres.cpp
View File

@ -114,21 +114,21 @@ int main(int argc_, const char *argv_[]) {
bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
Machine MachineType;
COFF::MachineTypes MachineType;
if (InputArgs.hasArg(OPT_MACHINE)) {
std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
MachineType = StringSwitch<Machine>(MachineString)
.Case("ARM", Machine::ARM)
.Case("X64", Machine::X64)
.Case("X86", Machine::X86)
.Default(Machine::UNKNOWN);
if (MachineType == Machine::UNKNOWN)
MachineType = StringSwitch<COFF::MachineTypes>(MachineString)
.Case("ARM", COFF::IMAGE_FILE_MACHINE_ARMNT)
.Case("X64", COFF::IMAGE_FILE_MACHINE_AMD64)
.Case("X86", COFF::IMAGE_FILE_MACHINE_I386)
.Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN)
reportError("Unsupported machine architecture");
} else {
if (Verbose)
outs() << "Machine architecture not specified; assumed X64.\n";
MachineType = Machine::X64;
MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
}
std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
@ -149,10 +149,10 @@ int main(int argc_, const char *argv_[]) {
if (Verbose) {
outs() << "Machine: ";
switch (MachineType) {
case Machine::ARM:
case COFF::IMAGE_FILE_MACHINE_ARMNT:
outs() << "ARM\n";
break;
case Machine::X86:
case COFF::IMAGE_FILE_MACHINE_I386:
outs() << "X86\n";
break;
default:
@ -196,8 +196,17 @@ int main(int argc_, const char *argv_[]) {
Parser.printTree(errs());
}
error(
llvm::object::writeWindowsResourceCOFF(OutputFile, MachineType, Parser));
std::unique_ptr<MemoryBuffer> OutputBuffer;
error(llvm::object::writeWindowsResourceCOFF(OutputBuffer, MachineType,
Parser));
auto FileOrErr =
FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
if (!FileOrErr)
reportError(OutputFile, FileOrErr.getError());
std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
FileBuffer->getBufferStart());
error(FileBuffer->commit());
if (Verbose) {
Expected<object::OwningBinary<object::Binary>> BinaryOrErr =