Clang

约定不等于承诺〃 2022-12-11 12:17 181阅读 0赞

http://clang.llvm.org/docs/index.html

http://clang.llvm.org/extra/clang-tidy/  
Clang\_tidy 说明  
clang-tidy is a clang-based C++ “linter” tool. Its purpose is to provide an extensible framework for diagnosing and fixing typical programming errors, like style violations, interface misuse, or bugs that can be deduced via static analysis. clang-tidy is modular and provides a convenient interface for writing new checks.

我们在ubuntu下安装clang\_tidy后

sudo apt install clang-tidy

然后在QtCreator中使用Clang-Tidy和Clazy检查C++代码质量（具体参照其他文档）  
当设置好以后，就可以在代码中检测了。  
这时候在qt中就会有\_\_clang\_\_这头宏定义了

#if defined(__clang__) && (!defined(SWIG))
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
    #else
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
    #endif

else后面就变灰了，说明全局环境中定义了\_\_clang\_\_宏定义  
这时候就可以用其他的保护语义了：

#ifndef MUTEX_H
    #define MUTEX_H
    #include <assert.h>
    #include <pthread.h>
    
    
    
    #if defined(__clang__) && (!defined(SWIG))
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
    #else
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
    #endif
    
    #define CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
    
    #define SCOPED_CAPABILITY THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
    
    #define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
    
    #define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
    
    #define ACQUIRED_BEFORE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
    
    #define ACQUIRED_AFTER(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
    
    #define REQUIRES(...) \ THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
    
    #define REQUIRES_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
    
    #define ACQUIRE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
    
    #define ACQUIRE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
    
    #define RELEASE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
    
    #define RELEASE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
    
    #define TRY_ACQUIRE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
    
    #define TRY_ACQUIRE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
    
    #define EXCLUDES(...) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
    
    #define ASSERT_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
    
    #define ASSERT_SHARED_CAPABILITY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
    
    #define RETURN_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
    
    #define NO_THREAD_SAFETY_ANALYSIS \ THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
    
    // End of thread safety annotations }
    
    
    class CAPABILITY("mutex")  Mutex { 
    public:
      Mutex();
    
      void lock();
      void unlock();
    
    private:
      pthread_mutex_t mutex_;
    };
    
    class BankAccount { 
    private:
        Mutex mu;
        int balance GUARDED_BY(mu);
        
        void depositImpl(int amount) { 
            balance += amount; // WARNING! Cannot write balance without locking mu.
        }
        
        void withdrawImpl(int amount) REQUIRES(mu) { 
            balance -= amount; // OK. Caller must have locked mu.
        }
        
    public:
        void withdraw(int amount) { 
            mu.lock();
            withdrawImpl(amount); // OK. We've locked mu.
        }                       // WARNING! Failed to unlock mu.
        
        void transferFrom(BankAccount &b, int amount) { 
            mu.lock();
            b.withdrawImpl(
                amount); // WARNING! Calling withdrawImpl() requires locking b.mu.
            depositImpl(amount); // OK. depositImpl() has no requirements.
            mu.unlock();
        }
    };
    
    #endif // MUTEX_H

https://clang.llvm.org/docs/ThreadSafetyAnalysis.html  
这里详细的说明了上述

那么可以明白muduo/Mutex.h中的宏定义了

