Lines Matching defs:mutex
211 // expected-warning{{releasing mutex 'sls_mu' that was not held}}
217 // expected-warning{{acquiring mutex 'sls_mu' that is already held}}
222 sls_mu.Lock(); // expected-note {{mutex acquired here}}
223 } // expected-warning{{mutex 'sls_mu' is still held at the end of function}}
227 sls_mu.Lock(); // expected-note{{mutex acquired here}}
229 sls_mu2.Lock(); // expected-note{{mutex acquired here}}
230 } // expected-warning{{mutex 'sls_mu' is not held on every path through here}} \
231 // expected-warning{{mutex 'sls_mu2' is not held on every path through here}}
234 sls_mu.Lock(); // expected-note {{mutex acquired here}}
237 } // expected-warning{{mutex 'sls_mu' is not held on every path through here}}
241 sls_mu.Lock(); // expected-note {{mutex acquired here}}
250 expected-warning{{mutex 'sls_mu' is not held on every path through here}}\
251 expected-warning{{releasing mutex 'sls_mu' that was not held}}
261 expected-warning{{expecting mutex 'sls_mu' to be held at start of each loop}}
264 sls_mu.Lock(); // expected-note {{mutex acquired here}}
270 sls_mu.Lock(); // expected-note{{mutex acquired here}}
273 sls_mu.Unlock(); // expected-warning{{expecting mutex 'sls_mu' to be held at start of each loop}}
280 // expected-warning{{expecting mutex 'sls_mu' to be held at start of each loop}} \
281 // expected-note{{mutex acquired here}}
287 sls_mu.Lock(); // expected-note 2{{mutex acquired here}}
288 while(getBool()) { // expected-warning{{expecting mutex 'sls_mu' to be held at start of each loop}}
291 } // expected-warning{{mutex 'sls_mu' is still held at the end of function}}
295 expected-warning{{expecting mutex 'sls_mu' to be held at start of each loop}}
296 sls_mu.Lock(); // expected-note {{mutex acquired here}}
299 // expected-warning{{releasing mutex 'sls_mu' that was not held}}
303 sls_mu.Lock(); // expected-note {{mutex acquired here}}
308 break; // expected-warning{{mutex 'sls_mu' is not held on every path through here}}
337 // expected-warning{{releasing mutex 'aa_mu' that was not held}}
343 // expected-warning{{acquiring mutex 'aa_mu' that is already held}}
348 glock.globalLock(); // expected-note{{mutex acquired here}}
349 } // expected-warning{{mutex 'aa_mu' is still held at the end of function}}
361 wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
362 } // EXPECTED-WARNING {{mutex 'wmu' is still held at the end of function}}
364 wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
365 } // EXPECTED-WARNING {{mutex 'wmu' is still held at the end of function}}
367 wmu.Lock(); // expected-note {{mutex acquired here}}
368 } // expected-warning {{mutex 'wmu' is still held at the end of function}}
370 wmu.Lock(); // expected-note {{mutex acquired here}}
372 } // expected-warning {{mutex 'wmu' is still held at the end of function}}
389 // expected-warning {{writing variable 'pgb_field' requires holding mutex 'sls_mu2' exclusively}}
390 *pgb_field = x; // expected-warning {{reading variable 'pgb_field' requires holding mutex 'sls_mu2'}} \
391 // expected-warning {{writing the value pointed to by 'pgb_field' requires holding mutex 'sls_mu' exclusively}}
392 x = *pgb_field; // expected-warning {{reading variable 'pgb_field' requires holding mutex 'sls_mu2'}} \
393 // expected-warning {{reading the value pointed to by 'pgb_field' requires holding mutex 'sls_mu'}}
394 (*pgb_field)++; // expected-warning {{reading variable 'pgb_field' requires holding mutex 'sls_mu2'}} \
395 // expected-warning {{writing the value pointed to by 'pgb_field' requires holding mutex 'sls_mu' exclusively}}
405 // expected-warning {{writing variable 'gb_field' requires holding mutex 'sls_mu' exclusively}}
438 // expected-warning{{writing variable 'sls_guard_var' requires holding any mutex exclusively}}
443 // expected-warning{{reading variable 'sls_guard_var' requires holding any mutex}}
448 // expected-warning {{writing variable 'sls_guardby_var' requires holding mutex 'sls_mu' exclusively}}
453 // expected-warning {{reading variable 'sls_guardby_var' requires holding mutex 'sls_mu'}}
458 // expected-warning {{writing the value pointed to by 'pgb_gvar' requires holding any mutex exclusively}}
463 // expected-warning {{reading the value pointed to by 'pgb_gvar' requires holding any mutex}}
468 // expected-warning {{writing the value pointed to by 'pgb_var' requires holding mutex 'sls_mu' exclusively}}
473 // expected-warning {{reading the value pointed to by 'pgb_var' requires holding mutex 'sls_mu'}}
479 // expected-warning {{writing variable 'gb_field' requires holding mutex 'sls_mu'}}
484 // expected-warning{{writing variable 'sls_guard_var' requires holding any mutex exclusively}}
486 // expected-warning{{writing variable 'sls_guard_var' requires holding any mutex exclusively}}
488 // expected-warning{{writing variable 'sls_guard_var' requires holding any mutex exclusively}}
490 // expected-warning{{writing variable 'sls_guard_var' requires holding any mutex exclusively}}
506 // expected-warning{{writing variable 'a' requires holding mutex 'mu' exclusively}}
508 // expected-warning {{reading variable 'a' requires holding mutex 'mu'}}
510 // expected-warning {{writing variable 'c' requires holding mutex 'mu' exclusively}}
552 // expected-warning{{writing variable 'a' requires holding mutex 'fooB.mu' exclusively}} \
563 // expected-warning{{reading the value pointed to by 'q' requires holding mutex 'b1.mu'}}
573 // expected-warning{{writing variable 'a' requires holding mutex 'BarA.Foo.mu' exclusively}} \
582 // expected-warning{{writing variable 'a' requires holding mutex 'BarA.FooPointer->mu' exclusively}} \
591 // expected-warning{{writing variable 'a' requires holding mutex 'BarA.Foo2.mu' exclusively}} \
611 // expected-warning {{mutex 'sls_mu' is acquired exclusively and shared in the same scope}}
615 // expected-note {{the other acquisition of mutex 'sls_mu' is here}}
641 // expected-warning {{mutex 'sls_mu' is acquired exclusively and shared in the same scope}}
644 // expected-note {{the other acquisition of mutex 'sls_mu' is here}}
650 // expected-warning {{mutex 'sls_mu' is acquired exclusively and shared in the same scope}}
654 // expected-note {{the other acquisition of mutex 'sls_mu' is here}}
662 // expected-warning {{mutex 'sls_mu' is acquired exclusively and shared in the same scope}}
665 // expected-note {{the other acquisition of mutex 'sls_mu' is here}}
673 // expected-warning {{mutex 'sls_mu' is acquired exclusively and shared in the same scope}}
676 // expected-note {{the other acquisition of mutex 'sls_mu' is here}}
765 // expected-warning {{calling function 'aa_elr_fun' requires holding mutex 'aa_mu' exclusively}}
771 // expected-warning {{calling function 'aa_elr_fun' requires holding mutex 'aa_mu' exclusively}}
777 // expected-warning {{calling function 'aa_elr_fun_s' requires holding mutex 'aa_mu'}}
782 // expected-warning {{calling function 'test' requires holding mutex 'sls_mu' exclusively}}
787 // expected-warning {{calling function 'testShared' requires holding mutex 'sls_mu2'}}
793 // expected-warning {{calling function 'test' requires holding mutex 'sls_mu' exclusively}}
800 // expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is held}}
807 // expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is held}}
1212 x = foo(); // expected-warning {{calling function 'foo' requires holding mutex 'mu2' exclusively}}
1226 f1.bar(); // expected-warning {{cannot call function 'bar' while mutex 'f1.mu_' is held}}
1232 f2->bar(); // expected-warning {{cannot call function 'bar' while mutex 'f2->mu_' is held}}
1261 // expected-warning {{writing variable 'a_' requires holding mutex 'b2->mu1_' exclusively}} \
1291 res = b1.a_ + b3->b_; // expected-warning {{reading variable 'a_' requires holding mutex 'b1.mu1_'}} \
1292 // expected-warning {{writing variable 'res' requires holding mutex 'mu' exclusively}} \
1294 *p = i; // expected-warning {{reading variable 'p' requires holding mutex 'mu'}} \
1295 // expected-warning {{writing the value pointed to by 'p' requires holding mutex 'mu' exclusively}}
1296 b1.a_ = res + b3->b_; // expected-warning {{reading variable 'res' requires holding mutex 'mu'}} \
1297 // expected-warning {{writing variable 'a_' requires holding mutex 'b1.mu1_' exclusively}} \
1299 b3->b_ = *b1.q; // expected-warning {{reading the value pointed to by 'q' requires holding mutex 'mu'}}
1301 b1.b_ = res; // expected-warning {{reading variable 'res' requires holding mutex 'mu'}}
1302 x = res; // expected-warning {{reading variable 'res' requires holding mutex 'mu'}}
1324 // expected-warning {{calling function 'bar' requires holding mutex 'child->lock_' exclusively}} \
1327 // expected-warning {{writing variable 'a_' requires holding mutex 'child->lock_' exclusively}} \
1365 child->Func(new_foo); // expected-warning {{cannot call function 'Func' while mutex 'child->lock_' is held}}
1404 f2(); // expected-warning {{cannot call function 'f2' while mutex 'mu1' is held}} \
1405 // expected-warning {{cannot call function 'f2' while mutex 'mu2' is held}}
1413 foo->f1(); // expected-warning {{calling function 'f1' requires holding mutex 'foo->mu2' exclusively}} \
1414 // expected-warning {{calling function 'f1' requires holding mutex 'foo->mu1' exclusively}}
1437 b->func1(); // expected-warning {{calling function 'func1' requires holding mutex 'b->mu_' exclusively}}
1439 b->func2(); // expected-warning {{cannot call function 'func2' while mutex 'b->mu_' is held}}
1442 c->func1(); // expected-warning {{calling function 'func1' requires holding mutex 'c->mu_' exclusively}}
1444 c->func2(); // expected-warning {{cannot call function 'func2' while mutex 'c->mu_' is held}}
1471 a.method1(1); // expected-warning {{calling function 'method1' requires holding mutex 'a.mu1'}} \
1472 // expected-warning {{calling function 'method1' requires holding mutex 'mu'}} \
1473 // expected-warning {{calling function 'method1' requires holding mutex 'a.mu2'}} \
1474 // expected-warning {{calling function 'method1' requires holding mutex 'mu3'}}
1517 dlr.lockData(d1); // expected-note {{mutex acquired here}}
1519 // expected-warning {{releasing mutex 'd2->mu' that was not held}}
1520 } // expected-warning {{mutex 'd1->mu' is still held at the end of function}}
1526 // expected-warning {{calling function 'foo' requires holding mutex 'd2->mu' exclusively}} \
1569 u->n = 0; // expected-warning {{reading variable 'u' requires holding mutex 'm'}}
1570 return t->s->n; // expected-warning {{reading variable 's' requires holding mutex 't->m'}}
1586 v.p->f(u); // expected-warning {{reading variable 'p' requires holding mutex 'v.m'}}
1623 // expected-warning {{acquiring mutex 'mu1' that is already held}}
1649 foo(); // expected-warning {{calling function 'foo' requires holding mutex 'fooObj.mu_' exclusively}}
1725 a = 8; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}}
1751 a = 10; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}}
1879 // expected-warning {{calling function 'barTD' requires holding mutex 'f1.mu_' exclusively}} \
1888 // expected-warning {{writing variable 'data' requires holding mutex 'cell.mu_' exclusively}}
1957 // expected-warning {{calling function 'foo1' requires holding mutex 'myfoo.mu_' exclusively}}
1967 struct __attribute__((lockable)) mutex {
1974 mutex m;
1983 continue; // expected-warning {{expecting mutex 'm' to be held at start of each loop}}
1987 m.lock(); // expected-note {{mutex acquired here}}
2072 // expected-warning {{calling function 'foo2' requires holding mutex 'myFoo.mu_' exclusively}}
2074 // expected-warning {{calling function 'foo3' requires holding mutex 'myFoo.mu_' exclusively}}
2076 // expected-warning {{calling function 'fooT1' requires holding mutex 'myFoo.mu_' exclusively}}
2079 // expected-warning {{calling function 'fooT2' requires holding mutex 'myFoo.mu_' exclusively}}
2082 // expected-warning {{calling function 'fooF1' requires holding mutex 'myFoo.mu_' exclusively}}
2084 // expected-warning {{calling function 'fooF2' requires holding mutex 'myFoo.mu_' exclusively}}
2086 // expected-warning {{calling function 'fooF3' requires holding mutex 'myFoo.mu_' exclusively}}
2102 // expected-warning {{calling function 'foo' requires holding mutex 'myFooT.mu_' exclusively}}
2130 // expected-warning {{writing variable 'foo' requires holding mutex 'this' exclusively}}
2195 // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
2197 // expected-warning {{writing variable 'b' requires holding mutex 'mu_' exclusively}}
2199 // expected-warning {{writing variable 'c' requires holding mutex 'mu_' exclusively}}
2286 // expected-warning {{writing variable 'a' requires holding mutex 'bar.getFooey().mu_' exclusively}} \
2292 // expected-warning {{writing variable 'a' requires holding mutex 'bar.getFoo2(b).mu_' exclusively}} \
2298 // expected-warning {{writing variable 'a' requires holding mutex 'bar.getFoo3(a,c).mu_' exclusively}} \
2304 // expected-warning {{writing variable 'a' requires holding mutex 'getBarFoo(bar,b).mu_' exclusively}} \
2310 // expected-warning {{writing variable 'a' requires holding mutex '((a#_)#_#fooArray[b]).mu_' exclusively}} \
2359 f1->a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'f1->mu_' exclusively}}
2360 f1->foo(); // expected-warning {{calling function 'foo' requires holding mutex 'f1->mu_' exclusively}}
2362 f1->foo2(f2); // expected-warning {{calling function 'foo2' requires holding mutex 'f1->mu_' exclusively}} \
2363 // expected-warning {{calling function 'foo2' requires holding mutex 'f2->mu_' exclusively}}
2364 Foo::sfoo(f1); // expected-warning {{calling function 'sfoo' requires holding mutex 'f1->mu_' exclusively}}
2371 // expected-warning {{calling function 'foo2' requires holding mutex 'f2->mu_' exclusively}} \
2401 b1->b = 0; // expected-warning {{writing variable 'b' requires holding mutex 'b1->mu_' exclusively}}
2402 b1->bar(); // expected-warning {{calling function 'bar' requires holding mutex 'b1->mu_' exclusively}}
2403 b1->bar2(b2); // expected-warning {{calling function 'bar2' requires holding mutex 'b1->mu_' exclusively}} \
2404 // expected-warning {{calling function 'bar2' requires holding mutex 'b2->mu_' exclusively}}
2405 Bar::sbar(b1); // expected-warning {{calling function 'sbar' requires holding mutex 'b1->mu_' exclusively}}
2406 Bar::sbar2(b1); // expected-warning {{calling function 'sbar2' requires holding mutex 'b1->mu_' exclusively}}
2413 // expected-warning {{calling function 'bar2' requires holding mutex 'b2->mu_' exclusively}} \
2428 // Sanity check -- lock the mutex directly, but use attributes that call getMu()
2429 // Also lock the mutex using getFooMu, which calls a lock_returned function.
2479 a = 1; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
2485 rlock.Release(); // expected-warning {{releasing mutex 'mu_' that was not held}}
2494 rlock.Release(); // expected-warning {{releasing mutex 'mu_' that was not held}}
2561 void foo1() EXCLUSIVE_LOCKS_REQUIRED(mutex_) { // expected-note {{mutex acquired here}}
2563 } // expected-warning {{expecting mutex 'mutex_' to be held at the end of function}}
2566 void foo2() SHARED_LOCKS_REQUIRED(mutex_) { // expected-note {{mutex acquired here}}
2568 } // expected-warning {{expecting mutex 'mutex_' to be held at the end of function}}
2601 WTF_ScopedLockable wtf(&mu_); // expected-note {{mutex acquired here}}
2602 } // expected-warning {{mutex 'mu_' is still held at the end of function}}
2623 WTF_ScopedLockable wtf(&mu_); // expected-note {{mutex acquired here}}
2625 } // expected-warning {{mutex 'mu_' is not held on every path through here}}
2632 WTF_ScopedLockable wtf(&mu_); // expected-note {{mutex acquired here}}
2634 } // expected-warning {{mutex 'mu_' is not held on every path through here}}
2658 int b = a; // expected-warning {{reading variable 'a' requires holding mutex 'getMutexPtr()'}}
2689 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
2690 b = 0; // expected-warning {{writing variable 'b' requires holding mutex 'mu_' exclusively}}
2691 c = 0; // expected-warning {{writing variable 'c' requires holding mutex 'mu_' exclusively}}
2775 mu_.get()->Lock(); // expected-warning {{acquiring mutex 'mu_' that is already held}}
2776 (*mu_).Lock(); // expected-warning {{acquiring mutex 'mu_' that is already held}}
2778 Unlock(); // expected-warning {{releasing mutex 'mu_' that was not held}}
2793 foo->a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'foo->mu_' exclusively}}
2794 (*foo).b = 0; // expected-warning {{writing variable 'b' requires holding mutex 'foo->mu_' exclusively}}
2795 foo.get()->c = 0; // expected-warning {{writing variable 'c' requires holding mutex 'foo->mu_' exclusively}}
2909 foo.lock(); // expected-warning {{acquiring mutex 'foo' that is already held}}
2911 foo.unlock(); // expected-warning {{releasing mutex 'foo' that was not held}}
2922 foo.lock1(); // expected-warning {{acquiring mutex 'foo.mu1_' that is already held}}
2925 foo.unlock1(); // expected-warning {{releasing mutex 'foo.mu1_' that was not held}}
2936 foo.slock1(); // expected-warning {{acquiring mutex 'foo.mu1_' that is already held}}
2939 foo.unlock1(); // expected-warning {{releasing mutex 'foo.mu1_' that was not held}}
2954 // expected-warning {{acquiring mutex 'foo.mu1_' that is already held}} \
2955 // expected-warning {{acquiring mutex 'foo.mu2_' that is already held}} \
2956 // expected-warning {{acquiring mutex 'foo.mu3_' that is already held}}
2962 // expected-warning {{releasing mutex 'foo.mu1_' that was not held}} \
2963 // expected-warning {{releasing mutex 'foo.mu2_' that was not held}} \
2964 // expected-warning {{releasing mutex 'foo.mu3_' that was not held}}
2978 // expected-warning {{acquiring mutex 'foo.mu1_' that is already held}} \
2979 // expected-warning {{acquiring mutex 'foo.mu2_' that is already held}} \
2980 // expected-warning {{acquiring mutex 'foo.mu3_' that is already held}}
2986 // expected-warning {{releasing mutex 'foo.mu1_' that was not held}} \
2987 // expected-warning {{releasing mutex 'foo.mu2_' that was not held}} \
2988 // expected-warning {{releasing mutex 'foo.mu3_' that was not held}}
3013 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3035 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3042 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3054 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3065 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3070 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3106 n1.a = 0; // expected-warning {{writing variable 'a' requires holding mutex '&ExistentialPatternMatching::Graph::mu_' exclusively}}
3107 n1.foo(); // expected-warning {{calling function 'foo' requires holding mutex '&ExistentialPatternMatching::Graph::mu_' exclusively}}
3113 n1.foo2(); // expected-warning {{cannot call function 'foo2' while mutex '&ExistentialPatternMatching::Graph::mu_' is held}}
3119 n1.foo2(); // expected-warning {{cannot call function 'foo2' while mutex '&ExistentialPatternMatching::Graph::mu_' is held}}
3125 n1.foo2(); // expected-warning {{cannot call function 'foo2' while mutex '&ExistentialPatternMatching::Graph::mu_' is held}}
3135 g1.mu_.Lock(); // expected-warning {{acquiring mutex 'g1.mu_' that is already held}}
3263 // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
3265 // expected-warning {{releasing mutex '*' that was not held}}
3393 Foo f; // expected-warning {{calling function 'Foo' requires holding mutex 'mu_' exclusively}}
3394 int a = f[0]; // expected-warning {{calling function 'operator[]' requires holding mutex 'mu_' exclusively}}
3395 } // expected-warning {{calling function '~Foo' requires holding mutex 'mu_' exclusively}}
3401 Bar b; // expected-warning {{cannot call function 'Bar' while mutex 'mu_' is held}}
3402 int a = b[0]; // expected-warning {{cannot call function 'operator[]' while mutex 'mu_' is held}}
3403 } // expected-warning {{cannot call function '~Bar' while mutex 'mu_' is held}}
3502 // expected-warning {{calling function 'elr' requires holding mutex 'cell.mu_' exclusively}}
3515 // expected-warning {{calling function 'globalELR' requires holding mutex 'cell.mu_' exclusively}}
3536 // expected-warning {{calling function 'globalELR2' requires holding mutex 'cell.mu_' exclusively}}
3553 // expected-warning {{calling function 'elr' requires holding mutex 'cell.mu_' exclusively}}
3741 // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3743 // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3746 // expected-warning {{reading variable 'datap1_' requires holding mutex 'mu_'}}
3748 // expected-warning {{reading variable 'datap1_' requires holding mutex 'mu_'}}
3751 // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3753 // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3756 // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3758 // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3776 data_ = Data(1); // expected-warning {{writing variable 'data_' requires holding mutex 'mu_' exclusively}}
3777 *datap1_ = data_; // expected-warning {{reading variable 'datap1_' requires holding mutex 'mu_'}} \
3778 // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3779 *datap2_ = data_; // expected-warning {{writing the value pointed to by 'datap2_' requires holding mutex 'mu_' exclusively}} \
3780 // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3781 data_ = *datap1_; // expected-warning {{writing variable 'data_' requires holding mutex 'mu_' exclusively}} \
3782 // expected-warning {{reading variable 'datap1_' requires holding mutex 'mu_'}}
3783 data_ = *datap2_; // expected-warning {{writing variable 'data_' requires holding mutex 'mu_' exclusively}} \
3784 // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3786 data_[0] = 0; // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3787 (*datap2_)[0] = 0; // expected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3789 data_(); // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3794 Data mydat(data_); // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3797 //showDataCell(data_); // xpected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3798 //showDataCell(*datap2_); // xpected-warning {{reading the value pointed to by 'datap2_' requires holding mutex 'mu_'}}
3800 int a = data_[0]; // expected-warning {{reading variable 'data_' requires holding mutex 'mu_'}}
3844 foo.myMethod(); // expected-warning {{reading variable 'foo' requires holding mutex 'mu_'}}
3846 int fa = foo.a; // expected-warning {{reading variable 'foo' requires holding mutex 'mu_'}}
3847 foo.a = fa; // expected-warning {{writing variable 'foo' requires holding mutex 'mu_' exclusively}}
3849 fa = foop->a; // expected-warning {{reading the value pointed to by 'foop' requires holding mutex 'mu_'}}
3850 foop->a = fa; // expected-warning {{writing the value pointed to by 'foop' requires holding mutex 'mu_' exclusively}}
3852 fa = (*foop).a; // expected-warning {{reading the value pointed to by 'foop' requires holding mutex 'mu_'}}
3853 (*foop).a = fa; // expected-warning {{writing the value pointed to by 'foop' requires holding mutex 'mu_' exclusively}}
3855 foo.c = Cell(0); // expected-warning {{writing variable 'foo' requires holding mutex 'mu_'}} \
3856 // expected-warning {{writing variable 'c' requires holding mutex 'foo.cell_mu_' exclusively}}
3857 foo.c.cellMethod(); // expected-warning {{reading variable 'foo' requires holding mutex 'mu_'}} \
3858 // expected-warning {{reading variable 'c' requires holding mutex 'foo.cell_mu_'}}
3860 foop->c = Cell(0); // expected-warning {{writing the value pointed to by 'foop' requires holding mutex 'mu_'}} \
3861 // expected-warning {{writing variable 'c' requires holding mutex 'foop->cell_mu_' exclusively}}
3862 foop->c.cellMethod(); // expected-warning {{reading the value pointed to by 'foop' requires holding mutex 'mu_'}} \
3863 // expected-warning {{reading variable 'c' requires holding mutex 'foop->cell_mu_'}}
3865 (*foop).c = Cell(0); // expected-warning {{writing the value pointed to by 'foop' requires holding mutex 'mu_'}} \
3866 // expected-warning {{writing variable 'c' requires holding mutex 'foop->cell_mu_' exclusively}}
3867 (*foop).c.cellMethod(); // expected-warning {{reading the value pointed to by 'foop' requires holding mutex 'mu_'}} \
3868 // expected-warning {{reading variable 'c' requires holding mutex 'foop->cell_mu_'}}
3938 void lockBad() EXCLUSIVE_LOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3941 } // expected-warning {{expecting mutex 'mu_' to be held at the end of function}}
3943 void readerLockBad() SHARED_LOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3946 } // expected-warning {{expecting mutex 'mu_' to be held at the end of function}}
3948 void unlockBad() UNLOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3951 } // expected-warning {{mutex 'mu_' is still held at the end of function}}
3954 void lockBad2() EXCLUSIVE_LOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3955 mu2_.Lock(); // expected-note {{mutex acquired here}}
3956 } // expected-warning {{expecting mutex 'mu_' to be held at the end of function}} \
3957 // expected-warning {{mutex 'mu2_' is still held at the end of function}}
3960 void readerLockBad2() SHARED_LOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3961 mu2_.ReaderLock(); // expected-note {{mutex acquired here}}
3962 } // expected-warning {{expecting mutex 'mu_' to be held at the end of function}} \
3963 // expected-warning {{mutex 'mu2_' is still held at the end of function}}
3966 void unlockBad2() UNLOCK_FUNCTION(mu_) { // expected-note {{mutex acquired here}}
3967 mu2_.Unlock(); // expected-warning {{releasing mutex 'mu2_' that was not held}}
3968 } // expected-warning {{mutex 'mu_' is still held at the end of function}}
3995 a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu_' exclusively}}
4054 mu_.Lock(); // expected-note {{mutex acquired here}}
4056 } // expected-warning {{mutex 'mu_' is still held at the end of function}}
4060 mu_.Lock(); // expected-note {{mutex acquired here}}
4065 } // expected-warning {{mutex 'mu_' is still held at the end of function}}
4202 if (*a == 0) doSomething(); // expected-warning {{reading the value pointed to by 'a' requires holding mutex 'mu2'}}
4203 *a = 0; // expected-warning {{writing the value pointed to by 'a' requires holding mutex 'mu2' exclusively}}
4205 if (c->a == 0) doSomething(); // expected-warning {{reading the value pointed to by 'c' requires holding mutex 'mu2'}}
4206 c->a = 0; // expected-warning {{writing the value pointed to by 'c' requires holding mutex 'mu2' exclusively}}
4208 if ((*c).a == 0) doSomething(); // expected-warning {{reading the value pointed to by 'c' requires holding mutex 'mu2'}}
4209 (*c).a = 0; // expected-warning {{writing the value pointed to by 'c' requires holding mutex 'mu2' exclusively}}
4211 if (a[0] == 42) doSomething(); // expected-warning {{reading the value pointed to by 'a' requires holding mutex 'mu2'}}
4212 a[0] = 57; // expected-warning {{writing the value pointed to by 'a' requires holding mutex 'mu2' exclusively}}
4213 if (c[0].a == 42) doSomething(); // expected-warning {{reading the value pointed to by 'c' requires holding mutex 'mu2'}}
4214 c[0].a = 57; // expected-warning {{writing the value pointed to by 'c' requires holding mutex 'mu2' exclusively}}
4220 if (*a == 0) doSomething(); // expected-warning {{reading variable 'a' requires holding mutex 'mu1'}}
4221 *a = 0; // expected-warning {{reading variable 'a' requires holding mutex 'mu1'}}
4223 if (c->a == 0) doSomething(); // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4224 c->a = 0; // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4226 if ((*c).a == 0) doSomething(); // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4227 (*c).a = 0; // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4229 if (a[0] == 42) doSomething(); // expected-warning {{reading variable 'a' requires holding mutex 'mu1'}}
4230 a[0] = 57; // expected-warning {{reading variable 'a' requires holding mutex 'mu1'}}
4231 if (c[0].a == 42) doSomething(); // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4232 c[0].a = 57; // expected-warning {{reading variable 'c' requires holding mutex 'mu1'}}
4237 if (sa[0] == 42) doSomething(); // expected-warning {{reading variable 'sa' requires holding mutex 'mu1'}}
4238 sa[0] = 57; // expected-warning {{writing variable 'sa' requires holding mutex 'mu1' exclusively}}
4239 if (sc[0].a == 42) doSomething(); // expected-warning {{reading variable 'sc' requires holding mutex 'mu1'}}
4240 sc[0].a = 57; // expected-warning {{writing variable 'sc' requires holding mutex 'mu1' exclusively}}
4242 if (*sa == 42) doSomething(); // expected-warning {{reading variable 'sa' requires holding mutex 'mu1'}}
4243 *sa = 57; // expected-warning {{writing variable 'sa' requires holding mutex 'mu1' exclusively}}
4244 if ((*sc).a == 42) doSomething(); // expected-warning {{reading variable 'sc' requires holding mutex 'mu1'}}
4245 (*sc).a = 57; // expected-warning {{writing variable 'sc' requires holding mutex 'mu1' exclusively}}
4246 if (sc->a == 42) doSomething(); // expected-warning {{reading variable 'sc' requires holding mutex 'mu1'}}
4247 sc->a = 57; // expected-warning {{writing variable 'sc' requires holding mutex 'mu1' exclusively}}
4292 sp.get(); // expected-warning {{reading variable 'sp' requires holding mutex 'mu1'}}
4293 if (*sp == 0) doSomething(); // expected-warning {{reading variable 'sp' requires holding mutex 'mu1'}}
4294 *sp = 0; // expected-warning {{reading variable 'sp' requires holding mutex 'mu1'}}
4295 sq->a = 0; // expected-warning {{reading variable 'sq' requires holding mutex 'mu1'}}
4297 if (sp[0] == 0) doSomething(); // expected-warning {{reading variable 'sp' requires holding mutex 'mu1'}}
4298 sp[0] = 0; // expected-warning {{reading variable 'sp' requires holding mutex 'mu1'}}
4299 if (sq[0].a == 0) doSomething(); // expected-warning {{reading variable 'sq' requires holding mutex 'mu1'}}
4300 sq[0].a = 0; // expected-warning {{reading variable 'sq' requires holding mutex 'mu1'}}
4309 if (*sp == 0) doSomething(); // expected-warning {{reading the value pointed to by 'sp' requires holding mutex 'mu2'}}
4310 *sp = 0; // expected-warning {{reading the value pointed to by 'sp' requires holding mutex 'mu2'}}
4311 sq->a = 0; // expected-warning {{reading the value pointed to by 'sq' requires holding mutex 'mu2'}}
4313 if (sp[0] == 0) doSomething(); // expected-warning {{reading the value pointed to by 'sp' requires holding mutex 'mu2'}}
4314 sp[0] = 0; // expected-warning {{reading the value pointed to by 'sp' requires holding mutex 'mu2'}}
4315 if (sq[0].a == 0) doSomething(); // expected-warning {{reading the value pointed to by 'sq' requires holding mutex 'mu2'}}
4316 sq[0].a = 0; // expected-warning {{reading the value pointed to by 'sq' requires holding mutex 'mu2'}}
4329 (RunHelper)(); // expected-warning {{calling function 'RunHelper' requires holding mutex 'M' exclusively}}
4373 func1(); // expected-warning {{calling function 'operator()' requires holding mutex 'mu_' exclusively}}