Clangd crashed when opening dense_hash_map from google's sparsehash-c11 library

clangd_log

V[18:04:46.119] <<< {"id":"1","jsonrpc":"2.0","method":"initialize","params":{"capabilities":{"textDocument":{"completion":{"completionItemKind":{"valueSet":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26]}}}},"initializationOptions":{},"processId":25076,"rootPath":"/home/bstaletic/Temp/sparsehash-c11","rootUri":"file:///home/bstaletic/Temp/sparsehash-c11"}}

I[18:04:46.120] <-- initialize("1")
I[18:04:46.120] --> reply("1")
V[18:04:46.120] >>> {"id":"1","jsonrpc":"2.0","result":{"capabilities":{"codeActionProvider":true,"completionProvider":{"resolveProvider":false,"triggerCharacters":[".",">",":"]},"definitionProvider":true,"documentFormattingProvider":true,"documentHighlightProvider":true,"documentOnTypeFormattingProvider":{"firstTriggerCharacter":"}","moreTriggerCharacter":[]},"documentRangeFormattingProvider":true,"documentSymbolProvider":true,"executeCommandProvider":{"commands":["clangd.applyFix"]},"hoverProvider":true,"renameProvider":true,"signatureHelpProvider":{"triggerCharacters":["(",","]},"textDocumentSync":2,"workspaceSymbolProvider":true}}}

V[18:04:46.122] <<< {"jsonrpc":"2.0","method":"initialized","params":{}}

I[18:04:46.122] <-- initialized
E[18:04:46.122] Error -32601: method not found
V[18:04:46.122] <<< {"jsonrpc":"2.0","method":"workspace/didChangeConfiguration","params":{"settings":{}}}

