[LLDB] Change formatting to use llvm::formatv

[ayermolo]

Summary

In preparation for eanbling 64bit support in LLDB switching to use llvm::formatv
instead of format MACROs.

[JDevlieghere]

I don't really understand the motivation. Can you elaborate on why "enabling 64 bit support" requires this change? I definitely prefer the formatv approach, but wouldn't the PRIx64 should do what you want here?

Also, at a higher level, can we do the same thing as the Log::Format function that takes varargs and uses formavt under the hood?

template <typename... Args>
void Format(llvm::StringRef file, llvm::StringRef function,
            const char *format, Args &&... args) {
  Format(file, function, llvm::formatv(format, std::forward<Args>(args)...));
}

lldb/include/lldb/Core/Module.h

826–847

Let's not keep both.

849

This should be (1) a doxygen comment and (2) using a group. But that's moot if we don't keep the printf-style variants around.

lldb/source/Core/Module.cpp

1169–1174

This is not using msg. Missing strm.PutCString(msg);?

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

15–56

Unrelated change?

[ayermolo]

In D139955#3992766, @JDevlieghere wrote:

I don't really understand the motivation. Can you elaborate on why "enabling 64 bit support" requires this change? I definitely prefer the formatv approach, but wouldn't the PRIx64 should do what you want here?

Also, at a higher level, can we do the same thing as the Log::Format function that takes varargs and uses formavt under the hood?

template <typename... Args>
void Format(llvm::StringRef file, llvm::StringRef function,
            const char *format, Args &&... args) {
  Format(file, function, llvm::formatv(format, std::forward<Args>(args)...));
}

This was suggested in https://reviews.llvm.org/D138618 by @labath My understanding to get away from the PRIx32/PRIx64 macros.
We are changing the dw_offset_t to be 64bit, and need to change wherever it's printed to print 64bit number.

[labath]

Yeah, I'm afraid this is all my fault. I suggested going in this direction, but this isn't exactly how I thought it would turn out. I was expecting that the inferface would be something along the lines of what Jonas posted in his comment. And I was not expecting that you will try to convert every single instance of PRIx32 dwarf offset printing. The majority of the modified lines are the ReportError and ReportWarning statements, so I though we would just be converting those. And the majority of the callers of these functions are coming from DWARF code, so I agree with Jonas that it would be nice to convert all callers of these functions -- but I won't insist on it.

I guess I should have been more explicit about my expectations -- I'm sorry.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

513

You could just change this to print a different delimiting character ([ for instance).

[ayermolo]

I tried to modify all the places wehre getOffset() is used. Which will later return 64bit instead of 32 bit.

Sorry I guess there was miss communication.
I am not quite clear in what you are suggesting.
The way I did it we now have two distinct interfaces. One for old way that takes in char* and args and applies formatting internally, and a new one which takes in std::string. So all formatting is done on caller side with std::string(llvm::formatv(..)).
Are you suggesting to change implementation of

void ReportError(const char *format, ...)
      __attribute__((format(printf, 2, 3)));

and others to use llvm::formatv under the hood instead?
So caller side will remain mostly the same. Except instead of using printf formating it will be formatvv.
In that case all of call sites will need to change.

[labath]

In D139955#3999381, @ayermolo wrote:

I tried to modify all the places wehre getOffset() is used. Which will later return 64bit instead of 32 bit.

Sorry I guess there was miss communication.
I am not quite clear in what you are suggesting.
The way I did it we now have two distinct interfaces. One for old way that takes in char* and args and applies formatting internally, and a new one which takes in std::string. So all formatting is done on caller side with std::string(llvm::formatv(..)).
Are you suggesting to change implementation of

void ReportError(const char *format, ...)
      __attribute__((format(printf, 2, 3)));

and others to use llvm::formatv under the hood instead?

Yes, that's pretty much it.

So caller side will remain mostly the same. Except instead of using printf formating it will be formatvv.
In that case all of call sites will need to change.

Yes, but in the case of ReportError, most of the callers are in DWARF code anyway, so I think it'd make sense to replace all of them (and some of them are already calling formatv, and then passing the string to this function).

If there are too many callers then you can just make a different function (ReportErrorv, or ReportErrorWithFormatv, depending on how verbose you feel), and then just change the callers that we care about.

[ayermolo]

In D139955#3999521, @labath wrote:

In D139955#3999381, @ayermolo wrote:

I tried to modify all the places wehre getOffset() is used. Which will later return 64bit instead of 32 bit.

Sorry I guess there was miss communication.
I am not quite clear in what you are suggesting.
The way I did it we now have two distinct interfaces. One for old way that takes in char* and args and applies formatting internally, and a new one which takes in std::string. So all formatting is done on caller side with std::string(llvm::formatv(..)).
Are you suggesting to change implementation of

void ReportError(const char *format, ...)
      __attribute__((format(printf, 2, 3)));

and others to use llvm::formatv under the hood instead?

Yes, that's pretty much it.

So caller side will remain mostly the same. Except instead of using printf formating it will be formatvv.
In that case all of call sites will need to change.

Yes, but in the case of ReportError, most of the callers are in DWARF code anyway, so I think it'd make sense to replace all of them (and some of them are already calling formatv, and then passing the string to this function).

If there are too many callers then you can just make a different function (ReportErrorv, or ReportErrorWithFormatv, depending on how verbose you feel), and then just change the callers that we care about.

Ah, gotcha. Thanks for elaborating.

[ayermolo]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

15–56

This was recommended in another diff. Although it was related to DIERef.h. I can move it to the second diff, or it's own diff?

[ayermolo]

pulled a trigger and changed all the call sites. I think less confusing then having two sets of APIs. One with printf symantics another with formatv.

[ayermolo]

removed include that snuck in.

[ayermolo]

missed couple of Status uses.

[labath]

This is looking much better -- and focused. I still have comments though. :)

lldb/include/lldb/Core/Module.h

832–837

Could you do this one as well? It only has one caller and it would be strange for it to use a different syntax than LogMessage

841

Let's remove this defensive nonsense while we're in here. All of the callers are in this patch, and none of them is passing an empty string or a null pointer.

lldb/include/lldb/Utility/Status.h

66

I don't think you've converted all the callers of this one. Given it's pervasiveness, I think we will need to do some sort of a staged conversion, to ensure call sites get compile errors instead of silent breakage. For now I think it would be fine to have a "named constructor" using formatv (static Status Status::WithFormat(fmt, args...)). Or just leave it out...

lldb/source/Core/Module.cpp

1157–1164

duplicated line

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

21–28

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

197

this shouldn't be necessary

lldb/source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.cpp

18–24

same here

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

585–586

This should be enough (also, I think doing a .str() on the format result would look nicer than a std::string constructor)

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

15–56

Yeah, this looks messy if the clang-format layout is significantly different than the original. Maybe you shouldn't do it here -- or do it as a separate patch (but do keep it in mind for future, particularly when creating new files).

3062

delete empty line

lldb/source/Symbol/DWARFCallFrameInfo.cpp

775–781

[ayermolo]

addressing comments

lldb/include/lldb/Utility/Status.h

66

Yeah you are right, missed a bunch. :/ As an experiment changed Status constructor to take a string and caller side to std::string(llvm::formatv() After 26 files, gave up. Would have exploded this diff. Added a static function that constructs Status using formatv

[ayermolo]

@labath ping. Is there anything else I need to do?

[JDevlieghere]

This looks good to me if we drop the explicit + for right alignment: it's the default and other places in LLDB (and LLVM, at least as far as I'm aware) don't include this unless there's ambiguity.

[ayermolo]

removed +

[labath]

I'm sorry for the delay, I was out for the holidays. Looks now, thanks for your patience.

[JDevlieghere]

LGTM too

[ayermolo]

rebase

[ayermolo]

Thanks for reviewing, really appreciate it!

[Michael137]

FYI, this is causing buildbot failures: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/49913/execution/node/74/log/

Currently checking what's wrong.

/Users/buildslave/jenkins/workspace/lldb-cmake@2/llvm-project/lldb/test/API/lang/cpp/accelerator-table -p TestCPPAccelerator.py
--
Exit Code: -6

