1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 2 "http://www.w3.org/TR/html4/strict.dtd"> 3 <html> 4 <head> 5 <title>Clang Compiler User's Manual</title> 6 <link type="text/css" rel="stylesheet" href="../menu.css"> 7 <link type="text/css" rel="stylesheet" href="../content.css"> 8 <style type="text/css"> 9 td { 10 vertical-align: top; 11 } 12 </style> 13 </head> 14 <body> 15 16 <!--#include virtual="../menu.html.incl"--> 17 18 <div id="content"> 19 20 <h1>Clang Compiler User's Manual</h1> 21 22 <ul> 23 <li><a href="#intro">Introduction</a> 24 <ul> 25 <li><a href="#terminology">Terminology</a></li> 26 <li><a href="#basicusage">Basic Usage</a></li> 27 </ul> 28 </li> 29 <li><a href="#commandline">Command Line Options</a> 30 <ul> 31 <li><a href="#cl_diagnostics">Options to Control Error and Warning 32 Messages</a></li> 33 <li><a href="#cl_crash_diagnostics">Options to Control Clang Crash 34 Diagnostics</a></li> 35 </ul> 36 </li> 37 <li><a href="#general_features">Language and Target-Independent Features</a> 38 <ul> 39 <li><a href="#diagnostics">Controlling Errors and Warnings</a> 40 <ul> 41 <li><a href="#diagnostics_display">Controlling How Clang Displays Diagnostics</a></li> 42 <li><a href="#diagnostics_mappings">Diagnostic Mappings</a></li> 43 <li><a href="#diagnostics_categories">Diagnostic Categories</a></li> 44 <li><a href="#diagnostics_commandline">Controlling Diagnostics via Command Line Flags</a></li> 45 <li><a href="#diagnostics_pragmas">Controlling Diagnostics via Pragmas</a></li> 46 <li><a href="#diagnostics_enable_everything">Enabling All Warnings</a></li> 47 <li><a href="#analyzer_diagnositics">Controlling Static Analyzer Diagnostics</a></li> 48 </ul> 49 </li> 50 <li><a href="#precompiledheaders">Precompiled Headers</a></li> 51 <li><a href="#codegen">Controlling Code Generation</a></li> 52 </ul> 53 </li> 54 <li><a href="#c">C Language Features</a> 55 <ul> 56 <li><a href="#c_ext">Extensions supported by clang</a></li> 57 <li><a href="#c_modes">Differences between various standard modes</a></li> 58 <li><a href="#c_unimpl_gcc">GCC extensions not implemented yet</a></li> 59 <li><a href="#c_unsupp_gcc">Intentionally unsupported GCC extensions</a></li> 60 <li><a href="#c_ms">Microsoft extensions</a></li> 61 </ul> 62 </li> 63 <li><a href="#cxx">C++ Language Features</a> 64 <ul> 65 <li><a href="#cxx_implimits">Controlling implementation limits</a></li> 66 </ul> 67 </li> 68 <li><a href="#target_features">Target-Specific Features and Limitations</a> 69 <ul> 70 <li><a href="#target_arch">CPU Architectures Features and Limitations</a> 71 <ul> 72 <li><a href="#target_arch_x86">X86</a></li> 73 <li><a href="#target_arch_arm">ARM</a></li> 74 <li><a href="#target_arch_other">Other platforms</a></li> 75 </ul> 76 </li> 77 <li><a href="#target_os">Operating System Features and Limitations</a> 78 <ul> 79 <li><a href="#target_os_darwin">Darwin (Mac OS/X)</a></li> 80 <li>Linux, etc.</li> 81 <li><a href="#target_os_win32">Windows</a></li> 82 </ul> 83 </li> 84 </ul> 85 </li> 86 </ul> 87 88 89 <!-- ======================================================================= --> 90 <h2 id="intro">Introduction</h2> 91 <!-- ======================================================================= --> 92 93 <p>The Clang Compiler is an open-source compiler for the C family of programming 94 languages, aiming to be the best in class implementation of these languages. 95 Clang builds on the LLVM optimizer and code generator, allowing it to provide 96 high-quality optimization and code generation support for many targets. For 97 more general information, please see the <a href="http://clang.llvm.org">Clang 98 Web Site</a> or the <a href="http://llvm.org">LLVM Web Site</a>.</p> 99 100 <p>This document describes important notes about using Clang as a compiler for 101 an end-user, documenting the supported features, command line options, etc. If 102 you are interested in using Clang to build a tool that processes code, please 103 see <a href="InternalsManual.html">the Clang Internals Manual</a>. If you are 104 interested in the <a href="http://clang-analyzer.llvm.org">Clang 105 Static Analyzer</a>, please see its web page.</p> 106 107 <p>Clang is designed to support the C family of programming languages, which 108 includes <a href="#c">C</a>, <a href="#objc">Objective-C</a>, <a 109 href="#cxx">C++</a>, and <a href="#objcxx">Objective-C++</a> as well as many 110 dialects of those. For language-specific information, please see the 111 corresponding language specific section:</p> 112 113 <ul> 114 <li><a href="#c">C Language</a>: K&R C, ANSI C89, ISO C90, ISO C94 115 (C89+AMD1), ISO C99 (+TC1, TC2, TC3). </li> 116 <li><a href="#objc">Objective-C Language</a>: ObjC 1, ObjC 2, ObjC 2.1, plus 117 variants depending on base language.</li> 118 <li><a href="#cxx">C++ Language</a></li> 119 <li><a href="#objcxx">Objective C++ Language</a></li> 120 </ul> 121 122 <p>In addition to these base languages and their dialects, Clang supports a 123 broad variety of language extensions, which are documented in the corresponding 124 language section. These extensions are provided to be compatible with the GCC, 125 Microsoft, and other popular compilers as well as to improve functionality 126 through Clang-specific features. The Clang driver and language features are 127 intentionally designed to be as compatible with the GNU GCC compiler as 128 reasonably possible, easing migration from GCC to Clang. In most cases, code 129 "just works".</p> 130 131 <p>In addition to language specific features, Clang has a variety of features 132 that depend on what CPU architecture or operating system is being compiled for. 133 Please see the <a href="#target_features">Target-Specific Features and 134 Limitations</a> section for more details.</p> 135 136 <p>The rest of the introduction introduces some basic <a 137 href="#terminology">compiler terminology</a> that is used throughout this manual 138 and contains a basic <a href="#basicusage">introduction to using Clang</a> 139 as a command line compiler.</p> 140 141 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 142 <h3 id="terminology">Terminology</h3> 143 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 144 145 <p>Front end, parser, backend, preprocessor, undefined behavior, diagnostic, 146 optimizer</p> 147 148 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 149 <h3 id="basicusage">Basic Usage</h3> 150 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 151 152 <p>Intro to how to use a C compiler for newbies.</p> 153 <p> 154 compile + link 155 156 compile then link 157 158 debug info 159 160 enabling optimizations 161 162 picking a language to use, defaults to C99 by default. Autosenses based on 163 extension. 164 165 using a makefile 166 </p> 167 168 169 <!-- ======================================================================= --> 170 <h2 id="commandline">Command Line Options</h2> 171 <!-- ======================================================================= --> 172 173 <p> 174 This section is generally an index into other sections. It does not go into 175 depth on the ones that are covered by other sections. However, the first part 176 introduces the language selection and other high level options like -c, -g, etc. 177 </p> 178 179 180 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 181 <h3 id="cl_diagnostics">Options to Control Error and Warning Messages</h3> 182 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 183 184 <p><b>-Werror</b>: Turn warnings into errors.</p> 185 <p><b>-Werror=foo</b>: Turn warning "foo" into an error.</p> 186 <p><b>-Wno-error=foo</b>: Turn warning "foo" into an warning even if -Werror is 187 specified.</p> 188 <p><b>-Wfoo</b>: Enable warning foo</p> 189 <p><b>-Wno-foo</b>: Disable warning foo</p> 190 <p><b>-w</b>: Disable all warnings.</p> 191 <p><b>-pedantic</b>: Warn on language extensions.</p> 192 <p><b>-pedantic-errors</b>: Error on language extensions.</p> 193 <p><b>-Wsystem-headers</b>: Enable warnings from system headers.</p> 194 195 <p><b>-ferror-limit=123</b>: Stop emitting diagnostics after 123 errors have 196 been produced. The default is 20, and the error limit can be disabled with 197 -ferror-limit=0.</p> 198 199 <p><b>-ftemplate-backtrace-limit=123</b>: Only emit up to 123 template instantiation notes within the template instantiation backtrace for a single warning or error. The default is 10, and the limit can be disabled with -ftemplate-backtrace-limit=0.</p> 200 201 <!-- ================================================= --> 202 <h4 id="cl_diag_formatting">Formatting of Diagnostics</h4> 203 <!-- ================================================= --> 204 205 <p>Clang aims to produce beautiful diagnostics by default, particularly for new 206 users that first come to Clang. However, different people have different 207 preferences, and sometimes Clang is driven by another program that wants to 208 parse simple and consistent output, not a person. For these cases, Clang 209 provides a wide range of options to control the exact output format of the 210 diagnostics that it generates.</p> 211 212 <dl> 213 214 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 215 <dt id="opt_fshow-column"><b>-f[no-]show-column</b>: Print column number in 216 diagnostic.</dt> 217 <dd>This option, which defaults to on, controls whether or not Clang prints the 218 column number of a diagnostic. For example, when this is enabled, Clang will 219 print something like: 220 221 <pre> 222 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 223 #endif bad 224 ^ 225 // 226 </pre> 227 228 <p>When this is disabled, Clang will print "test.c:28: warning..." with no 229 column number.</p> 230 </dd> 231 232 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 233 <dt id="opt_fshow-source-location"><b>-f[no-]show-source-location</b>: Print 234 source file/line/column information in diagnostic.</dt> 235 <dd>This option, which defaults to on, controls whether or not Clang prints the 236 filename, line number and column number of a diagnostic. For example, 237 when this is enabled, Clang will print something like: 238 239 <pre> 240 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 241 #endif bad 242 ^ 243 // 244 </pre> 245 246 <p>When this is disabled, Clang will not print the "test.c:28:8: " part.</p> 247 </dd> 248 249 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 250 <dt id="opt_fcaret-diagnostics"><b>-f[no-]caret-diagnostics</b>: Print source 251 line and ranges from source code in diagnostic.</dt> 252 <dd>This option, which defaults to on, controls whether or not Clang prints the 253 source line, source ranges, and caret when emitting a diagnostic. For example, 254 when this is enabled, Clang will print something like: 255 256 <pre> 257 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 258 #endif bad 259 ^ 260 // 261 </pre> 262 </dd> 263 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 264 <dt id="opt_fcolor_diagnostics"><b>-f[no-]color-diagnostics</b>: </dt> 265 <dd>This option, which defaults to on when a color-capable terminal is 266 detected, controls whether or not Clang prints diagnostics in color. 267 When this option is enabled, Clang will use colors to highlight 268 specific parts of the diagnostic, e.g., 269 <pre> 270 <b><span style="color:black">test.c:28:8: <span style="color:magenta">warning</span>: extra tokens at end of #endif directive [-Wextra-tokens]</span></b> 271 #endif bad 272 <span style="color:green">^</span> 273 <span style="color:green">//</span> 274 </pre> 275 276 <p>When this is disabled, Clang will just print:</p> 277 278 <pre> 279 test.c:2:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 280 #endif bad 281 ^ 282 // 283 </pre> 284 </dd> 285 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 286 <dt id="opt_fdiagnostics-format"><b>-fdiagnostics-format=clang/msvc/vi</b>: 287 Changes diagnostic output format to better match IDEs and command line tools.</dt> 288 <dd>This option controls the output format of the filename, line number, and column printed in diagnostic messages. The options, and their affect on formatting a simple conversion diagnostic, follow: 289 290 <dl> 291 <dt><b>clang</b> (default)</dt> 292 <dd> 293 <pre>t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int'</pre> 294 </dd> 295 296 <dt><b>msvc</b></dt> 297 <dd> 298 <pre>t.c(3,11) : warning: conversion specifies type 'char *' but the argument has type 'int'</pre> 299 </dd> 300 301 <dt><b>vi</b></dt> 302 <dd> 303 <pre>t.c +3:11: warning: conversion specifies type 'char *' but the argument has type 'int'</pre> 304 </dd> 305 </dl> 306 </dd> 307 308 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 309 <dt id="opt_fdiagnostics-show-name"><b>-f[no-]diagnostics-show-name</b>: 310 Enable the display of the diagnostic name.</dt> 311 <dd>This option, which defaults to off, controls whether or not 312 Clang prints the associated name.<p></p></dd> 313 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 314 <dt id="opt_fdiagnostics-show-option"><b>-f[no-]diagnostics-show-option</b>: 315 Enable <tt>[-Woption]</tt> information in diagnostic line.</dt> 316 <dd>This option, which defaults to on, 317 controls whether or not Clang prints the associated <A 318 href="#cl_diag_warning_groups">warning group</a> option name when outputting 319 a warning diagnostic. For example, in this output: 320 321 <pre> 322 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 323 #endif bad 324 ^ 325 // 326 </pre> 327 328 <p>Passing <b>-fno-diagnostics-show-option</b> will prevent Clang from printing 329 the [<a href="#opt_Wextra-tokens">-Wextra-tokens</a>] information in the 330 diagnostic. This information tells you the flag needed to enable or disable the 331 diagnostic, either from the command line or through <a 332 href="#pragma_GCC_diagnostic">#pragma GCC diagnostic</a>.</dd> 333 334 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 335 <dt id="opt_fdiagnostics-show-category"><b>-fdiagnostics-show-category=none/id/name</b>: 336 Enable printing category information in diagnostic line.</dt> 337 <dd>This option, which defaults to "none", 338 controls whether or not Clang prints the category associated with a diagnostic 339 when emitting it. Each diagnostic may or many not have an associated category, 340 if it has one, it is listed in the diagnostic categorization field of the 341 diagnostic line (in the []'s). 342 343 <p>For example, a format string warning will produce these three renditions 344 based on the setting of this option:</p> 345 346 <pre> 347 t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat] 348 t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat<b>,1</b>] 349 t.c:3:11: warning: conversion specifies type 'char *' but the argument has type 'int' [-Wformat<b>,Format String</b>] 350 </pre> 351 352 <p>This category can be used by clients that want to group diagnostics by 353 category, so it should be a high level category. We want dozens of these, not 354 hundreds or thousands of them.</p> 355 </dd> 356 357 358 359 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 360 <dt id="opt_fdiagnostics-fixit-info"><b>-f[no-]diagnostics-fixit-info</b>: 361 Enable "FixIt" information in the diagnostics output.</dt> 362 <dd>This option, which defaults to on, controls whether or not Clang prints the 363 information on how to fix a specific diagnostic underneath it when it knows. 364 For example, in this output: 365 366 <pre> 367 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 368 #endif bad 369 ^ 370 // 371 </pre> 372 373 <p>Passing <b>-fno-diagnostics-fixit-info</b> will prevent Clang from printing 374 the "//" line at the end of the message. This information is useful for users 375 who may not understand what is wrong, but can be confusing for machine 376 parsing.</p> 377 </dd> 378 379 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 380 <dt id="opt_fdiagnostics-print-source-range-info"> 381 <b>-f[no-]diagnostics-print-source-range-info</b>: 382 Print machine parsable information about source ranges.</dt> 383 <dd>This option, which defaults to off, controls whether or not Clang prints 384 information about source ranges in a machine parsable format after the 385 file/line/column number information. The information is a simple sequence of 386 brace enclosed ranges, where each range lists the start and end line/column 387 locations. For example, in this output: 388 389 <pre> 390 exprs.c:47:15:{47:8-47:14}{47:17-47:24}: error: invalid operands to binary expression ('int *' and '_Complex float') 391 P = (P-42) + Gamma*4; 392 ~~~~~~ ^ ~~~~~~~ 393 </pre> 394 395 <p>The {}'s are generated by -fdiagnostics-print-source-range-info.</p> 396 </dd> 397 398 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 399 <dt id="opt_fdiagnostics-parseable-fixits"> 400 <b>-fdiagnostics-parseable-fixits</b>: 401 Print Fix-Its in a machine parseable form.</dt> 402 <dd><p>This option makes Clang print available Fix-Its in a machine parseable format at the end of diagnostics. The following example illustrates the format:</p> 403 404 <pre> 405 fix-it:"t.cpp":{7:25-7:29}:"Gamma" 406 </pre> 407 408 <p>The range printed is a half-open range, so in this example the characters at 409 column 25 up to but not including column 29 on line 7 in t.cpp should be 410 replaced with the string "Gamma". Either the range or the replacement 411 string may be empty (representing strict insertions and strict erasures, 412 respectively). Both the file name and the insertion string escape backslash (as 413 "\\"), tabs (as "\t"), newlines (as "\n"), double 414 quotes(as "\"") and non-printable characters (as octal 415 "\xxx").</p> 416 </dd> 417 418 </dl> 419 420 421 422 <!-- ===================================================== --> 423 <h4 id="cl_diag_warning_groups">Individual Warning Groups</h4> 424 <!-- ===================================================== --> 425 426 <p>TODO: Generate this from tblgen. Define one anchor per warning group.</p> 427 428 429 <dl> 430 431 432 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 433 <dt id="opt_Wextra-tokens"><b>-Wextra-tokens</b>: Warn about excess tokens at 434 the end of a preprocessor directive.</dt> 435 <dd>This option, which defaults to on, enables warnings about extra tokens at 436 the end of preprocessor directives. For example: 437 438 <pre> 439 test.c:28:8: warning: extra tokens at end of #endif directive [-Wextra-tokens] 440 #endif bad 441 ^ 442 </pre> 443 444 <p>These extra tokens are not strictly conforming, and are usually best handled 445 by commenting them out.</p> 446 447 <p>This option is also enabled by <a href="">-Wfoo</a>, <a href="">-Wbar</a>, 448 and <a href="">-Wbaz</a>.</p> 449 </dd> 450 451 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 452 <dt id="opt_Wambiguous-member-template"><b>-Wambiguous-member-template</b>: 453 Warn about unqualified uses of a member template whose name resolves 454 to another template at the location of the use.</dt> 455 <dd>This option, which defaults to on, enables a warning in the 456 following code: 457 458 <pre> 459 template<typename T> struct set{}; 460 template<typename T> struct trait { typedef const T& type; }; 461 struct Value { 462 template<typename T> void set(typename trait<T>::type value) {} 463 }; 464 void foo() { 465 Value v; 466 v.set<double>(3.2); 467 } 468 </pre> 469 470 <p>C++ [basic.lookup.classref] requires this to be an error, but, 471 because it's hard to work around, Clang downgrades it to a warning as 472 an extension.</p> 473 </dd> 474 475 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 476 <dt id="opt_Wbind-to-temporary-copy"><b>-Wbind-to-temporary-copy</b>: Warn about 477 an unusable copy constructor when binding a reference to a temporary.</dt> 478 <dd>This option, which defaults to on, enables warnings about binding a 479 reference to a temporary when the temporary doesn't have a usable copy 480 constructor. For example: 481 482 <pre> 483 struct NonCopyable { 484 NonCopyable(); 485 private: 486 NonCopyable(const NonCopyable&); 487 }; 488 void foo(const NonCopyable&); 489 void bar() { 490 foo(NonCopyable()); // Disallowed in C++98; allowed in C++11. 491 } 492 </pre> 493 <pre> 494 struct NonCopyable2 { 495 NonCopyable2(); 496 NonCopyable2(NonCopyable2&); 497 }; 498 void foo(const NonCopyable2&); 499 void bar() { 500 foo(NonCopyable2()); // Disallowed in C++98; allowed in C++11. 501 } 502 </pre> 503 504 <p>Note that if <tt>NonCopyable2::NonCopyable2()</tt> has a default 505 argument whose instantiation produces a compile error, that error will 506 still be a hard error in C++98 mode even if this warning is turned 507 off.</p> 508 509 </dd> 510 511 </dl> 512 513 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 514 <h3 id="cl_crash_diagnostics">Options to Control Clang Crash Diagnostics</h3> 515 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 516 517 <p>As unbelievable as it may sound, Clang does crash from time to time. 518 Generally, this only occurs to those living on the 519 <a href="http://llvm.org/releases/download.html#svn">bleeding edge</a>. Clang 520 goes to great lengths to assist you in filing a bug report. Specifically, Clang 521 generates preprocessed source file(s) and associated run script(s) upon a 522 crash. These files should be attached to a bug report to ease reproducibility 523 of the failure. Below are the command line options to control the crash 524 diagnostics. 525 </p> 526 527 <p><b>-fno-crash-diagnostics</b>: Disable auto-generation of preprocessed 528 source files during a clang crash.</p> 529 530 <p>The -fno-crash-diagnostics flag can be helpful for speeding the process of 531 generating a delta reduced test case.</p> 532 533 534 <!-- ======================================================================= --> 535 <h2 id="general_features">Language and Target-Independent Features</h2> 536 <!-- ======================================================================= --> 537 538 539 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 540 <h3 id="diagnostics">Controlling Errors and Warnings</h3> 541 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 542 543 <p>Clang provides a number of ways to control which code constructs cause it to 544 emit errors and warning messages, and how they are displayed to the console.</p> 545 546 <h4 id="diagnostics_display">Controlling How Clang Displays Diagnostics</h4> 547 548 <p>When Clang emits a diagnostic, it includes rich information in the output, 549 and gives you fine-grain control over which information is printed. Clang has 550 the ability to print this information, and these are the options that control 551 it:</p> 552 553 <ol> 554 <li>A file/line/column indicator that shows exactly where the diagnostic occurs 555 in your code [<a href="#opt_fshow-column">-fshow-column</a>, <a 556 href="#opt_fshow-source-location">-fshow-source-location</a>].</li> 557 <li>A categorization of the diagnostic as a note, warning, error, or fatal 558 error.</li> 559 <li>A text string that describes what the problem is.</li> 560 <li>An option that indicates how to control the diagnostic (for diagnostics that 561 support it) [<a 562 href="#opt_fdiagnostics-show-option">-fdiagnostics-show-option</a>].</li> 563 <li>A <a href="#diagnostics_categories">high-level category</a> for the 564 diagnostic for clients that want to group diagnostics by class (for 565 diagnostics that support it) [<a 566 href="#opt_fdiagnostics-show-category">-fdiagnostics-show-category</a>].</li> 567 <li>The line of source code that the issue occurs on, along with a caret and 568 ranges that indicate the important locations [<a 569 href="opt_fcaret-diagnostics">-fcaret-diagnostics</a>].</li> 570 <li>"FixIt" information, which is a concise explanation of how to fix the 571 problem (when Clang is certain it knows) [<a 572 href="opt_fdiagnostics-fixit-info">-fdiagnostics-fixit-info</a>].</li> 573 <li>A machine-parsable representation of the ranges involved (off by 574 default) [<a 575 href="opt_fdiagnostics-print-source-range-info">-fdiagnostics-print-source-range-info</a>].</li> 576 </ol> 577 578 <p>For more information please see <a href="#cl_diag_formatting">Formatting of 579 Diagnostics</a>.</p> 580 581 582 <h4 id="diagnostics_mappings">Diagnostic Mappings</h4> 583 584 <p>All diagnostics are mapped into one of these 5 classes:</p> 585 586 <ul> 587 <li>Ignored</li> 588 <li>Note</li> 589 <li>Warning</li> 590 <li>Error</li> 591 <li>Fatal</li> 592 </ul> 593 594 <h4 id="diagnostics_categories">Diagnostic Categories</h4> 595 596 <p>Though not shown by default, diagnostics may each be associated with a 597 high-level category. This category is intended to make it possible to triage 598 builds that produce a large number of errors or warnings in a grouped way. 599 </p> 600 601 <p>Categories are not shown by default, but they can be turned on with the 602 <a href="#opt_fdiagnostics-show-category">-fdiagnostics-show-category</a> option. 603 When set to "<tt>name</tt>", the category is printed textually in the diagnostic 604 output. When it is set to "<tt>id</tt>", a category number is printed. The 605 mapping of category names to category id's can be obtained by running '<tt>clang 606 --print-diagnostic-categories</tt>'. 607 </p> 608 609 <h4 id="diagnostics_commandline">Controlling Diagnostics via Command Line 610 Flags</h4> 611 612 <p>-W flags, -pedantic, etc</p> 613 614 <h4 id="diagnostics_pragmas">Controlling Diagnostics via Pragmas</h4> 615 616 <p>Clang can also control what diagnostics are enabled through the use of 617 pragmas in the source code. This is useful for turning off specific warnings 618 in a section of source code. Clang supports GCC's pragma for compatibility 619 with existing source code, as well as several extensions. </p> 620 621 <p>The pragma may control any warning that can be used from the command line. 622 Warnings may be set to ignored, warning, error, or fatal. The following 623 example code will tell Clang or GCC to ignore the -Wall warnings:</p> 624 625 <pre> 626 #pragma GCC diagnostic ignored "-Wall" 627 </pre> 628 629 <p>In addition to all of the functionality provided by GCC's pragma, Clang 630 also allows you to push and pop the current warning state. This is particularly 631 useful when writing a header file that will be compiled by other people, because 632 you don't know what warning flags they build with.</p> 633 634 <p>In the below example 635 -Wmultichar is ignored for only a single line of code, after which the 636 diagnostics return to whatever state had previously existed.</p> 637 638 <pre> 639 #pragma clang diagnostic push 640 #pragma clang diagnostic ignored "-Wmultichar" 641 642 char b = 'df'; // no warning. 643 644 #pragma clang diagnostic pop 645 </pre> 646 647 <p>The push and pop pragmas will save and restore the full diagnostic state of 648 the compiler, regardless of how it was set. That means that it is possible to 649 use push and pop around GCC compatible diagnostics and Clang will push and pop 650 them appropriately, while GCC will ignore the pushes and pops as unknown 651 pragmas. It should be noted that while Clang supports the GCC pragma, Clang and 652 GCC do not support the exact same set of warnings, so even when using GCC 653 compatible #pragmas there is no guarantee that they will have identical behaviour 654 on both compilers. </p> 655 656 <h4 id="diagnostics_enable_everything">Enabling All Warnings</h4> 657 658 <p>In addition to the traditional <tt>-W</tt> flags, one can enable <b>all</b> 659 warnings by passing <tt>-Weverything</tt>. 660 This works as expected with <tt>-Werror</tt>, 661 and also includes the warnings from <tt>-pedantic</tt>.</p> 662 663 <p>Note that when combined with <tt>-w</tt> (which disables all warnings), that 664 flag wins.</p> 665 666 <h4 id="analyzer_diagnositics">Controlling Static Analyzer Diagnostics</h4> 667 668 <p>While not strictly part of the compiler, the diagnostics from Clang's <a 669 href="http://clang-analyzer.llvm.org">static analyzer</a> can also be influenced 670 by the user via changes to the source code. This can be done in two ways: 671 672 <ul> 673 674 <li id="analyzer_annotations"><b>Annotations</b>: The static analyzer recognizes various GCC-style 675 attributes (e.g., <tt>__attribute__((nonnull)))</tt>) that can either suppress 676 static analyzer warnings or teach the analyzer about code invariants which 677 enable it to find more bugs. While many of these attributes are standard GCC 678 attributes, additional ones have been added to Clang to specifically support the 679 static analyzer. Detailed information on these annotations can be found in the 680 <a href="http://clang-analyzer.llvm.org/annotations.html">analyzer's 681 documentation</a>.</li> 682 683 <li><b><tt>__clang_analyzer__</tt></b>: When the static analyzer is using Clang 684 to parse source files, it implicitly defines the preprocessor macro 685 <tt>__clang_analyzer__</tt>. While discouraged, code can use this macro to 686 selectively exclude code the analyzer examines. Here is an example: 687 688 <pre> 689 #ifndef __clang_analyzer__ 690 // Code not to be analyzed 691 #endif 692 </pre> 693 694 In general, this usage is discouraged. Instead, we prefer that users file bugs 695 against the analyzer when it flags false positives. There is also active 696 discussion of allowing users in the future to selectively silence specific 697 analyzer warnings (some of which can already be done using <a 698 href="#analyzer_annotations">annotations</a>).</li> 699 700 </ul> 701 702 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 703 <h3 id="precompiledheaders">Precompiled Headers</h3> 704 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 705 706 <p><a href="http://en.wikipedia.org/wiki/Precompiled_header">Precompiled 707 headers</a> are a general approach employed by many compilers to reduce 708 compilation time. The underlying motivation of the approach is that it is 709 common for the same (and often large) header files to be included by 710 multiple source files. Consequently, compile times can often be greatly improved 711 by caching some of the (redundant) work done by a compiler to process headers. 712 Precompiled header files, which represent one of many ways to implement 713 this optimization, are literally files that represent an on-disk cache that 714 contains the vital information necessary to reduce some of the work 715 needed to process a corresponding header file. While details of precompiled 716 headers vary between compilers, precompiled headers have been shown to be 717 highly effective at speeding up program compilation on systems with very large 718 system headers (e.g., Mac OS/X).</p> 719 720 <h4>Generating a PCH File</h4> 721 722 <p>To generate a PCH file using Clang, one invokes Clang with 723 the <b><tt>-x <i><language></i>-header</tt></b> option. This mirrors the 724 interface in GCC for generating PCH files:</p> 725 726 <pre> 727 $ gcc -x c-header test.h -o test.h.gch 728 $ clang -x c-header test.h -o test.h.pch 729 </pre> 730 731 <h4>Using a PCH File</h4> 732 733 <p>A PCH file can then be used as a prefix header when a 734 <b><tt>-include</tt></b> option is passed to <tt>clang</tt>:</p> 735 736 <pre> 737 $ clang -include test.h test.c -o test 738 </pre> 739 740 <p>The <tt>clang</tt> driver will first check if a PCH file for <tt>test.h</tt> 741 is available; if so, the contents of <tt>test.h</tt> (and the files it includes) 742 will be processed from the PCH file. Otherwise, Clang falls back to 743 directly processing the content of <tt>test.h</tt>. This mirrors the behavior of 744 GCC.</p> 745 746 <p><b>NOTE:</b> Clang does <em>not</em> automatically use PCH files 747 for headers that are directly included within a source file. For example:</p> 748 749 <pre> 750 $ clang -x c-header test.h -o test.h.pch 751 $ cat test.c 752 #include "test.h" 753 $ clang test.c -o test 754 </pre> 755 756 <p>In this example, <tt>clang</tt> will not automatically use the PCH file for 757 <tt>test.h</tt> since <tt>test.h</tt> was included directly in the source file 758 and not specified on the command line using <tt>-include</tt>.</p> 759 760 <h4>Relocatable PCH Files</h4> 761 <p>It is sometimes necessary to build a precompiled header from headers that 762 are not yet in their final, installed locations. For example, one might build a 763 precompiled header within the build tree that is then meant to be installed 764 alongside the headers. Clang permits the creation of "relocatable" precompiled 765 headers, which are built with a given path (into the build directory) and can 766 later be used from an installed location.</p> 767 768 <p>To build a relocatable precompiled header, place your headers into a 769 subdirectory whose structure mimics the installed location. For example, if you 770 want to build a precompiled header for the header <code>mylib.h</code> that 771 will be installed into <code>/usr/include</code>, create a subdirectory 772 <code>build/usr/include</code> and place the header <code>mylib.h</code> into 773 that subdirectory. If <code>mylib.h</code> depends on other headers, then 774 they can be stored within <code>build/usr/include</code> in a way that mimics 775 the installed location.</p> 776 777 <p>Building a relocatable precompiled header requires two additional arguments. 778 First, pass the <code>--relocatable-pch</code> flag to indicate that the 779 resulting PCH file should be relocatable. Second, pass 780 <code>-isysroot /path/to/build</code>, which makes all includes for your 781 library relative to the build directory. For example:</p> 782 783 <pre> 784 # clang -x c-header --relocatable-pch -isysroot /path/to/build /path/to/build/mylib.h mylib.h.pch 785 </pre> 786 787 <p>When loading the relocatable PCH file, the various headers used in the PCH 788 file are found from the system header root. For example, <code>mylib.h</code> 789 can be found in <code>/usr/include/mylib.h</code>. If the headers are installed 790 in some other system root, the <code>-isysroot</code> option can be used provide 791 a different system root from which the headers will be based. For example, 792 <code>-isysroot /Developer/SDKs/MacOSX10.4u.sdk</code> will look for 793 <code>mylib.h</code> in 794 <code>/Developer/SDKs/MacOSX10.4u.sdk/usr/include/mylib.h</code>.</p> 795 796 <p>Relocatable precompiled headers are intended to be used in a limited number 797 of cases where the compilation environment is tightly controlled and the 798 precompiled header cannot be generated after headers have been installed. 799 Relocatable precompiled headers also have some performance impact, because 800 the difference in location between the header locations at PCH build time vs. 801 at the time of PCH use requires one of the PCH optimizations, 802 <code>stat()</code> caching, to be disabled. However, this change is only 803 likely to affect PCH files that reference a large number of headers.</p> 804 805 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 806 <h3 id="codegen">Controlling Code Generation</h3> 807 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 808 809 <p>Clang provides a number of ways to control code generation. The options are listed below.</p> 810 811 <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --> 812 <dl> 813 <dt id="opt_fcatch-undefined-behavior"><b>-fcatch-undefined-behavior</b>: Turn 814 on runtime code generation to check for undefined behavior.</dt> 815 816 <dd>This option, which defaults to off, controls whether or not Clang 817 adds runtime checks for undefined runtime behavior. If a check fails, 818 <tt>__builtin_trap()</tt> is used to indicate failure. 819 The checks are: 820 <ul> 821 <li>Subscripting where the static type of one operand is a variable 822 which is decayed from an array type and the other operand is 823 greater than the size of the array or less than zero.</li> 824 <li>Shift operators where the amount shifted is greater or equal to the 825 promoted bit-width of the left-hand-side or less than zero.</li> 826 <li>If control flow reaches __builtin_unreachable. 827 <li>When llvm implements more __builtin_object_size support, reads and 828 writes for objects that __builtin_object_size indicates we aren't 829 accessing valid memory. Bit-fields and vectors are not yet checked. 830 </ul> 831 </dd> 832 833 <dt id="opt_faddress-sanitizer"><b>-f[no-]address-sanitizer</b>: 834 Turn on <a href="AddressSanitizer.html">AddressSanitizer</a>, 835 a memory error detector. 836 837 <dt id="opt_fthread-sanitizer"><b>-f[no-]thread-sanitizer</b>: 838 Turn on ThreadSanitizer, an <em>experimental</em> data race detector. 839 Not ready for widespread use. 840 841 <dt id="opt_fno-assume-sane-operator-new"><b>-fno-assume-sane-operator-new</b>: 842 Don't assume that the C++'s new operator is sane.</dt> 843 <dd>This option tells the compiler to do not assume that C++'s global new 844 operator will always return a pointer that does not 845 alias any other pointer when the function returns.</dd> 846 847 <dt id="opt_ftrap-function"><b>-ftrap-function=[name]</b>: Instruct code 848 generator to emit a function call to the specified function name for 849 <tt>__builtin_trap()</tt>.</dt> 850 851 <dd>LLVM code generator translates <tt>__builtin_trap()</tt> to a trap 852 instruction if it is supported by the target ISA. Otherwise, the builtin is 853 translated into a call to <tt>abort</tt>. If this option is set, then the code 854 generator will always lower the builtin to a call to the specified function 855 regardless of whether the target ISA has a trap instruction. This option is 856 useful for environments (e.g. deeply embedded) where a trap cannot be properly 857 handled, or when some custom behavior is desired.</dd> 858 </dl> 859 860 <!-- ======================================================================= --> 861 <h2 id="c">C Language Features</h2> 862 <!-- ======================================================================= --> 863 864 <p>The support for standard C in clang is feature-complete except for the C99 865 floating-point pragmas.</p> 866 867 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 868 <h3 id="c_ext">Extensions supported by clang</h3> 869 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 870 871 <p>See <a href="LanguageExtensions.html">clang language extensions</a>.</p> 872 873 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 874 <h3 id="c_modes">Differences between various standard modes</h3> 875 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 876 877 <p>clang supports the -std option, which changes what language mode clang uses. 878 The supported modes for C are c89, gnu89, c94, c99, gnu99 and various aliases 879 for those modes. If no -std option is specified, clang defaults to gnu99 mode. 880 </p> 881 882 <p>Differences between all c* and gnu* modes:</p> 883 <ul> 884 <li>c* modes define "__STRICT_ANSI__".</li> 885 <li>Target-specific defines not prefixed by underscores, like "linux", are 886 defined in gnu* modes.</li> 887 <li>Trigraphs default to being off in gnu* modes; they can be enabled by the 888 -trigraphs option.</li> 889 <li>The parser recognizes "asm" and "typeof" as keywords in gnu* modes; the 890 variants "__asm__" and "__typeof__" are recognized in all modes.</li> 891 <li>The Apple "blocks" extension is recognized by default in gnu* modes 892 on some platforms; it can be enabled in any mode with the "-fblocks" 893 option.</li> 894 <li>Arrays that are VLA's according to the standard, but which can be constant 895 folded by the frontend are treated as fixed size arrays. This occurs for 896 things like "int X[(1, 2)];", which is technically a VLA. c* modes are 897 strictly compliant and treat these as VLAs.</li> 898 </ul> 899 900 <p>Differences between *89 and *99 modes:</p> 901 <ul> 902 <li>The *99 modes default to implementing "inline" as specified in C99, while 903 the *89 modes implement the GNU version. This can be overridden for individual 904 functions with the __gnu_inline__ attribute.</li> 905 <li>Digraphs are not recognized in c89 mode.</li> 906 <li>The scope of names defined inside a "for", "if", "switch", "while", or "do" 907 statement is different. (example: "if ((struct x {int x;}*)0) {}".)</li> 908 <li>__STDC_VERSION__ is not defined in *89 modes.</li> 909 <li>"inline" is not recognized as a keyword in c89 mode.</li> 910 <li>"restrict" is not recognized as a keyword in *89 modes.</li> 911 <li>Commas are allowed in integer constant expressions in *99 modes.</li> 912 <li>Arrays which are not lvalues are not implicitly promoted to pointers in 913 *89 modes.</li> 914 <li>Some warnings are different.</li> 915 </ul> 916 917 <p>c94 mode is identical to c89 mode except that digraphs are enabled in 918 c94 mode (FIXME: And __STDC_VERSION__ should be defined!).</p> 919 920 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 921 <h3 id="c_unimpl_gcc">GCC extensions not implemented yet</h3> 922 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 923 924 <p>clang tries to be compatible with gcc as much as possible, but some gcc 925 extensions are not implemented yet:</p> 926 927 <ul> 928 929 <li>clang does not support #pragma weak 930 (<a href="http://llvm.org/bugs/show_bug.cgi?id=3679">bug 3679</a>). Due to 931 the uses described in the bug, this is likely to be implemented at some 932 point, at least partially.</li> 933 934 <li>clang does not support decimal floating point types (_Decimal32 and 935 friends) or fixed-point types (_Fract and friends); nobody has expressed 936 interest in these features yet, so it's hard to say when they will be 937 implemented.</li> 938 939 <li>clang does not support nested functions; this is a complex feature which 940 is infrequently used, so it is unlikely to be implemented anytime soon.</li> 941 942 <li>clang does not support global register variables, this is unlikely 943 to be implemented soon because it requires additional LLVM backend support. 944 </li> 945 946 <li>clang does not support static initialization of flexible array 947 members. This appears to be a rarely used extension, but could be 948 implemented pending user demand.</li> 949 950 <li>clang does not support __builtin_va_arg_pack/__builtin_va_arg_pack_len. 951 This is used rarely, but in some potentially interesting places, like the 952 glibc headers, so it may be implemented pending user demand. Note that 953 because clang pretends to be like GCC 4.2, and this extension was introduced 954 in 4.3, the glibc headers will not try to use this extension with clang at 955 the moment.</li> 956 957 <li>clang does not support the gcc extension for forward-declaring function 958 parameters; this has not showed up in any real-world code yet, though, so it 959 might never be implemented.</li> 960 961 </ul> 962 963 <p>This is not a complete list; if you find an unsupported extension 964 missing from this list, please send an e-mail to cfe-dev. This list 965 currently excludes C++; see <a href="#cxx">C++ Language Features</a>. 966 Also, this list does not include bugs in mostly-implemented features; please 967 see the <a href="http://llvm.org/bugs/buglist.cgi?quicksearch=product%3Aclang+component%3A-New%2BBugs%2CAST%2CBasic%2CDriver%2CHeaders%2CLLVM%2BCodeGen%2Cparser%2Cpreprocessor%2CSemantic%2BAnalyzer"> 968 bug tracker</a> for known existing bugs (FIXME: Is there a section for 969 bug-reporting guidelines somewhere?).</p> 970 971 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 972 <h3 id="c_unsupp_gcc">Intentionally unsupported GCC extensions</h3> 973 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 974 975 <ul> 976 977 <li>clang does not support the gcc extension that allows variable-length arrays 978 in structures. This is for a few reasons: one, it is tricky 979 to implement, two, the extension is completely undocumented, and three, the 980 extension appears to be rarely used. Note that clang <em>does</em> support 981 flexible array members (arrays with a zero or unspecified size at the end of 982 a structure).</li> 983 984 <li>clang does not have an equivalent to gcc's "fold"; this means that 985 clang doesn't accept some constructs gcc might accept in contexts where a 986 constant expression is required, like "x-x" where x is a variable.</li> 987 988 <li>clang does not support __builtin_apply and friends; this extension is 989 extremely obscure and difficult to implement reliably.</li> 990 991 </ul> 992 993 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 994 <h3 id="c_ms">Microsoft extensions</h3> 995 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 996 997 <p>clang has some experimental support for extensions from 998 Microsoft Visual C++; to enable it, use the -fms-extensions command-line 999 option. This is the default for Windows targets. Note that the 1000 support is incomplete; enabling Microsoft extensions will silently drop 1001 certain constructs (including __declspec and Microsoft-style asm statements). 1002 </p> 1003 1004 <ul> 1005 <li>clang allows setting _MSC_VER with -fmsc-version=. It defaults to 1300 which 1006 is the same as Visual C/C++ 2003. Any number is supported and can greatly affect 1007 what Windows SDK and c++stdlib headers clang can compile. This option will be 1008 removed when clang supports the full set of MS extensions required for these 1009 headers.</li> 1010 1011 <li>clang does not support the Microsoft extension where anonymous 1012 record members can be declared using user defined typedefs.</li> 1013 1014 <li>clang supports the Microsoft "#pragma pack" feature for 1015 controlling record layout. GCC also contains support for this feature, 1016 however where MSVC and GCC are incompatible clang follows the MSVC 1017 definition.</li> 1018 </ul> 1019 1020 <!-- ======================================================================= --> 1021 <h2 id="cxx">C++ Language Features</h2> 1022 <!-- ======================================================================= --> 1023 1024 <p>clang fully implements all of standard C++98 except for exported templates 1025 (which were removed in C++11), and 1026 <a href="http://clang.llvm.org/cxx_status.html">many C++11 features</a> are also 1027 implemented.</p> 1028 1029 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1030 <h3 id="cxx_implimits">Controlling implementation limits</h3> 1031 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1032 1033 <p><b>-fconstexpr-depth=N</b>: Sets the limit for recursive constexpr function 1034 invocations to N. The default is 512.</p> 1035 1036 <p><b>-ftemplate-depth=N</b>: Sets the limit for recursively nested template 1037 instantiations to N. The default is 1024.</p> 1038 1039 <!-- ======================================================================= --> 1040 <h2 id="target_features">Target-Specific Features and Limitations</h2> 1041 <!-- ======================================================================= --> 1042 1043 1044 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1045 <h3 id="target_arch">CPU Architectures Features and Limitations</h3> 1046 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1047 1048 <!-- ======================== --> 1049 <h4 id="target_arch_x86">X86</h4> 1050 <!-- ======================== --> 1051 1052 <p>The support for X86 (both 32-bit and 64-bit) is considered stable on Darwin 1053 (Mac OS/X), Linux, FreeBSD, and Dragonfly BSD: it has been tested to correctly 1054 compile many large C, C++, Objective-C, and Objective-C++ codebases.</p> 1055 1056 <p>On x86_64-mingw32, passing i128(by value) is incompatible to Microsoft x64 1057 calling conversion. You might need to tweak WinX86_64ABIInfo::classify() 1058 in lib/CodeGen/TargetInfo.cpp.</p> 1059 1060 <!-- ======================== --> 1061 <h4 id="target_arch_arm">ARM</h4> 1062 <!-- ======================== --> 1063 1064 <p>The support for ARM (specifically ARMv6 and ARMv7) is considered stable on 1065 Darwin (iOS): it has been tested to correctly compile many large C, C++, 1066 Objective-C, and Objective-C++ codebases. Clang only supports a limited number 1067 of ARM architectures. It does not yet fully support ARMv5, for example.</p> 1068 1069 <!-- ======================== --> 1070 <h4 id="target_arch_other">Other platforms</h4> 1071 <!-- ======================== --> 1072 clang currently contains some support for PPC and Sparc; however, significant 1073 pieces of code generation are still missing, and they haven't undergone 1074 significant testing. 1075 1076 <p>clang contains limited support for the MSP430 embedded processor, but both 1077 the clang support and the LLVM backend support are highly experimental. 1078 1079 <p>Other platforms are completely unsupported at the moment. Adding the 1080 minimal support needed for parsing and semantic analysis on a new platform 1081 is quite easy; see lib/Basic/Targets.cpp in the clang source tree. This level 1082 of support is also sufficient for conversion to LLVM IR for simple programs. 1083 Proper support for conversion to LLVM IR requires adding code to 1084 lib/CodeGen/CGCall.cpp at the moment; this is likely to change soon, though. 1085 Generating assembly requires a suitable LLVM backend. 1086 1087 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1088 <h3 id="target_os">Operating System Features and Limitations</h3> 1089 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --> 1090 1091 <!-- ======================================= --> 1092 <h4 id="target_os_darwin">Darwin (Mac OS/X)</h4> 1093 <!-- ======================================= --> 1094 1095 <p>No __thread support, 64-bit ObjC support requires SL tools.</p> 1096 1097 <!-- ======================================= --> 1098 <h4 id="target_os_win32">Windows</h4> 1099 <!-- ======================================= --> 1100 1101 <p>Experimental supports are on Cygming.</p> 1102 1103 <h5>Cygwin</h5> 1104 1105 <p>Clang works on Cygwin-1.7.</p> 1106 1107 <h5>MinGW32</h5> 1108 1109 <p>Clang works on some mingw32 distributions. 1110 Clang assumes directories as below;</p> 1111 1112 <ul> 1113 <li><tt>C:/mingw/include</tt></li> 1114 <li><tt>C:/mingw/lib</tt></li> 1115 <li><tt>C:/mingw/lib/gcc/mingw32/4.[3-5].0/include/c++</tt></li> 1116 </ul> 1117 1118 <p>On MSYS, a few tests might fail.</p> 1119 1120 <h5>MinGW-w64</h5> 1121 1122 <p>For 32-bit (i686-w64-mingw32), and 64-bit (x86_64-w64-mingw32), Clang assumes as below;<p> 1123 1124 <ul> 1125 <li><tt>GCC versions 4.5.0 to 4.5.3, 4.6.0 to 4.6.2, or 4.7.0 (for the C++ header search path)</tt></li> 1126 <li><tt>some_directory/bin/gcc.exe</tt></li> 1127 <li><tt>some_directory/bin/clang.exe</tt></li> 1128 <li><tt>some_directory/bin/clang++.exe</tt></li> 1129 <li><tt>some_directory/bin/../include/c++/GCC_version</tt></li> 1130 <li><tt>some_directory/bin/../include/c++/GCC_version/x86_64-w64-mingw32</tt></li> 1131 <li><tt>some_directory/bin/../include/c++/GCC_version/i686-w64-mingw32</tt></li> 1132 <li><tt>some_directory/bin/../include/c++/GCC_version/backward</tt></li> 1133 <li><tt>some_directory/bin/../x86_64-w64-mingw32/include</tt></li> 1134 <li><tt>some_directory/bin/../i686-w64-mingw32/include</tt></li> 1135 <li><tt>some_directory/bin/../include</tt></li> 1136 </ul> 1137 1138 <p>This directory layout is standard for any toolchain you will find on the official <a href="mingw-w64.sourceforge.net">MinGW-w64 website</a>. 1139 1140 <p>Clang expects the GCC executable "gcc.exe" compiled for i686-w64-mingw32 (or x86_64-w64-mingw32) to be present on PATH.</p> 1141 1142 <p><a href="http://llvm.org/bugs/show_bug.cgi?id=9072">Some tests might fail</a> 1143 on x86_64-w64-mingw32.</p> 1144 1145 </div> 1146 </body> 1147 </html> 1148