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

References

   97   CHECK(!asan_is_deactivated);

   45   CHECK(IsPowerOfTwo(rz_size));
  209   CHECK(ms);
  214   CHECK(ms);
  265     CHECK(IsPowerOfTwo(options.min_redzone));
  266     CHECK(IsPowerOfTwo(options.max_redzone));
  390     CHECK(AsanChunkView(left_chunk).AddrIsAtRight(addr, 1, &l_offset));
  391     CHECK(AsanChunkView(right_chunk).AddrIsAtLeft(addr, 1, &r_offset));
  408     CHECK(stack);
  423     CHECK(IsPowerOfTwo(alignment));
  437     CHECK(IsAligned(needed_size, min_alignment));
  497       CHECK(size);
  499       CHECK(allocator.FromPrimary(allocated));
  501       CHECK(!allocator.FromPrimary(allocated));
  651     CHECK(old_ptr && new_size);
  820   CHECK(id);
  822   CHECK(res.trace);
  960   CHECK(IsAligned((uptr)ptr, alignment));
 1025   CHECK(m);

  124   CHECK(region_kind);

   38   CHECK(((unsigned int)len) < sizeof(name));
   44   CHECK(context);
   72   CHECK(!AddrIsInMem(addr));
   80     CHECK(0 && "Address is not in memory and not in shadow?");
  175   CHECK(id);
  177   CHECK(res.trace);

  442         CHECK(0);
  444     CHECK(0);

  160   CHECK(IsPowerOfTwo(f->redzone));
  161   CHECK(IsPowerOfTwo(f->max_redzone));
  163     CHECK(!f->unmap_shadow_on_exit);
  164     CHECK(!f->protect_shadow_gap);

   99   CHECK(global_registration_site_vector);
  198   CHECK(asan_inited);
  201   CHECK(flags()->report_globals);
  202   CHECK(AddrIsInMem(g->beg));
  211     CHECK(AddrIsAlignedByGranularity(g->beg));
  213   CHECK(AddrIsAlignedByGranularity(g->size_with_redzone));
  239   CHECK(asan_inited);
  242   CHECK(flags()->report_globals);
  243   CHECK(AddrIsInMem(g->beg));
  244   CHECK(AddrIsAlignedByGranularity(g->beg));
  245   CHECK(AddrIsAlignedByGranularity(g->size_with_redzone));
  303   CHECK(res);
  384       CHECK(globals[i].size == 0 && globals[i].size_with_redzone == 0 &&
  425   CHECK(module_name);
  426   CHECK(asan_inited);
  450   CHECK(asan_inited);

  333   CHECK(REAL(__cxa_throw));
  341   CHECK(REAL(__cxa_rethrow_primary_exception));
  350   CHECK(REAL(_Unwind_RaiseException));
  630   CHECK(!was_called_once);

   91   CHECK(to >= from);
   99     CHECK("unable to unmap" && 0);

   69   CHECK(alignment >= kWordSize);

  366   CHECK(AddrIsInMem(p));

   55     CHECK(total_allocated_user_size_);

   35   CHECK(AddrIsAlignedByGranularity(addr));
   36   CHECK(AddrIsInMem(addr));
   37   CHECK(AddrIsAlignedByGranularity(addr + size));
   38   CHECK(AddrIsInMem(addr + size - SHADOW_GRANULARITY));
   39   CHECK(REAL(memset));
   48   CHECK(AddrIsAlignedByGranularity(addr));
   49   CHECK(AddrIsInMem(addr));
   79   CHECK(size);
   81   CHECK(IsAligned(end, SHADOW_GRANULARITY));

   90   CHECK(!tsd_key_inited);
   96   CHECK(tsd_key_inited);
  101   CHECK(tsd_key_inited);

   85   CHECK(frame_descr);

  378   CHECK(SHADOW_SCALE >= 3 && SHADOW_SCALE <= 7);
  380     CHECK(kMidShadowBeg > kLowShadowEnd &&
  401   CHECK(!asan_init_is_running && "ASan init calls itself!");
  574     CHECK(!SANITIZER_FUCHSIA);
  602   CHECK(t);
  608   CHECK(t);

  138     CHECK(kLowShadowBeg != kLowShadowEnd);

   28   CHECK(REAL(memset));

   47   CHECK(suppression_ctx);
   54   CHECK(suppression_ctx);
   60   CHECK(suppression_ctx);
   70   CHECK(suppression_ctx);
   85       CHECK(frames);

  227     CHECK(AddrIsInMem(stack_bottom_));
  228     CHECK(AddrIsInMem(stack_top_ - 1));
  300     CHECK(AddrIsInStack((uptr)&local));
  328     CHECK(bottom);
  356   CHECK(ptr[0] == kCurrentStackFrameMagic);
  369     CHECK(bottom);
  428   CHECK(t->context());

  183     CHECK(res != MAP_FAILED);
  333   CHECK(in_loader > 0);

   41   CHECK(t);
   46   CHECK(t);
  354   CHECK(!hwasan_init_is_running);
  552   CHECK(GetTagFromPointer(dst) == 0);
  570   CHECK(t);

  175   CHECK(tagged_ptr);
  183   CHECK(tagged_ptr);
  365   CHECK(IsAligned((uptr)ptr, alignment));

   32   CHECK(to >= from);
   37     CHECK("unable to unmap" && 0);

  238   CHECK(__hwasan_shadow_memory_dynamic_address);
  264   CHECK(GetTagFromPointer(p) == 0);
  318   CHECK(!tsd_key_inited);

   23   CHECK(IsAligned(p, kShadowAlignment));
   24   CHECK(IsAligned(size, kShadowAlignment));

   83   CHECK(id);
   85   CHECK(res.trace);
  516   CHECK(offset >= 0 && offset < static_cast<sptr>(access_size));

   63     CHECK(AddrIsInStack((uptr)&local));
   64     CHECK(MemIsApp(stack_bottom_));
   65     CHECK(MemIsApp(stack_top_ - 1));
  117       CHECK(random_buffer_);

   10   CHECK(hwasan_thread_list == nullptr);

   65   CHECK(0);
   89     CHECK(*cur && "thread not found");
  192     CHECK(IsAligned(free_space_, align));
  195     CHECK(free_space_ <= free_space_end_ && "out of thread memory");

  102   CHECK(!lsan_init_is_running);

   56   CHECK(m);
   66   CHECK(m);
  151   CHECK(IsAligned((uptr)ptr, alignment));
  248   CHECK(m);
  264   CHECK(metadata_);
  295   CHECK(m);

   96   CHECK(suppression_ctx);
  105   CHECK(!root_regions);
  159   CHECK(tag == kReachable || tag == kIndirectlyLeaked);
  338   CHECK(root_regions);
  368   CHECK(arg);
  379   CHECK(stack_id);
  396   CHECK(arg);
  482   CHECK(stack_trace_id);
  489   CHECK(arg);
  556   CHECK(param);
  557   CHECK(!param->success);
  668   CHECK(tag == kDirectlyLeaked || tag == kIndirectlyLeaked);
  699   CHECK(leaks_.size() <= kMaxLeaksConsidered);
  750   CHECK(leaks_.size() <= kMaxLeaksConsidered);
  819   CHECK(root_regions);
  830   CHECK(root_regions);

   72     CHECK(allocated < kCallocPoolSize);

  398   CHECK(!msan_init_is_running);

  124   CHECK(ms);
  176   CHECK(p);
  320   CHECK(IsAligned((uptr)ptr, alignment));

  158   CHECK(!res || (res >= dest && res <= (char *)dest + n));
  577   CHECK(MEM_IS_APP(s));

   85     CHECK(addr_is_type(start, type));
   86     CHECK(addr_is_type((start + end) / 2, type));
   87     CHECK(addr_is_type(end - 1, type));
   90       CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
   91       CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
   95       CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
   96       CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
  100       CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
  101       CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
  139     CHECK(!(map && protect));
  141       CHECK(type == MappingDesc::APP);
  226   CHECK(!tsd_key_inited);
  242   CHECK(tsd_key_inited);

   72     CHECK(isChainedOrigin());
   76     CHECK(isStackOrigin());
   80     CHECK(isHeapOrigin());
   86     CHECK(isChainedOrigin());
   98     CHECK((id & kStackIdMask) == id);
  104     CHECK(stack_id);
  105     CHECK((stack_id & kHeapIdMask) == stack_id);
  118         CHECK(depth < (1 << kDepthBits));
  132     CHECK((chained_id & kChainedIdMask) == chained_id);
  158     CHECK(isChainedOrigin());

   41   CHECK(sep);

   31   CHECK(AddrIsInStack((uptr)&local));
   46   CHECK(MEM_IS_APP(stack_bottom_));
   47   CHECK(MEM_IS_APP(stack_top_ - 1));

  183   CHECK(!h->remove_);

  225   CHECK(allocated_end_ - allocated_current_ >= (sptr)size);
  232   CHECK(IsPowerOfTwo(alignment));

  105     CHECK(PointerIsMine(p));

  156     CHECK(PointerIsMine(p));
  204     CHECK(PointerIsMine(p));
  215     CHECK(PointerIsMine(p));
  305     CHECK(IsAligned(res, kRegionSize));

  199     CHECK(PointerIsMine(p));

   37     CHECK(p);
   86     CHECK(IsPowerOfTwo(alignment));
  101     CHECK(IsAligned(map_beg, page_size_));
  107     CHECK(IsAligned(res, alignment));
  108     CHECK(IsAligned(res, page_size_));
  177       CHECK(IsAligned(reinterpret_cast<uptr>(p), page_size_));
  301     CHECK(IsAligned(p, page_size_));
  309     CHECK(IsAligned((uptr)h, page_size_));

   49     CHECK(!empty());
  192     CHECK(0);
  301         CHECK(it1_.hasNext());
  307       CHECK(it2_.hasNext());

  390   CHECK(size);
  413   CHECK(IsPowerOfTwo(x));
  696   CHECK(0 && "Invalid module arch");

  333   CHECK(h.created());
  344     CHECK(!h.created());
  345     CHECK(h->type == CommonInterceptorMetadata::CIMT_FILE);
  354   CHECK(h.exists());
 1815   CHECK(ioctl_initialized);
 3337   CHECK(endptr);
 3346   CHECK(*endptr >= nptr);

   30     CHECK(q);
  198     CHECK(p);
  207       CHECK(p);
  402     CHECK(p);
  423         CHECK(p);

  533   CHECK(desc);

   41   CHECK(name);
  110     CHECK(!initialized);
  120     CHECK(!*start);

  165       CHECK(available_nodes_.empty());
  190     CHECK(!available_nodes_.getBit(idx));
  191     CHECK(recycled_nodes_.setBit(idx));
  314     CHECK(!tmp_bv_.getBit(idx));

  166     CHECK(!dd.isHeld(&lt->dd, m->id));

   47         CHECK(base);
   71   CHECK(out < out_end - 1);

  114   CHECK(SANITIZER_LINUX);

   95   CHECK(stack_top);
   96   CHECK(stack_bottom);
  114     CHECK((uptr)&rl >= segment.start && (uptr)&rl < segment.end);

   65     CHECK(!empty());
   73     CHECK(!empty());

   61     CHECK("unable to unmap" && 0);
   85   CHECK(IsPowerOfTwo(size));
   86   CHECK(IsPowerOfTwo(alignment));
  194   CHECK(fd != kInvalidFd);
  218   CHECK(start1 <= end1);
  219   CHECK(start2 <= end2);
  347   CHECK(internal_strlen(name) < sizeof(shmname) - 10);

  122   CHECK(!StackSizeIsUnlimited());
  132   CHECK(AddressSpaceIsUnlimited());

  170     CHECK(!((precision >= 0 || left_justified) && *cur != 's'));
  199         CHECK(!have_width || left_justified);

   40   CHECK(base >= 2 && base <= 16);
   68   CHECK(!data_);

   45   CHECK(IsOneOf(*data_.current, '-', 'r'));
   48   CHECK(IsOneOf(*data_.current, '-', 'w'));
   50   CHECK(IsOneOf(*data_.current, '-', 'x'));
   52   CHECK(IsOneOf(*data_.current, 's', 'p'));

   87     CHECK((size == 0 && cache_size == 0) || cache_size != 0);
  186       CHECK(kPrefetch <= ARRAY_SIZE(b->batch));
  224       CHECK(b);

   95     CHECK(IsPowerOfTwo(size));

   80   CHECK(!was_called_once);

   35     CHECK(frames);
  135   CHECK(out_buf <= out_end);

  340     CHECK(MprotectNoAccess((uptr)guard_start_, guard_size_));

  118   CHECK(can_parse_);

   89   CHECK(start_hook_ == 0 && end_hook_ == 0);

   24   CHECK(symbolizer_);
  297   CHECK(file_line_info);
  328     CHECK(function_name);
  437   CHECK(module_name);
  464   CHECK(path_);

  132   CHECK(infd);
  133   CHECK(outfd);
  235     CHECK(garbage);
  424   CHECK(path == nullptr);

   28   CHECK(0);
   40   CHECK(status == ThreadStatusRunning ||

  152   CHECK(context);
  160   CHECK(map);

   59   CHECK(smodp);

  235   CHECK(region_kind);

  531   CHECK(0);
  566   CHECK(0);
  574   CHECK(0);
  581   CHECK(0);
  589   CHECK(0);

  507     CHECK(!(flagz & MutexFlagRecursiveUnlock));

  205   CHECK(0);
  223   CHECK(IsLoadOrder(mo));
  260   CHECK(IsStoreOrder(mo));

  272   CHECK(IsAligned((uptr)ptr, align));
  337     CHECK(0);
  346     CHECK(0);

  319         CHECK(IsAppMem(p));
  320         CHECK(IsShadowMem(s));
  322         CHECK(IsMetaMem(m));
  926     CHECK(IsShadowMem((uptr)p));
  927     CHECK(IsShadowMem((uptr)(p + size * kShadowCnt / kShadowCell - 1)));

   68     CHECK(!thr->is_freeing);
  134     CHECK(!thr->is_freeing);

  237   CHECK(thr);
  250   CHECK(thr);
  579   CHECK(!(s0.IsAtomic() && s1.IsAtomic()));

   63   CHECK(suppression_ctx);
  107   CHECK(suppression_ctx);
  126   CHECK(suppression_ctx);
  147   CHECK(suppression_ctx);

   26   CHECK(!thr->in_symbolizer);
   33   CHECK(thr->in_symbolizer);

  108         CHECK(0);
  283       CHECK(idx & kFlagSync);

  414   CHECK(suppression_ctx);
  421   CHECK(suppression_ctx);

   44   CHECK(CallerPC);
   82     CHECK(isSourceLocation());
   86     CHECK(isMemoryLocation());
   90     CHECK(isSymbolizedStack());
  192     CHECK(NumArgs != MaxArgs);
  198     CHECK(NumRanges != MaxRanges);

   23   CHECK(getType().isSignedIntegerTy());
   44   CHECK(getType().isUnsignedIntegerTy());
   63   CHECK(Val >= 0);
   71   CHECK(getType().isFloatTy());

  124     CHECK(isIntegerTy());
  130     CHECK(isFloatTy());
  152     CHECK(getType().isIntegerTy());
  160     CHECK(getType().isFloatTy());