Command Output (stdout):
--
lldb version 16.0.99git (https://github.com/llvm/llvm-project.git revision 706881825b2470c7176e07355b6ab54d8b4c5f95)
  clang revision 706881825b2470c7176e07355b6ab54d8b4c5f95
  llvm revision 706881825b2470c7176e07355b6ab54d8b4c5f95

--
Command Output (stderr):
--
Assertion failed: (Style.empty() && "Invalid integral format style!"), function format, file /Users/buildslave/jenkins/workspace/lldb-cmake@2/llvm-project/llvm/include/llvm/Support/FormatProviders.h, line 147.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.
Stack dump:
0.	HandleCommand(command = "frame variable inner_d")

frame #39: 0x0000000195adff34 dyld`start + 2248                                                                                                                                                                                                                                                                                                                           
frame #38: 0x0000000100006050 lldb`main(argc=10, argv=0x000000016fdfe8e8) at Driver.cpp:820:26                                                                                                                                                                                                                                                                            
frame #37: 0x000000010000558c lldb`Driver::MainLoop(this=0x000000016fdfe148) at Driver.cpp:577:20                                                                                     
frame #36: 0x000000012e38838c liblldb.16.0.0git.dylib`lldb::SBDebugger::RunCommandInterpreter(this=0x000000016fdfe168, options=0x000000016fdfde48) at SBDebugger.cpp:1274:14          
frame #35: 0x000000012e8abe54 liblldb.16.0.0git.dylib`lldb_private::CommandInterpreter::RunCommandInterpreter(this=0x000000010410cdb0, options=0x0000600000c1d140) at CommandInterpreter.cpp:3364:16
frame #34: 0x000000012e642fbc liblldb.16.0.0git.dylib`lldb_private::Debugger::RunIOHandlers(this=0x0000000104814800) at Debugger.cpp:1006:16                                                                                                                                                                                                                              
frame #33: 0x000000012e698ae4 liblldb.16.0.0git.dylib`lldb_private::IOHandlerEditline::Run(this=0x0000000100a053d8) at IOHandler.cpp:576:22                                           
frame #32: 0x000000012e8aa708 liblldb.16.0.0git.dylib`lldb_private::CommandInterpreter::IOHandlerInputComplete(this=0x000000010410cdb0, io_handler=0x0000000100a053d8, line="v inner_d") at CommandInterpreter.cpp:3110:3
frame #31: 0x000000012e8a5ef0 liblldb.16.0.0git.dylib`lldb_private::CommandInterpreter::HandleCommand(this=0x000000010410cdb0, command_line="v inner_d", lazy_add_to_history=eLazyBoolCalculate, result=0x000000016fdfd8b0) at CommandInterpreter.cpp:2035:14
frame #30: 0x000000012e8d1aec liblldb.16.0.0git.dylib`lldb_private::CommandObjectParsed::Execute(this=0x0000000104833600, args_string="inner_d", result=0x000000016fdfd8b0) at CommandObject.cpp:747:19
frame #29: 0x00000001325039bc liblldb.16.0.0git.dylib`CommandObjectFrameVariable::DoExecute(this=0x0000000104833600, command=0x000000016fdfd278, result=0x000000016fdfd8b0) at CommandObjectFrame.cpp:585:32
frame #28: 0x000000012eab1ff4 liblldb.16.0.0git.dylib`lldb_private::StackFrame::GetValueForVariableExpressionPath(this=0x0000000100a06ca8, var_expr=(Data = "", Length = 0), use_dynamic=eDynamicDontRunTarget, options=49, var_sp=std::__1::shared_ptr<lldb_private::Variable>::element_type @ 0x0000600003b28478 strong=5 weak=2, error=0x000000016fdfce20) at StackFram
e.cpp:619:17                                                                                                                                                                          
frame #27: 0x000000012eab42b8 liblldb.16.0.0git.dylib`lldb_private::StackFrame::GetValueObjectForFrameVariable(this=0x0000000100a06ca8, variable_sp=std::__1::shared_ptr<lldb_private::Variable>::element_type @ 0x0000600003b28478 strong=5 weak=2, use_dynamic=eDynamicDontRunTarget) at StackFrame.cpp:1190:43
frame #26: 0x000000012e76e660 liblldb.16.0.0git.dylib`lldb_private::ValueObject::GetDynamicValue(this=0x000000010189b400, use_dynamic=eDynamicDontRunTarget) at ValueObject.cpp:1849:5 
frame #25: 0x000000012e76e588 liblldb.16.0.0git.dylib`lldb_private::ValueObject::CalculateDynamicValue(this=0x000000010189b400, use_dynamic=eDynamicDontRunTarget) at ValueObject.cpp:1837:29
frame #24: 0x000000012ea5b5d8 liblldb.16.0.0git.dylib`lldb_private::Process::IsPossibleDynamicValue(this=0x000000010289e400, in_value=0x000000010189b400) at Process.cpp:1547:38      
frame #23: 0x000000012e773234 liblldb.16.0.0git.dylib`lldb_private::ValueObject::GetObjectRuntimeLanguage(this=0x000000010189b400) at ValueObject.h:374:12                            
frame #22: 0x000000012e488f7c liblldb.16.0.0git.dylib`lldb_private::ValueObject::GetCompilerType(this=0x000000010189b400) at ValueObject.h:352:43                                     
frame #21: 0x000000012e7669f0 liblldb.16.0.0git.dylib`lldb_private::ValueObject::MaybeCalculateCompleteType(this=0x000000010189b400) at ValueObject.cpp:248:30                        
frame #20: 0x000000012e78f5d8 liblldb.16.0.0git.dylib`lldb_private::ValueObjectVariable::GetCompilerTypeImpl(this=0x000000010189b400) at ValueObjectVariable.cpp:70:35                
frame #19: 0x000000012e9f3ae4 liblldb.16.0.0git.dylib`lldb_private::Variable::GetType(this=0x0000600003b28478) at Variable.cpp:98:31                                                  
frame #18: 0x000000012e9d3320 liblldb.16.0.0git.dylib`lldb_private::SymbolFileType::GetType(this=0x0000600002145e68) at Type.cpp:137:41                                               
frame #17: 0x000000012f3a2d2c liblldb.16.0.0git.dylib`SymbolFileDWARF::ResolveTypeUID(this=0x0000000102825000, type_uid=4294967591) at SymbolFileDWARF.cpp:1498:21                    
frame #16: 0x000000012f368878 liblldb.16.0.0git.dylib`DWARFDIE::ResolveType(this=0x000000016fdfb790) const at DWARFDIE.cpp:351:24                                                     
frame #15: 0x000000012f3a2ed0 liblldb.16.0.0git.dylib`SymbolFileDWARF::ResolveType(this=0x0000000102825000, die=0x000000016fdfb790, assert_not_being_parsed=true, resolve_function_context=false) at SymbolFileDWARF.cpp:1625:18
frame #14: 0x000000012f3a4280 liblldb.16.0.0git.dylib`SymbolFileDWARF::GetTypeForDIE(this=0x0000000102825000, die=0x000000016fdfb790, resolve_function_context=false) at SymbolFileDWARF.cpp:2715:17
frame #13: 0x000000012f3a9278 liblldb.16.0.0git.dylib`SymbolFileDWARF::ParseType(this=0x0000000102825000, sc=0x000000016fdfb598, die=0x000000016fdfb790, type_is_new_ptr=0x0000000000000000) at SymbolFileDWARF.cpp:3123:31
frame #12: 0x000000012f321e00 liblldb.16.0.0git.dylib`DWARFASTParserClang::ParseTypeFromDWARF(this=0x0000600003008480, sc=0x000000016fdfb598, die=0x000000016fdfb790, type_is_new_ptr=0x0000000000000000) at DWARFASTParserClang.cpp:429:42
frame #11: 0x000000012f322520 liblldb.16.0.0git.dylib`void lldb_private::Module::LogMessage<unsigned int, void*, unsigned int, char const*, char const*>(this=0x0000000103029ca8, log=0x0000600003d14008, format="DWARFASTParserClang::ParseTypeFromDWARF (die = {0:x16}, decl_ctx = {1:p} (die {2:16x})) (3:s) name = '{4}')", args=0x000000016fdfb21c, args=0x000000016f
dfb210, args=0x000000016fdfb20c, args=0x000000016fdfb200, args=0x000000016fdfb1f8) at Module.h:830:5
frame #10: 0x000000012e6ec718 liblldb.16.0.0git.dylib`lldb_private::Module::LogMessage(this=0x0000000103029ca8, log=0x0000600003d14008, payload=0x000000016fdfae08) at Module.cpp:1190:34
frame #9: 0x000000012e3e7e8c liblldb.16.0.0git.dylib`llvm::formatv_object_base::str(this=0x000000016fdfae08) const at FormatVariadic.h:111:12                             
frame #8: 0x000000012f6f1d30 liblldb.16.0.0git.dylib`llvm::raw_ostream::operator<<(llvm::formatv_object_base const&)(this=0x000000016fdfac70, Obj=0x000000016fdfae08) at raw_ostream.cpp:348:7
frame #7: 0x000000012f6f1ee0 liblldb.16.0.0git.dylib`llvm::formatv_object_base::format(this=0x000000016fdfae08, S=0x000000016fdfac70) const at FormatVariadic.h:101:13
frame #6: 0x000000012f6f50e8 liblldb.16.0.0git.dylib`llvm::FmtAlign::format(this=0x000000016fdfaad8, S=0x000000016fdfac70, Options=(Data = "16x})) (3:s) name = '{4}')", Length = 3)) at FormatCommon.h:36:15
frame #5: 0x000000012ec1a268 liblldb.16.0.0git.dylib`llvm::detail::provider_format_adapter<unsigned int>::format(this=0x000000016fdfae48, S=0x000000016fdfac70, Options=(Data = "16x})) (3:s) name = '{4}')", Length = 3)) at FormatVariadicDetails.h:40:5
frame #4: 0x000000012ec190c4 liblldb.16.0.0git.dylib`llvm::format_provider<unsigned int, void>::format(V=0x000000016fdfae50, Stream=0x000000016fdfac70, Style=(Data = "x})) (3:s) name = '{4}')", Length = 1)) at FormatProviders.h:147:5    
frame #3: 0x0000000195d44e84 libsystem_c.dylib`__assert_rtn + 272

[Michael137]

Ah it's just a typoed format (and lack of curly braces around one of the format specifiers)

Fixed in https://reviews.llvm.org/rGade3f1ccd807

[ayermolo]

In D139955#4047011, @Michael137 wrote:

Ah it's just a typoed format (and lack of curly braces around one of the format specifiers)

Fixed in https://reviews.llvm.org/rGade3f1ccd807

Thanks, for a fix. Sorry missed it.

[ayermolo]

Found another instance: https://reviews.llvm.org/D141624

lldb/include/lldb/Core/Module.h

public:
   /// Call \p callback for each \p TypeSystem in this \p Module.
   /// Return true from callback to keep iterating, false to stop iterating.
   void ForEachTypeSystem(llvm::function_ref<bool(lldb::TypeSystemSP)> callback);
 
   // Special error functions that can do printf style formatting that will
   // prepend the message with something appropriate for this module (like the
   // architecture, path and object name (if any)). This centralizes code so
   // that everyone doesn't need to format their error and log messages on their
   // own and keeps the output a bit more consistent.
-  void LogMessage(Log *log, const char *format, ...)
-      __attribute__((format(printf, 3, 4)));
+  template <typename... Args>
+  void LogMessage(Log *log, const char *format, Args &&...args) {
+    LogMessage(log, llvm::formatv(format, std::forward<Args>(args)...));
+  }
 
-  void LogMessageVerboseBacktrace(Log *log, const char *format, ...)
-      __attribute__((format(printf, 3, 4)));
+  template <typename... Args>
+  void LogMessageVerboseBacktrace(Log *log, const char *format,
+                                  Args &&...args) {
+    LogMessageVerboseBacktrace(
+        log, llvm::formatv(format, std::forward<Args>(args)...));
+  }
 
-  void ReportWarning(const char *format, ...)
-      __attribute__((format(printf, 2, 3)));
+  template <typename... Args>
+  void ReportWarning(const char *format, Args &&...args) {
+    ReportWarning(llvm::formatv(format, std::forward<Args>(args)...));
+  }
 
-  void ReportError(const char *format, ...)
-      __attribute__((format(printf, 2, 3)));
+  template <typename... Args>
+  void ReportError(const char *format, Args &&...args) {
+    ReportError(llvm::formatv(format, std::forward<Args>(args)...));
+  }
 
   // Only report an error once when the module is first detected to be modified
   // so we don't spam the console with many messages.
-  void ReportErrorIfModifyDetected(const char *format, ...)
-      __attribute__((format(printf, 2, 3)));
+  template <typename... Args>
+  void ReportErrorIfModifyDetected(const char *format, Args &&...args) {
+    ReportErrorIfModifyDetected(
+        llvm::formatv(format, std::forward<Args>(args)...));
+  }
 
   void ReportWarningOptimization(llvm::Optional<lldb::user_id_t> debugger_id);
 
   void
   ReportWarningUnsupportedLanguage(lldb::LanguageType language,
                                    llvm::Optional<lldb::user_id_t> debugger_id);
 
   // Return true if the file backing this module has changed since the module
private:
   void FindTypes_Impl(
       ConstString name, const CompilerDeclContext &parent_decl_ctx,
       size_t max_matches,
       llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
       TypeMap &types);
 
   Module(const Module &) = delete;
   const Module &operator=(const Module &) = delete;
+
+  void LogMessage(Log *log, const llvm::formatv_object_base &payload);
+  void LogMessageVerboseBacktrace(Log *log,
+                                  const llvm::formatv_object_base &payload);
+  void ReportWarning(const llvm::formatv_object_base &payload);
+  void ReportError(const llvm::formatv_object_base &payload);
+  void ReportErrorIfModifyDetected(const llvm::formatv_object_base &payload);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_MODULE_H

lldb/include/lldb/Utility/Status.h

public:
   ///     The type for \a err.
   explicit Status(ValueType err,
                   lldb::ErrorType type = lldb::eErrorTypeGeneric);
 
   Status(std::error_code EC);
 
   explicit Status(const char *format, ...)
       __attribute__((format(printf, 2, 3)));
 
+  template <typename... Args>
+  static Status createWithFormat(const char *format, Args &&...args) {
+    return Status(llvm::formatv(format, std::forward<Args>(args)...));
+  }
+
   ~Status();
 
   // llvm::Error support
   explicit Status(llvm::Error error) { *this = std::move(error); }
   const Status &operator=(llvm::Error error);
   llvm::Error ToError() const;
 
   /// Get the error string associated with the current error.
public:
   bool Success() const;
 
 protected:
   /// Member variables
   ValueType m_code = 0; ///< Status code as an integer value.
   lldb::ErrorType m_type =
       lldb::eErrorTypeInvalid;  ///< The type of the above error code.
   mutable std::string m_string; ///< A string representation of the error code.
