// Copyright (c) 2010 Google Inc. All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

// This file implements the google_breakpad::StabsReader class.
// See stabs_reader.h.

#include <a.out.h>
#include <stab.h>
#include <cstring>
#include <cassert>

#include "common/stabs_reader.h"

namespace google_breakpad {

StabsReader::StabsReader(const uint8_t *stab,    size_t stab_size,
                         const uint8_t *stabstr, size_t stabstr_size,
                         StabsHandler *handler) :
    stabstr_(stabstr),
    stabstr_size_(stabstr_size),
    handler_(handler),
    string_offset_(0),
    next_cu_string_offset_(0),
    symbol_(NULL),
    current_source_file_(NULL) { 
  symbols_ = reinterpret_cast<const struct nlist *>(stab);
  symbols_end_ = symbols_ + (stab_size / sizeof (*symbols_));
}

const char *StabsReader::SymbolString() {
  ptrdiff_t offset = string_offset_ + symbol_->n_un.n_strx;
  if (offset < 0 || (size_t) offset >= stabstr_size_) {
    handler_->Warning("symbol %d: name offset outside the string section\n",
                      symbol_ - symbols_);
    // Return our null string, to keep our promise about all names being
    // taken from the string section.
    offset = 0;
  }
  return reinterpret_cast<const char *>(stabstr_ + offset);
}

bool StabsReader::Process() {
  symbol_ = symbols_;
  while (symbol_ < symbols_end_) {
    if (symbol_->n_type == N_SO) {
      if (! ProcessCompilationUnit())
        return false;
    } else if (symbol_->n_type == N_UNDF) {
      // At the head of each compilation unit's entries there is an
      // N_UNDF stab giving the number of symbols in the compilation
      // unit, and the number of bytes that compilation unit's strings
      // take up in the .stabstr section. Each CU's strings are
      // separate; the n_strx values are offsets within the current
      // CU's portion of the .stabstr section.
      //
      // As an optimization, the GNU linker combines all the
      // compilation units into one, with a single N_UNDF at the
      // beginning. However, other linkers, like Gold, do not perform
      // this optimization.
      string_offset_ = next_cu_string_offset_;
      next_cu_string_offset_ = SymbolValue();
      symbol_++;
    } else
      symbol_++;
  }
  return true;
}

bool StabsReader::ProcessCompilationUnit() {
  assert(symbol_ < symbols_end_ && symbol_->n_type == N_SO);

  // There may be an N_SO entry whose name ends with a slash,
  // indicating the directory in which the compilation occurred.
  // The build directory defaults to NULL.
  const char *build_directory = NULL;  
  {
    const char *name = SymbolString();
    if (name[0] && name[strlen(name) - 1] == '/') {
      build_directory = name;
      symbol_++;
    }
  }
      
  // We expect to see an N_SO entry with a filename next, indicating
  // the start of the compilation unit.
  {
    if (symbol_ >= symbols_end_ || symbol_->n_type != N_SO)
      return true;
    const char *name = SymbolString();
    if (name[0] == '\0') {
      // This seems to be a stray end-of-compilation-unit marker;
      // consume it, but don't report the end, since we didn't see a
      // beginning.
      symbol_++;
      return true;
    }
    current_source_file_ = name;
  }

  if (! handler_->StartCompilationUnit(current_source_file_,
                                       SymbolValue(),
                                       build_directory))
    return false;

  symbol_++;

  // The STABS documentation says that some compilers may emit
  // additional N_SO entries with names immediately following the
  // first, and that they should be ignored.  However, the original
  // Breakpad STABS reader doesn't ignore them, so we won't either.

  // Process the body of the compilation unit, up to the next N_SO.
  while (symbol_ < symbols_end_ && symbol_->n_type != N_SO) {
    if (symbol_->n_type == N_FUN) {
      if (! ProcessFunction())
        return false;
    } else
      // Ignore anything else.
      symbol_++;
  }

  // An N_SO with an empty name indicates the end of the compilation
  // unit.  Default to zero.
  uint64_t ending_address = 0;
  if (symbol_ < symbols_end_) {
    assert(symbol_->n_type == N_SO);
    const char *name = SymbolString();
    if (name[0] == '\0') {
      ending_address = SymbolValue();
      symbol_++;
    }
  }

  if (! handler_->EndCompilationUnit(ending_address))
    return false;

  return true;
}          

bool StabsReader::ProcessFunction() {
  assert(symbol_ < symbols_end_ && symbol_->n_type == N_FUN);

  uint64_t function_address = SymbolValue();
  // The STABS string for an N_FUN entry is the name of the function,
  // followed by a colon, followed by type information for the
  // function.  We want to pass the name alone to StartFunction.
  const char *stab_string = SymbolString();
  const char *name_end = strchr(stab_string, ':');
  if (! name_end)
    name_end = stab_string + strlen(stab_string);
  std::string name(stab_string, name_end - stab_string);
  if (! handler_->StartFunction(name, function_address))
    return false;
  symbol_++;

  while (symbol_ < symbols_end_) {
    if (symbol_->n_type == N_SO || symbol_->n_type == N_FUN)
      break;
    else if (symbol_->n_type == N_SLINE) {
      // The value of an N_SLINE entry is the offset of the line from
      // the function's start address.
      uint64_t line_address = function_address + SymbolValue();
      // The n_desc of a N_SLINE entry is the line number.  It's a
      // signed 16-bit field; line numbers from 32768 to 65535 are
      // stored as n-65536.
      uint16_t line_number = symbol_->n_desc;
      if (! handler_->Line(line_address, current_source_file_, line_number))
        return false;
      symbol_++;
    } else if (symbol_->n_type == N_SOL) {
      current_source_file_ = SymbolString();
      symbol_++;
    } else
      // Ignore anything else.
      symbol_++;
  }

  // If there is a subsequent N_SO or N_FUN entry, its address is our
  // end address.
  uint64_t ending_address = 0;
  if (symbol_ < symbols_end_) {
    assert(symbol_->n_type == N_SO || symbol_->n_type == N_FUN);
    ending_address = SymbolValue();
    // Note: we do not increment symbol_ here, since we haven't consumed it.
  }

  if (! handler_->EndFunction(ending_address))
    return false;

  return true;
}

} // namespace google_breakpad