Lines Matching defs:lock
32 void Lock() __attribute__((exclusive_lock_function));
64 // The universal lock, written "*", allows checking to be selectively turned
116 sls_mw.mu.Lock();
122 sls_mu.Lock();
128 sls_mu.Lock();
134 sls_mu2.Lock();
140 sls_mu.Lock();
146 sls_mu.Lock();
152 sls_mu.Lock();
153 sls_mu2.Lock();
159 sls_mu.Lock();
168 sls_mu.Lock();
170 sls_mu.Lock();
176 sls_mu.Lock();
183 sls_mu.Lock();
189 sls_mu.Lock();
194 sls_mu.Lock();
198 sls_mu.Lock();
214 sls_mu.Lock();
215 sls_mu.Lock(); // \
221 sls_mu.Lock(); // expected-note {{mutex acquired here}}
226 sls_mu.Lock(); // expected-note{{mutex acquired here}}
228 sls_mu2.Lock(); // expected-note{{mutex acquired here}}
233 sls_mu.Lock(); // expected-note {{mutex acquired here}}
240 sls_mu.Lock(); // expected-note {{mutex acquired here}}
254 sls_mu.Lock();
263 sls_mu.Lock(); // expected-note {{mutex acquired here}}
269 sls_mu.Lock(); // expected-note{{mutex acquired here}}
278 sls_mu.Lock(); // \
286 sls_mu.Lock(); // expected-note 2{{mutex acquired here}}
295 sls_mu.Lock(); // expected-note {{mutex acquired here}}
302 sls_mu.Lock(); // expected-note {{mutex acquired here}}
310 sls_mu.Lock();
316 // Handling lock expressions in attribute args
360 wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
363 wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
366 wmu.Lock(); // expected-note {{mutex acquired here}}
369 wmu.Lock(); // expected-note {{mutex acquired here}}
415 sls_mu.Lock();
421 sls_mu.Lock();
534 FooA.mu.Lock();
541 BarA.FooPointer->mu.Lock();
549 fooA.mu.Lock();
558 mu.Lock();
559 b1.mu1_.Lock();
570 BarA.FooPointer->mu.Lock();
579 BarA.Foo.mu.Lock();
588 BarA.Foo.mu.Lock();
600 sls_mu.Lock();
603 sls_mu.Lock();
613 sls_mu.Lock(); // \
614 // expected-note {{the other lock of mutex 'sls_mu' is here}}
621 sls_mu.Lock();
623 sls_mu.Lock();
639 sls_mu.Lock(); // \
643 // expected-note {{the other lock of mutex 'sls_mu' is here}}
648 sls_mu.Lock(); // \
653 // expected-note {{the other lock of mutex 'sls_mu' is here}}
660 sls_mu.Lock(); // \
664 // expected-note {{the other lock of mutex 'sls_mu' is here}}
674 sls_mu.Lock(); // \
675 // expected-note {{the other lock of mutex 'sls_mu' is here}}
701 aa_mu.Lock();
707 aa_mu.Lock();
719 sls_mu.Lock();
725 sls_mu2.Lock();
741 sls_mu.Lock();
764 // expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}}
770 // expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}}
776 // expected-warning {{calling function 'aa_elr_fun_s' requires shared lock on 'aa_mu'}}
781 // expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}}
786 // expected-warning {{calling function 'testShared' requires shared lock on 'sls_mu2'}}
792 // expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}}
797 sls_mu.Lock();
812 // Unparseable lock expressions
870 mu.Lock();
871 b1.mu1_.Lock();
885 // test lock annotations applied to function definitions
913 mu1.Lock();
914 mu2.Lock();
925 // Test the case where a template member function is annotated with lock
945 // Tests lock canonicalization
963 fb->foo_->mu_->Lock();
970 // Test the support for use of lock expression in the annotations
983 foo->foo_mu_.Lock();
984 bar_mu_.Lock();
1065 a.mu2->Lock();
1066 a.mu1->Lock();
1067 mu.Lock();
1088 mu_.Lock();
1107 // Test delay parsing of lock attribute arguments with nested classes.
1165 b->mu_.Lock();
1170 c->mu_.Lock();
1210 mu_.Lock();
1211 x = foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'mu2'}}
1215 mu1.Lock();
1224 f1.mu_.Lock();
1226 mu2.Lock();
1230 f2->mu_.Lock();
1233 mu2.Lock();
1241 // Test the ability to distnguish between the same lock field of
1289 b3->mu1_.Lock();
1307 // Test the analyzer's ability to distinguish the lock field of different
1318 lock_.Lock();
1321 // acquired lock is not in child.
1323 // expected-warning {{calling function 'bar' requires exclusive lock on 'child->lock_'}} \
1346 // Test the analyzer's ability to distinguish the lock field of different
1361 lock_.Lock();
1363 child->lock_.Lock();
1387 // Test support of multiple lock attributes of the same kind on a decl.
1395 mu2.Lock();
1412 foo->f1(); // expected-warning {{calling function 'f1' requires exclusive lock on 'foo->mu2'}} \
1413 // expected-warning {{calling function 'f1' requires exclusive lock on 'foo->mu1'}}
1436 b->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'b->mu_'}}
1437 b->mu_.Lock();
1441 c->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'c->mu_'}}
1442 c->mu_.Lock();
1470 a.method1(1); // expected-warning {{calling function 'method1' requires shared lock on 'a.mu1'}} \
1471 // expected-warning {{calling function 'method1' requires shared lock on 'mu'}} \
1472 // expected-warning {{calling function 'method1' requires shared lock on 'a.mu2'}} \
1473 // expected-warning {{calling function 'method1' requires shared lock on 'mu3'}}
1525 // expected-warning {{calling function 'foo' requires exclusive lock on 'd2->mu'}} \
1648 foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'fooObj.mu_'}}
1649 fooObj.mu_.Lock();
1763 mu.Lock();
1853 mu_.Lock();
1865 f1.mu_.Lock();
1866 f2.mu_.Lock();
1867 bt.fooBase.mu_.Lock();
1868 bt.fooBaseT.mu_.Lock();
1878 // expected-warning {{calling function 'barTD' requires exclusive lock on 'f1.mu_'}} \
1889 cell.mu_.Lock();
1912 mu_.Lock();
1925 celld.mu_.Lock();
1926 celld2.mu_.Lock();
1956 // expected-warning {{calling function 'foo1' requires exclusive lock on 'myfoo.mu_'}}
1957 myfoo.mu_.Lock();
1967 void lock() __attribute__((exclusive_lock_function));
1975 m.lock();
1986 m.lock(); // expected-note {{mutex acquired here}}
2071 // expected-warning {{calling function 'foo2' requires exclusive lock on 'myFoo.mu_'}}
2073 // expected-warning {{calling function 'foo3' requires exclusive lock on 'myFoo.mu_'}}
2075 // expected-warning {{calling function 'fooT1' requires exclusive lock on 'myFoo.mu_'}}
2078 // expected-warning {{calling function 'fooT2' requires exclusive lock on 'myFoo.mu_'}}
2081 // expected-warning {{calling function 'fooF1' requires exclusive lock on 'myFoo.mu_'}}
2083 // expected-warning {{calling function 'fooF2' requires exclusive lock on 'myFoo.mu_'}}
2085 // expected-warning {{calling function 'fooF3' requires exclusive lock on 'myFoo.mu_'}}
2087 myFoo.mu_.Lock();
2101 // expected-warning {{calling function 'foo' requires exclusive lock on 'myFooT.mu_'}}
2113 void lock() EXCLUSIVE_LOCK_FUNCTION();
2117 this->lock(); // allow 'this' as a lock expression
2139 // don't check inside lock and unlock functions
2140 void lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.Lock(); }
2175 MutexLock lock(&mu_);
2251 bar.getFoo().mu_.Lock();
2255 (bar.getFoo().mu_).Lock(); // test parenthesis
2259 bar.getFoo2(a).mu_.Lock();
2263 bar.getFoo3(a, b).mu_.Lock();
2267 getBarFoo(bar, a).mu_.Lock();
2271 bar.getFoo2(10).mu_.Lock();
2275 bar.getFoo2(a + 1).mu_.Lock();
2279 (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock();
2283 bar.getFoo().mu_.Lock();
2289 bar.getFoo2(a).mu_.Lock();
2295 bar.getFoo3(a, b).mu_.Lock();
2301 getBarFoo(bar, a).mu_.Lock();
2307 (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock();
2329 mu.Lock();
2356 // Calls getMu() directly to lock and unlock
2359 f1->foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'f1->mu_'}}
2361 f1->foo2(f2); // expected-warning {{calling function 'foo2' requires exclusive lock on 'f1->mu_'}} \
2362 // expected-warning {{calling function 'foo2' requires exclusive lock on 'f2->mu_'}}
2363 Foo::sfoo(f1); // expected-warning {{calling function 'sfoo' requires exclusive lock on 'f1->mu_'}}
2365 f1->getMu()->Lock();
2370 // expected-warning {{calling function 'foo2' requires exclusive lock on 'f2->mu_'}} \
2373 Foo::getMu(f2)->Lock();
2401 b1->bar(); // expected-warning {{calling function 'bar' requires exclusive lock on 'b1->mu_'}}
2402 b1->bar2(b2); // expected-warning {{calling function 'bar2' requires exclusive lock on 'b1->mu_'}} \
2403 // expected-warning {{calling function 'bar2' requires exclusive lock on 'b2->mu_'}}
2404 Bar::sbar(b1); // expected-warning {{calling function 'sbar' requires exclusive lock on 'b1->mu_'}}
2405 Bar::sbar2(b1); // expected-warning {{calling function 'sbar2' requires exclusive lock on 'b1->mu_'}}
2407 b1->getMu()->Lock();
2412 // expected-warning {{calling function 'bar2' requires exclusive lock on 'b2->mu_'}} \
2415 b2->getMu()->Lock();
2427 // Sanity check -- lock the mutex directly, but use attributes that call getMu()
2428 // Also lock the mutex using getFooMu, which calls a lock_returned function.
2430 b1->mu_.Lock();
2434 getFooMu(b2)->Lock();
2492 // no warning on join point for managed lock.
2515 mu2_.Lock();
2654 ReaderMutexLock lock(getMutexPtr().get());
2673 void Lock() EXCLUSIVE_LOCK_FUNCTION(mu_);
2694 mu_->Lock();
2702 (*mu_).Lock();
2711 mu_.get()->Lock();
2720 MutexLock lock(mu_.get());
2728 MutexLock lock(&(*mu_));
2736 Lock();
2746 Lock();
2750 mu_->Lock();
2754 mu_.get()->Lock();
2758 mu_->Lock();
2762 mu_.get()->Lock();
2766 (*mu_).Lock();
2773 mu_->Lock();
2774 mu_.get()->Lock(); // expected-warning {{locking 'mu_' that is already locked}}
2775 (*mu_).Lock(); // expected-warning {{locking 'mu_' that is already locked}}
2799 foo->mu_->Lock();
2808 (*foo).mu_->Lock();
2817 MutexLock lock(foo->mu_.get());
2838 void lock() EXCLUSIVE_LOCK_FUNCTION();
2858 void Foo::lock() EXCLUSIVE_LOCK_FUNCTION() { }
2862 mu1_.Lock();
2870 mu1_.Lock();
2871 mu2_.Lock();
2872 mu3_.Lock();
2878 mu1_.Lock();
2879 mu2_.Lock();
2880 mu3_.Lock();
2904 foo.lock();
2907 foo.lock();
2908 foo.lock(); // expected-warning {{locking 'foo' that is already locked}}
3144 n1.foo(); // expected-warning {{calling function 'foo' requires exclusive lock on '&ExistentialPatternMatching::Graph::mu_'}}
3147 g1.mu_.Lock();
3153 g2.mu_.Lock();
3172 g1.mu_.Lock(); // expected-warning {{locking 'g1.mu_' that is already locked}}
3184 void lock() EXCLUSIVE_LOCK_FUNCTION("");
3197 f->lock();
3238 i->lock_.Lock();
3294 // don't warn on joins with universal lock
3306 // make sure the universal lock joins properly
3309 mu_.Lock();
3314 mu_.Lock();
3322 // combine universal lock with other locks
3325 mu_.Lock();
3329 mu_.Lock();
3334 mu_.Lock();
3393 foo->mu_.Lock();
3430 Foo f; // expected-warning {{calling function 'Foo' requires exclusive lock on 'mu_'}}
3431 int a = f[0]; // expected-warning {{calling function 'operator[]' requires exclusive lock on 'mu_'}}
3432 } // expected-warning {{calling function '~Foo' requires exclusive lock on 'mu_'}}
3436 Bar::mu_.Lock();
3539 // expected-warning {{calling function 'elr' requires exclusive lock on 'cell.mu_'}}
3552 // expected-warning {{calling function 'globalELR' requires exclusive lock on 'cell.mu_'}}
3573 // expected-warning {{calling function 'globalELR2' requires exclusive lock on 'cell.mu_'}}
3590 // expected-warning {{calling function 'elr' requires exclusive lock on 'cell.mu_'}}
3646 void lock() EXCLUSIVE_LOCK_FUNCTION(mu1_)
3671 void Foo::lock() { mu1_.Lock(); mu2_.Lock(); }
3679 mu1_.Lock();
3691 mu2_.Lock();
3695 lock();
3776 mu_.Lock();
3899 mu_.Lock();
3926 // Check built-in lock functions
3929 void lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.Lock(); }
3940 // Correct lock/unlock functions
3941 void lock() EXCLUSIVE_LOCK_FUNCTION(mu_) {
3942 mu_.Lock();
3953 // Check failure to lock.
3955 mu2_.Lock();
3960 mu2_.Lock();
3965 mu2_.Lock();
3971 mu2_.Lock(); // expected-note {{mutex acquired here}}
4046 mu_.Lock();
4055 mu_.Lock();
4070 mu_.Lock(); // expected-note {{mutex acquired here}}
4076 mu_.Lock(); // expected-note {{mutex acquired here}}
