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

References

   37 static u32 RZLog2Size(u32 rz_log) {
   37 static u32 RZLog2Size(u32 rz_log) {
   42 static u32 RZSize2Log(u32 rz_size) {
   42 static u32 RZSize2Log(u32 rz_size) {
   46   u32 res = Log2(rz_size) - 4;
   74   u32 chunk_state       : 8;  // Must be first.
   75   u32 alloc_tid         : 24;
   77   u32 free_tid          : 24;
   78   u32 from_memalign     : 1;
   79   u32 alloc_type        : 2;
   80   u32 rz_log            : 3;
   81   u32 lsan_tag          : 2;
   86   u32 user_requested_size : 29;
   89   u32 user_requested_alignment_log : 3;
   90   u32 alloc_context_id;
   95   u32 free_context_id;
  346     u32 rz_log =
  354     u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
  355     u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
  486     u32 alloc_tid = t ? t->tid() : 0;
  810 u32 AsanChunkView::UserRequestedAlignment() const {
  819 static StackTrace GetStackTraceFromId(u32 id) {
  826 u32 AsanChunkView::GetAllocStackId() const { return chunk_->alloc_context_id; }
  827 u32 AsanChunkView::GetFreeStackId() const { return chunk_->free_context_id; }
 1053 u32 LsanMetadata::stack_trace_id() const {

   34   u32 quarantine_size_mb;
   35   u32 thread_local_quarantine_size_kb;
   60   u32 UserRequestedAlignment() const;  // Originally requested alignment.
   64   u32 GetAllocStackId() const;
   65   u32 GetFreeStackId() const;

   49 uptr AsanGetStack(uptr addr, uptr *trace, u32 size, u32 *thread_id,
   49 uptr AsanGetStack(uptr addr, uptr *trace, u32 size, u32 *thread_id,
  131 uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
  136 uptr __asan_get_free_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {

   26 AsanThreadIdAndName::AsanThreadIdAndName(u32 tid) {
   36 void AsanThreadIdAndName::Init(u32 tid, const char *tname) {
  174 static StackTrace GetStackTraceFromId(u32 id) {

   32   explicit AsanThreadIdAndName(u32 tid);
   38   void Init(u32 tid, const char *tname);
  115   u32 user_requested_alignment : 12;
  116   u32 access_type : 2;
  117   u32 alloc_type : 2;
  124   u32 alloc_stack_id;
  125   u32 free_stack_id;
  154   u32 reg_sites[kMaxGlobals];

  386 ErrorGeneric::ErrorGeneric(u32 tid, uptr pc_, uptr bp_, uptr sp_, uptr addr,

   29   u32 tid;
   32   explicit ErrorBase(u32 tid_) : tid(tid_) {}
   33   ErrorBase(u32 tid_, int initial_score, const char *reason) : tid(tid_) {
   43   ErrorDeadlySignal(u32 tid, const SignalContext &sig)
   72   ErrorDoubleFree(u32 tid, BufferedStackTrace *stack, uptr addr)
   88   ErrorNewDeleteTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr,
  104   ErrorFreeNotMalloced(u32 tid, BufferedStackTrace *stack, uptr addr)
  117   ErrorAllocTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr,
  132   ErrorMallocUsableSizeNotOwned(u32 tid, BufferedStackTrace *stack_, uptr addr)
  144   ErrorSanitizerGetAllocatedSizeNotOwned(u32 tid, BufferedStackTrace *stack_,
  158   ErrorCallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr count_,
  173   ErrorReallocArrayOverflow(u32 tid, BufferedStackTrace *stack_, uptr count_,
  187   ErrorPvallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr size_)
  199   ErrorInvalidAllocationAlignment(u32 tid, BufferedStackTrace *stack_,
  213   ErrorInvalidAlignedAllocAlignment(u32 tid, BufferedStackTrace *stack_,
  227   ErrorInvalidPosixMemalignAlignment(u32 tid, BufferedStackTrace *stack_,
  242   ErrorAllocationSizeTooBig(u32 tid, BufferedStackTrace *stack_,
  256   ErrorRssLimitExceeded(u32 tid, BufferedStackTrace *stack_)
  267   ErrorOutOfMemory(u32 tid, BufferedStackTrace *stack_, uptr requested_size_)
  282   ErrorStringFunctionMemoryRangesOverlap(u32 tid, BufferedStackTrace *stack_,
  306   ErrorStringFunctionSizeOverflow(u32 tid, BufferedStackTrace *stack_,
  321   ErrorBadParamsToAnnotateContiguousContainer(u32 tid,
  336   u32 stack_id1, stack_id2;
  339   ErrorODRViolation(u32 tid, const __asan_global *g1, u32 stack_id1_,
  339   ErrorODRViolation(u32 tid, const __asan_global *g1, u32 stack_id1_,
  340                     const __asan_global *g2, u32 stack_id2_)
  355   ErrorInvalidPointerPair(u32 tid, uptr pc_, uptr bp_, uptr sp_, uptr p1,
  375   ErrorGeneric(u32 tid, uptr addr, uptr pc_, uptr bp_, uptr sp_, bool is_write_,

  182     const u32 kDefaultThreadLocalQuarantineSizeKb =

   53   u32 stack_id;
   97 static u32 FindRegistrationSite(const Global *g) {
  108 int GetGlobalsForAddress(uptr addr, Global *globals, u32 *reg_sites,
  361   u32 stack_id = StackDepotPut(stack);

  233     u32 current_tid = GetCurrentTidOrInvalid();

  153                               u32 *thread_id);
  157                              u32 *thread_id);
  164                            uptr addr, int is_write, uptr access_size, u32 exp);
  215   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load1(uptr p, u32 exp);
  216   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load2(uptr p, u32 exp);
  217   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load4(uptr p, u32 exp);
  218   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load8(uptr p, u32 exp);
  219   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_load16(uptr p, u32 exp);
  220   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store1(uptr p, u32 exp);
  221   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store2(uptr p, u32 exp);
  222   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store4(uptr p, u32 exp);
  223   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store8(uptr p, u32 exp);
  224   SANITIZER_INTERFACE_ATTRIBUTE void __asan_exp_store16(uptr p, u32 exp);
  226                                                       u32 exp);
  228                                                        u32 exp);

   26   u32 id;
   39       u32 id = cv.GetAllocStackId();
   85   void Insert(u32 id, uptr size) {

  236 u32 __sanitizer_unaligned_load32(const uu32 *p) {
  254 void __sanitizer_unaligned_store32(uu32 *p, u32 x) {

  351 void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
  352                         const __asan_global *g2, u32 stack_id2) {
  457                         uptr access_size, u32 exp, bool fatal) {
  482                          uptr access_size, u32 exp) {

   33 int GetGlobalsForAddress(uptr addr, __asan_global *globals, u32 *reg_sites,
   50                         uptr access_size, u32 exp, bool fatal);
   87 void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
   88                         const __asan_global *g2, u32 stack_id2);

  204 void __asan_exp_loadN(uptr addr, uptr size, u32 exp) {
  231 void __asan_exp_storeN(uptr addr, uptr size, u32 exp) {

   21 void SetMallocContextSize(u32 size) {
   25 u32 GetMallocContextSize() {
   57     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {

   24 static const u32 kDefaultMallocContextSize = 30;
   26 void SetMallocContextSize(u32 size);
   27 u32 GetMallocContextSize();

   49 static ThreadContextBase *GetAsanThreadContext(u32 tid) {
   70 AsanThreadContext *GetThreadContextByTidLocked(u32 tid) {
   78                                u32 parent_tid, StackTrace *stack,
  437 u32 GetCurrentTidOrInvalid() {

   31 const u32 kInvalidTid = 0xffffff;  // Must fit into 24 bits.
   32 const u32 kMaxNumberOfThreads = (1 << 22);  // 4M
   46   u32 stack_id;
   65                             u32 parent_tid, StackTrace *stack, bool detached);
   81   u32 tid() { return context_->tid; }
  177 AsanThreadContext *GetThreadContextByTidLocked(u32 tid);
  182 u32 GetCurrentTidOrInvalid();

   24                                                  u32 max_depth) {

  201     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
  221   u32 info;
  449 u32 __sanitizer_unaligned_load32(const uu32 *p) {
  458 void __sanitizer_unaligned_store32(uu32 *p, u32 x) {

  112 u32 ChainOrigin(u32 id, StackTrace *stack);
  112 u32 ChainOrigin(u32 id, StackTrace *stack);

   66 u32 HwasanChunkView::GetAllocStackId() const {
  195   u32 free_context_id = StackDepotPut(*stack);
  196   u32 alloc_context_id = meta->alloc_context_id;

   31   u32 requested_size : 31;  // sizes are < 2G.
   32   u32 right_aligned  : 1;
   33   u32 alloc_context_id;
   73   u32 GetAllocStackId() const;
   88   u32  alloc_context_id;
   89   u32  free_context_id;
   90   u32  requested_size;

  142 u32 __sanitizer_unaligned_load32(const uu32 *p);
  151 void __sanitizer_unaligned_store32(uu32 *p, u32 x);

   18 static u32 malloc_hash(StackTrace *stack, uptr orig_size) {

   82 static StackTrace GetStackTraceFromId(u32 id) {

   15 static u32 RandomSeed() {
   16   u32 seed;
  102 static u32 xorshift(u32 state) {
  102 static u32 xorshift(u32 state) {

   82   u32 random_state_;
   83   u32 random_buffer_;
   95   u32 tagging_disabled_;  // if non-zero, malloc uses zero tag in this thread.

   36     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
  117   u32 tid = ThreadCreate(0, 0, true);

  283 u32 LsanMetadata::stack_trace_id() const {

   49   u32 stack_trace_id;

  378 static uptr GetCallerPC(u32 stack_id, StackDepotReverseMap *map) {
  401     u32 stack_id = m.stack_trace_id();
  481 static void PrintStackTraceById(u32 stack_trace_id) {
  495     u32 resolution = flags()->resolution;
  496     u32 stack_trace_id = 0;
  647 static Suppression *GetSuppressionForStack(u32 stack_trace_id) {
  666 void LeakReport::AddLeakedChunk(uptr chunk, u32 stack_trace_id,
  741   u32 leak_id = leaks_[index].id;

   65 const u32 kInvalidTid = (u32) -1;
   83   u32 id;
   86   u32 stack_trace_id;
   92   u32 leak_id;
  101   void AddLeakedChunk(uptr chunk, u32 stack_trace_id, uptr leaked_size,
  112   u32 next_id_ = 0;
  249   u32 stack_trace_id() const;

   21 static THREADLOCAL u32 current_thread_tid = kInvalidTid;
   22 u32 GetCurrentThread() { return current_thread_tid; }
   23 void SetCurrentThread(u32 tid) { current_thread_tid = tid; }

   27 static ThreadContextBase *CreateThreadContext(u32 tid) {
   74 u32 ThreadCreate(u32 parent_tid, uptr user_id, bool detached) {
   74 u32 ThreadCreate(u32 parent_tid, uptr user_id, bool detached) {
   79 void ThreadStart(u32 tid, tid_t os_id, ThreadType thread_type) {
  113 u32 ThreadTid(uptr uid) {
  117 void ThreadJoin(u32 tid) {

   47 void ThreadStart(u32 tid, tid_t os_id,
   50 u32 ThreadCreate(u32 tid, uptr uid, bool detached);
   50 u32 ThreadCreate(u32 tid, uptr uid, bool detached);
   51 void ThreadJoin(u32 tid);
   52 u32 ThreadTid(uptr uid);
   54 u32 GetCurrentThread();
   55 void SetCurrentThread(u32 tid);

   49 THREADLOCAL u32 __msan_param_origin_tls[kMsanParamTlsSize / sizeof(u32)];
   49 THREADLOCAL u32 __msan_param_origin_tls[kMsanParamTlsSize / sizeof(u32)];
   55 THREADLOCAL u32 __msan_retval_origin_tls;
   62 THREADLOCAL u32 __msan_va_arg_origin_tls[kMsanParamTlsSize / sizeof(u32)];
   62 THREADLOCAL u32 __msan_va_arg_origin_tls[kMsanParamTlsSize / sizeof(u32)];
   68 THREADLOCAL u32 __msan_origin_tls;
  226 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin) {
  238   u32 report_origin =
  283 const char *GetStackOriginDescr(u32 id, uptr *pc) {
  289 u32 ChainOrigin(u32 id, StackTrace *stack) {
  289 u32 ChainOrigin(u32 id, StackTrace *stack) {
  303     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {
  549 void __msan_set_origin(const void *a, uptr size, u32 origin) {
  561   static const u32 dash = '-';
  562   static const u32 first_timer =
  564   u32 *id_ptr = (u32*)descr;
  566   u32 id = *id_ptr;
  568     u32 idx = atomic_fetch_add(&NumStackOriginDescrs, 1, memory_order_relaxed);
  589 u32 __msan_chain_origin(u32 id) {
  589 u32 __msan_chain_origin(u32 id) {
  596 u32 __msan_get_origin(const void *a) {
  604 int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id) {
  604 int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id) {
  611 u32 __msan_get_umr_origin() {
  621 u32 __sanitizer_unaligned_load32(const uu32 *p) {
  641 void __sanitizer_unaligned_store32(uu32 *p, u32 x) {
  642   u32 s = *(uu32 *)&__msan_param_tls[1];

  302 const char *GetStackOriginDescr(u32 id, uptr *pc);
  314 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin);
  322 u32 ChainOrigin(u32 id, StackTrace *stack);
  322 u32 ChainOrigin(u32 id, StackTrace *stack);

   19   u32 here_id;
   20   u32 prev_id;
   25   u32 id;
   26   u32 here_id;
   27   u32 prev_id;
   31   bool eq(u32 hash, const args_type &args) const {
   52   static u32 hash(const args_type &args) {
   53     const u32 m = 0x5bd1e995;
   54     const u32 seed = 0x9747b28c;
   55     const u32 r = 24;
   56     u32 h = seed;
   57     u32 k = args.here_id;
   77   void store(const args_type &args, u32 other_hash) {
   92     u32 id() { return node_->id; }
  108 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id) {
  108 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id) {
  108 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id) {
  117 u32 ChainedOriginDepotGet(u32 id, u32 *other) {
  117 u32 ChainedOriginDepotGet(u32 id, u32 *other) {
  117 u32 ChainedOriginDepotGet(u32 id, u32 *other) {

   19 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id);
   19 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id);
   19 bool ChainedOriginDepotPut(u32 here_id, u32 prev_id, u32 *new_id);
   21 u32 ChainedOriginDepotGet(u32 id, u32 *other);
   21 u32 ChainedOriginDepotGet(u32 id, u32 *other);
   21 u32 ChainedOriginDepotGet(u32 id, u32 *other);

   50 void __msan_maybe_warning_1(u8 s, u32 o);
   52 void __msan_maybe_warning_2(u16 s, u32 o);
   54 void __msan_maybe_warning_4(u32 s, u32 o);
   54 void __msan_maybe_warning_4(u32 s, u32 o);
   56 void __msan_maybe_warning_8(u64 s, u32 o);
   59 void __msan_maybe_store_origin_1(u8 s, void *p, u32 o);
   61 void __msan_maybe_store_origin_2(u16 s, void *p, u32 o);
   63 void __msan_maybe_store_origin_4(u32 s, void *p, u32 o);
   63 void __msan_maybe_store_origin_4(u32 s, void *p, u32 o);
   65 void __msan_maybe_store_origin_8(u64 s, void *p, u32 o);
  100 void __msan_set_origin(const void *a, uptr size, u32 origin);
  106 u32 __msan_chain_origin(u32 id);
  106 u32 __msan_chain_origin(u32 id);
  108 u32 __msan_get_origin(const void *a);
  114 int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id);
  114 int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id);
  141 u32 __msan_get_umr_origin();
  159 u32 __sanitizer_unaligned_load32(const uu32 *p);
  168 void __sanitizer_unaligned_store32(uu32 *p, u32 x);

   56   static bool isValidId(u32 id) { return id != 0 && id != (u32)-1; }
   58   u32 raw_id() const { return raw_id_; }
   71   u32 getChainedId() const {
   75   u32 getStackId() const {
   79   u32 getHeapId() const {
   87     u32 prev_id;
   88     u32 stack_id = ChainedOriginDepotGet(getChainedId(), &prev_id);
   97   static Origin CreateStackOrigin(u32 id) {
  103     u32 stack_id = StackDepotPut(*stack);
  130     u32 chained_id;
  140   static Origin FromRawId(u32 id) {
  149   static const u32 kChainedIdMask = ((u32)-1) >> (32 - kDepthShift);
  150   static const u32 kStackIdMask = ((u32)-1) >> (32 - kDepthShift);
  151   static const u32 kHeapIdMask = ((u32)-1) >> (32 - kHeapShift);
  153   u32 raw_id_;
  155   explicit Origin(u32 raw_id) : raw_id_(raw_id) {}

   25 u32 GetOriginIfPoisoned(uptr addr, uptr size) {
   33                          u32 src_origin) {
   50     u32 o = GetOriginIfPoisoned((uptr)src, d - beg);
   64     u32 o = GetOriginIfPoisoned((uptr)src + (end - d), (d + size) - end);
   76       u32 *src = (u32 *)MEM_TO_ORIGIN(s);
   77       u32 *src_s = (u32 *)MEM_TO_SHADOW(s);
   78       u32 *src_end = (u32 *)MEM_TO_ORIGIN(s + (end - beg));
   79       u32 *dst = (u32 *)MEM_TO_ORIGIN(beg);
   80       u32 src_o = 0;
   81       u32 dst_o = 0;
  147 void SetOrigin(const void *dst, uptr size, u32 origin) {

   21 u32 GetOriginIfPoisoned(uptr addr, uptr size);
   26 void SetOriginIfPoisoned(uptr addr, uptr src_shadow, uptr size, u32 src_origin);
   51 void SetOrigin(const void *dst, uptr size, u32 origin);

   59 static void DescribeOrigin(u32 id) {
   98 void ReportUMR(StackTrace *stack, u32 origin) {
  153   int insert(u32 o) {
  163   u32 get(int id) { return origins_[id]; }
  179   u32 origins_[kMaxSize_];
  229         u32 o = *(u32 *)SHADOW_TO_ORIGIN(s - 3);
  255     u32 o = origin_set.get(i);

   23 void ReportUMR(StackTrace *stack, u32 origin);

   55 INLINE u32 Rand(u32 *state) {  // ANSI C linear congruential PRNG.
   55 INLINE u32 Rand(u32 *state) {  // ANSI C linear congruential PRNG.
   59 INLINE u32 RandN(u32 *state, u32 n) { return Rand(state) % n; }  // [0, n)
   59 INLINE u32 RandN(u32 *state, u32 n) { return Rand(state) % n; }  // [0, n)
   59 INLINE u32 RandN(u32 *state, u32 n) { return Rand(state) % n; }  // [0, n)
   62 INLINE void RandomShuffle(T *a, u32 n, u32 *rand_state) {
   62 INLINE void RandomShuffle(T *a, u32 n, u32 *rand_state) {
   64   u32 state = *rand_state;
   65   for (u32 i = n - 1; i > 0; i--)

   78     u32 count;
   79     u32 max_count;

  160     u32 offset = mem - beg;
  208     u32 offset = mem - beg;
  209     u32 n = offset / (u32)size;  // 32-bit division
  281     u32 rand_state;

   63   typedef u32 CompactPtrT;
  604     u32 rand_state;  // Seed for random shuffle, used if kRandomShuffleChunks.

   45   typedef u32 Type;

   27 u32 NumberOfCPUsCached;
   58 typedef bool U32ComparisonFunction(const u32 &a, const u32 &b);
   58 typedef bool U32ComparisonFunction(const u32 &a, const u32 &b);

  235 u32 GetUid();
  306 void HandleDeadlySignal(void *siginfo, void *context, u32 tid,
  313 void ReportDeadlySignal(const SignalContext &sig, u32 tid,
  972 u32 GetNumberOfCPUs();
  973 extern u32 NumberOfCPUsCached;
  974 INLINE u32 GetNumberOfCPUsCached() {

 2179 int real_clock_gettime(u32 clk_id, void *tp) {

  118   void InitTracePcGuard(u32* start, u32* end) {
  118   void InitTracePcGuard(u32* start, u32* end) {
  123     u32 i = pc_vector.size();
  124     for (u32* p = start; p < end; p++) *p = ++i;
  128   void TracePcGuard(u32* guard, uptr pc) {
  129     u32 idx = *guard;

   59   bool addLock(uptr lock_id, uptr current_epoch, u32 stk) {
   69     u32 lock_id_short = static_cast<u32>(lock_id);
   99   u32 findLockContext(uptr lock_id) {
  120     u32 lock;
  121     u32 stk;
  208   u32 findLockContext(DeadlockDetectorTLS<BV> *dtls, uptr node) {
  213   void onLockAfter(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
  240   uptr addEdges(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk,
  258   bool findEdge(uptr from_node, uptr to_node, u32 *stk_from, u32 *stk_to,
  258   bool findEdge(uptr from_node, uptr to_node, u32 *stk_from, u32 *stk_to,
  275   bool onLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
  288   bool onTryLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk = 0) {
  298   bool onFirstLock(DeadlockDetectorTLS<BV> *dtls, uptr node, u32 stk = 0) {
  334   bool onLockFast(DeadlockDetectorTLS<BV> *dtls, uptr node, u32 stk = 0) {
  393     u32 stk_from;
  394     u32 stk_to;

  139     u32 stk_from = -1U, stk_to = -1U;
  154   u32 stk = 0;

   37   u32  stk;  // creation stack
   59     u32 stk[2];  // stack ids for the edge
   67   virtual u32 Unwind() { return 0; }

   19   static const u32 m = 0x5bd1e995;
   20   static const u32 seed = 0x9747b28c;
   21   static const u32 r = 24;
   22   u32 h;
   25   explicit MurMur2HashBuilder(u32 init = 0) { h = seed ^ init; }
   26   void add(u32 k) {
   33   u32 get() {
   34     u32 x = h;

   53   SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov(__sanitizer::u32 *guard);
  106   void __sanitizer_cov_trace_pc_guard(__sanitizer::u32*);
  108   void __sanitizer_cov_trace_pc_guard_init(__sanitizer::u32*,
  109                                            __sanitizer::u32*);

  259 typedef ALIGNED(1) u32 uu32;

  204 uptr internal_open(const char *filename, int flags, u32 mode) {
  666   u32 v = atomic_exchange(m, MtxUnlocked, memory_order_release);

  653 u32 GetNumberOfCPUs() {
  789 int real_clock_gettime(u32 clk_id, void *tp);

  108     u32 cmp = kUnlocked;
  116     u32 prev = atomic_fetch_sub(&state_, kWriteLock, memory_order_release);
  122     u32 prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
  129     u32 prev = atomic_fetch_sub(&state_, kReadLock, memory_order_release);
  154       u32 cmp = atomic_load(&state_, memory_order_relaxed);
  168       u32 prev = atomic_load(&state_, memory_order_acquire);

  136   u32 aio_key_or_aio_reserved1;  // Simply crazy.
  137   u32 aio_reserved1_or_aio_key;  // Luckily, we don't need these.
  140   u32 aio_fildes;

   34 uptr internal_open(const char *filename, int flags, u32 mode);

   51 u32 GetUid() {

   23   u32 id;
   25   u32 size;
   26   u32 tag;
   29   static const u32 kTabSizeLog = SANITIZER_ANDROID ? 16 : 20;
   32   static const u32 kUseCountBits = kTabSizeLog;
   33   static const u32 kMaxUseCount = 1 << kUseCountBits;
   34   static const u32 kUseCountMask = (1 << kUseCountBits) - 1;
   35   static const u32 kHashMask = ~kUseCountMask;
   38   bool eq(u32 hash, const args_type &args) const {
   39     u32 hash_bits =
   52   static u32 hash(const args_type &args) {
   60   void store(const args_type &args, u32 hash) {
   76 u32 StackDepotHandle::id() { return node_->id; }
   82   u32 prev =
   97 u32 StackDepotPut(StackTrace stack) {
  106 StackTrace StackDepotGet(u32 id) {
  138 StackTrace StackDepotReverseMap::Get(u32 id) {

   29   u32 id();
   37 u32 StackDepotPut(StackTrace stack);
   40 StackTrace StackDepotGet(u32 id);
   52   StackTrace Get(u32 id);
   56     u32 id;

   31   args_type Get(u32 id);
   39   static Node *find(Node *s, args_type args, u32 hash);
   45   static const int kPartShift = sizeof(u32) * 8 - kPartBits - kReservedBits;
   62                                                              u32 hash) {
  118   u32 id = atomic_fetch_add(&seq[part], 1, memory_order_relaxed) + 1;
  137 StackDepotBase<Node, kReservedBits, kTabSizeLog>::Get(u32 id) {

   71                                     uptr stack_bottom, u32 max_depth) {

   21 static const u32 kStackTraceMax = 256;
   44   u32 size;
   45   u32 tag;
   53   StackTrace(const uptr *trace, u32 size) : trace(trace), size(size), tag(0) {}
   54   StackTrace(const uptr *trace, u32 size, u32 tag)
   54   StackTrace(const uptr *trace, u32 size, u32 tag)
  106               u32 max_depth = kStackTraceMax) {
  118   void Unwind(u32 max_depth, uptr pc, uptr bp, void *context, uptr stack_top,
  129                   u32 max_depth);
  133                   u32 max_depth);
  134   void UnwindSlow(uptr pc, u32 max_depth);
  135   void UnwindSlow(uptr pc, void *context, u32 max_depth);

   57 void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,

  170 static void ReportStackOverflowImpl(const SignalContext &sig, u32 tid,
  188 static void ReportDeadlySignalImpl(const SignalContext &sig, u32 tid,
  230 void ReportDeadlySignal(const SignalContext &sig, u32 tid,
  239 void HandleDeadlySignal(void *siginfo, void *context, u32 tid,

   18 ThreadContextBase::ThreadContextBase(u32 tid)
   82                                    bool _detached, u32 _parent_tid, void *arg) {
  102 const u32 ThreadRegistry::kUnknownTid = ~0U;
  104 ThreadRegistry::ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
  105                                u32 thread_quarantine_size, u32 max_reuse)
  105                                u32 thread_quarantine_size, u32 max_reuse)
  135 u32 ThreadRegistry::CreateThread(uptr user_id, bool detached, u32 parent_tid,
  135 u32 ThreadRegistry::CreateThread(uptr user_id, bool detached, u32 parent_tid,
  138   u32 tid = kUnknownTid;
  174   for (u32 tid = 0; tid < n_contexts_; tid++) {
  182 u32 ThreadRegistry::FindThread(FindThreadCallback cb, void *arg) {
  184   for (u32 tid = 0; tid < n_contexts_; tid++) {
  195   for (u32 tid = 0; tid < n_contexts_; tid++) {
  214 void ThreadRegistry::SetThreadName(u32 tid, const char *name) {
  226   for (u32 tid = 0; tid < n_contexts_; tid++) {
  236 void ThreadRegistry::DetachThread(u32 tid, void *arg) {
  254 void ThreadRegistry::JoinThread(u32 tid, void *arg) {
  281 void ThreadRegistry::FinishThread(u32 tid) {
  305 void ThreadRegistry::StartThread(u32 tid, tid_t os_id, ThreadType thread_type,
  340 void ThreadRegistry::SetThreadUserId(u32 tid, uptr user_id) {

   41   explicit ThreadContextBase(u32 tid);
   44   const u32 tid;  // Thread ID. Main thread should have tid = 0.
   46   u32 reuse_count;  // Number of times this tid was reused.
   55   u32 parent_tid;
   67                   u32 _parent_tid, void *arg);
   85 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
   89   static const u32 kUnknownTid;
   91   ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
   92                  u32 thread_quarantine_size, u32 max_reuse = 0);
   92                  u32 thread_quarantine_size, u32 max_reuse = 0);
  102   ThreadContextBase *GetThreadLocked(u32 tid) {
  107   u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
  107   u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
  117   u32 FindThread(FindThreadCallback cb, void *arg);
  124   void SetThreadName(u32 tid, const char *name);
  126   void DetachThread(u32 tid, void *arg);
  127   void JoinThread(u32 tid, void *arg);
  128   void FinishThread(u32 tid);
  129   void StartThread(u32 tid, tid_t os_id, ThreadType thread_type, void *arg);
  130   void SetThreadUserId(u32 tid, uptr user_id);
  134   const u32 max_threads_;
  135   const u32 thread_quarantine_size_;
  136   const u32 max_reuse_;
  140   u32 n_contexts_;      // Number of created thread contexts,

   75   u32 max_depth;
  126 void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
  151 void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {

   40 static u32 Cookie;
   46 INLINE u32 computeCRC32(u32 Crc, uptr Value, uptr *Array, uptr ArraySize) {
   46 INLINE u32 computeCRC32(u32 Crc, uptr Value, uptr *Array, uptr ArraySize) {
  121     const u32 Crc = computeCRC32(Cookie, reinterpret_cast<uptr>(Ptr),
  233   u32 QuarantineChunksUpToSize;

  185   u32 NumberOfAllocs;
  186   u32 NumberOfFrees;

   19 u32 computeHardwareCRC32(u32 Crc, uptr Data) {
   19 u32 computeHardwareCRC32(u32 Crc, uptr Data) {

   42 static const u32 CRC32Table[] = {
   88 INLINE u32 computeSoftwareCRC32(u32 Crc, uptr Data) {
   88 INLINE u32 computeSoftwareCRC32(u32 Crc, uptr Data) {
   96 SANITIZER_WEAK_ATTRIBUTE u32 computeHardwareCRC32(u32 Crc, uptr Data);
   96 SANITIZER_WEAK_ATTRIBUTE u32 computeHardwareCRC32(u32 Crc, uptr Data);

   66   u32 Eax, Ebx, Ecx, Edx;

   70     for (u32 i = 0; i != smod->size; ++i) {

   32   u32 size;

   21 static u32 CurrentStackTrace(Thread *thr, uptr skip) {
   31 static void PrintStackTrace(Thread *thr, u32 stk) {
   63 u32 Callback::Unwind() {

   37   u32 Unwind() override;

   90 static void UnrefClockBlock(ClockCache *c, u32 idx, uptr blocks) {
   93   u32 v = atomic_load(ref, memory_order_acquire);
  422     u32 idx = ctx->clock_alloc.Alloc(c);
  436     u32 idx = ctx->clock_alloc.Alloc(c);
  460   u32 v = atomic_load(ref, memory_order_acquire);
  520   u32 idx = get_block(block);
  535 ALWAYS_INLINE u32 SyncClock::get_block(uptr bi) const {
  541 ALWAYS_INLINE void SyncClock::append_block(u32 idx) {
  580     u32 idx = parent_->get_block(block_);

  108   u32 tab_idx_;
  118   u32 get_block(uptr bi) const;
  119   void append_block(u32 idx);
  158   u32 cached_idx_;

   50   static const uptr kTableSize = kSize / sizeof(u32);
   56     u32       table[kTableSize];
  178   u32  stk;

   29   typedef u32 IndexT;

   30   u32 creation_stack;
  143 bool FdLocation(uptr addr, int *fd, int *tid, u32 *stack) {

   56 bool FdLocation(uptr addr, int *fd, int *tid, u32 *stack);

   22 void IgnoreSet::Add(u32 stack_id) {
   40 u32 IgnoreSet::At(uptr i) const {

   25   void Add(u32 stack_id);
   28   u32 At(uptr i) const;
   32   u32 stacks_[kMaxSize];

  863     u32 cmp = atomic_load(g, memory_order_acquire);
 1223     u32 flagz = 0;
 1439   u32 v = atomic_load(a, memory_order_acquire);
 2830 void __tsan_testonly_barrier_init(u64 *barrier, u32 count) {

   23 typedef u32 uint32_t;
   99 u32 __sanitizer_unaligned_load32(const uu32 *addr) {
  117 void __sanitizer_unaligned_store32(uu32 *addr, u32 v) {

  838 u32 *MemToMetaImpl(uptr x) {
  855 u32 *MemToMeta(uptr x) {

   97   u32 parent_tid;

   69 static ThreadContextBase *CreateThreadContext(u32 tid) {
   91 static const u32 kThreadQuarantineSize = 16;
  541 u32 CurrentStackId(ThreadState *thr, uptr pc) {
  554   u32 id = StackDepotPut(

  440   u32 last_sleep_stack_id;
  485   u32 creation_stack_id;
  597   void AddSleep(u32 stack_id);
  711 u32 CurrentStackId(ThreadState *thr, uptr pc);
  712 ReportStack *SymbolizeStackId(u32 stack_id);
  794 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  795 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  796 void MutexPreLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  797 void MutexPostLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0,
  799 int  MutexUnlock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  800 void MutexPreReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  801 void MutexPostReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);

   38   u32 Unwind() override { return CurrentStackId(thr, pc); }
   64 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
   80 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  142 void MutexPreLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  158 void MutexPostLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz, int rec) {
  213 int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  256 void MutexPreReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  268 void MutexPostReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  526       u32 stk = r->loop[i].stk[j];

  107 ReportStack *SymbolizeStackId(u32 stack_id) {
  316   u32 creat_stack = 0;
  365 void ScopedReportBase::AddSleep(u32 stack_id) {

  234   u32 parent_tid = thr ? thr->tid : kInvalidTid;  // No parent for GCD workers.

   46   for (u32 i = 0; i < (size >> 1); i++)
   54     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {

   62   u32 idx = block_alloc_.Alloc(&thr->proc()->block_cache);
   68   u32 *meta = MemToMeta(p);
   84   u32 *meta = MemToMeta(p);
   85   u32 *end = MemToMeta(p + sz);
   89     u32 idx = *meta;
  103         u32 next = s->next;
  183   u32 *meta = MemToMeta(p);
  184   u32 idx = *meta;
  207   u32 *meta = MemToMeta(addr);
  208   u32 idx0 = *meta;
  209   u32 myidx = 0;
  212     u32 idx = idx0;
  264   u32 *src_meta = MemToMeta(src);
  265   u32 *dst_meta = MemToMeta(dst);
  266   u32 *src_meta_end = MemToMeta(src + sz);
  276     u32 idx = *src_meta;

   58   u32 creation_stack_id;
   63   u32 next;  // in MetaMap
   86   bool IsFlagSet(u32 f) const {
   90   void SetFlags(u32 f) {
   94   void UpdateFlags(u32 flagz) {
   98     u32 current = atomic_load_relaxed(&flags);
  130   static const u32 kFlagMask  = 3u << 30;
  131   static const u32 kFlagBlock = 1u << 30;
  132   static const u32 kFlagSync  = 2u << 30;

   20     uptr pc, uptr bp, void *context, bool request_fast, u32 max_depth) {

   46   u32 Line;
   47   u32 Column;
   60     u32 OldColumn = __sanitizer::atomic_exchange(

   54   u32 BlockSize;
   55   u32 BlockNum;
  248   u32 I = 0;
  292     u32 CumulativeSizes = 0;