path: root/elff/dwarf_cu.cc

/* Copyright (C) 2007-2010 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
*/

/*
 * Contains implementation of a class DwarfCU, that encapsulates a compilation
 * unit in the .debug_info section of the mapped ELF file.
 */

#include "string.h"
#include "stdio.h"
#include "elf_file.h"
#include "dwarf_cu.h"
#include "dwarf_utils.h"

DwarfCU::DwarfCU(ElfFile* elf)
    : elf_file_(elf),
      cu_die_(NULL),
      prev_cu_(NULL) {
}

DwarfCU::~DwarfCU() {
  if (cu_die_ != NULL) {
    delete cu_die_;
  }
  abbrs_.empty();
}

DwarfCU* DwarfCU::create_instance(ElfFile* elf, const void* hdr) {
  DwarfCU* ret;

  /* 64-bit DWARF CU has first 4 bytes in its header set to 0xFFFFFFFF. */
  if (*reinterpret_cast<const Elf_Word*>(hdr) == 0xFFFFFFFF) {
    ret = new(elf) DwarfCUImpl<Dwarf64_CUHdr, Dwarf64_Off>
                      (elf, reinterpret_cast<const Dwarf64_CUHdr*>(hdr));
  } else {
    ret = new(elf) DwarfCUImpl<Dwarf32_CUHdr, Dwarf32_Off>
                      (elf, reinterpret_cast<const Dwarf32_CUHdr*>(hdr));
  }
  assert(ret != NULL);
  if (ret == NULL) {
    _set_errno(ENOMEM);
  }
  return ret;
}

