1 //===-- DataExtractorTest.cpp ---------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "gtest/gtest.h" 10 11 #include "lldb/Utility/DataExtractor.h" 12 13 using namespace lldb_private; 14 15 TEST(DataExtractorTest, GetBitfield) { 16 uint8_t buffer[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; 17 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 18 sizeof(void *)); 19 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 20 21 lldb::offset_t offset; 22 23 offset = 0; 24 ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8)); 25 offset = 0; 26 ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8)); 27 offset = 0; 28 ASSERT_EQ(static_cast<uint64_t>(0xEFCDAB8967452301), 29 LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0)); 30 offset = 0; 31 ASSERT_EQ(static_cast<uint64_t>(0x0123456789ABCDEF), 32 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0)); 33 offset = 0; 34 ASSERT_EQ(static_cast<uint64_t>(0x01234567), 35 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 32, 0)); 36 offset = 0; 37 ASSERT_EQ(static_cast<uint64_t>(0x012345678), 38 BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 36, 0)); 39 40 offset = 0; 41 ASSERT_EQ(int8_t(buffer[1]), 42 LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8)); 43 offset = 0; 44 ASSERT_EQ(int8_t(buffer[1]), 45 BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8)); 46 offset = 0; 47 ASSERT_EQ(static_cast<int64_t>(0xEFCDAB8967452301), 48 LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0)); 49 offset = 0; 50 ASSERT_EQ(static_cast<int64_t>(0x0123456789ABCDEF), 51 BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0)); 52 } 53 54 TEST(DataExtractorTest, PeekData) { 55 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04}; 56 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 57 58 EXPECT_EQ(buffer + 0, E.PeekData(0, 0)); 59 EXPECT_EQ(buffer + 0, E.PeekData(0, 4)); 60 EXPECT_EQ(nullptr, E.PeekData(0, 5)); 61 62 EXPECT_EQ(buffer + 2, E.PeekData(2, 0)); 63 EXPECT_EQ(buffer + 2, E.PeekData(2, 2)); 64 EXPECT_EQ(nullptr, E.PeekData(2, 3)); 65 66 EXPECT_EQ(buffer + 4, E.PeekData(4, 0)); 67 EXPECT_EQ(nullptr, E.PeekData(4, 1)); 68 } 69 70 TEST(DataExtractorTest, GetCStr) { 71 uint8_t buffer[] = {'X', 'f', 'o', 'o', '\0'}; 72 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 73 74 lldb::offset_t offset = 1; 75 EXPECT_STREQ("foo", E.GetCStr(&offset)); 76 EXPECT_EQ(5U, offset); 77 } 78 79 TEST(DataExtractorTest, GetCStrEmpty) { 80 uint8_t buffer[] = {'X', '\0'}; 81 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 82 83 lldb::offset_t offset = 1; 84 EXPECT_STREQ("", E.GetCStr(&offset)); 85 EXPECT_EQ(2U, offset); 86 } 87 88 TEST(DataExtractorTest, GetCStrUnterminated) { 89 uint8_t buffer[] = {'X', 'f', 'o', 'o'}; 90 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 91 92 lldb::offset_t offset = 1; 93 EXPECT_EQ(nullptr, E.GetCStr(&offset)); 94 EXPECT_EQ(1U, offset); 95 } 96 97 TEST(DataExtractorTest, GetCStrAtEnd) { 98 uint8_t buffer[] = {'X'}; 99 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 100 101 lldb::offset_t offset = 1; 102 EXPECT_EQ(nullptr, E.GetCStr(&offset)); 103 EXPECT_EQ(1U, offset); 104 } 105 106 TEST(DataExtractorTest, GetCStrAtNullOffset) { 107 uint8_t buffer[] = {'f', 'o', 'o', '\0'}; 108 DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4); 109 110 lldb::offset_t offset = 0; 111 EXPECT_STREQ("foo", E.GetCStr(&offset)); 112 EXPECT_EQ(4U, offset); 113 } 114 115 TEST(DataExtractorTest, UncommonAddressSize) { 116 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 117 DataExtractor E2(buffer, sizeof buffer, lldb::eByteOrderLittle, 2); 118 DataExtractor E5(buffer, sizeof buffer, lldb::eByteOrderLittle, 5); 119 DataExtractor E7(buffer, sizeof buffer, lldb::eByteOrderLittle, 7); 120 121 lldb::offset_t offset; 122 123 // Test 2-byte addresses (for AVR). 124 offset = 0; 125 EXPECT_EQ(0x0201U, E2.GetMaxU64(&offset, 2)); 126 EXPECT_EQ(2U, offset); 127 offset = 0; 128 EXPECT_EQ(0x0201U, E2.GetAddress(&offset)); 129 EXPECT_EQ(2U, offset); 130 131 // Test 5-byte addresses. 132 offset = 0; 133 EXPECT_EQ(0x030201U, E5.GetMaxU64(&offset, 3)); 134 EXPECT_EQ(3U, offset); 135 offset = 3; 136 EXPECT_EQ(0x0807060504U, E5.GetAddress(&offset)); 137 EXPECT_EQ(8U, offset); 138 139 // Test 7-byte addresses. 140 offset = 0; 141 EXPECT_EQ(0x0504030201U, E7.GetMaxU64(&offset, 5)); 142 EXPECT_EQ(5U, offset); 143 offset = 0; 144 EXPECT_EQ(0x07060504030201U, E7.GetAddress(&offset)); 145 EXPECT_EQ(7U, offset); 146 } 147 148 TEST(DataExtractorTest, GetMaxU64) { 149 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 150 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 151 sizeof(void *)); 152 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 153 154 lldb::offset_t offset; 155 156 // Check with the minimum allowed byte size. 157 offset = 0; 158 EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1)); 159 EXPECT_EQ(1U, offset); 160 offset = 0; 161 EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1)); 162 EXPECT_EQ(1U, offset); 163 164 // Check with a non-zero offset. 165 offset = 1; 166 EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2)); 167 EXPECT_EQ(3U, offset); 168 offset = 1; 169 EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2)); 170 EXPECT_EQ(3U, offset); 171 172 // Check with the byte size not being a multiple of 2. 173 offset = 0; 174 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7)); 175 EXPECT_EQ(7U, offset); 176 offset = 0; 177 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7)); 178 EXPECT_EQ(7U, offset); 179 180 // Check with the maximum allowed byte size. 181 offset = 0; 182 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8)); 183 EXPECT_EQ(8U, offset); 184 offset = 0; 185 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8)); 186 EXPECT_EQ(8U, offset); 187 } 188 189 TEST(DataExtractorTest, GetMaxS64) { 190 uint8_t buffer[] = {0x01, 0x02, 0x83, 0x04, 0x05, 0x06, 0x07, 0x08}; 191 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 192 sizeof(void *)); 193 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 194 195 lldb::offset_t offset; 196 197 // Check with the minimum allowed byte size. 198 offset = 0; 199 EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1)); 200 EXPECT_EQ(1U, offset); 201 offset = 0; 202 EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1)); 203 EXPECT_EQ(1U, offset); 204 205 // Check that sign extension works correctly. 206 offset = 0; 207 int64_t value = LE.GetMaxS64(&offset, 3); 208 EXPECT_EQ(0xffffffffff830201U, *reinterpret_cast<uint64_t *>(&value)); 209 EXPECT_EQ(3U, offset); 210 offset = 2; 211 value = BE.GetMaxS64(&offset, 3); 212 EXPECT_EQ(0xffffffffff830405U, *reinterpret_cast<uint64_t *>(&value)); 213 EXPECT_EQ(5U, offset); 214 215 // Check with the maximum allowed byte size. 216 offset = 0; 217 EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8)); 218 EXPECT_EQ(8U, offset); 219 offset = 0; 220 EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8)); 221 EXPECT_EQ(8U, offset); 222 } 223 224 TEST(DataExtractorTest, GetMaxU64_unchecked) { 225 uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 226 DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle, 227 sizeof(void *)); 228 DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *)); 229 230 lldb::offset_t offset; 231 232 // Check with the minimum allowed byte size. 233 offset = 0; 234 EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1)); 235 EXPECT_EQ(1U, offset); 236 offset = 0; 237 EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1)); 238 EXPECT_EQ(1U, offset); 239 240 // Check with a non-zero offset. 241 offset = 1; 242 EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2)); 243 EXPECT_EQ(3U, offset); 244 offset = 1; 245 EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2)); 246 EXPECT_EQ(3U, offset); 247 248 // Check with the byte size not being a multiple of 2. 249 offset = 0; 250 EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7)); 251 EXPECT_EQ(7U, offset); 252 offset = 0; 253 EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7)); 254 EXPECT_EQ(7U, offset); 255 256 // Check with the maximum allowed byte size. 257 offset = 0; 258 EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8)); 259 EXPECT_EQ(8U, offset); 260 offset = 0; 261 EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8)); 262 EXPECT_EQ(8U, offset); 263 } 264