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