const Elf_Byte* DwarfCU::process_attrib(const Elf_Byte* prop,
                                        Dwarf_Form form,
                                        Dwarf_Value* attr_value) const {
  assert(form != 0);
  Dwarf_Value tmp_val;
  Dwarf_Value leb128;

  attr_value->type = DWARF_VALUE_UNKNOWN;
  attr_value->encoded_size = 0;
  attr_value->u64 = 0;

  switch (form) {
    /* Property is a block of data, contained in .debug_info section. Block
     * size is encoded with 1 byte value, and block data immediately follows
     * block size. */
    case DW_FORM_block1:
      attr_value->type = DWARF_VALUE_BLOCK;
      attr_value->block.block_size = *prop;
      attr_value->block.block_ptr = prop + 1;
      attr_value->encoded_size =
          static_cast<Elf_Word>(attr_value->block.block_size + 1);
      break;

    /* Property is a block of data, contained in .debug_info section. Block
     * size is encoded with 2 bytes value, and block data immediately follows
     * block size. */
    case DW_FORM_block2:
      attr_value->type = DWARF_VALUE_BLOCK;
      attr_value->block.block_size =
          elf_file_->pull_val(reinterpret_cast<const Elf_Half*>(prop));
      attr_value->block.block_ptr = prop + 2;
      attr_value->encoded_size =
          static_cast<Elf_Word>(attr_value->block.block_size + 2);
      break;

    /* Property is a block of data, contained in .debug_info section. Block
     * size is encoded with 4 bytes value, and block data immediately follows
     * block size. */
    case DW_FORM_block4:
      attr_value->type = DWARF_VALUE_BLOCK;
      attr_value->block.block_size =
          elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
      attr_value->block.block_ptr = prop + 4;
      attr_value->encoded_size =
          static_cast<Elf_Word>(attr_value->block.block_size + 4);
      break;

    /* Property is a block of data, contained in .debug_info section. Block
     * size is encoded with unsigned LEB128 value, and block data immediately
     * follows block size. */
    case DW_FORM_block:
      reinterpret_cast<const Dwarf_Leb128*>(prop)->process_unsigned(&leb128);
      attr_value->type = DWARF_VALUE_BLOCK;
      attr_value->block.block_size = leb128.u32;
      attr_value->block.block_ptr = prop + leb128.encoded_size;
      attr_value->encoded_size =
          static_cast<Elf_Word>(attr_value->block.block_size +
                                leb128.encoded_size);
      break;

    /* Property is unsigned 1 byte value. */
    case DW_FORM_flag:
    case DW_FORM_data1:
    case DW_FORM_ref1:
      attr_value->type = DWARF_VALUE_U8;
      attr_value->u8 = *prop;
      attr_value->encoded_size = 1;
      break;

    /* Property is unsigned 2 bytes value. */
    case DW_FORM_data2:
    case DW_FORM_ref2:
      attr_value->type = DWARF_VALUE_U16;
      attr_value->u16 =
          elf_file_->pull_val(reinterpret_cast<const Elf_Half*>(prop));
      attr_value->encoded_size = 2;
      break;

    /* Property is unsigned 4 bytes value. */
    case DW_FORM_data4:
    case DW_FORM_ref4:
      attr_value->type = DWARF_VALUE_U32;
      attr_value->u32 =
          elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
      attr_value->encoded_size = 4;
      break;

    /* Property is unsigned 8 bytes value. */
    case DW_FORM_data8:
    case DW_FORM_ref8:
    case DW_FORM_ref_sig8:
      attr_value->type = DWARF_VALUE_U64;
      attr_value->u64 =
          elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
      attr_value->encoded_size = 8;
      break;

    /* Property is signed LEB128 value. */
    case DW_FORM_sdata:
      reinterpret_cast<const Dwarf_Leb128*>(prop)->process_signed(attr_value);
      break;

    /* Property is unsigned LEB128 value. */
    case DW_FORM_ref_udata:
    case DW_FORM_udata:
      reinterpret_cast<const Dwarf_Leb128*>(prop)->process_unsigned(attr_value);
      break;

    /* Property is a string contained directly in .debug_info section. */
    case DW_FORM_string:
      attr_value->type = DWARF_VALUE_STR;
      attr_value->str = reinterpret_cast<const char*>(prop);
      attr_value->encoded_size = strlen(attr_value->str) + 1;
      break;

    /* Property is an offset of a string contained in .debug_str section.
     * We will process the reference here, converting it into the actual
     * string value. */
    case DW_FORM_strp:
      attr_value->type = DWARF_VALUE_STR;
      if (elf_file_->is_DWARF_64()) {
        Elf_Xword str_offset =
            elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
        attr_value->str = elf_file_->get_debug_str(str_offset);
        attr_value->encoded_size = 8;
      } else {
        Elf_Word str_offset =
            elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
        attr_value->str = elf_file_->get_debug_str(str_offset);
        attr_value->encoded_size = 4;
      }
      break;

    /* Property is an address. */
    case DW_FORM_addr:
      if (addr_sizeof_ == 4) {
        attr_value->type = DWARF_VALUE_PTR32;
        attr_value->u32 =
            elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
      } else {
        attr_value->type = DWARF_VALUE_PTR64;
        attr_value->u64 =
            elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
      }
      attr_value->encoded_size = addr_sizeof_;
      break;

    /* Reference from the beginning of .debug_info section. */
    case DW_FORM_ref_addr:
      /* DWARF3+ requires that encoding size of this property must be 4 bytes
       * in 32-bit DWARF, and 8 bytes in 64-bit DWARF, while DWARF2- requires
       * encoding size to be equal to CU's pointer size. */
      if (is_DWARF3_or_higher()) {
        if (elf_file_->is_DWARF_64()) {
          attr_value->type = DWARF_VALUE_U64;
          attr_value->u64 =
              elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
          attr_value->encoded_size = 4;
        } else {
          attr_value->type = DWARF_VALUE_U32;
          attr_value->u32 =
              elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
          attr_value->encoded_size = 8;
        }
      } else {
        if (addr_sizeof_ == 4) {
          attr_value->type = DWARF_VALUE_U32;
          attr_value->u32 =
              elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
        } else {
          attr_value->type = DWARF_VALUE_U64;
          attr_value->u64 =
              elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
        }
        attr_value->encoded_size = addr_sizeof_;
      }
      break;

    /* Reference to a section, other than .debug_info, or .debug_str */
    case DW_FORM_sec_offset:
      if (elf_file_->is_DWARF_64()) {
        attr_value->type = DWARF_VALUE_U64;
        attr_value->u64 =
            elf_file_->pull_val(reinterpret_cast<const Elf_Xword*>(prop));
        attr_value->encoded_size = 4;
      } else {
        attr_value->type = DWARF_VALUE_U32;
        attr_value->u32 =
            elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
        attr_value->encoded_size = 8;
      }
      break;

    /* This is a replacement for DW_FORM_flag, which doesn't consume memory
     * in .debug_info section, and only by the fact of its existence it is
     * equal to DW_FORM_flag with value set to 1. */
    case DW_FORM_flag_present:
      attr_value->type = DWARF_VALUE_U8;
      attr_value->u8 = 1;
      attr_value->encoded_size = 0;
      break;

    /* Encodes the actual form to be used. */
    case DW_FORM_indirect:
      // Starts with ULEB128
      prop = reinterpret_cast<const Elf_Byte*>
                (reinterpret_cast<const Dwarf_Leb128*>
                    (prop)->process_unsigned(&tmp_val));
      /* ULEB128 encodes the actual form to be used to process this entry. */
      process_attrib(prop, tmp_val.u16, attr_value);
      attr_value->encoded_size += tmp_val.encoded_size;
      break;

    /* This form is defined for DWARF4, and has no documentation whatsoever. */
    case DW_FORM_exprloc:
    default:
      attr_value->type = DWARF_VALUE_U32;
      attr_value->u32 =
          elf_file_->pull_val(reinterpret_cast<const Elf_Word*>(prop));
      attr_value->encoded_size = 4;
      break;
  }

  return prop + attr_value->encoded_size;
}

