Add context to error messages for better debugging

- Add function name prefixes to all CobhanBuffer error messages
- Add 2GB limit clarification to size-related error messages
- Fix set_data_len_bytes message to say "maximum data size" (was "allocation size")
- Replace napi_throw_error with NapiUtils::ThrowException in ToString() for
  consistent error handling via C++ exceptions instead of pending JS exceptions

Author: jgowdy

src/cobhan_buffer.h

@@ -1,19 +1,19 @@
 #ifndef COBHAN_BUFFER_H
 #define COBHAN_BUFFER_H
 
+#include "hints.h"   // for unlikely
 #include <cstdint>   // for int32_t
 #include <cstring>   // for std::memcpy
 #include <iostream>  // for std::terminate
 #include <limits>    // for std::numeric_limits
 #include <sstream>   // for std::ostringstream
 #include <stdexcept> // for std::runtime_error, std::invalid_argument
 #include <string>    // for std::string
-#include "hints.h"   // for unlikely
 
 #ifdef _WIN32
 #include <windows.h> // for SecureZeroMemory
 #else
-#include <string.h>  // for explicit_bzero
+#include <string.h> // for explicit_bzero
 #endif
 
 class CobhanBuffer {
@@ -22,8 +22,8 @@ class CobhanBuffer {
   // data_len_bytes of data
   explicit CobhanBuffer(size_t data_len_bytes) {
     if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument(
-          "Requested data length exceeds maximum allowable size");
+      throw std::invalid_argument("CobhanBuffer(size_t): Requested data length "
+                                  "exceeds maximum allowable size (2GB limit)");
     }
     allocation_size = DataSizeToAllocationSize(data_len_bytes);
     cbuffer = new char[allocation_size];
@@ -37,7 +37,8 @@ class CobhanBuffer {
       : cbuffer(cbuffer), allocation_size(allocation_size), ownership(false) {
     if (allocation_size > max_int32_size) {
       throw std::invalid_argument(
-          "Allocation size exceeds maximum allowable size");
+          "CobhanBuffer(char*, size_t): Allocation size exceeds maximum "
+          "allowable size (2GB limit)");
     }
     initialize();
   }
@@ -75,7 +76,8 @@ class CobhanBuffer {
       // Fallback - volatile to prevent optimization
       volatile char *p = data_ptr;
       size_t len = get_data_len_bytes();
-      while (len--) *p++ = 0;
+      while (len--)
+        *p++ = 0;
 #endif
     }
   }
@@ -114,23 +116,26 @@ class CobhanBuffer {
         + safety_padding_bytes; // Add safety padding if configured
     if (allocation > max_int32_size) {
       throw std::invalid_argument(
-          "Calculated allocation size exceeds maximum allowable size");
+          "CobhanBuffer::DataSizeToAllocationSize: Calculated allocation size "
+          "exceeds maximum allowable size (2GB limit)");
     }
     return allocation;
   }
 
   static size_t AllocationSizeToMaxDataSize(size_t allocation_len_bytes) {
     // Check for buffer underflow with unlikely hint
-    constexpr size_t min_size = cobhan_header_size_bytes + canary_size_bytes + safety_padding_bytes;
+    constexpr size_t min_size =
+        cobhan_header_size_bytes + canary_size_bytes + safety_padding_bytes;
     if (unlikely(allocation_len_bytes < min_size)) {
       throw std::invalid_argument("Buffer allocation size too small");
     }
-    
+
     size_t data_len_bytes = allocation_len_bytes - cobhan_header_size_bytes -
                             canary_size_bytes - safety_padding_bytes;
     if (data_len_bytes > max_int32_size) {
       throw std::invalid_argument(
-          "Calculated data size exceeds maximum allowable size");
+          "CobhanBuffer::AllocationSizeToMaxDataSize: Calculated data size "
+          "exceeds maximum allowable size (2GB limit)");
     }
     return data_len_bytes;
   }
@@ -171,11 +176,13 @@ class CobhanBuffer {
   void set_data_len_bytes(size_t data_len_bytes) {
     if (data_len_bytes > max_int32_size) {
       throw std::invalid_argument(
-          "Requested data length exceeds maximum allowable size");
+          "CobhanBuffer::set_data_len_bytes: Requested data length exceeds "
+          "maximum allowable size (2GB limit)");
     }
     if (data_len_bytes > max_data_size) {
       throw std::invalid_argument(
-          "Requested data length exceeds allocation size");
+          "CobhanBuffer::set_data_len_bytes: Requested data length exceeds "
+          "buffer maximum data size");
     }
     *data_len_ptr = static_cast<int32_t>(data_len_bytes);
   }
@@ -204,7 +211,8 @@ class CobhanBuffer {
     }
 
     if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument("Data length exceeds maximum allowable size");
+      throw std::invalid_argument("CobhanBuffer::initialize: Data length "
+                                  "exceeds maximum allowable size (2GB limit)");
     }
 
     // Write Cobhan header values
@@ -249,7 +257,8 @@ class CobhanBuffer {
       allocation_size = other.allocation_size;
       if (allocation_size > max_int32_size) {
         throw std::invalid_argument(
-            "Allocation size exceeds maximum allowable size");
+            "CobhanBuffer::moveFrom: Allocation size exceeds maximum allowable "
+            "size (2GB limit)");
       }
 
       cbuffer = new char[allocation_size];

src/cobhan_buffer_napi.h

@@ -103,9 +103,8 @@ class CobhanBufferNapi : public CobhanBuffer {
         env, get_data_ptr(), get_data_len_bytes(), &napiStr);
 
     if (status != napi_ok) {
-      napi_throw_error(env, nullptr,
-                       "Failed to create Napi::String from CobhanBuffer");
-      return {};
+      NapiUtils::ThrowException(env, "CobhanBufferNapi::ToString: Failed to "
+                                     "create Napi::String from CobhanBuffer");
     }
 
     return {env, napiStr};
@@ -198,11 +197,11 @@ class CobhanBufferNapi : public CobhanBuffer {
 class SensitiveCobhanBufferNapi : public CobhanBufferNapi {
 public:
   using CobhanBufferNapi::CobhanBufferNapi; // Inherit all constructors
-  
+
   // Move constructor - needed for async workers
   SensitiveCobhanBufferNapi(SensitiveCobhanBufferNapi &&other) noexcept
       : CobhanBufferNapi(std::move(other)) {}
-  
+
   // Also allow moving from base class (for async worker initialization)
   SensitiveCobhanBufferNapi(CobhanBufferNapi &&other) noexcept
       : CobhanBufferNapi(std::move(other)) {}