Add a check whether or not a str is utf8 prior to emplacing

[lanza]

Summary

Highlighing junk data on VSCode can send a query for evaluate which
fails. In particular cases on Windows, this the error message can end
up as a c-string of [-35,-35,-35,-35,...]. Attempting to emplace this
as the error message causes an assert failure.

Prior to emplacing the error message, confirm that it is valid UTF8 to
eliminate errors such as mentione above.

[clayborg]

So any string in the debugger can contain invalid UTF8. This can easily happen for C string summaries or char array summaries from lldb::SBValue objects when a variable isn't yet initialized. It would rather us sanitize any strings that can contain invalid UTF8 and just change any invalid UTF8 sequences into either "\\xXX" where XX is the byte. Notice the extra backslash then the string would show up as \xXX when it gets displayed. Or we can use \uXXXX (notice just a single backslash) which would send the character over as is, just not as invalid UTF8. Best option would be to convert valid UTF8 sequences over to use \uXXXX format (single backslash to correctly encode the character as unicode), and invalid UTF8 sequences to send each invalid byte as \\xXX (double backslash to just display the non printable character correctly. One vote for using the first \\xXX format is it will display correctly in a variable view. If we encode invalid UTF8 sequences over as the actual characters themselves, then the GUI might show something unexpected, or have issues displaying the invalid UTF8.

I would vote to fix this in LLVM's JSON parser when it is encoding any string value. If we can't do this, then we need to make a function that sanitizes any string values and always use that to encode a string correctly.

[lanza]

You're certainly right. But the goal I'm working on now is simply to get lldb-vscode running on Windows. I'll take note of this task to fix it into the future.

[lanza]

Okay, so after looking into this it turns out that llvm::json does handle this well:

Value(std::string V) : Type(T_String) {
  if (LLVM_UNLIKELY(!isUTF8(V))) {
    assert(false && "Invalid UTF-8 in value used as JSON");
    V = fixUTF8(std::move(V));
  }
  create<std::string>(std::move(V));
}

it asserts that the string is valid utf8 but will attempt to fix it if noassert is enabled. So we should just call fixUTF8(thestring) within lldb-vscode at the necessary points where we can end up with non-utf8.

[lanza]

fix if possible

[clayborg]

So we need to do this everywhere for any string value that gets put into an object. Otherwise we are just waiting for a crash from any string value. Values of variables, summaries from variables, so many other places where we get the string value from the API in LLDB can fail. I am fine with just making a static helper function that does this for us:

void emplace_safe_string(llvm::json::Object &obj, llvm::StringRef key, llvm::StringRef str) {
  if (llvm::json::isUTF8(str))
    obj.try_emplace(key, str.str());
  else
    obj.try_emplace(key, llvm::json::fixUTF8(str));
}

Then we need to find all places where the string value is coming from an API, and use this function.

[lanza]

add more fixes

[clayborg]

Just reverse if statement as noted in inlined comments and this is good to go.

tools/lldb-vscode/JSONUtils.cpp

28–31

Reverse the if for clarity:

if (LLVM_LIKELY(llvm::json::isUTF8(str)))
    obj.try_emplace(key, str.str());
  else
    obj.try_emplace(key, llvm::json::fixUTF8(str));
}

[lanza]

👍🏼

