한국어

네트워킹

온누리070 플레이스토어 다운로드
    acrobits softphone
     온누리 070 카카오 프러스 친구추가온누리 070 카카오 프러스 친구추가친추
     카카오톡 채팅 상담 카카오톡 채팅 상담카톡
    
     라인상담
     라인으로 공유

     페북공유

   ◎위챗 : speedseoul


  
     PAYPAL
     
     PRICE
     

pixel.gif

    before pay call 0088 from app


Which is better, GCC or Clang?


  • GCC supports languages that clang does not aim to, such as Java, Ada, FORTRAN, Go, etc.
  • GCC supports more targets than LLVM.
  • GCC supports many language extensions, some of which are not implemented by Clang. For instance, in C mode, GCC supports nested functions and has an extension allowing VLAs in structs.

Pro's of clang vs GCC:

  • The Clang ASTs and design are intended to be easily understandableby anyone who is familiar with the languages involved and who has a basic understanding of how a compiler works. GCC has a very old codebase which presents a steep learning curve to new developers.
  • Clang is designed as an API from its inception, allowing it to be reused by source analysis tools, refactoring, IDEs (etc) as well as for code generation. GCC is built as a monolithic static compiler, which makes it extremely difficult to use as an API and integrate into other tools. Further, its historic design and current policy makes it difficult to decouple the front-end from the rest of the compiler.
  • Various GCC design decisions make it very difficult to reuse: its build system is difficult to modify, you can't link multiple targets into one binary, you can't link multiple front-ends into one binary, it uses a custom garbage collector, uses global variables extensively, is not reentrant or multi-threadable, etc. Clang has none of these problems.
  • Clang does not implicitly simplify code as it parses it like GCC does. Doing so causes many problems for source analysis tools: as one simple example, if you write "x-x" in your source code, the GCC AST will contain "0", with no mention of 'x'. This is extremely bad for a refactoring tool that wants to rename 'x'.
  • Clang can serialize its AST out to disk and read it back into another program, which is useful for whole program analysis. GCC does not have this. GCC's PCH mechanism (which is just a dump of the compiler memory image) is related, but is architecturally only able to read the dump back into the exact same executable as the one that produced it (it is not a structured format).
  • Clang is much faster and uses far less memory than GCC.
  • Clang has been designed from the start to provide extremely clear and concise diagnostics (error and warning messages), and includes support for expressive diagnostics. Modern versions of GCC have made significant advances in this area, incorporating various Clang features such as preserving typedefs in diagnostics and showing macro expansions, but GCC is still catching up.
  • GCC is licensed under the GPL license. clang uses a BSD license,which allows it to be embedded in software that is not GPL-licensed.
  • Clang inherits a number of features from its use of LLVM as a backend, including support for a bytecode representation for intermediate code, pluggable optimizers, link-time optimization support, Just-In-Time compilation, ability to link in multiple code generators, etc.
  • Clang's support for C++ is more compliant than GCC's in many ways.
  • Clang supports many language extensions, some of which are not implemented by GCC. For instance, Clang provides attributes for checking thread safety and extended vector types.

So, As a final thought, I think clang is better. Clang is backed by Google, Apple and Microsoft too. Latest version of clang is 5.0 and Clang AST is more advanced used by professional and Clang tooling is cool also. For example, Clang-format works great with vim and emacs. Clang error message and warnings is more robust than GCC. Clang has thread sanitizer, ASAN(Address sanitizer), MSAN and finally LLVM(low level virtual machine) compiler infrastructure project is really cool.

Barry Rountree

If you’re doing compiler research, LLVM/Clang is much, much easier to modify as plugins were part of the original architecture.

If you’re wanting faster binaries, there’s no substitute for trying them both and measuring the results.

Anton Carver

I assume you mean G++ (not GCC which is either the C compiler or the whole compiler system).

G++ still tends to generate slightly faster code for most cases. Clang tends to be much stricter about conformance to the standard (though G++ seems to be getting better). Clang / LLVM is generally more tool friendly, if you are interested in manipulating C++ code in a tool. GCC is GPL and Clang is BSD License.

There isn’t much in it really, they are both pretty good

조회 수 :
62525
등록일 :
2018.06.13
14:25:20 (*.160.88.18)
엮인글 :
http://webs.co.kr/index.php?document_srl=3316316&act=trackback&key=bd7
게시글 주소 :
http://webs.co.kr/index.php?document_srl=3316316
List of Articles