lib/DebugInfo/DWARFFormValue.cpp

//===-- DWARFFormValue.cpp ------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "DWARFFormValue.h"
#include "DWARFCompileUnit.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
using namespace llvm;
using namespace dwarf;

static const uint8_t form_sizes_addr4[] = {
    0, // 0x00 unused
    4, // 0x01 DW_FORM_addr
    0, // 0x02 unused
    0, // 0x03 DW_FORM_block2
    0, // 0x04 DW_FORM_block4
    2, // 0x05 DW_FORM_data2
    4, // 0x06 DW_FORM_data4
    8, // 0x07 DW_FORM_data8
    0, // 0x08 DW_FORM_string
    0, // 0x09 DW_FORM_block
    0, // 0x0a DW_FORM_block1
    1, // 0x0b DW_FORM_data1
    1, // 0x0c DW_FORM_flag
    0, // 0x0d DW_FORM_sdata
    4, // 0x0e DW_FORM_strp
    0, // 0x0f DW_FORM_udata
    4, // 0x10 DW_FORM_ref_addr
    1, // 0x11 DW_FORM_ref1
    2, // 0x12 DW_FORM_ref2
    4, // 0x13 DW_FORM_ref4
    8, // 0x14 DW_FORM_ref8
    0, // 0x15 DW_FORM_ref_udata
    0, // 0x16 DW_FORM_indirect
};

static const uint8_t form_sizes_addr8[] = {
    0, // 0x00 unused
    8, // 0x01 DW_FORM_addr
    0, // 0x02 unused
    0, // 0x03 DW_FORM_block2
    0, // 0x04 DW_FORM_block4
    2, // 0x05 DW_FORM_data2
    4, // 0x06 DW_FORM_data4
    8, // 0x07 DW_FORM_data8
    0, // 0x08 DW_FORM_string
    0, // 0x09 DW_FORM_block
    0, // 0x0a DW_FORM_block1
    1, // 0x0b DW_FORM_data1
    1, // 0x0c DW_FORM_flag
    0, // 0x0d DW_FORM_sdata
    4, // 0x0e DW_FORM_strp
    0, // 0x0f DW_FORM_udata
    8, // 0x10 DW_FORM_ref_addr
    1, // 0x11 DW_FORM_ref1
    2, // 0x12 DW_FORM_ref2
    4, // 0x13 DW_FORM_ref4
    8, // 0x14 DW_FORM_ref8
    0, // 0x15 DW_FORM_ref_udata
    0, // 0x16 DW_FORM_indirect
};

const uint8_t *
DWARFFormValue::getFixedFormSizesForAddressSize(uint8_t addr_size) {
    switch (addr_size) {
    case 4: return form_sizes_addr4;
    case 8: return form_sizes_addr8;
    }
    return NULL;
}

bool
DWARFFormValue::extractValue(DataExtractor data, uint32_t *offset_ptr,
                             const DWARFCompileUnit* cu) {
    bool indirect = false;
    bool is_block = false;
    Value.data = NULL;
    // Read the value for the form into value and follow and DW_FORM_indirect
    // instances we run into
    do {
        indirect = false;
        switch (Form) {
        case DW_FORM_addr:
        case DW_FORM_ref_addr:
          Value.uval = data.getUnsigned(offset_ptr, cu->getAddressByteSize());
          break;
        case DW_FORM_block:
          Value.uval = data.getULEB128(offset_ptr);
          is_block = true;
          break;
        case DW_FORM_block1:
          Value.uval = data.getU8(offset_ptr);
          is_block = true;
          break;
        case DW_FORM_block2:
          Value.uval = data.getU16(offset_ptr);
          is_block = true;
          break;
        case DW_FORM_block4:
          Value.uval = data.getU32(offset_ptr);
          is_block = true;
          break;
        case DW_FORM_data1:
        case DW_FORM_ref1:
        case DW_FORM_flag:
          Value.uval = data.getU8(offset_ptr);
          break;
        case DW_FORM_data2:
        case DW_FORM_ref2:
          Value.uval = data.getU16(offset_ptr);
          break;
        case DW_FORM_data4:
        case DW_FORM_ref4:
          Value.uval = data.getU32(offset_ptr);
          break;
        case DW_FORM_data8:
        case DW_FORM_ref8:
          Value.uval = data.getU64(offset_ptr);
          break;
        case DW_FORM_sdata:
          Value.sval = data.getSLEB128(offset_ptr);
          break;
        case DW_FORM_strp:
          Value.uval = data.getU32(offset_ptr);
          break;
        case DW_FORM_udata:
        case DW_FORM_ref_udata:
          Value.uval = data.getULEB128(offset_ptr);
          break;
        case DW_FORM_string:
          Value.cstr = data.getCStr(offset_ptr);
          // Set the string value to also be the data for inlined cstr form
          // values only so we can tell the differnence between DW_FORM_string
          // and DW_FORM_strp form values
          Value.data = (uint8_t*)Value.cstr;
          break;
        case DW_FORM_indirect:
          Form = data.getULEB128(offset_ptr);
          indirect = true;
          break;
        default:
          return false;
        }
    } while (indirect);

    if (is_block) {
      StringRef str = data.getData().substr(*offset_ptr, Value.uval);
      Value.data = NULL;
      if (!str.empty()) {
        Value.data = reinterpret_cast<const uint8_t *>(str.data());
        *offset_ptr += Value.uval;
      }
    }

    return true;
}

