The Tor Browser: comparison toolkit/crashreporter/google-breakpad/src/common/stabs

--1:000000000000
+:1b640f2dee59
+// 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 "common/stabs_reader.h"
+#include <assert.h>
+#include <stab.h>
+#include <string.h>
+#include <string>
+#include "common/using_std_string.h"
+using std::vector;
+namespace google_breakpad {
+StabsReader::EntryIterator::EntryIterator(const ByteBuffer *buffer,
+bool big_endian, size_t value_size)
+: value_size_(value_size), cursor_(buffer, big_endian) {
+// Actually, we could handle weird sizes just fine, but they're
+// probably mistakes --- expressed in bits, say.
+assert(value_size == 4 || value_size == 8);
+entry_.index = 0;
+Fetch();
+}
+void StabsReader::EntryIterator::Fetch() {
+cursor_
+.Read(4, false, &entry_.name_offset)
+.Read(1, false, &entry_.type)
+.Read(1, false, &entry_.other)
+.Read(2, false, &entry_.descriptor)
+.Read(value_size_, false, &entry_.value);
+entry_.at_end = !cursor_;
+}
+StabsReader::StabsReader(const uint8_t *stab,    size_t stab_size,
+const uint8_t *stabstr, size_t stabstr_size,
+bool big_endian, size_t value_size, bool unitized,
+StabsHandler *handler)
+: entries_(stab, stab_size),
+strings_(stabstr, stabstr_size),
+iterator_(&entries_, big_endian, value_size),
+unitized_(unitized),
+handler_(handler),
+string_offset_(0),
+next_cu_string_offset_(0),
+current_source_file_(NULL) { }
+const char *StabsReader::SymbolString() {
+ptrdiff_t offset = string_offset_ + iterator_->name_offset;
+if (offset < 0 || (size_t) offset >= strings_.Size()) {
+handler_->Warning("symbol %d: name offset outside the string section\n",
+iterator_->index);
+// Return our null string, to keep our promise about all names being
+// taken from the string section.
+offset = 0;
+}
+return reinterpret_cast<const char *>(strings_.start + offset);
+}
+bool StabsReader::Process() {
+while (!iterator_->at_end) {
+if (iterator_->type == N_SO) {
+if (! ProcessCompilationUnit())
+return false;
+} else if (iterator_->type == N_UNDF && unitized_) {
+// In unitized STABS (including Linux STABS, and pretty much anything
+// else that puts STABS data in sections), 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_ = iterator_->value;
+++iterator_;
+}
+#if defined(HAVE_MACH_O_NLIST_H)
+// Export symbols in Mach-O binaries look like this.
+// This is necessary in order to be able to dump symbols
+// from OS X system libraries.
+else if ((iterator_->type & N_STAB) == 0 &&
+(iterator_->type & N_TYPE) == N_SECT) {
+ProcessExtern();
+}
+#endif
+else {
+++iterator_;
+}
+}
+return true;
+}
+bool StabsReader::ProcessCompilationUnit() {
+assert(!iterator_->at_end && iterator_->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;
+++iterator_;
+}
+}
+// We expect to see an N_SO entry with a filename next, indicating
+// the start of the compilation unit.
+{
+if (iterator_->at_end || iterator_->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.
+++iterator_;
+return true;
+}
+current_source_file_ = name;
+}
+if (! handler_->StartCompilationUnit(current_source_file_,
+iterator_->value,
+build_directory))
+return false;
+++iterator_;
+// 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 (!iterator_->at_end && iterator_->type != N_SO) {
+if (iterator_->type == N_FUN) {
+if (! ProcessFunction())
+return false;
+} else if (iterator_->type == N_SLINE) {
+// Mac OS X STABS place SLINE records before functions.
+Line line;
+// The value of an N_SLINE entry that appears outside a function is
+// the absolute address of the line.
+line.address = iterator_->value;
+line.filename = current_source_file_;
+// 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.
+line.number = (uint16_t) iterator_->descriptor;
+queued_lines_.push_back(line);
+++iterator_;
+} else if (iterator_->type == N_SOL) {
+current_source_file_ = SymbolString();
+++iterator_;
+} else {
+// Ignore anything else.
+++iterator_;
+}
+}
+// An N_SO with an empty name indicates the end of the compilation
+// unit.  Default to zero.
+uint64_t ending_address = 0;
+if (!iterator_->at_end) {
+assert(iterator_->type == N_SO);
+const char *name = SymbolString();
+if (name[0] == '\0') {
+ending_address = iterator_->value;
+++iterator_;
+}
+}
+if (! handler_->EndCompilationUnit(ending_address))
+return false;
+queued_lines_.clear();
+return true;
+}
+bool StabsReader::ProcessFunction() {
+assert(!iterator_->at_end && iterator_->type == N_FUN);
+uint64_t function_address = iterator_->value;
+// 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);
+string name(stab_string, name_end - stab_string);
+if (! handler_->StartFunction(name, function_address))
+return false;
+++iterator_;
+// If there were any SLINE records given before the function, report them now.
+for (vector<Line>::const_iterator it = queued_lines_.begin();
+it != queued_lines_.end(); it++) {
+if (!handler_->Line(it->address, it->filename, it->number))
+return false;
+}
+queued_lines_.clear();
+while (!iterator_->at_end) {
+if (iterator_->type == N_SO || iterator_->type == N_FUN)
+break;
+else if (iterator_->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 + iterator_->value;
+// 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 = iterator_->descriptor;
+if (! handler_->Line(line_address, current_source_file_, line_number))
+return false;
+++iterator_;
+} else if (iterator_->type == N_SOL) {
+current_source_file_ = SymbolString();
+++iterator_;
+} else
+// Ignore anything else.
+++iterator_;
+}
+// We've reached the end of the function. See if we can figure out its
+// ending address.
+uint64_t ending_address = 0;
+if (!iterator_->at_end) {
+assert(iterator_->type == N_SO || iterator_->type == N_FUN);
+if (iterator_->type == N_FUN) {
+const char *symbol_name = SymbolString();
+if (symbol_name[0] == '\0') {
+// An N_FUN entry with no name is a terminator for this function;
+// its value is the function's size.
+ending_address = function_address + iterator_->value;
+++iterator_;
+} else {
+// An N_FUN entry with a name is the next function, and we can take
+// its value as our ending address. Don't advance the iterator, as
+// we'll use this symbol to start the next function as well.
+ending_address = iterator_->value;
+}
+} else {
+// An N_SO entry could be an end-of-compilation-unit marker, or the
+// start of the next compilation unit, but in either case, its value
+// is our ending address. We don't advance the iterator;
+// ProcessCompilationUnit will decide what to do with this symbol.
+ending_address = iterator_->value;
+}
+}
+if (! handler_->EndFunction(ending_address))
+return false;
+return true;
+}
+bool StabsReader::ProcessExtern() {
+#if defined(HAVE_MACH_O_NLIST_H)
+assert(!iterator_->at_end &&
+(iterator_->type & N_STAB) == 0 &&
+(iterator_->type & N_TYPE) == N_SECT);
+#endif
+// TODO(mark): only do symbols in the text section?
+if (!handler_->Extern(SymbolString(), iterator_->value))
+return false;
+++iterator_;
+return true;
+}
+} // namespace google_breakpad

The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/common/stabs_reader.cc

toolkit/crashreporter/google-breakpad/src/common/stabs_reader.cc