1 //===-- MemoryTagManagerAArch64MTETest.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 "Plugins/Process/Utility/MemoryTagManagerAArch64MTE.h" 10 #include "llvm/Testing/Support/Error.h" 11 #include "gtest/gtest.h" 12 13 using namespace lldb_private; 14 15 TEST(MemoryTagManagerAArch64MTETest, UnpackTagsData) { 16 MemoryTagManagerAArch64MTE manager; 17 18 // Error for insufficient tag data 19 std::vector<uint8_t> input; 20 ASSERT_THAT_EXPECTED( 21 manager.UnpackTagsData(input, 2), 22 llvm::FailedWithMessage( 23 "Packed tag data size does not match expected number of tags. " 24 "Expected 2 tag(s) for 2 granule(s), got 0 tag(s).")); 25 26 // This is out of the valid tag range 27 input.push_back(0x1f); 28 ASSERT_THAT_EXPECTED( 29 manager.UnpackTagsData(input, 1), 30 llvm::FailedWithMessage( 31 "Found tag 0x1f which is > max MTE tag value of 0xf.")); 32 33 // MTE tags are 1 per byte 34 input.pop_back(); 35 input.push_back(0xe); 36 input.push_back(0xf); 37 38 std::vector<lldb::addr_t> expected{0xe, 0xf}; 39 40 llvm::Expected<std::vector<lldb::addr_t>> got = 41 manager.UnpackTagsData(input, 2); 42 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 43 ASSERT_THAT(expected, testing::ContainerEq(*got)); 44 45 // Error for too much tag data 46 ASSERT_THAT_EXPECTED( 47 manager.UnpackTagsData(input, 1), 48 llvm::FailedWithMessage( 49 "Packed tag data size does not match expected number of tags. " 50 "Expected 1 tag(s) for 1 granule(s), got 2 tag(s).")); 51 52 // By default, we don't check number of tags 53 llvm::Expected<std::vector<lldb::addr_t>> got_zero = 54 manager.UnpackTagsData(input); 55 ASSERT_THAT_EXPECTED(got_zero, llvm::Succeeded()); 56 ASSERT_THAT(expected, testing::ContainerEq(*got)); 57 58 // Which is the same as granules=0 59 got_zero = manager.UnpackTagsData(input, 0); 60 ASSERT_THAT_EXPECTED(got_zero, llvm::Succeeded()); 61 ASSERT_THAT(expected, testing::ContainerEq(*got)); 62 } 63 64 TEST(MemoryTagManagerAArch64MTETest, PackTags) { 65 MemoryTagManagerAArch64MTE manager; 66 67 // Error for tag out of range 68 llvm::Expected<std::vector<uint8_t>> invalid_tag_err = 69 manager.PackTags({0x10}); 70 ASSERT_THAT_EXPECTED( 71 invalid_tag_err, 72 llvm::FailedWithMessage( 73 "Found tag 0x10 which is > max MTE tag value of 0xf.")); 74 75 // 0xf here is the max tag value that we can pack 76 std::vector<lldb::addr_t> tags{0, 1, 0xf}; 77 std::vector<uint8_t> expected{0, 1, 0xf}; 78 llvm::Expected<std::vector<uint8_t>> packed = manager.PackTags(tags); 79 ASSERT_THAT_EXPECTED(packed, llvm::Succeeded()); 80 ASSERT_THAT(expected, testing::ContainerEq(*packed)); 81 } 82 83 TEST(MemoryTagManagerAArch64MTETest, UnpackTagsFromCoreFileSegment) { 84 MemoryTagManagerAArch64MTE manager; 85 // This is our fake segment data where tags are compressed as 2 4 bit tags 86 // per byte. 87 std::vector<uint8_t> tags_data; 88 MemoryTagManager::CoreReaderFn reader = 89 [&tags_data](lldb::offset_t offset, size_t length, void *dst) { 90 std::memcpy(dst, tags_data.data() + offset, length); 91 return length; 92 }; 93 94 // Zero length is ok. 95 std::vector<lldb::addr_t> tags = 96 manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 0, 0); 97 ASSERT_EQ(tags.size(), (size_t)0); 98 99 // In the simplest case we read 2 tags which are in the same byte. 100 tags_data.push_back(0x21); 101 // The least significant bits are the first tag in memory. 102 std::vector<lldb::addr_t> expected{1, 2}; 103 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 0, 32); 104 ASSERT_THAT(expected, testing::ContainerEq(tags)); 105 106 // If we read just one then it will have to trim off the second one. 107 expected = std::vector<lldb::addr_t>{1}; 108 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 0, 16); 109 ASSERT_THAT(expected, testing::ContainerEq(tags)); 110 111 // If we read the second tag only then the first one must be trimmed. 112 expected = std::vector<lldb::addr_t>{2}; 113 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 16, 16); 114 ASSERT_THAT(expected, testing::ContainerEq(tags)); 115 116 // This trimming logic applies if you read a larger set of tags. 117 tags_data = std::vector<uint8_t>{0x21, 0x43, 0x65, 0x87}; 118 119 // Trailing tag should be trimmed. 120 expected = std::vector<lldb::addr_t>{1, 2, 3}; 121 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 0, 48); 122 ASSERT_THAT(expected, testing::ContainerEq(tags)); 123 124 // Leading tag should be trimmed. 125 expected = std::vector<lldb::addr_t>{2, 3, 4}; 126 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 16, 48); 127 ASSERT_THAT(expected, testing::ContainerEq(tags)); 128 129 // Leading and trailing trimmmed. 130 expected = std::vector<lldb::addr_t>{2, 3, 4, 5}; 131 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 0, 16, 64); 132 ASSERT_THAT(expected, testing::ContainerEq(tags)); 133 134 // The address given is an offset into the whole file so the address requested 135 // from the reader should be beyond that. 136 tags_data = std::vector<uint8_t>{0xFF, 0xFF, 0x21, 0x43, 0x65, 0x87}; 137 expected = std::vector<lldb::addr_t>{1, 2}; 138 tags = manager.UnpackTagsFromCoreFileSegment(reader, 0, 2, 0, 32); 139 ASSERT_THAT(expected, testing::ContainerEq(tags)); 140 141 // addr is a virtual address that we expect to be >= the tag segment's 142 // starting virtual address. So again an offset must be made from the 143 // difference. 144 expected = std::vector<lldb::addr_t>{3, 4}; 145 tags = manager.UnpackTagsFromCoreFileSegment(reader, 32, 2, 64, 32); 146 ASSERT_THAT(expected, testing::ContainerEq(tags)); 147 } 148 149 TEST(MemoryTagManagerAArch64MTETest, GetLogicalTag) { 150 MemoryTagManagerAArch64MTE manager; 151 152 // Set surrounding bits to check shift is correct 153 ASSERT_EQ((lldb::addr_t)0, manager.GetLogicalTag(0xe0e00000ffffffff)); 154 // Max tag value 155 ASSERT_EQ((lldb::addr_t)0xf, manager.GetLogicalTag(0x0f000000ffffffff)); 156 ASSERT_EQ((lldb::addr_t)2, manager.GetLogicalTag(0x02000000ffffffff)); 157 } 158 159 TEST(MemoryTagManagerAArch64MTETest, ExpandToGranule) { 160 MemoryTagManagerAArch64MTE manager; 161 // Reading nothing, no alignment needed 162 ASSERT_EQ( 163 MemoryTagManagerAArch64MTE::TagRange(0, 0), 164 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(0, 0))); 165 166 // Ranges with 0 size are unchanged even if address is non 0 167 // (normally 0x1234 would be aligned to 0x1230) 168 ASSERT_EQ( 169 MemoryTagManagerAArch64MTE::TagRange(0x1234, 0), 170 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(0x1234, 0))); 171 172 // Ranges already aligned don't change 173 ASSERT_EQ( 174 MemoryTagManagerAArch64MTE::TagRange(0x100, 64), 175 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(0x100, 64))); 176 177 // Any read of less than 1 granule is rounded up to reading 1 granule 178 ASSERT_EQ( 179 MemoryTagManagerAArch64MTE::TagRange(0, 16), 180 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(0, 1))); 181 182 // Start address is aligned down, and length modified accordingly 183 // Here bytes 8 through 24 straddle 2 granules. So the resulting range starts 184 // at 0 and covers 32 bytes. 185 ASSERT_EQ( 186 MemoryTagManagerAArch64MTE::TagRange(0, 32), 187 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(8, 16))); 188 189 // Here only the size of the range needs aligning 190 ASSERT_EQ( 191 MemoryTagManagerAArch64MTE::TagRange(16, 32), 192 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(16, 24))); 193 194 // Start and size need aligning here but we only need 1 granule to cover it 195 ASSERT_EQ( 196 MemoryTagManagerAArch64MTE::TagRange(16, 16), 197 manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(18, 4))); 198 } 199 200 static MemoryRegionInfo MakeRegionInfo(lldb::addr_t base, lldb::addr_t size, 201 bool tagged) { 202 return MemoryRegionInfo( 203 MemoryRegionInfo::RangeType(base, size), MemoryRegionInfo::eYes, 204 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo, 205 MemoryRegionInfo::eYes, ConstString(), MemoryRegionInfo::eNo, 0, 206 /*memory_tagged=*/ 207 tagged ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo, 208 MemoryRegionInfo::eDontKnow, MemoryRegionInfo::eDontKnow); 209 } 210 211 TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) { 212 MemoryTagManagerAArch64MTE manager; 213 MemoryRegionInfos memory_regions; 214 215 // No regions means no tagged regions, error 216 ASSERT_THAT_EXPECTED( 217 manager.MakeTaggedRange(0, 0x10, memory_regions), 218 llvm::FailedWithMessage( 219 "Address range 0x0:0x10 is not in a memory tagged region")); 220 221 // Alignment is done before checking regions. 222 // Here 1 is rounded up to the granule size of 0x10. 223 ASSERT_THAT_EXPECTED( 224 manager.MakeTaggedRange(0, 1, memory_regions), 225 llvm::FailedWithMessage( 226 "Address range 0x0:0x10 is not in a memory tagged region")); 227 228 // Range must not be inverted 229 ASSERT_THAT_EXPECTED( 230 manager.MakeTaggedRange(1, 0, memory_regions), 231 llvm::FailedWithMessage( 232 "End address (0x0) must be greater than the start address (0x1)")); 233 234 // The inversion check ignores tags in the addresses (MTE tags start at bit 235 // 56). 236 ASSERT_THAT_EXPECTED( 237 manager.MakeTaggedRange((lldb::addr_t)1 << 56, 238 ((lldb::addr_t)2 << 56) + 0x10, memory_regions), 239 llvm::FailedWithMessage( 240 "Address range 0x0:0x10 is not in a memory tagged region")); 241 242 // Adding a single region to cover the whole range 243 memory_regions.push_back(MakeRegionInfo(0, 0x1000, true)); 244 245 // Range can have different tags for begin and end 246 // (which would make it look inverted if we didn't remove them) 247 // Note that range comes back with an untagged base and alginment 248 // applied. 249 MemoryTagManagerAArch64MTE::TagRange expected_range(0x0, 0x10); 250 llvm::Expected<MemoryTagManagerAArch64MTE::TagRange> got = 251 manager.MakeTaggedRange(0x0f00000000000000, 0x0e00000000000001, 252 memory_regions); 253 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 254 ASSERT_EQ(*got, expected_range); 255 256 // Error if the range isn't within any region 257 ASSERT_THAT_EXPECTED( 258 manager.MakeTaggedRange(0x1000, 0x1010, memory_regions), 259 llvm::FailedWithMessage( 260 "Address range 0x1000:0x1010 is not in a memory tagged region")); 261 262 // Error if the first part of a range isn't tagged 263 memory_regions.clear(); 264 const char *err_msg = 265 "Address range 0x0:0x1000 is not in a memory tagged region"; 266 267 // First because it has no region entry 268 memory_regions.push_back(MakeRegionInfo(0x10, 0x1000, true)); 269 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 270 llvm::FailedWithMessage(err_msg)); 271 272 // Then because the first region is untagged 273 memory_regions.push_back(MakeRegionInfo(0, 0x10, false)); 274 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 275 llvm::FailedWithMessage(err_msg)); 276 277 // If we tag that first part it succeeds 278 memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes); 279 expected_range = MemoryTagManagerAArch64MTE::TagRange(0x0, 0x1000); 280 got = manager.MakeTaggedRange(0, 0x1000, memory_regions); 281 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 282 ASSERT_EQ(*got, expected_range); 283 284 // Error if the end of a range is untagged 285 memory_regions.clear(); 286 287 // First because it has no region entry 288 memory_regions.push_back(MakeRegionInfo(0, 0xF00, true)); 289 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 290 llvm::FailedWithMessage(err_msg)); 291 292 // Then because the last region is untagged 293 memory_regions.push_back(MakeRegionInfo(0xF00, 0x100, false)); 294 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 295 llvm::FailedWithMessage(err_msg)); 296 297 // If we tag the last part it succeeds 298 memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes); 299 got = manager.MakeTaggedRange(0, 0x1000, memory_regions); 300 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 301 ASSERT_EQ(*got, expected_range); 302 303 // Error if the middle of a range is untagged 304 memory_regions.clear(); 305 306 // First because it has no entry 307 memory_regions.push_back(MakeRegionInfo(0, 0x500, true)); 308 memory_regions.push_back(MakeRegionInfo(0x900, 0x700, true)); 309 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 310 llvm::FailedWithMessage(err_msg)); 311 312 // Then because it's untagged 313 memory_regions.push_back(MakeRegionInfo(0x500, 0x400, false)); 314 ASSERT_THAT_EXPECTED(manager.MakeTaggedRange(0, 0x1000, memory_regions), 315 llvm::FailedWithMessage(err_msg)); 316 317 // If we tag the middle part it succeeds 318 memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes); 319 got = manager.MakeTaggedRange(0, 0x1000, memory_regions); 320 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 321 ASSERT_EQ(*got, expected_range); 322 } 323 324 TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRanges) { 325 MemoryTagManagerAArch64MTE manager; 326 MemoryRegionInfos memory_regions; 327 328 // Note that MakeTaggedRanges takes start/end address. 329 // Whereas TagRanges and regions take start address and size. 330 331 // Range must not be inverted 332 ASSERT_THAT_EXPECTED( 333 manager.MakeTaggedRanges(1, 0, memory_regions), 334 llvm::FailedWithMessage( 335 "End address (0x0) must be greater than the start address (0x1)")); 336 337 // We remove tags before doing the inversion check, so this is not an error. 338 // Also no regions means no tagged regions returned. 339 // (bit 56 is where MTE tags begin) 340 llvm::Expected<std::vector<MemoryTagManager::TagRange>> got = 341 manager.MakeTaggedRanges((lldb::addr_t)2 << 56, 342 ((lldb::addr_t)1 << 56) + 0x10, memory_regions); 343 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 344 ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{}); 345 346 // Cover whole range, untagged. No ranges returned. 347 memory_regions.push_back(MakeRegionInfo(0, 0x20, false)); 348 got = manager.MakeTaggedRanges(0, 0x20, memory_regions); 349 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 350 ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{}); 351 352 // Make the region tagged and it'll be the one range returned. 353 memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes); 354 got = manager.MakeTaggedRanges(0, 0x20, memory_regions); 355 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 356 ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{ 357 MemoryTagManager::TagRange(0, 0x20)}); 358 359 // This region will be trimmed if it's larger than the whole range. 360 memory_regions.clear(); 361 memory_regions.push_back(MakeRegionInfo(0, 0x40, true)); 362 got = manager.MakeTaggedRanges(0x10, 0x30, memory_regions); 363 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 364 ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{ 365 MemoryTagManager::TagRange(0x10, 0x20)}); 366 367 memory_regions.clear(); 368 369 // For the following tests we keep the input regions 370 // in ascending order as MakeTaggedRanges expects. 371 372 // Only start of range is tagged, only that is returned. 373 // Start the region just before the requested range to check 374 // we limit the result to the requested range. 375 memory_regions.push_back(MakeRegionInfo(0, 0x20, true)); 376 got = manager.MakeTaggedRanges(0x10, 0x100, memory_regions); 377 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 378 ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{ 379 MemoryTagManager::TagRange(0x10, 0x10)}); 380 381 // Add a tagged region at the end, now we get both 382 // and the middle is untagged. 383 // <tagged: [0x0, 0x20)> 384 // <...> 385 // <tagged: [0xE0, 0x120)> 386 // The range added here is deliberately over the end of the 387 // requested range to show that we trim the end. 388 memory_regions.push_back(MakeRegionInfo(0xE0, 0x40, true)); 389 got = manager.MakeTaggedRanges(0x10, 0x110, memory_regions); 390 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 391 392 std::vector<MemoryTagManager::TagRange> expected{ 393 MemoryTagManager::TagRange(0x10, 0x10), 394 MemoryTagManager::TagRange(0xE0, 0x30)}; 395 ASSERT_EQ(*got, expected); 396 397 // Now add a middle tagged region. 398 // <tagged: [0x0, 0x20)> 399 // <...> 400 // <tagged: [0x90, 0xB0)> 401 // <...> 402 // <tagged: [0xE0, 0x120)> 403 memory_regions.insert(std::next(memory_regions.begin()), 404 MakeRegionInfo(0x90, 0x20, true)); 405 406 // As the given regions are in ascending order, the resulting 407 // tagged ranges are also. So this new range goes in the middle. 408 expected.insert(std::next(expected.begin()), 409 MemoryTagManager::TagRange(0x90, 0x20)); 410 got = manager.MakeTaggedRanges(0x10, 0x110, memory_regions); 411 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 412 ASSERT_EQ(*got, expected); 413 414 // Then if we add untagged regions in between the tagged, 415 // the output should stay the same. 416 // <tagged: [0x0, 0x20)> 417 // <untagged: [0x20, 0x90)> 418 // <tagged: [0x90, 0xB0)> 419 // <untagged: [0xB0, 0xE0)> 420 // <tagged: [0xE0, 0x120)> 421 memory_regions.insert(std::next(memory_regions.begin()), 422 MakeRegionInfo(0x20, 0x70, false)); 423 memory_regions.insert(std::prev(memory_regions.end()), 424 MakeRegionInfo(0xB0, 0x30, false)); 425 got = manager.MakeTaggedRanges(0x10, 0x110, memory_regions); 426 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 427 ASSERT_EQ(*got, expected); 428 429 // Finally check that we handle only having the end of the range. 430 memory_regions.clear(); 431 expected.clear(); 432 433 memory_regions.push_back(MakeRegionInfo(0x100, 0x10, true)); 434 expected.push_back(MemoryTagManager::TagRange(0x100, 0x10)); 435 got = manager.MakeTaggedRanges(0x10, 0x110, memory_regions); 436 ASSERT_THAT_EXPECTED(got, llvm::Succeeded()); 437 ASSERT_EQ(*got, expected); 438 } 439 440 TEST(MemoryTagManagerAArch64MTETest, RemoveTagBits) { 441 MemoryTagManagerAArch64MTE manager; 442 443 ASSERT_EQ(0, 0); 444 // Removes the whole top byte 445 ASSERT_EQ((lldb::addr_t)0x00ffeedd11223344, 446 manager.RemoveTagBits(0x00ffeedd11223344)); 447 ASSERT_EQ((lldb::addr_t)0x0000000000000000, 448 manager.RemoveTagBits(0xff00000000000000)); 449 ASSERT_EQ((lldb::addr_t)0x0055555566666666, 450 manager.RemoveTagBits(0xee55555566666666)); 451 } 452 453 TEST(MemoryTagManagerAArch64MTETest, AddressDiff) { 454 MemoryTagManagerAArch64MTE manager; 455 456 ASSERT_EQ(0, manager.AddressDiff(0, 0)); 457 // Result is signed 458 ASSERT_EQ(10, manager.AddressDiff(10, 0)); 459 ASSERT_EQ(-10, manager.AddressDiff(0, 10)); 460 // Anything in the top byte is ignored 461 ASSERT_EQ(0, manager.AddressDiff(0x2211222233334444, 0x3311222233334444)); 462 ASSERT_EQ(-32, manager.AddressDiff(0x5511222233334400, 0x4411222233334420)); 463 ASSERT_EQ(65, manager.AddressDiff(0x9911222233334441, 0x6611222233334400)); 464 } 465 466 // Helper to check that repeating "tags" over "range" gives you 467 // "expected_tags". 468 static void 469 test_repeating_tags(const std::vector<lldb::addr_t> &tags, 470 MemoryTagManagerAArch64MTE::TagRange range, 471 const std::vector<lldb::addr_t> &expected_tags) { 472 MemoryTagManagerAArch64MTE manager; 473 llvm::Expected<std::vector<lldb::addr_t>> tags_or_err = 474 manager.RepeatTagsForRange(tags, range); 475 ASSERT_THAT_EXPECTED(tags_or_err, llvm::Succeeded()); 476 ASSERT_THAT(expected_tags, testing::ContainerEq(*tags_or_err)); 477 } 478 479 TEST(MemoryTagManagerAArch64MTETest, RepeatTagsForRange) { 480 MemoryTagManagerAArch64MTE manager; 481 482 // Must have some tags if your range is not empty 483 llvm::Expected<std::vector<lldb::addr_t>> no_tags_err = 484 manager.RepeatTagsForRange({}, 485 MemoryTagManagerAArch64MTE::TagRange{0, 16}); 486 ASSERT_THAT_EXPECTED( 487 no_tags_err, llvm::FailedWithMessage( 488 "Expected some tags to cover given range, got zero.")); 489 490 // If the range is empty, you get no tags back 491 test_repeating_tags({1, 2, 3}, MemoryTagManagerAArch64MTE::TagRange{0, 0}, 492 {}); 493 // And you don't need tags for an empty range 494 test_repeating_tags({}, MemoryTagManagerAArch64MTE::TagRange{0, 0}, {}); 495 496 // A single tag will just be multiplied as many times as needed 497 test_repeating_tags({5}, MemoryTagManagerAArch64MTE::TagRange{0, 16}, {5}); 498 test_repeating_tags({6}, MemoryTagManagerAArch64MTE::TagRange{0, 32}, {6, 6}); 499 500 // If you've got as many tags as granules, it's a roundtrip 501 test_repeating_tags({7, 8}, MemoryTagManagerAArch64MTE::TagRange{0, 32}, 502 {7, 8}); 503 504 // If you've got fewer tags than granules, they repeat. Exactly or partially 505 // as needed. 506 test_repeating_tags({7, 8}, MemoryTagManagerAArch64MTE::TagRange{0, 64}, 507 {7, 8, 7, 8}); 508 test_repeating_tags({7, 8}, MemoryTagManagerAArch64MTE::TagRange{0, 48}, 509 {7, 8, 7}); 510 511 // If you've got more tags than granules you get back only those needed 512 test_repeating_tags({1, 2, 3, 4}, MemoryTagManagerAArch64MTE::TagRange{0, 32}, 513 {1, 2}); 514 } 515