Support specifying SPIRV extensions via -spirv-ext= flag (#626)

This flag specifies list of allowed/disallowed SPIRV extensions when
generating SPIRV. It is a comma-separated list of extensions prefixed
with '+' or '-'. Its syntax is exactly the same as `-spirv-ext=` flag of
llvm-spirv tool from SPIRV-LLVM-Translator repo.

If `-spirv-ext=` is omitted, all SPIRV extensions are enabled (same as
previous behavior).

(cherry picked from commit 1369172)

Author: wenju-he

opencl_clang.cpp

@@ -55,6 +55,7 @@ Copyright (c) Intel Corporation (2009-2017).
 // in https://github.com/KhronosGroup/OpenCL-Headers/blob/master/CL/cl.h
 #define CL_SUCCESS 0
 #define CL_COMPILE_PROGRAM_FAILURE -15
+#define CL_INVALID_BUILD_OPTIONS -43
 #define CL_OUT_OF_HOST_MEMORY -6
 
 #include "assert.h"
@@ -208,7 +209,11 @@ Compile(const char *pszProgramSource, const char **pInputHeaders,
       llvm::sys::SmartScopedLock<true> compileGuard{*compileMutex};
 #endif
       // Parse options
-      optionsParser.processOptions(pszOptions, pszOptionsEx);
+      if (optionsParser.processOptions(pszOptions, pszOptionsEx) != 0) {
+        if (pBinaryResult)
+          *pBinaryResult = nullptr;
+        return CL_INVALID_BUILD_OPTIONS;
+      }
 
       // Prepare our diagnostic client.
       llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagID(
@@ -313,8 +318,10 @@ Compile(const char *pszProgramSource, const char **pInputHeaders,
       SmallVectorBuffer StreamBuf(pResult->getIRBufferRef());
       std::ostream OS(&StreamBuf);
       std::string Err;
-      SPIRV::TranslatorOpts SPIRVOpts;
-      SPIRVOpts.enableAllExtensions();
+      SPIRV::TranslatorOpts SPIRVOpts(SPIRV::VersionNumber::MaximumVersion,
+                                      optionsParser.getSPIRVExtStatusMap());
+      if (!optionsParser.hasSPIRVExt())
+        SPIRVOpts.enableAllExtensions();
       if (!optionsParser.hasOptDisable()) {
         SPIRVOpts.setMemToRegEnabled(true);
       }

options.h

@@ -27,6 +27,7 @@ Copyright (c) Intel Corporation (2009-2017).
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "clang/Basic/OpenCLOptions.h"
+#include "LLVMSPIRVOpts.h"
 
 #include <list>
 
@@ -160,7 +161,7 @@ class CompileOptionsParser {
   // Validates and prepares the effective options to pass to clang upon
   // compilation
   //
-  void processOptions(const char *pszOptions, const char *pszOptionsEx);
+  int processOptions(const char *pszOptions, const char *pszOptionsEx);
 
   //
   // Just validates the user supplied OpenCL compile options
@@ -186,6 +187,13 @@ class CompileOptionsParser {
   std::string getEffectiveOptionsAsString() const;
 
   bool hasEmitSPIRV() const { return m_emitSPIRV; }
+
+  bool hasSPIRVExt() const { return m_hasSPIRVExt; }
+
+  SPIRV::TranslatorOpts::ExtensionsStatusMap getSPIRVExtStatusMap() const {
+    return m_SPIRVExtStatusMap;
+  }
+
   bool hasOptDisable() const { return m_optDisable; }
 
 private:
@@ -195,6 +203,8 @@ class CompileOptionsParser {
   llvm::SmallVector<const char *, 16> m_effectiveArgsRaw;
   std::string m_sourceName;
   bool m_emitSPIRV;
+  bool m_hasSPIRVExt = false;
+  SPIRV::TranslatorOpts::ExtensionsStatusMap m_SPIRVExtStatusMap = {};
   bool m_optDisable;
 };
 

options_compile.cpp

@@ -62,6 +62,70 @@ OpenCLCompileOptTable::OpenCLCompileOptTable()
 
 int EffectiveOptionsFilter::s_progID = 1;
 
+// This code was adopted from the SPIRV-LLVM-Translator repository.
+static int parseSPVExtOption(
+    llvm::StringRef SPVExt,
+    SPIRV::TranslatorOpts::ExtensionsStatusMap &ExtensionsStatus) {
+  // Map name -> id for known extensions
+  std::map<llvm::StringRef, SPIRV::ExtensionID> ExtensionNamesMap;
+#define _STRINGIFY(X) #X
+#define STRINGIFY(X) _STRINGIFY(X)
+#define EXT(X) ExtensionNamesMap[STRINGIFY(X)] = SPIRV::ExtensionID::X;
+#include "LLVMSPIRVExtensions.inc"
+#undef EXT
+#undef STRINGIFY
+#undef _STRINGIFY
+
+  // Set the initial state: assume that any known extension is disallowed.
+  std::optional<bool> DefaultVal;
+  for (const auto &It : ExtensionNamesMap)
+    ExtensionsStatus[It.second] = DefaultVal;
+
+  llvm::SmallVector<llvm::StringRef, 32> SPVExtList;
+  llvm::SplitString(SPVExt, SPVExtList, ",");
+
+  if (SPVExtList.empty())
+    return 0; // Nothing to do
+
+  for (unsigned i = 0; i < SPVExtList.size(); ++i) {
+    llvm::StringRef ExtString = SPVExtList[i];
+    if (ExtString.empty() ||
+        ('+' != ExtString.front() && '-' != ExtString.front())) {
+      llvm::errs() << "Invalid value of --spirv-ext, expected format is:\n"
+                   << "\t--spirv-ext=+EXT_NAME,-EXT_NAME\n";
+      return -1;
+    }
+
+    auto ExtName = ExtString.substr(1);
+
+    if (ExtName.empty()) {
+      llvm::errs() << "Invalid value of --spirv-ext, expected format is:\n"
+                   << "\t--spirv-ext=+EXT_NAME,-EXT_NAME\n";
+      return -1;
+    }
+
+    bool ExtStatus = ('+' == ExtString.front());
+    if ("all" == ExtName) {
+      // Update status for all known extensions
+      for (const auto &It : ExtensionNamesMap)
+        ExtensionsStatus[It.second] = ExtStatus;
+    } else {
+      // Reject unknown extensions
+      const auto &It = ExtensionNamesMap.find(ExtName);
+      if (ExtensionNamesMap.end() == It) {
+        llvm::errs() << "Unknown extension '" << ExtName
+                     << "' was specified via "
+                     << "--spirv-ext option\n";
+        return -1;
+      }
+
+      ExtensionsStatus[It->second] = ExtStatus;
+    }
+  }
+
+  return 0;
+}
+
 ///
 // Options filter that validates the opencl used options
 //
@@ -397,8 +461,8 @@ std::string EffectiveOptionsFilter::processOptions(const OpenCLArgList &args,
   return sourceName;
 }
 
-void CompileOptionsParser::processOptions(const char *pszOptions,
-                                          const char *pszOptionsEx) {
+int CompileOptionsParser::processOptions(const char *pszOptions,
+                                         const char *pszOptionsEx) {
   // parse options
   unsigned missingArgIndex, missingArgCount;
   std::unique_ptr<OpenCLArgList> pArgs(
@@ -412,16 +476,27 @@ void CompileOptionsParser::processOptions(const char *pszOptions,
   for (ArgsVector::iterator it = m_effectiveArgs.begin(),
                             end = m_effectiveArgs.end();
        it != end; ++it) {
-    if (it->compare("-cl-opt-disable") == 0) {
+    llvm::StringRef arg(*it);
+    (void)arg.consume_front("-");
+    // support -- prefix as well.
+    (void)arg.consume_front("-");
+    if (arg == "cl-opt-disable") {
       m_optDisable = true;
-    }
-    else if (it->compare("-emit-spirv") == 0) {
+    } else if (arg == "emit-spirv") {
       m_effectiveArgsRaw.push_back("-emit-llvm-bc");
       m_emitSPIRV = true;
       continue;
+    } else if (arg.consume_front("spirv-ext=")) {
+      m_hasSPIRVExt = true;
+      // m_SPIRVExtStatusMap will be initialized and updated according to `arg`.
+      int ret = parseSPVExtOption(arg, m_SPIRVExtStatusMap);
+      if (0 != ret)
+        return ret;
+      continue;
     }
     m_effectiveArgsRaw.push_back(it->c_str());
   }
+  return 0;
 }
 
 bool CompileOptionsParser::checkOptions(const char *pszOptions,