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

References

   47   CHECK_EQ(rz_size, RZLog2Size(res));
  142     CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
  152       CHECK_EQ(alloc_magic[0], kAllocBegMagic);
  156       CHECK_EQ(alloc_magic[1], reinterpret_cast<uptr>(m));
  488     CHECK_EQ(alloc_tid, m->alloc_tid);  // Does alloc_tid fit into the bitfield?
  560     CHECK_EQ(CHUNK_ALLOCATED, old_chunk_state);
  567     CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
  570       CHECK_EQ(m->free_tid, kInvalidTid);

  340   CHECK_EQ(0, ((uptr)stop - (uptr)start) % sizeof(__asan_global));
  350   CHECK_EQ(0, ((uptr)stop - (uptr)start) % sizeof(__asan_global));

  118     CHECK_EQ(value, end.value);
  158     CHECK_EQ(value, end.value);
  388     CHECK_EQ(*(u8*)MemToShadow(a), 0);
  400     CHECK_EQ(b2 - b1, granularity);

   92   CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
  109     CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));

  192     CHECK_EQ(current_error_.kind, kErrorKindInvalid);

  324   CHECK_EQ((kHighMemBeg % GetMmapGranularity()), 0);
  497   CHECK_EQ(0, main_thread->tid());

   29   CHECK_EQ((beg % GetMmapGranularity()), 0);
   30   CHECK_EQ(((end + 1) % GetMmapGranularity()), 0);
  103     CHECK_EQ(0, kLowShadowBeg);
  134     CHECK_EQ(kShadowGapEnd, kHighShadowBeg - 1);

   38   CHECK_EQ(nullptr, suppression_ctx);

  223   CHECK_EQ(this->stack_size(), 0U);
  258     CHECK_EQ(tid(), 0);
  432   CHECK_EQ(0, AsanTSDGet());
  434   CHECK_EQ(t->context(), AsanTSDGet());

  195     CHECK_EQ(kCfiShadowLimitsStorageSize, GetPageSizeCached());
  196     CHECK_EQ(0, GetShadow());
  200     CHECK_EQ(shadow_, GetShadow());
  311   CHECK_EQ(0, GetShadow());
  312   CHECK_EQ(0, GetShadowSize());

   39   CHECK_EQ(inited, 0);

  252   CHECK_EQ(inited, 0);

   61   CHECK_EQ((beg % GetMmapGranularity()), 0);
   62   CHECK_EQ(((end + 1) % GetMmapGranularity()), 0);
  120     CHECK_EQ(kHighShadowEnd + 1, kHighMemStart);
  125     CHECK_EQ(kLowMemEnd + 1, kHighShadowStart);
  130     CHECK_EQ(kLowMemEnd + 1, kLowShadowStart);
  132   CHECK_EQ(0, kLowMemStart);
  210   CHECK_EQ(kHighMemStart % GetMmapGranularity(), 0);
  304     CHECK_EQ(0, pthread_setspecific(tsd_key,
  311     CHECK_EQ(0, pthread_setspecific(tsd_key, (void *)(iterations - 1)));
  320   CHECK_EQ(0, pthread_key_create(&tsd_key, HwasanTSDDtor));

   49   CHECK_EQ(GetCurrentThread(), this);

  118   CHECK_EQ(tid, 0);

   86   CHECK_EQ(nullptr, suppression_ctx);
  456   CHECK_EQ(0, frontier.size());

 1600   CHECK_EQ(inited, 0);

   84     CHECK_EQ(prev_end, start);
   92       CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
   97       CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
  102       CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
  228   CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
  239   CHECK_EQ(0, msan_current_thread);
  250     CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));

  289   CHECK_EQ(atomic_load(&c->addr, memory_order_relaxed), 0);
  303     CHECK_EQ(addr1, 0);
  310     CHECK_EQ(addr1, h->addr_);
  338     CHECK_EQ(addr1, h->addr_);

  166   CHECK_EQ(kBlockMagic, ((u64*)addr)[0]);
  202   CHECK_EQ(kBlockMagic, ((u64*)addr)[0]);

   27     CHECK_EQ(0U, map_[idx]);
   71     CHECK_EQ(0U, map2[idx % kSize2]);

   73       CHECK_EQ(reinterpret_cast<uptr>(res) & (alignment - 1), 0);

   75       CHECK_EQ(kSpaceBeg, address_range.Init(TotalSpaceSize,
  641     CHECK_EQ(beg, mapped);
  647     CHECK_EQ(beg, address_range.MapOrDie(beg, size, name));

  139       CHECK_EQ(chunks_[idx], h);
  158       CHECK_EQ(h->chunk_idx, i);
  242       CHECK_EQ(beg + 1, end);
  287       CHECK_EQ(chunks[i], t);
  288       CHECK_EQ(AddressSpaceView::Load(chunks[i])->chunk_idx, i);

  212       CHECK_EQ(ClassID(s), c);
  214         CHECK_EQ(ClassID(s + 1), c + 1);
  215       CHECK_EQ(ClassID(s - 1), c);
  218     CHECK_EQ(ClassID(kMaxSize + 1), 0);

  315       CHECK_EQ(*p, 0);
  501       CHECK_EQ(*p, 0);

   23   CHECK_EQ(SoftRssLimitExceededCallback, nullptr);

   60     CHECK_EQ(epoch_, current_epoch);
  107     CHECK_EQ(epoch_, current_epoch);
  319       CHECK_EQ(path[0], cur_node);
  367     CHECK_EQ(current_epoch_, nodeToEpoch(node));

  128   CHECK_EQ(m->id, path[0]);

  231   CHECK_EQ(base, 10);

  648   CHECK_EQ(owner_, 0);
 1203   CHECK_EQ(0, (uptr)child_stack % 16);

  100     CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
  144   CHECK_EQ(pthread_getattr_np(pthread_self(), &attr), 0);
  160   CHECK_EQ(sizeof(setenv_f), sizeof(f));
  214   CHECK_EQ(sizeof(get_tls), sizeof(ptr));
  702   CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
  839   CHECK_EQ(internal_iserror(rv, &rverrno), true);

   76     CHECK_EQ(prev->next, x);
  118       CHECK_EQ(first_, 0);
  119       CHECK_EQ(last_, 0);
  126       CHECK_EQ(size(), count);
  127       CHECK_EQ(last_->next, 0);

   43     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
  104     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);

  354   CHECK_EQ(0, res);
  356   CHECK_EQ(0, res);

   92   CHECK_EQ(0, getrlimit(res, &rlim));
  176   CHECK_EQ(0, sigaltstack(nullptr, &oldstack));
  187   CHECK_EQ(0, sigaltstack(&altstack, nullptr));
  195   CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
  210   CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
  289     CHECK_EQ(EFAULT, write_errno);
  370     CHECK_EQ(addr + size, reinterpret_cast<uptr>(base_) + size_);

   42   CHECK_EQ(*data_.current++, '-');
   44   CHECK_EQ(*data_.current++, ' ');
   54   CHECK_EQ(*data_.current++, ' ');
   56   CHECK_EQ(*data_.current++, ' ');
   58   CHECK_EQ(*data_.current++, ':');
   60   CHECK_EQ(*data_.current++, ' ');

  262         CHECK_EQ(extracted->count, 0);
  263         CHECK_EQ(extracted->size, sizeof(QuarantineBatch));

   94     CHECK_EQ(sizeof(CompactRingBuffer<T>), sizeof(void *));
   98     CHECK_EQ(size % 4096, 0);
   99     CHECK_EQ(size % sizeof(T), 0);
  100     CHECK_EQ((uptr)storage % (size * 2), 0);

  123   CHECK_EQ(id & (((u32)-1) >> kReservedBits), id);
  141   CHECK_EQ(id & (((u32)-1) >> kReservedBits), id);

   61   CHECK_EQ(request_fast_unwind, WillUseFastUnwind(request_fast_unwind));

  430   CHECK_EQ(rv, 0);

  297     CHECK_EQ(0, internal_strcmp(module_name, addr2line->module_name()));

   57   CHECK_EQ(false, detached);
   58   CHECK_EQ(ThreadStatusFinished, status);
  160   CHECK_EQ(tctx->status, ThreadStatusInvalid);
  164     CHECK_EQ(alive_threads_, max_alive_threads_);
  219   CHECK_EQ(SANITIZER_FUCHSIA ? ThreadStatusCreated : ThreadStatusRunning,
  294     CHECK_EQ(tctx->status, ThreadStatusCreated);
  312   CHECK_EQ(ThreadStatusCreated, tctx->status);
  324   CHECK_EQ(tctx->status, ThreadStatusDead);
  347   CHECK_EQ(tctx->user_id, 0);

  128     CHECK_EQ(CommittedBeg, AddressRange.Map(CommittedBeg, CommittedSize));

   50   CHECK_EQ(pthread_key_create(&PThreadKey, teardownThread), 0);
   56   CHECK_EQ(pthread_once(&GlobalInitialized, initOnce), 0);
   59   CHECK_EQ(pthread_setspecific(PThreadKey, reinterpret_cast<void *>(

  114   CHECK_EQ(reused_, ((u64)reused_ << kClkBits) >> kClkBits);
  252     CHECK_EQ(dst->dirty_[0].tid, kInvalidTid);
  379   CHECK_EQ(size_, 0);
  380   CHECK_EQ(blocks_, 0);
  381   CHECK_EQ(tab_, 0);
  382   CHECK_EQ(tab_idx_, 0);
  412     CHECK_EQ(size_, 0);
  413     CHECK_EQ(blocks_, 0);
  414     CHECK_EQ(tab_, 0);
  415     CHECK_EQ(tab_idx_, 0);
  543   CHECK_EQ(get_block(bi), 0);

   43     CHECK_EQ(kL1Size & (kL1Size - 1), 0);
   44     CHECK_EQ(kL2Size & (kL2Size - 1), 0);

 1045     CHECK_EQ(thr, &cur_thread_placeholder);
 1132   CHECK_EQ(atomic_load(&ctx->in_blocking_func, memory_order_relaxed), 1);
 1949   CHECK_EQ(res, 0);
 1959   CHECK_EQ(res, 0);
 2036   CHECK_EQ(sctx->int_signal_send, sig);
 2051     CHECK_EQ(sctx->int_signal_send, sig);
 2067     CHECK_EQ(sctx->int_signal_send, sig);

   85   CHECK_EQ(sizeof(vptr_p), 8);
   95   CHECK_EQ(sizeof(vptr_p), 8);

   71   CHECK_EQ(jctx, 0);
   74   CHECK_EQ(heap_begin % kHeapAlignment, 0);
   75   CHECK_EQ(heap_size % kHeapAlignment, 0);
   95   CHECK_EQ(ptr % kHeapAlignment, 0);
   96   CHECK_EQ(size % kHeapAlignment, 0);
  108   CHECK_EQ(ptr % kHeapAlignment, 0);
  109   CHECK_EQ(size % kHeapAlignment, 0);
  121   CHECK_EQ(src % kHeapAlignment, 0);
  122   CHECK_EQ(dst % kHeapAlignment, 0);
  123   CHECK_EQ(size % kHeapAlignment, 0);
  155   CHECK_EQ((*from_ptr) % kHeapAlignment, 0);
  156   CHECK_EQ(to % kHeapAlignment, 0);

  223   CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);

   44     CHECK_EQ(size_, kMaxSize - 1);

  332     CHECK_EQ(rep->mutexes.Size() * (flags()->second_deadlock_stack ? 2 : 1),

  294   CHECK_EQ(addr, addr & ~((64 << 10) - 1));  // windows wants 64K alignment
  321         CHECK_EQ(p, ShadowToMem(s));
  328           CHECK_EQ(s - prev_s, (p - prev) * kShadowMultiplier);
  329           CHECK_EQ((m - prev_m) / kMetaShadowSize,
  406   CHECK_EQ(tid, 0);
  971   CHECK_EQ(thr->is_freeing, false);

  173     CHECK_EQ(s->recursion, 0);

   34   CHECK_EQ(proc->thr, nullptr);
   47   CHECK_EQ(thr->proc1, nullptr);
   48   CHECK_EQ(proc->thr, nullptr);
   54   CHECK_EQ(thr->proc1, proc);
   55   CHECK_EQ(proc->thr, thr);

  390   CHECK_EQ(RoundDown(epoch, kTracePartSize), hdr->epoch0);
  508   CHECK_EQ(thr->current_report, nullptr);

   38   CHECK_EQ(sync.size(), 0);
   69   CHECK_EQ(sync.size(), 0);

   52   CHECK_EQ(nullptr, suppression_ctx);

   47     CHECK_EQ(clock.size(), 0);
   48     CHECK_EQ(read_clock.size(), 0);
  149   CHECK_EQ(p, RoundUp(p, kPageSize));
  150   CHECK_EQ(sz, RoundUp(sz, kPageSize));
  275     CHECK_EQ(*dst_meta, 0);

   78     CHECK_EQ(uid, GetLsb(uid, 14));

  406   CHECK_EQ(nullptr, suppression_ctx);