+private:
+  explicit Status(const llvm::formatv_object_base &payload) {
+    SetErrorToGenericError();
+    m_string = payload.str();
+  }
 };
 
 } // namespace lldb_private
 
 namespace llvm {
 template <> struct format_provider<lldb_private::Status> {
   static void format(const lldb_private::Status &error, llvm::raw_ostream &OS,
                      llvm::StringRef Options);

lldb/source/Core/Module.cpp

void Module::ReportWarningUnsupportedLanguage(
   ss << "This version of LLDB has no plugin for the language \""
      << Language::GetNameForLanguageType(language)
      << "\". "
         "Inspection of frame variables will be limited.";
   Debugger::ReportWarning(std::string(ss.GetString()), debugger_id,
                           &m_language_warning);
 }
 
-void Module::ReportErrorIfModifyDetected(const char *format, ...) {
+void Module::ReportErrorIfModifyDetected(
+    const llvm::formatv_object_base &payload) {
   if (!m_first_file_changed_log) {
     if (FileHasChanged()) {
       m_first_file_changed_log = true;
-      if (format) {
-        StreamString strm;
-        strm.PutCString("the object file ");
-        GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
-        strm.PutCString(" has been modified\n");
-
-        va_list args;
-        va_start(args, format);
-        strm.PrintfVarArg(format, args);
-        va_end(args);
-
-        const int format_len = strlen(format);
-        if (format_len > 0) {
-          const char last_char = format[format_len - 1];
-          if (last_char != '\n' && last_char != '\r')
-            strm.EOL();
-        }
-        strm.PutCString("The debug session should be aborted as the original "
-                        "debug information has been overwritten.");
-        Debugger::ReportError(std::string(strm.GetString()));
-      }
-    }
-  }
-}
+      strm.PutCString(payload.str());
 
-void Module::ReportError(const char *format, ...) {
-  if (format && format[0]) {
-    StreamString strm;
-    GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief);
-    strm.PutChar(' ');
-
-    va_list args;
-    va_start(args, format);
-    strm.PrintfVarArg(format, args);
-    va_end(args);
-
-    Debugger::ReportError(std::string(strm.GetString()));
-  }
+void Module::ReportError(const llvm::formatv_object_base &payload) {
+  strm.PutCString(payload.str());
+  Debugger::ReportError(strm.GetString().str());
 }
 
-void Module::ReportWarning(const char *format, ...) {
-  if (format && format[0]) {
-    StreamString strm;
-    GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
-    strm.PutChar(' ');
-
-    va_list args;
-    va_start(args, format);
-    strm.PrintfVarArg(format, args);
-    va_end(args);
-
-    Debugger::ReportWarning(std::string(strm.GetString()));
-  }
-}
+void Module::ReportWarning(const llvm::formatv_object_base &payload) {
+  strm.PutCString(payload.str());
 
-void Module::LogMessage(Log *log, const char *format, ...) {
-  if (log != nullptr) {
-    StreamString log_message;
-    GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
-    log_message.PutCString(": ");
-    va_list args;
-    va_start(args, format);
-    log_message.PrintfVarArg(format, args);
-    va_end(args);
-    log->PutCString(log_message.GetData());
-  }
-}
+void Module::LogMessage(Log *log, const llvm::formatv_object_base &payload) {
+  log_message.PutCString(payload.str());
 
-void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) {
-  if (log != nullptr) {
-    StreamString log_message;
-    GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
-    log_message.PutCString(": ");
-    va_list args;
-    va_start(args, format);
-    log_message.PrintfVarArg(format, args);
-    va_end(args);
-    if (log->GetVerbose()) {
-      std::string back_trace;
-      llvm::raw_string_ostream stream(back_trace);
-      llvm::sys::PrintStackTrace(stream);
-      log_message.PutCString(back_trace);
-    }
-    log->PutCString(log_message.GetData());
-  }
-}
+void Module::LogMessageVerboseBacktrace(
+    Log *log, const llvm::formatv_object_base &payload) {
+  log_message.PutCString(payload.str());
 
 void Module::Dump(Stream *s) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
   s->Indent();
   s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
             m_object_name ? "(" : "",
             m_object_name ? m_object_name.GetCString() : "",
if (!m_did_load_objfile.load()) {
         if (m_objfile_sp) {
           // Once we get the object file, update our module with the object
           // file's architecture since it might differ in vendor/os if some
           // parts were unknown.  But since the matching arch might already be
           // more specific than the generic COFF architecture, only merge in
           // those values that overwrite unspecified unknown values.
           m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
         } else {
-          ReportError("failed to load objfile for %s",
+          ReportError("failed to load objfile for {0}",
                       GetFileSpec().GetPath().c_str());
         }
       }
     }
   }
   return m_objfile_sp.get();
 }
 

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() {
 
   // Uncompress the data
   DataExtractor data;
   section->GetSectionData(data);
   llvm::SmallVector<uint8_t, 0> uncompressedData;
   auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData);
   if (err) {
     GetModule()->ReportWarning(
-        "An error occurred while decompression the section %s: %s",
+        "An error occurred while decompression the section {0}: {1}",
         section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
     return nullptr;
   }
 
   // Construct ObjectFileELF object from decompressed buffer
   DataBufferSP gdd_data_buf(
       new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
   auto fspec = GetFileSpec().CopyByAppendingPathComponent(
if (hdr->Is32Bit()) {
     reloc_symbol = ELFRelocation::RelocSymbol32;
   } else {
     reloc_type = ELFRelocation::RelocType64;
     reloc_symbol = ELFRelocation::RelocSymbol64;
   }
 
   for (unsigned i = 0; i < num_relocations; ++i) {
     if (!rel.Parse(rel_data, &offset)) {
-      GetModule()->ReportError(".rel%s[%d] failed to parse relocation",
+      GetModule()->ReportError(".rel{0}[{1:d}] failed to parse relocation",
                                rel_section->GetName().AsCString(), i);
       break;
     }
     Symbol *symbol = nullptr;
 
     if (hdr->Is32Bit()) {
       switch (reloc_type(rel)) {
       case R_386_32:
if (hdr->Is32Bit()) {
           addr_t value = symbol->GetAddressRef().GetFileAddress();
           if (rel.IsRela()) {
             value += ELFRelocation::RelocAddend32(rel);
           } else {
             value += *dst;
           }
           *dst = value;
         } else {
-          GetModule()->ReportError(".rel%s[%u] unknown symbol id: %d",
+          GetModule()->ReportError(".rel{0}[{1}] unknown symbol id: {2:d}",
                                    rel_section->GetName().AsCString(), i,
                                    reloc_symbol(rel));
         }
         break;
       case R_386_PC32:
       default:
         GetModule()->ReportError("unsupported 32-bit relocation:"
-                                 " .rel%s[%u], type %u",
+                                 " .rel{0}[{1}], type {2}",
                                  rel_section->GetName().AsCString(), i,
                                  reloc_type(rel));
       }
     } else {
       switch (reloc_type(rel)) {
       case R_AARCH64_ABS64:
       case R_X86_64_64: {
         symbol = symtab->FindSymbolByID(reloc_symbol(rel));
size_t ObjectFileELF::ReadSectionData(Section *section,
 
   auto Decompressor = llvm::object::Decompressor::create(
       section->GetName().GetStringRef(),
       {reinterpret_cast<const char *>(section_data.GetDataStart()),
        size_t(section_data.GetByteSize())},
       GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8);
   if (!Decompressor) {
     GetModule()->ReportWarning(
-        "Unable to initialize decompressor for section '%s': %s",
+        "Unable to initialize decompressor for section '{0}': {1}",
         section->GetName().GetCString(),
         llvm::toString(Decompressor.takeError()).c_str());
     section_data.Clear();
     return 0;
   }
 
   auto buffer_sp =
       std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
   if (auto error = Decompressor->decompress(
           {buffer_sp->GetBytes(), size_t(buffer_sp->GetByteSize())})) {
-    GetModule()->ReportWarning(
-        "Decompression of section '%s' failed: %s",
+    GetModule()->ReportWarning("Decompression of section '{0}' failed: {1}",
                                section->GetName().GetCString(),
                                llvm::toString(std::move(error)).c_str());
     section_data.Clear();
     return 0;
   }
 
   section_data.SetData(buffer_sp);
   return buffer_sp->GetByteSize();
 }
 

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (seg_cmd.fileoff > m_length) {
     // This is likely a corrupt file.  We don't have any way to return an error
     // condition here (this method was likely invoked from something like
     // ObjectFile::GetSectionList()), so we just null out the section contents,
     // and dump a message to stdout.  The most common case here is core file
     // debugging with a truncated file.
     const char *lc_segment_name =
         seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
     GetModule()->ReportWarning(
-        "load command %u %s has a fileoff (0x%" PRIx64
-        ") that extends beyond the end of the file (0x%" PRIx64
-        "), ignoring this section",
+        "load command {0} {1} has a fileoff ({2:x16}) that extends beyond "
+        "the end of the file ({3:x16}), ignoring this section",
         cmd_idx, lc_segment_name, seg_cmd.fileoff, m_length);
 
     seg_cmd.fileoff = 0;
     seg_cmd.filesize = 0;
   }
 
   if (seg_cmd.fileoff + seg_cmd.filesize > m_length) {
     // We have a load command that says it extends past the end of the file.
     // This is likely a corrupt file.  We don't have any way to return an error
     // condition here (this method was likely invoked from something like
     // ObjectFile::GetSectionList()), so we just null out the section contents,
     // and dump a message to stdout.  The most common case here is core file
     // debugging with a truncated file.
     const char *lc_segment_name =
         seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
     GetModule()->ReportWarning(
-        "load command %u %s has a fileoff + filesize (0x%" PRIx64
-        ") that extends beyond the end of the file (0x%" PRIx64
-        "), the segment will be truncated to match",
+        "load command {0} {1} has a fileoff + filesize ({2:x16}) that "
+        "extends beyond the end of the file ({4:x16}), the segment will be "
+        "truncated to match",
         cmd_idx, lc_segment_name, seg_cmd.fileoff + seg_cmd.filesize, m_length);
 
     // Truncate the length
     seg_cmd.filesize = m_length - seg_cmd.fileoff;
   }
 }
 
 static uint32_t
UUID ObjectFileMachO::GetSharedCacheUUID(FileSpec dyld_shared_cache,
   DataExtractor dsc_header_data(DscData, byte_order, addr_byte_size);
 
   char version_str[7];
   lldb::offset_t offset = 0;
   memcpy(version_str, dsc_header_data.GetData(&offset, 6), 6);
   version_str[6] = '\0';
   if (strcmp(version_str, "dyld_v") == 0) {
     offset = offsetof(struct lldb_copy_dyld_cache_header_v1, uuid);
-    dsc_uuid = UUID(dsc_header_data.GetData(&offset, sizeof(uuid_t)), 
-                    sizeof(uuid_t));
+    dsc_uuid =
+        UUID(dsc_header_data.GetData(&offset, sizeof(uuid_t)), sizeof(uuid_t));
   }
   Log *log = GetLog(LLDBLog::Symbols);
   if (log && dsc_uuid.IsValid()) {
     LLDB_LOGF(log, "Shared cache %s has UUID %s",
               dyld_shared_cache.GetPath().c_str(),
               dsc_uuid.GetAsString().c_str());
   }
   return dsc_uuid;

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

static void PrepareContextToReceiveMembers(TypeSystemClang &ast,
 
   // If this type was not imported from an external AST, there's nothing to do.
   CompilerType type = ast.GetTypeForDecl(tag_decl_ctx);
   if (type && ast_importer.CanImport(type)) {
     auto qual_type = ClangUtil::GetQualType(type);
     if (ast_importer.RequireCompleteType(qual_type))
       return;
     die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
-        "Unable to complete the Decl context for DIE '%s' at offset "
-        "0x%8.8x.\nPlease file a bug report.",
+        "Unable to complete the Decl context for DIE {0} at offset "
+        "{1:x16}.\nPlease file a bug report.",
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
   }
 
   // We don't have a type definition and/or the import failed. We must
   // forcefully complete the type to avoid crashes.
   ForcefullyCompleteType(type);
 }
 
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   if (log) {
     DWARFDIE context_die;
     clang::DeclContext *context =
         GetClangDeclContextContainingDIE(die, &context_die);
 
     dwarf->GetObjectFile()->GetModule()->LogMessage(
         log,
         "DWARFASTParserClang::ParseTypeFromDWARF "
-        "(die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
+        "(die = {0:x16}, decl_ctx = {1:p} (die "
+        "{2:16x})) (3:s) name = '{4}')",
         die.GetOffset(), static_cast<void *>(context), context_die.GetOffset(),
         die.GetTagAsCString(), die.GetName());
   }
 
   Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr)
case DW_TAG_array_type: {
     break;
   }
   case DW_TAG_ptr_to_member_type: {
     type_sp = ParsePointerToMemberType(die, attrs);
     break;
   }
   default:
     dwarf->GetObjectFile()->GetModule()->ReportError(
-        "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
+        "[{0:x16}]: unhandled type tag {1:x4} ({2}), "
+        "please file a bug and "
         "attach the file at the start of this error message",
         die.GetOffset(), tag, DW_TAG_value_to_name(tag));
     break;
   }
 
   // TODO: We should consider making the switch above exhaustive to simplify
   // control flow in ParseTypeFromDWARF. Then, we could simply replace this
   // return statement with a call to llvm_unreachable.
   return UpdateSymbolContextScopeForType(sc, die, type_sp);
 }
 
if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
 
     if (cu_language == eLanguageTypeObjC ||
         cu_language == eLanguageTypeObjC_plus_plus) {
       if (attrs.name) {
         if (attrs.name == "id") {
           if (log)
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
-                "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' "
+                "SymbolFileDWARF::ParseType (die = {0:16x}) {1} '{2}' "
                 "is Objective-C 'id' built-in type.",
                 die.GetOffset(), die.GetTagAsCString(), die.GetName());
           clang_type = m_ast.GetBasicType(eBasicTypeObjCID);
           encoding_data_type = Type::eEncodingIsUID;
           attrs.type.Clear();
           resolve_state = Type::ResolveState::Full;
         } else if (attrs.name == "Class") {
           if (log)
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
-                "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' "
+                "SymbolFileDWARF::ParseType (die = {0:x16}) {1} '{2}' "
                 "is Objective-C 'Class' built-in type.",
                 die.GetOffset(), die.GetTagAsCString(), die.GetName());
           clang_type = m_ast.GetBasicType(eBasicTypeObjCClass);
           encoding_data_type = Type::eEncodingIsUID;
           attrs.type.Clear();
           resolve_state = Type::ResolveState::Full;
         } else if (attrs.name == "SEL") {
           if (log)
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
-                "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' "
+                "SymbolFileDWARF::ParseType (die = {0:x16}) {1} '{2}' "
                 "is Objective-C 'selector' built-in type.",
                 die.GetOffset(), die.GetTagAsCString(), die.GetName());
           clang_type = m_ast.GetBasicType(eBasicTypeObjCSel);
           encoding_data_type = Type::eEncodingIsUID;
           attrs.type.Clear();
           resolve_state = Type::ResolveState::Full;
         }
       } else if (encoding_data_type == Type::eEncodingIsPointerUID &&
                  attrs.type.IsValid()) {
         // Clang sometimes erroneously emits id as objc_object*.  In that
         // case we fix up the type to "id".
 
         const DWARFDIE encoding_die = attrs.type.Reference();
 
         if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type) {
           llvm::StringRef struct_name = encoding_die.GetName();
           if (struct_name == "objc_object") {
             if (log)
               dwarf->GetObjectFile()->GetModule()->LogMessage(
                   log,
-                  "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s "
-                  "'%s' is 'objc_object*', which we overrode to "
+                  "SymbolFileDWARF::ParseType (die = {0:x16}) {1} "
+                  "'{2}' is 'objc_object*', which we overrode to "
                   "'id'.",
                   die.GetOffset(), die.GetTagAsCString(), die.GetName());
             clang_type = m_ast.GetBasicType(eBasicTypeObjCID);
             encoding_data_type = Type::eEncodingIsUID;
             attrs.type.Clear();
             resolve_state = Type::ResolveState::Full;
           }
         }
if (!type_sp) {
         type_sp = debug_map_symfile->FindDefinitionTypeForDWARFDeclContext(die);
       }
     }
 
     if (type_sp) {
       if (log) {
         dwarf->GetObjectFile()->GetModule()->LogMessage(
             log,
-            "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a "
-            "forward declaration, complete type is 0x%8.8" PRIx64,
+            "SymbolFileDWARF({0:p}) - {1:x16}}: {2} type \"{3}\" is a "
+            "forward declaration, complete type is {4:x8}",
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this
       // die
if (die.HasChildren()) {
       bool is_signed = false;
       enumerator_clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type_sp->GetByteSize(nullptr).value_or(0), die);
     }
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   } else {
     dwarf->GetObjectFile()->GetModule()->ReportError(
-        "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
+        "DWARF DIE at {0:x16} named \"{1}\" was not able to start its "
         "definition.\nPlease file a bug and attach the file at the "
         "start of this error message",
         die.GetOffset(), attrs.name.GetCString());
   }
   return type_sp;
 }
 
 static clang::CallingConv
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                   attrs.accessibility, attrs.is_artificial, is_variadic,
                   attrs.is_objc_direct_call);
           type_handled = objc_method_decl != nullptr;
           if (type_handled) {
             LinkDeclContextToDIE(objc_method_decl, die);
             m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID());
           } else {
             dwarf->GetObjectFile()->GetModule()->ReportError(
-                "{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), "
+                "[{0:x16}]: invalid Objective-C method {1:x4} ({2}), "
                 "please file a bug and attach the file at the start of "
                 "this error message",
                 die.GetOffset(), tag, DW_TAG_value_to_name(tag));
           }
         }
       } else if (is_cxx_method) {
         // Look at the parent of this DIE and see if is is a class or
         // struct and see if this is actually a C++ method
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
             // die.
             DWARFDIE spec_die = attrs.specification.Reference();
             clang::DeclContext *spec_clang_decl_ctx =
                 GetClangDeclContextForDIE(spec_die);
             if (spec_clang_decl_ctx) {
               LinkDeclContextToDIE(spec_clang_decl_ctx, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
-                  "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
+                  "{0:x8}: DW_AT_specification({1:x16}"
                   ") has no decl\n",
                   die.GetID(), spec_die.GetOffset());
             }
             type_handled = true;
           } else if (attrs.abstract_origin.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
             // completed so that the m_die_to_decl_ctx for the method in
             // the abstract origin has a valid clang decl context.
             class_type->GetForwardCompilerType();
 
             DWARFDIE abs_die = attrs.abstract_origin.Reference();
             clang::DeclContext *abs_clang_decl_ctx =
                 GetClangDeclContextForDIE(abs_die);
             if (abs_clang_decl_ctx) {
               LinkDeclContextToDIE(abs_clang_decl_ctx, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
-                  "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
+                  "{0:x8}: DW_AT_abstract_origin({1:x16}"
                   ") has no decl\n",
                   die.GetID(), abs_die.GetOffset());
             }
             type_handled = true;
           } else {
             CompilerType class_opaque_type =
                 class_type->GetForwardCompilerType();
             if (TypeSystemClang::IsCXXClassType(class_opaque_type)) {
if (attributes.ExtractFormValueAtIndex(i, form_value)) {
       default:
         break;
       }
     }
   }
 
   Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference());
   if (base_class_type == nullptr) {
-    module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
-                           "resolve the base class at 0x%8.8x"
-                           " from enclosing type 0x%8.8x. \nPlease file "
+    module_sp->ReportError("{0:x16}: DW_TAG_inheritance failed to "
+                           "resolve the base class at {1:x16}"
+                           " from enclosing type {2:x16}. \nPlease file "
                            "a bug and attach the file at the start of "
                            "this error message",
                            die.GetOffset(),
                            encoding_form.Reference().GetOffset(),
                            parent_die.GetOffset());
     return;
   }
 
if (!attrs.is_complete_objc_class &&
               die, attrs.name, true);
         }
       }
 
       if (type_sp) {
         if (log) {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
-              "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is an "
-              "incomplete objc type, complete type is 0x%8.8" PRIx64,
+              "SymbolFileDWARF({0:p}) - {1:x16}: {2} type "
+              "\"{3}\" is an "
+              "incomplete objc type, complete type is {4:x8}",
               static_cast<void *>(this), die.GetOffset(),
               DW_TAG_value_to_name(tag), attrs.name.GetCString(),
               type_sp->GetID());
         }
 
         // We found a real definition for this type elsewhere so lets use
         // it and cache the fact that we found a complete type for this
         // die
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
         return type_sp;
       }
     }
   }
 
   if (attrs.is_forward_declaration) {
     // We have a forward declaration to a type and we need to try and
     // find a full declaration. We look in the current type index just in
     // case we have a forward declaration followed by an actual
     // declarations in the DWARF. If this fails, we need to look
     // elsewhere...
     if (log) {
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log,
-          "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a "
+          "SymbolFileDWARF({0:p}) - {1:x16}: {2} type \"{3}\" is a "
           "forward declaration, trying to find complete type",
           static_cast<void *>(this), die.GetOffset(), DW_TAG_value_to_name(tag),
           attrs.name.GetCString());
     }
 
     // See if the type comes from a Clang module and if so, track down
     // that type.
     type_sp = ParseTypeFromClangModule(sc, die, log);
