diff options
Diffstat (limited to 'test')
139 files changed, 4394 insertions, 297 deletions
diff --git a/test/Analysis/misc-ps-eager-assume.m b/test/Analysis/misc-ps-eager-assume.m index 818922eba925..db1a80b8efd9 100644 --- a/test/Analysis/misc-ps-eager-assume.m +++ b/test/Analysis/misc-ps-eager-assume.m @@ -77,3 +77,46 @@ void pr3836(int *a, int *b) { *a = 1; // no-warning *b = 1; // no-warning } + + +//===---------------------------------------------------------------------===// +// <rdar://problem/7342806> +// This false positive occured because the symbolic constraint on a short was +// not maintained via sign extension. The analyzer doesn't properly handle +// the sign extension, but now tracks the constraint. This particular +// case relies on -analyzer-eagerly-assume because of the expression +// 'Flag1 != Count > 0'. +//===---------------------------------------------------------------------===// + +void rdar7342806_aux(short x); + +void rdar7342806() { + extern short Count; + extern short Flag1; + + short *Pointer = 0; + short Flag2 = !!Pointer; // Flag2 is false (0). + short Ok = 1; + short Which; + + if( Flag1 != Count > 0 ) + // Static analyzer skips this so either + // Flag1 is true and Count > 0 + // or + // Flag1 is false and Count <= 0 + Ok = 0; + + if( Flag1 != Flag2 ) + // Analyzer skips this so Flag1 and Flag2 have the + // same value, both are false because Flag2 is false. And + // from that we know Count must be <= 0. + Ok = 0; + + for( Which = 0; + Which < Count && Ok; + Which++ ) + // This statement can only execute if Count > 0 which can only + // happen when Flag1 and Flag2 are both true and Flag2 will only + // be true when Pointer is not NULL. + rdar7342806_aux(*Pointer); // no-warning +} diff --git a/test/Analysis/misc-ps-region-store.m b/test/Analysis/misc-ps-region-store.m index b6fff102a701..4cde7726b49b 100644 --- a/test/Analysis/misc-ps-region-store.m +++ b/test/Analysis/misc-ps-region-store.m @@ -372,3 +372,62 @@ void doSomething_7312221_with_struct(struct rdar_7312221_container *Self) { } } +//===----------------------------------------------------------------------===// +// <rdar://problem/7332673> - Just more tests cases for regions +//===----------------------------------------------------------------------===// + +void rdar_7332673_test1() { + char value[1]; + if ( *(value) != 1 ) {} // expected-warning{{The left operand of '!=' is a garbage value}} +} +void rdar_rdar_7332673_test2_aux(char *x); +void rdar_7332673_test2() { + char *value; + if ( rdar_7332673_test2_aux(value) != 1 ) {} // expected-warning{{Pass-by-value argument in function call is undefined}} +} + +//===----------------------------------------------------------------------===// +// <rdar://problem/7347252>: Because of a bug in +// RegionStoreManager::RemoveDeadBindings(), the symbol for s->session->p +// would incorrectly be pruned from the state after the call to +// rdar7347252_malloc1(), and would incorrectly result in a warning about +// passing a null pointer to rdar7347252_memcpy(). +//===----------------------------------------------------------------------===// + +struct rdar7347252_AA { char *p;}; +typedef struct { + struct rdar7347252_AA *session; + int t; + char *q; +} rdar7347252_SSL1; + +int rdar7347252_f(rdar7347252_SSL1 *s); +char *rdar7347252_malloc1(int); +char *rdar7347252_memcpy1(char *d, char *s, int n) __attribute__((nonnull (1,2))); + +int rdar7347252(rdar7347252_SSL1 *s) { + rdar7347252_f(s); // the SymbolicRegion of 's' is set a default binding of conjured symbol + if (s->session->p == ((void*)0)) { + if ((s->session->p = rdar7347252_malloc1(10)) == ((void*)0)) { + return 0; + } + rdar7347252_memcpy1(s->session->p, "aa", 2); // no-warning + } + return 0; +} + +//===----------------------------------------------------------------------===// +// PR 5316 - "crash when accessing field of lazy compound value" +// Previously this caused a crash at the MemberExpr '.chr' when loading +// a field value from a LazyCompoundVal +//===----------------------------------------------------------------------===// + +typedef unsigned int pr5316_wint_t; +typedef pr5316_wint_t pr5316_REFRESH_CHAR; +typedef struct { + pr5316_REFRESH_CHAR chr; +} +pr5316_REFRESH_ELEMENT; +static void pr5316(pr5316_REFRESH_ELEMENT *dst, const pr5316_REFRESH_ELEMENT *src) { + while ((*dst++ = *src++).chr != L'\0') ; +} diff --git a/test/Analysis/misc-ps.m b/test/Analysis/misc-ps.m index fcc13a39a461..947b41ae794c 100644 --- a/test/Analysis/misc-ps.m +++ b/test/Analysis/misc-ps.m @@ -121,12 +121,12 @@ void check_zero_sized_VLA(int x) { if (x) return; - int vla[x]; // expected-warning{{Variable-length array 'vla' has zero elements (undefined behavior)}} + int vla[x]; // expected-warning{{Declare variable-length array (VLA) of zero size}} } void check_uninit_sized_VLA() { int x; - int vla[x]; // expected-warning{{Variable-length array 'vla' garbage value for array size}} + int vla[x]; // expected-warning{{Declare variable-length array (VLA) of undefined size}} } // sizeof(void) @@ -154,6 +154,12 @@ void handle_sizeof_void(unsigned flag) { *p = 1; // no-warning } +// check deference of undefined values +void check_deref_undef(void) { + int *p; + *p = 0xDEADBEEF; // expected-warning{{Dereference of undefined pointer value}} +} + // PR 3422 void pr3422_helper(char *p); void pr3422() { diff --git a/test/Analysis/outofbound.c b/test/Analysis/outofbound.c index 568f14329e9b..e676ea3b3889 100644 --- a/test/Analysis/outofbound.c +++ b/test/Analysis/outofbound.c @@ -1,5 +1,5 @@ // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -verify %s -// XFAIL +// XFAIL: * char f1() { char* s = "abcd"; diff --git a/test/Analysis/retain-release-gc-only.m b/test/Analysis/retain-release-gc-only.m index 2833b02f0771..e27cfe758aaf 100644 --- a/test/Analysis/retain-release-gc-only.m +++ b/test/Analysis/retain-release-gc-only.m @@ -92,6 +92,7 @@ typedef struct _NSZone NSZone; + (id)allocWithZone:(NSZone *)zone; + (id)alloc; - (void)dealloc; +- (void)release; @end @interface NSObject (NSCoderMethods) - (id)awakeAfterUsingCoder:(NSCoder *)aDecoder; @@ -322,6 +323,16 @@ void rdar_7174400(QCView *view, QCRenderer *renderer, CIContext *context, } //===----------------------------------------------------------------------===// +// <rdar://problem/6250216> Warn against using -[NSAutoreleasePool release] in +// GC mode +//===----------------------------------------------------------------------===// + +void rdar_6250216(void) { + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + [pool release]; // expected-warning{{Use -drain instead of -release when using NSAutoreleasePool and garbage collection}} +} + +//===----------------------------------------------------------------------===// // Tests of ownership attributes. //===----------------------------------------------------------------------===// diff --git a/test/Analysis/retain-release.m b/test/Analysis/retain-release.m index e620037b2c14..879e8a0413b4 100644 --- a/test/Analysis/retain-release.m +++ b/test/Analysis/retain-release.m @@ -1098,6 +1098,32 @@ CVReturn rdar_7283567_2(CFAllocatorRef allocator, size_t width, size_t height, } //===----------------------------------------------------------------------===// +// <rdar://problem/7358899> False leak associated with +// CGBitmapContextCreateWithData +//===----------------------------------------------------------------------===// +typedef uint32_t CGBitmapInfo; +typedef void (*CGBitmapContextReleaseDataCallback)(void *releaseInfo, void *data); + +CGContextRef CGBitmapContextCreateWithData(void *data, + size_t width, size_t height, size_t bitsPerComponent, + size_t bytesPerRow, CGColorSpaceRef space, CGBitmapInfo bitmapInfo, + CGBitmapContextReleaseDataCallback releaseCallback, void *releaseInfo); + +void rdar_7358899(void *data, + size_t width, size_t height, size_t bitsPerComponent, + size_t bytesPerRow, CGColorSpaceRef space, CGBitmapInfo bitmapInfo, + CGBitmapContextReleaseDataCallback releaseCallback) { + + // For the allocated object, it doesn't really matter what type it is + // for the purpose of this test. All we want to show is that + // this is freed later by the callback. + NSNumber *number = [[NSNumber alloc] initWithInt:5]; // no-warning + + CGBitmapContextCreateWithData(data, width, height, bitsPerComponent, // expected-warning{{leak}} + bytesPerRow, space, bitmapInfo, releaseCallback, number); +} + +//===----------------------------------------------------------------------===// // <rdar://problem/7265711> allow 'new', 'copy', 'alloc', 'init' prefix to // start before '_' when determining Cocoa fundamental rule // diff --git a/test/Analysis/uninit-vals-ps-region.c b/test/Analysis/uninit-vals-ps-region.c index 1561f11c9937..e927a92576e2 100644 --- a/test/Analysis/uninit-vals-ps-region.c +++ b/test/Analysis/uninit-vals-ps-region.c @@ -24,9 +24,20 @@ void test_uninit_pos() { struct TestUninit v1 = { 0, 0 }; struct TestUninit v2 = test_uninit_aux(); int z; - v1.y = z; - test_unit_aux2(v2.x + v1.y); // expected-warning{{The right operand of '+' is a garbage value}} + v1.y = z; // expected-warning{{Assigned value is garbage or undefined}} + test_unit_aux2(v2.x + v1.y); } +void test_uninit_pos_2() { + struct TestUninit v1 = { 0, 0 }; + struct TestUninit v2; + test_unit_aux2(v2.x + v1.y); // expected-warning{{The left operand of '+' is a garbage value}} +} +void test_uninit_pos_3() { + struct TestUninit v1 = { 0, 0 }; + struct TestUninit v2; + test_unit_aux2(v1.y + v2.x); // expected-warning{{The right operand of '+' is a garbage value}} +} + void test_uninit_neg() { struct TestUninit v1 = { 0, 0 }; struct TestUninit v2 = test_uninit_aux(); diff --git a/test/Analysis/unused-ivars.m b/test/Analysis/unused-ivars.m index aacd44e7e677..9e9360da50c6 100644 --- a/test/Analysis/unused-ivars.m +++ b/test/Analysis/unused-ivars.m @@ -43,3 +43,25 @@ b(); } @end + +//===----------------------------------------------------------------------===// +// <rdar://problem/6260004> Detect that ivar is in use, if used in category +// in the same file as the implementation +//===----------------------------------------------------------------------===// + +@protocol Protocol6260004 +- (id) getId; +@end + +@interface RDar6260004 { +@private + id x; // no-warning +} +@end +@implementation RDar6260004 @end +@implementation RDar6260004 (Protocol6260004) +- (id) getId { + return x; +} +@end + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 66f05bff6994..a83a1993c8f0 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -24,6 +24,7 @@ set(CLANG_TEST_DIRECTORIES include(FindPythonInterp) if(PYTHONINTERP_FOUND) + get_target_triple(TARGET_TRIPLE) get_target_property(LLVM_TOOLS_PATH clang RUNTIME_OUTPUT_DIRECTORY) get_target_property(LLVM_LIBS_PATH clang LIBRARY_OUTPUT_DIRECTORY) set(CLANG_TEST_EXTRA_ARGS) @@ -32,16 +33,17 @@ if(PYTHONINTERP_FOUND) endif() foreach(testdir ${CLANG_TEST_DIRECTORIES}) - add_custom_target(clang-test-${testdir} + add_custom_target(clang-test-${testdir} COMMAND sed -e "s#\@LLVM_SOURCE_DIR\@#${LLVM_MAIN_SRC_DIR}#" -e "s#\@LLVM_BINARY_DIR\@#${LLVM_BINARY_DIR}#" -e "s#\@LLVM_TOOLS_DIR\@#${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}#" -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#" -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#" -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#" + -e "s#\@TARGET_TRIPLE\@#${TARGET_TRIPLE}#" ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in > ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg - COMMAND ${PYTHON_EXECUTABLE} + COMMAND ${PYTHON_EXECUTABLE} ${LLVM_SOURCE_DIR}/utils/lit/lit.py -sv ${CLANG_TEST_EXTRA_ARGS} ${CMAKE_CURRENT_BINARY_DIR}/${testdir} @@ -56,9 +58,10 @@ if(PYTHONINTERP_FOUND) -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#" -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#" -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#" + -e "s#\@TARGET_TRIPLE\@#${TARGET_TRIPLE}#" ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in > ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg - COMMAND ${PYTHON_EXECUTABLE} + COMMAND ${PYTHON_EXECUTABLE} ${LLVM_SOURCE_DIR}/utils/lit/lit.py -sv ${CLANG_TEST_EXTRA_ARGS} ${CMAKE_CURRENT_BINARY_DIR} @@ -72,12 +75,13 @@ if(PYTHONINTERP_FOUND) -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#" -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#" -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#" + -e "s#\@TARGET_TRIPLE\@#${TARGET_TRIPLE}#" ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in > ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg - COMMAND ${PYTHON_EXECUTABLE} + COMMAND ${PYTHON_EXECUTABLE} ${LLVM_SOURCE_DIR}/utils/lit/lit.py -sv ${CLANG_TEST_EXTRA_ARGS} ${CMAKE_CURRENT_SOURCE_DIR}/../utils/C++Tests DEPENDS clang clang-cc index-test c-index-test COMMENT "Running Clang regression tests") -endif() +endif() diff --git a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p14.cpp b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p14.cpp index b9b136c5061b..141a5732c1d3 100644 --- a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p14.cpp +++ b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p14.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * namespace N { struct S {}; diff --git a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p15.cpp b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p15.cpp index 9572aaa14273..cebc3e99d09f 100644 --- a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p15.cpp +++ b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p15.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * class C { public: diff --git a/test/CXX/class/class.union/p1.cpp b/test/CXX/class/class.union/p1.cpp index 15c263467367..9c969c5b7552 100644 --- a/test/CXX/class/class.union/p1.cpp +++ b/test/CXX/class/class.union/p1.cpp @@ -16,6 +16,9 @@ class VirtualBase : virtual Okay { // expected-note 3 {{because type 'class Virt class Ctor { Ctor() { abort(); } // expected-note 3 {{because type 'class Ctor' has a user-declared constructor}} }; +class Ctor2 { + Ctor2(); // expected-note 3 {{because type 'class Ctor2' has a user-declared constructor}} +}; class CopyCtor { CopyCtor(CopyCtor &cc) { abort(); } // expected-note 3 {{because type 'class CopyCtor' has a user-declared copy constructor}} @@ -34,6 +37,7 @@ union U1 { Virtual v; // expected-error {{union member 'v' has a non-trivial copy constructor}} VirtualBase vbase; // expected-error {{union member 'vbase' has a non-trivial copy constructor}} Ctor ctor; // expected-error {{union member 'ctor' has a non-trivial constructor}} + Ctor2 ctor2; // expected-error {{union member 'ctor2' has a non-trivial constructor}} CopyCtor copyctor; // expected-error {{union member 'copyctor' has a non-trivial copy constructor}} CopyAssign copyassign; // expected-error {{union member 'copyassign' has a non-trivial copy assignment operator}} Dtor dtor; // expected-error {{union member 'dtor' has a non-trivial destructor}} @@ -51,6 +55,9 @@ union U2 { Ctor ctor; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial constructor}} } m3; // expected-error {{union member 'm3' has a non-trivial constructor}} struct { + Ctor2 ctor2; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial constructor}} + } m3a; // expected-error {{union member 'm3a' has a non-trivial constructor}} + struct { CopyCtor copyctor; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial copy constructor}} } m4; // expected-error {{union member 'm4' has a non-trivial copy constructor}} struct { @@ -71,6 +78,8 @@ union U3 { } m2; // expected-error {{union member 'm2' has a non-trivial copy constructor}} struct s3 : Ctor { // expected-note {{because type 'struct U3::s3' has a base class with a non-trivial constructor}} } m3; // expected-error {{union member 'm3' has a non-trivial constructor}} + struct s3a : Ctor2 { // expected-note {{because type 'struct U3::s3a' has a base class with a non-trivial constructor}} + } m3a; // expected-error {{union member 'm3a' has a non-trivial constructor}} struct s4 : CopyCtor { // expected-note {{because type 'struct U3::s4' has a base class with a non-trivial copy constructor}} } m4; // expected-error {{union member 'm4' has a non-trivial copy constructor}} struct s5 : CopyAssign { // expected-note {{because type 'struct U3::s5' has a base class with a non-trivial copy assignment operator}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp index 3b0e345f0172..dabe13a0ff66 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p3.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -verify %s -// XFAIL +// XFAIL: * void f0(void) { inline void f1(); // expected-error {{'inline' is not allowed on block scope function declaration}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp index 0142dcbb055c..7dc65c77d4a9 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -verify %s -// XFAIL +// XFAIL: * void f0() { } diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp index c5f0a51b22e5..7a1ba3e389ba 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -verify %s -// XFAIL +// XFAIL: * class A { public: diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp index 62ae7bfded14..d1251490ac1a 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p10.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -verify %s -// XFAIL +// XFAIL: * typedef const int T0; typedef int& T1; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp index f1413f9b41b8..69e843796ff7 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -verify %s -// XFAIL +// XFAIL: * struct S { typedef struct A {} A; // expected-note {{previous definition is here}} diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.ref/p5.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.ref/p5.cpp new file mode 100644 index 000000000000..98e1d302a717 --- /dev/null +++ b/test/CXX/dcl.decl/dcl.meaning/dcl.ref/p5.cpp @@ -0,0 +1,145 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// C++ [dcl.ref]p5: +// There shall be no references to references, no arrays of +// references, and no pointers to references. + +// The crazy formatting in here is to enforce the exact report locations. + +typedef int &intref; +typedef intref &intrefref; + +template <class T> class RefMem { + T + & + member; +}; + +struct RefRef { + int + & + & // expected-error {{declared as a reference to a reference}} + refref0; + + intref + & + refref1; // collapses + + intrefref + & + refref2; // collapses + + RefMem + < + int + & + > + refref3; // collapses +}; + + +template <class T> class PtrMem { + T + * // expected-error {{declared as a pointer to a reference}} + member; +}; + +struct RefPtr { + typedef + int + & + * // expected-error {{declared as a pointer to a reference}} + intrefptr; + + typedef + intref + * // expected-error {{declared as a pointer to a reference}} + intrefptr2; + + int + & + * // expected-error {{declared as a pointer to a reference}} + refptr0; + + intref + * // expected-error {{declared as a pointer to a reference}} + refptr1; + + PtrMem + < + int + & + > + refptr2; // expected-note {{in instantiation}} +}; + +template <class T> class ArrMem { + T + member + [ // expected-error {{declared as array of references}} + 10 + ]; +}; +template <class T, unsigned N> class DepArrMem { + T + member + [ // expected-error {{declared as array of references}} + N + ]; +}; + +struct RefArr { + typedef + int + & + intrefarr + [ // expected-error {{declared as array of references}} + 2 + ]; + + typedef + intref + intrefarr + [ // expected-error {{declared as array of references}} + 2 + ]; + + int + & + refarr0 + [ // expected-error {{declared as array of references}} + 2 + ]; + intref + refarr1 + [ // expected-error {{declared as array of references}} + 2 + ]; + ArrMem + < + int + & + > + refarr2; // expected-note {{in instantiation}} + DepArrMem + < + int + &, + 10 + > + refarr3; // expected-note {{in instantiation}} +}; + + +// The declaration of a reference shall contain an initializer +// (8.5.3) except when the declaration contains an explicit extern +// specifier (7.1.1), is a class member (9.2) declaration within a +// class definition, or is the declaration of a parameter or a +// return type (8.3.5); see 3.1. A reference shall be initialized to +// refer to a valid object or function. [ Note: in particular, a +// null reference cannot exist in a well-defined program, because +// the only way to create such a reference would be to bind it to +// the "object" obtained by dereferencing a null pointer, which +// causes undefined behavior. As described in 9.6, a reference +// cannot be bound directly to a bit-field. + diff --git a/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp b/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp index afe6ab2b968e..79d6c54e29f0 100644 --- a/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp +++ b/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp @@ -1,5 +1,6 @@ // RUN: clang-cc -fsyntax-only -verify %s +// Test class template partial specializations of member templates. template<typename T> struct X0 { template<typename U> struct Inner0 { @@ -16,5 +17,39 @@ struct X0<T>::Inner0<const U*> { static const unsigned value = 2; }; -// FIXME: Test instantiation of these partial specializations (once they are -// implemented). +int array0[X0<int>::Inner0<int>::value == 0? 1 : -1]; +int array1[X0<int>::Inner0<int*>::value == 1? 1 : -1]; +int array2[X0<int>::Inner0<const int*>::value == 2? 1 : -1]; + +// Make sure we can provide out-of-line class template partial specializations +// for member templates (and instantiate them). +template<class T> struct A { + struct C { + template<class T2> struct B; + }; +}; + +// partial specialization of A<T>::C::B<T2> +template<class T> template<class T2> struct A<T>::C::B<T2*> { }; + +A<short>::C::B<int*> absip; + +// Check for conflicts during template instantiation. +template<typename T, typename U> +struct Outer { + template<typename X, typename Y> struct Inner; + template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous}} + template<typename Y> struct Inner<U, Y> {}; // expected-error{{cannot be redeclared}} +}; + +Outer<int, int> outer; // expected-note{{instantiation}} + +// Test specialization of class template partial specialization members. +template<> template<typename Z> +struct X0<float>::Inner0<Z*> { + static const unsigned value = 3; +}; + +int array3[X0<float>::Inner0<int>::value == 0? 1 : -1]; +int array4[X0<float>::Inner0<int*>::value == 3? 1 : -1]; +int array5[X0<float>::Inner0<const int*>::value == 2? 1 : -1]; diff --git a/test/CXX/temp/temp.decls/temp.friend/p5.cpp b/test/CXX/temp/temp.decls/temp.friend/p5.cpp index f1142a4129b2..74895c490623 100644 --- a/test/CXX/temp/temp.decls/temp.friend/p5.cpp +++ b/test/CXX/temp/temp.decls/temp.friend/p5.cpp @@ -9,3 +9,5 @@ class B { template <class T> friend class A<T>::Member; }; +A<int> a; +B b; diff --git a/test/CXX/temp/temp.param/p14.cpp b/test/CXX/temp/temp.param/p14.cpp index 07e6bfe40983..150e0ad636be 100644 --- a/test/CXX/temp/temp.param/p14.cpp +++ b/test/CXX/temp/temp.param/p14.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * // A template-parameter shall not be used in its own default argument. template<typename T = typename T::type> struct X; // expected-error{{default}} diff --git a/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp b/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp index 650501069cc5..a41b46ff5c9b 100644 --- a/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp +++ b/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * // Note: we fail this test because we perform template instantiation // at the end of the translation unit, so argument-dependent lookup diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp index 2bd1400faefb..33fb93bacfaf 100644 --- a/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp +++ b/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp @@ -4,8 +4,7 @@ namespace N { template<class T> class X; } -// FIXME: this diagnostic is terrible (PR3844). -template<> class X<int> { /* ... */ }; // expected-error {{unqualified-id}} +template<> class X<int> { /* ... */ }; // expected-error {{non-template class 'X'}} namespace N { diff --git a/test/CXX/temp/temp.spec/temp.explicit/p10.cpp b/test/CXX/temp/temp.spec/temp.explicit/p10.cpp new file mode 100644 index 000000000000..900b0b309277 --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p10.cpp @@ -0,0 +1,33 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<typename T> +struct X0 { + void f(T&); + + struct Inner; + + static T static_var; +}; + +template<typename T> +void X0<T>::f(T& t) { + t = 1; // expected-error{{incompatible type}} +} + +template<typename T> +struct X0<T>::Inner { + T member; +}; + +template<typename T> +T X0<T>::static_var = 1; // expected-error{{incompatible type}} + +extern template struct X0<void*>; +template struct X0<void*>; // expected-note 2{{instantiation}} + +template struct X0<int>; // expected-note 4{{explicit instantiation definition is here}} + +extern template void X0<int>::f(int&); // expected-error{{follows explicit instantiation definition}} +extern template struct X0<int>::Inner; // expected-error{{follows explicit instantiation definition}} +extern template int X0<int>::static_var; // expected-error{{follows explicit instantiation definition}} +extern template struct X0<int>; // expected-error{{follows explicit instantiation definition}} diff --git a/test/CXX/temp/temp.spec/temp.explicit/p12.cpp b/test/CXX/temp/temp.spec/temp.explicit/p12.cpp new file mode 100644 index 000000000000..fdf4393d4385 --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p12.cpp @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +char* p = 0; +template<class T> T g(T x = &p) { return x; } +template int g<int>(int); // OK even though &p isn’t an int. + diff --git a/test/CXX/temp/temp.spec/temp.explicit/p3.cpp b/test/CXX/temp/temp.spec/temp.explicit/p3.cpp index 2bd781bbed28..9057971a5bb4 100644 --- a/test/CXX/temp/temp.spec/temp.explicit/p3.cpp +++ b/test/CXX/temp/temp.spec/temp.explicit/p3.cpp @@ -9,15 +9,13 @@ template void f0(int); // okay // template shall be in scope at the point of the explicit instantiation of // the member function template. struct X0; // expected-note 2{{forward declaration}} -template<typename> struct X1; // expected-note 2{{declared here}} \ - // expected-note 3{{forward declaration}} +template<typename> struct X1; // expected-note 5{{declared here}} // FIXME: Repeated diagnostics here! template void X0::f0<int>(int); // expected-error 2{{incomplete type}} \ - // expected-error{{invalid token after}} -template void X1<int>::f0<int>(int); // expected-error{{implicit instantiation of undefined template}} \ - // expected-error{{incomplete type}} \\ - // expected-error{{invalid token}} + // expected-error{{does not refer}} +template void X1<int>::f0<int>(int); // expected-error 2{{implicit instantiation of undefined template}} \ + // expected-error{{does not refer}} // A definition of a class template or class member template shall be in scope // at the point of the explicit instantiation of the class template or class @@ -37,10 +35,10 @@ template struct X2<int>::Inner<float>; // expected-error{{explicit instantiation // A definition of a class template shall be in scope at the point of an // explicit instantiation of a member function or a static data member of the // class template. -template void X1<int>::f1(int); // expected-error{{incomplete type}} \ +template void X1<int>::f1(int); // expected-error{{undefined template}} \ // expected-error{{does not refer}} -template int X1<int>::member; // expected-error{{incomplete type}} \ +template int X1<int>::member; // expected-error{{undefined template}} \ // expected-error{{does not refer}} // A definition of a member class of a class template shall be in scope at the diff --git a/test/CXX/temp/temp.spec/temp.explicit/p5.cpp b/test/CXX/temp/temp.spec/temp.explicit/p5.cpp new file mode 100644 index 000000000000..a992648d7c48 --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p5.cpp @@ -0,0 +1,17 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +namespace N { + template<class T> class Y { // expected-note{{explicit instantiation refers here}} + void mf() { } + }; +} + +template class Z<int>; // expected-error{{explicit instantiation of non-template class 'Z'}} + +// FIXME: This example from the standard is wrong; note posted to CWG reflector +// on 10/27/2009 +using N::Y; +template class Y<int>; // expected-error{{must occur in}} + +template class N::Y<char*>; +template void N::Y<double>::mf(); diff --git a/test/CXX/temp/temp.spec/temp.explicit/p6.cpp b/test/CXX/temp/temp.spec/temp.explicit/p6.cpp new file mode 100644 index 000000000000..763d679db7bb --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p6.cpp @@ -0,0 +1,14 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<class T> class Array { /* ... */ }; +template<class T> void sort(Array<T>& v) { } + +// instantiate sort(Array<int>&) - template-argument deduced +template void sort<>(Array<int>&); + +template void sort(Array<long>&); + +template<typename T, typename U> void f0(T, U*) { } + +template void f0<int>(int, float*); +template void f0<>(double, float*); diff --git a/test/CXX/temp/temp.spec/temp.explicit/p7.cpp b/test/CXX/temp/temp.spec/temp.explicit/p7.cpp new file mode 100644 index 000000000000..ffd653dbaa4f --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p7.cpp @@ -0,0 +1,36 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<typename T> +struct X0 { + struct MemberClass { + T member; // expected-error{{with function type}} + }; + + T* f0(T* ptr) { + return ptr + 1; // expected-error{{pointer to function}} + } + + static T* static_member; +}; + +template<typename T> +T* X0<T>::static_member = ((T*)0) + 1; // expected-error{{pointer to function}} + +template class X0<int>; // okay + +template class X0<int(int)>; // expected-note 3{{requested here}} + +// Specialize everything, so that the explicit instantiation does not trigger +// any diagnostics. +template<> +struct X0<int(long)>::MemberClass { }; + +typedef int int_long_func(long); +template<> +int_long_func *X0<int_long_func>::f0(int_long_func *) { return 0; } + +template<> +int_long_func *X0<int(long)>::static_member; + +template class X0<int(long)>; + diff --git a/test/CXX/temp/temp.spec/temp.explicit/p8.cpp b/test/CXX/temp/temp.spec/temp.explicit/p8.cpp new file mode 100644 index 000000000000..9a5bd3245c78 --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p8.cpp @@ -0,0 +1,27 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<typename T> +struct X0 { + struct MemberClass; + + T* f0(T* ptr); + + static T* static_member; +}; + +template class X0<int>; // okay +template class X0<int(int)>; // okay; nothing gets instantiated. + +template<typename T> +struct X0<T>::MemberClass { + T member; +}; + +template<typename T> +T* X0<T>::f0(T* ptr) { + return ptr + 1; +} + +template<typename T> +T* X0<T>::static_member = 0; + diff --git a/test/CXX/temp/temp.spec/temp.explicit/p9-linkage.cpp b/test/CXX/temp/temp.spec/temp.explicit/p9-linkage.cpp new file mode 100644 index 000000000000..59705d8a20e7 --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p9-linkage.cpp @@ -0,0 +1,66 @@ +// RUN: clang-cc -emit-llvm -std=c++0x -o - %s | FileCheck %s + +template<typename T> +struct X0 { + void f(T &t) { + t = 0; + } + + void g(T &t); + + void h(T &t); + + static T static_var; +}; + +template<typename T> +inline void X0<T>::g(T & t) { + t = 0; +} + +template<typename T> +void X0<T>::h(T & t) { + t = 0; +} + +template<typename T> +T X0<T>::static_var = 0; + +extern template struct X0<int*>; + +int *&test(X0<int*> xi, int *ip) { + // CHECK: define available_externally void @_ZN2X0IPiE1fERS0_ + xi.f(ip); + // CHECK: define available_externally void @_ZN2X0IPiE1gERS0_ + xi.g(ip); + // CHECK: declare void @_ZN2X0IPiE1hERS0_ + xi.h(ip); + return X0<int*>::static_var; +} + +template<typename T> +void f0(T& t) { + t = 0; +} + +template<typename T> +inline void f1(T& t) { + t = 0; +} + +extern template void f0<>(int *&); +extern template void f1<>(int *&); + +void test_f0(int *ip, float *fp) { + // CHECK: declare void @_Z2f0IPiEvRT_ + f0(ip); + // CHECK: define linkonce_odr void @_Z2f0IPfEvRT_ + f0(fp); +} + +void test_f1(int *ip, float *fp) { + // CHECK: define available_externally void @_Z2f1IPiEvRT_ + f1(ip); + // CHECK: define linkonce_odr void @_Z2f1IPfEvRT_ + f1(fp); +} diff --git a/test/CXX/temp/temp.spec/temp.explicit/p9.cpp b/test/CXX/temp/temp.spec/temp.explicit/p9.cpp new file mode 100644 index 000000000000..a53113fb969e --- /dev/null +++ b/test/CXX/temp/temp.spec/temp.explicit/p9.cpp @@ -0,0 +1,59 @@ +// RUN: clang-cc -fsyntax-only -std=c++0x -verify %s + +template<typename T> +struct X0 { + void f(T &t) { + t = 1; // expected-error{{incompatible type}} + } + + void g(T &t); + + void h(T &t); + + static T static_var; +}; + +template<typename T> +inline void X0<T>::g(T & t) { + t = 1; // expected-error{{incompatible type}} +} + +template<typename T> +void X0<T>::h(T & t) { + t = 1; +} + +template<typename T> +T X0<T>::static_var = 1; + +extern template struct X0<int*>; + +int *&test(X0<int*> xi, int *ip) { + xi.f(ip); // expected-note{{instantiation}} + xi.g(ip); // expected-note{{instantiation}} + xi.h(ip); + return X0<int*>::static_var; +} + +template<typename T> +void f0(T& t) { + t = 1; // expected-error{{incompatible type}} +} + +template<typename T> +inline void f1(T& t) { + t = 1; // expected-error 2{{incompatible type}} +} + +extern template void f0<>(int *&); +extern template void f1<>(int *&); + +void test_f0(int *ip, float *fp) { + f0(ip); + f0(fp); // expected-note{{instantiation}} +} + +void test_f1(int *ip, float *fp) { + f1(ip); // expected-note{{instantiation}} + f1(fp); // expected-note{{instantiation}} +} diff --git a/test/CodeCompletion/macros.c b/test/CodeCompletion/macros.c new file mode 100644 index 000000000000..d5c1f8f17fce --- /dev/null +++ b/test/CodeCompletion/macros.c @@ -0,0 +1,37 @@ +#define FOO +#define BAR(X, Y) X, Y +#define IDENTITY(X) X +#define WIBBLE(...) + +enum Color { + Red, Green, Blue +}; + +struct Point { + float x, y, z; + enum Color color; +}; + +void test(struct Point *p) { + // RUN: clang-cc -fsyntax-only -code-completion-at=%s:17:14 %s -o - | FileCheck -check-prefix=CC1 %s && + switch (p->IDENTITY(color)) { + // RUN: clang-cc -fsyntax-only -code-completion-at=%s:19:9 %s -o - | FileCheck -check-prefix=CC2 %s && + case + } + // CC1: color + // CC1: x + // CC1: y + // CC1: z + // CC1: BAR(<#X#>, <#Y#>) + // CC1: FOO + // CC1: IDENTITY(<#X#>) + // CC1: WIBBLE + // CC2: Blue + // CC2: Green + // CC2: Red + // CC2: BAR(<#X#>, <#Y#>) + // CC2: FOO + // CC2: IDENTITY(<#X#>) + // CC2: WIBBLE + // RUN: true +} diff --git a/test/CodeGen/2008-07-21-mixed-var-fn-decl.c b/test/CodeGen/2008-07-21-mixed-var-fn-decl.c index c55c86b2fc6c..59a3f3884951 100644 --- a/test/CodeGen/2008-07-21-mixed-var-fn-decl.c +++ b/test/CodeGen/2008-07-21-mixed-var-fn-decl.c @@ -1,5 +1,8 @@ -// RUN: clang-cc -emit-llvm -o - %s | grep -e "@g[0-9] " | count 2 +// RUN: clang-cc -emit-llvm -o - %s | FileCheck %s int g0, f0(); int f1(), g1; +// CHECK: @g0 = common global i32 0, align 4 +// CHECK: @g1 = common global i32 0, align 4 + diff --git a/test/CodeGen/2008-07-29-override-alias-decl.c b/test/CodeGen/2008-07-29-override-alias-decl.c index 4a36e0f13d5c..872950029618 100644 --- a/test/CodeGen/2008-07-29-override-alias-decl.c +++ b/test/CodeGen/2008-07-29-override-alias-decl.c @@ -1,7 +1,13 @@ -// RUN: clang-cc -emit-llvm -o - %s | grep -e "^@f" | count 1 +// RUN: clang-cc -emit-llvm -o - %s | FileCheck %s int x() { return 1; } +// CHECK: %retval = alloca i32 +// CHECK: store i32 1, i32* %retval +// CHECK: %0 = load i32* %retval +// CHECK: ret i32 %0 + + int f() __attribute__((weak, alias("x"))); /* Test that we link to the alias correctly instead of making a new @@ -10,3 +16,10 @@ int f(); int h() { return f(); } + +// CHECK: %retval = alloca i32 +// CHECK: %call = call i32 (...)* @f() +// CHECK: store i32 %call, i32* %retval +// CHECK: %0 = load i32* %retval +// CHECK: ret i32 %0 + diff --git a/test/CodeGen/asm-inout.c b/test/CodeGen/asm-inout.c index 0d8dbdfb9d38..bd287ad0ee69 100644 --- a/test/CodeGen/asm-inout.c +++ b/test/CodeGen/asm-inout.c @@ -1,6 +1,6 @@ // RUN: clang-cc -triple i386-unknown-unknown -emit-llvm %s -o %t && // RUN: grep "load i8\*\*\* %p.addr" %t | count 1 -// XFAIL +// XFAIL: * // PR3800 void f(void **p) diff --git a/test/CodeGen/blocks-2.c b/test/CodeGen/blocks-2.c index bc6c2b916abd..acbaafd95605 100644 --- a/test/CodeGen/blocks-2.c +++ b/test/CodeGen/blocks-2.c @@ -1,7 +1,7 @@ // RUN: clang-cc -g %s -emit-llvm -o %t -fblocks && // RUN: grep "func.start" %t | count 4 // 1 declaration, 1 bar, 1 test_block_dbg and 1 for the block. -// XFAIL +// XFAIL: * static __inline__ __attribute__((always_inline)) int bar(int va, int vb) { return (va == vb); } diff --git a/test/CodeGen/builtin-unwind-init.c b/test/CodeGen/builtin-unwind-init.c index 49a016a304f0..56872f7434ee 100644 --- a/test/CodeGen/builtin-unwind-init.c +++ b/test/CodeGen/builtin-unwind-init.c @@ -1,4 +1,5 @@ -// RUN: clang-cc -emit-llvm < %s -o - | grep -F "llvm.eh.unwind.init" +// RUN: clang-cc -emit-llvm < %s -o - | FileCheck %s -int a() { __builtin_unwind_init(); } +void a() { __builtin_unwind_init(); } +// CHECK: call void @llvm.eh.unwind.init() diff --git a/test/CodeGen/cast-to-union.c b/test/CodeGen/cast-to-union.c index 674299294928..1f7e0457706d 100644 --- a/test/CodeGen/cast-to-union.c +++ b/test/CodeGen/cast-to-union.c @@ -1,5 +1,5 @@ // RUN: clang-cc -emit-llvm %s -o - | FileCheck %s -// CHECK: w = global %0 { i32 2, [4 x i8] zeroinitializer } +// CHECK: w = global %0 { i32 2, [4 x i8] undef } // CHECK: y = global %union.u { double 7.300000e+0{{[0]*}}1 } // CHECK: store i32 351, i32 diff --git a/test/CodeGen/function-attributes.c b/test/CodeGen/function-attributes.c index d2d3b031a83b..b09b28b8d93d 100644 --- a/test/CodeGen/function-attributes.c +++ b/test/CodeGen/function-attributes.c @@ -1,12 +1,12 @@ -// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o %t %s && -// RUN: grep 'define signext i8 @f0(i32 %x) nounwind' %t && -// RUN: grep 'define zeroext i8 @f1(i32 %x) nounwind' %t && -// RUN: grep 'define void @f2(i8 signext %x) nounwind' %t && -// RUN: grep 'define void @f3(i8 zeroext %x) nounwind' %t && -// RUN: grep 'define signext i16 @f4(i32 %x) nounwind' %t && -// RUN: grep 'define zeroext i16 @f5(i32 %x) nounwind' %t && -// RUN: grep 'define void @f6(i16 signext %x) nounwind' %t && -// RUN: grep 'define void @f7(i16 zeroext %x) nounwind' %t && +// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -Os -o - %s | FileCheck %s +// CHECK: define signext i8 @f0(i32 %x) nounwind +// CHECK: define zeroext i8 @f1(i32 %x) nounwind +// CHECK: define void @f2(i8 signext %x) nounwind +// CHECK: define void @f3(i8 zeroext %x) nounwind +// CHECK: define signext i16 @f4(i32 %x) nounwind +// CHECK: define zeroext i16 @f5(i32 %x) nounwind +// CHECK: define void @f6(i16 signext %x) nounwind +// CHECK: define void @f7(i16 zeroext %x) nounwind signed char f0(int x) { return x; } @@ -24,15 +24,22 @@ void f6(signed short x) { } void f7(unsigned short x) { } -// RUN: grep 'define void @f8() nounwind alwaysinline' %t && +// CHECK: define void @f8() +// CHECK: nounwind +// CHECK: alwaysinline +// CHECK: { void __attribute__((always_inline)) f8(void) { } -// RUN: grep 'call void @f9_t() noreturn' %t && +// CHECK: call void @f9_t() +// CHECK: noreturn +// CHECK: { void __attribute__((noreturn)) f9_t(void); void f9(void) { f9_t(); } // FIXME: We should be setting nounwind on calls. -// RUN: grep 'call i32 @f10_t() readnone' %t && +// CHECK: call i32 @f10_t() +// CHECK: readnone +// CHECK: { int __attribute__((const)) f10_t(void); int f10(void) { return f10_t(); } int f11(void) { @@ -43,13 +50,15 @@ int f12(int arg) { return arg ? 0 : f10_t(); } -// RUN: grep 'define void @f13() nounwind readnone' %t && +// CHECK: define void @f13() nounwind readnone void f13(void) __attribute__((pure)) __attribute__((const)); void f13(void){} // Ensure that these get inlined: rdar://6853279 -// RUN: not grep '@ai_' %t && +// CHECK: define void @f14 +// CHECK-NOT: @ai_ +// CHECK: call void @f14_end static __inline__ __attribute__((always_inline)) int ai_1() { return 4; } @@ -58,12 +67,17 @@ struct { int a, b, c, d, e; } ai_2() { while (1) {} } - -int foo() { - ai_2(); - return ai_1(); +void f14(int a) { + extern void f14_end(void); + if (a) + ai_2(); + ai_1(); + f14_end(); } - - -// RUN: true +// <rdar://problem/7102668> [irgen] clang isn't setting the optsize bit on functions +// CHECK: define void @f15 +// CHECK: optsize +// CHECK: { +void f15(void) { +} diff --git a/test/CodeGen/indirect-goto.c b/test/CodeGen/indirect-goto.c index b9a601953877..6804f5739bbf 100644 --- a/test/CodeGen/indirect-goto.c +++ b/test/CodeGen/indirect-goto.c @@ -1,9 +1,7 @@ -// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t && -// RUN: grep "ret i32" %t | count 1 && -// RUN: grep "ret i32 210" %t | count 1 +// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm-bc -o - %s | opt -std-compile-opts -S | grep "ret i32 2520" static int foo(unsigned i) { - const void *addrs[] = { &&L1, &&L2, &&L3, &&L4, &&L5 }; + void *addrs[] = { &&L1, &&L2, &&L3, &&L4, &&L5 }; int res = 1; goto *addrs[i]; @@ -15,6 +13,19 @@ static int foo(unsigned i) { return res; } -int bar() { - return foo(3); +static int foo2(unsigned i) { + static const void *addrs[] = { &&L1, &&L2, &&L3, &&L4, &&L5 }; + int res = 1; + + goto *addrs[i]; +L5: res *= 11; +L4: res *= 7; +L3: res *= 5; +L2: res *= 3; +L1: res *= 2; + return res; +} + +int main() { + return foo(3)+foo2(4); } diff --git a/test/CodeGen/mangle.c b/test/CodeGen/mangle.c index 17d74ba71f0c..6f42f6f6496c 100644 --- a/test/CodeGen/mangle.c +++ b/test/CodeGen/mangle.c @@ -1,22 +1,20 @@ -// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s && -// RUN: grep '@_Z2f0i' %t && -// RUN: grep '@_Z2f0l' %t && +// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s -// Make sure we mangle overloadable, even in C system headers. +// CHECK: @"\01foo" +// Make sure we mangle overloadable, even in C system headers. # 1 "somesystemheader.h" 1 3 4 +// CHECK: @_Z2f0i void __attribute__((__overloadable__)) f0(int a) {} +// CHECK: @_Z2f0l void __attribute__((__overloadable__)) f0(long b) {} - +// CHECK: @"\01bar" // These should get merged. void foo() __asm__("bar"); void foo2() __asm__("bar"); -// RUN: grep '@"\\01foo"' %t && -// RUN: grep '@"\\01bar"' %t - int nux __asm__("foo"); extern float nux2 __asm__("foo"); @@ -52,3 +50,12 @@ void foo6() { int foo7 __asm__("foo7") __attribute__((used)); float foo8 __asm__("foo7") = 42; + +// PR4412 +int func(void); +extern int func (void) __asm__ ("FUNC"); + +// CHECK: @"\01FUNC" +int func(void) { + return 42; +} diff --git a/test/CodeGen/object-size.c b/test/CodeGen/object-size.c new file mode 100644 index 000000000000..61d85419fc69 --- /dev/null +++ b/test/CodeGen/object-size.c @@ -0,0 +1,126 @@ +// RUN: clang-cc -triple x86_64-apple-darwin -S %s -o - | FileCheck %s + +#define strcpy(dest, src) \ + ((__builtin_object_size(dest, 0) != -1ULL) \ + ? __builtin___strcpy_chk (dest, src, __builtin_object_size(dest, 1)) \ + : __inline_strcpy_chk(dest, src)) + +static char *__inline_strcpy_chk (char *dest, const char *src) { + return __builtin___strcpy_chk(dest, src, __builtin_object_size(dest, 1)); +} + +char gbuf[63]; +char *gp; +int gi, gj; + +void test1() { + // CHECK: movabsq $59, %rdx + // CHECK-NEXT: movq %rax, %rdi + // CHECK-NEXT: movq %rcx, %rsi + // CHECK-NEXT: call ___strcpy_chk + strcpy(&gbuf[4], "Hi there"); +} + +void test2() { + // CHECK: movabsq $63, %rdx + // CHECK-NEXT: movq %rax, %rdi + // CHECK-NEXT: movq %rcx, %rsi + // CHECK-NEXT: call ___strcpy_chk + strcpy(gbuf, "Hi there"); +} + +void test3() { + // CHECK: movabsq $0, %rdx + // CHECK-NEXT: movq %rax, %rdi + // CHECK-NEXT: movq %rcx, %rsi + // CHECK-NEXT: call ___strcpy_chk + strcpy(&gbuf[100], "Hi there"); +} + +void test4() { + // CHECK: movabsq $0, %rdx + // CHECK-NEXT: movq %rax, %rdi + // CHECK-NEXT: movq %rcx, %rsi + // CHECK-NEXT: call ___strcpy_chk + strcpy((char*)(void*)&gbuf[-1], "Hi there"); +} + +void test5() { + // CHECK: movb $0, %al + // CHECK-NEXT: testb %al, %al + // CHECK: call ___inline_strcpy_chk + strcpy(gp, "Hi there"); +} + +void test6() { + char buf[57]; + + // CHECK: movabsq $53, %rdx + // CHECK-NEXT: movq %rax, %rdi + // CHECK-NEXT: movq %rcx, %rsi + // CHECK-NEXT: call ___strcpy_chk + strcpy(&buf[4], "Hi there"); +} + +void test7() { + int i; + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy((++i, gbuf), "Hi there"); +} + +void test8() { + char *buf[50]; + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(buf[++gi], "Hi there"); +} + +void test9() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy((char *)((++gi) + gj), "Hi there"); +} + +char **p; +void test10() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(*(++p), "Hi there"); +} + +void test11() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(gp = gbuf, "Hi there"); +} + +void test12() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(++gp, "Hi there"); +} + +void test13() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(gp++, "Hi there"); +} + +void test14() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(--gp, "Hi there"); +} + +void test15() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(gp--, "Hi there"); +} + +void test16() { + // CHECK-NOT: call ___strcpy_chk + // CHECK: call ___inline_strcpy_chk + strcpy(gp += 1, "Hi there"); +} diff --git a/test/CodeGen/union-init2.c b/test/CodeGen/union-init2.c index 184d75f47156..e782425cf2b1 100644 --- a/test/CodeGen/union-init2.c +++ b/test/CodeGen/union-init2.c @@ -1,4 +1,4 @@ -// RUN: clang-cc -emit-llvm %s -o - -triple i686-pc-linux-gnu | grep "bitcast (%0\* @r to %union.x\*), \[4 x i8\] zeroinitializer" +// RUN: clang-cc -emit-llvm %s -o - -triple i686-pc-linux-gnu | grep "bitcast (%0\* @r to %union.x\*), \[4 x i8\] undef" // Make sure we generate something sane instead of a ptrtoint union x {long long b;union x* a;} r = {.a = &r}; diff --git a/test/CodeGen/volatile.c b/test/CodeGen/volatile.c index 87cb5ff4eb4f..e17669008a39 100644 --- a/test/CodeGen/volatile.c +++ b/test/CodeGen/volatile.c @@ -1,8 +1,8 @@ // RUN: clang-cc -emit-llvm < %s -o %t && -// RUN: grep volatile %t | count 25 && +// RUN: grep volatile %t | count 29 && // RUN: grep memcpy %t | count 7 -// The number 25 comes from the current codegen for volatile loads; +// The number 29 comes from the current codegen for volatile loads; // if this number changes, it's not necessarily something wrong, but // something has changed to affect volatile load/store codegen @@ -38,6 +38,9 @@ volatile extv4 vVE; volatile struct {int x;} aggFct(void); +typedef volatile int volatile_int; +volatile_int vtS; + int main() { int i; @@ -62,6 +65,7 @@ int main() { i=VE.yx[1]; i=vVE.zy[1]; i = aggFct().x; + i=vtS; // store @@ -81,12 +85,14 @@ int main() { vBF.x=i; V[3]=i; vV[3]=i; + vtS=i; // other ops: ++S; ++vS; i+=S; i+=vS; + ++vtS; (void)vF2; vF2 = vF2; vF2 = vF2 = vF2; diff --git a/test/CodeGenCXX/array-construction.cpp b/test/CodeGenCXX/array-construction.cpp new file mode 100644 index 000000000000..b444221533d3 --- /dev/null +++ b/test/CodeGenCXX/array-construction.cpp @@ -0,0 +1,40 @@ +// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s && +// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s && +// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s && +// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s && +// RUN: true + +extern "C" int printf(...); + +static int count; +static float fcount; + +class xpto { +public: + xpto() : i(count++), f(fcount++) { + printf("xpto::xpto()\n"); + } + int i; + float f; + +/** + NYI + ~xpto() { + printf("xpto::~xpto()\n"); + } +*/ +}; + +int main() { + xpto array[2][3][4]; + for (int h = 0; h < 2; h++) + for (int i = 0; i < 3; i++) + for (int j = 0; j < 4; j++) + printf("array[%d][%d][%d] = {%d, %f}\n", + h, i, j, array[h][i][j].i, array[h][i][j].f); +} + +// CHECK-LP64: call __ZN4xptoC1Ev + +// CHECK-LP32: call L__ZN4xptoC1Ev + diff --git a/test/CodeGenCXX/ptr-to-datamember.cpp b/test/CodeGenCXX/ptr-to-datamember.cpp index eee03c060f91..a7b4cc2f7afb 100644 --- a/test/CodeGenCXX/ptr-to-datamember.cpp +++ b/test/CodeGenCXX/ptr-to-datamember.cpp @@ -51,6 +51,21 @@ void test_aggr_pdata(A& a1) { pr(a1.*af); } +void test_aggr_pdata_1(A* pa) { + F A::* af = &A::Af; + pr(pa->*af); + + (pa->*af).iF = 100; + (pa->*af).fF = 200.00; + printf(" %d %f\n", (pa->*af).iF, (pa->*af).fF); + pr(pa->*af); + + (pa->*af).iF++; + (pa->*af).fF--; + --(pa->*af).fF; + pr(pa->*af); +} + int main() { A a1; @@ -67,4 +82,5 @@ int main() printf("%d\n", &A::B1::V::iV); printf("%d, %f, %f \n", a1.*pa, a1.*pf, a1.*pd); test_aggr_pdata(a1); + test_aggr_pdata_1(&a1); } diff --git a/test/CodeGenCXX/ptr-to-member-function.cpp b/test/CodeGenCXX/ptr-to-member-function.cpp new file mode 100644 index 000000000000..1e396e976575 --- /dev/null +++ b/test/CodeGenCXX/ptr-to-member-function.cpp @@ -0,0 +1,53 @@ +// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s && +// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s && +// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s && +// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s && +// RUN: true +// 13.3.3.2 Ranking implicit conversion sequences + +extern "C" int printf(...); + +struct A { +int Ai; +}; + +struct B : public A { + void bf() { printf("B::bf called\n"); } +}; + +struct C : public B { }; + +// conversion of B::* to C::* is better than conversion of A::* to C::* +typedef void (A::*pmfa)(); +typedef void (B::*pmfb)(); +typedef void (C::*pmfc)(); + +struct X { + operator pmfa(); + operator pmfb() { + return &B::bf; + } +}; + + +void g(pmfc pm) { + C c; + (c.*pm)(); +} + +void test2(X x) +{ + g(x); +} + +int main() +{ + X x; + test2(x); +} + +// CHECK-LP64: call __ZN1XcvM1BFvvEEv +// CHECK-LP64: call __Z1gM1CFvvE + +// CHECK-LP32: call L__ZN1XcvM1BFvvEEv +// CHECK-LP32: call __Z1gM1CFvvE diff --git a/test/CodeGenCXX/temporaries.cpp b/test/CodeGenCXX/temporaries.cpp index d622193f5986..e9ed0f7690bc 100644 --- a/test/CodeGenCXX/temporaries.cpp +++ b/test/CodeGenCXX/temporaries.cpp @@ -53,9 +53,9 @@ struct D { }; void f4() { - // CHECK call void @_ZN1DC1Ev - // CHECK call void @_ZN1DD1Ev - // CHECK call void @_ZN1DD1Ev + // CHECK: call void @_ZN1DC1Ev + // CHECK: call void @_ZN1DD1Ev + // CHECK: call void @_ZN1DD1Ev D()(); } diff --git a/test/CodeGenCXX/virt.cpp b/test/CodeGenCXX/virt.cpp index 21fecac11e7b..7911940c6dab 100644 --- a/test/CodeGenCXX/virt.cpp +++ b/test/CodeGenCXX/virt.cpp @@ -91,6 +91,50 @@ int main() { // CHECK-LP64: movl $1, 12(%rax) // CHECK-LP64: movl $2, 8(%rax) +// FIXME: This is the wrong thunk, but until these issues are fixed, better +// than nothing. +// CHECK-LP64: __ZTcvn16_n72_v16_n32_N8test16_D4foo1Ev: +// CHECK-LP64-NEXT:Leh_func_begin43: +// CHECK-LP64-NEXT: subq $24, %rsp +// CHECK-LP64-NEXT:Llabel43: +// CHECK-LP64-NEXT: movq %rdi, %rax +// CHECK-LP64-NEXT: movq %rax, 8(%rsp) +// CHECK-LP64-NEXT: movq 8(%rsp), %rax +// CHECK-LP64-NEXT: movq %rax, %rcx +// CHECK-LP64-NEXT: movabsq $-16, %rdx +// CHECK-LP64-NEXT: addq %rdx, %rcx +// CHECK-LP64-NEXT: movq -16(%rax), %rax +// CHECK-LP64-NEXT: movq -72(%rax), %rax +// CHECK-LP64-NEXT: addq %rax, %rcx +// CHECK-LP64-NEXT: movq %rcx, %rax +// CHECK-LP64-NEXT: movq %rax, %rdi +// CHECK-LP64-NEXT: call __ZTch0_v16_n32_N8test16_D4foo1Ev +// CHECK-LP64-NEXT: movq %rax, 16(%rsp) +// CHECK-LP64-NEXT: movq 16(%rsp), %rax +// CHECK-LP64-NEXT: addq $24, %rsp +// CHECK-LP64-NEXT: ret + +// CHECK-LP64: __ZTch0_v16_n32_N8test16_D4foo1Ev: +// CHECK-LP64-NEXT:Leh_func_begin44: +// CHECK-LP64-NEXT: subq $24, %rsp +// CHECK-LP64-NEXT:Llabel44: +// CHECK-LP64-NEXT: movq %rdi, %rax +// CHECK-LP64-NEXT: movq %rax, 8(%rsp) +// CHECK-LP64-NEXT: movq 8(%rsp), %rax +// CHECK-LP64-NEXT: movq %rax, %rdi +// CHECK-LP64-NEXT: call __ZN8test16_D4foo1Ev +// CHECK-LP64-NEXT: movq %rax, %rcx +// CHECK-LP64-NEXT: movabsq $16, %rdx +// CHECK-LP64-NEXT: addq %rdx, %rcx +// CHECK-LP64-NEXT: movq 16(%rax), %rax +// CHECK-LP64-NEXT: movq -32(%rax), %rax +// CHECK-LP64-NEXT: addq %rax, %rcx +// CHECK-LP64-NEXT: movq %rcx, %rax +// CHECK-LP64-NEXT: movq %rax, 16(%rsp) +// CHECK-LP64-NEXT: movq 16(%rsp), %rax +// CHECK-LP64-NEXT: addq $24, %rsp +// CHECK-LP64-NEXT: ret + struct test12_A { virtual void foo0() { } virtual void foo(); @@ -306,10 +350,10 @@ struct test5_D : virtual test5_B1, virtual test5_B21, virtual test5_B31 { // CHECK-LP32-NEXT: .long __ZN9test5_B227funcB22Ev // CHECK-LP32-NEXT: .long __ZN9test5_B217funcB21Ev // CHECK-LP32-NEXT: .space 4 -// CHECK-LP32: .long 8 -// CHECK-LP32 .space 4 -// CHECK-LP32 .space 4 FIXME -// CHECK-LP32: .long 4 +// CHECK-LP32-NEXT: .long 8 +// CHECK-LP32-NEXT: .space 4 +// CHECK-LP32-NEXT: .space 4 +// CHECK-LP32-NEXT: .long 4 // CHECK-LP32-NEXT: .space 4 // CHECK-LP32-NEXT: .space 4 // CHECK-LP32-NEXT: .long 4294967288 @@ -358,10 +402,10 @@ struct test5_D : virtual test5_B1, virtual test5_B21, virtual test5_B31 { // CHECK-LP64-NEXT: .quad __ZN9test5_B227funcB22Ev // CHECK-LP64-NEXT: .quad __ZN9test5_B217funcB21Ev // CHECK-LP64-NEXT: .space 8 -// CHECK-LP64: .quad 16 -// CHECK-LP64 .space 8 -// CHECK-LP64 .space 8 -// CHECK-LP64: .quad 8 +// CHECK-LP64-NEXT: .quad 16 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .quad 8 // CHECK-LP64-NEXT: .space 8 // CHECK-LP64-NEXT: .space 8 // CHECK-LP64-NEXT: .quad 18446744073709551600 @@ -1049,6 +1093,151 @@ struct test16_D : test16_NV1, virtual test16_B2 { // CHECK-LP32-NEXT: .long __ZN10test16_NV28foo_NV2bEv +class test17_B1 { + virtual void foo() = 0; + virtual void bar() { } +}; + +class test17_B2 : public test17_B1 { + void foo() { } + virtual void bar() = 0; +}; + +class test17_D : public test17_B2 { + void bar() { } +}; + + +// CHECK-LP64:__ZTV8test17_D: +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .quad __ZTI8test17_D +// CHECK-LP64-NEXT: .quad __ZN9test17_B23fooEv +// CHECK-LP64-NEXT: .quad __ZN8test17_D3barEv + +// CHECK-LP64:__ZTV9test17_B2: +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .quad __ZTI9test17_B2 +// CHECK-LP64-NEXT: .quad __ZN9test17_B23fooEv +// CHECK-LP64-NEXT: .quad ___cxa_pure_virtual + +// CHECK-LP64:__ZTV9test17_B1: +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .quad __ZTI9test17_B1 +// CHECK-LP64-NEXT: .quad ___cxa_pure_virtual +// CHECK-LP64-NEXT: .quad __ZN9test17_B13barEv + + +struct test18_NV1 { + virtual void fooNV1() { } +virtual void foo_NV1() { } + int i; +}; + +struct test18_NV2 { + virtual test18_NV2& foo1() { return *this; } +virtual void foo_NV2() { } +virtual void foo_NV2b() { } + int i; +}; + +struct test18_B : public test18_NV1, test18_NV2 { + virtual test18_B& foo1() { return *this; } + virtual test18_B *foo2() { return 0; } + virtual test18_B *foo3() { return 0; } +virtual void foo_B() { } + int i; +}; + +struct test18_B2 : test18_NV1, virtual test18_B { + virtual test18_B2& foo1() { return *this; } + virtual test18_B2 *foo2() { return 0; } +virtual void foo_B2() { } + int i; +}; + +struct test18_D : test18_NV1, virtual test18_B2 { + virtual test18_D& foo1() { return *this; } +}; + + +struct test19_VB1 { }; +struct test19_B1 : public virtual test19_VB1 { + virtual void fB1() { } + virtual void foB1B2() { } + virtual void foB1B3() { } + virtual void foB1B4() { } +}; + +struct test19_VB2 { }; +struct test19_B2: public test19_B1, public virtual test19_VB2 { + virtual void foB1B2() { } + virtual void foB1B3() { } + virtual void foB1B4() { } + + virtual void fB2() { } + virtual void foB2B3() { } + virtual void foB2B4() { } +}; + +struct test19_VB3 { }; +struct test19_B3: virtual public test19_B2, public virtual test19_VB3 { + virtual void foB1B3() { } + virtual void foB1B4() { } + + virtual void foB2B3() { } + virtual void foB2B4() { } + + virtual void fB3() { } + virtual void foB3B4() { } +}; + +struct test19_VB4 { }; +struct test19_B4: public test19_B3, public virtual test19_VB4 { + virtual void foB1B4() { } + + virtual void foB2B4() { } + + virtual void foB3B4() { } + + virtual void fB4() { } +}; + +struct test19_D : virtual test19_B4 { +}; + + +// CHECK-LP64: __ZTV8test19_D: +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .space 8 +// CHECK-LP64-NEXT: .quad __ZTI8test19_D +// CHECK-LP64-NEXT .quad __ZN9test19_B13fB1Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B26foB1B2Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B36foB1B3Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B46foB1B4Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B23fB2Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B36foB2B3Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B46foB2B4Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B33fB3Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B46foB3B4Ev +// CHECK-LP64-NEXT .quad __ZN9test19_B43fB4Ev + + + // CHECK-LP64: __ZTV1B: // CHECK-LP64-NEXT: .space 8 // CHECK-LP64-NEXT: .quad __ZTI1B @@ -1127,6 +1316,9 @@ struct test16_D : test16_NV1, virtual test16_B2 { // CHECK-LP64-NEXT: .quad __ZN2D14bar4Ev // CHECK-LP64-NEXT: .quad __ZN2D14bar5Ev +test19_D d19; +test18_D d18; +test17_D d17; test16_D d16; test15_D d15; test13_D d13; diff --git a/test/CodeGenObjC/PR4894-recursive-debug-crash.m b/test/CodeGenObjC/PR4894-recursive-debug-crash.m index c5f901c2680e..d7379111c11a 100644 --- a/test/CodeGenObjC/PR4894-recursive-debug-crash.m +++ b/test/CodeGenObjC/PR4894-recursive-debug-crash.m @@ -3,7 +3,7 @@ // // This test is actually just making sure we can generate the debug info for the // return type from im0 without crashing. -// XFAIL +// XFAIL: * @interface I0 { I0 *_iv0; diff --git a/test/CodeGenObjC/encode-test-2.m b/test/CodeGenObjC/encode-test-2.m index 6901168b1d09..07a53367557a 100644 --- a/test/CodeGenObjC/encode-test-2.m +++ b/test/CodeGenObjC/encode-test-2.m @@ -3,7 +3,7 @@ // RUN: grep -e "@\\\22<X><Y>\\\22" %t && // RUN: grep -e "@\\\22<X><Y><Z>\\\22" %t && // RUN: grep -e "@\\\22Foo<X><Y><Z>\\\22" %t && -// RUN: grep -e "{Intf=@@@@}" %t +// RUN: grep -e "{Intf=@@@@#}" %t @protocol X, Y, Z; @class Foo; @@ -17,6 +17,7 @@ id <X> IVAR_x; id <X, Y> IVAR_xy; id <X, Y, Z> IVAR_xyz; Foo <X, Y, Z> *IVAR_Fooxyz; +Class <X> IVAR_Classx; } @end diff --git a/test/CodeGenObjC/synthesize_ivar.m b/test/CodeGenObjC/synthesize_ivar.m index 7646f707bf76..e1746f1da136 100644 --- a/test/CodeGenObjC/synthesize_ivar.m +++ b/test/CodeGenObjC/synthesize_ivar.m @@ -1,8 +1,6 @@ // RUN: clang-cc -triple x86_64-apple-darwin10 -emit-llvm -o %t %s @interface I -{ -} @property int IP; @end @@ -25,3 +23,16 @@ @implementation OrganizerViolatorView @synthesize bindingInfo; @end + +// <rdar://problem/7336352> [irgen] crash in synthesized property construction + +@interface I0 @end +@protocol P0 @end +@interface I1 { + I0<P0> *iv0; +} +@property (assign, readwrite) id p0; +@end +@implementation I1 +@synthesize p0 = iv0; +@end diff --git a/test/Coverage/objc-language-features.inc b/test/Coverage/objc-language-features.inc index dd57dfbedd03..dbbf205fcd6b 100644 --- a/test/Coverage/objc-language-features.inc +++ b/test/Coverage/objc-language-features.inc @@ -14,6 +14,7 @@ @interface A : Root <P1> { int iv0; B *iv1; + B<P1> *iv2; } @property(readonly) int p0; @@ -21,11 +22,16 @@ @property(copy) id p2; @property(retain) id p3; @property(assign, getter=getme, setter=setme:) id p4; +@property(assign, readwrite) id p5; @end @implementation A @dynamic p0; @synthesize p1 = iv0; + +// Property type can differ from ivar type. +@synthesize p5 = iv2; + +(void) fm0 { [super fm0]; } diff --git a/test/Coverage/targets.c b/test/Coverage/targets.c index 5a87b4dcc554..c4f030fff3d0 100644 --- a/test/Coverage/targets.c +++ b/test/Coverage/targets.c @@ -16,4 +16,8 @@ // RUN: clang-cc -g -triple x86_64-apple-darwin9 -emit-llvm -o %t %s && // RUN: clang-cc -g -triple x86_64-pc-linux-gnu -emit-llvm -o %t %s && // RUN: clang-cc -g -triple x86_64-unknown-unknown -emit-llvm -o %t %s && + +// <rdar://problem/7181838> clang 1.0 fails to compile Python 2.6 +// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -### -S %s -mmacosx-version-min=10.4 && + // RUN: true diff --git a/test/Driver/analyze.c b/test/Driver/analyze.c index 5ca890f9ab48..03810688d1f7 100644 --- a/test/Driver/analyze.c +++ b/test/Driver/analyze.c @@ -2,8 +2,8 @@ // (at least for a few key ones). // RUN: env MACOSX_DEPLOYMENT_TARGET=10.5 clang -ccc-host-triple i386-apple-darwin9 -### --analyze -o /dev/null %s -msse 2> %t.log && -// RUN: grep '"-analyze"' %t.log && -// RUN: grep '"--fmath-errno=0"' %t.log && -// RUN: grep '"-target-feature" "+sse"' %t.log && -// RUN: grep '"-mmacosx-version-min=10.5"' %t.log +// RUN: FileCheck --input-file=%t.log %s +// CHECK: "-analyze" +// CHECK: "-target-feature" "+sse" +// CHECK: "--fmath-errno=0" diff --git a/test/Driver/ccc-add-args.c b/test/Driver/ccc-add-args.c index b504b0b42933..21e4471c1276 100644 --- a/test/Driver/ccc-add-args.c +++ b/test/Driver/ccc-add-args.c @@ -1,3 +1,3 @@ -// RUN: env CCC_ADD_ARGS="-ccc-echo,-ccc-print-options,,-v" clang -### 2> %t && -// RUN: grep -F 'Option 0 - Name: "-v", Values: {}' %t && -// RUN: grep -F 'Option 1 - Name: "-###", Values: {}' %t +// RUN: env CCC_ADD_ARGS="-ccc-echo,-ccc-print-options,,-v" clang -### 2>&1 | FileCheck %s +// CHECK: Option 0 - Name: "-v", Values: {} +// CHECK: Option 1 - Name: "-###", Values: {} diff --git a/test/Driver/hello.c b/test/Driver/hello.c index 7dbe9c74f9c5..ead0d07b57ce 100644 --- a/test/Driver/hello.c +++ b/test/Driver/hello.c @@ -6,6 +6,10 @@ // RUN: %t > %t.out && // RUN: grep "I'm a little driver, short and stout." %t.out +// FIXME: We don't have a usable assembler on Windows, so we can't build real +// apps yet. +// XFAIL: win32 + #include <stdio.h> int main() { diff --git a/test/Driver/phases.c b/test/Driver/phases.c index 0967d33816fe..61f68c452835 100644 --- a/test/Driver/phases.c +++ b/test/Driver/phases.c @@ -1,79 +1,79 @@ // Basic compilation for various types of files. -// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -x c %s -x objective-c %s -x c++ %s -x objective-c++ -x assembler %s -x assembler-with-cpp %s -x none %s 2> %t && -// RUN: grep '0: input, ".*phases.c", c' %t && -// RUN: grep -F '1: preprocessor, {0}, cpp-output' %t && -// RUN: grep -F '2: compiler, {1}, assembler' %t && -// RUN: grep -F '3: assembler, {2}, object' %t && -// RUN: grep '4: input, ".*phases.c", objective-c' %t && -// RUN: grep -F '5: preprocessor, {4}, objective-c-cpp-output' %t && -// RUN: grep -F '6: compiler, {5}, assembler' %t && -// RUN: grep -F '7: assembler, {6}, object' %t && -// RUN: grep '8: input, ".*phases.c", c++' %t && -// RUN: grep -F '9: preprocessor, {8}, c++-cpp-output' %t && -// RUN: grep -F '10: compiler, {9}, assembler' %t && -// RUN: grep -F '11: assembler, {10}, object' %t && -// RUN: grep '12: input, ".*phases.c", assembler' %t && -// RUN: grep -F '13: assembler, {12}, object' %t && -// RUN: grep '14: input, ".*phases.c", assembler-with-cpp' %t && -// RUN: grep -F '15: preprocessor, {14}, assembler' %t && -// RUN: grep -F '16: assembler, {15}, object' %t && -// RUN: grep '17: input, ".*phases.c", c' %t && -// RUN: grep -F '18: preprocessor, {17}, cpp-output' %t && -// RUN: grep -F '19: compiler, {18}, assembler' %t && -// RUN: grep -F '20: assembler, {19}, object' %t && -// RUN: grep -F '21: linker, {3, 7, 11, 13, 16, 20}, image' %t && +// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -x c %s -x objective-c %s -x c++ %s -x objective-c++ -x assembler %s -x assembler-with-cpp %s -x none %s 2>&1 | FileCheck -check-prefix=BASIC %s && +// BASIC: 0: input, "{{.*}}phases.c", c +// BASIC: 1: preprocessor, {0}, cpp-output +// BASIC: 2: compiler, {1}, assembler +// BASIC: 3: assembler, {2}, object +// BASIC: 4: input, "{{.*}}phases.c", objective-c +// BASIC: 5: preprocessor, {4}, objective-c-cpp-output +// BASIC: 6: compiler, {5}, assembler +// BASIC: 7: assembler, {6}, object +// BASIC: 8: input, "{{.*}}phases.c", c++ +// BASIC: 9: preprocessor, {8}, c++-cpp-output +// BASIC: 10: compiler, {9}, assembler +// BASIC: 11: assembler, {10}, object +// BASIC: 12: input, "{{.*}}phases.c", assembler +// BASIC: 13: assembler, {12}, object +// BASIC: 14: input, "{{.*}}phases.c", assembler-with-cpp +// BASIC: 15: preprocessor, {14}, assembler +// BASIC: 16: assembler, {15}, object +// BASIC: 17: input, "{{.*}}phases.c", c +// BASIC: 18: preprocessor, {17}, cpp-output +// BASIC: 19: compiler, {18}, assembler +// BASIC: 20: assembler, {19}, object +// BASIC: 21: linker, {3, 7, 11, 13, 16, 20}, image // Universal linked image. -// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -x c %s -arch ppc -arch i386 2> %t && -// RUN: grep '0: input, ".*phases.c", c' %t && -// RUN: grep -F '1: preprocessor, {0}, cpp-output' %t && -// RUN: grep -F '2: compiler, {1}, assembler' %t && -// RUN: grep -F '3: assembler, {2}, object' %t && -// RUN: grep -F '4: linker, {3}, image' %t && -// RUN: grep -F '5: bind-arch, "ppc", {4}, image' %t && -// RUN: grep -F '6: bind-arch, "i386", {4}, image' %t && -// RUN: grep -F '7: lipo, {5, 6}, image' %t && +// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -x c %s -arch ppc -arch i386 2>&1 | FileCheck -check-prefix=ULI %s && +// ULI: 0: input, "{{.*}}phases.c", c +// ULI: 1: preprocessor, {0}, cpp-output +// ULI: 2: compiler, {1}, assembler +// ULI: 3: assembler, {2}, object +// ULI: 4: linker, {3}, image +// ULI: 5: bind-arch, "ppc", {4}, image +// ULI: 6: bind-arch, "i386", {4}, image +// ULI: 7: lipo, {5, 6}, image // Universal object file. -// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x c %s -arch ppc -arch i386 2> %t && -// RUN: grep '0: input, ".*phases.c", c' %t && -// RUN: grep -F '1: preprocessor, {0}, cpp-output' %t && -// RUN: grep -F '2: compiler, {1}, assembler' %t && -// RUN: grep -F '3: assembler, {2}, object' %t && -// RUN: grep -F '4: bind-arch, "ppc", {3}, object' %t && -// RUN: grep -F '5: bind-arch, "i386", {3}, object' %t && -// RUN: grep -F '6: lipo, {4, 5}, object' %t && +// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x c %s -arch ppc -arch i386 2>&1 | FileCheck -check-prefix=UOF %s && +// UOF: 0: input, "{{.*}}phases.c", c +// UOF: 1: preprocessor, {0}, cpp-output +// UOF: 2: compiler, {1}, assembler +// UOF: 3: assembler, {2}, object +// UOF: 4: bind-arch, "ppc", {3}, object +// UOF: 5: bind-arch, "i386", {3}, object +// UOF: 6: lipo, {4, 5}, object // Arch defaulting -// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x assembler %s 2> %t && -// RUN: grep -F '2: bind-arch, "i386", {1}, object' %t && -// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x assembler %s -m32 -m64 2> %t && -// RUN: grep -F '2: bind-arch, "x86_64", {1}, object' %t && -// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -ccc-print-phases -c -x assembler %s 2> %t && -// RUN: grep -F '2: bind-arch, "x86_64", {1}, object' %t && -// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -ccc-print-phases -c -x assembler %s -m64 -m32 2> %t && -// RUN: grep -F '2: bind-arch, "i386", {1}, object' %t && +// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x assembler %s 2>&1 | FileCheck -check-prefix=ARCH1 %s && +// ARCH1: 2: bind-arch, "i386", {1}, object +// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c -x assembler %s -m32 -m64 2>&1 | FileCheck -check-prefix=ARCH2 %s && +// ARCH2: 2: bind-arch, "x86_64", {1}, object +// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -ccc-print-phases -c -x assembler %s 2>&1 | FileCheck -check-prefix=ARCH3 %s && +// ARCH3: 2: bind-arch, "x86_64", {1}, object +// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -ccc-print-phases -c -x assembler %s -m64 -m32 2>&1 | FileCheck -check-prefix=ARCH4 %s && +// ARCH4: 2: bind-arch, "i386", {1}, object // Analyzer -// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases --analyze %s 2> %t && -// RUN: grep '0: input, ".*phases.c", c' %t && -// RUN: grep -F '1: preprocessor, {0}, cpp-output' %t && -// RUN: grep -F '2: analyzer, {1}, plist' %t && +// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases --analyze %s 2>&1 | FileCheck -check-prefix=ANALYZE %s && +// ANALYZE: 0: input, "{{.*}}phases.c", c +// ANALYZE: 1: preprocessor, {0}, cpp-output +// ANALYZE: 2: analyzer, {1}, plist // Precompiler -// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -x c-header %s 2> %t && -// RUN: grep '0: input, ".*phases.c", c-header' %t && -// RUN: grep -F '1: preprocessor, {0}, c-header-cpp-output' %t && -// RUN: grep -F '2: precompiler, {1}, precompiled-header' %t && +// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -x c-header %s 2>&1 | FileCheck -check-prefix=PCH %s && +// PCH: 0: input, "{{.*}}phases.c", c-header +// PCH: 1: preprocessor, {0}, c-header-cpp-output +// PCH: 2: precompiler, {1}, precompiled-header // Darwin overrides the handling for .s // RUN: touch %t.s && -// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -c %t.s 2> %t && -// RUN: grep '0: input, ".*\.s", assembler' %t && -// RUN: grep -F '1: assembler, {0}, object' %t && -// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c %t.s 2> %t && -// RUN: grep '0: input, ".*\.s", assembler-with-cpp' %t && -// RUN: grep -F '1: preprocessor, {0}, assembler' %t && -// RUN: grep -F '2: assembler, {1}, object' %t && +// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -c %t.s 2>&1 | FileCheck -check-prefix=DARWIN1 %s && +// DARWIN1: 0: input, "{{.*}}.s", assembler +// DARWIN1: 1: assembler, {0}, object +// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-phases -c %t.s 2>&1 | FileCheck -check-prefix=DARWIN2 %s && +// DARWIN2: 0: input, "{{.*}}.s", assembler-with-cpp +// DARWIN2: 1: preprocessor, {0}, assembler +// DARWIN2: 2: assembler, {1}, object // RUN: true diff --git a/test/Driver/qa_override.c b/test/Driver/qa_override.c index 46e150c74fdc..6f72078f12af 100644 --- a/test/Driver/qa_override.c +++ b/test/Driver/qa_override.c @@ -1,7 +1,5 @@ -// RUN: env QA_OVERRIDE_GCC3_OPTIONS="#+-Os +-Oz +-O +-O3 +-Oignore +a +b +c xb Xa Omagic ^-ccc-print-options " clang x -O2 b -O3 2> %t && -// RUN: grep '### ' %t | count 0 && -// RUN: grep -F 'Option 0 - Name: "<input>", Values: {"x"}' %t && -// RUN: grep -F 'Option 1 - Name: "-O", Values: {"ignore"}' %t && -// RUN: grep -F 'Option 2 - Name: "-O", Values: {"magic"}' %t && -// RUN: true - +// RUN: env QA_OVERRIDE_GCC3_OPTIONS="#+-Os +-Oz +-O +-O3 +-Oignore +a +b +c xb Xa Omagic ^-ccc-print-options " clang x -O2 b -O3 2>&1 | FileCheck %s +// CHECK-NOT: ### +// CHECK: Option 0 - Name: "<input>", Values: {"x"} +// CHECK-NEXT: Option 1 - Name: "-O", Values: {"ignore"} +// CHECK-NEXT: Option 2 - Name: "-O", Values: {"magic"} diff --git a/test/Driver/std.c b/test/Driver/std.c index ef6d8f197754..04113d5af134 100644 --- a/test/Driver/std.c +++ b/test/Driver/std.c @@ -1,8 +1,8 @@ -// RUN: clang -std=c99 -trigraphs -std=gnu99 %s -E -o %t && -// RUN: grep '??(??)' %t && -// RUN: clang -ansi %s -E -o %t && -// RUN: grep -F '[]' %t && -// RUN: clang -std=gnu99 -trigraphs %s -E -o %t && -// RUN: grep -F '[]' %t +// RUN: clang -std=c99 -trigraphs -std=gnu99 %s -E -o - | FileCheck -check-prefix=OVERRIDE %s && +// OVERRIDE: ??(??) +// RUN: clang -ansi %s -E -o - | FileCheck -check-prefix=ANSI %s && +// ANSI: [] +// RUN: clang -std=gnu99 -trigraphs %s -E -o - | FileCheck -check-prefix=EXPLICIT %s +// EXPLICIT: [] ??(??) diff --git a/test/FixIt/fixit-pmem.cpp b/test/FixIt/fixit-pmem.cpp new file mode 100644 index 000000000000..bb36f7fa9343 --- /dev/null +++ b/test/FixIt/fixit-pmem.cpp @@ -0,0 +1,23 @@ +// RUN: clang-cc -fsyntax-only -pedantic -fixit %s -o - | clang-cc -fsyntax-only -pedantic -Werror -x c++ - + +/* This is a test of the various code modification hints that are + provided as part of warning or extension diagnostics. All of the + warnings will be fixed by -fixit, and the resulting file should + compile cleanly with -Werror -pedantic. */ + +struct S { + int i; +}; + +int foo(int S::* ps, S s, S* p) +{ + p.*ps = 1; + return s->*ps; +} + +void foo1(int (S::*ps)(), S s, S* p) +{ + (p.*ps)(); + (s->*ps)(); +} + diff --git a/test/Frontend/darwin-version.c b/test/Frontend/darwin-version.c index 513ea197e847..3217b9ad5e3b 100644 --- a/test/Frontend/darwin-version.c +++ b/test/Frontend/darwin-version.c @@ -1,23 +1,23 @@ -// RUN: clang-cc -triple armv6-apple-darwin9 -dM -E -o %t - < /dev/null && -// RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | grep '10000' | count 1 && +// RUN: clang -ccc-host-triple armv6-apple-darwin9 -dM -E -o %t %s && +// RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | grep '30000' | count 1 && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | count 0 && -// RUN: clang-cc -triple armv6-apple-darwin9 -miphoneos-version-min=2.0 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple armv6-apple-darwin9 -miphoneos-version-min=2.0 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | grep '20000' | count 1 && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | count 0 && -// RUN: clang-cc -triple armv6-apple-darwin9 -miphoneos-version-min=2.2 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple armv6-apple-darwin9 -miphoneos-version-min=2.2 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | grep '20200' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin8 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin8 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | count 0 && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1040' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin9 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin9 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1050' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin10 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin10 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1060' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin9 -mmacosx-version-min=10.4 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin9 -mmacosx-version-min=10.4 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t | count 0 && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1040' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin9 -mmacosx-version-min=10.5 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin9 -mmacosx-version-min=10.5 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1050' | count 1 && -// RUN: clang-cc -triple i686-apple-darwin9 -mmacosx-version-min=10.6 -dM -E -o %t - < /dev/null && +// RUN: clang -ccc-host-triple i686-apple-darwin9 -mmacosx-version-min=10.6 -dM -E -o %t %s && // RUN: grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t | grep '1060' | count 1 && // RUN: true diff --git a/test/Frontend/dependency-gen.c b/test/Frontend/dependency-gen.c index 4a1611aecff0..953869912bbb 100644 --- a/test/Frontend/dependency-gen.c +++ b/test/Frontend/dependency-gen.c @@ -1,7 +1,8 @@ // rdar://6533411 -// RUN: clang -MD -MF %t.d -c -x c -o %t.o /dev/null && +// RUN: clang -MD -MF %t.d -c -x c -o %t.o %s && // RUN: grep '.*dependency-gen.*:' %t.d && -// RUN: grep '/dev/null' %t.d && +// RUN: grep 'dependency-gen.c' %t.d && -// RUN: clang -M -x c /dev/null -o %t.deps && -// RUN: grep 'null.o: /dev/null' %t.deps +// RUN: clang -M -x c %s -o %t.d && +// RUN: grep '.*dependency-gen.*:' %t.d && +// RUN: grep 'dependency-gen.c' %t.d diff --git a/test/Lexer/block_cmt_end.c b/test/Lexer/block_cmt_end.c index d85cf81f214a..83d6cf189243 100644 --- a/test/Lexer/block_cmt_end.c +++ b/test/Lexer/block_cmt_end.c @@ -17,7 +17,7 @@ next comment ends with normal escaped newline: /* expected-warning {{escaped newline}} expected-warning {{backslash and newline}} *\ / -int bar +int bar /* expected-error {{invalid token after top level declarator}} */ /* xyz @@ -26,7 +26,7 @@ next comment ends with a trigraph escaped newline: */ /* expected-warning {{escaped newline between}} expected-warning {{backslash and newline separated by space}} expected-warning {{trigraph ends block comment}} *??/ / -foo /* expected-error {{invalid token after top level declarator}} */ +foo // rdar://6060752 - We should not get warnings about trigraphs in comments: diff --git a/test/Makefile b/test/Makefile index 8543d431442b..fdb9d8f713d9 100644 --- a/test/Makefile +++ b/test/Makefile @@ -40,9 +40,10 @@ lit.site.cfg: FORCE -e "s#@LLVM_LIBS_DIR@#$(LibDir)#g" \ -e "s#@CLANG_SOURCE_DIR@#$(PROJ_SRC_DIR)/..#g" \ -e "s#@CLANG_BINARY_DIR@#$(PROJ_OBJ_DIR)/..#g" \ + -e "s#@TARGET_TRIPLE@#$(TARGET_TRIPLE)#g" \ $(PROJ_SRC_DIR)/lit.site.cfg.in > $@ clean:: - @ rm -rf Output/ + @ find . -name Output | xargs rm -fr .PHONY: all report clean diff --git a/test/Misc/message-length.c b/test/Misc/message-length.c index 9f4d66fe71c0..4502951dbf62 100644 --- a/test/Misc/message-length.c +++ b/test/Misc/message-length.c @@ -29,4 +29,4 @@ void a_very_long_line(int *ip, float *FloatPointer) { // CHECK: FILE:23:78 -// CHECK: {{^ ...// some long comment text and a brace, eh {} $}} +// CHECK: {{^ ...// some long comment text and a brace, eh {} }} diff --git a/test/PCH/pr4489.c b/test/PCH/pr4489.c index 7730819e9213..d05d5cd7ddab 100644 --- a/test/PCH/pr4489.c +++ b/test/PCH/pr4489.c @@ -1,5 +1,6 @@ // RUN: clang -x c-header -o %t.pch %s && -// RUN: clang -include %t -x c /dev/null -emit-llvm -S -o - +// RUN: echo > %t.empty.c && +// RUN: clang -include %t -x c %t.empty.c -emit-llvm -S -o - // PR 4489: Crash with PCH // PR 4492: Crash with PCH (round two) // PR 4509: Crash with PCH (round three) @@ -37,4 +38,4 @@ void y1(void) { extern char e; fprintf (0, "asdf"); -}
\ No newline at end of file +} diff --git a/test/Parser/cxx-parse-member-pointer-op.cpp b/test/Parser/cxx-parse-member-pointer-op.cpp new file mode 100644 index 000000000000..cc2e8b142fcb --- /dev/null +++ b/test/Parser/cxx-parse-member-pointer-op.cpp @@ -0,0 +1,13 @@ +// RUN: clang-cc -fsyntax-only -pedantic -verify %s + +struct C {}; + +typedef void (C::*pmfc)(); + +void g(pmfc) { + C *c; + c->*pmfc(); // expected-error {{invalid use of pointer to member type after '->*'}} + C c1; + c1.*pmfc(); // expected-error {{invalid use of pointer to member type after '.*'}} +} + diff --git a/test/Parser/cxx-template-decl.cpp b/test/Parser/cxx-template-decl.cpp index 9309b72a556e..2b2d3de50497 100644 --- a/test/Parser/cxx-template-decl.cpp +++ b/test/Parser/cxx-template-decl.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify %s +// RUN: clang-cc -fsyntax-only -verify -fms-extensions=0 %s // Errors export class foo { }; // expected-error {{expected template}} @@ -92,3 +92,7 @@ void f2() { int x; A< typeof(x>1) > a; } + + +// PR3844 +template <> struct S<int> { }; // expected-error{{explicit specialization of non-template struct 'S'}} diff --git a/test/Preprocessor/assembler-with-cpp.c b/test/Preprocessor/assembler-with-cpp.c index f7706ca676ce..4f1c443fc042 100644 --- a/test/Preprocessor/assembler-with-cpp.c +++ b/test/Preprocessor/assembler-with-cpp.c @@ -1,4 +1,4 @@ -// RUN: clang-cc -x assembler-with-cpp -fdollars-in-identifiers=0 -E %s > %t && +// RUN: clang-cc -x assembler-with-cpp -fdollars-in-identifiers=0 -E %s -o - | FileCheck -strict-whitespace -check-prefix=CHECK-Identifiers-False %s && #ifndef __ASSEMBLER__ #error "__ASSEMBLER__ not defined" @@ -6,72 +6,70 @@ // Invalid token pasting is ok. -// RUN: grep '1: X .' %t && #define A X ## . 1: A +// CHECK-Identifiers-False: 1: X . // Line markers are not linemarkers in .S files, they are passed through. -// RUN: grep '# 321' %t && # 321 +// CHECK-Identifiers-False: # 321 // Unknown directives are passed through. -// RUN: grep '# B C' %t && # B C +// CHECK-Identifiers-False: # B C // Unknown directives are expanded. -// RUN: grep '# BAR42' %t && #define D(x) BAR ## x # D(42) +// CHECK-Identifiers-False: # BAR42 // Unmatched quotes are permitted. -// RUN: grep "2: '" %t && -// RUN: grep '3: "' %t && 2: ' 3: " +// CHECK-Identifiers-False: 2: ' +// CHECK-Identifiers-False: 3: " // (balance quotes to keep editors happy): "' // Empty char literals are ok. -// RUN: grep "4: ''" %t && 4: '' +// CHECK-Identifiers-False: 4: '' // Portions of invalid pasting should still expand as macros. // rdar://6709206 -// RUN: grep "5: expanded (" %t && #define M4 expanded #define M5() M4 ## ( 5: M5() +// CHECK-Identifiers-False: 5: expanded ( // rdar://6804322 -// RUN: grep -F "6: blarg $foo" %t && #define FOO(name) name ## $foo 6: FOO(blarg) +// CHECK-Identifiers-False: 6: blarg $foo -// RUN: clang-cc -x assembler-with-cpp -fdollars-in-identifiers=1 -E %s > %t && -// RUN: grep -F "7: blarg$foo" %t && +// RUN: clang-cc -x assembler-with-cpp -fdollars-in-identifiers=1 -E %s -o - | FileCheck -check-prefix=CHECK-Identifiers-True -strict-whitespace %s && #define FOO(name) name ## $foo 7: FOO(blarg) - +// CHECK-Identifiers-True: 7: blarg$foo // #define T6() T6 #nostring #define T7(x) T7 #x 8: T6() 9: T7(foo) -// RUN: grep '8: T6 #nostring' %t && -// RUN: grep '9: T7 "foo"' %t && +// CHECK-Identifiers-True: 8: T6 #nostring +// CHECK-Identifiers-True: 9: T7 "foo" // Concatenation with period doesn't leave a space -// RUN: grep -F '10: .T8' %t && #define T8(A,B) A ## B 10: T8(.,T8) - +// CHECK-Identifiers-True: 10: .T8 // This should not crash. -// RUN: grep '11: #0' %t && #define T11(a) #0 11: T11(b) +// CHECK-Identifiers-True: 11: #0 // RUN: true diff --git a/test/Preprocessor/c99-6_10_3_3_p4.c b/test/Preprocessor/c99-6_10_3_3_p4.c index 89660549b9a1..99ad6e88a3f9 100644 --- a/test/Preprocessor/c99-6_10_3_3_p4.c +++ b/test/Preprocessor/c99-6_10_3_3_p4.c @@ -1,6 +1,10 @@ -// RUN: clang-cc -E %s | grep -F 'char p[] = "x ## y";' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s + #define hash_hash # ## # #define mkstr(a) # a #define in_between(a) mkstr(a) #define join(c, d) in_between(c hash_hash d) char p[] = join(x, y); + +// CHECK: char p[] = "x ## y"; + diff --git a/test/Preprocessor/c99-6_10_3_4_p5.c b/test/Preprocessor/c99-6_10_3_4_p5.c index 22bdf8258cbe..08b2c423601f 100644 --- a/test/Preprocessor/c99-6_10_3_4_p5.c +++ b/test/Preprocessor/c99-6_10_3_4_p5.c @@ -1,10 +1,5 @@ // Example from C99 6.10.3.4p5 - -// RUN: clang-cc -E %s | grep -F 'f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);' && -// RUN: clang-cc -E %s | grep -F 'f(2 * (2 +(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);' && -// RUN: clang-cc -E %s | grep -F 'int i[] = { 1, 23, 4, 5, };' && -// RUN: clang-cc -E %s | grep -F 'char c[2][6] = { "hello", "" };' - +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define x 3 #define f(a) f(x * (a)) @@ -26,4 +21,8 @@ p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) }; char c[2][6] = { str(hello), str() }; +// CHECK: f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1); +// CHECK: f(2 * (2 +(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1); +// CHECK: int i[] = { 1, 23, 4, 5, }; +// CHECK: char c[2][6] = { "hello", "" }; diff --git a/test/Preprocessor/c99-6_10_3_4_p6.c b/test/Preprocessor/c99-6_10_3_4_p6.c index c48d2efd2eff..8072d7b87bf2 100644 --- a/test/Preprocessor/c99-6_10_3_4_p6.c +++ b/test/Preprocessor/c99-6_10_3_4_p6.c @@ -1,10 +1,6 @@ // Example from C99 6.10.3.4p6 -// RUN: clang-cc -E %s | grep -F 'printf("x" "1" "= %d, x" "2" "= s" x1, x2);' && -// RUN: clang-cc -E %s | grep 'fputs("strncmp(\\"abc\\\\0d\\" \\"abc\\", .\\\\4.) == 0" ": @\\n", s);' && -// RUN: clang-cc -E %s | grep -F 'include "vers2.h"' && -// RUN: clang-cc -E %s | grep -F '"hello";' && -// RUN: clang-cc -E %s | grep -F '"hello" ", world"' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define str(s) # s #define xstr(s) str(s) @@ -22,3 +18,10 @@ include xstr(INCFILE(2).h) glue(HIGH, LOW); xglue(HIGH, LOW) + +// CHECK: printf("x" "1" "= %d, x" "2" "= s" x1, x2); +// CHECK: fputs("strncmp(\"abc\\0d\" \"abc\", '\\4') == 0" ": @\n", s); +// CHECK: include "vers2.h" +// CHECK: "hello"; +// CHECK: "hello" ", world" + diff --git a/test/Preprocessor/c99-6_10_3_4_p7.c b/test/Preprocessor/c99-6_10_3_4_p7.c index a53df8263f19..6a7eb48173b8 100644 --- a/test/Preprocessor/c99-6_10_3_4_p7.c +++ b/test/Preprocessor/c99-6_10_3_4_p7.c @@ -1,9 +1,10 @@ // Example from C99 6.10.3.4p7 -// RUN: clang-cc -E %s | grep -F 'int j[] = { 123, 45, 67, 89,' && -// RUN: clang-cc -E %s | grep -F '10, 11, 12, };' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define t(x,y,z) x ## y ## z int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,), t(10,,), t(,11,), t(,,12), t(,,) }; +// CHECK: int j[] = { 123, 45, 67, 89, +// CHECK: 10, 11, 12, }; diff --git a/test/Preprocessor/c99-6_10_3_4_p9.c b/test/Preprocessor/c99-6_10_3_4_p9.c index 39c34546ad4d..704241e46e3f 100644 --- a/test/Preprocessor/c99-6_10_3_4_p9.c +++ b/test/Preprocessor/c99-6_10_3_4_p9.c @@ -1,16 +1,20 @@ // Example from C99 6.10.3.4p9 -// RUN: clang-cc -E %s | grep -F 'fprintf(stderr, "Flag");' && -// RUN: clang-cc -E %s | grep -F 'fprintf(stderr, "X = %d\n", x);' && -// RUN: clang-cc -E %s | grep -F 'puts("The first, second, and third items.");' && -// RUN: clang-cc -E %s | grep -F '((x>y)?puts("x>y"): printf("x is %d but y is %d", x, y));' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define debug(...) fprintf(stderr, __VA_ARGS__) #define showlist(...) puts(#__VA_ARGS__) #define report(test, ...) ((test)?puts(#test):\ printf(__VA_ARGS__)) -debug("Flag"); -debug("X = %d\n", x); -showlist(The first, second, and third items.); -report(x>y, "x is %d but y is %d", x, y); +debug("Flag"); +// CHECK: fprintf(stderr, "Flag"); + +debug("X = %d\n", x); +// CHECK: fprintf(stderr, "X = %d\n", x); + +showlist(The first, second, and third items.); +// CHECK: puts("The first, second, and third items."); + +report(x>y, "x is %d but y is %d", x, y); +// CHECK: ((x>y)?puts("x>y"): printf("x is %d but y is %d", x, y)); diff --git a/test/Preprocessor/comment_save.c b/test/Preprocessor/comment_save.c index 30b043433c97..ae609b117e7e 100644 --- a/test/Preprocessor/comment_save.c +++ b/test/Preprocessor/comment_save.c @@ -1,7 +1,8 @@ -// RUN: clang-cc -E -C %s | grep '^// foo$' && -// RUN: clang-cc -E -C %s | grep -F '^/* bar */$' +// RUN: clang-cc -E -C %s | FileCheck -strict-whitespace %s // foo -/* bar */ +// CHECK: // foo +/* bar */ +// CHECK: /* bar */ diff --git a/test/Preprocessor/comment_save_macro.c b/test/Preprocessor/comment_save_macro.c index 66b59d136d73..b9a25ed2e7f3 100644 --- a/test/Preprocessor/comment_save_macro.c +++ b/test/Preprocessor/comment_save_macro.c @@ -1,6 +1,11 @@ -// RUN: clang-cc -E -C %s | grep '^boo bork bar // zot$' && -// RUN: clang-cc -E -CC %s | grep -F '^boo bork /* blah*/ bar // zot$' && -// RUN: clang-cc -E %s | grep '^boo bork bar$' +// RUN: clang-cc -E -C %s | FileCheck -check-prefix=CHECK-C -strict-whitespace %s && +// CHECK-C: boo bork bar // zot + +// RUN: clang-cc -E -CC %s | FileCheck -check-prefix=CHECK-CC -strict-whitespace %s && +// CHECK-CC: boo bork /* blah*/ bar // zot + +// RUN: clang-cc -E %s | FileCheck -check-prefix=CHECK -strict-whitespace %s +// CHECK: boo bork bar #define FOO bork // blah diff --git a/test/Preprocessor/has_include.c b/test/Preprocessor/has_include.c new file mode 100644 index 000000000000..40697c099f4f --- /dev/null +++ b/test/Preprocessor/has_include.c @@ -0,0 +1,83 @@ +// RUN: clang-cc -Eonly -verify %s + +// Try different path permutations of __has_include with existing file. +#if __has_include("stdio.h") +#else + #error "__has_include failed (1)." +#endif + +#if __has_include(<stdio.h>) +#else + #error "__has_include failed (2)." +#endif + +// Try unary expression. +#if !__has_include("stdio.h") + #error "__has_include failed (5)." +#endif + +// Try binary expression. +#if __has_include("stdio.h") && __has_include("stddef.h") +#else + #error "__has_include failed (6)." +#endif + +// Try non-existing file. +#if __has_include("blahblah.h") + #error "__has_include failed (7)." +#endif + +// Try defined. +#if !defined(__has_include) + #error "defined(__has_include) failed (8)." +#endif + +// Try different path permutations of __has_include_next with existing file. +#if __has_include_next("stddef.h") // expected-warning {{#include_next in primary source file}} +#else + #error "__has_include failed (1)." +#endif + +#if __has_include_next(<stddef.h>) // expected-warning {{#include_next in primary source file}} +#else + #error "__has_include failed (2)." +#endif + +// Try unary expression. +#if !__has_include_next("stdio.h") // expected-warning {{#include_next in primary source file}} + #error "__has_include_next failed (5)." +#endif + +// Try binary expression. +#if __has_include_next("stdio.h") && __has_include("stddef.h") // expected-warning {{#include_next in primary source file}} +#else + #error "__has_include_next failed (6)." +#endif + +// Try non-existing file. +#if __has_include_next("blahblah.h") // expected-warning {{#include_next in primary source file}} + #error "__has_include_next failed (7)." +#endif + +// Try defined. +#if !defined(__has_include_next) + #error "defined(__has_include_next) failed (8)." +#endif + +// Try badly formed expressions. +// FIXME: I don't quite know how to avoid preprocessor side effects. +// Use FileCheck? +// It also assert due to unterminated #if's. +//#if __has_include("stdio.h" +//#if __has_include "stdio.h") +//#if __has_include(stdio.h) +//#if __has_include() +//#if __has_include( +//#if __has_include) +//#if __has_include +//#if __has_include(<stdio.h> +//#if __has_include<stdio.h>) +//#if __has_include("stdio.h) +//#if __has_include(stdio.h") +//#if __has_include(<stdio.h) +//#if __has_include(stdio.h>) diff --git a/test/Preprocessor/init.c b/test/Preprocessor/init.c new file mode 100644 index 000000000000..800b7506f4c2 --- /dev/null +++ b/test/Preprocessor/init.c @@ -0,0 +1,945 @@ +// RUN: clang-cc -E -dM -x=assembler-with-cpp < /dev/null | FileCheck -check-prefix ASM %s && +// +// ASM:#define __ASSEMBLER__ 1 +// +// +// RUN: clang-cc -fblocks -E -dM < /dev/null | FileCheck -check-prefix BLOCKS %s && +// +// BLOCKS:#define __BLOCKS__ 1 +// BLOCKS:#define __block __attribute__((__blocks__(byref))) +// +// +// RUN: clang-cc -x=c++ -std=c++0x -E -dM < /dev/null | FileCheck -check-prefix CXX0X %s && +// +// CXX0X:#define _GNU_SOURCE 1 +// CXX0X:#define __DEPRECATED 1 +// CXX0X:#define __GNUG__ +// CXX0X:#define __GXX_EXPERIMENTAL_CXX0X__ 1 +// CXX0X:#define __GXX_WEAK__ 1 +// CXX0X:#define __cplusplus 199711L +// CXX0X:#define __private_extern__ extern +// +// +// RUN: clang-cc -x=c++ -std=c++98 -E -dM < /dev/null | FileCheck -check-prefix CXX98 %s && +// +// CXX98:#define _GNU_SOURCE 1 +// CXX98:#define __DEPRECATED 1 +// CXX98:#define __GNUG__ +// CXX98:#define __GXX_WEAK__ 1 +// CXX98:#define __cplusplus 199711L +// CXX98:#define __private_extern__ extern +// +// +// RUN: clang-cc -std=c99 -E -dM < /dev/null | FileCheck -check-prefix C99 %s && +// +// C99:#define __STDC_VERSION__ 199901L +// C99:#define __STRICT_ANSI__ 1 +// +// +// RUN: clang-cc -E -dM -fms-extensions=0 < /dev/null | FileCheck -check-prefix COMMON %s && +// +// COMMON:#define __CONSTANT_CFSTRINGS__ 1 +// COMMON:#define __FINITE_MATH_ONLY__ 0 +// COMMON:#define __GNUC_MINOR__ +// COMMON:#define __GNUC_PATCHLEVEL__ +// COMMON:#define __GNUC_STDC_INLINE__ 1 +// COMMON:#define __GNUC__ +// COMMON:#define __GXX_ABI_VERSION +// COMMON:#define __STDC_HOSTED__ 1 +// COMMON:#define __STDC_VERSION__ +// COMMON:#define __STDC__ 1 +// COMMON:#define __VERSION__ +// COMMON:#define __clang__ 1 +// COMMON:#define __llvm__ 1 +// +// +// RUN: clang-cc -ffreestanding -E -dM < /dev/null | FileCheck -check-prefix FREESTANDING %s && +// FREESTANDING:#define __STDC_HOSTED__ 0 +// +// RUN: clang-cc -x=c++ -std=gnu++98 -E -dM < /dev/null | FileCheck -check-prefix GXX98 %s && +// +// GXX98:#define _GNU_SOURCE 1 +// GXX98:#define __DEPRECATED 1 +// GXX98:#define __GNUG__ +// GXX98:#define __GXX_WEAK__ 1 +// GXX98:#define __cplusplus 1 +// GXX98:#define __private_extern__ extern +// +// +// RUN: clang-cc -std=iso9899:199409 -E -dM < /dev/null | FileCheck -check-prefix C94 %s && +// +// C94:#define __STDC_VERSION__ 199409L +// +// +// RUN: clang-cc -fms-extensions -E -dM < /dev/null | FileCheck -check-prefix MSEXT %s && +// +// MSEXT-NOT:#define __STDC__ +// MSEXT:#define __int16 __INT16_TYPE__ +// MSEXT:#define __int32 __INT32_TYPE__ +// MSEXT:#define __int64 __INT64_TYPE__ +// MSEXT:#define __int8 __INT8_TYPE__ +// +// +// RUN: clang-cc -x=objective-c -E -dM < /dev/null | FileCheck -check-prefix OBJC %s && +// +// OBJC:#define OBJC_NEW_PROPERTIES 1 +// OBJC:#define __OBJC__ 1 +// +// +// RUN: clang-cc -x=objective-c -fobjc-gc -E -dM < /dev/null | FileCheck -check-prefix OBJCGC %s && +// +// OBJCGC:#define __OBJC_GC__ 1 +// +// +// RUN: clang-cc -x=objective-c -fnext-runtime -E -dM < /dev/null | FileCheck -check-prefix NEXTRT %s && +// +// NEXTRT:#define __NEXT_RUNTIME__ 1 +// +// +// RUN: clang-cc -x=objective-c -fobjc-nonfragile-abi -E -dM < /dev/null | FileCheck -check-prefix NONFRAGILE %s && +// +// NONFRAGILE:#define OBJC_ZEROCOST_EXCEPTIONS 1 +// NONFRAGILE:#define __OBJC2__ 1 +// +// +// RUN: clang-cc -O1 -E -dM < /dev/null | FileCheck -check-prefix O1 %s && +// +// O1:#define __OPTIMIZE__ 1 +// +// +// RUN: clang-cc -fpascal-strings -E -dM < /dev/null | FileCheck -check-prefix PASCAL %s && +// +// PASCAL:#define __PASCAL_STRINGS__ 1 +// +// +// RUN: clang-cc -fsigned-char -E -dM -fms-extensions=0 < /dev/null | FileCheck -check-prefix SCHAR %s && +// +// SCHAR:#define __STDC__ 1 +// SCHAR-NOT:#define __UNSIGNED_CHAR__ +// SCHAR:#define __clang__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=arm-none-none < /dev/null | FileCheck -check-prefix ARM %s && +// +// ARM:#define __APCS_32__ 1 +// ARM:#define __ARMEL__ 1 +// ARM:#define __ARM_ARCH_6K__ 1 +// ARM:#define __CHAR_BIT__ 8 +// ARM:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// ARM:#define __DBL_DIG__ 15 +// ARM:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// ARM:#define __DBL_HAS_DENORM__ 1 +// ARM:#define __DBL_HAS_INFINITY__ 1 +// ARM:#define __DBL_HAS_QUIET_NAN__ 1 +// ARM:#define __DBL_MANT_DIG__ 53 +// ARM:#define __DBL_MAX_10_EXP__ 308 +// ARM:#define __DBL_MAX_EXP__ 1024 +// ARM:#define __DBL_MAX__ 1.7976931348623157e+308 +// ARM:#define __DBL_MIN_10_EXP__ (-307) +// ARM:#define __DBL_MIN_EXP__ (-1021) +// ARM:#define __DBL_MIN__ 2.2250738585072014e-308 +// ARM:#define __DECIMAL_DIG__ 17 +// ARM:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// ARM:#define __FLT_DIG__ 6 +// ARM:#define __FLT_EPSILON__ 1.19209290e-7F +// ARM:#define __FLT_EVAL_METHOD__ 0 +// ARM:#define __FLT_HAS_DENORM__ 1 +// ARM:#define __FLT_HAS_INFINITY__ 1 +// ARM:#define __FLT_HAS_QUIET_NAN__ 1 +// ARM:#define __FLT_MANT_DIG__ 24 +// ARM:#define __FLT_MAX_10_EXP__ 38 +// ARM:#define __FLT_MAX_EXP__ 128 +// ARM:#define __FLT_MAX__ 3.40282347e+38F +// ARM:#define __FLT_MIN_10_EXP__ (-37) +// ARM:#define __FLT_MIN_EXP__ (-125) +// ARM:#define __FLT_MIN__ 1.17549435e-38F +// ARM:#define __FLT_RADIX__ 2 +// ARM:#define __INT16_TYPE__ short +// ARM:#define __INT32_TYPE__ int +// ARM:#define __INT64_TYPE__ long long int +// ARM:#define __INT8_TYPE__ char +// ARM:#define __INTMAX_MAX__ 9223372036854775807LL +// ARM:#define __INTMAX_TYPE__ long long int +// ARM:#define __INTPTR_TYPE__ long int +// ARM:#define __INT_MAX__ 2147483647 +// ARM:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// ARM:#define __LDBL_DIG__ 15 +// ARM:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// ARM:#define __LDBL_HAS_DENORM__ 1 +// ARM:#define __LDBL_HAS_INFINITY__ 1 +// ARM:#define __LDBL_HAS_QUIET_NAN__ 1 +// ARM:#define __LDBL_MANT_DIG__ 53 +// ARM:#define __LDBL_MAX_10_EXP__ 308 +// ARM:#define __LDBL_MAX_EXP__ 1024 +// ARM:#define __LDBL_MAX__ 1.7976931348623157e+308 +// ARM:#define __LDBL_MIN_10_EXP__ (-307) +// ARM:#define __LDBL_MIN_EXP__ (-1021) +// ARM:#define __LDBL_MIN__ 2.2250738585072014e-308 +// ARM:#define __LITTLE_ENDIAN__ 1 +// ARM:#define __LONG_LONG_MAX__ 9223372036854775807LL +// ARM:#define __LONG_MAX__ 2147483647L +// ARM:#define __NO_INLINE__ 1 +// ARM:#define __POINTER_WIDTH__ 32 +// ARM:#define __PTRDIFF_TYPE__ int +// ARM:#define __SCHAR_MAX__ 127 +// ARM:#define __SHRT_MAX__ 32767 +// ARM:#define __SIZE_TYPE__ unsigned int +// ARM:#define __THUMB_INTERWORK__ 1 +// ARM:#define __UINTMAX_TYPE__ long long unsigned int +// ARM:#define __USER_LABEL_PREFIX__ _ +// ARM:#define __VFP_FP__ 1 +// ARM:#define __WCHAR_MAX__ 2147483647 +// ARM:#define __WCHAR_TYPE__ int +// ARM:#define __WINT_TYPE__ int +// ARM:#define __arm 1 +// ARM:#define __arm__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=bfin-none-none < /dev/null | FileCheck -check-prefix BFIN %s && +// +// BFIN:#define BFIN 1 +// BFIN:#define __ADSPBLACKFIN__ 1 +// BFIN:#define __ADSPLPBLACKFIN__ 1 +// BFIN:#define __BFIN 1 +// BFIN:#define __BFIN__ 1 +// BFIN:#define __CHAR_BIT__ 8 +// BFIN:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// BFIN:#define __DBL_DIG__ 15 +// BFIN:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// BFIN:#define __DBL_HAS_DENORM__ 1 +// BFIN:#define __DBL_HAS_INFINITY__ 1 +// BFIN:#define __DBL_HAS_QUIET_NAN__ 1 +// BFIN:#define __DBL_MANT_DIG__ 53 +// BFIN:#define __DBL_MAX_10_EXP__ 308 +// BFIN:#define __DBL_MAX_EXP__ 1024 +// BFIN:#define __DBL_MAX__ 1.7976931348623157e+308 +// BFIN:#define __DBL_MIN_10_EXP__ (-307) +// BFIN:#define __DBL_MIN_EXP__ (-1021) +// BFIN:#define __DBL_MIN__ 2.2250738585072014e-308 +// BFIN:#define __DECIMAL_DIG__ 17 +// BFIN:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// BFIN:#define __FLT_DIG__ 6 +// BFIN:#define __FLT_EPSILON__ 1.19209290e-7F +// BFIN:#define __FLT_EVAL_METHOD__ 0 +// BFIN:#define __FLT_HAS_DENORM__ 1 +// BFIN:#define __FLT_HAS_INFINITY__ 1 +// BFIN:#define __FLT_HAS_QUIET_NAN__ 1 +// BFIN:#define __FLT_MANT_DIG__ 24 +// BFIN:#define __FLT_MAX_10_EXP__ 38 +// BFIN:#define __FLT_MAX_EXP__ 128 +// BFIN:#define __FLT_MAX__ 3.40282347e+38F +// BFIN:#define __FLT_MIN_10_EXP__ (-37) +// BFIN:#define __FLT_MIN_EXP__ (-125) +// BFIN:#define __FLT_MIN__ 1.17549435e-38F +// BFIN:#define __FLT_RADIX__ 2 +// BFIN:#define __INT16_TYPE__ short +// BFIN:#define __INT32_TYPE__ int +// BFIN:#define __INT64_TYPE__ long long int +// BFIN:#define __INT8_TYPE__ char +// BFIN:#define __INTMAX_MAX__ 9223372036854775807LL +// BFIN:#define __INTMAX_TYPE__ long long int +// BFIN:#define __INTPTR_TYPE__ long int +// BFIN:#define __INT_MAX__ 2147483647 +// BFIN:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// BFIN:#define __LDBL_DIG__ 15 +// BFIN:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// BFIN:#define __LDBL_HAS_DENORM__ 1 +// BFIN:#define __LDBL_HAS_INFINITY__ 1 +// BFIN:#define __LDBL_HAS_QUIET_NAN__ 1 +// BFIN:#define __LDBL_MANT_DIG__ 53 +// BFIN:#define __LDBL_MAX_10_EXP__ 308 +// BFIN:#define __LDBL_MAX_EXP__ 1024 +// BFIN:#define __LDBL_MAX__ 1.7976931348623157e+308 +// BFIN:#define __LDBL_MIN_10_EXP__ (-307) +// BFIN:#define __LDBL_MIN_EXP__ (-1021) +// BFIN:#define __LDBL_MIN__ 2.2250738585072014e-308 +// BFIN:#define __LONG_LONG_MAX__ 9223372036854775807LL +// BFIN:#define __LONG_MAX__ 2147483647L +// BFIN:#define __NO_INLINE__ 1 +// BFIN:#define __POINTER_WIDTH__ 32 +// BFIN:#define __PTRDIFF_TYPE__ long int +// BFIN:#define __SCHAR_MAX__ 127 +// BFIN:#define __SHRT_MAX__ 32767 +// BFIN:#define __SIZE_TYPE__ long unsigned int +// BFIN:#define __UINTMAX_TYPE__ long long unsigned int +// BFIN:#define __USER_LABEL_PREFIX__ _ +// BFIN:#define __WCHAR_MAX__ 2147483647 +// BFIN:#define __WCHAR_TYPE__ int +// BFIN:#define __WINT_TYPE__ int +// BFIN:#define __bfin 1 +// BFIN:#define __bfin__ 1 +// BFIN:#define bfin 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=i386-none-none < /dev/null | FileCheck -check-prefix I386 %s && +// +// I386:#define __CHAR_BIT__ 8 +// I386:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// I386:#define __DBL_DIG__ 15 +// I386:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// I386:#define __DBL_HAS_DENORM__ 1 +// I386:#define __DBL_HAS_INFINITY__ 1 +// I386:#define __DBL_HAS_QUIET_NAN__ 1 +// I386:#define __DBL_MANT_DIG__ 53 +// I386:#define __DBL_MAX_10_EXP__ 308 +// I386:#define __DBL_MAX_EXP__ 1024 +// I386:#define __DBL_MAX__ 1.7976931348623157e+308 +// I386:#define __DBL_MIN_10_EXP__ (-307) +// I386:#define __DBL_MIN_EXP__ (-1021) +// I386:#define __DBL_MIN__ 2.2250738585072014e-308 +// I386:#define __DECIMAL_DIG__ 21 +// I386:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// I386:#define __FLT_DIG__ 6 +// I386:#define __FLT_EPSILON__ 1.19209290e-7F +// I386:#define __FLT_EVAL_METHOD__ 0 +// I386:#define __FLT_HAS_DENORM__ 1 +// I386:#define __FLT_HAS_INFINITY__ 1 +// I386:#define __FLT_HAS_QUIET_NAN__ 1 +// I386:#define __FLT_MANT_DIG__ 24 +// I386:#define __FLT_MAX_10_EXP__ 38 +// I386:#define __FLT_MAX_EXP__ 128 +// I386:#define __FLT_MAX__ 3.40282347e+38F +// I386:#define __FLT_MIN_10_EXP__ (-37) +// I386:#define __FLT_MIN_EXP__ (-125) +// I386:#define __FLT_MIN__ 1.17549435e-38F +// I386:#define __FLT_RADIX__ 2 +// I386:#define __INT16_TYPE__ short +// I386:#define __INT32_TYPE__ int +// I386:#define __INT64_TYPE__ long long int +// I386:#define __INT8_TYPE__ char +// I386:#define __INTMAX_MAX__ 9223372036854775807LL +// I386:#define __INTMAX_TYPE__ long long int +// I386:#define __INTPTR_TYPE__ int +// I386:#define __INT_MAX__ 2147483647 +// I386:#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L +// I386:#define __LDBL_DIG__ 18 +// I386:#define __LDBL_EPSILON__ 1.08420217248550443401e-19L +// I386:#define __LDBL_HAS_DENORM__ 1 +// I386:#define __LDBL_HAS_INFINITY__ 1 +// I386:#define __LDBL_HAS_QUIET_NAN__ 1 +// I386:#define __LDBL_MANT_DIG__ 64 +// I386:#define __LDBL_MAX_10_EXP__ 4932 +// I386:#define __LDBL_MAX_EXP__ 16384 +// I386:#define __LDBL_MAX__ 1.18973149535723176502e+4932L +// I386:#define __LDBL_MIN_10_EXP__ (-4931) +// I386:#define __LDBL_MIN_EXP__ (-16381) +// I386:#define __LDBL_MIN__ 3.36210314311209350626e-4932L +// I386:#define __LITTLE_ENDIAN__ 1 +// I386:#define __LONG_LONG_MAX__ 9223372036854775807LL +// I386:#define __LONG_MAX__ 2147483647L +// I386:#define __NO_INLINE__ 1 +// I386:#define __NO_MATH_INLINES 1 +// I386:#define __POINTER_WIDTH__ 32 +// I386:#define __PTRDIFF_TYPE__ int +// I386:#define __REGISTER_PREFIX__ +// I386:#define __SCHAR_MAX__ 127 +// I386:#define __SHRT_MAX__ 32767 +// I386:#define __SIZE_TYPE__ unsigned int +// I386:#define __UINTMAX_TYPE__ long long unsigned int +// I386:#define __USER_LABEL_PREFIX__ _ +// I386:#define __WCHAR_MAX__ 2147483647 +// I386:#define __WCHAR_TYPE__ int +// I386:#define __WINT_TYPE__ int +// I386:#define __i386 1 +// I386:#define __i386__ 1 +// I386:#define __nocona 1 +// I386:#define __nocona__ 1 +// I386:#define __tune_nocona__ 1 +// I386:#define i386 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=msp430-none-none < /dev/null | FileCheck -check-prefix MSP430 %s && +// +// MSP430:#define MSP430 1 +// MSP430:#define __CHAR_BIT__ 8 +// MSP430:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// MSP430:#define __DBL_DIG__ 15 +// MSP430:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// MSP430:#define __DBL_HAS_DENORM__ 1 +// MSP430:#define __DBL_HAS_INFINITY__ 1 +// MSP430:#define __DBL_HAS_QUIET_NAN__ 1 +// MSP430:#define __DBL_MANT_DIG__ 53 +// MSP430:#define __DBL_MAX_10_EXP__ 308 +// MSP430:#define __DBL_MAX_EXP__ 1024 +// MSP430:#define __DBL_MAX__ 1.7976931348623157e+308 +// MSP430:#define __DBL_MIN_10_EXP__ (-307) +// MSP430:#define __DBL_MIN_EXP__ (-1021) +// MSP430:#define __DBL_MIN__ 2.2250738585072014e-308 +// MSP430:#define __DECIMAL_DIG__ 17 +// MSP430:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// MSP430:#define __FLT_DIG__ 6 +// MSP430:#define __FLT_EPSILON__ 1.19209290e-7F +// MSP430:#define __FLT_EVAL_METHOD__ 0 +// MSP430:#define __FLT_HAS_DENORM__ 1 +// MSP430:#define __FLT_HAS_INFINITY__ 1 +// MSP430:#define __FLT_HAS_QUIET_NAN__ 1 +// MSP430:#define __FLT_MANT_DIG__ 24 +// MSP430:#define __FLT_MAX_10_EXP__ 38 +// MSP430:#define __FLT_MAX_EXP__ 128 +// MSP430:#define __FLT_MAX__ 3.40282347e+38F +// MSP430:#define __FLT_MIN_10_EXP__ (-37) +// MSP430:#define __FLT_MIN_EXP__ (-125) +// MSP430:#define __FLT_MIN__ 1.17549435e-38F +// MSP430:#define __FLT_RADIX__ 2 +// MSP430:#define __INT16_TYPE__ short +// MSP430:#define __INT32_TYPE__ long long +// MSP430:#define __INT8_TYPE__ char +// MSP430:#define __INTMAX_MAX__ 2147483647L +// MSP430:#define __INTMAX_TYPE__ long int +// MSP430:#define __INTPTR_TYPE__ short +// MSP430:#define __INT_MAX__ 32767 +// MSP430:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// MSP430:#define __LDBL_DIG__ 15 +// MSP430:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// MSP430:#define __LDBL_HAS_DENORM__ 1 +// MSP430:#define __LDBL_HAS_INFINITY__ 1 +// MSP430:#define __LDBL_HAS_QUIET_NAN__ 1 +// MSP430:#define __LDBL_MANT_DIG__ 53 +// MSP430:#define __LDBL_MAX_10_EXP__ 308 +// MSP430:#define __LDBL_MAX_EXP__ 1024 +// MSP430:#define __LDBL_MAX__ 1.7976931348623157e+308 +// MSP430:#define __LDBL_MIN_10_EXP__ (-307) +// MSP430:#define __LDBL_MIN_EXP__ (-1021) +// MSP430:#define __LDBL_MIN__ 2.2250738585072014e-308 +// MSP430:#define __LONG_LONG_MAX__ 2147483647LL +// MSP430:#define __LONG_MAX__ 2147483647L +// MSP430:#define __MSP430__ 1 +// MSP430:#define __NO_INLINE__ 1 +// MSP430:#define __POINTER_WIDTH__ 16 +// MSP430:#define __PTRDIFF_TYPE__ int +// MSP430:#define __SCHAR_MAX__ 127 +// MSP430:#define __SHRT_MAX__ 32767 +// MSP430:#define __SIZE_TYPE__ unsigned int +// MSP430:#define __UINTMAX_TYPE__ long unsigned int +// MSP430:#define __USER_LABEL_PREFIX__ _ +// MSP430:#define __WCHAR_MAX__ 2147483647 +// MSP430:#define __WCHAR_TYPE__ int +// MSP430:#define __WINT_TYPE__ int +// MSP430:#define __clang__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=pic16-none-none < /dev/null | FileCheck -check-prefix PIC16 %s && +// +// PIC16:#define _CONFIG(conf) asm("CONFIG "#conf) +// PIC16:#define __CHAR_BIT__ 8 +// PIC16:#define __DBL_DENORM_MIN__ 1.40129846e-45F +// PIC16:#define __DBL_DIG__ 6 +// PIC16:#define __DBL_EPSILON__ 1.19209290e-7F +// PIC16:#define __DBL_HAS_DENORM__ 1 +// PIC16:#define __DBL_HAS_INFINITY__ 1 +// PIC16:#define __DBL_HAS_QUIET_NAN__ 1 +// PIC16:#define __DBL_MANT_DIG__ 24 +// PIC16:#define __DBL_MAX_10_EXP__ 38 +// PIC16:#define __DBL_MAX_EXP__ 128 +// PIC16:#define __DBL_MAX__ 3.40282347e+38F +// PIC16:#define __DBL_MIN_10_EXP__ (-37) +// PIC16:#define __DBL_MIN_EXP__ (-125) +// PIC16:#define __DBL_MIN__ 1.17549435e-38F +// PIC16:#define __DECIMAL_DIG__ -1 +// PIC16:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// PIC16:#define __FLT_DIG__ 6 +// PIC16:#define __FLT_EPSILON__ 1.19209290e-7F +// PIC16:#define __FLT_EVAL_METHOD__ 0 +// PIC16:#define __FLT_HAS_DENORM__ 1 +// PIC16:#define __FLT_HAS_INFINITY__ 1 +// PIC16:#define __FLT_HAS_QUIET_NAN__ 1 +// PIC16:#define __FLT_MANT_DIG__ 24 +// PIC16:#define __FLT_MAX_10_EXP__ 38 +// PIC16:#define __FLT_MAX_EXP__ 128 +// PIC16:#define __FLT_MAX__ 3.40282347e+38F +// PIC16:#define __FLT_MIN_10_EXP__ (-37) +// PIC16:#define __FLT_MIN_EXP__ (-125) +// PIC16:#define __FLT_MIN__ 1.17549435e-38F +// PIC16:#define __FLT_RADIX__ 2 +// PIC16:#define __INT16_TYPE__ short +// PIC16:#define __INT32_TYPE__ long long +// PIC16:#define __INT8_TYPE__ char +// PIC16:#define __INTMAX_MAX__ 2147483647L +// PIC16:#define __INTMAX_TYPE__ long int +// PIC16:#define __INTPTR_TYPE__ short +// PIC16:#define __INT_MAX__ 32767 +// PIC16:#define __LDBL_DENORM_MIN__ 1.40129846e-45F +// PIC16:#define __LDBL_DIG__ 6 +// PIC16:#define __LDBL_EPSILON__ 1.19209290e-7F +// PIC16:#define __LDBL_HAS_DENORM__ 1 +// PIC16:#define __LDBL_HAS_INFINITY__ 1 +// PIC16:#define __LDBL_HAS_QUIET_NAN__ 1 +// PIC16:#define __LDBL_MANT_DIG__ 24 +// PIC16:#define __LDBL_MAX_10_EXP__ 38 +// PIC16:#define __LDBL_MAX_EXP__ 128 +// PIC16:#define __LDBL_MAX__ 3.40282347e+38F +// PIC16:#define __LDBL_MIN_10_EXP__ (-37) +// PIC16:#define __LDBL_MIN_EXP__ (-125) +// PIC16:#define __LDBL_MIN__ 1.17549435e-38F +// PIC16:#define __LONG_LONG_MAX__ 2147483647LL +// PIC16:#define __LONG_MAX__ 2147483647L +// PIC16:#define __NO_INLINE__ 1 +// PIC16:#define __POINTER_WIDTH__ 16 +// PIC16:#define __PTRDIFF_TYPE__ int +// PIC16:#define __SCHAR_MAX__ 127 +// PIC16:#define __SHRT_MAX__ 32767 +// PIC16:#define __SIZE_TYPE__ unsigned int +// PIC16:#define __UINTMAX_TYPE__ long unsigned int +// PIC16:#define __USER_LABEL_PREFIX__ _ +// PIC16:#define __WCHAR_MAX__ 2147483647 +// PIC16:#define __WCHAR_TYPE__ int +// PIC16:#define __WINT_TYPE__ int +// PIC16:#define __clang__ 1 +// PIC16:#define __llvm__ 1 +// PIC16:#define __pic16 1 +// PIC16:#define _address(Addr) __attribute__((section("Address="#Addr))) +// PIC16:#define _interrupt __attribute__((section("interrupt=0x4"))) __attribute__((used)) +// PIC16:#define _section(SectName) __attribute__((section(SectName))) +// PIC16:#define ram __attribute__((address_space(0))) +// PIC16:#define rom __attribute__((address_space(1))) +// +// RUN: clang-cc -E -dM -ffreestanding -triple=powerpc64-none-none < /dev/null | FileCheck -check-prefix PPC64 %s && +// +// PPC64:#define _ARCH_PPC 1 +// PPC64:#define _ARCH_PPC64 1 +// PPC64:#define _BIG_ENDIAN 1 +// PPC64:#define _LP64 1 +// PPC64:#define __BIG_ENDIAN__ 1 +// PPC64:#define __CHAR_BIT__ 8 +// PPC64:#define __CHAR_UNSIGNED__ 1 +// PPC64:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// PPC64:#define __DBL_DIG__ 15 +// PPC64:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// PPC64:#define __DBL_HAS_DENORM__ 1 +// PPC64:#define __DBL_HAS_INFINITY__ 1 +// PPC64:#define __DBL_HAS_QUIET_NAN__ 1 +// PPC64:#define __DBL_MANT_DIG__ 53 +// PPC64:#define __DBL_MAX_10_EXP__ 308 +// PPC64:#define __DBL_MAX_EXP__ 1024 +// PPC64:#define __DBL_MAX__ 1.7976931348623157e+308 +// PPC64:#define __DBL_MIN_10_EXP__ (-307) +// PPC64:#define __DBL_MIN_EXP__ (-1021) +// PPC64:#define __DBL_MIN__ 2.2250738585072014e-308 +// PPC64:#define __DECIMAL_DIG__ 17 +// PPC64:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// PPC64:#define __FLT_DIG__ 6 +// PPC64:#define __FLT_EPSILON__ 1.19209290e-7F +// PPC64:#define __FLT_EVAL_METHOD__ 0 +// PPC64:#define __FLT_HAS_DENORM__ 1 +// PPC64:#define __FLT_HAS_INFINITY__ 1 +// PPC64:#define __FLT_HAS_QUIET_NAN__ 1 +// PPC64:#define __FLT_MANT_DIG__ 24 +// PPC64:#define __FLT_MAX_10_EXP__ 38 +// PPC64:#define __FLT_MAX_EXP__ 128 +// PPC64:#define __FLT_MAX__ 3.40282347e+38F +// PPC64:#define __FLT_MIN_10_EXP__ (-37) +// PPC64:#define __FLT_MIN_EXP__ (-125) +// PPC64:#define __FLT_MIN__ 1.17549435e-38F +// PPC64:#define __FLT_RADIX__ 2 +// PPC64:#define __INT16_TYPE__ short +// PPC64:#define __INT32_TYPE__ int +// PPC64:#define __INT64_TYPE__ long int +// PPC64:#define __INT8_TYPE__ char +// PPC64:#define __INTMAX_MAX__ 9223372036854775807L +// PPC64:#define __INTMAX_TYPE__ long int +// PPC64:#define __INTPTR_TYPE__ long int +// PPC64:#define __INT_MAX__ 2147483647 +// PPC64:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// PPC64:#define __LDBL_DIG__ 15 +// PPC64:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// PPC64:#define __LDBL_HAS_DENORM__ 1 +// PPC64:#define __LDBL_HAS_INFINITY__ 1 +// PPC64:#define __LDBL_HAS_QUIET_NAN__ 1 +// PPC64:#define __LDBL_MANT_DIG__ 53 +// PPC64:#define __LDBL_MAX_10_EXP__ 308 +// PPC64:#define __LDBL_MAX_EXP__ 1024 +// PPC64:#define __LDBL_MAX__ 1.7976931348623157e+308 +// PPC64:#define __LDBL_MIN_10_EXP__ (-307) +// PPC64:#define __LDBL_MIN_EXP__ (-1021) +// PPC64:#define __LDBL_MIN__ 2.2250738585072014e-308 +// PPC64:#define __LONG_DOUBLE_128__ 1 +// PPC64:#define __LONG_LONG_MAX__ 9223372036854775807LL +// PPC64:#define __LONG_MAX__ 9223372036854775807L +// PPC64:#define __LP64__ 1 +// PPC64:#define __NATURAL_ALIGNMENT__ 1 +// PPC64:#define __NO_INLINE__ 1 +// PPC64:#define __POINTER_WIDTH__ 64 +// PPC64:#define __POWERPC__ 1 +// PPC64:#define __PTRDIFF_TYPE__ long int +// PPC64:#define __REGISTER_PREFIX__ +// PPC64:#define __SCHAR_MAX__ 127 +// PPC64:#define __SHRT_MAX__ 32767 +// PPC64:#define __SIZE_TYPE__ long unsigned int +// PPC64:#define __UINTMAX_TYPE__ long unsigned int +// PPC64:#define __USER_LABEL_PREFIX__ _ +// PPC64:#define __WCHAR_MAX__ 2147483647 +// PPC64:#define __WCHAR_TYPE__ int +// PPC64:#define __WINT_TYPE__ int +// PPC64:#define __ppc64__ 1 +// PPC64:#define __ppc__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=powerpc-none-none < /dev/null | FileCheck -check-prefix PPC %s && +// +// PPC:#define _ARCH_PPC 1 +// PPC:#define _BIG_ENDIAN 1 +// PPC:#define __BIG_ENDIAN__ 1 +// PPC:#define __CHAR_BIT__ 8 +// PPC:#define __CHAR_UNSIGNED__ 1 +// PPC:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// PPC:#define __DBL_DIG__ 15 +// PPC:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// PPC:#define __DBL_HAS_DENORM__ 1 +// PPC:#define __DBL_HAS_INFINITY__ 1 +// PPC:#define __DBL_HAS_QUIET_NAN__ 1 +// PPC:#define __DBL_MANT_DIG__ 53 +// PPC:#define __DBL_MAX_10_EXP__ 308 +// PPC:#define __DBL_MAX_EXP__ 1024 +// PPC:#define __DBL_MAX__ 1.7976931348623157e+308 +// PPC:#define __DBL_MIN_10_EXP__ (-307) +// PPC:#define __DBL_MIN_EXP__ (-1021) +// PPC:#define __DBL_MIN__ 2.2250738585072014e-308 +// PPC:#define __DECIMAL_DIG__ 17 +// PPC:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// PPC:#define __FLT_DIG__ 6 +// PPC:#define __FLT_EPSILON__ 1.19209290e-7F +// PPC:#define __FLT_EVAL_METHOD__ 0 +// PPC:#define __FLT_HAS_DENORM__ 1 +// PPC:#define __FLT_HAS_INFINITY__ 1 +// PPC:#define __FLT_HAS_QUIET_NAN__ 1 +// PPC:#define __FLT_MANT_DIG__ 24 +// PPC:#define __FLT_MAX_10_EXP__ 38 +// PPC:#define __FLT_MAX_EXP__ 128 +// PPC:#define __FLT_MAX__ 3.40282347e+38F +// PPC:#define __FLT_MIN_10_EXP__ (-37) +// PPC:#define __FLT_MIN_EXP__ (-125) +// PPC:#define __FLT_MIN__ 1.17549435e-38F +// PPC:#define __FLT_RADIX__ 2 +// PPC:#define __INT16_TYPE__ short +// PPC:#define __INT32_TYPE__ int +// PPC:#define __INT64_TYPE__ long long int +// PPC:#define __INT8_TYPE__ char +// PPC:#define __INTMAX_MAX__ 9223372036854775807LL +// PPC:#define __INTMAX_TYPE__ long long int +// PPC:#define __INTPTR_TYPE__ long int +// PPC:#define __INT_MAX__ 2147483647 +// PPC:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// PPC:#define __LDBL_DIG__ 15 +// PPC:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// PPC:#define __LDBL_HAS_DENORM__ 1 +// PPC:#define __LDBL_HAS_INFINITY__ 1 +// PPC:#define __LDBL_HAS_QUIET_NAN__ 1 +// PPC:#define __LDBL_MANT_DIG__ 53 +// PPC:#define __LDBL_MAX_10_EXP__ 308 +// PPC:#define __LDBL_MAX_EXP__ 1024 +// PPC:#define __LDBL_MAX__ 1.7976931348623157e+308 +// PPC:#define __LDBL_MIN_10_EXP__ (-307) +// PPC:#define __LDBL_MIN_EXP__ (-1021) +// PPC:#define __LDBL_MIN__ 2.2250738585072014e-308 +// PPC:#define __LONG_DOUBLE_128__ 1 +// PPC:#define __LONG_LONG_MAX__ 9223372036854775807LL +// PPC:#define __LONG_MAX__ 2147483647L +// PPC:#define __NATURAL_ALIGNMENT__ 1 +// PPC:#define __NO_INLINE__ 1 +// PPC:#define __POINTER_WIDTH__ 32 +// PPC:#define __POWERPC__ 1 +// PPC:#define __PTRDIFF_TYPE__ long int +// PPC:#define __REGISTER_PREFIX__ +// PPC:#define __SCHAR_MAX__ 127 +// PPC:#define __SHRT_MAX__ 32767 +// PPC:#define __SIZE_TYPE__ long unsigned int +// PPC:#define __UINTMAX_TYPE__ long long unsigned int +// PPC:#define __USER_LABEL_PREFIX__ _ +// PPC:#define __WCHAR_MAX__ 2147483647 +// PPC:#define __WCHAR_TYPE__ int +// PPC:#define __WINT_TYPE__ int +// PPC:#define __ppc__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=s390x-none-none < /dev/null | FileCheck -check-prefix S390X %s && +// +// S390X:#define __CHAR_BIT__ 8 +// S390X:#define __CHAR_UNSIGNED__ 1 +// S390X:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// S390X:#define __DBL_DIG__ 15 +// S390X:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// S390X:#define __DBL_HAS_DENORM__ 1 +// S390X:#define __DBL_HAS_INFINITY__ 1 +// S390X:#define __DBL_HAS_QUIET_NAN__ 1 +// S390X:#define __DBL_MANT_DIG__ 53 +// S390X:#define __DBL_MAX_10_EXP__ 308 +// S390X:#define __DBL_MAX_EXP__ 1024 +// S390X:#define __DBL_MAX__ 1.7976931348623157e+308 +// S390X:#define __DBL_MIN_10_EXP__ (-307) +// S390X:#define __DBL_MIN_EXP__ (-1021) +// S390X:#define __DBL_MIN__ 2.2250738585072014e-308 +// S390X:#define __DECIMAL_DIG__ 17 +// S390X:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// S390X:#define __FLT_DIG__ 6 +// S390X:#define __FLT_EPSILON__ 1.19209290e-7F +// S390X:#define __FLT_EVAL_METHOD__ 0 +// S390X:#define __FLT_HAS_DENORM__ 1 +// S390X:#define __FLT_HAS_INFINITY__ 1 +// S390X:#define __FLT_HAS_QUIET_NAN__ 1 +// S390X:#define __FLT_MANT_DIG__ 24 +// S390X:#define __FLT_MAX_10_EXP__ 38 +// S390X:#define __FLT_MAX_EXP__ 128 +// S390X:#define __FLT_MAX__ 3.40282347e+38F +// S390X:#define __FLT_MIN_10_EXP__ (-37) +// S390X:#define __FLT_MIN_EXP__ (-125) +// S390X:#define __FLT_MIN__ 1.17549435e-38F +// S390X:#define __FLT_RADIX__ 2 +// S390X:#define __INT16_TYPE__ short +// S390X:#define __INT32_TYPE__ int +// S390X:#define __INT64_TYPE__ long long int +// S390X:#define __INT8_TYPE__ char +// S390X:#define __INTMAX_MAX__ 9223372036854775807LL +// S390X:#define __INTMAX_TYPE__ long long int +// S390X:#define __INTPTR_TYPE__ long int +// S390X:#define __INT_MAX__ 2147483647 +// S390X:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// S390X:#define __LDBL_DIG__ 15 +// S390X:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// S390X:#define __LDBL_HAS_DENORM__ 1 +// S390X:#define __LDBL_HAS_INFINITY__ 1 +// S390X:#define __LDBL_HAS_QUIET_NAN__ 1 +// S390X:#define __LDBL_MANT_DIG__ 53 +// S390X:#define __LDBL_MAX_10_EXP__ 308 +// S390X:#define __LDBL_MAX_EXP__ 1024 +// S390X:#define __LDBL_MAX__ 1.7976931348623157e+308 +// S390X:#define __LDBL_MIN_10_EXP__ (-307) +// S390X:#define __LDBL_MIN_EXP__ (-1021) +// S390X:#define __LDBL_MIN__ 2.2250738585072014e-308 +// S390X:#define __LONG_LONG_MAX__ 9223372036854775807LL +// S390X:#define __LONG_MAX__ 9223372036854775807L +// S390X:#define __NO_INLINE__ 1 +// S390X:#define __POINTER_WIDTH__ 64 +// S390X:#define __PTRDIFF_TYPE__ long int +// S390X:#define __SCHAR_MAX__ 127 +// S390X:#define __SHRT_MAX__ 32767 +// S390X:#define __SIZE_TYPE__ long unsigned int +// S390X:#define __UINTMAX_TYPE__ long long unsigned int +// S390X:#define __USER_LABEL_PREFIX__ _ +// S390X:#define __WCHAR_MAX__ 2147483647 +// S390X:#define __WCHAR_TYPE__ int +// S390X:#define __WINT_TYPE__ int +// S390X:#define __s390__ 1 +// S390X:#define __s390x__ 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=sparc-none-none < /dev/null | FileCheck -check-prefix SPARC %s && +// +// SPARC:#define __CHAR_BIT__ 8 +// SPARC:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// SPARC:#define __DBL_DIG__ 15 +// SPARC:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// SPARC:#define __DBL_HAS_DENORM__ 1 +// SPARC:#define __DBL_HAS_INFINITY__ 1 +// SPARC:#define __DBL_HAS_QUIET_NAN__ 1 +// SPARC:#define __DBL_MANT_DIG__ 53 +// SPARC:#define __DBL_MAX_10_EXP__ 308 +// SPARC:#define __DBL_MAX_EXP__ 1024 +// SPARC:#define __DBL_MAX__ 1.7976931348623157e+308 +// SPARC:#define __DBL_MIN_10_EXP__ (-307) +// SPARC:#define __DBL_MIN_EXP__ (-1021) +// SPARC:#define __DBL_MIN__ 2.2250738585072014e-308 +// SPARC:#define __DECIMAL_DIG__ 17 +// SPARC:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// SPARC:#define __FLT_DIG__ 6 +// SPARC:#define __FLT_EPSILON__ 1.19209290e-7F +// SPARC:#define __FLT_EVAL_METHOD__ 0 +// SPARC:#define __FLT_HAS_DENORM__ 1 +// SPARC:#define __FLT_HAS_INFINITY__ 1 +// SPARC:#define __FLT_HAS_QUIET_NAN__ 1 +// SPARC:#define __FLT_MANT_DIG__ 24 +// SPARC:#define __FLT_MAX_10_EXP__ 38 +// SPARC:#define __FLT_MAX_EXP__ 128 +// SPARC:#define __FLT_MAX__ 3.40282347e+38F +// SPARC:#define __FLT_MIN_10_EXP__ (-37) +// SPARC:#define __FLT_MIN_EXP__ (-125) +// SPARC:#define __FLT_MIN__ 1.17549435e-38F +// SPARC:#define __FLT_RADIX__ 2 +// SPARC:#define __INT16_TYPE__ short +// SPARC:#define __INT32_TYPE__ int +// SPARC:#define __INT64_TYPE__ long long int +// SPARC:#define __INT8_TYPE__ char +// SPARC:#define __INTMAX_MAX__ 9223372036854775807LL +// SPARC:#define __INTMAX_TYPE__ long long int +// SPARC:#define __INTPTR_TYPE__ long int +// SPARC:#define __INT_MAX__ 2147483647 +// SPARC:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324 +// SPARC:#define __LDBL_DIG__ 15 +// SPARC:#define __LDBL_EPSILON__ 2.2204460492503131e-16 +// SPARC:#define __LDBL_HAS_DENORM__ 1 +// SPARC:#define __LDBL_HAS_INFINITY__ 1 +// SPARC:#define __LDBL_HAS_QUIET_NAN__ 1 +// SPARC:#define __LDBL_MANT_DIG__ 53 +// SPARC:#define __LDBL_MAX_10_EXP__ 308 +// SPARC:#define __LDBL_MAX_EXP__ 1024 +// SPARC:#define __LDBL_MAX__ 1.7976931348623157e+308 +// SPARC:#define __LDBL_MIN_10_EXP__ (-307) +// SPARC:#define __LDBL_MIN_EXP__ (-1021) +// SPARC:#define __LDBL_MIN__ 2.2250738585072014e-308 +// SPARC:#define __LONG_LONG_MAX__ 9223372036854775807LL +// SPARC:#define __LONG_MAX__ 2147483647L +// SPARC:#define __NO_INLINE__ 1 +// SPARC:#define __POINTER_WIDTH__ 32 +// SPARC:#define __PTRDIFF_TYPE__ long int +// SPARC:#define __REGISTER_PREFIX__ +// SPARC:#define __SCHAR_MAX__ 127 +// SPARC:#define __SHRT_MAX__ 32767 +// SPARC:#define __SIZE_TYPE__ long unsigned int +// SPARC:#define __UINTMAX_TYPE__ long long unsigned int +// SPARC:#define __USER_LABEL_PREFIX__ _ +// SPARC:#define __VERSION__ "4.2.1 Compatible Clang Compiler" +// SPARC:#define __WCHAR_MAX__ 2147483647 +// SPARC:#define __WCHAR_TYPE__ int +// SPARC:#define __WINT_TYPE__ int +// SPARC:#define __sparc 1 +// SPARC:#define __sparc__ 1 +// SPARC:#define __sparcv8 1 +// SPARC:#define sparc 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=tce-none-none < /dev/null | FileCheck -check-prefix TCE %s && +// +// TCE:#define __CHAR_BIT__ 8 +// TCE:#define __DBL_DENORM_MIN__ 1.40129846e-45F +// TCE:#define __DBL_DIG__ 6 +// TCE:#define __DBL_EPSILON__ 1.19209290e-7F +// TCE:#define __DBL_HAS_DENORM__ 1 +// TCE:#define __DBL_HAS_INFINITY__ 1 +// TCE:#define __DBL_HAS_QUIET_NAN__ 1 +// TCE:#define __DBL_MANT_DIG__ 24 +// TCE:#define __DBL_MAX_10_EXP__ 38 +// TCE:#define __DBL_MAX_EXP__ 128 +// TCE:#define __DBL_MAX__ 3.40282347e+38F +// TCE:#define __DBL_MIN_10_EXP__ (-37) +// TCE:#define __DBL_MIN_EXP__ (-125) +// TCE:#define __DBL_MIN__ 1.17549435e-38F +// TCE:#define __DECIMAL_DIG__ -1 +// TCE:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// TCE:#define __FLT_DIG__ 6 +// TCE:#define __FLT_EPSILON__ 1.19209290e-7F +// TCE:#define __FLT_EVAL_METHOD__ 0 +// TCE:#define __FLT_HAS_DENORM__ 1 +// TCE:#define __FLT_HAS_INFINITY__ 1 +// TCE:#define __FLT_HAS_QUIET_NAN__ 1 +// TCE:#define __FLT_MANT_DIG__ 24 +// TCE:#define __FLT_MAX_10_EXP__ 38 +// TCE:#define __FLT_MAX_EXP__ 128 +// TCE:#define __FLT_MAX__ 3.40282347e+38F +// TCE:#define __FLT_MIN_10_EXP__ (-37) +// TCE:#define __FLT_MIN_EXP__ (-125) +// TCE:#define __FLT_MIN__ 1.17549435e-38F +// TCE:#define __FLT_RADIX__ 2 +// TCE:#define __INT16_TYPE__ short +// TCE:#define __INT32_TYPE__ int +// TCE:#define __INT8_TYPE__ char +// TCE:#define __INTMAX_MAX__ 2147483647L +// TCE:#define __INTMAX_TYPE__ long int +// TCE:#define __INTPTR_TYPE__ int +// TCE:#define __INT_MAX__ 2147483647 +// TCE:#define __LDBL_DENORM_MIN__ 1.40129846e-45F +// TCE:#define __LDBL_DIG__ 6 +// TCE:#define __LDBL_EPSILON__ 1.19209290e-7F +// TCE:#define __LDBL_HAS_DENORM__ 1 +// TCE:#define __LDBL_HAS_INFINITY__ 1 +// TCE:#define __LDBL_HAS_QUIET_NAN__ 1 +// TCE:#define __LDBL_MANT_DIG__ 24 +// TCE:#define __LDBL_MAX_10_EXP__ 38 +// TCE:#define __LDBL_MAX_EXP__ 128 +// TCE:#define __LDBL_MAX__ 3.40282347e+38F +// TCE:#define __LDBL_MIN_10_EXP__ (-37) +// TCE:#define __LDBL_MIN_EXP__ (-125) +// TCE:#define __LDBL_MIN__ 1.17549435e-38F +// TCE:#define __LONG_LONG_MAX__ 2147483647LL +// TCE:#define __LONG_MAX__ 2147483647L +// TCE:#define __NO_INLINE__ 1 +// TCE:#define __POINTER_WIDTH__ 32 +// TCE:#define __PTRDIFF_TYPE__ int +// TCE:#define __SCHAR_MAX__ 127 +// TCE:#define __SHRT_MAX__ 32767 +// TCE:#define __SIZE_TYPE__ unsigned int +// TCE:#define __TCE_V1__ 1 +// TCE:#define __TCE__ 1 +// TCE:#define __UINTMAX_TYPE__ long unsigned int +// TCE:#define __USER_LABEL_PREFIX__ _ +// TCE:#define __WCHAR_MAX__ 2147483647 +// TCE:#define __WCHAR_TYPE__ int +// TCE:#define __WINT_TYPE__ int +// TCE:#define __tce 1 +// TCE:#define __tce__ 1 +// TCE:#define tce 1 +// +// RUN: clang-cc -E -dM -ffreestanding -triple=x86_64-none-none < /dev/null | FileCheck -check-prefix X86_64 %s && +// +// X86_64:#define _LP64 1 +// X86_64:#define __CHAR_BIT__ 8 +// X86_64:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// X86_64:#define __DBL_DIG__ 15 +// X86_64:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// X86_64:#define __DBL_HAS_DENORM__ 1 +// X86_64:#define __DBL_HAS_INFINITY__ 1 +// X86_64:#define __DBL_HAS_QUIET_NAN__ 1 +// X86_64:#define __DBL_MANT_DIG__ 53 +// X86_64:#define __DBL_MAX_10_EXP__ 308 +// X86_64:#define __DBL_MAX_EXP__ 1024 +// X86_64:#define __DBL_MAX__ 1.7976931348623157e+308 +// X86_64:#define __DBL_MIN_10_EXP__ (-307) +// X86_64:#define __DBL_MIN_EXP__ (-1021) +// X86_64:#define __DBL_MIN__ 2.2250738585072014e-308 +// X86_64:#define __DECIMAL_DIG__ 21 +// X86_64:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// X86_64:#define __FLT_DIG__ 6 +// X86_64:#define __FLT_EPSILON__ 1.19209290e-7F +// X86_64:#define __FLT_EVAL_METHOD__ 0 +// X86_64:#define __FLT_HAS_DENORM__ 1 +// X86_64:#define __FLT_HAS_INFINITY__ 1 +// X86_64:#define __FLT_HAS_QUIET_NAN__ 1 +// X86_64:#define __FLT_MANT_DIG__ 24 +// X86_64:#define __FLT_MAX_10_EXP__ 38 +// X86_64:#define __FLT_MAX_EXP__ 128 +// X86_64:#define __FLT_MAX__ 3.40282347e+38F +// X86_64:#define __FLT_MIN_10_EXP__ (-37) +// X86_64:#define __FLT_MIN_EXP__ (-125) +// X86_64:#define __FLT_MIN__ 1.17549435e-38F +// X86_64:#define __FLT_RADIX__ 2 +// X86_64:#define __INT16_TYPE__ short +// X86_64:#define __INT32_TYPE__ int +// X86_64:#define __INT64_TYPE__ long int +// X86_64:#define __INT8_TYPE__ char +// X86_64:#define __INTMAX_MAX__ 9223372036854775807L +// X86_64:#define __INTMAX_TYPE__ long int +// X86_64:#define __INTPTR_TYPE__ long int +// X86_64:#define __INT_MAX__ 2147483647 +// X86_64:#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L +// X86_64:#define __LDBL_DIG__ 18 +// X86_64:#define __LDBL_EPSILON__ 1.08420217248550443401e-19L +// X86_64:#define __LDBL_HAS_DENORM__ 1 +// X86_64:#define __LDBL_HAS_INFINITY__ 1 +// X86_64:#define __LDBL_HAS_QUIET_NAN__ 1 +// X86_64:#define __LDBL_MANT_DIG__ 64 +// X86_64:#define __LDBL_MAX_10_EXP__ 4932 +// X86_64:#define __LDBL_MAX_EXP__ 16384 +// X86_64:#define __LDBL_MAX__ 1.18973149535723176502e+4932L +// X86_64:#define __LDBL_MIN_10_EXP__ (-4931) +// X86_64:#define __LDBL_MIN_EXP__ (-16381) +// X86_64:#define __LDBL_MIN__ 3.36210314311209350626e-4932L +// X86_64:#define __LITTLE_ENDIAN__ 1 +// X86_64:#define __LONG_LONG_MAX__ 9223372036854775807LL +// X86_64:#define __LONG_MAX__ 9223372036854775807L +// X86_64:#define __LP64__ 1 +// X86_64:#define __MMX__ 1 +// X86_64:#define __NO_INLINE__ 1 +// X86_64:#define __NO_MATH_INLINES 1 +// X86_64:#define __POINTER_WIDTH__ 64 +// X86_64:#define __PTRDIFF_TYPE__ long int +// X86_64:#define __REGISTER_PREFIX__ +// X86_64:#define __SCHAR_MAX__ 127 +// X86_64:#define __SHRT_MAX__ 32767 +// X86_64:#define __SIZE_TYPE__ long unsigned int +// X86_64:#define __SSE2_MATH__ 1 +// X86_64:#define __SSE2__ 1 +// X86_64:#define __SSE_MATH__ 1 +// X86_64:#define __SSE__ 1 +// X86_64:#define __UINTMAX_TYPE__ long unsigned int +// X86_64:#define __USER_LABEL_PREFIX__ _ +// X86_64:#define __WCHAR_MAX__ 2147483647 +// X86_64:#define __WCHAR_TYPE__ int +// X86_64:#define __WINT_TYPE__ int +// X86_64:#define __amd64 1 +// X86_64:#define __amd64__ 1 +// X86_64:#define __nocona 1 +// X86_64:#define __nocona__ 1 +// X86_64:#define __tune_nocona__ 1 +// X86_64:#define __x86_64 1 +// X86_64:#define __x86_64__ 1 +// +// RUN: true diff --git a/test/Preprocessor/line-directive.c b/test/Preprocessor/line-directive.c index ed9a6c40e5d7..4ebf95bab44c 100644 --- a/test/Preprocessor/line-directive.c +++ b/test/Preprocessor/line-directive.c @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify -pedantic %s && +// RUN: clang-cc -fsyntax-only -verify -pedantic -fms-extensions=0 %s && // RUN: clang-cc -E %s 2>&1 | grep 'blonk.c:92:2: error: #error ABC' && // RUN: clang-cc -E %s 2>&1 | grep 'blonk.c:93:2: error: #error DEF' diff --git a/test/Preprocessor/macro_disable3.c b/test/Preprocessor/macro_disable3.c index 011de3beed3d..d4a5664ae999 100644 --- a/test/Preprocessor/macro_disable3.c +++ b/test/Preprocessor/macro_disable3.c @@ -1,4 +1,4 @@ -// RUN: clang-cc %s -E | grep -F 'f(2 * (f(2 * (z[0]))));' +// RUN: clang-cc %s -E | FileCheck -strict-whitespace %s // Check for C99 6.10.3.4p2. #define f(a) f(x * (a)) @@ -6,3 +6,5 @@ #define z z[0] f(f(z)); +// CHECK: f(2 * (f(2 * (z[0])))); + diff --git a/test/Preprocessor/macro_paste_mscomment.c b/test/Preprocessor/macro_paste_mscomment.c index d6ead91068cf..ecd0b9d6a850 100644 --- a/test/Preprocessor/macro_paste_mscomment.c +++ b/test/Preprocessor/macro_paste_mscomment.c @@ -1,5 +1,4 @@ -// RUN: clang-cc -P -E -fms-extensions %s | sed '/^#.\+/d' | tr -d '\n' > %t && -// RUN: grep '^int foo;int bar;int baz;$' %t | count 1 +// RUN: clang-cc -P -E -fms-extensions %s | FileCheck -strict-whitespace %s // This horrible stuff should preprocess into (other than whitespace): // int foo; // int bar; @@ -7,14 +6,21 @@ int foo; +// CHECK: int foo; + #define comment /##/ dead tokens live here comment This is stupidity int bar; +// CHECK: int bar; + #define nested(x) int x comment cute little dead tokens... nested(baz) rise of the dead tokens ; +// CHECK: int baz +// CHECK: ; + diff --git a/test/Preprocessor/macro_rescan_varargs.c b/test/Preprocessor/macro_rescan_varargs.c index ed1056ab1b3f..8a3ad151141f 100644 --- a/test/Preprocessor/macro_rescan_varargs.c +++ b/test/Preprocessor/macro_rescan_varargs.c @@ -1,5 +1,5 @@ -// RUN: clang-cc -E %s | grep -F "1: F, (, 'a', 'b', );" && -// RUN: clang-cc -E %s | grep -F "2: 'a' + 'b';" +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s + #define LPAREN ( #define RPAREN ) #define F(x, y) x + y @@ -8,3 +8,6 @@ 1: ELLIP_FUNC(F, LPAREN, 'a', 'b', RPAREN); /* 1st invocation */ 2: ELLIP_FUNC(F LPAREN 'a', 'b' RPAREN); /* 2nd invocation */ +// CHECK: 1: F, (, 'a', 'b', ); +// CHECK: 2: 'a' + 'b'; + diff --git a/test/Preprocessor/macro_rparen_scan2.c b/test/Preprocessor/macro_rparen_scan2.c index 41748ac459b9..c7fb9e3b08c9 100644 --- a/test/Preprocessor/macro_rparen_scan2.c +++ b/test/Preprocessor/macro_rparen_scan2.c @@ -1,4 +1,4 @@ -// RUN: clang-cc -E %s | grep -F 'static int glob = (1 + 1 );' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define R_PAREN ) @@ -6,3 +6,5 @@ static int glob = (1 + FUNC(1 R_PAREN ); +// CHECK: static int glob = (1 + 1 ); + diff --git a/test/Preprocessor/macro_undef.c b/test/Preprocessor/macro_undef.c new file mode 100644 index 000000000000..4507cddcb796 --- /dev/null +++ b/test/Preprocessor/macro_undef.c @@ -0,0 +1,4 @@ +// RUN: clang-cc -dM -undef -Dfoo=1 -E %s | FileCheck %s + +// CHECK-NOT: #define __clang__ +// CHECK: #define foo 1 diff --git a/test/Preprocessor/output_paste_avoid.c b/test/Preprocessor/output_paste_avoid.c index ff8afc3e47ac..200ced9fba7a 100644 --- a/test/Preprocessor/output_paste_avoid.c +++ b/test/Preprocessor/output_paste_avoid.c @@ -1,23 +1,26 @@ -// RUN: clang-cc -E %s -o %t && -// This should print as ".. ." to avoid turning into ... -// RUN: grep -F 'A: . . .' %t && +// RUN: clang-cc -E %s -o - | FileCheck -strict-whitespace %s + + #define y(a) ..a A: y(.) +// This should print as ".. ." to avoid turning into ... +// CHECK: A: . . . + -// RUN: grep -F 'C: .. .' %t && #define DOT . C: ..DOT +// CHECK: C: .. . -// RUN: grep -F 'D: + + - - + + = = =' %t && #define PLUS + #define EMPTY #define f(x) =x= D: +PLUS -EMPTY- PLUS+ f(=) +// CHECK: D: + + - - + + = = = -// RUN: grep -F 'E: L "str"' %t -// Should expand to L "str" not L"str" #define test(x) L#x E: test(str) +// Should expand to L "str" not L"str" +// CHECK: E: L "str" diff --git a/test/Preprocessor/stdint.c b/test/Preprocessor/stdint.c new file mode 100644 index 000000000000..e292bd3ec7e5 --- /dev/null +++ b/test/Preprocessor/stdint.c @@ -0,0 +1,1244 @@ +// RUN: clang-cc -E -ffreestanding -triple=arm-none-none %s | FileCheck -check-prefix ARM %s && +// +// ARM:typedef signed char int8_t; +// ARM:typedef short int16_t; +// ARM:typedef int int32_t; +// ARM:typedef long long int int64_t; +// +// ARM:typedef unsigned char uint8_t; +// ARM:typedef int8_t int_least8_t; +// ARM:typedef uint8_t uint_least8_t; +// ARM:typedef int8_t int_fast8_t; +// ARM:typedef uint8_t uint_fast8_t; +// +// ARM:typedef unsigned short uint16_t; +// ARM:typedef int16_t int_least16_t; +// ARM:typedef uint16_t uint_least16_t; +// ARM:typedef int16_t int_fast16_t; +// ARM:typedef uint16_t uint_fast16_t; +// +// ARM:typedef unsigned int uint32_t; +// ARM:typedef int32_t int_least32_t; +// ARM:typedef uint32_t uint_least32_t; +// ARM:typedef int32_t int_fast32_t; +// ARM:typedef uint32_t uint_fast32_t; +// +// ARM:typedef unsigned long long int uint64_t; +// ARM:typedef int64_t int_least64_t; +// ARM:typedef uint64_t uint_least64_t; +// ARM:typedef int64_t int_fast64_t; +// ARM:typedef uint64_t uint_fast64_t; +// +// ARM:typedef long int intptr_t; +// ARM:typedef unsigned long int uintptr_t; +// +// ARM:typedef long long int intmax_t; +// ARM:typedef long long unsigned int uintmax_t; +// +// ARM:INT8_MAX_ 127 +// ARM:INT8_MIN_ (-128) +// ARM:UINT8_MAX_ 255 +// ARM:INT_LEAST8_MIN_ (-128) +// ARM:INT_LEAST8_MAX_ 127 +// ARM:UINT_LEAST8_MAX_ 255 +// ARM:INT_FAST8_MIN_ (-128) +// ARM:INT_FAST8_MAX_ 127 +// ARM:UINT_FAST8_MAX_ 255 +// +// ARM:INT16_MAX_ 32767 +// ARM:INT16_MIN_ (-32768) +// ARM:UINT16_MAX_ 65535 +// ARM:INT_LEAST16_MIN_ (-32768) +// ARM:INT_LEAST16_MAX_ 32767 +// ARM:UINT_LEAST16_MAX_ 65535 +// ARM:INT_FAST16_MIN_ (-32768) +// ARM:INT_FAST16_MAX_ 32767 +// ARM:UINT_FAST16_MAX_ 65535 +// +// ARM:INT32_MAX_ 2147483647 +// ARM:INT32_MIN_ (-2147483647 -1) +// ARM:UINT32_MAX_ 4294967295U +// ARM:INT_LEAST32_MIN_ (-2147483647 -1) +// ARM:INT_LEAST32_MAX_ 2147483647 +// ARM:UINT_LEAST32_MAX_ 4294967295U +// ARM:INT_FAST32_MIN_ (-2147483647 -1) +// ARM:INT_FAST32_MAX_ 2147483647 +// ARM:UINT_FAST32_MAX_ 4294967295U +// +// ARM:INT64_MAX_ 9223372036854775807LL +// ARM:INT64_MIN_ (-9223372036854775807LL -1) +// ARM:UINT64_MAX_ 18446744073709551615ULL +// ARM:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// ARM:INT_LEAST64_MAX_ 9223372036854775807LL +// ARM:UINT_LEAST64_MAX_ 18446744073709551615ULL +// ARM:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// ARM:INT_FAST64_MAX_ 9223372036854775807LL +// ARM:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// ARM:INTPTR_MIN_ (-2147483647 -1) +// ARM:INTPTR_MAX_ 2147483647 +// ARM:UINTPTR_MAX_ 4294967295U +// ARM:PTRDIFF_MIN_ (-2147483647 -1) +// ARM:PTRDIFF_MAX_ 2147483647 +// ARM:SIZE_MAX_ 4294967295U +// +// ARM:INTMAX_MIN_ (-9223372036854775807LL -1) +// ARM:INTMAX_MAX_ 9223372036854775807LL +// ARM:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// ARM:SIG_ATOMIC_MIN_ (-2147483647 -1) +// ARM:SIG_ATOMIC_MAX_ 2147483647 +// ARM:WINT_MIN_ (-2147483647 -1) +// ARM:WINT_MAX_ 2147483647 +// +// ARM:WCHAR_MAX_ 2147483647 +// ARM:WCHAR_MIN_ (-2147483647 -1) +// +// ARM:INT8_C_(0) (0) +// ARM:UINT8_C_(0) (0U) +// ARM:INT16_C_(0) (0) +// ARM:UINT16_C_(0) (0U) +// ARM:INT32_C_(0) (0) +// ARM:UINT32_C_(0) (0U) +// ARM:INT64_C_(0) (0LL) +// ARM:UINT64_C_(0) (0ULL) +// +// ARM:INTMAX_C_(0) (0LL) +// ARM:UINTMAX_C_(0) (0ULL) +// +// +// RUN: clang-cc -E -ffreestanding -triple=bfin-none-none %s | FileCheck -check-prefix BFIN %s && +// +// BFIN:typedef signed char int8_t; +// BFIN:typedef short int16_t; +// BFIN:typedef int int32_t; +// +// BFIN:typedef long long int int64_t; +// +// BFIN:typedef unsigned char uint8_t; +// BFIN:typedef int8_t int_least8_t; +// BFIN:typedef uint8_t uint_least8_t; +// BFIN:typedef int8_t int_fast8_t; +// BFIN:typedef uint8_t uint_fast8_t; +// +// BFIN:typedef unsigned short uint16_t; +// BFIN:typedef int16_t int_least16_t; +// BFIN:typedef uint16_t uint_least16_t; +// BFIN:typedef int16_t int_fast16_t; +// BFIN:typedef uint16_t uint_fast16_t; +// +// BFIN:typedef unsigned int uint32_t; +// BFIN:typedef int32_t int_least32_t; +// BFIN:typedef uint32_t uint_least32_t; +// BFIN:typedef int32_t int_fast32_t; +// BFIN:typedef uint32_t uint_fast32_t; +// +// BFIN:typedef unsigned long long int uint64_t; +// BFIN:typedef int64_t int_least64_t; +// BFIN:typedef uint64_t uint_least64_t; +// BFIN:typedef int64_t int_fast64_t; +// BFIN:typedef uint64_t uint_fast64_t; +// +// BFIN:typedef long int intptr_t; +// BFIN:typedef unsigned long int uintptr_t; +// +// BFIN:typedef long long int intmax_t; +// BFIN:typedef long long unsigned int uintmax_t; +// +// BFIN:INT8_MAX_ 127 +// BFIN:INT8_MIN_ (-128) +// BFIN:UINT8_MAX_ 255 +// BFIN:INT_LEAST8_MIN_ (-128) +// BFIN:INT_LEAST8_MAX_ 127 +// BFIN:UINT_LEAST8_MAX_ 255 +// BFIN:INT_FAST8_MIN_ (-128) +// BFIN:INT_FAST8_MAX_ 127 +// BFIN:UINT_FAST8_MAX_ 255 +// +// BFIN:INT16_MAX_ 32767 +// BFIN:INT16_MIN_ (-32768) +// BFIN:UINT16_MAX_ 65535 +// BFIN:INT_LEAST16_MIN_ (-32768) +// BFIN:INT_LEAST16_MAX_ 32767 +// BFIN:UINT_LEAST16_MAX_ 65535 +// BFIN:INT_FAST16_MIN_ (-32768) +// BFIN:INT_FAST16_MAX_ 32767 +// BFIN:UINT_FAST16_MAX_ 65535 +// +// BFIN:INT32_MAX_ 2147483647 +// BFIN:INT32_MIN_ (-2147483647 -1) +// BFIN:UINT32_MAX_ 4294967295U +// BFIN:INT_LEAST32_MIN_ (-2147483647 -1) +// BFIN:INT_LEAST32_MAX_ 2147483647 +// BFIN:UINT_LEAST32_MAX_ 4294967295U +// BFIN:INT_FAST32_MIN_ (-2147483647 -1) +// BFIN:INT_FAST32_MAX_ 2147483647 +// BFIN:UINT_FAST32_MAX_ 4294967295U +// +// BFIN:INT64_MAX_ 9223372036854775807LL +// BFIN:INT64_MIN_ (-9223372036854775807LL -1) +// BFIN:UINT64_MAX_ 18446744073709551615ULL +// BFIN:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// BFIN:INT_LEAST64_MAX_ 9223372036854775807LL +// BFIN:UINT_LEAST64_MAX_ 18446744073709551615ULL +// BFIN:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// BFIN:INT_FAST64_MAX_ 9223372036854775807LL +// BFIN:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// BFIN:INTPTR_MIN_ (-2147483647 -1) +// BFIN:INTPTR_MAX_ 2147483647 +// BFIN:UINTPTR_MAX_ 4294967295U +// BFIN:PTRDIFF_MIN_ (-2147483647 -1) +// BFIN:PTRDIFF_MAX_ 2147483647 +// BFIN:SIZE_MAX_ 4294967295U +// +// BFIN:INTMAX_MIN_ (-9223372036854775807LL -1) +// BFIN:INTMAX_MAX_ 9223372036854775807LL +// BFIN:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// BFIN:SIG_ATOMIC_MIN_ (-2147483647 -1) +// BFIN:SIG_ATOMIC_MAX_ 2147483647 +// BFIN:WINT_MIN_ (-2147483647 -1) +// BFIN:WINT_MAX_ 2147483647 +// +// BFIN:WCHAR_MAX_ 2147483647 +// BFIN:WCHAR_MIN_ (-2147483647 -1) +// +// BFIN:INT8_C_(0) (0) +// BFIN:UINT8_C_(0) (0U) +// BFIN:INT16_C_(0) (0) +// BFIN:UINT16_C_(0) (0U) +// BFIN:INT32_C_(0) (0) +// BFIN:UINT32_C_(0) (0U) +// BFIN:INT64_C_(0) (0LL) +// BFIN:UINT64_C_(0) (0ULL) +// +// BFIN:INTMAX_C_(0) (0LL) +// BFIN:UINTMAX_C_(0) (0ULL) +// +// +// RUN: clang-cc -E -ffreestanding -triple=i386-none-none %s | FileCheck -check-prefix I386 %s && +// +// I386:typedef signed char int8_t; +// I386:typedef short int16_t; +// I386:typedef int int32_t; +// I386:typedef long long int int64_t; +// +// I386:typedef unsigned char uint8_t; +// I386:typedef int8_t int_least8_t; +// I386:typedef uint8_t uint_least8_t; +// I386:typedef int8_t int_fast8_t; +// I386:typedef uint8_t uint_fast8_t; +// +// I386:typedef unsigned short uint16_t; +// I386:typedef int16_t int_least16_t; +// I386:typedef uint16_t uint_least16_t; +// I386:typedef int16_t int_fast16_t; +// I386:typedef uint16_t uint_fast16_t; +// +// I386:typedef unsigned int uint32_t; +// I386:typedef int32_t int_least32_t; +// I386:typedef uint32_t uint_least32_t; +// I386:typedef int32_t int_fast32_t; +// I386:typedef uint32_t uint_fast32_t; +// +// I386:typedef unsigned long long int uint64_t; +// I386:typedef int64_t int_least64_t; +// I386:typedef uint64_t uint_least64_t; +// I386:typedef int64_t int_fast64_t; +// I386:typedef uint64_t uint_fast64_t; +// +// I386:typedef int intptr_t; +// I386:typedef unsigned int uintptr_t; +// +// I386:typedef long long int intmax_t; +// I386:typedef long long unsigned int uintmax_t; +// +// I386:INT8_MAX_ 127 +// I386:INT8_MIN_ (-128) +// I386:UINT8_MAX_ 255 +// I386:INT_LEAST8_MIN_ (-128) +// I386:INT_LEAST8_MAX_ 127 +// I386:UINT_LEAST8_MAX_ 255 +// I386:INT_FAST8_MIN_ (-128) +// I386:INT_FAST8_MAX_ 127 +// I386:UINT_FAST8_MAX_ 255 +// +// I386:INT16_MAX_ 32767 +// I386:INT16_MIN_ (-32768) +// I386:UINT16_MAX_ 65535 +// I386:INT_LEAST16_MIN_ (-32768) +// I386:INT_LEAST16_MAX_ 32767 +// I386:UINT_LEAST16_MAX_ 65535 +// I386:INT_FAST16_MIN_ (-32768) +// I386:INT_FAST16_MAX_ 32767 +// I386:UINT_FAST16_MAX_ 65535 +// +// I386:INT32_MAX_ 2147483647 +// I386:INT32_MIN_ (-2147483647 -1) +// I386:UINT32_MAX_ 4294967295U +// I386:INT_LEAST32_MIN_ (-2147483647 -1) +// I386:INT_LEAST32_MAX_ 2147483647 +// I386:UINT_LEAST32_MAX_ 4294967295U +// I386:INT_FAST32_MIN_ (-2147483647 -1) +// I386:INT_FAST32_MAX_ 2147483647 +// I386:UINT_FAST32_MAX_ 4294967295U +// +// I386:INT64_MAX_ 9223372036854775807LL +// I386:INT64_MIN_ (-9223372036854775807LL -1) +// I386:UINT64_MAX_ 18446744073709551615ULL +// I386:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// I386:INT_LEAST64_MAX_ 9223372036854775807LL +// I386:UINT_LEAST64_MAX_ 18446744073709551615ULL +// I386:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// I386:INT_FAST64_MAX_ 9223372036854775807LL +// I386:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// I386:INTPTR_MIN_ (-2147483647 -1) +// I386:INTPTR_MAX_ 2147483647 +// I386:UINTPTR_MAX_ 4294967295U +// I386:PTRDIFF_MIN_ (-2147483647 -1) +// I386:PTRDIFF_MAX_ 2147483647 +// I386:SIZE_MAX_ 4294967295U +// +// I386:INTMAX_MIN_ (-9223372036854775807LL -1) +// I386:INTMAX_MAX_ 9223372036854775807LL +// I386:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// I386:SIG_ATOMIC_MIN_ (-2147483647 -1) +// I386:SIG_ATOMIC_MAX_ 2147483647 +// I386:WINT_MIN_ (-2147483647 -1) +// I386:WINT_MAX_ 2147483647 +// +// I386:WCHAR_MAX_ 2147483647 +// I386:WCHAR_MIN_ (-2147483647 -1) +// +// I386:INT8_C_(0) (0) +// I386:UINT8_C_(0) (0U) +// I386:INT16_C_(0) (0) +// I386:UINT16_C_(0) (0U) +// I386:INT32_C_(0) (0) +// I386:UINT32_C_(0) (0U) +// I386:INT64_C_(0) (0LL) +// I386:UINT64_C_(0) (0ULL) +// +// I386:INTMAX_C_(0) (0LL) +// I386:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=msp430-none-none %s | FileCheck -check-prefix MSP430 %s && +// +// MSP430:typedef signed char int8_t; +// MSP430:typedef short int16_t; +// MSP430:typedef long long int32_t; +// +// MSP430:typedef unsigned char uint8_t; +// MSP430:typedef int8_t int_least8_t; +// MSP430:typedef uint8_t uint_least8_t; +// MSP430:typedef int8_t int_fast8_t; +// MSP430:typedef uint8_t uint_fast8_t; +// +// MSP430:typedef unsigned short uint16_t; +// MSP430:typedef int16_t int_least16_t; +// MSP430:typedef uint16_t uint_least16_t; +// MSP430:typedef int16_t int_fast16_t; +// MSP430:typedef uint16_t uint_fast16_t; +// +// MSP430:typedef unsigned long long uint32_t; +// MSP430:typedef int32_t int_least32_t; +// MSP430:typedef uint32_t uint_least32_t; +// MSP430:typedef int32_t int_fast32_t; +// MSP430:typedef uint32_t uint_fast32_t; +// +// MSP430:typedef short intptr_t; +// MSP430:typedef unsigned short uintptr_t; +// +// MSP430:typedef long int intmax_t; +// MSP430:typedef long unsigned int uintmax_t; +// +// MSP430:INT8_MAX_ 127 +// MSP430:INT8_MIN_ (-128) +// MSP430:UINT8_MAX_ 255 +// MSP430:INT_LEAST8_MIN_ (-128) +// MSP430:INT_LEAST8_MAX_ 127 +// MSP430:UINT_LEAST8_MAX_ 255 +// MSP430:INT_FAST8_MIN_ (-128) +// MSP430:INT_FAST8_MAX_ 127 +// MSP430:UINT_FAST8_MAX_ 255 +// +// MSP430:INT16_MAX_ 32767 +// MSP430:INT16_MIN_ (-32768) +// MSP430:UINT16_MAX_ 65535 +// MSP430:INT_LEAST16_MIN_ (-32768) +// MSP430:INT_LEAST16_MAX_ 32767 +// MSP430:UINT_LEAST16_MAX_ 65535 +// MSP430:INT_FAST16_MIN_ (-32768) +// MSP430:INT_FAST16_MAX_ 32767 +// MSP430:UINT_FAST16_MAX_ 65535 +// +// MSP430:INT32_MAX_ 2147483647 +// MSP430:INT32_MIN_ (-2147483647 -1) +// MSP430:UINT32_MAX_ 4294967295U +// MSP430:INT_LEAST32_MIN_ (-2147483647 -1) +// MSP430:INT_LEAST32_MAX_ 2147483647 +// MSP430:UINT_LEAST32_MAX_ 4294967295U +// MSP430:INT_FAST32_MIN_ (-2147483647 -1) +// MSP430:INT_FAST32_MAX_ 2147483647 +// MSP430:UINT_FAST32_MAX_ 4294967295U +// +// MSP430:INT64_MAX_ INT64_MAX +// MSP430:INT64_MIN_ INT64_MIN +// MSP430:UINT64_MAX_ UINT64_MAX +// MSP430:INT_LEAST64_MIN_ INT_LEAST64_MIN +// MSP430:INT_LEAST64_MAX_ INT_LEAST64_MAX +// MSP430:UINT_LEAST64_MAX_ UINT_LEAST64_MAX +// MSP430:INT_FAST64_MIN_ INT_FAST64_MIN +// MSP430:INT_FAST64_MAX_ INT_FAST64_MAX +// MSP430:UINT_FAST64_MAX_ UINT_FAST64_MAX +// +// MSP430:INTPTR_MIN_ (-32768) +// MSP430:INTPTR_MAX_ 32767 +// MSP430:UINTPTR_MAX_ 65535 +// MSP430:PTRDIFF_MIN_ (-32768) +// MSP430:PTRDIFF_MAX_ 32767 +// MSP430:SIZE_MAX_ 65535 +// +// MSP430:INTMAX_MIN_ (-2147483647L -1) +// MSP430:INTMAX_MAX_ 2147483647L +// MSP430:UINTMAX_MAX_ (2147483647L*2ULL +1ULL) +// +// MSP430:SIG_ATOMIC_MIN_ (-2147483647 -1) +// MSP430:SIG_ATOMIC_MAX_ 2147483647 +// MSP430:WINT_MIN_ (-2147483647 -1) +// MSP430:WINT_MAX_ 2147483647 +// +// MSP430:WCHAR_MAX_ 2147483647 +// MSP430:WCHAR_MIN_ (-2147483647 -1) +// +// MSP430:INT8_C_(0) (0) +// MSP430:UINT8_C_(0) (0U) +// MSP430:INT16_C_(0) (0) +// MSP430:UINT16_C_(0) (0U) +// MSP430:INT32_C_(0) (0) +// MSP430:UINT32_C_(0) (0U) +// MSP430:INT64_C_(0) INT64_C(0) +// MSP430:UINT64_C_(0) UINT64_C(0) +// +// MSP430:INTMAX_C_(0) (0LL) +// MSP430:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=pic16-none-none %s | FileCheck -check-prefix PIC16 %s && +// +// PIC16:typedef signed char int8_t; +// PIC16:typedef short int16_t; +// PIC16:typedef long long int32_t; +// +// PIC16:typedef unsigned char uint8_t; +// PIC16:typedef int8_t int_least8_t; +// PIC16:typedef uint8_t uint_least8_t; +// PIC16:typedef int8_t int_fast8_t; +// PIC16:typedef uint8_t uint_fast8_t; +// +// PIC16:typedef unsigned short uint16_t; +// PIC16:typedef int16_t int_least16_t; +// PIC16:typedef uint16_t uint_least16_t; +// PIC16:typedef int16_t int_fast16_t; +// PIC16:typedef uint16_t uint_fast16_t; +// +// PIC16:typedef unsigned long long uint32_t; +// PIC16:typedef int32_t int_least32_t; +// PIC16:typedef uint32_t uint_least32_t; +// PIC16:typedef int32_t int_fast32_t; +// PIC16:typedef uint32_t uint_fast32_t; +// +// PIC16:typedef short intptr_t; +// PIC16:typedef unsigned short uintptr_t; +// +// PIC16:typedef long int intmax_t; +// PIC16:typedef long unsigned int uintmax_t; +// +// PIC16:INT8_MAX_ 127 +// PIC16:INT8_MIN_ (-128) +// PIC16:UINT8_MAX_ 255 +// PIC16:INT_LEAST8_MIN_ (-128) +// PIC16:INT_LEAST8_MAX_ 127 +// PIC16:UINT_LEAST8_MAX_ 255 +// PIC16:INT_FAST8_MIN_ (-128) +// PIC16:INT_FAST8_MAX_ 127 +// PIC16:UINT_FAST8_MAX_ 255 +// +// PIC16:INT16_MAX_ 32767 +// PIC16:INT16_MIN_ (-32768) +// PIC16:UINT16_MAX_ 65535 +// PIC16:INT_LEAST16_MIN_ (-32768) +// PIC16:INT_LEAST16_MAX_ 32767 +// PIC16:UINT_LEAST16_MAX_ 65535 +// PIC16:INT_FAST16_MIN_ (-32768) +// PIC16:INT_FAST16_MAX_ 32767 +// PIC16:UINT_FAST16_MAX_ 65535 +// +// PIC16:INT32_MAX_ 2147483647 +// PIC16:INT32_MIN_ (-2147483647 -1) +// PIC16:UINT32_MAX_ 4294967295U +// PIC16:INT_LEAST32_MIN_ (-2147483647 -1) +// PIC16:INT_LEAST32_MAX_ 2147483647 +// PIC16:UINT_LEAST32_MAX_ 4294967295U +// PIC16:INT_FAST32_MIN_ (-2147483647 -1) +// PIC16:INT_FAST32_MAX_ 2147483647 +// PIC16:UINT_FAST32_MAX_ 4294967295U +// +// PIC16:INT64_MAX_ INT64_MAX +// PIC16:INT64_MIN_ INT64_MIN +// PIC16:UINT64_MAX_ UINT64_MAX +// PIC16:INT_LEAST64_MIN_ INT_LEAST64_MIN +// PIC16:INT_LEAST64_MAX_ INT_LEAST64_MAX +// PIC16:UINT_LEAST64_MAX_ UINT_LEAST64_MAX +// PIC16:INT_FAST64_MIN_ INT_FAST64_MIN +// PIC16:INT_FAST64_MAX_ INT_FAST64_MAX +// PIC16:UINT_FAST64_MAX_ UINT_FAST64_MAX +// +// PIC16:INTPTR_MIN_ (-32768) +// PIC16:INTPTR_MAX_ 32767 +// PIC16:UINTPTR_MAX_ 65535 +// PIC16:PTRDIFF_MIN_ (-32768) +// PIC16:PTRDIFF_MAX_ 32767 +// PIC16:SIZE_MAX_ 65535 +// +// PIC16:INTMAX_MIN_ (-2147483647L -1) +// PIC16:INTMAX_MAX_ 2147483647L +// PIC16:UINTMAX_MAX_ (2147483647L*2ULL +1ULL) +// +// PIC16:SIG_ATOMIC_MIN_ (-2147483647 -1) +// PIC16:SIG_ATOMIC_MAX_ 2147483647 +// PIC16:WINT_MIN_ (-2147483647 -1) +// PIC16:WINT_MAX_ 2147483647 +// +// PIC16:WCHAR_MAX_ 2147483647 +// PIC16:WCHAR_MIN_ (-2147483647 -1) +// +// PIC16:INT8_C_(0) (0) +// PIC16:UINT8_C_(0) (0U) +// PIC16:INT16_C_(0) (0) +// PIC16:UINT16_C_(0) (0U) +// PIC16:INT32_C_(0) (0) +// PIC16:UINT32_C_(0) (0U) +// PIC16:INT64_C_(0) INT64_C(0) +// PIC16:UINT64_C_(0) UINT64_C(0) +// +// PIC16:INTMAX_C_(0) (0LL) +// PIC16:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=powerpc64-none-none %s | FileCheck -check-prefix PPC64 %s && +// +// PPC64:typedef signed char int8_t; +// PPC64:typedef short int16_t; +// PPC64:typedef int int32_t; +// PPC64:typedef long int int64_t; +// +// PPC64:typedef unsigned char uint8_t; +// PPC64:typedef int8_t int_least8_t; +// PPC64:typedef uint8_t uint_least8_t; +// PPC64:typedef int8_t int_fast8_t; +// PPC64:typedef uint8_t uint_fast8_t; +// +// PPC64:typedef unsigned short uint16_t; +// PPC64:typedef int16_t int_least16_t; +// PPC64:typedef uint16_t uint_least16_t; +// PPC64:typedef int16_t int_fast16_t; +// PPC64:typedef uint16_t uint_fast16_t; +// +// PPC64:typedef unsigned int uint32_t; +// PPC64:typedef int32_t int_least32_t; +// PPC64:typedef uint32_t uint_least32_t; +// PPC64:typedef int32_t int_fast32_t; +// PPC64:typedef uint32_t uint_fast32_t; +// +// PPC64:typedef unsigned long int uint64_t; +// PPC64:typedef int64_t int_least64_t; +// PPC64:typedef uint64_t uint_least64_t; +// PPC64:typedef int64_t int_fast64_t; +// PPC64:typedef uint64_t uint_fast64_t; +// +// PPC64:typedef long int intptr_t; +// PPC64:typedef unsigned long int uintptr_t; +// +// PPC64:typedef long int intmax_t; +// PPC64:typedef long unsigned int uintmax_t; +// +// PPC64:INT8_MAX_ 127 +// PPC64:INT8_MIN_ (-128) +// PPC64:UINT8_MAX_ 255 +// PPC64:INT_LEAST8_MIN_ (-128) +// PPC64:INT_LEAST8_MAX_ 127 +// PPC64:UINT_LEAST8_MAX_ 255 +// PPC64:INT_FAST8_MIN_ (-128) +// PPC64:INT_FAST8_MAX_ 127 +// PPC64:UINT_FAST8_MAX_ 255 +// +// PPC64:INT16_MAX_ 32767 +// PPC64:INT16_MIN_ (-32768) +// PPC64:UINT16_MAX_ 65535 +// PPC64:INT_LEAST16_MIN_ (-32768) +// PPC64:INT_LEAST16_MAX_ 32767 +// PPC64:UINT_LEAST16_MAX_ 65535 +// PPC64:INT_FAST16_MIN_ (-32768) +// PPC64:INT_FAST16_MAX_ 32767 +// PPC64:UINT_FAST16_MAX_ 65535 +// +// PPC64:INT32_MAX_ 2147483647 +// PPC64:INT32_MIN_ (-2147483647 -1) +// PPC64:UINT32_MAX_ 4294967295U +// PPC64:INT_LEAST32_MIN_ (-2147483647 -1) +// PPC64:INT_LEAST32_MAX_ 2147483647 +// PPC64:UINT_LEAST32_MAX_ 4294967295U +// PPC64:INT_FAST32_MIN_ (-2147483647 -1) +// PPC64:INT_FAST32_MAX_ 2147483647 +// PPC64:UINT_FAST32_MAX_ 4294967295U +// +// PPC64:INT64_MAX_ 9223372036854775807LL +// PPC64:INT64_MIN_ (-9223372036854775807LL -1) +// PPC64:UINT64_MAX_ 18446744073709551615ULL +// PPC64:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// PPC64:INT_LEAST64_MAX_ 9223372036854775807LL +// PPC64:UINT_LEAST64_MAX_ 18446744073709551615ULL +// PPC64:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// PPC64:INT_FAST64_MAX_ 9223372036854775807LL +// PPC64:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// PPC64:INTPTR_MIN_ (-9223372036854775807LL -1) +// PPC64:INTPTR_MAX_ 9223372036854775807LL +// PPC64:UINTPTR_MAX_ 18446744073709551615ULL +// PPC64:PTRDIFF_MIN_ (-9223372036854775807LL -1) +// PPC64:PTRDIFF_MAX_ 9223372036854775807LL +// PPC64:SIZE_MAX_ 18446744073709551615ULL +// +// PPC64:INTMAX_MIN_ (-9223372036854775807L -1) +// PPC64:INTMAX_MAX_ 9223372036854775807L +// PPC64:UINTMAX_MAX_ (9223372036854775807L*2ULL +1ULL) +// +// PPC64:SIG_ATOMIC_MIN_ (-2147483647 -1) +// PPC64:SIG_ATOMIC_MAX_ 2147483647 +// PPC64:WINT_MIN_ (-2147483647 -1) +// PPC64:WINT_MAX_ 2147483647 +// +// PPC64:WCHAR_MAX_ 2147483647 +// PPC64:WCHAR_MIN_ (-2147483647 -1) +// +// PPC64:INT8_C_(0) (0) +// PPC64:UINT8_C_(0) (0U) +// PPC64:INT16_C_(0) (0) +// PPC64:UINT16_C_(0) (0U) +// PPC64:INT32_C_(0) (0) +// PPC64:UINT32_C_(0) (0U) +// PPC64:INT64_C_(0) (0LL) +// PPC64:UINT64_C_(0) (0ULL) +// +// PPC64:INTMAX_C_(0) (0LL) +// PPC64:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=powerpc-none-none %s | FileCheck -check-prefix PPC %s && +// +// PPC:typedef signed char int8_t; +// PPC:typedef short int16_t; +// PPC:typedef int int32_t; +// PPC:typedef long long int int64_t; +// +// PPC:typedef unsigned char uint8_t; +// PPC:typedef int8_t int_least8_t; +// PPC:typedef uint8_t uint_least8_t; +// PPC:typedef int8_t int_fast8_t; +// PPC:typedef uint8_t uint_fast8_t; +// +// PPC:typedef unsigned short uint16_t; +// PPC:typedef int16_t int_least16_t; +// PPC:typedef uint16_t uint_least16_t; +// PPC:typedef int16_t int_fast16_t; +// PPC:typedef uint16_t uint_fast16_t; +// +// PPC:typedef unsigned int uint32_t; +// PPC:typedef int32_t int_least32_t; +// PPC:typedef uint32_t uint_least32_t; +// PPC:typedef int32_t int_fast32_t; +// PPC:typedef uint32_t uint_fast32_t; +// +// PPC:typedef unsigned long long int uint64_t; +// PPC:typedef int64_t int_least64_t; +// PPC:typedef uint64_t uint_least64_t; +// PPC:typedef int64_t int_fast64_t; +// PPC:typedef uint64_t uint_fast64_t; +// +// PPC:typedef long int intptr_t; +// PPC:typedef unsigned long int uintptr_t; +// +// PPC:typedef long long int intmax_t; +// PPC:typedef long long unsigned int uintmax_t; +// +// PPC:INT8_MAX_ 127 +// PPC:INT8_MIN_ (-128) +// PPC:UINT8_MAX_ 255 +// PPC:INT_LEAST8_MIN_ (-128) +// PPC:INT_LEAST8_MAX_ 127 +// PPC:UINT_LEAST8_MAX_ 255 +// PPC:INT_FAST8_MIN_ (-128) +// PPC:INT_FAST8_MAX_ 127 +// PPC:UINT_FAST8_MAX_ 255 +// +// PPC:INT16_MAX_ 32767 +// PPC:INT16_MIN_ (-32768) +// PPC:UINT16_MAX_ 65535 +// PPC:INT_LEAST16_MIN_ (-32768) +// PPC:INT_LEAST16_MAX_ 32767 +// PPC:UINT_LEAST16_MAX_ 65535 +// PPC:INT_FAST16_MIN_ (-32768) +// PPC:INT_FAST16_MAX_ 32767 +// PPC:UINT_FAST16_MAX_ 65535 +// +// PPC:INT32_MAX_ 2147483647 +// PPC:INT32_MIN_ (-2147483647 -1) +// PPC:UINT32_MAX_ 4294967295U +// PPC:INT_LEAST32_MIN_ (-2147483647 -1) +// PPC:INT_LEAST32_MAX_ 2147483647 +// PPC:UINT_LEAST32_MAX_ 4294967295U +// PPC:INT_FAST32_MIN_ (-2147483647 -1) +// PPC:INT_FAST32_MAX_ 2147483647 +// PPC:UINT_FAST32_MAX_ 4294967295U +// +// PPC:INT64_MAX_ 9223372036854775807LL +// PPC:INT64_MIN_ (-9223372036854775807LL -1) +// PPC:UINT64_MAX_ 18446744073709551615ULL +// PPC:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// PPC:INT_LEAST64_MAX_ 9223372036854775807LL +// PPC:UINT_LEAST64_MAX_ 18446744073709551615ULL +// PPC:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// PPC:INT_FAST64_MAX_ 9223372036854775807LL +// PPC:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// PPC:INTPTR_MIN_ (-2147483647 -1) +// PPC:INTPTR_MAX_ 2147483647 +// PPC:UINTPTR_MAX_ 4294967295U +// PPC:PTRDIFF_MIN_ (-2147483647 -1) +// PPC:PTRDIFF_MAX_ 2147483647 +// PPC:SIZE_MAX_ 4294967295U +// +// PPC:INTMAX_MIN_ (-9223372036854775807LL -1) +// PPC:INTMAX_MAX_ 9223372036854775807LL +// PPC:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// PPC:SIG_ATOMIC_MIN_ (-2147483647 -1) +// PPC:SIG_ATOMIC_MAX_ 2147483647 +// PPC:WINT_MIN_ (-2147483647 -1) +// PPC:WINT_MAX_ 2147483647 +// +// PPC:WCHAR_MAX_ 2147483647 +// PPC:WCHAR_MIN_ (-2147483647 -1) +// +// PPC:INT8_C_(0) (0) +// PPC:UINT8_C_(0) (0U) +// PPC:INT16_C_(0) (0) +// PPC:UINT16_C_(0) (0U) +// PPC:INT32_C_(0) (0) +// PPC:UINT32_C_(0) (0U) +// PPC:INT64_C_(0) (0LL) +// PPC:UINT64_C_(0) (0ULL) +// +// PPC:INTMAX_C_(0) (0LL) +// PPC:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=s390x-none-none %s | FileCheck -check-prefix S390X %s && +// +// S390X:typedef signed char int8_t; +// S390X:typedef short int16_t; +// S390X:typedef int int32_t; +// S390X:typedef long long int int64_t; +// +// S390X:typedef unsigned char uint8_t; +// S390X:typedef int8_t int_least8_t; +// S390X:typedef uint8_t uint_least8_t; +// S390X:typedef int8_t int_fast8_t; +// S390X:typedef uint8_t uint_fast8_t; +// +// S390X:typedef unsigned short uint16_t; +// S390X:typedef int16_t int_least16_t; +// S390X:typedef uint16_t uint_least16_t; +// S390X:typedef int16_t int_fast16_t; +// S390X:typedef uint16_t uint_fast16_t; +// +// S390X:typedef unsigned int uint32_t; +// S390X:typedef int32_t int_least32_t; +// S390X:typedef uint32_t uint_least32_t; +// S390X:typedef int32_t int_fast32_t; +// S390X:typedef uint32_t uint_fast32_t; +// +// S390X:typedef unsigned long long int uint64_t; +// S390X:typedef int64_t int_least64_t; +// S390X:typedef uint64_t uint_least64_t; +// S390X:typedef int64_t int_fast64_t; +// S390X:typedef uint64_t uint_fast64_t; +// +// S390X:typedef long int intptr_t; +// S390X:typedef unsigned long int uintptr_t; +// +// S390X:typedef long long int intmax_t; +// S390X:typedef long long unsigned int uintmax_t; +// +// S390X:INT8_MAX_ 127 +// S390X:INT8_MIN_ (-128) +// S390X:UINT8_MAX_ 255 +// S390X:INT_LEAST8_MIN_ (-128) +// S390X:INT_LEAST8_MAX_ 127 +// S390X:UINT_LEAST8_MAX_ 255 +// S390X:INT_FAST8_MIN_ (-128) +// S390X:INT_FAST8_MAX_ 127 +// S390X:UINT_FAST8_MAX_ 255 +// +// S390X:INT16_MAX_ 32767 +// S390X:INT16_MIN_ (-32768) +// S390X:UINT16_MAX_ 65535 +// S390X:INT_LEAST16_MIN_ (-32768) +// S390X:INT_LEAST16_MAX_ 32767 +// S390X:UINT_LEAST16_MAX_ 65535 +// S390X:INT_FAST16_MIN_ (-32768) +// S390X:INT_FAST16_MAX_ 32767 +// S390X:UINT_FAST16_MAX_ 65535 +// +// S390X:INT32_MAX_ 2147483647 +// S390X:INT32_MIN_ (-2147483647 -1) +// S390X:UINT32_MAX_ 4294967295U +// S390X:INT_LEAST32_MIN_ (-2147483647 -1) +// S390X:INT_LEAST32_MAX_ 2147483647 +// S390X:UINT_LEAST32_MAX_ 4294967295U +// S390X:INT_FAST32_MIN_ (-2147483647 -1) +// S390X:INT_FAST32_MAX_ 2147483647 +// S390X:UINT_FAST32_MAX_ 4294967295U +// +// S390X:INT64_MAX_ 9223372036854775807LL +// S390X:INT64_MIN_ (-9223372036854775807LL -1) +// S390X:UINT64_MAX_ 18446744073709551615ULL +// S390X:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// S390X:INT_LEAST64_MAX_ 9223372036854775807LL +// S390X:UINT_LEAST64_MAX_ 18446744073709551615ULL +// S390X:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// S390X:INT_FAST64_MAX_ 9223372036854775807LL +// S390X:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// S390X:INTPTR_MIN_ (-9223372036854775807LL -1) +// S390X:INTPTR_MAX_ 9223372036854775807LL +// S390X:UINTPTR_MAX_ 18446744073709551615ULL +// S390X:PTRDIFF_MIN_ (-9223372036854775807LL -1) +// S390X:PTRDIFF_MAX_ 9223372036854775807LL +// S390X:SIZE_MAX_ 18446744073709551615ULL +// +// S390X:INTMAX_MIN_ (-9223372036854775807LL -1) +// S390X:INTMAX_MAX_ 9223372036854775807LL +// S390X:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// S390X:SIG_ATOMIC_MIN_ (-2147483647 -1) +// S390X:SIG_ATOMIC_MAX_ 2147483647 +// S390X:WINT_MIN_ (-2147483647 -1) +// S390X:WINT_MAX_ 2147483647 +// +// S390X:WCHAR_MAX_ 2147483647 +// S390X:WCHAR_MIN_ (-2147483647 -1) +// +// S390X:INT8_C_(0) (0) +// S390X:UINT8_C_(0) (0U) +// S390X:INT16_C_(0) (0) +// S390X:UINT16_C_(0) (0U) +// S390X:INT32_C_(0) (0) +// S390X:UINT32_C_(0) (0U) +// S390X:INT64_C_(0) (0LL) +// S390X:UINT64_C_(0) (0ULL) +// +// S390X:INTMAX_C_(0) (0LL) +// S390X:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=sparc-none-none %s | FileCheck -check-prefix SPARC %s && +// +// SPARC:typedef signed char int8_t; +// SPARC:typedef short int16_t; +// SPARC:typedef int int32_t; +// SPARC:typedef long long int int64_t; +// +// SPARC:typedef unsigned char uint8_t; +// SPARC:typedef int8_t int_least8_t; +// SPARC:typedef uint8_t uint_least8_t; +// SPARC:typedef int8_t int_fast8_t; +// SPARC:typedef uint8_t uint_fast8_t; +// +// SPARC:typedef unsigned short uint16_t; +// SPARC:typedef int16_t int_least16_t; +// SPARC:typedef uint16_t uint_least16_t; +// SPARC:typedef int16_t int_fast16_t; +// SPARC:typedef uint16_t uint_fast16_t; +// +// SPARC:typedef unsigned int uint32_t; +// SPARC:typedef int32_t int_least32_t; +// SPARC:typedef uint32_t uint_least32_t; +// SPARC:typedef int32_t int_fast32_t; +// SPARC:typedef uint32_t uint_fast32_t; +// +// SPARC:typedef unsigned long long int uint64_t; +// SPARC:typedef int64_t int_least64_t; +// SPARC:typedef uint64_t uint_least64_t; +// SPARC:typedef int64_t int_fast64_t; +// SPARC:typedef uint64_t uint_fast64_t; +// +// SPARC:typedef long int intptr_t; +// SPARC:typedef unsigned long int uintptr_t; +// +// SPARC:typedef long long int intmax_t; +// SPARC:typedef long long unsigned int uintmax_t; +// +// SPARC:INT8_MAX_ 127 +// SPARC:INT8_MIN_ (-128) +// SPARC:UINT8_MAX_ 255 +// SPARC:INT_LEAST8_MIN_ (-128) +// SPARC:INT_LEAST8_MAX_ 127 +// SPARC:UINT_LEAST8_MAX_ 255 +// SPARC:INT_FAST8_MIN_ (-128) +// SPARC:INT_FAST8_MAX_ 127 +// SPARC:UINT_FAST8_MAX_ 255 +// +// SPARC:INT16_MAX_ 32767 +// SPARC:INT16_MIN_ (-32768) +// SPARC:UINT16_MAX_ 65535 +// SPARC:INT_LEAST16_MIN_ (-32768) +// SPARC:INT_LEAST16_MAX_ 32767 +// SPARC:UINT_LEAST16_MAX_ 65535 +// SPARC:INT_FAST16_MIN_ (-32768) +// SPARC:INT_FAST16_MAX_ 32767 +// SPARC:UINT_FAST16_MAX_ 65535 +// +// SPARC:INT32_MAX_ 2147483647 +// SPARC:INT32_MIN_ (-2147483647 -1) +// SPARC:UINT32_MAX_ 4294967295U +// SPARC:INT_LEAST32_MIN_ (-2147483647 -1) +// SPARC:INT_LEAST32_MAX_ 2147483647 +// SPARC:UINT_LEAST32_MAX_ 4294967295U +// SPARC:INT_FAST32_MIN_ (-2147483647 -1) +// SPARC:INT_FAST32_MAX_ 2147483647 +// SPARC:UINT_FAST32_MAX_ 4294967295U +// +// SPARC:INT64_MAX_ 9223372036854775807LL +// SPARC:INT64_MIN_ (-9223372036854775807LL -1) +// SPARC:UINT64_MAX_ 18446744073709551615ULL +// SPARC:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// SPARC:INT_LEAST64_MAX_ 9223372036854775807LL +// SPARC:UINT_LEAST64_MAX_ 18446744073709551615ULL +// SPARC:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// SPARC:INT_FAST64_MAX_ 9223372036854775807LL +// SPARC:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// SPARC:INTPTR_MIN_ (-2147483647 -1) +// SPARC:INTPTR_MAX_ 2147483647 +// SPARC:UINTPTR_MAX_ 4294967295U +// SPARC:PTRDIFF_MIN_ (-2147483647 -1) +// SPARC:PTRDIFF_MAX_ 2147483647 +// SPARC:SIZE_MAX_ 4294967295U +// +// SPARC:INTMAX_MIN_ (-9223372036854775807LL -1) +// SPARC:INTMAX_MAX_ 9223372036854775807LL +// SPARC:UINTMAX_MAX_ (9223372036854775807LL*2ULL +1ULL) +// +// SPARC:SIG_ATOMIC_MIN_ (-2147483647 -1) +// SPARC:SIG_ATOMIC_MAX_ 2147483647 +// SPARC:WINT_MIN_ (-2147483647 -1) +// SPARC:WINT_MAX_ 2147483647 +// +// SPARC:WCHAR_MAX_ 2147483647 +// SPARC:WCHAR_MIN_ (-2147483647 -1) +// +// SPARC:INT8_C_(0) (0) +// SPARC:UINT8_C_(0) (0U) +// SPARC:INT16_C_(0) (0) +// SPARC:UINT16_C_(0) (0U) +// SPARC:INT32_C_(0) (0) +// SPARC:UINT32_C_(0) (0U) +// SPARC:INT64_C_(0) (0LL) +// SPARC:UINT64_C_(0) (0ULL) +// +// SPARC:INTMAX_C_(0) (0LL) +// SPARC:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=tce-none-none %s | FileCheck -check-prefix TCE %s && +// +// TCE:typedef signed char int8_t; +// TCE:typedef short int16_t; +// TCE:typedef int int32_t; +// +// TCE:typedef unsigned char uint8_t; +// TCE:typedef int8_t int_least8_t; +// TCE:typedef uint8_t uint_least8_t; +// TCE:typedef int8_t int_fast8_t; +// TCE:typedef uint8_t uint_fast8_t; +// +// TCE:typedef unsigned short uint16_t; +// TCE:typedef int16_t int_least16_t; +// TCE:typedef uint16_t uint_least16_t; +// TCE:typedef int16_t int_fast16_t; +// TCE:typedef uint16_t uint_fast16_t; +// +// TCE:typedef unsigned int uint32_t; +// TCE:typedef int32_t int_least32_t; +// TCE:typedef uint32_t uint_least32_t; +// TCE:typedef int32_t int_fast32_t; +// TCE:typedef uint32_t uint_fast32_t; +// +// TCE:typedef int intptr_t; +// TCE:typedef unsigned int uintptr_t; +// +// TCE:typedef long int intmax_t; +// TCE:typedef long unsigned int uintmax_t; +// +// TCE:INT8_MAX_ 127 +// TCE:INT8_MIN_ (-128) +// TCE:UINT8_MAX_ 255 +// TCE:INT_LEAST8_MIN_ (-128) +// TCE:INT_LEAST8_MAX_ 127 +// TCE:UINT_LEAST8_MAX_ 255 +// TCE:INT_FAST8_MIN_ (-128) +// TCE:INT_FAST8_MAX_ 127 +// TCE:UINT_FAST8_MAX_ 255 +// +// TCE:INT16_MAX_ 32767 +// TCE:INT16_MIN_ (-32768) +// TCE:UINT16_MAX_ 65535 +// TCE:INT_LEAST16_MIN_ (-32768) +// TCE:INT_LEAST16_MAX_ 32767 +// TCE:UINT_LEAST16_MAX_ 65535 +// TCE:INT_FAST16_MIN_ (-32768) +// TCE:INT_FAST16_MAX_ 32767 +// TCE:UINT_FAST16_MAX_ 65535 +// +// TCE:INT32_MAX_ 2147483647 +// TCE:INT32_MIN_ (-2147483647 -1) +// TCE:UINT32_MAX_ 4294967295U +// TCE:INT_LEAST32_MIN_ (-2147483647 -1) +// TCE:INT_LEAST32_MAX_ 2147483647 +// TCE:UINT_LEAST32_MAX_ 4294967295U +// TCE:INT_FAST32_MIN_ (-2147483647 -1) +// TCE:INT_FAST32_MAX_ 2147483647 +// TCE:UINT_FAST32_MAX_ 4294967295U +// +// TCE:INT64_MAX_ INT64_MAX +// TCE:INT64_MIN_ INT64_MIN +// TCE:UINT64_MAX_ UINT64_MAX +// TCE:INT_LEAST64_MIN_ INT_LEAST64_MIN +// TCE:INT_LEAST64_MAX_ INT_LEAST64_MAX +// TCE:UINT_LEAST64_MAX_ UINT_LEAST64_MAX +// TCE:INT_FAST64_MIN_ INT_FAST64_MIN +// TCE:INT_FAST64_MAX_ INT_FAST64_MAX +// TCE:UINT_FAST64_MAX_ UINT_FAST64_MAX +// +// TCE:INTPTR_MIN_ (-2147483647 -1) +// TCE:INTPTR_MAX_ 2147483647 +// TCE:UINTPTR_MAX_ 4294967295U +// TCE:PTRDIFF_MIN_ (-2147483647 -1) +// TCE:PTRDIFF_MAX_ 2147483647 +// TCE:SIZE_MAX_ 4294967295U +// +// TCE:INTMAX_MIN_ (-2147483647L -1) +// TCE:INTMAX_MAX_ 2147483647L +// TCE:UINTMAX_MAX_ (2147483647L*2ULL +1ULL) +// +// TCE:SIG_ATOMIC_MIN_ (-2147483647 -1) +// TCE:SIG_ATOMIC_MAX_ 2147483647 +// TCE:WINT_MIN_ (-2147483647 -1) +// TCE:WINT_MAX_ 2147483647 +// +// TCE:WCHAR_MAX_ 2147483647 +// TCE:WCHAR_MIN_ (-2147483647 -1) +// +// TCE:INT8_C_(0) (0) +// TCE:UINT8_C_(0) (0U) +// TCE:INT16_C_(0) (0) +// TCE:UINT16_C_(0) (0U) +// TCE:INT32_C_(0) (0) +// TCE:UINT32_C_(0) (0U) +// TCE:INT64_C_(0) INT64_C(0) +// TCE:UINT64_C_(0) UINT64_C(0) +// +// TCE:INTMAX_C_(0) (0LL) +// TCE:UINTMAX_C_(0) (0ULL) +// +// RUN: clang-cc -E -ffreestanding -triple=x86_64-none-none %s | FileCheck -check-prefix X86_64 %s && +// +// X86_64:typedef signed char int8_t; +// X86_64:typedef short int16_t; +// X86_64:typedef int int32_t; +// X86_64:typedef long int int64_t; +// +// X86_64:typedef unsigned char uint8_t; +// X86_64:typedef int8_t int_least8_t; +// X86_64:typedef uint8_t uint_least8_t; +// X86_64:typedef int8_t int_fast8_t; +// X86_64:typedef uint8_t uint_fast8_t; +// +// X86_64:typedef unsigned short uint16_t; +// X86_64:typedef int16_t int_least16_t; +// X86_64:typedef uint16_t uint_least16_t; +// X86_64:typedef int16_t int_fast16_t; +// X86_64:typedef uint16_t uint_fast16_t; +// +// X86_64:typedef unsigned int uint32_t; +// X86_64:typedef int32_t int_least32_t; +// X86_64:typedef uint32_t uint_least32_t; +// X86_64:typedef int32_t int_fast32_t; +// X86_64:typedef uint32_t uint_fast32_t; +// +// X86_64:typedef unsigned long int uint64_t; +// X86_64:typedef int64_t int_least64_t; +// X86_64:typedef uint64_t uint_least64_t; +// X86_64:typedef int64_t int_fast64_t; +// X86_64:typedef uint64_t uint_fast64_t; +// +// X86_64:typedef long int intptr_t; +// X86_64:typedef unsigned long int uintptr_t; +// +// X86_64:typedef long int intmax_t; +// X86_64:typedef long unsigned int uintmax_t; +// +// X86_64:INT8_MAX_ 127 +// X86_64:INT8_MIN_ (-128) +// X86_64:UINT8_MAX_ 255 +// X86_64:INT_LEAST8_MIN_ (-128) +// X86_64:INT_LEAST8_MAX_ 127 +// X86_64:UINT_LEAST8_MAX_ 255 +// X86_64:INT_FAST8_MIN_ (-128) +// X86_64:INT_FAST8_MAX_ 127 +// X86_64:UINT_FAST8_MAX_ 255 +// +// X86_64:INT16_MAX_ 32767 +// X86_64:INT16_MIN_ (-32768) +// X86_64:UINT16_MAX_ 65535 +// X86_64:INT_LEAST16_MIN_ (-32768) +// X86_64:INT_LEAST16_MAX_ 32767 +// X86_64:UINT_LEAST16_MAX_ 65535 +// X86_64:INT_FAST16_MIN_ (-32768) +// X86_64:INT_FAST16_MAX_ 32767 +// X86_64:UINT_FAST16_MAX_ 65535 +// +// X86_64:INT32_MAX_ 2147483647 +// X86_64:INT32_MIN_ (-2147483647 -1) +// X86_64:UINT32_MAX_ 4294967295U +// X86_64:INT_LEAST32_MIN_ (-2147483647 -1) +// X86_64:INT_LEAST32_MAX_ 2147483647 +// X86_64:UINT_LEAST32_MAX_ 4294967295U +// X86_64:INT_FAST32_MIN_ (-2147483647 -1) +// X86_64:INT_FAST32_MAX_ 2147483647 +// X86_64:UINT_FAST32_MAX_ 4294967295U +// +// X86_64:INT64_MAX_ 9223372036854775807LL +// X86_64:INT64_MIN_ (-9223372036854775807LL -1) +// X86_64:UINT64_MAX_ 18446744073709551615ULL +// X86_64:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// X86_64:INT_LEAST64_MAX_ 9223372036854775807LL +// X86_64:UINT_LEAST64_MAX_ 18446744073709551615ULL +// X86_64:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// X86_64:INT_FAST64_MAX_ 9223372036854775807LL +// X86_64:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// X86_64:INTPTR_MIN_ (-9223372036854775807LL -1) +// X86_64:INTPTR_MAX_ 9223372036854775807LL +// X86_64:UINTPTR_MAX_ 18446744073709551615ULL +// X86_64:PTRDIFF_MIN_ (-9223372036854775807LL -1) +// X86_64:PTRDIFF_MAX_ 9223372036854775807LL +// X86_64:SIZE_MAX_ 18446744073709551615ULL +// +// X86_64:INTMAX_MIN_ (-9223372036854775807L -1) +// X86_64:INTMAX_MAX_ 9223372036854775807L +// X86_64:UINTMAX_MAX_ (9223372036854775807L*2ULL +1ULL) +// +// X86_64:SIG_ATOMIC_MIN_ (-2147483647 -1) +// X86_64:SIG_ATOMIC_MAX_ 2147483647 +// X86_64:WINT_MIN_ (-2147483647 -1) +// X86_64:WINT_MAX_ 2147483647 +// +// X86_64:WCHAR_MAX_ 2147483647 +// X86_64:WCHAR_MIN_ (-2147483647 -1) +// +// X86_64:INT8_C_(0) (0) +// X86_64:UINT8_C_(0) (0U) +// X86_64:INT16_C_(0) (0) +// X86_64:UINT16_C_(0) (0U) +// X86_64:INT32_C_(0) (0) +// X86_64:UINT32_C_(0) (0U) +// X86_64:INT64_C_(0) (0LL) +// X86_64:UINT64_C_(0) (0ULL) +// +// X86_64:INTMAX_C_(0) (0LL) +// X86_64:UINTMAX_C_(0) (0ULL) +// +// RUN: true + +#include <stdint.h> + +INT8_MAX_ INT8_MAX +INT8_MIN_ INT8_MIN +UINT8_MAX_ UINT8_MAX +INT_LEAST8_MIN_ INT_LEAST8_MIN +INT_LEAST8_MAX_ INT_LEAST8_MAX +UINT_LEAST8_MAX_ UINT_LEAST8_MAX +INT_FAST8_MIN_ INT_FAST8_MIN +INT_FAST8_MAX_ INT_FAST8_MAX +UINT_FAST8_MAX_ UINT_FAST8_MAX + +INT16_MAX_ INT16_MAX +INT16_MIN_ INT16_MIN +UINT16_MAX_ UINT16_MAX +INT_LEAST16_MIN_ INT_LEAST16_MIN +INT_LEAST16_MAX_ INT_LEAST16_MAX +UINT_LEAST16_MAX_ UINT_LEAST16_MAX +INT_FAST16_MIN_ INT_FAST16_MIN +INT_FAST16_MAX_ INT_FAST16_MAX +UINT_FAST16_MAX_ UINT_FAST16_MAX + +INT32_MAX_ INT32_MAX +INT32_MIN_ INT32_MIN +UINT32_MAX_ UINT32_MAX +INT_LEAST32_MIN_ INT_LEAST32_MIN +INT_LEAST32_MAX_ INT_LEAST32_MAX +UINT_LEAST32_MAX_ UINT_LEAST32_MAX +INT_FAST32_MIN_ INT_FAST32_MIN +INT_FAST32_MAX_ INT_FAST32_MAX +UINT_FAST32_MAX_ UINT_FAST32_MAX + +INT64_MAX_ INT64_MAX +INT64_MIN_ INT64_MIN +UINT64_MAX_ UINT64_MAX +INT_LEAST64_MIN_ INT_LEAST64_MIN +INT_LEAST64_MAX_ INT_LEAST64_MAX +UINT_LEAST64_MAX_ UINT_LEAST64_MAX +INT_FAST64_MIN_ INT_FAST64_MIN +INT_FAST64_MAX_ INT_FAST64_MAX +UINT_FAST64_MAX_ UINT_FAST64_MAX + +INTPTR_MIN_ INTPTR_MIN +INTPTR_MAX_ INTPTR_MAX +UINTPTR_MAX_ UINTPTR_MAX +PTRDIFF_MIN_ PTRDIFF_MIN +PTRDIFF_MAX_ PTRDIFF_MAX +SIZE_MAX_ SIZE_MAX + +INTMAX_MIN_ INTMAX_MIN +INTMAX_MAX_ INTMAX_MAX +UINTMAX_MAX_ UINTMAX_MAX + +SIG_ATOMIC_MIN_ SIG_ATOMIC_MIN +SIG_ATOMIC_MAX_ SIG_ATOMIC_MAX +WINT_MIN_ WINT_MIN +WINT_MAX_ WINT_MAX + +WCHAR_MAX_ WCHAR_MAX +WCHAR_MIN_ WCHAR_MIN + +INT8_C_(0) INT8_C(0) +UINT8_C_(0) UINT8_C(0) +INT16_C_(0) INT16_C(0) +UINT16_C_(0) UINT16_C(0) +INT32_C_(0) INT32_C(0) +UINT32_C_(0) UINT32_C(0) +INT64_C_(0) INT64_C(0) +UINT64_C_(0) UINT64_C(0) + +INTMAX_C_(0) INTMAX_C(0) +UINTMAX_C_(0) UINTMAX_C(0) diff --git a/test/Preprocessor/stringize_misc.c b/test/Preprocessor/stringize_misc.c index 251116acad66..60d66a0061f6 100644 --- a/test/Preprocessor/stringize_misc.c +++ b/test/Preprocessor/stringize_misc.c @@ -1,20 +1,23 @@ -// RUN: clang-cc -E %s | grep -F '"f(1, 2)" "g((x=y++, y))"' && -// RUN: clang-cc -E %s | grep -F '"{a=1" "b=2;}"' && -// RUN: clang-cc -E %s | grep -F '"<" "["' && -// RUN: clang-cc -E %s | grep -F '"(,)" "(...)"' && -// RUN: clang-cc -E %s | grep -F '{a=1 c=3; b=2;}' && -// RUN: clang-cc -E %s | grep -F '"a COMMA b" "(a, b)"' +// RUN: clang-cc -E %s | FileCheck -strict-whitespace %s #define M(x, y) #x #y M( f(1, 2), g((x=y++, y))) +// CHECK: "f(1, 2)" "g((x=y++, y))" + M( {a=1 , b=2;} ) /* A semicolon is not a comma */ +// CHECK: "{a=1" "b=2;}" + M( <, [ ) /* Passes the arguments < and [ */ +// CHECK: "<" "[" + M( (,), (...) ) /* Passes the arguments (,) and (...) */ +// CHECK: "(,)" "(...)" #define START_END(start, end) start c=3; end START_END( {a=1 , b=2;} ) /* braces are not parentheses */ +// CHECK: {a=1 c=3; b=2;} /* * To pass a comma token as an argument it is @@ -23,4 +26,5 @@ START_END( {a=1 , b=2;} ) /* braces are not parentheses */ #define COMMA , M(a COMMA b, (a, b)) +// CHECK: "a COMMA b" "(a, b)" diff --git a/test/Sema/attr-deprecated.c b/test/Sema/attr-deprecated.c index e15381e4c6d1..4b889fc8aa4f 100644 --- a/test/Sema/attr-deprecated.c +++ b/test/Sema/attr-deprecated.c @@ -43,3 +43,60 @@ void test1(struct foo *F) { typedef struct foo foo_dep __attribute__((deprecated)); foo_dep *test2; // expected-warning {{'foo_dep' is deprecated}} + +struct bar_dep __attribute__((deprecated, + invalid_attribute)); // expected-warning {{'invalid_attribute' attribute ignored}} + +struct bar_dep *test3; // expected-warning {{'bar_dep' is deprecated}} + + +// These should not warn because the actually declaration itself is deprecated. +// rdar://6756623 +foo_dep *test4 __attribute__((deprecated)); +struct bar_dep *test5 __attribute__((deprecated)); + +typedef foo_dep test6(struct bar_dep*); // expected-warning {{'foo_dep' is deprecated}} \ + // expected-warning {{'bar_dep' is deprecated}} +typedef foo_dep test7(struct bar_dep*) __attribute__((deprecated)); + +int test8(char *p) { + p += sizeof(foo_dep); // expected-warning {{'foo_dep' is deprecated}} + + foo_dep *ptr; // expected-warning {{'foo_dep' is deprecated}} + ptr = (foo_dep*) p; // expected-warning {{'foo_dep' is deprecated}} + + int func(foo_dep *foo); // expected-warning {{'foo_dep' is deprecated}} + return func(ptr); +} + +foo_dep *test9(void) __attribute__((deprecated)); +foo_dep *test9(void) { + void* myalloc(unsigned long); + + foo_dep *ptr + = (foo_dep*) + myalloc(sizeof(foo_dep)); + return ptr; +} + +void test10(void) __attribute__((deprecated)); +void test10(void) { + if (sizeof(foo_dep) == sizeof(void*)) { + } + foo_dep *localfunc(void); + foo_dep localvar; +} + +char test11[sizeof(foo_dep)] __attribute__((deprecated)); +char test12[sizeof(foo_dep)]; // expected-warning {{'foo_dep' is deprecated}} + +int test13(foo_dep *foo) __attribute__((deprecated)); +int test14(foo_dep *foo); // expected-warning {{'foo_dep' is deprecated}} + +unsigned long test15 = sizeof(foo_dep); // expected-warning {{'foo_dep' is deprecated}} +unsigned long test16 __attribute__((deprecated)) + = sizeof(foo_dep); + +foo_dep test17, // expected-warning {{'foo_dep' is deprecated}} + test18 __attribute__((deprecated)), + test19; diff --git a/test/Sema/callingconv.c b/test/Sema/callingconv.c index cb69c59c403a..102115b3bf2b 100644 --- a/test/Sema/callingconv.c +++ b/test/Sema/callingconv.c @@ -8,3 +8,12 @@ void __attribute__((stdcall)) bar(float *a) { void __attribute__((fastcall(1))) baz(float *a) { // expected-error {{attribute requires 0 argument(s)}} } + +void __attribute__((fastcall)) test0() { // expected-error {{function with no prototype cannot use 'fastcall' calling convention}} +} + +void __attribute__((fastcall)) test1(void) { +} + +void __attribute__((fastcall)) test2(int a, ...) { // expected-error {{variadic function cannot use 'fastcall' calling convention}} +} diff --git a/test/Sema/constant-builtins-2.c b/test/Sema/constant-builtins-2.c index 146d9e9bb92b..18dbb1e7c54a 100644 --- a/test/Sema/constant-builtins-2.c +++ b/test/Sema/constant-builtins-2.c @@ -48,3 +48,5 @@ extern int f(); int h0 = __builtin_types_compatible_p(int, float); //int h1 = __builtin_choose_expr(1, 10, f()); //int h2 = __builtin_expect(0, 0); +extern long int bi0; +extern __typeof__(__builtin_expect(0, 0)) bi0; diff --git a/test/Sema/decl-invalid.c b/test/Sema/decl-invalid.c index 051f0f7ffbcc..823551f02e6f 100644 --- a/test/Sema/decl-invalid.c +++ b/test/Sema/decl-invalid.c @@ -10,8 +10,7 @@ int a() { int r[x()]; // expected-error {{size of array has non-integer type 'void'}} static y ?; // expected-error{{unknown type name 'y'}} \ - expected-error{{expected identifier or '('}} \ - expected-error{{expected ';' at end of declaration}} + expected-error{{expected identifier or '('}} } int; // expected-error {{declaration does not declare anything}} diff --git a/test/Sema/format-strings.c b/test/Sema/format-strings.c index 1826c7457e30..797e53c1bd22 100644 --- a/test/Sema/format-strings.c +++ b/test/Sema/format-strings.c @@ -8,6 +8,10 @@ char * global_fmt; +#if defined(_WIN32) || defined(_WIN64) +extern int snprintf(char*, size_t, const char*, ...); +#endif + void check_string_literal( FILE* fp, const char* s, char *buf, ... ) { char * b; @@ -83,7 +87,7 @@ void check_wide_string(char* b, ...) va_start(ap,b); printf(L"foo %d",2); // expected-warning {{incompatible pointer types}}, expected-warning {{should not be a wide string}} - vasprintf(&b,L"bar %d",ap); // expected-warning {{incompatible pointer types}}, expected-warning {{should not be a wide string}} + vsprintf(b,L"bar %d",ap); // expected-warning {{incompatible pointer types}}, expected-warning {{should not be a wide string}} } void check_asterisk_precision_width(int x) { diff --git a/test/Sema/init.c b/test/Sema/init.c index 1cbcbb7e36f8..840b24fd30b0 100644 --- a/test/Sema/init.c +++ b/test/Sema/init.c @@ -21,7 +21,7 @@ int *h = &x; int test() { int a[10]; int b[10] = a; // expected-error {{initialization with '{...}' expected}} -int +; // expected-error {{expected identifier or '('}} expected-error {{expected ';' at end of declaration}} +int +; // expected-error {{expected identifier or '('}} } diff --git a/test/Sema/offsetof.c b/test/Sema/offsetof.c index f8b9fed03c3c..dfae99216f8a 100644 --- a/test/Sema/offsetof.c +++ b/test/Sema/offsetof.c @@ -48,3 +48,9 @@ int a[__builtin_offsetof(struct sockaddr_un, sun_path[len+1])]; // PR4079 union x {struct {int x;};}; int x[__builtin_offsetof(union x, x)]; + +// rdar://problem/7222956 +struct incomplete; // expected-note 2 {{forward declaration of 'struct incomplete'}} +int test1[__builtin_offsetof(struct incomplete, foo)]; // expected-error {{offsetof of incomplete type 'struct incomplete'}} + +int test1[__builtin_offsetof(struct incomplete[10], [4].foo)]; // expected-error {{array has incomplete element type 'struct incomplete'}} diff --git a/test/Sema/parentheses.c b/test/Sema/parentheses.c new file mode 100644 index 000000000000..a8ad260bf8b5 --- /dev/null +++ b/test/Sema/parentheses.c @@ -0,0 +1,20 @@ +// RUN: clang-cc -Wparentheses -fsyntax-only -verify %s && +// RUN: clang-cc -Wparentheses -fixit %s -o - | clang-cc -Wparentheses -Werror - + +// Test the various warnings under -Wparentheses +void if_assign(void) { + int i; + if (i = 4) {} // expected-warning {{assignment as a condition}} + if ((i = 4)) {} +} + +void bitwise_rel(unsigned i) { + (void)(i & 0x2 == 0); // expected-warning {{& has lower precedence than ==}} + (void)(0 == i & 0x2); // expected-warning {{& has lower precedence than ==}} + (void)(i & 0xff < 30); // expected-warning {{& has lower precedence than <}} + (void)((i & 0x2) == 0); + (void)(i & (0x2 == 0)); + // Eager logical op + (void)(i == 1 | i == 2 | i == 3); + (void)(i != 1 & i != 2 & i != 3); +} diff --git a/test/Sema/return-noreturn.c b/test/Sema/return-noreturn.c index e2452f407f4f..8868c9ee0aeb 100644 --- a/test/Sema/return-noreturn.c +++ b/test/Sema/return-noreturn.c @@ -27,3 +27,11 @@ __attribute__((__noreturn__)) void* test3(int arg) { __attribute__((__noreturn__)) void* test3_positive(int arg) { while (0) foo_test_3(); } // expected-warning{{function declared 'noreturn' should not return}} + + +// PR5298 - -Wmissing-noreturn shouldn't warn if the function is already +// declared noreturn. +void __attribute__((noreturn)) +test4() { + test2_positive(); +} diff --git a/test/Sema/return.c b/test/Sema/return.c index 64def306ebc8..cdd31059b3e7 100644 --- a/test/Sema/return.c +++ b/test/Sema/return.c @@ -203,7 +203,11 @@ int test30() { if (j) longjmp(test30_j, 1); else +#if defined(_WIN32) || defined(_WIN64) + longjmp(test30_j, 2); +#else _longjmp(test30_j, 1); +#endif } typedef void test31_t(int status); diff --git a/test/Sema/statements.c b/test/Sema/statements.c index 9a71a403700d..8eac052a25c7 100644 --- a/test/Sema/statements.c +++ b/test/Sema/statements.c @@ -27,3 +27,9 @@ int test8[({10;})]; // expected-error {{statement expression not allowed at file void test9(const void *P) { __builtin_prefetch(P); } + + +void *test10() { +bar: + return &&bar; // expected-warning {{returning address of label, which is local}} +} diff --git a/test/Sema/stdcall-fastcall.c b/test/Sema/stdcall-fastcall.c index 353bbfc25297..e0db63822fb3 100644 --- a/test/Sema/stdcall-fastcall.c +++ b/test/Sema/stdcall-fastcall.c @@ -5,6 +5,6 @@ int __attribute__((stdcall)) var1; // expected-warning{{'stdcall' attribute only int __attribute__((fastcall)) var2; // expected-warning{{'fastcall' attribute only applies to function types}} // Different CC qualifiers are not compatible -void __attribute__((stdcall, fastcall)) foo3(); // expected-error{{stdcall and fastcall attributes are not compatible}} +void __attribute__((stdcall, fastcall)) foo3(void); // expected-error{{stdcall and fastcall attributes are not compatible}} void __attribute__((stdcall)) foo4(); -void __attribute__((fastcall)) foo4(); // expected-error{{fastcall and stdcall attributes are not compatible}} +void __attribute__((fastcall)) foo4(void); // expected-error{{fastcall and stdcall attributes are not compatible}} diff --git a/test/Sema/vector-init.c b/test/Sema/vector-init.c index 18104d871d6c..9dac6c7114da 100644 --- a/test/Sema/vector-init.c +++ b/test/Sema/vector-init.c @@ -8,7 +8,7 @@ float4 foo = (float4){ 1.0, 2.0, 3.0, 4.0 }; float4 foo2 = (float4){ 1.0, 2.0, 3.0, 4.0 , 5.0 }; // expected-warning{{excess elements in vector initializer}} float4 array[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; -int array_sizecheck[(sizeof(array) / sizeof(float4)) == 3? 1 : -1]; +int array_sizecheck[(sizeof(array) / sizeof(float4)) == 3 ? 1 : -1]; float4 array2[2] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 }; // expected-warning {{excess elements in array initializer}} @@ -26,5 +26,5 @@ float f1(void) { // PR5265 typedef float __attribute__((ext_vector_type (3))) float3; -int test2[(sizeof(float3) == sizeof(float4))*2-1]; +int test2[sizeof(float3) == sizeof(float4) ? 1 : -1]; diff --git a/test/SemaCXX/constructor.cpp b/test/SemaCXX/constructor.cpp index 5ce595cdcece..58d28b55184c 100644 --- a/test/SemaCXX/constructor.cpp +++ b/test/SemaCXX/constructor.cpp @@ -14,7 +14,7 @@ class Foo { static Foo(short, short); // expected-error{{constructor cannot be declared 'static'}} virtual Foo(double); // expected-error{{constructor cannot be declared 'virtual'}} Foo(long) const; // expected-error{{'const' qualifier is not allowed on a constructor}} - + int Foo(int, int); // expected-error{{constructor cannot have a return type}} }; diff --git a/test/SemaCXX/implicit-int.cpp b/test/SemaCXX/implicit-int.cpp index 6fa8dd3463d3..723030516dee 100644 --- a/test/SemaCXX/implicit-int.cpp +++ b/test/SemaCXX/implicit-int.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify %s +// RUN: clang-cc -fsyntax-only -verify -fms-extensions=0 %s x; // expected-error{{C++ requires a type specifier for all declarations}} diff --git a/test/SemaCXX/invalid-member-expr.cpp b/test/SemaCXX/invalid-member-expr.cpp index 90932ed65e31..730beb32698b 100644 --- a/test/SemaCXX/invalid-member-expr.cpp +++ b/test/SemaCXX/invalid-member-expr.cpp @@ -5,8 +5,8 @@ class X {}; void test() { X x; - x.int; // expected-error{{expected identifier}} - x.~int(); // expected-error{{expected identifier}} + x.int; // expected-error{{expected unqualified-id}} + x.~int(); // expected-error{{expected the class name}} x.operator; // expected-error{{missing type specifier after 'operator'}} x.operator typedef; // expected-error{{missing type specifier after 'operator'}} } @@ -14,8 +14,8 @@ void test() { void test2() { X *x; - x->int; // expected-error{{expected identifier}} - x->~int(); // expected-error{{expected identifier}} + x->int; // expected-error{{expected unqualified-id}} + x->~int(); // expected-error{{expected the class name}} x->operator; // expected-error{{missing type specifier after 'operator'}} x->operator typedef; // expected-error{{missing type specifier after 'operator'}} } diff --git a/test/SemaCXX/invalid-template-specifier.cpp b/test/SemaCXX/invalid-template-specifier.cpp index a3f081ff60b5..034ad73b086a 100644 --- a/test/SemaCXX/invalid-template-specifier.cpp +++ b/test/SemaCXX/invalid-template-specifier.cpp @@ -8,5 +8,5 @@ const template basic_istream<char>; // expected-error {{expected unqualified-id} namespace S {} template <class X> class Y { void x() { S::template y<char>(1); } // expected-error {{does not refer to a template}} \ - // expected-error {{no member named 'y'}} + // expected-error {{unqualified-id}} }; diff --git a/test/SemaCXX/nested-name-spec.cpp b/test/SemaCXX/nested-name-spec.cpp index 5178557030b7..721758f4cae0 100644 --- a/test/SemaCXX/nested-name-spec.cpp +++ b/test/SemaCXX/nested-name-spec.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -std=c++98 -verify %s +// RUN: clang-cc -fsyntax-only -std=c++98 -verify -fms-extensions=0 %s namespace A { struct C { static int cx; diff --git a/test/SemaCXX/new-delete.cpp b/test/SemaCXX/new-delete.cpp index c67a3f653900..6f3e9effe538 100644 --- a/test/SemaCXX/new-delete.cpp +++ b/test/SemaCXX/new-delete.cpp @@ -58,6 +58,7 @@ void bad_news(int *ip) (void)new int[1.1]; // expected-error {{array size expression must have integral or enumerated type, not 'double'}} (void)new int[1][i]; // expected-error {{only the first dimension}} (void)new (int[1][i]); // expected-error {{only the first dimension}} + (void)new (int[i]); // expected-error {{when type is in parentheses}} (void)new int(*(S*)0); // expected-error {{incompatible type initializing}} (void)new int(1, 2); // expected-error {{initializer of a builtin type can only take one argument}} (void)new S(1); // expected-error {{no matching constructor}} diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp index 10b0f5a76804..0f723ad206b9 100644 --- a/test/SemaCXX/overloaded-operator.cpp +++ b/test/SemaCXX/overloaded-operator.cpp @@ -70,6 +70,34 @@ void enum_test(Enum1 enum1, Enum2 enum2, E1 e1, E2 e2) { float &f4 = (enum1 == enum2); // expected-error{{non-const lvalue reference to type 'float' cannot be initialized with a temporary of type 'bool'}} } +// PR5244 - Argument-dependent lookup would include the two operators below, +// which would break later assumptions and lead to a crash. +class pr5244_foo +{ + pr5244_foo(int); + pr5244_foo(char); +}; + +bool operator==(const pr5244_foo& s1, const pr5244_foo& s2); +bool operator==(char c, const pr5244_foo& s); + +enum pr5244_bar +{ + pr5244_BAR +}; + +class pr5244_baz +{ + pr5244_bar quux; +}; + +void pr5244_barbaz() +{ + pr5244_baz quuux; + (void)(pr5244_BAR == quuux.quux); +} + + struct PostInc { PostInc operator++(int); diff --git a/test/SemaCXX/ptrtomember-badcall.cpp b/test/SemaCXX/ptrtomember-badcall.cpp new file mode 100644 index 000000000000..42b8e3b6e0c9 --- /dev/null +++ b/test/SemaCXX/ptrtomember-badcall.cpp @@ -0,0 +1,13 @@ +// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x + +struct S { + int i; + + int mem(int); +}; + +int foo(int S::* ps, S *s) +{ + return (s->*ps)(1); // expected-error {{called object type 'int' is not a function or function pointer}} +} + diff --git a/test/SemaCXX/typedef-redecl.cpp b/test/SemaCXX/typedef-redecl.cpp index e38f47436d1c..85944a661d41 100644 --- a/test/SemaCXX/typedef-redecl.cpp +++ b/test/SemaCXX/typedef-redecl.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify %s +// RUN: clang-cc -fsyntax-only -verify -fms-extensions=0 %s typedef int INT; typedef INT REALLY_INT; // expected-note {{previous definition is here}} typedef REALLY_INT REALLY_REALLY_INT; diff --git a/test/SemaCXX/value-initialization.cpp b/test/SemaCXX/value-initialization.cpp new file mode 100644 index 000000000000..29d866fa64de --- /dev/null +++ b/test/SemaCXX/value-initialization.cpp @@ -0,0 +1,10 @@ +// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x + +struct A { + const int i; // expected-note {{declared at}} + virtual void f() { } +}; + +int main () { + (void)A(); // expected-error {{cannot define the implicit default constructor for 'struct A', because const member 'i' cannot be default-initialized}} +} diff --git a/test/SemaObjC/conditional-expr-6.m b/test/SemaObjC/conditional-expr-6.m new file mode 100644 index 000000000000..bba51bb8178f --- /dev/null +++ b/test/SemaObjC/conditional-expr-6.m @@ -0,0 +1,51 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +@protocol MyProtocol @end + +@interface NSObject @end + +@interface NSInterm : NSObject <MyProtocol> +@end + +@interface NSArray : NSInterm +@end + +@interface NSSet : NSObject <MyProtocol> +@end + + +@interface N1 : NSObject +@end + +@interface N1() <MyProtocol> +@end + +NSObject* test (int argc) { + NSArray *array = ((void*)0); + NSSet *set = ((void*)0); + return (argc) ? set : array ; +} + + +NSObject* test1 (int argc) { + NSArray *array = ((void*)0); + NSSet *set = ((void*)0); + id <MyProtocol> instance = (argc) ? array : set; + id <MyProtocol> instance1 = (argc) ? set : array; + + N1 *n1 = ((void*)0); + id <MyProtocol> instance2 = (argc) ? set : n1; + id <MyProtocol> instance3 = (argc) ? n1 : array; + + NSArray<MyProtocol> *qual_array = ((void*)0); + id <MyProtocol> instance4 = (argc) ? array : qual_array; + id <MyProtocol> instance5 = (argc) ? qual_array : array; + NSSet<MyProtocol> *qual_set = ((void*)0); + id <MyProtocol> instance6 = (argc) ? qual_set : qual_array; + id <MyProtocol> instance7 = (argc) ? qual_set : array; + id <MyProtocol> instance8 = (argc) ? qual_array : set; + id <MyProtocol> instance9 = (argc) ? qual_array : qual_set; + + + return (argc) ? array : set; +} diff --git a/test/SemaObjC/continuation-class-err.m b/test/SemaObjC/continuation-class-err.m index f516a9326a95..262b786b5408 100644 --- a/test/SemaObjC/continuation-class-err.m +++ b/test/SemaObjC/continuation-class-err.m @@ -5,11 +5,36 @@ id _object; id _object1; } -@property(readonly) id object; -@property(readwrite, assign) id object1; +@property(readonly) id object; // expected-note {{property declared here}} +@property(readwrite, assign) id object1; // expected-note {{property declared here}} @end @interface ReadOnly () -@property(readwrite, copy) id object; -@property(readonly) id object1; // expected-error {{attribute of property in continuation class of 'ReadOnly' can only be 'readwrite'}} +@property(readwrite, copy) id object; // expected-warning {{property attribute in continuation class does not match the primary class}} +@property(readonly) id object1; // expected-error {{property declaration in continuation class of 'ReadOnly' is to change a 'readonly' property to 'readwrite'}} @end + +@protocol Proto + @property (copy) id fee; // expected-note {{property declared here}} +@end + +@protocol Foo<Proto> + @property (copy) id foo; // expected-note {{property declared here}} +@end + +@interface Bar <Foo> { + id _foo; + id _fee; +} +@end + +@interface Bar () +@property (copy) id foo; // expected-error {{property declaration in continuation class of 'Bar' is to change a 'readonly' property to 'readwrite'}} +@property (copy) id fee; // expected-error {{property declaration in continuation class of 'Bar' is to change a 'readonly' property to 'readwrite'}} +@end + +@implementation Bar +@synthesize foo = _foo; +@synthesize fee = _fee; +@end + diff --git a/test/SemaObjC/id-isa-ref.m b/test/SemaObjC/id-isa-ref.m index dc42f9a53965..fa3293ce79b5 100644 --- a/test/SemaObjC/id-isa-ref.m +++ b/test/SemaObjC/id-isa-ref.m @@ -1,7 +1,7 @@ // RUN: clang-cc -fsyntax-only -verify %s // Failing currently due to Obj-C type representation changes. 2009-09-17 -// XFAIL +// XFAIL: * typedef struct objc_object { struct objc_class *isa; diff --git a/test/SemaObjC/property-category-4.m b/test/SemaObjC/property-category-4.m new file mode 100644 index 000000000000..ee08b09c0137 --- /dev/null +++ b/test/SemaObjC/property-category-4.m @@ -0,0 +1,18 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +@interface IDELogNavigator +{ + id selectedObjects; +} +@end + +@interface IDELogNavigator (CAT) + @property (readwrite, retain) id selectedObjects; // expected-note {{property declared here}} + @property (readwrite, retain) id d_selectedObjects; // expected-note {{property declared here}} +@end + +@implementation IDELogNavigator +@synthesize selectedObjects = _selectedObjects; // expected-error {{property declared in category 'CAT' cannot be implemented in class implementation}} +@dynamic d_selectedObjects; // expected-error {{property declared in category 'CAT' cannot be implemented in class implementation}} +@end + diff --git a/test/SemaObjC/return.m b/test/SemaObjC/return.m index 9acf47079958..ff6499479458 100644 --- a/test/SemaObjC/return.m +++ b/test/SemaObjC/return.m @@ -1,6 +1,22 @@ -// RUN: clang-cc %s -fsyntax-only -verify +// RUN: clang-cc %s -fsyntax-only -verify -Wmissing-noreturn int test1() { id a; @throw a; } + +// PR5286 +void test2(int a) { + while (1) { + if (a) + return; + } +} + +// PR5286 +void test3(int a) { // expected-warning {{function could be attribute 'noreturn'}} + while (1) { + if (a) + @throw (id)0; + } +} diff --git a/test/SemaObjCXX/overload.mm b/test/SemaObjCXX/overload.mm index 47141002864c..56dc5108eb95 100644 --- a/test/SemaObjCXX/overload.mm +++ b/test/SemaObjCXX/overload.mm @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * @interface Foo @end diff --git a/test/SemaObjCXX/references.mm b/test/SemaObjCXX/references.mm index 82797cef77c7..e02f360f7876 100644 --- a/test/SemaObjCXX/references.mm +++ b/test/SemaObjCXX/references.mm @@ -1,7 +1,7 @@ // FIXME: This crashes, disable it until fixed. // RN: clang-cc -verify -emit-llvm -o - %s // RUN: false -// XFAIL +// XFAIL: * // Test reference binding. diff --git a/test/SemaTemplate/class-template-spec.cpp b/test/SemaTemplate/class-template-spec.cpp index e44115c748c3..4cd43b469ae0 100644 --- a/test/SemaTemplate/class-template-spec.cpp +++ b/test/SemaTemplate/class-template-spec.cpp @@ -20,8 +20,7 @@ int test_incomplete_specs(A<double, double> *a1, A<double> *a2) { (void)a1->x; // expected-error{{incomplete definition of type 'A<double, double>'}} - (void)a2->x; // expected-error{{implicit instantiation of undefined template 'struct A<double, int>'}} \ - // expected-note{{first required here}} + (void)a2->x; // expected-error{{implicit instantiation of undefined template 'struct A<double, int>'}} } typedef float FLOAT; @@ -71,8 +70,7 @@ namespace N { } // Diagnose specialization errors -struct A<double> { }; // expected-error{{template specialization requires 'template<>'}} \ - // expected-error{{after instantiation}} +struct A<double> { }; // expected-error{{template specialization requires 'template<>'}} template<> struct ::A<double>; @@ -100,3 +98,9 @@ template<> struct N::B<char> { int testf(int x) { return f(x); } }; +// PR5264 +template <typename T> class Foo; +Foo<int>* v; +Foo<int>& F() { return *v; } +template <typename T> class Foo {}; +Foo<int> x; diff --git a/test/SemaTemplate/constructor-template.cpp b/test/SemaTemplate/constructor-template.cpp index acd845bc2fd5..79bf7c585e34 100644 --- a/test/SemaTemplate/constructor-template.cpp +++ b/test/SemaTemplate/constructor-template.cpp @@ -51,3 +51,4 @@ void test_X1(X1<int> xi) { template<class C> struct A {}; template <> struct A<int>{A(const A<int>&);}; struct B { A<int> x; B(B& a) : x(a.x) {} }; + diff --git a/test/SemaTemplate/copy-ctor-assign.cpp b/test/SemaTemplate/copy-ctor-assign.cpp index 90fb0133a721..69481ea557f4 100644 --- a/test/SemaTemplate/copy-ctor-assign.cpp +++ b/test/SemaTemplate/copy-ctor-assign.cpp @@ -33,4 +33,20 @@ void test3(X<int> &x, X<int> xi, X<long> xl, X<int Y::*> xmptr) { x = xi; x = xl; x = xmptr; // expected-note{{instantiation}} -}
\ No newline at end of file +} + +struct X1 { + X1 &operator=(const X1&); +}; + +template<typename T> +struct X2 : X1 { + template<typename U> X2 &operator=(const U&); +}; + +struct X3 : X2<int> { +}; + +void test_X2(X3 &to, X3 from) { + to = from; +} diff --git a/test/SemaTemplate/default-expr-arguments.cpp b/test/SemaTemplate/default-expr-arguments.cpp index 575283ed8b51..9c0f1ecf0c3b 100644 --- a/test/SemaTemplate/default-expr-arguments.cpp +++ b/test/SemaTemplate/default-expr-arguments.cpp @@ -84,3 +84,27 @@ struct X1 { void test_X1() { X1<int> x1; } + +// PR5283 +namespace PR5283 { +template<typename T> struct A { + A(T = 1); // expected-error 3 {{incompatible type initializing 'int', expected 'int *'}} +}; + +struct B : A<int*> { + B(); +}; +B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}} + +struct C : virtual A<int*> { + C(); +}; +C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}} + +struct D { + D(); + + A<int*> a; +}; +D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}} +} diff --git a/test/SemaTemplate/ext-vector-type.cpp b/test/SemaTemplate/ext-vector-type.cpp index b6aebc102fb4..7cc4ae930ed2 100644 --- a/test/SemaTemplate/ext-vector-type.cpp +++ b/test/SemaTemplate/ext-vector-type.cpp @@ -45,3 +45,16 @@ struct make5 { typedef int_ptr __attribute__((ext_vector_type(Length))) type; // expected-error{{invalid vector type}} }; +template<int Length> +struct make6 { + typedef int __attribute__((ext_vector_type(Length))) type; +}; + +int test_make6() { + make6<4>::type x; + x.w = 7; + + make6<2>::type y; + y.x = -1; + y.w = -1; // expected-error{{vector component access exceeds type}} +} diff --git a/test/SemaTemplate/friend-template.cpp b/test/SemaTemplate/friend-template.cpp index 761c13076d2a..84a8e899dbea 100644 --- a/test/SemaTemplate/friend-template.cpp +++ b/test/SemaTemplate/friend-template.cpp @@ -54,6 +54,7 @@ struct X1 { template<typename U> void f2(U); X1<int> x1i; +X0<int*> x0ip; template<> void f2(int); @@ -62,3 +63,31 @@ template<> void f2(int); template<typename U> void f3(U); template<> void f3(int); + +// PR5332 +template <typename T> +class Foo { + template <typename U> + friend class Foo; +}; + +Foo<int> foo; + +template<typename T, T Value> +struct X2a; + +template<typename T, int Size> +struct X2b; + +template<typename T> +class X3 { + template<typename U, U Value> + friend struct X2a; + + template<typename U, T Value> + friend struct X2b; +}; + +X3<int> x3i; // okay + +X3<long> x3l; // FIXME: should cause an instantiation-time failure diff --git a/test/SemaTemplate/instantiate-cast.cpp b/test/SemaTemplate/instantiate-cast.cpp index 6b3fc6e12534..c3c318f36d5d 100644 --- a/test/SemaTemplate/instantiate-cast.cpp +++ b/test/SemaTemplate/instantiate-cast.cpp @@ -96,7 +96,6 @@ struct FunctionalCast1 { template struct FunctionalCast1<int, float>; template struct FunctionalCast1<A, int>; // expected-note{{instantiation}} -#if 0 // Generates temporaries, which we cannot handle yet. template<int N, long M> struct FunctionalCast2 { @@ -106,4 +105,13 @@ struct FunctionalCast2 { }; template struct FunctionalCast2<1, 3>; -#endif + +// --------------------------------------------------------------------- +// implicit casting +// --------------------------------------------------------------------- +template<typename T> +struct Derived2 : public Base { }; + +void test_derived_to_base(Base *&bp, Derived2<int> *dp) { + bp = dp; +} diff --git a/test/SemaTemplate/instantiate-declref-ice.cpp b/test/SemaTemplate/instantiate-declref-ice.cpp index 21ee87202797..ab12b90f6c98 100644 --- a/test/SemaTemplate/instantiate-declref-ice.cpp +++ b/test/SemaTemplate/instantiate-declref-ice.cpp @@ -5,3 +5,33 @@ template<int i> struct x { x<j>* y; }; +template<int i> +const int x<i>::j; + +int array0[x<2>::j]; + + +template<typename T> +struct X0 { + static const unsigned value = sizeof(T); +}; + +template<typename T> +const unsigned X0<T>::value; + +int array1[X0<int>::value == sizeof(int)? 1 : -1]; + +const unsigned& testX0() { return X0<int>::value; } + +int array2[X0<int>::value == sizeof(int)? 1 : -1]; + +template<typename T> +struct X1 { + static const unsigned value; +}; + +template<typename T> +const unsigned X1<T>::value = sizeof(T); + +int array3[X1<int>::value == sizeof(int)? 1 : -1]; // expected-error{{variable length arrays are not permitted in C++}} \ +// expected-error{{variable length array declaration not allowed at file scope}} diff --git a/test/SemaTemplate/instantiate-declref.cpp b/test/SemaTemplate/instantiate-declref.cpp index 051c6050abea..359e2c7dfaa4 100644 --- a/test/SemaTemplate/instantiate-declref.cpp +++ b/test/SemaTemplate/instantiate-declref.cpp @@ -69,3 +69,21 @@ namespace N2 { template struct N2::Outer2::Inner<float>; template struct N2::Outer2::Inner<int*, float*>; // expected-note{{instantiation}} + +// Test dependent pointer-to-member expressions. +template<typename T> +struct smart_ptr { + struct safe_bool { + int member; + }; + + operator int safe_bool::*() const { + return ptr? &safe_bool::member : 0; + } + + T* ptr; +}; + +void test_smart_ptr(smart_ptr<int> p) { + if (p) { } +} diff --git a/test/SemaTemplate/instantiate-function-1.mm b/test/SemaTemplate/instantiate-function-1.mm index be995e7ff615..c119ab5da8b9 100644 --- a/test/SemaTemplate/instantiate-function-1.mm +++ b/test/SemaTemplate/instantiate-function-1.mm @@ -1,5 +1,5 @@ // RUN: clang-cc -fsyntax-only -verify %s -// XFAIL +// XFAIL: * template<typename T> struct Member0 { void f(T t) { diff --git a/test/SemaTemplate/instantiate-method.cpp b/test/SemaTemplate/instantiate-method.cpp index f7c09ef87900..df1e1d964eb6 100644 --- a/test/SemaTemplate/instantiate-method.cpp +++ b/test/SemaTemplate/instantiate-method.cpp @@ -81,3 +81,20 @@ int *a(A0<int> &x0, A1<int> &x1) { int *y0 = x0; int *y1 = x1; // expected-error{{initializing}} } + +struct X0Base { + int &f(); +}; + +template<typename T> +struct X0 : X0Base { +}; + +template<typename U> +struct X1 : X0<U> { + int &f2() { return X0Base::f(); } +}; + +void test_X1(X1<int> x1i) { + int &ir = x1i.f2(); +} diff --git a/test/SemaTemplate/instantiate-non-type-template-parameter.cpp b/test/SemaTemplate/instantiate-non-type-template-parameter.cpp new file mode 100644 index 000000000000..32acbd0d8bdc --- /dev/null +++ b/test/SemaTemplate/instantiate-non-type-template-parameter.cpp @@ -0,0 +1,14 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// PR5311 +template<typename T> +class StringSwitch { +public: + template<unsigned N> + void Case(const char (&S)[N], const int & Value) { + } +}; + +int main(int argc, char *argv[]) { + (void)StringSwitch<int>(); +} diff --git a/test/SemaTemplate/instantiate-subscript.cpp b/test/SemaTemplate/instantiate-subscript.cpp index 434d84e2b893..20e2c39d0cce 100644 --- a/test/SemaTemplate/instantiate-subscript.cpp +++ b/test/SemaTemplate/instantiate-subscript.cpp @@ -6,7 +6,7 @@ struct Sub0 { }; struct Sub1 { - long &operator[](long); + long &operator[](long); // expected-note{{candidate function}} }; struct ConvertibleToInt { @@ -24,3 +24,18 @@ template struct Subscript0<int*, int, int&>; template struct Subscript0<Sub0, int, int&>; template struct Subscript0<Sub1, ConvertibleToInt, long&>; template struct Subscript0<Sub1, Sub0, long&>; // expected-note{{instantiation}} + +// PR5345 +template <typename T> +struct S { + bool operator[](int n) const { return true; } +}; + +template <typename T> +void Foo(const S<int>& s, T x) { + if (s[0]) {} +} + +void Bar() { + Foo(S<int>(), 0); +} diff --git a/test/SemaTemplate/member-template-access-expr.cpp b/test/SemaTemplate/member-template-access-expr.cpp index 0f9f21f339d1..0238cd53c553 100644 --- a/test/SemaTemplate/member-template-access-expr.cpp +++ b/test/SemaTemplate/member-template-access-expr.cpp @@ -1,5 +1,4 @@ // RUN: clang-cc -fsyntax-only -verify %s - template<typename U, typename T> U f0(T t) { return t.template get<U>(); @@ -50,3 +49,47 @@ B<T>::destroy() void do_destroy_B(B<int> b) { b.destroy(); } + +struct X1 { + int* f1(int); + template<typename T> float* f1(T); + + static int* f2(int); + template<typename T> static float* f2(T); +}; + +void test_X1(X1 x1) { + float *fp1 = x1.f1<>(17); + float *fp2 = x1.f1<int>(3.14); + int *ip1 = x1.f1(17); + float *ip2 = x1.f1(3.14); + + float* (X1::*mf1)(int) = &X1::f1; + float* (X1::*mf2)(int) = &X1::f1<>; + float* (X1::*mf3)(float) = &X1::f1<float>; + + float* (*fp3)(int) = &X1::f2; + float* (*fp4)(int) = &X1::f2<>; + float* (*fp5)(float) = &X1::f2<float>; + float* (*fp6)(int) = X1::f2; + float* (*fp7)(int) = X1::f2<>; + float* (*fp8)(float) = X1::f2<float>; +} + +template<int A> struct X2 { + int m; +}; + +template<typename T> +struct X3 : T { }; + +template<typename T> +struct X4 { + template<typename U> + void f(X2<sizeof(X3<U>().U::m)>); +}; + +void f(X4<X3<int> > x4i) { + X2<sizeof(int)> x2; + x4i.f<X2<sizeof(int)> >(x2); +} diff --git a/test/SemaTemplate/nested-name-spec-template.cpp b/test/SemaTemplate/nested-name-spec-template.cpp index a5aa2dcb527a..1bdc7a89d4e8 100644 --- a/test/SemaTemplate/nested-name-spec-template.cpp +++ b/test/SemaTemplate/nested-name-spec-template.cpp @@ -1,4 +1,4 @@ -// RUN: clang-cc -fsyntax-only -verify %s +// RUN: clang-cc -fsyntax-only -verify -fms-extensions=0 %s namespace N { namespace M { diff --git a/test/SemaTemplate/nested-template.cpp b/test/SemaTemplate/nested-template.cpp index 5ee2c9954005..4d948184cee9 100644 --- a/test/SemaTemplate/nested-template.cpp +++ b/test/SemaTemplate/nested-template.cpp @@ -101,3 +101,10 @@ struct X0<T*> { template<typename U> void f(U u = T()) { } }; + +// PR5103 +template<typename> +struct X1 { + template<typename, bool = false> struct B { }; +}; +template struct X1<int>::B<bool>; diff --git a/test/SemaTemplate/operator-function-id-template.cpp b/test/SemaTemplate/operator-function-id-template.cpp new file mode 100644 index 000000000000..92a8c84e3be6 --- /dev/null +++ b/test/SemaTemplate/operator-function-id-template.cpp @@ -0,0 +1,28 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +template<typename T> +struct A { + template<typename U> A<T> operator+(U); +}; + +template<int Value, typename T> bool operator==(A<T>, A<T>); + +template<> bool operator==<0>(A<int>, A<int>); + +bool test_qualified_id(A<int> ai) { + return ::operator==<0, int>(ai, ai); +} + +void test_op(A<int> a, int i) { + const A<int> &air = a.operator+<int>(i); +} + +template<typename T> +void test_op_template(A<T> at, T x) { + const A<T> &atr = at.template operator+<T>(x); + const A<T> &atr2 = at.A::template operator+<T>(x); + // FIXME: unrelated template-name instantiation issue + // const A<T> &atr3 = at.template A<T>::template operator+<T>(x); +} + +template void test_op_template<float>(A<float>, float); diff --git a/test/SemaTemplate/template-id-expr.cpp b/test/SemaTemplate/template-id-expr.cpp new file mode 100644 index 000000000000..a0cbe4408494 --- /dev/null +++ b/test/SemaTemplate/template-id-expr.cpp @@ -0,0 +1,14 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// PR5336 +template<typename FromCl> +struct isa_impl_cl { + template<class ToCl> + static void isa(const FromCl &Val) { } +}; + +template<class X, class Y> +void isa(const Y &Val) { return isa_impl_cl<Y>::template isa<X>(Val); } + +class Value; +void f0(const Value &Val) { isa<Value>(Val); } diff --git a/test/SemaTemplate/template-id-printing.cpp b/test/SemaTemplate/template-id-printing.cpp new file mode 100644 index 000000000000..13250943e92c --- /dev/null +++ b/test/SemaTemplate/template-id-printing.cpp @@ -0,0 +1,13 @@ +// RUN: clang-cc -fsyntax-only -ast-print %s | FileCheck %s +namespace N { + template<typename T, typename U> void f(U); + template<int> void f(); +} + +void g() { + // CHECK: N::f<int>(3.14 + N::f<int>(3.14); + + // CHECK: N::f<double> + void (*fp)(int) = N::f<double>; +} diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in index 9dabafcde1f4..c88c90b7c5df 100644 --- a/test/lit.site.cfg.in +++ b/test/lit.site.cfg.in @@ -5,6 +5,7 @@ config.llvm_obj_root = "@LLVM_BINARY_DIR@" config.llvm_tools_dir = "@LLVM_TOOLS_DIR@" config.llvm_libs_dir = "@LLVM_LIBS_DIR@" config.clang_obj_root = "@CLANG_BINARY_DIR@" +config.target_triple = "@TARGET_TRIPLE@" # Let the main config do the real work. lit.load_config(config, "@CLANG_SOURCE_DIR@/test/lit.cfg") |