Fix SLANG_ENABLE_ASAN CMake option

cmake/CompilerFlags.cmake

@@ -214,19 +214,27 @@ function(set_default_compile_options target)
     )
 
     if(SLANG_ENABLE_ASAN)
-        add_supported_cxx_flags(
-            ${target}
-            PRIVATE
-            /fsanitize=address
-            -fsanitize=address
-        )
-        add_supported_cxx_linker_flags(
-            ${target}
-            BEFORE
-            PUBLIC
-            /INCREMENTAL:NO
-            -fsanitize=address
-        )
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+            # Clang defaults to statically linking the sanitizer runtime (except on macOS/Darwin),
+            # which is not compatible with `-Wl,--no-undefined`, so we need to use dynamic linking
+            # instead (`-shared-libsan`).
+            target_compile_options(
+                ${target}
+                PRIVATE -fsanitize=address -shared-libsan
+            )
+            target_link_options(
+                ${target}
+                PUBLIC -fsanitize=address -shared-libsan
+            )
+        elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+            target_compile_options(${target} PRIVATE -fsanitize=address)
+            target_link_options(${target} PUBLIC -fsanitize=address)
+        elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+            target_compile_options(${target} PRIVATE /fsanitize=address)
+            target_link_options(${target} PRIVATE /INCREMENTAL:NO)
+        else()
+            message(FATAL_ERROR "SLANG_ENABLE_ASAN: unsupported C++ compiler")
+        endif()
     endif()
 
     if(SLANG_ENABLE_COVERAGE)

source/compiler-core/slang-downstream-compiler.cpp