I[18:04:46.122] <-- workspace/didChangeConfiguration
V[18:04:46.123] <<< {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"languageId":"cpp","text":"// Copyright (c) 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n//     * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//     * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following disclaimer\n// in the documentation and/or other materials provided with the\n// distribution.\n//     * Neither the name of Google Inc. nor the names of its\n// contributors may be used to endorse or promote products derived from\n// this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n// ----\n//\n// This is just a very thin wrapper over densehashtable.h, just\n// like sgi stl's stl_hash_map is a very thin wrapper over\n// stl_hashtable.  The major thing we define is operator[], because\n// we have a concept of a data_type which stl_hashtable doesn't\n// (it only has a key and a value).\n//\n// NOTE: this is exactly like sparse_hash_map.h, with the word\n// \"sparse\" replaced by \"dense\", except for the addition of\n// set_empty_key().\n//\n//   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.\n//\n// Otherwise your program will die in mysterious ways.  (Note if you\n// use the constructor that takes an InputIterator range, you pass in\n// the empty key in the constructor, rather than after.  As a result,\n// this constructor differs from the standard STL version.)\n//\n// In other respects, we adhere mostly to the STL semantics for\n// hash-map.  One important exception is that insert() may invalidate\n// iterators entirely -- STL semantics are that insert() may reorder\n// iterators, but they all still refer to something valid in the\n// hashtable.  Not so for us.  Likewise, insert() may invalidate\n// pointers into the hashtable.  (Whether insert invalidates iterators\n// and pointers depends on whether it results in a hashtable resize).\n// On the plus side, delete() doesn't invalidate iterators or pointers\n// at all, or even change the ordering of elements.\n//\n// Here are a few \"power user\" tips:\n//\n//    1) set_deleted_key():\n//         If you want to use erase() you *must* call set_deleted_key(),\n//         in addition to set_empty_key(), after construction.\n//         The deleted and empty keys must differ.\n//\n//    2) resize(0):\n//         When an item is deleted, its memory isn't freed right\n//         away.  This allows you to iterate over a hashtable,\n//         and call erase(), without invalidating the iterator.\n//         To force the memory to be freed, call resize(0).\n//         For tr1 compatibility, this can also be called as rehash(0).\n//\n//    3) min_load_factor(0.0)\n//         Setting the minimum load factor to 0.0 guarantees that\n//         the hash table will never shrink.\n//\n// Roughly speaking:\n//   (1) dense_hash_map: fastest, uses the most memory unless entries are small\n//   (2) sparse_hash_map: slowest, uses the least memory\n//   (3) hash_map / unordered_map (STL): in the middle\n//\n// Typically I use sparse_hash_map when I care about space and/or when\n// I need to save the hashtable on disk.  I use hash_map otherwise.  I\n// don't personally use dense_hash_set ever; some people use it for\n// small sets with lots of lookups.\n//\n// - dense_hash_map has, typically, about 78% memory overhead (if your\n//   data takes up X bytes, the hash_map uses .78X more bytes in overhead).\n// - sparse_hash_map has about 4 bits overhead per entry.\n// - sparse_hash_map can be 3-7 times slower than the others for lookup and,\n//   especially, inserts.  See time_hash_map.cc for details.\n//\n// See /usr/(local/)?doc/sparsehash-*/dense_hash_map.html\n// for information about how to use this class.\n\n#pragma once\n\n#include <algorithm>   // needed by stl_alloc\n#include <functional>  // for equal_to<>, select1st<>, etc\n#include <initializer_list> // for initializer_list\n#include <memory>      // for alloc\n#include <utility>     // for pair<>\n#include <tuple>       // forward_as_tuple\n#include <type_traits> // for enable_if, is_constructible, etc\n#include <sparsehash/internal/densehashtable.h>  // IWYU pragma: export\n#include <sparsehash/internal/libc_allocator_with_realloc.h>\n\nnamespace google {\n\ntemplate <class Key, class T, class HashFcn = std::hash<Key>,\n          class EqualKey = std::equal_to<Key>,\n          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T>>>\nclass dense_hash_map {\n private:\n  // Apparently select1st is not stl-standard, so we define our own\n  struct SelectKey {\n    typedef const Key& result_type;\n    template <typename Pair>\n    const Key& operator()(Pair&& p) const {\n      return p.first;\n    }\n  };\n  struct SetKey {\n    void operator()(std::pair<const Key, T>* value, const Key& new_key) const {\n      using NCKey = typename std::remove_cv<Key>::type;\n      *const_cast<NCKey*>(&value->first) = new_key;\n\n      // It would be nice to clear the rest of value here as well, in\n      // case it's taking up a lot of memory.  We do this by clearing\n      // the value.  This assumes T has a zero-arg constructor!\n      value->second = T();\n    }\n    void operator()(std::pair<const Key, T>* value, const Key& new_key, bool) const {\n      new(value) std::pair<const Key, T>(std::piecewise_construct, std::forward_as_tuple(new_key), std::forward_as_tuple());\n    }\n  };\n  // The actual data\n  typedef dense_hashtable<std::pair<const Key, T>, Key, HashFcn, SelectKey,\n                          SetKey, EqualKey, Alloc> ht;\n  ht rep;\n\n public:\n  typedef typename ht::key_type key_type;\n  typedef T data_type;\n  typedef T mapped_type;\n  typedef typename ht::value_type value_type;\n  typedef typename ht::hasher hasher;\n  typedef typename ht::key_equal key_equal;\n  typedef Alloc allocator_type;\n\n  typedef typename ht::size_type size_type;\n  typedef typename ht::difference_type difference_type;\n  typedef typename ht::pointer pointer;\n  typedef typename ht::const_pointer const_pointer;\n  typedef typename ht::reference reference;\n  typedef typename ht::const_reference const_reference;\n\n  typedef typename ht::iterator iterator;\n  typedef typename ht::const_iterator const_iterator;\n  typedef typename ht::local_iterator local_iterator;\n  typedef typename ht::const_local_iterator const_local_iterator;\n\n  // Iterator functions\n  iterator begin() { return rep.begin(); }\n  iterator end() { return rep.end(); }\n  const_iterator begin() const { return rep.begin(); }\n  const_iterator end() const { return rep.end(); }\n  const_iterator cbegin() const { return rep.begin(); }\n  const_iterator cend() const { return rep.end(); }\n\n  // These come from tr1's unordered_map. For us, a bucket has 0 or 1 elements.\n  local_iterator begin(size_type i) { return rep.begin(i); }\n  local_iterator end(size_type i) { return rep.end(i); }\n  const_local_iterator begin(size_type i) const { return rep.begin(i); }\n  const_local_iterator end(size_type i) const { return rep.end(i); }\n  const_local_iterator cbegin(size_type i) const { return rep.begin(i); }\n  const_local_iterator cend(size_type i) const { return rep.end(i); }\n\n  // Accessor functions\n  allocator_type get_allocator() const { return rep.get_allocator(); }\n  hasher hash_funct() const { return rep.hash_funct(); }\n  hasher hash_function() const { return hash_funct(); }\n  key_equal key_eq() const { return rep.key_eq(); }\n\n  // Constructors\n  explicit dense_hash_map(size_type expected_max_items_in_table = 0,\n                          const hasher& hf = hasher(),\n                          const key_equal& eql = key_equal(),\n                          const allocator_type& alloc = allocator_type())\n      : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(),\n            alloc) {}\n\n  template <class InputIterator>\n  dense_hash_map(InputIterator f, InputIterator l,\n                 const key_type& empty_key_val,\n                 size_type expected_max_items_in_table = 0,\n                 const hasher& hf = hasher(),\n                 const key_equal& eql = key_equal(),\n                 const allocator_type& alloc = allocator_type())\n      : rep(expected_max_items_in_table, hf, eql, SelectKey(), SetKey(),\n            alloc) {\n    set_empty_key(empty_key_val);\n    rep.insert(f, l);\n  }\n  // We use the default copy constructor\n  // We use the default operator=()\n  // We use the default destructor\n\n  void clear() { rep.clear(); }\n  // This clears the hash map without resizing it down to the minimum\n  // bucket count, but rather keeps the number of buckets constant\n  void clear_no_resize() { rep.clear_no_resize(); }\n  void swap(dense_hash_map& hs) { rep.swap(hs.rep); }\n\n  // Functions concerning size\n  size_type size() const { return rep.size(); }\n  size_type max_size() const { return rep.max_size(); }\n  bool empty() const { return rep.empty(); }\n  size_type bucket_count() const { return rep.bucket_count(); }\n  size_type max_bucket_count() const { return rep.max_bucket_count(); }\n\n  // These are tr1 methods.  bucket() is the bucket the key is or would be in.\n  size_type bucket_size(size_type i) const { return rep.bucket_size(i); }\n  size_type bucket(const key_type& key) const { return rep.bucket(key); }\n  float load_factor() const { return size() * 1.0f / bucket_count(); }\n  float max_load_factor() const {\n    float shrink, grow;\n    rep.get_resizing_parameters(&shrink, &grow);\n    return grow;\n  }\n  void max_load_factor(float new_grow) {\n    float shrink, grow;\n    rep.get_resizing_parameters(&shrink, &grow);\n    rep.set_resizing_parameters(shrink, new_grow);\n  }\n  // These aren't tr1 methods but perhaps ought to be.\n  float min_load_factor() const {\n    float shrink, grow;\n    rep.get_resizing_parameters(&shrink, &grow);\n    return shrink;\n  }\n  void min_load_factor(float new_shrink) {\n    float shrink, grow;\n    rep.get_resizing_parameters(&shrink, &grow);\n    rep.set_resizing_parameters(new_shrink, grow);\n  }\n  // Deprecated; use min_load_factor() or max_load_factor() instead.\n  void set_resizing_parameters(float shrink, float grow) {\n    rep.set_resizing_parameters(shrink, grow);\n  }\n\n  void resize(size_type hint) { rep.resize(hint); }\n  void rehash(size_type hint) { resize(hint); }  // the tr1 name\n\n  // Lookup routines\n  iterator find(const key_type& key) { return rep.find(key); }\n  const_iterator find(const key_type& key) const { return rep.find(key); }\n\n  data_type& operator[](const key_type& key) {  // This is our value-add!\n    // If key is in the hashtable, returns find(key)->second,\n    // otherwise returns insert(value_type(key, T()).first->second.\n    // Note it does not create an empty T unless the find fails.\n    return rep.template find_or_insert<data_type>(key).second;\n  }\n\n  data_type& operator[](key_type&& key) {\n    return rep.template find_or_insert<data_type>(std::move(key)).second;\n  }\n\n  size_type count(const key_type& key) const { return rep.count(key); }\n\n  std::pair<iterator, iterator> equal_range(const key_type& key) {\n    return rep.equal_range(key);\n  }\n  std::pair<const_iterator, const_iterator> equal_range(\n      const key_type& key) const {\n    return rep.equal_range(key);\n  }\n\n  // Insertion routines\n  std::pair<iterator, bool> insert(const value_type& obj) {\n    return rep.insert(obj);\n  }\n\n  template <typename Pair, typename = typename std::enable_if<std::is_constructible<value_type, Pair&&>::value>::type>\n  std::pair<iterator, bool> insert(Pair&& obj) {\n    return rep.insert(std::forward<Pair>(obj));\n  }\n\n  // overload to allow {} syntax: .insert( { {key}, {args} } )\n  std::pair<iterator, bool> insert(value_type&& obj) {\n    return rep.insert(std::move(obj));\n  }\n\n  template <typename... Args>\n  std::pair<iterator, bool> emplace(Args&&... args) {\n    return rep.emplace(std::forward<Args>(args)...);\n  }\n\n  template <typename... Args>\n  std::pair<iterator, bool> emplace_hint(const_iterator hint, Args&&... args) {\n    return rep.emplace_hint(hint, std::forward<Args>(args)...);\n  }\n\n\n  template <class InputIterator>\n  void insert(InputIterator f, InputIterator l) {\n    rep.insert(f, l);\n  }\n  void insert(const_iterator f, const_iterator l) { rep.insert(f, l); }\n  void insert(std::initializer_list<value_type> ilist) { rep.insert(ilist.begin(), ilist.end()); }\n  // Required for std::insert_iterator; the passed-in iterator is ignored.\n  iterator insert(const_iterator, const value_type& obj) { return insert(obj).first; }\n  iterator insert(const_iterator, value_type&& obj) { return insert(std::move(obj)).first; }\n  template <class P, class = typename std::enable_if<\n                                        std::is_constructible<value_type, P&&>::value &&\n                                        !std::is_same<value_type, P>::value\n                                      >::type>\n  iterator insert(const_iterator, P&& obj) { return insert(std::forward<P>(obj)).first; }\n\n  // Deletion and empty routines\n  // THESE ARE NON-STANDARD!  I make you specify an \"impossible\" key\n  // value to identify deleted and empty buckets.  You can change the\n  // deleted key as time goes on, or get rid of it entirely to be insert-only.\n   // YOU MUST CALL THIS!\n  void set_empty_key(const key_type& key) { rep.set_empty_key(key); }\n  key_type empty_key() const {  return rep.empty_key(); }\n\n  void set_deleted_key(const key_type& key) { rep.set_deleted_key(key); }\n  void clear_deleted_key() { rep.clear_deleted_key(); }\n  key_type deleted_key() const { return rep.deleted_key(); }\n\n  // These are standard\n  size_type erase(const key_type& key) { return rep.erase(key); }\n  iterator erase(const_iterator it) { return rep.erase(it); }\n  iterator erase(const_iterator f, const_iterator l) { return rep.erase(f, l); }\n\n  // Comparison\n  bool operator==(const dense_hash_map& hs) const { return rep == hs.rep; }\n  bool operator!=(const dense_hash_map& hs) const { return rep != hs.rep; }\n\n  // I/O -- this is an add-on for writing hash map to disk\n  //\n  // For maximum flexibility, this does not assume a particular\n  // file type (though it will probably be a FILE *).  We just pass\n  // the fp through to rep.\n\n  // If your keys and values are simple enough, you can pass this\n  // serializer to serialize()/unserialize().  \"Simple enough\" means\n  // value_type is a POD type that contains no pointers.  Note,\n  // however, we don't try to normalize endianness.\n  typedef typename ht::NopointerSerializer NopointerSerializer;\n\n  // serializer: a class providing operator()(OUTPUT*, const value_type&)\n  //    (writing value_type to OUTPUT).  You can specify a\n  //    NopointerSerializer object if appropriate (see above).\n  // fp: either a FILE*, OR an ostream*/subclass_of_ostream*, OR a\n  //    pointer to a class providing size_t Write(const void*, size_t),\n  //    which writes a buffer into a stream (which fp presumably\n  //    owns) and returns the number of bytes successfully written.\n  //    Note basic_ostream<not_char> is not currently supported.\n  template <typename ValueSerializer, typename OUTPUT>\n  bool serialize(ValueSerializer serializer, OUTPUT* fp) {\n    return rep.serialize(serializer, fp);\n  }\n\n  // serializer: a functor providing operator()(INPUT*, value_type*)\n  //    (reading from INPUT and into value_type).  You can specify a\n  //    NopointerSerializer object if appropriate (see above).\n  // fp: either a FILE*, OR an istream*/subclass_of_istream*, OR a\n  //    pointer to a class providing size_t Read(void*, size_t),\n  //    which reads into a buffer from a stream (which fp presumably\n  //    owns) and returns the number of bytes successfully read.\n  //    Note basic_istream<not_char> is not currently supported.\n  // NOTE: Since value_type is std::pair<const Key, T>, ValueSerializer\n  // may need to do a const cast in order to fill in the key.\n  template <typename ValueSerializer, typename INPUT>\n  bool unserialize(ValueSerializer serializer, INPUT* fp) {\n    return rep.unserialize(serializer, fp);\n  }\n};\n\n// We need a global swap as well\ntemplate <class Key, class T, class HashFcn, class EqualKey, class Alloc>\ninline void swap(dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,\n                 dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2) {\n  hm1.swap(hm2);\n}\n\n}  // namespace google\n","uri":"file:///home/bstaletic/Temp/sparsehash-c11/sparsehash/dense_hash_map","version":1}}}

I[18:04:46.148] <-- textDocument/didOpen
#0 0x00000000004ffcba llvm::sys::PrintStackTrace(llvm::raw_ostream&) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x4ffcba)
#1 0x00000000004fe459 llvm::sys::RunSignalHandlers() (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x4fe459)
#2 0x00000000004fe58d SignalHandler(int) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x4fe58d)
#3 0x00007fa2856c23c0 __restore_rt (/usr/lib/libpthread.so.0+0x123c0)
#4 0x0000000000d3e3c7 clang::driver::types::onlyPrecompileType(clang::driver::types::ID) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0xd3e3c7)
#5 0x0000000000bfd00e clang::tooling::(anonymous namespace)::InterpolatingCompilationDatabase::getCompileCommands(llvm::StringRef) const (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0xbfd00e)
#6 0x000000000055ea65 clang::clangd::DirectoryBasedGlobalCompilationDatabase::getCompileCommand(llvm::StringRef) const (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x55ea65)
#7 0x000000000055ce7b clang::clangd::CachingCompilationDb::getCompileCommand(llvm::StringRef) const (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x55ce7b)
#8 0x0000000000531631 clang::clangd::ClangdServer::getCompileCommand(llvm::StringRef) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x531631)
#9 0x00000000005340fa clang::clangd::ClangdServer::addDocument(llvm::StringRef, llvm::StringRef, clang::clangd::WantDiagnostics) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x5340fa)
#10 0x0000000000525a8f clang::clangd::ClangdLSPServer::onDocumentDidOpen(clang::clangd::DidOpenTextDocumentParams&) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x525a8f)
#11 0x000000000056f3fb std::_Function_handler<void (llvm::json::Value const&), void (anonymous namespace)::HandlerRegisterer::operator()<clang::clangd::DidOpenTextDocumentParams&>(llvm::StringRef, void (clang::clangd::ProtocolCallbacks::*)(clang::clangd::DidOpenTextDocumentParams&))::'lambda'(llvm::json::Value const&)>::_M_invoke(std::_Any_data const&, llvm::json::Value const&) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x56f3fb)
#12 0x0000000000564995 clang::clangd::JSONRPCDispatcher::call(llvm::json::Value const&, clang::clangd::JSONOutput&) const (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x564995)
#13 0x000000000056515c clang::clangd::runLanguageServerLoop(_IO_FILE*, clang::clangd::JSONOutput&, clang::clangd::JSONStreamStyle, clang::clangd::JSONRPCDispatcher&, bool&) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x56515c)
#14 0x0000000000525738 clang::clangd::ClangdLSPServer::run(_IO_FILE*, clang::clangd::JSONStreamStyle) (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x525738)
#15 0x00000000004d118d main (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x4d118d)
#16 0x00007fa2851e2223 __libc_start_main (/usr/lib/libc.so.6+0x24223)
#17 0x00000000004d4cec _start (/home/bstaletic/.vim/pack/bundle/start/YouCompleteMe/third_party/ycmd/third_party/clangd/output/bin/clangd+0x4d4cec)

compile_commands.json

[
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/bench.dir/bench.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/bench.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/bench.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/testmain.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/testmain.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/testmain.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/sparsetable_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/sparsetable_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/sparsetable_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/simple_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/simple_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/simple_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/hashtable_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/hashtable_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/hashtable_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/hashtable_c11_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/hashtable_c11_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/hashtable_c11_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/fixture_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/fixture_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/fixture_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/sparsehash_unittests.dir/allocator_unittests.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/allocator_unittests.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/allocator_unittests.cc"
},
{
  "directory": "/home/bstaletic/Temp/sparsehash-c11/build/tests/gtest",
  "command": "/usr/sbin/c++   -I/home/bstaletic/Temp/sparsehash-c11/. -I/home/bstaletic/Temp/sparsehash-c11/tests/.   -std=c++11 -Wall -Wextra -Wpedantic -Wno-missing-field-initializers -O3 -DNDEBUG -O3   -o CMakeFiles/gtest.dir/gmock-gtest-all.cc.o -c /home/bstaletic/Temp/sparsehash-c11/tests/gtest/gmock-gtest-all.cc",
  "file": "/home/bstaletic/Temp/sparsehash-c11/tests/gtest/gmock-gtest-all.cc"
}
]