Ocloc: Add -s to options string for non-spirv input with -g option passed

Automatically add "-s" (source path) option if -g flag is present.
This applies only to non-spirv input.
- Due to conflict, do not automatically append source path when
CMC compiler is used.

Related-To: NEO-7285
Signed-off-by: Kacper Nowak kacper.nowak@intel.com

opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp

@@ -1243,6 +1243,123 @@ TEST_F(OfflineCompilerTests, givenDebugOptionThenInternalOptionShouldContainKern
     EXPECT_TRUE(hasSubstr(internalOptions, "-cl-kernel-debug-enable"));
 }
 
+TEST_F(OfflineCompilerTests, givenDebugOptionAndNonSpirvInputThenOptionsShouldContainDashSOptionAppendedAutomatically) {
+    auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
+    mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
+    mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
+    mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
+
+    std::vector<std::string> argv = {
+        "ocloc",
+        "-q",
+        "-options",
+        "-g",
+        "-file",
+        "some_input.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    mockOfflineCompiler->initialize(argv.size(), argv);
+    const auto &options = mockOfflineCompiler->options;
+    std::string appendedOption{"-s \"some_input.cl\""};
+    EXPECT_TRUE(hasSubstr(options, appendedOption));
+}
+
+TEST_F(OfflineCompilerTests, givenDebugOptionAndNonSpirvInputWhenFilenameIsSeparatedWithSpacesThenAppendedSourcePathIsSetCorrectly) {
+    auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
+    mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
+    mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
+    mockOfflineCompiler->uniqueHelper->filesMap["filename with spaces.cl"] = "";
+
+    std::vector<std::string> argv = {
+        "ocloc",
+        "-q",
+        "-options",
+        "-g",
+        "-file",
+        "filename with spaces.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    const auto result = mockOfflineCompiler->initialize(argv.size(), argv);
+    EXPECT_EQ(OclocErrorCode::SUCCESS, result);
+    const auto &options = mockOfflineCompiler->options;
+    std::string appendedOption{"-s \"filename with spaces.cl\""};
+    EXPECT_TRUE(hasSubstr(options, appendedOption));
+}
+
+TEST_F(OfflineCompilerTests, givenDebugOptionAndSpirvInputThenDoNotAppendDashSOptionAutomatically) {
+    auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
+    mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
+    mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
+    mockOfflineCompiler->uniqueHelper->filesMap["some_input.spirv"] = "";
+
+    std::vector<std::string> argvSpirvInput = {
+        "ocloc",
+        "-q",
+        "-spirv_input",
+        "-options",
+        "-g",
+        "-file",
+        "some_input.spirv",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    mockOfflineCompiler->initialize(argvSpirvInput.size(), argvSpirvInput);
+    const auto &options = mockOfflineCompiler->options;
+    std::string notAppendedOption{"-s \"some_input.spirv\""};
+    EXPECT_FALSE(hasSubstr(options, notAppendedOption));
+}
+
+TEST_F(OfflineCompilerTests, givenDebugOptionWhenCompilerIsCMCThenDoNotAppendDashSOptionAutomatically) {
+    auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
+    mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
+    mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
+    mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
+
+    std::vector<std::string> argvSpirvInput = {
+        "ocloc",
+        "-q",
+        "-options",
+        "-g cmc",
+        "-file",
+        "some_input.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    mockOfflineCompiler->initialize(argvSpirvInput.size(), argvSpirvInput);
+    const auto &options = mockOfflineCompiler->options;
+    std::string notAppendedOption{"-s \"some_input.spirv\""};
+    EXPECT_FALSE(hasSubstr(options, notAppendedOption));
+}
+
+TEST_F(OfflineCompilerTests, givenDebugOptionAndDashSOptionPassedManuallyThenDoNotAppendDashSOptionAutomatically) {
+    auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
+    mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
+    mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
+    mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
+    std::vector<std::string> argvDashSPassed = {
+        "ocloc",
+        "-q",
+        "-options",
+        "-g -s \"mockPath/some_input.cl\"",
+        "-file",
+        "some_input.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    mockOfflineCompiler->initialize(argvDashSPassed.size(), argvDashSPassed);
+    const auto &options = mockOfflineCompiler->options;
+    std::string appendedOption{"-s"};
+    auto occurrences = 0u;
+    size_t pos = 0u;
+    while ((pos = options.find(appendedOption, pos)) != std::string::npos) {
+        occurrences++;
+        pos++;
+    }
+    EXPECT_EQ(1u, occurrences);
+}
+
 TEST_F(OfflineCompilerTests, givenDashGInBiggerOptionStringWhenInitializingThenInternalOptionsShouldNotContainKernelDebugEnable) {
 
     std::vector<std::string> argv = {

shared/offline_compiler/source/offline_compiler.cpp

@@ -576,6 +576,12 @@ int OfflineCompiler::initialize(size_t numArgs, const std::vector<std::string> &
         if (hwInfo.platform.eRenderCoreFamily >= IGFX_GEN9_CORE) {
             internalOptions = CompilerOptions::concatenate(internalOptions, CompilerOptions::debugKernelEnable);
         }
+        if (false == inputFileSpirV && false == CompilerOptions::contains(options, CompilerOptions::generateSourcePath) && false == CompilerOptions::contains(options, CompilerOptions::usesCMCCompiler)) {
+            auto sourcePathStringOption = CompilerOptions::generateSourcePath.str();
+            sourcePathStringOption.append(" ");
+            sourcePathStringOption.append(CompilerOptions::wrapInQuotes(inputFile));
+            options = CompilerOptions::concatenate(options, sourcePathStringOption);
+        }
     }
 
     if (deviceName.empty()) {

shared/source/compiler_interface/compiler_options.cpp

@@ -32,6 +32,11 @@ bool contains(const std::string &options, ConstStringRef optionToFind) {
     return contains(options.c_str(), optionToFind);
 }
 
+std::string wrapInQuotes(const std::string &stringToWrap) {
+    std::string quoteEscape{"\""};
+    return std::string{quoteEscape + stringToWrap + quoteEscape};
+}
+
 TokenizedString tokenize(ConstStringRef src, char sperator) {
     TokenizedString ret;
     const char *it = src.begin();

shared/source/compiler_interface/compiler_options.h

@@ -29,6 +29,7 @@ constexpr ConstStringRef fastRelaxedMath = "-cl-fast-relaxed-math";
 constexpr ConstStringRef preserveVec3Type = "-fpreserve-vec3-type";
 constexpr ConstStringRef createLibrary = "-create-library";
 constexpr ConstStringRef generateDebugInfo = "-g";
+constexpr ConstStringRef generateSourcePath = "-s";
 constexpr ConstStringRef bindlessMode = "-cl-intel-use-bindless-mode -cl-intel-use-bindless-advanced-mode";
 constexpr ConstStringRef uniformWorkgroupSize = "-cl-uniform-work-group-size";
 constexpr ConstStringRef forceEmuInt32DivRem = "-cl-intel-force-emu-int32divrem";
@@ -42,6 +43,7 @@ constexpr ConstStringRef noRecompiledFromIr = "-Wno-recompiled-from-ir";
 constexpr ConstStringRef defaultGrf = "-cl-intel-128-GRF-per-thread";
 constexpr ConstStringRef largeGrf = "-cl-intel-256-GRF-per-thread";
 constexpr ConstStringRef numThreadsPerEu = "-cl-intel-reqd-eu-thread-count";
+constexpr ConstStringRef usesCMCCompiler = "cmc";
 
 constexpr size_t nullterminateSize = 1U;
 constexpr size_t spaceSeparatorSize = 1U;
@@ -177,6 +179,7 @@ bool contains(const char *options, ConstStringRef optionToFind);
 
 bool contains(const std::string &options, ConstStringRef optionToFind);
 
+std::string wrapInQuotes(const std::string &stringToWrap);
 using TokenizedString = StackVec<ConstStringRef, 32>;
 TokenizedString tokenize(ConstStringRef src, char sperator = ' ');