if (!type_sp) {
         type_sp = debug_map_symfile->FindDefinitionTypeForDWARFDeclContext(die);
       }
     }
 
     if (type_sp) {
       if (log) {
         dwarf->GetObjectFile()->GetModule()->LogMessage(
             log,
-            "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a "
-            "forward declaration, complete type is 0x%8.8" PRIx64,
+            "SymbolFileDWARF({0:p}) - {1:x16}: {2} type \"{3}\" is a "
+            "forward declaration, complete type is {4:x8}",
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this die
       dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
if (ParseTemplateParameterInfos(die, template_param_infos)) {
       clang::ClassTemplateDecl *class_template_decl =
           m_ast.ParseClassTemplateDecl(
               decl_ctx, GetOwningClangModule(die), attrs.accessibility,
               attrs.name.GetCString(), tag_decl_kind, template_param_infos);
       if (!class_template_decl) {
         if (log) {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
-              "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" "
+              "SymbolFileDWARF({0:p}) - {1:x16}: {2} type \"{3}\" "
               "clang::ClassTemplateDecl failed to return a decl.",
               static_cast<void *>(this), die.GetOffset(),
               DW_TAG_value_to_name(tag), attrs.name.GetCString());
         }
         return TypeSP();
       }
 
       clang::ClassTemplateSpecializationDecl *class_specialization_decl =
if (!attrs.is_forward_declaration) {
     // for use as their decl contexts the class will be ready to accept
     // these child definitions.
     if (!die.HasChildren()) {
       // No children for this struct/union/class, lets finish it
       if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
         TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
       } else {
         dwarf->GetObjectFile()->GetModule()->ReportError(
-            "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
+
+            "DWARF DIE at {0:x16} named \"{1}\" was not able to start "
+            "its "
             "definition.\nPlease file a bug and attach the file at the "
             "start of this error message",
             die.GetOffset(), attrs.name.GetCString());
       }
 
       // If the byte size of the record is specified then overwrite the size
       // that would be computed by Clang. This is only needed as LLDB's
       // TypeSystemClang is always in C++ mode, but some compilers such as
void DWARFASTParserClang::ParseObjCProperty(
   assert(die.Tag() == DW_TAG_APPLE_property);
 
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
 
   const MemberAttributes attrs(die, parent_die, module_sp);
   const PropertyAttributes propAttrs(die);
 
   if (!propAttrs.prop_name) {
-    module_sp->ReportError(
-        "0x%8.8" PRIx64 ": DW_TAG_APPLE_property has no name.", die.GetID());
+    module_sp->ReportError("{0:x8}: DW_TAG_APPLE_property has no name.",
+                           die.GetID());
     return;
   }
 
   Type *member_type = die.ResolveTypeUID(attrs.encoding_form.Reference());
   if (!member_type) {
-    module_sp->ReportError("0x%8.8" PRIx64
-                           ": DW_TAG_APPLE_property '%s' refers to type 0x%8.8x"
-                           " which was unable to be parsed",
-                           die.GetID(), propAttrs.prop_name,
-                           attrs.encoding_form.Reference().GetOffset());
+    module_sp->ReportError(
+        "{0:x8}: DW_TAG_APPLE_property '{1}' refers to type {2:x16}"
     return;
   }
 
   ClangASTMetadata metadata;
   metadata.SetUserID(die.GetID());
   delayed_properties.push_back(DelayedAddObjCClassProperty(
       class_clang_type, propAttrs.prop_name,
       member_type->GetLayoutCompilerType(), propAttrs.prop_setter_name,
if (attrs.member_byte_offset == UINT32_MAX &&
     }
     return;
   }
 
   Type *member_type = die.ResolveTypeUID(attrs.encoding_form.Reference());
   if (!member_type) {
     if (attrs.name)
       module_sp->ReportError(
-          "0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x"
+          "{0:x8}: DW_TAG_member '{1}' refers to type {2:x16}"
           " which was unable to be parsed",
           die.GetID(), attrs.name, attrs.encoding_form.Reference().GetOffset());
     else
-      module_sp->ReportError(
-          "0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8x"
+      module_sp->ReportError("{0:x8}: DW_TAG_member refers to type {1:x16}"
                              " which was unable to be parsed",
-          die.GetID(), attrs.encoding_form.Reference().GetOffset());
+                             die.GetID(),
+                             attrs.encoding_form.Reference().GetOffset());
     return;
   }
 
   const uint64_t character_width = 8;
   const uint64_t word_width = 32;
   CompilerType member_clang_type = member_type->GetLayoutCompilerType();
 
   if (attrs.accessibility == eAccessNone)
if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) &&
         !(parent_die.Tag() == DW_TAG_union_type &&
           this_field_info.bit_offset == 0) &&
         ((this_field_info.bit_offset >= parent_bit_size) ||
          (last_field_info.IsBitfield() &&
           !last_field_info.NextBitfieldOffsetIsValid(
               this_field_info.bit_offset)))) {
       ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
       objfile->GetModule()->ReportWarning(
-          "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
-          "bit offset (0x%8.8" PRIx64
-          ") member will be ignored. Please file a bug against the "
-          "compiler and include the preprocessed output for %s\n",
+          "{0:x16}: {1} bitfield named \"{2}\" has invalid "
+          "bit offset ({3:x8}) member will be ignored. Please file a bug "
+          "against the "
+          "compiler and include the preprocessed output for {4}\n",
           die.GetID(), DW_TAG_value_to_name(tag), attrs.name,
           this_field_info.bit_offset, GetUnitName(parent_die).c_str());
       return;
     }
 
     // Update the field bit offset we will report for layout
     field_bit_offset = this_field_info.bit_offset;
 
if (member_clang_type.IsArrayType(&member_array_element_type,
       uint64_t parent_byte_size =
           parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX);
 
       if (attrs.member_byte_offset >= parent_byte_size) {
         if (member_array_size != 1 &&
             (member_array_size != 0 ||
              attrs.member_byte_offset > parent_byte_size)) {
           module_sp->ReportError(
-              "0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x"
-              " which extends beyond the bounds of 0x%8.8" PRIx64,
+              "{0:x8}: DW_TAG_member '{1}' refers to type {2:x16}"
+              " which extends beyond the bounds of {3:x8}",
               die.GetID(), attrs.name,
-              attrs.encoding_form.Reference().GetOffset(),
-              parent_die.GetID());
+              attrs.encoding_form.Reference().GetOffset(), parent_die.GetID());
         }
 
         member_clang_type =
             m_ast.CreateArrayType(member_array_element_type, 0, false);
       }
     }
   }
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DWARFCompileUnit::Dump(Stream *s) const {
-  s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, "
-            "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
-            "{0x%8.8x})\n",
-            GetOffset(), GetLength(), GetVersion(), GetAbbrevOffset(),
-            GetAddressByteSize(), GetNextUnitOffset());
+  s->Format(
+
+      "{0:x16}: Compile Unit: length = {1:x8}, version = {2:x}, "
+      "abbr_offset = {3:x8}, addr_size = {4:x2} (next CU at "
+      "[{5:x16}])\n",
+      GetOffset(), GetLength(), GetVersion(), (uint32_t)GetAbbrevOffset(),
 }
 
 void DWARFCompileUnit::BuildAddressRangeTable(
     DWARFDebugAranges *debug_aranges) {
   // This function is usually called if there in no .debug_aranges section in
   // order to produce a compile unit level set of address ranges that is
   // accurate.
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

if (m_abbr_idx == 0) {
     m_has_children = false;
     return true; // NULL debug tag entry
   }
 
   lldb::offset_t offset = *offset_ptr;
   const auto *abbrevDecl = GetAbbreviationDeclarationPtr(cu);
   if (abbrevDecl == nullptr) {
     cu->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-        "{0x%8.8x}: invalid abbreviation code %u, please file a bug and "
+        "[{0:x16}]: invalid abbreviation code {1}, "
+        "please file a bug and "
         "attach the file at the start of this error message",
         m_offset, (unsigned)abbr_idx);
     // WE can't parse anymore if the DWARF is borked...
     *offset_ptr = UINT32_MAX;
     return false;
   }
   m_tag = abbrevDecl->Tag();
   m_has_children = abbrevDecl->HasChildren();
else {
           break;
 
         case DW_FORM_implicit_const:
           form_size = 0;
           break;
 
         default:
           cu->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-              "{0x%8.8x}: Unsupported DW_FORM_0x%x, please file a bug and "
+              "[{0:x16}]: Unsupported DW_FORM_{1:x}, please file a bug "
+              "and "
               "attach the file at the start of this error message",
               m_offset, (unsigned)form);
           *offset_ptr = m_offset;
           return false;
         }
         offset += form_size;
 
       } while (form_is_indirect);
     }
   }
   *offset_ptr = offset;
   return true;
 }
 
 static DWARFRangeList GetRangesOrReportError(DWARFUnit &unit,
                                              const DWARFDebugInfoEntry &die,
                                              const DWARFFormValue &value) {
   llvm::Expected<DWARFRangeList> expected_ranges =
       (value.Form() == DW_FORM_rnglistx)
           ? unit.FindRnglistFromIndex(value.Unsigned())
           : unit.FindRnglistFromOffset(value.Unsigned());
   if (expected_ranges)
     return std::move(*expected_ranges);
+
   unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-      "{0x%8.8x}: DIE has DW_AT_ranges(%s 0x%" PRIx64 ") attribute, but "
-      "range extraction failed (%s), please file a bug "
+      "[{0:x16}]: DIE has DW_AT_ranges({1} {2:x16}) attribute, but "
+      "range extraction failed ({3}), please file a bug "
       "and attach the file at the start of this error message",
       die.GetOffset(),
       llvm::dwarf::FormEncodingString(value.Form()).str().c_str(),
       value.Unsigned(), toString(expected_ranges.takeError()).c_str());
   return DWARFRangeList();
 }
 
 // GetDIENamesAndRanges

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

