Add processing of linking flags -l -Wl -L (#8)

* Add processing of linking flags -l -Wl -L

* Separate -static flag from -static-s

* Supplement testing system, add processing libs for compilation database

Author: mamaria-k

source/citnames/CMakeLists.txt

@@ -66,7 +66,8 @@ if (ENABLE_UNIT_TESTS)
             test/OutputTest.cc
             test/ParserTest.cc
             test/ToolClangTest.cc
-            test/ToolGccTest.cc
+            test/ToolGccCompileTest.cc
+            test/ToolGccLinkTest.cc
             test/ToolWrapperTest.cc
             test/ToolArTest.cc
             )

source/citnames/source/semantic/Parsers.h

@@ -106,7 +106,6 @@ namespace cs::semantic {
         PREPROCESSOR_MAKE,
         LINKER,
         DIRECTORY_SEARCH,
-        DIRECTORY_SEARCH_LINKER,
         OTHER,
         STATIC_ANALYZER,
         UNKNOWN,
@@ -116,6 +115,11 @@ namespace cs::semantic {
         LIBRARY,
 
         KIND_OF_OUTPUT_OUTPUT,
+
+        DIRECTORY_SEARCH_LIBRARY,
+        LINKER_LIBRARY_FLAG,
+        LINKER_LIBRARY_STATIC,
+        LINKER_OPTIONS_FLAG,
     };
 
     struct CompilerFlag {

source/citnames/source/semantic/ToolGcc.cc

@@ -28,13 +28,20 @@
 #include <set>
 #include <string_view>
 #include <numeric>
+#include <cassert>
 
 #include <spdlog/spdlog.h>
 
 using namespace cs::semantic;
 
 namespace {
 
+    enum class LibraryPriorityType {
+        FIRSTLY_SHARED,
+        ONLY_STATIC,
+        ONLY_STATIC_FIXED
+    };
+
     // https://gcc.gnu.org/onlinedocs/cpp/Environment-Variables.html
     Arguments flags_from_environment(const std::map<std::string, std::string> &environment) {
         Arguments flags;
@@ -71,6 +78,19 @@ namespace {
         return input_arguments;
     }
 
+    std::vector<std::string> get_library_directories(const Execution &execution) {
+        std::vector<std::string> library_directories;
+        if (const auto it = execution.environment.find("LIBRARY_PATH"); it != execution.environment.end())
+        {
+            for (const auto &path : sys::path::split(it->second)) {
+                auto directory = (path.empty()) ? "." : path.string();
+                library_directories.emplace_back(directory);
+            }
+        }
+
+        return library_directories;
+    }
+
     bool is_compiler_query(const CompilerFlags& flags)
     {
         // no flag is a no compilation
@@ -104,17 +124,117 @@ namespace {
         });
     }
 
+    std::string directory_path_from_flag(const CompilerFlag& flag) {
+        assert(flag.type == CompilerFlagType::DIRECTORY_SEARCH_LIBRARY);
+
+        if (flag.arguments.front() == "-L") {
+            return flag.arguments.back();
+        }
+        return flag.arguments.front().substr(2);
+    }
+
+    std::string library_name_from_flag(const CompilerFlag& flag) {
+        assert(flag.type == CompilerFlagType::LINKER_LIBRARY_FLAG);
+
+        if (flag.arguments.front() == "-l") {
+            return flag.arguments.back();
+        }
+        return flag.arguments.front().substr(2);
+    }
+
+    std::optional<fs::path> find_library(
+        const std::string& libname,
+        const std::vector<std::string>& library_directories,
+        const std::vector<std::string>& added_library_directories,
+        const LibraryPriorityType type
+    ) {
+        static const std::vector<std::string> shared_extensions = {
+            ".so", ".dylib", ".dll", ".DLL", ".ocx", ".OCX", ".lib", ".LIB", ".library"
+        };
+        static const std::vector<std::string> static_extensions = {
+            ".a", ".lib", ".LIB"
+        };
+
+        const std::string libname_with_prefix = "lib" + libname;
+
+        const auto find_lib = [&libname_with_prefix](
+            const std::vector<std::string>& dirs,
+            const std::vector<std::string>& extensions
+        ) -> std::optional<std::string> {
+            for (const auto& dir : dirs) {
+                for (const auto& extension: extensions) {
+                    fs::path libname_full = dir;
+                    libname_full /= libname_with_prefix + extension;
+
+                    if (fs::exists(libname_full)) {
+                        return std::make_optional(libname_full);
+                    }
+                }
+            }
+            return std::nullopt;
+        };
+
+        if (type == LibraryPriorityType::FIRSTLY_SHARED) {
+            if (const auto lib = find_lib(added_library_directories, shared_extensions); lib.has_value()) {
+                return lib;
+            }
+            if (const auto lib = find_lib(library_directories, shared_extensions); lib.has_value()) {
+                return lib;
+            }
+        }
+
+        if (const auto lib = find_lib(added_library_directories, static_extensions); lib.has_value()) {
+            return lib;
+        }
+        if (const auto lib = find_lib(library_directories, static_extensions); lib.has_value()) {
+            return lib;
+        }
+
+        return std::nullopt;
+    }
+
+    inline bool contains_static_flag(const CompilerFlags &flags) {
+        return std::any_of(flags.begin(), flags.end(), [](const auto& flag) {
+            return flag.type == CompilerFlagType::LINKER_LIBRARY_STATIC;
+        });
+    }
+
+    void processing_linker_options_flag(const CompilerFlag& flag, LibraryPriorityType& type) {
+        const auto& options = flag.arguments.front();
+        size_t option_start = 0;
+
+        while (option_start < options.size()) {
+            size_t option_end = options.find(',', option_start);
+            if (option_end == std::string::npos) {
+                option_end = options.size();
+            }
+            const auto option = options.substr(option_start, option_end - option_start);
+            if (type != LibraryPriorityType::ONLY_STATIC_FIXED && option == "-Bdynamic") {
+                type = LibraryPriorityType::FIRSTLY_SHARED;
+            }
+            if (type != LibraryPriorityType::ONLY_STATIC_FIXED && option == "-Bstatic") {
+                type = LibraryPriorityType::ONLY_STATIC;
+            }
+            option_start = option_end + 1;
+        }
+    }
+
     std::tuple<
             Arguments,
             std::list<fs::path>,
             std::list<fs::path>,
             std::optional<fs::path>
-    > split_compile(const CompilerFlags &flags) {
+    > split_compile(const CompilerFlags &flags, const std::vector<std::string>& library_directories) {
         Arguments arguments;
         std::list<fs::path> sources;
         std::list<fs::path> dependencies;
         std::optional<fs::path> output;
 
+        std::vector<std::string> added_library_directories;
+        LibraryPriorityType type = (contains_static_flag(flags))
+            ? LibraryPriorityType::ONLY_STATIC_FIXED
+            : LibraryPriorityType::FIRSTLY_SHARED;
+
         for (const auto &flag : flags) {
             switch (flag.type) {
                 case CompilerFlagType::KIND_OF_OUTPUT_OUTPUT: {
@@ -133,6 +253,21 @@ namespace {
                     dependencies.emplace_back(candidate);
                     break;
                 }
+                case CompilerFlagType::LINKER_OPTIONS_FLAG: {
+                    processing_linker_options_flag(flag, type);
+                    break;
+                }
+                case CompilerFlagType::DIRECTORY_SEARCH_LIBRARY: {
+                    added_library_directories.push_back(directory_path_from_flag(flag));
+                    break;
+                }
+                case CompilerFlagType::LINKER_LIBRARY_FLAG: {
+                    const auto library = find_library(library_name_from_flag(flag), library_directories, added_library_directories, type);
+                    if (library.has_value()) {
+                        dependencies.push_back(library.value());
+                    }
+                    break;
+                }
                 default: {
                     break;
                 }
@@ -147,12 +282,17 @@ namespace {
             std::list<fs::path>,
             std::optional<fs::path>,
             size_t
-    > split_link_with_updating_sources(const CompilerFlags &flags) {
+    > split_link_with_updating_sources(const CompilerFlags &flags, const std::vector<std::string>& library_directories) {
         Arguments arguments;
         std::list<fs::path> files;
         std::optional<fs::path> output;
         size_t sources_count = 0;
 
+        std::vector<std::string> added_library_directories;
+        LibraryPriorityType type = (contains_static_flag(flags))
+            ? LibraryPriorityType::ONLY_STATIC_FIXED
+            : LibraryPriorityType::FIRSTLY_SHARED;
+
         for (const auto &flag : flags) {
             switch (flag.type) {
                 case CompilerFlagType::KIND_OF_OUTPUT_OUTPUT: {
@@ -163,20 +303,35 @@ namespace {
                 case CompilerFlagType::SOURCE: {
                     sources_count++;
                     const auto source_after_compilation = flag.arguments.front() + ".o";
-                    arguments.push_back(source_after_compilation);
                     files.emplace_back(source_after_compilation);
-                    break;
+                    arguments.push_back(source_after_compilation);
+                    continue;
                 }
                 case CompilerFlagType::LIBRARY:
                 case CompilerFlagType::OBJECT_FILE: {
-                    arguments.push_back(flag.arguments.front());
                     files.emplace_back(flag.arguments.front());
                     break;
                 }
+                case CompilerFlagType::LINKER_OPTIONS_FLAG: {
+                    processing_linker_options_flag(flag, type);
+                    break;
+                }
+                case CompilerFlagType::DIRECTORY_SEARCH_LIBRARY: {
+                    added_library_directories.push_back(directory_path_from_flag(flag));
+                    break;
+                }
+                case CompilerFlagType::LINKER_LIBRARY_FLAG: {
+                    const auto library = find_library(library_name_from_flag(flag), library_directories, added_library_directories, type);
+                    if (library.has_value()) {
+                        files.push_back(library.value());
+                    }
+                    break;
+                }
                 default: {
-                    std::copy(flag.arguments.begin(), flag.arguments.end(), std::back_inserter(arguments));
+                    break;
                 }
             }
+            std::copy(flag.arguments.begin(), flag.arguments.end(), std::back_inserter(arguments));
         }
         return std::make_tuple(arguments, files, output, sources_count);
     }
@@ -252,12 +407,12 @@ namespace cs::semantic {
             {"-iwithprefixbefore", {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::DIRECTORY_SEARCH}},
             {"-isysroot",          {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::DIRECTORY_SEARCH}},
             {"-imultilib",         {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::DIRECTORY_SEARCH}},
-            {"-L",                 {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_OR_SEP,  CompilerFlagType::DIRECTORY_SEARCH_LINKER}},
+            {"-L",                 {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_OR_SEP,  CompilerFlagType::DIRECTORY_SEARCH_LIBRARY}},
             {"-B",                 {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_OR_SEP,  CompilerFlagType::DIRECTORY_SEARCH}},
             {"--sysroot",          {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_WITH_EQ, CompilerFlagType::DIRECTORY_SEARCH}},
             {"-flinker-output",    {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_WITH_EQ, CompilerFlagType::LINKER}},
             {"-fuse-ld",           {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_WITH_EQ, CompilerFlagType::LINKER}},
-            {"-l",                 {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_OR_SEP,  CompilerFlagType::LINKER}},
+            {"-l",                 {MatchInstruction::EXACTLY_WITH_1_OPT_GLUED_OR_SEP,  CompilerFlagType::LINKER_LIBRARY_FLAG}},
             {"-nostartfiles",      {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
             {"-nodefaultlibs",     {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
             {"-nolibc",            {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
@@ -271,11 +426,12 @@ namespace cs::semantic {
             {"-rdynamic",          {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
             {"-s",                 {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
             {"-symbolic",          {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER}},
-            {"-static",            {MatchInstruction::PREFIX,                           CompilerFlagType::LINKER}},
+            {"-static",            {MatchInstruction::EXACTLY,                          CompilerFlagType::LINKER_LIBRARY_STATIC}},
+            {"-static-",           {MatchInstruction::PREFIX,                           CompilerFlagType::LINKER}},
             {"-shared",            {MatchInstruction::PREFIX,                           CompilerFlagType::LINKER}},
             {"-T",                 {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::LINKER}},
             {"-Xlinker",           {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::LINKER}},
-            {"-Wl,",               {MatchInstruction::PREFIX,                           CompilerFlagType::LINKER}},
+            {"-Wl,",               {MatchInstruction::PREFIX,                           CompilerFlagType::LINKER_OPTIONS_FLAG}},
             {"-u",                 {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::LINKER}},
             {"-z",                 {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::LINKER}},
             {"-Xassembler",        {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,           CompilerFlagType::OTHER}},
@@ -358,7 +514,7 @@ namespace cs::semantic {
                     }
 
                     // arguments contains everything except output and sources
-                    auto[arguments, sources, dependencies, output] = split_compile(flags);
+                    auto[arguments, sources, dependencies, output] = split_compile(flags, get_library_directories(execution));
                     if (sources.empty()) {
                         return rust::Err(std::runtime_error("Source files not found for compilation."));
                     }
@@ -403,7 +559,7 @@ namespace cs::semantic {
                     }
 
                     // arguments contains everything except output
-                    auto[arguments, files, output, sources_count] = split_link_with_updating_sources(flags);
+                    auto[arguments, files, output, sources_count] = split_link_with_updating_sources(flags, get_library_directories(execution));
                     if (sources_count != 0 && !has_linker(flags)) {
                         return rust::Err(std::runtime_error("Without linking."));
                     }