/thirdparty/breakpad/common/dwarf/bytereader-inl.h

  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
 36namespace dwarf2reader {
 37
 38inline uint8 ByteReader::ReadOneByte(const char* buffer) const {
 39  return buffer[0];
 40}
 41
 42inline 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
 54inline 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
 68inline 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
 92inline 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
117inline 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
137inline uint64 ByteReader::ReadOffset(const char* buffer) const {
138  assert(this->offset_reader_);
139  return (this->*offset_reader_)(buffer);
140}
141
142inline uint64 ByteReader::ReadAddress(const char* buffer) const {
143  assert(this->address_reader_);
144  return (this->*address_reader_)(buffer);
145}
146
147inline void ByteReader::SetCFIDataBase(uint64 section_base,
148                                       const char *buffer_base) {
149  section_base_ = section_base;
150  buffer_base_ = buffer_base;
151  have_section_base_ = true;
152}
153
154inline void ByteReader::SetTextBase(uint64 text_base) {
155  text_base_ = text_base;
156  have_text_base_ = true;
157}
158
159inline void ByteReader::SetDataBase(uint64 data_base) {
160  data_base_ = data_base;
161  have_data_base_ = true;
162}
163
164inline void ByteReader::SetFunctionBase(uint64 function_base) {
165  function_base_ = function_base;
166  have_function_base_ = true;
167}
168
169inline void ByteReader::ClearFunctionBase() {
170  have_function_base_ = false;
171}
172
173}  // namespace dwarf2reader
174
175#endif  // UTIL_DEBUGINFO_BYTEREADER_INL_H__