DWARFDIE DWARFFormValue::Reference() const {
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
     assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
                     // unit relative or we will get this wrong
     value += m_unit->GetOffset();
     if (!m_unit->ContainsDIEOffset(value)) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-          "DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU",
-          value);
+          "DW_FORM_ref* DIE reference {0:x16} is outside of its CU", value);
       return {};
     }
     return const_cast<DWARFUnit *>(m_unit)->GetDIE(value);
 
   case DW_FORM_ref_addr: {
     DWARFUnit *ref_cu =
         m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset(
             DIERef::Section::DebugInfo, value);
     if (!ref_cu) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-          "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
-          value);
+          "DW_FORM_ref_addr DIE reference {0:x16} has no matching CU", value);
       return {};
     }
     return ref_cu->GetDIE(value);
   }
 
   case DW_FORM_ref_sig8: {
     DWARFTypeUnit *tu =
         m_unit->GetSymbolFileDWARF().DebugInfo().GetTypeUnitForHash(value);

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

if (DWARFDIE die = m_dwarf.GetDIE(ref))
     return m_callback(die);
   m_index.ReportInvalidDIERef(ref, m_name);
   return true;
 }
 
 void DWARFIndex::ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const {
   m_module.ReportErrorIfModifyDetected(
       "the DWARF debug information has been modified (accelerator table had "
-      "bad die 0x%8.8x for '%s')\n",
+      "bad die {0:x16} for '{1}')\n",
       ref.die_offset(), name.str().c_str());
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFTypeUnit.cpp

 
 #include "SymbolFileDWARF.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DWARFTypeUnit::Dump(Stream *s) const {
-  s->Printf("0x%8.8x: Type Unit: length = 0x%8.8x, version = 0x%4.4x, "
-            "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
-            "{0x%8.8x})\n",
-            GetOffset(), GetLength(), GetVersion(), GetAbbrevOffset(),
-            GetAddressByteSize(), GetNextUnitOffset());
+  s->Format("{0:x16}: Type Unit: length = {1:x8}, version = {2:x4}, "
+            "abbr_offset = {3:x8}, addr_size = {4:x2} (next CU at "
+            "[{5:x16}])\n",
+            GetOffset(), (uint32_t)GetLength(), GetVersion(),
+            (uint32_t)GetAbbrevOffset(), GetAddressByteSize(),
+            GetNextUnitOffset());
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::ExtractUnitDIEIfNeeded() {
   std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf.GetDwoSymbolFileForCompileUnit(*this, m_first_die);
   if (!dwo_symbol_file)
     return;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(*m_dwo_id);
 
   if (!dwo_cu) {
-    SetDwoError(
-        Status("unable to load .dwo file from \"%s\" due to ID (0x%16.16" PRIx64
-               ") mismatch for skeleton DIE at 0x%8.8" PRIx32,
-               dwo_symbol_file->GetObjectFile()->GetFileSpec().GetPath().c_str(),
-               *m_dwo_id, m_first_die.GetOffset()));
+    SetDwoError(Status::createWithFormat(
+        "unable to load .dwo file from \"{0}\" due to ID ({1:x16}) mismatch "
+        "for skeleton DIE at {2:x8}",
     return; // Can't fetch the compile unit from the dwo file.
   }
   dwo_cu->SetUserData(this);
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid()) {
     // Can't fetch the compile unit DIE from the dwo file.
-    SetDwoError(
-        Status("unable to extract compile unit DIE from .dwo file for skeleton "
-               "DIE at 0x%8.8" PRIx32, m_first_die.GetOffset()));
+    SetDwoError(Status::createWithFormat(
+        "unable to extract compile unit DIE from .dwo file for skeleton "
+        "DIE at {0:x16}",
+        m_first_die.GetOffset()));
     return;
   }
 
   // Here for DWO CU we want to use the address base set in the skeleton unit
   // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
   // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
   // attributes which were applicable to the DWO units. The corresponding
   // DW_AT_* attributes standardized in DWARF v5 are also applicable to the

 }
 
 // Parses a compile unit and indexes its DIEs, m_die_array_mutex must be
 // held R/W and m_die_array must be empty.
 void DWARFUnit::ExtractDIEsRWLocked() {
   llvm::sys::ScopedWriter first_die_lock(m_first_die_mutex);
 
   ElapsedTime elapsed(m_dwarf.GetDebugInfoParseTimeRef());
-  LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractDIEsIfNeeded()", GetOffset());
+  LLDB_SCOPED_TIMERF(
+      "%s",
+      llvm::formatv("{0:x16}: DWARFUnit::ExtractDIEsIfNeeded()", GetOffset())
+          .str()
+          .c_str());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
   lldb::offset_t next_cu_offset = GetNextUnitOffset();
 
   DWARFDebugInfoEntry die;
 

 
 void DWARFUnit::SetLoclistsBase(dw_addr_t loclists_base) {
   uint64_t offset = 0;
   if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     const auto *contribution = entry->getContribution(llvm::DW_SECT_LOCLISTS);
     if (!contribution) {
       GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "Failed to find location list contribution for CU with DWO Id "
-          "0x%" PRIx64,
+          "{0:x16}",
           *GetDWOId());
       return;
     }
     offset += contribution->Offset;
   }
   m_loclists_base = loclists_base;
 
   uint64_t header_size = llvm::DWARFListTableHeader::getHeaderSize(DWARF32);
   if (loclists_base < header_size)
     return;
 
   m_loclist_table_header.emplace(".debug_loclists", "locations");
   offset += loclists_base - header_size;
   if (llvm::Error E = m_loclist_table_header->extract(
           m_dwarf.GetDWARFContext().getOrLoadLocListsData().GetAsLLVM(),
           &offset)) {
     GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-        "Failed to extract location list table at offset 0x%" PRIx64
-        " (location list base: 0x%" PRIx64 "): %s",
+        "Failed to extract location list table at offset {0:x16} (location "
+        "list base: {1:x16}): {2}",
         offset, loclists_base, toString(std::move(E)).c_str());
   }
 }
 
 std::unique_ptr<llvm::DWARFLocationTable>
 DWARFUnit::GetLocationTable(const DataExtractor &data) const {
   llvm::DWARFDataExtractor llvm_data(
       data.GetData(), data.GetByteOrder() == lldb::eByteOrderLittle,
DWARFDataExtractor DWARFUnit::GetRnglistData() const {
   DWARFContext &Ctx = GetSymbolFileDWARF().GetDWARFContext();
   const DWARFDataExtractor &data = Ctx.getOrLoadRngListsData();
   if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     if (const auto *contribution =
             entry->getContribution(llvm::DW_SECT_RNGLISTS))
       return DWARFDataExtractor(data, contribution->Offset,
                                 contribution->Length);
     GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-        "Failed to find range list contribution for CU with signature "
-        "0x%" PRIx64,
+        "Failed to find range list contribution for CU with signature {0:x16}",
         entry->getSignature());
 
     return DWARFDataExtractor();
   }
   return data;
 }
 
 void DWARFUnit::SetRangesBase(dw_addr_t ranges_base) {
   lldbassert(!m_rnglist_table_done);
 
   m_ranges_base = ranges_base;
 }
 
 const llvm::Optional<llvm::DWARFDebugRnglistTable> &
 DWARFUnit::GetRnglistTable() {
   if (GetVersion() >= 5 && !m_rnglist_table_done) {
     m_rnglist_table_done = true;
     if (auto table_or_error =
             ParseListTableHeader<llvm::DWARFDebugRnglistTable>(
                 GetRnglistData().GetAsLLVM(), m_ranges_base, DWARF32))
       m_rnglist_table = std::move(table_or_error.get());
     else
       GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-          "Failed to extract range list table at offset 0x%" PRIx64 ": %s",
+          "Failed to extract range list table at offset {0:x16}: {1}",
           m_ranges_base, toString(table_or_error.takeError()).c_str());
   }
   return m_rnglist_table;
 }
 
 // This function is called only for DW_FORM_rnglistx.
 llvm::Expected<uint64_t> DWARFUnit::GetRnglistOffset(uint32_t Index) {
   if (!GetRnglistTable())
     return llvm::createStringError(std::errc::invalid_argument,
                                    "missing or invalid range list table");
   if (!m_ranges_base)
-    return llvm::createStringError(std::errc::invalid_argument,
-                                   "DW_FORM_rnglistx cannot be used without "
-                                   "DW_AT_rnglists_base for CU at 0x%8.8x",
-                                   GetOffset());
+    return llvm::createStringError(
+        std::errc::invalid_argument,
+        llvm::formatv("DW_FORM_rnglistx cannot be used without "
+                      "DW_AT_rnglists_base for CU at {0:x16}",
+                      GetOffset())
+            .str()
+            .c_str());
   if (std::optional<uint64_t> off = GetRnglistTable()->getOffsetEntry(
           GetRnglistData().GetAsLLVM(), Index))
     return *off + m_ranges_base;
   return llvm::createStringError(
       std::errc::invalid_argument,
       "invalid range list table index %u; OffsetEntryCount is %u, "
       "DW_AT_rnglists_base is %" PRIu64,
       Index, GetRnglistTable()->getOffsetEntryCount(), m_ranges_base);

 // DIE from this compile unit. Otherwise we grab the DIE from the DWARF file.
 DWARFDIE
 DWARFUnit::GetDIE(dw_offset_t die_offset) {
   if (die_offset == DW_INVALID_OFFSET)
     return DWARFDIE(); // Not found
 
   if (!ContainsDIEOffset(die_offset)) {
     GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
-        "GetDIE for DIE 0x%" PRIx32 " is outside of its CU 0x%" PRIx32,
-        die_offset, GetOffset());
+        "GetDIE for DIE {0:x16} is outside of its CU {0:x16}", die_offset,
+        GetOffset());
     return DWARFDIE(); // Not found
   }
 
   ExtractDIEsIfNeeded();
   DWARFDebugInfoEntry::const_iterator end = m_die_array.cend();
   DWARFDebugInfoEntry::const_iterator pos =
       lower_bound(m_die_array.cbegin(), end, die_offset, CompareDIEOffset);
 

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 }
 
 void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
                                  IndexSet &set) {
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     m_module.LogMessage(
-        log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
+        log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[{0:x16}]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
 
   // First check if the unit has a DWO ID. If it does then we only want to index
   // the .dwo file or nothing at all. If we have a compile unit where we can't
   // locate the .dwo/.dwp file we don't want to index anything from the skeleton

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 //===-- SymbolFileDWARF.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARF.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 
 #include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
if (section != nullptr) {
         abbrev->GetUnsupportedForms(invalid_forms);
         if (!invalid_forms.empty()) {
           StreamString error;
           error.Printf("unsupported DW_FORM value%s:",
                        invalid_forms.size() > 1 ? "s" : "");
           for (auto form : invalid_forms)
             error.Printf(" %#x", form);
           m_objfile_sp->GetModule()->ReportWarning(
-              "%s", error.GetString().str().c_str());
+              "{0}", error.GetString().str().c_str());
           return 0;
         }
       }
 
       section =
           section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
               .get();
       if (section)
case DW_TAG_lexical_block: {
         for (size_t i = 0; i < num_ranges; ++i) {
           const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
           const addr_t range_base = range.GetRangeBase();
           if (range_base >= subprogram_low_pc)
             block->AddRange(Block::Range(range_base - subprogram_low_pc,
                                          range.GetByteSize()));
           else {
             GetObjectFile()->GetModule()->ReportError(
-                "0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64
-                ") which has a base that is less than the function's low PC "
-                "0x%" PRIx64 ". Please file a bug and attach the file at the "
+                "{0x:+8}: adding range [{1:x16}-{2:x16}) which has a base "
+                "that is less than the function's low PC {3:x16}. Please file "
+                "a bug and attach the file at the "
                 "start of this error message",
                 block->GetID(), range_base, range.GetRangeEnd(),
                 subprogram_low_pc);
           }
         }
         block->FinalizeRanges();
 
         if (tag != DW_TAG_subprogram &&

 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
                                       bool assert_not_being_parsed) {
   if (die) {
     Log *log = GetLog(DWARFLog::DebugInfo);
     if (log)
       GetObjectFile()->GetModule()->LogMessage(
-          log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
+          log, "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) {1} '{2}'",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
     // We might be coming in in the middle of a type tree (a class within a
     // class, an enum within a class), so parse any needed parent DIEs before
     // we get to this one...
     DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
     if (decl_ctx_die) {
       if (log) {
         switch (decl_ctx_die.Tag()) {
         case DW_TAG_structure_type:
         case DW_TAG_union_type:
         case DW_TAG_class_type: {
           // Get the type, which could be a forward declaration
           if (log)
             GetObjectFile()->GetModule()->LogMessage(
                 log,
-                "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
-                "resolve parent forward type for 0x%8.8x",
+                "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) "
+                "{1} '{2}' "
+                "resolve parent forward type for {3:x16})",
                 die.GetOffset(), die.GetTagAsCString(), die.GetName(),
                 decl_ctx_die.GetOffset());
         } break;
 
         default:
           break;
         }
       }
if (dwarf_die) {
     // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
     GetForwardDeclClangTypeToDie().erase(die_it);
 
     Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
 
     Log *log = GetLog(DWARFLog::DebugInfo | DWARFLog::TypeCompletion);
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
-          log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
+          log, "{0:x8}: {1} '{2}' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
     if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
       return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
   }
   return false;
 }
 
 Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
                                    bool assert_not_being_parsed,
                                    bool resolve_function_context) {
   if (die) {
     Type *type = GetTypeForDIE(die, resolve_function_context).get();
 
     if (assert_not_being_parsed) {
       if (type != DIE_IS_BEING_PARSED)
         return type;
 
       GetObjectFile()->GetModule()->ReportError(
-          "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
+          "Parsing a die that is being parsed die: {0:x16}: {1} {2}",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
     } else
       return type;
   }
   return nullptr;
 }
 
SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
   DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit);
   // Only compile units can be split into two parts and we should only
   // look for a DWO file if there is a valid DWO ID.
   if (!dwarf_cu || !dwarf_cu->GetDWOId().has_value())
     return nullptr;
 
   const char *dwo_name = GetDWOName(*dwarf_cu, cu_die);
   if (!dwo_name) {
-    unit.SetDwoError(Status("missing DWO name in skeleton DIE 0x%8.8" PRIx32,
-                            cu_die.GetOffset()));
+    unit.SetDwoError(Status::createWithFormat(
+        "missing DWO name in skeleton DIE {0:x16}", cu_die.GetOffset()));
     return nullptr;
   }
 
   if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile())
     return dwp_sp;
 
   const char *comp_dir = nullptr;
   FileSpec dwo_file(dwo_name);
   FileSystem::Instance().Resolve(dwo_file);
   if (dwo_file.IsRelative()) {
     comp_dir = cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir,
                                                 nullptr);
     if (!comp_dir) {
-      unit.SetDwoError(
-          Status("unable to locate relative .dwo debug file \"%s\" for "
-                 "skeleton DIE 0x%8.8" PRIx32 " without valid DW_AT_comp_dir "
-                 "attribute", dwo_name, cu_die.GetOffset()));
+      unit.SetDwoError(Status::createWithFormat(
+          "unable to locate relative .dwo debug file \"{0}\" for "
+          "skeleton DIE {1:x16} without valid DW_AT_comp_dir "
+          "attribute",
+          dwo_name, cu_die.GetOffset()));
       return nullptr;
     }
 
     dwo_file.SetFile(comp_dir, FileSpec::Style::native);
     if (dwo_file.IsRelative()) {
       // if DW_AT_comp_dir is relative, it should be relative to the location
       // of the executable, not to the location from which the debugger was
       // launched.
       dwo_file.PrependPathComponent(
           m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef());
     }
     FileSystem::Instance().Resolve(dwo_file);
     dwo_file.AppendPathComponent(dwo_name);
   }
 
   if (!FileSystem::Instance().Exists(dwo_file)) {
-    unit.SetDwoError(
-        Status("unable to locate .dwo debug file \"%s\" for skeleton DIE "
-               "0x%8.8" PRIx32, dwo_file.GetPath().c_str(),
-               cu_die.GetOffset()));
+    unit.SetDwoError(Status::createWithFormat(
+        "unable to locate .dwo debug file \"{0}\" for skeleton DIE "
+        "{1:x16}",
+        dwo_file.GetPath().c_str(), cu_die.GetOffset()));
 
     if (m_dwo_warning_issued.test_and_set(std::memory_order_relaxed) == false) {
       GetObjectFile()->GetModule()->ReportWarning(
           "unable to locate separate debug file (dwo, dwp). Debugging will be "
           "degraded.");
     }
     return nullptr;
   }
 
   const lldb::offset_t file_offset = 0;
   DataBufferSP dwo_file_data_sp;
   lldb::offset_t dwo_file_data_offset = 0;
   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
       GetObjectFile()->GetModule(), &dwo_file, file_offset,
       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
       dwo_file_data_offset);
   if (dwo_obj_file == nullptr) {
-    unit.SetDwoError(
-          Status("unable to load object file for .dwo debug file \"%s\" for "
-                 "unit DIE 0x%8.8" PRIx32, dwo_name, cu_die.GetOffset()));
+    unit.SetDwoError(Status::createWithFormat(
+        "unable to load object file for .dwo debug file \"{0}\" for "
+        "unit DIE {1:x16}",
+        dwo_name, cu_die.GetOffset()));
     return nullptr;
   }
 
   return std::make_shared<SymbolFileDWARFDwo>(*this, dwo_obj_file,
                                               dwarf_cu->GetID());
 }
 
 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