tools/lldb-vscode/JSONUtils.h

 #define LLDBVSCODE_JSONUTILS_H_
 
 #include <stdint.h>
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.h"
 #include "VSCodeForward.h"
 
 namespace lldb_vscode {
-  
 //------------------------------------------------------------------
+/// Emplace a StringRef in a json::Object after enusring that the
+/// string is valid UTF8. If not, first call llvm::json::fixUTF8
+/// before emplacing.
+///
+/// @param[in] obj
+///     A JSON object that we will attempt to emplace the value in
+///
+/// @param[in] key
+///     The key to use when emplacing the value
+///
+/// @param[in] str
+///     The string to emplace
+//------------------------------------------------------------------
+void EmplaceSafeString(llvm::json::Object &obj, llvm::StringRef key,
+                       llvm::StringRef str);
+
+//------------------------------------------------------------------
 /// Extract simple values as a string.
 ///
 /// @param[in] value
 ///     A JSON value to extract the string from.
 ///
 /// @return
 ///     A llvm::StringRef that contains the string value, or an empty
 ///     string if \a value isn't a string.

tools/lldb-vscode/JSONUtils.cpp

 
 #include "ExceptionBreakpoint.h"
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "VSCode.h"
 
 namespace lldb_vscode {
 
+void EmplaceSafeString(llvm::json::Object &obj, llvm::StringRef key,
+                       llvm::StringRef str) {
+  if (LLVM_LIKELY(llvm::json::isUTF8(str)))
+    obj.try_emplace(key, str.str());
+  else
+    obj.try_emplace(key, llvm::json::fixUTF8(str));
+}
+
 llvm::StringRef GetAsString(const llvm::json::Value &value) {
   if (auto s = value.getAsString())
     return *s;
   return llvm::StringRef();
 }
 
 // Gets a string from a JSON object using the key, or returns an empty string.
 llvm::StringRef GetString(const llvm::json::Object &obj, llvm::StringRef key) {
case llvm::json::Value::Array:
       break;
     }
   }
   return strs;
 }
 
 void SetValueForKey(lldb::SBValue &v, llvm::json::Object &object,
                     llvm::StringRef key) {
-  
   llvm::StringRef value = v.GetValue();
   llvm::StringRef summary = v.GetSummary();
   llvm::StringRef type_name = v.GetType().GetDisplayTypeName();
-  
   std::string result;
   llvm::raw_string_ostream strm(result);
   if (!value.empty()) {
     strm << value;
     if (!summary.empty())
       strm << ' ' << summary;
   } else if (!summary.empty()) {
     strm << ' ' << summary;
   } else if (!type_name.empty()) {
     strm << type_name;
     lldb::addr_t address = v.GetLoadAddress();
     if (address != LLDB_INVALID_ADDRESS)
       strm << " @ " << llvm::format_hex(address, 0);
   }
   strm.flush();
-  object.try_emplace(key, result);
+  EmplaceSafeString(object, key, result);
 }
 
 void FillResponse(const llvm::json::Object &request,
                   llvm::json::Object &response) {
   // Fill in all of the needed response fields to a "request" and set "success"
   // to true by default.
   response.try_emplace("type", "response");
   response.try_emplace("seq", (int64_t)0);
-  response.try_emplace("command", GetString(request, "command"));
+  EmplaceSafeString(response, "command", GetString(request, "command"));
   const int64_t seq = GetSigned(request, "seq", 0);
   response.try_emplace("request_seq", seq);
   response.try_emplace("success", true);
 }
 
 //----------------------------------------------------------------------
 // "Scope": {
 //   "type": "object",

 //   },
 //   "required": [ "name", "variablesReference", "expensive" ]
 // }
 //----------------------------------------------------------------------
 llvm::json::Value CreateScope(const llvm::StringRef name,
                               int64_t variablesReference,
                               int64_t namedVariables, bool expensive) {
   llvm::json::Object object;
-  object.try_emplace("name", name.str());
+  EmplaceSafeString(object, "name", name.str());
   object.try_emplace("variablesReference", variablesReference);
   object.try_emplace("expensive", expensive);
   object.try_emplace("namedVariables", namedVariables);
   return llvm::json::Value(std::move(object));
 }
 
 //----------------------------------------------------------------------
 // "Breakpoint": {

 //   },
 //   "required": [ "seq", "type" ]
 // }
 //----------------------------------------------------------------------
 llvm::json::Object CreateEventObject(const llvm::StringRef event_name) {
   llvm::json::Object event;
   event.try_emplace("seq", 0);
   event.try_emplace("type", "event");
-  event.try_emplace("event", event_name);
+  EmplaceSafeString(event, "event", event_name);
   return event;
 }
 
 //----------------------------------------------------------------------
 // "ExceptionBreakpointsFilter": {
 //   "type": "object",
 //   "description": "An ExceptionBreakpointsFilter is shown in the UI as an
 //                   option for configuring how exceptions are dealt with.",

 //     }
 //   },
 //   "required": [ "filter", "label" ]
 // }
 //----------------------------------------------------------------------
 llvm::json::Value
 CreateExceptionBreakpointFilter(const ExceptionBreakpoint &bp) {
   llvm::json::Object object;
-  object.try_emplace("filter", bp.filter);
-  object.try_emplace("label", bp.label);
+  EmplaceSafeString(object, "filter", bp.filter);
+  EmplaceSafeString(object, "label", bp.label);
   object.try_emplace("default", bp.default_value);
   return llvm::json::Value(std::move(object));
 }
 
 //----------------------------------------------------------------------
 // "Source": {
 //   "type": "object",
 //   "description": "A Source is a descriptor for source code. It is returned

 // }
 //----------------------------------------------------------------------
 llvm::json::Value CreateSource(lldb::SBLineEntry &line_entry) {
   llvm::json::Object object;
   lldb::SBFileSpec file = line_entry.GetFileSpec();
   if (file.IsValid()) {
     const char *name = file.GetFilename();
     if (name)
-      object.try_emplace("name", name);
+      EmplaceSafeString(object, "name", name);
     char path[PATH_MAX] = "";
     file.GetPath(path, sizeof(path));
     if (path[0]) {
-      object.try_emplace("path", std::string(path));
+      EmplaceSafeString(object, "path", std::string(path));
     }
   }
   return llvm::json::Value(std::move(object));
 }
 
 llvm::json::Value CreateSource(lldb::SBFrame &frame, int64_t &disasm_line) {
   disasm_line = 0;
   auto line_entry = frame.GetLineEntry();
if (symbol.IsValid()) {
         disasm_line = g_vsc.GetLineForPC(addr_srcref->second, pc);
       } else {
         insts = symbol.GetInstructions(g_vsc.target);
       }
     }
   }
   const auto num_insts = insts.GetSize();
   if (low_pc != LLDB_INVALID_ADDRESS && num_insts > 0) {
-    object.try_emplace("name", frame.GetFunctionName());
+    EmplaceSafeString(object, "name", frame.GetFunctionName());
     SourceReference source;
     llvm::raw_string_ostream src_strm(source.content);
     std::string line;
     for (size_t i = 0; i < num_insts; ++i) {
       lldb::SBInstruction inst = insts.GetInstructionAtIndex(i);
       const auto inst_addr = inst.GetAddress().GetLoadAddress(g_vsc.target);
       const char *m = inst.GetMnemonic(g_vsc.target);
       const char *o = inst.GetOperands(g_vsc.target);
       const char *c = inst.GetComment(g_vsc.target);
       if (pc == inst_addr)
         disasm_line = i + 1;
       const auto inst_offset = inst_addr - low_pc;
       int spaces = 0;
       if (inst_offset < 10)
         spaces = 3;
       else if (inst_offset < 100)
         spaces = 2;
       else if (inst_offset < 1000)
         spaces = 1;
       line.clear();
       llvm::raw_string_ostream line_strm(line);
       line_strm << llvm::formatv("{0:X+}: <{1}> {2} {3,12} {4}", inst_addr,
-                                 inst_offset, llvm::fmt_repeat(' ', spaces),
-                                 m, o);
+                                 inst_offset, llvm::fmt_repeat(' ', spaces), m,
+                                 o);
 
       // If there is a comment append it starting at column 60 or after one
       // space past the last char
       const uint32_t comment_row = std::max(line_strm.str().size(), (size_t)60);
       if (c && c[0]) {
         if (line.size() < comment_row)
           line_strm.indent(comment_row - line_strm.str().size());
         line_strm << " # " << c;

 //   },
 //   "required": [ "id", "name", "line", "column" ]
 // }
 //----------------------------------------------------------------------
 llvm::json::Value CreateStackFrame(lldb::SBFrame &frame) {
   llvm::json::Object object;
   int64_t frame_id = MakeVSCodeFrameID(frame);
   object.try_emplace("id", frame_id);
-  object.try_emplace("name", frame.GetFunctionName());
+  EmplaceSafeString(object, "name", frame.GetFunctionName());
   int64_t disasm_line = 0;
   object.try_emplace("source", CreateSource(frame, disasm_line));
 
   auto line_entry = frame.GetLineEntry();
   if (disasm_line > 0) {
     object.try_emplace("line", disasm_line);
   } else {
     auto line = line_entry.GetLine();
llvm::json::Value CreateThread(lldb::SBThread &thread) {
   object.try_emplace("id", (int64_t)thread.GetThreadID());
   char thread_str[64];
   snprintf(thread_str, sizeof(thread_str), "Thread #%u", thread.GetIndexID());
   const char *name = thread.GetName();
   if (name) {
     std::string thread_with_name(thread_str);
     thread_with_name += ' ';
     thread_with_name += name;
-    object.try_emplace("name", thread_with_name);
+    EmplaceSafeString(object, "name", thread_with_name);
   } else {
-    object.try_emplace("name", std::string(thread_str));
+    EmplaceSafeString(object, "name", std::string(thread_str));
   }
   return llvm::json::Value(std::move(object));
 }
 
 //----------------------------------------------------------------------
 // "StoppedEvent": {
 //   "allOf": [ { "$ref": "#/definitions/Event" }, {
 //     "type": "object",
llvm::json::Value CreateThreadStopped(lldb::SBThread &thread,
   case lldb::eStopReasonTrace:
   case lldb::eStopReasonPlanComplete:
     body.try_emplace("reason", "step");
     break;
   case lldb::eStopReasonBreakpoint: {
     ExceptionBreakpoint *exc_bp = g_vsc.GetExceptionBPFromStopReason(thread);
     if (exc_bp) {
       body.try_emplace("reason", "exception");
-      body.try_emplace("description", exc_bp->label);
+      EmplaceSafeString(body, "description", exc_bp->label);
     } else {
       body.try_emplace("reason", "breakpoint");
     }
   } break;
   case lldb::eStopReasonWatchpoint:
   case lldb::eStopReasonInstrumentation:
     body.try_emplace("reason", "breakpoint");
     break;
llvm::json::Value CreateThreadStopped(lldb::SBThread &thread,
   const lldb::tid_t tid = thread.GetThreadID();
   body.try_emplace("threadId", (int64_t)tid);
   // If no description has been set, then set it to the default thread stopped
   // description. If we have breakpoints that get hit and shouldn't be reported
   // as breakpoints, then they will set the description above.
   if (ObjectContainsKey(body, "description")) {
     char description[1024];
     if (thread.GetStopDescription(description, sizeof(description))) {
-      body.try_emplace("description", std::string(description));
+      EmplaceSafeString(body, "description", std::string(description));
     }
   }
   if (tid == g_vsc.focus_tid) {
     body.try_emplace("threadCausedFocus", true);
   }
   body.try_emplace("preserveFocusHint", tid != g_vsc.focus_tid);
   body.try_emplace("allThreadsStopped", true);
   event.try_emplace("body", std::move(body));

 //   },
 //   "required": [ "name", "value", "variablesReference" ]
 // }
 //----------------------------------------------------------------------
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex) {
   llvm::json::Object object;
   auto name = v.GetName();
-  object.try_emplace("name", name ? name : "<null>");
+  EmplaceSafeString(object, "name", name ? name : "<null>");
   if (format_hex)
     v.SetFormat(lldb::eFormatHex);
   SetValueForKey(v, object, "value");
   auto type_cstr = v.GetType().GetDisplayTypeName();
-  object.try_emplace("type", type_cstr ? type_cstr : NO_TYPENAME);
+  EmplaceSafeString(object, "type", type_cstr ? type_cstr : NO_TYPENAME);
   if (varID != INT64_MAX)
     object.try_emplace("id", varID);
   if (v.MightHaveChildren())
     object.try_emplace("variablesReference", variablesReference);
   else
     object.try_emplace("variablesReference", (int64_t)0);
   lldb::SBStream evaluateStream;
   v.GetExpressionPath(evaluateStream);
   const char *evaluateName = evaluateStream.GetData();
   if (evaluateName && evaluateName[0])
-    object.try_emplace("evaluateName", std::string(evaluateName));
+    EmplaceSafeString(object, "evaluateName", std::string(evaluateName));
   return llvm::json::Value(std::move(object));
 }
 
 } // namespace lldb_vscode
 

tools/lldb-vscode/VSCode.cpp

void VSCode::SendOutput(OutputType o, const llvm::StringRef output) {
   case OutputType::Stderr:
     category = "stderr";
     break;
   case OutputType::Telemetry:
     category = "telemetry";
     break;
   }
   body.try_emplace("category", category);
-  body.try_emplace("output", output.str());
+  EmplaceSafeString(body, "output", output.str());
   event.try_emplace("body", std::move(body));
   SendJSON(llvm::json::Value(std::move(event)));
 }
 
 void __attribute__((format(printf, 3, 4)))
 VSCode::SendFormattedOutput(OutputType o, const char *format, ...) {
   char buffer[1024];
   va_list args;

tools/lldb-vscode/lldb-vscode.cpp

 // }
 //----------------------------------------------------------------------
 void SendProcessEvent(LaunchMethod launch_method) {
   lldb::SBFileSpec exe_fspec = g_vsc.target.GetExecutable();
   char exe_path[PATH_MAX];
   exe_fspec.GetPath(exe_path, sizeof(exe_path));
   llvm::json::Object event(CreateEventObject("process"));
   llvm::json::Object body;
-  body.try_emplace("name", std::string(exe_path));
+  EmplaceSafeString(body, "name", std::string(exe_path));
   const auto pid = g_vsc.target.GetProcess().GetProcessID();
   body.try_emplace("systemProcessId", (int64_t)pid);
   body.try_emplace("isLocalProcess", true);
   const char *startMethod = nullptr;
   switch (launch_method) {
   case Launch:
     startMethod = "launch";
     break;
g_vsc.launch_info.SetExecutableFile(program_fspec,
                                         false /*add_as_first_arg*/);
     const char *target_triple = nullptr;
     const char *uuid_cstr = nullptr;
     // Stand alone debug info file if different from executable
     const char *symfile = nullptr;
     g_vsc.target.AddModule(program.data(), target_triple, uuid_cstr, symfile);
     if (error.Fail()) {
       response.try_emplace("success", false);
-      response.try_emplace("message", std::string(error.GetCString()));
+      EmplaceSafeString(response, "message", std::string(error.GetCString()));
       g_vsc.SendJSON(llvm::json::Value(std::move(response)));
       return;
     }
   }
 
   const bool detatchOnError = GetBoolean(arguments, "detachOnError", false);
   g_vsc.launch_info.SetDetachOnError(detatchOnError);
 
if (attached_pid == LLDB_INVALID_PROCESS_ID) {
         error.SetErrorString("failed to attach to a process");
       else
         error.SetErrorString("attachCommands failed to attach to a process");
     }
   }
 
   if (error.Fail()) {
     response.try_emplace("success", false);
-    response.try_emplace("message", std::string(error.GetCString()));
+    EmplaceSafeString(response, "message", std::string(error.GetCString()));
   }
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
   if (error.Success()) {
     SendProcessEvent(Attach);
     g_vsc.SendJSON(CreateEventObject("initialized"));
     // SendThreadStoppedEvent();
   }
 }
void request_exceptionInfo(const llvm::json::Object &request) {
   lldb::SBThread thread = g_vsc.GetLLDBThread(*arguments);
   if (thread.IsValid()) {
     auto stopReason = thread.GetStopReason();
     if (stopReason == lldb::eStopReasonSignal)
       body.try_emplace("exceptionId", "signal");
     else if (stopReason == lldb::eStopReasonBreakpoint) {
       ExceptionBreakpoint *exc_bp = g_vsc.GetExceptionBPFromStopReason(thread);
       if (exc_bp) {
-        body.try_emplace("exceptionId", exc_bp->filter);
-        body.try_emplace("description", exc_bp->label);
+        EmplaceSafeString(body, "exceptionId", exc_bp->filter);
+        EmplaceSafeString(body, "description", exc_bp->label);
       } else {
         body.try_emplace("exceptionId", "exception");
       }
     } else {
       body.try_emplace("exceptionId", "exception");
     }
     if (!ObjectContainsKey(body, "description")) {
       char description[1024];
       if (thread.GetStopDescription(description, sizeof(description))) {
-        body.try_emplace("description", std::string(description));
+        EmplaceSafeString(body, "description", std::string(description));
       }
     }
     body.try_emplace("breakMode", "always");
     // auto excInfoCount = thread.GetStopReasonDataCount();
     // for (auto i=0; i<excInfoCount; ++i) {
     //   uint64_t exc_data = thread.GetStopReasonDataAtIndex(i);
     // }
   } else {
void request_evaluate(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Object body;
   auto arguments = request.getObject("arguments");
   lldb::SBFrame frame = g_vsc.GetLLDBFrame(*arguments);
   const auto expression = GetString(arguments, "expression");
 
   if (!expression.empty() && expression[0] == '`') {
-    body.try_emplace("result",
-                     RunLLDBCommands(llvm::StringRef(),
-                                     {expression.substr(1)}));
+    auto result = RunLLDBCommands(llvm::StringRef(),
+                                     {expression.substr(1)});
+    EmplaceSafeString(body, "result", result);
     body.try_emplace("variablesReference", (int64_t)0);
   } else {
     // Always try to get the answer from the local variables if possible. If
     // this fails, then actually evaluate an expression using the expression
     // parser. "frame variable" is more reliable than the expression parser in
     // many cases and it is faster.
     lldb::SBValue value = frame.GetValueForVariablePath(
         expression.data(), lldb::eDynamicDontRunTarget);
     if (value.GetError().Fail())
       value = frame.EvaluateExpression(expression.data());
     if (value.GetError().Fail()) {
       response.try_emplace("success", false);
       const char *error_cstr = value.GetError().GetCString();
       if (error_cstr && error_cstr[0])
-        response.try_emplace("message", std::string(error_cstr));
+        EmplaceSafeString(response, "message", std::string(error_cstr));
       else
-        response.try_emplace("message", "evaluate failed");
+        EmplaceSafeString(response, "message", "evaluate failed");
     } else {
       SetValueForKey(value, body, "result");
       auto value_typename = value.GetType().GetDisplayTypeName();
-      body.try_emplace("type", value_typename ? value_typename : NO_TYPENAME);
+      EmplaceSafeString(body, "type", value_typename ? value_typename : NO_TYPENAME);
       if (value.MightHaveChildren()) {
         auto variablesReference = VARIDX_TO_VARREF(g_vsc.variables.GetSize());
         g_vsc.variables.Append(value);
         body.try_emplace("variablesReference", variablesReference);
       } else {
         body.try_emplace("variablesReference", (int64_t)0);
       }
     }
g_vsc.launch_info.SetExecutableFile(program_fspec,
                                         true /*add_as_first_arg*/);
     const char *target_triple = nullptr;
     const char *uuid_cstr = nullptr;
     // Stand alone debug info file if different from executable
     const char *symfile = nullptr;
     g_vsc.target.AddModule(program.data(), target_triple, uuid_cstr, symfile);
     if (error.Fail()) {
       response.try_emplace("success", false);
-      response.try_emplace("message", std::string(error.GetCString()));
+      EmplaceSafeString(response, "message", std::string(error.GetCString()));
       g_vsc.SendJSON(llvm::json::Value(std::move(response)));
     }
   }
 
   // Extract any extra arguments and append them to our program arguments for
   // when we launch
   auto args = GetStrings(arguments, "args");
   if (!args.empty())
void request_launch(const llvm::json::Object &request) {
   g_vsc.RunPreRunCommands();
 
   // Disable async events so the launch will be successful when we return from
   // the launch call and the launch will happen synchronously
   g_vsc.debugger.SetAsync(false);
   g_vsc.target.Launch(g_vsc.launch_info, error);
   if (error.Fail()) {
     response.try_emplace("success", false);
-    response.try_emplace("message", std::string(error.GetCString()));
+    EmplaceSafeString(response, "message", std::string(error.GetCString()));
   }
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 
   SendProcessEvent(Launch);
   g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));
   // Reenable async events and start the event thread to catch async events.
   g_vsc.debugger.SetAsync(true);
 }
void request_source(const llvm::json::Object &request) {
   FillResponse(request, response);
   llvm::json::Object body;
 
   auto arguments = request.getObject("arguments");
   auto source = arguments->getObject("source");
   auto sourceReference = GetSigned(source, "sourceReference", -1);
   auto pos = g_vsc.source_map.find((lldb::addr_t)sourceReference);
   if (pos != g_vsc.source_map.end()) {
-    body.try_emplace("content", pos->second.content);
+    EmplaceSafeString(body, "content", pos->second.content);
   } else {
     response.try_emplace("success", false);
   }
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 //----------------------------------------------------------------------
if (id_value != UINT64_MAX) {
     }
   }
 
   if (variable.IsValid()) {
     lldb::SBError error;
     bool success = variable.SetValueFromCString(value.data(), error);
     if (success) {
       SetValueForKey(variable, body, "value");
-      body.try_emplace("type", variable.GetType().GetDisplayTypeName());
+      EmplaceSafeString(body, "type", variable.GetType().GetDisplayTypeName());
       body.try_emplace("variablesReference", newVariablesReference);
     } else {
-      body.try_emplace("message", std::string(error.GetCString()));
+      EmplaceSafeString(body, "message", std::string(error.GetCString()));
     }
     response.try_emplace("success", success);
   }
 
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }