reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

projects/compiler-rt/lib/asan/asan_allocator.cpp

  336     options->min_redzone = atomic_load(&min_redzone, memory_order_acquire);
  337     options->max_redzone = atomic_load(&max_redzone, memory_order_acquire);
  340         atomic_load(&alloc_dealloc_mismatch, memory_order_acquire);
  354     u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
  355     u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
  555                                         memory_order_acquire)) {
  633       if (atomic_load(&alloc_dealloc_mismatch, memory_order_acquire)) {

projects/compiler-rt/lib/asan/asan_interceptors.cpp

  202               atomic_load(&param->t, memory_order_acquire))) == nullptr)
  243     while (atomic_load(&param.is_registered, memory_order_acquire) == 0)

projects/compiler-rt/lib/asan/asan_poisoning.cpp

   30   return atomic_load(&can_poison_memory, memory_order_acquire);

projects/compiler-rt/lib/asan/asan_stack.cpp

   26   return atomic_load(&malloc_context_size, memory_order_acquire);

projects/compiler-rt/lib/asan/asan_thread.cpp

  163   if (!atomic_load(&stack_switching_, memory_order_acquire)) {

projects/compiler-rt/lib/dfsan/dfsan.cpp

  184                                      memory_order_acquire)) {
  204       label = atomic_load(table_ent, memory_order_acquire);

projects/compiler-rt/lib/lsan/lsan_interceptors.cpp

  417   while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
  455     while (atomic_load(&p.tid, memory_order_acquire) != 0)

projects/compiler-rt/lib/sanitizer_common/sanitizer_addrhashmap.h

  187     uptr addr1 = atomic_load(&c->addr, memory_order_acquire);

projects/compiler-rt/lib/sanitizer_common/sanitizer_allocator.cpp

   97   if (atomic_load(&internal_allocator_initialized, memory_order_acquire) == 0) {

projects/compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h

   87         atomic_load(&map1_[idx], memory_order_acquire));

projects/compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_x86.h

   44     } else if (mo == memory_order_acquire) {

projects/compiler-rt/lib/sanitizer_common/sanitizer_lfstack.h

   48     u64 cmp = atomic_load(&head_, memory_order_acquire);
   57                                        memory_order_acquire))

projects/compiler-rt/lib/sanitizer_common/sanitizer_libignore.h

   91   const uptr n = atomic_load(&ignored_ranges_count_, memory_order_acquire);
  105   const uptr n = atomic_load(&instrumented_ranges_count_, memory_order_acquire);

projects/compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

  650   if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked)
  652   while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) {

projects/compiler-rt/lib/sanitizer_common/sanitizer_mutex.h

   35     return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
   56           && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
  110                                        memory_order_acquire))
  122     u32 prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
  157                                        memory_order_acquire))
  168       u32 prev = atomic_load(&state_, memory_order_acquire);

projects/compiler-rt/lib/sanitizer_common/sanitizer_persistent_allocator.h

   37     uptr cmp = atomic_load(&region_pos, memory_order_acquire);
   38     uptr end = atomic_load(&region_end, memory_order_acquire);
   41                                      memory_order_acquire))

projects/compiler-rt/lib/sanitizer_common/sanitizer_stackdepotbase.h

   79         atomic_compare_exchange_weak(p, &cmp, cmp | 1, memory_order_acquire))

projects/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

   52   return !!atomic_load(&thread_destroyed, memory_order_acquire);

projects/compiler-rt/lib/tsan/dd/dd_interceptors.cpp

  163   uptr cond = atomic_load(p, memory_order_acquire);

projects/compiler-rt/lib/tsan/rtl/tsan_clock.cpp

   93   u32 v = atomic_load(ref, memory_order_acquire);
  301     if (atomic_load(ref, memory_order_acquire) == 1)
  460   u32 v = atomic_load(ref, memory_order_acquire);

projects/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

  863     u32 cmp = atomic_load(g, memory_order_acquire);
  945     while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
 1009     while (atomic_load(&p.tid, memory_order_acquire) != 0)
 1106   uptr cond = atomic_load(p, memory_order_acquire);
 1439   u32 v = atomic_load(a, memory_order_acquire);
 1449       v = atomic_load(a, memory_order_acquire);

projects/compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cpp

  200   case mo_acquire: return memory_order_acquire;

projects/compiler-rt/lib/tsan/rtl/tsan_mutex.cpp

  232                                      memory_order_acquire))
  238                                        memory_order_acquire)) {
  261   uptr prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
  265     prev = atomic_load(&state_, memory_order_acquire);

projects/compiler-rt/lib/xray/xray_basic_logging.cpp

   94     if (atomic_load(&UseRealTSC, memory_order_acquire))
  106   Header.CycleFrequency = atomic_load(&CycleFrequency, memory_order_acquire);
  424                atomic_load(&TicksPerSec, memory_order_acquire) *
  427   __xray_set_handler_arg1(atomic_load(&UseRealTSC, memory_order_acquire)
  430   __xray_set_handler(atomic_load(&UseRealTSC, memory_order_acquire)

projects/compiler-rt/lib/xray/xray_buffer_queue.cpp

  162   if (atomic_load(&Finalizing, memory_order_acquire))
  212   atomic_store(B->Buff.Extents, atomic_load(Buf.Extents, memory_order_acquire),

projects/compiler-rt/lib/xray/xray_buffer_queue.h

  233     return atomic_load(&Finalizing, memory_order_acquire);
  237     return atomic_load(&Generation, memory_order_acquire);

projects/compiler-rt/lib/xray/xray_fdr_logging.cpp

  252   atomic_thread_fence(memory_order_acquire);
  253   auto BufferSize = atomic_load(It->Extents, memory_order_acquire);
  280   if (atomic_load(&LoggingStatus, memory_order_acquire) !=
  367     auto BufferExtents = atomic_load(B.Extents, memory_order_acquire);
  449     auto Status = atomic_load(&LoggingStatus, memory_order_acquire);

projects/compiler-rt/lib/xray/xray_init.cpp

   66   if (atomic_load(&XRayInitialized, memory_order_acquire))
   72   if (!atomic_load(&XRayFlagsInitialized, memory_order_acquire)) {

projects/compiler-rt/lib/xray/xray_interface.cpp

  181                                 memory_order_acquire))
  232                                 memory_order_acquire))
  374                                memory_order_acquire)) {
  387                                memory_order_acquire)) {
  399                                memory_order_acquire)) {
  450                                 memory_order_acquire))

projects/compiler-rt/lib/xray/xray_log_interface.cpp

  201       atomic_load(&XRayBufferIterator, memory_order_acquire));

projects/compiler-rt/lib/xray/xray_profile_collector.cpp

  115   if (!atomic_load(&CollectorInitialized, memory_order_acquire)) {
  233   if (!atomic_load(&CollectorInitialized, memory_order_acquire))

projects/compiler-rt/lib/xray/xray_profiling.cpp

  208   if (atomic_load(&ProfilerLogStatus, memory_order_acquire) !=
  279   auto Status = atomic_load(&ProfilerLogStatus, memory_order_acquire);