Improve command handle (#149)

Author: 16bit-ykiko

CMakeLists.txt

@@ -93,6 +93,7 @@ if(NOT WIN32)
     target_link_libraries(clice-core PUBLIC
         LLVMSupport
         LLVMFrontendOpenMP
+        LLVMOption
         clangAST
         clangASTMatchers
         clangBasic
@@ -135,7 +136,7 @@ if(CLICE_ENABLE_TEST)
     )
     FetchContent_MakeAvailable(googletest)
 
-    target_link_libraries(unit_tests PRIVATE  gtest_main clice-core)
+    target_link_libraries(unit_tests PRIVATE gtest_main clice-core)
 
     # integration_tests
     add_executable(integration_tests "${CMAKE_SOURCE_DIR}/src/Driver/integration_tests.cc")

include/Compiler/Command.h

@@ -4,67 +4,128 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/ADT/ArrayRef.h"
+#include <deque>
 
 namespace clice {
 
-/// `CompilationDatabase` is responsible for managing the compile commands.
-///
-/// FIXME: currently we assume that a file only occurs once in the CDB.
-/// This is not always correct, but it is enough for now.
 class CompilationDatabase {
 public:
     using Self = CompilationDatabase;
 
-    /// Update the compile commands with the given file.
-    void update_commands(this Self& self, llvm::StringRef file);
+    enum class UpdateKind : std::uint8_t {
+        Unchange,
+        Create,
+        Update,
+        Delete,
+    };
+
+    struct CommandInfo {
+        /// TODO: add sysroot or no stdinc command info.
+        llvm::StringRef dictionary;
 
-    /// Update the module map with the given file and module name.
-    void update_module(llvm::StringRef file, llvm::StringRef name);
+        /// The canonical command list.
+        llvm::ArrayRef<const char*> arguments;
+    };
 
-    /// Lookup the module interface unit file path of the given module name.
-    llvm::StringRef get_module_file(llvm::StringRef name);
+    struct DriverInfo {
+        /// The target of this driver.
+        llvm::StringRef target;
 
-    auto size() const {
-        return commands.size();
-    }
+        /// The default system includes of this driver.
+        llvm::ArrayRef<const char*> system_includes;
+    };
+
+    struct UpdateInfo {
+        /// The kind of update.
+        UpdateKind kind;
 
-    enum class Style {
-        GNU = 0,
-        MSVC,
+        llvm::StringRef file;
     };
 
-    void add_command(this Self& self,
-                     llvm::StringRef path,
-                     llvm::StringRef command,
-                     Style style = Style::GNU);
+    struct LookupInfo {
+        llvm::StringRef dictionary;
 
-    llvm::ArrayRef<const char*> get_command(this Self& self, llvm::StringRef path);
+        std::vector<const char*> arguments;
+    };
 
-private:
-    /// Save a string into memory pool. Make sure end with `\0`.
-    llvm::StringRef save_string(this Self& self, llvm::StringRef string);
+    CompilationDatabase();
 
-    std::vector<const char*> save_args(this Self& self, llvm::ArrayRef<const char*> args);
+    auto save_string(this Self& self, llvm::StringRef string) -> llvm::StringRef;
+
+    auto save_cstring_list(this Self& self, llvm::ArrayRef<const char*> arguments)
+        -> llvm::ArrayRef<const char*>;
+
+    /// Get an the option for specific argument.
+    static std::optional<std::uint32_t> get_option_id(llvm::StringRef argument);
+
+    /// Query the compiler driver and return its driver info.
+    auto query_driver(this Self& self, llvm::StringRef driver)
+        -> std::expected<DriverInfo, std::string>;
+
+    /// Update with arguments.
+    auto update_command(this Self& self,
+                        llvm::StringRef dictionary,
+                        llvm::StringRef file,
+                        llvm::ArrayRef<const char*> arguments) -> UpdateInfo;
+
+    /// Update with full command.
+    auto update_command(this Self& self,
+                        llvm::StringRef dictionary,
+                        llvm::StringRef file,
+                        llvm::StringRef command) -> UpdateInfo;
+
+    /// Update commands from json file and return all updated file.
+    auto load_commands(this Self& self, llvm::StringRef json_content)
+        -> std::expected<std::vector<UpdateInfo>, std::string>;
+
+    auto get_command(this Self& self, llvm::StringRef file, bool resource_dir = false) -> LookupInfo;
 
 private:
-    /// For C++20 module, we only can got dependent module name
-    /// in source context. But we need dependent module file path
-    /// to build PCM. So we will scan(preprocess) all project files
-    /// to build a module map between module name and module file path.
-    /// **Note that** this only includes module interface unit, for module
-    /// implementation unit, the scan could be delayed until compiling it.
-    llvm::StringMap<std::string> moduleMap;
-
-    /// Memory pool for command arguments.
-    llvm::BumpPtrAllocator memory_pool;
-
-    /// For lookup whether we already have the key.
-    llvm::DenseSet<llvm::StringRef> unique;
-
-    // A map between file path and compile commands.
-    /// TODO: Path cannot represent unique file, we should use better, like inode ...
-    llvm::DenseMap<const char*, std::unique_ptr<std::vector<const char*>>> commands;
+    /// The memory pool to hold all cstring and command list.
+    llvm::BumpPtrAllocator allocator;
+
+    /// A cache between input string and its cache cstring
+    /// in the allocator, make sure end with `\0`.
+    llvm::DenseSet<llvm::StringRef> string_cache;
+
+    /// A cache between input command and its cache array
+    /// in the allocator.
+    llvm::DenseSet<llvm::ArrayRef<const char*>> arguments_cache;
+
+    /// The clang options we want to filter in all cases, like -c and -o.
+    llvm::DenseSet<std::uint32_t> filtered_options;
+
+    /// A map between file path and its canonical command list.
+    llvm::DenseMap<const void*, CommandInfo> command_infos;
+
+    /// A map between driver path and its query driver info.
+    llvm::DenseMap<const void*, DriverInfo> driver_infos;
 };
 
 }  // namespace clice
 
+namespace llvm {
+
+template <>
+struct DenseMapInfo<llvm::ArrayRef<const char*>> {
+    using T = llvm::ArrayRef<const char*>;
+
+    inline static T getEmptyKey() {
+        return T(reinterpret_cast<T::const_pointer>(~0), T::size_type(0));
+    }
+
+    inline static T getTombstoneKey() {
+        return T(reinterpret_cast<T::const_pointer>(~1), T::size_type(0));
+    }
+
+    static unsigned getHashValue(const T& value) {
+        return llvm::hash_combine_range(value.begin(), value.end());
+    }
+
+    static bool isEqual(const T& lhs, const T& rhs) {
+        return lhs == rhs;
+    }
+};
+
+}  // namespace llvm

include/Compiler/Compilation.h

@@ -15,8 +15,10 @@ struct CompilationParams {
     /// Output file path.
     llvm::SmallString<128> outPath;
 
+    std::string directory;
+
     /// Responsible for storing the arguments.
-    llvm::ArrayRef<const char*> arguments;
+    std::vector<const char*> arguments;
 
     llvm::IntrusiveRefCntPtr<vfs::FileSystem> vfs = new ThreadSafeFS();
 
@@ -32,12 +34,11 @@ struct CompilationParams {
     /// The memory buffers for all remapped file.
     llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> buffers;
 
-    
     void add_remapped_file(llvm::StringRef path,
                            llvm::StringRef content,
                            std::uint32_t bound = -1) {
-        if(bound != -1) {
-            assert(bound < content.size());
+        if(bound != 0 && bound != -1) {
+            assert(bound <= content.size());
             content = content.substr(0, bound);
         }
         buffers.try_emplace(path, llvm::MemoryBuffer::getMemBufferCopy(content));

include/Test/CTest.h

@@ -80,9 +80,9 @@ struct Tester {
 
     Tester& compile(llvm::StringRef standard = "-std=c++20") {
         auto command = std::format("clang++ {} {} -fms-extensions", standard, src_path);
-        database.add_command(src_path, command);
-        params.arguments = database.get_command(src_path);
-        
+        database.update_command("fake", src_path, command);
+        params.arguments = database.get_command(src_path).arguments;
+
         auto info = clice::compile(params);
         ASSERT_TRUE(info);
         this->unit.emplace(std::move(*info));