void DwarfCU::dump() const {
  printf("\n\n>>>>>>>>>>>>>>> CU %p (version %u, address size %u)\n",
         cu_die_->die(), static_cast<Elf_Word>(version_),
         static_cast<Elf_Word>(addr_sizeof_));
  printf(">>>>> Build dir path:  %s\n", comp_dir_path());
  printf(">>>>> Build file path: %s\n", rel_cu_path());
  if (cu_die_ != NULL) {
    cu_die_->dump(false);
  }
}

//=============================================================================
// DwarfCUImpl implementation
//=============================================================================

template <typename Dwarf_CUHdr, typename Dwarf_Off>
DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::DwarfCUImpl(ElfFile* elf,
                                                 const Dwarf_CUHdr* hdr)
    : DwarfCU(elf),
      cu_header_(hdr) {
  /* Cache CU's DIE abbreviation descriptor in the array. This MUST be done
   * BEFORE first call to array's cache_to() method. */
  const Dwarf_Abbr_DIE* cu_abbr_die = reinterpret_cast<const Dwarf_Abbr_DIE*>
                                 (INC_CPTR(elf->get_debug_abbrev_data(),
                                           elf->pull_val(hdr->abbrev_offset)));
  abbrs_.add(cu_abbr_die);

  cu_size_ = elf->pull_val(hdr->size_hdr.size);
  version_ = elf->pull_val(hdr->version);
  addr_sizeof_ = hdr->address_size;
  memset(&stmtl_header_, 0, sizeof(stmtl_header_));
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::parse(
    const DwarfParseContext* parse_context,
    const void** next_cu_die) {
  /* Start parsing with the DIE for this CU. */
  if (process_DIE(parse_context, get_DIE(), NULL) == NULL) {
    return false;
  }

  /* CU area size (thus, next CU header offset) in .debug_info section equals
   * to CU size, plus number of bytes, required to encode CU size in CU header
   * (4 for 32-bit CU, and 12 for 64-bit CU. */
  *next_cu_die =
      INC_CPTR(cu_header_, cu_size_ + ELFF_FIELD_OFFSET(Dwarf_CUHdr, version));

  return true;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
const Elf_Byte* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::process_DIE(
    const DwarfParseContext* parse_context,
    const Dwarf_DIE* die,
    DIEObject* parent_obj) {
  while (is_attrib_ptr_valid(die) && !die->is_separator()) {
    Dwarf_AbbrNum abbr_num;
    Dwarf_Tag     die_tag;
    Elf_Word      sibling_off = 0;

    /* Get DIE's abbreviation number, and advance to DIE's properties. */
    const Elf_Byte* die_attr = die->process(&abbr_num);

    /* Get abbreviation for the current DIE. */
    const Dwarf_Abbr_DIE* die_abbr = abbrs_.cache_to(abbr_num);
    if (die_abbr == NULL) {
      return NULL;
    }

    /* Get base DIE properties, and advance to the DIE's
     * attribute descriptors. */
    const Dwarf_Abbr_AT* at_abbr = die_abbr->process(NULL, &die_tag);

    /* Instantiate DIE object for this DIE, and get list of properties,
     * that should be collected while processing that DIE. */
    DIEObject* die_obj =
      create_die_object(parse_context, die, parent_obj, die_tag);
    if (die_obj == NULL && errno != 0) {
      return NULL;
    }

    if (die_obj != NULL) {
      if (parent_obj != NULL) {
        /* Update list of parent's children. */
        die_obj->link_sibling(parent_obj->last_child());
        parent_obj->link_child(die_obj);
      } else {
        /* NULL parent object is allowed only for CU DIE itself. */
        assert(cu_die_ == NULL && die_tag == DW_TAG_compile_unit);
        if (cu_die_ == NULL && die_tag != DW_TAG_compile_unit) {
          _set_errno(EINVAL);
          return NULL;
        }
        cu_die_ = die_obj;
        /* This CU DIE object will be used as a parent for all DIE
         * objects, created in this method. */
        parent_obj = cu_die_;
      }
    }

    // Loop through all DIE properties.
    while (elf_file_->is_valid_abbr_ptr(at_abbr, sizeof(Dwarf_Abbr_AT)) &&
           !at_abbr->is_separator()) {
      Dwarf_At    at_value;
      Dwarf_Form  at_form;
      Dwarf_Value attr_value;

      // Obtain next property value.
      at_abbr = at_abbr->process(&at_value, &at_form);
      die_attr = process_attrib(die_attr, at_form, &attr_value);

      if (at_value == DW_AT_sibling) {
        /* DW_AT_sibling means that next DIE is a child of the one that's
         * being currently processed. We need to cache value of this property
         * in order to correctly calculate next sibling of this DIE after
         * child's DIE has been processed. */
        assert(sibling_off == 0);
        sibling_off = attr_value.u32;
      }
    }

    /* Next DIE immediately follows last property for the current DIE. */
    die = reinterpret_cast<const Dwarf_DIE*>(die_attr);
    if (sibling_off != 0) {
      // Process child DIE.
      process_DIE(parse_context, die, die_obj != NULL ? die_obj : parent_obj);
      // Next sibling DIE offset is relative to this CU's header beginning.
      die = INC_CPTR_T(Dwarf_DIE, cu_header_, sibling_off);
    }
  }

  return INC_CPTR_T(Elf_Byte, die, 1);
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
DIEObject* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::create_die_object(
    const DwarfParseContext* parse_context,
    const Dwarf_DIE* die,
    DIEObject* parent,
    Dwarf_Tag tag) {
  DIEObject* ret = NULL;

  /* We will always create a DIE object for CU DIE. */
  if (tag == DW_TAG_compile_unit || collect_die(parse_context, tag)) {
    ret = new(elf_file_) DIEObject(die, this, parent);
    assert(ret != NULL);
    if (ret == NULL) {
      _set_errno(ENOMEM);
    }
  } else {
    _set_errno(0);
  }
  return ret;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::init_stmtl() {
  if (stmtl_header_.unit_length != 0) {
    return true;
  }

  assert(cu_die_ != NULL);
  if (cu_die_ == NULL) {
    _set_errno(EINVAL);
    return false;
  }

  DIEAttrib stmtl;
  if (!cu_die()->get_attrib(DW_AT_stmt_list, &stmtl)) {
    _set_errno(EINVAL);
    return false;
  }

  const void* stmtl_start =
      INC_CPTR(elf_file()->get_debug_line_data(), stmtl.value()->u32);
  if (*reinterpret_cast<const Elf_Word*>(stmtl_start) == 0xFFFFFFFF) {
    cache_stmtl<Dwarf64_STMTLHdr>(reinterpret_cast<const Dwarf64_STMTLHdr*>(stmtl_start));
  } else {
    cache_stmtl<Dwarf32_STMTLHdr>(reinterpret_cast<const Dwarf32_STMTLHdr*>(stmtl_start));
  }

  return true;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_pc_address_file_info(
    Elf_Xword address,
    Dwarf_AddressInfo* info) {
  /* Make sure STMTL header is cached. */
  if (!init_stmtl()) {
    return false;
  }
  /* Flags address match, that should trigger return next time
   * source line gets adjusted. */
  bool found = false;
  /* Create new state machine. */
  DwarfStateMachine state(stmtl_header_.default_is_stmt != 0);

  /* Start the "Line Number Program" */
  const Elf_Byte* go = stmtl_header_.start;
  while (go < stmtl_header_.end) {
    const Elf_Byte op = *go;
    go++;

    if (op == 0) {
      /* This is an extended opcode. */
      Dwarf_Value op_size;

      /* First ULEB128 contains opcode size, (excluding ULEB128 itself). */
      go = reinterpret_cast<const Elf_Byte*>
             (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&op_size));
      /* Next is the extended opcode. */
      const Elf_Byte* ex_op_ptr = go;
      switch (*ex_op_ptr) {
        case DW_LNE_end_sequence:
          state.end_sequence_ = true;
          state.reset(stmtl_header_.default_is_stmt != 0);
          found = false;
          break;

        case DW_LNE_set_address: {
          Elf_Xword prev_address = state.address_;
          if (is_CU_address_64()) {
            state.address_ =
              elf_file()->pull_val(reinterpret_cast<const Elf_Xword*>(ex_op_ptr + 1));
          } else {
            state.address_ =
              elf_file()->pull_val(reinterpret_cast<const Elf_Word*>(ex_op_ptr + 1));
          }
          if (prev_address != 0 &&
              address >= prev_address && address < state.address_) {
            return set_source_info(&state, info);
          } else if (address == state.address_) {
            found = true;
          }
          break;
        }

        case DW_LNE_define_file: {
          /* Parameters start with the directly encoded zero-terminated
           * file name. */
          state.set_file_info_ = INC_CPTR_T(Dwarf_STMTL_FileDesc, ex_op_ptr, 1);
          assert(state.set_file_info_ != NULL);
          if (state.set_file_info_ != NULL) {
            ex_op_ptr = reinterpret_cast<const Elf_Byte*>(state.set_file_info_->process(NULL));
          }
          break;
        }

        case DW_LNE_set_discriminator: {
          Dwarf_Value discr_val;
          /* One parameter: discriminator's ULEB128 value. */
          reinterpret_cast<const Dwarf_Leb128*>(ex_op_ptr + 1)->process_unsigned(&discr_val);
          state.discriminator_ = discr_val.u32;
          break;
        }

        default:
          assert(0);
          return false;
      }
      go += op_size.u32;
    } else if (op < stmtl_header_.opcode_base) {
      /* This is a standard opcode. */
      switch (op) {
        case DW_LNS_copy:
          /* No parameters. */
          state.basic_block_ = false;
          state.prologue_end_ = false;
          state.epilogue_begin_ = false;
          break;

        case DW_LNS_advance_pc: {
          /* One parameter: ULEB128 value to add to the current address value
           * in the state machine. */
          Dwarf_Value addr_add;
          go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&addr_add));
          Elf_Xword prev_address = state.address_;
          state.address_ += addr_add.u64;
          if (prev_address != 0 &&
              address >= prev_address && address < state.address_) {
            return set_source_info(&state, info);
          } else if (address == state.address_) {
            found = true;
          }
          break;
        }

        case DW_LNS_advance_line: {
          /* One parameter: signed LEB128 value to add to the current line
           * number in the state machine. */
          Dwarf_Value line_add;
          go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_signed(&line_add));
          state.line_ += line_add.s32;
          if (found) {
            return set_source_info(&state, info);
          }
          break;
        }

        case DW_LNS_set_file: {
          /* One parameter: ULEB128 value encoding current file number. */
          Dwarf_Value file_num;
          go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&file_num));
          state.file_ = file_num.u32;
          /* This operation should discard previously saved file information. */
          state.set_file_info_ = NULL;
          break;
        }

        case DW_LNS_set_column: {
          /* One parameter: ULEB128 value encoding current column number. */
          Dwarf_Value column_num;
          go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&column_num));
          state.column_ = column_num.u32;
          break;
        }

        case DW_LNS_negate_stmt:
          /* No parameters. */
          state.is_stmt_ = !state.is_stmt_;
          break;

        case DW_LNS_set_basic_block:
          /* No parameters. */
          state.basic_block_ = true;
          break;

        case DW_LNS_const_add_pc: {
          Elf_Xword prev_address = state.address_;
          /* No parameters. This operation does the same thing, as special
           * opcode 255 would do to the current address. */
          Elf_Word adjusted =
              static_cast<Elf_Word>(255) - stmtl_header_.opcode_base;
          state.address_ += (adjusted / stmtl_header_.line_range) *
                            stmtl_header_.min_instruction_len;
          if (prev_address != 0 &&
              address >= prev_address && address < state.address_) {
            return set_source_info(&state, info);
          } else if (address == state.address_) {
            found = true;
          }
          break;
        }

        case DW_LNS_fixed_advance_pc: {
          Elf_Xword prev_address = state.address_;
          /* One parameter: directly encoded 16-bit value to add to the
           * current address. */
          state.address_ +=
              elf_file()->pull_val(reinterpret_cast<const Elf_Half*>(go));
          if (prev_address != 0 &&
              address >= prev_address && address < state.address_) {
            return set_source_info(&state, info);
          } else if (address == state.address_) {
            found = true;
          }
          go += sizeof(Elf_Half);
          break;
        }

        case DW_LNS_set_prologue_end:
          /* No parameters. */
          state.prologue_end_ = true;
          break;

        case DW_LNS_set_epilogue_begin:
          /* No parameters. */
          state.epilogue_begin_ = true;
          break;

        case DW_LNS_set_isa: {
          /* One parameter: ISA value encoded as ULEB128. */
          Dwarf_Value isa_val;
          go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&isa_val));
          state.isa_ = isa_val.u32;
          break;
        }

        default:
          /* Unknown opcode. Just skip it. */
          for (Elf_Byte uleb = 0;
               uleb < stmtl_header_.standard_opcode_lengths[op - 1]; uleb++) {
            Dwarf_Value tmp;
            go = reinterpret_cast<const Elf_Byte*>
              (reinterpret_cast<const Dwarf_Leb128*>(go)->process_unsigned(&tmp));
          }
          break;
      }
    } else {
      Elf_Xword prev_address = state.address_;
      /* This is a special opcode. */
      const Elf_Word adjusted = op - stmtl_header_.opcode_base;
      /* Advance address. */
      state.address_ += (adjusted / stmtl_header_.line_range) *
                        stmtl_header_.min_instruction_len;
      if (prev_address != 0 &&
          address >= prev_address && address < state.address_) {
        return set_source_info(&state, info);
      }
      /* Advance line. */
      state.line_ += stmtl_header_.line_base +
                     (adjusted % stmtl_header_.line_range);
      if (state.address_ == address) {
        return set_source_info(&state, info);
      }
      /* Do the woodoo. */
      state.basic_block_ = false;
      state.prologue_end_ = false;
      state.epilogue_begin_ = false;
    }
  }

  return false;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