@@ -69,16 +69,30 @@ SlangResult CommandLineDownstreamCompiler::compile(
     if (!isVersionCompatible(inOptions))
     {
         // Not possible to compile with this version of the interface.
+        // TODO: Fix other `IDownstreamCompiler::compile` implementations not always writing to
+        // `outArtifact` when returning early.
+        const auto targetDesc = ArtifactDescUtil::makeDescForCompileTarget(SLANG_TARGET_UNKNOWN);
+        auto artifact = ArtifactUtil::createArtifact(targetDesc);
+        *outArtifact = artifact.detach();
         return SLANG_E_NOT_IMPLEMENTED;
     }
 
     CompileOptions options = getCompatibleVersion(&inOptions);
+    const auto targetDesc = ArtifactDescUtil::makeDescForCompileTarget(options.targetType);
 
-    // Copy the command line options
-    CommandLine cmdLine(m_cmdLine);
+    // Create the result artifact
+    auto resultArtifact = ArtifactUtil::createArtifact(targetDesc);
 
-    // Work out the ArtifactDesc
-    const auto targetDesc = ArtifactDescUtil::makeDescForCompileTarget(options.targetType);
+    // Create the diagnostics
+    auto diagnostics = ArtifactDiagnostics::create();
+    ArtifactUtil::addAssociated(resultArtifact, diagnostics);
+
+    // If Slang was built with Clang or GCC and sanitizers were enabled, the same `-fsanitize=...`
+    // flag must be passed when linking an executable or shared library with a Slang library, or
+    // linking will fail. We can't instrument C++ generated from Slang code with sanitizers as they
+    // might report errors that can't be fixed, so we separate compilation and linking into two
+    // commands to enable sanitizers only during linking.
+    bool shouldSeparateCompileAndLink = options.targetType != SLANG_OBJECT_CODE;
 
     auto helper = DefaultArtifactHelper::getSingleton();
 
@@ -95,8 +109,13 @@ SlangResult CommandLineDownstreamCompiler::compile(
     {
         // We could use the path to the source, or use the source name/paths as defined on the
         // artifact For now we just go with a lock file based on "slang-generated".
-        SLANG_RETURN_ON_FAIL(
-            helper->createLockFile(asCharSlice(toSlice("slang-generated")), lockFile.writeRef()));
+        if (SLANG_FAILED(helper->createLockFile(
+                asCharSlice(toSlice("slang-generated")),
+                lockFile.writeRef())))
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
 
         auto lockArtifact = Artifact::create(
             ArtifactDesc::make(ArtifactKind::Base, ArtifactPayload::Lock, ArtifactStyle::None));
@@ -110,17 +129,83 @@ SlangResult CommandLineDownstreamCompiler::compile(
         options.modulePath = SliceUtil::asTerminatedCharSlice(modulePath);
     }
 
+    // Compile stage if executable or library target: compile source to object code
+
+    ComPtr<IArtifact> objectArtifact;
+
+    if (shouldSeparateCompileAndLink)
+    {
+        CompileOptions compileOptions = options;
+        compileOptions.targetType = SLANG_OBJECT_CODE;
+
+        CommandLine compileCmdLine(m_cmdLine);
+        if (SLANG_FAILED(calcArgs(compileOptions, compileCmdLine)))
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
+
+        List<ComPtr<IArtifact>> compileArtifacts;
+        if (SLANG_FAILED(calcCompileProducts(
+                compileOptions,
+                DownstreamProductFlag::All,
+                lockFile,
+                compileArtifacts)))
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
+
+        // There should only be one object file (.o/.obj) as artifact
+        SLANG_ASSERT(compileArtifacts.getCount() == 1);
+        SLANG_ASSERT(compileArtifacts[0]->getDesc().kind == ArtifactKind::ObjectCode);
+        objectArtifact = compileArtifacts[0];
+
+        ExecuteResult compileResult;
+        if (SLANG_FAILED(ProcessUtil::execute(compileCmdLine, compileResult)) ||
+            SLANG_FAILED(parseOutput(compileResult, diagnostics)))
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
+
+        // If compilation failed, return the diagnostics
+        if (compileResult.resultCode != 0 || !objectArtifact->exists())
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
+    }
+
+    // Link stage if executable or library target, or single-stage compile if object code target
+
+    CommandLine cmdLine(m_cmdLine);
+
+    if (shouldSeparateCompileAndLink)
+    {
+        // Pass compiled object to linker
+        options.sourceArtifacts = makeSlice(objectArtifact.readRef(), 1);
+    }
+
     // Append command line args to the end of cmdLine using the target specific function for the
     // specified options
-    SLANG_RETURN_ON_FAIL(calcArgs(options, cmdLine));
+    if (SLANG_FAILED(calcArgs(options, cmdLine)))
+    {
+        *outArtifact = resultArtifact.detach();
+        return SLANG_FAIL;
+    }
 
     // The 'productArtifact' is the main product produced from the compilation - the
     // executable/sharedlibrary/object etc
     ComPtr<IArtifact> productArtifact;
     {
         List<ComPtr<IArtifact>> artifacts;
-        SLANG_RETURN_ON_FAIL(
-            calcCompileProducts(options, DownstreamProductFlag::All, lockFile, artifacts));
+        if (SLANG_FAILED(
+                calcCompileProducts(options, DownstreamProductFlag::All, lockFile, artifacts)))
+        {
+            *outArtifact = resultArtifact.detach();
+            return SLANG_FAIL;
+        }
 
         for (IArtifact* artifact : artifacts)
         {
@@ -139,6 +224,7 @@ SlangResult CommandLineDownstreamCompiler::compile(
     // Somethings gone wrong if we don't find the main artifact
     if (!productArtifact)
     {
+        *outArtifact = resultArtifact.detach();
         return SLANG_FAIL;
     }
 
@@ -152,7 +238,13 @@ SlangResult CommandLineDownstreamCompiler::compile(
     }
 #endif
 
-    SLANG_RETURN_ON_FAIL(ProcessUtil::execute(cmdLine, exeRes));
+    if (SLANG_FAILED(ProcessUtil::execute(cmdLine, exeRes)) ||
+        SLANG_FAILED(parseOutput(exeRes, diagnostics)))
+    {
+        // If the process failed or the output parsing failed, return the diagnostics
+        *outArtifact = resultArtifact.detach();
+        return SLANG_FAIL;
+    }
 
 #if 0
     {
@@ -209,23 +301,13 @@ SlangResult CommandLineDownstreamCompiler::compile(
         }
     }
 
-    // Create the result artifact
-    auto artifact = ArtifactUtil::createArtifact(targetDesc);
-
-    // Createa the diagnostics
-    auto diagnostics = ArtifactDiagnostics::create();
-
-    SLANG_RETURN_ON_FAIL(parseOutput(exeRes, diagnostics));
-
-    ArtifactUtil::addAssociated(artifact, diagnostics);
-
     // Find the rep from the 'main' artifact, we'll just use the same representation on the output
     // artifact. Sharing is desirable, because the rep owns the file.
     if (auto fileRep = productArtifact
                            ? findRepresentation<IOSFileArtifactRepresentation>(productArtifact)
                            : nullptr)
     {
-        artifact->addRepresentation(fileRep);
+        resultArtifact->addRepresentation(fileRep);
     }
 
     // Add the artifact list if there is anything in it
@@ -242,10 +324,10 @@ SlangResult CommandLineDownstreamCompiler::compile(
 
         artifactContainer->setChildren(slice.data, slice.count);
 
-        artifact->addAssociated(artifactContainer);
+        resultArtifact->addAssociated(artifactContainer);
     }
 
-    *outArtifact = artifact.detach();
+    *outArtifact = resultArtifact.detach();
     return SLANG_OK;
 }
 

source/compiler-core/slang-gcc-compiler-util.cpp

@@ -375,8 +375,7 @@ static SlangResult _parseGCCFamilyLine(
 
     SliceAllocator allocator;
 
-    diagnostics->reset();
-    diagnostics->setRaw(SliceUtil::asCharSlice(exeRes.standardError));
+    diagnostics->appendRaw(SliceUtil::asCharSlice(exeRes.standardError));
 
     // We hold in workDiagnostics so as it is more convenient to append to the last with a
     // continuation also means we don't hold the allocations of building up continuations, just the
@@ -603,12 +602,6 @@ static SlangResult _parseGCCFamilyLine(
         {
             // Shared library
             cmdLine.addArg("-shared");
-
-            if (PlatformUtil::isFamily(PlatformFamily::Unix, platformKind))
-            {
-                // Position independent
-                cmdLine.addArg("-fPIC");
-            }
             break;
         }
     case SLANG_HOST_EXECUTABLE:
@@ -620,12 +613,33 @@ static SlangResult _parseGCCFamilyLine(
         {
             // Don't link, just produce object file
             cmdLine.addArg("-c");
+
             break;
         }
     default:
         break;
     }
 
+    if (PlatformUtil::isFamily(PlatformFamily::Unix, platformKind))
+    {
+        // Position independent
+        cmdLine.addArg("-fPIC");
+    }
+
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+    if (options.targetType != SLANG_OBJECT_CODE)
+    {
+#if SLANG_CLANG || SLANG_GCC
+        cmdLine.addArg("-fsanitize=address");
+#endif
+#if SLANG_CLANG
+        cmdLine.addArg("-shared-libsan");
+#endif
+    }
+#endif
+#endif
+
     // Add defines
     for (const auto& define : options.defines)
     {
@@ -711,13 +725,17 @@ static SlangResult _parseGCCFamilyLine(
             const UnownedStringSlice path(fileRep->getPath());
             libPathPool.add(Path::getParentDirectory(path));
 
-            cmdLine.addPrefixPathArg(
-                "-l",
-                ArtifactDescUtil::getBaseNameFromPath(artifact->getDesc(), path));
+            if (options.targetType != SLANG_OBJECT_CODE)
+            {
+                cmdLine.addPrefixPathArg(
+                    "-l",
+                    ArtifactDescUtil::getBaseNameFromPath(artifact->getDesc(), path));
+            }
         }
     }
 
     if (options.sourceLanguage == SLANG_SOURCE_LANGUAGE_CPP &&
+        options.targetType != SLANG_OBJECT_CODE &&
         !PlatformUtil::isFamily(PlatformFamily::Windows, platformKind))
     {
         // Make STD libs available
@@ -728,9 +746,12 @@ static SlangResult _parseGCCFamilyLine(
 
     for (const auto& libPath : libPathPool.getAdded())
     {
-        // Note that any escaping of the path is handled in the ProcessUtil::
-        cmdLine.addArg("-L");
-        cmdLine.addArg(libPath);
+        if (options.targetType != SLANG_OBJECT_CODE)
+        {
+            // Note that any escaping of the path is handled in the ProcessUtil::
+            cmdLine.addArg("-L");
+            cmdLine.addArg(libPath);
+        }
         cmdLine.addArg("-F");
         cmdLine.addArg(libPath);
     }

source/compiler-core/slang-visual-studio-compiler-util.cpp

@@ -502,9 +502,7 @@ static SlangResult _parseVisualStudioLine(
     const ExecuteResult& exeRes,
     IArtifactDiagnostics* diagnostics)
 {
-    diagnostics->reset();
-
-    diagnostics->setRaw(SliceUtil::asTerminatedCharSlice(exeRes.standardOutput));
+    diagnostics->appendRaw(SliceUtil::asTerminatedCharSlice(exeRes.standardOutput));
 
     SliceAllocator allocator;
 

source/core/slang-string.h

@@ -467,7 +467,11 @@ class SLANG_RT_API String
     friend class StringBuilder;
 
 private:
-    char* getData() const { return m_buffer ? m_buffer->getData() : (char*)""; }
+    char* getData() const
+    {
+        static char empty[] = "";
+        return m_buffer ? m_buffer->getData() : empty;
+    }
 
 
     void ensureUniqueStorageWithCapacity(Index capacity);
@@ -658,7 +662,11 @@ class SLANG_RT_API String
 #endif
         }
     }
-    bool operator==(const char* strbuffer) const { return (strcmp(begin(), strbuffer) == 0); }
+    bool operator==(const char* strbuffer) const
+    {
+        const char* volatile b = begin();
+        return (strcmp(b, strbuffer) == 0);
+    }
 
     bool operator==(const String& str) const { return (strcmp(begin(), str.begin()) == 0); }
     bool operator!=(const char* strbuffer) const { return (strcmp(begin(), strbuffer) != 0); }