[llvm-rc] Add directory lookup support (serialization, pt 11).

[mnbvmar]

Summary

This enables llvm-rc to look for its resource files in various paths. Documentation says that the path must be relative or absolute to the current working directory, however that's not whole truth. The order of directory lookup is as follows:

• Directory where .rc file resides in.
• Current working directory.
• Paths provided by -I (/I) switch, in order of the arguments.

If a relative path is given, we seek for an existing file relative to any of these locations.

Thanks for Nico Weber for his original research on this topic.

llvm/test/tools/llvm-rc/Inputs/DirTest/Dir1/Dir2/a.html

+d1/d2

llvm/test/tools/llvm-rc/Inputs/DirTest/Dir1/a.html

+d1

llvm/test/tools/llvm-rc/Inputs/DirTest/Dir1/dir-test.rc

+1 HTML "a.html"
+2 HTML "Dir2/a.html"

llvm/test/tools/llvm-rc/Inputs/DirTest/Dir2/a.html

+d2

llvm/test/tools/llvm-rc/Inputs/DirTest/Dir3/dir-test.rc

+1 HTML "a.html"
+2 HTML "Dir2/a.html"

llvm/test/tools/llvm-rc/Inputs/DirTest/a.html

+root

llvm/test/tools/llvm-rc/Inputs/DirTest/dir-test.rc

+1 HTML "a.html"
+2 HTML "Dir2/a.html"

llvm/test/tools/llvm-rc/lookup.test

+; REQUIRES: shell
+; RUN: rm -rf %t && cp -r %p/Inputs/DirTest %t && cd %t
+
+; RUN: cd %t && llvm-rc /fo %t/out1.res dir-test.rc
+; RUN: llvm-readobj %t/out1.res | FileCheck %s --check-prefix=DIR1
+
+; DIR1:      Resource type (int): 23
+; DIR1-NEXT: Resource name (int): 1
+; DIR1-NEXT: Data version: 0
+; DIR1-NEXT: Memory flags: 0x30
+; DIR1-NEXT: Language ID: 1033
+; DIR1-NEXT: Version (major): 0
+; DIR1-NEXT: Version (minor): 0
+; DIR1-NEXT: Characteristics: 0
+; DIR1-NEXT: Data size: 5
+; DIR1-NEXT: Data:: (72 6F 6F 74 0A)
+
+; DIR1-DAG:  Resource type (int): 23
+; DIR1-NEXT: Resource name (int): 2
+; DIR1-NEXT: Data version: 0
+; DIR1-NEXT: Memory flags: 0x30
+; DIR1-NEXT: Language ID: 1033
+; DIR1-NEXT: Version (major): 0
+; DIR1-NEXT: Version (minor): 0
+; DIR1-NEXT: Characteristics: 0
+; DIR1-NEXT: Data size: 3
+; DIR1-NEXT: Data:: (64 32 0A)
+
+; RUN: cd %t && llvm-rc /fo %t/out2.res Dir1/dir-test.rc
+; RUN: llvm-readobj %t/out2.res | FileCheck %s --check-prefix=DIR2
+
+; DIR2:      Resource type (int): 23
+; DIR2-NEXT: Resource name (int): 1
+; DIR2-NEXT: Data version: 0
+; DIR2-NEXT: Memory flags: 0x30
+; DIR2-NEXT: Language ID: 1033
+; DIR2-NEXT: Version (major): 0
+; DIR2-NEXT: Version (minor): 0
+; DIR2-NEXT: Characteristics: 0
+; DIR2-NEXT: Data size: 3
+; DIR2-NEXT: Data:: (64 31 0A)
+
+; DIR2-DAG:  Resource type (int): 23
+; DIR2-NEXT: Resource name (int): 2
+; DIR2-NEXT: Data version: 0
+; DIR2-NEXT: Memory flags: 0x30
+; DIR2-NEXT: Language ID: 1033
+; DIR2-NEXT: Version (major): 0
+; DIR2-NEXT: Version (minor): 0
+; DIR2-NEXT: Characteristics: 0
+; DIR2-NEXT: Data size: 6
+; DIR2-NEXT: Data:: (64 31 2F 64 32 0A)
+
+; RUN: cd %t && llvm-rc /fo %t/out3.res Dir3/dir-test.rc
+; RUN: llvm-readobj %t/out3.res | FileCheck %s --check-prefix=DIR3
+
+; DIR3:      Resource type (int): 23
+; DIR3-NEXT: Resource name (int): 1
+; DIR3-NEXT: Data version: 0
+; DIR3-NEXT: Memory flags: 0x30
+; DIR3-NEXT: Language ID: 1033
+; DIR3-NEXT: Version (major): 0
+; DIR3-NEXT: Version (minor): 0
+; DIR3-NEXT: Characteristics: 0
+; DIR3-NEXT: Data size: 5
+; DIR3-NEXT: Data:: (72 6F 6F 74 0A)
+
+; DIR3-DAG:  Resource type (int): 23
+; DIR3-NEXT: Resource name (int): 2
+; DIR3-NEXT: Data version: 0
+; DIR3-NEXT: Memory flags: 0x30
+; DIR3-NEXT: Language ID: 1033
+; DIR3-NEXT: Version (major): 0
+; DIR3-NEXT: Version (minor): 0
+; DIR3-NEXT: Characteristics: 0
+; DIR3-NEXT: Data size: 3
+; DIR3-NEXT: Data:: (64 32 0A)
+
+; RUN: cd %t/Dir3 && llvm-rc /fo %t/out4.res -I .. dir-test.rc
+; RUN: llvm-readobj %t/out4.res | FileCheck %s --check-prefix=DIR4
+
+; DIR4:      Resource type (int): 23
+; DIR4-NEXT: Resource name (int): 1
+; DIR4-NEXT: Data version: 0
+; DIR4-NEXT: Memory flags: 0x30
+; DIR4-NEXT: Language ID: 1033
+; DIR4-NEXT: Version (major): 0
+; DIR4-NEXT: Version (minor): 0
+; DIR4-NEXT: Characteristics: 0
+; DIR4-NEXT: Data size: 5
+; DIR4-NEXT: Data:: (72 6F 6F 74 0A)
+
+; DIR4-DAG:  Resource type (int): 23
+; DIR4-NEXT: Resource name (int): 2
+; DIR4-NEXT: Data version: 0
+; DIR4-NEXT: Memory flags: 0x30
+; DIR4-NEXT: Language ID: 1033
+; DIR4-NEXT: Version (major): 0
+; DIR4-NEXT: Version (minor): 0
+; DIR4-NEXT: Characteristics: 0
+; DIR4-NEXT: Data size: 3
+; DIR4-NEXT: Data:: (64 32 0A)
+
+; RUN: cd %t/Dir3 && llvm-rc /fo %t/out5.res -I %t/Dir1 -I %t dir-test.rc
+; RUN: llvm-readobj %t/out5.res | FileCheck %s --check-prefix=DIR5
+
+; DIR5:      Resource type (int): 23
+; DIR5-NEXT: Resource name (int): 1
+; DIR5-NEXT: Data version: 0
+; DIR5-NEXT: Memory flags: 0x30
+; DIR5-NEXT: Language ID: 1033
+; DIR5-NEXT: Version (major): 0
+; DIR5-NEXT: Version (minor): 0
+; DIR5-NEXT: Characteristics: 0
+; DIR5-NEXT: Data size: 3
+; DIR5-NEXT: Data:: (64 31 0A)
+
+; DIR5-DAG:  Resource type (int): 23
+; DIR5-NEXT: Resource name (int): 2
+; DIR5-NEXT: Data version: 0
+; DIR5-NEXT: Memory flags: 0x30
+; DIR5-NEXT: Language ID: 1033
+; DIR5-NEXT: Version (major): 0
+; DIR5-NEXT: Version (minor): 0
+; DIR5-NEXT: Characteristics: 0
+; DIR5-NEXT: Data size: 6
+; DIR5-NEXT: Data:: (64 31 2F 64 32 0A)
+
+
+; RUN: cd %t/Dir3 && llvm-rc /fo %t/out6.res ../Dir1/dir-test.rc
+; RUN: llvm-readobj %t/out6.res | FileCheck %s --check-prefix=DIR6
+
+; DIR6:      Resource type (int): 23
+; DIR6-NEXT: Resource name (int): 1
+; DIR6-NEXT: Data version: 0
+; DIR6-NEXT: Memory flags: 0x30
+; DIR6-NEXT: Language ID: 1033
+; DIR6-NEXT: Version (major): 0
+; DIR6-NEXT: Version (minor): 0
+; DIR6-NEXT: Characteristics: 0
+; DIR6-NEXT: Data size: 3
+; DIR6-NEXT: Data:: (64 31 0A)
+
+; DIR6-DAG:  Resource type (int): 23
+; DIR6-NEXT: Resource name (int): 2
+; DIR6-NEXT: Data version: 0
+; DIR6-NEXT: Memory flags: 0x30
+; DIR6-NEXT: Language ID: 1033
+; DIR6-NEXT: Version (major): 0
+; DIR6-NEXT: Version (minor): 0
+; DIR6-NEXT: Characteristics: 0
+; DIR6-NEXT: Data size: 6
+; DIR6-NEXT: Data:: (64 31 2F 64 32 0A)

llvm/test/tools/llvm-rc/tag-html.test

 ; HTML-NEXT:   0020: 202D2D3E 0A3C696D 67207372 633D226B  | -->.<img src="k|
 ; HTML-NEXT:   0030: 69747465 6E732E62 6D70223E 0A        |ittens.bmp">.|
 ; HTML-NEXT: )
 
 
 ; RUN: not llvm-rc /FO %t/tag-html-wrong.res %p/Inputs/tag-html-wrong.rc 2>&1 | FileCheck %s --check-prefix NOFILE
 
 ; NOFILE: llvm-rc: Error in HTML statement (ID 1):
-; NOFILE-NEXT: Error opening file 'some-really-nonexistent-file.html':
+; NOFILE-NEXT: Error opening file "some-really-nonexistent-file.html":

llvm/test/tools/llvm-rc/tag-icon-cursor.test

 ; CHECK-NEXT: Data: (
 ; CHECK-NEXT:   0000: 00000100 01001010 00000100 20005200  |............ .R.|
 ; CHECK-NEXT:   0010: 00000C00                             |....|
 ; CHECK-NEXT: )
 
 
 ; RUN: not llvm-rc /FO %t/1 %p/Inputs/tag-icon-cursor-nonexistent.rc 2>&1 | FileCheck %s --check-prefix NOFILE
 ; NOFILE: llvm-rc: Error in CURSOR statement (ID 500):
-; NOFILE-NEXT: Error opening cursor 'this-file-does-not-exist.cur':
+; NOFILE-NEXT: Error opening cursor "this-file-does-not-exist.cur":
 
 
 ; RUN: not llvm-rc /FO %t/1 %p/Inputs/tag-icon-cursor-nonsense.rc 2>&1 | FileCheck %s --check-prefix NONSENSE
 
 ; NONSENSE: llvm-rc: Error in ICON statement (ID 1):
 ; NONSENSE-NEXT: Incorrect icon/cursor Reserved field; should be 0.
 
 