bool
DWARFFormValue::skipValue(DataExtractor debug_info_data, uint32_t* offset_ptr,
                          const DWARFCompileUnit* cu) const {
    return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, cu);
}

bool
DWARFFormValue::skipValue(uint16_t form, DataExtractor debug_info_data,
                          uint32_t *offset_ptr, const DWARFCompileUnit *cu) {
  bool indirect = false;
  do {
    indirect = false;
    switch (form) {
    // Blocks if inlined data that have a length field and the data bytes
    // inlined in the .debug_info
    case DW_FORM_block: {
      uint64_t size = debug_info_data.getULEB128(offset_ptr);
      *offset_ptr += size;
      return true;
    }
    case DW_FORM_block1: {
      uint8_t size = debug_info_data.getU8(offset_ptr);
      *offset_ptr += size;
      return true;
    }
    case DW_FORM_block2: {
      uint16_t size = debug_info_data.getU16(offset_ptr);
      *offset_ptr += size;
      return true;
    }
    case DW_FORM_block4: {
      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;

    // Compile unit address sized values
    case DW_FORM_addr:
    case DW_FORM_ref_addr:
      *offset_ptr += cu->getAddressByteSize();
      return true;

    // 1 byte values
    case DW_FORM_data1:
    case DW_FORM_flag:
    case DW_FORM_ref1:
      *offset_ptr += 1;
      return true;

    // 2 byte values
    case DW_FORM_data2:
    case DW_FORM_ref2:
      *offset_ptr += 2;
      return true;

    // 4 byte values
    case DW_FORM_strp:
    case DW_FORM_data4:
    case DW_FORM_ref4:
      *offset_ptr += 4;
      return true;

    // 8 byte values
    case DW_FORM_data8:
    case DW_FORM_ref8:
      *offset_ptr += 8;
      return true;

    // signed or unsigned LEB 128 values
    //  case DW_FORM_APPLE_db_str:
    case DW_FORM_sdata:
    case DW_FORM_udata:
    case DW_FORM_ref_udata:
      debug_info_data.getULEB128(offset_ptr);
      return true;

    case DW_FORM_indirect:
      indirect = true;
      form = debug_info_data.getULEB128(offset_ptr);
      break;
    default:
      return false;
    }
  } while (indirect);
  return true;
}

void
DWARFFormValue::dump(raw_ostream &OS, const DataExtractor *debug_str_data,
                     const DWARFCompileUnit *cu) const {
  uint64_t uvalue = getUnsigned();
  bool cu_relative_offset = false;

  switch (Form)
  {
  case DW_FORM_addr:      OS << format("0x%016x", uvalue); break;
  case DW_FORM_flag:
  case DW_FORM_data1:     OS << format("0x%02x", uvalue);  break;
  case DW_FORM_data2:     OS << format("0x%04x", uvalue);  break;
  case DW_FORM_data4:     OS << format("0x%08x", uvalue);  break;
  case DW_FORM_data8:     OS << format("0x%016x", uvalue); break;
  case DW_FORM_string:
    OS << '"';
    OS.write_escaped(getAsCString(NULL));
    OS << '"';
    break;
  case DW_FORM_block:
  case DW_FORM_block1:
  case DW_FORM_block2:
  case DW_FORM_block4:
    if (uvalue > 0) {
      switch (Form) {
      case DW_FORM_block:  OS << format("<0x%llx> ", uvalue);            break;
      case DW_FORM_block1: OS << format("<0x%2.2x> ", (uint8_t)uvalue);  break;
      case DW_FORM_block2: OS << format("<0x%4.4x> ", (uint16_t)uvalue); break;
      case DW_FORM_block4: OS << format("<0x%8.8x> ", (uint32_t)uvalue); break;
      default: break;
      }

      const uint8_t* data_ptr = Value.data;
      if (data_ptr) {
        // uvalue contains size of block
        const uint8_t* end_data_ptr = data_ptr + uvalue;
        while (data_ptr < end_data_ptr) {
          OS << format("%2.2x ", *data_ptr);
          ++data_ptr;
        }
      }
      else
        OS << "NULL";
    }
    break;

  case DW_FORM_sdata:     OS << getSigned();   break;
  case DW_FORM_udata:     OS << getUnsigned(); break;
  case DW_FORM_strp:
    if (debug_str_data) {
      OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
      const char* dbg_str = getAsCString(debug_str_data);
      if (dbg_str) {
        OS << '"';
        OS.write_escaped(dbg_str);
        OS << '"';
      }
    } else {
      OS << format("0x%08x", uvalue);
    }
    break;
  case DW_FORM_ref_addr:
    OS << format("0x%016x", uvalue);
    break;
  case DW_FORM_ref1:
    cu_relative_offset = true;
    OS << format("cu + 0x%2.2x", (uint8_t)uvalue);
    break;
  case DW_FORM_ref2:
    cu_relative_offset = true;
    OS << format("cu + 0x%4.4x", (uint16_t)uvalue);
    break;
  case DW_FORM_ref4:
    cu_relative_offset = true;
    OS << format("cu + 0x%4.4x", (uint32_t)uvalue);
    break;
  case DW_FORM_ref8:
    cu_relative_offset = true;
    OS << format("cu + 0x%8.8llx", uvalue);
    break;
  case DW_FORM_ref_udata:
    cu_relative_offset = true;
    OS << format("cu + 0x%llx", uvalue);
    break;

    // All DW_FORM_indirect attributes should be resolved prior to calling
    // this function
  case DW_FORM_indirect:
    OS << "DW_FORM_indirect";
    break;
  default:
    OS << format("DW_FORM(0x%4.4x)", Form);
    break;
  }

  if (cu_relative_offset)
    OS << format(" => {0x%8.8x}", (uvalue + (cu ? cu->getOffset() : 0)));
}

const char*
DWARFFormValue::getAsCString(const DataExtractor *debug_str_data_ptr) const {
  if (isInlinedCStr()) {
    return Value.cstr;
  } else if (debug_str_data_ptr) {
    uint32_t offset = Value.uval;
    return debug_str_data_ptr->getCStr(&offset);
  }
  return NULL;
}

uint64_t
DWARFFormValue::getReference(const DWARFCompileUnit *cu) const {
    uint64_t die_offset = Value.uval;
    switch (Form) {
    case DW_FORM_ref1:
    case DW_FORM_ref2:
    case DW_FORM_ref4:
    case DW_FORM_ref8:
    case DW_FORM_ref_udata:
        die_offset += (cu ? cu->getOffset() : 0);
        break;
    default:
        break;
    }

    return die_offset;
}

bool
DWARFFormValue::resolveCompileUnitReferences(const DWARFCompileUnit* cu) {
    switch (Form) {
    case DW_FORM_ref1:
    case DW_FORM_ref2:
    case DW_FORM_ref4:
    case DW_FORM_ref8:
    case DW_FORM_ref_udata:
        Value.uval += cu->getOffset();
        Form = DW_FORM_ref_addr;
        return true;
    default:
        break;
    }

    return false;
}

const uint8_t *DWARFFormValue::BlockData() const {
    if (!isInlinedCStr())
        return Value.data;
    return NULL;
}

bool DWARFFormValue::isBlockForm(uint16_t form) {
    switch (form)
    {
    case DW_FORM_block:
    case DW_FORM_block1:
    case DW_FORM_block2:
    case DW_FORM_block4:
        return true;
    }
    return false;
}

bool DWARFFormValue::isDataForm(uint16_t form) {
    switch (form)
    {
    case DW_FORM_sdata:
    case DW_FORM_udata:
    case DW_FORM_data1:
    case DW_FORM_data2:
    case DW_FORM_data4:
    case DW_FORM_data8:
        return true;
    }
    return false;
}