1 /* 2 This file is part of drd, a thread error detector. 3 4 Copyright (C) 2006-2013 Bart Van Assche <bvanassche (at) acm.org>. 5 6 This program is free software; you can redistribute it and/or 7 modify it under the terms of the GNU General Public License as 8 published by the Free Software Foundation; either version 2 of the 9 License, or (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 19 02111-1307, USA. 20 21 The GNU General Public License is contained in the file COPYING. 22 */ 23 24 25 #ifndef __DRD_BITMAP_H 26 #define __DRD_BITMAP_H 27 28 29 #include "pub_drd_bitmap.h" 30 #include "pub_tool_basics.h" 31 #include "pub_tool_oset.h" 32 #include "pub_tool_libcbase.h" 33 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 34 #include "pub_tool_libcassert.h" 35 #endif 36 37 38 /* Bitmap representation. A bitmap is a data structure in which two bits are 39 * reserved per 32 bit address: one bit that indicates that the data at the 40 * specified address has been read, and one bit that indicates that the data 41 * has been written to. 42 */ 43 44 /* Client addresses are split into bitfields as follows: 45 * ------------------------------------------------------ 46 * | Address MSB | Address LSB | Ignored bits | 47 * ------------------------------------------------------ 48 * | Address MSB | UWord MSB | UWord LSB | Ignored bits | 49 * ------------------------------------------------------ 50 */ 51 52 53 54 /* Address MSB / LSB split. */ 55 56 57 /** Number of least significant address bits that are ignored. */ 58 #define ADDR_IGNORED_BITS 0 59 #define ADDR_IGNORED_MASK ((1U << ADDR_IGNORED_BITS) - 1U) 60 #define ADDR_GRANULARITY (1U << ADDR_IGNORED_BITS) 61 62 /** 63 * Round argument a up to a multiple of (1 << ADDR_GRANULARITY), and next 64 * shift it right ADDR_GRANULARITY bits. The expression below is optimized 65 * for the case where a is a constant. 66 */ 67 #define SCALED_SIZE(a) \ 68 (((((a) - 1U) | ADDR_IGNORED_MASK) + 1U) >> ADDR_IGNORED_BITS) 69 70 /** 71 * Number of bits assigned to the least significant component of an address. 72 */ 73 #define ADDR_LSB_BITS 12 74 75 /** 76 * Mask that has to be applied to an address of type Addr in order to 77 * compute the least significant part of an address split, after having 78 * shifted the address bits ADDR_GRANULARITY to the right. 79 */ 80 #define ADDR_LSB_MASK (((UWord)1 << ADDR_LSB_BITS) - 1U) 81 82 /** Compute least significant bits of an address of type Addr. */ 83 static __inline__ 84 UWord address_lsb(const Addr a) 85 { return (a >> ADDR_IGNORED_BITS) & ADDR_LSB_MASK; } 86 87 /** 88 * Compute the first address for which address_lsb() is equal to 89 * address_lsb(a). 90 */ 91 static __inline__ 92 Addr first_address_with_same_lsb(const Addr a) 93 { 94 return ((a | ADDR_IGNORED_MASK) ^ ADDR_IGNORED_MASK); 95 } 96 97 /** 98 * Compute the first address for which address_lsb() is greater than 99 * address_lsb(a). 100 */ 101 static __inline__ 102 Addr first_address_with_higher_lsb(const Addr a) 103 { 104 return ((a | ADDR_IGNORED_MASK) + 1U); 105 } 106 107 /** Compute most significant bits of an address of type Addr. */ 108 static __inline__ 109 UWord address_msb(const Addr a) 110 { return a >> (ADDR_LSB_BITS + ADDR_IGNORED_BITS); } 111 112 static __inline__ 113 Addr first_address_with_higher_msb(const Addr a) 114 { 115 return ((a | ((ADDR_LSB_MASK << ADDR_IGNORED_BITS) | ADDR_IGNORED_MASK)) 116 + 1U); 117 } 118 119 /** 120 * Convert LSB and MSB back into an address. 121 * 122 * @note It is assumed that sizeof(Addr) == sizeof(UWord). 123 */ 124 static __inline__ 125 Addr make_address(const UWord a1, const UWord a0) 126 { 127 return ((a1 << (ADDR_LSB_BITS + ADDR_IGNORED_BITS)) 128 | (a0 << ADDR_IGNORED_BITS)); 129 } 130 131 132 133 134 135 /** Number of bits that fit in a variable of type UWord. */ 136 #define BITS_PER_UWORD (8U * sizeof(UWord)) 137 138 /** Log2 of BITS_PER_UWORD. */ 139 #if defined(VGA_x86) || defined(VGA_ppc32) || defined(VGA_arm) \ 140 || defined(VGA_mips32) 141 #define BITS_PER_BITS_PER_UWORD 5 142 #elif defined(VGA_amd64) || defined(VGA_ppc64) || defined(VGA_s390x) \ 143 || defined(VGA_mips64) || defined(VGA_arm64) 144 #define BITS_PER_BITS_PER_UWORD 6 145 #else 146 #error Unknown platform. 147 #endif 148 149 /** Number of UWord's needed to store one bit per address LSB. */ 150 #define BITMAP1_UWORD_COUNT (1U << (ADDR_LSB_BITS - BITS_PER_BITS_PER_UWORD)) 151 152 /** 153 * Mask that has to be applied to an (Addr >> ADDR_IGNORED_BITS) expression 154 * in order to compute the least significant part of an UWord. 155 */ 156 #define UWORD_LSB_MASK (((UWord)1 << BITS_PER_BITS_PER_UWORD) - 1) 157 158 /** 159 * Compute index into bm0[] array. 160 * 161 * @param a Address shifted right ADDR_IGNORED_BITS bits. 162 */ 163 static __inline__ 164 UWord uword_msb(const UWord a) 165 { 166 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 167 tl_assert(a < (1U << ADDR_LSB_BITS)); 168 #endif 169 return a >> BITS_PER_BITS_PER_UWORD; 170 } 171 172 /** 173 * Return the least significant bits. 174 * 175 * @param a Address shifted right ADDR_IGNORED_BITS bits. 176 */ 177 static __inline__ 178 UWord uword_lsb(const UWord a) 179 { 180 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 181 tl_assert(a < (1U << ADDR_LSB_BITS)); 182 #endif 183 return a & UWORD_LSB_MASK; 184 } 185 186 /** 187 * Compute the highest address lower than a for which 188 * uword_lsb(address_lsb(a)) == 0. 189 * 190 * @param a Address. 191 */ 192 static __inline__ 193 Addr first_address_with_same_uword_lsb(const Addr a) 194 { 195 return (a & (~UWORD_LSB_MASK << ADDR_IGNORED_BITS)); 196 } 197 198 /** 199 * First address that will go in the UWord past the one 'a' goes in. 200 * 201 * @param a Address. 202 */ 203 static __inline__ 204 Addr first_address_with_higher_uword_msb(const Addr a) 205 { 206 return ((a | ((UWORD_LSB_MASK << ADDR_IGNORED_BITS) | ADDR_IGNORED_MASK)) 207 + 1); 208 } 209 210 211 212 /* Local variables. */ 213 214 static ULong s_bitmap2_creation_count; 215 216 217 218 /*********************************************************************/ 219 /* Functions for manipulating a struct bitmap1. */ 220 /*********************************************************************/ 221 222 223 /* Lowest level, corresponding to the lowest ADDR_LSB_BITS of an address. */ 224 struct bitmap1 225 { 226 UWord bm0_r[BITMAP1_UWORD_COUNT]; 227 UWord bm0_w[BITMAP1_UWORD_COUNT]; 228 }; 229 230 static __inline__ UWord bm0_mask(const UWord a) 231 { 232 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 233 tl_assert(address_msb(make_address(0, a)) == 0); 234 #endif 235 return ((UWord)1 << uword_lsb(a)); 236 } 237 238 /** Set the bit corresponding to address a in bitmap bm0. */ 239 static __inline__ void bm0_set(UWord* bm0, const UWord a) 240 { 241 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 242 tl_assert(address_msb(make_address(0, a)) == 0); 243 #endif 244 bm0[uword_msb(a)] |= (UWord)1 << uword_lsb(a); 245 } 246 247 /** 248 * Set the bits corresponding to all of the addresses in range 249 * [ a << ADDR_IGNORED_BITS .. (a + size) << ADDR_IGNORED_BITS [ 250 * in bitmap bm0. 251 */ 252 static __inline__ void bm0_set_range(UWord* bm0, 253 const UWord a, const SizeT size) 254 { 255 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 256 tl_assert(size > 0); 257 tl_assert(address_msb(make_address(0, a)) == 0); 258 tl_assert(address_msb(make_address(0, a + size - 1)) == 0); 259 tl_assert(uword_msb(a) == uword_msb(a + size - 1)); 260 #endif 261 bm0[uword_msb(a)] 262 |= (((UWord)1 << size) - 1) << uword_lsb(a); 263 } 264 265 /** Clear the bit corresponding to address a in bitmap bm0. */ 266 static __inline__ void bm0_clear(UWord* bm0, const UWord a) 267 { 268 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 269 tl_assert(address_msb(make_address(0, a)) == 0); 270 #endif 271 bm0[uword_msb(a)] &= ~((UWord)1 << uword_lsb(a)); 272 } 273 274 /** 275 * Clear all of the addresses in range 276 * [ a << ADDR_IGNORED_BITS .. (a + size) << ADDR_IGNORED_BITS [ 277 * in bitmap bm0. 278 */ 279 static __inline__ void bm0_clear_range(UWord* bm0, 280 const UWord a, const SizeT size) 281 { 282 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 283 tl_assert(address_msb(make_address(0, a)) == 0); 284 tl_assert(size == 0 || address_msb(make_address(0, a + size - 1)) == 0); 285 tl_assert(size == 0 || uword_msb(a) == uword_msb(a + size - 1)); 286 #endif 287 /* 288 * Note: although the expression below yields a correct result even if 289 * size == 0, do not touch bm0[] if size == 0 because this might otherwise 290 * cause an access of memory just past the end of the bm0[] array. 291 */ 292 if (size > 0) 293 { 294 bm0[uword_msb(a)] 295 &= ~((((UWord)1 << size) - 1) << uword_lsb(a)); 296 } 297 } 298 299 /** Test whether the bit corresponding to address a is set in bitmap bm0. */ 300 static __inline__ UWord bm0_is_set(const UWord* bm0, const UWord a) 301 { 302 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 303 tl_assert(address_msb(make_address(0, a)) == 0); 304 #endif 305 return (bm0[uword_msb(a)] & ((UWord)1 << uword_lsb(a))); 306 } 307 308 /** 309 * Return true if a bit corresponding to any of the addresses in range 310 * [ a << ADDR_IGNORED_BITS .. (a + size) << ADDR_IGNORED_BITS [ 311 * is set in bm0. 312 */ 313 static __inline__ UWord bm0_is_any_set(const UWord* bm0, 314 const Addr a, const SizeT size) 315 { 316 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 317 tl_assert(size > 0); 318 tl_assert(address_msb(make_address(0, a)) == 0); 319 tl_assert(address_msb(make_address(0, a + size - 1)) == 0); 320 tl_assert(uword_msb(a) == uword_msb(a + size - 1)); 321 #endif 322 return (bm0[uword_msb(a)] & ((((UWord)1 << size) - 1) << uword_lsb(a))); 323 } 324 325 326 327 /*********************************************************************/ 328 /* Functions for manipulating a struct bitmap. */ 329 /*********************************************************************/ 330 331 332 /* Second level bitmap. */ 333 struct bitmap2 334 { 335 Addr addr; ///< address_msb(...) 336 Bool recalc; 337 struct bitmap1 bm1; 338 }; 339 340 341 static void bm2_clear(struct bitmap2* const bm2); 342 static __inline__ 343 struct bitmap2* bm2_insert(struct bitmap* const bm, const UWord a1); 344 345 346 347 /** 348 * Rotate elements cache[0..n-1] such that the element at position n-1 is 349 * moved to position 0. This allows to speed up future cache lookups. 350 */ 351 static __inline__ 352 void bm_cache_rotate(struct bm_cache_elem cache[], const int n) 353 { 354 #if 0 355 struct bm_cache_elem t; 356 357 tl_assert(2 <= n && n <= 8); 358 359 t = cache[0]; 360 if (n > 1) 361 cache[0] = cache[1]; 362 if (n > 2) 363 cache[1] = cache[2]; 364 if (n > 3) 365 cache[2] = cache[3]; 366 if (n > 4) 367 cache[3] = cache[4]; 368 if (n > 5) 369 cache[4] = cache[5]; 370 if (n > 6) 371 cache[5] = cache[6]; 372 if (n > 7) 373 cache[6] = cache[7]; 374 cache[n - 1] = t; 375 #endif 376 } 377 378 static __inline__ 379 Bool bm_cache_lookup(struct bitmap* const bm, const UWord a1, 380 struct bitmap2** bm2) 381 { 382 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 383 tl_assert(bm); 384 tl_assert(bm2); 385 #endif 386 387 #if DRD_BITMAP_N_CACHE_ELEM > 8 388 #error Please update the code below. 389 #endif 390 #if DRD_BITMAP_N_CACHE_ELEM >= 1 391 if (a1 == bm->cache[0].a1) 392 { 393 *bm2 = bm->cache[0].bm2; 394 return True; 395 } 396 #endif 397 #if DRD_BITMAP_N_CACHE_ELEM >= 2 398 if (a1 == bm->cache[1].a1) 399 { 400 *bm2 = bm->cache[1].bm2; 401 return True; 402 } 403 #endif 404 #if DRD_BITMAP_N_CACHE_ELEM >= 3 405 if (a1 == bm->cache[2].a1) 406 { 407 *bm2 = bm->cache[2].bm2; 408 bm_cache_rotate(bm->cache, 3); 409 return True; 410 } 411 #endif 412 #if DRD_BITMAP_N_CACHE_ELEM >= 4 413 if (a1 == bm->cache[3].a1) 414 { 415 *bm2 = bm->cache[3].bm2; 416 bm_cache_rotate(bm->cache, 4); 417 return True; 418 } 419 #endif 420 #if DRD_BITMAP_N_CACHE_ELEM >= 5 421 if (a1 == bm->cache[4].a1) 422 { 423 *bm2 = bm->cache[4].bm2; 424 bm_cache_rotate(bm->cache, 5); 425 return True; 426 } 427 #endif 428 #if DRD_BITMAP_N_CACHE_ELEM >= 6 429 if (a1 == bm->cache[5].a1) 430 { 431 *bm2 = bm->cache[5].bm2; 432 bm_cache_rotate(bm->cache, 6); 433 return True; 434 } 435 #endif 436 #if DRD_BITMAP_N_CACHE_ELEM >= 7 437 if (a1 == bm->cache[6].a1) 438 { 439 *bm2 = bm->cache[6].bm2; 440 bm_cache_rotate(bm->cache, 7); 441 return True; 442 } 443 #endif 444 #if DRD_BITMAP_N_CACHE_ELEM >= 8 445 if (a1 == bm->cache[7].a1) 446 { 447 *bm2 = bm->cache[7].bm2; 448 bm_cache_rotate(bm->cache, 8); 449 return True; 450 } 451 #endif 452 *bm2 = 0; 453 return False; 454 } 455 456 static __inline__ 457 void bm_update_cache(struct bitmap* const bm, 458 const UWord a1, 459 struct bitmap2* const bm2) 460 { 461 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 462 tl_assert(bm); 463 #endif 464 465 #if DRD_BITMAP_N_CACHE_ELEM > 8 466 #error Please update the code below. 467 #endif 468 #if DRD_BITMAP_N_CACHE_ELEM >= 8 469 bm->cache[7] = bm->cache[6]; 470 #endif 471 #if DRD_BITMAP_N_CACHE_ELEM >= 7 472 bm->cache[6] = bm->cache[5]; 473 #endif 474 #if DRD_BITMAP_N_CACHE_ELEM >= 6 475 bm->cache[5] = bm->cache[4]; 476 #endif 477 #if DRD_BITMAP_N_CACHE_ELEM >= 5 478 bm->cache[4] = bm->cache[3]; 479 #endif 480 #if DRD_BITMAP_N_CACHE_ELEM >= 4 481 bm->cache[3] = bm->cache[2]; 482 #endif 483 #if DRD_BITMAP_N_CACHE_ELEM >= 3 484 bm->cache[2] = bm->cache[1]; 485 #endif 486 #if DRD_BITMAP_N_CACHE_ELEM >= 2 487 bm->cache[1] = bm->cache[0]; 488 #endif 489 bm->cache[0].a1 = a1; 490 bm->cache[0].bm2 = bm2; 491 } 492 493 /** 494 * Look up the address a1 in bitmap bm and return a pointer to a potentially 495 * shared second level bitmap. The bitmap where the returned pointer points 496 * at may not be modified by the caller. 497 * 498 * @param a1 client address shifted right by ADDR_LSB_BITS. 499 * @param bm bitmap pointer. 500 */ 501 static __inline__ 502 const struct bitmap2* bm2_lookup(struct bitmap* const bm, const UWord a1) 503 { 504 struct bitmap2* bm2; 505 506 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 507 tl_assert(bm); 508 #endif 509 510 if (! bm_cache_lookup(bm, a1, &bm2)) 511 { 512 bm2 = VG_(OSetGen_Lookup)(bm->oset, &a1); 513 bm_update_cache(bm, a1, bm2); 514 } 515 return bm2; 516 } 517 518 /** 519 * Look up the address a1 in bitmap bm and return a pointer to a second 520 * level bitmap that is not shared and hence may be modified. 521 * 522 * @param a1 client address shifted right by ADDR_LSB_BITS. 523 * @param bm bitmap pointer. 524 */ 525 static __inline__ 526 struct bitmap2* 527 bm2_lookup_exclusive(struct bitmap* const bm, const UWord a1) 528 { 529 struct bitmap2* bm2; 530 531 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 532 tl_assert(bm); 533 #endif 534 535 if (! bm_cache_lookup(bm, a1, &bm2)) 536 { 537 bm2 = VG_(OSetGen_Lookup)(bm->oset, &a1); 538 } 539 540 return bm2; 541 } 542 543 /** Clear the content of the second-level bitmap. */ 544 static __inline__ 545 void bm2_clear(struct bitmap2* const bm2) 546 { 547 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 548 tl_assert(bm2); 549 #endif 550 VG_(memset)(&bm2->bm1, 0, sizeof(bm2->bm1)); 551 } 552 553 /** 554 * Insert an uninitialized second level bitmap for the address a1. 555 * 556 * @param bm bitmap pointer. 557 * @param a1 client address shifted right by ADDR_LSB_BITS. 558 * 559 * @note bitmap2::recalc isn't initialized here on purpose. 560 */ 561 static __inline__ 562 struct bitmap2* bm2_insert(struct bitmap* const bm, const UWord a1) 563 { 564 struct bitmap2* bm2; 565 566 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 567 tl_assert(bm); 568 #endif 569 570 s_bitmap2_creation_count++; 571 572 bm2 = VG_(OSetGen_AllocNode)(bm->oset, sizeof(*bm2)); 573 bm2->addr = a1; 574 VG_(OSetGen_Insert)(bm->oset, bm2); 575 576 bm_update_cache(bm, a1, bm2); 577 578 return bm2; 579 } 580 581 static __inline__ 582 struct bitmap2* bm2_insert_copy(struct bitmap* const bm, 583 struct bitmap2* const bm2) 584 { 585 struct bitmap2* bm2_copy; 586 587 bm2_copy = bm2_insert(bm, bm2->addr); 588 VG_(memcpy)(&bm2_copy->bm1, &bm2->bm1, sizeof(bm2->bm1)); 589 return bm2_copy; 590 } 591 592 /** 593 * Look up the address a1 in bitmap bm, and insert it if not found. 594 * The returned second level bitmap may not be modified. 595 * 596 * @param bm bitmap pointer. 597 * @param a1 client address shifted right by ADDR_LSB_BITS. 598 */ 599 static __inline__ 600 struct bitmap2* bm2_lookup_or_insert(struct bitmap* const bm, const UWord a1) 601 { 602 struct bitmap2* bm2; 603 604 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 605 tl_assert(bm); 606 #endif 607 608 if (bm_cache_lookup(bm, a1, &bm2)) 609 { 610 if (bm2 == 0) 611 { 612 bm2 = bm2_insert(bm, a1); 613 bm2_clear(bm2); 614 } 615 } 616 else 617 { 618 bm2 = VG_(OSetGen_Lookup)(bm->oset, &a1); 619 if (! bm2) 620 { 621 bm2 = bm2_insert(bm, a1); 622 bm2_clear(bm2); 623 } 624 bm_update_cache(bm, a1, bm2); 625 } 626 return bm2; 627 } 628 629 /** 630 * Look up the address a1 in bitmap bm, and insert it if not found. 631 * The returned second level bitmap may be modified. 632 * 633 * @param a1 client address shifted right by ADDR_LSB_BITS. 634 * @param bm bitmap pointer. 635 */ 636 static __inline__ 637 struct bitmap2* bm2_lookup_or_insert_exclusive(struct bitmap* const bm, 638 const UWord a1) 639 { 640 return bm2_lookup_or_insert(bm, a1); 641 } 642 643 static __inline__ 644 void bm2_remove(struct bitmap* const bm, const UWord a1) 645 { 646 struct bitmap2* bm2; 647 648 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 649 tl_assert(bm); 650 #endif 651 652 bm2 = VG_(OSetGen_Remove)(bm->oset, &a1); 653 VG_(OSetGen_FreeNode)(bm->oset, bm2); 654 655 bm_update_cache(bm, a1, NULL); 656 } 657 658 static __inline__ 659 void bm_access_aligned_load(struct bitmap* const bm, 660 const Addr a1, const SizeT size) 661 { 662 struct bitmap2* bm2; 663 664 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 665 tl_assert(bm); 666 #endif 667 668 bm2 = bm2_lookup_or_insert_exclusive(bm, address_msb(a1)); 669 bm0_set_range(bm2->bm1.bm0_r, 670 (a1 >> ADDR_IGNORED_BITS) & ADDR_LSB_MASK, 671 SCALED_SIZE(size)); 672 } 673 674 static __inline__ 675 void bm_access_aligned_store(struct bitmap* const bm, 676 const Addr a1, const SizeT size) 677 { 678 struct bitmap2* bm2; 679 680 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 681 tl_assert(bm); 682 #endif 683 684 bm2 = bm2_lookup_or_insert_exclusive(bm, address_msb(a1)); 685 bm0_set_range(bm2->bm1.bm0_w, 686 (a1 >> ADDR_IGNORED_BITS) & ADDR_LSB_MASK, 687 SCALED_SIZE(size)); 688 } 689 690 static __inline__ 691 Bool bm_aligned_load_has_conflict_with(struct bitmap* const bm, 692 const Addr a, const SizeT size) 693 { 694 const struct bitmap2* bm2; 695 696 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 697 tl_assert(bm); 698 #endif 699 700 bm2 = bm2_lookup(bm, address_msb(a)); 701 return (bm2 702 && bm0_is_any_set(bm2->bm1.bm0_w, 703 address_lsb(a), 704 SCALED_SIZE(size))); 705 } 706 707 static __inline__ 708 Bool bm_aligned_store_has_conflict_with(struct bitmap* const bm, 709 const Addr a, const SizeT size) 710 { 711 const struct bitmap2* bm2; 712 713 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS 714 tl_assert(bm); 715 #endif 716 717 bm2 = bm2_lookup(bm, address_msb(a)); 718 if (bm2) 719 { 720 if (bm0_is_any_set(bm2->bm1.bm0_r, address_lsb(a), SCALED_SIZE(size)) 721 | bm0_is_any_set(bm2->bm1.bm0_w, address_lsb(a), SCALED_SIZE(size))) 722 { 723 return True; 724 } 725 } 726 return False; 727 } 728 729 #endif /* __DRD_BITMAP_H */ 730
