LCOV - app.info - toolkit/crashreporter/google-breakpad/src/common/dwarf/bytereader-inl.h

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-04-07 | 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