From ae23d0bd395059981dc35427b79aeb7b13a5e427 Mon Sep 17 00:00:00 2001 From: Hugo Date: Sat, 14 Nov 2026 23:15:08 +0100 Subject: [PATCH 1/9] build(deps): pin coretrace-compiler to compileToModule The pinned commit, from CoreTrace/coretrace-compiler#265, gives the module of a compilation in the caller's context. The analyzer does not use it yet. Refs #273 --- cmake/compiler/coretrace-compiler.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/compiler/coretrace-compiler.cmake b/cmake/compiler/coretrace-compiler.cmake index fb853b9f..cc62737f 100644 --- a/cmake/compiler/coretrace-compiler.cmake +++ b/cmake/compiler/coretrace-compiler.cmake @@ -13,7 +13,7 @@ endif() FetchContent_Declare( cc GIT_REPOSITORY https://github.com/CoreTrace/coretrace-compiler.git - GIT_TAG b4ad33638e9020a93f052a7a299e4105bd48f975 # v0.10.0 + GIT_TAG 3c715b2907b44a72c9e8c273b082ad4f584576f2 # CoreTrace/coretrace-compiler#265 ) FetchContent_MakeAvailable(cc) From 3bbb15cdeffbddac4a50fa953d5d9f280f8f1997 Mon Sep 17 00:00:00 2001 From: Hugo Date: Sat, 14 Nov 2026 23:18:38 +0100 Subject: [PATCH 2/9] refactor(input): run each compilation in its directory through one helper The lock, the move to the compile command's directory and the timing of a compilation now wrap a callable, which compile() is the only one to use yet. No behaviour changes. Refs #273 --- src/analysis/InputPipeline.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/analysis/InputPipeline.cpp b/src/analysis/InputPipeline.cpp index 0828f54e..9ec441e6 100644 --- a/src/analysis/InputPipeline.cpp +++ b/src/analysis/InputPipeline.cpp @@ -919,15 +919,13 @@ namespace ctrace::stack::analysis // A compile command's relative paths are relative to its directory: compile there, // even when the current directory also resolves them, to another header. - auto compileInWorkingDir = - [&](const std::vector& compileArgs, - compilerlib::OutputMode outputMode) -> std::optional + auto inWorkingDir = [&](auto&& compileHere) -> std::optional { std::lock_guard compileLock(gCompileInvokeMutex); if (workingDir.empty()) { const ScopedHotspot hotspot(config.timing, "input.compiler.invoke"); - return compilerlib::compile(compileArgs, outputMode); + return compileHere(); } std::string cwdError; @@ -938,8 +936,11 @@ namespace ctrace::stack::analysis return std::nullopt; } const ScopedHotspot hotspot(config.timing, "input.compiler.invoke.cwd"); - return compilerlib::compile(compileArgs, outputMode); + return compileHere(); }; + auto compileInWorkingDir = + [&](const std::vector& compileArgs, compilerlib::OutputMode outputMode) + { return inWorkingDir([&] { return compilerlib::compile(compileArgs, outputMode); }); }; if (cachePaths.enabled) { From 02732dd39050dc84d1cc00e5976ff468f4ae5f5d Mon Sep 17 00:00:00 2001 From: Hugo Date: Sat, 14 Nov 2026 23:20:29 +0100 Subject: [PATCH 3/9] perf(input): take each module from compileToModule in the bitcode format The bitcode format compiled each source to a temporary .bc file, read it into a string, copied it into a buffer and parsed it. The module now comes from compileToModule, created in the context of the load: nothing is written to a temporary file, and nothing is parsed. With the compile IR cache, the cache stores the bitcode of that module, written with the order of each value's uses. With --timing, a source compiled that way logs "Compiled to a module in N ms", where it logged "Compilation done", then "Bitcode parse done". check_compile_ir_format_switch recognized the bitcode format by the parse line: it now expects the new line from an empty cache, and either line once the cache is filled. Refs #273 --- run_test.py | 24 +++++-- src/analysis/InputPipeline.cpp | 121 ++++++++++----------------------- 2 files changed, 55 insertions(+), 90 deletions(-) diff --git a/run_test.py b/run_test.py index a14c5f68..7e68c9ec 100755 --- a/run_test.py +++ b/run_test.py @@ -1681,6 +1681,9 @@ def check_compile_ir_format_switch() -> bool: """ Validate that --compile-ir-format selects the expected source compile IR path and that cache keys invalidate correctly when switching format. + + In the bc format, a compilation gives its module itself: nothing is parsed. Only a + module read from the compile IR cache is parsed, from the bitcode the cache stored. """ print("=== Testing compile IR format switch ===") sample_c = RUN_CONFIG.test_dir / "alloca/oversized-constant.c" @@ -1703,12 +1706,16 @@ def run_and_capture(fmt: str) -> tuple[bool, str]: bc_ok, bc_output = run_and_capture("bc") ok = ok and bc_ok if bc_ok: - if "Bitcode parse done in" not in bc_output: - print(" ❌ --compile-ir-format=bc did not use bitcode parse path") + if "Compiled to a module in" not in bc_output: + print(" ❌ --compile-ir-format=bc did not take the module from the compilation") + print(bc_output) + ok = False + elif "Bitcode parse done in" in bc_output or "IR parse done in" in bc_output: + print(" ❌ --compile-ir-format=bc parsed the module it had compiled") print(bc_output) ok = False else: - print(" ✅ --compile-ir-format=bc uses bitcode parse path") + print(" ✅ --compile-ir-format=bc takes the module from the compilation") ll_ok, ll_output = run_and_capture("ll") ok = ok and ll_ok @@ -1717,8 +1724,8 @@ def run_and_capture(fmt: str) -> tuple[bool, str]: print(" ❌ --compile-ir-format=ll did not use textual IR parse path") print(ll_output) ok = False - elif "Bitcode parse done in" in ll_output: - print(" ❌ --compile-ir-format=ll unexpectedly used bitcode parse path") + elif "Bitcode parse done in" in ll_output or "Compiled to a module in" in ll_output: + print(" ❌ --compile-ir-format=ll unexpectedly used the bitcode path") print(ll_output) ok = False else: @@ -1729,7 +1736,12 @@ def run_and_capture(fmt: str) -> tuple[bool, str]: bc2_ok, bc2_output = run_and_capture("bc") ok = ok and bc2_ok if bc2_ok: - if "Bitcode parse done in" not in bc2_output: + # With the compile IR cache, the bitcode of the first run is parsed; without + # it, the source is compiled to a module again. + if ( + "Bitcode parse done in" not in bc2_output + and "Compiled to a module in" not in bc2_output + ): print(" ❌ cache invalidation failed when switching back to bc") print(bc2_output) ok = False diff --git a/src/analysis/InputPipeline.cpp b/src/analysis/InputPipeline.cpp index 9ec441e6..643d16cd 100644 --- a/src/analysis/InputPipeline.cpp +++ b/src/analysis/InputPipeline.cpp @@ -33,6 +33,7 @@ #include #include +#include #include #include @@ -78,17 +79,16 @@ namespace ctrace::stack::analysis args.swap(filtered); } + // The arguments of a bitcode compilation, whose module coretrace-compiler gives + // without writing an output file. static std::vector - buildBitcodeCompileArgs(const std::vector& baseArgs, - const std::filesystem::path& outputBitcodePath) + buildBitcodeCompileArgs(const std::vector& baseArgs) { std::vector args = baseArgs; args.erase(std::remove(args.begin(), args.end(), "-S"), args.end()); removeOutputPathArgs(args); appendIfMissing(args, "-emit-llvm"); appendIfMissing(args, "-c"); - args.push_back("-o"); - args.push_back(outputBitcodePath.string()); return args; } @@ -781,22 +781,6 @@ namespace ctrace::stack::analysis std::uint64_t active_ : 1 = false; std::uint64_t reservedFlags_ : 63 = 0; }; - - class ScopedFileCleanup - { - public: - explicit ScopedFileCleanup(const std::filesystem::path& path) : path_(path) {} - - ~ScopedFileCleanup() - { - std::error_code ec; - if (!path_.empty()) - std::filesystem::remove(path_, ec); - } - - private: - std::filesystem::path path_; - }; } // namespace static std::string extractExtension(const std::string& path) @@ -904,18 +888,7 @@ namespace ctrace::stack::analysis const CompileIRCachePaths cachePaths = buildCompileIRCachePaths( config, inputPath, result.language, args, workingDir, coretraceCompilerRevision); - std::error_code tempDirErr; - std::filesystem::path tempDir = std::filesystem::temp_directory_path(tempDirErr); - if (tempDirErr) - tempDir = std::filesystem::path("."); - const std::string tempBitcodeName = - "coretrace-compile-ir-" + - md5Hex(filename + "|" + std::to_string(compileStart.time_since_epoch().count())) + - ".bc"; - const std::filesystem::path tempBitcodePath = tempDir / tempBitcodeName; - const ScopedFileCleanup tempBitcodeCleanup(tempBitcodePath); - const std::vector bitcodeArgs = - buildBitcodeCompileArgs(args, tempBitcodePath); + const std::vector bitcodeArgs = buildBitcodeCompileArgs(args); // A compile command's relative paths are relative to its directory: compile there, // even when the current directory also resolves them, to another header. @@ -941,6 +914,20 @@ namespace ctrace::stack::analysis auto compileInWorkingDir = [&](const std::vector& compileArgs, compilerlib::OutputMode outputMode) { return inWorkingDir([&] { return compilerlib::compile(compileArgs, outputMode); }); }; + // A bitcode compilation gives its module itself, created in `ctx`: no bitcode is + // written to a file and read back. + std::unique_ptr compiledModule; + auto compileModuleInWorkingDir = [&](const std::vector& compileArgs) + { + return inWorkingDir( + [&]() -> compilerlib::CompileResult + { + compilerlib::ModuleResult compiled = + compilerlib::compileToModule(compileArgs, ctx); + compiledModule = std::move(compiled.module); + return {compiled.success, std::move(compiled.diagnostics), {}, {}}; + }); + }; if (cachePaths.enabled) { @@ -1075,9 +1062,9 @@ namespace ctrace::stack::analysis preferBitcodeCompile ? bitcodeArgs : args; appendDependencyCaptureArgs(cacheCompileArgs, cachePaths.depFile); - res = compileInWorkingDir(cacheCompileArgs, - preferBitcodeCompile ? compilerlib::OutputMode::ToFile - : compilerlib::OutputMode::ToMemory); + res = preferBitcodeCompile ? compileModuleInWorkingDir(cacheCompileArgs) + : compileInWorkingDir(cacheCompileArgs, + compilerlib::OutputMode::ToMemory); if (preferBitcodeCompile && (!res || !res->success)) { @@ -1112,9 +1099,9 @@ namespace ctrace::stack::analysis } else { - res = compileInWorkingDir(preferBitcodeCompile ? bitcodeArgs : args, - preferBitcodeCompile ? compilerlib::OutputMode::ToFile - : compilerlib::OutputMode::ToMemory); + res = preferBitcodeCompile + ? compileModuleInWorkingDir(bitcodeArgs) + : compileInWorkingDir(args, compilerlib::OutputMode::ToMemory); if (res && res->success) { compiledViaBitcode = preferBitcodeCompile; @@ -1142,61 +1129,24 @@ namespace ctrace::stack::analysis } compileDiagnosticsText = res->diagnostics; + if (compiledViaBitcode) + result.module = std::move(compiledModule); + if (config.timing) { auto compileEnd = Clock::now(); auto ms = std::chrono::duration_cast(compileEnd - compileStart) .count(); - coretrace::log(coretrace::Level::Info, "Compilation done in {} ms\n", ms); + // No parse follows a compilation that gave its module. + if (result.module) + coretrace::log(coretrace::Level::Info, "Compiled to a module in {} ms\n", ms); + else + coretrace::log(coretrace::Level::Info, "Compilation done in {} ms\n", ms); } std::string llvmIRForCache; std::string llvmBitcodeForCache; - if (compiledViaBitcode) - { - if (readTextFile(tempBitcodePath, llvmBitcodeForCache) && - !llvmBitcodeForCache.empty()) - { - const auto parseStart = Clock::now(); - auto bcBuffer = llvm::MemoryBuffer::getMemBufferCopy( - llvm::StringRef(llvmBitcodeForCache.data(), llvmBitcodeForCache.size()), - "compiled_bc"); - auto bitcodeModule = [&]() - { - const ScopedHotspot hotspot(config.timing, - "input.compile.parse_bitcode_output"); - return llvm::parseBitcodeFile(bcBuffer->getMemBufferRef(), ctx); - }(); - if (bitcodeModule) - { - result.module = std::move(*bitcodeModule); - if (config.timing) - { - const auto parseEnd = Clock::now(); - const auto ms = std::chrono::duration_cast( - parseEnd - parseStart) - .count(); - coretrace::log(coretrace::Level::Info, "Bitcode parse done in {} ms\n", - ms); - } - } - else if (config.timing) - { - std::string bitcodeError = llvm::toString(bitcodeModule.takeError()); - coretrace::log(coretrace::Level::Warn, - "Bitcode output invalid for {}; " - "falling back to textual IR ({})\n", - filename, bitcodeError); - } - } - else if (config.timing) - { - coretrace::log(coretrace::Level::Warn, - "Missing bitcode output for {}; falling back to textual IR\n", - filename); - } - } if (!result.module) { @@ -1260,8 +1210,11 @@ namespace ctrace::stack::analysis { if (llvmBitcodeForCache.empty()) { + // With the order of each value's uses, which the module then read from the + // cache finds again. llvm::raw_string_ostream bitcodeStream(llvmBitcodeForCache); - llvm::WriteBitcodeToFile(*result.module, bitcodeStream); + llvm::WriteBitcodeToFile(*result.module, bitcodeStream, + /*ShouldPreserveUseListOrder=*/true); bitcodeStream.flush(); } From 0ee5c0469261bc9f9b2396894d5eeaa9785a30bd Mon Sep 17 00:00:00 2001 From: Hugo Date: Sat, 14 Nov 2026 23:20:29 +0100 Subject: [PATCH 4/9] docs(readme): say that the bitcode format takes the compilation's module Refs #273 --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 420cbbdc..0d15cd9a 100644 --- a/README.md +++ b/README.md @@ -302,7 +302,7 @@ IR that another compiler produced (another coretrace-compiler revision or LLVM v The cache is not used when coretrace-compiler's sources are not a clean checkout FetchContent fetched itself (`FETCHCONTENT_SOURCE_DIR_CC`, for instance): the analyzer cannot then tell which revision it was built with. `--compile-ir-format=bc|ll` controls source compilation output format before module load: -- `bc` (default): compile to LLVM bitcode then parse bitcode. +- `bc` (default): take the module from the compilation itself; no bitcode is written or parsed. The compile IR cache stores that module as bitcode. - `ll`: compile to textual LLVM IR then parse text IR. `--timing` now also includes pipeline traversal estimates per step (`module/function/instruction` estimates) and by execution model From 923e27436a17cb8a8b1e483b8b016ad7c4dc6dcf Mon Sep 17 00:00:00 2001 From: Hugo Date: Sat, 14 Nov 2026 23:20:29 +0100 Subject: [PATCH 5/9] docs(changelog): announce modules taken from the compilation Refs #273 --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c2ad54ff..6b1fb8bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,12 @@ Notable changes are grouped by release. See [all releases](https://github.com/Co - Added an authors file and linked the repository documents from the README. - SARIF rules carry a title (`shortDescription`) and a description (`fullDescription`) instead of their id, and `describeRule` (`RuleCatalog.hpp`) gives them to programs linking the analyzer. +- In the `bc` format of `--compile-ir-format`, the default, each module comes from the + compilation itself, through coretrace-compiler's `compileToModule` (#273). The analyzer + compiled each source to a temporary `.bc` file, then read and parsed it. With `--timing`, a + source compiled that way logs `Compiled to a module in N ms`, in place of `Compilation done` + and `Bitcode parse done`. coretrace-compiler is pinned to a commit of + CoreTrace/coretrace-compiler#265, which adds `compileToModule`. ## v0.22.0 From cb0efd13ed827c342b50425104ec2b770d9c3c6b Mon Sep 17 00:00:00 2001 From: Hugo Date: Sun, 15 Nov 2026 02:47:09 +0100 Subject: [PATCH 6/9] docs(input): say why the cache's bitcode keeps the order of uses The analyses walk a module read from the compile IR cache as they walked the compiled one only if the bitcode holds the order of each value's uses: the first match of a walk and the order of a variable's reports follow that order. Refs #273 --- src/analysis/InputPipeline.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/analysis/InputPipeline.cpp b/src/analysis/InputPipeline.cpp index 643d16cd..39b2e449 100644 --- a/src/analysis/InputPipeline.cpp +++ b/src/analysis/InputPipeline.cpp @@ -1210,8 +1210,10 @@ namespace ctrace::stack::analysis { if (llvmBitcodeForCache.empty()) { - // With the order of each value's uses, which the module then read from the - // cache finds again. + // The order of each value's uses is written too. Some analyses depend on it: + // the first match of a walk, the order of a variable's reports. The reader + // otherwise rebuilds that order its own way, and a run that reads the cache + // would not walk the uses as the run that compiled the source did. llvm::raw_string_ostream bitcodeStream(llvmBitcodeForCache); llvm::WriteBitcodeToFile(*result.module, bitcodeStream, /*ShouldPreserveUseListOrder=*/true); From dbe9c0333fa9c08b0fc92fd83d059779157752f0 Mon Sep 17 00:00:00 2001 From: Hugo Date: Sun, 15 Nov 2026 04:29:08 +0100 Subject: [PATCH 7/9] test(unit): check that a module read from the cache keeps the order of uses A source compiled in the bitcode format is analyzed as the module of its compilation, then read from the compile IR cache by the next run. The test compiles a source whose calls Clang emits in another order than the module lists their functions, and compares each value's users between the two modules. A third load, on the entry written again without the order of uses, gives another order: the source tells the two apart, and a load reads the entry. Refs #273 --- test/unit/analyzer_module_unit_tests.cpp | 124 +++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/test/unit/analyzer_module_unit_tests.cpp b/test/unit/analyzer_module_unit_tests.cpp index 82fa8b97..4d6d97b6 100644 --- a/test/unit/analyzer_module_unit_tests.cpp +++ b/test/unit/analyzer_module_unit_tests.cpp @@ -45,7 +45,9 @@ #include #include +#include #include +#include #include #include #include @@ -3412,6 +3414,127 @@ namespace return report.failures == 0; } + /// Each value an analysis can walk from, with its users in the order of its use list. A + /// user is named by its position in the module, which two modules of one source share, and + /// by the operand that holds the value; a user that has no position, a constant, is 0. + using UseLists = std::vector>>; + + UseLists useLists(const llvm::Module& module) + { + llvm::DenseMap positions; + std::vector values; + const auto add = [&](const llvm::Value& value) + { + values.push_back(&value); + positions[&value] = values.size(); + }; + for (const llvm::GlobalVariable& global : module.globals()) + add(global); + for (const llvm::Function& function : module) + add(function); + for (const llvm::Function& function : module) + { + for (const llvm::Argument& argument : function.args()) + add(argument); + for (const llvm::BasicBlock& block : function) + { + add(block); + for (const llvm::Instruction& instruction : block) + add(instruction); + } + } + + UseLists lists; + lists.reserve(values.size()); + for (const llvm::Value* value : values) + { + auto& users = lists.emplace_back(); + for (const llvm::Use& use : value->uses()) + users.emplace_back(positions.lookup(use.getUser()), use.getOperandNo()); + } + return lists; + } + + /// In the bitcode format, a run analyzes the module of the compilation and writes it in the + /// compile IR cache; the next run analyzes the module it reads there. Analyses walk the uses + /// of a value, and can keep the first match, stop on a budget or report in the order of the + /// walk: the module read from the cache must list each value's uses in the order the + /// compiled one does. + /// + /// `early` calls `late`, defined after `other`. Clang emits the three bodies in the order of + /// the source, and the module lists `late`, created by that call, before `other`. Bitcode + /// holds the bodies in the module's order, so a reader that is not told the order of uses + /// lists the callers of `callee` another way. The last load checks it, on the entry written + /// again without that order: it also shows that a load reads the entry. + bool testCompileIRCacheKeepsUseOrder(TestReport& report) + { + char rootTemplate[] = "/tmp/ctrace-use-order-XXXXXX"; + if (mkdtemp(rootTemplate) == nullptr) + { + report.expect(false, "Compile IR cache use order: no temporary directory"); + return false; + } + const std::filesystem::path root(rootTemplate); + const std::filesystem::path source = root / "order.c"; + std::ofstream(source) << "int callee(int value);\n" + "int late(int value);\n" + "int early(int value) { return late(value) + callee(value); }\n" + "int other(int value) { return callee(value); }\n" + "int late(int value) { return callee(value); }\n"; + + ctrace::stack::AnalysisConfig config; + config.compileIRFormat = ctrace::stack::CompileIRFormat::BC; + config.compileIRCacheDir = (root / "cache").string(); + const auto load = [&](LoadedModule& out) + { + llvm::SMDiagnostic err; + out.module = ctrace::stack::analysis::detail::loadModuleForAnalysis( + source.string(), config, out.context, err, "known") + .module; + return out.module != nullptr; + }; + + LoadedModule compiled; + std::filesystem::path entry; + if (load(compiled)) + { + std::error_code ec; + for (const auto& file : std::filesystem::directory_iterator(root / "cache", ec)) + { + if (file.path().extension() == ".bc") + entry = file.path(); + } + } + report.expect(!entry.empty(), + "Compile IR cache use order: the compilation writes its module's bitcode"); + LoadedModule cached; + if (entry.empty() || !load(cached)) + { + report.expect(false, "Compile IR cache use order: the second load gives a module"); + std::filesystem::remove_all(root); + return false; + } + + const UseLists expected = useLists(*compiled.module); + report.expect(useLists(*cached.module) == expected, + "Compile IR cache use order: the module read from the cache lists each " + "value's uses as the compiled module does"); + + { + std::error_code ec; + llvm::raw_fd_ostream bitcode(entry.string(), ec); + if (!ec) + llvm::WriteBitcodeToFile(*compiled.module, bitcode); + } + LoadedModule unordered; + report.expect(load(unordered) && useLists(*unordered.module) != expected, + "Compile IR cache use order: an entry written without the order of uses " + "lists them another way"); + + std::filesystem::remove_all(root); + return report.failures == 0; + } + /// resolveParameterDebugBinding: each parameter gets its own type, and its position among the /// parameters the source declares. The others are artificial: `this`, the vtt that the /// base-object constructor (C2) of a class with a virtual base takes, is_most_derived under the @@ -3749,6 +3872,7 @@ int main(int argc, char** argv) (void)testOwnershipCollectorExceptions(repoRoot, report); (void)testOwnershipSummaryIndex(repoRoot, report); (void)testCompileIRCacheWithoutCompilerRevision(report); + (void)testCompileIRCacheKeepsUseOrder(report); if (report.failures == 0) { From 6f50b2bfb98723226c44cd86338fef6bc0df3fc5 Mon Sep 17 00:00:00 2001 From: Hugo Date: Tue, 17 Nov 2026 20:02:17 +0100 Subject: [PATCH 8/9] build(deps): update coretrace-compiler to v0.13.0 The pinned commit was one of the branch of CoreTrace/coretrace-compiler#265. v0.13.0 is the release that holds compileToModule. Refs #273 --- cmake/compiler/coretrace-compiler.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/compiler/coretrace-compiler.cmake b/cmake/compiler/coretrace-compiler.cmake index cc62737f..d1e01a66 100644 --- a/cmake/compiler/coretrace-compiler.cmake +++ b/cmake/compiler/coretrace-compiler.cmake @@ -13,7 +13,7 @@ endif() FetchContent_Declare( cc GIT_REPOSITORY https://github.com/CoreTrace/coretrace-compiler.git - GIT_TAG 3c715b2907b44a72c9e8c273b082ad4f584576f2 # CoreTrace/coretrace-compiler#265 + GIT_TAG e21305389a2e639460b2bf619b3a800c15c94fe1 # v0.13.0 ) FetchContent_MakeAvailable(cc) From aa8b606178e23c337ca61fdd48199b36f82ecbd5 Mon Sep 17 00:00:00 2001 From: Hugo Date: Tue, 17 Nov 2026 20:02:17 +0100 Subject: [PATCH 9/9] docs(changelog): say that coretrace-compiler is updated to v0.13.0 Refs #273 --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6b1fb8bf..5fff4622 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -55,8 +55,8 @@ Notable changes are grouped by release. See [all releases](https://github.com/Co compilation itself, through coretrace-compiler's `compileToModule` (#273). The analyzer compiled each source to a temporary `.bc` file, then read and parsed it. With `--timing`, a source compiled that way logs `Compiled to a module in N ms`, in place of `Compilation done` - and `Bitcode parse done`. coretrace-compiler is pinned to a commit of - CoreTrace/coretrace-compiler#265, which adds `compileToModule`. + and `Bitcode parse done`. coretrace-compiler is updated to v0.13.0, which adds + `compileToModule`. ## v0.22.0