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__
176