diff --git a/build/gen.py b/build/gen.py
index 2d109ed..76fddfb 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -688,6 +688,7 @@
         'src/gn/pattern.cc',
         'src/gn/pool.cc',
         'src/gn/qt_creator_writer.cc',
+        'src/gn/resolved_target_data.cc',
         'src/gn/runtime_deps.cc',
         'src/gn/rust_substitution_type.cc',
         'src/gn/rust_tool.cc',
@@ -807,6 +808,7 @@
         'src/gn/path_output_unittest.cc',
         'src/gn/pattern_unittest.cc',
         'src/gn/pointer_set_unittest.cc',
+        'src/gn/resolved_target_data_unittest.cc',
         'src/gn/resolved_target_deps_unittest.cc',
         'src/gn/runtime_deps_unittest.cc',
         'src/gn/scope_per_file_provider_unittest.cc',
diff --git a/src/gn/resolved_target_data.cc b/src/gn/resolved_target_data.cc
new file mode 100644
index 0000000..742a4cc
--- /dev/null
+++ b/src/gn/resolved_target_data.cc
@@ -0,0 +1,14 @@
+// Copyright 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gn/resolved_target_data.h"
+
+ResolvedTargetData::TargetInfo* ResolvedTargetData::GetTargetInfo(
+    const Target* target) const {
+  auto ret = targets_.PushBackWithIndex(target);
+  if (ret.first) {
+    infos_.push_back(std::make_unique<TargetInfo>(target));
+  }
+  return infos_[ret.second].get();
+}
diff --git a/src/gn/resolved_target_data.h b/src/gn/resolved_target_data.h
new file mode 100644
index 0000000..510d6f6
--- /dev/null
+++ b/src/gn/resolved_target_data.h
@@ -0,0 +1,90 @@
+// Copyright 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TOOLS_GN_RESOLVED_TARGET_DATA_H_
+#define TOOLS_GN_RESOLVED_TARGET_DATA_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/containers/span.h"
+#include "gn/lib_file.h"
+#include "gn/resolved_target_deps.h"
+#include "gn/source_dir.h"
+#include "gn/target.h"
+#include "gn/target_public_pair.h"
+#include "gn/unique_vector.h"
+
+// A class used to compute target-specific data by collecting information
+// from its tree of dependencies.
+//
+// For example, linkable targets can call GetLinkedLibraries() and
+// GetLinkedLibraryDirs() to find the library files and library search
+// paths to add to their final linker command string, based on the
+// definitions of the `libs` and `lib_dirs` config values of their
+// transitive dependencies.
+//
+// Values are computed on demand, but memorized by the class instance in order
+// to speed up multiple queries for targets that share dependencies.
+//
+// Usage is:
+//
+//  1) Create instance.
+//
+//  2) Call any of the methods to retrieve the value of the corresponding
+//     data. For all methods, the input Target instance passed as argument
+//     must have been fully resolved (meaning that Target::OnResolved()
+//     must have been called and completed). Input target pointers are
+//     const and thus are never modified. This allows using multiple
+//     ResolvedTargetData instances from the same input graph in multiple
+//     threads safely.
+//
+class ResolvedTargetData {
+ public:
+  // Return the public/private/data/dependencies of a given target
+  // as a ResolvedTargetDeps instance.
+  const ResolvedTargetDeps& GetTargetDeps(const Target* target) const {
+    return GetTargetInfo(target)->deps;
+  }
+
+  // Return the data dependencies of a given target.
+  // Convenience shortcut for GetTargetDeps(target).data_deps().
+  base::span<const Target*> GetDataDeps(const Target* target) const {
+    return GetTargetDeps(target).data_deps();
+  }
+
+  // Return the public and private dependencies of a given target.
+  // Convenience shortcut for GetTargetDeps(target).linked_deps().
+  base::span<const Target*> GetLinkedDeps(const Target* target) const {
+    return GetTargetDeps(target).linked_deps();
+  }
+
+ private:
+  // The information associated with a given Target pointer.
+  struct TargetInfo {
+    TargetInfo() = default;
+
+    TargetInfo(const Target* target)
+        : target(target),
+          deps(target->public_deps(),
+               target->private_deps(),
+               target->data_deps()) {}
+
+    const Target* target = nullptr;
+    ResolvedTargetDeps deps;
+  };
+
+  // Retrieve TargetInfo value associated with |target|. Create
+  // a new empty instance on demand if none is already available.
+  TargetInfo* GetTargetInfo(const Target* target) const;
+
+  // A { Target* -> TargetInfo } map that will create entries
+  // on demand (hence the mutable qualifier). Implemented with a
+  // UniqueVector<> and a parallel vector of unique TargetInfo
+  // instances for best performance.
+  mutable UniqueVector<const Target*> targets_;
+  mutable std::vector<std::unique_ptr<TargetInfo>> infos_;
+};
+
+#endif  // TOOLS_GN_RESOLVED_TARGET_DATA_H_
diff --git a/src/gn/resolved_target_data_unittest.cc b/src/gn/resolved_target_data_unittest.cc
new file mode 100644
index 0000000..03cd28b
--- /dev/null
+++ b/src/gn/resolved_target_data_unittest.cc
@@ -0,0 +1,53 @@
+// Copyright 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gn/resolved_target_data.h"
+
+#include "gn/test_with_scope.h"
+#include "util/test/test.h"
+
+// Tests that lib[_dir]s are inherited across deps boundaries for static
+// libraries but not executables.
+TEST(ResolvedTargetDataTest, GetTargetDeps) {
+  TestWithScope setup;
+  Err err;
+
+  TestTarget a(setup, "//foo:a", Target::GROUP);
+  TestTarget b(setup, "//foo:b", Target::GROUP);
+  TestTarget c(setup, "//foo:c", Target::GROUP);
+  TestTarget d(setup, "//foo:d", Target::GROUP);
+  TestTarget e(setup, "//foo:e", Target::GROUP);
+
+  a.private_deps().push_back(LabelTargetPair(&b));
+  a.private_deps().push_back(LabelTargetPair(&c));
+  a.public_deps().push_back(LabelTargetPair(&d));
+  a.data_deps().push_back(LabelTargetPair(&e));
+
+  b.private_deps().push_back(LabelTargetPair(&e));
+
+  ASSERT_TRUE(e.OnResolved(&err));
+  ASSERT_TRUE(d.OnResolved(&err));
+  ASSERT_TRUE(c.OnResolved(&err));
+  ASSERT_TRUE(b.OnResolved(&err));
+  ASSERT_TRUE(a.OnResolved(&err));
+
+  ResolvedTargetData resolved;
+
+  const auto& a_deps = resolved.GetTargetDeps(&a);
+  EXPECT_EQ(a_deps.size(), 4u);
+  EXPECT_EQ(a_deps.private_deps().size(), 2u);
+  EXPECT_EQ(a_deps.private_deps()[0], &b);
+  EXPECT_EQ(a_deps.private_deps()[1], &c);
+  EXPECT_EQ(a_deps.public_deps().size(), 1u);
+  EXPECT_EQ(a_deps.public_deps()[0], &d);
+  EXPECT_EQ(a_deps.data_deps().size(), 1u);
+  EXPECT_EQ(a_deps.data_deps()[0], &e);
+
+  const auto& b_deps = resolved.GetTargetDeps(&b);
+  EXPECT_EQ(b_deps.size(), 1u);
+  EXPECT_EQ(b_deps.private_deps().size(), 1u);
+  EXPECT_EQ(b_deps.private_deps()[0], &e);
+  EXPECT_EQ(b_deps.public_deps().size(), 0u);
+  EXPECT_EQ(b_deps.data_deps().size(), 0u);
+}