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

source code of lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp