Revert "[lldb] Support custom LLVM formatting for variables (#81196)"

This reverts commit 7a8d15e.

Author: kastiglione

lldb/docs/use/variable.rst

@@ -460,15 +460,6 @@ summary strings, regardless of the format they have applied to their types. To
 do that, you can use %format inside an expression path, as in ${var.x->x%u},
 which would display the value of x as an unsigned integer.
 
-Additionally, custom output can be achieved by using an LLVM format string,
-commencing with the ``:`` marker. To illustrate, compare ``${var.byte%x}`` and
-``${var.byte:x-}``. The former uses lldb's builtin hex formatting (``x``),
-which unconditionally inserts a ``0x`` prefix, and also zero pads the value to
-match the size of the type. The latter uses ``llvm::formatv`` formatting
-(``:x-``), and will print only the hex value, with no ``0x`` prefix, and no
-padding. This raw control is useful when composing multiple pieces into a
-larger whole.
-
 You can also use some other special format markers, not available for formats
 themselves, but which carry a special meaning when used in this context:
 

lldb/source/Core/FormatEntity.cpp

@@ -57,7 +57,6 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/Regex.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include <cctype>
@@ -659,38 +658,6 @@ static char ConvertValueObjectStyleToChar(
   return '\0';
 }
 
-static llvm::Regex LLVMFormatPattern{"x[-+]?\\d*|n|d", llvm::Regex::IgnoreCase};
-
-static bool DumpValueWithLLVMFormat(Stream &s, llvm::StringRef options,
-                                    ValueObject &valobj) {
-  std::string formatted;
-  std::string llvm_format = ("{0:" + options + "}").str();
-
-  // Options supported by format_provider<T> for integral arithmetic types.
-  // See table in FormatProviders.h.
-
-  auto type_info = valobj.GetTypeInfo();
-  if (type_info & eTypeIsInteger && LLVMFormatPattern.match(options)) {
-    if (type_info & eTypeIsSigned) {
-      bool success = false;
-      int64_t integer = valobj.GetValueAsSigned(0, &success);
-      if (success)
-        formatted = llvm::formatv(llvm_format.data(), integer);
-    } else {
-      bool success = false;
-      uint64_t integer = valobj.GetValueAsUnsigned(0, &success);
-      if (success)
-        formatted = llvm::formatv(llvm_format.data(), integer);
-    }
-  }
-
-  if (formatted.empty())
-    return false;
-
-  s.Write(formatted.data(), formatted.size());
-  return true;
-}
-
 static bool DumpValue(Stream &s, const SymbolContext *sc,
                       const ExecutionContext *exe_ctx,
                       const FormatEntity::Entry &entry, ValueObject *valobj) {
@@ -761,12 +728,9 @@ static bool DumpValue(Stream &s, const SymbolContext *sc,
     return RunScriptFormatKeyword(s, sc, exe_ctx, valobj, entry.string.c_str());
   }
 
-  auto split = llvm::StringRef(entry.string).split(':');
-  auto subpath = split.first;
-  auto llvm_format = split.second;
-
+  llvm::StringRef subpath(entry.string);
   // simplest case ${var}, just print valobj's value
-  if (subpath.empty()) {
+  if (entry.string.empty()) {
     if (entry.printf_format.empty() && entry.fmt == eFormatDefault &&
         entry.number == ValueObject::eValueObjectRepresentationStyleValue)
       was_plain_var = true;
@@ -775,19 +739,22 @@ static bool DumpValue(Stream &s, const SymbolContext *sc,
     target = valobj;
   } else // this is ${var.something} or multiple .something nested
   {
-    if (subpath[0] == '[')
+    if (entry.string[0] == '[')
       was_var_indexed = true;
     ScanBracketedRange(subpath, close_bracket_index,
                        var_name_final_if_array_range, index_lower,
                        index_higher);
 
     Status error;
 
-    LLDB_LOG(log, "[Debugger::FormatPrompt] symbol to expand: {0}", subpath);
+    const std::string &expr_path = entry.string;
+
+    LLDB_LOGF(log, "[Debugger::FormatPrompt] symbol to expand: %s",
+              expr_path.c_str());
 
     target =
         valobj
-            ->GetValueForExpressionPath(subpath, &reason_to_stop,
+            ->GetValueForExpressionPath(expr_path.c_str(), &reason_to_stop,
                                         &final_value_type, options, &what_next)
             .get();
 
@@ -916,18 +883,8 @@ static bool DumpValue(Stream &s, const SymbolContext *sc,
   }
 
   if (!is_array_range) {
-    if (!llvm_format.empty()) {
-      if (DumpValueWithLLVMFormat(s, llvm_format, *target)) {
-        LLDB_LOGF(log, "dumping using llvm format");
-        return true;
-      } else {
-        LLDB_LOG(
-            log,
-            "empty output using llvm format '{0}' - with type info flags {1}",
-            entry.printf_format, target->GetTypeInfo());
-      }
-    }
-    LLDB_LOGF(log, "dumping ordinary printable output");
+    LLDB_LOGF(log,
+              "[Debugger::FormatPrompt] dumping ordinary printable output");
     return target->DumpPrintableRepresentation(s, val_obj_display,
                                                custom_format);
   } else {
@@ -2270,13 +2227,6 @@ static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
           if (error.Fail())
             return error;
 
-          auto [_, llvm_format] = llvm::StringRef(entry.string).split(':');
-          if (!LLVMFormatPattern.match(llvm_format)) {
-            error.SetErrorStringWithFormat("invalid llvm format: '%s'",
-                                           llvm_format.data());
-            return error;
-          }
-
           if (verify_is_thread_id) {
             if (entry.type != Entry::Type::ThreadID &&
                 entry.type != Entry::Type::ThreadProtocolID) {