llvm/tools/llvm-rc/ResourceFileWriter.h

 #include "ResourceScriptStmt.h"
 #include "ResourceVisitor.h"
 
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace rc {
 
+using PathType = SmallVector<char, 64>;
+
 class ResourceFileWriter : public Visitor {
 public:
   ResourceFileWriter(std::unique_ptr<raw_fd_ostream> Stream)
       : FS(std::move(Stream)), IconCursorID(1) {
     assert(FS && "Output stream needs to be provided to the serializator");
   }
 
   Error visitNullResource(const RCResource *) override;
public:
   Error visitStyleStmt(const StyleStmt *) override;
   Error visitVersionStmt(const VersionStmt *) override;
 
   // Stringtables are output at the end of .res file. We need a separate
   // function to do it.
   Error dumpAllStringTables();
 
   bool AppendNull; // Append '\0' to each existing STRINGTABLE element?
+  std::vector<PathType> IncludeList; // List of include paths.
 
   struct ObjectInfo {
     uint16_t LanguageInfo;
     uint32_t Characteristics;
     uint32_t VersionInfo;
 
     Optional<uint32_t> Style;
     StringRef Caption;
private:
 
   Error writeCString(StringRef Str, bool WriteTerminator = true);
 
   Error writeIdentifier(const IntOrString &Ident);
   Error writeIntOrString(const IntOrString &Data);
 
   void writeRCInt(RCInt);
 
+  ErrorOr<std::unique_ptr<MemoryBuffer>> openFile(StringRef Filename);
   Error appendFile(StringRef Filename);
 
   void padStream(uint64_t Length);
 
   // Icon and cursor IDs are allocated starting from 1 and increasing for
   // each icon/cursor dumped. This maintains the current ID to be allocated.
   uint16_t IconCursorID;
 };
 
 } // namespace rc
 } // namespace llvm
 
 #endif

llvm/tools/llvm-rc/ResourceFileWriter.cpp

 //===---------------------------------------------------------------------===//
 
 #include "ResourceFileWriter.h"
 
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/EndianStream.h"
+#include "llvm/Support/Path.h"
 
 using namespace llvm::support;
 
 // Take an expression returning llvm::Error and forward the error if it exists.
 #define RETURN_IF_ERROR(Expr)                                                  \
   if (auto Err = (Expr))                                                       \
     return Err;
 

 
 void ResourceFileWriter::writeRCInt(RCInt Value) {
   if (Value.isLong())
     writeObject((uint32_t)Value);
   else
     writeObject((uint16_t)Value);
 }
 
