contrib/llvm/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

   1 //===-- DWARFFormValue.cpp --------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <assert.h>
  11
  12 #include "lldb/Core/Stream.h"
  13 #include "lldb/Core/dwarf.h"
  14
  15 #include "DWARFCompileUnit.h"
  16 #include "DWARFFormValue.h"
  17
  18 class DWARFCompileUnit;
  19
  20 using namespace lldb_private;
  21
  22 static uint8_t g_form_sizes_addr4[] = {
  23     0, // 0x00 unused
  24     4, // 0x01 DW_FORM_addr
  25     0, // 0x02 unused
  26     0, // 0x03 DW_FORM_block2
  27     0, // 0x04 DW_FORM_block4
  28     2, // 0x05 DW_FORM_data2
  29     4, // 0x06 DW_FORM_data4
  30     8, // 0x07 DW_FORM_data8
  31     0, // 0x08 DW_FORM_string
  32     0, // 0x09 DW_FORM_block
  33     0, // 0x0a DW_FORM_block1
  34     1, // 0x0b DW_FORM_data1
  35     1, // 0x0c DW_FORM_flag
  36     0, // 0x0d DW_FORM_sdata
  37     4, // 0x0e DW_FORM_strp
  38     0, // 0x0f DW_FORM_udata
  39     0, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes for
  40        // DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
  41     1, // 0x11 DW_FORM_ref1
  42     2, // 0x12 DW_FORM_ref2
  43     4, // 0x13 DW_FORM_ref4
  44     8, // 0x14 DW_FORM_ref8
  45     0, // 0x15 DW_FORM_ref_udata
  46     0, // 0x16 DW_FORM_indirect
  47     4, // 0x17 DW_FORM_sec_offset
  48     0, // 0x18 DW_FORM_exprloc
  49     0, // 0x19 DW_FORM_flag_present
  50     0, // 0x1a
  51     0, // 0x1b
  52     0, // 0x1c
  53     0, // 0x1d
  54     0, // 0x1e
  55     0, // 0x1f
  56     8, // 0x20 DW_FORM_ref_sig8
  57
  58 };
  59
  60 static uint8_t g_form_sizes_addr8[] = {
  61     0, // 0x00 unused
  62     8, // 0x01 DW_FORM_addr
  63     0, // 0x02 unused
  64     0, // 0x03 DW_FORM_block2
  65     0, // 0x04 DW_FORM_block4
  66     2, // 0x05 DW_FORM_data2
  67     4, // 0x06 DW_FORM_data4
  68     8, // 0x07 DW_FORM_data8
  69     0, // 0x08 DW_FORM_string
  70     0, // 0x09 DW_FORM_block
  71     0, // 0x0a DW_FORM_block1
  72     1, // 0x0b DW_FORM_data1
  73     1, // 0x0c DW_FORM_flag
  74     0, // 0x0d DW_FORM_sdata
  75     4, // 0x0e DW_FORM_strp
  76     0, // 0x0f DW_FORM_udata
  77     0, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes for
  78        // DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
  79     1, // 0x11 DW_FORM_ref1
  80     2, // 0x12 DW_FORM_ref2
  81     4, // 0x13 DW_FORM_ref4
  82     8, // 0x14 DW_FORM_ref8
  83     0, // 0x15 DW_FORM_ref_udata
  84     0, // 0x16 DW_FORM_indirect
  85     4, // 0x17 DW_FORM_sec_offset
  86     0, // 0x18 DW_FORM_exprloc
  87     0, // 0x19 DW_FORM_flag_present
  88     0, // 0x1a
  89     0, // 0x1b
  90     0, // 0x1c
  91     0, // 0x1d
  92     0, // 0x1e
  93     0, // 0x1f
  94     8, // 0x20 DW_FORM_ref_sig8
  95 };
  96
  97 // Difference with g_form_sizes_addr8:
  98 // DW_FORM_strp and DW_FORM_sec_offset are 8 instead of 4
  99 static uint8_t g_form_sizes_addr8_dwarf64[] = {
 100     0, // 0x00 unused
 101     8, // 0x01 DW_FORM_addr
 102     0, // 0x02 unused
 103     0, // 0x03 DW_FORM_block2
 104     0, // 0x04 DW_FORM_block4
 105     2, // 0x05 DW_FORM_data2
 106     4, // 0x06 DW_FORM_data4
 107     8, // 0x07 DW_FORM_data8
 108     0, // 0x08 DW_FORM_string
 109     0, // 0x09 DW_FORM_block
 110     0, // 0x0a DW_FORM_block1
 111     1, // 0x0b DW_FORM_data1
 112     1, // 0x0c DW_FORM_flag
 113     0, // 0x0d DW_FORM_sdata
 114     8, // 0x0e DW_FORM_strp
 115     0, // 0x0f DW_FORM_udata
 116     0, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes for
 117        // DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
 118     1, // 0x11 DW_FORM_ref1
 119     2, // 0x12 DW_FORM_ref2
 120     4, // 0x13 DW_FORM_ref4
 121     8, // 0x14 DW_FORM_ref8
 122     0, // 0x15 DW_FORM_ref_udata
 123     0, // 0x16 DW_FORM_indirect
 124     8, // 0x17 DW_FORM_sec_offset
 125     0, // 0x18 DW_FORM_exprloc
 126     0, // 0x19 DW_FORM_flag_present
 127     0, // 0x1a
 128     0, // 0x1b
 129     0, // 0x1c
 130     0, // 0x1d
 131     0, // 0x1e
 132     0, // 0x1f
 133     8, // 0x20 DW_FORM_ref_sig8
 134 };
 135
 136 DWARFFormValue::FixedFormSizes
 137 DWARFFormValue::GetFixedFormSizesForAddressSize(uint8_t addr_size,
 138                                                 bool is_dwarf64) {
 139   if (!is_dwarf64) {
 140     switch (addr_size) {
 141     case 4:
 142       return FixedFormSizes(g_form_sizes_addr4, sizeof(g_form_sizes_addr4));
 143     case 8:
 144       return FixedFormSizes(g_form_sizes_addr8, sizeof(g_form_sizes_addr8));
 145     }
 146   } else {
 147     if (addr_size == 8)
 148       return FixedFormSizes(g_form_sizes_addr8_dwarf64,
 149                             sizeof(g_form_sizes_addr8_dwarf64));
 150     // is_dwarf64 && addr_size == 4 : no provider does this.
 151   }
 152   return FixedFormSizes();
 153 }
 154
 155 DWARFFormValue::DWARFFormValue() : m_cu(NULL), m_form(0), m_value() {}
 156
 157 DWARFFormValue::DWARFFormValue(const DWARFCompileUnit *cu, dw_form_t form)
 158     : m_cu(cu), m_form(form), m_value() {}
 159
 160 void DWARFFormValue::Clear() {
 161   m_cu = nullptr;
 162   m_form = 0;
 163   memset(&m_value, 0, sizeof(m_value));
 164 }
 165
 166 bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
 167                                   lldb::offset_t *offset_ptr) {
 168   bool indirect = false;
 169   bool is_block = false;
 170   m_value.data = NULL;
 171   uint8_t ref_addr_size;
 172   // Read the value for the form into value and follow and DW_FORM_indirect
 173   // instances we run into
 174   do {
 175     indirect = false;
 176     switch (m_form) {
 177     case DW_FORM_addr:
 178       assert(m_cu);
 179       m_value.value.uval = data.GetMaxU64(
 180           offset_ptr, DWARFCompileUnit::GetAddressByteSize(m_cu));
 181       break;
 182     case DW_FORM_block2:
 183       m_value.value.uval = data.GetU16(offset_ptr);
 184       is_block = true;
 185       break;
 186     case DW_FORM_block4:
 187       m_value.value.uval = data.GetU32(offset_ptr);
 188       is_block = true;
 189       break;
 190     case DW_FORM_data2:
 191       m_value.value.uval = data.GetU16(offset_ptr);
 192       break;
 193     case DW_FORM_data4:
 194       m_value.value.uval = data.GetU32(offset_ptr);
 195       break;
 196     case DW_FORM_data8:
 197       m_value.value.uval = data.GetU64(offset_ptr);
 198       break;
 199     case DW_FORM_string:
 200       m_value.value.cstr = data.GetCStr(offset_ptr);
 201       break;
 202     case DW_FORM_exprloc:
 203     case DW_FORM_block:
 204       m_value.value.uval = data.GetULEB128(offset_ptr);
 205       is_block = true;
 206       break;
 207     case DW_FORM_block1:
 208       m_value.value.uval = data.GetU8(offset_ptr);
 209       is_block = true;
 210       break;
 211     case DW_FORM_data1:
 212       m_value.value.uval = data.GetU8(offset_ptr);
 213       break;
 214     case DW_FORM_flag:
 215       m_value.value.uval = data.GetU8(offset_ptr);
 216       break;
 217     case DW_FORM_sdata:
 218       m_value.value.sval = data.GetSLEB128(offset_ptr);
 219       break;
 220     case DW_FORM_strp:
 221       assert(m_cu);
 222       m_value.value.uval =
 223           data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(m_cu) ? 8 : 4);
 224       break;
 225     //  case DW_FORM_APPLE_db_str:
 226     case DW_FORM_udata:
 227       m_value.value.uval = data.GetULEB128(offset_ptr);
 228       break;
 229     case DW_FORM_ref_addr:
 230       assert(m_cu);
 231       ref_addr_size = 4;
 232       if (m_cu->GetVersion() <= 2)
 233         ref_addr_size = m_cu->GetAddressByteSize();
 234       else
 235         ref_addr_size = m_cu->IsDWARF64() ? 8 : 4;
 236       m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
 237       break;
 238     case DW_FORM_ref1:
 239       m_value.value.uval = data.GetU8(offset_ptr);
 240       break;
 241     case DW_FORM_ref2:
 242       m_value.value.uval = data.GetU16(offset_ptr);
 243       break;
 244     case DW_FORM_ref4:
 245       m_value.value.uval = data.GetU32(offset_ptr);
 246       break;
 247     case DW_FORM_ref8:
 248       m_value.value.uval = data.GetU64(offset_ptr);
 249       break;
 250     case DW_FORM_ref_udata:
 251       m_value.value.uval = data.GetULEB128(offset_ptr);
 252       break;
 253     case DW_FORM_indirect:
 254       m_form = data.GetULEB128(offset_ptr);
 255       indirect = true;
 256       break;
 257
 258     case DW_FORM_sec_offset:
 259       assert(m_cu);
 260       m_value.value.uval =
 261           data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(m_cu) ? 8 : 4);
 262       break;
 263     case DW_FORM_flag_present:
 264       m_value.value.uval = 1;
 265       break;
 266     case DW_FORM_ref_sig8:
 267       m_value.value.uval = data.GetU64(offset_ptr);
 268       break;
 269     case DW_FORM_GNU_str_index:
 270       m_value.value.uval = data.GetULEB128(offset_ptr);
 271       break;
 272     case DW_FORM_GNU_addr_index:
 273       m_value.value.uval = data.GetULEB128(offset_ptr);
 274       break;
 275     default:
 276       return false;
 277       break;
 278     }
 279   } while (indirect);
 280
 281   if (is_block) {
 282     m_value.data = data.PeekData(*offset_ptr, m_value.value.uval);
 283     if (m_value.data != NULL) {
 284       *offset_ptr += m_value.value.uval;
 285     }
 286   }
 287
 288   return true;
 289 }
 290
 291 bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
 292                                lldb::offset_t *offset_ptr) const {
 293   return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_cu);
 294 }
 295
 296 bool DWARFFormValue::SkipValue(dw_form_t form,
 297                                const DWARFDataExtractor &debug_info_data,
 298                                lldb::offset_t *offset_ptr,
 299                                const DWARFCompileUnit *cu) {
 300   uint8_t ref_addr_size;
 301   switch (form) {
 302   // Blocks if inlined data that have a length field and the data bytes
 303   // inlined in the .debug_info
 304   case DW_FORM_exprloc:
 305   case DW_FORM_block: {
 306     dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
 307     *offset_ptr += size;
 308   }
 309     return true;
 310   case DW_FORM_block1: {
 311     dw_uleb128_t size = debug_info_data.GetU8(offset_ptr);
 312     *offset_ptr += size;
 313   }
 314     return true;
 315   case DW_FORM_block2: {
 316     dw_uleb128_t size = debug_info_data.GetU16(offset_ptr);
 317     *offset_ptr += size;
 318   }
 319     return true;
 320   case DW_FORM_block4: {
 321     dw_uleb128_t size = debug_info_data.GetU32(offset_ptr);
 322     *offset_ptr += size;
 323   }
 324     return true;
 325
 326   // Inlined NULL terminated C-strings
 327   case DW_FORM_string:
 328     debug_info_data.GetCStr(offset_ptr);
 329     return true;
 330
 331   // Compile unit address sized values
 332   case DW_FORM_addr:
 333     *offset_ptr += DWARFCompileUnit::GetAddressByteSize(cu);
 334     return true;
 335
 336   case DW_FORM_ref_addr:
 337     ref_addr_size = 4;
 338     assert(cu); // CU must be valid for DW_FORM_ref_addr objects or we will get
 339                 // this wrong
 340     if (cu->GetVersion() <= 2)
 341       ref_addr_size = cu->GetAddressByteSize();
 342     else
 343       ref_addr_size = cu->IsDWARF64() ? 8 : 4;
 344     *offset_ptr += ref_addr_size;
 345     return true;
 346
 347   // 0 bytes values (implied from DW_FORM)
 348   case DW_FORM_flag_present:
 349     return true;
 350
 351   // 1 byte values
 352   case DW_FORM_data1:
 353   case DW_FORM_flag:
 354   case DW_FORM_ref1:
 355     *offset_ptr += 1;
 356     return true;
 357
 358   // 2 byte values
 359   case DW_FORM_data2:
 360   case DW_FORM_ref2:
 361     *offset_ptr += 2;
 362     return true;
 363
 364   // 32 bit for DWARF 32, 64 for DWARF 64
 365   case DW_FORM_sec_offset:
 366   case DW_FORM_strp:
 367     assert(cu);
 368     *offset_ptr += (cu->IsDWARF64() ? 8 : 4);
 369     return true;
 370
 371   // 4 byte values
 372   case DW_FORM_data4:
 373   case DW_FORM_ref4:
 374     *offset_ptr += 4;
 375     return true;
 376
 377   // 8 byte values
 378   case DW_FORM_data8:
 379   case DW_FORM_ref8:
 380   case DW_FORM_ref_sig8:
 381     *offset_ptr += 8;
 382     return true;
 383
 384   // signed or unsigned LEB 128 values
 385   case DW_FORM_sdata:
 386   case DW_FORM_udata:
 387   case DW_FORM_ref_udata:
 388   case DW_FORM_GNU_addr_index:
 389   case DW_FORM_GNU_str_index:
 390     debug_info_data.Skip_LEB128(offset_ptr);
 391     return true;
 392
 393   case DW_FORM_indirect: {
 394     dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
 395     return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
 396                                      cu);
 397   }
 398
 399   default:
 400     break;
 401   }
 402   return false;
 403 }
 404
 405 void DWARFFormValue::Dump(Stream &s) const {
 406   uint64_t uvalue = Unsigned();
 407   bool cu_relative_offset = false;
 408
 409   bool verbose = s.GetVerbose();
 410
 411   switch (m_form) {
 412   case DW_FORM_addr:
 413     s.Address(uvalue, sizeof(uint64_t));
 414     break;
 415   case DW_FORM_flag:
 416   case DW_FORM_data1:
 417     s.PutHex8(uvalue);
 418     break;
 419   case DW_FORM_data2:
 420     s.PutHex16(uvalue);
 421     break;
 422   case DW_FORM_sec_offset:
 423   case DW_FORM_data4:
 424     s.PutHex32(uvalue);
 425     break;
 426   case DW_FORM_ref_sig8:
 427   case DW_FORM_data8:
 428     s.PutHex64(uvalue);
 429     break;
 430   case DW_FORM_string:
 431     s.QuotedCString(AsCString());
 432     break;
 433   case DW_FORM_exprloc:
 434   case DW_FORM_block:
 435   case DW_FORM_block1:
 436   case DW_FORM_block2:
 437   case DW_FORM_block4:
 438     if (uvalue > 0) {
 439       switch (m_form) {
 440       case DW_FORM_exprloc:
 441       case DW_FORM_block:
 442         s.Printf("<0x%" PRIx64 "> ", uvalue);
 443         break;
 444       case DW_FORM_block1:
 445         s.Printf("<0x%2.2x> ", (uint8_t)uvalue);
 446         break;
 447       case DW_FORM_block2:
 448         s.Printf("<0x%4.4x> ", (uint16_t)uvalue);
 449         break;
 450       case DW_FORM_block4:
 451         s.Printf("<0x%8.8x> ", (uint32_t)uvalue);
 452         break;
 453       default:
 454         break;
 455       }
 456
 457       const uint8_t *data_ptr = m_value.data;
 458       if (data_ptr) {
 459         const uint8_t *end_data_ptr =
 460             data_ptr + uvalue; // uvalue contains size of block
 461         while (data_ptr < end_data_ptr) {
 462           s.Printf("%2.2x ", *data_ptr);
 463           ++data_ptr;
 464         }
 465       } else
 466         s.PutCString("NULL");
 467     }
 468     break;
 469
 470   case DW_FORM_sdata:
 471     s.PutSLEB128(uvalue);
 472     break;
 473   case DW_FORM_udata:
 474     s.PutULEB128(uvalue);
 475     break;
 476   case DW_FORM_strp: {
 477     const char *dbg_str = AsCString();
 478     if (dbg_str) {
 479       if (verbose)
 480         s.Printf(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
 481       s.QuotedCString(dbg_str);
 482     } else {
 483       s.PutHex32(uvalue);
 484     }
 485   } break;
 486
 487   case DW_FORM_ref_addr: {
 488     assert(m_cu); // CU must be valid for DW_FORM_ref_addr objects or we will
 489                   // get this wrong
 490     if (m_cu->GetVersion() <= 2)
 491       s.Address(uvalue, sizeof(uint64_t) * 2);
 492     else
 493       s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
 494                                 // support DWARF64 yet
 495     break;
 496   }
 497   case DW_FORM_ref1:
 498     cu_relative_offset = true;
 499     if (verbose)
 500       s.Printf("cu + 0x%2.2x", (uint8_t)uvalue);
 501     break;
 502   case DW_FORM_ref2:
 503     cu_relative_offset = true;
 504     if (verbose)
 505       s.Printf("cu + 0x%4.4x", (uint16_t)uvalue);
 506     break;
 507   case DW_FORM_ref4:
 508     cu_relative_offset = true;
 509     if (verbose)
 510       s.Printf("cu + 0x%4.4x", (uint32_t)uvalue);
 511     break;
 512   case DW_FORM_ref8:
 513     cu_relative_offset = true;
 514     if (verbose)
 515       s.Printf("cu + 0x%8.8" PRIx64, uvalue);
 516     break;
 517   case DW_FORM_ref_udata:
 518     cu_relative_offset = true;
 519     if (verbose)
 520       s.Printf("cu + 0x%" PRIx64, uvalue);
 521     break;
 522
 523   // All DW_FORM_indirect attributes should be resolved prior to calling this
 524   // function
 525   case DW_FORM_indirect:
 526     s.PutCString("DW_FORM_indirect");
 527     break;
 528   case DW_FORM_flag_present:
 529     break;
 530   default:
 531     s.Printf("DW_FORM(0x%4.4x)", m_form);
 532     break;
 533   }
 534
 535   if (cu_relative_offset) {
 536     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
 537                   // unit relative or we will get this wrong
 538     if (verbose)
 539       s.PutCString(" => ");
 540
 541     s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
 542   }
 543 }
 544
 545 const char *DWARFFormValue::AsCString() const {
 546   SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
 547
 548   if (m_form == DW_FORM_string) {
 549     return m_value.value.cstr;
 550   } else if (m_form == DW_FORM_strp) {
 551     if (!symbol_file)
 552       return nullptr;
 553
 554     return symbol_file->get_debug_str_data().PeekCStr(m_value.value.uval);
 555   } else if (m_form == DW_FORM_GNU_str_index) {
 556     if (!symbol_file)
 557       return nullptr;
 558
 559     uint32_t index_size = m_cu->IsDWARF64() ? 8 : 4;
 560     lldb::offset_t offset = m_value.value.uval * index_size;
 561     dw_offset_t str_offset =
 562         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset,
 563                                                             index_size);
 564     return symbol_file->get_debug_str_data().PeekCStr(str_offset);
 565   }
 566   return nullptr;
 567 }
 568
 569 dw_addr_t DWARFFormValue::Address() const {
 570   SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
 571
 572   if (m_form == DW_FORM_addr)
 573     return Unsigned();
 574
 575   assert(m_cu);
 576   assert(m_form == DW_FORM_GNU_addr_index);
 577
 578   if (!symbol_file)
 579     return 0;
 580
 581   uint32_t index_size = m_cu->GetAddressByteSize();
 582   dw_offset_t addr_base = m_cu->GetAddrBase();
 583   lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
 584   return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
 585 }
 586
 587 uint64_t DWARFFormValue::Reference() const {
 588   uint64_t die_offset = m_value.value.uval;
 589   switch (m_form) {
 590   case DW_FORM_ref1:
 591   case DW_FORM_ref2:
 592   case DW_FORM_ref4:
 593   case DW_FORM_ref8:
 594   case DW_FORM_ref_udata:
 595     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
 596                   // unit relative or we will get this wrong
 597     die_offset += m_cu->GetOffset();
 598     break;
 599
 600   default:
 601     break;
 602   }
 603
 604   return die_offset;
 605 }
 606
 607 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
 608   uint64_t die_offset = m_value.value.uval;
 609   switch (m_form) {
 610   case DW_FORM_ref1:
 611   case DW_FORM_ref2:
 612   case DW_FORM_ref4:
 613   case DW_FORM_ref8:
 614   case DW_FORM_ref_udata:
 615     die_offset += base_offset;
 616     break;
 617
 618   default:
 619     break;
 620   }
 621
 622   return die_offset;
 623 }
 624
 625 const uint8_t *DWARFFormValue::BlockData() const { return m_value.data; }
 626
 627 bool DWARFFormValue::IsBlockForm(const dw_form_t form) {
 628   switch (form) {
 629   case DW_FORM_exprloc:
 630   case DW_FORM_block:
 631   case DW_FORM_block1:
 632   case DW_FORM_block2:
 633   case DW_FORM_block4:
 634     return true;
 635   }
 636   return false;
 637 }
 638
 639 bool DWARFFormValue::IsDataForm(const dw_form_t form) {
 640   switch (form) {
 641   case DW_FORM_sdata:
 642   case DW_FORM_udata:
 643   case DW_FORM_data1:
 644   case DW_FORM_data2:
 645   case DW_FORM_data4:
 646   case DW_FORM_data8:
 647     return true;
 648   }
 649   return false;
 650 }
 651
 652 int DWARFFormValue::Compare(const DWARFFormValue &a_value,
 653                             const DWARFFormValue &b_value) {
 654   dw_form_t a_form = a_value.Form();
 655   dw_form_t b_form = b_value.Form();
 656   if (a_form < b_form)
 657     return -1;
 658   if (a_form > b_form)
 659     return 1;
 660   switch (a_form) {
 661   case DW_FORM_addr:
 662   case DW_FORM_flag:
 663   case DW_FORM_data1:
 664   case DW_FORM_data2:
 665   case DW_FORM_data4:
 666   case DW_FORM_data8:
 667   case DW_FORM_udata:
 668   case DW_FORM_ref_addr:
 669   case DW_FORM_sec_offset:
 670   case DW_FORM_flag_present:
 671   case DW_FORM_ref_sig8:
 672   case DW_FORM_GNU_addr_index: {
 673     uint64_t a = a_value.Unsigned();
 674     uint64_t b = b_value.Unsigned();
 675     if (a < b)
 676       return -1;
 677     if (a > b)
 678       return 1;
 679     return 0;
 680   }
 681
 682   case DW_FORM_sdata: {
 683     int64_t a = a_value.Signed();
 684     int64_t b = b_value.Signed();
 685     if (a < b)
 686       return -1;
 687     if (a > b)
 688       return 1;
 689     return 0;
 690   }
 691
 692   case DW_FORM_string:
 693   case DW_FORM_strp:
 694   case DW_FORM_GNU_str_index: {
 695     const char *a_string = a_value.AsCString();
 696     const char *b_string = b_value.AsCString();
 697     if (a_string == b_string)
 698       return 0;
 699     else if (a_string && b_string)
 700       return strcmp(a_string, b_string);
 701     else if (a_string == NULL)
 702       return -1; // A string is NULL, and B is valid
 703     else
 704       return 1; // A string valid, and B is NULL
 705   }
 706
 707   case DW_FORM_block:
 708   case DW_FORM_block1:
 709   case DW_FORM_block2:
 710   case DW_FORM_block4:
 711   case DW_FORM_exprloc: {
 712     uint64_t a_len = a_value.Unsigned();
 713     uint64_t b_len = b_value.Unsigned();
 714     if (a_len < b_len)
 715       return -1;
 716     if (a_len > b_len)
 717       return 1;
 718     // The block lengths are the same
 719     return memcmp(a_value.BlockData(), b_value.BlockData(), a_value.Unsigned());
 720   } break;
 721
 722   case DW_FORM_ref1:
 723   case DW_FORM_ref2:
 724   case DW_FORM_ref4:
 725   case DW_FORM_ref8:
 726   case DW_FORM_ref_udata: {
 727     uint64_t a = a_value.Reference();
 728     uint64_t b = b_value.Reference();
 729     if (a < b)
 730       return -1;
 731     if (a > b)
 732       return 1;
 733     return 0;
 734   }
 735
 736   case DW_FORM_indirect:
 737     llvm_unreachable(
 738         "This shouldn't happen after the form has been extracted...");
 739
 740   default:
 741     llvm_unreachable("Unhandled DW_FORM");
 742   }
 743   return -1;
 744 }