if (m_objfile_sp->GetFileSpec().GetFileNameExtension() == ".dwo" &&
             .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
       continue;
     }
 
     Status error = ModuleList::GetSharedModule(dwo_module_spec, module_sp,
                                                nullptr, nullptr, nullptr);
     if (!module_sp) {
       GetObjectFile()->GetModule()->ReportWarning(
-          "0x%8.8x: unable to locate module needed for external types: "
-          "%s\nerror: %s\nDebugging will be degraded due to missing "
+          "{0:x16}: unable to locate module needed for external types: "
+          "{1}\nerror: {2}\nDebugging will be degraded due to missing "
           "types. Rebuilding the project will regenerate the needed "
           "module files.",
           die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str(),
           error.AsCString("unknown error"));
       continue;
     }
 
     // Verify the DWO hash.
     // FIXME: Technically "0" is a valid hash.
     llvm::Optional<uint64_t> dwo_id = ::GetDWOId(*dwarf_cu, *die.GetDIE());
     if (!dwo_id)
       continue;
 
     auto *dwo_symfile =
         llvm::dyn_cast_or_null<SymbolFileDWARF>(module_sp->GetSymbolFile());
     if (!dwo_symfile)
       continue;
     llvm::Optional<uint64_t> dwo_dwo_id = dwo_symfile->GetDWOId();
     if (!dwo_dwo_id)
       continue;
 
     if (dwo_id != dwo_dwo_id) {
       GetObjectFile()->GetModule()->ReportWarning(
-          "0x%8.8x: Module %s is out-of-date (hash mismatch). Type information "
+          "{0:x16}: Module {1} is out-of-date (hash mismatch). Type "
+          "information "
           "from this module may be incomplete or inconsistent with the rest of "
           "the program. Rebuilding the project will regenerate the needed "
           "module files.",
           die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str());
     }
   }
 }
 
