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

toolkit/crashreporter/google-breakpad/src/common/stabs_reader.h@129ffea94266 (annotated)

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

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 // -*- mode: c++ -*-
 // 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>
 // stabs_reader.h: Define StabsReader, a parser for STABS debugging
 // information. A description of the STABS debugging format can be
 // found at:
 //
 //    http://sourceware.org/gdb/current/onlinedocs/stabs_toc.html
 //
 // The comments here assume you understand the format.
 //
 // This parser can handle big-endian and little-endian data, and the symbol
 // values may be either 32 or 64 bits long. It handles both STABS in
 // sections (as used on Linux) and STABS appearing directly in an
 // a.out-like symbol table (as used in Darwin OS X Mach-O files).
 #ifndef COMMON_STABS_READER_H__
 #define COMMON_STABS_READER_H__
 #include <stddef.h>
 #include <stdint.h>
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #ifdef HAVE_A_OUT_H
 #include <a.out.h>
 #endif
 #ifdef HAVE_MACH_O_NLIST_H
 #include <mach-o/nlist.h>
 #endif
 #include <string>
 #include <vector>
 #include "common/byte_cursor.h"
 #include "common/using_std_string.h"
 namespace google_breakpad {
 class StabsHandler;
 class StabsReader {
  public:
   // Create a reader for the STABS debug information whose .stab section is
   // being traversed by ITERATOR, and whose .stabstr section is referred to
   // by STRINGS. The reader will call the member functions of HANDLER to
   // report the information it finds, when the reader's 'Process' member
   // function is called.
   //
   // BIG_ENDIAN should be true if the entries in the .stab section are in
   // big-endian form, or false if they are in little-endian form.
   //
   // VALUE_SIZE should be either 4 or 8, indicating the size of the 'value'
   // field in each entry in bytes.
   //
   // UNITIZED should be true if the STABS data is stored in units with
   // N_UNDF headers. This is usually the case for STABS stored in sections,
   // like .stab/.stabstr, and usually not the case for STABS stored in the
   // actual symbol table; UNITIZED should be true when parsing Linux stabs,
   // false when parsing Mac OS X STABS. For details, see:
   // http://sourceware.org/gdb/current/onlinedocs/stabs/Stab-Section-Basics.html
   //
   // Note that, in ELF, the .stabstr section should be found using the
   // 'sh_link' field of the .stab section header, not by name.
   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);
   // Process the STABS data, calling the handler's member functions to
   // report what we find.  While the handler functions return true,
   // continue to process until we reach the end of the section.  If we
   // processed the entire section and all handlers returned true,
   // return true.  If any handler returned false, return false.
   //
   // This is only meant to be called once per StabsReader instance;
   // resuming a prior processing pass that stopped abruptly isn't supported.
   bool Process();
  private:
   // An class for walking arrays of STABS entries. This isolates the main
   // STABS reader from the exact format (size; endianness) of the entries
   // themselves.
   class EntryIterator {
    public:
     // The contents of a STABS entry, adjusted for the host's endianness,
     // word size, 'struct nlist' layout, and so on.
     struct Entry {
       // True if this iterator has reached the end of the entry array. When
       // this is set, the other members of this structure are not valid.
       bool at_end;
       // The number of this entry within the list.
       size_t index;
       // The current entry's name offset. This is the offset within the
       // current compilation unit's strings, as establish by the N_UNDF entries.
       size_t name_offset;
       // The current entry's type, 'other' field, descriptor, and value.
       unsigned char type;
       unsigned char other;
       short descriptor;
       uint64_t value;
     };
     // Create a EntryIterator walking the entries in BUFFER. Treat the
     // entries as big-endian if BIG_ENDIAN is true, as little-endian
     // otherwise. Assume each entry has a 'value' field whose size is
     // VALUE_SIZE.
     //
     // This would not be terribly clean to extend to other format variations,
     // but it's enough to handle Linux and Mac, and we'd like STABS to die
     // anyway.
     //
     // For the record: on Linux, STABS entry values are always 32 bits,
     // regardless of the architecture address size (don't ask me why); on
     // Mac, they are 32 or 64 bits long. Oddly, the section header's entry
     // size for a Linux ELF .stab section varies according to the ELF class
     // from 12 to 20 even as the actual entries remain unchanged.
     EntryIterator(const ByteBuffer *buffer, bool big_endian, size_t value_size);
     // Move to the next entry. This function's behavior is undefined if
     // at_end() is true when it is called.
     EntryIterator &operator++() { Fetch(); entry_.index++; return *this; }
     // Dereferencing this iterator produces a reference to an Entry structure
     // that holds the current entry's values. The entry is owned by this
     // EntryIterator, and will be invalidated at the next call to operator++.
     const Entry &operator*() const { return entry_; }
     const Entry *operator->() const { return &entry_; }
    private:
     // Read the STABS entry at cursor_, and set entry_ appropriately.
     void Fetch();
     // The size of entries' value field, in bytes.
     size_t value_size_;
     // A byte cursor traversing buffer_.
     ByteCursor cursor_;
     // Values for the entry this iterator refers to.
     Entry entry_;
   };
   // A source line, saved to be reported later.
   struct Line {
     uint64_t address;
     const char *filename;
     int number;
   };
   // Return the name of the current symbol.
   const char *SymbolString();
   // Process a compilation unit starting at symbol_.  Return true
   // to continue processing, or false to abort.
   bool ProcessCompilationUnit();
   // Process a function in current_source_file_ starting at symbol_.
   // Return true to continue processing, or false to abort.
   bool ProcessFunction();
   // Process an exported function symbol.
   // Return true to continue processing, or false to abort.
   bool ProcessExtern();
   // The STABS entries being parsed.
   ByteBuffer entries_;
   // The string section to which the entries refer.
   ByteBuffer strings_;
   // The iterator walking the STABS entries.
   EntryIterator iterator_;
   // True if the data is "unitized"; see the explanation in the comment for
   // StabsReader::StabsReader.
   bool unitized_;
   StabsHandler *handler_;
   // The offset of the current compilation unit's strings within stabstr_.
   size_t string_offset_;
   // The value string_offset_ should have for the next compilation unit,
   // as established by N_UNDF entries.
   size_t next_cu_string_offset_;
   // The current source file name.
   const char *current_source_file_;
   // Mac OS X STABS place SLINE records before functions; we accumulate a
   // vector of these until we see the FUN record, and then report them
   // after the StartFunction call.
   std::vector<Line> queued_lines_;
 };
 // Consumer-provided callback structure for the STABS reader.  Clients
 // of the STABS reader provide an instance of this structure.  The
 // reader then invokes the member functions of that instance to report
 // the information it finds.
 //
 // The default definitions of the member functions do nothing, and return
 // true so processing will continue.
 class StabsHandler {
  public:
   StabsHandler() { }
   virtual ~StabsHandler() { }
   // Some general notes about the handler callback functions:
   // Processing proceeds until the end of the .stabs section, or until
   // one of these functions returns false.
   // The addresses given are as reported in the STABS info, without
   // regard for whether the module may be loaded at different
   // addresses at different times (a shared library, say).  When
   // processing STABS from an ELF shared library, the addresses given
   // all assume the library is loaded at its nominal load address.
   // They are *not* offsets from the nominal load address.  If you
   // want offsets, you must subtract off the library's nominal load
   // address.
   // The arguments to these functions named FILENAME are all
   // references to strings stored in the .stabstr section.  Because
   // both the Linux and Solaris linkers factor out duplicate strings
   // from the .stabstr section, the consumer can assume that if two
   // FILENAME values are different addresses, they represent different
   // file names.
   //
   // Thus, it's safe to use (say) std::map<char *, ...>, which does
   // string address comparisons, not string content comparisons.
   // Since all the strings are in same array of characters --- the
   // .stabstr section --- comparing their addresses produces
   // predictable, if not lexicographically meaningful, results.
   // Begin processing a compilation unit whose main source file is
   // named FILENAME, and whose base address is ADDRESS.  If
   // BUILD_DIRECTORY is non-NULL, it is the name of the build
   // directory in which the compilation occurred.
   virtual bool StartCompilationUnit(const char *filename, uint64_t address,
                                     const char *build_directory) {
     return true;
   }
   // Finish processing the compilation unit.  If ADDRESS is non-zero,
   // it is the ending address of the compilation unit.  If ADDRESS is
   // zero, then the compilation unit's ending address is not
   // available, and the consumer must infer it by other means.
   virtual bool EndCompilationUnit(uint64_t address) { return true; }
   // Begin processing a function named NAME, whose starting address is
   // ADDRESS.  This function belongs to the compilation unit that was
   // most recently started but not ended.
   //
   // Note that, unlike filenames, NAME is not a pointer into the
   // .stabstr section; this is because the name as it appears in the
   // STABS data is followed by type information.  The value passed to
   // StartFunction is the function name alone.
   //
   // In languages that use name mangling, like C++, NAME is mangled.
   virtual bool StartFunction(const string &name, uint64_t address) {
     return true;
   }
   // Finish processing the function.  If ADDRESS is non-zero, it is
   // the ending address for the function.  If ADDRESS is zero, then
   // the function's ending address is not available, and the consumer
   // must infer it by other means.
   virtual bool EndFunction(uint64_t address) { return true; }
   // Report that the code at ADDRESS is attributable to line NUMBER of
   // the source file named FILENAME.  The caller must infer the ending
   // address of the line.
   virtual bool Line(uint64_t address, const char *filename, int number) {
     return true;
   }
   // Report that an exported function NAME is present at ADDRESS.
   // The size of the function is unknown.
   virtual bool Extern(const string &name, uint64_t address) {
     return true;
   }
   // Report a warning.  FORMAT is a printf-like format string,
   // specifying how to format the subsequent arguments.
   virtual void Warning(const char *format, ...) = 0;
 };
 } // namespace google_breakpad
 #endif  // COMMON_STABS_READER_H__

The Tor Browser / annotate

toolkit/crashreporter/google-breakpad/src/common/stabs_reader.h@129ffea94266 (annotated)

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