<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>stdint-generalize-with-tests.patch</title>
<style type="text/css">
body { color:#000000; background-color:#ffffff;
font-family:Helvetica, sans-serif; font-size:10pt }
h1 { text-align: right; border-right: solid 10px #008; padding-right: 1em; padding-top: 20px; padding-bottom: 50px; border-bottom: solid 2px #008; margin-right: 20px;}
ul { line-height: 1.3em }
h3 { font-size:14pt }
div.footer { font-size: 0.6em; color: #999; text-align: right; border-top: 1px solid #999; padding-top: 3px; }
div.code { font-family: "Andale Mono", monospace; font-size:10pt }
div.code { padding: 2em; line-height: 1.2 }
table.index { border-width: 0; }
tr { vertical-align: top; }
span.same { color: #777; }
span.addi { color: #082; }
span.dele { color: #820; }
span.mark { color: #0AA; }
div.code_title { padding: 10px; margin: 0.5em; border-width: 1px; border-color: #000;
border: solid 1px; background-color: #EEF; -webkit-border-radius: 10px; }
p.nav { float: right; }
p.rev { color: #AAA; margin:3px; }
</style>
</head>
<body>
<h1>stdint-generalize-with-tests.patch</h1>
<table class="ind"><tr><td><h3>New Files</h3><ul>
<li><a name="test_Preprocessor_init_asm_c_nav" href="#test_Preprocessor_init_asm_c">test/Preprocessor/init_asm.c</a></li>
<li><a name="test_Preprocessor_init_blocks_c_nav" href="#test_Preprocessor_init_blocks_c">test/Preprocessor/init_blocks.c</a></li>
<li><a name="test_Preprocessor_init_c__0x_c_nav" href="#test_Preprocessor_init_c__0x_c">test/Preprocessor/init_c++0x.c</a></li>
<li><a name="test_Preprocessor_init_c__98_c_nav" href="#test_Preprocessor_init_c__98_c">test/Preprocessor/init_c++98.c</a></li>
<li><a name="test_Preprocessor_init_c99_c_nav" href="#test_Preprocessor_init_c99_c">test/Preprocessor/init_c99.c</a></li>
<li><a name="test_Preprocessor_init_common_c_nav" href="#test_Preprocessor_init_common_c">test/Preprocessor/init_common.c</a></li>
<li><a name="test_Preprocessor_init_freestanding_c_nav" href="#test_Preprocessor_init_freestanding_c">test/Preprocessor/init_freestanding.c</a></li>
<li><a name="test_Preprocessor_init_gnu__98_c_nav" href="#test_Preprocessor_init_gnu__98_c">test/Preprocessor/init_gnu++98.c</a></li>
<li><a name="test_Preprocessor_init_iso9899_199409_c_nav" href="#test_Preprocessor_init_iso9899_199409_c">test/Preprocessor/init_iso9899-199409.c</a></li>
<li><a name="test_Preprocessor_init_ms_extensions_c_nav" href="#test_Preprocessor_init_ms_extensions_c">test/Preprocessor/init_ms_extensions.c</a></li>
<li><a name="test_Preprocessor_init_objective_c_c_nav" href="#test_Preprocessor_init_objective_c_c">test/Preprocessor/init_objective_c.c</a></li>
<li><a name="test_Preprocessor_init_objective_c_gc_c_nav" href="#test_Preprocessor_init_objective_c_gc_c">test/Preprocessor/init_objective_c_gc.c</a></li>
<li><a name="test_Preprocessor_init_objective_c_next_runtime_c_nav" href="#test_Preprocessor_init_objective_c_next_runtime_c">test/Preprocessor/init_objective_c_next_runtime.c</a></li>
<li><a name="test_Preprocessor_init_objective_c_non_fragile_abi_c_nav" href="#test_Preprocessor_init_objective_c_non_fragile_abi_c">test/Preprocessor/init_objective_c_non_fragile_abi.c</a></li>
<li><a name="test_Preprocessor_init_optimize_c_nav" href="#test_Preprocessor_init_optimize_c">test/Preprocessor/init_optimize.c</a></li>
<li><a name="test_Preprocessor_init_optimize_size_c_nav" href="#test_Preprocessor_init_optimize_size_c">test/Preprocessor/init_optimize_size.c</a></li>
<li><a name="test_Preprocessor_init_pascal_strings_c_nav" href="#test_Preprocessor_init_pascal_strings_c">test/Preprocessor/init_pascal_strings.c</a></li>
<li><a name="test_Preprocessor_init_signed_char_c_nav" href="#test_Preprocessor_init_signed_char_c">test/Preprocessor/init_signed_char.c</a></li>
<li><a name="test_Targets_arm_cpp_init_c_nav" href="#test_Targets_arm_cpp_init_c">test/Targets/arm/cpp-init.c</a></li>
<li><a name="test_Targets_arm_stdint_c_nav" href="#test_Targets_arm_stdint_c">test/Targets/arm/stdint.c</a></li>
<li><a name="test_Targets_bfin_cpp_init_c_nav" href="#test_Targets_bfin_cpp_init_c">test/Targets/bfin/cpp-init.c</a></li>
<li><a name="test_Targets_bfin_stdint_c_nav" href="#test_Targets_bfin_stdint_c">test/Targets/bfin/stdint.c</a></li>
<li><a name="test_Targets_i386_cpp_init_c_nav" href="#test_Targets_i386_cpp_init_c">test/Targets/i386/cpp-init.c</a></li>
<li><a name="test_Targets_i386_stdint_c_nav" href="#test_Targets_i386_stdint_c">test/Targets/i386/stdint.c</a></li>
<li><a name="test_Targets_msp430_cpp_init_c_nav" href="#test_Targets_msp430_cpp_init_c">test/Targets/msp430/cpp-init.c</a></li>
<li><a name="test_Targets_msp430_stdint_c_nav" href="#test_Targets_msp430_stdint_c">test/Targets/msp430/stdint.c</a></li>
<li><a name="test_Targets_pic16_cpp_init_c_nav" href="#test_Targets_pic16_cpp_init_c">test/Targets/pic16/cpp-init.c</a></li>
<li><a name="test_Targets_pic16_stdint_c_nav" href="#test_Targets_pic16_stdint_c">test/Targets/pic16/stdint.c</a></li>
<li><a name="test_Targets_powerpc_cpp_init_c_nav" href="#test_Targets_powerpc_cpp_init_c">test/Targets/powerpc/cpp-init.c</a></li>
<li><a name="test_Targets_powerpc_stdint_c_nav" href="#test_Targets_powerpc_stdint_c">test/Targets/powerpc/stdint.c</a></li>
<li><a name="test_Targets_powerpc64_cpp_init_c_nav" href="#test_Targets_powerpc64_cpp_init_c">test/Targets/powerpc64/cpp-init.c</a></li>
<li><a name="test_Targets_powerpc64_stdint_c_nav" href="#test_Targets_powerpc64_stdint_c">test/Targets/powerpc64/stdint.c</a></li>
<li><a name="test_Targets_s390x_cpp_init_c_nav" href="#test_Targets_s390x_cpp_init_c">test/Targets/s390x/cpp-init.c</a></li>
<li><a name="test_Targets_s390x_stdint_c_nav" href="#test_Targets_s390x_stdint_c">test/Targets/s390x/stdint.c</a></li>
<li><a name="test_Targets_sparc_cpp_init_c_nav" href="#test_Targets_sparc_cpp_init_c">test/Targets/sparc/cpp-init.c</a></li>
<li><a name="test_Targets_sparc_stdint_c_nav" href="#test_Targets_sparc_stdint_c">test/Targets/sparc/stdint.c</a></li>
<li><a name="test_Targets_stdint_test_h_nav" href="#test_Targets_stdint_test_h">test/Targets/stdint_test.h</a></li>
<li><a name="test_Targets_tce_cpp_init_c_nav" href="#test_Targets_tce_cpp_init_c">test/Targets/tce/cpp-init.c</a></li>
<li><a name="test_Targets_tce_stdint_c_nav" href="#test_Targets_tce_stdint_c">test/Targets/tce/stdint.c</a></li>
<li><a name="test_Targets_x86_64_cpp_init_c_nav" href="#test_Targets_x86_64_cpp_init_c">test/Targets/x86_64/cpp-init.c</a></li>
<li><a name="test_Targets_x86_64_stdint_c_nav" href="#test_Targets_x86_64_stdint_c">test/Targets/x86_64/stdint.c</a></li>
</ul></td>
<td><h3>Modified Files</h3><ul>
<li><a name="include_clang_Basic_TargetInfo_h_nav" href="#include_clang_Basic_TargetInfo_h">include/clang/Basic/TargetInfo.h</a></li>
<li><a name="lib_Basic_TargetInfo_cpp_nav" href="#lib_Basic_TargetInfo_cpp">lib/Basic/TargetInfo.cpp</a></li>
<li><a name="lib_Basic_Targets_cpp_nav" href="#lib_Basic_Targets_cpp">lib/Basic/Targets.cpp</a></li>
<li><a name="lib_Frontend_InitPreprocessor_cpp_nav" href="#lib_Frontend_InitPreprocessor_cpp">lib/Frontend/InitPreprocessor.cpp</a></li>
<li><a name="lib_Headers_stdint_h_nav" href="#lib_Headers_stdint_h">lib/Headers/stdint.h</a></li>
<li><a name="test_CMakeLists_txt_nav" href="#test_CMakeLists_txt">test/CMakeLists.txt</a></li>
<li><a name="test_Index_c_index_api_test_m_nav" href="#test_Index_c_index_api_test_m">test/Index/c-index-api-test.m</a></li>
</ul></td></tr></table>
<div class="code_title"><h3><a name="include_clang_Basic_TargetInfo_h">include/clang/Basic/TargetInfo.h</a></h3><p class="nav"><a href="#include_clang_Basic_TargetInfo_h_nav">Back ↩</a></p>
<p class="rev">--- include/clang/Basic/TargetInfo.h (revision 84372)</p>
<p class="rev">+++ include/clang/Basic/TargetInfo.h (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -25,6 +25,7 @@</span>
<span class="same"> namespace llvm {</span>
<span class="same"> struct fltSemantics;</span>
<span class="same"> class StringRef;</span>
<span class="addi">+class raw_ostream;</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> namespace clang {</span>
<span class="mark">@@ -97,6 +98,15 @@</span>
<span class="same"> IntType getChar32Type() const { return Char32Type; }</span>
<span class="same"> IntType getInt64Type() const { return Int64Type; }</span>
<span class="same"> </span>
<span class="addi">+</span>
<span class="addi">+ /// getTypeWidth - Return the width (in bits) of the specified integer type </span>
<span class="addi">+ /// enum. For example, SignedInt -> getIntWidth().</span>
<span class="addi">+ unsigned getTypeWidth(IntType T) const;</span>
<span class="addi">+</span>
<span class="addi">+ /// getTypeSigned - Return whether an integer types is signed. Returns true if</span>
<span class="addi">+ /// the type is signed; false otherwise.</span>
<span class="addi">+ bool getTypeSigned(IntType T) const;</span>
<span class="addi">+</span>
<span class="same"> /// getPointerWidth - Return the width of pointers on this target, for the</span>
<span class="same"> /// specified address space.</span>
<span class="same"> uint64_t getPointerWidth(unsigned AddrSpace) const {</span>
<span class="mark">@@ -185,13 +195,18 @@</span>
<span class="same"> /// For example, SignedShort -> "short".</span>
<span class="same"> static const char *getTypeName(IntType T);</span>
<span class="same"> </span>
<span class="addi">+ /// getTypeConstantSuffix - Return the constant suffix for the specified</span>
<span class="addi">+ /// integer type enum. For example, SignedLong -> "L".</span>
<span class="addi">+ static const char *getTypeConstantSuffix(IntType T);</span>
<span class="addi">+</span>
<span class="same"> ///===---- Other target property query methods --------------------------===//</span>
<span class="same"> </span>
<span class="same"> /// getTargetDefines - Appends the target-specific #define values for this</span>
<span class="same"> /// target set to the specified buffer.</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &DefineBuffer) const = 0;</span>
<span class="addi">+ llvm::raw_ostream &DefineBuffer) const = 0;</span>
<span class="same"> </span>
<span class="addi">+</span>
<span class="same"> /// getTargetBuiltins - Return information about target-specific builtins for</span>
<span class="same"> /// the current primary target, and info about which builtins are non-portable</span>
<span class="same"> /// across the current set of primary and secondary targets.</span></pre></div>
<div class="code_title"><h3><a name="lib_Basic_TargetInfo_cpp">lib/Basic/TargetInfo.cpp</a></h3><p class="nav"><a href="#lib_Basic_TargetInfo_cpp_nav">Back ↩</a></p>
<p class="rev">--- lib/Basic/TargetInfo.cpp (revision 84372)</p>
<p class="rev">+++ lib/Basic/TargetInfo.cpp (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -67,12 +67,63 @@</span>
<span class="same"> case SignedInt: return "int";</span>
<span class="same"> case UnsignedInt: return "unsigned int";</span>
<span class="same"> case SignedLong: return "long int";</span>
<span class="dele">- case UnsignedLong: return "long unsigned int";</span>
<span class="addi">+ case UnsignedLong: return "unsigned long int";</span>
<span class="same"> case SignedLongLong: return "long long int";</span>
<span class="dele">- case UnsignedLongLong: return "long long unsigned int";</span>
<span class="addi">+ case UnsignedLongLong: return "unsigned long long int";</span>
<span class="same"> }</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="addi">+/// getTypeConstantSuffix - Return the constant suffix for the specified</span>
<span class="addi">+/// integer type enum. For example, SignedLong -> "L".</span>
<span class="addi">+const char *TargetInfo::getTypeConstantSuffix(IntType T) {</span>
<span class="addi">+ switch (T) {</span>
<span class="addi">+ default: assert(0 && "not an integer!");</span>
<span class="addi">+ case SignedShort:</span>
<span class="addi">+ case SignedInt: return "";</span>
<span class="addi">+ case SignedLong: return "L";</span>
<span class="addi">+ case SignedLongLong: return "LL";</span>
<span class="addi">+ case UnsignedShort:</span>
<span class="addi">+ case UnsignedInt: return "U";</span>
<span class="addi">+ case UnsignedLong: return "UL";</span>
<span class="addi">+ case UnsignedLongLong: return "ULL";</span>
<span class="addi">+ }</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="addi">+/// getTypeWidth - Return the width (in bits) of the specified integer type </span>
<span class="addi">+/// enum. For example, SignedInt -> getIntWidth().</span>
<span class="addi">+unsigned TargetInfo::getTypeWidth(IntType T) const {</span>
<span class="addi">+ switch (T) {</span>
<span class="addi">+ default: assert(0 && "not an integer!");</span>
<span class="addi">+ case SignedShort: return getShortWidth();</span>
<span class="addi">+ case UnsignedShort: return getShortWidth();</span>
<span class="addi">+ case SignedInt: return getIntWidth();</span>
<span class="addi">+ case UnsignedInt: return getIntWidth();</span>
<span class="addi">+ case SignedLong: return getLongWidth();</span>
<span class="addi">+ case UnsignedLong: return getLongWidth();</span>
<span class="addi">+ case SignedLongLong: return getLongLongWidth();</span>
<span class="addi">+ case UnsignedLongLong: return getLongLongWidth();</span>
<span class="addi">+ };</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="addi">+/// getTypeSigned - Return whether an integer types is signed. Returns true if</span>
<span class="addi">+/// the type is signed; false otherwise.</span>
<span class="addi">+bool TargetInfo::getTypeSigned(IntType T) const {</span>
<span class="addi">+ switch (T) {</span>
<span class="addi">+ default: assert(0 && "not an integer!");</span>
<span class="addi">+ case SignedShort:</span>
<span class="addi">+ case SignedInt:</span>
<span class="addi">+ case SignedLong:</span>
<span class="addi">+ case SignedLongLong: </span>
<span class="addi">+ return true;</span>
<span class="addi">+ case UnsignedShort:</span>
<span class="addi">+ case UnsignedInt:</span>
<span class="addi">+ case UnsignedLong:</span>
<span class="addi">+ case UnsignedLongLong: </span>
<span class="addi">+ return false;</span>
<span class="addi">+ };</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="same"> //===----------------------------------------------------------------------===//</span>
<span class="same"> </span>
<span class="same"> </span></pre></div>
<div class="code_title"><h3><a name="lib_Basic_Targets_cpp">lib/Basic/Targets.cpp</a></h3><p class="nav"><a href="#lib_Basic_Targets_cpp_nav">Back ↩</a></p>
<p class="rev">--- lib/Basic/Targets.cpp (revision 84372)</p>
<p class="rev">+++ lib/Basic/Targets.cpp (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -22,26 +22,22 @@</span>
<span class="same"> #include "llvm/ADT/STLExtras.h"</span>
<span class="same"> #include "llvm/ADT/Triple.h"</span>
<span class="same"> #include "llvm/MC/MCSectionMachO.h"</span>
<span class="addi">+#include "llvm/Support/raw_ostream.h"</span>
<span class="same"> using namespace clang;</span>
<span class="same"> </span>
<span class="same"> //===----------------------------------------------------------------------===//</span>
<span class="same"> // Common code shared among targets.</span>
<span class="same"> //===----------------------------------------------------------------------===//</span>
<span class="same"> </span>
<span class="dele">-static void Define(std::vector<char> &Buf, const llvm::StringRef &Macro,</span>
<span class="addi">+static void Define(llvm::raw_ostream &Buf, const llvm::StringRef &Macro,</span>
<span class="same"> const llvm::StringRef &Val = "1") {</span>
<span class="dele">- const char *Def = "#define ";</span>
<span class="dele">- Buf.insert(Buf.end(), Def, Def+strlen(Def));</span>
<span class="dele">- Buf.insert(Buf.end(), Macro.begin(), Macro.end());</span>
<span class="dele">- Buf.push_back(' ');</span>
<span class="dele">- Buf.insert(Buf.end(), Val.begin(), Val.end());</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="addi">+ Buf << "#define " << Macro << ' ' << Val << '\n';</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> /// DefineStd - Define a macro name and standard variants. For example if</span>
<span class="same"> /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"</span>
<span class="same"> /// when in GNU mode.</span>
<span class="dele">-static void DefineStd(std::vector<char> &Buf, const char *MacroName,</span>
<span class="addi">+static void DefineStd(llvm::raw_ostream &Buf, const char *MacroName,</span>
<span class="same"> const LangOptions &Opts) {</span>
<span class="same"> assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");</span>
<span class="same"> </span>
<span class="mark">@@ -70,11 +66,11 @@</span>
<span class="same"> class OSTargetInfo : public TgtInfo {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defines) const=0;</span>
<span class="addi">+ llvm::raw_ostream &Defines) const=0;</span>
<span class="same"> public:</span>
<span class="same"> OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> TgtInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> getOSDefines(Opts, TgtInfo::getTriple(), Defines);</span>
<span class="same"> }</span>
<span class="mark">@@ -83,7 +79,7 @@</span>
<span class="same"> } // end anonymous namespace</span>
<span class="same"> </span>
<span class="same"> </span>
<span class="dele">-static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {</span>
<span class="addi">+static void getDarwinDefines(llvm::raw_ostream &Defs, const LangOptions &Opts) {</span>
<span class="same"> Define(Defs, "__APPLE_CC__", "5621");</span>
<span class="same"> Define(Defs, "__APPLE__");</span>
<span class="same"> Define(Defs, "__MACH__");</span>
<span class="mark">@@ -107,7 +103,7 @@</span>
<span class="same"> Define(Defs, "_REENTRANT", "1");</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-static void getDarwinOSXDefines(std::vector<char> &Defs,</span>
<span class="addi">+static void getDarwinOSXDefines(llvm::raw_ostream &Defs,</span>
<span class="same"> const llvm::Triple &Triple) {</span>
<span class="same"> if (Triple.getOS() != llvm::Triple::Darwin)</span>
<span class="same"> return;</span>
<span class="mark">@@ -128,7 +124,7 @@</span>
<span class="same"> Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,</span>
<span class="addi">+static void getDarwinIPhoneOSDefines(llvm::raw_ostream &Defs,</span>
<span class="same"> const llvm::Triple &Triple) {</span>
<span class="same"> if (Triple.getOS() != llvm::Triple::Darwin)</span>
<span class="same"> return;</span>
<span class="mark">@@ -179,7 +175,7 @@</span>
<span class="same"> class DarwinTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> getDarwinDefines(Defines, Opts);</span>
<span class="same"> getDarwinOSXDefines(Defines, Triple);</span>
<span class="same"> }</span>
<span class="mark">@@ -216,7 +212,7 @@</span>
<span class="same"> class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // DragonFly defines; list based off of gcc output</span>
<span class="same"> Define(Defs, "__DragonFly__");</span>
<span class="same"> Define(Defs, "__DragonFly_cc_version", "100001");</span>
<span class="mark">@@ -235,7 +231,7 @@</span>
<span class="same"> class FreeBSDTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // FreeBSD defines; list based off of gcc output</span>
<span class="same"> </span>
<span class="same"> // FIXME: Move version number handling to llvm::Triple.</span>
<span class="mark">@@ -265,7 +261,7 @@</span>
<span class="same"> class LinuxTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // Linux defines; list based off of gcc output</span>
<span class="same"> DefineStd(Defs, "unix", Opts);</span>
<span class="same"> DefineStd(Defs, "linux", Opts);</span>
<span class="mark">@@ -286,7 +282,7 @@</span>
<span class="same"> class NetBSDTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // NetBSD defines; list based off of gcc output</span>
<span class="same"> Define(Defs, "__NetBSD__", "1");</span>
<span class="same"> Define(Defs, "__unix__", "1");</span>
<span class="mark">@@ -306,7 +302,7 @@</span>
<span class="same"> class OpenBSDTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // OpenBSD defines; list based off of gcc output</span>
<span class="same"> </span>
<span class="same"> Define(Defs, "__OpenBSD__", "1");</span>
<span class="mark">@@ -325,7 +321,7 @@</span>
<span class="same"> class SolarisTargetInfo : public OSTargetInfo<Target> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> DefineStd(Defs, "sun", Opts);</span>
<span class="same"> DefineStd(Defs, "unix", Opts);</span>
<span class="same"> Define(Defs, "__ELF__");</span>
<span class="mark">@@ -363,7 +359,7 @@</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const;</span>
<span class="addi">+ llvm::raw_ostream &Defines) const;</span>
<span class="same"> </span>
<span class="same"> virtual const char *getVAListDeclaration() const {</span>
<span class="same"> return "typedef char* __builtin_va_list;";</span>
<span class="mark">@@ -411,7 +407,7 @@</span>
<span class="same"> /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific</span>
<span class="same"> /// #defines that are not tied to a specific subtarget.</span>
<span class="same"> void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // Target identification.</span>
<span class="same"> Define(Defs, "__ppc__");</span>
<span class="same"> Define(Defs, "_ARCH_PPC");</span>
<span class="mark">@@ -628,7 +624,7 @@</span>
<span class="same"> return "~{dirflag},~{fpsr},~{flags}";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const;</span>
<span class="addi">+ llvm::raw_ostream &Defines) const;</span>
<span class="same"> virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,</span>
<span class="same"> const std::string &Name,</span>
<span class="same"> bool Enabled) const;</span>
<span class="mark">@@ -771,7 +767,7 @@</span>
<span class="same"> /// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines</span>
<span class="same"> /// that are not tied to a specific subtarget.</span>
<span class="same"> void X86TargetInfo::getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // Target identification.</span>
<span class="same"> if (PointerWidth == 64) {</span>
<span class="same"> Define(Defs, "_LP64");</span>
<span class="mark">@@ -943,7 +939,7 @@</span>
<span class="same"> "a0:0:64-f80:32:32";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> X86_32TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> // This list is based off of the the list of things MingW defines</span>
<span class="same"> Define(Defines, "_WIN32");</span>
<span class="mark">@@ -968,7 +964,7 @@</span>
<span class="same"> : WindowsX86_32TargetInfo(triple) {</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> // The value of the following reflects processor type.</span>
<span class="same"> // 300=386, 400=486, 500=Pentium, 600=Blend (default)</span>
<span class="mark">@@ -990,7 +986,7 @@</span>
<span class="same"> : WindowsX86_32TargetInfo(triple) {</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> Define(Defines, "__MSVCRT__");</span>
<span class="same"> Define(Defines, "__MINGW32__");</span>
<span class="mark">@@ -1014,7 +1010,7 @@</span>
<span class="same"> "a0:0:64-f80:32:32";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> X86_32TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> Define(Defines, "__CYGWIN__");</span>
<span class="same"> Define(Defines, "__CYGWIN32__");</span>
<span class="mark">@@ -1071,7 +1067,7 @@</span>
<span class="same"> DoubleAlign = LongLongAlign = 64;</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> X86_64TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> Define(Defines, "_WIN64");</span>
<span class="same"> DefineStd(Defines, "WIN64", Opts);</span>
<span class="mark">@@ -1087,7 +1083,7 @@</span>
<span class="same"> : WindowsX86_64TargetInfo(triple) {</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> Define(Defines, "_M_X64");</span>
<span class="same"> }</span>
<span class="mark">@@ -1105,7 +1101,7 @@</span>
<span class="same"> : WindowsX86_64TargetInfo(triple) {</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);</span>
<span class="same"> Define(Defines, "__MSVCRT__");</span>
<span class="same"> Define(Defines, "__MINGW64__");</span>
<span class="mark">@@ -1227,7 +1223,7 @@</span>
<span class="same"> return true;</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defs) const {</span>
<span class="addi">+ llvm::raw_ostream &Defs) const {</span>
<span class="same"> // Target identification.</span>
<span class="same"> Define(Defs, "__arm");</span>
<span class="same"> Define(Defs, "__arm__");</span>
<span class="mark">@@ -1351,7 +1347,7 @@</span>
<span class="same"> public DarwinTargetInfo<ARMTargetInfo> {</span>
<span class="same"> protected:</span>
<span class="same"> virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> getDarwinDefines(Defines, Opts);</span>
<span class="same"> getDarwinIPhoneOSDefines(Defines, Triple);</span>
<span class="same"> }</span>
<span class="mark">@@ -1373,7 +1369,7 @@</span>
<span class="same"> "i64:64:64-f32:32:32-f64:64:64-v64:64:64";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> DefineStd(Defines, "sparc", Opts);</span>
<span class="same"> Define(Defines, "__sparcv8");</span>
<span class="same"> Define(Defines, "__REGISTER_PREFIX__", "");</span>
<span class="mark">@@ -1498,7 +1494,7 @@</span>
<span class="same"> virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }</span>
<span class="same"> virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> Define(Defines, "__pic16");</span>
<span class="same"> Define(Defines, "rom", "__attribute__((address_space(1)))");</span>
<span class="same"> Define(Defines, "ram", "__attribute__((address_space(0)))");</span>
<span class="mark">@@ -1552,7 +1548,7 @@</span>
<span class="same"> DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> Define(Defines, "MSP430");</span>
<span class="same"> Define(Defines, "__MSP430__");</span>
<span class="same"> // FIXME: defines for different 'flavours' of MCU</span>
<span class="mark">@@ -1611,7 +1607,7 @@</span>
<span class="same"> DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16";</span>
<span class="same"> }</span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> Define(Defines, "__s390__");</span>
<span class="same"> Define(Defines, "__s390x__");</span>
<span class="same"> }</span>
<span class="mark">@@ -1675,7 +1671,7 @@</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> DefineStd(Defines, "bfin", Opts);</span>
<span class="same"> DefineStd(Defines, "BFIN", Opts);</span>
<span class="same"> Define(Defines, "__ADSPBLACKFIN__");</span>
<span class="mark">@@ -1777,7 +1773,7 @@</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> virtual void getTargetDefines(const LangOptions &Opts,</span>
<span class="dele">- std::vector<char> &Defines) const {</span>
<span class="addi">+ llvm::raw_ostream &Defines) const {</span>
<span class="same"> DefineStd(Defines, "tce", Opts);</span>
<span class="same"> Define(Defines, "__TCE__");</span>
<span class="same"> Define(Defines, "__TCE_V1__");</span></pre></div>
<div class="code_title"><h3><a name="lib_Frontend_InitPreprocessor_cpp">lib/Frontend/InitPreprocessor.cpp</a></h3><p class="nav"><a href="#lib_Frontend_InitPreprocessor_cpp_nav">Back ↩</a></p>
<p class="rev">--- lib/Frontend/InitPreprocessor.cpp (revision 84372)</p>
<p class="rev">+++ lib/Frontend/InitPreprocessor.cpp (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -16,54 +16,70 @@</span>
<span class="same"> #include "clang/Lex/Preprocessor.h"</span>
<span class="same"> #include "llvm/ADT/StringExtras.h"</span>
<span class="same"> #include "llvm/ADT/STLExtras.h"</span>
<span class="addi">+#include "llvm/Support/raw_ostream.h"</span>
<span class="same"> #include "llvm/System/Path.h"</span>
<span class="same"> </span>
<span class="same"> namespace clang {</span>
<span class="same"> </span>
<span class="dele">-// Append a #define line to Buf for Macro. Macro should be of the form XXX,</span>
<span class="dele">-// in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit</span>
<span class="dele">-// "#define XXX Y z W". To get a #define with no value, use "XXX=".</span>
<span class="dele">-static void DefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) {</span>
<span class="dele">- const char *Command = "#define ";</span>
<span class="dele">- Buf.insert(Buf.end(), Command, Command+strlen(Command));</span>
<span class="dele">- if (const char *Equal = strchr(Macro, '=')) {</span>
<span class="dele">- // Turn the = into ' '.</span>
<span class="dele">- Buf.insert(Buf.end(), Macro, Equal);</span>
<span class="dele">- Buf.push_back(' ');</span>
<span class="addi">+/// Append a line to Buf to #define Macro as Replacement. If</span>
<span class="addi">+/// no Replacement is specified, a value of "1" is used. To define</span>
<span class="addi">+/// a macro with no replacement text, specify an empty string for Replacement.</span>
<span class="addi">+static void DefineBuiltinMacro(llvm::raw_ostream& Buf, </span>
<span class="addi">+ const std::string& Macro, </span>
<span class="addi">+ const std::string& Replacement="1") {</span>
<span class="same"> </span>
<span class="dele">- // Per GCC -D semantics, the macro ends at \n if it exists.</span>
<span class="dele">- const char *End = strpbrk(Equal, "\n\r");</span>
<span class="dele">- if (End) {</span>
<span class="dele">- fprintf(stderr, "warning: macro '%s' contains embedded newline, text "</span>
<span class="dele">- "after the newline is ignored.\n",</span>
<span class="dele">- std::string(Macro, Equal).c_str());</span>
<span class="dele">- } else {</span>
<span class="dele">- End = Equal+strlen(Equal);</span>
<span class="dele">- }</span>
<span class="addi">+ // Per GCC -D semantics, the macro ends at \n if it exists.</span>
<span class="addi">+ std::string::size_type newline_pos = Replacement.find_first_of("\n\r");</span>
<span class="addi">+ if (newline_pos != std::string::npos) { // LF or CR character found</span>
<span class="addi">+ llvm::errs() << "warning: macro " </span>
<span class="addi">+ << "'" << Macro << "' "</span>
<span class="addi">+ << "contains embedded newline, text "</span>
<span class="addi">+ << "after the newline is ignored.\n";</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- Buf.insert(Buf.end(), Equal+1, End);</span>
<span class="addi">+ // write the definition to the output stream</span>
<span class="addi">+ Buf << "#define " << Macro;</span>
<span class="addi">+ if (Replacement.size() > 0) {</span>
<span class="addi">+ Buf << " " << Replacement.substr(0, newline_pos);</span>
<span class="addi">+ }</span>
<span class="addi">+</span>
<span class="addi">+ Buf << '\n';</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="addi">+static void DefineBuiltinMacroFromOption(llvm::raw_ostream& Buf,</span>
<span class="addi">+ const std::string& Option) {</span>
<span class="addi">+ std::string::size_type EqualPos = Option.find('=');</span>
<span class="addi">+ if (EqualPos == std::string::npos) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, Option);</span>
<span class="same"> } else {</span>
<span class="dele">- // Push "macroname 1".</span>
<span class="dele">- Buf.insert(Buf.end(), Macro, Macro+strlen(Macro));</span>
<span class="dele">- Buf.push_back(' ');</span>
<span class="dele">- Buf.push_back('1');</span>
<span class="addi">+ DefineBuiltinMacro(Buf, Option.substr(0, EqualPos), </span>
<span class="addi">+ Option.substr(EqualPos + 1));</span>
<span class="same"> }</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="addi">+/// Append a line to Buf to #define Macro as a decimal value, wrapping</span>
<span class="addi">+/// in parentheses if N is negative. </span>
<span class="addi">+static void DefineBuiltinMacro(llvm::raw_ostream& Buf, </span>
<span class="addi">+ const std::string& Macro, </span>
<span class="addi">+ int N) {</span>
<span class="addi">+ // write the definition to the output stream</span>
<span class="addi">+ Buf << "#define " << Macro << ' ';</span>
<span class="addi">+ if (N < 0) {</span>
<span class="addi">+ Buf << " (" << N << ")";</span>
<span class="addi">+ } else {</span>
<span class="addi">+ Buf << N;</span>
<span class="addi">+ }</span>
<span class="addi">+</span>
<span class="addi">+ Buf << '\n';</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="same"> // Append a #undef line to Buf for Macro. Macro should be of the form XXX</span>
<span class="same"> // and we emit "#undef XXX".</span>
<span class="dele">-static void UndefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) {</span>
<span class="dele">- // Push "macroname".</span>
<span class="dele">- const char *Command = "#undef ";</span>
<span class="dele">- Buf.insert(Buf.end(), Command, Command+strlen(Command));</span>
<span class="dele">- Buf.insert(Buf.end(), Macro, Macro+strlen(Macro));</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="addi">+static void UndefineBuiltinMacro(llvm::raw_ostream& Buf, const char *Macro) {</span>
<span class="addi">+ Buf << "#undef " << Macro << '\n';</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-/// Add the quoted name of an implicit include file.</span>
<span class="dele">-static void AddQuotedIncludePath(std::vector<char> &Buf,</span>
<span class="dele">- const std::string &File) {</span>
<span class="addi">+static std::string QuoteIncludePath(const std::string &File) {</span>
<span class="same"> // Implicit include paths should be resolved relative to the current</span>
<span class="same"> // working directory first, and then use the regular header search</span>
<span class="same"> // mechanism. The proper way to handle this is to have the</span>
<span class="mark">@@ -77,46 +93,38 @@</span>
<span class="same"> Path = File;</span>
<span class="same"> </span>
<span class="same"> // Escape double quotes etc.</span>
<span class="dele">- Buf.push_back('"');</span>
<span class="dele">- std::string EscapedFile = Lexer::Stringify(Path.str());</span>
<span class="dele">- Buf.insert(Buf.end(), EscapedFile.begin(), EscapedFile.end());</span>
<span class="dele">- Buf.push_back('"');</span>
<span class="addi">+ return "\"" + Lexer::Stringify(Path.str()) + "\"";</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> /// AddImplicitInclude - Add an implicit #include of the specified file to the</span>
<span class="same"> /// predefines buffer.</span>
<span class="dele">-static void AddImplicitInclude(std::vector<char> &Buf,</span>
<span class="addi">+static void AddImplicitInclude(llvm::raw_ostream &Buf,</span>
<span class="same"> const std::string &File) {</span>
<span class="dele">- const char *Inc = "#include ";</span>
<span class="dele">- Buf.insert(Buf.end(), Inc, Inc+strlen(Inc));</span>
<span class="dele">- AddQuotedIncludePath(Buf, File);</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="addi">+ Buf << "#include " << QuoteIncludePath(File) << '\n';</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-static void AddImplicitIncludeMacros(std::vector<char> &Buf,</span>
<span class="addi">+static void AddImplicitIncludeMacros(llvm::raw_ostream &Buf,</span>
<span class="same"> const std::string &File) {</span>
<span class="dele">- const char *Inc = "#__include_macros ";</span>
<span class="dele">- Buf.insert(Buf.end(), Inc, Inc+strlen(Inc));</span>
<span class="dele">- AddQuotedIncludePath(Buf, File);</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="addi">+ Buf << "#__include_macros " << QuoteIncludePath(File) << '\n';</span>
<span class="same"> // Marker token to stop the __include_macros fetch loop.</span>
<span class="dele">- const char *Marker = "##\n"; // ##?</span>
<span class="dele">- Buf.insert(Buf.end(), Marker, Marker+strlen(Marker));</span>
<span class="addi">+ Buf << "##\n";</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> /// AddImplicitIncludePTH - Add an implicit #include using the original file</span>
<span class="same"> /// used to generate a PTH cache.</span>
<span class="dele">-static void AddImplicitIncludePTH(std::vector<char> &Buf, Preprocessor &PP,</span>
<span class="dele">- const std::string& ImplicitIncludePTH) {</span>
<span class="addi">+static void AddImplicitIncludePTH(llvm::raw_ostream &Buf,</span>
<span class="addi">+ Preprocessor &PP,</span>
<span class="addi">+ const std::string& ImplicitIncludePTH) {</span>
<span class="same"> PTHManager *P = PP.getPTHManager();</span>
<span class="same"> assert(P && "No PTHManager.");</span>
<span class="same"> const char *OriginalFile = P->getOriginalSourceFile();</span>
<span class="same"> </span>
<span class="same"> if (!OriginalFile) {</span>
<span class="same"> assert(!ImplicitIncludePTH.empty());</span>
<span class="dele">- fprintf(stderr, "error: PTH file '%s' does not designate an original "</span>
<span class="dele">- "source header file for -include-pth\n",</span>
<span class="dele">- ImplicitIncludePTH.c_str());</span>
<span class="addi">+ llvm::errs() << "error: PTH file "</span>
<span class="addi">+ << "'" << ImplicitIncludePTH << "' "</span>
<span class="addi">+ << "does not designate an original "</span>
<span class="addi">+ << "source header file for -include-pth\n";</span>
<span class="same"> exit (1);</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="mark">@@ -141,7 +149,13 @@</span>
<span class="same"> return IEEEQuadVal;</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-static void DefineFloatMacros(std::vector<char> &Buf, const char *Prefix,</span>
<span class="addi">+static std::string PrefixedMacro(const std::string& Prefix, </span>
<span class="addi">+ const std::string& Name) {</span>
<span class="addi">+ return "__" + Prefix + "_" + Name + "__";</span>
<span class="addi">+}</span>
<span class="addi">+</span>
<span class="addi">+static void DefineFloatMacros(llvm::raw_ostream& Buf,</span>
<span class="addi">+ const char* Prefix,</span>
<span class="same"> const llvm::fltSemantics *Sem) {</span>
<span class="same"> const char *DenormMin, *Epsilon, *Max, *Min;</span>
<span class="same"> DenormMin = PickFP(Sem, "1.40129846e-45F", "4.9406564584124654e-324",</span>
<span class="mark">@@ -153,7 +167,7 @@</span>
<span class="same"> "1.08420217248550443401e-19L",</span>
<span class="same"> "4.94065645841246544176568792868221e-324L",</span>
<span class="same"> "1.92592994438723585305597794258492732e-34L");</span>
<span class="dele">- int HasInifinity = 1, HasQuietNaN = 1;</span>
<span class="addi">+ int HasInfinity = 1, HasQuietNaN = 1;</span>
<span class="same"> int MantissaDigits = PickFP(Sem, 24, 53, 64, 106, 113);</span>
<span class="same"> int Min10Exp = PickFP(Sem, -37, -307, -4931, -291, -4931);</span>
<span class="same"> int Max10Exp = PickFP(Sem, 38, 308, 4932, 308, 4932);</span>
<span class="mark">@@ -168,162 +182,156 @@</span>
<span class="same"> "1.79769313486231580793728971405301e+308L",</span>
<span class="same"> "1.18973149535723176508575932662800702e+4932L");</span>
<span class="same"> </span>
<span class="dele">- char MacroBuf[100];</span>
<span class="dele">- sprintf(MacroBuf, "__%s_DENORM_MIN__=%s", Prefix, DenormMin);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_DIG__=%d", Prefix, Digits);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_EPSILON__=%s", Prefix, Epsilon);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_HAS_INFINITY__=%d", Prefix, HasInifinity);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_HAS_QUIET_NAN__=%d", Prefix, HasQuietNaN);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MANT_DIG__=%d", Prefix, MantissaDigits);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MAX_10_EXP__=%d", Prefix, Max10Exp);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MAX_EXP__=%d", Prefix, MaxExp);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MAX__=%s", Prefix, Max);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MIN_10_EXP__=(%d)", Prefix, Min10Exp);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MIN_EXP__=(%d)", Prefix, MinExp);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_MIN__=%s", Prefix, Min);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">- sprintf(MacroBuf, "__%s_HAS_DENORM__=1", Prefix);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "DENORM_MIN"), DenormMin);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "DIG"), Digits);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "EPSILON"), Epsilon);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "HAS_INFINITY"), </span>
<span class="addi">+ HasInfinity);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "HAS_QUIET_NAN"), </span>
<span class="addi">+ HasQuietNaN);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MANT_DIG"), MantissaDigits);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MAX_10_EXP"), Max10Exp);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MAX_EXP"), MaxExp);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MAX"), Max);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MIN_10_EXP"), Min10Exp);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MIN_EXP"), MinExp);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "MIN"), Min);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Prefix, "HAS_DENORM"));</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> </span>
<span class="same"> /// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro</span>
<span class="dele">-/// named MacroName with the max value for a type with width 'TypeWidth' a</span>
<span class="dele">-/// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL).</span>
<span class="addi">+/// named MacroName with the max value for a signed integer type with width</span>
<span class="addi">+/// 'TypeWidth' and with a value suffix of 'ValSuffix' (e.g. LL).</span>
<span class="same"> static void DefineTypeSize(const char *MacroName, unsigned TypeWidth,</span>
<span class="dele">- const char *ValSuffix, bool isSigned,</span>
<span class="dele">- std::vector<char> &Buf) {</span>
<span class="dele">- char MacroBuf[60];</span>
<span class="dele">- long long MaxVal;</span>
<span class="dele">- if (isSigned)</span>
<span class="dele">- MaxVal = (1LL << (TypeWidth - 1)) - 1;</span>
<span class="dele">- else</span>
<span class="dele">- MaxVal = ~0LL >> (64-TypeWidth);</span>
<span class="addi">+ const char *ValSuffix, llvm::raw_ostream& Buf) {</span>
<span class="addi">+ uint_least64_t MaxVal = (1LL << (TypeWidth - 1)) - 1;</span>
<span class="addi">+ DefineBuiltinMacro(Buf, MacroName, llvm::utostr(MaxVal) + ValSuffix);</span>
<span class="addi">+}</span>
<span class="same"> </span>
<span class="dele">- // FIXME: Switch to using raw_ostream and avoid utostr().</span>
<span class="dele">- sprintf(MacroBuf, "%s=%s%s", MacroName, llvm::utostr(MaxVal).c_str(),</span>
<span class="dele">- ValSuffix);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+static void DefineType(const char *Name, TargetInfo::IntType Ty, </span>
<span class="addi">+ const TargetInfo& TI, </span>
<span class="addi">+ llvm::raw_ostream& Buf) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Name, "TYPE"), </span>
<span class="addi">+ TargetInfo::getTypeName(Ty));</span>
<span class="addi">+ DefineBuiltinMacro(Buf, PrefixedMacro(Name, "WIDTH"), </span>
<span class="addi">+ TI.getTypeWidth(Ty));</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-static void DefineType(const char *MacroName, TargetInfo::IntType Ty,</span>
<span class="dele">- std::vector<char> &Buf) {</span>
<span class="dele">- char MacroBuf[60];</span>
<span class="dele">- sprintf(MacroBuf, "%s=%s", MacroName, TargetInfo::getTypeName(Ty));</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+static std::string IntNMacro(unsigned width, const std::string& suffix) {</span>
<span class="addi">+ std::string result;</span>
<span class="addi">+ llvm::raw_string_ostream stream(result);</span>
<span class="addi">+ stream << "__INT" << width << "_" << suffix << "__";</span>
<span class="addi">+ return result;</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">-</span>
<span class="same"> static void InitializePredefinedMacros(const TargetInfo &TI,</span>
<span class="same"> const LangOptions &LangOpts,</span>
<span class="dele">- std::vector<char> &Buf) {</span>
<span class="dele">- char MacroBuf[60];</span>
<span class="addi">+ llvm::raw_ostream& Buf) {</span>
<span class="same"> // Compiler version introspection macros.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__llvm__=1"); // LLVM Backend</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__clang__=1"); // Clang Frontend</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__llvm__"); // LLVM Backend</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__clang__"); // LLVM Backend</span>
<span class="same"> </span>
<span class="same"> // Currently claim to be compatible with GCC 4.2.1-5621.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUC_MINOR__=2");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUC_PATCHLEVEL__=1");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUC__=4");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GXX_ABI_VERSION=1002");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__VERSION__=\"4.2.1 Compatible Clang Compiler\"");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUC_MINOR__", 2); </span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUC_PATCHLEVEL__", 1);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUC__", 4);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GXX_ABI_VERSION", 1002);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__VERSION__", </span>
<span class="addi">+ "\"4.2.1 Compatible Clang Compiler\"");</span>
<span class="same"> </span>
<span class="dele">-</span>
<span class="same"> // Initialize language-specific preprocessor defines.</span>
<span class="same"> </span>
<span class="same"> // These should all be defined in the preprocessor according to the</span>
<span class="same"> // current language configuration.</span>
<span class="dele">- if (!LangOpts.Microsoft)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STDC__=1");</span>
<span class="dele">- if (LangOpts.AsmPreprocessor)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__ASSEMBLER__=1");</span>
<span class="addi">+ if (!LangOpts.Microsoft) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__STDC__"); </span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="addi">+ if (LangOpts.AsmPreprocessor) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__ASSEMBLER__"); </span>
<span class="addi">+ }</span>
<span class="addi">+</span>
<span class="same"> if (!LangOpts.CPlusPlus) {</span>
<span class="dele">- if (LangOpts.C99)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STDC_VERSION__=199901L");</span>
<span class="dele">- else if (!LangOpts.GNUMode && LangOpts.Digraphs)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STDC_VERSION__=199409L");</span>
<span class="addi">+ if (LangOpts.C99) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__STDC_VERSION__", "199901L");</span>
<span class="addi">+ } else if (!LangOpts.GNUMode && LangOpts.Digraphs) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__STDC_VERSION__", "199409L");</span>
<span class="addi">+ }</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> // Standard conforming mode?</span>
<span class="dele">- if (!LangOpts.GNUMode)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STRICT_ANSI__=1");</span>
<span class="addi">+ if (!LangOpts.GNUMode) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__STRICT_ANSI__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.CPlusPlus0x)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GXX_EXPERIMENTAL_CXX0X__");</span>
<span class="addi">+ if (LangOpts.CPlusPlus0x) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GXX_EXPERIMENTAL_CXX0X__", "");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.Freestanding)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STDC_HOSTED__=0");</span>
<span class="dele">- else</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__STDC_HOSTED__=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__STDC_HOSTED__", !LangOpts.Freestanding);</span>
<span class="same"> </span>
<span class="same"> if (LangOpts.ObjC1) {</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__OBJC__=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__OBJC__");</span>
<span class="same"> if (LangOpts.ObjCNonFragileABI) {</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__OBJC2__=1");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "OBJC_ZEROCOST_EXCEPTIONS=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__OBJC2__");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "OBJC_ZEROCOST_EXCEPTIONS");</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.getGCMode() != LangOptions::NonGC)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__OBJC_GC__=1");</span>
<span class="addi">+ if (LangOpts.getGCMode() != LangOptions::NonGC) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__OBJC_GC__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.NeXTRuntime)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__NEXT_RUNTIME__=1");</span>
<span class="addi">+ if (LangOpts.NeXTRuntime) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__NEXT_RUNTIME__");</span>
<span class="addi">+ }</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> // darwin_constant_cfstrings controls this. This is also dependent</span>
<span class="same"> // on other things like the runtime I believe. This is set even for C code.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__CONSTANT_CFSTRINGS__=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__CONSTANT_CFSTRINGS__");</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.ObjC2)</span>
<span class="addi">+ if (LangOpts.ObjC2) {</span>
<span class="same"> DefineBuiltinMacro(Buf, "OBJC_NEW_PROPERTIES");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.PascalStrings)</span>
<span class="addi">+ if (LangOpts.PascalStrings) {</span>
<span class="same"> DefineBuiltinMacro(Buf, "__PASCAL_STRINGS__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="same"> if (LangOpts.Blocks) {</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__block=__attribute__((__blocks__(byref)))");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__BLOCKS__=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__block", "__attribute__((__blocks__(byref)))");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__BLOCKS__");</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> if (LangOpts.Exceptions)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__EXCEPTIONS=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__EXCEPTIONS");</span>
<span class="same"> </span>
<span class="same"> if (LangOpts.CPlusPlus) {</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__DEPRECATED=1");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUG__=4");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GXX_WEAK__=1");</span>
<span class="dele">- if (LangOpts.GNUMode)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__cplusplus=1");</span>
<span class="dele">- else</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__DEPRECATED");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUG__", 4);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GXX_WEAK__");</span>
<span class="addi">+ if (LangOpts.GNUMode) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__cplusplus");</span>
<span class="addi">+ } else {</span>
<span class="same"> // C++ [cpp.predefined]p1:</span>
<span class="dele">- // The name_ _cplusplusis defined to the value199711Lwhen compiling a</span>
<span class="addi">+ // The name_ _cplusplusis defined to the value 199711L when compiling a</span>
<span class="same"> // C++ translation unit.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__cplusplus=199711L");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__private_extern__=extern");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__cplusplus", "199711L");</span>
<span class="addi">+ }</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__private_extern__", "extern");</span>
<span class="addi">+</span>
<span class="same"> // Ugly hack to work with GNU libstdc++.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "_GNU_SOURCE=1");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "_GNU_SOURCE");</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> if (LangOpts.Microsoft) {</span>
<span class="same"> // Filter out some microsoft extensions when trying to parse in ms-compat</span>
<span class="same"> // mode.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__int8=__INT8_TYPE__");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__int16=__INT16_TYPE__");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__int32=__INT32_TYPE__");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__int64=__INT64_TYPE__");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__int8", "__INT8_TYPE__");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__int16", "__INT16_TYPE__");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__int32", "__INT32_TYPE__");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__int64", "__INT64_TYPE__");</span>
<span class="same"> // Work around some issues with Visual C++ headerws.</span>
<span class="same"> if (LangOpts.CPlusPlus) {</span>
<span class="same"> // Since we define wchar_t in C++ mode.</span>
<span class="mark">@@ -335,119 +343,122 @@</span>
<span class="same"> }</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.Optimize)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__OPTIMIZE__=1");</span>
<span class="dele">- if (LangOpts.OptimizeSize)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__OPTIMIZE_SIZE__=1");</span>
<span class="addi">+ if (LangOpts.Optimize) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__OPTIMIZE__");</span>
<span class="addi">+ }</span>
<span class="addi">+ if (LangOpts.OptimizeSize) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__OPTIMIZE_SIZE__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="same"> // Initialize target-specific preprocessor defines.</span>
<span class="same"> </span>
<span class="same"> // Define type sizing macros based on the target properties.</span>
<span class="dele">- assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__CHAR_BIT__=8");</span>
<span class="addi">+ assert(TI.getCharWidth() >= 8 && "Chars must be at least 8-bits.");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__CHAR_BIT__", TI.getCharWidth());</span>
<span class="same"> </span>
<span class="dele">- unsigned IntMaxWidth;</span>
<span class="dele">- const char *IntMaxSuffix;</span>
<span class="dele">- if (TI.getIntMaxType() == TargetInfo::SignedLongLong) {</span>
<span class="dele">- IntMaxWidth = TI.getLongLongWidth();</span>
<span class="dele">- IntMaxSuffix = "LL";</span>
<span class="dele">- } else if (TI.getIntMaxType() == TargetInfo::SignedLong) {</span>
<span class="dele">- IntMaxWidth = TI.getLongWidth();</span>
<span class="dele">- IntMaxSuffix = "L";</span>
<span class="dele">- } else {</span>
<span class="dele">- assert(TI.getIntMaxType() == TargetInfo::SignedInt);</span>
<span class="dele">- IntMaxWidth = TI.getIntWidth();</span>
<span class="dele">- IntMaxSuffix = "";</span>
<span class="dele">- }</span>
<span class="addi">+ TargetInfo::IntType IntMaxType = TI.getIntMaxType();</span>
<span class="addi">+ unsigned IntMaxWidth = TI.getTypeWidth(IntMaxType);</span>
<span class="addi">+ const char *IntMaxSuffix = TI.getTypeConstantSuffix(IntMaxType);</span>
<span class="same"> </span>
<span class="dele">- DefineTypeSize("__SCHAR_MAX__", TI.getCharWidth(), "", true, Buf);</span>
<span class="dele">- DefineTypeSize("__SHRT_MAX__", TI.getShortWidth(), "", true, Buf);</span>
<span class="dele">- DefineTypeSize("__INT_MAX__", TI.getIntWidth(), "", true, Buf);</span>
<span class="dele">- DefineTypeSize("__LONG_MAX__", TI.getLongWidth(), "L", true, Buf);</span>
<span class="dele">- DefineTypeSize("__LONG_LONG_MAX__", TI.getLongLongWidth(), "LL", true, Buf);</span>
<span class="dele">- DefineTypeSize("__WCHAR_MAX__", TI.getWCharWidth(), "", true, Buf);</span>
<span class="dele">- DefineTypeSize("__INTMAX_MAX__", IntMaxWidth, IntMaxSuffix, true, Buf);</span>
<span class="addi">+ DefineTypeSize("__SCHAR_MAX__", TI.getCharWidth(), "", Buf);</span>
<span class="addi">+ DefineTypeSize("__SHRT_MAX__", TI.getShortWidth(), "", Buf);</span>
<span class="addi">+ DefineTypeSize("__INT_MAX__", TI.getIntWidth(), "", Buf);</span>
<span class="addi">+ DefineTypeSize("__LONG_MAX__", TI.getLongWidth(), "L", Buf);</span>
<span class="addi">+ DefineTypeSize("__LONG_LONG_MAX__", TI.getLongLongWidth(), "LL", Buf);</span>
<span class="addi">+ DefineTypeSize("__WCHAR_MAX__", TI.getWCharWidth(), "", Buf);</span>
<span class="addi">+ DefineTypeSize("__INTMAX_MAX__", IntMaxWidth, IntMaxSuffix, Buf);</span>
<span class="same"> </span>
<span class="dele">- DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Buf);</span>
<span class="dele">- DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Buf);</span>
<span class="dele">- DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Buf);</span>
<span class="dele">- DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Buf);</span>
<span class="dele">- DefineType("__SIZE_TYPE__", TI.getSizeType(), Buf);</span>
<span class="dele">- DefineType("__WCHAR_TYPE__", TI.getWCharType(), Buf);</span>
<span class="addi">+ DefineType("INTMAX", IntMaxType, TI, Buf);</span>
<span class="addi">+ DefineType("UINTMAX", TI.getUIntMaxType(), TI, Buf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__INTMAX_C_SUFFIX__", IntMaxSuffix);</span>
<span class="addi">+ DefineType("PTRDIFF", TI.getPtrDiffType(0), TI, Buf);</span>
<span class="addi">+ DefineType("INTPTR", TI.getIntPtrType(), TI, Buf);</span>
<span class="addi">+ DefineType("SIZE", TI.getSizeType(), TI, Buf);</span>
<span class="addi">+ DefineType("WCHAR", TI.getWCharType(), TI, Buf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__WCHAR_SIGNED__", </span>
<span class="addi">+ TI.getTypeSigned(TI.getWCharType()));</span>
<span class="addi">+ </span>
<span class="same"> // FIXME: TargetInfo hookize __WINT_TYPE__.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__WINT_TYPE__=int");</span>
<span class="addi">+ DefineType("WINT", TargetInfo::SignedInt, TI, Buf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__WINT_SIGNED__");</span>
<span class="addi">+ </span>
<span class="addi">+ // FIXME: TargetInfo hookize __SIG_ATOMIC_TYPE__.</span>
<span class="addi">+ DefineType("SIG_ATOMIC", TargetInfo::SignedInt, TI, Buf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__SIG_ATOMIC_SIGNED__");</span>
<span class="same"> </span>
<span class="same"> DefineFloatMacros(Buf, "FLT", &TI.getFloatFormat());</span>
<span class="same"> DefineFloatMacros(Buf, "DBL", &TI.getDoubleFormat());</span>
<span class="same"> DefineFloatMacros(Buf, "LDBL", &TI.getLongDoubleFormat());</span>
<span class="same"> </span>
<span class="same"> // Define a __POINTER_WIDTH__ macro for stdint.h.</span>
<span class="dele">- sprintf(MacroBuf, "__POINTER_WIDTH__=%d", (int)TI.getPointerWidth(0));</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__POINTER_WIDTH__", TI.getPointerWidth(0));</span>
<span class="same"> </span>
<span class="dele">- if (!LangOpts.CharIsSigned)</span>
<span class="addi">+ if (!LangOpts.CharIsSigned) {</span>
<span class="same"> DefineBuiltinMacro(Buf, "__CHAR_UNSIGNED__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- // Define fixed-sized integer types for stdint.h</span>
<span class="dele">- assert(TI.getCharWidth() == 8 && "unsupported target types");</span>
<span class="dele">- assert(TI.getShortWidth() == 16 && "unsupported target types");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__INT8_TYPE__=char");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__INT16_TYPE__=short");</span>
<span class="addi">+ // Define exact-sized integer types for stdint.h</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(TI.getCharWidth(), "TYPE"), "char");</span>
<span class="same"> </span>
<span class="dele">- if (TI.getIntWidth() == 32)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__INT32_TYPE__=int");</span>
<span class="dele">- else {</span>
<span class="dele">- assert(TI.getLongLongWidth() == 32 && "unsupported target types");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__INT32_TYPE__=long long");</span>
<span class="addi">+ if (TI.getShortWidth() > TI.getCharWidth()) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(TI.getShortWidth(), "TYPE"), "short");</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">- // 16-bit targets doesn't necessarily have a 64-bit type.</span>
<span class="dele">- if (TI.getLongLongWidth() == 64)</span>
<span class="dele">- DefineType("__INT64_TYPE__", TI.getInt64Type(), Buf);</span>
<span class="dele">-</span>
<span class="addi">+ if (TI.getIntWidth() > TI.getShortWidth()) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(TI.getIntWidth(), "TYPE"), "int");</span>
<span class="addi">+ }</span>
<span class="addi">+ </span>
<span class="addi">+ if (TI.getLongWidth() > TI.getIntWidth()) {</span>
<span class="addi">+ unsigned LongWidth = TI.getLongWidth();</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(LongWidth, "TYPE"), "long int");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(LongWidth, "C_SUFFIX"), "L");</span>
<span class="addi">+ }</span>
<span class="addi">+ </span>
<span class="addi">+ if (TI.getLongLongWidth() > TI.getLongWidth()) {</span>
<span class="addi">+ unsigned LongLongWidth = TI.getLongLongWidth();</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(LongLongWidth, "TYPE"), </span>
<span class="addi">+ "long long int");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, IntNMacro(LongLongWidth, "C_SUFFIX"), "LL");</span>
<span class="addi">+ }</span>
<span class="addi">+ </span>
<span class="same"> // Add __builtin_va_list typedef.</span>
<span class="dele">- {</span>
<span class="dele">- const char *VAList = TI.getVAListDeclaration();</span>
<span class="dele">- Buf.insert(Buf.end(), VAList, VAList+strlen(VAList));</span>
<span class="dele">- Buf.push_back('\n');</span>
<span class="dele">- }</span>
<span class="addi">+ Buf << TI.getVAListDeclaration() << '\n';</span>
<span class="addi">+ </span>
<span class="same"> </span>
<span class="same"> if (const char *Prefix = TI.getUserLabelPrefix()) {</span>
<span class="dele">- sprintf(MacroBuf, "__USER_LABEL_PREFIX__=%s", Prefix);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__USER_LABEL_PREFIX__", Prefix);</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> // Build configuration options. FIXME: these should be controlled by</span>
<span class="same"> // command line options or something.</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__FINITE_MATH_ONLY__=0");</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__FINITE_MATH_ONLY__", 0);</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.GNUInline)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUC_GNU_INLINE__=1");</span>
<span class="dele">- else</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__GNUC_STDC_INLINE__=1");</span>
<span class="addi">+ if (LangOpts.GNUInline) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUC_GNU_INLINE__");</span>
<span class="addi">+ } else {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__GNUC_STDC_INLINE__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.NoInline)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__NO_INLINE__=1");</span>
<span class="addi">+ if (LangOpts.NoInline) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__NO_INLINE__");</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="same"> if (unsigned PICLevel = LangOpts.PICLevel) {</span>
<span class="dele">- sprintf(MacroBuf, "__PIC__=%d", PICLevel);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="dele">-</span>
<span class="dele">- sprintf(MacroBuf, "__pic__=%d", PICLevel);</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__PIC__", PICLevel);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__pic__", PICLevel);</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> // Macros to control C99 numerics and <float.h></span>
<span class="dele">- DefineBuiltinMacro(Buf, "__FLT_EVAL_METHOD__=0");</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__FLT_RADIX__=2");</span>
<span class="dele">- sprintf(MacroBuf, "__DECIMAL_DIG__=%d",</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__FLT_EVAL_METHOD__", 0);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__FLT_RADIX__", 2);</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__DECIMAL_DIG__",</span>
<span class="same"> PickFP(&TI.getLongDoubleFormat(), -1/*FIXME*/, 17, 21, 33, 36));</span>
<span class="dele">- DefineBuiltinMacro(Buf, MacroBuf);</span>
<span class="same"> </span>
<span class="dele">- if (LangOpts.getStackProtectorMode() == LangOptions::SSPOn)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__SSP__=1");</span>
<span class="dele">- else if (LangOpts.getStackProtectorMode() == LangOptions::SSPReq)</span>
<span class="dele">- DefineBuiltinMacro(Buf, "__SSP_ALL__=2");</span>
<span class="addi">+ if (LangOpts.getStackProtectorMode() == LangOptions::SSPOn) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__SSP__");</span>
<span class="addi">+ } else if (LangOpts.getStackProtectorMode() == LangOptions::SSPReq) {</span>
<span class="addi">+ DefineBuiltinMacro(Buf, "__SSP_ALL__", 2);</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="same"> // Get other target #defines.</span>
<span class="same"> TI.getTargetDefines(LangOpts, Buf);</span>
<span class="mark">@@ -458,49 +469,46 @@</span>
<span class="same"> ///</span>
<span class="same"> bool InitializePreprocessor(Preprocessor &PP,</span>
<span class="same"> const PreprocessorInitOptions& InitOpts) {</span>
<span class="dele">- std::vector<char> PredefineBuffer;</span>
<span class="addi">+ std::string Buffer;</span>
<span class="addi">+ llvm::raw_string_ostream PredefineStream(Buffer);</span>
<span class="same"> </span>
<span class="dele">- const char *LineDirective = "# 1 \"<built-in>\" 3\n";</span>
<span class="dele">- PredefineBuffer.insert(PredefineBuffer.end(),</span>
<span class="dele">- LineDirective, LineDirective+strlen(LineDirective));</span>
<span class="addi">+ PredefineStream << "# 1 \"<built-in>\" 3\n";</span>
<span class="same"> </span>
<span class="same"> // Install things like __POWERPC__, __GNUC__, etc into the macro table.</span>
<span class="same"> InitializePredefinedMacros(PP.getTargetInfo(), PP.getLangOptions(),</span>
<span class="dele">- PredefineBuffer);</span>
<span class="addi">+ PredefineStream);</span>
<span class="same"> </span>
<span class="same"> // Add on the predefines from the driver. Wrap in a #line directive to report</span>
<span class="same"> // that they come from the command line.</span>
<span class="dele">- LineDirective = "# 1 \"<command line>\" 1\n";</span>
<span class="dele">- PredefineBuffer.insert(PredefineBuffer.end(),</span>
<span class="dele">- LineDirective, LineDirective+strlen(LineDirective));</span>
<span class="addi">+ PredefineStream << "# 1 \"<command line>\" 1\n";</span>
<span class="same"> </span>
<span class="same"> // Process #define's and #undef's in the order they are given.</span>
<span class="same"> for (PreprocessorInitOptions::macro_iterator I = InitOpts.macro_begin(),</span>
<span class="same"> E = InitOpts.macro_end(); I != E; ++I) {</span>
<span class="dele">- if (I->second) // isUndef</span>
<span class="dele">- UndefineBuiltinMacro(PredefineBuffer, I->first.c_str());</span>
<span class="dele">- else</span>
<span class="dele">- DefineBuiltinMacro(PredefineBuffer, I->first.c_str());</span>
<span class="addi">+ if (I->second) { // isUndef</span>
<span class="addi">+ UndefineBuiltinMacro(PredefineStream, I->first.c_str());</span>
<span class="addi">+ } else {</span>
<span class="addi">+ DefineBuiltinMacroFromOption(PredefineStream, I->first);</span>
<span class="addi">+ }</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="same"> // If -imacros are specified, include them now. These are processed before</span>
<span class="same"> // any -include directives.</span>
<span class="same"> for (PreprocessorInitOptions::imacro_iterator I = InitOpts.imacro_begin(),</span>
<span class="dele">- E = InitOpts.imacro_end(); I != E; ++I)</span>
<span class="dele">- AddImplicitIncludeMacros(PredefineBuffer, *I);</span>
<span class="addi">+ E = InitOpts.imacro_end(); I != E; ++I) {</span>
<span class="addi">+ AddImplicitIncludeMacros(PredefineStream, *I);</span>
<span class="addi">+ }</span>
<span class="same"> </span>
<span class="same"> // Process -include directives.</span>
<span class="same"> for (PreprocessorInitOptions::include_iterator I = InitOpts.include_begin(),</span>
<span class="same"> E = InitOpts.include_end(); I != E; ++I) {</span>
<span class="same"> if (I->second) // isPTH</span>
<span class="dele">- AddImplicitIncludePTH(PredefineBuffer, PP, I->first);</span>
<span class="addi">+ AddImplicitIncludePTH(PredefineStream, PP, I->first);</span>
<span class="same"> else</span>
<span class="dele">- AddImplicitInclude(PredefineBuffer, I->first);</span>
<span class="addi">+ AddImplicitInclude(PredefineStream, I->first);</span>
<span class="same"> }</span>
<span class="same"> </span>
<span class="dele">- // Null terminate PredefinedBuffer and add it.</span>
<span class="dele">- PredefineBuffer.push_back(0);</span>
<span class="dele">- PP.setPredefines(&PredefineBuffer[0]);</span>
<span class="addi">+ PP.setPredefines(PredefineStream.str().c_str());</span>
<span class="same"> </span>
<span class="same"> // Once we've read this, we're done.</span>
<span class="same"> return false;</span></pre></div>
<div class="code_title"><h3><a name="lib_Headers_stdint_h">lib/Headers/stdint.h</a></h3><p class="nav"><a href="#lib_Headers_stdint_h_nav">Back ↩</a></p>
<p class="rev">--- lib/Headers/stdint.h (revision 84372)</p>
<p class="rev">+++ lib/Headers/stdint.h (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -32,58 +32,184 @@</span>
<span class="same"> # include_next <stdint.h></span>
<span class="same"> #else</span>
<span class="same"> </span>
<span class="dele">-/* We currently only support targets with power of two, 2s complement integers.</span>
<span class="dele">- */</span>
<span class="dele">-</span>
<span class="same"> /* C99 7.18.1.1 Exact-width integer types.</span>
<span class="same"> * C99 7.18.1.2 Minimum-width integer types.</span>
<span class="same"> * C99 7.18.1.3 Fastest minimum-width integer types.</span>
<span class="dele">- * Since we only support pow-2 targets, these map directly to exact width types.</span>
<span class="addi">+ *</span>
<span class="addi">+ * The standard requires that exact-width type be defined for 8-, 16-, 32-, and </span>
<span class="addi">+ * 64-bit types if they are implemented. Other exact width types are optional.</span>
<span class="addi">+ * This implementation defines an exact-width types for every integer width</span>
<span class="addi">+ * that is represented in the standard integer types.</span>
<span class="addi">+ *</span>
<span class="addi">+ * The standard also requires minimum-width types be defined for 8-, 16-, 32-,</span>
<span class="addi">+ * and 64-bit widths regardless of whether there are corresponding exact-width</span>
<span class="addi">+ * types. </span>
<span class="addi">+ *</span>
<span class="addi">+ * To accomodate targets that are missing types that are exactly 8, 16, 32, or</span>
<span class="addi">+ * 64 bits wide, this implementation takes an approach of cascading</span>
<span class="addi">+ * redefintions, redefining __int_leastN_t to successively smaller exact-width</span>
<span class="addi">+ * types. It is therefore important that the types are defined in order of</span>
<span class="addi">+ * descending widths.</span>
<span class="addi">+ *</span>
<span class="addi">+ * We currently assume that the minimum-width types and the fastest</span>
<span class="addi">+ * minimum-width types are the same. This is allowed by the standard, but is</span>
<span class="addi">+ * suboptimal.</span>
<span class="addi">+ *</span>
<span class="addi">+ * In violation of the standard, some targets do not implement a type that is</span>
<span class="addi">+ * wide enough to represent all of the required widths (8-, 16-, 32-, 64-bit). </span>
<span class="addi">+ * To accomodate these targets, a required minimum-width type is only</span>
<span class="addi">+ * defined if there exists an exact-width type of equal or greater width.</span>
<span class="same"> */</span>
<span class="same"> </span>
<span class="dele">-#ifndef __int8_t_defined /* glibc does weird things with sys/types.h */</span>
<span class="dele">-#define __int8_t_defined</span>
<span class="dele">-typedef signed __INT8_TYPE__ int8_t;</span>
<span class="dele">-typedef __INT16_TYPE__ int16_t;</span>
<span class="dele">-typedef __INT32_TYPE__ int32_t;</span>
<span class="same"> #ifdef __INT64_TYPE__</span>
<span class="dele">-typedef __INT64_TYPE__ int64_t;</span>
<span class="dele">-#endif</span>
<span class="dele">-#endif</span>
<span class="addi">+# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/</span>
<span class="addi">+typedef signed __INT64_TYPE__ int64_t;</span>
<span class="addi">+# endif /* __int8_t_defined */</span>
<span class="addi">+typedef unsigned __INT64_TYPE__ uint64_t;</span>
<span class="addi">+# define __int_least64_t int64_t</span>
<span class="addi">+# define __uint_least64_t uint64_t</span>
<span class="addi">+# define __int_least32_t int64_t</span>
<span class="addi">+# define __uint_least32_t uint64_t</span>
<span class="addi">+# define __int_least16_t int64_t</span>
<span class="addi">+# define __uint_least16_t uint64_t</span>
<span class="addi">+# define __int_least8_t int64_t</span>
<span class="addi">+# define __uint_least8_t uint64_t</span>
<span class="addi">+#endif /* __INT64_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-typedef unsigned __INT8_TYPE__ uint8_t;</span>
<span class="dele">-typedef int8_t int_least8_t;</span>
<span class="dele">-typedef uint8_t uint_least8_t;</span>
<span class="dele">-typedef int8_t int_fast8_t;</span>
<span class="dele">-typedef uint8_t uint_fast8_t;</span>
<span class="addi">+#ifdef __int_least64_t</span>
<span class="addi">+typedef __int_least64_t int_least64_t;</span>
<span class="addi">+typedef __uint_least64_t uint_least64_t;</span>
<span class="addi">+typedef __int_least64_t int_fast64_t;</span>
<span class="addi">+typedef __uint_least64_t uint_fast64_t;</span>
<span class="addi">+#endif /* __int_least64_t */</span>
<span class="same"> </span>
<span class="dele">-typedef unsigned __INT16_TYPE__ uint16_t;</span>
<span class="dele">-typedef int16_t int_least16_t;</span>
<span class="dele">-typedef uint16_t uint_least16_t;</span>
<span class="dele">-typedef int16_t int_fast16_t;</span>
<span class="dele">-typedef uint16_t uint_fast16_t;</span>
<span class="addi">+#ifdef __INT56_TYPE__</span>
<span class="addi">+typedef signed __INT56_TYPE__ int56_t;</span>
<span class="addi">+typedef unsigned __INT56_TYPE__ uint56_t;</span>
<span class="addi">+typedef int56_t int_least56_t;</span>
<span class="addi">+typedef uint56_t uint_least56_t;</span>
<span class="addi">+typedef int56_t int_fast56_t;</span>
<span class="addi">+typedef uint56_t uint_fast56_t;</span>
<span class="addi">+# define __int_least32_t int56_t</span>
<span class="addi">+# define __uint_least32_t uint56_t</span>
<span class="addi">+# define __int_least16_t int56_t</span>
<span class="addi">+# define __uint_least16_t uint56_t</span>
<span class="addi">+# define __int_least8_t int56_t</span>
<span class="addi">+# define __uint_least8_t uint56_t</span>
<span class="addi">+#endif /* __INT56_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-#ifndef __uint32_t_defined /* more glibc compatibility */</span>
<span class="dele">-#define __uint32_t_defined</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT48_TYPE__</span>
<span class="addi">+typedef signed __INT48_TYPE__ int48_t;</span>
<span class="addi">+typedef unsigned __INT48_TYPE__ uint48_t;</span>
<span class="addi">+typedef int48_t int_least48_t;</span>
<span class="addi">+typedef uint48_t uint_least48_t;</span>
<span class="addi">+typedef int48_t int_fast48_t;</span>
<span class="addi">+typedef uint48_t uint_fast48_t;</span>
<span class="addi">+# define __int_least32_t int48_t</span>
<span class="addi">+# define __uint_least32_t uint48_t</span>
<span class="addi">+# define __int_least16_t int48_t</span>
<span class="addi">+# define __uint_least16_t uint48_t</span>
<span class="addi">+# define __int_least8_t int48_t</span>
<span class="addi">+# define __uint_least8_t uint48_t</span>
<span class="addi">+#endif /* __INT48_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT40_TYPE__</span>
<span class="addi">+typedef signed __INT40_TYPE__ int40_t;</span>
<span class="addi">+typedef unsigned __INT40_TYPE__ uint40_t;</span>
<span class="addi">+typedef int40_t int_least40_t;</span>
<span class="addi">+typedef uint40_t uint_least40_t;</span>
<span class="addi">+typedef int40_t int_fast40_t;</span>
<span class="addi">+typedef uint40_t uint_fast40_t;</span>
<span class="addi">+# define __int_least32_t int40_t</span>
<span class="addi">+# define __uint_least32_t uint40_t</span>
<span class="addi">+# define __int_least16_t int40_t</span>
<span class="addi">+# define __uint_least16_t uint40_t</span>
<span class="addi">+# define __int_least8_t int40_t</span>
<span class="addi">+# define __uint_least8_t uint40_t</span>
<span class="addi">+#endif /* __INT40_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT32_TYPE__</span>
<span class="addi">+</span>
<span class="addi">+# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/</span>
<span class="addi">+typedef signed __INT32_TYPE__ int32_t;</span>
<span class="addi">+# endif /* __int8_t_defined */</span>
<span class="addi">+</span>
<span class="addi">+# ifndef __uint32_t_defined /* more glibc compatibility */</span>
<span class="addi">+# define __uint32_t_defined</span>
<span class="same"> typedef unsigned __INT32_TYPE__ uint32_t;</span>
<span class="dele">-#endif</span>
<span class="dele">-typedef int32_t int_least32_t;</span>
<span class="dele">-typedef uint32_t uint_least32_t;</span>
<span class="dele">-typedef int32_t int_fast32_t;</span>
<span class="dele">-typedef uint32_t uint_fast32_t;</span>
<span class="addi">+# endif /* __uint32_t_defined */</span>
<span class="same"> </span>
<span class="dele">-/* Some 16-bit targets do not have a 64-bit datatype. Only define the 64-bit</span>
<span class="dele">- * typedefs if there is something to typedef them to.</span>
<span class="dele">- */</span>
<span class="dele">-#ifdef __INT64_TYPE__</span>
<span class="dele">-typedef unsigned __INT64_TYPE__ uint64_t;</span>
<span class="dele">-typedef int64_t int_least64_t;</span>
<span class="dele">-typedef uint64_t uint_least64_t;</span>
<span class="dele">-typedef int64_t int_fast64_t;</span>
<span class="dele">-typedef uint64_t uint_fast64_t;</span>
<span class="dele">-#endif</span>
<span class="addi">+# define __int_least32_t int32_t</span>
<span class="addi">+# define __uint_least32_t uint32_t</span>
<span class="addi">+# define __int_least16_t int32_t</span>
<span class="addi">+# define __uint_least16_t uint32_t</span>
<span class="addi">+# define __int_least8_t int32_t</span>
<span class="addi">+# define __uint_least8_t uint32_t</span>
<span class="addi">+#endif /* __INT32_TYPE__ */</span>
<span class="same"> </span>
<span class="addi">+#ifdef __int_least32_t</span>
<span class="addi">+typedef __int_least32_t int_least32_t;</span>
<span class="addi">+typedef __uint_least32_t uint_least32_t;</span>
<span class="addi">+typedef __int_least32_t int_fast32_t;</span>
<span class="addi">+typedef __uint_least32_t uint_fast32_t;</span>
<span class="addi">+#endif /* __int_least32_t */</span>
<span class="same"> </span>
<span class="addi">+#ifdef __INT24_TYPE__</span>
<span class="addi">+typedef signed __INT24_TYPE__ int24_t;</span>
<span class="addi">+typedef unsigned __INT24_TYPE__ uint24_t;</span>
<span class="addi">+typedef int24_t int_least24_t;</span>
<span class="addi">+typedef uint24_t uint_least24_t;</span>
<span class="addi">+typedef int24_t int_fast24_t;</span>
<span class="addi">+typedef uint24_t uint_fast24_t;</span>
<span class="addi">+# define __int_least16_t int24_t</span>
<span class="addi">+# define __uint_least16_t uint24_t</span>
<span class="addi">+# define __int_least8_t int24_t</span>
<span class="addi">+# define __uint_least8_t uint24_t</span>
<span class="addi">+#endif /* __INT24_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT16_TYPE__</span>
<span class="addi">+#ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/</span>
<span class="addi">+typedef signed __INT16_TYPE__ int16_t;</span>
<span class="addi">+#endif /* __int8_t_defined */</span>
<span class="addi">+typedef unsigned __INT16_TYPE__ uint16_t;</span>
<span class="addi">+# define __int_least16_t int16_t</span>
<span class="addi">+# define __uint_least16_t uint16_t</span>
<span class="addi">+# define __int_least8_t int16_t</span>
<span class="addi">+# define __uint_least8_t uint16_t</span>
<span class="addi">+#endif /* __INT16_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least16_t</span>
<span class="addi">+typedef __int_least16_t int_least16_t;</span>
<span class="addi">+typedef __uint_least16_t uint_least16_t;</span>
<span class="addi">+typedef __int_least16_t int_fast16_t;</span>
<span class="addi">+typedef __uint_least16_t uint_fast16_t;</span>
<span class="addi">+#endif /* __int_least16_t */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT8_TYPE__</span>
<span class="addi">+#ifndef __int8_t_defined /* glibc sys/types.h also defines int8_t*/</span>
<span class="addi">+typedef signed __INT8_TYPE__ int8_t;</span>
<span class="addi">+#endif /* __int8_t_defined */</span>
<span class="addi">+typedef unsigned __INT8_TYPE__ uint8_t;</span>
<span class="addi">+# define __int_least8_t int8_t</span>
<span class="addi">+# define __uint_least8_t uint8_t</span>
<span class="addi">+#endif /* __INT8_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least8_t</span>
<span class="addi">+typedef __int_least8_t int_least8_t;</span>
<span class="addi">+typedef __uint_least8_t uint_least8_t;</span>
<span class="addi">+typedef __int_least8_t int_fast8_t;</span>
<span class="addi">+typedef __uint_least8_t uint_fast8_t;</span>
<span class="addi">+#endif /* __int_least8_t */</span>
<span class="addi">+</span>
<span class="addi">+/* prevent glibc sys/types.h from defining conflicting types */</span>
<span class="addi">+#ifndef __int8_t_defined </span>
<span class="addi">+# define __int8_t_defined</span>
<span class="addi">+#endif /* __int8_t_defined */</span>
<span class="addi">+</span>
<span class="same"> /* C99 7.18.1.4 Integer types capable of holding object pointers.</span>
<span class="same"> */</span>
<span class="same"> #ifndef __intptr_t_defined</span>
<span class="mark">@@ -97,136 +223,438 @@</span>
<span class="same"> typedef __INTMAX_TYPE__ intmax_t;</span>
<span class="same"> typedef __UINTMAX_TYPE__ uintmax_t;</span>
<span class="same"> </span>
<span class="addi">+/* C99 7.18.4 Macros for minimum-width integer constants.</span>
<span class="addi">+ *</span>
<span class="addi">+ * The standard requires that integer constant macros be defined for all the</span>
<span class="addi">+ * minimum-width types defined above. As 8-, 16-, 32-, and 64-bit minimum-width</span>
<span class="addi">+ * types are required, the corresponding integer constant macros are defined </span>
<span class="addi">+ * here. This implementation also defines minimum-width types for every other</span>
<span class="addi">+ * integer width that the target implements, so corresponding macros are </span>
<span class="addi">+ * defined below, too.</span>
<span class="addi">+ *</span>
<span class="addi">+ * These macros are defined using the same successive-shrinking approach as</span>
<span class="addi">+ * the type definitions above. It is likewise important that macros are defined</span>
<span class="addi">+ * in order of decending width.</span>
<span class="addi">+ *</span>
<span class="addi">+ * Note that C++ should not check __STDC_CONSTANT_MACROS here, contrary to the</span>
<span class="addi">+ * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).</span>
<span class="addi">+ */</span>
<span class="addi">+</span>
<span class="addi">+#define __int_c_join(a, b) a ## b</span>
<span class="addi">+#define __int_c(v, suffix) (__int_c_join(v, suffix))</span>
<span class="addi">+#define __uint_c(v, suffix) (__int_c_join(v##U, suffix))</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT64_TYPE__</span>
<span class="addi">+# ifdef __INT64_C_SUFFIX__</span>
<span class="addi">+# define __int64_c_suffix __INT64_C_SUFFIX__</span>
<span class="addi">+# define __int32_c_suffix __INT64_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT64_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT64_C_SUFFIX__</span>
<span class="addi">+# else</span>
<span class="addi">+# undef __int64_c_suffix</span>
<span class="addi">+# undef __int32_c_suffix</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT64_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT64_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least64_t</span>
<span class="addi">+# ifdef __int64_c_suffix</span>
<span class="addi">+# define INT64_C(v) __int_c(v, __int64_c_suffix)</span>
<span class="addi">+# define UINT64_C(v) __uint_c(v, __int64_c_suffix)</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT64_C(v) (v)</span>
<span class="addi">+# define UINT64_C(v) (v ## U)</span>
<span class="addi">+# endif /* __int64_c_suffix */</span>
<span class="addi">+#endif /* __int_least64_t */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT56_TYPE__</span>
<span class="addi">+# ifdef __INT56_C_SUFFIX__</span>
<span class="addi">+# define INT56_C(v) __int_c(v, __INT56_C_SUFFIX__)</span>
<span class="addi">+# define UINT56_C(v) __uint_c(v, __INT56_C_SUFFIX__)</span>
<span class="addi">+# define __int32_c_suffix __INT56_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT56_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT56_C_SUFFIX__</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT56_C(v) (v)</span>
<span class="addi">+# define UINT56_C(v) (v ## U)</span>
<span class="addi">+# undef __int32_c_suffix</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT56_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT56_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT48_TYPE__</span>
<span class="addi">+# ifdef __INT48_C_SUFFIX__</span>
<span class="addi">+# define INT48_C(v) __int_c(v, __INT48_C_SUFFIX__)</span>
<span class="addi">+# define UINT48_C(v) __uint_c(v, __INT48_C_SUFFIX__)</span>
<span class="addi">+# define __int32_c_suffix __INT48_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT48_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT48_C_SUFFIX__</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT48_C(v) (v)</span>
<span class="addi">+# define UINT48_C(v) (v ## U)</span>
<span class="addi">+# undef __int32_c_suffix</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT48_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT48_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT40_TYPE__</span>
<span class="addi">+# ifdef __INT40_C_SUFFIX__</span>
<span class="addi">+# define INT40_C(v) __int_c(v, __INT40_C_SUFFIX__)</span>
<span class="addi">+# define UINT40_C(v) __uint_c(v, __INT40_C_SUFFIX__)</span>
<span class="addi">+# define __int32_c_suffix __INT40_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT40_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT40_C_SUFFIX__</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT40_C(v) (v)</span>
<span class="addi">+# define UINT40_C(v) (v ## U)</span>
<span class="addi">+# undef __int32_c_suffix</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT40_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT40_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT32_TYPE__</span>
<span class="addi">+# ifdef __INT32_C_SUFFIX__</span>
<span class="addi">+# define __int32_c_suffix __INT32_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT32_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT32_C_SUFFIX__</span>
<span class="addi">+#else</span>
<span class="addi">+# undef __int32_c_suffix</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT32_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT32_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least32_t</span>
<span class="addi">+# ifdef __int32_c_suffix</span>
<span class="addi">+# define INT32_C(v) __int_c(v, __int32_c_suffix)</span>
<span class="addi">+# define UINT32_C(v) __uint_c(v, __int32_c_suffix)</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT32_C(v) (v)</span>
<span class="addi">+# define UINT32_C(v) (v ## U)</span>
<span class="addi">+# endif /* __int32_c_suffix */</span>
<span class="addi">+#endif /* __int_least32_t */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT24_TYPE__</span>
<span class="addi">+# ifdef __INT24_C_SUFFIX__</span>
<span class="addi">+# define INT24_C(v) __int_c(v, __INT24_C_SUFFIX__)</span>
<span class="addi">+# define UINT24_C(v) __uint_c(v, __INT24_C_SUFFIX__)</span>
<span class="addi">+# define __int16_c_suffix __INT24_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT24_C_SUFFIX__</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT24_C(v) (v)</span>
<span class="addi">+# define UINT24_C(v) (v ## U)</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT24_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT24_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT16_TYPE__</span>
<span class="addi">+# ifdef __INT16_C_SUFFIX__</span>
<span class="addi">+# define __int16_c_suffix __INT16_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT16_C_SUFFIX__</span>
<span class="addi">+#else</span>
<span class="addi">+# undef __int16_c_suffix</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT16_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT16_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least16_t</span>
<span class="addi">+# ifdef __int16_c_suffix</span>
<span class="addi">+# define INT16_C(v) __int_c(v, __int16_c_suffix)</span>
<span class="addi">+# define UINT16_C(v) __uint_c(v, __int16_c_suffix)</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT16_C(v) (v)</span>
<span class="addi">+# define UINT16_C(v) (v ## U)</span>
<span class="addi">+# endif /* __int16_c_suffix */</span>
<span class="addi">+#endif /* __int_least16_t */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT8_TYPE__</span>
<span class="addi">+# ifdef __INT8_C_SUFFIX__</span>
<span class="addi">+# define __int8_c_suffix __INT8_C_SUFFIX__</span>
<span class="addi">+#else</span>
<span class="addi">+# undef __int8_c_suffix</span>
<span class="addi">+# endif /* __INT8_C_SUFFIX__ */</span>
<span class="addi">+#endif /* __INT8_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __int_least8_t</span>
<span class="addi">+# ifdef __int8_c_suffix</span>
<span class="addi">+# define INT8_C(v) __int_c(v, __int8_c_suffix)</span>
<span class="addi">+# define UINT8_C(v) __uint_c(v, __int8_c_suffix)</span>
<span class="addi">+# else</span>
<span class="addi">+# define INT8_C(v) (v)</span>
<span class="addi">+# define UINT8_C(v) (v ## U)</span>
<span class="addi">+# endif /* __int8_c_suffix */</span>
<span class="addi">+#endif /* __int_least8_t */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="same"> /* C99 7.18.2.1 Limits of exact-width integer types. </span>
<span class="same"> * Fixed sized values have fixed size max/min.</span>
<span class="addi">+ *</span>
<span class="same"> * C99 7.18.2.2 Limits of minimum-width integer types.</span>
<span class="dele">- * Since we map these directly onto fixed-sized types, these values the same.</span>
<span class="same"> * C99 7.18.2.3 Limits of fastest minimum-width integer types.</span>
<span class="same"> *</span>
<span class="addi">+ * The limit macros are completely optional. This implementation defines</span>
<span class="addi">+ * limits for all of the types (exact- and minimum-width) that it defines</span>
<span class="addi">+ * above, using the limits of the minimum-width type for any types that do not</span>
<span class="addi">+ * have exact-width representations.</span>
<span class="addi">+ *</span>
<span class="addi">+ * As in the type definitions, this section takes an approach of</span>
<span class="addi">+ * successive-shrinking to determine which limits to use for the standard (8,</span>
<span class="addi">+ * 16, 32, 64) bit widths when they don't have exact representations. It is</span>
<span class="addi">+ * therefore important that the defintions be kept in order of decending</span>
<span class="addi">+ * widths.</span>
<span class="addi">+ *</span>
<span class="same"> * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the</span>
<span class="same"> * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).</span>
<span class="same"> */</span>
<span class="same"> </span>
<span class="dele">-#define INT8_MAX 127</span>
<span class="dele">-#define INT8_MIN (-128)</span>
<span class="dele">-#define UINT8_MAX 255</span>
<span class="dele">-#define INT_LEAST8_MIN INT8_MIN</span>
<span class="dele">-#define INT_LEAST8_MAX INT8_MAX</span>
<span class="dele">-#define UINT_LEAST8_MAX UINT8_MAX</span>
<span class="dele">-#define INT_FAST8_MIN INT8_MIN</span>
<span class="dele">-#define INT_FAST8_MAX INT8_MAX</span>
<span class="dele">-#define UINT_FAST8_MAX UINT8_MAX</span>
<span class="addi">+#ifdef __INT64_TYPE__</span>
<span class="addi">+# define INT64_MAX INT64_C( 9223372036854775807)</span>
<span class="addi">+# define INT64_MIN INT64_C(-9223372036854775808)</span>
<span class="addi">+# define UINT64_MAX UINT64_C(18446744073709551615)</span>
<span class="addi">+# define __INT_LEAST64_MIN INT64_MIN</span>
<span class="addi">+# define __INT_LEAST64_MAX INT64_MAX</span>
<span class="addi">+# define __UINT_LEAST64_MAX UINT64_MAX</span>
<span class="addi">+# define __INT_LEAST32_MIN INT64_MIN</span>
<span class="addi">+# define __INT_LEAST32_MAX INT64_MAX</span>
<span class="addi">+# define __UINT_LEAST32_MAX UINT64_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT64_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT64_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT64_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT64_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT64_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT64_MAX</span>
<span class="addi">+#endif /* __INT64_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-#define INT16_MAX 32767</span>
<span class="dele">-#define INT16_MIN (-32768)</span>
<span class="dele">-#define UINT16_MAX 65535</span>
<span class="dele">-#define INT_LEAST16_MIN INT16_MIN</span>
<span class="dele">-#define INT_LEAST16_MAX INT16_MAX</span>
<span class="dele">-#define UINT_LEAST16_MAX UINT16_MAX</span>
<span class="dele">-#define INT_FAST16_MIN INT16_MIN</span>
<span class="dele">-#define INT_FAST16_MAX INT16_MAX</span>
<span class="dele">-#define UINT_FAST16_MAX UINT16_MAX</span>
<span class="addi">+#ifdef __INT_LEAST64_MIN</span>
<span class="addi">+# define INT_LEAST64_MIN __INT_LEAST64_MIN</span>
<span class="addi">+# define INT_LEAST64_MAX __INT_LEAST64_MAX</span>
<span class="addi">+# define UINT_LEAST64_MAX __UINT_LEAST64_MAX</span>
<span class="addi">+# define INT_FAST64_MIN __INT_LEAST64_MIN</span>
<span class="addi">+# define INT_FAST64_MAX __INT_LEAST64_MAX</span>
<span class="addi">+# define UINT_FAST64_MAX __UINT_LEAST64_MAX</span>
<span class="addi">+#endif /* __INT_LEAST64_MIN */</span>
<span class="same"> </span>
<span class="dele">-#define INT32_MAX 2147483647</span>
<span class="dele">-#define INT32_MIN (-2147483647-1)</span>
<span class="dele">-#define UINT32_MAX 4294967295U</span>
<span class="dele">-#define INT_LEAST32_MIN INT32_MIN</span>
<span class="dele">-#define INT_LEAST32_MAX INT32_MAX</span>
<span class="dele">-#define UINT_LEAST32_MAX UINT32_MAX</span>
<span class="dele">-#define INT_FAST32_MIN INT32_MIN</span>
<span class="dele">-#define INT_FAST32_MAX INT32_MAX</span>
<span class="dele">-#define UINT_FAST32_MAX UINT32_MAX</span>
<span class="same"> </span>
<span class="dele">-/* If we do not have 64-bit support, don't define the 64-bit size macros. */</span>
<span class="dele">-#ifdef __INT64_TYPE__</span>
<span class="dele">-#define INT64_MAX 9223372036854775807LL</span>
<span class="dele">-#define INT64_MIN (-9223372036854775807LL-1)</span>
<span class="dele">-#define UINT64_MAX 18446744073709551615ULL</span>
<span class="dele">-#define INT_LEAST64_MIN INT64_MIN</span>
<span class="dele">-#define INT_LEAST64_MAX INT64_MAX</span>
<span class="dele">-#define UINT_LEAST64_MAX UINT64_MAX</span>
<span class="dele">-#define INT_FAST64_MIN INT64_MIN</span>
<span class="dele">-#define INT_FAST64_MAX INT64_MAX</span>
<span class="dele">-#define UINT_FAST64_MAX UINT64_MAX</span>
<span class="dele">-#endif</span>
<span class="addi">+#ifdef __INT56_TYPE__</span>
<span class="addi">+# define INT56_MAX INT56_C( 36028797018963967)</span>
<span class="addi">+# define INT56_MIN INT56_C(-36028797018963968)</span>
<span class="addi">+# define UINT56_MAX UINT56_C( 72057594037927935)</span>
<span class="addi">+# define INT_LEAST56_MIN INT56_MIN</span>
<span class="addi">+# define INT_LEAST56_MAX INT56_MAX</span>
<span class="addi">+# define UINT_LEAST56_MAX UINT56_MAX</span>
<span class="addi">+# define INT_FAST56_MIN INT56_MIN</span>
<span class="addi">+# define INT_FAST56_MAX INT56_MAX</span>
<span class="addi">+# define UINT_FAST56_MAX UINT56_MAX</span>
<span class="addi">+# define __INT_LEAST32_MIN INT56_MIN</span>
<span class="addi">+# define __INT_LEAST32_MAX INT56_MAX</span>
<span class="addi">+# define __UINT_LEAST32_MAX UINT56_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT56_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT56_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT56_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT56_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT56_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT56_MAX</span>
<span class="addi">+#endif /* __INT56_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-/* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */</span>
<span class="dele">-/* C99 7.18.3 Limits of other integer types. */</span>
<span class="same"> </span>
<span class="dele">-#if __POINTER_WIDTH__ == 64</span>
<span class="addi">+#ifdef __INT48_TYPE__</span>
<span class="addi">+# define INT48_MAX INT48_C( 140737488355327)</span>
<span class="addi">+# define INT48_MIN INT48_C(-140737488355328)</span>
<span class="addi">+# define UINT48_MAX UINT48_C( 281474976710655)</span>
<span class="addi">+# define INT_LEAST48_MIN INT48_MIN</span>
<span class="addi">+# define INT_LEAST48_MAX INT48_MAX</span>
<span class="addi">+# define UINT_LEAST48_MAX UINT48_MAX</span>
<span class="addi">+# define INT_FAST48_MIN INT48_MIN</span>
<span class="addi">+# define INT_FAST48_MAX INT48_MAX</span>
<span class="addi">+# define UINT_FAST48_MAX UINT48_MAX</span>
<span class="addi">+# define __INT_LEAST32_MIN INT48_MIN</span>
<span class="addi">+# define __INT_LEAST32_MAX INT48_MAX</span>
<span class="addi">+# define __UINT_LEAST32_MAX UINT48_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT48_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT48_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT48_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT48_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT48_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT48_MAX</span>
<span class="addi">+#endif /* __INT48_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-#define INTPTR_MIN INT64_MIN</span>
<span class="dele">-#define INTPTR_MAX INT64_MAX</span>
<span class="dele">-#define UINTPTR_MAX UINT64_MAX</span>
<span class="dele">-#define PTRDIFF_MIN INT64_MIN</span>
<span class="dele">-#define PTRDIFF_MAX INT64_MAX</span>
<span class="dele">-#define SIZE_MAX UINT64_MAX</span>
<span class="same"> </span>
<span class="dele">-#elif __POINTER_WIDTH__ == 32</span>
<span class="addi">+#ifdef __INT40_TYPE__</span>
<span class="addi">+# define INT40_MAX INT40_C( 549755813887)</span>
<span class="addi">+# define INT40_MIN INT40_C(-549755813888)</span>
<span class="addi">+# define UINT40_MAX UINT40_C(1099511627775)</span>
<span class="addi">+# define INT_LEAST40_MIN INT40_MIN</span>
<span class="addi">+# define INT_LEAST40_MAX INT40_MAX</span>
<span class="addi">+# define UINT_LEAST40_MAX UINT40_MAX</span>
<span class="addi">+# define INT_FAST40_MIN INT40_MIN</span>
<span class="addi">+# define INT_FAST40_MAX INT40_MAX</span>
<span class="addi">+# define UINT_FAST40_MAX UINT40_MAX</span>
<span class="addi">+# define __INT_LEAST32_MIN INT40_MIN</span>
<span class="addi">+# define __INT_LEAST32_MAX INT40_MAX</span>
<span class="addi">+# define __UINT_LEAST32_MAX UINT40_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT40_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT40_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT40_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT40_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT40_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT40_MAX</span>
<span class="addi">+#endif /* __INT40_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-#define INTPTR_MIN INT32_MIN</span>
<span class="dele">-#define INTPTR_MAX INT32_MAX</span>
<span class="dele">-#define UINTPTR_MAX UINT32_MAX</span>
<span class="dele">-#define PTRDIFF_MIN INT32_MIN</span>
<span class="dele">-#define PTRDIFF_MAX INT32_MAX</span>
<span class="dele">-#define SIZE_MAX UINT32_MAX</span>
<span class="same"> </span>
<span class="dele">-#elif __POINTER_WIDTH__ == 16</span>
<span class="addi">+#ifdef __INT32_TYPE__</span>
<span class="addi">+# define INT32_MAX INT32_C( 2147483647)</span>
<span class="addi">+# define INT32_MIN INT32_C(-2147483648)</span>
<span class="addi">+# define UINT32_MAX UINT32_C( 4294967295)</span>
<span class="addi">+# define __INT_LEAST32_MIN INT32_MIN</span>
<span class="addi">+# define __INT_LEAST32_MAX INT32_MAX</span>
<span class="addi">+# define __UINT_LEAST32_MAX UINT32_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT32_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT32_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT32_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT32_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT32_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT32_MAX</span>
<span class="addi">+#endif /* __INT32_TYPE__ */</span>
<span class="same"> </span>
<span class="dele">-#define INTPTR_MIN INT16_MIN</span>
<span class="dele">-#define INTPTR_MAX INT16_MAX</span>
<span class="dele">-#define UINTPTR_MAX UINT16_MAX</span>
<span class="dele">-#define PTRDIFF_MIN INT16_MIN</span>
<span class="dele">-#define PTRDIFF_MAX INT16_MAX</span>
<span class="dele">-#define SIZE_MAX UINT16_MAX</span>
<span class="addi">+#ifdef __INT_LEAST32_MIN</span>
<span class="addi">+# define INT_LEAST32_MIN __INT_LEAST32_MIN</span>
<span class="addi">+# define INT_LEAST32_MAX __INT_LEAST32_MAX</span>
<span class="addi">+# define UINT_LEAST32_MAX __UINT_LEAST32_MAX</span>
<span class="addi">+# define INT_FAST32_MIN __INT_LEAST32_MIN</span>
<span class="addi">+# define INT_FAST32_MAX __INT_LEAST32_MAX</span>
<span class="addi">+# define UINT_FAST32_MAX __UINT_LEAST32_MAX</span>
<span class="addi">+#endif /* __INT_LEAST32_MIN */</span>
<span class="same"> </span>
<span class="dele">-#else</span>
<span class="dele">-#error "unknown or unset pointer width!"</span>
<span class="dele">-#endif</span>
<span class="same"> </span>
<span class="addi">+#ifdef __INT24_TYPE__</span>
<span class="addi">+# define INT24_MAX INT24_C( 8388607)</span>
<span class="addi">+# define INT24_MIN INT24_C(-8388608)</span>
<span class="addi">+# define UINT24_MAX UINT24_C(16777215)</span>
<span class="addi">+# define INT_LEAST24_MIN INT24_MIN</span>
<span class="addi">+# define INT_LEAST24_MAX INT24_MAX</span>
<span class="addi">+# define UINT_LEAST24_MAX UINT24_MAX</span>
<span class="addi">+# define INT_FAST24_MIN INT24_MIN</span>
<span class="addi">+# define INT_FAST24_MAX INT24_MAX</span>
<span class="addi">+# define UINT_FAST24_MAX UINT24_MAX</span>
<span class="addi">+# define __INT_LEAST16_MIN INT24_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT24_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT24_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT24_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT24_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT24_MAX</span>
<span class="addi">+#endif /* __INT24_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT16_TYPE__</span>
<span class="addi">+#define INT16_MAX INT16_C( 32767)</span>
<span class="addi">+#define INT16_MIN INT16_C(-32768)</span>
<span class="addi">+#define UINT16_MAX UINT16_C( 65535)</span>
<span class="addi">+# define __INT_LEAST16_MIN INT16_MIN</span>
<span class="addi">+# define __INT_LEAST16_MAX INT16_MAX</span>
<span class="addi">+# define __UINT_LEAST16_MAX UINT16_MAX</span>
<span class="addi">+# define __INT_LEAST8_MIN INT16_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT16_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT16_MAX</span>
<span class="addi">+#endif /* __INT16_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT_LEAST16_MIN</span>
<span class="addi">+# define INT_LEAST16_MIN __INT_LEAST16_MIN</span>
<span class="addi">+# define INT_LEAST16_MAX __INT_LEAST16_MAX</span>
<span class="addi">+# define UINT_LEAST16_MAX __UINT_LEAST16_MAX</span>
<span class="addi">+# define INT_FAST16_MIN __INT_LEAST16_MIN</span>
<span class="addi">+# define INT_FAST16_MAX __INT_LEAST16_MAX</span>
<span class="addi">+# define UINT_FAST16_MAX __UINT_LEAST16_MAX</span>
<span class="addi">+#endif /* __INT_LEAST16_MIN */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT8_TYPE__</span>
<span class="addi">+# define INT8_MAX INT8_C( 127)</span>
<span class="addi">+# define INT8_MIN INT8_C(-128)</span>
<span class="addi">+# define UINT8_MAX UINT8_C( 255)</span>
<span class="addi">+# define __INT_LEAST8_MIN INT8_MIN</span>
<span class="addi">+# define __INT_LEAST8_MAX INT8_MAX</span>
<span class="addi">+# define __UINT_LEAST8_MAX UINT8_MAX</span>
<span class="addi">+#endif /* __INT8_TYPE__ */</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __INT_LEAST8_MIN</span>
<span class="addi">+# define INT_LEAST8_MIN __INT_LEAST8_MIN</span>
<span class="addi">+# define INT_LEAST8_MAX __INT_LEAST8_MAX</span>
<span class="addi">+# define UINT_LEAST8_MAX __UINT_LEAST8_MAX</span>
<span class="addi">+# define INT_FAST8_MIN __INT_LEAST8_MIN</span>
<span class="addi">+# define INT_FAST8_MAX __INT_LEAST8_MAX</span>
<span class="addi">+# define UINT_FAST8_MAX __UINT_LEAST8_MAX</span>
<span class="addi">+#endif /* __INT_LEAST8_MIN */</span>
<span class="addi">+</span>
<span class="addi">+</span>
<span class="addi">+/* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */</span>
<span class="addi">+</span>
<span class="addi">+#define __int_limit_join3(a, b, c) a ## b ## c</span>
<span class="addi">+#define __int_limit(prefix, width, suffix) \</span>
<span class="addi">+ __int_limit_join3(prefix, width, suffix)</span>
<span class="addi">+</span>
<span class="addi">+#define INTPTR_MIN __int_limit( INT, __POINTER_WIDTH__, _MIN)</span>
<span class="addi">+#define INTPTR_MAX __int_limit( INT, __POINTER_WIDTH__, _MAX)</span>
<span class="addi">+#define UINTPTR_MAX __int_limit(UINT, __POINTER_WIDTH__, _MAX)</span>
<span class="addi">+</span>
<span class="same"> /* C99 7.18.2.5 Limits of greatest-width integer types. */</span>
<span class="dele">-#define INTMAX_MIN (-__INTMAX_MAX__-1)</span>
<span class="dele">-#define INTMAX_MAX __INTMAX_MAX__</span>
<span class="dele">-#define UINTMAX_MAX (__INTMAX_MAX__*2ULL+1ULL)</span>
<span class="addi">+#define INTMAX_MIN __int_limit( INT, __INTMAX_WIDTH__, _MIN)</span>
<span class="addi">+#define INTMAX_MAX __int_limit( INT, __INTMAX_WIDTH__, _MAX)</span>
<span class="addi">+#define UINTMAX_MAX __int_limit(UINT, __INTMAX_WIDTH__, _MAX)</span>
<span class="same"> </span>
<span class="same"> /* C99 7.18.3 Limits of other integer types. */</span>
<span class="dele">-#define SIG_ATOMIC_MIN INT32_MIN</span>
<span class="dele">-#define SIG_ATOMIC_MAX INT32_MAX</span>
<span class="dele">-#define WINT_MIN INT32_MIN</span>
<span class="dele">-#define WINT_MAX INT32_MAX</span>
<span class="addi">+#define PTRDIFF_MIN __int_limit( INT, __PTRDIFF_WIDTH__, _MIN)</span>
<span class="addi">+#define PTRDIFF_MAX __int_limit( INT, __PTRDIFF_WIDTH__, _MAX)</span>
<span class="same"> </span>
<span class="dele">-/* FIXME: if we ever support a target with unsigned wchar_t, this should be</span>
<span class="dele">- * 0 .. Max.</span>
<span class="dele">- */</span>
<span class="dele">-#ifndef WCHAR_MAX</span>
<span class="dele">-#define WCHAR_MAX __WCHAR_MAX__</span>
<span class="addi">+#if __SIG_ATOMIC_SIGNED__</span>
<span class="addi">+# define SIG_ATOMIC_MIN __int_limit( INT, __SIG_ATOMIC_WIDTH__, _MIN)</span>
<span class="addi">+# define SIG_ATOMIC_MAX __int_limit( INT, __SIG_ATOMIC_WIDTH__, _MAX)</span>
<span class="addi">+#else</span>
<span class="addi">+# define SIG_ATOMIC_MIN 0</span>
<span class="addi">+# define SIG_ATOMIC_MAX __int_limit(UINT, __SIG_ATOMIC_WIDTH__, _MAX)</span>
<span class="same"> #endif</span>
<span class="dele">-#ifndef WCHAR_MIN</span>
<span class="dele">-#define WCHAR_MIN (-__WCHAR_MAX__-1)</span>
<span class="dele">-#endif</span>
<span class="same"> </span>
<span class="dele">-/* C99 7.18.4 Macros for minimum-width integer constants.</span>
<span class="dele">- *</span>
<span class="dele">- * Note that C++ should not check __STDC_CONSTANT_MACROS here, contrary to the</span>
<span class="dele">- * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).</span>
<span class="dele">- */</span>
<span class="addi">+#define SIZE_MAX __int_limit(UINT, __SIZE_WIDTH__, _MAX)</span>
<span class="same"> </span>
<span class="dele">-#define INT8_C(v) (v)</span>
<span class="dele">-#define UINT8_C(v) (v##U)</span>
<span class="dele">-#define INT16_C(v) (v)</span>
<span class="dele">-#define UINT16_C(v) (v##U)</span>
<span class="dele">-#define INT32_C(v) (v)</span>
<span class="dele">-#define UINT32_C(v) (v##U)</span>
<span class="addi">+#if __WCHAR_SIGNED__</span>
<span class="addi">+# ifndef WCHAR_MIN</span>
<span class="addi">+# define WCHAR_MIN __int_limit( INT, __WCHAR_WIDTH__, _MIN)</span>
<span class="addi">+# endif</span>
<span class="addi">+# ifndef WCHAR_MAX</span>
<span class="addi">+# define WCHAR_MAX __int_limit( INT, __WCHAR_WIDTH__, _MAX) </span>
<span class="addi">+# endif</span>
<span class="addi">+#else</span>
<span class="addi">+# ifndef WCHAR_MIN</span>
<span class="addi">+# define WCHAR_MIN 0</span>
<span class="addi">+# endif</span>
<span class="addi">+# ifndef WCHAR_MAX</span>
<span class="addi">+# define WCHAR_MAX __int_limit(UINT, __WCHAR_WIDTH__, _MAX) </span>
<span class="addi">+# endif</span>
<span class="addi">+#endif</span>
<span class="same"> </span>
<span class="dele">-/* Only define the 64-bit size macros if we have 64-bit support. */</span>
<span class="dele">-#ifdef __INT64_TYPE__</span>
<span class="dele">-#define INT64_C(v) (v##LL)</span>
<span class="dele">-#define UINT64_C(v) (v##ULL)</span>
<span class="addi">+#if __WCHAR_SIGNED__</span>
<span class="addi">+# define WINT_MIN __int_limit( INT, __WINT_WIDTH__, _MIN)</span>
<span class="addi">+# define WINT_MAX __int_limit( INT, __WINT_WIDTH__, _MAX)</span>
<span class="addi">+#else</span>
<span class="addi">+# define WINT_MIN 0</span>
<span class="addi">+# define WINT_MAX __int_limit(UINT, __WINT_WIDTH__, _MAX)</span>
<span class="same"> #endif</span>
<span class="same"> </span>
<span class="same"> /* 7.18.4.2 Macros for greatest-width integer constants. */</span>
<span class="dele">-#define INTMAX_C(v) (v##LL)</span>
<span class="dele">-#define UINTMAX_C(v) (v##ULL)</span>
<span class="addi">+#define INTMAX_C(v) __int_c(v, __INTMAX_C_SUFFIX__)</span>
<span class="addi">+#define UINTMAX_C(v) __uint_c(v, __INTMAX_C_SUFFIX__)</span>
<span class="same"> </span>
<span class="same"> #endif /* __STDC_HOSTED__ */</span>
<span class="same"> #endif /* __CLANG_STDINT_H */</span></pre></div>
<div class="code_title"><h3><a name="test_CMakeLists_txt">test/CMakeLists.txt</a></h3><p class="nav"><a href="#test_CMakeLists_txt_nav">Back ↩</a></p>
<p class="rev">--- test/CMakeLists.txt (revision 84372)</p>
<p class="rev">+++ test/CMakeLists.txt (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -20,7 +20,8 @@</span>
<span class="same"> "SemaCXX"</span>
<span class="same"> "SemaObjC"</span>
<span class="same"> "SemaObjCXX"</span>
<span class="dele">- "SemaTemplate")</span>
<span class="addi">+ "SemaTemplate"</span>
<span class="addi">+ "Targets")</span>
<span class="same"> </span>
<span class="same"> include(FindPythonInterp)</span>
<span class="same"> if(PYTHONINTERP_FOUND)</span></pre></div>
<div class="code_title"><h3><a name="test_Index_c_index_api_test_m">test/Index/c-index-api-test.m</a></h3><p class="nav"><a href="#test_Index_c_index_api_test_m_nav">Back ↩</a></p>
<p class="rev">--- test/Index/c-index-api-test.m (revision 84372)</p>
<p class="rev">+++ test/Index/c-index-api-test.m (working copy)</p>
</div>
<div class="code"><pre><span class="mark">@@ -8,13 +8,13 @@</span>
<span class="same"> // CHECK: <invalid loc>:0:0: ObjCInterfaceDecl=Protocol:0:0 [Context=c-index-api-test.m]</span>
<span class="same"> // CHECK: <invalid loc>:0:0: TypedefDecl=id:0:0 [Context=c-index-api-test.m]</span>
<span class="same"> // CHECK: <invalid loc>:0:0: TypedefDecl=Class:0:0 [Context=c-index-api-test.m]</span>
<span class="dele">-// CHECK: <built-in>:79:16: StructDecl=__va_list_tag:79:16 [Context=c-index-api-test.m]</span>
<span class="dele">-// CHECK: <built-in>:79:42: FieldDecl=gp_offset:79:42 [Context=__va_list_tag]</span>
<span class="dele">-// CHECK: <built-in>:79:63: FieldDecl=fp_offset:79:63 [Context=__va_list_tag]</span>
<span class="dele">-// CHECK: <built-in>:79:81: FieldDecl=overflow_arg_area:79:81 [Context=__va_list_tag]</span>
<span class="dele">-// CHECK: <built-in>:79:107: FieldDecl=reg_save_area:79:107 [Context=__va_list_tag]</span>
<span class="dele">-// CHECK: <built-in>:79:123: TypedefDecl=__va_list_tag:79:123 [Context=c-index-api-test.m]</span>
<span class="dele">-// CHECK: <built-in>:79:159: TypedefDecl=__builtin_va_list:79:159 [Context=c-index-api-test.m]</span>
<span class="addi">+// CHECK: <built-in>:93:16: StructDecl=__va_list_tag:93:16 [Context=c-index-api-test.m]</span>
<span class="addi">+// CHECK: <built-in>:93:42: FieldDecl=gp_offset:93:42 [Context=__va_list_tag]</span>
<span class="addi">+// CHECK: <built-in>:93:63: FieldDecl=fp_offset:93:63 [Context=__va_list_tag]</span>
<span class="addi">+// CHECK: <built-in>:93:81: FieldDecl=overflow_arg_area:93:81 [Context=__va_list_tag]</span>
<span class="addi">+// CHECK: <built-in>:93:107: FieldDecl=reg_save_area:93:107 [Context=__va_list_tag]</span>
<span class="addi">+// CHECK: <built-in>:93:123: TypedefDecl=__va_list_tag:93:123 [Context=c-index-api-test.m]</span>
<span class="addi">+// CHECK: <built-in>:93:159: TypedefDecl=__builtin_va_list:93:159 [Context=c-index-api-test.m]</span>
<span class="same"> // </span>
<span class="same"> </span>
<span class="same"> @interface Foo </span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_asm_c">test/Preprocessor/init_asm.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_asm_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_asm.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_asm.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -x=assembler-with-cpp -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __ASSEMBLER__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_blocks_c">test/Preprocessor/init_blocks.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_blocks_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_blocks.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_blocks.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,7 @@</span>
<span class="addi">+// RUN: clang-cc -fblocks -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __BLOCKS__ 1</span>
<span class="addi">+// CHECK:#define __block __attribute__((__blocks__(byref)))</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_c__0x_c">test/Preprocessor/init_c++0x.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_c__0x_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_c++0x.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_c++0x.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,13 @@</span>
<span class="addi">+// RUN: clang-cc -x=c++ -fexceptions -std=c++0x -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _GNU_SOURCE 1</span>
<span class="addi">+// CHECK:#define __DEPRECATED 1</span>
<span class="addi">+// CHECK:#define __EXCEPTIONS 1</span>
<span class="addi">+// CHECK:#define __GNUG__ 4</span>
<span class="addi">+// CHECK:#define __GXX_EXPERIMENTAL_CXX0X__</span>
<span class="addi">+// CHECK:#define __GXX_WEAK__ 1</span>
<span class="addi">+// CHECK:#define __cplusplus 199711L</span>
<span class="addi">+// CHECK:#define __private_extern__ extern</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_c__98_c">test/Preprocessor/init_c++98.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_c__98_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_c++98.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_c++98.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,12 @@</span>
<span class="addi">+// RUN: clang-cc -x=c++ -fexceptions -std=c++98 -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+// </span>
<span class="addi">+// CHECK:#define _GNU_SOURCE 1</span>
<span class="addi">+// CHECK:#define __DEPRECATED 1</span>
<span class="addi">+// CHECK:#define __EXCEPTIONS 1</span>
<span class="addi">+// CHECK:#define __GNUG__</span>
<span class="addi">+// CHECK:#define __GXX_WEAK__ 1</span>
<span class="addi">+// CHECK:#define __cplusplus 199711L</span>
<span class="addi">+// CHECK:#define __private_extern__ extern</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_c99_c">test/Preprocessor/init_c99.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_c99_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_c99.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_c99.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,7 @@</span>
<span class="addi">+// RUN: clang-cc -std=c99 -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __STDC_VERSION__ 199901L</span>
<span class="addi">+// CHECK:#define __STRICT_ANSI__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_common_c">test/Preprocessor/init_common.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_common_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_common.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_common.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,18 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __CONSTANT_CFSTRINGS__ 1</span>
<span class="addi">+// CHECK:#define __FINITE_MATH_ONLY__ 0</span>
<span class="addi">+// CHECK:#define __GNUC_MINOR__</span>
<span class="addi">+// CHECK:#define __GNUC_PATCHLEVEL__</span>
<span class="addi">+// CHECK:#define __GNUC_STDC_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __GNUC__</span>
<span class="addi">+// CHECK:#define __GXX_ABI_VERSION</span>
<span class="addi">+// CHECK:#define __STDC_HOSTED__ 1</span>
<span class="addi">+// CHECK:#define __STDC_VERSION__</span>
<span class="addi">+// CHECK:#define __STDC__ 1</span>
<span class="addi">+// CHECK:#define __VERSION__</span>
<span class="addi">+// CHECK:#define __clang__ 1</span>
<span class="addi">+// CHECK:#define __llvm__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_freestanding_c">test/Preprocessor/init_freestanding.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_freestanding_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_freestanding.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_freestanding.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,3 @@</span>
<span class="addi">+// RUN: clang-cc -ffreestanding -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: grep '^#define __STDC_HOSTED__ 0$' %t &&</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_gnu__98_c">test/Preprocessor/init_gnu++98.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_gnu__98_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_gnu++98.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_gnu++98.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,12 @@</span>
<span class="addi">+// RUN: clang-cc -x=c++ -std=gnu++98 -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _GNU_SOURCE 1</span>
<span class="addi">+// CHECK:#define __DEPRECATED 1</span>
<span class="addi">+// CHECK-NOT:#define __EXCEPTIONS 1</span>
<span class="addi">+// CHECK:#define __GNUG__</span>
<span class="addi">+// CHECK:#define __GXX_WEAK__ 1</span>
<span class="addi">+// CHECK:#define __cplusplus 1</span>
<span class="addi">+// CHECK:#define __private_extern__ extern</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_iso9899_199409_c">test/Preprocessor/init_iso9899-199409.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_iso9899_199409_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_iso9899-199409.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_iso9899-199409.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -std=iso9899:199409 -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __STDC_VERSION__ 199409L</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_ms_extensions_c">test/Preprocessor/init_ms_extensions.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_ms_extensions_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_ms_extensions.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_ms_extensions.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,14 @@</span>
<span class="addi">+// RUN: clang-cc -fms-extensions -E -dM -o %t %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK-NOT:#define __STDC__</span>
<span class="addi">+// CHECK:#define __int16 __INT16_TYPE__</span>
<span class="addi">+// CHECK:#define __int32 __INT32_TYPE__</span>
<span class="addi">+// CHECK:#define __int64 __INT64_TYPE__</span>
<span class="addi">+// CHECK:#define __int8 __INT8_TYPE__</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __STDC__</span>
<span class="addi">+# error __STDC__ defined</span>
<span class="addi">+#endif</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_objective_c_c">test/Preprocessor/init_objective_c.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_objective_c_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_objective_c.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_objective_c.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,7 @@</span>
<span class="addi">+// RUN: clang-cc -x=objective-c -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define OBJC_NEW_PROPERTIES 1</span>
<span class="addi">+// CHECK:#define __OBJC__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_objective_c_gc_c">test/Preprocessor/init_objective_c_gc.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_objective_c_gc_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_objective_c_gc.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_objective_c_gc.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -x=objective-c -fobjc-gc -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __OBJC_GC__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_objective_c_next_runtime_c">test/Preprocessor/init_objective_c_next_runtime.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_objective_c_next_runtime_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_objective_c_next_runtime.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_objective_c_next_runtime.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -x=objective-c -fnext-runtime -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __NEXT_RUNTIME__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_objective_c_non_fragile_abi_c">test/Preprocessor/init_objective_c_non_fragile_abi.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_objective_c_non_fragile_abi_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_objective_c_non_fragile_abi.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_objective_c_non_fragile_abi.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,8 @@</span>
<span class="addi">+// RUN: clang-cc -x=objective-c -fobjc-nonfragile-abi -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define OBJC_ZEROCOST_EXCEPTIONS 1</span>
<span class="addi">+// CHECK-NOT:#define __EXCEPTIONS 1</span>
<span class="addi">+// CHECK:#define __OBJC2__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_optimize_c">test/Preprocessor/init_optimize.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_optimize_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_optimize.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_optimize.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -O1 -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __OPTIMIZE__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_optimize_size_c">test/Preprocessor/init_optimize_size.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_optimize_size_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_optimize_size.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_optimize_size.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,7 @@</span>
<span class="addi">+// XFAIL</span>
<span class="addi">+// RUN: clang-cc -Os -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __OPTIMIZE_SIZE__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_pascal_strings_c">test/Preprocessor/init_pascal_strings.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_pascal_strings_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_pascal_strings.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_pascal_strings.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -fpascal-strings -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __PASCAL_STRINGS__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Preprocessor_init_signed_char_c">test/Preprocessor/init_signed_char.c</a></h3><p class="nav"><a href="#test_Preprocessor_init_signed_char_c_nav">Back ↩</a></p>
<p class="rev">--- test/Preprocessor/init_signed_char.c (revision 0)</p>
<p class="rev">+++ test/Preprocessor/init_signed_char.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,6 @@</span>
<span class="addi">+// RUN: clang-cc -fsigned-char -E -dM -o %t - < /dev/null &&</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#ifdef __UNSIGNED_CHAR__</span>
<span class="addi">+# error __UNSIGNED_CHAR__ defined when forcing signed characters</span>
<span class="addi">+#endif</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_arm_cpp_init_c">test/Targets/arm/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_arm_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/arm/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/arm/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,91 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=arm-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __APCS_32__ 1</span>
<span class="addi">+// CHECK:#define __ARMEL__ 1</span>
<span class="addi">+// CHECK:#define __ARM_ARCH_6K__ 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LITTLE_ENDIAN__ 1</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __THUMB_INTERWORK__ 1</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __VFP_FP__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __arm 1</span>
<span class="addi">+// CHECK:#define __arm__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_arm_stdint_c">test/Targets/arm/stdint.c</a></h3><p class="nav"><a href="#test_Targets_arm_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/arm/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/arm/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=arm-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_bfin_cpp_init_c">test/Targets/bfin/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_bfin_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/bfin/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/bfin/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,91 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=bfin-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define BFIN 1</span>
<span class="addi">+// CHECK:#define __ADSPBLACKFIN__ 1</span>
<span class="addi">+// CHECK:#define __ADSPLPBLACKFIN__ 1</span>
<span class="addi">+// CHECK:#define __BFIN 1</span>
<span class="addi">+// CHECK:#define __BFIN__ 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __bfin 1</span>
<span class="addi">+// CHECK:#define __bfin__ 1</span>
<span class="addi">+// CHECK:#define bfin 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_bfin_stdint_c">test/Targets/bfin/stdint.c</a></h3><p class="nav"><a href="#test_Targets_bfin_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/bfin/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/bfin/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,118 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=bfin-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0ULL)</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_i386_cpp_init_c">test/Targets/i386/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_i386_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/i386/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/i386/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,92 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=i386-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 21</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 18</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 1.08420217248550443401e-19L</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 64</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 4932</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 16384</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.18973149535723176502e+4932L</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-4931)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-16381)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 3.36210314311209350626e-4932L</span>
<span class="addi">+// CHECK:#define __LITTLE_ENDIAN__ 1</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __NO_MATH_INLINES 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __REGISTER_PREFIX__ </span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __i386 1</span>
<span class="addi">+// CHECK:#define __i386__ 1</span>
<span class="addi">+// CHECK:#define __nocona 1</span>
<span class="addi">+// CHECK:#define __nocona__ 1</span>
<span class="addi">+// CHECK:#define __tune_nocona__ 1</span>
<span class="addi">+// CHECK:#define i386 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_i386_stdint_c">test/Targets/i386/stdint.c</a></h3><p class="nav"><a href="#test_Targets_i386_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/i386/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/i386/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=i386-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+// </span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_msp430_cpp_init_c">test/Targets/msp430/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_msp430_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/msp430/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/msp430/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,85 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=msp430-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define MSP430 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 2147483647LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __MSP430__ 1</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __clang__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_msp430_stdint_c">test/Targets/msp430/stdint.c</a></h3><p class="nav"><a href="#test_Targets_msp430_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/msp430/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/msp430/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,110 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=msp430-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed long int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef short intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:UINT32_MAX_ (4294967295UL)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ (4294967295UL)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ (4294967295UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ INT64_MAX</span>
<span class="addi">+// CHECK:INT64_MIN_ INT64_MIN</span>
<span class="addi">+// CHECK:UINT64_MAX_ UINT64_MAX</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ INT_LEAST64_MIN</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ INT_LEAST64_MAX</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ UINT_LEAST64_MAX</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ INT_FAST64_MIN</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ INT_FAST64_MAX</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ UINT_FAST64_MAX</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-32768)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (32767)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (4294967295UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-32768)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (32767)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-32768)</span>
<span class="addi">+// CHECK:WINT_MAX_ (32767)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (32767)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-32768)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0UL)</span>
<span class="addi">+// CHECK:INT64_C_(0) INT64_C(0)</span>
<span class="addi">+// CHECK:UINT64_C_(0) UINT64_C(0)</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_pic16_cpp_init_c">test/Targets/pic16/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_pic16_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/pic16/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/pic16/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,91 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=pic16-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _CONFIG(conf) asm("CONFIG "#conf)</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 6</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ (-1)</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 6</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 2147483647LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 16</span>
<span class="addi">+// CHECK:#define __clang__ 1</span>
<span class="addi">+// CHECK:#define __llvm__ 1</span>
<span class="addi">+// CHECK:#define __pic16 1</span>
<span class="addi">+// CHECK:#define _address(Addr) __attribute__((section("Address="#Addr)))</span>
<span class="addi">+// CHECK:#define _interrupt __attribute__((section("interrupt=0x4"))) __attribute__((used))</span>
<span class="addi">+// CHECK:#define _section(SectName) __attribute__((section(SectName)))</span>
<span class="addi">+// CHECK:#define ram __attribute__((address_space(0)))</span>
<span class="addi">+// CHECK:#define rom __attribute__((address_space(1)))</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_pic16_stdint_c">test/Targets/pic16/stdint.c</a></h3><p class="nav"><a href="#test_Targets_pic16_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/pic16/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/pic16/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,111 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=pic16-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+// </span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed long int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef short intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:UINT32_MAX_ (4294967295UL)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ (4294967295UL)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ (4294967295UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ INT64_MAX</span>
<span class="addi">+// CHECK:INT64_MIN_ INT64_MIN</span>
<span class="addi">+// CHECK:UINT64_MAX_ UINT64_MAX</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ INT_LEAST64_MIN</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ INT_LEAST64_MAX</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ UINT_LEAST64_MAX</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ INT_FAST64_MIN</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ INT_FAST64_MAX</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ UINT_FAST64_MAX</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-32768)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (32767)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-2147483648L)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (2147483647L)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (4294967295UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-32768)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (32767)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-32768)</span>
<span class="addi">+// CHECK:WINT_MAX_ (32767)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (32767)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-32768)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0UL)</span>
<span class="addi">+// CHECK:INT64_C_(0) INT64_C(0)</span>
<span class="addi">+// CHECK:UINT64_C_(0) UINT64_C(0)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_powerpc_cpp_init_c">test/Targets/powerpc/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_powerpc_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/powerpc/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/powerpc/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,92 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=powerpc-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _ARCH_PPC 1</span>
<span class="addi">+// CHECK:#define _BIG_ENDIAN 1</span>
<span class="addi">+// CHECK:#define __BIG_ENDIAN__ 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __CHAR_UNSIGNED__ 1</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_DOUBLE_128__ 1</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NATURAL_ALIGNMENT__ 1</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __POWERPC__ 1</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __REGISTER_PREFIX__ </span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __ppc__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_powerpc_stdint_c">test/Targets/powerpc/stdint.c</a></h3><p class="nav"><a href="#test_Targets_powerpc_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/powerpc/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/powerpc/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=powerpc-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_powerpc64_cpp_init_c">test/Targets/powerpc64/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_powerpc64_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/powerpc64/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/powerpc64/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,96 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=powerpc64-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _ARCH_PPC 1</span>
<span class="addi">+// CHECK:#define _ARCH_PPC64 1</span>
<span class="addi">+// CHECK:#define _BIG_ENDIAN 1</span>
<span class="addi">+// CHECK:#define _LP64 1</span>
<span class="addi">+// CHECK:#define __BIG_ENDIAN__ 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __CHAR_UNSIGNED__ 1</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807L</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_DOUBLE_128__ 1</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 9223372036854775807L</span>
<span class="addi">+// CHECK:#define __LP64__ 1</span>
<span class="addi">+// CHECK:#define __NATURAL_ALIGNMENT__ 1</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __POWERPC__ 1</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __REGISTER_PREFIX__ </span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __ppc64__ 1</span>
<span class="addi">+// CHECK:#define __ppc__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_powerpc64_stdint_c">test/Targets/powerpc64/stdint.c</a></h3><p class="nav"><a href="#test_Targets_powerpc64_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/powerpc64/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/powerpc64/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=powerpc64-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:SIZE_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_s390x_cpp_init_c">test/Targets/s390x/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_s390x_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/s390x/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/s390x/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,86 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=s390x-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __CHAR_UNSIGNED__ 1</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 9223372036854775807L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __s390__ 1</span>
<span class="addi">+// CHECK:#define __s390x__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_s390x_stdint_c">test/Targets/s390x/stdint.c</a></h3><p class="nav"><a href="#test_Targets_s390x_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/s390x/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/s390x/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,118 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=s390x-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+// </span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:SIZE_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_sparc_cpp_init_c">test/Targets/sparc/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_sparc_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/sparc/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/sparc/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,89 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=sparc-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 17</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ LL</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __REGISTER_PREFIX__ </span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __VERSION__ "4.2.1 Compatible Clang Compiler"</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __sparc 1</span>
<span class="addi">+// CHECK:#define __sparc__ 1</span>
<span class="addi">+// CHECK:#define __sparcv8 1</span>
<span class="addi">+// CHECK:#define sparc 1</span>
<span class="addi">+// </span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_sparc_stdint_c">test/Targets/sparc/stdint.c</a></h3><p class="nav"><a href="#test_Targets_sparc_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/sparc/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/sparc/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=sparc-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808LL)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807LL)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0LL)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0ULL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_stdint_test_h">test/Targets/stdint_test.h</a></h3><p class="nav"><a href="#test_Targets_stdint_test_h_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/stdint_test.h (revision 0)</p>
<p class="rev">+++ test/Targets/stdint_test.h (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,72 @@</span>
<span class="addi">+#include <stdint.h></span>
<span class="addi">+</span>
<span class="addi">+INT8_MAX_ INT8_MAX</span>
<span class="addi">+INT8_MIN_ INT8_MIN</span>
<span class="addi">+UINT8_MAX_ UINT8_MAX</span>
<span class="addi">+INT_LEAST8_MIN_ INT_LEAST8_MIN</span>
<span class="addi">+INT_LEAST8_MAX_ INT_LEAST8_MAX</span>
<span class="addi">+UINT_LEAST8_MAX_ UINT_LEAST8_MAX</span>
<span class="addi">+INT_FAST8_MIN_ INT_FAST8_MIN</span>
<span class="addi">+INT_FAST8_MAX_ INT_FAST8_MAX</span>
<span class="addi">+UINT_FAST8_MAX_ UINT_FAST8_MAX</span>
<span class="addi">+</span>
<span class="addi">+INT16_MAX_ INT16_MAX</span>
<span class="addi">+INT16_MIN_ INT16_MIN</span>
<span class="addi">+UINT16_MAX_ UINT16_MAX</span>
<span class="addi">+INT_LEAST16_MIN_ INT_LEAST16_MIN</span>
<span class="addi">+INT_LEAST16_MAX_ INT_LEAST16_MAX</span>
<span class="addi">+UINT_LEAST16_MAX_ UINT_LEAST16_MAX</span>
<span class="addi">+INT_FAST16_MIN_ INT_FAST16_MIN</span>
<span class="addi">+INT_FAST16_MAX_ INT_FAST16_MAX</span>
<span class="addi">+UINT_FAST16_MAX_ UINT_FAST16_MAX</span>
<span class="addi">+</span>
<span class="addi">+INT32_MAX_ INT32_MAX</span>
<span class="addi">+INT32_MIN_ INT32_MIN</span>
<span class="addi">+UINT32_MAX_ UINT32_MAX</span>
<span class="addi">+INT_LEAST32_MIN_ INT_LEAST32_MIN</span>
<span class="addi">+INT_LEAST32_MAX_ INT_LEAST32_MAX</span>
<span class="addi">+UINT_LEAST32_MAX_ UINT_LEAST32_MAX</span>
<span class="addi">+INT_FAST32_MIN_ INT_FAST32_MIN</span>
<span class="addi">+INT_FAST32_MAX_ INT_FAST32_MAX</span>
<span class="addi">+UINT_FAST32_MAX_ UINT_FAST32_MAX</span>
<span class="addi">+</span>
<span class="addi">+INT64_MAX_ INT64_MAX</span>
<span class="addi">+INT64_MIN_ INT64_MIN</span>
<span class="addi">+UINT64_MAX_ UINT64_MAX</span>
<span class="addi">+INT_LEAST64_MIN_ INT_LEAST64_MIN</span>
<span class="addi">+INT_LEAST64_MAX_ INT_LEAST64_MAX</span>
<span class="addi">+UINT_LEAST64_MAX_ UINT_LEAST64_MAX</span>
<span class="addi">+INT_FAST64_MIN_ INT_FAST64_MIN</span>
<span class="addi">+INT_FAST64_MAX_ INT_FAST64_MAX</span>
<span class="addi">+UINT_FAST64_MAX_ UINT_FAST64_MAX</span>
<span class="addi">+</span>
<span class="addi">+INTPTR_MIN_ INTPTR_MIN</span>
<span class="addi">+INTPTR_MAX_ INTPTR_MAX</span>
<span class="addi">+UINTPTR_MAX_ UINTPTR_MAX</span>
<span class="addi">+PTRDIFF_MIN_ PTRDIFF_MIN</span>
<span class="addi">+PTRDIFF_MAX_ PTRDIFF_MAX</span>
<span class="addi">+SIZE_MAX_ SIZE_MAX</span>
<span class="addi">+</span>
<span class="addi">+INTMAX_MIN_ INTMAX_MIN</span>
<span class="addi">+INTMAX_MAX_ INTMAX_MAX</span>
<span class="addi">+UINTMAX_MAX_ UINTMAX_MAX</span>
<span class="addi">+</span>
<span class="addi">+SIG_ATOMIC_MIN_ SIG_ATOMIC_MIN</span>
<span class="addi">+SIG_ATOMIC_MAX_ SIG_ATOMIC_MAX</span>
<span class="addi">+WINT_MIN_ WINT_MIN</span>
<span class="addi">+WINT_MAX_ WINT_MAX</span>
<span class="addi">+</span>
<span class="addi">+WCHAR_MAX_ WCHAR_MAX</span>
<span class="addi">+WCHAR_MIN_ WCHAR_MIN</span>
<span class="addi">+</span>
<span class="addi">+INT8_C_(0) INT8_C(0)</span>
<span class="addi">+UINT8_C_(0) UINT8_C(0)</span>
<span class="addi">+INT16_C_(0) INT16_C(0)</span>
<span class="addi">+UINT16_C_(0) UINT16_C(0)</span>
<span class="addi">+INT32_C_(0) INT32_C(0)</span>
<span class="addi">+UINT32_C_(0) UINT32_C(0)</span>
<span class="addi">+INT64_C_(0) INT64_C(0)</span>
<span class="addi">+UINT64_C_(0) UINT64_C(0)</span>
<span class="addi">+</span>
<span class="addi">+INTMAX_C_(0) INTMAX_C(0)</span>
<span class="addi">+UINTMAX_C_(0) UINTMAX_C(0)</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_tce_cpp_init_c">test/Targets/tce/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_tce_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/tce/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/tce/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,86 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=tce-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 6</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ (-1)</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 6</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 2147483647LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 2147483647L</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __TCE_V1__ 1</span>
<span class="addi">+// CHECK:#define __TCE__ 1</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __tce 1</span>
<span class="addi">+// CHECK:#define __tce__ 1</span>
<span class="addi">+// CHECK:#define tce 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_tce_stdint_c">test/Targets/tce/stdint.c</a></h3><p class="nav"><a href="#test_Targets_tce_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/tce/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/tce/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,111 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=tce-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ INT64_MAX</span>
<span class="addi">+// CHECK:INT64_MIN_ INT64_MIN</span>
<span class="addi">+// CHECK:UINT64_MAX_ UINT64_MAX</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ INT_LEAST64_MIN</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ INT_LEAST64_MAX</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ UINT_LEAST64_MAX</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ INT_FAST64_MIN</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ INT_FAST64_MAX</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ UINT_FAST64_MAX</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:SIZE_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) INT64_C(0)</span>
<span class="addi">+// CHECK:UINT64_C_(0) UINT64_C(0)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_x86_64_cpp_init_c">test/Targets/x86_64/cpp-init.c</a></h3><p class="nav"><a href="#test_Targets_x86_64_cpp_init_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/x86_64/cpp-init.c (revision 0)</p>
<p class="rev">+++ test/Targets/x86_64/cpp-init.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,100 @@</span>
<span class="addi">+// RUN: clang-cc -E -dM -o %t -ffreestanding -triple=x86_64-none-none < /dev/null &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:#define _LP64 1</span>
<span class="addi">+// CHECK:#define __CHAR_BIT__ 8</span>
<span class="addi">+// CHECK:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324</span>
<span class="addi">+// CHECK:#define __DBL_DIG__ 15</span>
<span class="addi">+// CHECK:#define __DBL_EPSILON__ 2.2204460492503131e-16</span>
<span class="addi">+// CHECK:#define __DBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __DBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __DBL_MANT_DIG__ 53</span>
<span class="addi">+// CHECK:#define __DBL_MAX_10_EXP__ 308</span>
<span class="addi">+// CHECK:#define __DBL_MAX_EXP__ 1024</span>
<span class="addi">+// CHECK:#define __DBL_MAX__ 1.7976931348623157e+308</span>
<span class="addi">+// CHECK:#define __DBL_MIN_10_EXP__ (-307)</span>
<span class="addi">+// CHECK:#define __DBL_MIN_EXP__ (-1021)</span>
<span class="addi">+// CHECK:#define __DBL_MIN__ 2.2250738585072014e-308</span>
<span class="addi">+// CHECK:#define __DECIMAL_DIG__ 21</span>
<span class="addi">+// CHECK:#define __FLT_DENORM_MIN__ 1.40129846e-45F</span>
<span class="addi">+// CHECK:#define __FLT_DIG__ 6</span>
<span class="addi">+// CHECK:#define __FLT_EPSILON__ 1.19209290e-7F</span>
<span class="addi">+// CHECK:#define __FLT_EVAL_METHOD__ 0</span>
<span class="addi">+// CHECK:#define __FLT_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __FLT_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __FLT_MANT_DIG__ 24</span>
<span class="addi">+// CHECK:#define __FLT_MAX_10_EXP__ 38</span>
<span class="addi">+// CHECK:#define __FLT_MAX_EXP__ 128</span>
<span class="addi">+// CHECK:#define __FLT_MAX__ 3.40282347e+38F</span>
<span class="addi">+// CHECK:#define __FLT_MIN_10_EXP__ (-37)</span>
<span class="addi">+// CHECK:#define __FLT_MIN_EXP__ (-125)</span>
<span class="addi">+// CHECK:#define __FLT_MIN__ 1.17549435e-38F</span>
<span class="addi">+// CHECK:#define __FLT_RADIX__ 2</span>
<span class="addi">+// CHECK:#define __INT16_TYPE__ short</span>
<span class="addi">+// CHECK:#define __INT32_TYPE__ int</span>
<span class="addi">+// CHECK:#define __INT64_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INT64_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INT8_TYPE__ char</span>
<span class="addi">+// CHECK:#define __INTMAX_C_SUFFIX__ L</span>
<span class="addi">+// CHECK:#define __INTMAX_MAX__ 9223372036854775807L</span>
<span class="addi">+// CHECK:#define __INTMAX_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INTPTR_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __INTPTR_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __INT_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L</span>
<span class="addi">+// CHECK:#define __LDBL_DIG__ 18</span>
<span class="addi">+// CHECK:#define __LDBL_EPSILON__ 1.08420217248550443401e-19L</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_DENORM__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_INFINITY__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_HAS_QUIET_NAN__ 1</span>
<span class="addi">+// CHECK:#define __LDBL_MANT_DIG__ 64</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_10_EXP__ 4932</span>
<span class="addi">+// CHECK:#define __LDBL_MAX_EXP__ 16384</span>
<span class="addi">+// CHECK:#define __LDBL_MAX__ 1.18973149535723176502e+4932L</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_10_EXP__ (-4931)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN_EXP__ (-16381)</span>
<span class="addi">+// CHECK:#define __LDBL_MIN__ 3.36210314311209350626e-4932L</span>
<span class="addi">+// CHECK:#define __LITTLE_ENDIAN__ 1</span>
<span class="addi">+// CHECK:#define __LONG_LONG_MAX__ 9223372036854775807LL</span>
<span class="addi">+// CHECK:#define __LONG_MAX__ 9223372036854775807L</span>
<span class="addi">+// CHECK:#define __LP64__ 1</span>
<span class="addi">+// CHECK:#define __MMX__ 1</span>
<span class="addi">+// CHECK:#define __NO_INLINE__ 1</span>
<span class="addi">+// CHECK:#define __NO_MATH_INLINES 1</span>
<span class="addi">+// CHECK:#define __POINTER_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __PTRDIFF_TYPE__ long int</span>
<span class="addi">+// CHECK:#define __PTRDIFF_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __REGISTER_PREFIX__ </span>
<span class="addi">+// CHECK:#define __SCHAR_MAX__ 127</span>
<span class="addi">+// CHECK:#define __SHRT_MAX__ 32767</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_TYPE__ int</span>
<span class="addi">+// CHECK:#define __SIG_ATOMIC_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __SIZE_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __SIZE_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __SSE2_MATH__ 1</span>
<span class="addi">+// CHECK:#define __SSE2__ 1</span>
<span class="addi">+// CHECK:#define __SSE_MATH__ 1</span>
<span class="addi">+// CHECK:#define __SSE__ 1</span>
<span class="addi">+// CHECK:#define __UINTMAX_TYPE__ unsigned long int</span>
<span class="addi">+// CHECK:#define __UINTMAX_WIDTH__ 64</span>
<span class="addi">+// CHECK:#define __USER_LABEL_PREFIX__ _</span>
<span class="addi">+// CHECK:#define __WCHAR_MAX__ 2147483647</span>
<span class="addi">+// CHECK:#define __WCHAR_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WCHAR_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WCHAR_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __WINT_SIGNED__ 1</span>
<span class="addi">+// CHECK:#define __WINT_TYPE__ int</span>
<span class="addi">+// CHECK:#define __WINT_WIDTH__ 32</span>
<span class="addi">+// CHECK:#define __amd64 1</span>
<span class="addi">+// CHECK:#define __amd64__ 1</span>
<span class="addi">+// CHECK:#define __nocona 1</span>
<span class="addi">+// CHECK:#define __nocona__ 1</span>
<span class="addi">+// CHECK:#define __tune_nocona__ 1</span>
<span class="addi">+// CHECK:#define __x86_64 1</span>
<span class="addi">+// CHECK:#define __x86_64__ 1</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span></pre></div>
<div class="code_title"><h3><a name="test_Targets_x86_64_stdint_c">test/Targets/x86_64/stdint.c</a></h3><p class="nav"><a href="#test_Targets_x86_64_stdint_c_nav">Back ↩</a></p>
<p class="rev">--- test/Targets/x86_64/stdint.c (revision 0)</p>
<p class="rev">+++ test/Targets/x86_64/stdint.c (revision 0)</p>
</div>
<div class="code"><pre><span class="mark">@@ -0,0 +1,119 @@</span>
<span class="addi">+// RUN: clang-cc -E -o %t -ffreestanding -triple=x86_64-none-none %s &&</span>
<span class="addi">+// RUN: FileCheck -input-file %t %s &&</span>
<span class="addi">+//</span>
<span class="addi">+// 64-bit types</span>
<span class="addi">+// CHECK:typedef signed long int int64_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uint64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_least64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_least64_t;</span>
<span class="addi">+// CHECK:typedef int64_t int_fast64_t;</span>
<span class="addi">+// CHECK:typedef uint64_t uint_fast64_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 32-bit types</span>
<span class="addi">+// CHECK:typedef signed int int32_t;</span>
<span class="addi">+// CHECK:typedef unsigned int uint32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_least32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_least32_t;</span>
<span class="addi">+// CHECK:typedef int32_t int_fast32_t;</span>
<span class="addi">+// CHECK:typedef uint32_t uint_fast32_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 16-bit types</span>
<span class="addi">+// CHECK:typedef signed short int16_t;</span>
<span class="addi">+// CHECK:typedef unsigned short uint16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_least16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_least16_t;</span>
<span class="addi">+// CHECK:typedef int16_t int_fast16_t;</span>
<span class="addi">+// CHECK:typedef uint16_t uint_fast16_t;</span>
<span class="addi">+//</span>
<span class="addi">+// 8-bit types</span>
<span class="addi">+// CHECK:typedef signed char int8_t;</span>
<span class="addi">+// CHECK:typedef unsigned char uint8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_least8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_least8_t;</span>
<span class="addi">+// CHECK:typedef int8_t int_fast8_t;</span>
<span class="addi">+// CHECK:typedef uint8_t uint_fast8_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Integer types capable of holding object pointers</span>
<span class="addi">+// CHECK:typedef long int intptr_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintptr_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Greatest-width integer types</span>
<span class="addi">+// CHECK:typedef long int intmax_t;</span>
<span class="addi">+// CHECK:typedef unsigned long int uintmax_t;</span>
<span class="addi">+//</span>
<span class="addi">+// Limits of specified-width integer types</span>
<span class="addi">+// CHECK:INT8_MAX_ (127)</span>
<span class="addi">+// CHECK:INT8_MIN_ (-128)</span>
<span class="addi">+// CHECK:UINT8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_LEAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_LEAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_LEAST8_MAX_ ( 255U)</span>
<span class="addi">+// CHECK:INT_FAST8_MIN_ (-128)</span>
<span class="addi">+// CHECK:INT_FAST8_MAX_ (127)</span>
<span class="addi">+// CHECK:UINT_FAST8_MAX_ ( 255U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT16_MAX_ (32767)</span>
<span class="addi">+// CHECK:INT16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:UINT16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_LEAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_LEAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_LEAST16_MAX_ ( 65535U)</span>
<span class="addi">+// CHECK:INT_FAST16_MIN_ (-32768)</span>
<span class="addi">+// CHECK:INT_FAST16_MAX_ (32767)</span>
<span class="addi">+// CHECK:UINT_FAST16_MAX_ ( 65535U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:INT32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:UINT32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_LEAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_LEAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_LEAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+// CHECK:INT_FAST32_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:INT_FAST32_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:UINT_FAST32_MAX_ ( 4294967295U)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INT64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:INT64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:UINT64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_LEAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_LEAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_LEAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:INT_FAST64_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INT_FAST64_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINT_FAST64_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTPTR_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTPTR_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTPTR_MAX_ (18446744073709551615UL)</span>
<span class="addi">+// CHECK:PTRDIFF_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:PTRDIFF_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:SIZE_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_MIN_ (-9223372036854775808L)</span>
<span class="addi">+// CHECK:INTMAX_MAX_ (9223372036854775807L)</span>
<span class="addi">+// CHECK:UINTMAX_MAX_ (18446744073709551615UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:SIG_ATOMIC_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WINT_MIN_ (-2147483648)</span>
<span class="addi">+// CHECK:WINT_MAX_ (2147483647)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:WCHAR_MAX_ (2147483647)</span>
<span class="addi">+// CHECK:WCHAR_MIN_ (-2147483648)</span>
<span class="addi">+//</span>
<span class="addi">+// Macros for integer constants</span>
<span class="addi">+// CHECK:INT8_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT8_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT16_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT16_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT32_C_(0) (0)</span>
<span class="addi">+// CHECK:UINT32_C_(0) (0U)</span>
<span class="addi">+// CHECK:INT64_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINT64_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// CHECK:INTMAX_C_(0) (0L)</span>
<span class="addi">+// CHECK:UINTMAX_C_(0) (0UL)</span>
<span class="addi">+//</span>
<span class="addi">+// RUN: true</span>
<span class="addi">+</span>
<span class="addi">+#include "../stdint_test.h"</span></pre></div>
<div class="footer">Created by patch2html.rb 2009-10-17T20:01:31-04:00</div>
</body>
</html>