if (cu_offset == DW_INVALID_OFFSET) {
             // Discontiguous compile unit address ranges should only happen when
             // there aren't other functions from other compile units in these
             // gaps. This helps keep the size of the aranges down.
             sc.comp_unit = nullptr;
             resolved &= ~eSymbolContextCompUnit;
           }
         } else {
           GetObjectFile()->GetModule()->ReportWarning(
-              "0x%8.8x: compile unit %u failed to create a valid "
+              "{0:x16}: compile unit {1} failed to create a valid "
               "lldb_private::CompileUnit class.",
               cu_offset, cu_idx);
         }
       }
     }
   }
   return resolved;
 }
void SymbolFileDWARF::FindGlobalVariables(
     ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
-        "parent_decl_ctx=%p, max_matches=%u, variables)",
+        "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
+        "parent_decl_ctx={1:p}, max_matches={2}, variables)",
         name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
         max_matches);
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
     return variables.GetSize() - original_size < max_matches;
   });
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
-        "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
+        "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
+        "parent_decl_ctx={1:p}, max_matches={2}, variables) => {3}",
         name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
         max_matches, num_matches);
   }
 }
 
 void SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
                                           uint32_t max_matches,
                                           VariableList &variables) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
-        "max_matches=%u, variables)",
+        "SymbolFileDWARF::FindGlobalVariables (regex=\"{0}\", "
+        "max_matches={1}, variables)",
         regex.GetText().str().c_str(), max_matches);
   }
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   SymbolContext sc;
   m_index->GetGlobalVariables(regex, [&](DWARFDIE die) {
void SymbolFileDWARF::FindFunctions(const Module::LookupInfo &lookup_info,
   // Module::LookupInfo::LookupInfo()
   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, "
+        "SymbolFileDWARF::FindFunctions (name=\"{0}\", name_type_mask={1:x}, "
         "sc_list)",
         name.GetCString(), name_type_mask);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
   // If name is empty then we won't find anything.
void SymbolFileDWARF::FindFunctions(const Module::LookupInfo &lookup_info,
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindFunctions (name=\"%s\", "
-        "name_type_mask=0x%x, include_inlines=%d, sc_list) => %u",
+        "SymbolFileDWARF::FindFunctions (name=\"{0}\", "
+        "name_type_mask={1:x}, include_inlines={2:d}, sc_list) => {3}",
         name.GetCString(), name_type_mask, include_inlines, num_matches);
   }
 }
 
 void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
                                     bool include_inlines,
                                     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (regex = '%s')",
                      regex.GetText().str().c_str());
 
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
-        log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
+        log, "SymbolFileDWARF::FindFunctions (regex=\"{0}\", sc_list)",
         regex.GetText().str().c_str());
   }
 
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
   m_index->GetFunctions(regex, [&](DWARFDIE die) {
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
     return true;
if (!searched_symbol_files.insert(this).second)
     return;
 
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     if (parent_decl_ctx)
       GetObjectFile()->GetModule()->LogMessage(
           log,
-          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
-          "%p (\"%s\"), max_matches=%u, type_list)",
+          "SymbolFileDWARF::FindTypes (sc, name=\"{0}\", parent_decl_ctx = "
+          "{1:p} (\"{2}\"), max_matches={3}, type_list)",
           name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
           parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches);
     else
       GetObjectFile()->GetModule()->LogMessage(
           log,
-          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
-          "NULL, max_matches=%u, type_list)",
+          "SymbolFileDWARF::FindTypes (sc, name=\"{0}\", parent_decl_ctx = "
+          "NULL, max_matches={1}, type_list)",
           name.GetCString(), max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
   // Unlike FindFunctions(), FindTypes() following cannot produce false
   // positives.
for (const auto &pair : m_external_type_modules)
           sym_file->FindTypes(name, parent_decl_ctx, max_matches,
                               searched_symbol_files, types);
   }
 
   if (log && types.GetSize()) {
     if (parent_decl_ctx) {
       GetObjectFile()->GetModule()->LogMessage(
           log,
-          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
-          "= %p (\"%s\"), max_matches=%u, type_list) => %u",
+          "SymbolFileDWARF::FindTypes (sc, name=\"{0}\", parent_decl_ctx "
+          "= {1:p} (\"{2}\"), max_matches={3}, type_list) => {4}",
           name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
           parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches,
           types.GetSize());
     } else {
       GetObjectFile()->GetModule()->LogMessage(
           log,
-          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
-          "= NULL, max_matches=%u, type_list) => %u",
+          "SymbolFileDWARF::FindTypes (sc, name=\"{0}\", parent_decl_ctx "
+          "= NULL, max_matches={1}, type_list) => {2}",
           name.GetCString(), max_matches, types.GetSize());
     }
   }
 }
 
 void SymbolFileDWARF::FindTypes(
     llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {

 CompilerDeclContext
 SymbolFileDWARF::FindNamespace(ConstString name,
                                const CompilerDeclContext &parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log = GetLog(DWARFLog::Lookups);
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
-        log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
+        log, "SymbolFileDWARF::FindNamespace (sc, name=\"{0}\")",
         name.GetCString());
   }
 
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
   m_index->GetNamespaces(name, [&](DWARFDIE die) {
     if (!DIEInDeclContext(parent_decl_ctx, die))
       return true; // The containing decl contexts don't match
 
     DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
     if (!dwarf_ast)
       return true;
 
     namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
     return !namespace_decl_ctx.IsValid();
   });
 
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
-        "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
-        "CompilerDeclContext(%p/%p) \"%s\"",
+        "SymbolFileDWARF::FindNamespace (sc, name=\"{0}\") => "
+        "CompilerDeclContext({1:p}/{2:p}) \"{3}\"",
         name.GetCString(),
         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
         namespace_decl_ctx.GetName().AsCString("<NULL>"));
   }
 
   return namespace_decl_ctx;
 }
SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(const DWARFDIE &die) {
   if (die.GetName()) {
     const dw_tag_t tag = die.Tag();
 
     Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups);
     if (log) {
       GetObjectFile()->GetModule()->LogMessage(
           log,
           "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
-          "s, name='%s')",
+          "s, name='{0}')",
           DW_TAG_value_to_name(tag), die.GetName());
     }
 
     // Get the type system that we are looking to find a type for. We will
     // use this to ensure any matches we find are in a language that this
     // type system supports
     const LanguageType language = GetLanguage(*die.GetCU());
     TypeSystemSP type_system = nullptr;
m_index->GetTypes(GetDWARFDeclContext(die), [&](DWARFDIE type_die) {
         }
       }
 
       if (!try_resolving_type) {
         if (log) {
           GetObjectFile()->GetModule()->LogMessage(
               log,
               "SymbolFileDWARF::"
-              "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
-              "name='%s') ignoring die=0x%8.8x (%s)",
+              "FindDefinitionTypeForDWARFDeclContext(tag={0}, "
+              "name='{1}') ignoring die={2:x16} ({3})",
               DW_TAG_value_to_name(tag), die.GetName(), type_die.GetOffset(),
               type_die.GetName());
         }
         return true;
       }
 
       DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(type_die);
 
       if (log) {
         GetObjectFile()->GetModule()->LogMessage(
             log,
             "SymbolFileDWARF::"
-            "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
-            "name='%s') trying die=0x%8.8x (%s)",
+            "FindDefinitionTypeForDWARFDeclContext(tag={0}, "
+            "name='{1}') trying die={2:x16} ({3})",
             DW_TAG_value_to_name(tag), die.GetName(), type_die.GetOffset(),
             type_dwarf_decl_ctx.GetQualifiedName());
       }
 
       // Make sure the decl contexts match all the way up
       if (GetDWARFDeclContext(die) != type_dwarf_decl_ctx)
         return true;
 
if (!location_is_const_value_data) {
       const DWARFExpression* location = location_list.GetAlwaysValidExpr();
       if (location)
         location_DW_OP_addr = location->GetLocation_DW_OP_addr(
             location_form.GetUnit(), 0, op_error);
       if (op_error) {
         StreamString strm;
         location->DumpLocation(&strm, eDescriptionLevelFull, nullptr);
         GetObjectFile()->GetModule()->ReportError(
-            "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
+            "{0:x16}: {1} has an invalid location: {2}", die.GetOffset(),
             die.GetTagAsCString(), strm.GetData());
       }
       if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
         is_static_lifetime = true;
     }
     SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
     if (debug_map_symfile)
       // Set the module of the expression to the linked module
void SymbolFileDWARF::ParseAndAppendGlobalVariable(
   dw_tag_t parent_tag = sc_parent_die.Tag();
   switch (parent_tag) {
   case DW_TAG_compile_unit:
   case DW_TAG_partial_unit:
     if (sc.comp_unit != nullptr) {
       variable_list_sp = sc.comp_unit->GetVariableList(false);
     } else {
       GetObjectFile()->GetModule()->ReportError(
-          "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
-          "symbol context for 0x%8.8" PRIx64 " %s.\n",
+          "parent {0:x8} {1} with no valid compile unit in "
+          "symbol context for {2:x8} {3}.\n",
           sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(), die.GetID(),
           die.GetTagAsCString());
       return;
     }
     break;
 
   default:
     GetObjectFile()->GetModule()->ReportError(
-        "didn't find appropriate parent DIE for variable list for "
-        "0x%8.8" PRIx64 " %s.\n",
+        "didn't find appropriate parent DIE for variable list for {0:x8} "
+        "{1}.\n",
         die.GetID(), die.GetTagAsCString());
     return;
   }
 
   var_sp = ParseVariableDIECached(sc, die);
   if (!var_sp)
     return;
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (oso_index_count > 0) {
           m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
           m_compile_unit_infos[i].oso_mod_time =
               llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
           // The sibling index can't be less that or equal to the current index
           // "i"
           if (sibling_idx == UINT32_MAX) {
             m_objfile_sp->GetModule()->ReportError(
-                "N_SO in symbol with UID %u has invalid sibling in debug map, "
+                "N_SO in symbol with UID {0} has invalid sibling in debug "
+                "map, "
                 "please file a bug and attach the binary listed in this error",
                 so_symbol->GetID());
           } else {
             const Symbol *last_symbol = symtab->SymbolAtIndex(sibling_idx - 1);
             m_compile_unit_infos[i].first_symbol_index = so_idx;
             m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1;
             m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
             m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
 
             LLDB_LOGF(log, "Initialized OSO 0x%8.8x: file=%s", i,
                       oso_symbol->GetName().GetCString());
           }
         } else {
           if (oso_symbol == nullptr)
             m_objfile_sp->GetModule()->ReportError(
-                "N_OSO symbol[%u] can't be found, please file a bug and attach "
+                "N_OSO symbol[{0}] can't be found, please file a bug and "
+                "attach "
                 "the binary listed in this error",
                 oso_idx);
           else if (so_symbol == nullptr)
             m_objfile_sp->GetModule()->ReportError(
-                "N_SO not found for N_OSO symbol[%u], please file a bug and "
+                "N_SO not found for N_OSO symbol[{0}], please file a bug and "
                 "attach the binary listed in this error",
                 oso_idx);
           else if (so_symbol->GetType() != eSymbolTypeSourceFile)
             m_objfile_sp->GetModule()->ReportError(
-                "N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], "
+                "N_SO has incorrect symbol type ({0}) for N_OSO "
+                "symbol[{1}], "
                 "please file a bug and attach the binary listed in this error",
                 so_symbol->GetType(), oso_idx);
           else if (oso_symbol->GetType() != eSymbolTypeSourceFile)
             m_objfile_sp->GetModule()->ReportError(
-                "N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], "
+                "N_OSO has incorrect symbol type ({0}) for N_OSO "
+                "symbol[{1}], "
                 "please file a bug and attach the binary listed in this error",
                 oso_symbol->GetType(), oso_idx);
         }
       }
     }
   }
 }
 
