Fix formatting to match LLVM style

Author: UltimateForce21

lldb/include/lldb/Expression/DWARFExpressionList.h

@@ -59,7 +59,7 @@ class DWARFExpressionList {
   }
 
   lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; }
-  
+
   /// Represents an entry in the DWARFExpressionList with all needed metadata.
   struct DWARFExpressionEntry {
     /// Represents a DWARF location range in the DWARF unit’s file‐address space
@@ -69,7 +69,8 @@ class DWARFExpressionList {
 
   /// Returns a DWARFExpressionEntry whose file_range contains the given
   /// load‐address.  `func_load_addr` is the load‐address of the function
-  /// start; `load_addr` is the full runtime PC.  On success, `expr` is non-null.
+  /// start; `load_addr` is the full runtime PC.  On success, `expr` is
+  /// non-null.
   std::optional<DWARFExpressionEntry>
   GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
                               lldb::addr_t load_addr) const;

lldb/source/Expression/DWARFExpression.cpp

@@ -67,7 +67,8 @@ void DWARFExpression::UpdateValue(uint64_t const_value,
 }
 
 void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level,
-                                   ABI *abi, llvm::DIDumpOptions options) const {
+                                   ABI *abi,
+                                   llvm::DIDumpOptions options) const {
   auto *MCRegInfo = abi ? &abi->GetMCRegisterInfo() : nullptr;
   auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum,
                                  bool IsEH) -> llvm::StringRef {

lldb/source/Expression/DWARFExpressionList.cpp

@@ -6,7 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Core/AddressRange.h"
 #include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/Function.h"
@@ -57,28 +56,29 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t func_load_addr,
 
 std::optional<DWARFExpressionList::DWARFExpressionEntry>
 DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
-                                                lldb::addr_t load_addr) const {
+                                                 lldb::addr_t load_addr) const {
   if (const DWARFExpression *always = GetAlwaysValidExpr()) {
     return DWARFExpressionEntry{std::nullopt, always};
   }
 
   if (func_load_addr == LLDB_INVALID_ADDRESS)
     func_load_addr = m_func_file_addr;
 
-  // Guard against underflow when translating a load address back into file space.
+  // Guard against underflow when translating a load address back into file
+  // space.
   if (load_addr < func_load_addr)
-      return std::nullopt;
+    return std::nullopt;
 
   // Guard against overflow.
   lldb::addr_t delta = load_addr - func_load_addr;
   if (delta > std::numeric_limits<lldb::addr_t>::max() - m_func_file_addr)
     return std::nullopt;
 
   lldb::addr_t file_pc = (load_addr - func_load_addr) + m_func_file_addr;
-  
+
   if (const auto *entry = m_exprs.FindEntryThatContains(file_pc)) {
     AddressRange range_in_file(entry->GetRangeBase(),
-                              entry->GetRangeEnd() - entry->GetRangeBase());
+                               entry->GetRangeEnd() - entry->GetRangeBase());
     return DWARFExpressionEntry{range_in_file, &entry->data};
   }
 

llvm/lib/DebugInfo/DWARF/DWARFExpressionPrinter.cpp

@@ -68,23 +68,24 @@ static bool printOp(const DWARFExpression::Operation *Op, raw_ostream &OS,
 
   if (!DumpOpts.PrintRegisterOnly) {
     for (unsigned Operand = 0; Operand < Op->getDescription().Op.size();
-        ++Operand) {
+         ++Operand) {
       unsigned Size = Op->getDescription().Op[Operand];
       unsigned Signed = Size & DWARFExpression::Operation::SignBit;
 
       if (Size == DWARFExpression::Operation::SizeSubOpLEB) {
-        StringRef SubName =
-            SubOperationEncodingString(Op->getCode(), Op->getRawOperand(Operand));
+        StringRef SubName = SubOperationEncodingString(
+            Op->getCode(), Op->getRawOperand(Operand));
         assert(!SubName.empty() && "DW_OP SubOp has no name!");
         OS << " " << SubName;
       } else if (Size == DWARFExpression::Operation::BaseTypeRef && U) {
         // For DW_OP_convert the operand may be 0 to indicate that conversion to
-        // the generic type should be done. The same holds for DW_OP_reinterpret,
-        // which is currently not supported.
+        // the generic type should be done. The same holds for
+        // DW_OP_reinterpret, which is currently not supported.
         if (Op->getCode() == DW_OP_convert && Op->getRawOperand(Operand) == 0)
           OS << " 0x0";
         else
-          prettyPrintBaseTypeRef(U, OS, DumpOpts, Op->getRawOperands(), Operand);
+          prettyPrintBaseTypeRef(U, OS, DumpOpts, Op->getRawOperands(),
+                                 Operand);
       } else if (Size == DWARFExpression::Operation::WasmLocationArg) {
         assert(Operand == 1);
         switch (Op->getRawOperand(0)) {
@@ -102,12 +103,12 @@ static bool printOp(const DWARFExpression::Operation *Op, raw_ostream &OS,
         uint64_t Offset = Op->getRawOperand(Operand);
         for (unsigned i = 0; i < Op->getRawOperand(Operand - 1); ++i)
           OS << format(" 0x%02x",
-                      static_cast<uint8_t>(Expr->getData()[Offset++]));
+                       static_cast<uint8_t>(Expr->getData()[Offset++]));
       } else {
         if (Signed)
           OS << format(" %+" PRId64, (int64_t)Op->getRawOperand(Operand));
         else if (Op->getCode() != DW_OP_entry_value &&
-                Op->getCode() != DW_OP_GNU_entry_value)
+                 Op->getCode() != DW_OP_GNU_entry_value)
           OS << format(" 0x%" PRIx64, Op->getRawOperand(Operand));
       }
     }