44 improve diagnostic source locations and enable recursion regression coverage

CMakeLists.txt

@@ -34,9 +34,17 @@ FetchContent_Declare(
     GIT_REPOSITORY https://github.com/CoreTrace/coretrace-compiler.git
     GIT_TAG main
 )
-
 FetchContent_MakeAvailable(cc)
 
+set(CORETRACE_LOGGER_BUILD_EXAMPLES OFF CACHE BOOL "Disable logger examples" FORCE)
+set(CORETRACE_LOGGER_BUILD_TESTS OFF CACHE BOOL "Disable logger tests" FORCE)
+include(FetchContent)
+FetchContent_Declare(coretrace-logger
+  GIT_REPOSITORY https://github.com/CoreTrace/coretrace-log.git
+  GIT_TAG        main
+)
+FetchContent_MakeAvailable(coretrace-logger)
+
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
@@ -117,13 +125,15 @@ target_link_libraries(stack_usage_analyzer_lib
     PUBLIC
         ${llvm_libs}
         cc::compilerlib_static
+        coretrace::logger
 )
 # by this one :
 if(LLVM_LINK_LLVM_DYLIB)
     target_link_libraries(stack_usage_analyzer_lib
         PUBLIC
             LLVM
             cc::compilerlib_static
+            coretrace::logger
     )
 else()
     llvm_map_components_to_libnames(llvm_libs
@@ -135,6 +145,7 @@ else()
         PUBLIC
             ${llvm_libs}
             cc::compilerlib_static
+            coretrace::logger
     )
 endif()
 

extern-project/src/main.cpp

@@ -2,6 +2,7 @@
 #include <llvm/Support/SourceMgr.h>
 #include <llvm/IR/LLVMContext.h>
 #include <iostream>
+#include "analysis/CompileCommands.hpp"
 
 int main(int argc, char **argv)
 {
@@ -12,14 +13,26 @@ int main(int argc, char **argv)
     }
 
     std::string filename = argv[1];
+    std::string compile_file = argv[2];
+    std::string dbLoadError;
 
+    std::cout << compile_file << std::endl;
+    auto db = ctrace::stack::analysis::CompilationDatabase::loadFromFile(compile_file,
+                                                                        dbLoadError);
+    if (!db)
+    {
+        std::cerr << "Failed to load compilation database: " << dbLoadError << std::endl;
+        return 1;
+    }
     llvm::LLVMContext ctx;
     llvm::SMDiagnostic diag;
 
     ctrace::stack::AnalysisConfig cfg;
     cfg.mode = ctrace::stack::AnalysisMode::IR;
     cfg.stackLimit = 8 * 1024 * 1024;
 
+    cfg.compilationDatabase = std::move(db);
+    // std::call_once(ctrace::stack::initializeLLVM, ctrace::stack::initializeLLVMFlag);
     auto res = ctrace::stack::analyzeFile(filename, cfg, ctx, diag);
 
     // Example: SARIF output to stdout

include/StackUsageAnalyzer.hpp

@@ -121,12 +121,13 @@ namespace ctrace::stack
         ConstParameterNotModified = 11,
         SizeMinusOneWrite = 12,
         DuplicateIfCondition = 13,
