The Tor Browser: toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader.cc

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.

 // 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.
 #include <assert.h>
 #include <stdlib.h>
 #include "common/dwarf/bytereader-inl.h"
 #include "common/dwarf/bytereader.h"
 namespace dwarf2reader {
 ByteReader::ByteReader(enum Endianness endian)
     :offset_reader_(NULL), address_reader_(NULL), endian_(endian),
      address_size_(0), offset_size_(0),
      have_section_base_(), have_text_base_(), have_data_base_(),
      have_function_base_() { }
 ByteReader::~ByteReader() { }
 void ByteReader::SetOffsetSize(uint8 size) {
   offset_size_ = size;
   assert(size == 4 || size == 8);
   if (size == 4) {
     this->offset_reader_ = &ByteReader::ReadFourBytes;
   } else {
     this->offset_reader_ = &ByteReader::ReadEightBytes;
   }
 }
 void ByteReader::SetAddressSize(uint8 size) {
   address_size_ = size;
   assert(size == 4 || size == 8);
   if (size == 4) {
     this->address_reader_ = &ByteReader::ReadFourBytes;
   } else {
     this->address_reader_ = &ByteReader::ReadEightBytes;
   }
 }
 uint64 ByteReader::ReadInitialLength(const char* start, size_t* len) {
   const uint64 initial_length = ReadFourBytes(start);
   start += 4;
   // In DWARF2/3, if the initial length is all 1 bits, then the offset
   // size is 8 and we need to read the next 8 bytes for the real length.
   if (initial_length == 0xffffffff) {
     SetOffsetSize(8);
     *len = 12;
     return ReadOffset(start);
   } else {
     SetOffsetSize(4);
     *len = 4;
   }
   return initial_length;
 }
 bool ByteReader::ValidEncoding(DwarfPointerEncoding encoding) const {
   if (encoding == DW_EH_PE_omit) return true;
   if (encoding == DW_EH_PE_aligned) return true;
   if ((encoding & 0x7) > DW_EH_PE_udata8)
     return false;
   if ((encoding & 0x70) > DW_EH_PE_funcrel)
     return false;
   return true;
 }
 bool ByteReader::UsableEncoding(DwarfPointerEncoding encoding) const {
   switch (encoding & 0x70) {
     case DW_EH_PE_absptr:  return true;
     case DW_EH_PE_pcrel:   return have_section_base_;
     case DW_EH_PE_textrel: return have_text_base_;
     case DW_EH_PE_datarel: return have_data_base_;
     case DW_EH_PE_funcrel: return have_function_base_;
     default:               return false;
   }
 }
 uint64 ByteReader::ReadEncodedPointer(const char *buffer,
                                       DwarfPointerEncoding encoding,
                                       size_t *len) const {
   // UsableEncoding doesn't approve of DW_EH_PE_omit, so we shouldn't
   // see it here.
   assert(encoding != DW_EH_PE_omit);
   // The Linux Standards Base 4.0 does not make this clear, but the
   // GNU tools (gcc/unwind-pe.h; readelf/dwarf.c; gdb/dwarf2-frame.c)
   // agree that aligned pointers are always absolute, machine-sized,
   // machine-signed pointers.
   if (encoding == DW_EH_PE_aligned) {
     assert(have_section_base_);
     // We don't need to align BUFFER in *our* address space. Rather, we
     // need to find the next position in our buffer that would be aligned
     // when the .eh_frame section the buffer contains is loaded into the
     // program's memory. So align assuming that buffer_base_ gets loaded at
     // address section_base_, where section_base_ itself may or may not be
     // aligned.
     // First, find the offset to START from the closest prior aligned
     // address.
     uint64 skew = section_base_ & (AddressSize() - 1);
     // Now find the offset from that aligned address to buffer.
     uint64 offset = skew + (buffer - buffer_base_);
     // Round up to the next boundary.
     uint64 aligned = (offset + AddressSize() - 1) & -AddressSize();
     // Convert back to a pointer.
     const char *aligned_buffer = buffer_base_ + (aligned - skew);
     // Finally, store the length and actually fetch the pointer.
     *len = aligned_buffer - buffer + AddressSize();
     return ReadAddress(aligned_buffer);
   }
   // Extract the value first, ignoring whether it's a pointer or an
   // offset relative to some base.
   uint64 offset;
   switch (encoding & 0x0f) {
     case DW_EH_PE_absptr:
       // DW_EH_PE_absptr is weird, as it is used as a meaningful value for
       // both the high and low nybble of encoding bytes. When it appears in
       // the high nybble, it means that the pointer is absolute, not an
       // offset from some base address. When it appears in the low nybble,
       // as here, it means that the pointer is stored as a normal
       // machine-sized and machine-signed address. A low nybble of
       // DW_EH_PE_absptr does not imply that the pointer is absolute; it is
       // correct for us to treat the value as an offset from a base address
       // if the upper nybble is not DW_EH_PE_absptr.
       offset = ReadAddress(buffer);
       *len = AddressSize();
       break;
     case DW_EH_PE_uleb128:
       offset = ReadUnsignedLEB128(buffer, len);
       break;
     case DW_EH_PE_udata2:
       offset = ReadTwoBytes(buffer);
       *len = 2;
       break;
     case DW_EH_PE_udata4:
       offset = ReadFourBytes(buffer);
       *len = 4;
       break;
     case DW_EH_PE_udata8:
       offset = ReadEightBytes(buffer);
       *len = 8;
       break;
     case DW_EH_PE_sleb128:
       offset = ReadSignedLEB128(buffer, len);
       break;
     case DW_EH_PE_sdata2:
       offset = ReadTwoBytes(buffer);
       // Sign-extend from 16 bits.
       offset = (offset ^ 0x8000) - 0x8000;
       *len = 2;
       break;
     case DW_EH_PE_sdata4:
       offset = ReadFourBytes(buffer);
       // Sign-extend from 32 bits.
       offset = (offset ^ 0x80000000ULL) - 0x80000000ULL;
       *len = 4;
       break;
     case DW_EH_PE_sdata8:
       // No need to sign-extend; this is the full width of our type.
       offset = ReadEightBytes(buffer);
       *len = 8;
       break;
     default:
       abort();
   }
   // Find the appropriate base address.
   uint64 base;
   switch (encoding & 0x70) {
     case DW_EH_PE_absptr:
       base = 0;
       break;
     case DW_EH_PE_pcrel:
       assert(have_section_base_);
       base = section_base_ + (buffer - buffer_base_);
       break;
     case DW_EH_PE_textrel:
       assert(have_text_base_);
       base = text_base_;
       break;
     case DW_EH_PE_datarel:
       assert(have_data_base_);
       base = data_base_;
       break;
     case DW_EH_PE_funcrel:
       assert(have_function_base_);
       base = function_base_;
       break;
     default:
       abort();
   }
   uint64 pointer = base + offset;
   // Remove inappropriate upper bits.
   if (AddressSize() == 4)
     pointer = pointer & 0xffffffff;
   else
     assert(AddressSize() == sizeof(uint64));
   return pointer;
 }
 }  // namespace dwarf2reader

The Tor Browser / annotate

toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader.cc