// Use of this source code is governed by a BSD-style license
    // that can be found in the License file.
    //
    // Author: Shuo Chen (chenshuo at chenshuo dot com)
    
    #ifndef MUDUO_BASE_MUTEX_H
    #define MUDUO_BASE_MUTEX_H
    
    #include "muduo/base/CurrentThread.h"
    #include "muduo/base/noncopyable.h"
    #include <assert.h>
    #include <pthread.h>
    
    // Thread safety annotations { 
    // https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
    
    // Enable thread safety attributes only with clang.
    // The attributes can be safely erased when compiling with other compilers.
    #if defined(__clang__) && (!defined(SWIG))
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
    #else
    #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
    #endif
    
    #define CAPABILITY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
    
    #define SCOPED_CAPABILITY \ THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
    
    #define GUARDED_BY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
    
    #define PT_GUARDED_BY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
    
    #define ACQUIRED_BEFORE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
    
    #define ACQUIRED_AFTER(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
    
    #define REQUIRES(...) \ THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
    
    #define REQUIRES_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
    
    #define ACQUIRE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
    
    #define ACQUIRE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
    
    #define RELEASE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
    
    #define RELEASE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
    
    #define TRY_ACQUIRE(...) \ THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
    
    #define TRY_ACQUIRE_SHARED(...) \ THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
    
    #define EXCLUDES(...) \ THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
    
    #define ASSERT_CAPABILITY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
    
    #define ASSERT_SHARED_CAPABILITY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
    
    #define RETURN_CAPABILITY(x) \ THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
    
    #define NO_THREAD_SAFETY_ANALYSIS \ THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
    
    // End of thread safety annotations }
    
    #ifdef CHECK_PTHREAD_RETURN_VALUE
    
    #ifdef NDEBUG
    __BEGIN_DECLS
    extern void __assert_perror_fail (int errnum,
                                      const char *file,
                                      unsigned int line,
                                      const char *function)
        noexcept __attribute__ ((__noreturn__));
    __END_DECLS
    #endif
    
    #define MCHECK(ret) ({ __typeof__ (ret) errnum = (ret); \ if (__builtin_expect(errnum != 0, 0)) \ __assert_perror_fail (errnum, __FILE__, __LINE__, __func__);})
    
    #else // CHECK_PTHREAD_RETURN_VALUE
    
    #define MCHECK(ret) ({ __typeof__ (ret) errnum = (ret); \ assert(errnum == 0); (void) errnum;})
    
    #endif // CHECK_PTHREAD_RETURN_VALUE
    
    namespace muduo
    { 
    
    // Use as data member of a class, eg.
    //
    // class Foo
    // { 
    // public:
    // int size() const;
    //
    // private:
    // mutable MutexLock mutex_;
    // std::vector<int> data_ GUARDED_BY(mutex_);
    // };
    class CAPABILITY("mutex") MutexLock : noncopyable
    { 
     public:
      MutexLock()
        : holder_(0)
      { 
        MCHECK(pthread_mutex_init(&mutex_, NULL));
      }
    
      ~MutexLock()
      { 
        assert(holder_ == 0);
        MCHECK(pthread_mutex_destroy(&mutex_));
      }
    
      // must be called when locked, i.e. for assertion
      bool isLockedByThisThread() const
      { 
        return holder_ == CurrentThread::tid();
      }
    
      void assertLocked() const ASSERT_CAPABILITY(this)
      { 
        assert(isLockedByThisThread());
      }
    
      // internal usage
    
      void lock() ACQUIRE()
      { 
        MCHECK(pthread_mutex_lock(&mutex_));
        assignHolder();
      }
    
      void unlock() RELEASE()
      { 
        unassignHolder();
        MCHECK(pthread_mutex_unlock(&mutex_));
      }
    
      pthread_mutex_t* getPthreadMutex() /* non-const */
      { 
        return &mutex_;
      }
    
     private:
      friend class Condition;
    
      class UnassignGuard : noncopyable
      { 
       public:
        explicit UnassignGuard(MutexLock& owner)
          : owner_(owner)
        { 
          owner_.unassignHolder();
        }
    
        ~UnassignGuard()
        { 
          owner_.assignHolder();
        }
    
       private:
        MutexLock& owner_;
      };
    
      void unassignHolder()
      { 
        holder_ = 0;
      }
    
      void assignHolder()
      { 
        holder_ = CurrentThread::tid();
      }
    
      pthread_mutex_t mutex_;
      pid_t holder_;
    };
    
    // Use as a stack variable, eg.
    // int Foo::size() const
    // { 
    // MutexLockGuard lock(mutex_);
    // return data_.size();
    // }
    class SCOPED_CAPABILITY MutexLockGuard : noncopyable
    { 
     public:
      explicit MutexLockGuard(MutexLock& mutex) ACQUIRE(mutex)
        : mutex_(mutex)
      { 
        mutex_.lock();
      }
    
      ~MutexLockGuard() RELEASE()
      { 
        mutex_.unlock();
      }
    
     private:
    
      MutexLock& mutex_;
    };
    
    }  // namespace muduo
    
    // Prevent misuse like:
    // MutexLockGuard(mutex_);
    // A tempory object doesn't hold the lock for long!
    #define MutexLockGuard(x) error "Missing guard object name"
    
    #endif // MUDUO_BASE_MUTEX_H