-        UninitializedLocalRead = 14
+        UninitializedLocalRead = 14,
+        StackFrameTooLarge = 15
     };
 
     template <> struct EnumTraits<DescriptiveErrorCode>
     {
-        static constexpr std::array<std::string_view, 15> names = {"None",
+        static constexpr std::array<std::string_view, 16> names = {"None",
                                                                    "StackBufferOverflow",
                                                                    "NegativeStackIndex",
                                                                    "VLAUsage",
@@ -140,7 +141,8 @@ namespace ctrace::stack
                                                                    "ConstParameterNotModified",
                                                                    "SizeMinusOneWrite",
                                                                    "DuplicateIfCondition",
-                                                                   "UninitializedLocalRead"};
+                                                                   "UninitializedLocalRead",
+                                                                   "StackFrameTooLarge"};
     };
 
     /*

main.cpp

@@ -16,6 +16,8 @@
 #include "analysis/CompileCommands.hpp"
 #include "mangle.hpp"
 
+#include <coretrace/logger.hpp>
+
 using namespace ctrace::stack;
 
 enum class OutputFormat
@@ -391,6 +393,14 @@ static AnalysisResult filterWarningsOnly(const AnalysisResult& result, const Ana
 
 int main(int argc, char** argv)
 {
+    coretrace::enable_logging();
+    coretrace::set_prefix("==stack-analyzer==");
+    coretrace::set_min_level(coretrace::Level::Info);
+    coretrace::set_source_location(true);
+
+    coretrace::log(coretrace::Level::Debug, coretrace::Module("cli"),
+                   "Starting analysis for {} input(s)\n", argc - 1);
+
     llvm::LLVMContext context;
     std::vector<std::string> inputFilenames;
     OutputFormat outputFormat = OutputFormat::Human;
@@ -400,12 +410,21 @@ int main(int argc, char** argv)
     cfg.warningsOnly = false;
     std::string compileCommandsPath;
     bool compileCommandsExplicit = false;
-    // cfg.mode = AnalysisMode::IR; -> already set by default constructor
-    // cfg.stackLimit = 8ull * 1024ull * 1024ull; // 8 MiB -> already set by default constructor but needed to be set with args
 
     cfg.extraCompileArgs.emplace_back("-O0");
     cfg.extraCompileArgs.emplace_back("--ct-optnone");
 
+    if (argc < 2)
+    {
+        printHelp();
+        return 1;
+    }
+    else if (argc < 2)
+    {
+        printHelp();
+        return 1;
+    }
+
     for (int i = 1; i < argc; ++i)
     {
         const char* arg = argv[i];
@@ -420,6 +439,12 @@ int main(int argc, char** argv)
             cfg.quiet = true;
             continue;
         }
+        if (argStr == "--verbose")
+        {
+            cfg.quiet = false;
+            coretrace::set_min_level(coretrace::Level::Debug);
+            continue;
+        }
         if (argStr == "--STL" || argStr == "--stl")
         {
             cfg.includeSTL = true;
@@ -502,6 +527,18 @@ int main(int argc, char** argv)
             cfg.stackLimit = value;
             continue;
         }
+        else if (argStr == "--stack-limit")
+        {
+            std::string error;
+            StackSize value = 0;
+            if (!parseStackLimitValue(argStr.substr(std::strlen("--stack-limit=")), value, error))
+            {
+                llvm::errs() << "Invalid --stack-limit value: " << error << "\n";
+                return 1;
+            }
+            cfg.stackLimit = value;
+            continue;
+        }
         if (argStr.rfind("--stack-limit=", 0) == 0)
         {
             std::string error;
@@ -654,7 +691,8 @@ int main(int argc, char** argv)
     {
         if (compileCommandsPath.empty())
         {
-            llvm::errs() << "compile commands path is empty\n";
+            // llvm::errs() << "compile commands path is empty\n";
+            coretrace::log(coretrace::Level::Error, "Compile commands path is empty\n");
             return 1;
         }
 
@@ -666,20 +704,25 @@ int main(int argc, char** argv)
         }
         else if (fsErr)
         {
-            llvm::errs() << "Failed to inspect compile commands path: " << fsErr.message() << "\n";
+            coretrace::log(coretrace::Level::Error, "Failed to inspect compile commands path: {}\n",
+                           fsErr.message());
             return 1;
         }
 
         if (!std::filesystem::exists(compdbPath, fsErr))
         {
             if (fsErr)
             {
-                llvm::errs() << "Failed to inspect compile commands path: " << fsErr.message()
-                             << "\n";
+                // llvm::errs() << "Failed to inspect compile commands path: " << fsErr.message()
+                //  << "\n";
+                coretrace::log(coretrace::Level::Error,
+                               "Failed to inspect compile commands path: {}\n", fsErr.message());
             }
             else
             {
-                llvm::errs() << "compile commands file not found: " << compdbPath.string() << "\n";
+                // llvm::errs() << "compile commands file not found: " << compdbPath.string() << "\n";
+                coretrace::log(coretrace::Level::Error, "Compile commands file not found: {}\n",
+                               compdbPath.string());
             }
             return 1;
         }
@@ -689,7 +732,8 @@ int main(int argc, char** argv)
             ctrace::stack::analysis::CompilationDatabase::loadFromFile(compdbPath.string(), error);
         if (!db)
         {
-            llvm::errs() << "Failed to load compile commands: " << error << "\n";
+            // llvm::errs() << "Failed to load compile commands: " << error << "\n";
+            coretrace::log(coretrace::Level::Error, "Failed to load compile commands: {}\n", error);
             return 1;
         }
         cfg.compilationDatabase = std::move(db);
@@ -698,8 +742,11 @@ int main(int argc, char** argv)
 
     if (inputFilenames.empty())
     {
-        llvm::errs() << "Usage: stack_usage_analyzer <file.ll> [file2.ll ...] [options]\n"
-                     << "Try --help for more information.\n";
+        // llvm::errs() << "Usage: stack_usage_analyzer <file.ll> [file2.ll ...] [options]\n"
+        //  << "Try --help for more information.\n";
+        coretrace::log(coretrace::Level::Error,
+                       "Usage: stack_usage_analyzer <file.ll> [file2.ll ...] [options]\n");
+        coretrace::log(coretrace::Level::Error, "Try --help for more information.\n");
         return 1;
     }
 
@@ -751,6 +798,8 @@ int main(int argc, char** argv)
             else
             {
                 llvm::errs() << "Failed to analyze: " << inputFilename << "\n";
+                coretrace::log(coretrace::Level::Error, coretrace::Module("cli"),
+                               "Failed to analyze:{}\n", inputFilename);
                 localErr.print("stack_usage_analyzer", llvm::errs());
                 return 1;
             }
@@ -853,7 +902,7 @@ int main(int argc, char** argv)
                          << "\n";
             if (f.localStackUnknown)
             {
-                llvm::outs() << "  local stack: unknown";
+                llvm::outs() << "\tlocal stack: unknown";
                 if (f.localStack > 0)
                 {
                     llvm::outs() << " (>= " << f.localStack << " bytes)";
@@ -862,12 +911,12 @@ int main(int argc, char** argv)
             }
             else
             {
-                llvm::outs() << "  local stack: " << f.localStack << " bytes\n";
+                llvm::outs() << "\tlocal stack: " << f.localStack << " bytes\n";
             }
 
             if (f.maxStackUnknown)
             {
-                llvm::outs() << "  max stack (including callees): unknown";
+                llvm::outs() << "\tmax stack (including callees): unknown";
                 if (f.maxStack > 0)
                 {
                     llvm::outs() << " (>= " << f.maxStack << " bytes)";
@@ -876,7 +925,7 @@ int main(int argc, char** argv)
             }
             else
             {
-                llvm::outs() << "  max stack (including callees): " << f.maxStack << " bytes\n";
+                llvm::outs() << "\tmax stack (including callees): " << f.maxStack << " bytes\n";
             }
 
             if (!result.config.quiet)
@@ -891,7 +940,7 @@ int main(int argc, char** argv)
 
                     if (d.line != 0)
                     {
-                        llvm::outs() << "  at line " << d.line << ", column " << d.column << "\n";
+                        llvm::outs() << "\tat line " << d.line << ", column " << d.column << "\n";
                     }
                     llvm::outs() << d.message << "\n";
                 }