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