精华内容
下载资源
问答
  • Clang

    2020-09-30 16:15:25
    Clang 12.0.0 (In-Progress) Release Notes Using Clang as a Compiler Clang Compiler User’s Manual Assembling a Complete Toolchain Clang Language Extensions Clang command line argument reference ...

    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
    
    
    展开全文
  • clang

    2017-09-30 23:58:48
    Clang和LLVM的关系  Clang和LLVM到底是什么关系,这是在研究Clang的过程中所不可避免的一个问题。如果要搞清楚Clang和LLVM之间的关系,首先先要知道宏观的LLVM和微观的LLVM。  宏观的LLVM,指的是整个的LLVM的...
    Clang和LLVM的关系
            Clang和LLVM到底是什么关系,这是在研究Clang的过程中所不可避免的一个问题。如果要搞清楚Clang和LLVM之间的关系,首先先要知道宏观的LLVM和微观的LLVM。
            宏观的LLVM,指的是整个的LLVM的框架,它肯定包含了Clang,因为Clang是LLVM的框架的一部分,是它的一个C/C++的前端。虽然这个前端占的比重比较大,但是它依然只是个前端,LLVM框架可以有很多个前端和很多个后端,只要你想继续扩展。
            微观的LLVM指的是以实际开发过程中,包括实际使用过程中,划分出来的LLVM。比如编译LLVM和Clang的时候,LLVM的源码包是不包含Clang的源码包的,需要单独下载Clang的源码包。
            所以这里想讨论的就是微观的LLVM和Clang的关系。从编译器用户的角度,Clang使用了LLVM中的一些功能,目前所知道的主要就是对中间格式代码的优化,或许还有一部分生成代码的功能。从Clang和微观LLVM的源码位置可以看出,Clang是基于微观的LLVM的一个工具。而从功能的角度来说,微观的LLVM可以认为是一个编译器的后端,而Clang是一个编译器的前端,它们的关系就更加的明了了,一个编译器前端想要程序最终变成可执行文件,是缺少不了对编译器后端的介绍的。
            这样基本就确定了Clang和LLVM的关系。这个问题虽然并不复杂,但是对于后续的结构理解和深入研究确是一个很重要的出发点。这个出发点不理清楚的话,后续的研究没有办法继续深入下去。

    Clang的整体架构
            如果要深入的研究Clang,那么首先需要知道Clang的整体架构。直接打开Clang的源码的话,里面目录较多,无从下手。可以直接从doxygen文档看,Clang的doxygen的地址是:http://clang.llvm.org/doxygen/index.html 。从这个首页选取Directories,可以直接进到文件目录列表:http://clang.llvm.org/doxygen/dirs.html 。在这个里面看目录,就比较清晰了,在clang目录下面一共就三个目录: docs、include和lib。为什么只有这三个呢?仔细研究和对比就会发现,如果你要研究Clang的内部实现,只需要这三个目录就够了,其他的目录和Clang核心没有任何关系,是一些基于Clang的工具,Clang的一些例子,或者是一些测试用例等。
              现在看起来,Clang的结构已经很明显了。docs很明显放置的都是一些文档相关的内容,include放置的都是一些头文件。就只剩下一个lib目录了,下面是分类的目录,这个时候也可以推断出Clang的总体架构了,它的总体架构是基于库的。在Clang的官方文档“Clang" CFE Internals Manual (http://clang.llvm.org/docs/InternalsManual.html )中,对Clang内部的介绍也是依据库来进行分类的。


    展开全文
  • Ubuntu安装Clang\Clang版本切换

    万次阅读 多人点赞 2018-11-27 20:22:18
    目录1、废话2、安装不同版本的Clang2、Clang不同版本的切换 1、废话 clang这种可以直接用apt-get来安装的,居然还有人写了手动编译的教程。。。直接使用apt-get安装不是更好?虽然说使用apt-get可能不能安装不了...

    1、废话

    clang这种可以直接用apt-get来安装的,居然还有人写了手动编译的教程。。。直接使用apt-get安装不是更好?虽然说使用apt-get可能不能安装不了最新版,但是,最新版的特性也用不上啊。。。

    使用apt-get安装最新版本的clang(感谢Lysine_Four补充):

    sudo apt-get install clang
    

    2、安装不同版本的Clang

    使用apt-get命令安装clang的某个版本

    sudo apt-get install clang-3.8
    

    然后通过update-alternatives安装该版本clang的“快捷方式”:

    sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.8 1 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-3.8
    

    如果安装的是clang-4.0,就把上面的命令中的“/usr/bin/clang-3.8”(实际的可执行文件名,不同的clang版本是不同的)换成“/usr/bin/clang-4.0”,“/usr/bin/clang++-3.8”换成“/usr/bin/clang++-4.0”,其他版本也是同理。至于update-alternatives,大家可自行查阅其用法。
    获取clang版本:

    clang --version
    clang++ --version
    

    不知道选哪个clang版本就选最新的。

    2.1、Ubuntu 16.04 可选版本

    # clang-3.5
    sudo apt-get install clang-3.5
    # clang-3.6
    sudo apt-get install clang-3.6
    # clang-3.7
    sudo apt-get install clang-3.7
    # clang-3.8
    sudo apt-get install clang-3.8
    # clang-3.9
    sudo apt-get install clang-3.9
    # clang-4.0
    sudo apt-get install clang-4.0
    

    2.2、Ubuntu 18.04 可选版本

    # clang-3.9
    sudo apt-get install clang-3.9
    # clang-4.0
    sudo apt-get install clang-4.0
    # clang-5.0
    sudo apt-get install clang-5.0
    # clang-6.0
    sudo apt-get install clang-6.0
    

    2.3、Ubuntu 18.10 可选版本

    # clang-3.9
    sudo apt-get install clang-3.9
    # clang-4.0
    sudo apt-get install clang-4.0
    # clang-5.0
    sudo apt-get install clang-5.0
    # clang-6.0
    sudo apt-get install clang-6.0
    # clang-7
    sudo apt-get install clang-7
    

    2、Clang不同版本的切换

    update-alternatives可以很方便的完成不同版本的切换,直接来个例子吧。比如说我需要安装clang-3.8和clang-4.0,然后需要在这两个版本之间切换。
    先安装clang-3.8和clang-4.0:

    sudo apt-get install clang-3.8 clang-4.0
    

    然后使用update-alternatives“安装”两个版本的clang:

    # for clang-3.8
    sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.8 1 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-3.8
    # for clang-4.0
    sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-4.0 2 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-4.0
    

    打印clang版本:

    clang --version
    clang++ --version
    

    输出:

    clang version 4.0.0-1ubuntu1~16.04.2 (tags/RELEASE_400/rc1)
    Target: x86_64-pc-linux-gnu
    Thread model: posix
    InstalledDir: /usr/bin
    

    由于clang-4.0的优先级“2”要比clang-3.8的“1”要高,所以此时clang-4.0是默认的版本。
    如果要切换版本,输入如下命令:

    sudo update-alternatives --config clang
    

    然后出现如下提示:

    There are 2 choices for the alternative clang (providing /usr/bin/clang).
    
      Selection    Path                Priority   Status
    ------------------------------------------------------------
    * 0            /usr/bin/clang-4.0   2         auto mode
      1            /usr/bin/clang-3.8   1         manual mode
      2            /usr/bin/clang-4.0   2         manual mode
    
    Press <enter> to keep the current choice[*], or type selection number:
    

    然后在“selection number:”后面输入你要使用的clang版本序号(第一列),加入要切换为clang-3.8,就输入1,然后回车,就切换为clang-3.8了。

    打印clang版本:

    clang --version
    clang++ --version
    

    输出:

    clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)
    Target: x86_64-pc-linux-gnu
    Thread model: posix
    InstalledDir: /usr/bin
    

    update-alternatives也可以用来管理其他软件的版本,比如还常常用于gcc的版本管理,是个很有用的工具。

    展开全文
  • 用于pypi的Clang Python ppackage 这是llvm clang存储库的python绑定子目录。 debian软件包从llvm仓库中提取,提取并推送到pypi。
  • Clang 10 fails

    2020-12-30 12:01:49
    5 -fuse-linker-plugin -pipe -Wl,-rpath-link,/var/tmp/portage/sys-devel/clang-10.0.0/work/x/y/clang-abi_x86_64.amd64/./lib64 -Wl,-O3 -Wl,--gc-sections tools/extra/clang-doc/tool/CMakeFiles/clang-doc....
  • facebook-clang-plugins, clang分析器和clang前端插件 Facebook这个存储库的目标是分享一些有用的clang插件。它包含了两个插件到 clang编译器插件:分析器插件使用分析器的内部api查找并报告它们;前端插件直接处理...
  • Clang fixes

    2021-01-11 19:31:11
    <div><p>These commits add preliminary clang support to Cmake and offer a few workarounds for assembly stuff that doesn't compile under clang (clang seems to follow a slightly different syntax than...
  • auto-complete-clang, clang自动完整源 AC Clang Yasnippet ! 简介Clang的交流源。 结合交流。锣和Yasnippet的力量。如果你没有 Yasnippet,我建议你安装一个。 如果你不想安装 Yasnippet,你可以尝试使用 snippet....
  • Handle clang

    2020-12-26 04:54:29
    <div><p><code>clang</code> is a common C compiler. Some people (cough… me) prefer <code>clang</code> over <code>gcc</code> for mostly personal reasons and have <code>export CC=clang CXX=clang...
  • Clang format

    2020-12-25 18:00:38
    <div><p>Here is a run of clang-format on the whole code-base (excluding sub-modules) using: <pre><code>sh pre-commit run clang-format -a </code></pre> <p>I've tried to keep the configuration as ...
  • Forced Clang

    2020-12-26 23:29:59
    t compile it, in any case i know i can compile and install clang (i use gentoo 64), but is really necessary use clang? <p>Thx.</p><p>该提问来源于开源项目:EUA/wxHexEditor</p></div>
  • <p>I plan to either remove the example commit after making sure the clang-format file is complete or run clang-format on all files <p>Available clang-format options for the latest clang-format: ...
  • vim-clang 使用clang来解析和完成C / C ++源文件。 安装 需要安装可执行的clang 。 将plugin/的内容放入~/.vim/plugin 。 建议使用,例如 。 通过病原体安装是通过cd ~/.vim/bundle; git clone ...
  • ClangFormat-Xcode:Xcode插件,用于在Xcode中使用clang格式,并始终使用Clang格式化代码
  • <div><p>I installed LLVM 9.0.0 from the official ..., clang::AccessSpecifier, clang::Parser::DeclSpecContext, clang::Parser::LateParsedAttrList*) /build/llvm-toolchain-snapshot-9~svn366056/tools/clang...
  • <div><p>Doris is short...s better to add clang-format and clang-tidy. I will add some clang-format and clang-tidy in the following patch</p><p>该提问来源于开源项目:apache/incubator-doris</p></div>
  • linter-clang, 基于Clang的Lint文件 linter-clang 这个用于Linter插件的Linter插件为clang提供接口。 它将与具有"C "。"c"。"objective-c"和"objective-c "语法的文件一起使用。插件插件安装通过搜索
  • <div><p>If LLVM and Clang have not been installed into the same location it is necessary to specify the include directory for the clang headers separate from the LLVM include directory.</p><p>该提问...
  • 调试Clang

    2020-05-13 09:55:25
    使用VS code调试Clang VS code是一款非常好用的开发工具,是远程开发的必备利器。Clang虽是编译器,但对于程序员来说也是一个app,所以自然也可以使用gdb来调试。为了更好的学习Clang的代码,推荐使用VS code + gdb...

    使用VS code调试Clang

    VS code是一款非常好用的开发工具,是远程开发的必备利器。Clang虽是编译器,但对于程序员来说也是一个app,所以自然也可以使用gdb来调试。为了更好的学习Clang的代码,推荐使用VS code + gdb的方式直接debug Clang的代码,结合文档说明做到深入学习理解。

    编译Clang

    可以参考LLVM官网使用CMake命令编译,由于要debug,所以必须编译Debug版本的Clang。可参考使用下列编译命令:

    cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE="Debug" -DBUILD_SHARED_LIBS=True -DLLVM_USE_SPLIT_DWARF=True -DCMAKE_INSTALL_PREFIX="/home/user/prefix-test" -DLLVM_OPTIMIZED_TABLEGEN=True -DLLVM_BUILD_TESTS=True -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_ENABLE_PROJECTS="clang;llvm;compiler-rt" -DLLVM_ENABLE_ASSERTIONS=On ../llvm
    

    配置VS code

    VS code需要预先安装C++的插件,然后点击“RUN”---->“Open Configrations”,仅需要配置“program”和“args”两项即可

        "version": "0.2.0",
        "configurations": [
            {
                "name": "(gdb) Launch",
                "type": "cppdbg",
                "request": "launch",
                "program": "${workspaceFolder}/out/stage2-install/bin/clang++",//配置Clang编译结果路径
                "args": ["--target=riscv64 -o ${workspaceFolder}/test_c++.cpp.o -c++ ${workspaceFolder}/test_c++.cpp"], //Clang参数
                "stopAtEntry": false,
                "cwd": "${workspaceFolder}",
                "environment": [],
                "externalConsole": false,
                "MIMode": "gdb",
    

    调试

    完成以上步骤,就可以F5直接调试了!
    运行前先在Clang的main函数打个断点,位置在
    llvm-project/clang/tools/driver/driver.cpp
    调试界面

    展开全文
  • Clang浅尝辄止

    千次阅读 2018-03-13 14:58:36
    Clang是一个C语言、C++、Objective-C、Objective-C++语言的轻量级编译器。 我们可以使用clang命令来重写OC的.m文件(重写之后以C++文件的形式展现在相应的文件夹里头. 首先.我们使用cd命令或者是直接拖动的方式把...
  • <div><p>We should consider splitting Clang and Apple Clang into separate compilers, like <code>%clang</code> and <code>%apple</code>. <h3>Rationale <p>I'm trying to build the latest version of ...
  • The checks created const refs with the original types which resulted in clang warnings: https://cmssdt.cern.ch/SDT/jenkins-artifacts/pull-request-integration/PR-fc4bbb/7669/clang-new-warnings.log</p> ...
  • <div><p>This adds support for clang & clang-check. clang emits more friendly warnings. clang-check does static checking of compiled codes. The checker requires cmake to generate compile command ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,243
精华内容 14,497
关键字:

clang