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

References

  143     atomic_store((atomic_uint8_t*)m, CHUNK_AVAILABLE, memory_order_relaxed);
  286     return atomic_load(&rss_limit_exceeded, memory_order_relaxed);
  290     atomic_store(&rss_limit_exceeded, limit_exceeded, memory_order_relaxed);

  219   atomic_store(&param.t, 0, memory_order_relaxed);
  220   atomic_store(&param.is_registered, 0, memory_order_relaxed);

  449                                                    pc, memory_order_relaxed))

   44   if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
   72   if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) == 0) {

  119   if (atomic_load(&stack_switching_, memory_order_relaxed)) {
  141   if (!atomic_load(&stack_switching_, memory_order_relaxed)) {
  206       memory_order_relaxed)) {

  110     return !atomic_load(&stack_switching_, memory_order_relaxed) &&
  117     if (atomic_load(&stack_switching_, memory_order_relaxed))

  194         atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1;
  257     atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1;
  343       atomic_load(&__dfsan_last_label, memory_order_relaxed);
  351       atomic_load(&__dfsan_last_label, memory_order_relaxed);

   60   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed);
   67   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed);

  440   atomic_store(&p.tid, 0, memory_order_relaxed);

  568     u32 idx = atomic_fetch_add(&NumStackOriginDescrs, 1, memory_order_relaxed);

 1004       (signal_cb)atomic_load(&sigactions[signo], memory_order_relaxed);
 1017       (sigaction_cb)atomic_load(&sigactions[signo], memory_order_relaxed);
 1381     uptr old_cb = atomic_load(&sigactions[signo], memory_order_relaxed);
 1391         atomic_store(&sigactions[signo], cb, memory_order_relaxed);
 1418       atomic_store(&sigactions[signo], cb, memory_order_relaxed);

  195   if (atomic_load(&b->add, memory_order_relaxed)) {
  197     AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
  200       uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
  216     uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
  228   AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
  232       uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
  256     uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
  271     atomic_store(&b->add, (uptr)add, memory_order_relaxed);
  283     atomic_store(&b->add, (uptr)add1, memory_order_relaxed);
  289   CHECK_EQ(atomic_load(&c->addr, memory_order_relaxed), 0);
  300   uptr addr1 = atomic_load(&c->addr, memory_order_relaxed);
  313     AddBucket *add = (AddBucket*)atomic_load(&b->add, memory_order_relaxed);
  320         uptr addr1 = atomic_load(&c1->addr, memory_order_relaxed);
  330         atomic_store(&c1->addr, 0, memory_order_relaxed);

   99     if (atomic_load(&internal_allocator_initialized, memory_order_relaxed) ==
  254   return atomic_load(&allocator_may_return_null, memory_order_relaxed);
  259                memory_order_relaxed);

   90     return atomic_load(&release_to_os_interval_ms_, memory_order_relaxed);
   95                  memory_order_relaxed);

   34     v += atomic_load(&stats_[i], memory_order_relaxed);
   35     atomic_store(&stats_[i], v, memory_order_relaxed);
   39     v = atomic_load(&stats_[i], memory_order_relaxed) - v;
   40     atomic_store(&stats_[i], v, memory_order_relaxed);
   44     atomic_store(&stats_[i], v, memory_order_relaxed);
   48     return atomic_load(&stats_[i], memory_order_relaxed);

   76   return atomic_load(a, memory_order_relaxed);
   81   atomic_store(a, v, memory_order_relaxed);

   36     if (mo == memory_order_relaxed) {
   80     if (mo == memory_order_relaxed) {

  183       atomic_fetch_add(&g_total_mmaped, size, memory_order_relaxed) + size;
  191   atomic_fetch_sub(&g_total_mmaped, size, memory_order_relaxed);
  337   return !atomic_exchange(&in_crash_state, 1, memory_order_relaxed);

   57   atomic_store(&current_verbosity, verbosity, memory_order_relaxed);
   60   return atomic_load(&current_verbosity, memory_order_relaxed);

 6112   if (atomic_exchange(&printed, 1, memory_order_relaxed))

  134     if (atomic_load(pc_ptr, memory_order_relaxed) == 0)
  135       atomic_store(pc_ptr, pc, memory_order_relaxed);

   28     atomic_store(&head_, 0, memory_order_relaxed);
   32     return (atomic_load(&head_, memory_order_relaxed) & kPtrMask) == 0;
   36     u64 cmp = atomic_load(&head_, memory_order_relaxed);

   82             atomic_load(&ignored_ranges_count_, memory_order_relaxed);
  111             atomic_load(&instrumented_ranges_count_, memory_order_relaxed);

  681   CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed));

   25     atomic_store(&state_, 0, memory_order_relaxed);
   43     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
   55       if (atomic_load(&state_, memory_order_relaxed) == 0
  100     atomic_store(&state_, kUnlocked, memory_order_relaxed);
  104     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
  136     CHECK_NE(atomic_load(&state_, memory_order_relaxed), kUnlocked);
  154       u32 cmp = atomic_load(&state_, memory_order_relaxed);

   55     atomic_store(&region_pos, 0, memory_order_relaxed);

   40         atomic_load(&hash_and_use_count, memory_order_relaxed) & kHashMask;
   61     atomic_store(&hash_and_use_count, hash & kHashMask, memory_order_relaxed);
   78   return atomic_load(&node_->hash_and_use_count, memory_order_relaxed) &
   83       atomic_fetch_add(&node_->hash_and_use_count, 1, memory_order_relaxed) &

   77     uptr cmp = atomic_load(p, memory_order_relaxed);
  118   u32 id = atomic_fetch_add(&seq[part], 1, memory_order_relaxed) + 1;
  170     uptr s = atomic_load(p, memory_order_relaxed);

  269     atomic_store(&inst->arg->done, 1, memory_order_relaxed);
  327   atomic_store(&tracer_thread_argument->done, 1, memory_order_relaxed);
  401   atomic_store(&tracer_thread_argument.done, 0, memory_order_relaxed);
  455     while (atomic_load(&tracer_thread_argument.done, memory_order_relaxed) == 0)

  260                                        memory_order_relaxed)) {

   72   if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) > 10) {

   49   atomic_fetch_sub(&number_of_live_dtls, 1, memory_order_relaxed);
   59       atomic_fetch_add(&number_of_live_dtls, 1, memory_order_relaxed);
  102           atomic_load(&number_of_live_dtls, memory_order_relaxed));

  170             memory_order_relaxed)))
  641                                     CurrentCheck, memory_order_relaxed))

  220   atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);

  101   uptr id = atomic_fetch_add(&id_gen, 1, memory_order_relaxed);

  262     atomic_fetch_add(ref_ptr(dst->tab_), 1, memory_order_relaxed);
  304       atomic_fetch_add(ref_ptr(dst->tab_), 1, memory_order_relaxed);

   31   if (tag >= atomic_load(&used_tags, memory_order_relaxed)) return nullptr;
   50   uptr tag_count = atomic_load(&used_tags, memory_order_relaxed);
   61   CHECK_LT(tag, atomic_load(&used_tags, memory_order_relaxed));
   76   uptr new_tag = atomic_fetch_add(&used_tags, 1, memory_order_relaxed);
   99   CHECK_LT(tag, atomic_load(&used_tags, memory_order_relaxed));

   52   atomic_store(&s->rc, 1, memory_order_relaxed);
   57   if (s && atomic_load(&s->rc, memory_order_relaxed) != (u64)-1)
   58     atomic_fetch_add(&s->rc, 1, memory_order_relaxed);
   63   if (s && atomic_load(&s->rc, memory_order_relaxed) != (u64)-1) {
  123   atomic_store(&fdctx.globsync.rc, (u64)-1, memory_order_relaxed);
  124   atomic_store(&fdctx.filesync.rc, (u64)-1, memory_order_relaxed);
  125   atomic_store(&fdctx.socksync.rc, (u64)-1, memory_order_relaxed);
  133     FdDesc *tab = (FdDesc*)atomic_load(&fdctx.tab[l1], memory_order_relaxed);
  145     FdDesc *tab = (FdDesc*)atomic_load(&fdctx.tab[l1], memory_order_relaxed);

  324       atomic_store(&ctx->in_blocking_func, 1, memory_order_relaxed);
  325       if (atomic_load(&ctx->have_pending_signals, memory_order_relaxed) == 0)
  327       atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
  340     atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
  502       atomic_load(&sctx->in_blocking_func, memory_order_relaxed) :
  505       memory_order_relaxed);
  522             memory_order_relaxed);
  525           memory_order_relaxed);
  865       if (atomic_compare_exchange_strong(g, &cmp, 1<<16, memory_order_relaxed))
  884   atomic_store(g, 0, memory_order_relaxed);
  989   atomic_store(&p.tid, 0, memory_order_relaxed);
 1132   CHECK_EQ(atomic_load(&ctx->in_blocking_func, memory_order_relaxed), 1);
 1133   atomic_store(&ctx->in_blocking_func, 0, memory_order_relaxed);
 1214     atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
 1441                                                memory_order_relaxed)) {
 1943       atomic_load(&sctx->have_pending_signals, memory_order_relaxed) == 0)
 1945   atomic_store(&sctx->have_pending_signals, 0, memory_order_relaxed);
 1946   atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
 1960   atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
 1988       (sctx && atomic_load(&sctx->in_blocking_func, memory_order_relaxed))) {
 1989     atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
 1990     if (sctx && atomic_load(&sctx->in_blocking_func, memory_order_relaxed)) {
 1991       atomic_store(&sctx->in_blocking_func, 0, memory_order_relaxed);
 1993       atomic_store(&sctx->in_blocking_func, 1, memory_order_relaxed);
 2003     atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
 2017     atomic_store(&sctx->have_pending_signals, 1, memory_order_relaxed);

  134   atomic_fetch_add(&race->hitcount, 1, memory_order_relaxed);
  173         atomic_fetch_add(&(race0->*counter), cnt, memory_order_relaxed);

  198   case mo_relaxed: return memory_order_relaxed;

  219   atomic_store(&state_, kUnlocked, memory_order_relaxed);
  223   CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
  235     if (atomic_load(&state_, memory_order_relaxed) == kUnlocked) {
  286   CHECK_NE(atomic_load(&state_, memory_order_relaxed), 0);

  178       atomic_load(&ctx->stop_background_thread, memory_order_relaxed) == 0;
  214                              memory_order_relaxed);
  219         atomic_store(&ctx->last_symbolize_time_ns, 0, memory_order_relaxed);
  231   atomic_store(&ctx->stop_background_thread, 1, memory_order_relaxed);
  433   if (atomic_load(&bg_thread, memory_order_relaxed) == 0 &&
  434       atomic_exchange(&bg_thread, 1, memory_order_relaxed) == 0) {
  607   u64 raw = atomic_load((atomic_uint64_t*)p, memory_order_relaxed);
  613   atomic_store((atomic_uint64_t*)sp, s, memory_order_relaxed);

  553           atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed);
  569         atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed);

  100     atomic_fetch_add(&(*sp)->hit_count, 1, memory_order_relaxed);
  138       atomic_fetch_add(&s->hit_count, 1, memory_order_relaxed);

   58   atomic_store(&uid_gen_, 0, memory_order_relaxed);
  241       const u64 uid = atomic_fetch_add(&uid_gen_, 1, memory_order_relaxed);

   62                         __sanitizer::memory_order_relaxed);

  219       if (Delta < atomic_load(&ThresholdTicks, memory_order_relaxed)) {
  392     if (!atomic_load(&UseRealTSC, memory_order_relaxed) && Verbosity())