lldb/unittests/Utility/DataExtractorTest.cpp

   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
 265 TEST(DataExtractorTest, GetSLEB128_bit63) {
 266   uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};
 267
 268   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 269                    sizeof(void *));
 270   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
 271
 272   lldb::offset_t offset;
 273
 274   int64_t expected =
 275       0b1111111100000001111111000000011111110000000111111100000001111111;
 276   offset = 0;
 277   EXPECT_EQ(expected, LE.GetSLEB128(&offset));
 278   EXPECT_EQ(9U, offset);
 279   offset = 0;
 280   EXPECT_EQ(expected, BE.GetSLEB128(&offset));
 281   EXPECT_EQ(9U, offset);
 282 }
 283
 284 TEST(DataExtractorTest, GetULEB128_bit63) {
 285   uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};
 286
 287   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 288                    sizeof(void *));
 289   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));
 290
 291   lldb::offset_t offset;
 292
 293   uint64_t expected =
 294       0b0111111100000001111111000000011111110000000111111100000001111111;
 295   offset = 0;
 296   EXPECT_EQ(expected, LE.GetULEB128(&offset));
 297   EXPECT_EQ(9U, offset);
 298   offset = 0;
 299   EXPECT_EQ(expected, BE.GetULEB128(&offset));
 300   EXPECT_EQ(9U, offset);
 301 }
 302
 303 TEST(DataExtractorTest, GetFloat) {
 304   float expected = 4.0f;
 305   lldb::offset_t offset;
 306
 307   {
 308     uint8_t buffer[] = {0x00, 0x00, 0x80, 0x40};
 309     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 310                      sizeof(void *));
 311
 312     offset = 0;
 313     EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
 314     EXPECT_EQ(4U, offset);
 315   }
 316
 317   {
 318     uint8_t buffer[] = {0x40, 0x80, 0x00, 0x00};
 319     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
 320                      sizeof(void *));
 321     offset = 0;
 322     EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
 323     EXPECT_EQ(4U, offset);
 324   }
 325 }
 326
 327 TEST(DataExtractorTest, GetFloatUnaligned) {
 328   float expected = 4.0f;
 329   lldb::offset_t offset;
 330
 331   {
 332     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x80, 0x40};
 333     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 334                      sizeof(void *));
 335
 336     offset = 1;
 337     EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
 338     EXPECT_EQ(5U, offset);
 339   }
 340
 341   {
 342     uint8_t buffer[] = {0x00, 0x40, 0x80, 0x00, 0x00};
 343     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
 344                      sizeof(void *));
 345     offset = 1;
 346     EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
 347     EXPECT_EQ(5U, offset);
 348   }
 349 }
 350
 351 TEST(DataExtractorTest, GetDouble) {
 352   if (sizeof(double) != 8)
 353     return;
 354
 355   double expected = 4.0f;
 356   lldb::offset_t offset;
 357
 358   {
 359     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
 360     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 361                      sizeof(void *));
 362
 363     offset = 0;
 364     EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
 365     EXPECT_EQ(8U, offset);
 366   }
 367
 368   {
 369     uint8_t buffer[] = {0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 370     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
 371                      sizeof(void *));
 372     offset = 0;
 373     EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
 374     EXPECT_EQ(8U, offset);
 375   }
 376 }
 377
 378 TEST(DataExtractorTest, GetDoubleUnaligned) {
 379   if (sizeof(double) != 8)
 380     return;
 381
 382   float expected = 4.0f;
 383   lldb::offset_t offset;
 384
 385   {
 386     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
 387     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
 388                      sizeof(void *));
 389
 390     offset = 1;
 391     EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
 392     EXPECT_EQ(9U, offset);
 393   }
 394
 395   {
 396     uint8_t buffer[] = {0x00, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 397     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
 398                      sizeof(void *));
 399     offset = 1;
 400     EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
 401     EXPECT_EQ(9U, offset);
 402   }
 403 }