spirv-val: Allow tool to process directories (KhronosGroup#6292)

This patch enables spirv-val to process a directory as its input.
The behaviour remains unchanged, except now filename is printed
alongside a line number in the error message, when a single file
is passed. When a directory is passed the tool will process all
files in the directory and its nested directories recursively.
Only files with the `.spv` extension are processed.

When in the "directory mode" the tool will process all files (no
early exit) and print validation errors as it goes. When any of
the files fails validation non-zero code is returned.

The selection of the mode (single file or directory) is done
transparently to the user based on the path passed to the tool.

This change is done to improve validation of SPIR-V modules in
SPIR-V MLIR (see KhronosGroup#6276).

Author: IgWod-IMG

tools/val/val.cpp

@@ -15,6 +15,7 @@
 #include <cassert>
 #include <cstdio>
 #include <cstring>
+#include <filesystem>
 #include <iostream>
 #include <vector>
 
@@ -27,12 +28,15 @@
 void print_usage(char* argv0) {
   std::string target_env_list = spvTargetEnvList(36, 105);
   printf(
-      R"(%s - Validate a SPIR-V binary file.
+      R"(%s - Validate a SPIR-V binary file(s).
 
-USAGE: %s [options] [<filename>]
+USAGE: %s [options] [<path>]
 
-The SPIR-V binary is read from <filename>. If no file is specified,
-or if the filename is "-", then the binary is read from standard input.
+The SPIR-V binary is read from <path>. If no path is specified,
+or if the path is "-", then the binary is read from standard input.
+The <path> parameter may also specify a directory; in this case,
+the tool will recursively process all regular files with the .spv
+extension within that directory.
 
 NOTE: The validator is a work in progress.
 
@@ -79,6 +83,53 @@ NOTE: The validator is a work in progress.
       argv0, argv0, target_env_list.c_str());
 }
 
+bool process_single_file(const char* filename, spv_target_env& target_env,
+                         spvtools::ValidatorOptions& options,
+                         bool use_default_msg_consumer) {
+  std::vector<uint32_t> contents;
+  if (!ReadBinaryFile(filename, &contents)) return false;
+
+  spvtools::SpirvTools tools(target_env);
+
+  // Use a lambda expression here so filename can be captured. Messages use a
+  // fairly standard notation of `filename:line`.
+  auto CLIMessageConsumerWithFilename =
+      [filename](spv_message_level_t level, const char*,
+                 const spv_position_t& position, const char* message) {
+        const char* pretty_filename = filename;
+        if (!filename || 0 == strcmp(filename, "-")) {
+          pretty_filename = "stdin";
+        }
+
+        switch (level) {
+          case SPV_MSG_FATAL:
+          case SPV_MSG_INTERNAL_ERROR:
+          case SPV_MSG_ERROR:
+            std::cerr << "error: " << pretty_filename << ":" << position.index
+                      << ": " << message << std::endl;
+            break;
+          case SPV_MSG_WARNING:
+            std::cout << "warning: " << pretty_filename << ":" << position.index
+                      << ": " << message << std::endl;
+            break;
+          case SPV_MSG_INFO:
+            std::cout << "info: " << pretty_filename << ":" << position.index
+                      << ": " << message << std::endl;
+            break;
+          default:
+            break;
+        }
+      };
+
+  if (use_default_msg_consumer) {
+    tools.SetMessageConsumer(spvtools::utils::CLIMessageConsumer);
+  } else {
+    tools.SetMessageConsumer(CLIMessageConsumerWithFilename);
+  }
+
+  return tools.Validate(contents.data(), contents.size(), options);
+}
+
 int main(int argc, char** argv) {
   const char* inFile = nullptr;
   spv_target_env target_env = SPV_ENV_UNIVERSAL_1_6;
@@ -201,13 +252,28 @@ int main(int argc, char** argv) {
     return return_code;
   }
 
-  std::vector<uint32_t> contents;
-  if (!ReadBinaryFile(inFile, &contents)) return 1;
+  if (inFile &&
+      std::filesystem::is_directory(std::filesystem::status(inFile))) {
+    const std::filesystem::path dir(inFile);
+    bool succeed = true;
+    for (auto const& entry :
+         std::filesystem::recursive_directory_iterator(dir)) {
+      if (!entry.is_regular_file()) {
+        continue;
+      }
 
-  spvtools::SpirvTools tools(target_env);
-  tools.SetMessageConsumer(spvtools::utils::CLIMessageConsumer);
+      std::filesystem::path filepath = entry.path();
 
-  bool succeed = tools.Validate(contents.data(), contents.size(), options);
+      if (filepath.extension() != ".spv") continue;
+
+      if (!process_single_file(filepath.u8string().c_str(), target_env, options,
+                               false)) {
+        succeed = false;
+      }
+    }
+
+    return !succeed;
+  }
 
-  return !succeed;
+  return !process_single_file(inFile, target_env, options, true);
 }