-Error ResourceFileWriter::appendFile(StringRef Filename) {
+// Open requested file, taking all include paths into account.
+ErrorOr<std::unique_ptr<MemoryBuffer>>
+ResourceFileWriter::openFile(StringRef Filename) {
   bool IsLong;
   stripQuotes(Filename, IsLong);
 
-  // Filename path should be relative to the current working directory.
-  // FIXME: docs say so, but reality is more complicated, script
-  // location and include paths must be taken into account.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> File =
-      MemoryBuffer::getFile(Filename, -1, false);
+  for (auto Path : IncludeList) {
+    PathType FullPath = Path;
+    sys::path::append(FullPath, Filename);
+    if (!sys::fs::exists(FullPath))
+      continue;
+
+    return MemoryBuffer::getFile(FullPath, -1, false);
+  }
+
+  return std::make_error_code(std::errc::no_such_file_or_directory);
+}
+
+Error ResourceFileWriter::appendFile(StringRef Filename) {
+  auto File = openFile(Filename);
   if (!File)
-    return make_error<StringError>("Error opening file '" + Filename +
-                                       "': " + File.getError().message(),
+    return make_error<StringError>("Error opening file " + Filename +
+                                       ": " + File.getError().message(),
                                    File.getError());
   *FS << (*File)->getBuffer();
   return Error::success();
 }
 
 void ResourceFileWriter::padStream(uint64_t Length) {
   assert(Length > 0);
   uint64_t Location = tell();
if (auto *IconRes = dyn_cast<IconResource>(Base)) {
     FileStr = IconRes->IconLoc;
     Type = IconCursorGroupType::Icon;
   } else {
     auto *CursorRes = dyn_cast<CursorResource>(Base);
     FileStr = CursorRes->CursorLoc;
     Type = IconCursorGroupType::Cursor;
   }
 
-  bool IsLong;
-  stripQuotes(FileStr, IsLong);
-  ErrorOr<std::unique_ptr<MemoryBuffer>> File =
-      MemoryBuffer::getFile(FileStr, -1, false);
-
+  auto File = openFile(FileStr);
   if (!File)
     return make_error<StringError>(
         "Error opening " +
             Twine(Type == IconCursorGroupType::Icon ? "icon" : "cursor") +
-            " '" + FileStr + "': " + File.getError().message(),
+            " " + FileStr + ": " + File.getError().message(),
         File.getError());
 
   BinaryStreamReader Reader((*File)->getBuffer(), support::little);
 
   // Read the file headers.
   //   - At the beginning, ICONDIR/NEWHEADER header.
   //   - Then, a number of RESDIR headers follow. These contain offsets
   //       to data.

llvm/tools/llvm-rc/llvm-rc.cpp

 #include "ResourceScriptStmt.h"
 #include "ResourceScriptToken.h"
 
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <system_error>
 
 using namespace llvm;

 
 static ExitOnError ExitOnErr;
 
 LLVM_ATTRIBUTE_NORETURN static void fatalError(Twine Message) {
   errs() << Message << "\n";
   exit(1);
 }
 
+PathType pathToNative(StringRef Location) {
+  PathType LocationStr;
+  sys::path::native(Location, LocationStr);
+  if (auto EC = sys::fs::make_absolute(LocationStr))
+    fatalError("Could not process get absolute input file name.");
+  return LocationStr;
+}
+
+std::vector<PathType>
+fetchIncludes(StringRef InputName, const opt::InputArgList &InputArgs) {
+  // Include search order:
+  // 1. next to the input .rc
+  // 2. cwd
+  // 3. in all /I args (relative to cwd), in order
+  // 4. in directories in %INCLUDE% (FIXME: not implemented; also a bit silly),
+  //    if /x isn't passed (/x makes MS rc not look in %INCLUDE%)
+
+  std::vector<PathType> Dirs{pathToNative(sys::path::parent_path(InputName)),
+                             pathToNative(StringRef())};
+  for (auto Include : InputArgs.getAllArgValues(OPT_INCLUDE))
+    Dirs.push_back(pathToNative(Include));
+  return Dirs;
+}
+
 } // anonymous namespace
 
 int main(int argc_, const char *argv_[]) {
   sys::PrintStackTraceOnErrorSignal(argv_[0]);
   PrettyStackTraceProgram X(argc_, argv_);
 
   ExitOnErr.setBanner("llvm-rc: ");
 
int main(int argc_, const char *argv_[]) {
   const bool BeVerbose = InputArgs.hasArg(OPT_VERBOSE);
 
   std::vector<std::string> InArgsInfo = InputArgs.getAllArgValues(OPT_INPUT);
   if (InArgsInfo.size() != 1) {
     fatalError("Exactly one input file should be provided.");
   }
 
   // Read and tokenize the input file.
-  const Twine &Filename = InArgsInfo[0];
+  StringRef Filename = InArgsInfo[0];
   ErrorOr<std::unique_ptr<MemoryBuffer>> File = MemoryBuffer::getFile(Filename);
   if (!File) {
     fatalError("Error opening file '" + Filename +
                "': " + File.getError().message());
   }
 
   std::unique_ptr<MemoryBuffer> FileContents = std::move(*File);
   StringRef Contents = FileContents->getBuffer();
if (!IsDryRun) {
     std::error_code EC;
     auto FOut =
         llvm::make_unique<raw_fd_ostream>(OutArgsInfo[0], EC, sys::fs::F_RW);
     if (EC)
       fatalError("Error opening output file '" + OutArgsInfo[0] +
                  "': " + EC.message());
     Visitor = make_unique<ResourceFileWriter>(std::move(FOut));
     Visitor->AppendNull = InputArgs.hasArg(OPT_ADD_NULL);
+    Visitor->IncludeList = fetchIncludes(Filename, InputArgs);
 
     ExitOnErr(NullResource().visit(Visitor.get()));
 
     // Set the default language; choose en-US arbitrarily.
     ExitOnErr(LanguageResource(0x09, 0x01).visit(Visitor.get()));
   }
 
   rc::RCParser Parser{std::move(Tokens)};