[lldb][NFCI] Remove custom dwarf LEB128 types

[bulbazord]

Summary

The LEB128 type defined by the DWARF standard is explicitly a variable-length
encoding of an integer. LLDB had defined uleb128 and sleb128 types
to be 32-bit but in many places in both LLVM and LLDB we treat the maximum
width of LEB128 types to be 64, so let's remove these types and be
consistent.

[fdeazeve]

Nice cleanup! This gets rid of some implicit conversions

[rastogishubham]

LGTM!

lldb/include/lldb/Core/dwarf.h

 #include "llvm/BinaryFormat/Dwarf.h"
 
 namespace lldb_private {
 namespace dwarf {
   using namespace llvm::dwarf;
 }
 }
 
-typedef uint32_t dw_uleb128_t;
-typedef int32_t dw_sleb128_t;
 typedef uint16_t dw_attr_t;
 typedef uint16_t dw_form_t;
 typedef llvm::dwarf::Tag dw_tag_t;
 typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
                             // any addresses in the compile units that get
                             // parsed
 
 typedef uint64_t dw_offset_t; // Dwarf Debug Information Entry offset for any

lldb/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h

 class DWARFAbbreviationDeclaration {
 public:
   enum { InvalidCode = 0 };
   DWARFAbbreviationDeclaration();
 
   // For hand crafting an abbreviation declaration
   DWARFAbbreviationDeclaration(dw_tag_t tag, uint8_t has_children);
 
-  dw_uleb128_t Code() const { return m_code; }
-  void SetCode(dw_uleb128_t code) { m_code = code; }
+  uint32_t Code() const { return m_code; }
+  void SetCode(uint32_t code) { m_code = code; }
   dw_tag_t Tag() const { return m_tag; }
   bool HasChildren() const { return m_has_children; }
   size_t NumAttributes() const { return m_attributes.size(); }
   dw_form_t GetFormByIndex(uint32_t idx) const {
     return m_attributes.size() > idx ? m_attributes[idx].get_form() : 0;
   }
 
   // idx is assumed to be valid when calling GetAttrAndFormByIndex()
public:
   ///       user should call this function again to retrieve the next decl.
   ///   llvm::Error - A parsing error occurred.  The debug info is malformed.
   llvm::Expected<lldb_private::DWARFEnumState>
   extract(const lldb_private::DWARFDataExtractor &data,
           lldb::offset_t *offset_ptr);
   bool IsValid();
 
 protected:
-  dw_uleb128_t m_code = InvalidCode;
+  uint32_t m_code = InvalidCode;
   dw_tag_t m_tag = llvm::dwarf::DW_TAG_null;
   uint8_t m_has_children = 0;
   DWARFAttribute::collection m_attributes;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFABBREVIATIONDECLARATION_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.h

public:
   /// Extract all abbrev decls in a set.  Returns llvm::ErrorSuccess() on
   /// success, and an appropriate llvm::Error object otherwise.
   llvm::Error extract(const lldb_private::DWARFDataExtractor &data,
                       lldb::offset_t *offset_ptr);
   // void Encode(BinaryStreamBuf& debug_abbrev_buf) const;
   void GetUnsupportedForms(std::set<dw_form_t> &invalid_forms) const;
 
   const DWARFAbbreviationDeclaration *
-  GetAbbreviationDeclaration(dw_uleb128_t abbrCode) const;
+  GetAbbreviationDeclaration(uint32_t abbrCode) const;
 
   /// Unit test accessor functions.
   /// @{
   uint32_t GetIndexOffset() const { return m_idx_offset; }
   /// @}
 private:
   dw_offset_t m_offset;
   uint32_t m_idx_offset = 0;

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

 // DWARFAbbreviationDeclarationSet::Extract()
 llvm::Error
 DWARFAbbreviationDeclarationSet::extract(const DWARFDataExtractor &data,
                                          lldb::offset_t *offset_ptr) {
   const lldb::offset_t begin_offset = *offset_ptr;
   m_offset = begin_offset;
   Clear();
   DWARFAbbreviationDeclaration abbrevDeclaration;
-  dw_uleb128_t prev_abbr_code = 0;
+  uint32_t prev_abbr_code = 0;
   while (true) {
     llvm::Expected<DWARFEnumState> es =
         abbrevDeclaration.extract(data, offset_ptr);
     if (!es)
       return es.takeError();
     if (*es == DWARFEnumState::Complete)
       break;
     m_decls.push_back(abbrevDeclaration);
     if (m_idx_offset == 0)
       m_idx_offset = abbrevDeclaration.Code();
     else if (prev_abbr_code + 1 != abbrevDeclaration.Code()) {
       // Out of order indexes, we can't do O(1) lookups...
       m_idx_offset = UINT32_MAX;
     }
     prev_abbr_code = abbrevDeclaration.Code();
   }
   return llvm::ErrorSuccess();
 }
 
 // DWARFAbbreviationDeclarationSet::GetAbbreviationDeclaration()
 const DWARFAbbreviationDeclaration *
 DWARFAbbreviationDeclarationSet::GetAbbreviationDeclaration(
-    dw_uleb128_t abbrCode) const {
+    uint32_t abbrCode) const {
   if (m_idx_offset == UINT32_MAX) {
     DWARFAbbreviationDeclarationCollConstIter pos;
     DWARFAbbreviationDeclarationCollConstIter end = m_decls.end();
     for (pos = m_decls.begin(); pos != end; ++pos) {
       if (pos->Code() == abbrCode)
         return &(*pos);
     }
   } else {
     uint32_t idx = abbrCode - m_idx_offset;
     if (idx < m_decls.size())
       return &m_decls[idx];
   }
   return nullptr;
 }
 
-
 // DWARFAbbreviationDeclarationSet::GetUnsupportedForms()
 void DWARFAbbreviationDeclarationSet::GetUnsupportedForms(
     std::set<dw_form_t> &invalid_forms) const {
   for (const auto &abbr_decl : m_decls) {
     const size_t num_attrs = abbr_decl.NumAttributes();
     for (size_t i=0; i<num_attrs; ++i) {
       dw_form_t form = abbr_decl.GetFormByIndex(i);
       if (!DWARFFormValue::FormIsSupported(form))

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

bool DWARFFormValue::SkipValue(dw_form_t form,
                                lldb::offset_t *offset_ptr,
                                const DWARFUnit *unit) {
   uint8_t ref_addr_size;
   switch (form) {
   // Blocks if inlined data that have a length field and the data bytes inlined
   // in the .debug_info
   case DW_FORM_exprloc:
   case DW_FORM_block: {
-    dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
+    uint64_t size = debug_info_data.GetULEB128(offset_ptr);
     *offset_ptr += size;
   }
     return true;
   case DW_FORM_block1: {
-    dw_uleb128_t size = debug_info_data.GetU8(offset_ptr);
+    uint8_t size = debug_info_data.GetU8(offset_ptr);
     *offset_ptr += size;
   }
     return true;
   case DW_FORM_block2: {
-    dw_uleb128_t size = debug_info_data.GetU16(offset_ptr);
+    uint16_t size = debug_info_data.GetU16(offset_ptr);
     *offset_ptr += size;
   }
     return true;
   case DW_FORM_block4: {
-    dw_uleb128_t size = debug_info_data.GetU32(offset_ptr);
+    uint32_t size = debug_info_data.GetU32(offset_ptr);
     *offset_ptr += size;
   }
     return true;
 
   // Inlined NULL terminated C-strings
   case DW_FORM_string:
     debug_info_data.GetCStr(offset_ptr);
     return true;