LCOV - code coverage report
Current view: directory - toolkit/crashreporter/google-breakpad/src/common/dwarf - bytereader-inl.h (source / functions) Found Hit Coverage
Test: app.info Lines: 13 13 100.0 %
Date: 2012-06-02 Functions: 3 3 100.0 %

       1                 : // Copyright 2006 Google Inc. All Rights Reserved.
       2                 : //
       3                 : // Redistribution and use in source and binary forms, with or without
       4                 : // modification, are permitted provided that the following conditions are
       5                 : // met:
       6                 : //
       7                 : //     * Redistributions of source code must retain the above copyright
       8                 : // notice, this list of conditions and the following disclaimer.
       9                 : //     * Redistributions in binary form must reproduce the above
      10                 : // copyright notice, this list of conditions and the following disclaimer
      11                 : // in the documentation and/or other materials provided with the
      12                 : // distribution.
      13                 : //     * Neither the name of Google Inc. nor the names of its
      14                 : // contributors may be used to endorse or promote products derived from
      15                 : // this software without specific prior written permission.
      16                 : //
      17                 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      18                 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      19                 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      20                 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      21                 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      22                 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      23                 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      24                 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      25                 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      26                 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      27                 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      28                 : 
      29                 : #ifndef UTIL_DEBUGINFO_BYTEREADER_INL_H__
      30                 : #define UTIL_DEBUGINFO_BYTEREADER_INL_H__
      31                 : 
      32                 : #include "common/dwarf/bytereader.h"
      33                 : 
      34                 : #include <assert.h>
      35                 : 
      36                 : namespace dwarf2reader {
      37                 : 
      38                 : inline uint8 ByteReader::ReadOneByte(const char* buffer) const {
      39                 :   return buffer[0];
      40                 : }
      41                 : 
      42                 : inline uint16 ByteReader::ReadTwoBytes(const char* signed_buffer) const {
      43                 :   const unsigned char *buffer
      44                 :     = reinterpret_cast<const unsigned char *>(signed_buffer);
      45                 :   const uint16 buffer0 = buffer[0];
      46                 :   const uint16 buffer1 = buffer[1];
      47                 :   if (endian_ == ENDIANNESS_LITTLE) {
      48                 :     return buffer0 | buffer1 << 8;
      49                 :   } else {
      50                 :     return buffer1 | buffer0 << 8;
      51                 :   }
      52                 : }
      53                 : 
      54                 : inline uint64 ByteReader::ReadFourBytes(const char* signed_buffer) const {
      55                 :   const unsigned char *buffer
      56                 :     = reinterpret_cast<const unsigned char *>(signed_buffer);
      57                 :   const uint32 buffer0 = buffer[0];
      58                 :   const uint32 buffer1 = buffer[1];
      59                 :   const uint32 buffer2 = buffer[2];
      60                 :   const uint32 buffer3 = buffer[3];
      61                 :   if (endian_ == ENDIANNESS_LITTLE) {
      62                 :     return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24;
      63                 :   } else {
      64                 :     return buffer3 | buffer2 << 8 | buffer1 << 16 | buffer0 << 24;
      65                 :   }
      66                 : }
      67                 : 
      68                 : inline uint64 ByteReader::ReadEightBytes(const char* signed_buffer) const {
      69                 :   const unsigned char *buffer
      70                 :     = reinterpret_cast<const unsigned char *>(signed_buffer);
      71                 :   const uint64 buffer0 = buffer[0];
      72                 :   const uint64 buffer1 = buffer[1];
      73                 :   const uint64 buffer2 = buffer[2];
      74                 :   const uint64 buffer3 = buffer[3];
      75                 :   const uint64 buffer4 = buffer[4];
      76                 :   const uint64 buffer5 = buffer[5];
      77                 :   const uint64 buffer6 = buffer[6];
      78                 :   const uint64 buffer7 = buffer[7];
      79                 :   if (endian_ == ENDIANNESS_LITTLE) {
      80                 :     return buffer0 | buffer1 << 8 | buffer2 << 16 | buffer3 << 24 |
      81                 :       buffer4 << 32 | buffer5 << 40 | buffer6 << 48 | buffer7 << 56;
      82                 :   } else {
      83                 :     return buffer7 | buffer6 << 8 | buffer5 << 16 | buffer4 << 24 |
      84                 :       buffer3 << 32 | buffer2 << 40 | buffer1 << 48 | buffer0 << 56;
      85                 :   }
      86                 : }
      87                 : 
      88                 : // Read an unsigned LEB128 number.  Each byte contains 7 bits of
      89                 : // information, plus one bit saying whether the number continues or
      90                 : // not.
      91                 : 
      92                 : inline uint64 ByteReader::ReadUnsignedLEB128(const char* buffer,
      93                 :                                              size_t* len) const {
      94                 :   uint64 result = 0;
      95                 :   size_t num_read = 0;
      96                 :   unsigned int shift = 0;
      97                 :   unsigned char byte;
      98                 : 
      99                 :   do {
     100                 :     byte = *buffer++;
     101                 :     num_read++;
     102                 : 
     103                 :     result |= (static_cast<uint64>(byte & 0x7f)) << shift;
     104                 : 
     105                 :     shift += 7;
     106                 : 
     107                 :   } while (byte & 0x80);
     108                 : 
     109                 :   *len = num_read;
     110                 : 
     111                 :   return result;
     112                 : }
     113                 : 
     114                 : // Read a signed LEB128 number.  These are like regular LEB128
     115                 : // numbers, except the last byte may have a sign bit set.
     116                 : 
     117                 : inline int64 ByteReader::ReadSignedLEB128(const char* buffer,
     118                 :                                           size_t* len) const {
     119                 :   int64 result = 0;
     120                 :   unsigned int shift = 0;
     121                 :   size_t num_read = 0;
     122                 :   unsigned char byte;
     123                 : 
     124                 :   do {
     125                 :       byte = *buffer++;
     126                 :       num_read++;
     127                 :       result |= (static_cast<uint64>(byte & 0x7f) << shift);
     128                 :       shift += 7;
     129                 :   } while (byte & 0x80);
     130                 : 
     131                 :   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
     132                 :     result |= -((static_cast<int64>(1)) << shift);
     133                 :   *len = num_read;
     134                 :   return result;
     135                 : }
     136                 : 
     137                 : inline uint64 ByteReader::ReadOffset(const char* buffer) const {
     138                 :   assert(this->offset_reader_);
     139                 :   return (this->*offset_reader_)(buffer);
     140                 : }
     141                 : 
     142                 : inline uint64 ByteReader::ReadAddress(const char* buffer) const {
     143                 :   assert(this->address_reader_);
     144                 :   return (this->*address_reader_)(buffer);
     145                 : }
     146                 : 
     147             248 : inline void ByteReader::SetCFIDataBase(uint64 section_base,
     148                 :                                        const char *buffer_base) {
     149             248 :   section_base_ = section_base;
     150             248 :   buffer_base_ = buffer_base;
     151             248 :   have_section_base_ = true;
     152             248 : }
     153                 : 
     154             124 : inline void ByteReader::SetTextBase(uint64 text_base) {
     155             124 :   text_base_ = text_base;
     156             124 :   have_text_base_ = true;
     157             124 : }
     158                 : 
     159             124 : inline void ByteReader::SetDataBase(uint64 data_base) {
     160             124 :   data_base_ = data_base;
     161             124 :   have_data_base_ = true;
     162             124 : }
     163                 : 
     164                 : inline void ByteReader::SetFunctionBase(uint64 function_base) {
     165                 :   function_base_ = function_base;
     166                 :   have_function_base_ = true;
     167                 : }
     168                 : 
     169                 : inline void ByteReader::ClearFunctionBase() {
     170                 :   have_function_base_ = false;
     171                 : }
     172                 : 
     173                 : }  // namespace dwarf2reader
     174                 : 
     175                 : #endif  // UTIL_DEBUGINFO_BYTEREADER_INL_H__

Generated by: LCOV version 1.7