const Dwarf_STMTL_FileDesc* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_stmt_file_info(
    Elf_Word index) {
  /* Index must be 1-based. */
  if (index == 0) {
    return NULL;
  }

  const Dwarf_STMTL_FileDesc* cur_desc = stmtl_header_.file_infos;
  while (index != 1 && !cur_desc->is_last_entry()) {
    cur_desc = cur_desc->process(NULL);
    index--;
  }
  assert(!cur_desc->is_last_entry());
  return cur_desc->is_last_entry() ? NULL : cur_desc;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
const char* DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::get_stmt_dir_name(
    Elf_Word dir_index) {
  if (dir_index == 0) {
    /* Requested is current compilation directory. */
    return comp_dir_path();
  }
  if (dir_index > stmtl_header_.inc_dir_num) {
    return NULL;
  }

  const char* cur_dir = stmtl_header_.include_directories;
  while (dir_index != 1) {
    cur_dir += strlen(cur_dir) + 1;
    dir_index--;
  }
  return cur_dir;
}

template <typename Dwarf_CUHdr, typename Dwarf_Off>
bool DwarfCUImpl<Dwarf_CUHdr, Dwarf_Off>::set_source_info(
    const DwarfStateMachine* state,
    Dwarf_AddressInfo* info) {
  info->line_number = state->line_;
  const Dwarf_STMTL_FileDesc* file_info = state->set_file_info_;
  if (file_info == NULL) {
    file_info = get_stmt_file_info(state->file_);
    if (file_info == NULL) {
      info->file_name = rel_cu_path();
      info->dir_name = comp_dir_path();
      return true;
    }
  }
  info->file_name = file_info->get_file_name();
  const Elf_Word dir_index = file_info->get_dir_index();
  info->dir_name = get_stmt_dir_name(dir_index);
  return true;
}