if (pos != m_oso_map.end()) {
         if (comp_unit_info->oso_mod_time != llvm::sys::TimePoint<>() &&
             oso_mod_time != comp_unit_info->oso_mod_time) {
           comp_unit_info->oso_load_error.SetErrorStringWithFormat(
               "debug map object file \"%s\" changed (actual: 0x%8.8x, debug "
               "map: 0x%8.8x) since this executable was linked, debug info "
               "will not be loaded", oso_file.GetPath().c_str(),
               (uint32_t)llvm::sys::toTimeT(oso_mod_time),
               (uint32_t)llvm::sys::toTimeT(comp_unit_info->oso_mod_time));
-          obj_file->GetModule()->ReportError("%s",
-              comp_unit_info->oso_load_error.AsCString());
+          obj_file->GetModule()->ReportError(
+              "{0}", comp_unit_info->oso_load_error.AsCString());
           return nullptr;
         }
 
       } else {
         const bool must_exist = true;
 
         if (!ObjectFile::SplitArchivePathWithObject(oso_path, oso_file,
                                                     oso_object, must_exist)) {

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

case S_BLOCK32: {
     lldb::addr_t block_base =
         m_index->MakeVirtualAddress(block.Segment, block.CodeOffset);
     lldb::addr_t func_base =
         func->GetAddressRange().GetBaseAddress().GetFileAddress();
     if (block_base >= func_base)
       child_block->AddRange(Block::Range(block_base - func_base, block.CodeSize));
     else {
       GetObjectFile()->GetModule()->ReportError(
-          "S_BLOCK32 at modi: %d offset: %d: adding range [0x%" PRIx64
-          "-0x%" PRIx64 ") which has a base that is less than the function's "
+          "S_BLOCK32 at modi: {0:d} offset: {1:d}: adding range "
+          "[{2:x16}-{3:x16}) which has a base that is less than the "
+          "function's "
           "low PC 0x%" PRIx64 ". Please file a bug and attach the file at the "
           "start of this error message",
           block_id.modi, block_id.offset, block_base,
           block_base + block.CodeSize, func_base);
     }
     parent_block.AddChild(child_block);
     ast_builder->GetOrCreateBlockDecl(block_id);
     m_blocks.insert({opaque_block_uid, child_block});

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

while (auto member = members_enum.getNext()) {
 
     auto member_type = symbol_file.ResolveTypeUID(member->getTypeId());
     if (!member_type)
       continue;
 
     auto member_comp_type = member_type->GetLayoutCompilerType();
     if (!member_comp_type.GetCompleteType()) {
       symbol_file.GetObjectFile()->GetModule()->ReportError(
-          ":: Class '%s' has a member '%s' of type '%s' "
+          ":: Class '{0}' has a member '{1}' of type '{2}' "
           "which does not have a complete definition.",
           record_type.GetTypeName().GetCString(), member_name.c_str(),
           member_comp_type.GetTypeName().GetCString());
       if (TypeSystemClang::StartTagDeclarationDefinition(member_comp_type))
         TypeSystemClang::CompleteTagDeclarationDefinition(member_comp_type);
     }
 
     auto access = TranslateMemberAccess(member->getAccess());
void PDBASTParser::AddRecordBases(
   while (auto base = bases_enum.getNext()) {
     auto base_type = symbol_file.ResolveTypeUID(base->getTypeId());
     if (!base_type)
       continue;
 
     auto base_comp_type = base_type->GetFullCompilerType();
     if (!base_comp_type.GetCompleteType()) {
       symbol_file.GetObjectFile()->GetModule()->ReportError(
-          ":: Class '%s' has a base class '%s' "
+          ":: Class '{0}' has a base class '{1}' "
           "which does not have a complete definition.",
           record_type.GetTypeName().GetCString(),
           base_comp_type.GetTypeName().GetCString());
       if (TypeSystemClang::StartTagDeclarationDefinition(base_comp_type))
         TypeSystemClang::CompleteTagDeclarationDefinition(base_comp_type);
     }
 
     auto access = TranslateMemberAccess(base->getAccess());
PDBASTParser::AddRecordMethod(lldb_private::SymbolFile &symbol_file,
   Type *method_type = symbol_file.ResolveTypeUID(method.getSymIndexId());
   // MSVC specific __vecDelDtor.
   if (!method_type)
     return nullptr;
 
   CompilerType method_comp_type = method_type->GetFullCompilerType();
   if (!method_comp_type.GetCompleteType()) {
     symbol_file.GetObjectFile()->GetModule()->ReportError(
-        ":: Class '%s' has a method '%s' whose type cannot be completed.",
+        ":: Class '{0}' has a method '{1}' whose type cannot be completed.",
         record_type.GetTypeName().GetCString(),
         method_comp_type.GetTypeName().GetCString());
     if (TypeSystemClang::StartTagDeclarationDefinition(method_comp_type))
       TypeSystemClang::CompleteTagDeclarationDefinition(method_comp_type);
   }
 
   AccessType access = TranslateMemberAccess(method.getAccess());
   if (access == eAccessNone)

lldb/source/Symbol/CompileUnit.cpp

if (resolve_scope == eSymbolContextLineEntry) {
         if (resolved_sc.comp_unit == nullptr && resolved_sc.module_sp) {
           // Only report an error if we don't map back to any compile unit. With
           // link time optimizations, the debug info might have many compile
           // units that have the same address range due to function outlining
           // or other link time optimizations. If the compile unit is NULL, then
           // address resolving is completely failing and more deserving of an
           // error message the user can see.
           resolved_sc.module_sp->ReportError(
-              "unable to resolve a line table file address 0x%" PRIx64 " back "
+              "unable to resolve a line table file address {0:x16} back "
               "to a compile unit, please file a bug and attach the address "
-              "and file.", line_entry.range.GetBaseAddress().GetFileAddress());
+              "and file.",
+              line_entry.range.GetBaseAddress().GetFileAddress());
         }
         sc_list.Append(sc);
       }
     }
 
     if (num_file_indexes == 1)
       line_idx = line_table->FindLineEntryIndexByFileIndex(
           line_idx + 1, file_indexes.front(), found_entry, &line_entry);

lldb/source/Symbol/DWARFCallFrameInfo.cpp

if (!HandleCommonDwarfOpcode(primary_opcode, extended_opcode, data_align,
           // These instructions define a stack of information. Encountering the
           // DW_CFA_remember_state instruction means to save the rules for
           // every register on the current row on the stack. Encountering the
           // DW_CFA_restore_state instruction means to pop the set of rules off
           // the stack and place them in the current row. (This operation is
           // useful for compilers that move epilogue code into the body of a
           // function.)
           if (stack.empty()) {
-            LLDB_LOGF(log,
-                      "DWARFCallFrameInfo::%s(dwarf_offset: %" PRIx32
-                      ", startaddr: %" PRIx64
-                      " encountered DW_CFA_restore_state but state stack "
-                      "is empty. Corrupt unwind info?",
-                      __FUNCTION__, dwarf_offset, startaddr.GetFileAddress());
+            LLDB_LOG(log,
+                     "DWARFCallFrameInfo::{0}(dwarf_offset: "
+                     "{1:x16}, startaddr: [{2:x16}] encountered "
+                     "DW_CFA_restore_state but state stack "
             break;
           }
           lldb::addr_t offset = row->GetOffset();
           row = stack.back();
           stack.pop_back();
           row->SetOffset(offset);
           break;
         }
 

lldb/source/Target/SectionLoadList.cpp

if (ats_pos != m_addr_to_sect.end()) {
       // shared the same "__LINKEDIT" sections, so the dynamic loader can pass
       // false for "warn_multiple").
       if (warn_multiple && section != ats_pos->second) {
         ModuleSP module_sp(section->GetModule());
         if (module_sp) {
           ModuleSP curr_module_sp(ats_pos->second->GetModule());
           if (curr_module_sp) {
             module_sp->ReportWarning(
-                "address 0x%16.16" PRIx64
-                " maps to more than one section: %s.%s and %s.%s",
+                "address {0:x16} maps to more than one section: {1}.{2} and "
+                "{3}.{4}",
                 load_addr, module_sp->GetFileSpec().GetFilename().GetCString(),
                 section->GetName().GetCString(),
                 curr_module_sp->GetFileSpec().GetFilename().GetCString(),
                 ats_pos->second->GetName().GetCString());
           }
         }
       }
       ats_pos->second = section;

lldb/test/Shell/SymbolFile/DWARF/DW_AT_range-DW_FORM_sec_offset.s

 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj \
 # RUN:   --defsym RNGLISTX=0 %s > %t-rnglistx
 # RUN: %lldb %t-rnglistx -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit 2>%t.error | FileCheck --check-prefix=RNGLISTX %s
 # RUN: cat %t.error | FileCheck --check-prefix=ERROR %s
 
 # RNGLISTX-LABEL: image lookup -v -s lookup_rnglists
-# ERROR: error: {{.*}} {0x0000003f}: DIE has DW_AT_ranges(DW_FORM_rnglistx 0x0) attribute, but range extraction failed (DW_FORM_rnglistx cannot be used without DW_AT_rnglists_base for CU at 0x00000000), please file a bug and attach the file at the start of this error message
+# ERROR: error: {{.*}} [0x000000000000003f]: DIE has DW_AT_ranges(DW_FORM_rnglistx 0x0000000000000000) attribute, but range extraction failed (DW_FORM_rnglistx cannot be used without DW_AT_rnglists_base for CU at 0x0000000000000000), please file a bug and attach the file at the start of this error message
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj \
 # RUN:   --defsym RNGLISTX=0 --defsym RNGLISTBASE=0 %s > %t-rnglistbase
 # RUN: %lldb %t-rnglistbase -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit 2>%t.error | FileCheck --check-prefix=RNGLISTBASE %s
 # RUN: cat %t.error | FileCheck --check-prefix=ERRORBASE %s
 
 # RNGLISTBASE-LABEL: image lookup -v -s lookup_rnglists
-# ERRORBASE: error: {{.*}}-rnglistbase {0x00000043}: DIE has DW_AT_ranges(DW_FORM_rnglistx 0x0) attribute, but range extraction failed (invalid range list table index 0; OffsetEntryCount is 0, DW_AT_rnglists_base is 24), please file a bug and attach the file at the start of this error message
+# ERRORBASE: error: {{.*}}-rnglistbase [0x0000000000000043]: DIE has DW_AT_ranges(DW_FORM_rnglistx 0x0000000000000000) attribute, but range extraction failed (invalid range list table index 0; OffsetEntryCount is 0, DW_AT_rnglists_base is 24), please file a bug and attach the file at the start of this error message
 
         .text
 rnglists:
         nop
 .Lblock1_begin:
 lookup_rnglists:
         nop
 .Lblock1_end:

lldb/test/Shell/SymbolFile/DWARF/x86/debug_ranges-missing-section.s

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_ranges" -o exit 2>%t.error | FileCheck %s
 # RUN: cat %t.error | FileCheck %s --check-prefix ERROR
 
-# ERROR: DIE has DW_AT_ranges(DW_FORM_sec_offset 0x47) attribute, but range extraction failed (No debug_ranges section),
+# ERROR: DIE has DW_AT_ranges(DW_FORM_sec_offset 0x0000000000000047) attribute, but range extraction failed (No debug_ranges section),
 # CHECK:  Function: id = {0x0000001c}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
 # CHECK:    Blocks: id = {0x0000001c}, range = [0x00000000-0x00000004)
 
         .text
         .p2align 12
         .globl  ranges
         .type   ranges,@function
 ranges:                                    # @ranges