@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/debug_utils-inl.h

@@ -0,0 +1,291 @@
+#ifndef SRC_DEBUG_UTILS_INL_H_
+#define SRC_DEBUG_UTILS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "debug_utils.h"
+#include "env.h"
+#include "util-inl.h"
+
+#include <type_traits>
+
+namespace node {
+
+template <typename T>
+concept StringViewConvertible = requires(T a) {
+                                  {
+                                    a.ToStringView()
+                                    } -> std::convertible_to<std::string_view>;
+                                };
+template <typename T>
+concept StringConvertible = requires(T a) {
+                              {
+                                a.ToString()
+                                } -> std::convertible_to<std::string>;
+                            };
+// For std::filesystem::path and similar types
+template <typename T>
+concept StringConvertibleFSPathLike = requires(T a) {
+                                        {
+                                          a.string()
+                                          } -> std::convertible_to<std::string>;
+                                      };
+
+struct ToStringHelper {
+  template <typename T>
+    requires(StringConvertible<T>) && (!StringViewConvertible<T>)
+  static std::string Convert(const T& value) {
+    return value.ToString();
+  }
+  template <typename T>
+    requires(StringConvertibleFSPathLike<T>) && (!StringViewConvertible<T>) &&
+            (!StringConvertible<T>)
+  static std::string Convert(const T& value) {
+    return value.string();
+  }
+  template <typename T>
+    requires StringViewConvertible<T>
+  static std::string_view Convert(const T& value) {
+    return value.ToStringView();
+  }
+
+  template <NumericOrEnum T>
+  static std::string Convert(const T& value) {
+    return std::to_string(value);
+  }
+  static std::string_view Convert(const char* value) {
+    return value != nullptr ? value : "(null)";
+  }
+  static std::string Convert(const std::string& value) { return value; }
+  static std::string_view Convert(std::string_view value) { return value; }
+  static std::string Convert(bool value) { return value ? "true" : "false"; }
+
+  static std::string Convert(v8::Local<v8::Value> value) {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    if (value->IsString()) {
+      Utf8Value utf8_value(isolate, value);
+      return SPrintF("\"%s\"", utf8_value.ToString());
+    }
+    v8::MaybeLocal<v8::String> maybe_detail =
+        value->ToDetailString(isolate->GetCurrentContext());
+    v8::Local<v8::String> detail;
+    if (!maybe_detail.ToLocal(&detail)) {
+      // This will only occur when terminating. No exception is expected
+      // with `ToDetailString`.
+      return "<Unable to stringify v8::Value>";
+    }
+    Utf8Value utf8_value(isolate, detail);
+    return utf8_value.ToString();
+  }
+
+  template <unsigned BASE_BITS, std::integral T>
+  static std::string BaseConvert(const T& value) {
+    auto v = static_cast<uint64_t>(value);
+    char ret[3 * sizeof(T)];
+    char* ptr = ret + 3 * sizeof(T) - 1;
+    *ptr = '\0';
+    const char* digits = "0123456789abcdef";
+    do {
+      unsigned digit = v & ((1 << BASE_BITS) - 1);
+      *--ptr = (BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
+    } while ((v >>= BASE_BITS) != 0);
+    return ptr;
+  }
+  template <unsigned BASE_BITS, typename T>
+    requires(!std::integral<T>)
+  static auto BaseConvert(T&& value) {
+    return Convert(std::forward<T>(value));
+  }
+};
+
+template <typename T>
+auto ToStringOrStringView(const T& value) {
+  return ToStringHelper::Convert(value);
+}
+
+template <typename T>
+std::string ToString(const T& value) {
+  return std::string(ToStringOrStringView(value));
+}
+
+template <unsigned BASE_BITS, typename T>
+auto ToBaseString(const T& value) {
+  return ToStringHelper::BaseConvert<BASE_BITS>(value);
+}
+
+inline std::string SPrintFImpl(std::string_view format) {
+  auto offset = format.find('%');
+  if (offset == std::string_view::npos) return std::string(format);
+  CHECK_LT(offset + 1, format.size());
+  CHECK_EQ(format[offset + 1],
+           '%');  // Only '%%' allowed when there are no arguments.
+
+  return std::string(format.substr(0, offset + 1)) +
+         SPrintFImpl(format.substr(offset + 2));
+}
+
+template <typename Arg, typename... Args>
+std::string COLD_NOINLINE SPrintFImpl(  // NOLINT(runtime/string)
+    std::string_view format,
+    Arg&& arg,
+    Args&&... args) {
+  auto offset = format.find('%');
+  CHECK_NE(offset, std::string_view::npos);  // If you hit this, you passed in
+                                             // too many arguments.
+  std::string ret(format.substr(0, offset));
+  // Ignore long / size_t modifiers
+  while (++offset < format.size() &&
+         (format[offset] == 'l' || format[offset] == 'z')) {
+  }
+  switch (offset == format.size() ? '\0' : format[offset]) {
+    case '%': {
+      return ret + '%' +
+             SPrintFImpl(format.substr(offset + 1),
+                         std::forward<Arg>(arg),
+                         std::forward<Args>(args)...);
+    }
+    default: {
+      return ret + '%' +
+             SPrintFImpl(format.substr(offset),
+                         std::forward<Arg>(arg),
+                         std::forward<Args>(args)...);
+    }
+    case 'd':
+    case 'i':
+    case 'u':
+    case 's':
+      ret += ToStringOrStringView(arg);
+      break;
+    case 'o':
+      ret += ToBaseString<3>(arg);
+      break;
+    case 'x':
+      ret += ToBaseString<4>(arg);
+      break;
+    case 'X':
+      ret += node::ToUpper(ToBaseString<4>(arg));
+      break;
+    case 'p': {
+      CHECK(std::is_pointer_v<typename std::remove_reference_t<Arg>>);
+      char out[20];
+      int n = snprintf(
+          out, sizeof(out), "%p", *reinterpret_cast<const void* const*>(&arg));
+      CHECK_GE(n, 0);
+      ret += out;
+      break;
+    }
+  }
+  return ret +
+         SPrintFImpl(format.substr(offset + 1), std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+std::string COLD_NOINLINE SPrintF(  // NOLINT(runtime/string)
+    std::string_view format,
+    Args&&... args) {
+  return SPrintFImpl(format, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void COLD_NOINLINE FPrintF(FILE* file,
+                           std::string_view format,
+                           Args&&... args) {
+  FWrite(file, SPrintF(format, std::forward<Args>(args)...));
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* format,
+                               Args&&... args) {
+  if (!list->enabled(cat)) [[unlikely]]
+    return;
+  FPrintF(stderr, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* message) {
+  if (!list->enabled(cat)) [[unlikely]]
+    return;
+  FPrintF(stderr, "%s", message);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE
+Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args) {
+  Debug(env->enabled_debug_list(), cat, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(Environment* env,
+                               DebugCategory cat,
+                               const char* message) {
+  Debug(env->enabled_debug_list(), cat, message);
+}
+
+template <typename... Args>
+inline void Debug(Environment* env,
+                  DebugCategory cat,
+                  const std::string& format,
+                  Args&&... args) {
+  Debug(env->enabled_debug_list(),
+        cat,
+        format.c_str(),
+        std::forward<Args>(args)...);
+}
+
+// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
+// the FORCE_INLINE flag on them doesn't apply to the contents of this function
+// as well.
+// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
+// this function for speed and it should rather focus on keeping it out of
+// hot code paths. In particular, we want to keep the string concatenating code
+// out of the function containing the original `Debug()` call.
+template <typename... Args>
+void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
+                                               const char* format,
+                                               Args&&... args) {
+  Debug(async_wrap->env(),
+        static_cast<DebugCategory>(async_wrap->provider_type()),
+        async_wrap->diagnostic_name() + " " + format + "\n",
+        std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const char* format,
+                               Args&&... args) {
+  DCHECK_NOT_NULL(async_wrap);
+  if (auto cat = static_cast<DebugCategory>(async_wrap->provider_type());
+      !async_wrap->env()->enabled_debug_list()->enabled(cat)) [[unlikely]] {
+    return;
+  }
+  UnconditionalAsyncWrapDebug(async_wrap, format, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const std::string& format,
+                               Args&&... args) {
+  Debug(async_wrap, format.c_str(), std::forward<Args>(args)...);
+}
+
+namespace per_process {
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(DebugCategory cat,
+                               const char* format,
+                               Args&&... args) {
+  Debug(&enabled_debug_list, cat, format, std::forward<Args>(args)...);
+}
+
+inline void FORCE_INLINE Debug(DebugCategory cat, const char* message) {
+  Debug(&enabled_debug_list, cat, message);
+}
+
+}  // namespace per_process
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DEBUG_UTILS_INL_H_

package/src/headers/26/debug_utils.h

@@ -0,0 +1,200 @@
+#ifndef SRC_DEBUG_UTILS_H_
+#define SRC_DEBUG_UTILS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+// Use FORCE_INLINE on functions that have a debug-category-enabled check first
+// and then ideally only a single function call following it, to maintain
+// performance for the common case (no debugging used).
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline))
+#define COLD_NOINLINE __attribute__((cold, noinline))
+#else
+#define FORCE_INLINE
+#define COLD_NOINLINE
+#endif
+
+namespace node {
+class Environment;
+
+template <typename T>
+inline std::string ToString(const T& value);
+template <typename T>
+inline auto ToStringOrStringView(const T& value);
+
+// C++-style variant of sprintf()/fprintf() that:
+// - Returns an std::string
+// - Handles \0 bytes correctly
+// - Supports %p and %s. %d, %i and %u are aliases for %s.
+// - Accepts any class that has a ToString() method for stringification.
+template <typename... Args>
+inline std::string SPrintF(std::string_view format, Args&&... args);
+template <typename... Args>
+inline void FPrintF(FILE* file, std::string_view format, Args&&... args);
+void NODE_EXTERN_PRIVATE FWrite(FILE* file, const std::string& str);
+
+// Listing the AsyncWrap provider types first enables us to cast directly
+// from a provider type to a debug category.
+#define DEBUG_CATEGORY_NAMES(V)                                                \
+  NODE_ASYNC_PROVIDER_TYPES(V)                                                 \
+  V(BOOTSTRAP)                                                                 \
+  V(CRYPTO)                                                                    \
+  V(COMPILE_CACHE)                                                             \
+  V(CONTEXTIFY)                                                                \
+  V(DIAGNOSTICS)                                                               \
+  V(HUGEPAGES)                                                                 \
+  V(INSPECTOR_SERVER)                                                          \
+  V(INSPECTOR_CLIENT)                                                          \
+  V(INSPECTOR_PROFILER)                                                        \
+  V(CODE_CACHE)                                                                \
+  V(NGTCP2)                                                                    \
+  V(NGHTTP3)                                                                   \
+  V(SEA)                                                                       \
+  V(WASI)                                                                      \
+  V(MODULE)                                                                    \
+  V(MKSNAPSHOT)                                                                \
+  V(SNAPSHOT_SERDES)                                                           \
+  V(PERFETTO)                                                                  \
+  V(PERMISSION_MODEL)                                                          \
+  V(PLATFORM_MINIMAL)                                                          \
+  V(PLATFORM_VERBOSE)                                                          \
+  V(QUIC)
+
+enum class DebugCategory : unsigned int {
+#define V(name) name,
+  DEBUG_CATEGORY_NAMES(V)
+#undef V
+};
+
+#define V(name) +1
+constexpr unsigned int kDebugCategoryCount = DEBUG_CATEGORY_NAMES(V);
+#undef V
+
+class NODE_EXTERN_PRIVATE EnabledDebugList {
+ public:
+  bool FORCE_INLINE enabled(DebugCategory category) const {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
+    return enabled_[static_cast<unsigned int>(category)];
+  }
+
+  // Uses NODE_DEBUG_NATIVE to initialize the categories. env->env_vars()
+  // is parsed if it is not a nullptr, otherwise the system environment
+  // variables are parsed.
+  void Parse(Environment* env);
+
+ private:
+  // Enable all categories matching cats.
+  void Parse(const std::string& cats);
+  void set_enabled(DebugCategory category) {
+    DCHECK_LT(static_cast<unsigned int>(category), kDebugCategoryCount);
+    enabled_[static_cast<int>(category)] = true;
+  }
+
+  bool enabled_[kDebugCategoryCount] = {false};
+};
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(EnabledDebugList* list,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void FORCE_INLINE
+Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args);
+
+inline void FORCE_INLINE Debug(Environment* env,
+                               DebugCategory cat,
+                               const char* message);
+
+template <typename... Args>
+inline void Debug(Environment* env,
+                  DebugCategory cat,
+                  const std::string& format,
+                  Args&&... args);
+
+// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
+// the FORCE_INLINE flag on them doesn't apply to the contents of this function
+// as well.
+// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
+// this function for speed and it should rather focus on keeping it out of
+// hot code paths. In particular, we want to keep the string concatenating code
+// out of the function containing the original `Debug()` call.
+template <typename... Args>
+void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
+                                               const char* format,
+                                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const char* format,
+                               Args&&... args);
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
+                               const std::string& format,
+                               Args&&... args);
+
+// Debug helper for inspecting the currently running `node` executable.
+class NativeSymbolDebuggingContext {
+ public:
+  static std::unique_ptr<NativeSymbolDebuggingContext> New();
+
+  class SymbolInfo {
+   public:
+    std::string name;
+    std::string filename;
+    size_t line = 0;
+    size_t dis = 0;
+
+    std::string Display() const;
+  };
+
+  NativeSymbolDebuggingContext() = default;
+  virtual ~NativeSymbolDebuggingContext() = default;
+
+  virtual SymbolInfo LookupSymbol(void* address) { return {}; }
+  virtual bool IsMapped(void* address) { return false; }
+  virtual int GetStackTrace(void** frames, int count) { return 0; }
+
+  NativeSymbolDebuggingContext(const NativeSymbolDebuggingContext&) = delete;
+  NativeSymbolDebuggingContext(NativeSymbolDebuggingContext&&) = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&)
+    = delete;
+  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&&)
+    = delete;
+  static std::vector<std::string> GetLoadedLibraries();
+};
+
+// Variant of `uv_loop_close` that tries to be as helpful as possible
+// about giving information on currently existing handles, if there are any,
+// but still aborts the process.
+void CheckedUvLoopClose(uv_loop_t* loop);
+void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream);
+
+namespace per_process {
+extern NODE_EXTERN_PRIVATE EnabledDebugList enabled_debug_list;
+
+template <typename... Args>
+inline void FORCE_INLINE Debug(DebugCategory cat,
+                               const char* format,
+                               Args&&... args);
+
+inline void FORCE_INLINE Debug(DebugCategory cat, const char* message);
+}  // namespace per_process
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DEBUG_UTILS_H_

package/src/headers/26/diagnosticfilename-inl.h

@@ -0,0 +1,33 @@
+#ifndef SRC_DIAGNOSTICFILENAME_INL_H_
+#define SRC_DIAGNOSTICFILENAME_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+namespace node {
+
+class Environment;
+
+inline DiagnosticFilename::DiagnosticFilename(
+    Environment* env,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(env->thread_id(), prefix, ext)) {
+}
+
+inline DiagnosticFilename::DiagnosticFilename(
+    uint64_t thread_id,
+    const char* prefix,
+    const char* ext) :
+  filename_(MakeFilename(thread_id, prefix, ext)) {
+}
+
+inline const char* DiagnosticFilename::operator*() const {
+  return filename_.c_str();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_DIAGNOSTICFILENAME_INL_H_

package/src/headers/26/embedded_data.h

@@ -0,0 +1,17 @@
+#ifndef SRC_EMBEDDED_DATA_H_
+#define SRC_EMBEDDED_DATA_H_
+
+#include <cinttypes>
+#include <string>
+
+// This file must not depend on node.h or other code that depends on
+// the full Node.js implementation because it is used during the
+// compilation of the Node.js implementation itself (especially js2c).
+
+namespace node {
+
+const std::string& GetOctalCode(uint8_t index);
+
+}  // namespace node
+
+#endif  // SRC_EMBEDDED_DATA_H_

package/src/headers/26/encoding_binding.h

@@ -0,0 +1,59 @@
+#ifndef SRC_ENCODING_BINDING_H_
+#define SRC_ENCODING_BINDING_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "aliased_buffer.h"
+#include "node_snapshotable.h"
+#include "v8-fast-api-calls.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace encoding_binding {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex encode_into_results_buffer;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(encoding_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void EncodeInto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EncodeUtf8String(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DecodeUTF8(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void ToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kEncodeIntoResultsLength = 2;
+  AliasedUint32Array encode_into_results_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+}  // namespace encoding_binding
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ENCODING_BINDING_H_