added default profiles release and debug

evanwporter · evanwporter · commit e405261f7ebe · 2025-05-11T12:47:48.000-07:00
* added profile settings
* added specification of sanitizers
diff --git a/include/flags.hpp b/include/flags.hpp
@@ -54,7 +54,6 @@ namespace muuk {
 
         { "lto", FlagCategory::Advanced, { "-flto", "-flto", "/GL" } },
         { "march_native", FlagCategory::Advanced, { "-march=native", "-march=native", "/arch:AVX2" } },
-        { "cpp_std_17", FlagCategory::Advanced, { "-std=c++17", "-std=c++17", "/std:c++17" } },
         { "no_exceptions", FlagCategory::Advanced, { "-fno-exceptions", "-fno-exceptions", "/EHs-c-" } },
         { "no_rtti", FlagCategory::Advanced, { "-fno-rtti", "-fno-rtti", "/GR-" } },
 
diff --git a/include/lockgen/config/base.hpp b/include/lockgen/config/base.hpp
@@ -10,6 +10,7 @@
 
 #include "compiler.hpp"
 #include "muuk.hpp"
+#include "opt_level.hpp"
 #include "toml_ext.hpp"
 #include "util.hpp"
 
@@ -269,10 +270,39 @@ namespace muuk {
             }
         };
 
+        struct Settings {
+            // CXX_Standard cxx_standard;
+            // C_Standard c_standard;
+            OptimizationLevel optimization_level;
+            bool lto = false;
+            bool debug = false;
+            bool rpath = false;
+            bool debug_assertions = false; // -DNDEBUG
+        };
+
+        void load(Settings& settings, const toml::value& v);
+
+        void serialize(const Settings& settings, toml::value& out);
+
+        struct Sanitizers {
+            bool address = false; // ASan
+            bool thread = false; // TSan
+            bool undefined = false; // UBSan
+            bool memory = false; // MSan
+            bool leak = false; // LSan
+        };
+
+        void load(Sanitizers& sanitizers, const toml::value& v);
+
+        void serialize(const Sanitizers& sanitizers, toml::value& out);
+
         struct ProfileConfig : BaseConfig<ProfileConfig> {
             std::string name;
             std::vector<std::string> inherits;
 
+            Settings settings;
+            Sanitizers sanitizers;
+
             void load(
                 const toml::value& v,
                 const std::string& profile_name,
diff --git a/include/opt_level.hpp b/include/opt_level.hpp
@@ -0,0 +1,83 @@
+#pragma once
+#ifndef MUUK_OPT_LEVEL_HPP
+#define MUUK_OPT_LEVEL_HPP
+
+#include <string>
+
+#include <compiler.hpp>
+#include <logger.hpp>
+
+#define OPTIMIZATION_LEVELS(X)           \
+    X(O0, '0', "-O0", "-O0", "/Od")      \
+    X(O1, '1', "-O1", "-O1", "/O1")      \
+    X(O2, '2', "-O2", "-O2", "/O2")      \
+    X(O3, '3', "-O3", "-O3", "/Ox /Ob2") \
+    X(Os, 's', "-Os", "-Os", "/Os")      \
+    X(Oz, 'z', "-Os", "-Oz", "/Os")
+//              CLANG,  GCC,   MSVC
+
+#define X_ENUM(name, chr, gcc, clang, msvc) name,
+enum class OptimizationLevel {
+    OPTIMIZATION_LEVELS(X_ENUM)
+};
+
+namespace muuk {
+    inline OptimizationLevel opt_lvl_from_string(const std::string& str) {
+        if (str.empty())
+            return OptimizationLevel::O1;
+
+        char c;
+        if ((str.size() == 2 || str.size() == 1) && (str[0] == 'O' || str[0] == 'o')) {
+            c = str.size() == 2 ? str[1] : '\0';
+        } else if (str.size() == 1) {
+            c = str[0];
+        } else {
+            muuk::logger::warn("Invalid optimization level string: '{}'. Defaulting to O1.", str);
+            return OptimizationLevel::O1;
+        }
+
+#define X_FROM_CHAR(name, chr, gcc, clang, msvc) \
+    if (c == chr)                                \
+        return OptimizationLevel::name;
+        OPTIMIZATION_LEVELS(X_FROM_CHAR)
+#undef X_FROM_CHAR
+
+        return OptimizationLevel::O1; // Default optimization level
+    }
+
+    inline std::string to_flag(OptimizationLevel level, Compiler::Type compiler) {
+        switch (level) {
+#define X_TO_FLAG(name, chr, gcc, clang, msvc) \
+    case OptimizationLevel::name:              \
+        switch (compiler) {                    \
+        case Compiler::Type::GCC:              \
+            return gcc;                        \
+        case Compiler::Type::Clang:            \
+            return clang;                      \
+        case Compiler::Type::MSVC:             \
+            return msvc;                       \
+        default:                               \
+            return "";                         \
+        }
+            OPTIMIZATION_LEVELS(X_TO_FLAG)
+#undef X_TO_FLAG
+        }
+
+        return "";
+    }
+
+    inline std::string to_string(OptimizationLevel level) {
+        switch (level) {
+#define X_TO_CHAR(name, chr, gcc, clang, msvc) \
+    case OptimizationLevel::name:              \
+        return std::string(1, chr);
+            OPTIMIZATION_LEVELS(X_TO_CHAR)
+#undef X_TO_CHAR
+        }
+        return "1"; // Default string
+    }
+}
+
+#undef OPTIMIZATION_LEVELS
+
+#endif // MUUK_OPT_LEVEL_HPP
diff --git a/include/version.h b/include/version.h
@@ -3,7 +3,7 @@
 
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 0
-#define VERSION_PATCH 5
+#define VERSION_PATCH 6
 
 #define STRINGIFY(x) #x
 #define TOSTRING(x) STRINGIFY(x)
diff --git a/muuk.toml b/muuk.toml
@@ -61,19 +61,14 @@ sources = ['test/internal/muuk_test.cpp']
 dependencies = { googletest = '3fbe4db9a39291ae8d7a9c5f1d75896bb4c5a18f' }
 
 [profile.base]
-cflags = ['-std=c++20', '/utf-8', '/EHsc', '/FS', '/nologo']
+cflags = ['-std=c++20', '/utf-8', '/EHsc', '/nologo']
 aflags = ['/nologo']
 lflags = ['/nologo']
 
 [profile.release]
-cflags = ['/O2', '/DNDEBUG', '/GL']
 inherits = ['base']
-lflags = ['/OPT:REF', '/OPT:ICF', '/LTCG']
 
 [profile.debug]
-cflags = ['/Od', '/DDEBUG', '/Zi', '/RTC1', '/FC', '/GS']
 default = true
-include = ['include']
 inherits = ['base']
-lflags = ['/DEBUG']
-libs = []
+cflags = ['/DDEBUG', '/FC']
diff --git a/src/build/parser.cpp b/src/build/parser.cpp
@@ -16,6 +16,7 @@
 #include "logger.hpp"
 #include "muuk.hpp"
 #include "muuk_parser.hpp"
+#include "opt_level.hpp"
 #include "rustify.hpp"
 #include "util.hpp"
 
@@ -41,7 +42,7 @@ namespace muuk {
             if (!profile_table.contains(profile))
                 return Err("Profile '{}' does not exist in the configuration.", profile);
 
-            auto profile_entry = profile_table.at(profile).as_table();
+            auto profile_entry = profile_table.at(profile);
 
             BuildProfile build_profile;
             build_profile.cflags = muuk::parse_array_as_vec(profile_entry, "cflags");
@@ -54,6 +55,87 @@ namespace muuk {
             muuk::normalize_flags_inplace(build_profile.lflags, compiler);
             muuk::normalize_flags_inplace(build_profile.defines, compiler);
 
+            // --- Link Type Optimization ---
+            if (profile_entry.at("lto").as_boolean()) {
+                muuk::logger::info("LTO enabled for profile '{}'", profile);
+                switch (compiler.getType()) {
+                case Compiler::Type::GCC:
+                case Compiler::Type::Clang:
+                    build_profile.cflags.push_back("-flto");
+                    build_profile.lflags.push_back("-flto");
+                case Compiler::Type::MSVC:
+                    build_profile.cflags.push_back("/GL");
+                    build_profile.lflags.push_back("/LTCG");
+                }
+            }
+
+            // --- Debug ---
+            if (profile_entry.at("debug").as_boolean()) {
+                muuk::logger::info("LTO enabled for profile '{}'", profile);
+                switch (compiler.getType()) {
+                case Compiler::Type::GCC:
+                case Compiler::Type::Clang:
+                    build_profile.cflags.push_back("-g");
+                case Compiler::Type::MSVC:
+                    build_profile.cflags.push_back("/Zi");
+                    build_profile.lflags.push_back("/DEBUG");
+                }
+            }
+
+            // --- Debug Assertions ---
+            if (!profile_entry.at("debug-assertions").as_boolean()) {
+                muuk::logger::info("LTO enabled for profile '{}'", profile);
+                switch (compiler.getType()) {
+                case Compiler::Type::GCC:
+                case Compiler::Type::Clang:
+                    build_profile.cflags.push_back("-DNDEBUG");
+                case Compiler::Type::MSVC:
+                    build_profile.cflags.push_back("/DNDEBUG");
+                }
+            }
+
+            // --- Optimization Level ---
+            build_profile.cflags.push_back(to_flag(
+                opt_lvl_from_string(profile_entry.at("opt-level").as_string()),
+                compiler.getType()));
+
+            // --- Sanitizers ---
+            if (profile_entry.contains("sanitizers") && profile_entry.at("sanitizers").is_array()) {
+                for (const auto& item : profile_entry.at("sanitizers").as_array()) {
+                    if (!item.is_string())
+                        continue;
+
+                    const std::string name = item.as_string();
+
+                    switch (compiler.getType()) {
+                    case Compiler::Type::GCC:
+                    case Compiler::Type::Clang:
+                        if (name == "address")
+                            build_profile.cflags.push_back("-fsanitize=address");
+                        else if (name == "thread")
+                            build_profile.cflags.push_back("-fsanitize=thread");
+                        else if (name == "undefined")
+                            build_profile.cflags.push_back("-fsanitize=undefined");
+                        else if (name == "memory")
+                            build_profile.cflags.push_back("-fsanitize=memory");
+                        else if (compiler.getType() == Compiler::Type::Clang && name == "leak")
+                            build_profile.cflags.push_back("-fsanitize=leak");
+                        break;
+
+                    case Compiler::Type::MSVC:
+                        if (name == "address")
+                            build_profile.cflags.push_back("/fsanitize=address");
+                        else if (name == "undefined") {
+                            build_profile.cflags.push_back("/RTC1");
+                            build_profile.cflags.push_back("/RTCc");
+                            build_profile.cflags.push_back("/RTCs");
+                        }
+                        // No leak, memory, or thread sanitizers in MSVC
+                        break;
+                    }
+                }
+            }
+
             muuk::logger::trace("Profile '{}' CFLAGS: {}", profile, fmt::join(build_profile.cflags, " "));
             muuk::logger::trace("Profile '{}' AFLAGS: {}", profile, fmt::join(build_profile.cflags, " "));
             muuk::logger::trace("Profile '{}' LFLAGS: {}", profile, fmt::join(build_profile.lflags, " "));
diff --git a/src/compiler.cpp b/src/compiler.cpp
@@ -220,5 +220,4 @@ namespace muuk {
             return "";
         }
     }
-
 } // namespace muuk
diff --git a/src/lockgen/base_config.cpp b/src/lockgen/base_config.cpp
@@ -147,7 +147,12 @@ namespace muuk {
         void ProfileConfig::load(const toml::value& v, const std::string& profile_name, const std::string& base_path) {
             BaseConfig<ProfileConfig>::load(v, base_path);
             name = profile_name;
-            inherits = toml::find_or<std::vector<std::string>>(v, "inherits", {});
+            inherits = toml::try_find_or<std::vector<std::string>>(
+                v,
+                "inherits",
+                {});
+            lockgen::load(settings, v);
+            lockgen::load(sanitizers, v);
         }
 
         void ProfileConfig::serialize(toml::value& out) const {
@@ -156,6 +161,9 @@ namespace muuk {
             // Serialize inheritance
             if (!inherits.empty())
                 out["inherits"] = inherits;
+
+            lockgen::serialize(settings, out);
+            lockgen::serialize(sanitizers, out);
         }
 
         void Library::External::load(const toml::value& v) {
diff --git a/src/lockgen/parsing.cpp b/src/lockgen/parsing.cpp
@@ -43,17 +43,37 @@ namespace muuk {
         }
 
         Result<void> MuukLockGenerator::parse_profile(const toml::value& data) {
+            // Default Profiles (debug and release)
+            {
+                ProfileConfig debug_profile;
+                debug_profile.name = "debug";
+                debug_profile.settings.debug = true;
+                debug_profile.settings.optimization_level = OptimizationLevel::O0;
+                debug_profile.settings.debug_assertions = true;
+                debug_profile.settings.lto = false;
+                debug_profile.sanitizers.address = true;
+                debug_profile.sanitizers.undefined = true;
+
+                ProfileConfig release_profile;
+                release_profile.name = "release";
+                release_profile.settings.debug = false;
+                release_profile.settings.optimization_level = OptimizationLevel::O3;
+                debug_profile.settings.debug_assertions = false;
+                release_profile.settings.lto = true;
+                debug_profile.sanitizers.undefined = true;
+
+                profiles_config_["debug"] = std::move(debug_profile);
+                profiles_config_["release"] = std::move(release_profile);
+            }
+
             // Two pass parsing for profiles
             // First pass: Load all profiles
             if (data.contains("profile") && data.at("profile").is_table()) {
                 for (const auto& [profile_name, profile_data] : data.at("profile").as_table()) {
-                    if (!profile_data.is_table())
-                        continue;
+                    // this will create or get an existing profile
+                    ProfileConfig& config = profiles_config_[profile_name];
 
-                    ProfileConfig config;
-                    config.name = profile_name;
-                    config.load(profile_data, profile_name, base_path_); // assuming you have `base_path_`
-                    profiles_config_[profile_name] = std::move(config);
+                    config.load(profile_data, profile_name, base_path_);
                 }
             }
 
diff --git a/src/lockgen/settings.cpp b/src/lockgen/settings.cpp

Original file line number	Diff line number	Diff line change
`@@ -220,5 +220,4 @@ namespace muuk {`
`220`	`220`	`return "";`
`221`	`221`	`}`
`222`	`222`	`}`
`223`		`-`
`224`	`223`	`} // namespace muuk`