diff options
Diffstat (limited to 'test')
1417 files changed, 44273 insertions, 5965 deletions
diff --git a/test/ARCMT/checking.m b/test/ARCMT/checking.m index 7815103822a1..6a7cf76c3865 100644 --- a/test/ARCMT/checking.m +++ b/test/ARCMT/checking.m @@ -182,7 +182,7 @@ void test6(unsigned cond) { ; id x; // expected-note {{jump bypasses initialization of retaining variable}} - case 1: // expected-error {{switch case is in protected scope}} + case 1: // expected-error {{cannot jump}} x = 0; break; } @@ -304,7 +304,7 @@ void rdar9491791(int p) { // rdar://9504750 void rdar9504750(id p) { - RELEASE_MACRO(p); // expected-error {{ARC forbids explicit message send of 'release'}} + RELEASE_MACRO(p); // expected-error {{ARC forbids explicit message send of 'release'}} } // rdar://8939557 diff --git a/test/ARCMT/objcmt-boxing.m b/test/ARCMT/objcmt-boxing.m index 2ad65a1399db..c4b6f42b1bd5 100644 --- a/test/ARCMT/objcmt-boxing.m +++ b/test/ARCMT/objcmt-boxing.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -objcmt-migrate-literals -objcmt-migrate-subscripting -mt-migrate-directory %t %s -x objective-c++ -verify +// RUN: %clang_cc1 -fobjc-arc -objcmt-migrate-literals -objcmt-migrate-subscripting -mt-migrate-directory %t %s -x objective-c++ -verify // RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c++ %s.result @@ -68,6 +68,7 @@ typedef NSUInteger NSStringEncoding; + (id)stringWithUTF8String:(const char *)nullTerminatedCString; + (id)stringWithCString:(const char *)cString encoding:(NSStringEncoding)enc; + (id)stringWithCString:(const char *)bytes; +- (instancetype)initWithUTF8String:(const char *)nullTerminatedCString; @end enum MyEnm { @@ -99,4 +100,8 @@ void boxString() { static const char strarr[] = "coolbox"; s = [NSString stringWithUTF8String:strarr]; + // rdar://18080352 + const char *utf8Bytes = "blah"; + NSString *string1 = [NSString stringWithUTF8String:utf8Bytes]; + NSString *string2 = [[NSString alloc] initWithUTF8String:utf8Bytes]; } diff --git a/test/ARCMT/objcmt-boxing.m.result b/test/ARCMT/objcmt-boxing.m.result index f1019892ff37..59fdb88d51a3 100644 --- a/test/ARCMT/objcmt-boxing.m.result +++ b/test/ARCMT/objcmt-boxing.m.result @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -objcmt-migrate-literals -objcmt-migrate-subscripting -mt-migrate-directory %t %s -x objective-c++ -verify +// RUN: %clang_cc1 -fobjc-arc -objcmt-migrate-literals -objcmt-migrate-subscripting -mt-migrate-directory %t %s -x objective-c++ -verify // RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c++ %s.result @@ -68,6 +68,7 @@ typedef NSUInteger NSStringEncoding; + (id)stringWithUTF8String:(const char *)nullTerminatedCString; + (id)stringWithCString:(const char *)cString encoding:(NSStringEncoding)enc; + (id)stringWithCString:(const char *)bytes; +- (instancetype)initWithUTF8String:(const char *)nullTerminatedCString; @end enum MyEnm { @@ -99,4 +100,8 @@ void boxString() { static const char strarr[] = "coolbox"; s = @(strarr); + // rdar://18080352 + const char *utf8Bytes = "blah"; + NSString *string1 = @(utf8Bytes); + NSString *string2 = @(utf8Bytes); } diff --git a/test/ARCMT/objcmt-ns-macros.m b/test/ARCMT/objcmt-ns-macros.m index 1bf55d8ed46b..1d5583b92f26 100644 --- a/test/ARCMT/objcmt-ns-macros.m +++ b/test/ARCMT/objcmt-ns-macros.m @@ -3,8 +3,17 @@ // RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c -fobjc-runtime-has-weak -fobjc-arc %s.result +typedef signed char int8_t; +typedef short int16_t; +typedef int int32_t; typedef long NSInteger; +typedef long long int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; typedef unsigned long NSUInteger; +typedef unsigned long long uint64_t; #define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type #define NS_OPTIONS(_type, _name) enum _name : _type _name; enum _name : _type @@ -294,3 +303,63 @@ enum { NSWindowToolbarButton, NSWindowDocumentIconButton }; + +// rdar://18262255 +typedef enum : NSUInteger { + ThingOne, + ThingTwo, + ThingThree, +} Thing; + +// rdar://18498539 +typedef enum { + one = 1 +} NumericEnum; + +typedef enum { + Two = 2 +}NumericEnum2; + +typedef enum { + Three = 3 +} +NumericEnum3; + +typedef enum { + Four = 4 +} + + NumericEnum4; + +// rdar://18532199 +enum +{ + UI8one = 1 +}; +typedef int8_t MyEnumeratedType; + + +enum { + UI16One = 0, + UI16Two = 0x1, + UI16three = 0x8, + UI16Four = 0x100 +}; +typedef int16_t UI16; + +enum { + UI32ViewAutoresizingNone = 0, + UI32ViewAutoresizingFlexibleLeftMargin, + UI32ViewAutoresizingFlexibleWidth, + UI32ViewAutoresizingFlexibleRightMargin, + UI32ViewAutoresizingFlexibleTopMargin, + UI32ViewAutoresizingFlexibleHeight, + UI32ViewAutoresizingFlexibleBottomMargin +}; +typedef uint32_t UI32TableViewCellStyle; + +enum +{ + UIU8one = 1 +}; +typedef uint8_t UI8Type; diff --git a/test/ARCMT/objcmt-ns-macros.m.result b/test/ARCMT/objcmt-ns-macros.m.result index 0b640ac35676..63eec7d37ede 100644 --- a/test/ARCMT/objcmt-ns-macros.m.result +++ b/test/ARCMT/objcmt-ns-macros.m.result @@ -3,13 +3,25 @@ // RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c -fobjc-runtime-has-weak -fobjc-arc %s.result +typedef signed char int8_t; +typedef short int16_t; +typedef int int32_t; typedef long NSInteger; +typedef long long int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; typedef unsigned long NSUInteger; +typedef unsigned long long uint64_t; #define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type #define NS_OPTIONS(_type, _name) enum _name : _type _name; enum _name : _type #define DEPRECATED __attribute__((deprecated)) +#ifndef NS_ENUM +#import <Foundation/Foundation.h> +#endif typedef NS_ENUM(NSInteger, wibble) { blah, blarg @@ -25,15 +37,15 @@ typedef NS_ENUM(NSUInteger, UITableViewCellStyle) { UIViewAutoresizingFlexibleBottomMargin }; -typedef NS_ENUM(NSInteger, UIViewAnimationTransition) { +typedef NS_ENUM(unsigned int, UIViewAnimationTransition) { UIViewAnimationTransitionNone, UIViewAnimationTransitionFlipFromLeft, UIViewAnimationTransitionFlipFromRight, UIViewAnimationTransitionCurlUp, UIViewAnimationTransitionCurlDown, -} ; +}; -typedef NS_OPTIONS(NSUInteger, UITableView) { +typedef NS_OPTIONS(unsigned int, UITableView) { UIViewOne = 0, UIViewTwo = 1 << 0, UIViewThree = 1 << 1, @@ -41,7 +53,7 @@ typedef NS_OPTIONS(NSUInteger, UITableView) { UIViewFive = 1 << 3, UIViewSix = 1 << 4, UIViewSeven = 1 << 5 -} ; +}; typedef NS_OPTIONS(NSUInteger, UI) { UIOne = 0, @@ -50,12 +62,12 @@ typedef NS_OPTIONS(NSUInteger, UI) { UIFour = 0x100 }; -typedef NS_OPTIONS(NSUInteger, UIPOWER2) { +typedef NS_OPTIONS(unsigned int, UIPOWER2) { UIP2One = 0, UIP2Two = 0x1, UIP2three = 0x8, UIP2Four = 0x100 -} ; +}; enum { UNOne, @@ -68,12 +80,12 @@ typedef NS_ENUM(NSInteger, UIK) { UIKTwo = 2, }; -typedef NS_ENUM(NSInteger, NSTickMarkPosition) { +typedef NS_ENUM(unsigned int, NSTickMarkPosition) { NSTickMarkBelow = 0, NSTickMarkAbove = 1, NSTickMarkLeft = NSTickMarkAbove, NSTickMarkRight = NSTickMarkBelow -} ; +}; typedef NS_OPTIONS(NSUInteger, UITableStyle) { UIViewNone = 0x0, @@ -138,55 +150,55 @@ typedef NS_OPTIONS(NSUInteger, NSFOptions) { NSFCopyIn NS_ENUM_AVAILABLE(10_5, 6_0) = (1UL << 16), }; -typedef NS_ENUM(NSInteger, UIP) { +typedef NS_ENUM(unsigned int, UIP) { UIP0One = 0, UIP0Two = 1, UIP0Three = 2, UIP0Four = 10, UIP0Last = 0x100 -} ; +}; -typedef NS_OPTIONS(NSUInteger, UIP_3) { +typedef NS_OPTIONS(unsigned int, UIP_3) { UIPZero = 0x0, UIPOne = 0x1, UIPTwo = 0x2, UIP10 = 0x10, UIPHundred = 0x100 -} ; +}; -typedef NS_ENUM(NSInteger, UIP4_3) { +typedef NS_ENUM(unsigned int, UIP4_3) { UIP4Zero = 0x0, UIP4One = 0x1, UIP4Two = 0x2, UIP410 = 0x10, UIP4Hundred = 100 -} ; +}; -typedef NS_OPTIONS(NSUInteger, UIP5_3) { +typedef NS_OPTIONS(unsigned int, UIP5_3) { UIP5Zero = 0x0, UIP5Two = 0x2, UIP510 = 0x3, UIP5Hundred = 0x4 -} ; +}; -typedef NS_ENUM(NSInteger, UIP6_3) { +typedef NS_ENUM(unsigned int, UIP6_3) { UIP6Zero = 0x0, UIP6One = 0x1, UIP6Two = 0x2, UIP610 = 10, UIP6Hundred = 0x100 -} ; +}; -typedef NS_ENUM(NSInteger, UIP7_3) { +typedef NS_ENUM(unsigned int, UIP7_3) { UIP7Zero = 0x0, UIP7One = 1, UIP7Two = 0x2, UIP710 = 10, UIP7Hundred = 100 -} ; +}; -typedef NS_ENUM(NSInteger, UIP8_3) { +typedef NS_ENUM(unsigned int, UIP8_3) { Random = 0, Random1 = 2, Random2 = 4, @@ -194,7 +206,7 @@ typedef NS_ENUM(NSInteger, UIP8_3) { Random4 = 0x3444444, Random5 = 0xbadbeef, Random6 -} ; +}; // rdar://15200602 #define NS_AVAILABLE_MAC(X) __attribute__((availability(macosx,introduced=X))) @@ -277,3 +289,56 @@ typedef NS_ENUM(NSUInteger, NSSelectionDirection) { }; // standard window buttons + +// rdar://18262255 +typedef enum : NSUInteger { + ThingOne, + ThingTwo, + ThingThree, +} Thing; + +// rdar://18498539 +typedef NS_ENUM(unsigned int, NumericEnum) { + one = 1 +}; + +typedef NS_ENUM(unsigned int, NumericEnum2) { + Two = 2 +}; + +typedef NS_ENUM(unsigned int, NumericEnum3) { + Three = 3 +}; + +typedef NS_OPTIONS(unsigned int, NumericEnum4) { + Four = 4 +}; + +// rdar://18532199 +typedef NS_ENUM(int8_t, MyEnumeratedType) +{ + UI8one = 1 +}; + + +typedef NS_OPTIONS(uint16_t, UI16) { + UI16One = 0, + UI16Two = 0x1, + UI16three = 0x8, + UI16Four = 0x100 +}; + +typedef NS_ENUM(uint32_t, UI32TableViewCellStyle) { + UI32ViewAutoresizingNone = 0, + UI32ViewAutoresizingFlexibleLeftMargin, + UI32ViewAutoresizingFlexibleWidth, + UI32ViewAutoresizingFlexibleRightMargin, + UI32ViewAutoresizingFlexibleTopMargin, + UI32ViewAutoresizingFlexibleHeight, + UI32ViewAutoresizingFlexibleBottomMargin +}; + +typedef NS_ENUM(uint8_t, UI8Type) +{ + UIU8one = 1 +}; diff --git a/test/ARCMT/objcmt-property-dot-syntax.m b/test/ARCMT/objcmt-property-dot-syntax.m new file mode 100644 index 000000000000..0e25abcb89ec --- /dev/null +++ b/test/ARCMT/objcmt-property-dot-syntax.m @@ -0,0 +1,61 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -objcmt-migrate-property-dot-syntax -mt-migrate-directory %t %s -x objective-c -fobjc-runtime-has-weak -fobjc-arc -triple x86_64-apple-darwin11 +// RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result +// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c -fobjc-runtime-has-weak -fobjc-arc %s.result + +// rdar://18498572 +@interface NSObject @end + +@interface P : NSObject +{ + P* obj; + int i1, i2, i3; +} +@property int count; +@property (copy) P* PropertyReturnsPObj; +- (P*) MethodReturnsPObj; +@end + +P* fun(); + +@implementation P +- (int) Meth : (P*)array { + [obj setCount : 100]; + + [(P*)0 setCount : [array count]]; + + [[obj PropertyReturnsPObj] setCount : [array count]]; + + [obj setCount : (i1+i2*i3 - 100)]; + + return [obj count] - + [(P*)0 count] + [array count] + + [fun() count] - + [[obj PropertyReturnsPObj] count] + + [self->obj count]; +} + +- (P*) MethodReturnsPObj { return 0; } +@end + +// rdar://19140267 +@interface Sub : P +@end + +@implementation Sub +- (int) Meth : (P*)array { + [super setCount : 100]; + + [super setCount : [array count]]; + + [[super PropertyReturnsPObj] setCount : [array count]]; + + [super setCount : (i1+i2*i3 - 100)]; + + return [super count] - + [(P*)0 count] + [array count] + + [fun() count] - + [[super PropertyReturnsPObj] count] + + [self->obj count]; +} +@end diff --git a/test/ARCMT/objcmt-property-dot-syntax.m.result b/test/ARCMT/objcmt-property-dot-syntax.m.result new file mode 100644 index 000000000000..6822d44ac0a5 --- /dev/null +++ b/test/ARCMT/objcmt-property-dot-syntax.m.result @@ -0,0 +1,61 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -objcmt-migrate-property-dot-syntax -mt-migrate-directory %t %s -x objective-c -fobjc-runtime-has-weak -fobjc-arc -triple x86_64-apple-darwin11 +// RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result +// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin10 -fsyntax-only -x objective-c -fobjc-runtime-has-weak -fobjc-arc %s.result + +// rdar://18498572 +@interface NSObject @end + +@interface P : NSObject +{ + P* obj; + int i1, i2, i3; +} +@property int count; +@property (copy) P* PropertyReturnsPObj; +- (P*) MethodReturnsPObj; +@end + +P* fun(); + +@implementation P +- (int) Meth : (P*)array { + obj.count = 100; + + ((P*)0).count = array.count; + + obj.PropertyReturnsPObj.count = array.count; + + obj.count = (i1+i2*i3 - 100); + + return obj.count - + ((P*)0).count + array.count + + fun().count - + obj.PropertyReturnsPObj.count + + self->obj.count; +} + +- (P*) MethodReturnsPObj { return 0; } +@end + +// rdar://19140267 +@interface Sub : P +@end + +@implementation Sub +- (int) Meth : (P*)array { + super.count = 100; + + super.count = array.count; + + super.PropertyReturnsPObj.count = array.count; + + super.count = (i1+i2*i3 - 100); + + return super.count - + ((P*)0).count + array.count + + fun().count - + super.PropertyReturnsPObj.count + + self->obj.count; +} +@end diff --git a/test/ARCMT/objcmt-undefined-ns-macros.m b/test/ARCMT/objcmt-undefined-ns-macros.m new file mode 100644 index 000000000000..2e1fa51d04b8 --- /dev/null +++ b/test/ARCMT/objcmt-undefined-ns-macros.m @@ -0,0 +1,24 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -objcmt-migrate-ns-macros -mt-migrate-directory %t %s -x objective-c -fobjc-runtime-has-weak -fobjc-arc -triple x86_64-apple-darwin11 +// RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result + +// rdar://18498550 + +typedef long NSInteger; +enum { + UIViewNone = 0x0, + UIViewMargin = 0x1, + UIViewWidth = 0x2, + UIViewRightMargin = 0x3, + UIViewBottomMargin = 0xbadbeef +}; +typedef NSInteger UITableStyle; + + +typedef + enum { two = 1 } NumericEnum2; + +typedef enum { three = 1 } NumericEnum3; + +typedef enum { four = 1 } NumericEnum4; + diff --git a/test/ARCMT/objcmt-undefined-ns-macros.m.result b/test/ARCMT/objcmt-undefined-ns-macros.m.result new file mode 100644 index 000000000000..30277ac57d49 --- /dev/null +++ b/test/ARCMT/objcmt-undefined-ns-macros.m.result @@ -0,0 +1,26 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -objcmt-migrate-ns-macros -mt-migrate-directory %t %s -x objective-c -fobjc-runtime-has-weak -fobjc-arc -triple x86_64-apple-darwin11 +// RUN: c-arcmt-test -mt-migrate-directory %t | arcmt-test -verify-transformed-files %s.result + +// rdar://18498550 + +typedef long NSInteger; +#ifndef NS_ENUM +@import Foundation; +#endif +typedef NS_OPTIONS(NSUInteger, UITableStyle) { + UIViewNone = 0x0, + UIViewMargin = 0x1, + UIViewWidth = 0x2, + UIViewRightMargin = 0x3, + UIViewBottomMargin = 0xbadbeef +}; + + +typedef + NS_ENUM(unsigned int, NumericEnum2) { two = 1 }; + +typedef NS_ENUM(unsigned int, NumericEnum3) { three = 1 }; + +typedef NS_ENUM(unsigned int, NumericEnum4) { four = 1 }; + diff --git a/test/Analysis/Inputs/Models/modeledFunction.model b/test/Analysis/Inputs/Models/modeledFunction.model new file mode 100644 index 000000000000..3aff5fc1b443 --- /dev/null +++ b/test/Analysis/Inputs/Models/modeledFunction.model @@ -0,0 +1,3 @@ +void modelled(intptr p) { + ++*p; +}
\ No newline at end of file diff --git a/test/Analysis/Inputs/Models/notzero.model b/test/Analysis/Inputs/Models/notzero.model new file mode 100644 index 000000000000..26161029d6ed --- /dev/null +++ b/test/Analysis/Inputs/Models/notzero.model @@ -0,0 +1,3 @@ +bool notzero(int i) { + return i != 0; +}
\ No newline at end of file diff --git a/test/Analysis/Inputs/system-header-simulator-for-pthread-lock.h b/test/Analysis/Inputs/system-header-simulator-for-pthread-lock.h new file mode 100644 index 000000000000..b290ffe8d879 --- /dev/null +++ b/test/Analysis/Inputs/system-header-simulator-for-pthread-lock.h @@ -0,0 +1,28 @@ +// Like the compiler, the static analyzer treats some functions differently if +// they come from a system header -- for example, pthread_mutex* functions +// should not invalidate regions of their arguments. +#pragma clang system_header + +typedef struct { + void *foo; +} pthread_mutex_t; + +typedef struct { + void *foo; +} pthread_mutexattr_t; + +typedef struct { + void *foo; +} lck_grp_t; + +typedef pthread_mutex_t lck_mtx_t; + +extern int pthread_mutex_lock(pthread_mutex_t *); +extern int pthread_mutex_unlock(pthread_mutex_t *); +extern int pthread_mutex_trylock(pthread_mutex_t *); +extern int pthread_mutex_destroy(pthread_mutex_t *); +extern int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); +extern int lck_mtx_lock(lck_mtx_t *); +extern int lck_mtx_unlock(lck_mtx_t *); +extern int lck_mtx_try_lock(lck_mtx_t *); +extern void lck_mtx_destroy(lck_mtx_t *lck, lck_grp_t *grp); diff --git a/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp b/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp index 5a596d47eca8..fca02aa278fd 100644 --- a/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp +++ b/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,unix.MismatchedDeallocator,cplusplus.NewDelete -std=c++11 -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,unix.MismatchedDeallocator,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,unix.MismatchedDeallocator,cplusplus.NewDelete,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -verify %s #include "Inputs/system-header-simulator-for-malloc.h" diff --git a/test/Analysis/Malloc+NewDelete_intersections.cpp b/test/Analysis/Malloc+NewDelete_intersections.cpp index 310663646a10..d10020dc8e66 100644 --- a/test/Analysis/Malloc+NewDelete_intersections.cpp +++ b/test/Analysis/Malloc+NewDelete_intersections.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete -std=c++11 -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks -std=c++11 -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,cplusplus.NewDeleteLeaks -std=c++11 -verify %s typedef __typeof(sizeof(int)) size_t; void *malloc(size_t); diff --git a/test/Analysis/NSContainers.m b/test/Analysis/NSContainers.m index 4b3492645682..402ce2c90a17 100644 --- a/test/Analysis/NSContainers.m +++ b/test/Analysis/NSContainers.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=core,osx.cocoa.NonNilReturnValue,osx.cocoa.NilArg,osx.cocoa.Loops,debug.ExprInspection -verify -Wno-objc-root-class %s +// RUN: %clang_cc1 -Wno-objc-literal-conversion -analyze -analyzer-checker=core,osx.cocoa.NonNilReturnValue,osx.cocoa.NilArg,osx.cocoa.Loops,debug.ExprInspection -verify -Wno-objc-root-class %s void clang_analyzer_eval(int); diff --git a/test/Analysis/NewDelete+MismatchedDeallocator_intersections.cpp b/test/Analysis/NewDelete+MismatchedDeallocator_intersections.cpp index b606f23ec8cc..49358f6a2aba 100644 --- a/test/Analysis/NewDelete+MismatchedDeallocator_intersections.cpp +++ b/test/Analysis/NewDelete+MismatchedDeallocator_intersections.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,unix.MismatchedDeallocator -std=c++11 -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks,unix.MismatchedDeallocator -DLEAKS -std=c++11 -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.MismatchedDeallocator -DLEAKS -std=c++11 -verify %s // expected-no-diagnostics typedef __typeof(sizeof(int)) size_t; diff --git a/test/Analysis/NewDelete-checker-test.cpp b/test/Analysis/NewDelete-checker-test.cpp index 855b05d66333..84176c9097ca 100644 --- a/test/Analysis/NewDelete-checker-test.cpp +++ b/test/Analysis/NewDelete-checker-test.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDeleteLeaks -DLEAKS -std=c++11 -fblocks -verify %s #include "Inputs/system-header-simulator-cxx.h" typedef __typeof__(sizeof(int)) size_t; diff --git a/test/Analysis/NewDelete-custom.cpp b/test/Analysis/NewDelete-custom.cpp index c64bfce2dee3..d368889c968e 100644 --- a/test/Analysis/NewDelete-custom.cpp +++ b/test/Analysis/NewDelete-custom.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -fblocks -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS -fblocks -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS -fblocks -verify %s #include "Inputs/system-header-simulator-cxx.h" #ifndef LEAKS diff --git a/test/Analysis/NewDelete-intersections.mm b/test/Analysis/NewDelete-intersections.mm index 9024ed57668b..886df1268f9f 100644 --- a/test/Analysis/NewDelete-intersections.mm +++ b/test/Analysis/NewDelete-intersections.mm @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete -std=c++11 -fblocks -verify %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks -std=c++11 -DLEAKS -fblocks -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks -std=c++11 -DLEAKS -fblocks -verify %s #include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-objc.h" diff --git a/test/Analysis/NewDelete-variadic.cpp b/test/Analysis/NewDelete-variadic.cpp index 62a7d17e1b2a..f9ef079bfe80 100644 --- a/test/Analysis/NewDelete-variadic.cpp +++ b/test/Analysis/NewDelete-variadic.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,alpha.cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -fblocks -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -fblocks -verify %s // expected-no-diagnostics namespace std { diff --git a/test/Analysis/NewDeleteLeaks-PR18394.cpp b/test/Analysis/NewDeleteLeaks-PR18394.cpp index dfd94561628f..d0d70375f5a2 100644 --- a/test/Analysis/NewDeleteLeaks-PR18394.cpp +++ b/test/Analysis/NewDeleteLeaks-PR18394.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyzer-config graph-trim-interval=1 -analyzer-max-loop 1 -analyze -analyzer-checker=core,alpha.cplusplus.NewDeleteLeaks -verify %s +// RUN: %clang_cc1 -analyzer-config graph-trim-interval=1 -analyzer-max-loop 1 -analyze -analyzer-checker=core,cplusplus.NewDeleteLeaks -verify %s // expected-no-diagnostics class A { diff --git a/test/Analysis/NewDeleteLeaks-PR19102.cpp b/test/Analysis/NewDeleteLeaks-PR19102.cpp new file mode 100644 index 000000000000..b141301e456f --- /dev/null +++ b/test/Analysis/NewDeleteLeaks-PR19102.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core,cplusplus.NewDeleteLeaks -verify %s + +class A0 {}; + +class A1 { +public: + A1(int); +}; + +struct S{ + int i; +}; + +class A2 { +public: + A2(); + A2(S); + A2(int*); + A2(S*); + A2(S&, int); + A2(int, S**); +}; + +void test() { + new int; // expected-warning@+1 {{Potential memory leak}} + new A0; // expected-warning@+1 {{Potential memory leak}} + new A1(0); // expected-warning@+1 {{Potential memory leak}} + new A2; // expected-warning@+1 {{Potential memory leak}} + S s; + s.i = 1; + S* ps = new S; + new A2(s); // expected-warning@+1 {{Potential memory leak}} + new A2(&(s.i)); // expected-warning@+1 {{Potential memory leak}} + new A2(ps); // no warning + new A2(*ps, 1); // no warning + new A2(1, &ps); // no warning + + // Tests to ensure that leaks are reported for consumed news no matter what the arguments are. + A2 *a2p1 = new A2; // expected-warning@+1 {{Potential leak of memory}} + A2 *a2p2 = new A2(ps); // expected-warning@+1 {{Potential leak of memory}} + A2 *a2p3 = new A2(*ps, 1); // expected-warning@+1 {{Potential leak of memory}} + A2 *a2p4 = new A2(1, &ps); // expected-warning@+1 {{Potential leak of memory}} +} diff --git a/test/Analysis/bstring.c b/test/Analysis/bstring.c index 69d281afee4a..824aa7c063b7 100644 --- a/test/Analysis/bstring.c +++ b/test/Analysis/bstring.c @@ -257,6 +257,45 @@ void mempcpy13() { mempcpy(a, 0, 0); // no-warning } +void mempcpy14() { + int src[] = {1, 2, 3, 4}; + int dst[5] = {0}; + int *p; + + p = mempcpy(dst, src, 4 * sizeof(int)); + + clang_analyzer_eval(p == &dst[4]); // expected-warning{{TRUE}} +} + +struct st { + int i; + int j; +}; + +void mempcpy15() { + struct st s1 = {0}; + struct st s2; + struct st *p1; + struct st *p2; + + p1 = (&s2) + 1; + p2 = mempcpy(&s2, &s1, sizeof(struct st)); + + clang_analyzer_eval(p1 == p2); // expected-warning{{TRUE}} +} + +void mempcpy16() { + struct st s1[10] = {{0}}; + struct st s2[10]; + struct st *p1; + struct st *p2; + + p1 = (&s2[0]) + 5; + p2 = mempcpy(&s2[0], &s1[0], 5 * sizeof(struct st)); + + clang_analyzer_eval(p1 == p2); // expected-warning{{TRUE}} +} + void mempcpy_unknown_size_warn (size_t n) { char a[4]; void *result = mempcpy(a, 0, n); // expected-warning{{Null pointer argument in call to memory copy function}} diff --git a/test/Analysis/builtin-functions.cpp b/test/Analysis/builtin-functions.cpp index 72d5ad23b16e..d3afab5bd615 100644 --- a/test/Analysis/builtin-functions.cpp +++ b/test/Analysis/builtin-functions.cpp @@ -22,3 +22,31 @@ void testSize() { clang_analyzer_eval(i == 0); // expected-warning{{TRUE}} } + +void test_assume_aligned_1(char *p) { + char *q; + + q = (char*) __builtin_assume_aligned(p, 16); + clang_analyzer_eval(p == q); // expected-warning{{TRUE}} +} + +void test_assume_aligned_2(char *p) { + char *q; + + q = (char*) __builtin_assume_aligned(p, 16, 8); + clang_analyzer_eval(p == q); // expected-warning{{TRUE}} +} + +void test_assume_aligned_3(char *p) { + void *q; + + q = __builtin_assume_aligned(p, 16, 8); + clang_analyzer_eval(p == q); // expected-warning{{TRUE}} +} + +void test_assume_aligned_4(char *p) { + char *q; + + q = (char*) __builtin_assume_aligned(p + 1, 16); + clang_analyzer_eval(p == q); // expected-warning{{FALSE}} +} diff --git a/test/Analysis/cfg.cpp b/test/Analysis/cfg.cpp index 65060b168744..28cc440c46fc 100644 --- a/test/Analysis/cfg.cpp +++ b/test/Analysis/cfg.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -std=c++11 %s > %t 2>&1 +// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -analyzer-config cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1 // RUN: FileCheck --input-file=%t %s // CHECK-LABEL: void checkWrap(int i) @@ -377,6 +377,61 @@ void test_placement_new_array() { } +// CHECK-LABEL: void test_lifetime_extended_temporaries() +// CHECK: [B1] +struct LifetimeExtend { LifetimeExtend(int); ~LifetimeExtend(); }; +struct Aggregate { const LifetimeExtend a; const LifetimeExtend b; }; +struct AggregateRef { const LifetimeExtend &a; const LifetimeExtend &b; }; +void test_lifetime_extended_temporaries() { + // CHECK: LifetimeExtend(1); + // CHECK-NEXT: : 1 + // CHECK-NEXT: ~LifetimeExtend() + // CHECK-NOT: ~LifetimeExtend() + { + const LifetimeExtend &l = LifetimeExtend(1); + 1; + } + // CHECK: LifetimeExtend(2) + // CHECK-NEXT: ~LifetimeExtend() + // CHECK-NEXT: : 2 + // CHECK-NOT: ~LifetimeExtend() + { + // No life-time extension. + const int &l = (LifetimeExtend(2), 2); + 2; + } + // CHECK: LifetimeExtend(3) + // CHECK-NEXT: : 3 + // CHECK-NEXT: ~LifetimeExtend() + // CHECK-NOT: ~LifetimeExtend() + { + // The last one is lifetime extended. + const LifetimeExtend &l = (3, LifetimeExtend(3)); + 3; + } + // CHECK: LifetimeExtend(4) + // CHECK-NEXT: ~LifetimeExtend() + // CHECK-NEXT: ~LifetimeExtend() + // CHECK-NEXT: : 4 + // CHECK-NOT: ~LifetimeExtend() + { + Aggregate a{LifetimeExtend(4), LifetimeExtend(4)}; + 4; + } + // CHECK: LifetimeExtend(5) + // CHECK-NEXT: : 5 + // FIXME: We want to emit the destructors of the lifetime + // extended variables here. + // CHECK-NOT: ~LifetimeExtend() + { + AggregateRef a{LifetimeExtend(5), LifetimeExtend(5)}; + 5; + } + // FIXME: Add tests for lifetime extension via subobject + // references (LifetimeExtend().some_member). +} + + // CHECK-LABEL: int *PR18472() // CHECK: [B2 (ENTRY)] // CHECK-NEXT: Succs (1): B1 diff --git a/test/Analysis/debug-CallGraph.c b/test/Analysis/debug-CallGraph.c index 4523c789351b..64259e2069a4 100644 --- a/test/Analysis/debug-CallGraph.c +++ b/test/Analysis/debug-CallGraph.c @@ -23,11 +23,22 @@ void bbb(int y) { foo(x, y); }(); } +void ccc(); +void ddd() { ccc(); } +void ccc() {} + +void eee(); +void eee() {} +void fff() { eee(); } // CHECK:--- Call graph Dump --- -// CHECK: Function: < root > calls: mmm foo aaa < > bbb -// CHECK: Function: bbb calls: < > -// CHECK: Function: < > calls: foo -// CHECK: Function: aaa calls: foo -// CHECK: Function: foo calls: mmm -// CHECK: Function: mmm calls: +// CHECK-NEXT: {{Function: < root > calls: mmm foo aaa < > bbb ccc ddd eee fff $}} +// CHECK-NEXT: {{Function: fff calls: eee $}} +// CHECK-NEXT: {{Function: eee calls: $}} +// CHECK-NEXT: {{Function: ddd calls: ccc $}} +// CHECK-NEXT: {{Function: ccc calls: $}} +// CHECK-NEXT: {{Function: bbb calls: < > $}} +// CHECK-NEXT: {{Function: < > calls: foo $}} +// CHECK-NEXT: {{Function: aaa calls: foo $}} +// CHECK-NEXT: {{Function: foo calls: mmm $}} +// CHECK-NEXT: {{Function: mmm calls: $}} diff --git a/test/Analysis/disable-all-checks.c b/test/Analysis/disable-all-checks.c new file mode 100644 index 000000000000..461e6d9bf94a --- /dev/null +++ b/test/Analysis/disable-all-checks.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core -analyzer-store=region -analyzer-disable-all-checks -verify %s +// RUN: %clang_cc1 -analyze -analyzer-disable-all-checks -analyzer-checker=core -analyzer-store=region -verify %s +// RUN: %clang --analyze -Xanalyzer -analyzer-disable-all-checks -Xclang -verify %s +// RUN: not %clang_cc1 -analyze -analyzer-checker=core -analyzer-store=region -analyzer-disable-checker -verify %s 2>&1 | FileCheck %s +// expected-no-diagnostics + +// CHECK: use -analyzer-disable-all-checks to disable all static analyzer checkers +int buggy() { + int x = 0; + return 5/x; // no warning +}
\ No newline at end of file diff --git a/test/Analysis/identical-expressions.cpp b/test/Analysis/identical-expressions.cpp index 85e3322002dd..46dd56289c4e 100644 --- a/test/Analysis/identical-expressions.cpp +++ b/test/Analysis/identical-expressions.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.core.IdenticalExpr -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.core.IdenticalExpr -w -verify %s /* Only one expected warning per function allowed at the very end. */ @@ -1511,3 +1511,22 @@ void test_nowarn_chained_if_stmts_3(int x) { else if (x++) // no-warning ; } + +void test_warn_wchar() { + const wchar_t * a = 0 ? L"Warning" : L"Warning"; // expected-warning {{identical expressions on both sides of ':' in conditional expression}} +} +void test_nowarn_wchar() { + const wchar_t * a = 0 ? L"No" : L"Warning"; +} + +void test_nowarn_long() { + int a = 0, b = 0; + long c; + if (0) { + b -= a; + c = 0; + } else { // no-warning + b -= a; + c = 0LL; + } +} diff --git a/test/Analysis/logical-ops.c b/test/Analysis/logical-ops.c index afaa2f107780..0b63bc9ec835 100644 --- a/test/Analysis/logical-ops.c +++ b/test/Analysis/logical-ops.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -verify %s +// RUN: %clang_cc1 -Wno-pointer-bool-conversion -analyze -analyzer-checker=core,debug.ExprInspection -verify %s void clang_analyzer_eval(int); diff --git a/test/Analysis/malloc-protoype.c b/test/Analysis/malloc-protoype.c new file mode 100644 index 000000000000..f056f0f2855d --- /dev/null +++ b/test/Analysis/malloc-protoype.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -w -analyze -analyzer-checker=core,unix.Malloc -verify %s +// expected-no-diagnostics + +// Test that strange prototypes doesn't crash the analyzer + +void malloc(int i); +void valloc(int i); + +void test1() +{ + malloc(1); +} + +void test2() +{ + valloc(1); +} diff --git a/test/Analysis/malloc-sizeof.cpp b/test/Analysis/malloc-sizeof.cpp new file mode 100644 index 000000000000..8589975f8fc2 --- /dev/null +++ b/test/Analysis/malloc-sizeof.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=unix.MallocSizeof -verify %s + +#include <stddef.h> + +void *malloc(size_t size); +void *calloc(size_t nmemb, size_t size); +void *realloc(void *ptr, size_t size); +void free(void *ptr); + +struct A {}; +struct B {}; + +void foo(unsigned int unsignedInt, unsigned int readSize) { + // Sanity check the checker is working as expected. + A* a = static_cast<A*>(malloc(sizeof(int))); // expected-warning {{Result of 'malloc' is converted to a pointer of type 'struct A', which is incompatible with sizeof operand type 'int'}} + free(a); +} + +void bar() { + A *x = static_cast<A*>(calloc(10, sizeof(void*))); // expected-warning {{Result of 'calloc' is converted to a pointer of type 'struct A', which is incompatible with sizeof operand type 'void *'}} + // sizeof(void*) is compatible with any pointer. + A **y = static_cast<A**>(calloc(10, sizeof(void*))); // no-warning + free(x); + free(y); +} + diff --git a/test/Analysis/misc-ps.m b/test/Analysis/misc-ps.m index 6da9604467de..ad7393b82d30 100644 --- a/test/Analysis/misc-ps.m +++ b/test/Analysis/misc-ps.m @@ -118,19 +118,6 @@ __m128i vec128i(long long __q1, long long __q0) { return __extension__ (__m128i)(__v2di){ __q0, __q1 }; } -// Zero-sized VLAs. -void check_zero_sized_VLA(int x) { - if (x) - return; - - int vla[x]; // expected-warning{{Declared variable-length array (VLA) has zero size}} -} - -void check_uninit_sized_VLA() { - int x; - int vla[x]; // expected-warning{{Declared variable-length array (VLA) uses a garbage value as its size}} -} - // sizeof(void) // - Tests a regression reported in PR 3211: http://llvm.org/bugs/show_bug.cgi?id=3211 void handle_sizeof_void(unsigned flag) { diff --git a/test/Analysis/model-file.cpp b/test/Analysis/model-file.cpp new file mode 100644 index 000000000000..24d6e9312da9 --- /dev/null +++ b/test/Analysis/model-file.cpp @@ -0,0 +1,288 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core -analyzer-config faux-bodies=true,model-path=%S/Inputs/Models -analyzer-output=plist-multi-file -verify %s -o %t +// RUN: FileCheck --input-file=%t %s + +typedef int* intptr; + +// This function is modeled and the p pointer is dereferenced in the model +// function and there is no function definition available. The modeled +// function can use any types that are available in the original translation +// unit, for example intptr in this case. +void modeledFunction(intptr p); + +// This function is modeled and returns true if the parameter is not zero +// and there is no function definition available. +bool notzero(int i); + +// This functions is not modeled and there is no function definition. +// available +bool notzero_notmodeled(int i); + +int main() { + // There is a nullpointer dereference inside this function. + modeledFunction(0); + + int p = 0; + if (notzero(p)) { + // It is known that p != 0 because of the information provided by the + // model of the notzero function. + int j = 5 / p; + } + + if (notzero_notmodeled(p)) { + // There is no information about the value of p, because + // notzero_notmodeled is not modeled and the function definition + // is not available. + int j = 5 / p; // expected-warning {{Division by zero}} + } + + return 0; +} + +// CHECK: <key>diagnostics</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>path</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>22</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>'p' initialized to 0</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>'p' initialized to 0</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>24</integer> +// CHECK-NEXT: <key>col</key><integer>5</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>25</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>3</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>4</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>control</string> +// CHECK-NEXT: <key>edges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>start</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>7</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>31</integer> +// CHECK-NEXT: <key>col</key><integer>24</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>end</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>kind</key><string>event</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <key>ranges</key> +// CHECK-NEXT: <array> +// CHECK-NEXT: <array> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>13</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>17</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>depth</key><integer>0</integer> +// CHECK-NEXT: <key>extended_message</key> +// CHECK-NEXT: <string>Division by zero</string> +// CHECK-NEXT: <key>message</key> +// CHECK-NEXT: <string>Division by zero</string> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array> +// CHECK-NEXT: <key>description</key><string>Division by zero</string> +// CHECK-NEXT: <key>category</key><string>Logic error</string> +// CHECK-NEXT: <key>type</key><string>Division by zero</string> +// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> +// CHECK-NEXT: <key>issue_context</key><string>main</string> +// CHECK-NEXT: <key>issue_hash</key><string>15</string> +// CHECK-NEXT: <key>location</key> +// CHECK-NEXT: <dict> +// CHECK-NEXT: <key>line</key><integer>35</integer> +// CHECK-NEXT: <key>col</key><integer>15</integer> +// CHECK-NEXT: <key>file</key><integer>0</integer> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </dict> +// CHECK-NEXT: </array>
\ No newline at end of file diff --git a/test/Analysis/nonnull.m b/test/Analysis/nonnull.m index 0cea80b536d8..c21360ded8d1 100644 --- a/test/Analysis/nonnull.m +++ b/test/Analysis/nonnull.m @@ -75,3 +75,121 @@ int rdar16153464(union rdar16153464_full_ctx_t inner) rdar16153464_check(inner); // no-warning rdar16153464_check(0); // expected-warning{{nonnull}} } + +// Multiple attributes, the basic case +void multipleAttributes_1(char *p, char *q) __attribute((nonnull(1))) __attribute((nonnull(2))); + +void testMultiple_1(void) { + char c; + multipleAttributes_1(&c, &c); // no-warning +} + +void testMultiple_2(void) { + char c; + multipleAttributes_1(0, &c); // expected-warning{{nonnull}} +} + +void testMultiple_3(void) { + char c; + multipleAttributes_1(&c, 0); // expected-warning{{nonnull}} +} + +void testMultiple_4(void) { + multipleAttributes_1(0, 0);// expected-warning{{nonnull}} +} + +// Multiple attributes, multiple prototypes +void multipleAttributes_2(char *p, char *q) __attribute((nonnull(1))); +void multipleAttributes_2(char *p, char *q) __attribute((nonnull(2))); + +void testMultiple_5(void) { + char c; + multipleAttributes_2(0, &c);// expected-warning{{nonnull}} +} + +void testMultiple_6(void) { + char c; + multipleAttributes_2(&c, 0);// expected-warning{{nonnull}} +} + +void testMultiple_7(void) { + multipleAttributes_2(0, 0);// expected-warning{{nonnull}} +} + +// Multiple attributes, same index +void multipleAttributes_3(char *p, char *q) __attribute((nonnull(1))) __attribute((nonnull(1))); + +void testMultiple_8(void) { + char c; + multipleAttributes_3(0, &c); // expected-warning{{nonnull}} +} + +void testMultiple_9(void) { + char c; + multipleAttributes_3(&c, 0); // no-warning +} + +// Multiple attributes, the middle argument is missing an attribute +void multipleAttributes_4(char *p, char *q, char *r) __attribute((nonnull(1))) __attribute((nonnull(3))); + +void testMultiple_10(void) { + char c; + multipleAttributes_4(0, &c, &c); // expected-warning{{nonnull}} +} + +void testMultiple_11(void) { + char c; + multipleAttributes_4(&c, 0, &c); // no-warning +} + +void testMultiple_12(void) { + char c; + multipleAttributes_4(&c, &c, 0); // expected-warning{{nonnull}} +} + + +// Multiple attributes, when the last is without index +void multipleAttributes_all_1(char *p, char *q) __attribute((nonnull(1))) __attribute((nonnull)); + +void testMultiple_13(void) { + char c; + multipleAttributes_all_1(0, &c); // expected-warning{{nonnull}} +} + +void testMultiple_14(void) { + char c; + multipleAttributes_all_1(&c, 0); // expected-warning{{nonnull}} +} + +// Multiple attributes, when the first is without index +void multipleAttributes_all_2(char *p, char *q) __attribute((nonnull)) __attribute((nonnull(2))); + +void testMultiple_15(void) { + char c; + multipleAttributes_all_2(0, &c); // expected-warning{{nonnull}} +} + +void testMultiple_16(void) { + char c; + multipleAttributes_all_2(&c, 0); // expected-warning{{nonnull}} +} + +void testVararg(int k, void *p) { + extern void testVararg_check(int, ...) __attribute__((nonnull)); + void *n = 0; + testVararg_check(0); + testVararg_check(1, p); + if (k == 1) + testVararg_check(1, n); // expected-warning{{nonnull}} + testVararg_check(2, p, p); + if (k == 2) + testVararg_check(2, n, p); // expected-warning{{nonnull}} + if (k == 3) + testVararg_check(2, p, n); // expected-warning{{nonnull}} +} + +void testNotPtr() { + struct S { int a; int b; int c; } s = {}; + extern void testNotPtr_check(struct S, int) __attribute__((nonnull(1, 2))); + testNotPtr_check(s, 0); +} diff --git a/test/Analysis/objc-boxing.m b/test/Analysis/objc-boxing.m index c23192e17e5d..73386f463bc8 100644 --- a/test/Analysis/objc-boxing.m +++ b/test/Analysis/objc-boxing.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,osx.cocoa.NonNilReturnValue,debug.ExprInspection -analyzer-store=region -verify %s +// RUN: %clang_cc1 -Wno-objc-literal-conversion -analyze -analyzer-checker=core,unix.Malloc,osx.cocoa.NonNilReturnValue,debug.ExprInspection -analyzer-store=region -verify %s void clang_analyzer_eval(int); diff --git a/test/Analysis/pthreadlock.c b/test/Analysis/pthreadlock.c index 2a59e0ffe98a..a6e29e78ff38 100644 --- a/test/Analysis/pthreadlock.c +++ b/test/Analysis/pthreadlock.c @@ -2,31 +2,10 @@ // Tests performing normal locking patterns and wrong locking orders -typedef struct { - void *foo; -} pthread_mutex_t; - -typedef struct { - void *foo; -} pthread_mutexattr_t; - -typedef struct { - void *foo; -} lck_grp_t; - -typedef pthread_mutex_t lck_mtx_t; - -extern int pthread_mutex_lock(pthread_mutex_t *); -extern int pthread_mutex_unlock(pthread_mutex_t *); -extern int pthread_mutex_trylock(pthread_mutex_t *); -extern int pthread_mutex_destroy(pthread_mutex_t *); -extern int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); -extern int lck_mtx_lock(lck_mtx_t *); -extern int lck_mtx_unlock(lck_mtx_t *); -extern int lck_mtx_try_lock(lck_mtx_t *); -extern void lck_mtx_destroy(lck_mtx_t *lck, lck_grp_t *grp); +#include "Inputs/system-header-simulator-for-pthread-lock.h" pthread_mutex_t mtx1, mtx2; +pthread_mutex_t *pmtx; lck_mtx_t lck1, lck2; lck_grp_t grp1; @@ -184,6 +163,21 @@ ok20(void) } void +ok21(void) { + pthread_mutex_lock(pmtx); // no-warning + pthread_mutex_unlock(pmtx); // no-warning +} + +void +ok22(void) { + pthread_mutex_lock(pmtx); // no-warning + pthread_mutex_unlock(pmtx); // no-warning + pthread_mutex_lock(pmtx); // no-warning + pthread_mutex_unlock(pmtx); // no-warning +} + + +void bad1(void) { pthread_mutex_lock(&mtx1); // no-warning diff --git a/test/Analysis/temp-obj-dtors-cfg-output.cpp b/test/Analysis/temp-obj-dtors-cfg-output.cpp index 5fb33d36b855..491c68e1bc8b 100644 --- a/test/Analysis/temp-obj-dtors-cfg-output.cpp +++ b/test/Analysis/temp-obj-dtors-cfg-output.cpp @@ -324,7 +324,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B3] // CHECK: 1: [B5.8] && [B4.5] // CHECK: 2: [B5.3]([B3.1]) -// CHECK: T: (Temp Dtor) [B5.8] && ... +// CHECK: T: (Temp Dtor) [B4.2] // CHECK: Preds (2): B4 B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4] @@ -354,7 +354,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B7] // CHECK: 1: [B9.5] && [B8.5] // CHECK: 2: bool a = A() && B(); -// CHECK: T: (Temp Dtor) [B9.5] && ... +// CHECK: T: (Temp Dtor) [B8.2] // CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B6 B5 // CHECK: [B8] @@ -390,9 +390,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B3] // CHECK: 1: [B5.8] || [B4.5] // CHECK: 2: [B5.3]([B3.1]) -// CHECK: T: (Temp Dtor) [B5.8] || ... +// CHECK: T: (Temp Dtor) [B4.2] // CHECK: Preds (2): B4 B5 -// CHECK: Succs (2): B1 B2 +// CHECK: Succs (2): B2 B1 // CHECK: [B4] // CHECK: 1: B() (CXXConstructExpr, class B) // CHECK: 2: [B4.1] (BindTemporary) @@ -420,9 +420,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B7] // CHECK: 1: [B9.5] || [B8.5] // CHECK: 2: bool a = A() || B(); -// CHECK: T: (Temp Dtor) [B9.5] || ... +// CHECK: T: (Temp Dtor) [B8.2] // CHECK: Preds (2): B8 B9 -// CHECK: Succs (2): B5 B6 +// CHECK: Succs (2): B6 B5 // CHECK: [B8] // CHECK: 1: B() (CXXConstructExpr, class B) // CHECK: 2: [B8.1] (BindTemporary) @@ -492,9 +492,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 3: [B7.2] // CHECK: 4: [B7.3] (CXXConstructExpr, class A) // CHECK: 5: A a = B() ? A() : A(B()); -// CHECK: T: (Temp Dtor) [B10.5] ? ... : ... +// CHECK: T: (Temp Dtor) [B9.2] // CHECK: Preds (2): B8 B9 -// CHECK: Succs (2): B5 B6 +// CHECK: Succs (2): B6 B5 // CHECK: [B8] // CHECK: 1: A() (CXXConstructExpr, class A) // CHECK: 2: [B8.1] (BindTemporary) @@ -533,7 +533,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B8 B9 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: C() : b_(true) // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] @@ -543,12 +542,10 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: ~C() // CHECK: [B1 (ENTRY)] // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: operator bool() // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] @@ -560,7 +557,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: D() : b_(true) // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] @@ -570,7 +566,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: operator bool() // CHECK: [B2 (ENTRY)] // CHECK: Succs (1): B1 // CHECK: [B1] @@ -582,7 +577,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (1): B1 -// CHECK: int test_cond_unnamed_custom_destructor() // CHECK: [B4 (ENTRY)] // CHECK: Succs (1): B3 // CHECK: [B1] @@ -607,7 +601,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B2 B1 // CHECK: [B0 (EXIT)] // CHECK: Preds (2): B1 B2 -// CHECK: int test_cond_named_custom_destructor() // CHECK: [B5 (ENTRY)] // CHECK: Succs (1): B4 // CHECK: [B1] @@ -642,7 +635,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B3 B2 // CHECK: [B0 (EXIT)] // CHECK: Preds (3): B1 B2 B3 -// CHECK: int test_cond_unnamed_auto_destructor() // CHECK: [B4 (ENTRY)] // CHECK: Succs (1): B3 // CHECK: [B1] @@ -665,7 +657,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B2 B1 // CHECK: [B0 (EXIT)] // CHECK: Preds (2): B1 B2 -// CHECK: int test_cond_named_auto_destructor() // CHECK: [B4 (ENTRY)] // CHECK: Succs (1): B3 // CHECK: [B1] @@ -718,9 +709,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B4.2] // CHECK: 4: [B7.3]([B4.3]) -// CHECK: T: (Temp Dtor) [B7.8] ? ... : ... +// CHECK: T: (Temp Dtor) [B6.2] // CHECK: Preds (2): B5 B6 -// CHECK: Succs (2): B2 B3 +// CHECK: Succs (2): B3 B2 // CHECK: [B5] // CHECK: 1: A() (CXXConstructExpr, class A) // CHECK: 2: [B5.1] (BindTemporary) @@ -775,9 +766,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B10.2] // CHECK: 4: const A &a = B() ? A() : A(B()); -// CHECK: T: (Temp Dtor) [B13.5] ? ... : ... +// CHECK: T: (Temp Dtor) [B12.2] // CHECK: Preds (2): B11 B12 -// CHECK: Succs (2): B8 B9 +// CHECK: Succs (2): B9 B8 // CHECK: [B11] // CHECK: 1: A() (CXXConstructExpr, class A) // CHECK: 2: [B11.1] (BindTemporary) @@ -819,9 +810,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B8 (ENTRY)] // CHECK: Succs (1): B7 // CHECK: [B1] -// CHECK: 1: ~A() (Temporary object destructor) -// CHECK: 2: int b; -// CHECK: 3: [B4.5].~A() (Implicit destructor) +// CHECK: 1: int b; +// CHECK: 2: [B4.5].~A() (Implicit destructor) // CHECK: Preds (2): B2 B3 // CHECK: Succs (1): B0 // CHECK: [B2] @@ -839,9 +829,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 3: [B4.2] // CHECK: 4: [B4.3] (CXXConstructExpr, class A) // CHECK: 5: A a = A() ?: A(); -// CHECK: T: (Temp Dtor) [B7.5] ? ... : ... +// CHECK: T: (Temp Dtor) [B6.2] // CHECK: Preds (2): B5 B6 -// CHECK: Succs (2): B2 B3 +// CHECK: Succs (2): B3 B2 // CHECK: [B5] // CHECK: 1: [B7.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 2: [B5.1] @@ -872,9 +862,8 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: [B13 (ENTRY)] // CHECK: Succs (1): B12 // CHECK: [B1] -// CHECK: 1: ~A() (Temporary object destructor) -// CHECK: 2: int b; -// CHECK: 3: [B9.4].~A() (Implicit destructor) +// CHECK: 1: int b; +// CHECK: 2: [B9.4].~A() (Implicit destructor) // CHECK: Preds (2): B2 B3 // CHECK: Succs (1): B0 // CHECK: [B2] @@ -887,15 +876,15 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B4 // CHECK: Succs (1): B1 // CHECK: [B4] -// CHECK: 1: [B7.5] ?: [B6.6] +// CHECK: 1: [B7.4] ?: [B6.6] // CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B4.2] -// CHECK: 4: [B7.3]([B4.3]) -// CHECK: T: (Temp Dtor) [B7.8] ? ... : ... +// CHECK: 4: [B7.2]([B4.3]) +// CHECK: T: (Temp Dtor) [B6.2] // CHECK: Preds (2): B5 B6 -// CHECK: Succs (2): B2 B3 +// CHECK: Succs (2): B3 B2 // CHECK: [B5] -// CHECK: 1: [B7.5] (ImplicitCastExpr, NoOp, const class A) +// CHECK: 1: [B7.4] (ImplicitCastExpr, NoOp, const class A) // CHECK: 2: [B5.1] // CHECK: 3: [B5.2] (CXXConstructExpr, class A) // CHECK: 4: [B5.3] (BindTemporary) @@ -911,16 +900,15 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Preds (1): B7 // CHECK: Succs (1): B4 // CHECK: [B7] -// CHECK: 1: ~A() (Temporary object destructor) -// CHECK: 2: foo -// CHECK: 3: [B7.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) -// CHECK: 4: A() (CXXConstructExpr, class A) -// CHECK: 5: [B7.4] (BindTemporary) -// CHECK: 6: [B7.5].operator bool -// CHECK: 7: [B7.5] -// CHECK: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) -// CHECK: T: [B7.8] ? ... : ... -// CHECK: Preds (2): B9 B8 +// CHECK: 1: foo +// CHECK: 2: [B7.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &)) +// CHECK: 3: A() (CXXConstructExpr, class A) +// CHECK: 4: [B7.3] (BindTemporary) +// CHECK: 5: [B7.4].operator bool +// CHECK: 6: [B7.4] +// CHECK: 7: [B7.6] (ImplicitCastExpr, UserDefinedConversion, _Bool) +// CHECK: T: [B7.7] ? ... : ... +// CHECK: Preds (2): B8 B9 // CHECK: Succs (2): B5 B6 // CHECK: [B8] // CHECK: 1: ~A() (Temporary object destructor) @@ -931,9 +919,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: 2: [B9.1] (ImplicitCastExpr, NoOp, const class A) // CHECK: 3: [B9.2] // CHECK: 4: const A &a = A() ?: A(); -// CHECK: T: (Temp Dtor) [B12.5] ? ... : ... +// CHECK: T: (Temp Dtor) [B11.2] // CHECK: Preds (2): B10 B11 -// CHECK: Succs (2): B7 B8 +// CHECK: Succs (2): B8 B7 // CHECK: [B10] // CHECK: 1: [B12.2] (ImplicitCastExpr, NoOp, const class A) // CHECK: 2: [B10.1] @@ -1089,6 +1077,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B2 // CHECK: [B1] // CHECK: 1: int b; +// CHECK: Preds (1): B2(Unreachable) // CHECK: Succs (1): B0 // CHECK: [B2 (NORETURN)] // CHECK: 1: int a; @@ -1105,6 +1094,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B2 // CHECK: [B1] // CHECK: 1: int b; +// CHECK: Preds (1): B2(Unreachable) // CHECK: Succs (1): B0 // CHECK: [B2 (NORETURN)] // CHECK: 1: int a; @@ -1117,7 +1107,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B0 (EXIT)] // CHECK: Preds (2): B1 B2 -// CHECK: int testConsistencyNestedSimple(bool value) // CHECK: [B9 (ENTRY)] // CHECK: Succs (1): B8 // CHECK: [B1] @@ -1132,7 +1121,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B3] // CHECK: T: if [B5.1] -// CHECK: Preds (1): B5 +// CHECK: Preds (2): B4(Unreachable) B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4 (NORETURN)] // CHECK: 1: ~NoReturn() (Temporary object destructor) @@ -1140,9 +1129,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B5] // CHECK: 1: [B7.3] || [B6.7] -// CHECK: T: (Temp Dtor) [B7.3] || ... +// CHECK: T: (Temp Dtor) [B6.4] // CHECK: Preds (2): B6 B7 -// CHECK: Succs (2): B3 B4 +// CHECK: Succs (2): B4 B3 // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) @@ -1168,7 +1157,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B7 B1 // CHECK: [B0 (EXIT)] // CHECK: Preds (3): B1 B2 B4 -// CHECK: int testConsistencyNestedComplex(bool value) // CHECK: [B10 (ENTRY)] // CHECK: Succs (1): B9 // CHECK: [B1] @@ -1183,7 +1171,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B3] // CHECK: T: if [B5.1] -// CHECK: Preds (1): B5 +// CHECK: Preds (2): B4(Unreachable) B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4 (NORETURN)] // CHECK: 1: ~NoReturn() (Temporary object destructor) @@ -1191,9 +1179,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B5] // CHECK: 1: [B8.3] || [B7.3] || [B6.7] -// CHECK: T: (Temp Dtor) [B8.3] || [B7.3] || ... +// CHECK: T: (Temp Dtor) [B6.4] // CHECK: Preds (3): B6 B7 B8 -// CHECK: Succs (2): B3 B4 +// CHECK: Succs (2): B4 B3 // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) @@ -1226,7 +1214,6 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (2): B8 B1 // CHECK: [B0 (EXIT)] // CHECK: Preds (3): B1 B2 B4 -// CHECK: int testConsistencyNestedNormalReturn(bool value) // CHECK: [B10 (ENTRY)] // CHECK: Succs (1): B9 // CHECK: [B1] @@ -1241,7 +1228,7 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B3] // CHECK: T: if [B5.1] -// CHECK: Preds (1): B5 +// CHECK: Preds (2): B4(Unreachable) B5 // CHECK: Succs (2): B2 B1 // CHECK: [B4 (NORETURN)] // CHECK: 1: ~NoReturn() (Temporary object destructor) @@ -1249,9 +1236,9 @@ int testConsistencyNestedNormalReturn(bool value) { // CHECK: Succs (1): B0 // CHECK: [B5] // CHECK: 1: [B8.3] || [B7.2] || [B6.7] -// CHECK: T: (Temp Dtor) [B8.3] || [B7.2] || ... +// CHECK: T: (Temp Dtor) [B6.4] // CHECK: Preds (3): B6 B7 B8 -// CHECK: Succs (2): B3 B4 +// CHECK: Succs (2): B4 B3 // CHECK: [B6] // CHECK: 1: check // CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &)) diff --git a/test/Analysis/temporaries.cpp b/test/Analysis/temporaries.cpp index c57d984a1dc8..6e476339cb77 100644 --- a/test/Analysis/temporaries.cpp +++ b/test/Analysis/temporaries.cpp @@ -1,8 +1,9 @@ // RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++03 %s // RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++11 %s -// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true %s +// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true %s -std=c++11 extern bool clang_analyzer_eval(bool); +extern bool clang_analyzer_warnIfReached(); struct Trivial { Trivial(int x) : value(x) {} @@ -111,13 +112,13 @@ namespace compound_literals { } namespace destructors { - void testPR16664andPR18159Crash() { - struct Dtor { - ~Dtor(); - }; - extern bool coin(); - extern bool check(const Dtor &); + struct Dtor { + ~Dtor(); + }; + extern bool coin(); + extern bool check(const Dtor &); + void testPR16664andPR18159Crash() { // Regression test: we used to assert here when tmp dtors are enabled. // PR16664 and PR18159 if (coin() && (coin() || coin() || check(Dtor()))) { @@ -193,8 +194,7 @@ namespace destructors { (i == 4 || i == 4 || compute(i == 5 && (i == 4 || check(NoReturnDtor()))))) || i != 4) { - // FIXME: This shouldn't cause a warning. - clang_analyzer_eval(true); // expected-warning{{TRUE}} + clang_analyzer_eval(true); // no warning, unreachable code } } @@ -211,8 +211,7 @@ namespace destructors { void testConsistencyNestedComplex(bool value) { if (value) { if (!value || !value || check(NoReturnDtor())) { - // FIXME: This shouldn't cause a warning. - clang_analyzer_eval(true); // expected-warning{{TRUE}} + clang_analyzer_eval(true); // no warning, unreachable code } } } @@ -225,6 +224,120 @@ namespace destructors { } } } + // PR16664 and PR18159 + void testConsistencyNestedComplexMidBranch(bool value) { + if (value) { + if (!value || !value || check(NoReturnDtor()) || value) { + clang_analyzer_eval(true); // no warning, unreachable code + } + } + } + + // PR16664 and PR18159 + void testConsistencyNestedComplexNestedBranch(bool value) { + if (value) { + if (!value || (!value || check(NoReturnDtor()) || value)) { + clang_analyzer_eval(true); // no warning, unreachable code + } + } + } + + // PR16664 and PR18159 + void testConsistencyNestedVariableModification(bool value) { + bool other = true; + if (value) { + if (!other || !value || (other = false) || check(NoReturnDtor()) || + !other) { + clang_analyzer_eval(true); // no warning, unreachable code + } + } + } + + void testTernaryNoReturnTrueBranch(bool value) { + if (value) { + bool b = value && (value ? check(NoReturnDtor()) : true); + clang_analyzer_eval(true); // no warning, unreachable code + } + } + void testTernaryNoReturnFalseBranch(bool value) { + if (value) { + bool b = !value && !value ? true : check(NoReturnDtor()); + clang_analyzer_eval(true); // no warning, unreachable code + } + } + void testTernaryIgnoreNoreturnBranch(bool value) { + if (value) { + bool b = !value && !value ? check(NoReturnDtor()) : true; + clang_analyzer_eval(true); // expected-warning{{TRUE}} + } + } + void testTernaryTrueBranchReached(bool value) { + value ? clang_analyzer_warnIfReached() : // expected-warning{{REACHABLE}} + check(NoReturnDtor()); + } + void testTernaryFalseBranchReached(bool value) { + value ? check(NoReturnDtor()) : + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + + void testLoop() { + for (int i = 0; i < 10; ++i) { + if (i < 3 && (i >= 2 || check(NoReturnDtor()))) { + clang_analyzer_eval(true); // no warning, unreachable code + } + } + } + + bool testRecursiveFrames(bool isInner) { + if (isInner || + (clang_analyzer_warnIfReached(), false) || // expected-warning{{REACHABLE}} + check(NoReturnDtor()) || + testRecursiveFrames(true)) { + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + } + void testRecursiveFramesStart() { testRecursiveFrames(false); } + + void testLambdas() { + // This is the test we would like to write: + // []() { check(NoReturnDtor()); } != nullptr || check(Dtor()); + // But currently the analyzer stops when it encounters a lambda: + [] {}; + // The CFG for this now looks correct, but we still do not reach the line + // below. + clang_analyzer_warnIfReached(); // FIXME: Should warn. + } + + void testGnuExpressionStatements(int v) { + ({ ++v; v == 10 || check(NoReturnDtor()); v == 42; }) || v == 23; + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + + ({ ++v; check(NoReturnDtor()); v == 42; }) || v == 23; + clang_analyzer_warnIfReached(); // no warning, unreachable code + } + + void testGnuExpressionStatementsDestructionPoint(int v) { + // In normal context, the temporary destructor runs at the end of the full + // statement, thus the last statement is reached. + (++v, check(NoReturnDtor()), v == 42), + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + + // GNU expression statements execute temporary destructors within the + // blocks, thus the last statement is not reached. + ({ ++v; check(NoReturnDtor()); v == 42; }), + clang_analyzer_warnIfReached(); // no warning, unreachable code + } + + void testMultipleTemporaries(bool value) { + if (value) { + // FIXME: Find a way to verify construction order. + // ~Dtor should run before ~NoReturnDtor() because construction order is + // guaranteed by comma operator. + if (!value || check((NoReturnDtor(), Dtor())) || value) { + clang_analyzer_eval(true); // no warning, unreachable code + } + } + } void testBinaryOperatorShortcut(bool value) { if (value) { @@ -234,6 +347,78 @@ namespace destructors { } } + void testIfAtEndOfLoop() { + int y = 0; + while (true) { + if (y > 0) { + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + ++y; + // Test that the CFG gets hooked up correctly when temporary destructors + // are handled after a statically known branch condition. + if (true) (void)0; else (void)check(NoReturnDtor()); + } + } + + void testTernaryAtEndOfLoop() { + int y = 0; + while (true) { + if (y > 0) { + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + ++y; + // Test that the CFG gets hooked up correctly when temporary destructors + // are handled after a statically known branch condition. + true ? (void)0 : (void)check(NoReturnDtor()); + } + } + + void testNoReturnInComplexCondition() { + check(Dtor()) && + (check(NoReturnDtor()) || check(NoReturnDtor())) && check(Dtor()); + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + + void testSequencingOfConditionalTempDtors(bool b) { + b || (check(Dtor()), check(NoReturnDtor())); + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + + void testSequencingOfConditionalTempDtors2(bool b) { + (b || check(Dtor())), check(NoReturnDtor()); + clang_analyzer_warnIfReached(); // no warning, unreachable code + } + + void testSequencingOfConditionalTempDtorsWithinBinaryOperators(bool b) { + b || (check(Dtor()) + check(NoReturnDtor())); + clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}} + } + + void f(Dtor d = Dtor()); + void testDefaultParameters() { + f(); + } + + struct DefaultParam { + DefaultParam(int, const Dtor& d = Dtor()); + ~DefaultParam(); + }; + void testDefaultParamConstructorsInLoops() { + while (true) { + // FIXME: This exact pattern triggers the temporary cleanup logic + // to fail when adding a 'clean' state. + DefaultParam(42); + DefaultParam(42); + } + } + void testDefaultParamConstructorsInTernariesInLoops(bool value) { + while (true) { + // FIXME: This exact pattern triggers the temporary cleanup logic + // to visit the bind-temporary logic with a state that already has that + // temporary marked as executed. + value ? DefaultParam(42) : DefaultParam(42); + } + } #endif // TEMPORARY_DTORS } diff --git a/test/Analysis/unix-api.c b/test/Analysis/unix-api.c new file mode 100644 index 000000000000..86c702d72594 --- /dev/null +++ b/test/Analysis/unix-api.c @@ -0,0 +1,75 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.API -verify %s + +#ifndef O_RDONLY +#define O_RDONLY 0 +#endif + +#ifndef NULL +#define NULL ((void*) 0) +#endif + +int open(const char *, int, ...); +int close(int fildes); + +void open_1(const char *path) { + int fd; + fd = open(path, O_RDONLY); // no-warning + if (fd > -1) + close(fd); +} + +void open_2(const char *path) { + int fd; + int mode = 0x0; + fd = open(path, O_RDONLY, mode, NULL); // expected-warning{{Call to 'open' with more than three arguments}} + if (fd > -1) + close(fd); +} + +void open_3(const char *path) { + int fd; + fd = open(path, O_RDONLY, NULL); // expected-warning{{Third argument to 'open' is not an integer}} + if (fd > -1) + close(fd); +} + +void open_4(const char *path) { + int fd; + fd = open(path, O_RDONLY, ""); // expected-warning{{Third argument to 'open' is not an integer}} + if (fd > -1) + close(fd); +} + +void open_5(const char *path) { + int fd; + struct { + int val; + } st = {0}; + fd = open(path, O_RDONLY, st); // expected-warning{{Third argument to 'open' is not an integer}} + if (fd > -1) + close(fd); +} + +void open_6(const char *path) { + int fd; + struct { + int val; + } st = {0}; + fd = open(path, O_RDONLY, st.val); // no-warning + if (fd > -1) + close(fd); +} + +void open_7(const char *path) { + int fd; + fd = open(path, O_RDONLY, &open); // expected-warning{{Third argument to 'open' is not an integer}} + if (fd > -1) + close(fd); +} + +void open_8(const char *path) { + int fd; + fd = open(path, O_RDONLY, 0.0f); // expected-warning{{Third argument to 'open' is not an integer}} + if (fd > -1) + close(fd); +} diff --git a/test/Analysis/virtualcall.cpp b/test/Analysis/virtualcall.cpp index c3319b0ac54f..8ce1d4103b9c 100644 --- a/test/Analysis/virtualcall.cpp +++ b/test/Analysis/virtualcall.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.VirtualCall -analyzer-store region -verify %s +// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.VirtualCall -analyzer-store region -verify -std=c++11 %s class A { public: @@ -46,10 +46,31 @@ C::C() { f(foo()); // expected-warning{{Call virtual functions during construction or destruction will never go to a more derived class}} } +class D : public B { +public: + D() { + foo(); // no-warning + } + ~D() { bar(); } + int foo() final; + void bar() final { foo(); } // no-warning +}; + +class E final : public B { +public: + E() { + foo(); // no-warning + } + ~E() { bar(); } + int foo() override; +}; + int main() { A *a; B *b; C *c; + D *d; + E *e; } #include "virtualcall.h" diff --git a/test/Analysis/vla.c b/test/Analysis/vla.c new file mode 100644 index 000000000000..f94bea96e8f6 --- /dev/null +++ b/test/Analysis/vla.c @@ -0,0 +1,86 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core -verify %s + +// Zero-sized VLAs. +void check_zero_sized_VLA(int x) { + if (x) + return; + + int vla[x]; // expected-warning{{Declared variable-length array (VLA) has zero size}} +} + +void check_uninit_sized_VLA() { + int x; + int vla[x]; // expected-warning{{Declared variable-length array (VLA) uses a garbage value as its size}} +} + +// Negative VLAs. +static void vla_allocate_signed(int x) { + int vla[x]; // expected-warning{{Declared variable-length array (VLA) has negative size}} +} + +static void vla_allocate_unsigned(unsigned int x) { + int vla[x]; // no-warning +} + +void check_negative_sized_VLA_1() { + vla_allocate_signed(-1); +} + +void check_negative_sized_VLA_2() { + vla_allocate_unsigned(-1); +} + +void check_negative_sized_VLA_3() { + int x = -1; + int vla[x]; // expected-warning{{Declared variable-length array (VLA) has negative size}} +} + +void check_negative_sized_VLA_4() { + unsigned int x = -1; + int vla[x]; // no-warning +} + +void check_negative_sized_VLA_5() { + signed char x = -1; + int vla[x]; // expected-warning{{Declared variable-length array (VLA) has negative size}} +} + +void check_negative_sized_VLA_6() { + unsigned char x = -1; + int vla[x]; // no-warning +} + +void check_negative_sized_VLA_7() { + signed char x = -1; + int vla[x + 2]; // no-warning +} + +void check_negative_sized_VLA_8() { + signed char x = 1; + int vla[x - 2]; // expected-warning{{Declared variable-length array (VLA) has negative size}} +} + +void check_negative_sized_VLA_9() { + int x = 1; + int vla[x]; // no-warning +} + +static void check_negative_sized_VLA_10_sub(int x) +{ + int vla[x]; // expected-warning{{Declared variable-length array (VLA) has negative size}} +} + +void check_negative_sized_VLA_10(int x) { + if (x < 0) + check_negative_sized_VLA_10_sub(x); +} + +static void check_negative_sized_VLA_11_sub(int x) +{ + int vla[x]; // no-warning +} + +void check_negative_sized_VLA_11(int x) { + if (x > 0) + check_negative_sized_VLA_11_sub(x); +} diff --git a/test/CXX/basic/basic.types/p10.cpp b/test/CXX/basic/basic.types/p10.cpp index 9d99a777449b..7b1af00b5d5c 100644 --- a/test/CXX/basic/basic.types/p10.cpp +++ b/test/CXX/basic/basic.types/p10.cpp @@ -38,15 +38,14 @@ constexpr ClassTemp<int> classtemplate2[] = {}; // - it has a trivial destructor struct UserProvDtor { - constexpr int f() const; // expected-error {{non-literal type 'UserProvDtor' cannot have constexpr members}} ~UserProvDtor(); // expected-note {{has a user-provided destructor}} }; - +constexpr int f(UserProvDtor) { return 0; } // expected-error {{'UserProvDtor' is not a literal type}} struct NonTrivDtor { constexpr NonTrivDtor(); - constexpr int f() const; // expected-error {{non-literal type 'NonTrivDtor' cannot have constexpr members}} virtual ~NonTrivDtor() = default; // expected-note {{has a non-trivial destructor}} expected-note {{because it is virtual}} }; +constexpr int f(NonTrivDtor) { return 0; } // expected-error {{'NonTrivDtor' is not a literal type}} struct NonTrivDtorBase { ~NonTrivDtorBase(); }; @@ -77,12 +76,12 @@ struct CtorTemplate { }; struct CopyCtorOnly { // expected-note {{'CopyCtorOnly' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}} constexpr CopyCtorOnly(CopyCtorOnly&); - constexpr int f() const; // expected-error {{non-literal type 'CopyCtorOnly' cannot have constexpr members}} }; +constexpr int f(CopyCtorOnly) { return 0; } // expected-error {{'CopyCtorOnly' is not a literal type}} struct MoveCtorOnly { // expected-note {{no constexpr constructors other than copy or move constructors}} constexpr MoveCtorOnly(MoveCtorOnly&&); - constexpr int f() const; // expected-error {{non-literal type 'MoveCtorOnly' cannot have constexpr members}} }; +constexpr int f(MoveCtorOnly) { return 0; } // expected-error {{'MoveCtorOnly' is not a literal type}} template<typename T> struct CtorArg { constexpr CtorArg(T); @@ -110,8 +109,8 @@ constexpr int f(NonLitMember) {} // expected-error {{1st parameter type 'NonLitM struct NonLitBase : S { // expected-note {{base class 'S' of non-literal type}} constexpr NonLitBase(); - constexpr int f() const { return 0; } // expected-error {{non-literal type 'NonLitBase' cannot have constexpr members}} }; +constexpr int f(NonLitBase) { return 0; } // expected-error {{'NonLitBase' is not a literal type}} struct LitMemBase : Agg { Agg agg; }; diff --git a/test/CXX/class.access/class.friend/p11.cpp b/test/CXX/class.access/class.friend/p11.cpp index ba44a0d49245..a5107fd20728 100644 --- a/test/CXX/class.access/class.friend/p11.cpp +++ b/test/CXX/class.access/class.friend/p11.cpp @@ -24,6 +24,8 @@ namespace test2 { void foo() { // expected-note {{'::test2::foo' declared here}} struct S1 { friend void foo(); // expected-error {{no matching function 'foo' found in local scope; did you mean '::test2::foo'?}} + // expected-note@-1{{'::test2::foo' declared here}} + // TODO: the above note should go on line 24 }; void foo(); // expected-note {{local declaration nearly matches}} @@ -40,17 +42,19 @@ namespace test2 { { int foo; struct S3 { - friend void foo(); // expected-error {{no matching function found in local scope}} + friend void foo(); // expected-error {{no matching function 'foo' found in local scope; did you mean '::test2::foo'?}} }; } struct S4 { friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean '::test2::bar'?}} + // expected-note@-1 2 {{'::test2::bar' declared here}} + // TODO: the above two notes should go on line 22 }; { void bar(); } struct S5 { - friend void bar(); // expected-error {{no matching function found in local scope}} + friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean '::test2::bar'?}} }; { @@ -85,7 +89,7 @@ namespace test2 { void quux() {} void foo() { struct Inner1 { - friend void bar(); // expected-error {{no matching function found in local scope}} + friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean '::test2::bar'?}} friend void quux(); // expected-error {{no matching function found in local scope}} }; diff --git a/test/CXX/class/class.mem/p2.cpp b/test/CXX/class/class.mem/p2.cpp index 4aa4a5c6f1b7..d45c03860654 100644 --- a/test/CXX/class/class.mem/p2.cpp +++ b/test/CXX/class/class.mem/p2.cpp @@ -56,3 +56,33 @@ namespace test3 { template struct A2<int>; } + +namespace PR12629 { + struct S { + static int (f)() throw(); + static int ((((((g))))() throw(U))); + int (*h)() noexcept(false); + static int (&i)() noexcept(true); + static int (*j)() throw(U); // expected-error {{unknown type name 'U'}} + static int (k)() throw(U); + + struct U {}; + }; + static_assert(noexcept(S::f()), ""); + static_assert(!noexcept(S::g()), ""); + static_assert(!noexcept(S().h()), ""); + static_assert(noexcept(S::i()), ""); +} + +namespace PR12688 { + struct S { + // FIXME: Producing one error saying this can't have the same name + // as the class because it's not a constructor, then producing + // another error saying this can't have a return type because + // it is a constructor, is redundant and inconsistent. + nonsense S() throw (more_nonsense); // \ + // expected-error {{'nonsense'}} \ + // expected-error {{has the same name as its class}} \ + // expected-error {{constructor cannot have a return type}} + }; +} diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp index 4f89dcfb3f52..ebe5388d65ac 100644 --- a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp +++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp @@ -17,6 +17,11 @@ void f() { using X::s; // expected-error{{using declaration cannot refer to class member}} } +template <typename T> +struct PR21933 : T { + static void StaticFun() { using T::member; } // expected-error{{using declaration cannot refer to class member}} +}; + struct S { static int n; struct Q {}; diff --git a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.deprecated/p1.cpp b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.deprecated/p1.cpp index 3bbbf9eed6e4..a27cea84db45 100644 --- a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.deprecated/p1.cpp +++ b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.deprecated/p1.cpp @@ -21,8 +21,7 @@ e my_enum; // expected-warning {{'e' is deprecated}} template <typename T> class X {}; template <> class [[deprecated]] X<int> {}; // expected-note {{'X<int>' has been explicitly marked deprecated here}} X<char> x1; -// FIXME: The diagnostic here could be much better by mentioning X<int>. -X<int> x2; // expected-warning {{'X' is deprecated}} +X<int> x2; // expected-warning {{'X<int>' is deprecated}} template <typename T> class [[deprecated]] X2 {}; template <> class X2<int> {}; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp index 08fefdc91fb5..35dbec93e5bb 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp @@ -71,7 +71,7 @@ struct ConstexprDtor { template <typename T> constexpr T ft(T t) { return t; } template <typename T> T gt(T t) { return t; } struct S { - template<typename T> constexpr T f(); // expected-warning {{C++1y}} + template<typename T> constexpr T f(); // expected-warning {{C++14}} template <typename T> T g() const; // expected-note-re {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}} }; @@ -82,7 +82,7 @@ template <> char ft(char c) { return c; } // expected-note {{previous}} template <> constexpr char ft(char nl); // expected-error {{constexpr declaration of 'ft<char>' follows non-constexpr declaration}} template <> constexpr int gt(int nl) { return nl; } template <> notlit S::f() const { return notlit(); } -template <> constexpr int S::g() { return 0; } // expected-note {{previous}} expected-warning {{C++1y}} +template <> constexpr int S::g() { return 0; } // expected-note {{previous}} expected-warning {{C++14}} template <> int S::g() const; // expected-error {{non-constexpr declaration of 'g<int>' follows constexpr declaration}} // specializations can drop the 'constexpr' but not the implied 'const'. template <> char S::g() { return 0; } // expected-error {{no function template matches}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp index 780a420959d6..1e3734e54311 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp @@ -21,15 +21,15 @@ struct Literal { struct S { virtual int ImplicitlyVirtual() const = 0; // expected-note {{overridden virtual function}} }; -struct SS : S { +struct SS : S { int ImplicitlyVirtual() const; }; // The definition of a constexpr function shall satisfy the following // constraints: -struct T : SS, NonLiteral { // expected-note {{base class 'NonLiteral' of non-literal type}} +struct T : SS, NonLiteral { constexpr T(); - constexpr int f() const; // expected-error {{non-literal type 'T' cannot have constexpr members}} + constexpr int f() const; // - it shall not be virtual; virtual constexpr int ExplicitlyVirtual() const { return 0; } // expected-error {{virtual function cannot be constexpr}} @@ -62,7 +62,7 @@ struct T : SS, NonLiteral { // expected-note {{base class 'NonLiteral' of non-li constexpr T &operator=(const T&) = default; #ifndef CXX1Y // expected-error@-2 {{an explicitly-defaulted copy assignment operator may not have 'const', 'constexpr' or 'volatile' qualifiers}} - // expected-warning@-3 {{C++1y}} + // expected-warning@-3 {{C++14}} #else // expected-error@-5 {{defaulted definition of copy assignment operator is not constexpr}} #endif @@ -161,21 +161,21 @@ constexpr int ForStmt() { constexpr int VarDecl() { int a = 0; #ifndef CXX1Y - // expected-error@-2 {{variable declaration in a constexpr function is a C++1y extension}} + // expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}} #endif return 0; } constexpr int ConstexprVarDecl() { constexpr int a = 0; #ifndef CXX1Y - // expected-error@-2 {{variable declaration in a constexpr function is a C++1y extension}} + // expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}} #endif return 0; } constexpr int VarWithCtorDecl() { Literal a; #ifndef CXX1Y - // expected-error@-2 {{variable declaration in a constexpr function is a C++1y extension}} + // expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}} #endif return 0; } @@ -183,7 +183,7 @@ NonLiteral nl; constexpr NonLiteral &ExternNonLiteralVarDecl() { extern NonLiteral nl; #ifndef CXX1Y - // expected-error@-2 {{variable declaration in a constexpr function is a C++1y extension}} + // expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}} #endif return nl; } @@ -191,28 +191,28 @@ static_assert(&ExternNonLiteralVarDecl() == &nl, ""); constexpr int FuncDecl() { constexpr int ForwardDecl(int); #ifndef CXX1Y - // expected-error@-2 {{use of this statement in a constexpr function is a C++1y extension}} + // expected-error@-2 {{use of this statement in a constexpr function is a C++14 extension}} #endif return ForwardDecl(42); } constexpr int ClassDecl1() { typedef struct { } S1; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr function is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr function is a C++14 extension}} #endif return 0; } constexpr int ClassDecl2() { using S2 = struct { }; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr function is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr function is a C++14 extension}} #endif return 0; } constexpr int ClassDecl3() { struct S3 { }; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr function is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr function is a C++14 extension}} #endif return 0; } @@ -245,11 +245,11 @@ namespace DR1364 { namespace rdar13584715 { typedef __PTRDIFF_TYPE__ ptrdiff_t; - + template<typename T> struct X { static T value() {}; }; - + void foo(ptrdiff_t id) { switch (id) { case reinterpret_cast<ptrdiff_t>(&X<long>::value): // expected-error{{case value is not a constant expression}} \ @@ -269,7 +269,7 @@ namespace std_example { constexpr int abs(int x) { if (x < 0) #ifndef CXX1Y - // expected-error@-2 {{C++1y}} + // expected-error@-2 {{C++14}} #endif x = -x; return x; @@ -295,7 +295,7 @@ namespace std_example { return r; } #ifndef CXX1Y - // expected-error@-5 {{C++1y}} + // expected-error@-5 {{C++14}} // expected-error@-5 {{statement not allowed}} #endif } diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp index 708c259d5b61..9c1cab54b617 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp @@ -92,37 +92,37 @@ struct V { constexpr V(int(&)[2]) { constexpr int a = 0; #ifndef CXX1Y - // expected-error@-2 {{variable declaration in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{variable declaration in a constexpr constructor is a C++14 extension}} #endif } constexpr V(int(&)[3]) { constexpr int ForwardDecl(int); #ifndef CXX1Y - // expected-error@-2 {{use of this statement in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{use of this statement in a constexpr constructor is a C++14 extension}} #endif } constexpr V(int(&)[4]) { typedef struct { } S1; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}} #endif } constexpr V(int(&)[5]) { using S2 = struct { }; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}} #endif } constexpr V(int(&)[6]) { struct S3 { }; #ifndef CXX1Y - // expected-error@-2 {{type definition in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}} #endif } constexpr V(int(&)[7]) { return; #ifndef CXX1Y - // expected-error@-2 {{use of this statement in a constexpr constructor is a C++1y extension}} + // expected-error@-2 {{use of this statement in a constexpr constructor is a C++14 extension}} #endif } }; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp index 5e40f69d77ba..48973237ea0b 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp @@ -102,7 +102,7 @@ X x = cmin(X(), X()); // ok, not constexpr template<typename T> struct Y { constexpr Y() {} - constexpr int get() { return T(); } // expected-warning {{C++1y}} + constexpr int get() { return T(); } // expected-warning {{C++14}} }; struct Z { operator int(); }; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p8.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p8.cpp index 40aa600ba1f7..428fd50b270f 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p8.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p8.cpp @@ -3,13 +3,13 @@ using size_t = decltype(sizeof(int)); struct S { - constexpr int f(); // expected-warning {{C++1y}} + constexpr int f(); // expected-warning {{C++14}} constexpr int g() const; - constexpr int h(); // expected-warning {{C++1y}} + constexpr int h(); // expected-warning {{C++14}} int h(); static constexpr int Sf(); /*static*/ constexpr void *operator new(size_t) noexcept; - template<typename T> constexpr T tm(); // expected-warning {{C++1y}} + template<typename T> constexpr T tm(); // expected-warning {{C++14}} template<typename T> static constexpr T ts(); }; @@ -26,20 +26,20 @@ void f(const S &s) { } constexpr int S::f() const { return 0; } -constexpr int S::g() { return 1; } // expected-warning {{C++1y}} -constexpr int S::h() { return 0; } // expected-warning {{C++1y}} +constexpr int S::g() { return 1; } // expected-warning {{C++14}} +constexpr int S::h() { return 0; } // expected-warning {{C++14}} int S::h() { return 0; } constexpr int S::Sf() { return 2; } constexpr void *S::operator new(size_t) noexcept { return 0; } -template<typename T> constexpr T S::tm() { return T(); } // expected-warning {{C++1y}} +template<typename T> constexpr T S::tm() { return T(); } // expected-warning {{C++14}} template<typename T> constexpr T S::ts() { return T(); } namespace std_example { - class debug_flag { // expected-note {{not an aggregate and has no constexpr constructors}} + class debug_flag { public: explicit debug_flag(bool); - constexpr bool is_on() const; // expected-error {{non-literal type 'std_example::debug_flag' cannot have constexpr members}} + constexpr bool is_on() const; // ok (dr1684) private: bool flag; }; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p9.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p9.cpp index 2412a145f866..5f102e7458ea 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p9.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p9.cpp @@ -17,7 +17,7 @@ extern int (*const d)(int); // A variable declaration which uses the constexpr specifier shall have an // initializer and shall be initialized by a constant expression. -constexpr int ni1; // expected-error {{default initialization of an object of const type 'const int'}} +constexpr int ni1; // expected-error {{default initialization of an object of const type 'const int'}} expected-note {{add an explicit initializer to initialize 'ni1'}} constexpr struct C { C(); } ni2; // expected-error {{cannot have non-literal type 'const struct C'}} expected-note 3{{has no constexpr constructors}} constexpr double &ni3; // expected-error {{declaration of reference variable 'ni3' requires an initializer}} @@ -34,4 +34,4 @@ struct pixel { int x, y; }; constexpr pixel ur = { 1294, 1024 }; // ok -constexpr pixel origin; // expected-error {{default initialization of an object of const type 'const pixel' requires a user-provided default constructor}} +constexpr pixel origin; // expected-error {{default initialization of an object of const type 'const pixel' without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'origin'}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp index cc44f74a5547..865abb081a44 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp @@ -44,7 +44,7 @@ namespace VariableLengthArrays { void f() { int n = 42; - goto foo; // expected-error {{goto into protected scope}} + goto foo; // expected-error {{cannot jump}} using T = int[n]; // expected-note {{bypasses initialization of VLA type alias}} foo: ; } diff --git a/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.default/p2.cpp b/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.default/p2.cpp index b9a1bc52886c..81876192caa7 100644 --- a/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.default/p2.cpp +++ b/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.default/p2.cpp @@ -36,7 +36,7 @@ struct S3 { constexpr S3 s3a = S3(0); constexpr S3 s3b = s3a; constexpr S3 s3c = S3(); -constexpr S3 s3d; // expected-error {{default initialization of an object of const type 'const S3' requires a user-provided default constructor}} +constexpr S3 s3d; // expected-error {{default initialization of an object of const type 'const S3' without a user-provided default constructor}} expected-note{{add an explicit initializer to initialize 's3d'}} struct S4 { S4() = default; @@ -119,6 +119,6 @@ namespace PR13492 { }; void f() { - const B b; // expected-error {{default initialization of an object of const type 'const PR13492::B' requires a user-provided default constructor}} + const B b; // expected-error {{default initialization of an object of const type 'const PR13492::B' without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'b'}} } } diff --git a/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.general/p8.cpp b/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.general/p8.cpp new file mode 100644 index 000000000000..ff5d3dec3083 --- /dev/null +++ b/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.general/p8.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify +// expected-no-diagnostics + +using size_t = decltype(sizeof(0)); +template<typename T> struct check; +template<size_t N> struct check<const char[N]> {}; + +constexpr bool startswith(const char *p, const char *q) { + return !*q || (*p == *q && startswith(p + 1, q + 1)); +} +constexpr bool contains(const char *p, const char *q) { + return *p && (startswith(p, q) || contains(p + 1, q)); +} + +void foo() { + check<decltype(__func__)>(); + static_assert(contains(__func__, "foo"), ""); +} diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp index 971e0c11aff1..d7ffd0758a68 100644 --- a/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp +++ b/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp @@ -4,7 +4,7 @@ namespace std { typedef decltype(sizeof(int)) size_t; template <typename E> - struct initializer_list // expected-note 2{{candidate}} + struct initializer_list { const E *p; size_t n; @@ -112,15 +112,16 @@ namespace bullet8 { } namespace rdar13395022 { - struct MoveOnly { - MoveOnly(MoveOnly&&); + struct MoveOnly { // expected-note {{candidate}} + MoveOnly(MoveOnly&&); // expected-note 2{{copy constructor is implicitly deleted because}} expected-note {{candidate}} }; void test(MoveOnly mo) { - // FIXME: These diagnostics are poor. - auto &&list1 = {mo}; // expected-error{{no viable conversion}} - MoveOnly (&&list2)[1] = {mo}; // expected-error{{no viable conversion}} + auto &&list1 = {mo}; // expected-error {{call to implicitly-deleted copy constructor}} expected-note {{in initialization of temporary of type 'std::initializer_list}} + MoveOnly (&&list2)[1] = {mo}; // expected-error {{call to implicitly-deleted copy constructor}} expected-note {{in initialization of temporary of type 'rdar13395022::MoveOnly [1]'}} std::initializer_list<MoveOnly> &&list3 = {}; - MoveOnly (&&list4)[1] = {}; // expected-error{{uninitialized}} + MoveOnly (&&list4)[1] = {}; // expected-error {{no matching constructor}} + // expected-note@-1 {{in implicit initialization of array element 0 with omitted initializer}} + // expected-note@-2 {{in initialization of temporary of type 'rdar13395022::MoveOnly [1]' created to list-initialize this reference}} } } diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp index 4ba75efebbb3..f86b24e99259 100644 --- a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp +++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -verify %s +// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify %s // C++03 requires that we check for a copy constructor when binding a // reference to a temporary, since we are allowed to make a copy, Even diff --git a/test/CXX/dcl.decl/dcl.init/p6.cpp b/test/CXX/dcl.decl/dcl.init/p6.cpp index 514fd0c9b620..76b7e7625d57 100644 --- a/test/CXX/dcl.decl/dcl.init/p6.cpp +++ b/test/CXX/dcl.decl/dcl.init/p6.cpp @@ -10,15 +10,15 @@ struct NoUserDefault : public MakeNonPOD { }; struct HasUserDefault { HasUserDefault(); }; void test_const_default_init() { - const NoUserDefault x1; // expected-error{{default initialization of an object of const type 'const NoUserDefault' requires a user-provided default constructor}} + const NoUserDefault x1; // expected-error{{default initialization of an object of const type 'const NoUserDefault' without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'x1'}} const HasUserDefault x2; - const int x3; // expected-error{{default initialization of an object of const type 'const int'}} + const int x3; // expected-error{{default initialization of an object of const type 'const int'}} expected-note{{add an explicit initializer to initialize 'x3'}} } // rdar://8501008 struct s0 {}; struct s1 { static const s0 foo; }; -const struct s0 s1::foo; // expected-error{{default initialization of an object of const type 'const struct s0' requires a user-provided default constructor}} +const struct s0 s1::foo; // expected-error{{default initialization of an object of const type 'const struct s0' without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'foo'}} template<typename T> struct s2 { diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp index 19a5f23e3f17..de1c5a708db6 100644 --- a/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp +++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p13.cpp @@ -46,3 +46,34 @@ struct X2 { template<typename T> void f4(T ...args); // expected-error{{type 'T' of function parameter pack does not contain any unexpanded parameter packs}} +void f4i(int ... x); // expected-error{{type 'int' of function parameter pack does not contain any unexpanded parameter packs}} +void f4i0(int ...); + +namespace array_type { +template<typename T> +void a(T[] ... x); // expected-error{{expected ')'}} expected-note{{to match this '('}} + +template<typename T> +void b(T[] ...); + +template<typename T> +void c(T ... []); // expected-error{{type 'T []' of function parameter pack does not contain any unexpanded parameter packs}} + +template<typename T> +void d(T ... x[]); // expected-error{{type 'T []' of function parameter pack does not contain any unexpanded parameter packs}} + +void ai(int[] ... x); // expected-error{{expected ')'}} expected-note{{to match this '('}} +void bi(int[] ...); +void ci(int ... []); // expected-error{{type 'int []' of function parameter pack does not contain any unexpanded parameter packs}} +void di(int ... x[]); // expected-error{{type 'int []' of function parameter pack does not contain any unexpanded parameter packs}} +} + +void f5a(auto fp(int)->unk ...) {} // expected-error{{unknown type name 'unk'}} +void f5b(auto fp(int)->auto ...) {} // expected-error{{'auto' not allowed in function return type}} +void f5c(auto fp()->...) {} // expected-error{{expected a type}} + +// FIXME: Expand for function and member pointer types. + + + + diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p14.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p14.cpp index bc249b5a087b..ac9344dea1c1 100644 --- a/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p14.cpp +++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p14.cpp @@ -1,5 +1,4 @@ // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -// expected-no-diagnostics template<typename T> struct identity; template<typename ...Types> struct tuple; @@ -22,7 +21,7 @@ template<typename T> struct is_same<T, T> { template<typename T, typename ...Types> struct X0 { typedef identity<T(Types...)> function_pack_1; - typedef identity<T(Types......)> variadic_function_pack_1; + typedef identity<T(Types......)> variadic_function_pack_1; // expected-warning {{varargs}} expected-note {{pack}} expected-note {{insert ','}} typedef identity<T(T...)> variadic_1; typedef tuple<T(Types, ...)...> template_arg_expansion_1; }; diff --git a/test/CXX/dcl.decl/dcl.meaning/p1.cpp b/test/CXX/dcl.decl/dcl.meaning/p1.cpp index 5747380f2806..cefee7b8dc41 100644 --- a/test/CXX/dcl.decl/dcl.meaning/p1.cpp +++ b/test/CXX/dcl.decl/dcl.meaning/p1.cpp @@ -27,6 +27,7 @@ namespace NS { struct X; template<typename T> struct Y; template<typename T> void wibble(T); + struct Z; } namespace NS { // Under DR482, these are all valid, except for forward-declaring a struct @@ -43,3 +44,6 @@ namespace NS { template<typename T> struct NS::Y { }; // expected-warning{{extra qualification on member 'Y'}} template<typename T> void NS::wibble(T) { } // expected-warning{{extra qualification on member 'wibble'}} } + +struct ::{} a; // expected-error{{expected identifier}} +struct NS::Z:: {} b; // expected-error{{expected identifier}} diff --git a/test/CXX/drs/dr0xx.cpp b/test/CXX/drs/dr0xx.cpp index 29e1720b1bbf..5b34cc3380c1 100644 --- a/test/CXX/drs/dr0xx.cpp +++ b/test/CXX/drs/dr0xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors namespace dr1 { // dr1: no namespace X { extern "C" void dr1_f(int a = 1); } @@ -520,17 +521,28 @@ namespace dr48 { // dr48: yes } namespace dr49 { // dr49: yes - template<int*> struct A {}; // expected-note {{here}} + template<int*> struct A {}; // expected-note 0-2{{here}} int k; #if __has_feature(cxx_constexpr) constexpr #endif - int *const p = &k; + int *const p = &k; // expected-note 0-2{{here}} A<&k> a; - A<p> b; // expected-error {{must have its address taken}} + A<p> b; +#if __cplusplus <= 201402L + // expected-error@-2 {{must have its address taken}} +#endif +#if __cplusplus < 201103L + // expected-error@-5 {{internal linkage}} +#endif + int *q = &k; + A<q> c; #if __cplusplus < 201103L - // expected-error@-2 {{internal linkage}} - // expected-note@-5 {{here}} + // expected-error@-2 {{must have its address taken}} +#else + // expected-error@-4 {{constant expression}} + // expected-note@-5 {{read of non-constexpr}} + // expected-note@-7 {{declared here}} #endif } @@ -822,7 +834,7 @@ namespace dr70 { // dr70: yes namespace dr73 { // dr73: no // The resolution to dr73 is unworkable. Consider: int a, b; - static_assert(&a + 1 != &b, ""); + static_assert(&a + 1 != &b, ""); // expected-error {{not an integral constant expression}} } #endif @@ -852,7 +864,7 @@ namespace dr77 { // dr77: yes namespace dr78 { // dr78: sup ???? // Under DR78, this is valid, because 'k' has static storage duration, so is // zero-initialized. - const int k; // expected-error {{default initialization of an object of const}} + const int k; // expected-error {{default initialization of an object of const}} expected-note{{add an explicit initializer to initialize 'k'}} } // dr79: na @@ -994,6 +1006,10 @@ namespace dr92 { // dr92: yes g(q); // expected-error {{is not superset}} } + // Prior to C++17, this is OK because the exception specification is not + // considered in this context. In C++17, we *do* perform an implicit + // conversion (which performs initialization), but we convert to the type of + // the template parameter, which does not include the exception specification. template<void() throw()> struct X {}; X<&f> xp; // ok } @@ -1051,18 +1067,18 @@ namespace dr98 { // dr98: yes void test(int n) { switch (n) { try { // expected-note 2{{bypasses}} - case 0: // expected-error {{protected}} + case 0: // expected-error {{cannot jump}} x: throw n; } catch (...) { // expected-note 2{{bypasses}} - case 1: // expected-error {{protected}} + case 1: // expected-error {{cannot jump}} y: throw n; } case 2: - goto x; // expected-error {{protected}} + goto x; // expected-error {{cannot jump}} case 3: - goto y; // expected-error {{protected}} + goto y; // expected-error {{cannot jump}} } } } diff --git a/test/CXX/drs/dr10xx.cpp b/test/CXX/drs/dr10xx.cpp index 64c71b2b0f92..a1d7ef67c66d 100644 --- a/test/CXX/drs/dr10xx.cpp +++ b/test/CXX/drs/dr10xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // expected-no-diagnostics @@ -13,6 +14,24 @@ namespace std { }; } +namespace dr1048 { // dr1048: 3.6 + struct A {}; + const A f(); + A g(); + typedef const A CA; +#if __cplusplus >= 201103L + // ok: we deduce non-const A in each case. + A &&a = [] (int n) { + while (1) switch (n) { + case 0: return f(); + case 1: return g(); + case 2: return A(); + case 3: return CA(); + } + } (0); +#endif +} + namespace dr1070 { // dr1070: 3.5 #if __cplusplus >= 201103L struct A { diff --git a/test/CXX/drs/dr13xx.cpp b/test/CXX/drs/dr13xx.cpp index 5827291142dc..29b39cbb95a1 100644 --- a/test/CXX/drs/dr13xx.cpp +++ b/test/CXX/drs/dr13xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors namespace dr1346 { // dr1346: 3.5 auto a(1); // expected-error 0-1{{extension}} diff --git a/test/CXX/drs/dr14xx.cpp b/test/CXX/drs/dr14xx.cpp index 8de1b8d623a9..e93192427268 100644 --- a/test/CXX/drs/dr14xx.cpp +++ b/test/CXX/drs/dr14xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors #if __cplusplus < 201103L // expected-no-diagnostics diff --git a/test/CXX/drs/dr15xx.cpp b/test/CXX/drs/dr15xx.cpp index 66618c1716d6..d7c2b9225c4d 100644 --- a/test/CXX/drs/dr15xx.cpp +++ b/test/CXX/drs/dr15xx.cpp @@ -1,16 +1,17 @@ // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // expected-no-diagnostics -namespace DR1550 { // dr1550: yes +namespace dr1550 { // dr1550: yes int f(bool b, int n) { return (b ? (throw 0) : n) + (b ? n : (throw 0)); } } -namespace DR1560 { // dr1560: 3.5 +namespace dr1560 { // dr1560: 3.5 void f(bool b, int n) { (b ? throw 0 : n) = (b ? n : throw 0) = 0; } diff --git a/test/CXX/drs/dr16xx.cpp b/test/CXX/drs/dr16xx.cpp new file mode 100644 index 000000000000..62040f1a130a --- /dev/null +++ b/test/CXX/drs/dr16xx.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +#if __cplusplus < 201103L +// expected-no-diagnostics +#endif + +namespace dr1684 { // dr1684: 3.6 +#if __cplusplus >= 201103L + struct NonLiteral { // expected-note {{because}} + NonLiteral(); + constexpr int f() { return 0; } // expected-warning 0-1{{will not be implicitly 'const'}} + }; + constexpr int f(NonLiteral &) { return 0; } + constexpr int f(NonLiteral) { return 0; } // expected-error {{not a literal type}} +#endif +} diff --git a/test/CXX/drs/dr18xx.cpp b/test/CXX/drs/dr18xx.cpp new file mode 100644 index 000000000000..bc72b67d1e0b --- /dev/null +++ b/test/CXX/drs/dr18xx.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +#if __cplusplus < 201103L +// expected-no-diagnostics +#endif + +void dr1891() { // dr1891: 3.6 +#if __cplusplus >= 201103L + int n; + auto a = []{}; // expected-note 2{{candidate}} + auto b = [=]{ return n; }; // expected-note 2{{candidate}} + typedef decltype(a) A; + typedef decltype(b) B; + + static_assert(!__has_trivial_constructor(A), ""); + static_assert(!__has_trivial_constructor(B), ""); + + A x; // expected-error {{no matching constructor}} + B y; // expected-error {{no matching constructor}} +#endif +} diff --git a/test/CXX/drs/dr1xx.cpp b/test/CXX/drs/dr1xx.cpp index 6aff43c6a488..cc6c5af81708 100644 --- a/test/CXX/drs/dr1xx.cpp +++ b/test/CXX/drs/dr1xx.cpp @@ -1,10 +1,11 @@ // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors namespace dr100 { // dr100: yes - template<const char *> struct A {}; // expected-note {{declared here}} - template<const char (&)[4]> struct B {}; // expected-note {{declared here}} + template<const char *> struct A {}; // expected-note 0-1{{declared here}} + template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}} A<"foo"> a; // expected-error {{does not refer to any declaration}} B<"bar"> b; // expected-error {{does not refer to any declaration}} } diff --git a/test/CXX/drs/dr2xx.cpp b/test/CXX/drs/dr2xx.cpp index bb9af9fd9337..bb1f13ac64ee 100644 --- a/test/CXX/drs/dr2xx.cpp +++ b/test/CXX/drs/dr2xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // PR13819 -- __SIZE_TYPE__ is incompatible. typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}} @@ -195,8 +196,8 @@ namespace dr218 { // dr218: yes // dr220: na namespace dr221 { // dr221: yes - struct A { - A &operator=(int&); + struct A { // expected-note 2-4{{candidate}} + A &operator=(int&); // expected-note 2{{candidate}} A &operator+=(int&); static A &operator=(A&, double&); // expected-error {{cannot be a static member}} static A &operator+=(A&, double&); // expected-error {{cannot be a static member}} @@ -209,9 +210,9 @@ namespace dr221 { // dr221: yes void test(A a, int n, char c, float f) { a = n; a += n; - a = c; + a = c; // expected-error {{no viable}} a += c; - a = f; + a = f; // expected-error {{no viable}} a += f; } } @@ -466,7 +467,7 @@ namespace dr243 { // dr243: yes A a2 = b; // expected-error {{ambiguous}} } -namespace dr244 { // dr244: 3.5 +namespace dr244 { // dr244: partial struct B {}; struct D : B {}; // expected-note {{here}} D D_object; @@ -484,6 +485,28 @@ namespace dr244 { // dr244: 3.5 B_ptr->dr244::~B(); // expected-error {{refers to a member in namespace}} B_ptr->dr244::~B_alias(); // expected-error {{refers to a member in namespace}} } + + namespace N { + template<typename T> struct E {}; + typedef E<int> F; + } + void g(N::F f) { + typedef N::F G; + f.~G(); + f.G::~E(); + f.G::~F(); // expected-error {{expected the class name after '~' to name a destructor}} + f.G::~G(); + // This is technically ill-formed; E is looked up in 'N::' and names the + // class template, not the injected-class-name of the class. But that's + // probably a bug in the standard. + f.N::F::~E(); + // This is valid; we look up the second F in the same scope in which we + // found the first one, that is, 'N::'. + f.N::F::~F(); // FIXME: expected-error {{expected the class name after '~' to name a destructor}} + // This is technically ill-formed; G is looked up in 'N::' and is not found; + // as above, this is probably a bug in the standard. + f.N::F::~G(); + } } namespace dr245 { // dr245: yes @@ -499,7 +522,7 @@ namespace dr246 { // dr246: yes throw 0; X: ; } catch (int) { - goto X; // expected-error {{protected scope}} + goto X; // expected-error {{cannot jump}} } }; } @@ -968,12 +991,11 @@ namespace dr289 { // dr289: yes namespace dr294 { // dr294: no void f() throw(int); int main() { - // FIXME: we reject this for the wrong reason, because we don't implement - // dr87 yet. - (void)static_cast<void (*)() throw()>(f); // expected-error {{not superset}} - void (*p)() throw() = f; // expected-error {{not superset}} - + (void)static_cast<void (*)() throw()>(f); // FIXME: ill-formed (void)static_cast<void (*)() throw(int)>(f); // FIXME: ill-formed + + void (*p)() throw() = f; // expected-error {{not superset}} + void (*q)() throw(int) = f; } } diff --git a/test/CXX/drs/dr3xx.cpp b/test/CXX/drs/dr3xx.cpp index 53fc20e23fe6..cea4d64e7eb6 100644 --- a/test/CXX/drs/dr3xx.cpp +++ b/test/CXX/drs/dr3xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors namespace dr300 { // dr300: yes template<typename R, typename A> void f(R (&)(A)) {} @@ -181,9 +182,15 @@ namespace dr308 { // dr308: yes namespace dr311 { // dr311: yes namespace X { namespace Y {} } - namespace X::Y {} // expected-error {{must define each namespace separately}} + namespace X::Y {} +#if __cplusplus <= 201402L + // expected-error@-2 {{define each namespace separately}} +#endif namespace X { - namespace X::Y {} // expected-error {{must define each namespace separately}} + namespace X::Y {} +#if __cplusplus <= 201402L + // expected-error@-2 {{define each namespace separately}} +#endif } // FIXME: The diagnostics here are not very good. namespace ::dr311::X {} // expected-error 2+{{}} // expected-warning {{extra qual}} @@ -199,7 +206,7 @@ namespace dr313 { // dr313: dup 299 c++11 #endif } -namespace dr314 { // dr314: dup 1710 +namespace dr314 { // FIXME 314: dup 1710 template<typename T> struct A { template<typename U> struct B {}; }; @@ -322,6 +329,7 @@ namespace dr324 { // dr324: yes int *f = &(true ? s.n : s.n); // expected-error {{address of bit-field}} int &g = (void(), s.n); // expected-error {{non-const reference cannot bind to bit-field}} int *h = &(void(), s.n); // expected-error {{address of bit-field}} + int *i = &++s.n; // expected-error {{address of bit-field}} } namespace dr326 { // dr326: yes @@ -365,7 +373,7 @@ namespace dr331 { // dr331: yes } const a, b(a); // expected-error {{no matching constructor}} } -namespace dr332 { // dr332: dup 557 +namespace dr332 { // dr332: dup 577 void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}} void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}} void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}} @@ -497,7 +505,7 @@ namespace dr341 { // dr342: na -namespace dr343 { // dr343: no +namespace dr343 { // FIXME 343: no // FIXME: dup 1710 template<typename T> struct A { template<typename U> struct B {}; @@ -697,7 +705,7 @@ namespace dr354 { // dr354: yes c++11 // FIXME: Should we allow this in C++98 too? struct S {}; - template<int*> struct ptr {}; // expected-note +{{here}} + template<int*> struct ptr {}; // expected-note 0-4{{here}} ptr<0> p0; ptr<(int*)0> p1; ptr<(float*)0> p2; @@ -707,11 +715,16 @@ namespace dr354 { // dr354: yes c++11 // expected-error@-5 {{does not refer to any decl}} // expected-error@-5 {{does not refer to any decl}} // expected-error@-5 {{does not refer to any decl}} -#else +#elif __cplusplus <= 201402L // expected-error@-10 {{must be cast}} // ok // expected-error@-10 {{does not match}} // expected-error@-10 {{does not match}} +#else + // expected-error@-15 {{conversion from 'int' to 'int *' is not allowed}} + // ok + // expected-error@-15 {{'float *' is not implicitly convertible to 'int *'}} + // expected-error@-15 {{'int dr354::S::*' is not implicitly convertible to 'int *'}} #endif template<int*> int both(); @@ -724,7 +737,7 @@ namespace dr354 { // dr354: yes c++11 // expected-note@-6 {{candidate}} #endif - template<int S::*> struct ptr_mem {}; // expected-note +{{here}} + template<int S::*> struct ptr_mem {}; // expected-note 0-4{{here}} ptr_mem<0> m0; ptr_mem<(int S::*)0> m1; ptr_mem<(float S::*)0> m2; @@ -734,11 +747,16 @@ namespace dr354 { // dr354: yes c++11 // expected-error@-5 {{is not a pointer to member constant}} // expected-error@-5 {{cannot be converted}} // expected-error@-5 {{cannot be converted}} -#else +#elif __cplusplus <= 201402L // expected-error@-10 {{must be cast}} // ok // expected-error@-10 {{does not match}} // expected-error@-10 {{does not match}} +#else + // expected-error@-15 {{conversion from 'int' to 'int dr354::S::*' is not allowed}} + // ok + // expected-error@-15 {{'float dr354::S::*' is not implicitly convertible to 'int dr354::S::*'}} + // expected-error@-15 {{'int *' is not implicitly convertible to 'int dr354::S::*'}} #endif } @@ -1201,7 +1219,7 @@ namespace dr391 { // dr391: yes c++11 namespace dr395 { // dr395: yes struct S { - template <typename T, int N>(&operator T())[N]; // expected-error {{must use a typedef}} + template <typename T, int N>(&operator T())[N]; // expected-error {{cannot specify any part of a return type}} template <typename T, int N> operator(T (&)[N])(); // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error +{{}} template <typename T> operator T *() const { return 0; } template <typename T, typename U> operator T U::*() const { return 0; } diff --git a/test/CXX/drs/dr412.cpp b/test/CXX/drs/dr412.cpp index cb33e206a632..39cdd6182d20 100644 --- a/test/CXX/drs/dr412.cpp +++ b/test/CXX/drs/dr412.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT="throw()" -DBAD_ALLOC="throw(std::bad_alloc)" // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC= -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC= +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC= +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC= // dr412: yes // lwg404: yes diff --git a/test/CXX/drs/dr4xx.cpp b/test/CXX/drs/dr4xx.cpp index 815dbfc0b401..42c6774dd186 100644 --- a/test/CXX/drs/dr4xx.cpp +++ b/test/CXX/drs/dr4xx.cpp @@ -1,6 +1,7 @@ // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // FIXME: __SIZE_TYPE__ expands to 'long long' on some targets. __extension__ typedef __SIZE_TYPE__ size_t; @@ -501,15 +502,15 @@ namespace dr436 { // dr436: yes void f(); // expected-error {{redefinition}} } -namespace dr437 { // dr437: no +namespace dr437 { // dr437: sup 1308 // This is superseded by 1308, which is in turn superseded by 1330, // which restores this rule. - template<typename U> struct T : U {}; // expected-error {{incomplete}} - struct S { // expected-note {{not complete}} + template<typename U> struct T : U {}; + struct S { void f() throw(S); - void g() throw(T<S>); // expected-note {{in instantiation of}} - struct U; // expected-note {{forward}} - void h() throw(U); // expected-error {{incomplete}} + void g() throw(T<S>); + struct U; + void h() throw(U); struct U {}; }; } @@ -755,7 +756,7 @@ namespace dr467 { // dr467: yes return k; } int g() { - goto later; // expected-error {{protected scope}} + goto later; // expected-error {{cannot jump}} int k = stuff(); // expected-note {{bypasses variable initialization}} later: return k; @@ -1201,7 +1202,7 @@ namespace dr497 { // dr497: yes struct S { mutable int i; }; - const S cs; // expected-error {{default initialization}} + const S cs; // expected-error {{default initialization}} expected-note {{add an explicit initializer}} int S::*pm = &S::i; cs.*pm = 88; } diff --git a/test/CXX/drs/dr5xx.cpp b/test/CXX/drs/dr5xx.cpp index 0c0d451c4b22..5bf085f52204 100644 --- a/test/CXX/drs/dr5xx.cpp +++ b/test/CXX/drs/dr5xx.cpp @@ -1,6 +1,13 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +// FIXME: This is included to avoid a diagnostic with no source location +// pointing at the implicit operator new. We can't match such a diagnostic +// with -verify. +__extension__ typedef __SIZE_TYPE__ size_t; +void *operator new(size_t); // expected-warning 0-1{{missing exception spec}} expected-note{{candidate}} namespace dr500 { // dr500: dup 372 class D; @@ -195,6 +202,153 @@ namespace dr525 { // dr525: yes } } +namespace dr526 { // dr526: yes + template<int> struct S {}; + template<int N> void f1(S<N> s); + template<int N> void f2(S<(N)> s); // expected-note {{couldn't infer}} + template<int N> void f3(S<+N> s); // expected-note {{couldn't infer}} + template<int N> void g1(int (&)[N]); + template<int N> void g2(int (&)[(N)]); // expected-note {{couldn't infer}} + template<int N> void g3(int (&)[+N]); // expected-note {{couldn't infer}} + + void test(int (&a)[3], S<3> s) { + f1(s); + f2(s); // expected-error {{no matching}} + f3(s); // expected-error {{no matching}} + g1(a); + g2(a); // expected-error {{no matching}} + g3(a); // expected-error {{no matching}} + } + + template<int N> struct X { + typedef int type; + X<N>::type v1; + X<(N)>::type v2; // expected-error {{missing 'typename'}} + X<+N>::type v3; // expected-error {{missing 'typename'}} + }; +} + +namespace dr527 { // dr527: na + // This DR is meaningless. It removes a required diagnostic from the case + // where a not-externally-visible object is odr-used but not defined, which + // requires a diagnostic for a different reason. + extern struct { int x; } a; // FIXME: We should reject this, per dr389. + static struct { int x; } b; + extern "C" struct { int x; } c; + namespace { extern struct { int x; } d; } + typedef struct { int x; } *P; + struct E { static P e; }; // FIXME: We should reject this, per dr389. + namespace { struct F { static P f; }; } + + int ax = a.x, bx = b.x, cx = c.x, dx = d.x, ex = E::e->x, fx = F::f->x; +} + +namespace dr530 { // dr530: yes + template<int*> struct S { enum { N = 1 }; }; + template<void(*)()> struct T { enum { N = 1 }; }; + int n; + void f(); + int a[S<&n>::N]; + int b[T<&f>::N]; +} + +namespace dr531 { // dr531: partial + namespace good { + template<typename T> struct A { + void f(T) { T::error; } + template<typename U> void g(T, U) { T::error; } + struct B { typename T::error error; }; + template<typename U> struct C { typename T::error error; }; + static T n; + }; + template<typename T> T A<T>::n = T::error; + + template<> void A<int>::f(int) {} + template<> template<typename U> void A<int>::g(int, U) {} + template<> struct A<int>::B {}; + template<> template<typename U> struct A<int>::C {}; + template<> int A<int>::n = 0; + + void use(A<int> a) { + a.f(a.n); + a.g(0, 0); + A<int>::B b; + A<int>::C<int> c; + } + + template<> struct A<char> { + void f(char); + template<typename U> void g(char, U); + struct B; + template<typename U> struct C; + static char n; + }; + + void A<char>::f(char) {} + template<typename U> void A<char>::g(char, U) {} + struct A<char>::B {}; + template<typename U> struct A<char>::C {}; + char A<char>::n = 0; + } + + namespace bad { + template<typename T> struct A { + void f(T) { T::error; } + template<typename U> void g(T, U) { T::error; } + struct B { typename T::error error; }; + template<typename U> struct C { typename T::error error; }; // expected-note {{here}} + static T n; + }; + template<typename T> T A<T>::n = T::error; + + void A<int>::f(int) {} // expected-error {{requires 'template<>'}} + template<typename U> void A<int>::g(int, U) {} // expected-error {{should be empty}} + struct A<int>::B {}; // expected-error {{requires 'template<>'}} + template<typename U> struct A<int>::C {}; // expected-error {{should be empty}} expected-error {{different kind of symbol}} + int A<int>::n = 0; // expected-error {{requires 'template<>'}} + + template<> struct A<char> { // expected-note 2{{here}} + void f(char); + template<typename U> void g(char, U); + struct B; // expected-note {{here}} + template<typename U> struct C; + static char n; + }; + + template<> void A<char>::f(char) {} // expected-error {{no function template matches}} + // FIXME: This is ill-formed; -pedantic-errors should reject. + template<> template<typename U> void A<char>::g(char, U) {} // expected-warning {{extraneous template parameter list}} + template<> struct A<char>::B {}; // expected-error {{extraneous 'template<>'}} expected-error {{does not specialize}} + // FIXME: This is ill-formed; -pedantic-errors should reject. + template<> template<typename U> struct A<char>::C {}; // expected-warning {{extraneous template parameter list}} + template<> char A<char>::n = 0; // expected-error {{extraneous 'template<>'}} + } + + namespace nested { + template<typename T> struct A { + template<typename U> struct B; + }; + template<> template<typename U> struct A<int>::B { + void f(); + void g(); + template<typename V> void h(); + template<typename V> void i(); + }; + template<> template<typename U> void A<int>::B<U>::f() {} + template<typename U> void A<int>::B<U>::g() {} // expected-error {{should be empty}} + + template<> template<typename U> template<typename V> void A<int>::B<U>::h() {} + template<typename U> template<typename V> void A<int>::B<U>::i() {} // expected-error {{should be empty}} + + template<> template<> void A<int>::B<int>::f() {} + template<> template<> template<typename V> void A<int>::B<int>::h() {} + template<> template<> template<> void A<int>::B<int>::h<int>() {} + + template<> void A<int>::B<char>::f() {} // expected-error {{requires 'template<>'}} + template<> template<typename V> void A<int>::B<char>::h() {} // expected-error {{should be empty}} + } +} + // PR8130 namespace dr532 { // dr532: 3.5 struct A { }; @@ -210,3 +364,632 @@ namespace dr532 { // dr532: 3.5 int &ir = b * a; } } + +// dr533: na + +namespace dr534 { // dr534: yes + struct S {}; + template<typename T> void operator+(S, T); + template<typename T> void operator+<T*>(S, T*) {} // expected-error {{function template partial spec}} +} + +namespace dr535 { // dr535: yes + class X { private: X(const X&); }; + struct A { + X x; + template<typename T> A(T&); + }; + struct B : A { + X y; + B(volatile A&); + }; + + extern A a1; + A a2(a1); // ok, uses constructor template + + extern volatile B b1; + B b2(b1); // ok, uses converting constructor + + void f() { throw a1; } + +#if __cplusplus >= 201103L + struct C { + constexpr C() : n(0) {} + template<typename T> constexpr C(T&t) : n(t.n == 0 ? throw 0 : 0) {} + int n; + }; + constexpr C c() { return C(); } + // ok, copy is elided + constexpr C x = c(); +#endif +} + +// dr537: na +// dr538: na + +// dr539: yes +const dr539( // expected-error {{requires a type specifier}} + const a) { // expected-error {{unknown type name 'a'}} + const b; // expected-error {{requires a type specifier}} + new const; // expected-error {{expected a type}} + try {} catch (const n) {} // expected-error {{unknown type name 'n'}} + try {} catch (const) {} // expected-error {{expected a type}} + if (const n = 0) {} // expected-error {{requires a type specifier}} + switch (const n = 0) {} // expected-error {{requires a type specifier}} + while (const n = 0) {} // expected-error {{requires a type specifier}} + for (const n = 0; // expected-error {{requires a type specifier}} + const m = 0; ) {} // expected-error {{requires a type specifier}} + sizeof(const); // expected-error {{requires a type specifier}} + struct S { + const n; // expected-error {{requires a type specifier}} + operator const(); // expected-error {{expected a type}} + }; +#if __cplusplus >= 201103L + int arr[3]; + // FIXME: The extra braces here are to avoid the parser getting too + // badly confused when recovering here. We should fix this recovery. + { for (const n // expected-error {{unknown type name 'n'}} expected-note {{}} + : arr) ; {} } // expected-error +{{}} + (void) [](const) {}; // expected-error {{requires a type specifier}} + (void) [](const n) {}; // expected-error {{unknown type name 'n'}} + enum E : const {}; // expected-error {{expected a type}} + using T = const; // expected-error {{expected a type}} + auto f() -> const; // expected-error {{expected a type}} +#endif +} + +namespace dr540 { // dr540: yes + typedef int &a; + typedef const a &a; // expected-warning {{has no effect}} + typedef const int &b; + typedef b &b; + typedef const a &c; // expected-note {{previous}} expected-warning {{has no effect}} + typedef const b &c; // expected-error {{different}} expected-warning {{has no effect}} +} + +namespace dr541 { // dr541: yes + template<int> struct X { typedef int type; }; + template<typename T> struct S { + int f(T); + + int g(int); + T g(bool); + + int h(); + int h(T); + + void x() { + // These are type-dependent expressions, even though we could + // determine that all calls have type 'int'. + X<sizeof(f(0))>::type a; // expected-error +{{}} + X<sizeof(g(0))>::type b; // expected-error +{{}} + X<sizeof(h(0))>::type b; // expected-error +{{}} + + typename X<sizeof(f(0))>::type a; + typename X<sizeof(h(0))>::type b; + } + }; +} + +namespace dr542 { // dr542: yes +#if __cplusplus >= 201103L + struct A { A() = delete; int n; }; + A a[32] = {}; // ok, constructor not called + + struct B { + int n; + private: + B() = default; + }; + B b[32] = {}; // ok, constructor not called +#endif +} + +namespace dr543 { // dr543: yes + // In C++98+DR543, this is valid because value-initialization doesn't call a + // trivial default constructor, so we never notice that defining the + // constructor would be ill-formed. + // + // In C++11+DR543, this is ill-formed, because the default constructor is + // deleted, and value-initialization *does* call a deleted default + // constructor, even if it is trivial. + struct A { + const int n; + }; + A a = A(); +#if __cplusplus >= 201103L + // expected-error@-2 {{deleted}} + // expected-note@-5 {{would not be initialized}} +#endif +} + +namespace dr544 { // dr544: yes + int *n; + + template<class T> struct A { int n; }; + template<class T> struct B : A<T> { int get(); }; + template<> int B<int>::get() { return n; } + int k = B<int>().get(); +} + +namespace dr546 { // dr546: yes + template<typename T> struct A { void f(); }; + template struct A<int>; + template<typename T> void A<T>::f() { T::error; } +} + +namespace dr547 { // dr547: yes + // When targeting the MS x86 ABI, the type of a member function includes a + // __thiscall qualifier. This is non-conforming, but we still implement + // the intent of dr547 +#if defined(_M_IX86) || (defined(__MINGW32__) && !defined(__MINGW64__)) +#define THISCALL __thiscall +#else +#define THISCALL +#endif + + template<typename T> struct X; + template<typename T> struct X<THISCALL T() const> {}; + template<typename T, typename C> X<T> f(T C::*) { return X<T>(); } + + struct S { void f() const; }; + X<THISCALL void() const> x = f(&S::f); + +#undef THISCALL +} + +namespace dr548 { // dr548: dup 482 + template<typename T> struct S {}; + template<typename T> void f() {} + template struct dr548::S<int>; + template void dr548::f<int>(); +} + +namespace dr551 { // dr551: yes c++11 + // FIXME: This obviously should apply in C++98 mode too. + template<typename T> void f() {} + template inline void f<int>(); +#if __cplusplus >= 201103L + // expected-error@-2 {{cannot be 'inline'}} +#endif + + template<typename T> inline void g() {} + template inline void g<int>(); +#if __cplusplus >= 201103L + // expected-error@-2 {{cannot be 'inline'}} +#endif + + template<typename T> struct X { + void f() {} + }; + template inline void X<int>::f(); +#if __cplusplus >= 201103L + // expected-error@-2 {{cannot be 'inline'}} +#endif +} + +namespace dr552 { // dr552: yes + template<typename T, typename T::U> struct X {}; + struct Y { typedef int U; }; + X<Y, 0> x; +} + +struct dr553_class { + friend void *operator new(size_t, dr553_class); +}; +namespace dr553 { + dr553_class c; + // Contrary to the apparent intention of the DR, operator new is not actually + // looked up with a lookup mechanism that performs ADL; the standard says it + // "is looked up in global scope", where it is not visible. + void *p = new (c) int; // expected-error {{no matching function}} + + struct namespace_scope { + friend void *operator new(size_t, namespace_scope); // expected-error {{cannot be declared inside a namespace}} + }; +} + +// dr556: na + +namespace dr557 { // dr557: yes + template<typename T> struct S { + friend void f(S<T> *); + friend void g(S<S<T> > *); + }; + void x(S<int> *p, S<S<int> > *q) { + f(p); + g(q); + } +} + +namespace dr558 { // dr558: yes + wchar_t a = L'\uD7FF'; + wchar_t b = L'\xD7FF'; + wchar_t c = L'\uD800'; // expected-error {{invalid universal character}} + wchar_t d = L'\xD800'; + wchar_t e = L'\uDFFF'; // expected-error {{invalid universal character}} + wchar_t f = L'\xDFFF'; + wchar_t g = L'\uE000'; + wchar_t h = L'\xE000'; +} + +template<typename> struct dr559 { typedef int T; dr559::T u; }; // dr559: yes + +namespace dr561 { // dr561: yes + template<typename T> void f(int); + template<typename T> void g(T t) { + f<T>(t); + } + namespace { + struct S {}; + template<typename T> static void f(S); + } + void h(S s) { + g(s); + } +} + +namespace dr564 { // dr564: yes + extern "C++" void f(int); + void f(int); // ok + extern "C++" { extern int n; } + int n; // ok +} + +namespace dr565 { // dr565: yes + namespace N { + template<typename T> int f(T); // expected-note {{target}} + } + using N::f; // expected-note {{using}} + template<typename T> int f(T*); + template<typename T> void f(T); + template<typename T, int = 0> int f(T); // expected-error 0-1{{extension}} + template<typename T> int f(T, int = 0); + template<typename T> int f(T); // expected-error {{conflicts with}} +} + +namespace dr566 { // dr566: yes +#if __cplusplus >= 201103L + int check[int(-3.99) == -3 ? 1 : -1]; +#endif +} + +// dr567: na + +namespace dr568 { // dr568: yes c++11 + // FIXME: This is a DR issue against C++98, so should probably apply there + // too. + struct x { int y; }; + class trivial : x { + x y; + public: + int n; + }; + int check_trivial[__is_trivial(trivial) ? 1 : -1]; + + struct std_layout { + std_layout(); + std_layout(const std_layout &); + ~std_layout(); + private: + int n; + }; + int check_std_layout[__is_standard_layout(std_layout) ? 1 : -1]; + + struct aggregate { + int x; + int y; + trivial t; + std_layout sl; + }; + aggregate aggr = {}; + + void f(...); + void g(trivial t) { f(t); } +#if __cplusplus < 201103L + // expected-error@-2 {{non-POD}} +#endif + + void jump() { + goto x; +#if __cplusplus < 201103L + // expected-error@-2 {{cannot jump}} + // expected-note@+2 {{non-POD}} +#endif + trivial t; + x: ; + } +} + +namespace dr569 { // dr569: yes c++11 + // FIXME: This is a DR issue against C++98, so should probably apply there + // too. + ;;;;; +#if __cplusplus < 201103L + // expected-error@-2 {{C++11 extension}} +#endif +} + +namespace dr570 { // dr570: dup 633 + int n; + int &r = n; // expected-note {{previous}} + int &r = n; // expected-error {{redefinition}} +} + +namespace dr571 { // dr571 unknown + // FIXME: Add a codegen test. + typedef int &ir; + int n; + const ir r = n; // expected-warning {{has no effect}} FIXME: Test if this has internal linkage. +} + +namespace dr572 { // dr572: yes + enum E { a = 1, b = 2 }; + int check[a + b == 3 ? 1 : -1]; +} + +namespace dr573 { // dr573: no + void *a; + int *b = reinterpret_cast<int*>(a); + void (*c)() = reinterpret_cast<void(*)()>(a); + void *d = reinterpret_cast<void*>(c); +#if __cplusplus < 201103L + // expected-error@-3 {{extension}} + // expected-error@-3 {{extension}} +#endif + void f() { delete a; } // expected-error {{cannot delete}} + int n = d - a; // expected-error {{arithmetic on pointers to void}} + // FIXME: This is ill-formed. + template<void*> struct S; + template<int*> struct T; +} + +namespace dr574 { // dr574: yes + struct A { + A &operator=(const A&) const; // expected-note {{does not match because it is const}} + }; + struct B { + B &operator=(const B&) volatile; // expected-note {{nearly matches}} + }; +#if __cplusplus >= 201103L + struct C { + C &operator=(const C&) &; // expected-note {{not viable}} expected-note {{nearly matches}} expected-note {{here}} + }; + struct D { + D &operator=(const D&) &&; // expected-note {{not viable}} expected-note {{nearly matches}} expected-note {{here}} + }; + void test(C c, D d) { + c = c; + C() = c; // expected-error {{no viable}} + d = d; // expected-error {{no viable}} + D() = d; + } +#endif + struct Test { + friend A &A::operator=(const A&); // expected-error {{does not match}} + friend B &B::operator=(const B&); // expected-error {{does not match}} +#if __cplusplus >= 201103L + // FIXME: We shouldn't produce the 'cannot overload' diagnostics here. + friend C &C::operator=(const C&); // expected-error {{does not match}} expected-error {{cannot overload}} + friend D &D::operator=(const D&); // expected-error {{does not match}} expected-error {{cannot overload}} +#endif + }; +} + +namespace dr575 { // dr575: yes + template<typename T, typename U = typename T::type> void a(T); void a(...); // expected-error 0-1{{extension}} + template<typename T, typename T::type U = 0> void b(T); void b(...); // expected-error 0-1{{extension}} + template<typename T, int U = T::value> void c(T); void c(...); // expected-error 0-1{{extension}} + template<typename T> void d(T, int = T::value); void d(...); // expected-error {{cannot be used prior to '::'}} + void x() { + a(0); + b(0); + c(0); + d(0); // expected-note {{in instantiation of default function argument}} + } + + template<typename T = int&> void f(T* = 0); // expected-error 0-1{{extension}} + template<typename T = int> void f(T = 0); // expected-error 0-1{{extension}} + void g() { f<>(); } + + template<typename T> T &h(T *); + template<typename T> T *h(T *); + void *p = h((void*)0); +} + +namespace dr576 { // dr576: yes + typedef void f() {} // expected-error {{function definition declared 'typedef'}} + void f(typedef int n); // expected-error {{invalid storage class}} + void f(char c) { typedef int n; } +} + +namespace dr577 { // dr577: yes + typedef void V; + typedef const void CV; + void a(void); + void b(const void); // expected-error {{qualifiers}} + void c(V); + void d(CV); // expected-error {{qualifiers}} + void (*e)(void) = c; + void (*f)(const void); // expected-error {{qualifiers}} + void (*g)(V) = a; + void (*h)(CV); // expected-error {{qualifiers}} + template<typename T> void i(T); // expected-note 2{{requires 1 arg}} + template<typename T> void j(void (*)(T)); // expected-note 2{{argument may not have 'void' type}} + void k() { + a(); + c(); + i<void>(); // expected-error {{no match}} + i<const void>(); // expected-error {{no match}} + j<void>(0); // expected-error {{no match}} + j<const void>(0); // expected-error {{no match}} + } +} + +namespace dr580 { // dr580: no + class C; + struct A { static C c; }; + struct B { static C c; }; + class C { + C(); // expected-note {{here}} + ~C(); // expected-note {{here}} + + typedef int I; // expected-note {{here}} + template<int> struct X; + template<int> friend struct Y; + template<int> void f(); + template<int> friend void g(); + friend struct A; + }; + + template<C::I> struct C::X {}; + template<C::I> struct Y {}; + template<C::I> struct Z {}; // FIXME: should reject, accepted because C befriends A! + + template<C::I> void C::f() {} + template<C::I> void g() {} + template<C::I> void h() {} // expected-error {{private}} + + C A::c; + C B::c; // expected-error 2{{private}} +} + +// dr582: na + +namespace dr583 { // dr583: no + // see n3624 + int *p; + // FIXME: These are all ill-formed. + bool b1 = p < 0; + bool b2 = p > 0; + bool b3 = p <= 0; + bool b4 = p >= 0; +} + +// dr584: na + +namespace dr585 { // dr585: yes + template<typename> struct T; + struct A { + friend T; // expected-error {{requires a type specifier}} expected-error {{can only be classes or functions}} + // FIXME: It's not clear whether the standard allows this or what it means, + // but the DR585 writeup suggests it as an alternative. + template<typename U> friend T<U>; // expected-error {{must use an elaborated type}} + }; + template<template<typename> class T> struct B { + friend T; // expected-error {{requires a type specifier}} expected-error {{can only be classes or functions}} + template<typename U> friend T<U>; // expected-error {{must use an elaborated type}} + }; +} + +// dr586: na + +namespace dr587 { // dr587: yes + template<typename T> void f(bool b, const T x, T y) { + const T *p = &(b ? x : y); + } + struct S {}; + template void f(bool, const int, int); + template void f(bool, const S, S); +} + +namespace dr588 { // dr588: yes + struct A { int n; }; // expected-note {{ambiguous}} + template<typename T> int f() { + struct S : A, T { int f() { return n; } } s; + int a = s.f(); + int b = s.n; // expected-error {{found in multiple}} + } + struct B { int n; }; // expected-note {{ambiguous}} + int k = f<B>(); // expected-note {{here}} +} + +namespace dr589 { // dr589: yes + struct B { }; + struct D : B { }; + D f(); + extern const B &b; + bool a; + const B *p = &(a ? f() : b); // expected-error {{temporary}} + const B *q = &(a ? D() : b); // expected-error {{temporary}} +} + +namespace dr590 { // dr590: yes + template<typename T> struct A { + struct B { + struct C { + A<T>::B::C f(A<T>::B::C); // ok, no 'typename' required. + }; + }; + }; + template<typename T> typename A<T>::B::C A<T>::B::C::f(A<T>::B::C) {} +} + +namespace dr591 { // dr591: no + template<typename T> struct A { + typedef int M; + struct B { + typedef void M; + struct C; + }; + }; + + template<typename T> struct A<T>::B::C : A<T> { + // FIXME: Should find member of non-dependent base class A<T>. + M m; // expected-error {{incomplete type 'M' (aka 'void'}} + }; +} + +// dr592: na +// dr593 needs an IRGen test. +// dr594: na + +namespace dr595 { // dr595: dup 1330 + template<class T> struct X { + void f() throw(T) {} + }; + struct S { + X<S> xs; + }; +} + +// dr597: na + +namespace dr598 { // dr598: yes + namespace N { + void f(int); + void f(char); + // Not found by ADL. + void g(void (*)(int)); + void h(void (*)(int)); + + namespace M { + struct S {}; + int &h(void (*)(S)); + } + void i(M::S); + void i(); + } + int &g(void(*)(char)); + int &r = g(N::f); + int &s = h(N::f); // expected-error {{undeclared}} + int &t = h(N::i); +} + +namespace dr599 { // dr599: partial + typedef int Fn(); + struct S { operator void*(); }; + struct T { operator Fn*(); }; + struct U { operator int*(); operator void*(); }; // expected-note 2{{conversion}} + struct V { operator int*(); operator Fn*(); }; + void f(void *p, void (*q)(), S s, T t, U u, V v) { + delete p; // expected-error {{cannot delete}} + delete q; // expected-error {{cannot delete}} + delete s; // expected-error {{cannot delete}} + delete t; // expected-error {{cannot delete}} + // FIXME: This is valid, but is rejected due to a non-conforming GNU + // extension allowing deletion of pointers to void. + delete u; // expected-error {{ambiguous}} + delete v; + } +} diff --git a/test/CXX/drs/dr6xx.cpp b/test/CXX/drs/dr6xx.cpp new file mode 100644 index 000000000000..988c8f43011d --- /dev/null +++ b/test/CXX/drs/dr6xx.cpp @@ -0,0 +1,349 @@ +// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +namespace std { struct type_info {}; } + +namespace dr601 { // dr601: yes +#if __cplusplus >= 201103L +#define MAX __LLONG_MAX__ +#else +#define MAX __LONG_MAX__ +#endif + +#if 0x8000 < -1 +#error 0x8000 should be signed +#endif + +#if MAX > 0xFFFFFFFF && 0x80000000 < -1 +#error 0x80000000 should be signed +#endif + +#if __INT_MAX__ == 0x7FFFFFFF +_Static_assert(0x80000000 < -1, "0x80000000 should be unsigned"); // expected-error {{C11}} +#endif + +#if MAX > 0xFFFFFFFFFFFFFFFF && 0x8000000000000000 < -1 +#error 0x8000000000000000 should be signed +#endif + +#if __cplusplus >= 201103L && __LLONG_MAX__ == 0x7FFFFFFFFFFFFFFF +static_assert(0x8000000000000000 < -1, "0x8000000000000000 should be unsigned"); // expected-error {{C11}} +#endif + +#undef MAX +} + +namespace dr602 { // dr602: yes + template<class T> struct A { + template<class U> friend struct A; + }; + + template<class T> struct B { + class C { + template<class U> friend struct B; + typedef int type; + }; + typename C::type ct; // ok, befriended + }; + B<int> b; +} + +namespace dr603 { // dr603: yes + template<unsigned char> struct S {}; + typedef S<'\001'> S1; + typedef S<(1ul << __CHAR_BIT__) + 1> S1; +#if __cplusplus >= 201103L + // expected-error@-2 {{cannot be narrowed}} +#endif +} + +// dr604: na +// dr605 needs IRGen test + +namespace dr606 { // dr606: yes +#if __cplusplus >= 201103L + template<typename T> struct S {}; + template<typename T> void f(S<T> &&); // expected-note {{no known conversion from 'S<int>' to 'S<int> &&'}} + template<typename T> void g(T &&); + template<typename T> void h(const T &&); // expected-note {{no known conversion from 'S<int>' to 'const dr606::S<int> &&'}} + + void test(S<int> s) { + f(s); // expected-error {{no match}} + g(s); + h(s); // expected-error {{no match}} + + g(test); + h(test); // ok, an rvalue reference can bind to a function lvalue + } +#endif +} + +namespace dr608 { // dr608: yes + struct A { virtual void f(); }; + struct B : A {}; + struct C : A { void f(); }; + struct D : B, C {}; +} + +int dr610[-0u == 0u ? 1 : -1]; // dr610: yes + +namespace dr611 { // dr611: yes + int k; + struct S { int &r; } s = { k ? k : k }; +} + +// dr612: na + +namespace dr613 { // dr613: yes c++11 + // see also n2253 + struct A { int n; static void f(); }; + int f(int); + struct B { virtual void f(); }; + B &g(int); + + int an1 = sizeof(A::n); + int an2 = sizeof(A::n + 1); // valid per dr850 + int an3 = sizeof A::n; + int an4 = sizeof(f(A::n)); + int an5 = sizeof(g(A::n)); + const std::type_info &an6 = typeid(A::n); + const std::type_info &an7 = typeid(A::n + 1); + const std::type_info &an8 = typeid(f(A::n)); + const std::type_info &an9 = typeid(g(A::n)); // expected-error {{non-static}} +#if __cplusplus < 201103L + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} + // expected-error@-10 {{non-static}} +#endif + + void A::f() { + int an1 = sizeof n; + const std::type_info &an2 = typeid(n + 1); +#if __cplusplus < 201103L + // expected-error@-3 {{static}} + // expected-error@-3 {{static}} +#endif + const std::type_info &an3 = typeid(g(n)); // expected-error {{static}} + } +} + +int dr614_a[(-1) / 2 == 0 ? 1 : -1]; // dr614: yes +int dr614_b[(-1) % 2 == -1 ? 1 : -1]; + +namespace dr615 { // dr615: yes + int f(); + static int n = f(); +} + +namespace dr616 { // dr616: no +#if __cplusplus >= 201103L + struct S { int n; } s; + // FIXME: These should all be 'int &&' + using T = decltype(S().n); // expected-note 2{{previous}} + using T = decltype(static_cast<S&&>(s).n); + using T = decltype(S().*&S::n); + using T = decltype(static_cast<S&&>(s).*&S::n); // expected-error {{different type}} + using T = int&&; // expected-error {{different type}} +#endif +} + +namespace dr618 { // dr618: yes +#if (unsigned)-1 > 0 +#error wrong +#endif +} + +namespace dr619 { // dr619: yes + extern int x[10]; + struct S { static int x[10]; }; + + int x[]; + _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}} + extern int x[]; + _Static_assert(sizeof(x) == sizeof(int) * 10, ""); // expected-error {{C11}} + + int S::x[]; + _Static_assert(sizeof(S::x) == sizeof(int) * 10, ""); // expected-error {{C11}} + + void f() { + extern int x[]; + sizeof(x); // expected-error {{incomplete}} + } +} + +// dr620: dup 568 + +namespace dr621 { + template<typename T> T f(); + template<> int f() {} // expected-note {{previous}} + template<> int f<int>() {} // expected-error {{redefinition}} +} + +// dr623: na +// FIXME: Add documentation saying we allow invalid pointer values. + +// dr624 needs an IRGen check. + +namespace dr625 { // dr625: yes + template<typename T> struct A {}; + A<auto> x = A<int>(); // expected-error {{'auto' not allowed in template argument}} expected-error 0-1{{extension}} + void f(int); + void (*p)(auto) = f; // expected-error {{'auto' not allowed in function prototype}} expected-error 0-1{{extension}} +} + +namespace dr626 { // dr626: yes +#define STR(x) #x + char c[2] = STR(c); // ok, type matches + wchar_t w[2] = STR(w); // expected-error {{initializing wide char array with non-wide string literal}} +} + +namespace dr627 { // dr627: yes + void f() { + true a = 0; // expected-error +{{}} expected-warning {{unused}} + } +} + +// dr628: na + +namespace dr629 { // dr629: yes + typedef int T; + int n = 1; + void f() { + auto T = 2; +#if __cplusplus < 201103L + // expected-error@-2 {{expected unqualified-id}} +#else + // expected-note@-4 {{previous}} +#endif + + auto T(n); +#if __cplusplus >= 201103L + // expected-error@-2 {{redefinition of 'T'}} +#endif + } +} + +namespace dr630 { // dr630: yes +const bool MB_EQ_WC = + ' ' == L' ' && '\t' == L'\t' && '\v' == L'\v' && '\r' == L'\r' && + '\n' == L'\n' && // + 'a' == L'a' && 'b' == L'b' && 'c' == L'c' && 'd' == L'd' && 'e' == L'e' && + 'f' == L'f' && 'g' == L'g' && 'h' == L'h' && 'i' == L'i' && 'j' == L'j' && + 'k' == L'k' && 'l' == L'l' && 'm' == L'm' && 'n' == L'n' && 'o' == L'o' && + 'p' == L'p' && 'q' == L'q' && 'r' == L'r' && 's' == L's' && 't' == L't' && + 'u' == L'u' && 'v' == L'v' && 'w' == L'w' && 'x' == L'x' && 'y' == L'y' && + 'z' == L'z' && // + 'A' == L'A' && 'B' == L'B' && 'C' == L'C' && 'D' == L'D' && 'E' == L'E' && + 'F' == L'F' && 'G' == L'G' && 'H' == L'H' && 'I' == L'I' && 'J' == L'J' && + 'K' == L'K' && 'L' == L'L' && 'M' == L'M' && 'N' == L'N' && 'O' == L'O' && + 'P' == L'P' && 'Q' == L'Q' && 'R' == L'R' && 'S' == L'S' && 'T' == L'T' && + 'U' == L'U' && 'V' == L'V' && 'W' == L'W' && 'X' == L'X' && 'Y' == L'Y' && + 'Z' == L'Z' && // + '0' == L'0' && '1' == L'1' && '2' == L'2' && '3' == L'3' && '4' == L'4' && + '5' == L'5' && '6' == L'6' && '7' == L'7' && '8' == L'8' && + '9' == L'9' && // + '_' == L'_' && '{' == L'{' && '}' == L'}' && '[' == L'[' && ']' == L']' && + '#' == L'#' && '(' == L'(' && ')' == L')' && '<' == L'<' && '>' == L'>' && + '%' == L'%' && ':' == L':' && ';' == L';' && '.' == L'.' && '?' == L'?' && + '*' == L'*' && '+' == L'+' && '-' == L'-' && '/' == L'/' && '^' == L'^' && + '&' == L'&' && '|' == L'|' && '~' == L'~' && '!' == L'!' && '=' == L'=' && + ',' == L',' && '\\' == L'\\' && '"' == L'"' && '\'' == L'\''; +#if __STDC_MB_MIGHT_NEQ_WC__ +#ifndef __FreeBSD__ // PR22208, FreeBSD expects us to give a bad (but conforming) answer here. +_Static_assert(!MB_EQ_WC, "__STDC_MB_MIGHT_NEQ_WC__ but all basic source characters have same representation"); // expected-error {{C11}} +#endif +#else +_Static_assert(MB_EQ_WC, "!__STDC_MB_MIGHT_NEQ_WC__ but some character differs"); // expected-error {{C11}} +#endif +} + +// dr631: na + +namespace dr632 { // dr632: yes + struct S { int n; } s = {{5}}; // expected-warning {{braces}} +} + +// dr633: na +// see also n2993 + +namespace dr634 { // dr634: yes + struct S { S(); S(const S&); virtual void f(); ~S(); }; + int f(...); + char f(int); + template<typename T> int (&g(T))[sizeof f(T())]; + int (&a)[sizeof(int)] = g(S()); + int (&b)[1] = g(0); + int k = f(S()); // expected-error {{cannot pass}} +} + +namespace dr635 { // dr635: yes + template<typename T> struct A { A(); ~A(); }; + template<typename T> A<T>::A<T>() {} // expected-error {{cannot have template arguments}} + template<typename T> A<T>::~A<T>() {} + + template<typename T> struct B { B(); ~B(); }; + template<typename T> B<T>::B() {} + template<typename T> B<T>::~B() {} + + struct C { template<typename T> C(); C(); }; + template<typename T> C::C() {} + C::C() {} + template<> C::C<int>() {} // expected-error {{constructor name}} expected-error {{unqualified-id}} + /*FIXME: needed for error recovery:*/; + + template<typename T> struct D { template<typename U> D(); D(); }; + template<typename T> D<T>::D() {} // expected-note {{previous}} + template<typename T> template<typename U> D<T>::D() {} + template<typename T> D<T>::D<T>() {} // expected-error {{redefinition}} expected-error {{cannot have template arg}} +} + +namespace dr637 { // dr637: yes + void f(int i) { + i = ++i + 1; + i = i++ + 1; // expected-warning {{unsequenced}} + } +} + +namespace dr638 { // dr638: no + template<typename T> struct A { + struct B; + void f(); + void g(); + struct C { + void h(); + }; + }; + + class X { + typedef int type; + template<class T> friend struct A<T>::B; // expected-warning {{not supported}} + template<class T> friend void A<T>::f(); // expected-warning {{not supported}} + template<class T> friend void A<T>::g(); // expected-warning {{not supported}} + template<class T> friend void A<T>::C::h(); // expected-warning {{not supported}} + }; + + template<> struct A<int> { + X::type a; // FIXME: private + struct B { + X::type b; // ok + }; + int f() { X::type c; } // FIXME: private + void g() { X::type d; } // ok + struct D { + void h() { X::type e; } // FIXME: private + }; + }; +} + +namespace dr639 { // dr639: yes + void f(int i) { + void((i = 0) + (i = 0)); // expected-warning {{unsequenced}} + } +} diff --git a/test/CXX/drs/dr9xx.cpp b/test/CXX/drs/dr9xx.cpp index 40dc2821adc3..4bcd6565e068 100644 --- a/test/CXX/drs/dr9xx.cpp +++ b/test/CXX/drs/dr9xx.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors #if __cplusplus < 201103L // expected-no-diagnostics diff --git a/test/CXX/except/except.spec/p1.cpp b/test/CXX/except/except.spec/p1.cpp index a32f37d55208..fa53c9f5d23f 100644 --- a/test/CXX/except/except.spec/p1.cpp +++ b/test/CXX/except/except.spec/p1.cpp @@ -77,5 +77,12 @@ namespace PR11084 { static int f() noexcept(1/X) { return 10; } // expected-error{{argument to noexcept specifier must be a constant expression}} expected-note{{division by zero}} }; - void g() { A<0>::f(); } // expected-note{{in instantiation of exception specification for 'f' requested here}} + template<int X> void f() { + int (*p)() noexcept(1/X); // expected-error{{argument to noexcept specifier must be a constant expression}} expected-note{{division by zero}} + }; + + void g() { + A<0>::f(); // expected-note{{in instantiation of exception specification for 'f'}} + f<0>(); // expected-note{{in instantiation of function template specialization}} + } } diff --git a/test/CXX/except/except.spec/p5-delayed.cpp b/test/CXX/except/except.spec/p5-delayed.cpp new file mode 100644 index 000000000000..99c0e2de31a9 --- /dev/null +++ b/test/CXX/except/except.spec/p5-delayed.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s -fexceptions -fcxx-exceptions + +struct A { struct X { virtual ~X() throw(Y); }; struct Y : X {}; }; +struct B { struct X { virtual void f() throw(Y); }; struct Y : X { void f() throw(Y); }; }; +struct C { struct X { virtual void f() throw(Y); }; struct Y : X { void f() throw(); }; }; +struct D { struct X { virtual void f() throw(Y); }; struct Y : X { void f() noexcept; }; }; +struct E { struct Y; struct X { virtual Y &operator=(const Y&) throw(Y); }; struct Y : X {}; }; +struct F { + struct X { + virtual void f() throw(Y); // expected-note {{here}} + }; + struct Y : X { + void f() throw(int); // expected-error {{more lax}} + }; +}; diff --git a/test/CXX/expr/expr.const/p2-0x.cpp b/test/CXX/expr/expr.const/p2-0x.cpp index bcf45a0c05b4..d027c7a388bb 100644 --- a/test/CXX/expr/expr.const/p2-0x.cpp +++ b/test/CXX/expr/expr.const/p2-0x.cpp @@ -131,14 +131,14 @@ namespace IncompleteClassTypeAddr { namespace UndefinedBehavior { void f(int n) { switch (n) { - case (int)4.4e9: // expected-error {{constant expression}} expected-note {{value 4.4E+9 is outside the range of representable values of type 'int'}} expected-note {{previous case defined here}} + case (int)4.4e9: // expected-error {{constant expression}} expected-note {{value 4.4E+9 is outside the range of representable values of type 'int'}} case (int)0x80000000u: // ok case (int)10000000000ll: // expected-note {{here}} case (unsigned int)10000000000ll: // expected-error {{duplicate case value}} case (int)(unsigned)(long long)4.4e9: // ok - case (int)(float)1e300: // expected-error {{constant expression}} expected-note {{value 1.0E+300 is outside the range of representable values of type 'float'}} expected-error {{duplicate case value '2147483647'}} expected-note {{previous case defined here}} + case (int)(float)1e300: // expected-error {{constant expression}} expected-note {{value 1.0E+300 is outside the range of representable values of type 'float'}} case (int)((float)1e37 / 1e30): // ok - case (int)(__fp16)65536: // expected-error {{constant expression}} expected-note {{value 65536 is outside the range of representable values of type '__fp16'}} expected-error {{duplicate case value '2147483647'}} + case (int)(__fp16)65536: // expected-error {{constant expression}} expected-note {{value 65536 is outside the range of representable values of type '__fp16'}} break; } } @@ -277,7 +277,7 @@ namespace UndefinedBehavior { // - a lambda-expression (5.1.2); struct Lambda { - int n : []{ return 1; }(); // expected-error {{constant expression}} expected-error {{integral constant expression}} + int n : []{ return 1; }(); // expected-error {{constant expression}} expected-error {{integral constant expression}} expected-note {{non-literal type}} }; // - an lvalue-to-rvalue conversion (4.1) unless it is applied to diff --git a/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp b/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp index fd90482ae8d2..0e948ce00031 100644 --- a/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp @@ -136,12 +136,11 @@ namespace Static { namespace PR12564 { struct Base { - void bar(Base&) {} // FIXME: expected-note {{here}} + void bar(Base&) {} }; struct Derived : Base { - // FIXME: This should be accepted. - void foo(Derived& d) noexcept(noexcept(d.bar(d))) {} // expected-error {{cannot bind to a value of unrelated type}} + void foo(Derived& d) noexcept(noexcept(d.bar(d))) {} }; } diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p19.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p19.cpp index 35b77896c868..40360e40694c 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p19.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p19.cpp @@ -7,10 +7,10 @@ struct MoveOnly { template<typename T> T &&move(T&); void test_special_member_functions(MoveOnly mo, int i) { - auto lambda1 = [i]() { }; // expected-note 2 {{lambda expression begins here}} + auto lambda1 = [i]() { }; // expected-note {{lambda expression begins here}} expected-note 2{{candidate}} // Default constructor - decltype(lambda1) lambda2; // expected-error{{call to implicitly-deleted default constructor of 'decltype(lambda1)' (aka '(lambda}} + decltype(lambda1) lambda2; // expected-error{{no matching constructor}} // Copy assignment operator lambda1 = lambda1; // expected-error{{copy assignment operator is implicitly deleted}} diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p2-generic-lambda-1y.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p2-generic-lambda-1y.cpp index 03147a692dd5..d791ed60cfca 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p2-generic-lambda-1y.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p2-generic-lambda-1y.cpp @@ -18,7 +18,7 @@ void unevaluated_operand(P &p, int i) { //expected-note{{declared here}} // FIXME: this should only emit one error. int i2 = sizeof([](auto a, auto b)->void{}(3, '4')); // expected-error{{lambda expression in an unevaluated operand}} \ // expected-error{{invalid application of 'sizeof'}} - const std::type_info &ti1 = typeid([](auto &a) -> P& { static P p; return p; }(i)); + const std::type_info &ti1 = typeid([](auto &a) -> P& { static P p; return p; }(i)); // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} const std::type_info &ti2 = typeid([](auto) -> int { return i; }(i)); // expected-error{{lambda expression in an unevaluated operand}}\ // expected-error{{cannot be implicitly captured}}\ // expected-note{{begins here}} diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p2.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p2.cpp index 1fbe28722a41..647c76d604e4 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p2.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p2.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wno-unused-value %s -verify // prvalue void prvalue() { diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p3.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p3.cpp index 562f92a78bbc..80771d7a229a 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p3.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p3.cpp @@ -1,6 +1,11 @@ // RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify void test_nonaggregate(int i) { - auto lambda = [i]() -> void {}; // expected-note 3{{candidate constructor}} + auto lambda = [i]() -> void {}; // expected-note 2{{candidate constructor}} decltype(lambda) foo = { 1 }; // expected-error{{no matching constructor}} + static_assert(!__is_literal(decltype(lambda)), ""); + + auto lambda2 = []{}; // expected-note 2{{candidate constructor}} + decltype(lambda2) bar = {}; // expected-error{{no matching constructor}} + static_assert(!__is_literal(decltype(lambda2)), ""); } diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp index 1016cb1d3056..a36175af6fec 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp @@ -34,15 +34,12 @@ X infer_X_return_type(X x) { }(5); } -X infer_X_return_type_fail(X x) { +X infer_X_return_type_2(X x) { return [x](int y) { if (y > 0) return X(); else - return x; -#if __cplusplus <= 201103L - // expected-error@-2 {{return type 'const X' must match previous return type 'X' when lambda expression has unspecified explicit return type}} -#endif + return x; // ok even in c++11, per dr1048. }(5); } diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp index 407b083231a3..90cbf02b2a6a 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp @@ -140,11 +140,11 @@ namespace NonLocalLambdaInstantation { } template<typename T> - struct X2 { + struct X2 { // expected-note{{in instantiation of default member initializer 'NonLocalLambdaInstantation::X2<int *>::x' requested here}} int x = []{ return T(); }(); // expected-error{{cannot initialize a member subobject of type 'int' with an rvalue of type 'int *'}} }; X2<int> x2i; X2<float> x2f; - X2<int*> x2ip; // expected-note{{in instantiation of template class 'NonLocalLambdaInstantation::X2<int *>' requested here}} + X2<int*> x2ip; // expected-note{{implicit default constructor for 'NonLocalLambdaInstantation::X2<int *>' first required here}} } diff --git a/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp b/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp index 427e8c5007f2..a2a57956df9b 100644 --- a/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp +++ b/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -fms-extensions -Wno-delete-incomplete %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -fms-extensions -Wno-delete-incomplete -Wno-unused-value %s // expected-no-diagnostics #define P(e) static_assert(noexcept(e), "expected nothrow") diff --git a/test/CXX/lex/lex.literal/lex.ext/p3.cpp b/test/CXX/lex/lex.literal/lex.ext/p3.cpp index e812ddddd8a4..d764989312c2 100644 --- a/test/CXX/lex/lex.literal/lex.ext/p3.cpp +++ b/test/CXX/lex/lex.literal/lex.ext/p3.cpp @@ -9,7 +9,7 @@ int &i2 = 45_x1; template<char...> char &operator "" _x1 (); int &i3 = 0377_x1; -int &i4 = 90000000000000000000000000000000000000000000000_x1; // expected-error {{integer constant is larger than the largest unsigned integer type}} +int &i4 = 90000000000000000000000000000000000000000000000_x1; // expected-error {{integer literal is too large to be represented in any integer type}} double &operator "" _x2 (const char *); double &i5 = 123123123123123123123123123123123123123123123_x2; diff --git a/test/CXX/lex/lex.trigraph/p1.cpp b/test/CXX/lex/lex.trigraph/p1.cpp index aacbc55b28fe..a80b00eabe7e 100644 --- a/test/CXX/lex/lex.trigraph/p1.cpp +++ b/test/CXX/lex/lex.trigraph/p1.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -trigraphs -Wtrigraphs -verify %s +// RUN: %clang_cc1 -fsyntax-only -ftrigraphs -Wtrigraphs -verify %s ??=pragma // expected-warning {{trigraph converted to '#' character}} diff --git a/test/CXX/lex/lex.trigraph/p2.cpp b/test/CXX/lex/lex.trigraph/p2.cpp index 7d11d5bf5d59..6502aa8d7921 100644 --- a/test/CXX/lex/lex.trigraph/p2.cpp +++ b/test/CXX/lex/lex.trigraph/p2.cpp @@ -1,3 +1,3 @@ -// RUN: %clang_cc1 -fsyntax-only -trigraphs -Wtrigraphs -verify %s +// RUN: %clang_cc1 -fsyntax-only -ftrigraphs -Wtrigraphs -verify %s ??=define arraycheck(a,b) a??(b??) ??!??! b??(a??) // expected-warning {{trigraph converted to '#' character}} expected-warning {{trigraph converted to '[' character}} expected-warning {{trigraph converted to ']' character}} expected-warning {{trigraph converted to '|' character}} expected-warning {{trigraph converted to '|' character}} expected-warning {{trigraph converted to '[' character}} expected-warning {{trigraph converted to ']' character}} diff --git a/test/CXX/lex/lex.trigraph/p3.cpp b/test/CXX/lex/lex.trigraph/p3.cpp index c74d8f358d02..bf935708a243 100644 --- a/test/CXX/lex/lex.trigraph/p3.cpp +++ b/test/CXX/lex/lex.trigraph/p3.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -trigraphs -Wtrigraphs -verify %s +// RUN: %clang_cc1 -fsyntax-only -ftrigraphs -Wtrigraphs -verify %s // expected-no-diagnostics char a[] = diff --git a/test/CXX/stmt.stmt/stmt.dcl/p3-0x.cpp b/test/CXX/stmt.stmt/stmt.dcl/p3-0x.cpp index 574cb40c4670..d7726c944cdb 100644 --- a/test/CXX/stmt.stmt/stmt.dcl/p3-0x.cpp +++ b/test/CXX/stmt.stmt/stmt.dcl/p3-0x.cpp @@ -30,11 +30,11 @@ struct Y { void f(); void test_Y() { - goto end; // expected-error{{goto into protected scope}} + goto end; // expected-error{{cannot jump from this goto statement to its label}} Y y; // expected-note{{jump bypasses variable with a non-trivial destructor}} end: f(); - goto inner; // expected-error{{goto into protected scope}} + goto inner; // expected-error{{cannot jump from this goto statement to its label}} { Y y2; // expected-note{{jump bypasses variable with a non-trivial destructor}} inner: diff --git a/test/CXX/stmt.stmt/stmt.dcl/p3.cpp b/test/CXX/stmt.stmt/stmt.dcl/p3.cpp index f52e3b6d142d..4bcc648e84aa 100644 --- a/test/CXX/stmt.stmt/stmt.dcl/p3.cpp +++ b/test/CXX/stmt.stmt/stmt.dcl/p3.cpp @@ -29,7 +29,7 @@ struct Y { }; void test_Y() { - goto end; // expected-error{{goto into protected scope}} + goto end; // expected-error{{cannot jump from this goto statement to its label}} Y y; // expected-note{{jump bypasses variable with a non-trivial destructor}} end: return; @@ -40,7 +40,7 @@ struct Z { }; void test_Z() { - goto end; // expected-error{{goto into protected scope}} + goto end; // expected-error{{cannot jump from this goto statement to its label}} Z z; // expected-note{{jump bypasses initialization of non-POD variable}} end: return; diff --git a/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp index 8a3168e5f806..b0305dd756a6 100644 --- a/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp +++ b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp @@ -8,7 +8,7 @@ struct X0 { template<typename T> T X0<T>::value = 0; // expected-error{{no viable conversion}} -struct X1 { +struct X1 { X1(int); }; @@ -19,8 +19,8 @@ X1& get_X1() { return X0<X1>::value; } double*& get_double_ptr() { return X0<int*>::value; } // expected-error{{non-const lvalue reference to type 'double *' cannot bind to a value of unrelated type 'int *'}} -X2& get_X2() { +X2& get_X2() { return X0<X2>::value; // expected-note{{instantiation}} } - -template<typename T> T x; // expected-warning{{variable templates are a C++1y extension}} + +template<typename T> T x; // expected-warning{{variable templates are a C++14 extension}} diff --git a/test/CXX/temp/temp.decls/temp.friend/p5.cpp b/test/CXX/temp/temp.decls/temp.friend/p5.cpp index b26abb64f838..c4f9d63b7c66 100644 --- a/test/CXX/temp/temp.decls/temp.friend/p5.cpp +++ b/test/CXX/temp/temp.decls/temp.friend/p5.cpp @@ -20,7 +20,7 @@ namespace test1 { class C { static void foo(); - template <class T> friend void A<T>::f(); + template <class T> friend void A<T>::f(); // expected-warning {{not supported}} }; template <class T> struct A { @@ -42,7 +42,7 @@ namespace test2 { class C { static void foo(); - template <class T> friend void A<T>::g(); + template <class T> friend void A<T>::g(); // expected-warning {{not supported}} }; template <class T> struct A { @@ -86,7 +86,7 @@ namespace test4 { template <class V> template <class U> - friend void X<V>::operator+=(U); + friend void X<V>::operator+=(U); // expected-warning {{not supported}} }; void test() { @@ -96,7 +96,7 @@ namespace test4 { namespace test5 { template<template <class> class T> struct A { - template<template <class> class U> friend void A<U>::foo(); + template<template <class> class U> friend void A<U>::foo(); // expected-warning {{not supported}} }; template <class> struct B {}; diff --git a/test/CXX/temp/temp.decls/temp.variadic/metafunctions.cpp b/test/CXX/temp/temp.decls/temp.variadic/metafunctions.cpp index 73cbd0749cbd..f1231f61111e 100644 --- a/test/CXX/temp/temp.decls/temp.variadic/metafunctions.cpp +++ b/test/CXX/temp/temp.decls/temp.variadic/metafunctions.cpp @@ -243,7 +243,7 @@ namespace FunctionTypes { }; template<typename R, typename ...Types> - struct Arity<R(Types......)> { + struct Arity<R(Types......)> { // expected-warning {{varargs}} expected-note {{pack}} expected-note {{insert ','}} static const unsigned value = sizeof...(Types); }; diff --git a/test/CXX/temp/temp.decls/temp.variadic/p5.cpp b/test/CXX/temp/temp.decls/temp.variadic/p5.cpp index dae686566691..4f9368f6b605 100644 --- a/test/CXX/temp/temp.decls/temp.variadic/p5.cpp +++ b/test/CXX/temp/temp.decls/temp.variadic/p5.cpp @@ -354,6 +354,7 @@ void test_unexpanded_exprs(Types ...values) { for (auto t : values) { } // expected-error{{expression contains unexpanded parameter pack 'values'}} switch (values) { } // expected-error{{expression contains unexpanded parameter pack 'values'}} + switch (0) { case 0: case values: ; } // expected-error{{expression contains unexpanded parameter pack 'values'}} do { } while (values); // expected-error{{expression contains unexpanded parameter pack 'values'}} @@ -422,3 +423,17 @@ namespace PR16303 { B<1,2>::C<4,5,6> c1; // expected-note{{in instantiation of}} B<1,2,3,4>::C<4,5,6> c2; // expected-note{{in instantiation of}} } + +namespace PR21289 { + template<int> using T = int; + template<typename> struct S { static const int value = 0; }; + template<typename> const int vt = 0; // expected-warning {{extension}} + int f(...); + template<int ...Ns> void g() { + f(T<Ns>()...); + f(S<T<Ns>>::value...); + f(vt<T<Ns>>...); + } + template void g<>(); + template void g<1, 2, 3>(); +} diff --git a/test/CXX/temp/temp.param/p5.cpp b/test/CXX/temp/temp.param/p5.cpp index c25868267e49..ab430fb8741f 100644 --- a/test/CXX/temp/temp.param/p5.cpp +++ b/test/CXX/temp/temp.param/p5.cpp @@ -1,13 +1,13 @@ // RUN: %clang_cc1 -verify %s -std=c++11 -template<const int I> struct S { +template<const int I> struct S { // expected-note {{instantiation}} decltype(I) n; int &&r = I; // expected-warning 2{{binding reference member 'r' to a temporary value}} expected-note 2{{declared here}} }; -S<5> s; // expected-note {{instantiation}} +S<5> s; -template<typename T, T v> struct U { +template<typename T, T v> struct U { // expected-note {{instantiation}} decltype(v) n; int &&r = v; // expected-warning {{binding reference member 'r' to a temporary value}} expected-note {{declared here}} }; -U<const int, 6> u; // expected-note {{instantiation}} +U<const int, 6> u; diff --git a/test/CXX/temp/temp.spec/temp.explicit/p1-0x.cpp b/test/CXX/temp/temp.spec/temp.explicit/p1-0x.cpp index f804d4db1299..580ef3151e5d 100644 --- a/test/CXX/temp/temp.spec/temp.explicit/p1-0x.cpp +++ b/test/CXX/temp/temp.spec/temp.explicit/p1-0x.cpp @@ -9,7 +9,7 @@ template inline void X<int>::f(); // expected-error{{explicit instantiation cann template<typename T> struct Y { - constexpr int f() { return 0; } // expected-warning{{C++1y}} + constexpr int f() { return 0; } // expected-warning{{C++14}} }; template constexpr int Y<int>::f() const; // expected-error{{explicit instantiation cannot be 'constexpr'}} diff --git a/test/CodeGen/2003-08-21-WideString.c b/test/CodeGen/2003-08-21-WideString.c index 4071d17c7970..1a6e5b7c8829 100644 --- a/test/CodeGen/2003-08-21-WideString.c +++ b/test/CodeGen/2003-08-21-WideString.c @@ -5,9 +5,9 @@ typedef __WCHAR_TYPE__ wchar_t; #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \ || defined(_M_X64) || defined(SHORT_WCHAR) #define WCHAR_T_TYPE unsigned short -#elif defined(__sun) || defined(__AuroraUX__) +#elif defined(__sun) #define WCHAR_T_TYPE long -#else /* Solaris or AuroraUX. */ +#else /* Solaris. */ #define WCHAR_T_TYPE int #endif diff --git a/test/CodeGen/2005-06-15-ExpandGotoInternalProblem.c b/test/CodeGen/2005-06-15-ExpandGotoInternalProblem.c index dd1acc54bc1d..0698601ad133 100644 --- a/test/CodeGen/2005-06-15-ExpandGotoInternalProblem.c +++ b/test/CodeGen/2005-06-15-ExpandGotoInternalProblem.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -std=c99 %s -emit-llvm -o - | \ -// RUN: opt -std-compile-opts -disable-output +// RUN: opt -O3 -disable-output // PR580 int X, Y; diff --git a/test/CodeGen/2005-09-24-AsmUserPrefix.c b/test/CodeGen/2005-09-24-AsmUserPrefix.c index 16283130beb0..d0e5bd1c3a44 100644 --- a/test/CodeGen/2005-09-24-AsmUserPrefix.c +++ b/test/CodeGen/2005-09-24-AsmUserPrefix.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -emit-llvm -o - | opt -std-compile-opts | llc | \ +// RUN: %clang_cc1 %s -emit-llvm -o - | opt -O3 | llc | \ // RUN: not grep _foo2 void foo() __asm__("foo2"); diff --git a/test/CodeGen/2007-06-18-SextAttrAggregate.c b/test/CodeGen/2007-06-18-SextAttrAggregate.c index 92171e2bd9b7..23c211d3ba04 100644 --- a/test/CodeGen/2007-06-18-SextAttrAggregate.c +++ b/test/CodeGen/2007-06-18-SextAttrAggregate.c @@ -1,11 +1,13 @@ // RUN: %clang_cc1 %s -o - -emit-llvm | FileCheck %s -// XFAIL: aarch64, arm64 +// XFAIL: aarch64, arm64, x86_64-pc-win32, x86_64-w64-mingw32 // PR1513 // AArch64 ABI actually requires the reverse of what this is testing: the callee // does any extensions and remaining bits are unspecified. +// Win64 ABI does expect extensions for type smaller than 64bits. + // Technically this test wasn't written to test that feature, but it's a // valuable check nevertheless. diff --git a/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c b/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c index 33bd800456f9..7401e114ddd0 100644 --- a/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c +++ b/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c @@ -8,5 +8,4 @@ struct et7 { 52, }; -// CHECK: @yv7 = global -// CHECK: i8 52, +// CHECK: @yv7 = global %struct.et7 { [0 x float] zeroinitializer, i8 52 } diff --git a/test/CodeGen/2009-07-15-pad-wchar_t-array.c b/test/CodeGen/2009-07-15-pad-wchar_t-array.c index df12cae90ea0..4ae35158fa8a 100644 --- a/test/CodeGen/2009-07-15-pad-wchar_t-array.c +++ b/test/CodeGen/2009-07-15-pad-wchar_t-array.c @@ -5,9 +5,9 @@ typedef __WCHAR_TYPE__ wchar_t; #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \ || defined(_M_X64) || defined(SHORT_WCHAR) #define WCHAR_T_TYPE unsigned short -#elif defined(__sun) || defined(__AuroraUX__) +#elif defined(__sun) #define WCHAR_T_TYPE long -#else /* Solaris or AuroraUX. */ +#else /* Solaris. */ #define WCHAR_T_TYPE int #endif diff --git a/test/CodeGen/2009-10-20-GlobalDebug.c b/test/CodeGen/2009-10-20-GlobalDebug.c index c48ad28ad065..e56f227d2ac6 100644 --- a/test/CodeGen/2009-10-20-GlobalDebug.c +++ b/test/CodeGen/2009-10-20-GlobalDebug.c @@ -6,5 +6,5 @@ int main() { return 0; } -// CHECK: metadata !{i32 {{.*}}, i32 0, metadata !{{.*}}, metadata !"localstatic", metadata !"localstatic", metadata !"", metadata !{{.*}}, i32 5, metadata !{{.*}}, i32 1, i32 1, i32* @main.localstatic, null} ; [ DW_TAG_variable ] -// CHECK: metadata !{i32 {{.*}}, i32 0, null, metadata !"global", metadata !"global", metadata !"", metadata !{{.*}}, i32 3, metadata !{{.*}}, i32 0, i32 1, i32* @global, null} ; [ DW_TAG_variable ] +// CHECK: !"0x34\00localstatic\00localstatic\00\005\001\001", !{{.*}}, !{{.*}}, !{{.*}}, i32* @main.localstatic, null} ; [ DW_TAG_variable ] +// CHECK: !"0x34\00global\00global\00\003\000\001", null, !{{.*}}, !{{.*}}, i32* @global, null} ; [ DW_TAG_variable ] diff --git a/test/CodeGen/2010-02-15-DbgStaticVar.c b/test/CodeGen/2010-02-15-DbgStaticVar.c index facd14e03ee6..8980b60cf68d 100644 --- a/test/CodeGen/2010-02-15-DbgStaticVar.c +++ b/test/CodeGen/2010-02-15-DbgStaticVar.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -g -emit-llvm %s -o - | grep "metadata ..b., metadata ..b., metadata ...," +// RUN: %clang_cc1 -g -emit-llvm %s -o - | FileCheck %s // Test to check intentionally empty linkage name for a static variable. // Radar 7651244. static int foo(int a) @@ -11,3 +11,4 @@ int main() { int j = foo(1); return 0; } +// CHECK: !"0x34\00b\00b\00\00{{.*}}", diff --git a/test/CodeGen/2010-07-08-DeclDebugLineNo.c b/test/CodeGen/2010-07-08-DeclDebugLineNo.c index 5e9edd9acd99..44c973acda67 100644 --- a/test/CodeGen/2010-07-08-DeclDebugLineNo.c +++ b/test/CodeGen/2010-07-08-DeclDebugLineNo.c @@ -6,5 +6,5 @@ void foo() { int p = 0; // line #5: CHECK: {{call.*llvm.dbg.declare.*%p.*\!dbg }}[[variable_p:![0-9]+]] } // Now match the line number records: -// CHECK: {{^}}[[variable_l]]{{ = metadata ![{]i32 5,}} -// CHECK: {{^}}[[variable_p]]{{ = metadata ![{]i32 6,}} +// CHECK: {{^}}[[variable_l]] = !MDLocation(line: 5, +// CHECK: {{^}}[[variable_p]] = !MDLocation(line: 6, diff --git a/test/CodeGen/24-bit.c b/test/CodeGen/24-bit.c new file mode 100644 index 000000000000..9dd0157fd3b4 --- /dev/null +++ b/test/CodeGen/24-bit.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -O0 -o - %s | FileCheck %s + +static union ibtt2 +{ + struct ibtt0 { signed ibt0:10; unsigned short ibt1; } ibt5; + struct ibtt1 { signed ibt2:3; signed ibt3:9; signed ibt4:9; } ibt6; +} ibt15 = {{267, 15266}}; + +void callee_ibt0f(union ibtt2 ibtp5); + +void test(void) { +// CHECK: = load i32* + callee_ibt0f(ibt15); +} diff --git a/test/CodeGen/Atomics.c b/test/CodeGen/Atomics.c index 684f36d40440..f957883575de 100644 --- a/test/CodeGen/Atomics.c +++ b/test/CodeGen/Atomics.c @@ -49,6 +49,15 @@ void test_op_ignore (void) // CHECK-LABEL: define void @test_op_ignore (void) __sync_fetch_and_xor (&sll, 1); // CHECK: atomicrmw xor i64 (void) __sync_fetch_and_xor (&ull, 1); // CHECK: atomicrmw xor i64 + (void) __sync_fetch_and_nand (&sc, 1); // CHECK: atomicrmw nand i8 + (void) __sync_fetch_and_nand (&uc, 1); // CHECK: atomicrmw nand i8 + (void) __sync_fetch_and_nand (&ss, 1); // CHECK: atomicrmw nand i16 + (void) __sync_fetch_and_nand (&us, 1); // CHECK: atomicrmw nand i16 + (void) __sync_fetch_and_nand (&si, 1); // CHECK: atomicrmw nand i32 + (void) __sync_fetch_and_nand (&ui, 1); // CHECK: atomicrmw nand i32 + (void) __sync_fetch_and_nand (&sll, 1); // CHECK: atomicrmw nand i64 + (void) __sync_fetch_and_nand (&ull, 1); // CHECK: atomicrmw nand i64 + (void) __sync_fetch_and_and (&sc, 1); // CHECK: atomicrmw and i8 (void) __sync_fetch_and_and (&uc, 1); // CHECK: atomicrmw and i8 (void) __sync_fetch_and_and (&ss, 1); // CHECK: atomicrmw and i16 @@ -98,6 +107,15 @@ void test_fetch_and_op (void) // CHECK-LABEL: define void @test_fetch_and_op sll = __sync_fetch_and_xor (&sll, 11); // CHECK: atomicrmw xor ull = __sync_fetch_and_xor (&ull, 11); // CHECK: atomicrmw xor + sc = __sync_fetch_and_nand (&sc, 11); // CHECK: atomicrmw nand + uc = __sync_fetch_and_nand (&uc, 11); // CHECK: atomicrmw nand + ss = __sync_fetch_and_nand (&ss, 11); // CHECK: atomicrmw nand + us = __sync_fetch_and_nand (&us, 11); // CHECK: atomicrmw nand + si = __sync_fetch_and_nand (&si, 11); // CHECK: atomicrmw nand + ui = __sync_fetch_and_nand (&ui, 11); // CHECK: atomicrmw nand + sll = __sync_fetch_and_nand (&sll, 11); // CHECK: atomicrmw nand + ull = __sync_fetch_and_nand (&ull, 11); // CHECK: atomicrmw nand + sc = __sync_fetch_and_and (&sc, 11); // CHECK: atomicrmw and uc = __sync_fetch_and_and (&uc, 11); // CHECK: atomicrmw and ss = __sync_fetch_and_and (&ss, 11); // CHECK: atomicrmw and @@ -147,6 +165,31 @@ void test_op_and_fetch (void) sll = __sync_xor_and_fetch (&sll, uc); // CHECK: atomicrmw xor ull = __sync_xor_and_fetch (&ull, uc); // CHECK: atomicrmw xor + sc = __sync_nand_and_fetch (&sc, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + uc = __sync_nand_and_fetch (&uc, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + ss = __sync_nand_and_fetch (&ss, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + us = __sync_nand_and_fetch (&us, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + si = __sync_nand_and_fetch (&si, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + ui = __sync_nand_and_fetch (&ui, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + sll = __sync_nand_and_fetch (&sll, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + ull = __sync_nand_and_fetch (&ull, uc); // CHECK: atomicrmw nand + // CHECK: and + // CHECK: xor + sc = __sync_and_and_fetch (&sc, uc); // CHECK: atomicrmw and uc = __sync_and_and_fetch (&uc, uc); // CHECK: atomicrmw and ss = __sync_and_and_fetch (&ss, uc); // CHECK: atomicrmw and diff --git a/test/CodeGen/aarch64-fix-cortex-a53-835769.c b/test/CodeGen/aarch64-fix-cortex-a53-835769.c new file mode 100644 index 000000000000..7ad124012e6d --- /dev/null +++ b/test/CodeGen/aarch64-fix-cortex-a53-835769.c @@ -0,0 +1,27 @@ +// REQUIRES: aarch64-registered-target + +// RUN: %clang -O3 -target aarch64-linux-eabi %s -S -o- \ +// RUN: | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s +// RUN: %clang -O3 -target aarch64-linux-eabi -mfix-cortex-a53-835769 %s -S -o- 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s +// RUN: %clang -O3 -target aarch64-linux-eabi -mno-fix-cortex-a53-835769 %s -S -o- 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s + +// RUN: %clang -O3 -target aarch64-android-eabi %s -S -o- \ +// RUN: | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s +// RUN: %clang -O3 -target aarch64-android-eabi -mfix-cortex-a53-835769 %s -S -o- \ +// RUN: | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s +// RUN: %clang -O3 -target aarch64-android-eabi -mno-fix-cortex-a53-835769 %s -S -o- \ +// RUN: | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s + +typedef long int64_t; + +int64_t f_load_madd_64(int64_t a, int64_t b, int64_t *c) { + int64_t result = a+b*(*c); + return result; +} + +// CHECK: ldr +// CHECK-YES-NEXT: nop +// CHECK-NO-NEXT-NOT: nop +// CHECK-NEXT: madd diff --git a/test/CodeGen/aarch64-poly64.c b/test/CodeGen/aarch64-poly64.c index 290cc69bd43f..a14162c05353 100644 --- a/test/CodeGen/aarch64-poly64.c +++ b/test/CodeGen/aarch64-poly64.c @@ -102,6 +102,18 @@ poly64x2_t test_vdupq_n_p64(poly64_t a) { // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}} } +poly64x1_t test_vmov_n_p64(poly64_t a) { + // CHECK-LABEL: test_vmov_n_p64 + return vmov_n_p64(a); + // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}} +} + +poly64x2_t test_vmovq_n_p64(poly64_t a) { + // CHECK-LABEL: test_vmovq_n_p64 + return vmovq_n_p64(a); + // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}} +} + poly64x1_t test_vdup_lane_p64(poly64x1_t vec) { // CHECK-LABEL: test_vdup_lane_p64 return vdup_lane_p64(vec, 0); diff --git a/test/CodeGen/aarch64-type-sizes.c b/test/CodeGen/aarch64-type-sizes.c index b331b6c3c32c..3ff8c4f0d4d0 100644 --- a/test/CodeGen/aarch64-type-sizes.c +++ b/test/CodeGen/aarch64-type-sizes.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple arm64_be-none-linux-gnu -emit-llvm -w -o - %s | FileCheck --check-prefix=CHECK --check-prefix=CHECK-BE %s +// RUN: %clang_cc1 -triple aarch64_be-none-linux-gnu -emit-llvm -w -o - %s | FileCheck --check-prefix=CHECK --check-prefix=CHECK-BE %s // char by definition has size 1 // CHECK-LE: target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" diff --git a/test/CodeGen/aarch64-varargs.c b/test/CodeGen/aarch64-varargs.c index f787afe37e51..248f1c10cec4 100644 --- a/test/CodeGen/aarch64-varargs.c +++ b/test/CodeGen/aarch64-varargs.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -triple arm64-linux-gnu -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=CHECK-LE %s -// RUN: %clang_cc1 -triple arm64_be-linux-gnu -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=CHECK-BE %s +// RUN: %clang_cc1 -triple aarch64_be-linux-gnu -emit-llvm -o - %s | FileCheck --check-prefix=CHECK --check-prefix=CHECK-BE %s #include <stdarg.h> diff --git a/test/CodeGen/adc-builtins.c b/test/CodeGen/adc-builtins.c new file mode 100644 index 000000000000..5577d22c60b3 --- /dev/null +++ b/test/CodeGen/adc-builtins.c @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ffreestanding -emit-llvm -o - %s | FileCheck %s + +#include <x86intrin.h> + +unsigned char test_addcarry_u32(unsigned char __cf, unsigned int __x, + unsigned int __y, unsigned int *__p) { +// CHECK-LABEL: test_addcarry_u32 +// CHECK: call i8 @llvm.x86.addcarry.u32 + return _addcarry_u32(__cf, __x, __y, __p); +} + +unsigned char test_addcarry_u64(unsigned char __cf, unsigned long long __x, + unsigned long long __y, + unsigned long long *__p) { +// CHECK-LABEL: test_addcarry_u64 +// CHECK: call i8 @llvm.x86.addcarry.u64 + return _addcarry_u64(__cf, __x, __y, __p); +} + +unsigned char test_subborrow_u32(unsigned char __cf, unsigned int __x, + unsigned int __y, unsigned int *__p) { +// CHECK-LABEL: test_subborrow_u32 +// CHECK: call i8 @llvm.x86.subborrow.u32 + return _subborrow_u32(__cf, __x, __y, __p); +} + +unsigned char test_subborrow_u64(unsigned char __cf, unsigned long long __x, + unsigned long long __y, + unsigned long long *__p) { +// CHECK-LABEL: test_subborrow_u64 +// CHECK: call i8 @llvm.x86.subborrow.u64 + return _subborrow_u64(__cf, __x, __y, __p); +} diff --git a/test/CodeGen/address-safety-attr.cpp b/test/CodeGen/address-safety-attr.cpp index f94efd62c9c0..031d013a9b50 100644 --- a/test/CodeGen/address-safety-attr.cpp +++ b/test/CodeGen/address-safety-attr.cpp @@ -1,9 +1,16 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck -check-prefix=WITHOUT %s -// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -fsanitize=address | FileCheck -check-prefix=ASAN %s -// RUN: echo "src:%s" > %t.file.blacklist +int DefinedInDifferentFile(int *a); +// RUN: echo "int DefinedInDifferentFile(int *a) { return *a; }" > %t.extra-source.cpp +// RUN: echo "struct S { S(){} ~S(){} };" >> %t.extra-source.cpp +// RUN: echo "S glob_array[5];" >> %t.extra-source.cpp + +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp | FileCheck -check-prefix=WITHOUT %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address | FileCheck -check-prefix=ASAN %s + // RUN: echo "fun:*BlacklistedFunction*" > %t.func.blacklist -// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -fsanitize=address -fsanitize-blacklist=%t.file.blacklist | FileCheck -check-prefix=BLFILE %s -// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -fsanitize=address -fsanitize-blacklist=%t.func.blacklist | FileCheck -check-prefix=BLFUNC %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.func.blacklist | FileCheck -check-prefix=BLFUNC %s + +// RUN: echo "src:%s" > %t.file.blacklist +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.file.blacklist | FileCheck -check-prefix=BLFILE %s // FIXME: %t.file.blacklist is like "src:x:\path\to\clang\test\CodeGen\address-safety-attr.cpp" // REQUIRES: shell @@ -12,7 +19,25 @@ // when AddressSanitizer is enabled, unless no_sanitize_address attribute // is present. -// WITHOUT: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] +// Attributes for function defined in different source file: +// WITHOUT: DefinedInDifferentFile{{.*}} [[NOATTR:#[0-9]+]] +// BLFILE: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] +// BLFUNC: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] +// ASAN: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] + +// Check that functions generated for global in different source file are +// not blacklisted. +// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR_NO_TF:#[0-9]+]] +// WITHOUT: @__cxx_global_array_dtor{{.*}}[[NOATTR_NO_TF]] +// BLFILE: @__cxx_global_var_init{{.*}}[[WITH_NO_TF:#[0-9]+]] +// BLFILE: @__cxx_global_array_dtor{{.*}}[[WITH_NO_TF]] +// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH_NO_TF:#[0-9]+]] +// BLFUNC: @__cxx_global_array_dtor{{.*}}[[WITH_NO_TF]] +// ASAN: @__cxx_global_var_init{{.*}}[[WITH_NO_TF:#[0-9]+]] +// ASAN: @__cxx_global_array_dtor{{.*}}[[WITH_NO_TF]] + + +// WITHOUT: NoAddressSafety1{{.*}}) [[NOATTR]] // BLFILE: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] // BLFUNC: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] // ASAN: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] @@ -29,8 +54,8 @@ int NoAddressSafety2(int *a) { return *a; } // WITHOUT: AddressSafetyOk{{.*}}) [[NOATTR]] // BLFILE: AddressSafetyOk{{.*}}) [[NOATTR]] -// BLFUNC: AddressSafetyOk{{.*}}) [[WITH:#[0-9]+]] -// ASAN: AddressSafetyOk{{.*}}) [[WITH:#[0-9]+]] +// BLFUNC: AddressSafetyOk{{.*}}) [[WITH]] +// ASAN: AddressSafetyOk{{.*}}) [[WITH]] int AddressSafetyOk(int *a) { return *a; } // WITHOUT: BlacklistedFunction{{.*}}) [[NOATTR]] @@ -39,6 +64,21 @@ int AddressSafetyOk(int *a) { return *a; } // ASAN: BlacklistedFunction{{.*}}) [[WITH]] int BlacklistedFunction(int *a) { return *a; } +#define GENERATE_FUNC(name) \ + int name(int *a) { return *a; } +// WITHOUT: GeneratedFunction{{.*}}) [[NOATTR]] +// BLFILE: GeneratedFunction{{.*}}) [[NOATTR]] +// BLFUNC: GeneratedFunction{{.*}}) [[WITH]] +// ASAN: GeneratedFunction{{.*}}) [[WITH]] +GENERATE_FUNC(GeneratedFunction) + +#define GENERATE_NAME(name) name##_generated +// WITHOUT: Function_generated{{.*}}) [[NOATTR]] +// BLFILE: Function_generated{{.*}}) [[NOATTR]] +// BLFUNC: Function_generated{{.*}}) [[WITH]] +// ASAN: Function_generated{{.*}}) [[WITH]] +int GENERATE_NAME(Function)(int *a) { return *a; } + // WITHOUT: TemplateAddressSafetyOk{{.*}}) [[NOATTR]] // BLFILE: TemplateAddressSafetyOk{{.*}}) [[NOATTR]] // BLFUNC: TemplateAddressSafetyOk{{.*}}) [[WITH]] @@ -60,21 +100,23 @@ int force_instance = TemplateAddressSafetyOk<42>() // Check that __cxx_global_var_init* get the sanitize_address attribute. int global1 = 0; int global2 = *(int*)((char*)&global1+1); -// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR_NO_TF:#[0-9]+]] +// WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR_NO_TF]] // BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR_NO_TF:#[0-9]+]] -// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH_NO_TF:#[0-9]+]] -// ASAN: @__cxx_global_var_init{{.*}}[[WITH_NO_TF:#[0-9]+]] +// BLFUNC: @__cxx_global_var_init{{.*}}[[WITH_NO_TF]] +// ASAN: @__cxx_global_var_init{{.*}}[[WITH_NO_TF]] // WITHOUT: attributes [[NOATTR]] = { nounwind{{.*}} } // WITHOUT: attributes [[NOATTR_NO_TF]] = { nounwind } -// BLFILE: attributes [[NOATTR]] = { nounwind{{.*}} } +// BLFILE: attributes [[WITH]] = { nounwind sanitize_address{{.*}} } +// BLFILE: attributes [[WITH_NO_TF]] = { nounwind sanitize_address } // BLFILE: attributes [[NOATTR_NO_TF]] = { nounwind } +// BLFILE: attributes [[NOATTR]] = { nounwind{{.*}} } -// BLFUNC: attributes [[NOATTR]] = { nounwind{{.*}} } // BLFUNC: attributes [[WITH]] = { nounwind sanitize_address{{.*}} } // BLFUNC: attributes [[WITH_NO_TF]] = { nounwind sanitize_address } +// BLFUNC: attributes [[NOATTR]] = { nounwind{{.*}} } -// ASAN: attributes [[NOATTR]] = { nounwind{{.*}} } // ASAN: attributes [[WITH]] = { nounwind sanitize_address{{.*}} } // ASAN: attributes [[WITH_NO_TF]] = { nounwind sanitize_address } +// ASAN: attributes [[NOATTR]] = { nounwind{{.*}} } diff --git a/test/CodeGen/address-sanitizer-and-array-cookie.cpp b/test/CodeGen/address-sanitizer-and-array-cookie.cpp new file mode 100644 index 000000000000..ea8953778916 --- /dev/null +++ b/test/CodeGen/address-sanitizer-and-array-cookie.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -triple x86_64-gnu-linux -emit-llvm -o - %s | FileCheck %s -check-prefix=PLAIN +// RUN: %clang_cc1 -triple x86_64-gnu-linux -emit-llvm -o - -fsanitize=address %s | FileCheck %s -check-prefix=ASAN + +typedef __typeof__(sizeof(0)) size_t; +namespace std { + struct nothrow_t {}; + std::nothrow_t nothrow; +} +void *operator new[](size_t, const std::nothrow_t &) throw(); +void *operator new[](size_t, char *); + +struct C { + int x; + ~C(); +}; + +C *CallNew() { + return new C[10]; +} +// PLAIN-LABEL: CallNew +// PLAIN-NOT: nosanitize +// PLAIN-NOT: __asan_poison_cxx_array_cookie +// ASAN-LABEL: CallNew +// ASAN: store{{.*}}nosanitize +// ASAN-NOT: nosanitize +// ASAN: call void @__asan_poison_cxx_array_cookie + +C *CallNewNoThrow() { + return new (std::nothrow) C[10]; +} +// PLAIN-LABEL: CallNewNoThrow +// PLAIN-NOT: nosanitize +// PLAIN-NOT: __asan_poison_cxx_array_cookie +// ASAN-LABEL: CallNewNoThrow +// ASAN: store{{.*}}nosanitize +// ASAN-NOT: nosanitize +// ASAN: call void @__asan_poison_cxx_array_cookie + +void CallDelete(C *c) { + delete [] c; +} + +// PLAIN-LABEL: CallDelete +// PLAIN-NOT: nosanitize +// ASAN-LABEL: CallDelete +// ASAN-NOT: nosanitize +// ASAN: call i64 @__asan_load_cxx_array_cookie +// ASAN-NOT: nosanitize + +char Buffer[20]; +C *CallPlacementNew() { + return new (Buffer) C[20]; +} +// ASAN-LABEL: CallPlacementNew +// ASAN-NOT: __asan_poison_cxx_array_cookie diff --git a/test/CodeGen/adx-builtins.c b/test/CodeGen/adx-builtins.c new file mode 100644 index 000000000000..8738c5d17715 --- /dev/null +++ b/test/CodeGen/adx-builtins.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -ffreestanding -target-feature +adx -emit-llvm -o - %s | FileCheck %s + +#include <x86intrin.h> + +unsigned char test_addcarryx_u32(unsigned char __cf, unsigned int __x, + unsigned int __y, unsigned int *__p) { +// CHECK-LABEL: test_addcarryx_u32 +// CHECK: call i8 @llvm.x86.addcarryx.u32 + return _addcarryx_u32(__cf, __x, __y, __p); +} + +unsigned char test_addcarryx_u64(unsigned char __cf, unsigned long long __x, + unsigned long long __y, + unsigned long long *__p) { +// CHECK-LABEL: test_addcarryx_u64 +// CHECK: call i8 @llvm.x86.addcarryx.u64 + return _addcarryx_u64(__cf, __x, __y, __p); +} diff --git a/test/CodeGen/alias.c b/test/CodeGen/alias.c index 98449d36edf6..b773cc8de938 100644 --- a/test/CodeGen/alias.c +++ b/test/CodeGen/alias.c @@ -3,6 +3,8 @@ int g0; // CHECKBASIC: @g0 = common global i32 0 +__thread int TL_WITH_ALIAS; +// CHECKBASIC-DAG: @TL_WITH_ALIAS = thread_local global i32 0, align 4 static int bar1 = 42; // CHECKBASIC: @bar1 = internal global i32 42 @@ -10,11 +12,14 @@ extern int g1; extern int g1 __attribute((alias("g0"))); // CHECKBASIC-DAG: @g1 = alias i32* @g0 +extern __thread int __libc_errno __attribute__ ((alias ("TL_WITH_ALIAS"))); +// CHECKBASIC-DAG: @__libc_errno = thread_local alias i32* @TL_WITH_ALIAS + void f0(void) { } extern void f1(void); extern void f1(void) __attribute((alias("f0"))); // CHECKBASIC-DAG: @f1 = alias void ()* @f0 -// CHECKBASIC-DAG: @test8_foo = alias weak bitcast (void ()* @test8_bar to void (...)*) +// CHECKBASIC-DAG: @test8_foo = weak alias bitcast (void ()* @test8_bar to void (...)*) // CHECKBASIC-DAG: @test8_zed = alias bitcast (void ()* @test8_bar to void (...)*) // CHECKBASIC-DAG: @test9_zed = alias void ()* @test9_bar // CHECKBASIC: define void @f0() [[NUW:#[0-9]+]] { diff --git a/test/CodeGen/align_value.cpp b/test/CodeGen/align_value.cpp new file mode 100644 index 000000000000..6d0e48128cb2 --- /dev/null +++ b/test/CodeGen/align_value.cpp @@ -0,0 +1,103 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s + +typedef double * __attribute__((align_value(64))) aligned_double; + +void foo(aligned_double x, double * y __attribute__((align_value(32))), + double & z __attribute__((align_value(128)))) { }; +// CHECK: define void @_Z3fooPdS_Rd(double* align 64 %x, double* align 32 %y, double* dereferenceable(8) align 128 %z) + +struct ad_struct { + aligned_double a; +}; + +double *foo(ad_struct& x) { +// CHECK-LABEL: @_Z3fooR9ad_struct + +// CHECK: [[PTRINT1:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR1:%.+]] = and i64 [[PTRINT1]], 63 +// CHECK: [[MASKCOND1:%.+]] = icmp eq i64 [[MASKEDPTR1]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND1]]) + return x.a; +} + +double *goo(ad_struct *x) { +// CHECK-LABEL: @_Z3gooP9ad_struct + +// CHECK: [[PTRINT2:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR2:%.+]] = and i64 [[PTRINT2]], 63 +// CHECK: [[MASKCOND2:%.+]] = icmp eq i64 [[MASKEDPTR2]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND2]]) + return x->a; +} + +double *bar(aligned_double *x) { +// CHECK-LABEL: @_Z3barPPd + +// CHECK: [[PTRINT3:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR3:%.+]] = and i64 [[PTRINT3]], 63 +// CHECK: [[MASKCOND3:%.+]] = icmp eq i64 [[MASKEDPTR3]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND3]]) + return *x; +} + +double *car(aligned_double &x) { +// CHECK-LABEL: @_Z3carRPd + +// CHECK: [[PTRINT4:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR4:%.+]] = and i64 [[PTRINT4]], 63 +// CHECK: [[MASKCOND4:%.+]] = icmp eq i64 [[MASKEDPTR4]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND4]]) + return x; +} + +double *dar(aligned_double *x) { +// CHECK-LABEL: @_Z3darPPd + +// CHECK: [[PTRINT5:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR5:%.+]] = and i64 [[PTRINT5]], 63 +// CHECK: [[MASKCOND5:%.+]] = icmp eq i64 [[MASKEDPTR5]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND5]]) + return x[5]; +} + +aligned_double eep(); +double *ret() { +// CHECK-LABEL: @_Z3retv + +// CHECK: [[PTRINT6:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR6:%.+]] = and i64 [[PTRINT6]], 63 +// CHECK: [[MASKCOND6:%.+]] = icmp eq i64 [[MASKEDPTR6]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND6]]) + return eep(); +} + +double **no1(aligned_double *x) { +// CHECK-LABEL: @_Z3no1PPd + return x; +// CHECK-NOT: call void @llvm.assume +} + +double *&no2(aligned_double &x) { +// CHECK-LABEL: @_Z3no2RPd + return x; +// CHECK-NOT: call void @llvm.assume +} + +double **no3(aligned_double &x) { +// CHECK-LABEL: @_Z3no3RPd + return &x; +// CHECK-NOT: call void @llvm.assume +} + +double no3(aligned_double x) { +// CHECK-LABEL: @_Z3no3Pd + return *x; +// CHECK-NOT: call void @llvm.assume +} + +double *no4(aligned_double x) { +// CHECK-LABEL: @_Z3no4Pd + return x; +// CHECK-NOT: call void @llvm.assume +} + diff --git a/test/CodeGen/arm-aapcs-vfp.c b/test/CodeGen/arm-aapcs-vfp.c index eea6ab2f154d..7ef7c4e52edb 100644 --- a/test/CodeGen/arm-aapcs-vfp.c +++ b/test/CodeGen/arm-aapcs-vfp.c @@ -1,4 +1,5 @@ // REQUIRES: arm-registered-target +// REQUIRES: aarch64-registered-target // RUN: %clang_cc1 -triple thumbv7-apple-darwin9 \ // RUN: -target-abi aapcs \ // RUN: -target-cpu cortex-a8 \ @@ -28,7 +29,7 @@ struct homogeneous_struct { float f4; }; // CHECK: define arm_aapcs_vfpcc %struct.homogeneous_struct @test_struct(%struct.homogeneous_struct %{{.*}}) -// CHECK64: define %struct.homogeneous_struct @test_struct(float %{{.*}}, float %{{.*}}, float %{{.*}}, float %{{.*}}) +// CHECK64: define %struct.homogeneous_struct @test_struct([4 x float] %{{.*}}) extern struct homogeneous_struct struct_callee(struct homogeneous_struct); struct homogeneous_struct test_struct(struct homogeneous_struct arg) { return struct_callee(arg); @@ -43,7 +44,7 @@ struct nested_array { double d[4]; }; // CHECK: define arm_aapcs_vfpcc void @test_array(%struct.nested_array %{{.*}}) -// CHECK64: define void @test_array(double %{{.*}}, double %{{.*}}, double %{{.*}}, double %{{.*}}) +// CHECK64: define void @test_array([4 x double] %{{.*}}) extern void array_callee(struct nested_array); void test_array(struct nested_array arg) { array_callee(arg); @@ -51,7 +52,7 @@ void test_array(struct nested_array arg) { extern void complex_callee(__complex__ double); // CHECK: define arm_aapcs_vfpcc void @test_complex({ double, double } %{{.*}}) -// CHECK64: define void @test_complex(double %{{.*}}, double %{{.*}}) +// CHECK64: define void @test_complex([2 x double] %cd.coerce) void test_complex(__complex__ double cd) { complex_callee(cd); } @@ -72,7 +73,7 @@ struct big_struct { float f3; float f4; }; -// CHECK: define arm_aapcs_vfpcc void @test_big({ [5 x i32] } %{{.*}}) +// CHECK: define arm_aapcs_vfpcc void @test_big([5 x i32] %{{.*}}) // CHECK64: define void @test_big(%struct.big_struct* %{{.*}}) // CHECK64: call void @llvm.memcpy // CHECK64: call void @big_callee(%struct.big_struct* @@ -88,7 +89,7 @@ struct heterogeneous_struct { float f1; int i2; }; -// CHECK: define arm_aapcs_vfpcc void @test_hetero({ [2 x i32] } %{{.*}}) +// CHECK: define arm_aapcs_vfpcc void @test_hetero([2 x i32] %{{.*}}) // CHECK64: define void @test_hetero(i64 %{{.*}}) extern void hetero_callee(struct heterogeneous_struct); void test_hetero(struct heterogeneous_struct arg) { @@ -97,7 +98,7 @@ void test_hetero(struct heterogeneous_struct arg) { // Neon multi-vector types are homogeneous aggregates. // CHECK: define arm_aapcs_vfpcc <16 x i8> @f0(%struct.int8x16x4_t %{{.*}}) -// CHECK64: define <16 x i8> @f0(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}) +// CHECK64: define <16 x i8> @f0([4 x <16 x i8>] %{{.*}}) int8x16_t f0(int8x16x4_t v4) { return vaddq_s8(v4.val[0], v4.val[3]); } @@ -111,7 +112,7 @@ struct neon_struct { int16x4_t v4; }; // CHECK: define arm_aapcs_vfpcc void @test_neon(%struct.neon_struct %{{.*}}) -// CHECK64: define void @test_neon(<8 x i8> %{{.*}}, <8 x i8> %{{.*}}, <2 x i32> %{{.*}}, <4 x i16> %{{.*}}) +// CHECK64: define void @test_neon([4 x <8 x i8>] %{{.*}}) extern void neon_callee(struct neon_struct); void test_neon(struct neon_struct arg) { neon_callee(arg); @@ -125,25 +126,25 @@ typedef struct { long long x; int y; } struct_long_long_int; // CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_1(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, i64 %k, i32 %l) void test_vfp_stack_gpr_split_1(double a, double b, double c, double d, double e, double f, double g, double h, double i, int j, long long k, int l) {} -// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_2(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, [3 x i32], { [2 x i64] } %k.coerce) +// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_2(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, [3 x i32], [2 x i64] %k.coerce) void test_vfp_stack_gpr_split_2(double a, double b, double c, double d, double e, double f, double g, double h, double i, int j, struct_long_long_int k) {} -// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_3(%struct.struct_long_long_int* noalias sret %agg.result, double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, [3 x i32], { [2 x i64] } %k.coerce) +// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_3(%struct.struct_long_long_int* noalias sret %agg.result, double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, [3 x i32], [2 x i64] %k.coerce) struct_long_long_int test_vfp_stack_gpr_split_3(double a, double b, double c, double d, double e, double f, double g, double h, double i, struct_long_long_int k) {} typedef struct { int a; int b:4; int c; } struct_int_bitfield_int; -// CHECK: define arm_aapcs_vfpcc void @test_test_vfp_stack_gpr_split_bitfield(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, i32 %k, [2 x i32], { [3 x i32] } %l.coerce) +// CHECK: define arm_aapcs_vfpcc void @test_test_vfp_stack_gpr_split_bitfield(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, i32 %k, [2 x i32], [3 x i32] %l.coerce) void test_test_vfp_stack_gpr_split_bitfield(double a, double b, double c, double d, double e, double f, double g, double h, double i, int j, int k, struct_int_bitfield_int l) {} // Note: this struct requires internal padding typedef struct { int x; long long y; } struct_int_long_long; -// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_4(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, [3 x i32], { [2 x i64] } %k.coerce) +// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_4(double %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, i32 %j, [3 x i32], [2 x i64] %k.coerce) void test_vfp_stack_gpr_split_4(double a, double b, double c, double d, double e, double f, double g, double h, double i, int j, struct_int_long_long k) {} // This very large struct (passed byval) uses up the GPRs, so no padding is needed typedef struct { int x[17]; } struct_seventeen_ints; typedef struct { int x[4]; } struct_four_ints; -// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_5(%struct.struct_seventeen_ints* byval align 4 %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, double %j, { [4 x i32] } %k.coerce) +// CHECK: define arm_aapcs_vfpcc void @test_vfp_stack_gpr_split_5(%struct.struct_seventeen_ints* byval align 4 %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h, double %i, double %j, [4 x i32] %k.coerce) void test_vfp_stack_gpr_split_5(struct_seventeen_ints a, double b, double c, double d, double e, double f, double g, double h, double i, double j, struct_four_ints k) {} // Here, parameter k would need padding to prevent it from being split, but it diff --git a/test/CodeGen/arm-arguments.c b/test/CodeGen/arm-arguments.c index 2c5df91c58ac..e4a10fd9e27b 100644 --- a/test/CodeGen/arm-arguments.c +++ b/test/CodeGen/arm-arguments.c @@ -183,14 +183,9 @@ void f33(struct s33 s) { } struct s34 { char c; }; void f34(struct s34 s); void g34(struct s34 *s) { f34(*s); } -// APCS-GNU: @g34(%struct.s34* %s) -// APCS-GNU: %[[a:.*]] = alloca { [1 x i32] } -// APCS-GNU: %[[gep:.*]] = getelementptr { [1 x i32] }* %[[a]], i32 0, i32 0 -// APCS-GNU: load [1 x i32]* %[[gep]] // AAPCS: @g34(%struct.s34* %s) -// AAPCS: %[[a:.*]] = alloca { [1 x i32] } -// AAPCS: %[[gep:.*]] = getelementptr { [1 x i32] }* %[[a]], i32 0, i32 0 -// AAPCS: load [1 x i32]* %[[gep]] +// AAPCS: %[[a:.*]] = alloca [1 x i32] +// AAPCS: load [1 x i32]* %[[a]] // rdar://12596507 struct s35 diff --git a/test/CodeGen/arm-homogenous.c b/test/CodeGen/arm-homogenous.c index d1b489793f98..3426d995caef 100644 --- a/test/CodeGen/arm-homogenous.c +++ b/test/CodeGen/arm-homogenous.c @@ -5,7 +5,7 @@ // RUN: -ffreestanding -emit-llvm -w -o - %s | FileCheck -check-prefix=CHECK64 %s // RUN: %clang_cc1 -triple arm64-linux-gnu -ffreestanding -emit-llvm -w -o - %s \ -// RUN: | FileCheck --check-prefix=CHECK64-AAPCS %s +// RUN: | FileCheck --check-prefix=CHECK64 %s typedef long long int64_t; typedef unsigned int uint32_t; @@ -22,7 +22,7 @@ extern union_with_first_floats returns_union_with_first_floats(void); void test_union_with_first_floats(void) { takes_union_with_first_floats(g_u_f); } -// CHECK: declare arm_aapcs_vfpcc void @takes_union_with_first_floats({ [4 x i32] }) +// CHECK: declare arm_aapcs_vfpcc void @takes_union_with_first_floats([4 x i32]) void test_return_union_with_first_floats(void) { g_u_f = returns_union_with_first_floats(); @@ -42,7 +42,7 @@ extern union_with_non_first_floats returns_union_with_non_first_floats(void); void test_union_with_non_first_floats(void) { takes_union_with_non_first_floats(g_u_nf_f); } -// CHECK: declare arm_aapcs_vfpcc void @takes_union_with_non_first_floats({ [4 x i32] }) +// CHECK: declare arm_aapcs_vfpcc void @takes_union_with_non_first_floats([4 x i32]) void test_return_union_with_non_first_floats(void) { g_u_nf_f = returns_union_with_non_first_floats(); @@ -62,7 +62,7 @@ extern struct_with_union_with_first_floats returns_struct_with_union_with_first_ void test_struct_with_union_with_first_floats(void) { takes_struct_with_union_with_first_floats(g_s_f); } -// CHECK: declare arm_aapcs_vfpcc void @takes_struct_with_union_with_first_floats({ [5 x i32] }) +// CHECK: declare arm_aapcs_vfpcc void @takes_struct_with_union_with_first_floats([5 x i32]) void test_return_struct_with_union_with_first_floats(void) { g_s_f = returns_struct_with_union_with_first_floats(); @@ -82,7 +82,7 @@ extern struct_with_union_with_non_first_floats returns_struct_with_union_with_no void test_struct_with_union_with_non_first_floats(void) { takes_struct_with_union_with_non_first_floats(g_s_nf_f); } -// CHECK: declare arm_aapcs_vfpcc void @takes_struct_with_union_with_non_first_floats({ [5 x i32] }) +// CHECK: declare arm_aapcs_vfpcc void @takes_struct_with_union_with_non_first_floats([5 x i32]) void test_return_struct_with_union_with_non_first_floats(void) { g_s_nf_f = returns_struct_with_union_with_non_first_floats(); @@ -176,9 +176,7 @@ void test_struct_of_four_doubles(void) { // CHECK: test_struct_of_four_doubles // CHECK: call arm_aapcs_vfpcc void @takes_struct_of_four_doubles(double {{.*}}, %struct.struct_of_four_doubles {{.*}}, %struct.struct_of_four_doubles {{.*}}, double {{.*}}) // CHECK64: test_struct_of_four_doubles -// CHECK64: call void @takes_struct_of_four_doubles(double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, [3 x float] undef, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}) -// CHECK64-AAPCS: test_struct_of_four_doubles -// CHECK64-AAPCS: call void @takes_struct_of_four_doubles(double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, [3 x float] undef, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}) +// CHECK64: call void @takes_struct_of_four_doubles(double {{.*}}, [4 x double] {{.*}}, [4 x double] {{.*}}, double {{.*}}) takes_struct_of_four_doubles(3.0, g_s4d, g_s4d, 4.0); } @@ -186,7 +184,7 @@ extern void takes_struct_of_four_doubles_variadic(double a, struct_of_four_doubl void test_struct_of_four_doubles_variadic(void) { // CHECK: test_struct_of_four_doubles_variadic -// CHECK: call arm_aapcs_vfpcc void (double, { [4 x i64] }, { [4 x i64] }, double, ...)* @takes_struct_of_four_doubles_variadic(double {{.*}}, { [4 x i64] } {{.*}}, { [4 x i64] } {{.*}}, double {{.*}}) +// CHECK: call arm_aapcs_vfpcc void (double, [4 x i64], [4 x i64], double, ...)* @takes_struct_of_four_doubles_variadic(double {{.*}}, [4 x i64] {{.*}}, [4 x i64] {{.*}}, double {{.*}}) takes_struct_of_four_doubles_variadic(3.0, g_s4d, g_s4d, 4.0); } @@ -212,9 +210,7 @@ void test_struct_of_vecs(void) { // CHECK: test_struct_of_vecs // CHECK: call arm_aapcs_vfpcc void @takes_struct_of_vecs(double {{.*}}, %struct.struct_of_vecs {{.*}}, %struct.struct_of_vecs {{.*}}, double {{.*}}) // CHECK64: test_struct_of_vecs -// CHECK64: call void @takes_struct_of_vecs(double {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, [3 x float] undef, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, double {{.*}}) -// CHECK64-AAPCS: test_struct_of_vecs -// CHECK64-AAPCS: call void @takes_struct_of_vecs(double {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, [3 x float] undef, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, double {{.*}}) +// CHECK64: call void @takes_struct_of_vecs(double {{.*}}, [4 x <8 x i8>] {{.*}}, [4 x <8 x i8>] {{.*}}, double {{.*}}) takes_struct_of_vecs(3.0, g_vec, g_vec, 4.0); } diff --git a/test/CodeGen/arm-metadata.c b/test/CodeGen/arm-metadata.c index 1cd9880f1b53..1f7756cc8d48 100644 --- a/test/CodeGen/arm-metadata.c +++ b/test/CodeGen/arm-metadata.c @@ -2,11 +2,11 @@ // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-enums | FileCheck -check-prefix=SHORT-ENUM %s // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-wchar | FileCheck -check-prefix=SHORT-WCHAR %s -// DEFAULT: !{{[0-9]+}} = metadata !{i32 1, metadata !"wchar_size", i32 4} -// DEFAULT: !{{[0-9]+}} = metadata !{i32 1, metadata !"min_enum_size", i32 4} +// DEFAULT: !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4} +// DEFAULT: !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4} -// SHORT-WCHAR: !{{[0-9]+}} = metadata !{i32 1, metadata !"wchar_size", i32 2} -// SHORT-WCHAR: !{{[0-9]+}} = metadata !{i32 1, metadata !"min_enum_size", i32 4} +// SHORT-WCHAR: !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 2} +// SHORT-WCHAR: !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4} -// SHORT_ENUM: !{{[0-9]+}} = metadata !{i32 1, metadata !"wchar_size", i32 4} -// SHORT-ENUM: !{{[0-9]+}} = metadata !{i32 1, metadata !"min_enum_size", i32 1} +// SHORT_ENUM: !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4} +// SHORT-ENUM: !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 1} diff --git a/test/CodeGen/arm-neon-directed-rounding.c b/test/CodeGen/arm-neon-directed-rounding.c new file mode 100644 index 000000000000..84029318865c --- /dev/null +++ b/test/CodeGen/arm-neon-directed-rounding.c @@ -0,0 +1,75 @@ +// RUN: %clang_cc1 -triple thumbv8-linux-gnueabihf -target-cpu cortex-a57 -ffreestanding -O1 -emit-llvm %s -o - | FileCheck %s + +#include <arm_neon.h> + +float32x2_t test_vrnda_f32(float32x2_t a) { + // CHECK-LABEL: test_vrnda_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrinta.v2f32(<2 x float> %a) + return vrnda_f32(a); +} + +float32x4_t test_vrndaq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndaq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrinta.v4f32(<4 x float> %a) + return vrndaq_f32(a); +} + +float32x2_t test_vrndm_f32(float32x2_t a) { + // CHECK-LABEL: test_vrndm_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrintm.v2f32(<2 x float> %a) + return vrndm_f32(a); +} + +float32x4_t test_vrndmq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndmq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrintm.v4f32(<4 x float> %a) + return vrndmq_f32(a); +} + +float32x2_t test_vrndn_f32(float32x2_t a) { + // CHECK-LABEL: test_vrndn_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrintn.v2f32(<2 x float> %a) + return vrndn_f32(a); +} + +float32x4_t test_vrndnq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndnq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrintn.v4f32(<4 x float> %a) + return vrndnq_f32(a); +} + +float32x2_t test_vrndp_f32(float32x2_t a) { + // CHECK-LABEL: test_vrndp_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrintp.v2f32(<2 x float> %a) + return vrndp_f32(a); +} + +float32x4_t test_vrndpq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndpq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrintp.v4f32(<4 x float> %a) + return vrndpq_f32(a); +} + +float32x2_t test_vrndx_f32(float32x2_t a) { + // CHECK-LABEL: test_vrndx_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrintx.v2f32(<2 x float> %a) + return vrndx_f32(a); +} + +float32x4_t test_vrndxq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndxq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrintx.v4f32(<4 x float> %a) + return vrndxq_f32(a); +} + +float32x2_t test_vrnd_f32(float32x2_t a) { + // CHECK-LABEL: test_vrnd_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vrintz.v2f32(<2 x float> %a) + return vrnd_f32(a); +} + +float32x4_t test_vrndq_f32(float32x4_t a) { + // CHECK-LABEL: test_vrndq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vrintz.v4f32(<4 x float> %a) + return vrndq_f32(a); +} diff --git a/test/CodeGen/arm-neon-numeric-maxmin.c b/test/CodeGen/arm-neon-numeric-maxmin.c new file mode 100644 index 000000000000..615a854b5e21 --- /dev/null +++ b/test/CodeGen/arm-neon-numeric-maxmin.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -triple thumbv8-linux-gnueabihf -target-cpu cortex-a57 -ffreestanding -O1 -emit-llvm %s -o - | FileCheck %s + +#include <arm_neon.h> + +float32x2_t test_vmaxnm_f32(float32x2_t a, float32x2_t b) { + // CHECK-LABEL: test_vmaxnm_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vmaxnm.v2f32(<2 x float> %a, <2 x float> %b) + return vmaxnm_f32(a, b); +} + +float32x4_t test_vmaxnmq_f32(float32x4_t a, float32x4_t b) { + // CHECK-LABEL: test_vmaxnmq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vmaxnm.v4f32(<4 x float> %a, <4 x float> %b) + return vmaxnmq_f32(a, b); +} + +float32x2_t test_vminnm_f32(float32x2_t a, float32x2_t b) { + // CHECK-LABEL: test_vminnm_f32 + // CHECK: call <2 x float> @llvm.arm.neon.vminnm.v2f32(<2 x float> %a, <2 x float> %b) + return vminnm_f32(a, b); +} + +float32x4_t test_vminnmq_f32(float32x4_t a, float32x4_t b) { + // CHECK-LABEL: test_vminnmq_f32 + // CHECK: call <4 x float> @llvm.arm.neon.vminnm.v4f32(<4 x float> %a, <4 x float> %b) + return vminnmq_f32(a, b); +} diff --git a/test/CodeGen/arm64-aapcs-arguments.c b/test/CodeGen/arm64-aapcs-arguments.c index b430630b0711..ab302d407041 100644 --- a/test/CodeGen/arm64-aapcs-arguments.c +++ b/test/CodeGen/arm64-aapcs-arguments.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple arm64-linux-gnu -target-feature +neon -target-abi aapcs -ffreestanding -emit-llvm -w -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -target-abi aapcs -ffreestanding -fallow-half-arguments-and-returns -emit-llvm -w -o - %s | FileCheck %s // AAPCS clause C.8 says: If the argument has an alignment of 16 then the NGRN // is rounded up to the next even number. @@ -17,7 +17,7 @@ void test2(int x0, Small x2_x3, int x4, Small x6_x7, int sp, Small sp16) { // stack in order to avoid holes. Make sure we get all of them, and not just the // first: -// CHECK: void @test3(float %s0_s3.0, float %s0_s3.1, float %s0_s3.2, float %s0_s3.3, float %s4, [3 x float], [2 x double] %sp.coerce, [2 x double] %sp16.coerce) +// CHECK: void @test3([4 x float] %s0_s3.coerce, float %s4, [4 x float] %sp.coerce, [4 x float] %sp16.coerce) typedef struct { float arr[4]; } HFA; void test3(HFA s0_s3, float s4, HFA sp, HFA sp16) { } @@ -28,7 +28,7 @@ void test3(HFA s0_s3, float s4, HFA sp, HFA sp16) { // fp128] or something, but leaving them as-is retains more information for // users to debug. -// CHECK: void @test4(<16 x i8> %v0_v2.0, <16 x i8> %v0_v2.1, <16 x i8> %v0_v2.2, <16 x i8> %v3_v5.0, <16 x i8> %v3_v5.1, <16 x i8> %v3_v5.2, [2 x float], <16 x i8> %sp.0, <16 x i8> %sp.1, <16 x i8> %sp.2, double %sp48, <16 x i8> %sp64.0, <16 x i8> %sp64.1, <16 x i8> %sp64.2) +// CHECK: void @test4([3 x <16 x i8>] %v0_v2.coerce, [3 x <16 x i8>] %v3_v5.coerce, [3 x <16 x i8>] %sp.coerce, double %sp48, [3 x <16 x i8>] %sp64.coerce) typedef __attribute__((neon_vector_type(16))) signed char int8x16_t; typedef struct { int8x16_t arr[3]; } BigHFA; void test4(BigHFA v0_v2, BigHFA v3_v5, BigHFA sp, double sp48, BigHFA sp64) { @@ -40,3 +40,12 @@ void test4(BigHFA v0_v2, BigHFA v3_v5, BigHFA sp, double sp48, BigHFA sp64) { // CHECK: define i8 @test5(i8 %a, i16 %b) unsigned char test5(unsigned char a, signed short b) { } + +// __fp16 can be used as a function argument or return type (ACLE 2.0) +// CHECK: define half @test_half(half %{{.*}}) +__fp16 test_half(__fp16 A) { } + +// __fp16 is a base type for homogeneous floating-point aggregates for AArch64 (but not 32-bit ARM). +// CHECK: define %struct.HFA_half @test_half_hfa([4 x half] %{{.*}}) +struct HFA_half { __fp16 a[4]; }; +struct HFA_half test_half_hfa(struct HFA_half A) { } diff --git a/test/CodeGen/arm64-arguments.c b/test/CodeGen/arm64-arguments.c index b2de08dbe68c..ae1ff98800ac 100644 --- a/test/CodeGen/arm64-arguments.c +++ b/test/CodeGen/arm64-arguments.c @@ -123,8 +123,7 @@ void f31(struct s31 s) { } struct s32 { double x; }; void f32(struct s32 s) { } -// Expand Homogeneous Aggregate. -// CHECK: @f32(double %{{.*}}) +// CHECK: @f32([1 x double] %{{.*}}) // A composite type larger than 16 bytes should be passed indirectly. struct s33 { char buf[32*32]; }; @@ -197,7 +196,7 @@ typedef struct s35 s35_with_align; typedef __attribute__((neon_vector_type(4))) float float32x4_t; float32x4_t f35(int i, s35_with_align s1, s35_with_align s2) { -// CHECK: define <4 x float> @f35(i32 %i, float %s1.0, float %s1.1, float %s1.2, float %s1.3, float %s2.0, float %s2.1, float %s2.2, float %s2.3) +// CHECK: define <4 x float> @f35(i32 %i, [4 x float] %s1.coerce, [4 x float] %s2.coerce) // CHECK: %s1 = alloca %struct.s35, align 16 // CHECK: %s2 = alloca %struct.s35, align 16 // CHECK: %[[a:.*]] = bitcast %struct.s35* %s1 to <4 x float>* @@ -598,24 +597,24 @@ int caller43_stack() { __attribute__ ((noinline)) int f40_split(int i, int i2, int i3, int i4, int i5, int i6, int i7, s40_no_align s1, s40_no_align s2) { -// CHECK: define i32 @f40_split(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, [1 x i32], [2 x i64] %s1.coerce, [2 x i64] %s2.coerce) +// CHECK: define i32 @f40_split(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, [2 x i64] %s1.coerce, [2 x i64] %s2.coerce) return s1.i + s2.i + i + i2 + i3 + i4 + i5 + i6 + i7 + s1.s + s2.s; } int caller40_split() { // CHECK: define i32 @caller40_split() -// CHECK: call i32 @f40_split(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, [1 x i32] undef, [2 x i64] %{{.*}} [2 x i64] %{{.*}}) +// CHECK: call i32 @f40_split(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, [2 x i64] %{{.*}} [2 x i64] %{{.*}}) return f40_split(1, 2, 3, 4, 5, 6, 7, g40, g40_2); } __attribute__ ((noinline)) int f41_split(int i, int i2, int i3, int i4, int i5, int i6, int i7, s41_with_align s1, s41_with_align s2) { -// CHECK: define i32 @f41_split(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, [1 x i32], i128 %s1.coerce, i128 %s2.coerce) +// CHECK: define i32 @f41_split(i32 %i, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, i128 %s1.coerce, i128 %s2.coerce) return s1.i + s2.i + i + i2 + i3 + i4 + i5 + i6 + i7 + s1.s + s2.s; } int caller41_split() { // CHECK: define i32 @caller41_split() -// CHECK: call i32 @f41_split(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, [1 x i32] undef, i128 %{{.*}}, i128 %{{.*}}) +// CHECK: call i32 @f41_split(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i128 %{{.*}}, i128 %{{.*}}) return f41_split(1, 2, 3, 4, 5, 6, 7, g41, g41_2); } @@ -642,7 +641,7 @@ float test_hfa(int n, ...) { float test_hfa_call(struct HFA *a) { // CHECK-LABEL: define float @test_hfa_call(%struct.HFA* %a) -// CHECK: call float (i32, ...)* @test_hfa(i32 1, [2 x double] {{.*}}) +// CHECK: call float (i32, ...)* @test_hfa(i32 1, [4 x float] {{.*}}) test_hfa(1, *a); } diff --git a/test/CodeGen/arm64-be-bitfield.c b/test/CodeGen/arm64-be-bitfield.c index f563596bdda3..b8d497c5580d 100644 --- a/test/CodeGen/arm64-be-bitfield.c +++ b/test/CodeGen/arm64-be-bitfield.c @@ -1,9 +1,15 @@ -// RUN: %clang_cc1 -triple arm64_be-linux-gnu -ffreestanding -emit-llvm -O0 -o - %s | FileCheck %s +// REQUIRES: aarch64-registered-target +// RUN: %clang_cc1 -triple aarch64_be-linux-gnu -ffreestanding -emit-llvm -O0 -o - %s | FileCheck --check-prefix IR %s +// RUN: %clang_cc1 -triple aarch64_be-linux-gnu -ffreestanding -S -O1 -o - %s | FileCheck --check-prefix ARM %s struct bt3 { signed b2:10; signed b3:10; } b16; -// The correct right-shift amount is 40 bits for big endian. +// Get the high 32-bits and then shift appropriately for big-endian. signed callee_b0f(struct bt3 bp11) { -// CHECK: = lshr i64 %{{.*}}, 40 +// IR: callee_b0f(i64 [[ARG:%.*]]) +// IR: store i64 [[ARG]], i64* [[PTR:%.*]] +// IR: [[BITCAST:%.*]] = bitcast i64* [[PTR]] to i8* +// IR: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* [[BITCAST]], i64 4 +// ARM: asr x0, x0, #54 return bp11.b2; } diff --git a/test/CodeGen/arm64-be-hfa-vararg.c b/test/CodeGen/arm64-be-hfa-vararg.c index c9d650794d6e..537aab52b3b5 100644 --- a/test/CodeGen/arm64-be-hfa-vararg.c +++ b/test/CodeGen/arm64-be-hfa-vararg.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple arm64_be-linux-gnu -ffreestanding -emit-llvm -O0 -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple aarch64_be-linux-gnu -ffreestanding -emit-llvm -O0 -o - %s | FileCheck %s #include <stdarg.h> diff --git a/test/CodeGen/arm64-lanes.c b/test/CodeGen/arm64-lanes.c index 8ab2bd4c6690..4e80df9d6c52 100644 --- a/test/CodeGen/arm64-lanes.c +++ b/test/CodeGen/arm64-lanes.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -O3 -triple arm64-apple-ios7 -target-feature +neon -ffreestanding -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -O3 -triple arm64_be-linux-gnu -target-feature +neon -ffreestanding -emit-llvm -o - %s | FileCheck %s --check-prefix CHECK-BE +// RUN: %clang_cc1 -O3 -triple aarch64_be-linux-gnu -target-feature +neon -ffreestanding -emit-llvm -o - %s | FileCheck %s --check-prefix CHECK-BE #include <arm_neon.h> diff --git a/test/CodeGen/arm_acle.c b/test/CodeGen/arm_acle.c index 8550c58b3677..5b024506a50e 100644 --- a/test/CodeGen/arm_acle.c +++ b/test/CodeGen/arm_acle.c @@ -62,6 +62,53 @@ void test_sevl(void) { __sevl(); } +#if __ARM_32BIT_STATE +// AArch32-LABEL: test_dbg +// AArch32: call void @llvm.arm.dbg(i32 0) +void test_dbg(void) { + __dbg(0); +} +#endif + +/* 8.5 Swap */ +// ARM-LABEL: test_swp +// AArch32: call i32 @llvm.arm.ldrex +// AArch32: call i32 @llvm.arm.strex +// AArch64: call i64 @llvm.aarch64.ldxr +// AArch64: call i32 @llvm.aarch64.stxr +uint32_t test_swp(uint32_t x, volatile void *p) { + __swp(x, p); +} + +/* 8.6 Memory prefetch intrinsics */ +/* 8.6.1 Data prefetch */ +// ARM-LABEL: test_pld +// ARM: call void @llvm.prefetch(i8* null, i32 0, i32 3, i32 1) +void test_pld() { + __pld(0); +} + +// ARM-LABEL: test_pldx +// AArch32: call void @llvm.prefetch(i8* null, i32 1, i32 3, i32 1) +// AArch64: call void @llvm.prefetch(i8* null, i32 1, i32 1, i32 1) +void test_pldx() { + __pldx(1, 2, 0, 0); +} + +/* 8.6.2 Instruction prefetch */ +// ARM-LABEL: test_pli +// ARM: call void @llvm.prefetch(i8* null, i32 0, i32 3, i32 0) +void test_pli() { + __pli(0); +} + +// ARM-LABEL: test_plix +// AArch32: call void @llvm.prefetch(i8* null, i32 0, i32 3, i32 0) +// AArch64: call void @llvm.prefetch(i8* null, i32 0, i32 1, i32 0) +void test_plix() { + __plix(2, 0, 0); +} + /* 8.7 NOP */ // ARM-LABEL: test_nop // AArch32: call void @llvm.arm.hint(i32 0) @@ -72,23 +119,31 @@ void test_nop(void) { /* 9 DATA-PROCESSING INTRINSICS */ /* 9.2 Miscellaneous data-processing intrinsics */ -// ARM-LABEL: test_rev -// ARM: call i32 @llvm.bswap.i32(i32 %t) -uint32_t test_rev(uint32_t t) { - return __rev(t); +// ARM-LABEL: test_ror +// ARM: lshr +// ARM: sub +// ARM: shl +// ARM: or +uint32_t test_ror(uint32_t x, uint32_t y) { + return __ror(x, y); } -// ARM-LABEL: test_revl -// AArch32: call i32 @llvm.bswap.i32(i32 %t) -// AArch64: call i64 @llvm.bswap.i64(i64 %t) -long test_revl(long t) { - return __revl(t); +// ARM-LABEL: test_rorl +// ARM: lshr +// ARM: sub +// ARM: shl +// ARM: or +unsigned long test_rorl(unsigned long x, uint32_t y) { + return __rorl(x, y); } -// ARM-LABEL: test_revll -// ARM: call i64 @llvm.bswap.i64(i64 %t) -uint64_t test_revll(uint64_t t) { - return __revll(t); +// ARM-LABEL: test_rorll +// ARM: lshr +// ARM: sub +// ARM: shl +// ARM: or +uint64_t test_rorll(uint64_t x, uint32_t y) { + return __rorll(x, y); } // ARM-LABEL: test_clz @@ -110,6 +165,80 @@ uint64_t test_clzll(uint64_t t) { return __clzll(t); } +// ARM-LABEL: test_rev +// ARM: call i32 @llvm.bswap.i32(i32 %t) +uint32_t test_rev(uint32_t t) { + return __rev(t); +} + +// ARM-LABEL: test_revl +// AArch32: call i32 @llvm.bswap.i32(i32 %t) +// AArch64: call i64 @llvm.bswap.i64(i64 %t) +long test_revl(long t) { + return __revl(t); +} + +// ARM-LABEL: test_revll +// ARM: call i64 @llvm.bswap.i64(i64 %t) +uint64_t test_revll(uint64_t t) { + return __revll(t); +} + +// ARM-LABEL: test_rev16 +// ARM: llvm.bswap +// ARM: lshr +// ARM: shl +// ARM: or +uint32_t test_rev16(uint32_t t) { + return __rev16(t); +} + +// ARM-LABEL: test_rev16l +// ARM: llvm.bswap +// ARM: lshr +// ARM: shl +// ARM: or +long test_rev16l(long t) { + return __rev16l(t); +} + +// ARM-LABEL: test_rev16ll +// ARM: llvm.bswap +// ARM: lshr +// ARM: shl +// ARM: or +uint64_t test_rev16ll(uint64_t t) { + return __rev16ll(t); +} + +// ARM-LABEL: test_revsh +// ARM: call i16 @llvm.bswap.i16(i16 %t) +int16_t test_revsh(int16_t t) { + return __revsh(t); +} + +// ARM-LABEL: test_rbit +// AArch32: call i32 @llvm.arm.rbit +// AArch64: call i32 @llvm.aarch64.rbit.i32 +uint32_t test_rbit(uint32_t t) { + return __rbit(t); +} + +// ARM-LABEL: test_rbitl +// AArch32: call i32 @llvm.arm.rbit +// AArch64: call i64 @llvm.aarch64.rbit.i64 +long test_rbitl(long t) { + return __rbitl(t); +} + +// ARM-LABEL: test_rbitll +// AArch32: call i32 @llvm.arm.rbit +// AArch32: call i32 @llvm.arm.rbit +// AArch64: call i64 @llvm.aarch64.rbit.i64 +uint64_t test_rbitll(uint64_t t) { + return __rbitll(t); +} + /* 9.4 Saturating intrinsics */ #ifdef __ARM_32BIT_STATE diff --git a/test/CodeGen/arm_neon_intrinsics.c b/test/CodeGen/arm_neon_intrinsics.c index a084d8b2c84c..756e3b43fc54 100644 --- a/test/CodeGen/arm_neon_intrinsics.c +++ b/test/CodeGen/arm_neon_intrinsics.c @@ -1474,79 +1474,109 @@ poly8x16_t test_vcntq_p8(poly8x16_t a) { // CHECK-LABEL: test_vcombine_s8 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} int8x16_t test_vcombine_s8(int8x8_t a, int8x8_t b) { return vcombine_s8(a, b); } // CHECK-LABEL: test_vcombine_s16 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} int16x8_t test_vcombine_s16(int16x4_t a, int16x4_t b) { return vcombine_s16(a, b); } // CHECK-LABEL: test_vcombine_s32 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} int32x4_t test_vcombine_s32(int32x2_t a, int32x2_t b) { return vcombine_s32(a, b); } // CHECK-LABEL: test_vcombine_s64 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} int64x2_t test_vcombine_s64(int64x1_t a, int64x1_t b) { return vcombine_s64(a, b); } // CHECK-LABEL: test_vcombine_f16 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} float16x8_t test_vcombine_f16(float16x4_t a, float16x4_t b) { return vcombine_f16(a, b); } // CHECK-LABEL: test_vcombine_f32 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} float32x4_t test_vcombine_f32(float32x2_t a, float32x2_t b) { return vcombine_f32(a, b); } // CHECK-LABEL: test_vcombine_u8 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} uint8x16_t test_vcombine_u8(uint8x8_t a, uint8x8_t b) { return vcombine_u8(a, b); } // CHECK-LABEL: test_vcombine_u16 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} uint16x8_t test_vcombine_u16(uint16x4_t a, uint16x4_t b) { return vcombine_u16(a, b); } // CHECK-LABEL: test_vcombine_u32 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} uint32x4_t test_vcombine_u32(uint32x2_t a, uint32x2_t b) { return vcombine_u32(a, b); } // CHECK-LABEL: test_vcombine_u64 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} uint64x2_t test_vcombine_u64(uint64x1_t a, uint64x1_t b) { return vcombine_u64(a, b); } // CHECK-LABEL: test_vcombine_p8 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} poly8x16_t test_vcombine_p8(poly8x8_t a, poly8x8_t b) { return vcombine_p8(a, b); } // CHECK-LABEL: test_vcombine_p16 +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} +// CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} poly16x8_t test_vcombine_p16(poly16x4_t a, poly16x4_t b) { return vcombine_p16(a, b); } // CHECK-LABEL: test_vcreate_s8 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i8 d{{[0-9]+}}, [[REG]] int8x8_t test_vcreate_s8(uint64_t a) { - return vcreate_s8(a); + return vclz_s8(vcreate_s8(a)); } // CHECK-LABEL: test_vcreate_s16 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i16 d{{[0-9]+}}, [[REG]] int16x4_t test_vcreate_s16(uint64_t a) { - return vcreate_s16(a); + return vclz_s16(vcreate_s16(a)); } // CHECK-LABEL: test_vcreate_s32 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i32 d{{[0-9]+}}, [[REG]] int32x2_t test_vcreate_s32(uint64_t a) { - return vcreate_s32(a); + return vclz_s32(vcreate_s32(a)); } // CHECK-LABEL: test_vcreate_f16 @@ -1560,38 +1590,59 @@ float32x2_t test_vcreate_f32(uint64_t a) { } // CHECK-LABEL: test_vcreate_u8 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i8 d{{[0-9]+}}, [[REG]] uint8x8_t test_vcreate_u8(uint64_t a) { - return vcreate_u8(a); + return vclz_s8(vcreate_u8(a)); } // CHECK-LABEL: test_vcreate_u16 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i16 d{{[0-9]+}}, [[REG]] uint16x4_t test_vcreate_u16(uint64_t a) { - return vcreate_u16(a); + return vclz_s16(vcreate_u16(a)); } // CHECK-LABEL: test_vcreate_u32 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vclz.i32 d{{[0-9]+}}, [[REG]] uint32x2_t test_vcreate_u32(uint64_t a) { - return vcreate_u32(a); + return vclz_s32(vcreate_u32(a)); } + +// We have two ways of lowering that. Either with one 'vmov d, r, r' or +// with two 'vmov d[],r'. LLVM does the latter. We may want to be less +// strict about the matching pattern if it starts causing problem. // CHECK-LABEL: test_vcreate_u64 +// CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 +// CHECK: vmov.32 [[REG]][1], r1 uint64x1_t test_vcreate_u64(uint64_t a) { - return vcreate_u64(a); + uint64x1_t tmp = vcreate_u64(a); + return vadd_u64(tmp, tmp); + } // CHECK-LABEL: test_vcreate_p8 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 +// CHECK: vcnt.8 d{{[0-9]+}}, [[REG]] poly8x8_t test_vcreate_p8(uint64_t a) { - return vcreate_p8(a); + return vcnt_p8(vcreate_p8(a)); } // CHECK-LABEL: test_vcreate_p16 +// CHECK: vmov [[REG:d[0-9]+]], r0, r1 poly16x4_t test_vcreate_p16(uint64_t a) { - return vcreate_p16(a); + poly16x4_t tmp = vcreate_p16(a); + return vbsl_p16(tmp, tmp, tmp); } // CHECK-LABEL: test_vcreate_s64 +// CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 +// CHECK: vmov.32 [[REG]][1], r1 int64x1_t test_vcreate_s64(uint64_t a) { - return vcreate_s64(a); + int64x1_t tmp = vcreate_s64(a); + return vadd_s64(tmp, tmp); } @@ -1855,7 +1906,7 @@ uint16x4_t test_vdup_n_u16(uint16_t a) { } // CHECK-LABEL: test_vdup_n_u32 -// CHECK: vmov +// CHECK: mov uint32x2_t test_vdup_n_u32(uint32_t a) { return vdup_n_u32(a); } @@ -1873,7 +1924,7 @@ int16x4_t test_vdup_n_s16(int16_t a) { } // CHECK-LABEL: test_vdup_n_s32 -// CHECK: vmov +// CHECK: mov int32x2_t test_vdup_n_s32(int32_t a) { return vdup_n_s32(a); } @@ -1897,7 +1948,7 @@ float16x4_t test_vdup_n_f16(float16_t *a) { } // CHECK-LABEL: test_vdup_n_f32 -// CHECK: vmov +// CHECK: mov float32x2_t test_vdup_n_f32(float32_t a) { return vdup_n_f32(a); } @@ -1963,27 +2014,32 @@ float32x4_t test_vdupq_n_f32(float32_t a) { } // CHECK-LABEL: test_vdup_n_s64 -// CHECK: vmov +// CHECK: vmov int64x1_t test_vdup_n_s64(int64_t a) { - return vdup_n_s64(a); + int64x1_t tmp = vdup_n_s64(a); + return vadd_s64(tmp, tmp); } // CHECK-LABEL: test_vdup_n_u64 -// CHECK: vmov +// CHECK: vmov uint64x1_t test_vdup_n_u64(uint64_t a) { - return vdup_n_u64(a); + int64x1_t tmp = vdup_n_u64(a); + return vadd_s64(tmp, tmp); + } // CHECK-LABEL: test_vdupq_n_s64 -// CHECK: vmov +// CHECK: vmov int64x2_t test_vdupq_n_s64(int64_t a) { - return vdupq_n_s64(a); + int64x2_t tmp = vdupq_n_s64(a); + return vaddq_s64(tmp, tmp); } // CHECK-LABEL: test_vdupq_n_u64 -// CHECK: vmov +// CHECK: vmov uint64x2_t test_vdupq_n_u64(uint64_t a) { - return vdupq_n_u64(a); + int64x2_t tmp = vdupq_n_u64(a); + return vaddq_u64(tmp, tmp); } @@ -2302,7 +2358,7 @@ uint16_t test_vget_lane_u16(uint16x4_t a) { } // CHECK-LABEL: test_vget_lane_u32 -// CHECK: vmov +// CHECK: mov uint32_t test_vget_lane_u32(uint32x2_t a) { return vget_lane_u32(a, 1); } @@ -2320,7 +2376,7 @@ int16_t test_vget_lane_s16(int16x4_t a) { } // CHECK-LABEL: test_vget_lane_s32 -// CHECK: vmov +// CHECK: mov int32_t test_vget_lane_s32(int32x2_t a) { return vget_lane_s32(a, 1); } @@ -2398,13 +2454,13 @@ float32_t test_vgetq_lane_f32(float32x4_t a) { } // CHECK-LABEL: test_vget_lane_s64 -// CHECK: vmov +// The optimizer is able to remove all moves now. int64_t test_vget_lane_s64(int64x1_t a) { return vget_lane_s64(a, 0); } // CHECK-LABEL: test_vget_lane_u64 -// CHECK: vmov +// The optimizer is able to remove all moves now. uint64_t test_vget_lane_u64(uint64x1_t a) { return vget_lane_u64(a, 0); } @@ -4849,49 +4905,49 @@ uint32x2_t test_vmovn_u64(uint64x2_t a) { // CHECK-LABEL: test_vmov_n_u8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint8x8_t test_vmov_n_u8(uint8_t a) { return vmov_n_u8(a); } // CHECK-LABEL: test_vmov_n_u16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint16x4_t test_vmov_n_u16(uint16_t a) { return vmov_n_u16(a); } // CHECK-LABEL: test_vmov_n_u32 -// CHECK: vmov +// CHECK: mov {{r[0-9]+}} uint32x2_t test_vmov_n_u32(uint32_t a) { return vmov_n_u32(a); } // CHECK-LABEL: test_vmov_n_s8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int8x8_t test_vmov_n_s8(int8_t a) { return vmov_n_s8(a); } // CHECK-LABEL: test_vmov_n_s16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int16x4_t test_vmov_n_s16(int16_t a) { return vmov_n_s16(a); } // CHECK-LABEL: test_vmov_n_s32 -// CHECK: vmov +// CHECK: mov {{r[0-9]+}} int32x2_t test_vmov_n_s32(int32_t a) { return vmov_n_s32(a); } // CHECK-LABEL: test_vmov_n_p8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} poly8x8_t test_vmov_n_p8(poly8_t a) { return vmov_n_p8(a); } // CHECK-LABEL: test_vmov_n_p16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} poly16x4_t test_vmov_n_p16(poly16_t a) { return vmov_n_p16(a); } @@ -4903,55 +4959,55 @@ float16x4_t test_vmov_n_f16(float16_t *a) { } // CHECK-LABEL: test_vmov_n_f32 -// CHECK: vmov +// CHECK: mov {{r[0-9]+}} float32x2_t test_vmov_n_f32(float32_t a) { return vmov_n_f32(a); } // CHECK-LABEL: test_vmovq_n_u8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint8x16_t test_vmovq_n_u8(uint8_t a) { return vmovq_n_u8(a); } // CHECK-LABEL: test_vmovq_n_u16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint16x8_t test_vmovq_n_u16(uint16_t a) { return vmovq_n_u16(a); } // CHECK-LABEL: test_vmovq_n_u32 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint32x4_t test_vmovq_n_u32(uint32_t a) { return vmovq_n_u32(a); } // CHECK-LABEL: test_vmovq_n_s8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int8x16_t test_vmovq_n_s8(int8_t a) { return vmovq_n_s8(a); } // CHECK-LABEL: test_vmovq_n_s16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int16x8_t test_vmovq_n_s16(int16_t a) { return vmovq_n_s16(a); } // CHECK-LABEL: test_vmovq_n_s32 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int32x4_t test_vmovq_n_s32(int32_t a) { return vmovq_n_s32(a); } // CHECK-LABEL: test_vmovq_n_p8 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} poly8x16_t test_vmovq_n_p8(poly8_t a) { return vmovq_n_p8(a); } // CHECK-LABEL: test_vmovq_n_p16 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} poly16x8_t test_vmovq_n_p16(poly16_t a) { return vmovq_n_p16(a); } @@ -4963,31 +5019,35 @@ float16x8_t test_vmovq_n_f16(float16_t *a) { } // CHECK-LABEL: test_vmovq_n_f32 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} float32x4_t test_vmovq_n_f32(float32_t a) { return vmovq_n_f32(a); } // CHECK-LABEL: test_vmov_n_s64 -// CHECK: vmov +// CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 +// CHECK: vmov.32 [[REG]][1], r1 int64x1_t test_vmov_n_s64(int64_t a) { - return vmov_n_s64(a); + int64x1_t tmp = vmov_n_s64(a); + return vadd_s64(tmp, tmp); } // CHECK-LABEL: test_vmov_n_u64 -// CHECK: vmov +// CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 +// CHECK: vmov.32 [[REG]][1], r1 uint64x1_t test_vmov_n_u64(uint64_t a) { - return vmov_n_u64(a); + uint64x1_t tmp = vmov_n_u64(a); + return vadd_u64(tmp, tmp); } // CHECK-LABEL: test_vmovq_n_s64 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} int64x2_t test_vmovq_n_s64(int64_t a) { return vmovq_n_s64(a); } // CHECK-LABEL: test_vmovq_n_u64 -// CHECK: vmov +// CHECK: vmov {{r[0-9]+}} uint64x2_t test_vmovq_n_u64(uint64_t a) { return vmovq_n_u64(a); } @@ -9056,7 +9116,7 @@ uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) { } // CHECK-LABEL: test_vset_lane_u32 -// CHECK: vmov +// CHECK: mov uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) { return vset_lane_u32(a, b, 1); } @@ -9074,7 +9134,7 @@ int16x4_t test_vset_lane_s16(int16_t a, int16x4_t b) { } // CHECK-LABEL: test_vset_lane_s32 -// CHECK: vmov +// CHECK: mov int32x2_t test_vset_lane_s32(int32_t a, int32x2_t b) { return vset_lane_s32(a, b, 1); } @@ -9092,7 +9152,7 @@ poly16x4_t test_vset_lane_p16(poly16_t a, poly16x4_t b) { } // CHECK-LABEL: test_vset_lane_f32 -// CHECK: vmov +// CHECK: mov float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) { return vset_lane_f32(a, b, 1); } @@ -9152,13 +9212,13 @@ float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) { } // CHECK-LABEL: test_vset_lane_s64 -// CHECK: vmov +// The optimizer is able to get rid of all moves now. int64x1_t test_vset_lane_s64(int64_t a, int64x1_t b) { return vset_lane_s64(a, b, 0); } // CHECK-LABEL: test_vset_lane_u64 -// CHECK: vmov +// The optimizer is able to get rid of all moves now. uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) { return vset_lane_u64(a, b, 0); } diff --git a/test/CodeGen/asan-globals.cpp b/test/CodeGen/asan-globals.cpp index d9ecc6461542..20c1fa702a86 100644 --- a/test/CodeGen/asan-globals.cpp +++ b/test/CodeGen/asan-globals.cpp @@ -1,36 +1,37 @@ +// RUN: echo "int extra_global;" > %t.extra-source.cpp // RUN: echo "global:*blacklisted_global*" > %t.blacklist -// RUN: %clang_cc1 -fsanitize=address -fsanitize-blacklist=%t.blacklist -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.blacklist -emit-llvm -o - %s | FileCheck %s // RUN: echo "src:%s" > %t.blacklist-src -// RUN: %clang_cc1 -fsanitize=address -fsanitize-blacklist=%t.blacklist-src -emit-llvm -o - %s | FileCheck %s --check-prefix=BLACKLIST-SRC +// RUN: %clang_cc1 -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.blacklist-src -emit-llvm -o - %s | FileCheck %s --check-prefix=BLACKLIST-SRC // REQUIRES: shell int global; -// CHECK: [[GLOBAL_LOC:@.asan_loc_descr[0-9]*]] = private unnamed_addr constant {{.*}} i32 [[@LINE-1]], i32 5 -// CHECK: [[GLOBAL_NAME:@.str[0-9]+]] = private unnamed_addr constant {{.*}} c"global\00" int dyn_init_global = global; -// CHECK: [[DYN_INIT_LOC:@.asan_loc_descr[0-9]*]] = {{.*}} i32 [[@LINE-1]], i32 5 -// CHECK: [[DYN_INIT_NAME:@.str[0-9]+]] = private unnamed_addr constant {{.*}} c"dyn_init_global\00" int blacklisted_global; void func() { static int static_var = 0; - // CHECK: [[STATIC_LOC:@.asan_loc_descr[0-9]*]] = {{.*}} i32 [[@LINE-1]], i32 14 - // CHECK: [[STATIC_NAME:@.str[0-9]+]] = private unnamed_addr constant {{.*}} c"static_var\00" const char *literal = "Hello, world!"; - // CHECK: [[LITERAL_LOC:@.asan_loc_descr[0-9]*]] = {{.*}} i32 [[@LINE-1]], i32 25 - // CHECK: [[LITERAL_NAME:@.str[0-9]+]] = private unnamed_addr constant {{.*}} c"<string literal>\00" } -// CHECK: !llvm.asan.globals = !{![[GLOBAL:[0-9]+]], ![[DYN_INIT_GLOBAL:[0-9]+]], ![[BLACKLISTED_GLOBAL:[0-9]+]], ![[STATIC_VAR:[0-9]+]], ![[LITERAL:[0-9]+]]} -// CHECK: ![[GLOBAL]] = metadata !{{{.*}} [[GLOBAL_LOC]], {{.*}} [[GLOBAL_NAME]], i1 false, i1 false} -// CHECK: ![[DYN_INIT_GLOBAL]] = metadata !{{{.*}} [[DYN_INIT_LOC]], {{.*}} [[DYN_INIT_NAME]], i1 true, i1 false} -// CHECK: ![[BLACKLISTED_GLOBAL]] = metadata !{{{.*}}, null, null, i1 false, i1 true} -// CHECK: ![[STATIC_VAR]] = metadata !{{{.*}} [[STATIC_LOC]], {{.*}} [[STATIC_NAME]], i1 false, i1 false} -// CHECK: ![[LITERAL]] = metadata !{{{.*}} [[LITERAL_LOC]], {{.*}} [[LITERAL_NAME]], i1 false, i1 false} +// CHECK: !llvm.asan.globals = !{![[EXTRA_GLOBAL:[0-9]+]], ![[GLOBAL:[0-9]+]], ![[DYN_INIT_GLOBAL:[0-9]+]], ![[BLACKLISTED_GLOBAL:[0-9]+]], ![[STATIC_VAR:[0-9]+]], ![[LITERAL:[0-9]+]]} +// CHECK: ![[EXTRA_GLOBAL]] = !{{{.*}} ![[EXTRA_GLOBAL_LOC:[0-9]+]], !"extra_global", i1 false, i1 false} +// CHECK: ![[EXTRA_GLOBAL_LOC]] = !{!"{{.*}}extra-source.cpp", i32 1, i32 5} +// CHECK: ![[GLOBAL]] = !{{{.*}} ![[GLOBAL_LOC:[0-9]+]], !"global", i1 false, i1 false} +// CHECK: ![[GLOBAL_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 8, i32 5} +// CHECK: ![[DYN_INIT_GLOBAL]] = !{{{.*}} ![[DYN_INIT_LOC:[0-9]+]], !"dyn_init_global", i1 true, i1 false} +// CHECK: ![[DYN_INIT_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 9, i32 5} +// CHECK: ![[BLACKLISTED_GLOBAL]] = !{{{.*}}, null, null, i1 false, i1 true} +// CHECK: ![[STATIC_VAR]] = !{{{.*}} ![[STATIC_LOC:[0-9]+]], !"static_var", i1 false, i1 false} +// CHECK: ![[STATIC_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 13, i32 14} +// CHECK: ![[LITERAL]] = !{{{.*}} ![[LITERAL_LOC:[0-9]+]], !"<string literal>", i1 false, i1 false} +// CHECK: ![[LITERAL_LOC]] = !{!"{{.*}}asan-globals.cpp", i32 14, i32 25} -// BLACKLIST-SRC: !llvm.asan.globals = !{![[GLOBAL:[0-9]+]], ![[DYN_INIT_GLOBAL:[0-9]+]], ![[BLACKLISTED_GLOBAL:[0-9]+]], ![[STATIC_VAR:[0-9]+]], ![[LITERAL:[0-9]+]]} -// BLACKLIST-SRC: ![[GLOBAL]] = metadata !{{{.*}} null, null, i1 false, i1 true} -// BLACKLIST-SRC: ![[DYN_INIT_GLOBAL]] = metadata !{{{.*}} null, null, i1 true, i1 true} -// BLACKLIST-SRC: ![[BLACKLISTED_GLOBAL]] = metadata !{{{.*}}, null, null, i1 false, i1 true} -// BLACKLIST-SRC: ![[STATIC_VAR]] = metadata !{{{.*}} null, null, i1 false, i1 true} -// BLACKLIST-SRC: ![[LITERAL]] = metadata !{{{.*}} null, null, i1 false, i1 true} +// BLACKLIST-SRC: !llvm.asan.globals = !{![[EXTRA_GLOBAL:[0-9]+]], ![[GLOBAL:[0-9]+]], ![[DYN_INIT_GLOBAL:[0-9]+]], ![[BLACKLISTED_GLOBAL:[0-9]+]], ![[STATIC_VAR:[0-9]+]], ![[LITERAL:[0-9]+]]} +// BLACKLIST-SRC: ![[EXTRA_GLOBAL]] = !{{{.*}} ![[EXTRA_GLOBAL_LOC:[0-9]+]], !"extra_global", i1 false, i1 false} +// BLACKLIST-SRC: ![[EXTRA_GLOBAL_LOC]] = !{!"{{.*}}extra-source.cpp", i32 1, i32 5} +// BLACKLIST-SRC: ![[GLOBAL]] = !{{{.*}} null, null, i1 false, i1 true} +// BLACKLIST-SRC: ![[DYN_INIT_GLOBAL]] = !{{{.*}} null, null, i1 true, i1 true} +// BLACKLIST-SRC: ![[BLACKLISTED_GLOBAL]] = !{{{.*}}, null, null, i1 false, i1 true} +// BLACKLIST-SRC: ![[STATIC_VAR]] = !{{{.*}} null, null, i1 false, i1 true} +// BLACKLIST-SRC: ![[LITERAL]] = !{{{.*}} null, null, i1 false, i1 true} diff --git a/test/CodeGen/asm.c b/test/CodeGen/asm.c index 5dbc01b1211d..038d346e9993 100644 --- a/test/CodeGen/asm.c +++ b/test/CodeGen/asm.c @@ -248,3 +248,17 @@ void t29(void) { // CHECK: @t29 // CHECK: call void asm sideeffect "movl %eax, $0", "*m,~{dirflag},~{fpsr},~{flags}"([1 x i32]* @t29_var) } + +void t30(int len) { + __asm__ volatile("" + : "+&&rm"(len)); + // CHECK: @t30 + // CHECK: call void asm sideeffect "", "=*&rm,0,~{dirflag},~{fpsr},~{flags}" +} + +void t31(int len) { + __asm__ volatile("" + : "+%%rm"(len), "+rm"(len)); + // CHECK: @t31 + // CHECK: call void asm sideeffect "", "=*%rm,=*rm,0,1,~{dirflag},~{fpsr},~{flags}" +} diff --git a/test/CodeGen/atomic-ops-libcall.c b/test/CodeGen/atomic-ops-libcall.c index 2a2ff5e80fcf..e55a1bd1eae3 100644 --- a/test/CodeGen/atomic-ops-libcall.c +++ b/test/CodeGen/atomic-ops-libcall.c @@ -7,31 +7,31 @@ enum memory_order { int *test_c11_atomic_fetch_add_int_ptr(_Atomic(int *) *p) { // CHECK: test_c11_atomic_fetch_add_int_ptr - // CHECK: {{%[^ ]*}} = tail call i32* @__atomic_fetch_add_4(i8* {{%[0-9]+}}, i32 12, i32 5) + // CHECK: {{%[^ ]*}} = tail call i32 @__atomic_fetch_add_4(i8* {{%[0-9]+}}, i32 12, i32 5) return __c11_atomic_fetch_add(p, 3, memory_order_seq_cst); } int *test_c11_atomic_fetch_sub_int_ptr(_Atomic(int *) *p) { // CHECK: test_c11_atomic_fetch_sub_int_ptr - // CHECK: {{%[^ ]*}} = tail call i32* @__atomic_fetch_sub_4(i8* {{%[0-9]+}}, i32 20, i32 5) + // CHECK: {{%[^ ]*}} = tail call i32 @__atomic_fetch_sub_4(i8* {{%[0-9]+}}, i32 20, i32 5) return __c11_atomic_fetch_sub(p, 5, memory_order_seq_cst); } int test_c11_atomic_fetch_add_int(_Atomic(int) *p) { // CHECK: test_c11_atomic_fetch_add_int - // CHECK: {{%[^ ]*}} = tail call i32 bitcast (i32* (i8*, i32, i32)* @__atomic_fetch_add_4 to i32 (i8*, i32, i32)*)(i8* {{%[0-9]+}}, i32 3, i32 5) + // CHECK: {{%[^ ]*}} = tail call i32 @__atomic_fetch_add_4(i8* {{%[0-9]+}}, i32 3, i32 5) return __c11_atomic_fetch_add(p, 3, memory_order_seq_cst); } int test_c11_atomic_fetch_sub_int(_Atomic(int) *p) { // CHECK: test_c11_atomic_fetch_sub_int - // CHECK: {{%[^ ]*}} = tail call i32 bitcast (i32* (i8*, i32, i32)* @__atomic_fetch_sub_4 to i32 (i8*, i32, i32)*)(i8* {{%[0-9]+}}, i32 5, i32 5) + // CHECK: {{%[^ ]*}} = tail call i32 @__atomic_fetch_sub_4(i8* {{%[0-9]+}}, i32 5, i32 5) return __c11_atomic_fetch_sub(p, 5, memory_order_seq_cst); } int *fp2a(int **p) { // CHECK: @fp2a - // CHECK: {{%[^ ]*}} = tail call i32* @__atomic_fetch_sub_4(i8* {{%[0-9]+}}, i32 4, i32 0) + // CHECK: {{%[^ ]*}} = tail call i32 @__atomic_fetch_sub_4(i8* {{%[0-9]+}}, i32 4, i32 0) // Note, the GNU builtins do not multiply by sizeof(T)! return __atomic_fetch_sub(p, 4, memory_order_relaxed); } diff --git a/test/CodeGen/atomic-ops.c b/test/CodeGen/atomic-ops.c index 9e6b4805e8cb..559b13541323 100644 --- a/test/CodeGen/atomic-ops.c +++ b/test/CodeGen/atomic-ops.c @@ -1,18 +1,15 @@ -// RUN: %clang_cc1 %s -emit-llvm -o - -triple=i686-apple-darwin9 | FileCheck %s +// RUN: %clang_cc1 %s -emit-llvm -o - -ffreestanding -triple=i686-apple-darwin9 | FileCheck %s // Also test serialization of atomic operations here, to avoid duplicating the // test. -// RUN: %clang_cc1 %s -emit-pch -o %t -triple=i686-apple-darwin9 -// RUN: %clang_cc1 %s -include-pch %t -triple=i686-apple-darwin9 -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -emit-pch -o %t -ffreestanding -triple=i686-apple-darwin9 +// RUN: %clang_cc1 %s -include-pch %t -ffreestanding -triple=i686-apple-darwin9 -emit-llvm -o - | FileCheck %s #ifndef ALREADY_INCLUDED #define ALREADY_INCLUDED -// Basic IRGen tests for __c11_atomic_* and GNU __atomic_* +#include <stdatomic.h> -typedef enum memory_order { - memory_order_relaxed, memory_order_consume, memory_order_acquire, - memory_order_release, memory_order_acq_rel, memory_order_seq_cst -} memory_order; +// Basic IRGen tests for __c11_atomic_* and GNU __atomic_* int fi1(_Atomic(int) *i) { // CHECK-LABEL: @fi1 @@ -34,6 +31,12 @@ int fi1b(int *i) { return __atomic_load_n(i, memory_order_seq_cst); } +int fi1c(atomic_int *i) { + // CHECK-LABEL: @fi1c + // CHECK: load atomic i32* {{.*}} seq_cst + return atomic_load(i); +} + void fi2(_Atomic(int) *i) { // CHECK-LABEL: @fi2 // CHECK: store atomic i32 {{.*}} seq_cst @@ -53,6 +56,12 @@ void fi2b(int *i) { __atomic_store_n(i, 1, memory_order_seq_cst); } +void fi2c(atomic_int *i) { + // CHECK-LABEL: @fi2c + // CHECK: store atomic i32 {{.*}} seq_cst + atomic_store(i, 1); +} + int fi3(_Atomic(int) *i) { // CHECK-LABEL: @fi3 // CHECK: atomicrmw and @@ -89,8 +98,15 @@ int fi3d(int *i) { return __atomic_nand_fetch(i, 1, memory_order_seq_cst); } +int fi3e(atomic_int *i) { + // CHECK-LABEL: @fi3e + // CHECK: atomicrmw or + // CHECK-NOT: {{ or }} + return atomic_fetch_or(i, 1); +} + _Bool fi4(_Atomic(int) *i) { - // CHECK-LABEL: @fi4 + // CHECK-LABEL: @fi4( // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]] // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0 // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1 @@ -101,7 +117,7 @@ _Bool fi4(_Atomic(int) *i) { } _Bool fi4a(int *i) { - // CHECK-LABEL: @fi4 + // CHECK-LABEL: @fi4a // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]] // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0 // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1 @@ -113,7 +129,7 @@ _Bool fi4a(int *i) { } _Bool fi4b(int *i) { - // CHECK-LABEL: @fi4 + // CHECK-LABEL: @fi4b( // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg weak i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]] // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0 // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1 @@ -123,6 +139,13 @@ _Bool fi4b(int *i) { return __atomic_compare_exchange_n(i, &cmp, 1, 1, memory_order_acquire, memory_order_acquire); } +_Bool fi4c(atomic_int *i) { + // CHECK-LABEL: @fi4c + // CHECK: cmpxchg i32* + int cmp = 0; + return atomic_compare_exchange_strong(i, &cmp, 1); +} + float ff1(_Atomic(float) *d) { // CHECK-LABEL: @ff1 // CHECK: load atomic i32* {{.*}} monotonic @@ -139,6 +162,79 @@ float ff3(_Atomic(float) *d) { return __c11_atomic_exchange(d, 2, memory_order_seq_cst); } +struct S { + double x; +}; + +struct S fd1(struct S *a) { + // CHECK-LABEL: @fd1 + // CHECK: [[RETVAL:%.*]] = alloca %struct.S, align 4 + // CHECK: [[RET:%.*]] = alloca %struct.S, align 4 + // CHECK: [[CALL:%.*]] = call i64 @__atomic_load_8( + // CHECK: [[CAST:%.*]] = bitcast %struct.S* [[RET]] to i64* + // CHECK: store i64 [[CALL]], i64* [[CAST]], align 4 + struct S ret; + __atomic_load(a, &ret, memory_order_seq_cst); + return ret; +} + +void fd2(struct S *a, struct S *b) { + // CHECK-LABEL: @fd2 + // CHECK: [[A_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: store %struct.S* %a, %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8* + // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i64* + // CHECK-NEXT: [[LOAD_B:%.*]] = load i64* [[COERCED_B]], align 4 + // CHECK-NEXT: call void @__atomic_store_8(i8* [[COERCED_A]], i64 [[LOAD_B]], + // CHECK-NEXT: ret void + __atomic_store(a, b, memory_order_seq_cst); +} + +void fd3(struct S *a, struct S *b, struct S *c) { + // CHECK-LABEL: @fd3 + // CHECK: [[A_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: [[C_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: store %struct.S* %a, %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: store %struct.S* %c, %struct.S** [[C_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_C_PTR:%.*]] = load %struct.S** [[C_ADDR]], align 4 + // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8* + // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i64* + // CHECK-NEXT: [[LOAD_B:%.*]] = load i64* [[COERCED_B]], align 4 + // CHECK-NEXT: [[CALL:%.*]] = call i64 @__atomic_exchange_8(i8* [[COERCED_A]], i64 [[LOAD_B]], + // CHECK-NEXT: [[COERCED_C:%.*]] = bitcast %struct.S* [[LOAD_C_PTR]] to i64* + // CHECK-NEXT: store i64 [[CALL]], i64* [[COERCED_C]], align 4 + + __atomic_exchange(a, b, c, memory_order_seq_cst); +} + +_Bool fd4(struct S *a, struct S *b, struct S *c) { + // CHECK-LABEL: @fd4 + // CHECK: [[A_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK-NEXT: [[C_ADDR:%.*]] = alloca %struct.S*, align 4 + // CHECK: store %struct.S* %a, %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: store %struct.S* %c, %struct.S** [[C_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4 + // CHECK-NEXT: [[LOAD_C_PTR:%.*]] = load %struct.S** [[C_ADDR]], align 4 + // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8* + // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i8* + // CHECK-NEXT: [[COERCED_C:%.*]] = bitcast %struct.S* [[LOAD_C_PTR]] to i64* + // CHECK-NEXT: [[LOAD_C:%.*]] = load i64* [[COERCED_C]], align 4 + // CHECK-NEXT: [[CALL:%.*]] = call zeroext i1 @__atomic_compare_exchange_8(i8* [[COERCED_A]], i8* [[COERCED_B]], i64 [[LOAD_C]] + // CHECK-NEXT: ret i1 [[CALL]] + return __atomic_compare_exchange(a, b, c, 1, 5, 5); +} + int* fp1(_Atomic(int*) *p) { // CHECK-LABEL: @fp1 // CHECK: load atomic i32* {{.*}} seq_cst @@ -287,14 +383,23 @@ struct foo structAtomicExchange() { } int structAtomicCmpExchange() { // CHECK-LABEL: @structAtomicCmpExchange + // CHECK: %[[x_mem:.*]] = alloca i8 _Bool x = __atomic_compare_exchange(&smallThing, &thing1, &thing2, 1, 5, 5); - // CHECK: call zeroext i1 @__atomic_compare_exchange(i32 3, {{.*}} @smallThing{{.*}} @thing1{{.*}} @thing2 + // CHECK: %[[call1:.*]] = call zeroext i1 @__atomic_compare_exchange(i32 3, {{.*}} @smallThing{{.*}} @thing1{{.*}} @thing2 + // CHECK: %[[zext1:.*]] = zext i1 %[[call1]] to i8 + // CHECK: store i8 %[[zext1]], i8* %[[x_mem]], align 1 + // CHECK: %[[x:.*]] = load i8* %[[x_mem]] + // CHECK: %[[x_bool:.*]] = trunc i8 %[[x]] to i1 + // CHECK: %[[conv1:.*]] = zext i1 %[[x_bool]] to i32 struct foo f = {0}; struct foo g = {0}; g.big[12] = 12; return x & __c11_atomic_compare_exchange_strong(&bigAtomic, &f, g, 5, 5); - // CHECK: call zeroext i1 @__atomic_compare_exchange(i32 512, i8* bitcast ({{.*}} @bigAtomic to i8*), + // CHECK: %[[call2:.*]] = call zeroext i1 @__atomic_compare_exchange(i32 512, i8* bitcast ({{.*}} @bigAtomic to i8*), + // CHECK: %[[conv2:.*]] = zext i1 %[[call2]] to i32 + // CHECK: %[[and:.*]] = and i32 %[[conv1]], %[[conv2]] + // CHECK: ret i32 %[[and]] } // Check that no atomic operations are used in any initialisation of _Atomic @@ -447,4 +552,51 @@ void EMIT_ALL_THE_THINGS(int *ptr, int *ptr2, int new, _Bool weak, int success, // CHECK: = cmpxchg weak {{.*}} seq_cst seq_cst } +int PR21643() { + return __atomic_or_fetch((int __attribute__((address_space(257))) *)0x308, 1, + __ATOMIC_RELAXED); + // CHECK: %[[atomictmp:.*]] = alloca i32, align 4 + // CHECK: %[[atomicdst:.*]] = alloca i32, align 4 + // CHECK: store i32 1, i32* %[[atomictmp]] + // CHECK: %[[one:.*]] = load i32* %[[atomictmp]], align 4 + // CHECK: %[[old:.*]] = atomicrmw or i32 addrspace(257)* inttoptr (i32 776 to i32 addrspace(257)*), i32 %[[one]] monotonic + // CHECK: %[[new:.*]] = or i32 %[[old]], %[[one]] + // CHECK: store i32 %[[new]], i32* %[[atomicdst]], align 4 + // CHECK: %[[ret:.*]] = load i32* %[[atomicdst]], align 4 + // CHECK: ret i32 %[[ret]] +} + +int PR17306_1(volatile _Atomic(int) *i) { + // CHECK-LABEL: @PR17306_1 + // CHECK: %[[i_addr:.*]] = alloca i32 + // CHECK-NEXT: %[[atomicdst:.*]] = alloca i32 + // CHECK-NEXT: store i32* %i, i32** %[[i_addr]] + // CHECK-NEXT: %[[addr:.*]] = load i32** %[[i_addr]] + // CHECK-NEXT: %[[res:.*]] = load atomic volatile i32* %[[addr]] seq_cst + // CHECK-NEXT: store i32 %[[res]], i32* %[[atomicdst]] + // CHECK-NEXT: %[[retval:.*]] = load i32* %[[atomicdst]] + // CHECK-NEXT: ret i32 %[[retval]] + return __c11_atomic_load(i, memory_order_seq_cst); +} + +int PR17306_2(volatile int *i, int value) { + // CHECK-LABEL: @PR17306_2 + // CHECK: %[[i_addr:.*]] = alloca i32* + // CHECK-NEXT: %[[value_addr:.*]] = alloca i32 + // CHECK-NEXT: %[[atomictmp:.*]] = alloca i32 + // CHECK-NEXT: %[[atomicdst:.*]] = alloca i32 + // CHECK-NEXT: store i32* %i, i32** %[[i_addr]] + // CHECK-NEXT: store i32 %value, i32* %[[value_addr]] + // CHECK-NEXT: %[[i_lval:.*]] = load i32** %[[i_addr]] + // CHECK-NEXT: %[[value:.*]] = load i32* %[[value_addr]] + // CHECK-NEXT: store i32 %[[value]], i32* %[[atomictmp]] + // CHECK-NEXT: %[[value_lval:.*]] = load i32* %[[atomictmp]] + // CHECK-NEXT: %[[old_val:.*]] = atomicrmw volatile add i32* %[[i_lval]], i32 %[[value_lval]] seq_cst + // CHECK-NEXT: %[[new_val:.*]] = add i32 %[[old_val]], %[[value_lval]] + // CHECK-NEXT: store i32 %[[new_val]], i32* %[[atomicdst]] + // CHECK-NEXT: %[[retval:.*]] = load i32* %[[atomicdst]] + // CHECK-NEXT: ret i32 %[[retval]] + return __atomic_add_fetch(i, value, memory_order_seq_cst); +} + #endif diff --git a/test/CodeGen/atomic.c b/test/CodeGen/atomic.c index 43f5bc81ee98..4db3c8e6d69c 100644 --- a/test/CodeGen/atomic.c +++ b/test/CodeGen/atomic.c @@ -50,7 +50,10 @@ int atomic(void) { old = __sync_fetch_and_xor(&val, 0xb); // CHECK: atomicrmw xor i32* %val, i32 11 seq_cst - + + old = __sync_fetch_and_nand(&val, 0xc); + // CHECK: atomicrmw nand i32* %val, i32 12 seq_cst + old = __sync_add_and_fetch(&val, 1); // CHECK: atomicrmw add i32* %val, i32 1 seq_cst @@ -65,7 +68,10 @@ int atomic(void) { old = __sync_xor_and_fetch(&valc, 5); // CHECK: atomicrmw xor i8* %valc, i8 5 seq_cst - + + old = __sync_nand_and_fetch(&valc, 6); + // CHECK: atomicrmw nand i8* %valc, i8 6 seq_cst + __sync_val_compare_and_swap((void **)0, (void *)0, (void *)0); // CHECK: [[PAIR:%[a-z0-9_.]+]] = cmpxchg i32* null, i32 0, i32 0 seq_cst // CHECK: extractvalue { i32, i1 } [[PAIR]], 0 diff --git a/test/CodeGen/atomic_ops.c b/test/CodeGen/atomic_ops.c index 910e9b950506..29009bef894c 100644 --- a/test/CodeGen/atomic_ops.c +++ b/test/CodeGen/atomic_ops.c @@ -7,12 +7,12 @@ void foo(int x) // Check that multiply / divides on atomics produce a cmpxchg loop i *= 2; // CHECK: mul nsw i32 - // CHECK: cmpxchg i32* + // CHECK: {{(cmpxchg i32*|i1 @__atomic_compare_exchange\(i32 4,)}} i /= 2; // CHECK: sdiv i32 - // CHECK: cmpxchg i32* + // CHECK: {{(cmpxchg i32*|i1 @__atomic_compare_exchange\(i32 4, )}} j /= x; // CHECK: sdiv i32 - // CHECK: cmpxchg i16* + // CHECK: {{(cmpxchg i16*|i1 @__atomic_compare_exchange\(i32 2, )}} } diff --git a/test/CodeGen/atomics-inlining.c b/test/CodeGen/atomics-inlining.c index ec916e1b5eef..9cd280294f38 100644 --- a/test/CodeGen/atomics-inlining.c +++ b/test/CodeGen/atomics-inlining.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple arm-linux-gnu -emit-llvm %s -o - | FileCheck %s -check-prefix=ARM +// RUN: %clang_cc1 -triple arm-linux-gnueabi -emit-llvm %s -o - | FileCheck %s -check-prefix=ARM // RUN: %clang_cc1 -triple powerpc-linux-gnu -emit-llvm %s -o - | FileCheck %s -check-prefix=PPC32 // RUN: %clang_cc1 -triple powerpc64-linux-gnu -emit-llvm %s -o - | FileCheck %s -check-prefix=PPC64 // RUN: %clang_cc1 -triple mipsel-linux-gnu -emit-llvm %s -o - | FileCheck %s -check-prefix=MIPS32 @@ -31,17 +31,17 @@ void test1(void) { (void)__atomic_load(&a1, &a2, memory_order_seq_cst); (void)__atomic_store(&a1, &a2, memory_order_seq_cst); -// ARM-LABEL: define arm_aapcscc void @test1 -// ARM: = call arm_aapcscc zeroext i8 @__atomic_load_1(i8* @c1 -// ARM: call arm_aapcscc void @__atomic_store_1(i8* @c1, i8 zeroext -// ARM: = call arm_aapcscc zeroext i16 @__atomic_load_2(i8* bitcast (i16* @s1 to i8*) -// ARM: call arm_aapcscc void @__atomic_store_2(i8* bitcast (i16* @s1 to i8*), i16 zeroext -// ARM: = call arm_aapcscc i32 @__atomic_load_4(i8* bitcast (i32* @i1 to i8*) -// ARM: call arm_aapcscc void @__atomic_store_4(i8* bitcast (i32* @i1 to i8*), i32 -// ARM: = call arm_aapcscc i64 @__atomic_load_8(i8* bitcast (i64* @ll1 to i8*) -// ARM: call arm_aapcscc void @__atomic_store_8(i8* bitcast (i64* @ll1 to i8*), i64 -// ARM: call arm_aapcscc void @__atomic_load(i32 100, i8* getelementptr inbounds ([100 x i8]* @a1, i32 0, i32 0), i8* getelementptr inbounds ([100 x i8]* @a2, i32 0, i32 0) -// ARM: call arm_aapcscc void @__atomic_store(i32 100, i8* getelementptr inbounds ([100 x i8]* @a1, i32 0, i32 0), i8* getelementptr inbounds ([100 x i8]* @a2, i32 0, i32 0) +// ARM-LABEL: define{{.*}} void @test1 +// ARM: = call{{.*}} zeroext i8 @__atomic_load_1(i8* @c1 +// ARM: call{{.*}} void @__atomic_store_1(i8* @c1, i8 zeroext +// ARM: = call{{.*}} zeroext i16 @__atomic_load_2(i8* bitcast (i16* @s1 to i8*) +// ARM: call{{.*}} void @__atomic_store_2(i8* bitcast (i16* @s1 to i8*), i16 zeroext +// ARM: = call{{.*}} i32 @__atomic_load_4(i8* bitcast (i32* @i1 to i8*) +// ARM: call{{.*}} void @__atomic_store_4(i8* bitcast (i32* @i1 to i8*), i32 +// ARM: = call{{.*}} i64 @__atomic_load_8(i8* bitcast (i64* @ll1 to i8*) +// ARM: call{{.*}} void @__atomic_store_8(i8* bitcast (i64* @ll1 to i8*), i64 +// ARM: call{{.*}} void @__atomic_load(i32 100, i8* getelementptr inbounds ([100 x i8]* @a1, i32 0, i32 0), i8* getelementptr inbounds ([100 x i8]* @a2, i32 0, i32 0) +// ARM: call{{.*}} void @__atomic_store(i32 100, i8* getelementptr inbounds ([100 x i8]* @a1, i32 0, i32 0), i8* getelementptr inbounds ([100 x i8]* @a2, i32 0, i32 0) // PPC32-LABEL: define void @test1 // PPC32: = load atomic i8* @c1 seq_cst diff --git a/test/CodeGen/attr-naked.c b/test/CodeGen/attr-naked.c index c07dd8d3732a..270fc7959f44 100644 --- a/test/CodeGen/attr-naked.c +++ b/test/CodeGen/attr-naked.c @@ -12,7 +12,15 @@ void t1() // Make sure this doesn't explode in the verifier. // (It doesn't really make sense, but it isn't invalid.) // CHECK: define void @t2() [[NAKED]] { -__attribute((naked, always_inline)) void t2() { +__attribute((naked, always_inline)) void t2() { +} + +// Make sure not to generate prolog or epilog for naked functions. +__attribute((naked)) void t3(int x) { +// CHECK: define void @t3(i32) +// CHECK-NOT: alloca +// CHECK-NOT: store +// CHECK: unreachable } // CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} } diff --git a/test/CodeGen/attr-optnone.c b/test/CodeGen/attr-optnone.c index e7069b10f21a..96493bfe3613 100644 --- a/test/CodeGen/attr-optnone.c +++ b/test/CodeGen/attr-optnone.c @@ -1,12 +1,19 @@ // RUN: %clang_cc1 -emit-llvm < %s > %t // RUN: FileCheck %s --check-prefix=PRESENT < %t // RUN: FileCheck %s --check-prefix=ABSENT < %t +// RUN: %clang_cc1 -emit-llvm -Os < %s > %t +// RUN: FileCheck %s --check-prefix=PRESENT < %t +// RUN: FileCheck %s --check-prefix=OPTSIZE < %t +// RUN: %clang_cc1 -emit-llvm -Oz < %s > %t +// RUN: FileCheck %s --check-prefix=PRESENT < %t +// RUN: FileCheck %s --check-prefix=MINSIZE < %t __attribute__((always_inline)) int test2() { return 0; } -// PRESENT-DAG: @test2{{.*}}[[ATTR2:#[0-9]+]] +// OPTSIZE: @test2{{.*}}[[ATTR2:#[0-9]+]] +// MINSIZE: @test2{{.*}}[[ATTR2:#[0-9]+]] -__attribute__((optnone)) __attribute__((minsize)) +__attribute__((optnone)) int test3() { return 0; } // PRESENT-DAG: @test3{{.*}}[[ATTR3:#[0-9]+]] @@ -23,3 +30,13 @@ int test4() { return test2(); } // Check that no 'optsize' or 'minsize' attributes appear. // ABSENT-NOT: optsize // ABSENT-NOT: minsize + +// With -Os, check that 'optsize' appears only on test2. +// OPTSIZE-NOT: optsize +// OPTSIZE: attributes [[ATTR2]] = { {{.*}}optsize{{.*}} } +// OPTSIZE-NOT: optsize + +// With -Oz, check that 'minsize' appears only on test2. +// MINSIZE-NOT: minsize +// MINSIZE: attributes [[ATTR2]] = { {{.*}}minsize{{.*}} } +// MINSIZE-NOT: minsize diff --git a/test/CodeGen/attributes.c b/test/CodeGen/attributes.c index 356a17996a88..5c9c90d7cee4 100644 --- a/test/CodeGen/attributes.c +++ b/test/CodeGen/attributes.c @@ -26,7 +26,7 @@ int t6 __attribute__((visibility("protected"))); // CHECK: @t12 = global i32 0, section "SECT" int t12 __attribute__((section("SECT"))); -// CHECK: @t9 = alias weak bitcast (void ()* @__t8 to void (...)*) +// CHECK: @t9 = weak alias bitcast (void ()* @__t8 to void (...)*) void __t8() {} void t9() __attribute__((weak, alias("__t8"))); diff --git a/test/CodeGen/avx2-builtins.c b/test/CodeGen/avx2-builtins.c index 10c3a1b726a1..04825ffa2f60 100644 --- a/test/CodeGen/avx2-builtins.c +++ b/test/CodeGen/avx2-builtins.c @@ -6,7 +6,7 @@ #include <immintrin.h> __m256i test_mm256_mpsadbw_epu8(__m256i x, __m256i y) { - // CHECK: @llvm.x86.avx2.mpsadbw({{.*}}, {{.*}}, i32 3) + // CHECK: @llvm.x86.avx2.mpsadbw({{.*}}, {{.*}}, i8 3) return _mm256_mpsadbw_epu8(x, y, 3); } diff --git a/test/CodeGen/avx512bw-builtins.c b/test/CodeGen/avx512bw-builtins.c new file mode 100644 index 000000000000..ada84657a607 --- /dev/null +++ b/test/CodeGen/avx512bw-builtins.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512bw -emit-llvm -o - -Werror | FileCheck %s + +#include <immintrin.h> + +__mmask64 test_mm512_cmpeq_epi8_mask(__m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.512 + return (__mmask64)_mm512_cmpeq_epi8_mask(__a, __b); +} + +__mmask64 test_mm512_mask_cmpeq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_mask_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.512 + return (__mmask64)_mm512_mask_cmpeq_epi8_mask(__u, __a, __b); +} + +__mmask32 test_mm512_cmpeq_epi16_mask(__m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.512 + return (__mmask32)_mm512_cmpeq_epi16_mask(__a, __b); +} + +__mmask32 test_mm512_mask_cmpeq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_mask_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.512 + return (__mmask32)_mm512_mask_cmpeq_epi16_mask(__u, __a, __b); +} diff --git a/test/CodeGen/avx512f-builtins.c b/test/CodeGen/avx512f-builtins.c new file mode 100644 index 000000000000..8bb013fef731 --- /dev/null +++ b/test/CodeGen/avx512f-builtins.c @@ -0,0 +1,212 @@ +// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -o - -Werror | FileCheck %s + +// Don't include mm_malloc.h, it's system specific. +#define __MM_MALLOC_H + +#include <immintrin.h> + +__m512d test_mm512_sqrt_pd(__m512d a) +{ + // CHECK-LABEL: @test_mm512_sqrt_pd + // CHECK: @llvm.x86.avx512.sqrt.pd.512 + return _mm512_sqrt_pd(a); +} + +__m512 test_mm512_sqrt_ps(__m512 a) +{ + // CHECK-LABEL: @test_mm512_sqrt_ps + // CHECK: @llvm.x86.avx512.sqrt.ps.512 + return _mm512_sqrt_ps(a); +} + +__m512d test_mm512_rsqrt14_pd(__m512d a) +{ + // CHECK-LABEL: @test_mm512_rsqrt14_pd + // CHECK: @llvm.x86.avx512.rsqrt14.pd.512 + return _mm512_rsqrt14_pd(a); +} + +__m512 test_mm512_rsqrt14_ps(__m512 a) +{ + // CHECK-LABEL: @test_mm512_rsqrt14_ps + // CHECK: @llvm.x86.avx512.rsqrt14.ps.512 + return _mm512_rsqrt14_ps(a); +} + +__m512 test_mm512_add_ps(__m512 a, __m512 b) +{ + // CHECK-LABEL: @test_mm512_add_ps + // CHECK: fadd <16 x float> + return _mm512_add_ps(a, b); +} + +__m512d test_mm512_add_pd(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_add_pd + // CHECK: fadd <8 x double> + return _mm512_add_pd(a, b); +} + +__m512 test_mm512_mul_ps(__m512 a, __m512 b) +{ + // CHECK-LABEL: @test_mm512_mul_ps + // CHECK: fmul <16 x float> + return _mm512_mul_ps(a, b); +} + +__m512d test_mm512_mul_pd(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_mul_pd + // CHECK: fmul <8 x double> + return _mm512_mul_pd(a, b); +} + +void test_mm512_storeu_ps(void *p, __m512 a) +{ + // CHECK-LABEL: @test_mm512_storeu_ps + // CHECK: @llvm.x86.avx512.mask.storeu.ps.512 + _mm512_storeu_ps(p, a); +} + +void test_mm512_storeu_pd(void *p, __m512d a) +{ + // CHECK-LABEL: @test_mm512_storeu_pd + // CHECK: @llvm.x86.avx512.mask.storeu.pd.512 + _mm512_storeu_pd(p, a); +} + +void test_mm512_store_ps(void *p, __m512 a) +{ + // CHECK-LABEL: @test_mm512_store_ps + // CHECK: store <16 x float> + _mm512_store_ps(p, a); +} + +void test_mm512_store_pd(void *p, __m512d a) +{ + // CHECK-LABEL: @test_mm512_store_pd + // CHECK: store <8 x double> + _mm512_store_pd(p, a); +} + +__m512 test_mm512_loadu_ps(void *p) +{ + // CHECK-LABEL: @test_mm512_loadu_ps + // CHECK: load <16 x float>* {{.*}}, align 1{{$}} + return _mm512_loadu_ps(p); +} + +__m512d test_mm512_loadu_pd(void *p) +{ + // CHECK-LABEL: @test_mm512_loadu_pd + // CHECK: load <8 x double>* {{.*}}, align 1{{$}} + return _mm512_loadu_pd(p); +} + +__m512d test_mm512_set1_pd(double d) +{ + // CHECK-LABEL: @test_mm512_set1_pd + // CHECK: insertelement <8 x double> {{.*}}, i32 0 + // CHECK: insertelement <8 x double> {{.*}}, i32 1 + // CHECK: insertelement <8 x double> {{.*}}, i32 2 + // CHECK: insertelement <8 x double> {{.*}}, i32 3 + // CHECK: insertelement <8 x double> {{.*}}, i32 4 + // CHECK: insertelement <8 x double> {{.*}}, i32 5 + // CHECK: insertelement <8 x double> {{.*}}, i32 6 + // CHECK: insertelement <8 x double> {{.*}}, i32 7 + return _mm512_set1_pd(d); +} + +__m512d test_mm512_castpd256_pd512(__m256d a) +{ + // CHECK-LABEL: @test_mm512_castpd256_pd512 + // CHECK: shufflevector <4 x double> {{.*}} <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef> + return _mm512_castpd256_pd512(a); +} + +__mmask16 test_mm512_knot(__mmask16 a) +{ + // CHECK-LABEL: @test_mm512_knot + // CHECK: @llvm.x86.avx512.knot.w + return _mm512_knot(a); +} + +__m512i test_mm512_valign_epi64(__m512i a, __m512i b) +{ + // CHECK-LABEL: @test_mm512_valign_epi64 + // CHECK: @llvm.x86.avx512.mask.valign.q.512 + return _mm512_valign_epi64(a, b, 2); +} + +__m512d test_mm512_broadcastsd_pd(__m128d a) +{ + // CHECK-LABEL: @test_mm512_broadcastsd_pd + // CHECK: insertelement <8 x double> {{.*}}, i32 0 + // CHECK: insertelement <8 x double> {{.*}}, i32 1 + // CHECK: insertelement <8 x double> {{.*}}, i32 2 + // CHECK: insertelement <8 x double> {{.*}}, i32 3 + // CHECK: insertelement <8 x double> {{.*}}, i32 4 + // CHECK: insertelement <8 x double> {{.*}}, i32 5 + // CHECK: insertelement <8 x double> {{.*}}, i32 6 + // CHECK: insertelement <8 x double> {{.*}}, i32 7 + return _mm512_broadcastsd_pd(a); +} + +__m512i test_mm512_fmadd_pd(__m512d a, __m512d b, __m512d c) +{ + // CHECK-LABEL: @test_mm512_fmadd_pd + // CHECK: @llvm.x86.fma.mask.vfmadd.pd.512 + return _mm512_fmadd_pd(a, b, c); +} + +__mmask16 test_mm512_cmpeq_epi32_mask(__m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.512 + return (__mmask16)_mm512_cmpeq_epi32_mask(__a, __b); +} + +__mmask16 test_mm512_mask_cmpeq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_mask_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.512 + return (__mmask16)_mm512_mask_cmpeq_epi32_mask(__u, __a, __b); +} + +__mmask8 test_mm512_mask_cmpeq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_mask_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.512 + return (__mmask8)_mm512_mask_cmpeq_epi64_mask(__u, __a, __b); +} + +__mmask8 test_mm512_cmpeq_epi64_mask(__m512i __a, __m512i __b) { + // CHECK-LABEL: @test_mm512_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.512 + return (__mmask8)_mm512_cmpeq_epi64_mask(__a, __b); +} + +__m512d test_mm512_unpackhi_pd(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_unpackhi_pd + // CHECK: shufflevector <8 x double> {{.*}} <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> + return _mm512_unpackhi_pd(a, b); +} + +__m512d test_mm512_unpacklo_pd(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_unpacklo_pd + // CHECK: shufflevector <8 x double> {{.*}} <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> + return _mm512_unpacklo_pd(a, b); +} + +__m512d test_mm512_unpackhi_ps(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_unpackhi_ps + // CHECK: shufflevector <16 x float> {{.*}} <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> + return _mm512_unpackhi_ps(a, b); +} + +__m512d test_mm512_unpacklo_ps(__m512d a, __m512d b) +{ + // CHECK-LABEL: @test_mm512_unpacklo_ps + // CHECK: shufflevector <16 x float> {{.*}} <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> + return _mm512_unpacklo_ps(a, b); +} diff --git a/test/CodeGen/avx512vl-builtins.c b/test/CodeGen/avx512vl-builtins.c new file mode 100644 index 000000000000..e4b45173bb13 --- /dev/null +++ b/test/CodeGen/avx512vl-builtins.c @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Werror | FileCheck %s + +#include <immintrin.h> + +__mmask8 test_mm256_cmpeq_epi32_mask(__m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 + return (__mmask8)_mm256_cmpeq_epi32_mask(__a, __b); +} + +__mmask8 test_mm256_mask_cmpeq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_mask_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 + return (__mmask8)_mm256_mask_cmpeq_epi32_mask(__u, __a, __b); +} + +__mmask8 test_mm_cmpeq_epi32_mask(__m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 + return (__mmask8)_mm_cmpeq_epi32_mask(__a, __b); +} + +__mmask8 test_mm_mask_cmpeq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_mask_cmpeq_epi32_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 + return (__mmask8)_mm_mask_cmpeq_epi32_mask(__u, __a, __b); +} + +__mmask8 test_mm256_cmpeq_epi64_mask(__m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 + return (__mmask8)_mm256_cmpeq_epi64_mask(__a, __b); +} + +__mmask8 test_mm256_mask_cmpeq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_mask_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 + return (__mmask8)_mm256_mask_cmpeq_epi64_mask(__u, __a, __b); +} + +__mmask8 test_mm_cmpeq_epi64_mask(__m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 + return (__mmask8)_mm_cmpeq_epi64_mask(__a, __b); +} + +__mmask8 test_mm_mask_cmpeq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_mask_cmpeq_epi64_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 + return (__mmask8)_mm_mask_cmpeq_epi64_mask(__u, __a, __b); +} diff --git a/test/CodeGen/avx512vlbw-builtins.c b/test/CodeGen/avx512vlbw-builtins.c new file mode 100644 index 000000000000..a304f7b3d361 --- /dev/null +++ b/test/CodeGen/avx512vlbw-builtins.c @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Werror | FileCheck %s + +#include <immintrin.h> + +__mmask32 test_mm256_cmpeq_epi8_mask(__m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 + return (__mmask32)_mm256_cmpeq_epi8_mask(__a, __b); +} + +__mmask32 test_mm256_mask_cmpeq_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_mask_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 + return (__mmask32)_mm256_mask_cmpeq_epi8_mask(__u, __a, __b); +} + +__mmask16 test_mm_cmpeq_epi8_mask(__m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 + return (__mmask16)_mm_cmpeq_epi8_mask(__a, __b); +} + +__mmask16 test_mm_mask_cmpeq_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_mask_cmpeq_epi8_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 + return (__mmask16)_mm_mask_cmpeq_epi8_mask(__u, __a, __b); +} + +__mmask16 test_mm256_cmpeq_epi16_mask(__m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 + return (__mmask16)_mm256_cmpeq_epi16_mask(__a, __b); +} + +__mmask16 test_mm256_mask_cmpeq_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { + // CHECK-LABEL: @test_mm256_mask_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 + return (__mmask16)_mm256_mask_cmpeq_epi16_mask(__u, __a, __b); +} + +__mmask8 test_mm_cmpeq_epi16_mask(__m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 + return (__mmask8)_mm_cmpeq_epi16_mask(__a, __b); +} + +__mmask8 test_mm_mask_cmpeq_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { + // CHECK-LABEL: @test_mm_mask_cmpeq_epi16_mask + // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 + return (__mmask8)_mm_mask_cmpeq_epi16_mask(__u, __a, __b); +} diff --git a/test/CodeGen/block-with-perdefinedexpr.c b/test/CodeGen/block-with-perdefinedexpr.c new file mode 100644 index 000000000000..68fdea60f379 --- /dev/null +++ b/test/CodeGen/block-with-perdefinedexpr.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -fblocks -triple x86_64-apple-darwin10 | FileCheck %s +// rdar://18961148 + +void syslog(const char *, ...); + +void handler( ); + +static void (^spd)() = ^() +{ + handler( ^(){ syslog("%s", __FUNCTION__); } ); +}; +// CHECK: @__FUNCTION__.spd_block_invoke_2 = private unnamed_addr constant [19 x i8] c"spd_block_invoke_2\00" +// CHECK: define internal void @spd_block_invoke_2 +// CHECK: @__FUNCTION__.spd_block_invoke_2 diff --git a/test/CodeGen/bmi2-builtins.c b/test/CodeGen/bmi2-builtins.c index 201cac63b9fe..5aa54fd0ec34 100644 --- a/test/CodeGen/bmi2-builtins.c +++ b/test/CodeGen/bmi2-builtins.c @@ -24,9 +24,9 @@ unsigned int test_pext_u32(unsigned int __X, unsigned int __Y) { unsigned int test_mulx_u32(unsigned int __X, unsigned int __Y, unsigned int *__P) { // CHECK: @test_mulx_u32 - // CHECK-NOT: mul i64 + // CHECK-NOT: mul nuw i64 // B32: @test_mulx_u32 - // B32: mul i64 + // B32: mul nuw i64 return _mulx_u32(__X, __Y, __P); } @@ -48,6 +48,6 @@ unsigned long long test_pext_u64(unsigned long long __X, unsigned long long __Y) unsigned long long test_mulx_u64(unsigned long long __X, unsigned long long __Y, unsigned long long *__P) { // CHECK: @test_mulx_u64 - // CHECK: mul i128 + // CHECK: mul nuw i128 return _mulx_u64(__X, __Y, __P); } diff --git a/test/CodeGen/bool_test.c b/test/CodeGen/bool_test.c index c836b9830339..cf62dba1df21 100644 --- a/test/CodeGen/bool_test.c +++ b/test/CodeGen/bool_test.c @@ -15,4 +15,4 @@ void f(_Bool *x, _Bool *y) { // CHECK: store i32 [[TOMEM]] // CHECK: ret void -// CHECK: metadata !{i32 0, i32 2} +// CHECK: i32 0, i32 2} diff --git a/test/CodeGen/builtin-assume-aligned.c b/test/CodeGen/builtin-assume-aligned.c new file mode 100644 index 000000000000..1d807a40cad4 --- /dev/null +++ b/test/CodeGen/builtin-assume-aligned.c @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s + +// CHECK-LABEL: @test1 +int test1(int *a) { +// CHECK: [[PTRINT1:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR1:%.+]] = and i64 [[PTRINT1]], 31 +// CHECK: [[MASKCOND1:%.+]] = icmp eq i64 [[MASKEDPTR1]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND1]]) + a = __builtin_assume_aligned(a, 32, 0ull); + return a[0]; +} + +// CHECK-LABEL: @test2 +int test2(int *a) { +// CHECK: [[PTRINT2:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR2:%.+]] = and i64 [[PTRINT2]], 31 +// CHECK: [[MASKCOND2:%.+]] = icmp eq i64 [[MASKEDPTR2]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND2]]) + a = __builtin_assume_aligned(a, 32, 0); + return a[0]; +} + +// CHECK-LABEL: @test3 +int test3(int *a) { +// CHECK: [[PTRINT3:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR3:%.+]] = and i64 [[PTRINT3]], 31 +// CHECK: [[MASKCOND3:%.+]] = icmp eq i64 [[MASKEDPTR3]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND3]]) + a = __builtin_assume_aligned(a, 32); + return a[0]; +} + +// CHECK-LABEL: @test4 +int test4(int *a, int b) { +// CHECK-DAG: [[PTRINT4:%.+]] = ptrtoint +// CHECK-DAG: [[CONV4:%.+]] = sext i32 +// CHECK: [[OFFSETPTR4:%.+]] = sub i64 [[PTRINT4]], [[CONV4]] +// CHECK: [[MASKEDPTR4:%.+]] = and i64 [[OFFSETPTR4]], 31 +// CHECK: [[MASKCOND4:%.+]] = icmp eq i64 [[MASKEDPTR4]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND4]]) + a = __builtin_assume_aligned(a, 32, b); + return a[0]; +} + +int *m1() __attribute__((assume_aligned(64))); + +// CHECK-LABEL: @test5 +int test5() { + return *m1(); +// CHECK: [[PTRINT5:%.+]] = ptrtoint +// CHECK: [[MASKEDPTR5:%.+]] = and i64 [[PTRINT5]], 63 +// CHECK: [[MASKCOND5:%.+]] = icmp eq i64 [[MASKEDPTR5]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND5]]) +} + +int *m2() __attribute__((assume_aligned(64, 12))); + +// CHECK-LABEL: @test6 +int test6() { + return *m2(); +// CHECK: [[PTRINT6:%.+]] = ptrtoint +// CHECK: [[OFFSETPTR6:%.+]] = sub i64 [[PTRINT6]], 12 +// CHECK: [[MASKEDPTR6:%.+]] = and i64 [[OFFSETPTR6]], 63 +// CHECK: [[MASKCOND6:%.+]] = icmp eq i64 [[MASKEDPTR6]], 0 +// CHECK: call void @llvm.assume(i1 [[MASKCOND6]]) +} + diff --git a/test/CodeGen/builtin-assume.c b/test/CodeGen/builtin-assume.c index a381a4c1dfb0..8411b729abf5 100644 --- a/test/CodeGen/builtin-assume.c +++ b/test/CodeGen/builtin-assume.c @@ -1,8 +1,27 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple i386-mingw32 -fms-extensions -emit-llvm -o - %s | FileCheck %s // CHECK-LABEL: @test1 -int test1(int *a) { - __assume(a != 0); +int test1(int *a, int i) { +// CHECK: store i32* %a, i32** [[A_ADDR:%.+]], align +// CHECK: [[A:%.+]] = load i32** [[A_ADDR]] +// CHECK: [[CMP:%.+]] = icmp ne i32* [[A]], null +// CHECK: call void @llvm.assume(i1 [[CMP]]) +#ifdef _MSC_VER + __assume(a != 0) +#else + __builtin_assume(a != 0); +#endif + +// Nothing is generated for an assume with side effects... +// CHECK-NOT: load i32** %i.addr +// CHECK-NOT: call void @llvm.assume +#ifdef _MSC_VER + __assume(++i != 0) +#else + __builtin_assume(++i != 0); +#endif + return a[0]; } diff --git a/test/CodeGen/builtin-recursive.cc b/test/CodeGen/builtin-recursive.cpp index 81e9b9a37c25..7553a6e48f53 100644 --- a/test/CodeGen/builtin-recursive.cc +++ b/test/CodeGen/builtin-recursive.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -nostdsysteminc -nobuiltininc -isystem Inputs -emit-llvm-only %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -nostdsysteminc -nobuiltininc -isystem %S/Inputs -emit-llvm-only %s // This used to cause a read past the end of a global variable. diff --git a/test/CodeGen/builtins-arm-msvc-compat-error.c b/test/CodeGen/builtins-arm-msvc-compat-error.c new file mode 100644 index 000000000000..29469deb6a70 --- /dev/null +++ b/test/CodeGen/builtins-arm-msvc-compat-error.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -triple thumbv7-windows -fms-extensions -verify %s + +void emit_error(unsigned int opcode) { + __emit(opcode); // expected-error {{argument to '__emit' must be a constant integer}} +} + diff --git a/test/CodeGen/builtins-arm-msvc-compat-only.c b/test/CodeGen/builtins-arm-msvc-compat-only.c new file mode 100644 index 000000000000..db82ca406652 --- /dev/null +++ b/test/CodeGen/builtins-arm-msvc-compat-only.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -triple thumbv7-windows -fms-extensions -emit-llvm -o - %s \ +// RUN: | FileCheck %s -check-prefix CHECK-MSVC +// RUN: %clang_cc1 -triple armv7-eabi -emit-llvm %s -o /dev/null 2>&1 \ +// RUN: | FileCheck %s -check-prefix CHECK-EABI +// REQUIRES: arm-registered-target + +void emit() { + __emit(0xdefe); +} + +// CHECK-MSVC: call void asm sideeffect ".inst.n 0xDEFE", ""() +// CHECK-EABI: warning: implicit declaration of function '__emit' is invalid in C99 + +void emit_truncated() { + __emit(0x11110000); // movs r0, r0 +} + +// CHECK-MSVC: call void asm sideeffect ".inst.n 0x0", ""() + diff --git a/test/CodeGen/builtins-arm.c b/test/CodeGen/builtins-arm.c index a51df15ce56b..9f3ed9ac78a1 100644 --- a/test/CodeGen/builtins-arm.c +++ b/test/CodeGen/builtins-arm.c @@ -55,6 +55,12 @@ void sevl() { // CHECK: call {{.*}} @llvm.arm.hint(i32 5) +void dbg() { + __builtin_arm_dbg(0); +} + +// CHECK: call {{.*}} @llvm.arm.dbg(i32 0) + void test_barrier() { __builtin_arm_dmb(1); //CHECK: call {{.*}} @llvm.arm.dmb(i32 1) __builtin_arm_dsb(2); //CHECK: call {{.*}} @llvm.arm.dsb(i32 2) @@ -66,3 +72,15 @@ void test_barrier() { unsigned rbit(unsigned a) { return __builtin_arm_rbit(a); } + +void prefetch(int i) { + __builtin_arm_prefetch(&i, 0, 1); +// CHECK: call {{.*}} @llvm.prefetch(i8* %{{.*}}, i32 0, i32 3, i32 1) + + __builtin_arm_prefetch(&i, 1, 1); +// CHECK: call {{.*}} @llvm.prefetch(i8* %{{.*}}, i32 1, i32 3, i32 1) + + + __builtin_arm_prefetch(&i, 1, 0); +// CHECK: call {{.*}} @llvm.prefetch(i8* %{{.*}}, i32 1, i32 3, i32 0) +} diff --git a/test/CodeGen/builtins-arm64.c b/test/CodeGen/builtins-arm64.c index cfa118122793..cc1f54732b30 100644 --- a/test/CodeGen/builtins-arm64.c +++ b/test/CodeGen/builtins-arm64.c @@ -29,3 +29,17 @@ void barriers() { __builtin_arm_dsb(2); //CHECK: call {{.*}} @llvm.aarch64.dsb(i32 2) __builtin_arm_isb(3); //CHECK: call {{.*}} @llvm.aarch64.isb(i32 3) } + +void prefetch() { + __builtin_arm_prefetch(0, 1, 2, 0, 1); // pstl3keep +// CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 1, i32 1, i32 1) + + __builtin_arm_prefetch(0, 0, 0, 1, 1); // pldl1keep +// CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 0, i32 0, i32 1) + + __builtin_arm_prefetch(0, 0, 0, 1, 1); // pldl1strm +// CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 0, i32 0, i32 1) + + __builtin_arm_prefetch(0, 0, 0, 0, 0); // plil1keep +// CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 0, i32 3, i32 0) +} diff --git a/test/CodeGen/builtins-nvptx.c b/test/CodeGen/builtins-nvptx.c index cee9061292bd..5f91f7ad3b0b 100644 --- a/test/CodeGen/builtins-nvptx.c +++ b/test/CodeGen/builtins-nvptx.c @@ -155,6 +155,8 @@ void nvvm_math(float f1, float f2, double d1, double d2) { float t3 = __nvvm_sqrt_rn_f(f1); // CHECK: call float @llvm.nvvm.rcp.rn.f float t4 = __nvvm_rcp_rn_f(f2); +// CHECK: call float @llvm.nvvm.add.rn.f + float t5 = __nvvm_add_rn_f(f1, f2); // CHECK: call double @llvm.nvvm.fmax.d double td1 = __nvvm_fmax_d(d1, d2); diff --git a/test/CodeGen/builtins-ppc-altivec.c b/test/CodeGen/builtins-ppc-altivec.c index 31491072a1d4..c6aa3c2faac2 100644 --- a/test/CodeGen/builtins-ppc-altivec.c +++ b/test/CodeGen/builtins-ppc-altivec.c @@ -1047,7 +1047,7 @@ void test6() { // CHECK-LE: @llvm.ppc.altivec.vcmpgtfp /* vec_ctf */ - res_vf = vec_ctf(vi, param_i); + res_vf = vec_ctf(vi, 0); // CHECK: @llvm.ppc.altivec.vcfsx // CHECK-LE: @llvm.ppc.altivec.vcfsx @@ -1082,7 +1082,7 @@ void test6() { // CHECK-LE: @llvm.ppc.altivec.vctuxs /* vec_dss */ - vec_dss(param_i); + vec_dss(0); // CHECK: @llvm.ppc.altivec.dss // CHECK-LE: @llvm.ppc.altivec.dss diff --git a/test/CodeGen/builtins-ppc-vsx.c b/test/CodeGen/builtins-ppc-vsx.c new file mode 100644 index 000000000000..58a8cc32dce3 --- /dev/null +++ b/test/CodeGen/builtins-ppc-vsx.c @@ -0,0 +1,116 @@ +// REQUIRES: powerpc-registered-target +// RUN: %clang_cc1 -faltivec -target-feature +vsx -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s + +vector unsigned char vuc = { 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7}; +vector float vf = { -1.5, 2.5, -3.5, 4.5 }; +vector double vd = { 3.5, -7.5 }; +vector signed int vsi = { -1, 2, -3, 4 }; +vector unsigned int vui = { 0, 1, 2, 3 }; +vector signed long long vsll = { 255LL, -937LL }; +vector unsigned long long vull = { 1447LL, 2894LL }; +double d = 23.4; + +vector float res_vf; +vector double res_vd; +vector signed int res_vsi; +vector unsigned int res_vui; +vector signed long long res_vsll; +vector unsigned long long res_vull; +double res_d; + +void test1() { +// CHECK-LABEL: define void @test1 + + /* vec_div */ + res_vf = vec_div(vf, vf); +// CHECK: @llvm.ppc.vsx.xvdivsp + + res_vd = vec_div(vd, vd); +// CHECK: @llvm.ppc.vsx.xvdivdp + + /* vec_max */ + res_vf = vec_max(vf, vf); +// CHECK: @llvm.ppc.vsx.xvmaxsp + + res_vd = vec_max(vd, vd); +// CHECK: @llvm.ppc.vsx.xvmaxdp + + res_vf = vec_vmaxfp(vf, vf); +// CHECK: @llvm.ppc.vsx.xvmaxsp + + /* vec_min */ + res_vf = vec_min(vf, vf); +// CHECK: @llvm.ppc.vsx.xvminsp + + res_vd = vec_min(vd, vd); +// CHECK: @llvm.ppc.vsx.xvmindp + + res_vf = vec_vminfp(vf, vf); +// CHECK: @llvm.ppc.vsx.xvminsp + + res_d = __builtin_vsx_xsmaxdp(d, d); +// CHECK: @llvm.ppc.vsx.xsmaxdp + + res_d = __builtin_vsx_xsmindp(d, d); +// CHECK: @llvm.ppc.vsx.xsmindp + + /* vec_perm */ + res_vsll = vec_perm(vsll, vsll, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + res_vull = vec_perm(vull, vull, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + res_vd = vec_perm(vd, vd, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + res_vsll = vec_vperm(vsll, vsll, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + res_vull = vec_vperm(vull, vull, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + res_vd = vec_vperm(vd, vd, vuc); +// CHECK: @llvm.ppc.altivec.vperm + + /* vec_vsx_ld */ + + res_vsi = vec_vsx_ld(0, &vsi); +// CHECK: @llvm.ppc.vsx.lxvw4x + + res_vui = vec_vsx_ld(0, &vui); +// CHECK: @llvm.ppc.vsx.lxvw4x + + res_vf = vec_vsx_ld (0, &vf); +// CHECK: @llvm.ppc.vsx.lxvw4x + + res_vsll = vec_vsx_ld(0, &vsll); +// CHECK: @llvm.ppc.vsx.lxvd2x + + res_vull = vec_vsx_ld(0, &vull); +// CHECK: @llvm.ppc.vsx.lxvd2x + + res_vd = vec_vsx_ld(0, &vd); +// CHECK: @llvm.ppc.vsx.lxvd2x + + /* vec_vsx_st */ + + vec_vsx_st(vsi, 0, &res_vsi); +// CHECK: @llvm.ppc.vsx.stxvw4x + + vec_vsx_st(vui, 0, &res_vui); +// CHECK: @llvm.ppc.vsx.stxvw4x + + vec_vsx_st(vf, 0, &res_vf); +// CHECK: @llvm.ppc.vsx.stxvw4x + + vec_vsx_st(vsll, 0, &res_vsll); +// CHECK: @llvm.ppc.vsx.stxvd2x + + vec_vsx_st(vull, 0, &res_vull); +// CHECK: @llvm.ppc.vsx.stxvd2x + + vec_vsx_st(vd, 0, &res_vd); +// CHECK: @llvm.ppc.vsx.stxvd2x +} diff --git a/test/CodeGen/builtins-x86.c b/test/CodeGen/builtins-x86.c index 0f038b87355c..e9ae834b3cfa 100644 --- a/test/CodeGen/builtins-x86.c +++ b/test/CodeGen/builtins-x86.c @@ -386,7 +386,7 @@ void f0() { tmp_V4f = __builtin_ia32_roundss(tmp_V4f, tmp_V4f, imm_i_0_16); tmp_V2d = __builtin_ia32_roundsd(tmp_V2d, tmp_V2d, imm_i_0_16); tmp_V2d = __builtin_ia32_roundpd(tmp_V2d, imm_i_0_16); - tmp_V4f = __builtin_ia32_insertps128(tmp_V4f, tmp_V4f, tmp_i); + tmp_V4f = __builtin_ia32_insertps128(tmp_V4f, tmp_V4f, imm_i_0_256); #endif tmp_V4d = __builtin_ia32_addsubpd256(tmp_V4d, tmp_V4d); diff --git a/test/CodeGen/builtins.c b/test/CodeGen/builtins.c index 39bd84c5a5a4..1ab29a659b31 100644 --- a/test/CodeGen/builtins.c +++ b/test/CodeGen/builtins.c @@ -171,32 +171,55 @@ void bar() { void test_float_builtins(float F, double D, long double LD) { volatile int res; res = __builtin_isinf(F); - // CHECK: call float @fabsf(float + // CHECK: call float @llvm.fabs.f32(float // CHECK: fcmp oeq float {{.*}}, 0x7FF0000000000000 res = __builtin_isinf(D); - // CHECK: call double @fabs(double + // CHECK: call double @llvm.fabs.f64(double // CHECK: fcmp oeq double {{.*}}, 0x7FF0000000000000 res = __builtin_isinf(LD); - // CHECK: call x86_fp80 @fabsl(x86_fp80 + // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 // CHECK: fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000 res = __builtin_isfinite(F); // CHECK: fcmp oeq float - // CHECK: call float @fabsf + // CHECK: call float @llvm.fabs.f32(float // CHECK: fcmp une float {{.*}}, 0x7FF0000000000000 // CHECK: and i1 res = __builtin_isnormal(F); // CHECK: fcmp oeq float - // CHECK: call float @fabsf + // CHECK: call float @llvm.fabs.f32(float // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000 // CHECK: fcmp uge float {{.*}}, 0x3810000000000000 // CHECK: and i1 // CHECK: and i1 } +// CHECK-LABEL: define void @test_float_builtin_ops +void test_float_builtin_ops(float F, double D, long double LD) { + volatile float resf; + volatile double resd; + volatile long double resld; + + resf = __builtin_fmodf(F,F); + // CHECK: frem float + + resd = __builtin_fmod(D,D); + // CHECK: frem double + + resld = __builtin_fmodl(LD,LD); + // CHECK: frem x86_fp80 + + resf = __builtin_fabsf(F); + resd = __builtin_fabs(D); + resld = __builtin_fabsl(LD); + // CHECK: call float @llvm.fabs.f32(float + // CHECK: call double @llvm.fabs.f64(double + // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 +} + // CHECK-LABEL: define void @test_builtin_longjmp void test_builtin_longjmp(void **buffer) { // CHECK: [[BITCAST:%.*]] = bitcast diff --git a/test/CodeGen/c11atomics-ios.c b/test/CodeGen/c11atomics-ios.c index ad004fa4b2f3..ad57550441b0 100644 --- a/test/CodeGen/c11atomics-ios.c +++ b/test/CodeGen/c11atomics-ios.c @@ -6,7 +6,7 @@ // This work was done in pursuit of <rdar://13338582>. -// CHECK-LABEL: define arm_aapcscc void @testFloat(float* +// CHECK-LABEL: define void @testFloat(float* void testFloat(_Atomic(float) *fp) { // CHECK: [[FP:%.*]] = alloca float* // CHECK-NEXT: [[X:%.*]] = alloca float @@ -37,7 +37,7 @@ void testFloat(_Atomic(float) *fp) { // CHECK-NEXT: ret void } -// CHECK: define arm_aapcscc void @testComplexFloat([[CF:{ float, float }]]* +// CHECK: define void @testComplexFloat([[CF:{ float, float }]]* void testComplexFloat(_Atomic(_Complex float) *fp) { // CHECK: [[FP:%.*]] = alloca [[CF]]*, align 4 // CHECK-NEXT: [[X:%.*]] = alloca [[CF]], align 8 @@ -93,7 +93,7 @@ void testComplexFloat(_Atomic(_Complex float) *fp) { } typedef struct { short x, y, z, w; } S; -// CHECK: define arm_aapcscc void @testStruct([[S:.*]]* +// CHECK: define void @testStruct([[S:.*]]* void testStruct(_Atomic(S) *fp) { // CHECK: [[FP:%.*]] = alloca [[S]]*, align 4 // CHECK-NEXT: [[X:%.*]] = alloca [[S]], align 8 @@ -143,7 +143,7 @@ void testStruct(_Atomic(S) *fp) { } typedef struct { short x, y, z; } PS; -// CHECK: define arm_aapcscc void @testPromotedStruct([[APS:.*]]* +// CHECK: define void @testPromotedStruct([[APS:.*]]* void testPromotedStruct(_Atomic(PS) *fp) { // CHECK: [[FP:%.*]] = alloca [[APS]]*, align 4 // CHECK-NEXT: [[X:%.*]] = alloca [[APS]], align 8 diff --git a/test/CodeGen/c11atomics.c b/test/CodeGen/c11atomics.c index f4c9522cbdb2..376c58267410 100644 --- a/test/CodeGen/c11atomics.c +++ b/test/CodeGen/c11atomics.c @@ -57,7 +57,7 @@ void testinc(void) // CHECK: testdec void testdec(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b b--; // CHECK: atomicrmw sub i32* @i, i32 1 seq_cst i--; @@ -65,7 +65,7 @@ void testdec(void) l--; // CHECK: atomicrmw sub i16* @s, i16 1 seq_cst s--; - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b --b; // CHECK: atomicrmw sub i32* @i, i32 1 seq_cst // CHECK: sub i32 @@ -80,7 +80,7 @@ void testdec(void) // CHECK: testaddeq void testaddeq(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b // CHECK: atomicrmw add i32* @i, i32 42 seq_cst // CHECK: atomicrmw add i64* @l, i64 42 seq_cst // CHECK: atomicrmw add i16* @s, i16 42 seq_cst @@ -92,7 +92,7 @@ void testaddeq(void) // CHECK: testsubeq void testsubeq(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b // CHECK: atomicrmw sub i32* @i, i32 42 seq_cst // CHECK: atomicrmw sub i64* @l, i64 42 seq_cst // CHECK: atomicrmw sub i16* @s, i16 42 seq_cst @@ -104,7 +104,7 @@ void testsubeq(void) // CHECK: testxoreq void testxoreq(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b // CHECK: atomicrmw xor i32* @i, i32 42 seq_cst // CHECK: atomicrmw xor i64* @l, i64 42 seq_cst // CHECK: atomicrmw xor i16* @s, i16 42 seq_cst @@ -116,7 +116,7 @@ void testxoreq(void) // CHECK: testoreq void testoreq(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b // CHECK: atomicrmw or i32* @i, i32 42 seq_cst // CHECK: atomicrmw or i64* @l, i64 42 seq_cst // CHECK: atomicrmw or i16* @s, i16 42 seq_cst @@ -128,7 +128,7 @@ void testoreq(void) // CHECK: testandeq void testandeq(void) { - // CHECK: cmpxchg i8* @b + // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 1, i8* @b // CHECK: atomicrmw and i32* @i, i32 42 seq_cst // CHECK: atomicrmw and i64* @l, i64 42 seq_cst // CHECK: atomicrmw and i16* @s, i16 42 seq_cst diff --git a/test/CodeGen/captured-statements-nested.c b/test/CodeGen/captured-statements-nested.c index 2ff9ee9cc88c..cd20b5a66462 100644 --- a/test/CodeGen/captured-statements-nested.c +++ b/test/CodeGen/captured-statements-nested.c @@ -11,9 +11,9 @@ struct A { void test_nest_captured_stmt(int param, int size, int param_arr[size]) { int w; int arr[param][size]; - // CHECK1: %struct.anon{{.*}} = type { i32*, i32*, i{{.+}}*, i32**, i32* } - // CHECK1: %struct.anon{{.*}} = type { i32*, i32*, i32**, i32*, i{{.+}}*, i32**, i32* } - // CHECK1: [[T:%struct.anon.*]] = type { i32*, i32*, %struct.A*, i32**, i32*, i{{.+}}*, i32**, i32* } + // CHECK1: %struct.anon{{.*}} = type { [[INT:i.+]]*, [[INT]]*, [[SIZE_TYPE:i.+]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* } + // CHECK1: %struct.anon{{.*}} = type { [[INT]]*, [[INT]]*, [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* } + // CHECK1: [[T:%struct.anon.*]] = type { [[INT]]*, [[INT]]*, %struct.A*, [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* } #pragma clang __debug captured { int x; @@ -31,39 +31,45 @@ void test_nest_captured_stmt(int param, int size, int param_arr[size]) { arr[10][z.a] = 12; // CHECK1: define internal void @__captured_stmt{{.*}}([[T]] + // CHECK1: [[PARAM_ARR_SIZE_REF:%.+]] = getelementptr inbounds [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 5 + // CHECK1: [[PARAM_ARR_SIZE:%.+]] = load [[SIZE_TYPE]]* [[PARAM_ARR_SIZE_REF]] + // CHECK1: [[ARR_SIZE1_REF:%.+]] = getelementptr inbounds [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8 + // CHECK1: [[ARR_SIZE1:%.+]] = load [[SIZE_TYPE]]* [[ARR_SIZE1_REF]] + // CHECK1: [[ARR_SIZE2_REF:%.+]] = getelementptr inbounds [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 9 + // CHECK1: [[ARR_SIZE2:%.+]] = load [[SIZE_TYPE]]* [[ARR_SIZE2_REF]] // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 2 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 // CHECK1-NEXT: load %struct.A** // CHECK1-NEXT: getelementptr inbounds %struct.A* // CHECK1-NEXT: store i{{.+}} 1 // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 1 - // CHECK1-NEXT: load i32** - // CHECK1-NEXT: store i32 1 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1 + // CHECK1-NEXT: load i{{[0-9]+}}** + // CHECK1-NEXT: store i{{[0-9]+}} 1 // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 0 - // CHECK1-NEXT: load i32** - // CHECK1-NEXT: store i32 1 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // CHECK1-NEXT: load i{{[0-9]+}}** + // CHECK1-NEXT: store i{{[0-9]+}} 1 // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 4 - // CHECK1-NEXT: load i32** - // CHECK1-NEXT: load i32* - // CHECK1-NEXT: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 3 - // CHECK1-NEXT: load i32*** - // CHECK1-NEXT: load i32** - // CHECK1-NEXT: store i32 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 4 + // CHECK1-NEXT: load i{{[0-9]+}}** + // CHECK1-NEXT: load i{{[0-9]+}}* + // CHECK1-NEXT: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3 + // CHECK1-NEXT: load i{{[0-9]+}}*** + // CHECK1-NEXT: load i{{[0-9]+}}** + // CHECK1-NEXT: store i{{[0-9]+}} // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 2 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 // CHECK1-NEXT: load %struct.A** // CHECK1-NEXT: getelementptr inbounds %struct.A* // CHECK1-NEXT: store float // - // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i32 0, i32 2 + // CHECK1: getelementptr inbounds [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 // CHECK1-NEXT: load %struct.A** // CHECK1-NEXT: getelementptr inbounds %struct.A* // CHECK1-NEXT: store i8 99 // - // CHECK1: [[SIZE_ADDR_REF:%.*]] = getelementptr inbounds [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 5 + // CHECK1: [[SIZE_ADDR_REF:%.*]] = getelementptr inbounds [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 7 // CHECK1-DAG: [[SIZE_ADDR:%.*]] = load i{{.+}}** [[SIZE_ADDR_REF]] // CHECK1-DAG: [[SIZE:%.*]] = load i{{.+}}* [[SIZE_ADDR]] // CHECK1-DAG: [[PARAM_ARR_IDX:%.*]] = sub nsw i{{.+}} [[SIZE]], 1 @@ -77,7 +83,7 @@ void test_nest_captured_stmt(int param, int size, int param_arr[size]) { // CHECK1-DAG: [[Z_ADDR:%.*]] = load %struct.A** [[Z_ADDR_REF]] // CHECK1-DAG: [[Z_A_ADDR:%.*]] = getelementptr inbounds %struct.A* [[Z_ADDR]], i{{.+}} 0, i{{.+}} 0 // CHECK1-DAG: [[ARR_IDX_2:%.*]] = load i{{.+}}* [[Z_A_ADDR]] - // CHECK1-DAG: [[ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 7 + // CHECK1-DAG: [[ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 10 // CHECK1-DAG: [[ARR_ADDR:%.*]] = load i{{.+}}** [[ARR_ADDR_REF]] // CHECK1-DAG: [[ARR_IDX_1:%.*]] = mul {{.*}} 10 // CHECK1-DAG: [[ARR_10_ADDR:%.*]] = getelementptr inbounds i{{.+}}* [[ARR_ADDR]], i{{.*}} [[ARR_IDX_1]] @@ -102,15 +108,15 @@ void test_nest_block() { // CHECK2: define internal void @{{.*}}test_nest_block_block_invoke // - // CHECK2: [[Z:%[0-9a-z_]*]] = alloca i32 + // CHECK2: [[Z:%[0-9a-z_]*]] = alloca i{{[0-9]+}}, // CHECK2: alloca %struct.anon{{.*}} // - // CHECK2: store i32 - // CHECK2: store i32* [[Z]] + // CHECK2: store i{{[0-9]+}} + // CHECK2: store i{{[0-9]+}}* [[Z]] // // CHECK2: getelementptr inbounds %struct.anon // CHECK2-NEXT: getelementptr inbounds - // CHECK2-NEXT: store i32* + // CHECK2-NEXT: store i{{[0-9]+}}* // // CHECK2: call void @__captured_stmt @@ -128,22 +134,22 @@ void test_nest_block() { } // CHECK2: alloca %struct.__block_byref_b - // CHECK2-NEXT: [[C:%[0-9a-z_]*]] = alloca i32 + // CHECK2-NEXT: [[C:%[0-9a-z_]*]] = alloca i{{[0-9]+}} // CHECK2-NEXT: alloca %struct.__block_byref_d // // CHECK2: bitcast %struct.__block_byref_b* // CHECK2-NEXT: store i8* // - // CHECK2: [[CapA:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i32 0, i32 7 + // CHECK2: [[CapA:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 7 // - // CHECK2: getelementptr inbounds %struct.anon{{.*}}, i32 0, i32 0 - // CHECK2: load i32** - // CHECK2: load i32* - // CHECK2: store i32 {{.*}}, i32* [[CapA]] + // CHECK2: getelementptr inbounds %struct.anon{{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // CHECK2: load i{{[0-9]+}}** + // CHECK2: load i{{[0-9]+}}* + // CHECK2: store i{{[0-9]+}} {{.*}}, i{{[0-9]+}}* [[CapA]] // - // CHECK2: [[CapC:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i32 0, i32 8 - // CHECK2-NEXT: [[Val:%[0-9a-z_]*]] = load i32* [[C]] - // CHECK2-NEXT: store i32 [[Val]], i32* [[CapC]] + // CHECK2: [[CapC:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8 + // CHECK2-NEXT: [[Val:%[0-9a-z_]*]] = load i{{[0-9]+}}* [[C]] + // CHECK2-NEXT: store i{{[0-9]+}} [[Val]], i{{[0-9]+}}* [[CapC]] // // CHECK2: bitcast %struct.__block_byref_d* // CHECK2-NEXT: store i8* diff --git a/test/CodeGen/captured-statements.c b/test/CodeGen/captured-statements.c index 85d597aeb3c3..52747fba1e90 100644 --- a/test/CodeGen/captured-statements.c +++ b/test/CodeGen/captured-statements.c @@ -4,6 +4,8 @@ // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2 // RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-3 +typedef __INTPTR_TYPE__ intptr_t; + int foo(); int global; @@ -61,15 +63,16 @@ void test3(int size) { } // Capture VLA array -void test4(int size, int vla_arr[size]) { +void test4(intptr_t size, intptr_t vla_arr[size]) { #pragma clang __debug captured { vla_arr[0] = 1; } - // CHECK-3: test4([[INT:i.+]] {{.*}}[[SIZE:%.+]], [[INT]]* - // CHECK-3: store [[INT]] {{.*}}[[SIZE]], [[INT]]* [[SIZE_ADDR:%.+]], + // CHECK-3: test4([[INTPTR_T:i.+]] {{.*}}[[SIZE_ARG:%.+]], [[INTPTR_T]]* + // CHECK-3: store [[INTPTR_T]] {{.*}}[[SIZE_ARG]], [[INTPTR_T]]* [[SIZE_ADDR:%.+]], + // CHECK-3: [[SIZE:%.+]] = load [[INTPTR_T]]* [[SIZE_ADDR]], // CHECK-3: [[REF:%.+]] = getelementptr inbounds - // CHECK-3: store [[INT]]* [[SIZE_ADDR]], [[INT]]** [[REF]] + // CHECK-3: store [[INTPTR_T]] [[SIZE]], [[INTPTR_T]]* [[REF]] // CHECK-3: call void @__captured_stmt } diff --git a/test/CodeGen/catch-undef-behavior.c b/test/CodeGen/catch-undef-behavior.c index 00962e40f665..c41b37c39bc8 100644 --- a/test/CodeGen/catch-undef-behavior.c +++ b/test/CodeGen/catch-undef-behavior.c @@ -1,61 +1,49 @@ -// RUN: %clang_cc1 -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -// RUN: %clang_cc1 -fsanitize-undefined-trap-on-error -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-TRAP -// RUN: %clang_cc1 -fsanitize=null -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-NULL +// RUN: %clang_cc1 -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-COMMON --check-prefix=CHECK-UBSAN +// RUN: %clang_cc1 -fsanitize-undefined-trap-on-error -fsanitize=alignment,null,object-size,shift,return,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -fsanitize-recover=alignment,null,object-size,shift,signed-integer-overflow,vla-bound,float-cast-overflow,integer-divide-by-zero,bool,returns-nonnull-attribute,nonnull-attribute -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-COMMON --check-prefix=CHECK-TRAP +// RUN: %clang_cc1 -fsanitize=null -fsanitize-recover=null -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-NULL // RUN: %clang_cc1 -fsanitize=signed-integer-overflow -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-OVERFLOW -// CHECK: @[[INT:.*]] = private unnamed_addr constant { i16, i16, [6 x i8] } { i16 0, i16 11, [6 x i8] c"'int'\00" } +// CHECK-UBSAN: @[[INT:.*]] = private unnamed_addr constant { i16, i16, [6 x i8] } { i16 0, i16 11, [6 x i8] c"'int'\00" } // FIXME: When we only emit each type once, use [[INT]] more below. -// CHECK: @[[LINE_100:.*]] = private unnamed_addr global {{.*}}, i32 100, i32 5 {{.*}} @[[INT]], i64 4, i8 1 -// CHECK: @[[LINE_200:.*]] = {{.*}}, i32 200, i32 10 {{.*}}, i64 4, i8 0 -// CHECK: @[[LINE_300:.*]] = {{.*}}, i32 300, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}} -// CHECK: @[[LINE_400:.*]] = {{.*}}, i32 400, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}} -// CHECK: @[[LINE_500:.*]] = {{.*}}, i32 500, i32 10 {{.*}} @{{.*}}, i64 4, i8 0 } -// CHECK: @[[LINE_600:.*]] = {{.*}}, i32 600, i32 3 {{.*}} @{{.*}}, i64 4, i8 1 } +// CHECK-UBSAN: @[[LINE_100:.*]] = private unnamed_addr global {{.*}}, i32 100, i32 5 {{.*}} @[[INT]], i64 4, i8 1 +// CHECK-UBSAN: @[[LINE_200:.*]] = {{.*}}, i32 200, i32 10 {{.*}}, i64 4, i8 0 +// CHECK-UBSAN: @[[LINE_300:.*]] = {{.*}}, i32 300, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}} +// CHECK-UBSAN: @[[LINE_400:.*]] = {{.*}}, i32 400, i32 12 {{.*}} @{{.*}}, {{.*}} @{{.*}} +// CHECK-UBSAN: @[[LINE_500:.*]] = {{.*}}, i32 500, i32 10 {{.*}} @{{.*}}, i64 4, i8 0 } +// CHECK-UBSAN: @[[LINE_600:.*]] = {{.*}}, i32 600, i32 3 {{.*}} @{{.*}}, i64 4, i8 1 } -// CHECK: @[[STRUCT_S:.*]] = private unnamed_addr constant { i16, i16, [11 x i8] } { i16 -1, i16 0, [11 x i8] c"'struct S'\00" } +// CHECK-UBSAN: @[[STRUCT_S:.*]] = private unnamed_addr constant { i16, i16, [11 x i8] } { i16 -1, i16 0, [11 x i8] c"'struct S'\00" } -// CHECK: @[[LINE_700:.*]] = {{.*}}, i32 700, i32 14 {{.*}} @[[STRUCT_S]], i64 4, i8 3 } -// CHECK: @[[LINE_800:.*]] = {{.*}}, i32 800, i32 12 {{.*}} @{{.*}} } -// CHECK: @[[LINE_900:.*]] = {{.*}}, i32 900, i32 11 {{.*}} @{{.*}} } +// CHECK-UBSAN: @[[LINE_700:.*]] = {{.*}}, i32 700, i32 14 {{.*}} @[[STRUCT_S]], i64 4, i8 3 } +// CHECK-UBSAN: @[[LINE_800:.*]] = {{.*}}, i32 800, i32 12 {{.*}} @{{.*}} } +// CHECK-UBSAN: @[[LINE_900:.*]] = {{.*}}, i32 900, i32 11 {{.*}} @{{.*}} } // CHECK-NULL: @[[LINE_100:.*]] = private unnamed_addr global {{.*}}, i32 100, i32 5 {{.*}} // PR6805 -// CHECK-LABEL: @foo +// CHECK-COMMON-LABEL: @foo // CHECK-NULL-LABEL: @foo -// CHECK-TRAP-LABEL: @foo void foo() { union { int i; } u; - // CHECK: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null - // CHECK-TRAP: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null + // CHECK-COMMON: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null - // CHECK: %[[I8PTR:.*]] = bitcast i32* %[[PTR]] to i8* - // CHECK-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false) - // CHECK-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4 - // CHECK-NEXT: %[[CHECK01:.*]] = and i1 %[[CHECK0]], %[[CHECK1]] + // CHECK-COMMON: %[[I8PTR:.*]] = bitcast i32* %[[PTR]] to i8* + // CHECK-COMMON-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false) + // CHECK-COMMON-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4 - // CHECK-TRAP: %[[I8PTR:.*]] = bitcast i32* %[[PTR]] to i8* - // CHECK-TRAP-NEXT: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* %[[I8PTR]], i1 false) - // CHECK-TRAP-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4 - // CHECK-TRAP-NEXT: %[[CHECK01:.*]] = and i1 %[[CHECK0]], %[[CHECK1]] + // CHECK-COMMON: %[[PTRTOINT:.*]] = ptrtoint {{.*}}* %[[PTR]] to i64 + // CHECK-COMMON-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRTOINT]], 3 + // CHECK-COMMON-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0 - // CHECK: %[[PTRTOINT:.*]] = ptrtoint {{.*}}* %[[PTR]] to i64 - // CHECK-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRTOINT]], 3 - // CHECK-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0 + // CHECK-COMMON: %[[CHECK01:.*]] = and i1 %[[CHECK0]], %[[CHECK1]] + // CHECK-COMMON-NEXT: %[[OK:.*]] = and i1 %[[CHECK01]], %[[CHECK2]] - // CHECK-TRAP: %[[PTRTOINT:.*]] = ptrtoint {{.*}}* %[[PTR]] to i64 - // CHECK-TRAP-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRTOINT]], 3 - // CHECK-TRAP-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0 + // CHECK-UBSAN: br i1 %[[OK]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize + // CHECK-TRAP: br i1 %[[OK]], {{.*}} - // CHECK: %[[OK:.*]] = and i1 %[[CHECK01]], %[[CHECK2]] - // CHECK-NEXT: br i1 %[[OK]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize - - // CHECK-TRAP: %[[OK:.*]] = and i1 %[[CHECK01]], %[[CHECK2]] - // CHECK-TRAP-NEXT: br i1 %[[OK]], {{.*}} - - // CHECK: %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64 - // CHECK-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]]) + // CHECK-UBSAN: %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64 + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]]) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW:#[0-9]+]] // CHECK-TRAP-NEXT: unreachable @@ -68,25 +56,17 @@ void foo() { u.i=1; } -// CHECK-LABEL: @bar -// CHECK-TRAP-LABEL: @bar +// CHECK-COMMON-LABEL: @bar int bar(int *a) { - // CHECK: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64 - // CHECK-NEXT: icmp uge i64 %[[SIZE]], 4 - - // CHECK-TRAP: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64 - // CHECK-TRAP-NEXT: icmp uge i64 %[[SIZE]], 4 + // CHECK-COMMON: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64 + // CHECK-COMMON-NEXT: icmp uge i64 %[[SIZE]], 4 - // CHECK: %[[PTRINT:.*]] = ptrtoint - // CHECK-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRINT]], 3 - // CHECK-NEXT: icmp eq i64 %[[MISALIGN]], 0 + // CHECK-COMMON: %[[PTRINT:.*]] = ptrtoint + // CHECK-COMMON-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRINT]], 3 + // CHECK-COMMON-NEXT: icmp eq i64 %[[MISALIGN]], 0 - // CHECK-TRAP: %[[PTRINT:.*]] = ptrtoint - // CHECK-TRAP-NEXT: %[[MISALIGN:.*]] = and i64 %[[PTRINT]], 3 - // CHECK-TRAP-NEXT: icmp eq i64 %[[MISALIGN]], 0 - - // CHECK: %[[ARG:.*]] = ptrtoint - // CHECK-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), i64 %[[ARG]]) + // CHECK-UBSAN: %[[ARG:.*]] = ptrtoint + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), i64 %[[ARG]]) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable @@ -95,85 +75,62 @@ int bar(int *a) { return *a; } -// CHECK-LABEL: @addr_space +// CHECK-UBSAN-LABEL: @addr_space int addr_space(int __attribute__((address_space(256))) *a) { - // CHECK-NOT: __ubsan + // CHECK-UBSAN-NOT: __ubsan return *a; } -// CHECK-LABEL: @lsh_overflow -// CHECK-TRAP-LABEL: @lsh_overflow +// CHECK-COMMON-LABEL: @lsh_overflow int lsh_overflow(int a, int b) { - // CHECK: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 - // CHECK-NEXT: br i1 %[[INBOUNDS]], label %[[CHECKBB:.*]], label %[[CONTBB:.*]] - - // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]], label %[[CHECKBB:.*]], label %[[CONTBB:.*]] + // CHECK-COMMON: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]], label %[[CHECKBB:.*]], label %[[CONTBB:.*]] - // CHECK: %[[SHIFTED_OUT_WIDTH:.*]] = sub nuw nsw i32 31, %[[RHS]] - // CHECK-NEXT: %[[SHIFTED_OUT:.*]] = lshr i32 %[[LHS:.*]], %[[SHIFTED_OUT_WIDTH]] - // CHECK-NEXT: %[[NO_OVERFLOW:.*]] = icmp eq i32 %[[SHIFTED_OUT]], 0 - // CHECK-NEXT: br label %[[CONTBB]] + // CHECK-COMMON: %[[SHIFTED_OUT_WIDTH:.*]] = sub nuw nsw i32 31, %[[RHS]] + // CHECK-COMMON-NEXT: %[[SHIFTED_OUT:.*]] = lshr i32 %[[LHS:.*]], %[[SHIFTED_OUT_WIDTH]] + // CHECK-COMMON-NEXT: %[[NO_OVERFLOW:.*]] = icmp eq i32 %[[SHIFTED_OUT]], 0 + // CHECK-COMMON-NEXT: br label %[[CONTBB]] - // CHECK-TRAP: %[[SHIFTED_OUT_WIDTH:.*]] = sub nuw nsw i32 31, %[[RHS]] - // CHECK-TRAP-NEXT: %[[SHIFTED_OUT:.*]] = lshr i32 %[[LHS:.*]], %[[SHIFTED_OUT_WIDTH]] - // CHECK-TRAP-NEXT: %[[NO_OVERFLOW:.*]] = icmp eq i32 %[[SHIFTED_OUT]], 0 - // CHECK-TRAP-NEXT: br label %[[CONTBB]] + // CHECK-COMMON: %[[VALID:.*]] = phi i1 [ %[[INBOUNDS]], {{.*}} ], [ %[[NO_OVERFLOW]], %[[CHECKBB]] ] + // CHECK-UBSAN: br i1 %[[VALID]], {{.*}} !prof ![[WEIGHT_MD]] + // CHECK-TRAP: br i1 %[[VALID]] - // CHECK: %[[VALID:.*]] = phi i1 [ %[[INBOUNDS]], {{.*}} ], [ %[[NO_OVERFLOW]], %[[CHECKBB]] ] - // CHECK-NEXT: br i1 %[[VALID]], {{.*}} !prof ![[WEIGHT_MD]] - - // CHECK-TRAP: %[[VALID:.*]] = phi i1 [ %[[INBOUNDS]], {{.*}} ], [ %[[NO_OVERFLOW]], %[[CHECKBB]] ] - // CHECK-TRAP-NEXT: br i1 %[[VALID]] - - - // CHECK: %[[ARG1:.*]] = zext - // CHECK-NEXT: %[[ARG2:.*]] = zext - // CHECK-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) - // CHECK-NOT: call void @__ubsan_handle_shift_out_of_bounds + // CHECK-UBSAN: %[[ARG1:.*]] = zext + // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) + // CHECK-UBSAN-NOT: call void @__ubsan_handle_shift_out_of_bounds // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP: unreachable // CHECK-TRAP-NOT: call void @llvm.trap() - // CHECK: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]] - // CHECK-NEXT: ret i32 %[[RET]] - - // CHECK-TRAP: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]] - // CHECK-TRAP-NEXT: ret i32 %[[RET]] + // CHECK-COMMON: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]] + // CHECK-COMMON-NEXT: ret i32 %[[RET]] #line 300 return a << b; } -// CHECK-LABEL: @rsh_inbounds -// CHECK-TRAP-LABEL: @rsh_inbounds +// CHECK-COMMON-LABEL: @rsh_inbounds int rsh_inbounds(int a, int b) { - // CHECK: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 - // CHECK: br i1 %[[INBOUNDS]] + // CHECK-COMMON: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 + // CHECK-COMMON: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i32 %[[RHS:.*]], 31 - // CHECK-TRAP: br i1 %[[INBOUNDS]] - - // CHECK: %[[ARG1:.*]] = zext - // CHECK-NEXT: %[[ARG2:.*]] = zext - // CHECK-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_400]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) + // CHECK-UBSAN: %[[ARG1:.*]] = zext + // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_400]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable - // CHECK: %[[RET:.*]] = ashr i32 %[[LHS]], %[[RHS]] - // CHECK-NEXT: ret i32 %[[RET]] - - // CHECK-TRAP: %[[RET:.*]] = ashr i32 %[[LHS]], %[[RHS]] - // CHECK-TRAP-NEXT: ret i32 %[[RET]] + // CHECK-COMMON: %[[RET:.*]] = ashr i32 %[[LHS]], %[[RHS]] + // CHECK-COMMON-NEXT: ret i32 %[[RET]] #line 400 return a >> b; } -// CHECK-LABEL: @load -// CHECK-TRAP-LABEL: @load +// CHECK-COMMON-LABEL: @load int load(int *p) { - // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_500]] to i8*), i64 %{{.*}}) + // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_500]] to i8*), i64 %{{.*}}) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable @@ -181,10 +138,9 @@ int load(int *p) { return *p; } -// CHECK-LABEL: @store -// CHECK-TRAP-LABEL: @store +// CHECK-COMMON-LABEL: @store void store(int *p, int q) { - // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_600]] to i8*), i64 %{{.*}}) + // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_600]] to i8*), i64 %{{.*}}) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable @@ -194,10 +150,9 @@ void store(int *p, int q) { struct S { int k; }; -// CHECK-LABEL: @member_access -// CHECK-TRAP-LABEL: @member_access +// CHECK-COMMON-LABEL: @member_access int *member_access(struct S *p) { - // CHECK: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_700]] to i8*), i64 %{{.*}}) + // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_700]] to i8*), i64 %{{.*}}) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable @@ -205,12 +160,11 @@ int *member_access(struct S *p) { return &p->k; } -// CHECK-LABEL: @signed_overflow -// CHECK-TRAP-LABEL: @signed_overflow +// CHECK-COMMON-LABEL: @signed_overflow int signed_overflow(int a, int b) { - // CHECK: %[[ARG1:.*]] = zext - // CHECK-NEXT: %[[ARG2:.*]] = zext - // CHECK-NEXT: call void @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_800]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) + // CHECK-UBSAN: %[[ARG1:.*]] = zext + // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_800]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]]) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable @@ -218,220 +172,213 @@ int signed_overflow(int a, int b) { return a + b; } -// CHECK-LABEL: @no_return -// CHECK-TRAP-LABEL: @no_return +// CHECK-COMMON-LABEL: @no_return int no_return() { // Reaching the end of a noreturn function is fine in C. // FIXME: If the user explicitly requests -fsanitize=return, we should catch // that here even though it's not undefined behavior. - // CHECK-NOT: call - // CHECK-NOT: unreachable - // CHECK: ret i32 - - // CHECK-TRAP-NOT: call - // CHECK-TRAP-NOT: unreachable - // CHECK-TRAP: ret i32 + // CHECK-COMMON-NOT: call + // CHECK-COMMON-NOT: unreachable + // CHECK-COMMON: ret i32 } -// CHECK-LABEL: @vla_bound +// CHECK-UBSAN-LABEL: @vla_bound void vla_bound(int n) { - // CHECK: icmp sgt i32 %[[PARAM:.*]], 0 + // CHECK-UBSAN: icmp sgt i32 %[[PARAM:.*]], 0 // - // CHECK: %[[ARG:.*]] = zext i32 %[[PARAM]] to i64 - // CHECK-NEXT: call void @__ubsan_handle_vla_bound_not_positive(i8* bitcast ({{.*}} @[[LINE_900]] to i8*), i64 %[[ARG]]) + // CHECK-UBSAN: %[[ARG:.*]] = zext i32 %[[PARAM]] to i64 + // CHECK-UBSAN-NEXT: call void @__ubsan_handle_vla_bound_not_positive(i8* bitcast ({{.*}} @[[LINE_900]] to i8*), i64 %[[ARG]]) #line 900 int arr[n * 3]; } -// CHECK-LABEL: @int_float_no_overflow +// CHECK-UBSAN-LABEL: @int_float_no_overflow float int_float_no_overflow(__int128 n) { - // CHECK-NOT: call void @__ubsan_handle + // CHECK-UBSAN-NOT: call void @__ubsan_handle return n; } -// CHECK-LABEL: @int_float_overflow -// CHECK-TRAP-LABEL: @int_float_overflow +// CHECK-COMMON-LABEL: @int_float_overflow float int_float_overflow(unsigned __int128 n) { // This is 2**104. FLT_MAX is 2**128 - 2**104. - // CHECK: icmp ule i128 %{{.*}}, -20282409603651670423947251286016 - // CHECK: call void @__ubsan_handle_float_cast_overflow( + // CHECK-COMMON: %[[INBOUNDS:.*]] = icmp ule i128 %{{.*}}, -20282409603651670423947251286016 + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[INBOUNDS:.*]] = icmp ule i128 %{{.*}}, -20282409603651670423947251286016 - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow( // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return n; } -// CHECK-LABEL: @int_fp16_overflow -// CHECK-TRAP-LABEL: @int_fp16_overflow +// CHECK-COMMON-LABEL: @int_fp16_overflow void int_fp16_overflow(int n, __fp16 *p) { - // CHECK: %[[GE:.*]] = icmp sge i32 %{{.*}}, -65504 - // CHECK: %[[LE:.*]] = icmp sle i32 %{{.*}}, 65504 - // CHECK: and i1 %[[GE]], %[[LE]] - // CHECK: call void @__ubsan_handle_float_cast_overflow( + // CHECK-COMMON: %[[GE:.*]] = icmp sge i32 %{{.*}}, -65504 + // CHECK-COMMON: %[[LE:.*]] = icmp sle i32 %{{.*}}, 65504 + // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[GE:.*]] = icmp sge i32 %{{.*}}, -65504 - // CHECK-TRAP: %[[LE:.*]] = icmp sle i32 %{{.*}}, 65504 - // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow( // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable *p = n; } -// CHECK-LABEL: @float_int_overflow -// CHECK-TRAP-LABEL: @float_int_overflow +// CHECK-COMMON-LABEL: @float_int_overflow int float_int_overflow(float f) { - // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], 0xC1E0000020000000 - // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 0x41E0000000000000 - // CHECK: and i1 %[[GE]], %[[LE]] - - // CHECK: %[[CAST:.*]] = bitcast float %[[F]] to i32 - // CHECK: %[[ARG:.*]] = zext i32 %[[CAST]] to i64 - // CHECK: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]] + // CHECK-COMMON: %[[GE:.*]] = fcmp ogt float %[[F:.*]], 0xC1E0000020000000 + // CHECK-COMMON: %[[LE:.*]] = fcmp olt float %[[F]], 0x41E0000000000000 + // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], 0xC1E0000020000000 - // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 0x41E0000000000000 - // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: %[[CAST:.*]] = bitcast float %[[F]] to i32 + // CHECK-UBSAN: %[[ARG:.*]] = zext i32 %[[CAST]] to i64 + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]] // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return f; } -// CHECK-LABEL: @long_double_int_overflow -// CHECK-TRAP-LABEL: @long_double_int_overflow +// CHECK-COMMON-LABEL: @long_double_int_overflow int long_double_int_overflow(long double ld) { - // CHECK: alloca x86_fp80 - // CHECK: %[[GE:.*]] = fcmp ogt x86_fp80 %[[F:.*]], 0xKC01E8000000100000000 - // CHECK: %[[LE:.*]] = fcmp olt x86_fp80 %[[F]], 0xK401E8000000000000000 - // CHECK: and i1 %[[GE]], %[[LE]] + // CHECK-UBSAN: alloca x86_fp80 - // CHECK: store x86_fp80 %[[F]], x86_fp80* %[[ALLOCA:.*]], !nosanitize - // CHECK: %[[ARG:.*]] = ptrtoint x86_fp80* %[[ALLOCA]] to i64 - // CHECK: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]] + // CHECK-COMMON: %[[GE:.*]] = fcmp ogt x86_fp80 %[[F:.*]], 0xKC01E800000010000000 + // CHECK-COMMON: %[[LE:.*]] = fcmp olt x86_fp80 %[[F]], 0xK401E800000000000000 + // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[GE:.*]] = fcmp ogt x86_fp80 %[[F:.*]], 0xKC01E800000010000000 - // CHECK-TRAP: %[[LE:.*]] = fcmp olt x86_fp80 %[[F]], 0xK401E800000000000000 - // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: store x86_fp80 %[[F]], x86_fp80* %[[ALLOCA:.*]], !nosanitize + // CHECK-UBSAN: %[[ARG:.*]] = ptrtoint x86_fp80* %[[ALLOCA]] to i64 + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow({{.*}}, i64 %[[ARG]] // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return ld; } -// CHECK-LABEL: @float_uint_overflow -// CHECK-TRAP-LABEL: @float_uint_overflow +// CHECK-COMMON-LABEL: @float_uint_overflow unsigned float_uint_overflow(float f) { - // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.{{0*}}e+00 - // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 0x41F0000000000000 - // CHECK: and i1 %[[GE]], %[[LE]] - // CHECK: call void @__ubsan_handle_float_cast_overflow( + // CHECK-COMMON: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.{{0*}}e+00 + // CHECK-COMMON: %[[LE:.*]] = fcmp olt float %[[F]], 0x41F0000000000000 + // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.{{0*}}e+00 - // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 0x41F0000000000000 - // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow( // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return f; } -// CHECK-LABEL: @fp16_char_overflow -// CHECK-TRAP-LABEL: @fp16_char_overflow +// CHECK-COMMON-LABEL: @fp16_char_overflow signed char fp16_char_overflow(__fp16 *p) { - // CHECK: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.29{{0*}}e+02 - // CHECK: %[[LE:.*]] = fcmp olt float %[[F]], 1.28{{0*}}e+02 - // CHECK: and i1 %[[GE]], %[[LE]] - // CHECK: call void @__ubsan_handle_float_cast_overflow( + // CHECK-COMMON: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.29{{0*}}e+02 + // CHECK-COMMON: %[[LE:.*]] = fcmp olt float %[[F]], 1.28{{0*}}e+02 + // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] - // CHECK-TRAP: %[[GE:.*]] = fcmp ogt float %[[F:.*]], -1.29{{0*}}e+02 - // CHECK-TRAP: %[[LE:.*]] = fcmp olt float %[[F]], 1.28{{0*}}e+02 - // CHECK-TRAP: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow( // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return *p; } -// CHECK-LABEL: @float_float_overflow -// CHECK-TRAP-LABEL: @float_float_overflow +// CHECK-COMMON-LABEL: @float_float_overflow float float_float_overflow(double f) { - // CHECK: %[[F:.*]] = call double @llvm.fabs.f64( - // CHECK: %[[GE:.*]] = fcmp ogt double %[[F]], 0x47EFFFFFE0000000 - // CHECK: %[[LE:.*]] = fcmp olt double %[[F]], 0x7FF0000000000000 - // CHECK: and i1 %[[GE]], %[[LE]] - // CHECK: call void @__ubsan_handle_float_cast_overflow( - - // CHECK-TRAP: %[[F:.*]] = call double @llvm.fabs.f64( - // CHECK-TRAP: %[[GE:.*]] = fcmp ogt double %[[F]], 0x47EFFFFFE0000000 - // CHECK-TRAP: %[[LE:.*]] = fcmp olt double %[[F]], 0x7FF0000000000000 - // CHECK-TRAP: %[[OUTOFBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] - // CHECK-TRAP: %[[INBOUNDS:.*]] = xor i1 %[[OUTOFBOUNDS]], true - // CHECK-TRAP-NEXT: br i1 %[[INBOUNDS]] + // CHECK-COMMON: %[[F:.*]] = call double @llvm.fabs.f64( + // CHECK-COMMON: %[[GE:.*]] = fcmp ogt double %[[F]], 0x47EFFFFFE0000000 + // CHECK-COMMON: %[[LE:.*]] = fcmp olt double %[[F]], 0x7FF0000000000000 + // CHECK-COMMON: %[[OUTOFBOUNDS:.*]] = and i1 %[[GE]], %[[LE]] + // CHECK-COMMON: %[[INBOUNDS:.*]] = xor i1 %[[OUTOFBOUNDS]], true + // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]] + + // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow( // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP-NEXT: unreachable return f; } -// CHECK-LABEL: @int_divide_overflow +// CHECK-COMMON-LABEL: @int_divide_overflow // CHECK-OVERFLOW-LABEL: @int_divide_overflow int int_divide_overflow(int a, int b) { - // CHECK: %[[ZERO:.*]] = icmp ne i32 %[[B:.*]], 0 + // CHECK-COMMON: %[[ZERO:.*]] = icmp ne i32 %[[B:.*]], 0 // CHECK-OVERFLOW-NOT: icmp ne i32 %{{.*}}, 0 - // CHECK-TRAP: %[[ZERO:.*]] = icmp ne i32 %[[B:.*]], 0 - // CHECK: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648 - // CHECK-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B]], -1 - // CHECK-NEXT: %[[OVER:.*]] = or i1 %[[AOK]], %[[BOK]] + // CHECK-COMMON: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648 + // CHECK-COMMON-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B]], -1 + // CHECK-COMMON-NEXT: %[[OVER:.*]] = or i1 %[[AOK]], %[[BOK]] + // CHECK-COMMON: %[[OK:.*]] = and i1 %[[ZERO]], %[[OVER]] + // CHECK-COMMON: br i1 %[[OK]] // CHECK-OVERFLOW: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648 // CHECK-OVERFLOW-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B:.*]], -1 // CHECK-OVERFLOW-NEXT: %[[OK:.*]] = or i1 %[[AOK]], %[[BOK]] - - // CHECK-TRAP: %[[AOK:.*]] = icmp ne i32 %[[A:.*]], -2147483648 - // CHECK-TRAP-NEXT: %[[BOK:.*]] = icmp ne i32 %[[B]], -1 - // CHECK-TRAP-NEXT: %[[OVER:.*]] = or i1 %[[AOK]], %[[BOK]] - - // CHECK: %[[OK:.*]] = and i1 %[[ZERO]], %[[OVER]] - - // CHECK: br i1 %[[OK]] // CHECK-OVERFLOW: br i1 %[[OK]] - // CHECK-TRAP: %[[OK:.*]] = and i1 %[[ZERO]], %[[OVER]] - // CHECK-TRAP: br i1 %[[OK]] - // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP: unreachable return a / b; - // CHECK: } + // CHECK-COMMON: } // CHECK-OVERFLOW: } - // CHECK-TRAP: } } -// CHECK-LABEL: @sour_bool +// CHECK-COMMON-LABEL: @sour_bool _Bool sour_bool(_Bool *p) { - // CHECK: %[[OK:.*]] = icmp ule i8 {{.*}}, 1 - // CHECK: br i1 %[[OK]] - // CHECK: call void @__ubsan_handle_load_invalid_value(i8* bitcast ({{.*}}), i64 {{.*}}) + // CHECK-COMMON: %[[OK:.*]] = icmp ule i8 {{.*}}, 1 + // CHECK-COMMON: br i1 %[[OK]] - // CHECK-TRAP: %[[OK:.*]] = icmp ule i8 {{.*}}, 1 - // CHECK-TRAP: br i1 %[[OK]] + // CHECK-UBSAN: call void @__ubsan_handle_load_invalid_value(i8* bitcast ({{.*}}), i64 {{.*}}) // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] // CHECK-TRAP: unreachable return *p; } -// CHECK: ![[WEIGHT_MD]] = metadata !{metadata !"branch_weights", i32 1048575, i32 1} +// CHECK-COMMON-LABEL: @ret_nonnull +__attribute__((returns_nonnull)) +int *ret_nonnull(int *a) { + // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null + // CHECK-COMMON: br i1 [[OK]] + + // CHECK-UBSAN: call void @__ubsan_handle_nonnull_return + + // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] + // CHECK-TRAP: unreachable + return a; +} + +// CHECK-COMMON-LABEL: @call_decl_nonnull +__attribute__((nonnull)) void decl_nonnull(int *a); +void call_decl_nonnull(int *a) { + // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null + // CHECK-COMMON: br i1 [[OK]] + + // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg + + // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]] + // CHECK-TRAP: unreachable + decl_nonnull(a); +} + +// CHECK-COMMON-LABEL: @call_nonnull_variadic +__attribute__((nonnull)) void nonnull_variadic(int a, ...); +void call_nonnull_variadic(int a, int *b) { + // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null + // CHECK-COMMON: br i1 [[OK]] + + // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg + // CHECK-UBSAN-NOT: __ubsan_handle_nonnull_arg + + // CHECK-COMMON: call void (i32, ...)* @nonnull_variadic + nonnull_variadic(a, b); +} + +// CHECK-UBSAN: ![[WEIGHT_MD]] = !{!"branch_weights", i32 1048575, i32 1} // CHECK-TRAP: attributes [[NR_NUW]] = { noreturn nounwind } diff --git a/test/CodeGen/complex-math.c b/test/CodeGen/complex-math.c new file mode 100644 index 000000000000..36ef271b0ae0 --- /dev/null +++ b/test/CodeGen/complex-math.c @@ -0,0 +1,481 @@ +// RUN: %clang_cc1 %s -O1 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86 +// RUN: %clang_cc1 %s -O1 -emit-llvm -triple x86_64-pc-win64 -o - | FileCheck %s --check-prefix=X86 +// RUN: %clang_cc1 %s -O1 -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s --check-prefix=X86 +// RUN: %clang_cc1 %s -O1 -emit-llvm -triple powerpc-unknown-unknown -o - | FileCheck %s --check-prefix=PPC +// RUN: %clang_cc1 %s -O1 -emit-llvm -triple armv7-none-linux-gnueabihf -o - | FileCheck %s --check-prefix=ARM + +float _Complex add_float_rr(float a, float b) { + // X86-LABEL: @add_float_rr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +float _Complex add_float_cr(float _Complex a, float b) { + // X86-LABEL: @add_float_cr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +float _Complex add_float_rc(float a, float _Complex b) { + // X86-LABEL: @add_float_rc( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +float _Complex add_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @add_float_cc( + // X86: fadd + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} + +float _Complex sub_float_rr(float a, float b) { + // X86-LABEL: @sub_float_rr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +float _Complex sub_float_cr(float _Complex a, float b) { + // X86-LABEL: @sub_float_cr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +float _Complex sub_float_rc(float a, float _Complex b) { + // X86-LABEL: @sub_float_rc( + // X86: fsub + // X86: fsub float -0.{{0+}}e+00, + // X86-NOT: fsub + // X86: ret + return a - b; +} +float _Complex sub_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @sub_float_cc( + // X86: fsub + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} + +float _Complex mul_float_rr(float a, float b) { + // X86-LABEL: @mul_float_rr( + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +float _Complex mul_float_cr(float _Complex a, float b) { + // X86-LABEL: @mul_float_cr( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +float _Complex mul_float_rc(float a, float _Complex b) { + // X86-LABEL: @mul_float_rc( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +float _Complex mul_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @mul_float_cc( + // X86: %[[AC:[^ ]+]] = fmul + // X86: %[[BD:[^ ]+]] = fmul + // X86: %[[AD:[^ ]+]] = fmul + // X86: %[[BC:[^ ]+]] = fmul + // X86: %[[RR:[^ ]+]] = fsub float %[[AC]], %[[BD]] + // X86: %[[RI:[^ ]+]] = fadd float + // X86-DAG: %[[AD]] + // X86-DAG: , + // X86-DAG: %[[BC]] + // X86: fcmp uno float %[[RR]] + // X86: fcmp uno float %[[RI]] + // X86: call {{.*}} @__mulsc3( + // X86: ret + return a * b; +} + +float _Complex div_float_rr(float a, float b) { + // X86-LABEL: @div_float_rr( + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +float _Complex div_float_cr(float _Complex a, float b) { + // X86-LABEL: @div_float_cr( + // X86: fdiv + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +float _Complex div_float_rc(float a, float _Complex b) { + // X86-LABEL: @div_float_rc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divsc3( + // X86: ret + return a / b; +} +float _Complex div_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @div_float_cc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divsc3( + // X86: ret + return a / b; +} + +double _Complex add_double_rr(double a, double b) { + // X86-LABEL: @add_double_rr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +double _Complex add_double_cr(double _Complex a, double b) { + // X86-LABEL: @add_double_cr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +double _Complex add_double_rc(double a, double _Complex b) { + // X86-LABEL: @add_double_rc( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +double _Complex add_double_cc(double _Complex a, double _Complex b) { + // X86-LABEL: @add_double_cc( + // X86: fadd + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} + +double _Complex sub_double_rr(double a, double b) { + // X86-LABEL: @sub_double_rr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +double _Complex sub_double_cr(double _Complex a, double b) { + // X86-LABEL: @sub_double_cr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +double _Complex sub_double_rc(double a, double _Complex b) { + // X86-LABEL: @sub_double_rc( + // X86: fsub + // X86: fsub double -0.{{0+}}e+00, + // X86-NOT: fsub + // X86: ret + return a - b; +} +double _Complex sub_double_cc(double _Complex a, double _Complex b) { + // X86-LABEL: @sub_double_cc( + // X86: fsub + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} + +double _Complex mul_double_rr(double a, double b) { + // X86-LABEL: @mul_double_rr( + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +double _Complex mul_double_cr(double _Complex a, double b) { + // X86-LABEL: @mul_double_cr( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +double _Complex mul_double_rc(double a, double _Complex b) { + // X86-LABEL: @mul_double_rc( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +double _Complex mul_double_cc(double _Complex a, double _Complex b) { + // X86-LABEL: @mul_double_cc( + // X86: %[[AC:[^ ]+]] = fmul + // X86: %[[BD:[^ ]+]] = fmul + // X86: %[[AD:[^ ]+]] = fmul + // X86: %[[BC:[^ ]+]] = fmul + // X86: %[[RR:[^ ]+]] = fsub double %[[AC]], %[[BD]] + // X86: %[[RI:[^ ]+]] = fadd double + // X86-DAG: %[[AD]] + // X86-DAG: , + // X86-DAG: %[[BC]] + // X86: fcmp uno double %[[RR]] + // X86: fcmp uno double %[[RI]] + // X86: call {{.*}} @__muldc3( + // X86: ret + return a * b; +} + +double _Complex div_double_rr(double a, double b) { + // X86-LABEL: @div_double_rr( + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +double _Complex div_double_cr(double _Complex a, double b) { + // X86-LABEL: @div_double_cr( + // X86: fdiv + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +double _Complex div_double_rc(double a, double _Complex b) { + // X86-LABEL: @div_double_rc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divdc3( + // X86: ret + return a / b; +} +double _Complex div_double_cc(double _Complex a, double _Complex b) { + // X86-LABEL: @div_double_cc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divdc3( + // X86: ret + return a / b; +} + +long double _Complex add_long_double_rr(long double a, long double b) { + // X86-LABEL: @add_long_double_rr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +long double _Complex add_long_double_cr(long double _Complex a, long double b) { + // X86-LABEL: @add_long_double_cr( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +long double _Complex add_long_double_rc(long double a, long double _Complex b) { + // X86-LABEL: @add_long_double_rc( + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} +long double _Complex add_long_double_cc(long double _Complex a, long double _Complex b) { + // X86-LABEL: @add_long_double_cc( + // X86: fadd + // X86: fadd + // X86-NOT: fadd + // X86: ret + return a + b; +} + +long double _Complex sub_long_double_rr(long double a, long double b) { + // X86-LABEL: @sub_long_double_rr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +long double _Complex sub_long_double_cr(long double _Complex a, long double b) { + // X86-LABEL: @sub_long_double_cr( + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} +long double _Complex sub_long_double_rc(long double a, long double _Complex b) { + // X86-LABEL: @sub_long_double_rc( + // X86: fsub + // X86: fsub x86_fp80 0xK8{{0+}}, + // X86-NOT: fsub + // X86: ret + return a - b; +} +long double _Complex sub_long_double_cc(long double _Complex a, long double _Complex b) { + // X86-LABEL: @sub_long_double_cc( + // X86: fsub + // X86: fsub + // X86-NOT: fsub + // X86: ret + return a - b; +} + +long double _Complex mul_long_double_rr(long double a, long double b) { + // X86-LABEL: @mul_long_double_rr( + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +long double _Complex mul_long_double_cr(long double _Complex a, long double b) { + // X86-LABEL: @mul_long_double_cr( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +long double _Complex mul_long_double_rc(long double a, long double _Complex b) { + // X86-LABEL: @mul_long_double_rc( + // X86: fmul + // X86: fmul + // X86-NOT: fmul + // X86: ret + return a * b; +} +long double _Complex mul_long_double_cc(long double _Complex a, long double _Complex b) { + // X86-LABEL: @mul_long_double_cc( + // X86: %[[AC:[^ ]+]] = fmul + // X86: %[[BD:[^ ]+]] = fmul + // X86: %[[AD:[^ ]+]] = fmul + // X86: %[[BC:[^ ]+]] = fmul + // X86: %[[RR:[^ ]+]] = fsub x86_fp80 %[[AC]], %[[BD]] + // X86: %[[RI:[^ ]+]] = fadd x86_fp80 + // X86-DAG: %[[AD]] + // X86-DAG: , + // X86-DAG: %[[BC]] + // X86: fcmp uno x86_fp80 %[[RR]] + // X86: fcmp uno x86_fp80 %[[RI]] + // X86: call {{.*}} @__mulxc3( + // X86: ret + // PPC-LABEL: @mul_long_double_cc( + // PPC: %[[AC:[^ ]+]] = fmul + // PPC: %[[BD:[^ ]+]] = fmul + // PPC: %[[AD:[^ ]+]] = fmul + // PPC: %[[BC:[^ ]+]] = fmul + // PPC: %[[RR:[^ ]+]] = fsub ppc_fp128 %[[AC]], %[[BD]] + // PPC: %[[RI:[^ ]+]] = fadd ppc_fp128 + // PPC-DAG: %[[AD]] + // PPC-DAG: , + // PPC-DAG: %[[BC]] + // PPC: fcmp uno ppc_fp128 %[[RR]] + // PPC: fcmp uno ppc_fp128 %[[RI]] + // PPC: call {{.*}} @__multc3( + // PPC: ret + return a * b; +} + +long double _Complex div_long_double_rr(long double a, long double b) { + // X86-LABEL: @div_long_double_rr( + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +long double _Complex div_long_double_cr(long double _Complex a, long double b) { + // X86-LABEL: @div_long_double_cr( + // X86: fdiv + // X86: fdiv + // X86-NOT: fdiv + // X86: ret + return a / b; +} +long double _Complex div_long_double_rc(long double a, long double _Complex b) { + // X86-LABEL: @div_long_double_rc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divxc3( + // X86: ret + // PPC-LABEL: @div_long_double_rc( + // PPC-NOT: fdiv + // PPC: call {{.*}} @__divtc3( + // PPC: ret + return a / b; +} +long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) { + // X86-LABEL: @div_long_double_cc( + // X86-NOT: fdiv + // X86: call {{.*}} @__divxc3( + // X86: ret + // PPC-LABEL: @div_long_double_cc( + // PPC-NOT: fdiv + // PPC: call {{.*}} @__divtc3( + // PPC: ret + return a / b; +} + +// Comparison operators don't rely on library calls or have interseting math +// properties, but test that mixed types work correctly here. +_Bool eq_float_cr(float _Complex a, float b) { + // X86-LABEL: @eq_float_cr( + // X86: fcmp oeq + // X86: fcmp oeq + // X86: and i1 + // X86: ret + return a == b; +} +_Bool eq_float_rc(float a, float _Complex b) { + // X86-LABEL: @eq_float_rc( + // X86: fcmp oeq + // X86: fcmp oeq + // X86: and i1 + // X86: ret + return a == b; +} +_Bool eq_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @eq_float_cc( + // X86: fcmp oeq + // X86: fcmp oeq + // X86: and i1 + // X86: ret + return a == b; +} +_Bool ne_float_cr(float _Complex a, float b) { + // X86-LABEL: @ne_float_cr( + // X86: fcmp une + // X86: fcmp une + // X86: or i1 + // X86: ret + return a != b; +} +_Bool ne_float_rc(float a, float _Complex b) { + // X86-LABEL: @ne_float_rc( + // X86: fcmp une + // X86: fcmp une + // X86: or i1 + // X86: ret + return a != b; +} +_Bool ne_float_cc(float _Complex a, float _Complex b) { + // X86-LABEL: @ne_float_cc( + // X86: fcmp une + // X86: fcmp une + // X86: or i1 + // X86: ret + return a != b; +} + +// Check that the libcall will obtain proper calling convention on ARM +_Complex double foo(_Complex double a, _Complex double b) { + // ARM-LABEL: @foo( + // ARM: call arm_aapcscc { double, double } @__muldc3 + return a*b; +} diff --git a/test/CodeGen/complex.c b/test/CodeGen/complex.c index 206db253caa4..1c0e7cb2ee95 100644 --- a/test/CodeGen/complex.c +++ b/test/CodeGen/complex.c @@ -98,3 +98,19 @@ void t8() { const _Complex double test9const = 0; _Complex double test9func() { return test9const; } + +// D6217 +void t91() { + // Check for proper type promotion of conditional expression + char c[(int)(sizeof(typeof((0 ? 2.0f : (_Complex double) 2.0f))) - sizeof(_Complex double))]; + // Check for proper codegen + (0 ? 2.0f : (_Complex double) 2.0f); +} + +void t92() { + // Check for proper type promotion of conditional expression + char c[(int)(sizeof(typeof((0 ? (_Complex double) 2.0f : 2.0f))) - sizeof(_Complex double))]; + // Check for proper codegen + (0 ? (_Complex double) 2.0f : 2.0f); +} + diff --git a/test/CodeGen/compound-assign-overflow.c b/test/CodeGen/compound-assign-overflow.c index 15334294d47e..f126bb05d53c 100644 --- a/test/CodeGen/compound-assign-overflow.c +++ b/test/CodeGen/compound-assign-overflow.c @@ -1,5 +1,5 @@ // Verify proper type emitted for compound assignments -// RUN: %clang_cc1 -ffreestanding -triple x86_64-apple-darwin10 -emit-llvm -o - %s -fsanitize=signed-integer-overflow,unsigned-integer-overflow | FileCheck %s +// RUN: %clang_cc1 -ffreestanding -triple x86_64-apple-darwin10 -emit-llvm -o - %s -fsanitize=signed-integer-overflow,unsigned-integer-overflow -fsanitize-recover=signed-integer-overflow,unsigned-integer-overflow | FileCheck %s #include <stdint.h> diff --git a/test/CodeGen/const-init.c b/test/CodeGen/const-init.c index 7d7ccae370dd..b86274fc8242 100644 --- a/test/CodeGen/const-init.c +++ b/test/CodeGen/const-init.c @@ -159,3 +159,25 @@ void g29() { static int b[1] = { "asdf" }; // expected-warning {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [5]'}} static int c[1] = { L"a" }; } + +// PR21300 +void g30() { +#pragma pack(1) + static struct { + int : 1; + int x; + } a = {}; + // CHECK: @g30.a = internal global %struct.anon.1 <{ i8 undef, i32 0 }>, align 1 +#pragma pack() +} + +void g31() { +#pragma pack(4) + static struct { + short a; + long x; + short z; + } a = {23122, -12312731, -312}; +#pragma pack() + // CHECK: @g31.a = internal global %struct.anon.2 { i16 23122, i32 -12312731, i16 -312 }, align 4 +} diff --git a/test/CodeGen/debug-info-args.c b/test/CodeGen/debug-info-args.c index 50b85411adb9..33cf5bcbd06c 100644 --- a/test/CodeGen/debug-info-args.c +++ b/test/CodeGen/debug-info-args.c @@ -2,8 +2,8 @@ int somefunc(char *x, int y, double z) { - // CHECK: metadata ![[NUM:[^,]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type - // CHECK: ![[NUM]] = {{metadata !{metadata ![^,]*, metadata ![^,]*, metadata ![^,]*, metadata ![^,]*}}} + // CHECK: ![[NUM:[^,]*]], null, null, null} ; [ DW_TAG_subroutine_type + // CHECK: ![[NUM]] = {{!{![^,]*, ![^,]*, ![^,]*, ![^,]*}}} return y; } diff --git a/test/CodeGen/debug-info-block-decl.c b/test/CodeGen/debug-info-block-decl.c index 06c0e1ad3192..f3f5e6bd0a91 100644 --- a/test/CodeGen/debug-info-block-decl.c +++ b/test/CodeGen/debug-info-block-decl.c @@ -9,8 +9,8 @@ int main() { -// CHECK: [[ASSIGNMENT]] = metadata !{i32 [[@LINE+2]], -// CHECK: [[BLOCK_ENTRY]] = metadata !{i32 [[@LINE+1]], +// CHECK: [[ASSIGNMENT]] = !MDLocation(line: [[@LINE+2]], +// CHECK: [[BLOCK_ENTRY]] = !MDLocation(line: [[@LINE+1]], int (^blockptr)(void) = ^(void) { return 0; }; diff --git a/test/CodeGen/debug-info-block-out-return.c b/test/CodeGen/debug-info-block-out-return.c new file mode 100644 index 000000000000..47b90ce6882a --- /dev/null +++ b/test/CodeGen/debug-info-block-out-return.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -fblocks -emit-llvm -o - %s | FileCheck %s + +// Check that arg numbering is not affected by LLVM IR argument numbering - +// since the latter is affected by return-by-out-parameter ABI requirements + +// 1 for the argument number (1 indexed), 2 for the line number +// 16777218 == 1 << 24 | 2 +// 33554434 == 2 << 24 | 2 +// This explains the two magic numbers below, testing that these two arguments +// are numbered correctly. If they are not numbered correctly they may appear +// out of order or not at all (the latter would occur if they were both assigned +// the same argument number by mistake). + +// CHECK: !"0x101\00.block_descriptor\0016777218\00{{[0-9]+}}", {{.*}} ; [ DW_TAG_arg_variable ] [.block_descriptor] +// CHECK: !"0x101\00param\0033554434\00{{[0-9]+}}", {{.*}} ; [ DW_TAG_arg_variable ] [param] + +// Line directive so we don't have to worry about how many lines preceed the +// test code (as the line number is mangled in with the argument number as shown +// above) +#line 1 +typedef struct { int array[12]; } BigStruct_t; +BigStruct_t (^a)() = ^(int param) { + BigStruct_t b; + return b; +}; diff --git a/test/CodeGen/debug-info-enum.c b/test/CodeGen/debug-info-enum.c index acf3f524088b..1f6b384d8527 100644 --- a/test/CodeGen/debug-info-enum.c +++ b/test/CodeGen/debug-info-enum.c @@ -1,8 +1,8 @@ // RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s -// CHECK: metadata [[TEST3_ENUMS:![0-9]*]], {{[^,]*}}, null, null, null} ; [ DW_TAG_enumeration_type ] [e] -// CHECK: [[TEST3_ENUMS]] = metadata !{metadata [[TEST3_E:![0-9]*]]} -// CHECK: [[TEST3_E]] = {{.*}}, metadata !"E", i64 -1} ; [ DW_TAG_enumerator ] [E :: -1] +// CHECK: [[TEST3_ENUMS:![0-9]*]], null, null, null} ; [ DW_TAG_enumeration_type ] [e] +// CHECK: [[TEST3_ENUMS]] = !{[[TEST3_E:![0-9]*]]} +// CHECK: [[TEST3_E]] = !{!"0x28\00E\00-1"} ; [ DW_TAG_enumerator ] [E :: -1] enum e; void func(enum e *p) { diff --git a/test/CodeGen/debug-info-line3.c b/test/CodeGen/debug-info-line3.c index d01b023b82d3..d2efcf724094 100644 --- a/test/CodeGen/debug-info-line3.c +++ b/test/CodeGen/debug-info-line3.c @@ -13,4 +13,4 @@ void func(char c, char* d) } // CHECK: ret void, !dbg [[LINE:.*]] -// CHECK: [[LINE]] = metadata !{i32 6, +// CHECK: [[LINE]] = !MDLocation(line: 6, diff --git a/test/CodeGen/debug-info-line4.c b/test/CodeGen/debug-info-line4.c index 004176c7a507..2b3e0fe5bc65 100644 --- a/test/CodeGen/debug-info-line4.c +++ b/test/CodeGen/debug-info-line4.c @@ -8,4 +8,4 @@ int foo(int a, int b) { int c = a + b; } // Without column information we wouldn't change locations for b. -// CHECK: metadata !{i32 4, i32 20, +// CHECK: !MDLocation(line: 4, column: 20, diff --git a/test/CodeGen/debug-info-scope-file.c b/test/CodeGen/debug-info-scope-file.c index 3479ade7a329..226fb27021eb 100644 --- a/test/CodeGen/debug-info-scope-file.c +++ b/test/CodeGen/debug-info-scope-file.c @@ -7,8 +7,8 @@ // CHECK: ret void, !dbg [[F2_LINE:![0-9]*]] // CHECK: [[F1:![0-9]*]] = {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [f1] // CHECK: [[F2:![0-9]*]] = {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [f2] -// CHECK: [[F1_LINE]] = {{.*}}, metadata [[F1]], null} -// CHECK: [[F2_LINE]] = {{.*}}, metadata [[F2]], null} +// CHECK: [[F1_LINE]] = !MDLocation({{.*}}, scope: [[F1]]) +// CHECK: [[F2_LINE]] = !MDLocation({{.*}}, scope: [[F2]]) void f1() { } diff --git a/test/CodeGen/debug-info-scope.c b/test/CodeGen/debug-info-scope.c index 9decaeafd50e..d84fafd018d2 100644 --- a/test/CodeGen/debug-info-scope.c +++ b/test/CodeGen/debug-info-scope.c @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -g -emit-llvm < %s | FileCheck %s +// RUN: %clang_cc1 -gline-tables-only -emit-llvm < %s | FileCheck --check-prefix=GMLT %s // Two variables with same name in separate scope. // Radar 8330217. int main() { @@ -6,10 +7,21 @@ int main() { int k = 0; // CHECK: DW_TAG_auto_variable ] [i] // CHECK-NEXT: DW_TAG_lexical_block + +// FIXME: Looks like we don't actually need both these lexical blocks (disc 2 +// just refers to disc 1, nothing actually uses disc 2). +// GMLT-NOT: DW_TAG_lexical_block +// GMLT: "0xb\002", {{.*}}} ; [ DW_TAG_lexical_block ] +// GMLT-NOT: DW_TAG_lexical_block +// GMLT: "0xb\001", {{.*}}} ; [ DW_TAG_lexical_block ] +// Make sure we don't have any more lexical blocks because we don't need them in +// -gmlt. +// GMLT-NOT: DW_TAG_lexical_block for (int i = 0; i < 10; i++) j++; // CHECK: DW_TAG_auto_variable ] [i] // CHECK-NEXT: DW_TAG_lexical_block +// GMLT-NOT: DW_TAG_lexical_block for (int i = 0; i < 10; i++) k++; return 0; diff --git a/test/CodeGen/debug-info-typedef.c b/test/CodeGen/debug-info-typedef.c index 51ebcc4d8749..3db7d537890b 100644 --- a/test/CodeGen/debug-info-typedef.c +++ b/test/CodeGen/debug-info-typedef.c @@ -7,5 +7,5 @@ typedef int MyType; MyType a; -// CHECK: metadata ![[HEADER:[0-9]+]], null, metadata !"MyType"{{.*}} ; [ DW_TAG_typedef ] [MyType] [line 2, size 0, align 0, offset 0] [from int] -// CHECK: ![[HEADER]] = metadata !{metadata !"b.h", +// CHECK: !"0x16\00MyType\002\00{{.*}}", ![[HEADER:[0-9]+]], null{{.*}}} ; [ DW_TAG_typedef ] [MyType] [line 2, size 0, align 0, offset 0] [from int] +// CHECK: ![[HEADER]] = !{!"b.h", diff --git a/test/CodeGen/debug-info-version.c b/test/CodeGen/debug-info-version.c index 325345f0b26e..5fe2e4eb570b 100644 --- a/test/CodeGen/debug-info-version.c +++ b/test/CodeGen/debug-info-version.c @@ -4,5 +4,5 @@ int main (void) { return 0; } -// CHECK: metadata !{i32 2, metadata !"Debug Info Version", i32 1} -// NO_DEBUG-NOT: metadata !"Debug Info Version" +// CHECK: i32 2, !"Debug Info Version", i32 2} +// NO_DEBUG-NOT: !"Debug Info Version" diff --git a/test/CodeGen/debug-info-vla.c b/test/CodeGen/debug-info-vla.c index 7a8da960db47..ac45dd0a7643 100644 --- a/test/CodeGen/debug-info-vla.c +++ b/test/CodeGen/debug-info-vla.c @@ -2,7 +2,7 @@ void testVLAwithSize(int s) { -// CHECK: metadata !{i32 {{.*}}, metadata {{.*}}, metadata !"vla", metadata {{.*}}, i32 [[@LINE+1]], metadata {{.*}}, i32 8192, i32 0} ; [ DW_TAG_auto_variable ] [vla] [line [[@LINE+1]]] +// CHECK: !"0x100\00vla\00[[@LINE+1]]\008192", {{.*}}, {{.*}}, {{.*}}} ; [ DW_TAG_auto_variable ] [vla] [line [[@LINE+1]]] int vla[s]; int i; for (i = 0; i < s; i++) { diff --git a/test/CodeGen/debug-info.c b/test/CodeGen/debug-info.c index 12ba6058d39e..bf08c589809c 100644 --- a/test/CodeGen/debug-info.c +++ b/test/CodeGen/debug-info.c @@ -42,7 +42,7 @@ struct foo2 foo2; // Radar 7325611 -// CHECK: "barfoo" +// CHECK: !"0x16\00barfoo\00{{.*}}" typedef int barfoo; barfoo foo() { } diff --git a/test/CodeGen/dependent-lib.c b/test/CodeGen/dependent-lib.c index 20913d33f5be..b3abc2f5bc41 100644 --- a/test/CodeGen/dependent-lib.c +++ b/test/CodeGen/dependent-lib.c @@ -3,13 +3,13 @@ // RUN: %clang_cc1 %s --dependent-lib=msvcrt -triple i686-pc-linux -emit-llvm -o - | FileCheck -check-prefix LINUX %s // CHECK: !llvm.module.flags = !{{{.*}}} -// CHECK: !{{[0-9]+}} = metadata !{i32 6, metadata !"Linker Options", metadata ![[link_opts:[0-9]+]]} -// CHECK: ![[link_opts]] = metadata !{metadata ![[msvcrt:[0-9]+]]} -// CHECK: ![[msvcrt]] = metadata !{metadata !"/DEFAULTLIB:msvcrt.lib"} +// CHECK: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[link_opts:[0-9]+]]} +// CHECK: ![[link_opts]] = !{![[msvcrt:[0-9]+]]} +// CHECK: ![[msvcrt]] = !{!"/DEFAULTLIB:msvcrt.lib"} // LINUX: !llvm.module.flags = !{{{.*}}} -// LINUX: !{{[0-9]+}} = metadata !{i32 6, metadata !"Linker Options", metadata ![[link_opts:[0-9]+]]} -// LINUX: ![[link_opts]] = metadata !{metadata ![[msvcrt:[0-9]+]]} -// LINUX: ![[msvcrt]] = metadata !{metadata !"-lmsvcrt"} +// LINUX: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[link_opts:[0-9]+]]} +// LINUX: ![[link_opts]] = !{![[msvcrt:[0-9]+]]} +// LINUX: ![[msvcrt]] = !{!"-lmsvcrt"} int f(); diff --git a/test/CodeGen/designated-initializers.c b/test/CodeGen/designated-initializers.c index b11c67a45421..74532c8fa5b4 100644 --- a/test/CodeGen/designated-initializers.c +++ b/test/CodeGen/designated-initializers.c @@ -139,6 +139,9 @@ union_16644_t union_16644_instance_4[2] = [1].b[1] = 4 }; +// CHECK: @lab = global { [4 x i8], i32 } { [4 x i8] undef, i32 123 } +struct leading_anon_bitfield { int : 32; int n; } lab = { .n = 123 }; + void test1(int argc, char **argv) { // CHECK: internal global %struct.foo { i8* null, i32 1024 } diff --git a/test/CodeGen/dllimport.c b/test/CodeGen/dllimport.c index 32ee81f85924..89dbb9f3461c 100644 --- a/test/CodeGen/dllimport.c +++ b/test/CodeGen/dllimport.c @@ -1,9 +1,9 @@ -// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple x86_64-windows-gnu -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s -// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c11 -O1 -o - %s | FileCheck --check-prefix=O1 %s -// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c11 -O1 -o - %s | FileCheck --check-prefix=O1 %s +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c11 -O0 -o - %s | FileCheck --check-prefix=CHECK --check-prefix=MS %s +// RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -std=c11 -O0 -o - %s | FileCheck --check-prefix=CHECK --check-prefix=MS %s +// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c11 -O0 -o - %s | FileCheck --check-prefix=CHECK --check-prefix=GNU %s +// RUN: %clang_cc1 -triple x86_64-windows-gnu -emit-llvm -std=c11 -O0 -o - %s | FileCheck --check-prefix=CHECK --check-prefix=GNU %s +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c11 -O1 -o - %s | FileCheck --check-prefix=O1 --check-prefix=MO1 %s +// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c11 -O1 -o - %s | FileCheck --check-prefix=O1 --check-prefix=GO1 %s #define JOIN2(x, y) x##y #define JOIN(x, y) JOIN2(x, y) @@ -44,6 +44,26 @@ __declspec(dllimport) extern int GlobalRedecl3; extern int GlobalRedecl3; // dllimport ignored USEVAR(GlobalRedecl3) +// Make sure this works even if the decl has been used before it's defined (PR20792). +// CHECK: @GlobalRedecl4 = common global i32 +__declspec(dllimport) extern int GlobalRedecl4; +USEVAR(GlobalRedecl4) + int GlobalRedecl4; // dllimport ignored + +// FIXME: dllimport is dropped in the AST; this should be reflected in codegen (PR02803). +// CHECK: @GlobalRedecl5 = external dllimport global i32 +__declspec(dllimport) extern int GlobalRedecl5; +USEVAR(GlobalRedecl5) + extern int GlobalRedecl5; // dllimport ignored + +// Redeclaration in local context. +// CHECK: @GlobalRedecl6 = external dllimport global i32 +__declspec(dllimport) int GlobalRedecl6; +int functionScope() { + extern int GlobalRedecl6; // still dllimport + return GlobalRedecl6; +} + //===----------------------------------------------------------------------===// @@ -59,14 +79,18 @@ __declspec(dllimport) void decl(void); void (*use_decl)(void) = &decl; // Import inline function. -// CHECK-DAG: declare dllimport void @inlineFunc() -// O1-DAG: define available_externally dllimport void @inlineFunc() +// MS-DAG: declare dllimport void @inlineFunc() +// MO1-DAG: define available_externally dllimport void @inlineFunc() +// GNU-DAG: declare void @inlineFunc() +// GO1-DAG: define available_externally void @inlineFunc() __declspec(dllimport) inline void inlineFunc(void) {} USE(inlineFunc) // inline attributes -// CHECK-DAG: declare dllimport void @noinline() -// O1-DAG: define available_externally dllimport void @noinline() +// MS-DAG: declare dllimport void @noinline() +// MO1-DAG: define available_externally dllimport void @noinline() +// GNU-DAG: declare void @noinline() +// GO1-DAG: define available_externally void @noinline() // CHECK-NOT: @alwaysInline() // O1-NOT: @alwaysInline() __declspec(dllimport) __attribute__((noinline)) inline void noinline(void) {} @@ -91,3 +115,15 @@ USE(redecl2) __declspec(dllimport) void redecl3(void); void redecl3(void) {} // dllimport ignored USE(redecl3) + +// Make sure this works even if the decl is used before it's defined (PR20792). +// CHECK-DAG: define void @redecl4() +__declspec(dllimport) void redecl4(void); +USE(redecl4) + void redecl4(void) {} // dllimport ignored + +// FIXME: dllimport is dropped in the AST; this should be reflected in codegen (PR20803). +// CHECK-DAG: declare dllimport +__declspec(dllimport) void redecl5(void); +USE(redecl5) + void redecl5(void); // dllimport ignored diff --git a/test/CodeGen/dwarf-version.c b/test/CodeGen/dwarf-version.c index 0c67b4f86eb5..cb95f28bc735 100644 --- a/test/CodeGen/dwarf-version.c +++ b/test/CodeGen/dwarf-version.c @@ -5,10 +5,11 @@ // RUN: %clang -target x86_64-apple-darwin -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER2 // RUN: %clang -target powerpc-unknown-openbsd -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER2 // RUN: %clang -target powerpc-unknown-freebsd -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER2 +// RUN: %clang -target i386-pc-solaris -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER2 int main (void) { return 0; } -// VER2: metadata !{i32 2, metadata !"Dwarf Version", i32 2} -// VER3: metadata !{i32 2, metadata !"Dwarf Version", i32 3} -// VER4: metadata !{i32 2, metadata !"Dwarf Version", i32 4} +// VER2: !{i32 2, !"Dwarf Version", i32 2} +// VER3: !{i32 2, !"Dwarf Version", i32 3} +// VER4: !{i32 2, !"Dwarf Version", i32 4} diff --git a/test/CodeGen/ext-vector-indexing.c b/test/CodeGen/ext-vector-indexing.c new file mode 100644 index 000000000000..28c0e1e9e25a --- /dev/null +++ b/test/CodeGen/ext-vector-indexing.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s + +typedef __attribute__(( ext_vector_type(4) )) float float4; +// CHECK: @test +void test() +{ + float4 va; + va.hi[0] = 3.0; +// CHECK: [[VA:%.*]] = alloca <4 x float> +// CHECK: [[CONV:%.*]] = bitcast <4 x float>* [[VA]] to float* +// CHECK: [[ADD:%.*]] = getelementptr inbounds float* [[CONV]], i64 2 +// CHECK: [[ARRIDX:%.*]] = getelementptr inbounds float* [[ADD]], i64 0 +// CHECK: store float 3.000000e+00, float* [[ARRIDX]] +} diff --git a/test/CodeGen/fp128_complex.c b/test/CodeGen/fp128_complex.c new file mode 100644 index 000000000000..877599932951 --- /dev/null +++ b/test/CodeGen/fp128_complex.c @@ -0,0 +1,9 @@ +// RUN: %clang -target aarch64-linux-gnuabi %s -O3 -S -emit-llvm -o - | FileCheck %s + +_Complex long double a, b, c, d; +void test_fp128_compound_assign(void) { + // CHECK: tail call { fp128, fp128 } @__multc3 + a *= b; + // CHECK: tail call { fp128, fp128 } @__divtc3 + c /= d; +} diff --git a/test/CodeGen/fsgsbase-builtins.c b/test/CodeGen/fsgsbase-builtins.c new file mode 100644 index 000000000000..14c51a9945f8 --- /dev/null +++ b/test/CodeGen/fsgsbase-builtins.c @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 %s -O3 -triple=x86_64-apple-darwin -target-feature +fsgsbase -emit-llvm -o - | FileCheck %s + +// Don't include mm_malloc.h, it's system specific. +#define __MM_MALLOC_H + +#include <x86intrin.h> + +unsigned int test_readfsbase_u32() +{ + // CHECK: @llvm.x86.rdfsbase.32 + return _readfsbase_u32(); +} + +unsigned long long test_readfsbase_u64() +{ + // CHECK: @llvm.x86.rdfsbase.64 + return _readfsbase_u64(); +} + +unsigned int test_readgsbase_u32() +{ + // CHECK: @llvm.x86.rdgsbase.32 + return _readgsbase_u32(); +} + +unsigned long long test_readgsbase_u64() +{ + // CHECK: @llvm.x86.rdgsbase.64 + return _readgsbase_u64(); +} + +void test_writefsbase_u32(unsigned int __X) +{ + // CHECK: @llvm.x86.wrfsbase.32 + _writefsbase_u32(__X); +} + +void test_writefsbase_u64(unsigned long long __X) +{ + // CHECK: @llvm.x86.wrfsbase.64 + _writefsbase_u64(__X); +} + +void test_writegsbase_u32(unsigned int __X) +{ + // CHECK: @llvm.x86.wrgsbase.32 + _writegsbase_u32(__X); +} + +void test_writegsbase_u64(unsigned long long __X) +{ + // CHECK: @llvm.x86.wrgsbase.64 + _writegsbase_u64(__X); +} diff --git a/test/CodeGen/lineno-dbginfo.c b/test/CodeGen/lineno-dbginfo.c index 1f9b7a569ece..28c72438f542 100644 --- a/test/CodeGen/lineno-dbginfo.c +++ b/test/CodeGen/lineno-dbginfo.c @@ -1,5 +1,6 @@ // RUN: echo "#include <stddef.h>" > %t.h -// RUN: %clang_cc1 -S -g -include %t.h %s -emit-llvm -o %t.ll -// RUN: grep "i32 5" %t.ll -// outer is at line number 5. +// RUN: %clang_cc1 -S -g -include %t.h %s -emit-llvm -o - | FileCheck %s + +// CHECK: !"0x34\00outer\00outer\00\00[[@LINE+1]]\000\001" int outer = 42; + diff --git a/test/CodeGen/linetable-endscope.c b/test/CodeGen/linetable-endscope.c index 236f605d7efa..9a737cf79655 100644 --- a/test/CodeGen/linetable-endscope.c +++ b/test/CodeGen/linetable-endscope.c @@ -11,7 +11,7 @@ void foo(char c) { int i; - // CHECK: ![[CONV]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[CONV]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) i = c; - // CHECK: ![[RET]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } diff --git a/test/CodeGen/link-bitcode-file.c b/test/CodeGen/link-bitcode-file.c index cf9493f988ae..fb97b4d1f585 100644 --- a/test/CodeGen/link-bitcode-file.c +++ b/test/CodeGen/link-bitcode-file.c @@ -6,7 +6,7 @@ int f(void); #ifdef BITCODE -// CHECK-BC: 'f': symbol multiply defined +// CHECK-BC: fatal error: cannot link module {{.*}}'f': symbol multiply defined int f(void) { return 42; } diff --git a/test/CodeGen/lzcnt-builtins.c b/test/CodeGen/lzcnt-builtins.c index a43c4eede452..a083de9d35f0 100644 --- a/test/CodeGen/lzcnt-builtins.c +++ b/test/CodeGen/lzcnt-builtins.c @@ -22,3 +22,15 @@ unsigned long long test__lzcnt64(unsigned long long __X) // CHECK: @llvm.ctlz.i64 return __lzcnt64(__X); } + +unsigned int test_lzcnt_u32(unsigned int __X) +{ + // CHECK: @llvm.ctlz.i32 + return _lzcnt_u32(__X); +} + +unsigned long long test__lzcnt_u64(unsigned long long __X) +{ + // CHECK: @llvm.ctlz.i64 + return _lzcnt_u64(__X); +} diff --git a/test/CodeGen/mangle-blocks.c b/test/CodeGen/mangle-blocks.c new file mode 100644 index 000000000000..c5e08e9dd5b1 --- /dev/null +++ b/test/CodeGen/mangle-blocks.c @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -triple i386-apple-ios -fblocks -emit-llvm -o - %s | FileCheck %s + +void __assert_rtn(const char *, const char *, int, const char *) + __attribute__ (( noreturn )); + +void (^mangle(void))(void) { + return ^{ + void (^block)(void) = ^{ + __assert_rtn(__func__, __FILE__, __LINE__, "mangle"); + }; + }; +} + +// CHECK: @__func__.__mangle_block_invoke_2 = private unnamed_addr constant [24 x i8] c"__mangle_block_invoke_2\00", align 1 +// CHECK: @.str = private unnamed_addr constant {{.*}}, align 1 +// CHECK: @.str1 = private unnamed_addr constant [7 x i8] c"mangle\00", align 1 + +// CHECK: define internal void @__mangle_block_invoke(i8* %.block_descriptor) + +// CHECK: define internal void @__mangle_block_invoke_2(i8* %.block_descriptor){{.*}}{ +// CHECK: call void @__assert_rtn(i8* getelementptr inbounds ([24 x i8]* @__func__.__mangle_block_invoke_2, i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 9, i8* getelementptr inbounds ([7 x i8]* @.str1, i32 0, i32 0)) +// CHECK: } + diff --git a/test/CodeGen/mangle-windows.c b/test/CodeGen/mangle-windows.c index 37d101828358..4a108751aa4b 100644 --- a/test/CodeGen/mangle-windows.c +++ b/test/CodeGen/mangle-windows.c @@ -1,33 +1,68 @@ // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | FileCheck %s +// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck %s --check-prefix=X64 +// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-mingw32 | FileCheck %s --check-prefix=X64 void __stdcall f1(void) {} // CHECK: define x86_stdcallcc void @"\01_f1@0" +// X64: define void @f1( void __fastcall f2(void) {} // CHECK: define x86_fastcallcc void @"\01@f2@0" +// X64: define void @f2( void __stdcall f3() {} // CHECK: define x86_stdcallcc void @"\01_f3@0" +// X64: define void @f3( void __fastcall f4(char a) {} // CHECK: define x86_fastcallcc void @"\01@f4@4" +// X64: define void @f4( void __fastcall f5(short a) {} // CHECK: define x86_fastcallcc void @"\01@f5@4" +// X64: define void @f5( void __fastcall f6(int a) {} // CHECK: define x86_fastcallcc void @"\01@f6@4" +// X64: define void @f6( void __fastcall f7(long a) {} // CHECK: define x86_fastcallcc void @"\01@f7@4" +// X64: define void @f7( void __fastcall f8(long long a) {} // CHECK: define x86_fastcallcc void @"\01@f8@8" +// X64: define void @f8( void __fastcall f9(long long a, char b, char c, short d) {} -// CHECK: define x86_fastcallcc void @"\01@f9@20"(i64 %a, i8 signext %b, i8 -// signext %c, i16 signext %d) +// CHECK: define x86_fastcallcc void @"\01@f9@20"(i64 %a, i8 signext %b, i8 signext %c, i16 signext %d) +// X64: define void @f9( void f12(void) {} // CHECK: define void @f12( +// X64: define void @f12( + +void __vectorcall v1(void) {} +// CHECK: define x86_vectorcallcc void @"\01v1@@0"( +// X64: define x86_vectorcallcc void @"\01v1@@0"( + +void __vectorcall v2(char a) {} +// CHECK: define x86_vectorcallcc void @"\01v2@@4"( +// X64: define x86_vectorcallcc void @"\01v2@@8"( + +void __vectorcall v3(short a) {} +// CHECK: define x86_vectorcallcc void @"\01v3@@4"( +// X64: define x86_vectorcallcc void @"\01v3@@8"( + +void __vectorcall v4(int a) {} +// CHECK: define x86_vectorcallcc void @"\01v4@@4"( +// X64: define x86_vectorcallcc void @"\01v4@@8"( + +void __vectorcall v5(long long a) {} +// CHECK: define x86_vectorcallcc void @"\01v5@@8"( +// X64: define x86_vectorcallcc void @"\01v5@@8"( + +void __vectorcall v6(char a, char b) {} +// CHECK: define x86_vectorcallcc void @"\01v6@@8"( +// X64: define x86_vectorcallcc void @"\01v6@@16"( diff --git a/test/CodeGen/may-alias.c b/test/CodeGen/may-alias.c index 4d6f721f6abb..520b7abea6c1 100644 --- a/test/CodeGen/may-alias.c +++ b/test/CodeGen/may-alias.c @@ -27,16 +27,16 @@ void test1(struct Test1MA *p1, struct Test1 *p2) { // PATH: store i32 3, i32* {{%.*}}, !tbaa [[TAG_test1_x:!.*]] p2->x = 3; } -// CHECK: metadata !{metadata !"any pointer", metadata [[TYPE_CHAR:!.*]], -// CHECK: [[TYPE_CHAR]] = metadata !{metadata !"omnipotent char", metadata [[TAG_CXX_TBAA:!.*]], -// CHECK: [[TAG_CXX_TBAA]] = metadata !{metadata !"Simple C/C++ TBAA"} -// CHECK: [[TAG_CHAR]] = metadata !{metadata [[TYPE_CHAR]], metadata [[TYPE_CHAR]], i64 0} -// CHECK: [[TAG_INT]] = metadata !{metadata [[TYPE_INT:!.*]], metadata [[TYPE_INT]], i64 0} -// CHECK: [[TYPE_INT]] = metadata !{metadata !"int", metadata [[TYPE_CHAR]] +// CHECK: !"any pointer", [[TYPE_CHAR:!.*]], +// CHECK: [[TYPE_CHAR]] = !{!"omnipotent char", [[TAG_CXX_TBAA:!.*]], +// CHECK: [[TAG_CXX_TBAA]] = !{!"Simple C/C++ TBAA"} +// CHECK: [[TAG_CHAR]] = !{[[TYPE_CHAR]], [[TYPE_CHAR]], i64 0} +// CHECK: [[TAG_INT]] = !{[[TYPE_INT:!.*]], [[TYPE_INT]], i64 0} +// CHECK: [[TYPE_INT]] = !{!"int", [[TYPE_CHAR]] -// PATH: [[TYPE_CHAR:!.*]] = metadata !{metadata !"omnipotent char", metadata !{{.*}} -// PATH: [[TAG_CHAR]] = metadata !{metadata [[TYPE_CHAR]], metadata [[TYPE_CHAR]], i64 0} -// PATH: [[TAG_INT]] = metadata !{metadata [[TYPE_INT:!.*]], metadata [[TYPE_INT]], i64 0} -// PATH: [[TYPE_INT]] = metadata !{metadata !"int", metadata [[TYPE_CHAR]] -// PATH: [[TAG_test1_x]] = metadata !{metadata [[TYPE_test1:!.*]], metadata [[TYPE_INT]], i64 0} -// PATH: [[TYPE_test1]] = metadata !{metadata !"Test1", metadata [[TYPE_INT]], i64 0} +// PATH: [[TYPE_CHAR:!.*]] = !{!"omnipotent char", !{{.*}} +// PATH: [[TAG_CHAR]] = !{[[TYPE_CHAR]], [[TYPE_CHAR]], i64 0} +// PATH: [[TAG_INT]] = !{[[TYPE_INT:!.*]], [[TYPE_INT]], i64 0} +// PATH: [[TYPE_INT]] = !{!"int", [[TYPE_CHAR]] +// PATH: [[TAG_test1_x]] = !{[[TYPE_test1:!.*]], [[TYPE_INT]], i64 0} +// PATH: [[TYPE_test1]] = !{!"Test1", [[TYPE_INT]], i64 0} diff --git a/test/CodeGen/merge-statics.c b/test/CodeGen/merge-statics.c index 6716935c4d12..4baf902488c5 100644 --- a/test/CodeGen/merge-statics.c +++ b/test/CodeGen/merge-statics.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 < %s -emit-llvm | grep internal | count 1 +// RUN: %clang_cc1 < %s -emit-llvm | FileCheck %s // The two decls for 'a' should merge into one llvm GlobalVariable. @@ -11,3 +11,6 @@ static struct s a = { 10 }; +// CHECK-NOT: internal global +// CHECK: @a = internal global %struct.s { i32 10 } +// CHECK-NOT: internal-global diff --git a/test/CodeGen/microsoft-call-conv.c b/test/CodeGen/microsoft-call-conv.c index b80c58dfd1f2..c24db1296f12 100644 --- a/test/CodeGen/microsoft-call-conv.c +++ b/test/CodeGen/microsoft-call-conv.c @@ -20,6 +20,11 @@ void __thiscall f6(void) { f3(); // CHECK: call x86_thiscallcc void @f3() } +void __vectorcall f61(void) { +// CHECK-LABEL: define x86_vectorcallcc void @f61() + f3(); +// CHECK: call x86_thiscallcc void @f3() +} // PR5280 void (__fastcall *pf1)(void) = f1; @@ -28,19 +33,22 @@ void (__thiscall *pf3)(void) = f3; void (__fastcall *pf4)(void) = f4; void (__stdcall *pf5)(void) = f5; void (__thiscall *pf6)(void) = f6; +void (__vectorcall *pf7)(void) = f61; int main(void) { - f4(); f5(); f6(); + f4(); f5(); f6(); f61(); // CHECK: call x86_fastcallcc void @f4() // CHECK: call x86_stdcallcc void @f5() // CHECK: call x86_thiscallcc void @f6() - pf1(); pf2(); pf3(); pf4(); pf5(); pf6(); + // CHECK: call x86_vectorcallcc void @f61() + pf1(); pf2(); pf3(); pf4(); pf5(); pf6(); pf7(); // CHECK: call x86_fastcallcc void %{{.*}}() // CHECK: call x86_stdcallcc void %{{.*}}() // CHECK: call x86_thiscallcc void %{{.*}}() // CHECK: call x86_fastcallcc void %{{.*}}() // CHECK: call x86_stdcallcc void %{{.*}}() // CHECK: call x86_thiscallcc void %{{.*}}() + // CHECK: call x86_vectorcallcc void %{{.*}}() return 0; } diff --git a/test/CodeGen/mips-constraint-regs.c b/test/CodeGen/mips-constraint-regs.c index 0d533f5fc771..4dfd62ddbfcf 100644 --- a/test/CodeGen/mips-constraint-regs.c +++ b/test/CodeGen/mips-constraint-regs.c @@ -9,7 +9,7 @@ int main() // 'c': 16 bit address register for Mips16, GPR for all others // I am using 'c' to constrain both the target and one of the source // registers. We are looking for syntactical correctness. - // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "addi $0,$1,$2 \0A\09\09", "=c,c,I"(i32 %{{[0-9]+}}, i32 %{{[0-9]+}}) [[NUW:#[0-9]+]], !srcloc !{{[0-9]+}} + // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "addi $0,$1,$2 \0A\09\09", "=c,c,I,~{$1}"(i32 %{{[0-9]+}}, i32 %{{[0-9]+}}) [[NUW:#[0-9]+]], !srcloc !{{[0-9]+}} int __s, __v = 17; int __t; __asm__ __volatile__( @@ -20,7 +20,7 @@ int main() // 'l': lo register // We are making it clear that destination register is lo with the // use of the 'l' constraint ("=l"). - // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "mtlo $1 \0A\09\09", "=l,r,~{lo}"(i32 %{{[0-9]+}}) [[NUW]], !srcloc !{{[0-9]+}} + // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "mtlo $1 \0A\09\09", "=l,r,~{lo},~{$1}"(i32 %{{[0-9]+}}) [[NUW]], !srcloc !{{[0-9]+}} int i_temp = 44; int i_result; __asm__ __volatile__( @@ -32,7 +32,7 @@ int main() // 'x': Combined lo/hi registers // We are specifying that destination registers are the hi/lo pair with the // use of the 'x' constraint ("=x"). - // CHECK: %{{[0-9]+}} = call i64 asm sideeffect "mthi $1 \0A\09\09mtlo $2 \0A\09\09", "=x,r,r"(i32 %{{[0-9]+}}, i32 %{{[0-9]+}}) [[NUW]], !srcloc !{{[0-9]+}} + // CHECK: %{{[0-9]+}} = call i64 asm sideeffect "mthi $1 \0A\09\09mtlo $2 \0A\09\09", "=x,r,r,~{$1}"(i32 %{{[0-9]+}}, i32 %{{[0-9]+}}) [[NUW]], !srcloc !{{[0-9]+}} int i_hi = 3; int i_lo = 2; long long ll_result = 0; diff --git a/test/CodeGen/mips-constraints-mem.c b/test/CodeGen/mips-constraints-mem.c index 2c3c01ac11e2..295d67cadf0a 100644 --- a/test/CodeGen/mips-constraints-mem.c +++ b/test/CodeGen/mips-constraints-mem.c @@ -9,7 +9,7 @@ int foo() // 'R': An address that can be used in a non-macro load or stor' // This test will result in the higher and lower nibbles being // switched due to the lwl/lwr instruction pairs. - // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "lwl $0, 1 + $1\0A\09lwr $0, 2 + $1\0A\09", "=r,*R"(i32* %{{[0-9,a-f]+}}) #1, + // CHECK: %{{[0-9]+}} = call i32 asm sideeffect "lwl $0, 1 + $1\0A\09lwr $0, 2 + $1\0A\09", "=r,*R,~{$1}"(i32* %{{[0-9,a-f]+}}) #1, int c = 0xffbbccdd; diff --git a/test/CodeGen/mips-inline-asm-modifiers.c b/test/CodeGen/mips-inline-asm-modifiers.c index 9d697e8b228e..9437dbe5abe5 100644 --- a/test/CodeGen/mips-inline-asm-modifiers.c +++ b/test/CodeGen/mips-inline-asm-modifiers.c @@ -7,9 +7,9 @@ int printf(const char*, ...); typedef int v4i32 __attribute__((vector_size(16))); - // CHECK: %{{[0-9]+}} = call i32 asm ".set noreorder;\0Alw $0,$1;\0A.set reorder;\0A", "=r,*m"(i32* getelementptr inbounds ([8 x i32]* @b, i32 {{[0-9]+}}, i32 {{[0-9]+}})) #2, - // CHECK: %{{[0-9]+}} = call i32 asm "lw $0,${1:D};\0A", "=r,*m"(i32* getelementptr inbounds ([8 x i32]* @b, i32 {{[0-9]+}}, i32 {{[0-9]+}})) #2, - // CHECK: %{{[0-9]+}} = call <4 x i32> asm "ldi.w ${0:w},1", "=f" + // CHECK: %{{[0-9]+}} = call i32 asm ".set noreorder;\0Alw $0,$1;\0A.set reorder;\0A", "=r,*m,~{$1}"(i32* getelementptr inbounds ([8 x i32]* @b, i32 {{[0-9]+}}, i32 {{[0-9]+}})) #2, + // CHECK: %{{[0-9]+}} = call i32 asm "lw $0,${1:D};\0A", "=r,*m,~{$1}"(i32* getelementptr inbounds ([8 x i32]* @b, i32 {{[0-9]+}}, i32 {{[0-9]+}})) #2, + // CHECK: %{{[0-9]+}} = call <4 x i32> asm "ldi.w ${0:w},1", "=f,~{$1}" int b[8] = {0,1,2,3,4,5,6,7}; int main() { diff --git a/test/CodeGen/mips-transparent-union.c b/test/CodeGen/mips-transparent-union.c new file mode 100644 index 000000000000..ad417dd9f5da --- /dev/null +++ b/test/CodeGen/mips-transparent-union.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -triple mips64-linux-gnu -S -o - -emit-llvm %s | FileCheck %s +// +// Transparent unions are passed according to the calling convention rules of +// the first member. In this case, it is as if it were a void pointer so we +// do not have the inreg attribute we would normally have for unions. +// +// This comes up in glibc's wait() function and matters for the big-endian N32 +// case where pointers are promoted to i64 and a non-transparent union would be +// passed in the upper 32-bits of an i64. + +union either_pointer { + void *void_ptr; + int *int_ptr; +} __attribute__((transparent_union)); + +extern void foo(union either_pointer p); + +int data; + +void bar(void) { + return foo(&data); +} + +// CHECK-LABEL: define void @bar() +// CHECK: call void @foo(i8* %{{[0-9]+}}) + +// CHECK: declare void @foo(i8*) diff --git a/test/CodeGen/mips-varargs.c b/test/CodeGen/mips-varargs.c index ad202ff85bf0..383831f2e824 100644 --- a/test/CodeGen/mips-varargs.c +++ b/test/CodeGen/mips-varargs.c @@ -28,18 +28,19 @@ int test_i32(char *fmt, ...) { // ALL: [[VA1:%.+]] = bitcast i8** %va to i8* // ALL: call void @llvm.va_start(i8* [[VA1]]) // -// ALL: [[AP_CUR:%.+]] = load i8** %va, align [[PTRALIGN]] -// -// O32: [[TMP0:%.+]] = bitcast i8* [[AP_CUR]] to i32* -// NEW: [[TMP0:%.+]] = bitcast i8* [[AP_CUR]] to i64* +// O32: [[TMP0:%.+]] = bitcast i8** %va to i32** +// O32: [[AP_CUR:%.+]] = load i32** [[TMP0]], align [[PTRALIGN]] +// NEW: [[TMP0:%.+]] = bitcast i8** %va to i64** +// NEW: [[AP_CUR:%.+]] = load i64** [[TMP0]], align [[PTRALIGN]] // -// O32: [[AP_NEXT:%.+]] = getelementptr i8* [[AP_CUR]], i32 4 -// NEW: [[AP_NEXT:%.+]] = getelementptr i8* [[AP_CUR]], {{i32|i64}} 8 +// O32: [[AP_NEXT:%.+]] = getelementptr i32* [[AP_CUR]], i32 1 +// NEW: [[AP_NEXT:%.+]] = getelementptr i64* [[AP_CUR]], {{i32|i64}} 1 // -// ALL: store i8* [[AP_NEXT]], i8** %va, align [[PTRALIGN]] +// O32: store i32* [[AP_NEXT]], i32** [[TMP0]], align [[PTRALIGN]] +// NEW: store i64* [[AP_NEXT]], i64** [[TMP0]], align [[PTRALIGN]] // -// O32: [[ARG1:%.+]] = load i32* [[TMP0]], align 4 -// NEW: [[TMP2:%.+]] = load i64* [[TMP0]], align 8 +// O32: [[ARG1:%.+]] = load i32* [[AP_CUR]], align 4 +// NEW: [[TMP2:%.+]] = load i64* [[AP_CUR]], align 8 // NEW: [[ARG1:%.+]] = trunc i64 [[TMP2]] to i32 // // ALL: call void @llvm.va_end(i8* [[VA1]]) @@ -63,32 +64,30 @@ int test_i32_2args(char *fmt, ...) { // ALL: [[VA1:%.+]] = bitcast i8** %va to i8* // ALL: call void @llvm.va_start(i8* [[VA1]]) // -// ALL: [[AP_CUR:%.+]] = load i8** %va, align [[PTRALIGN]] -// -// O32: [[TMP0:%.+]] = bitcast i8* [[AP_CUR]] to i32* -// NEW: [[TMP0:%.+]] = bitcast i8* [[AP_CUR]] to i64* +// O32: [[TMP0:%.+]] = bitcast i8** %va to i32** +// O32: [[AP_CUR:%.+]] = load i32** [[TMP0]], align [[PTRALIGN]] +// NEW: [[TMP0:%.+]] = bitcast i8** %va to i64** +// NEW: [[AP_CUR:%.+]] = load i64** [[TMP0]], align [[PTRALIGN]] // -// O32: [[AP_NEXT:%.+]] = getelementptr i8* [[AP_CUR]], i32 4 -// NEW: [[AP_NEXT:%.+]] = getelementptr i8* [[AP_CUR]], [[INTPTR_T:i32|i64]] 8 +// O32: [[AP_NEXT1:%.+]] = getelementptr i32* [[AP_CUR]], i32 1 +// NEW: [[AP_NEXT1:%.+]] = getelementptr i64* [[AP_CUR]], [[INTPTR_T:i32|i64]] 1 // -// O32: store i8* [[AP_NEXT]], i8** %va, align [[PTRALIGN]] +// O32: store i32* [[AP_NEXT1]], i32** [[TMP0]], align [[PTRALIGN]] // FIXME: N32 optimised this store out. Why only for this ABI? -// N64: store i8* [[AP_NEXT]], i8** %va, align [[PTRALIGN]] +// N64: store i64* [[AP_NEXT1]], i64** [[TMP0]], align [[PTRALIGN]] // -// O32: [[ARG1:%.+]] = load i32* [[TMP0]], align 4 -// NEW: [[TMP3:%.+]] = load i64* [[TMP0]], align 8 +// O32: [[ARG1:%.+]] = load i32* [[AP_CUR]], align 4 +// NEW: [[TMP3:%.+]] = load i64* [[AP_CUR]], align 8 // NEW: [[ARG1:%.+]] = trunc i64 [[TMP3]] to i32 // -// O32: [[TMP1:%.+]] = bitcast i8* [[AP_NEXT]] to i32* -// NEW: [[TMP1:%.+]] = bitcast i8* [[AP_NEXT]] to i64* +// O32: [[AP_NEXT2:%.+]] = getelementptr i32* [[AP_CUR]], i32 2 +// NEW: [[AP_NEXT2:%.+]] = getelementptr i64* [[AP_CUR]], [[INTPTR_T]] 2 // -// O32: [[AP_NEXT3:%.+]] = getelementptr i8* [[AP_CUR]], i32 8 -// NEW: [[AP_NEXT3:%.+]] = getelementptr i8* [[AP_CUR]], [[INTPTR_T]] 16 +// O32: store i32* [[AP_NEXT2]], i32** [[TMP0]], align [[PTRALIGN]] +// NEW: store i64* [[AP_NEXT2]], i64** [[TMP0]], align [[PTRALIGN]] // -// ALL: store i8* [[AP_NEXT3]], i8** %va, align [[PTRALIGN]] -// -// O32: [[ARG2:%.+]] = load i32* [[TMP1]], align 4 -// NEW: [[TMP4:%.+]] = load i64* [[TMP1]], align 8 +// O32: [[ARG2:%.+]] = load i32* [[AP_NEXT1]], align 4 +// NEW: [[TMP4:%.+]] = load i64* [[AP_NEXT1]], align 8 // NEW: [[ARG2:%.+]] = trunc i64 [[TMP4]] to i32 // // ALL: call void @llvm.va_end(i8* [[VA1]]) @@ -112,9 +111,9 @@ long long test_i64(char *fmt, ...) { // ALL: [[VA1:%.+]] = bitcast i8** %va to i8* // ALL: call void @llvm.va_start(i8* [[VA1]]) // -// ALL: [[AP_CUR:%.+]] = load i8** %va, align [[PTRALIGN]] -// -// NEW: [[TMP0:%.+]] = bitcast i8* [[AP_CUR]] to i64* +// O32: [[AP_CUR:%.+]] = load i8** %va, align [[PTRALIGN]] +// NEW: [[TMP0:%.+]] = bitcast i8** %va to i64** +// NEW: [[AP_CUR:%.+]] = load i64** [[TMP0]], align [[PTRALIGN]] // // i64 is 8-byte aligned, while this is within O32's stack alignment there's no // guarantee that the offset is still 8-byte aligned after earlier reads. @@ -125,17 +124,67 @@ long long test_i64(char *fmt, ...) { // O32: [[PTR4:%.+]] = inttoptr [[INTPTR_T]] [[PTR2]] to i8* // // O32: [[AP_NEXT:%.+]] = getelementptr i8* [[PTR4]], [[INTPTR_T]] 8 -// NEW: [[AP_NEXT:%.+]] = getelementptr i8* [[AP_CUR]], [[INTPTR_T]] 8 +// NEW: [[AP_NEXT:%.+]] = getelementptr i64* [[AP_CUR]], [[INTPTR_T:i32|i64]] 1 // -// ALL: store i8* [[AP_NEXT]], i8** %va, align [[PTRALIGN]] +// O32: store i8* [[AP_NEXT]], i8** %va, align [[PTRALIGN]] +// NEW: store i64* [[AP_NEXT]], i64** [[TMP0]], align [[PTRALIGN]] // // O32: [[ARG1:%.+]] = load i64* [[PTR3]], align 8 -// NEW: [[ARG1:%.+]] = load i64* [[TMP0]], align 8 +// NEW: [[ARG1:%.+]] = load i64* [[AP_CUR]], align 8 // // ALL: call void @llvm.va_end(i8* [[VA1]]) // ALL: ret i64 [[ARG1]] // ALL: } +char *test_ptr(char *fmt, ...) { + va_list va; + + va_start(va, fmt); + char *v = va_arg(va, char *); + va_end(va); + + return v; +} + +// ALL-LABEL: define i8* @test_ptr(i8*{{.*}} %fmt, ...) +// +// O32: %va = alloca i8*, align [[PTRALIGN:4]] +// N32: %va = alloca i8*, align [[PTRALIGN:4]] +// N64: %va = alloca i8*, align [[PTRALIGN:8]] +// +// ALL: [[VA1:%.+]] = bitcast i8** %va to i8* +// ALL: call void @llvm.va_start(i8* [[VA1]]) +// +// O32: [[TMP0:%.+]] = bitcast i8** %va to i8*** +// O32: [[AP_CUR:%.+]] = load i8*** [[TMP0]], align [[PTRALIGN]] +// N32 differs because the vararg is not a N32 pointer. It's been promoted to 64-bit. +// N32: [[TMP0:%.+]] = bitcast i8** %va to i64** +// N32: [[AP_CUR:%.+]] = load i64** [[TMP0]], align [[PTRALIGN]] +// N64: [[TMP0:%.+]] = bitcast i8** %va to i8*** +// N64: [[AP_CUR:%.+]] = load i8*** [[TMP0]], align [[PTRALIGN]] +// +// O32: [[AP_NEXT:%.+]] = getelementptr i8** [[AP_CUR]], i32 1 +// N32 differs because the vararg is not a N32 pointer. It's been promoted to 64-bit. +// N32: [[AP_NEXT:%.+]] = getelementptr i64* [[AP_CUR]], {{i32|i64}} 1 +// N64: [[AP_NEXT:%.+]] = getelementptr i8** [[AP_CUR]], {{i32|i64}} 1 +// +// O32: store i8** [[AP_NEXT]], i8*** [[TMP0]], align [[PTRALIGN]] +// N32 differs because the vararg is not a N32 pointer. It's been promoted to 64-bit. +// N32: store i64* [[AP_NEXT]], i64** [[TMP0]], align [[PTRALIGN]] +// N64: store i8** [[AP_NEXT]], i8*** [[TMP0]], align [[PTRALIGN]] +// +// O32: [[ARG1:%.+]] = load i8** [[AP_CUR]], align 4 +// N32 differs because the vararg is not a N32 pointer. It's been promoted to +// 64-bit so we must truncate the excess and bitcast to a N32 pointer. +// N32: [[TMP2:%.+]] = load i64* [[AP_CUR]], align 8 +// N32: [[TMP3:%.+]] = trunc i64 [[TMP2]] to i32 +// N32: [[ARG1:%.+]] = inttoptr i32 [[TMP3]] to i8* +// N64: [[ARG1:%.+]] = load i8** [[AP_CUR]], align 8 +// +// ALL: call void @llvm.va_end(i8* [[VA1]]) +// ALL: ret i8* [[ARG1]] +// ALL: } + int test_v4i32(char *fmt, ...) { va_list va; diff --git a/test/CodeGen/mmx-inline-asm-error.c b/test/CodeGen/mmx-inline-asm-error.c index 876c664e3b57..1e2246176a11 100644 --- a/test/CodeGen/mmx-inline-asm-error.c +++ b/test/CodeGen/mmx-inline-asm-error.c @@ -4,9 +4,9 @@ typedef int vec256 __attribute__((ext_vector_type(8))); vec256 foo(vec256 in) { vec256 out; - asm("something %0" : : "y"(in)); // expected-error {{invalid type 'vec256' (vector of 8 'int' values) in asm input for constraint 'y'}} - asm("something %0" : "=y"(out)); // expected-error {{invalid type 'vec256' (vector of 8 'int' values) in asm input for constraint 'y'}} - asm("something %0, %0" : "+y"(out)); // expected-error {{invalid type 'vec256' (vector of 8 'int' values) in asm input for constraint 'y'}} + asm("something %0" : : "y"(in)); // expected-error {{invalid input size for constraint 'y'}} + asm("something %0" : "=y"(out)); // expected-error {{invalid output size for constraint '=y'}} + asm("something %0, %0" : "+y"(out)); // expected-error {{invalid output size for constraint '+y'}} return out; } diff --git a/test/CodeGen/mozilla-ms-inline-asm.c b/test/CodeGen/mozilla-ms-inline-asm.c index 0f541d70fcdd..b8b7a2d677dd 100644 --- a/test/CodeGen/mozilla-ms-inline-asm.c +++ b/test/CodeGen/mozilla-ms-inline-asm.c @@ -3,6 +3,8 @@ // Some test cases for MS inline asm support from Mozilla code base. +void invoke_copy_to_stack() {} + void invoke(void* that, unsigned methodIndex, unsigned paramCount, void* params) { @@ -18,24 +20,25 @@ void invoke(void* that, unsigned methodIndex, // CHECK: call void asm sideeffect inteldialect // CHECK: mov edx,dword ptr $1 // CHECK: test edx,edx -// CHECK: jz noparams +// CHECK: jz {{[^_]*}}__MSASMLABEL_.0__noparams +// ^ Can't use {{.*}} here because the matching is greedy. // CHECK: mov eax,edx // CHECK: shl eax,$$3 // CHECK: sub esp,eax // CHECK: mov ecx,esp // CHECK: push dword ptr $0 -// CHECK: call invoke_copy_to_stack -// CHECK: noparams: -// CHECK: mov ecx,dword ptr $2 +// CHECK: call dword ptr $2 +// CHECK: {{.*}}__MSASMLABEL_.0__noparams: +// CHECK: mov ecx,dword ptr $3 // CHECK: push ecx // CHECK: mov edx,[ecx] -// CHECK: mov eax,dword ptr $3 +// CHECK: mov eax,dword ptr $4 // CHECK: call dword ptr[edx+eax*$$4] // CHECK: mov esp,ebp // CHECK: pop ebp // CHECK: ret -// CHECK: "=*m,*m,*m,*m,~{eax},~{ebp},~{ecx},~{edx},~{flags},~{esp},~{dirflag},~{fpsr},~{flags}" -// CHECK: (i8** %8, i32* %7, i8** %5, i32* %6) +// CHECK: "=*m,*m,*m,*m,*m,~{eax},~{ebp},~{ecx},~{edx},~{flags},~{esp},~{dirflag},~{fpsr},~{flags}" +// CHECK: (i8** %8, i32* %7, void (...)* bitcast (void ()* @invoke_copy_to_stack to void (...)*), i8** %5, i32* %6) // CHECK: ret void __asm { mov edx,paramCount diff --git a/test/CodeGen/mrtd.c b/test/CodeGen/mrtd.c index 8fa7cf02cead..f929d4c26b28 100644 --- a/test/CodeGen/mrtd.c +++ b/test/CodeGen/mrtd.c @@ -1,4 +1,6 @@ -// RUN: %clang_cc1 -mrtd -triple i386-unknown-unknown -std=c89 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -mrtd -triple i386-unknown-unknown -std=c89 -emit-llvm -o - %s 2>&1 | FileCheck %s + +// CHECK: mrtd.c:10:3: warning: function with no prototype cannot use the stdcall calling convention void baz(int arg); diff --git a/test/CodeGen/ms-align-tentative.c b/test/CodeGen/ms-align-tentative.c new file mode 100644 index 000000000000..ccd761616471 --- /dev/null +++ b/test/CodeGen/ms-align-tentative.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -triple i386-pc-win32 %s -emit-llvm -fms-compatibility -o - | FileCheck %s + +char __declspec(align(8192)) x; +// CHECK-DAG: @x = global i8 0, align 8192 + +typedef char __declspec(align(8192)) T; +T y; +// CHECK-DAG: @y = global i8 0, align 8192 + +T __declspec(align(8192)) z; +// CHECK-DAG: @z = global i8 0, align 8192 + +int __declspec(align(16)) redef; +int __declspec(align(32)) redef = 8; +// CHECK-DAG: @redef = global i32 8, align 32 diff --git a/test/CodeGen/ms-declspecs.c b/test/CodeGen/ms-declspecs.c index 5dc7787b8fb9..328fc835d347 100644 --- a/test/CodeGen/ms-declspecs.c +++ b/test/CodeGen/ms-declspecs.c @@ -2,8 +2,8 @@ __declspec(selectany) int x1 = 1; const __declspec(selectany) int x2 = 2; -// CHECK: @x1 = weak_odr global i32 1, align 4 -// CHECK: @x2 = weak_odr constant i32 2, align 4 +// CHECK: @x1 = weak_odr global i32 1, comdat, align 4 +// CHECK: @x2 = weak_odr constant i32 2, comdat, align 4 struct __declspec(align(16)) S { char x; diff --git a/test/CodeGen/ms-inline-asm-functions.c b/test/CodeGen/ms-inline-asm-functions.c new file mode 100644 index 000000000000..1a6ead9286df --- /dev/null +++ b/test/CodeGen/ms-inline-asm-functions.c @@ -0,0 +1,60 @@ +// REQUIRES: x86-registered-target +// RUN: %clang_cc1 %s -triple i386-pc-windows-msvc -fms-extensions -S -o - | FileCheck %s + +// Yes, this is an assembly test from Clang, because we need to make it all the +// way through code generation to know if our call became a direct, pc-relative +// call or an indirect call through memory. + +int k(int); +__declspec(dllimport) int kimport(int); +int (*kptr)(int); +int (*gptr())(int); + +int foo() { + // CHECK-LABEL: _foo: + int (*r)(int) = gptr(); + + // Simple case: direct call. + __asm call k; + // CHECK: calll _k + + // Marginally harder: indirect calls, via dllimport or function pointer. + __asm call r; + // CHECK: calll *({{.*}}) + __asm call kimport; + // CHECK: calll *({{.*}}) + + // Broken case: Call through a global function pointer. + __asm call kptr; + // CHECK: calll _kptr + // CHECK-FIXME: calll *_kptr +} + +int bar() { + // CHECK-LABEL: _bar: + __asm jmp k; + // CHECK: jmp _k +} + +int baz() { + // CHECK-LABEL: _baz: + __asm mov eax, k; + // CHECK: movl _k, %eax + __asm mov eax, kptr; + // CHECK: movl _kptr, %eax +} + +// Test that this asm blob doesn't require more registers than available. This +// has to be an LLVM code generation test. + +void __declspec(naked) naked() { + __asm pusha + __asm call k + __asm popa + __asm ret + // CHECK-LABEL: _naked: + // CHECK: pushal + // CHECK-NEXT: calll _k + // CHECK-NEXT: popal + // CHECK-NEXT: retl +} diff --git a/test/CodeGen/ms-inline-asm.c b/test/CodeGen/ms-inline-asm.c index 2c6710694142..59ff2023a465 100644 --- a/test/CodeGen/ms-inline-asm.c +++ b/test/CodeGen/ms-inline-asm.c @@ -10,9 +10,7 @@ void t1() { void t2() { // CHECK: @t2 -// CHECK: call void asm sideeffect inteldialect "nop", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "nop", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "nop", "~{dirflag},~{fpsr},~{flags}"() +// CHECK: call void asm sideeffect inteldialect "nop\0A\09nop\0A\09nop", "~{dirflag},~{fpsr},~{flags}"() // CHECK: ret void __asm nop __asm nop @@ -28,8 +26,7 @@ void t3() { void t4(void) { // CHECK: @t4 -// CHECK: call void asm sideeffect inteldialect "mov ebx, eax", "~{ebx},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov ecx, ebx", "~{ecx},~{dirflag},~{fpsr},~{flags}"() +// CHECK: call void asm sideeffect inteldialect "mov ebx, eax\0A\09mov ecx, ebx", "~{ebx},~{ecx},~{dirflag},~{fpsr},~{flags}"() // CHECK: ret void __asm mov ebx, eax __asm mov ecx, ebx @@ -69,9 +66,7 @@ int t8() { __asm int 4 return 10; // CHECK: t8 -// CHECK: call void asm sideeffect inteldialect "int $$4", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "int $$4", "~{dirflag},~{fpsr},~{flags}"() +// CHECK: call i32 asm sideeffect inteldialect "int $$4\0A\09int $$4", "={eax},~{dirflag},~{fpsr},~{flags}"() // CHECK: ret i32 10 } @@ -93,10 +88,11 @@ unsigned t10(void) { } return j; // CHECK: t10 +// CHECK: [[r:%[a-zA-Z0-9]+]] = alloca i32, align 4 // CHECK: [[I:%[a-zA-Z0-9]+]] = alloca i32, align 4 // CHECK: [[J:%[a-zA-Z0-9]+]] = alloca i32, align 4 // CHECK: store i32 1, i32* [[I]], align 4 -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $1\0A\09mov dword ptr $0, eax", "=*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}) +// CHECK: call i32 asm sideeffect inteldialect "mov eax, dword ptr $2\0A\09mov dword ptr $0, eax", "=*m,={eax},*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}) // CHECK: [[RET:%[a-zA-Z0-9]+]] = load i32* [[J]], align 4 // CHECK: ret i32 [[RET]] } @@ -117,7 +113,7 @@ unsigned t12(void) { } return j + m; // CHECK: t12 -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $2\0A\09mov dword ptr $0, eax\0A\09mov eax, dword ptr $3\0A\09mov dword ptr $1, eax", "=*m,=*m,*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}) +// CHECK: call i32 asm sideeffect inteldialect "mov eax, dword ptr $3\0A\09mov dword ptr $0, eax\0A\09mov eax, dword ptr $4\0A\09mov dword ptr $1, eax", "=*m,=*m,={eax},*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}) } void t13() { @@ -126,8 +122,7 @@ void t13() { __asm movzx eax, i __asm movzx eax, j // CHECK: t13 -// CHECK: call void asm sideeffect inteldialect "movzx eax, byte ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i8* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "movzx eax, word ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i16* %{{.*}}) +// CHECK: call void asm sideeffect inteldialect "movzx eax, byte ptr $0\0A\09movzx eax, word ptr $1", "*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i8* %{{.*}}i, i16* %{{.*}}j) } void t14() { @@ -145,14 +140,15 @@ void t14() { int gvar = 10; void t15() { +// CHECK: t15 int lvar = 10; __asm mov eax, lvar ; eax = 10 +// CHECK: mov eax, dword ptr $0 __asm mov eax, offset lvar ; eax = address of lvar +// CHECK: mov eax, $1 __asm mov eax, offset gvar ; eax = address of gvar -// CHECK: t15 -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* @{{.*}}) +// CHECK: mov eax, $2 +// CHECK: "*m,r,r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* @{{.*}}) } void t16() { @@ -163,50 +159,52 @@ void t16() { } void t17() { +// CHECK: t17 __asm _emit 0x4A +// CHECK: .byte 0x4A __asm _emit 0x43 +// CHECK: .byte 0x43 __asm _emit 0x4B +// CHECK: .byte 0x4B __asm _EMIT 0x4B -// CHECK: t17 -// CHECK: call void asm sideeffect inteldialect ".byte 0x4A", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0x43", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0x4B", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0x4B", "~{dirflag},~{fpsr},~{flags}"() +// CHECK: .byte 0x4B +// CHECK: "~{dirflag},~{fpsr},~{flags}"() } void t20() { +// CHECK: t20 char bar; int foo; char _bar[2]; int _foo[4]; __asm mov eax, LENGTH foo +// CHECK: mov eax, $$1 __asm mov eax, LENGTH bar +// CHECK: mov eax, $$1 __asm mov eax, LENGTH _foo +// CHECK: mov eax, $$4 __asm mov eax, LENGTH _bar -// CHECK: t20 -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, $$2 __asm mov eax, TYPE foo +// CHECK: mov eax, $$4 __asm mov eax, TYPE bar +// CHECK: mov eax, $$1 __asm mov eax, TYPE _foo +// CHECK: mov eax, $$4 __asm mov eax, TYPE _bar -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, $$1 __asm mov eax, SIZE foo +// CHECK: mov eax, $$4 __asm mov eax, SIZE bar +// CHECK: mov eax, $$1 __asm mov eax, SIZE _foo +// CHECK: mov eax, $$16 __asm mov eax, SIZE _bar -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$16", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, $$2 +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t21() { @@ -242,45 +240,46 @@ void t23() { the_label: } // CHECK: t23 -// CHECK: call void asm sideeffect inteldialect "the_label:", "~{dirflag},~{fpsr},~{flags}"() +// CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.0__the_label:", "~{dirflag},~{fpsr},~{flags}"() } void t24_helper(void) {} void t24() { __asm call t24_helper // CHECK: t24 -// CHECK: call void asm sideeffect inteldialect "call $0", "r,~{dirflag},~{fpsr},~{flags}"(void ()* @t24_helper) +// CHECK: call void asm sideeffect inteldialect "call dword ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(void ()* @t24_helper) } void t25() { +// CHECK: t25 __asm mov eax, 0ffffffffh +// CHECK: mov eax, $$4294967295 __asm mov eax, 0fh +// CHECK: mov eax, $$15 __asm mov eax, 0a2h +// CHECK: mov eax, $$162 __asm mov eax, 0xa2h +// CHECK: mov eax, $$0xa2h __asm mov eax, 0xa2 -// CHECK: t25 -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4294967295", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$15", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$162", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$0xa2h", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$0xa2", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, $$0xa2 +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t26() { +// CHECK: t26 __asm pushad +// CHECK: pushad __asm mov eax, 0 +// CHECK: mov eax, $$0 __asm __emit 0fh +// CHECK: .byte 0fh __asm __emit 0a2h +// CHECK: .byte 0a2h __asm __EMIT 0a2h +// CHECK: .byte 0a2h __asm popad -// FIXME: These all need to be merged into the same asm blob. -// CHECK: t26 -// CHECK: call void asm sideeffect inteldialect "pushad", "~{esp},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$0", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0fh", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0a2h", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".byte 0a2h", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "popad", "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"() +// CHECK: popad +// CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"() } void t27() { @@ -290,160 +289,171 @@ void t27() { } void t28() { +// CHECK: t28 __asm align 8 +// CHECK: .align 3 __asm align 16; +// CHECK: .align 4 __asm align 128; +// CHECK: .align 7 __asm ALIGN 256; -// CHECK: t28 -// CHECK: call void asm sideeffect inteldialect ".align 3", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".align 4", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".align 7", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect ".align 8", "~{dirflag},~{fpsr},~{flags}"() +// CHECK: .align 8 +// CHECK: "~{dirflag},~{fpsr},~{flags}"() } void t29() { +// CHECK: t29 int arr[2] = {0, 0}; int olen = 0, osize = 0, otype = 0; __asm mov olen, LENGTH arr +// CHECK: mov dword ptr $0, $$2 __asm mov osize, SIZE arr +// CHECK: mov dword ptr $1, $$8 __asm mov otype, TYPE arr -// CHECK: t29 -// CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, $$2", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, $$8", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, $$4", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) +// CHECK: mov dword ptr $2, $$4 +// CHECK: "=*m,=*m,=*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}) } int results[2] = {13, 37}; int *t30() +// CHECK: t30 { int *res; __asm lea edi, results +// CHECK: lea edi, dword ptr $2 __asm mov res, edi +// CHECK: mov dword ptr $0, edi return res; -// CHECK: t30 -// CHECK: call void asm sideeffect inteldialect "lea edi, dword ptr $0", "*m,~{edi},~{dirflag},~{fpsr},~{flags}"([2 x i32]* @{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, edi", "=*m,~{dirflag},~{fpsr},~{flags}"(i32** %{{.*}}) +// CHECK: "=*m,={eax},*m,~{edi},~{dirflag},~{fpsr},~{flags}"(i32** %{{.*}}, [2 x i32]* @{{.*}}) } void t31() { +// CHECK: t31 __asm pushad +// CHECK: pushad __asm popad -// CHECK: t31 -// CHECK: call void asm sideeffect inteldialect "pushad", "~{esp},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "popad", "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"() +// CHECK: popad +// CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"() } void t32() { +// CHECK: t32 int i; __asm mov eax, i +// CHECK: mov eax, dword ptr $0 __asm mov eax, dword ptr i +// CHECK: mov eax, dword ptr $1 __asm mov ax, word ptr i +// CHECK: mov ax, word ptr $2 __asm mov al, byte ptr i -// CHECK: t32 -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov ax, word ptr $0", "*m,~{ax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov al, byte ptr $0", "*m,~{al},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) +// CHECK: mov al, byte ptr $3 +// CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}) } void t33() { +// CHECK: t33 int i; __asm mov eax, [i] +// CHECK: mov eax, dword ptr $0 __asm mov eax, dword ptr [i] +// CHECK: mov eax, dword ptr $1 __asm mov ax, word ptr [i] +// CHECK: mov ax, word ptr $2 __asm mov al, byte ptr [i] -// CHECK: t33 -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov ax, word ptr $0", "*m,~{ax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) -// CHECK: call void asm sideeffect inteldialect "mov al, byte ptr $0", "*m,~{al},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}) +// CHECK: mov al, byte ptr $3 +// CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}) } void t34() { +// CHECK: t34 __asm prefetchnta 64[eax] +// CHECK: prefetchnta $$64[eax] __asm mov eax, dword ptr 4[eax] -// CHECK: t34 -// CHECK: call void asm sideeffect inteldialect "prefetchnta $$64[eax]", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4[eax]", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, dword ptr $$4[eax] +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t35() { +// CHECK: t35 __asm prefetchnta [eax + (200*64)] +// CHECK: prefetchnta [eax + ($$200*$$64)] __asm mov eax, dword ptr [eax + (200*64)] -// CHECK: t35 -// CHECK: call void asm sideeffect inteldialect "prefetchnta [eax + ($$200*$$64)]", "~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr [eax + ($$200*$$64)]", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, dword ptr [eax + ($$200*$$64)] +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t36() { - int arr[4]; - __asm mov eax, 4[arr] - __asm mov eax, 4[arr + 4] - __asm mov eax, 8[arr + 4 + 32*2 - 4] - __asm mov eax, 12[4 + arr] - __asm mov eax, 4[4 + arr + 4] - __asm mov eax, 4[64 + arr + (2*32)] - __asm mov eax, 4[64 + arr - 2*32] - __asm mov eax, [arr + 4] - __asm mov eax, [arr + 4 + 32*2 - 4] - __asm mov eax, [4 + arr] - __asm mov eax, [4 + arr + 4] - __asm mov eax, [64 + arr + (2*32)] - __asm mov eax, [64 + arr - 2*32] // CHECK: t36 + int arr[4]; + // Work around PR20368: These should be single line blocks + __asm { mov eax, 4[arr] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4[arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 8[arr + 4 + 32*2 - 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$72$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 12[4 + arr] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$16$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4[4 + arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$12$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4[64 + arr + (2*32)] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$132$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4[64 + arr - 2*32] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [arr + 4 + 32*2 - 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$64$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [4 + arr] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [4 + arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [64 + arr + (2*32)] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$128$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, [64 + arr - 2*32] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) } void t37() { +// CHECK: t37 __asm mov eax, 4 + 8 +// CHECK: mov eax, $$12 __asm mov eax, 4 + 8 * 16 +// CHECK: mov eax, $$132 __asm mov eax, -4 + 8 * 16 +// CHECK: mov eax, $$124 __asm mov eax, (4 + 4) * 16 +// CHECK: mov eax, $$128 __asm mov eax, 4 + 8 * -16 +// CHECK: mov eax, $$4294967172 __asm mov eax, 4 + 16 / -8 +// CHECK: mov eax, $$2 __asm mov eax, (16 + 16) / -8 +// CHECK: mov eax, $$4294967292 __asm mov eax, ~15 -// CHECK: t37 -// CHECK: call void asm sideeffect inteldialect "mov eax, $$12", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$132", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$124", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$128", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4294967172", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4294967292", "~{eax},~{dirflag},~{fpsr},~{flags}"() -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4294967280", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, $$4294967280 +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t38() { - int arr[4]; - __asm mov eax, 4+4[arr] - __asm mov eax, (4+4)[arr + 4] - __asm mov eax, 8*2[arr + 4 + 32*2 - 4] - __asm mov eax, 12+20[4 + arr] - __asm mov eax, 4*16+4[4 + arr + 4] - __asm mov eax, 4*4[64 + arr + (2*32)] - __asm mov eax, 4*(4-2)[64 + arr - 2*32] - __asm mov eax, 32*(4-2)[arr - 2*32] // CHECK: t38 + int arr[4]; + // Work around PR20368: These should be single line blocks + __asm { mov eax, 4+4[arr] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, (4+4)[arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$12$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 8*2[arr + 4 + 32*2 - 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$80$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 12+20[4 + arr] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$36$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4*16+4[4 + arr + 4] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$76$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4*4[64 + arr + (2*32)] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$144$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 4*(4-2)[64 + arr - 2*32] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) + __asm { mov eax, 32*(4-2)[arr - 2*32] } // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$0$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}}) } @@ -459,38 +469,87 @@ typedef struct { } A; void t39() { +// CHECK-LABEL: define void @t39 __asm mov eax, [eax].A.b +// CHECK: mov eax, [eax].4 __asm mov eax, [eax] A.b +// CHECK: mov eax, [eax] .4 __asm mov eax, fs:[0] A.b - // CHECK-LABEL: define void @t39 - // CHECK: call void asm sideeffect inteldialect "mov eax, [eax].4", "~{eax},~{dirflag},~{fpsr},~{flags}"() - // CHECK: call void asm sideeffect inteldialect "mov eax, [eax] .4", "~{eax},~{dirflag},~{fpsr},~{flags}"() - // CHECK: call void asm sideeffect inteldialect "mov eax, fs:[$$0] .4", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: mov eax, fs:[$$0] .4 +// CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"() } void t40(float a) { +// CHECK-LABEL: define void @t40 int i; __asm fld a +// CHECK: fld dword ptr $1 __asm fistp i - // CHECK-LABEL: define void @t40 - // CHECK: call void asm sideeffect inteldialect "fld dword ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(float* {{.*}}) - // CHECK: call void asm sideeffect inteldialect "fistp dword ptr $0", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* {{.*}}) +// CHECK: fistp dword ptr $0 +// CHECK: "=*m,*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, float* %{{.*}}) } void t41(unsigned short a) { +// CHECK-LABEL: define void @t41(i16 zeroext %a) __asm mov cs, a; +// CHECK: mov cs, word ptr $0 __asm mov ds, a; +// CHECK: mov ds, word ptr $1 __asm mov es, a; +// CHECK: mov es, word ptr $2 __asm mov fs, a; +// CHECK: mov fs, word ptr $3 __asm mov gs, a; +// CHECK: mov gs, word ptr $4 __asm mov ss, a; - // CHECK-LABEL: define void @t41(i16 zeroext %a) - // CHECK: [[T41_A_ADDR:%.+]] = alloca i16 - // CHECK: store i16 %a, i16* [[T41_A_ADDR]] - // CHECK: call void asm sideeffect inteldialect "mov cs, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) - // CHECK: call void asm sideeffect inteldialect "mov ds, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) - // CHECK: call void asm sideeffect inteldialect "mov es, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) - // CHECK: call void asm sideeffect inteldialect "mov fs, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) - // CHECK: call void asm sideeffect inteldialect "mov gs, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) - // CHECK: call void asm sideeffect inteldialect "mov ss, word ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(i16* [[T41_A_ADDR]]) +// CHECK: mov ss, word ptr $5 +// CHECK: "*m,*m,*m,*m,*m,*m,~{dirflag},~{fpsr},~{flags}"(i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}) +} + +void call_clobber() { + __asm call t41 + // CHECK-LABEL: define void @call_clobber + // CHECK: call void asm sideeffect inteldialect "call dword ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(void (i16)* @t41) +} + +void xgetbv() { + __asm xgetbv +} +// CHECK-LABEL: define void @xgetbv() +// CHECK: call void asm sideeffect inteldialect "xgetbv", "~{eax},~{edx},~{dirflag},~{fpsr},~{flags}"() + +void label1() { + __asm { + label: + jmp label + } + // CHECK-LABEL: define void @label1 + // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.1__label:\0A\09jmp {{.*}}__MSASMLABEL_.1__label", "~{dirflag},~{fpsr},~{flags}"() +} + +void label2() { + __asm { + jmp label + label: + } + // CHECK-LABEL: define void @label2 + // CHECK: call void asm sideeffect inteldialect "jmp {{.*}}__MSASMLABEL_.2__label\0A\09{{.*}}__MSASMLABEL_.2__label:", "~{dirflag},~{fpsr},~{flags}"() +} + +void label3() { + __asm { + label: + mov eax, label + } + // CHECK-LABEL: define void @label3 + // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.3__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.3__label", "~{eax},~{dirflag},~{fpsr},~{flags}"() +} + +void label4() { + __asm { + label: + mov eax, [label] + } + // CHECK-LABEL: define void @label4 + // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.4__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.4__label", "~{eax},~{dirflag},~{fpsr},~{flags}"() } diff --git a/test/CodeGen/ms-inline-asm.cpp b/test/CodeGen/ms-inline-asm.cpp index 83fe1075aff7..03d971e698b5 100644 --- a/test/CodeGen/ms-inline-asm.cpp +++ b/test/CodeGen/ms-inline-asm.cpp @@ -22,11 +22,7 @@ void t1() { __asm mov eax, dword ptr [Foo :: ptr] __asm mov eax, dword ptr [Foo :: ptr] // CHECK: @_Z2t1v -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3Bar3ptrE) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE) -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE) +// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0\0A\09mov eax, dword ptr $1\0A\09mov eax, dword ptr $2\0A\09mov eax, dword ptr $3\0A\09mov eax, dword ptr $4", "*m,*m,*m,*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE, i32** @_ZN3Foo3Bar3ptrE, i32** @_ZN3Foo3ptrE, i32** @_ZN3Foo3ptrE, i32** @_ZN3Foo3ptrE) } int gvar = 10; @@ -35,38 +31,26 @@ void t2() { __asm mov eax, offset Foo::ptr __asm mov eax, offset Foo::Bar::ptr // CHECK: t2 -// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE) -// CHECK: call void asm sideeffect inteldialect "mov eax, $0", "r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3Bar3ptrE) +// CHECK: call void asm sideeffect inteldialect "mov eax, $0\0A\09mov eax, $1", "r,r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32** @_ZN3Foo3ptrE, i32** @_ZN3Foo3Bar3ptrE) } // CHECK-LABEL: define void @_Z2t3v() void t3() { __asm mov eax, LENGTH Foo::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, LENGTH Foo::Bar::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, LENGTH Foo::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, LENGTH Foo::Bar::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, TYPE Foo::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, TYPE Foo::Bar::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, TYPE Foo::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, TYPE Foo::Bar::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, SIZE Foo::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, SIZE Foo::Bar::ptr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$4", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, SIZE Foo::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$16", "~{eax},~{dirflag},~{fpsr},~{flags}"() __asm mov eax, SIZE Foo::Bar::arr -// CHECK: call void asm sideeffect inteldialect "mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() +// CHECK: call void asm sideeffect inteldialect "mov eax, $$1\0A\09mov eax, $$1\0A\09mov eax, $$4\0A\09mov eax, $$2\0A\09mov eax, $$4\0A\09mov eax, $$4\0A\09mov eax, $$4\0A\09mov eax, $$1\0A\09mov eax, $$4\0A\09mov eax, $$4\0A\09mov eax, $$16\0A\09mov eax, $$2", "~{eax},~{dirflag},~{fpsr},~{flags}"() } @@ -82,9 +66,8 @@ void T4::test() { // CHECK: [[THIS:%.*]] = load [[T4]]** [[T0]] // CHECK: [[X:%.*]] = getelementptr inbounds [[T4]]* [[THIS]], i32 0, i32 0 __asm mov eax, x; -// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* [[X]]) __asm mov y, eax; -// CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, eax", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* @_ZN2T41yE) +// CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $1\0A\09mov dword ptr $0, eax", "=*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* @_ZN2T41yE, i32* {{.*}}) } template <class T> struct T5 { @@ -97,11 +80,9 @@ void test5() { // CHECK: [[Y:%.*]] = alloca i32 int x, y; __asm push y - // CHECK: call void asm sideeffect inteldialect "push dword ptr $0", "=*m,~{esp},~{dirflag},~{fpsr},~{flags}"(i32* [[Y]]) __asm call T5<int>::create<float> - // CHECK: call void asm sideeffect inteldialect "call $0", "r,~{dirflag},~{fpsr},~{flags}"(i32 (float)* @_ZN2T5IiE6createIfEEiT_) __asm mov x, eax - // CHECK: call void asm sideeffect inteldialect "mov dword ptr $0, eax", "=*m,~{dirflag},~{fpsr},~{flags}"(i32* [[X]]) + // CHECK: call void asm sideeffect inteldialect "push dword ptr $0\0A\09call dword ptr $2\0A\09mov dword ptr $1, eax", "=*m,=*m,*m,~{esp},~{dirflag},~{fpsr},~{flags}"(i32* %y, i32* %x, i32 (float)* @_ZN2T5IiE6createIfEEiT_) } // Just verify this doesn't emit an error. @@ -141,3 +122,20 @@ void t7_using() { // CHECK-LABEL: define void @_Z8t7_usingv // CHECK: call void asm sideeffect inteldialect "mov eax, [eax].4", "~{eax},~{dirflag},~{fpsr},~{flags}"() } + +void t8() { + __asm some_label: + // CHECK-LABEL: define void @_Z2t8v() + // CHECK: call void asm sideeffect inteldialect "L__MSASMLABEL_.1__some_label:", "~{dirflag},~{fpsr},~{flags}"() + struct A { + static void g() { + __asm jmp some_label ; This should jump forwards + __asm some_label: + __asm nop + // CHECK-LABEL: define internal void @_ZZ2t8vEN1A1gEv() + // CHECK: call void asm sideeffect inteldialect "jmp L__MSASMLABEL_.2__some_label\0A\09L__MSASMLABEL_.2__some_label:\0A\09nop", "~{dirflag},~{fpsr},~{flags}"() + } + }; + A::g(); +} + diff --git a/test/CodeGen/ms-intrinsics.c b/test/CodeGen/ms-intrinsics.c index fb0f62c61c4b..4498b34bc48d 100644 --- a/test/CodeGen/ms-intrinsics.c +++ b/test/CodeGen/ms-intrinsics.c @@ -1,15 +1,28 @@ -// RUN: %clang_cc1 -triple i686--windows -fms-compatibility -Oz -emit-llvm %s -o - | FileCheck %s -// RUN: %clang_cc1 -triple thumbv7--windows -fms-compatibility -Oz -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \ +// RUN: -triple i686--windows -Oz -emit-llvm %s -o - \ +// RUN: | FileCheck %s -check-prefix CHECK -check-prefix CHECK-I386 +// RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \ +// RUN: -triple thumbv7--windows -Oz -emit-llvm %s -o - \ +// RUN: | FileCheck %s +// RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \ +// RUN: -triple x86_64--windows -Oz -emit-llvm %s -o - \ +// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-X64 + +// Intrin.h needs size_t, but -ffreestanding prevents us from getting it from +// stddef.h. Work around it with this typedef. +typedef __SIZE_TYPE__ size_t; + +#include <Intrin.h> void *test_InterlockedExchangePointer(void * volatile *Target, void *Value) { return _InterlockedExchangePointer(Target, Value); } // CHECK: define{{.*}}i8* @test_InterlockedExchangePointer(i8** %Target, i8* %Value){{.*}}{ -// CHECK: %[[TARGET:[0-9]+]] = bitcast i8** %Target to i32* -// CHECK: %[[VALUE:[0-9]+]] = ptrtoint i8* %Value to i32 -// CHECK: %[[EXCHANGE:[0-9]+]] = atomicrmw xchg i32* %[[TARGET]], i32 %[[VALUE]] seq_cst -// CHECK: %[[RESULT:[0-9]+]] = inttoptr i32 %[[EXCHANGE]] to i8* +// CHECK: %[[TARGET:[0-9]+]] = bitcast i8** %Target to [[iPTR:i[0-9]+]]* +// CHECK: %[[VALUE:[0-9]+]] = ptrtoint i8* %Value to [[iPTR]] +// CHECK: %[[EXCHANGE:[0-9]+]] = atomicrmw xchg [[iPTR]]* %[[TARGET]], [[iPTR]] %[[VALUE]] seq_cst +// CHECK: %[[RESULT:[0-9]+]] = inttoptr [[iPTR]] %[[EXCHANGE]] to i8* // CHECK: ret i8* %[[RESULT]] // CHECK: } @@ -19,12 +32,12 @@ void *test_InterlockedCompareExchangePointer(void * volatile *Destination, } // CHECK: define{{.*}}i8* @test_InterlockedCompareExchangePointer(i8** %Destination, i8* %Exchange, i8* %Comparand){{.*}}{ -// CHECK: %[[DEST:[0-9]+]] = bitcast i8** %Destination to i32* -// CHECK: %[[EXCHANGE:[0-9]+]] = ptrtoint i8* %Exchange to i32 -// CHECK: %[[COMPARAND:[0-9]+]] = ptrtoint i8* %Comparand to i32 -// CHECK: %[[XCHG:[0-9]+]] = cmpxchg volatile i32* %[[DEST:[0-9]+]], i32 %[[COMPARAND:[0-9]+]], i32 %[[EXCHANGE:[0-9]+]] seq_cst seq_cst -// CHECK: %[[EXTRACT:[0-9]+]] = extractvalue { i32, i1 } %[[XCHG]], 0 -// CHECK: %[[RESULT:[0-9]+]] = inttoptr i32 %[[EXTRACT]] to i8* +// CHECK: %[[DEST:[0-9]+]] = bitcast i8** %Destination to [[iPTR]]* +// CHECK: %[[EXCHANGE:[0-9]+]] = ptrtoint i8* %Exchange to [[iPTR]] +// CHECK: %[[COMPARAND:[0-9]+]] = ptrtoint i8* %Comparand to [[iPTR]] +// CHECK: %[[XCHG:[0-9]+]] = cmpxchg volatile [[iPTR]]* %[[DEST:[0-9]+]], [[iPTR]] %[[COMPARAND:[0-9]+]], [[iPTR]] %[[EXCHANGE:[0-9]+]] seq_cst seq_cst +// CHECK: %[[EXTRACT:[0-9]+]] = extractvalue { [[iPTR]], i1 } %[[XCHG]], 0 +// CHECK: %[[RESULT:[0-9]+]] = inttoptr [[iPTR]] %[[EXTRACT]] to i8* // CHECK: ret i8* %[[RESULT:[0-9]+]] // CHECK: } @@ -36,3 +49,25 @@ long test_InterlockedExchange(long *Target, long Value) { // CHECK: %[[EXCHANGE:[0-9]+]] = atomicrmw xchg i32* %Target, i32 %Value seq_cst // CHECK: ret i32 %[[EXCHANGE:[0-9]+]] // CHECK: } + +#if defined(__i386__) +long test__readfsdword(unsigned long Offset) { + return __readfsdword(Offset); +} + +// CHECK-I386: define i32 @test__readfsdword(i32 %Offset){{.*}}{ +// CHECK-I386: [[PTR:%[0-9]+]] = inttoptr i32 %Offset to i32 addrspace(257)* +// CHECK-I386: [[VALUE:%[0-9]+]] = load volatile i32 addrspace(257)* [[PTR]], align 4 +// CHECK-I386: ret i32 [[VALUE:%[0-9]+]] +// CHECK-I386: } +#endif + +#if defined(__x86_64__) +unsigned __int64 test__umulh(unsigned __int64 a, unsigned __int64 b) { + return __umulh(a, b); +} +// CHECK-X64-LABEL: define i64 @test__umulh(i64 %a, i64 %b) +// CHECK-X64: = mul nuw i128 % + +#endif + diff --git a/test/CodeGen/mult-alt-generic.c b/test/CodeGen/mult-alt-generic.c index 6c9d789e412b..303edfcf3c42 100644 --- a/test/CodeGen/mult-alt-generic.c +++ b/test/CodeGen/mult-alt-generic.c @@ -17,7 +17,7 @@ int marray[2]; // CHECK: @single_m void single_m() { - // CHECK: call void asm "foo $1,$0", "=*m,*m[[CLOBBERS:[a-zA-Z0-9@%{},~_ ]*\"]](i32* {{[a-zA-Z0-9@%]+}}, i32* {{[a-zA-Z0-9@%]+}}) + // CHECK: call void asm "foo $1,$0", "=*m,*m[[CLOBBERS:[a-zA-Z0-9@%{},~_$ ]*\"]](i32* {{[a-zA-Z0-9@%]+}}, i32* {{[a-zA-Z0-9@%]+}}) asm("foo %1,%0" : "=m" (mout0) : "m" (min1)); } diff --git a/test/CodeGen/named_reg_global.c b/test/CodeGen/named_reg_global.c index 8117daef615c..d888a3ff1733 100644 --- a/test/CodeGen/named_reg_global.c +++ b/test/CodeGen/named_reg_global.c @@ -44,4 +44,4 @@ void fn2(struct p4_Thread *val) { // CHECK: call void @llvm.write_register.i[[bits]](metadata !0, i[[bits]] %[[regw]]) // CHECK: !llvm.named.register.sp = !{!0} -// CHECK: !0 = metadata !{metadata !"sp"} +// CHECK: !0 = !{!"sp"} diff --git a/test/CodeGen/nonnull.c b/test/CodeGen/nonnull.c index 4d6cc4568d8b..7c33e6329fdd 100644 --- a/test/CodeGen/nonnull.c +++ b/test/CodeGen/nonnull.c @@ -21,3 +21,31 @@ int * bar3() __attribute__((returns_nonnull)) { return &a; } +// CHECK: define i32 @bar4(i32 %n, i32* nonnull %p) +int bar4(int n, int *p) __attribute__((nonnull)) { + return n + *p; +} + +// CHECK: define i32 @bar5(i32 %n, i32* nonnull %p) +int bar5(int n, int *p) __attribute__((nonnull(1, 2))) { + return n + *p; +} + +typedef union { + unsigned long long n; + int *p; + double d; +} TransparentUnion __attribute__((transparent_union)); + +// CHECK: define i32 @bar6(i64 % +int bar6(TransparentUnion tu) __attribute__((nonnull(1))) { + return *tu.p; +} + +// CHECK: define void @bar7(i32* nonnull %a, i32* nonnull %b) +void bar7(int *a, int *b) __attribute__((nonnull(1))) +__attribute__((nonnull(2))) {} + +// CHECK: define void @bar8(i32* nonnull %a, i32* nonnull %b) +void bar8(int *a, int *b) __attribute__((nonnull)) +__attribute__((nonnull(1))) {} diff --git a/test/CodeGen/nvptx-abi.c b/test/CodeGen/nvptx-abi.c index f846def2de52..58ad6a17f242 100644 --- a/test/CodeGen/nvptx-abi.c +++ b/test/CodeGen/nvptx-abi.c @@ -5,13 +5,39 @@ typedef struct float4_s { float x, y, z, w; } float4_t; -float4_t my_function(void); - -// CHECK-DAG: declare %struct.float4_s @my_function +float4_t my_function(void) { +// CHECK-LABEL: define %struct.float4_s @my_function + float4_t t; + return t; +}; float bar(void) { float4_t ret; -// CHECK-DAG: call %struct.float4_s @my_function +// CHECK-LABEL: @bar +// CHECK: call %struct.float4_s @my_function ret = my_function(); return ret.x; } + +void foo(float4_t x) { +// CHECK-LABEL: @foo +// CHECK: %struct.float4_s* byval %x +} + +void fooN(float4_t x, float4_t y, float4_t z) { +// CHECK-LABEL: @fooN +// CHECK: %struct.float4_s* byval %x +// CHECK: %struct.float4_s* byval %y +// CHECK: %struct.float4_s* byval %z +} + +typedef struct nested_s { + unsigned long long x; + float z[64]; + float4_t t; +} nested_t; + +void baz(nested_t x) { +// CHECK-LABEL: @baz +// CHECK: %struct.nested_s* byval %x) +} diff --git a/test/CodeGen/piclevels.c b/test/CodeGen/piclevels.c new file mode 100644 index 000000000000..54744e2efa7d --- /dev/null +++ b/test/CodeGen/piclevels.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -emit-llvm -pic-level 2 %s -o - | FileCheck %s -check-prefix=CHECK-BIGPIC +// RUN: %clang_cc1 -emit-llvm -pic-level 1 %s -o - | FileCheck %s -check-prefix=CHECK-SMALLPIC + +// CHECK-BIGPIC: !llvm.module.flags = !{{{.*}}} +// CHECK-BIGPIC: !{{[0-9]+}} = !{i32 1, !"PIC Level", i32 2} +// CHECK-SMALLPIC: !llvm.module.flags = !{{{.*}}} +// CHECK-SMALLPIC: !{{[0-9]+}} = !{i32 1, !"PIC Level", i32 1} diff --git a/test/CodeGen/ppc-signbit.c b/test/CodeGen/ppc-signbit.c new file mode 100644 index 000000000000..31b71d8cdbb9 --- /dev/null +++ b/test/CodeGen/ppc-signbit.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -triple powerpc64-linux-gnu | FileCheck %s +// RUN: %clang_cc1 %s -emit-llvm -o - -triple powerpc64le-linux-gnu | FileCheck %s + +int test(long double x) { return __builtin_signbitl(x); } + +// CHECK-LABEL: define signext i32 @test(ppc_fp128 %x) +// CHECK: bitcast ppc_fp128 %{{.*}} to i128 +// CHECK: trunc i128 %{{.*}} to i64 +// CHECK: icmp slt i64 %{{.*}}, 0 +// CHECK: zext i1 %{{.*}} to i32 + diff --git a/test/CodeGen/ppc-varargs-struct.c b/test/CodeGen/ppc-varargs-struct.c new file mode 100644 index 000000000000..f0e075b048d7 --- /dev/null +++ b/test/CodeGen/ppc-varargs-struct.c @@ -0,0 +1,112 @@ +// REQUIRES: powerpc-registered-target +// REQUIRES: asserts +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple powerpc-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-PPC + +#include <stdarg.h> + +struct x { + long a; + double b; +}; + +void testva (int n, ...) +{ + va_list ap; + + struct x t = va_arg (ap, struct x); +// CHECK: bitcast i8* %{{[a-z.0-9]*}} to %struct.x* +// CHECK: bitcast %struct.x* %t to i8* +// CHECK: bitcast %struct.x* %{{[0-9]+}} to i8* +// CHECK: call void @llvm.memcpy +// CHECK-PPC: [[ARRAYDECAY:%[a-z0-9]+]] = getelementptr inbounds [1 x %struct.__va_list_tag]* %ap, i32 0, i32 0 +// CHECK-PPC-NEXT: [[GPRPTR:%[a-z0-9]+]] = bitcast %struct.__va_list_tag* [[ARRAYDECAY]] to i8* +// CHECK-PPC-NEXT: [[ZERO:%[0-9]+]] = ptrtoint i8* [[GPRPTR]] to i32 +// CHECK-PPC-NEXT: [[ONE:%[0-9]+]] = add i32 [[ZERO]], 1 +// CHECK-PPC-NEXT: [[TWO:%[0-9]+]] = inttoptr i32 [[ONE]] to i8* +// CHECK-PPC-NEXT: [[THREE:%[0-9]+]] = add i32 [[ONE]], 3 +// CHECK-PPC-NEXT: [[FOUR:%[0-9]+]] = inttoptr i32 [[THREE]] to i8** +// CHECK-PPC-NEXT: [[FIVE:%[0-9]+]] = add i32 [[THREE]], 4 +// CHECK-PPC-NEXT: [[SIX:%[0-9]+]] = inttoptr i32 [[FIVE]] to i8** +// CHECK-PPC-NEXT: [[GPR:%[a-z0-9]+]] = load i8* [[GPRPTR]] +// CHECK-PPC-NEXT: [[FPR:%[a-z0-9]+]] = load i8* [[TWO]] +// CHECK-PPC-NEXT: [[OVERFLOW_AREA:%[a-z_0-9]+]] = load i8** [[FOUR]] +// CHECK-PPC-NEXT: [[SEVEN:%[0-9]+]] = ptrtoint i8* [[OVERFLOW_AREA]] to i32 +// CHECK-PPC-NEXT: [[REGSAVE_AREA:%[a-z_0-9]+]] = load i8** [[SIX]] +// CHECK-PPC-NEXT: [[EIGHT:%[0-9]+]] = ptrtoint i8* [[REGSAVE_AREA]] to i32 +// CHECK-PPC-NEXT: [[COND:%[a-z0-9]+]] = icmp ult i8 [[GPR]], 8 +// CHECK-PPC-NEXT: [[NINE:%[0-9]+]] = mul i8 [[GPR]], 4 +// CHECK-PPC-NEXT: [[TEN:%[0-9]+]] = sext i8 [[NINE]] to i32 +// CHECK-PPC-NEXT: [[ELEVEN:%[0-9]+]] = add i32 [[EIGHT]], [[TEN]] +// CHECK-PPC-NEXT: br i1 [[COND]], label [[USING_REGS:%[a-z_0-9]+]], label [[USING_OVERFLOW:%[a-z_0-9]+]] +// +// CHECK-PPC1:[[USING_REGS]] +// CHECK-PPC: [[TWELVE:%[0-9]+]] = inttoptr i32 [[ELEVEN]] to %struct.x* +// CHECK-PPC-NEXT: [[THIRTEEN:%[0-9]+]] = add i8 [[GPR]], 1 +// CHECK-PPC-NEXT: store i8 [[THIRTEEN]], i8* [[GPRPTR]] +// CHECK-PPC-NEXT: br label [[CONT:%[a-z0-9]+]] +// +// CHECK-PPC1:[[USING_OVERFLOW]] +// CHECK-PPC: [[FOURTEEN:%[0-9]+]] = inttoptr i32 [[SEVEN]] to %struct.x* +// CHECK-PPC-NEXT: [[FIFTEEN:%[0-9]+]] = add i32 [[SEVEN]], 4 +// CHECK-PPC-NEXT: [[SIXTEEN:%[0-9]+]] = inttoptr i32 [[FIFTEEN]] to i8* +// CHECK-PPC-NEXT: store i8* [[SIXTEEN]], i8** [[FOUR]] +// CHECK-PPC-NEXT: br label [[CONT]] +// +// CHECK-PPC1:[[CONT]] +// CHECK-PPC: [[VAARG_ADDR:%[a-z.0-9]+]] = phi %struct.x* [ [[TWELVE]], [[USING_REGS]] ], [ [[FOURTEEN]], [[USING_OVERFLOW]] ] +// CHECK-PPC-NEXT: [[AGGRPTR:%[a-z0-9]+]] = bitcast %struct.x* [[VAARG_ADDR]] to i8** +// CHECK-PPC-NEXT: [[AGGR:%[a-z0-9]+]] = load i8** [[AGGRPTR]] +// CHECK-PPC-NEXT: [[SEVENTEEN:%[0-9]+]] = bitcast %struct.x* %t to i8* +// CHECK-PPC-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* [[SEVENTEEN]], i8* [[AGGR]], i32 16, i32 8, i1 false) + + int v = va_arg (ap, int); +// CHECK: ptrtoint i8* %{{[a-z.0-9]*}} to i64 +// CHECK: add i64 %{{[0-9]+}}, 4 +// CHECK: inttoptr i64 %{{[0-9]+}} to i8* +// CHECK: bitcast i8* %{{[0-9]+}} to i32* +// CHECK-PPC: [[ARRAYDECAY1:%[a-z0-9]+]] = getelementptr inbounds [1 x %struct.__va_list_tag]* %ap, i32 0, i32 0 +// CHECK-PPC-NEXT: [[GPRPTR1:%[a-z0-9]+]] = bitcast %struct.__va_list_tag* [[ARRAYDECAY1]] to i8* +// CHECK-PPC-NEXT: [[EIGHTEEN:%[0-9]+]] = ptrtoint i8* [[GPRPTR1]] to i32 +// CHECK-PPC-NEXT: [[NINETEEN:%[0-9]+]] = add i32 [[EIGHTEEN]], 1 +// CHECK-PPC-NEXT: [[TWENTY:%[0-9]+]] = inttoptr i32 [[NINETEEN]] to i8* +// CHECK-PPC-NEXT: [[TWENTYONE:%[0-9]+]] = add i32 [[NINETEEN]], 3 +// CHECK-PPC-NEXT: [[TWENTYTWO:%[0-9]+]] = inttoptr i32 [[TWENTYONE]] to i8** +// CHECK-PPC-NEXT: [[TWENTYTHREE:%[0-9]+]] = add i32 [[TWENTYONE]], 4 +// CHECK-PPC-NEXT: [[TWENTYFOUR:%[0-9]+]] = inttoptr i32 [[TWENTYTHREE]] to i8** +// CHECK-PPC-NEXT: [[GPR1:%[a-z0-9]+]] = load i8* [[GPRPTR1]] +// CHECK-PPC-NEXT: [[FPR1:%[a-z0-9]+]] = load i8* [[TWENTY]] +// CHECK-PPC-NEXT: [[OVERFLOW_AREA1:%[a-z_0-9]+]] = load i8** [[TWENTYTWO]] +// CHECK-PPC-NEXT: [[TWENTYFIVE:%[0-9]+]] = ptrtoint i8* [[OVERFLOW_AREA1]] to i32 +// CHECK-PPC-NEXT: [[REGSAVE_AREA1:%[a-z_0-9]+]] = load i8** [[TWENTYFOUR]] +// CHECK-PPC-NEXT: [[TWENTYSIX:%[0-9]+]] = ptrtoint i8* [[REGSAVE_AREA1]] to i32 +// CHECK-PPC-NEXT: [[COND1:%[a-z0-9]+]] = icmp ult i8 [[GPR1]], 8 +// CHECK-PPC-NEXT: [[TWENTYSEVEN:%[0-9]+]] = mul i8 [[GPR1]], 4 +// CHECK-PPC-NEXT: [[TWENTYEIGHT:%[0-9]+]] = sext i8 [[TWENTYSEVEN]] to i32 +// CHECK-PPC-NEXT: [[TWENTYNINE:%[0-9]+]] = add i32 [[TWENTYSIX]], [[TWENTYEIGHT]] +// CHECK-PPC-NEXT: br i1 [[COND1]], label [[USING_REGS1:%[a-z_0-9]+]], label [[USING_OVERFLOW1:%[a-z_0-9]+]] +// +// CHECK-PPC1:[[USING_REGS1]]: +// CHECK-PPC: [[THIRTY:%[0-9]+]] = inttoptr i32 [[TWENTYNINE]] to i32* +// CHECK-PPC-NEXT: [[THIRTYONE:%[0-9]+]] = add i8 [[GPR1]], 1 +// CHECK-PPC-NEXT: store i8 [[THIRTYONE]], i8* [[GPRPTR1]] +// CHECK-PPC-NEXT: br label [[CONT1:%[a-z0-9]+]] +// +// CHECK-PPC1:[[USING_OVERFLOW1]]: +// CHECK-PPC: [[THIRTYTWO:%[0-9]+]] = inttoptr i32 [[TWENTYFIVE]] to i32* +// CHECK-PPC-NEXT: [[THIRTYTHREE:%[0-9]+]] = add i32 [[TWENTYFIVE]], 4 +// CHECK-PPC-NEXT: [[THIRTYFOUR:%[0-9]+]] = inttoptr i32 [[THIRTYTHREE]] to i8* +// CHECK-PPC-NEXT: store i8* [[THIRTYFOUR]], i8** [[TWENTYTWO]] +// CHECK-PPC-NEXT: br label [[CONT1]] +// +// CHECK-PPC1:[[CONT1]]: +// CHECK-PPC: [[VAARG_ADDR1:%[a-z.0-9]+]] = phi i32* [ [[THIRTY]], [[USING_REGS1]] ], [ [[THIRTYTWO]], [[USING_OVERFLOW1]] ] +// CHECK-PPC-NEXT: [[THIRTYFIVE:%[0-9]+]] = load i32* [[VAARG_ADDR1]] +// CHECK-PPC-NEXT: store i32 [[THIRTYFIVE]], i32* %v, align 4 + +#ifdef __powerpc64__ + __int128_t u = va_arg (ap, __int128_t); +#endif +// CHECK: bitcast i8* %{{[a-z.0-9]+}} to i128* +// CHECK-NEXT: load i128* %{{[0-9]+}} +} diff --git a/test/CodeGen/ppc64-elf-abi.c b/test/CodeGen/ppc64-elf-abi.c new file mode 100644 index 000000000000..0dd183e2a6da --- /dev/null +++ b/test/CodeGen/ppc64-elf-abi.c @@ -0,0 +1,40 @@ +// REQUIRES: powerpc-registered-target + +// Verify ABI selection by the front end + +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: | FileCheck %s --check-prefix=CHECK-ELFv1 +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: -target-abi elfv1 | FileCheck %s --check-prefix=CHECK-ELFv1 +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: -target-abi elfv2 | FileCheck %s --check-prefix=CHECK-ELFv2 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: | FileCheck %s --check-prefix=CHECK-ELFv2 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: -target-abi elfv1 | FileCheck %s --check-prefix=CHECK-ELFv1 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s \ +// RUN: -target-abi elfv2 | FileCheck %s --check-prefix=CHECK-ELFv2 + +// CHECK-ELFv1: define void @func_fab(%struct.fab* noalias sret %agg.result, i64 %x.coerce) +// CHECK-ELFv2: define [2 x float] @func_fab([2 x float] %x.coerce) +struct fab { float a; float b; }; +struct fab func_fab(struct fab x) { return x; } + +// Verify ABI choice is passed on to the back end + +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -S -o - %s \ +// RUN: | FileCheck %s --check-prefix=CHECK-ASM-ELFv1 +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -S -o - %s \ +// RUN: -target-abi elfv1 | FileCheck %s --check-prefix=CHECK-ASM-ELFv1 +// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -S -o - %s \ +// RUN: -target-abi elfv2 | FileCheck %s --check-prefix=CHECK-ASM-ELFv2 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -S -o - %s \ +// RUN: | FileCheck %s --check-prefix=CHECK-ASM-ELFv2 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -S -o - %s \ +// RUN: -target-abi elfv1 | FileCheck %s --check-prefix=CHECK-ASM-ELFv1 +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -S -o - %s \ +// RUN: -target-abi elfv2 | FileCheck %s --check-prefix=CHECK-ASM-ELFv2 + +// CHECK-ASM-ELFv2: .abiversion 2 +// CHECK-ASM-ELFv1-NOT: .abiversion 2 + diff --git a/test/CodeGen/ppc64-varargs-struct.c b/test/CodeGen/ppc64-varargs-struct.c deleted file mode 100644 index 70b242c7f417..000000000000 --- a/test/CodeGen/ppc64-varargs-struct.c +++ /dev/null @@ -1,30 +0,0 @@ -// REQUIRES: powerpc-registered-target -// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s - -#include <stdarg.h> - -struct x { - long a; - double b; -}; - -void testva (int n, ...) -{ - va_list ap; - - struct x t = va_arg (ap, struct x); -// CHECK: bitcast i8* %{{[a-z.0-9]*}} to %struct.x* -// CHECK: bitcast %struct.x* %t to i8* -// CHECK: bitcast %struct.x* %{{[0-9]+}} to i8* -// CHECK: call void @llvm.memcpy - - int v = va_arg (ap, int); -// CHECK: ptrtoint i8* %{{[a-z.0-9]*}} to i64 -// CHECK: add i64 %{{[0-9]+}}, 4 -// CHECK: inttoptr i64 %{{[0-9]+}} to i8* -// CHECK: bitcast i8* %{{[0-9]+}} to i32* - - __int128_t u = va_arg (ap, __int128_t); -// CHECK: bitcast i8* %{{[a-z.0-9]+}} to i128* -// CHECK-NEXT: load i128* %{{[0-9]+}} -} diff --git a/test/CodeGen/ppc64le-aggregates.c b/test/CodeGen/ppc64le-aggregates.c index acf34a8a8012..e193dcc3faef 100644 --- a/test/CodeGen/ppc64le-aggregates.c +++ b/test/CodeGen/ppc64le-aggregates.c @@ -1,4 +1,3 @@ -// REQUIRES: powerpc-registered-target // RUN: %clang_cc1 -faltivec -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s // Test homogeneous float aggregate passing and returning. @@ -16,6 +15,8 @@ struct f9 { float f[9]; }; struct fab { float a; float b; }; struct fabc { float a; float b; float c; }; +struct f2a2b { float a[2]; float b[2]; }; + // CHECK: define [1 x float] @func_f1(float inreg %x.coerce) struct f1 func_f1(struct f1 x) { return x; } @@ -49,6 +50,9 @@ struct fab func_fab(struct fab x) { return x; } // CHECK: define [3 x float] @func_fabc([3 x float] %x.coerce) struct fabc func_fabc(struct fabc x) { return x; } +// CHECK: define [4 x float] @func_f2a2b([4 x float] %x.coerce) +struct f2a2b func_f2a2b(struct f2a2b x) { return x; } + // CHECK-LABEL: @call_f1 // CHECK: %[[TMP:[^ ]+]] = load float* getelementptr inbounds (%struct.f1* @global_f1, i32 0, i32 0, i32 0), align 1 // CHECK: call [1 x float] @func_f1(float inreg %[[TMP]]) diff --git a/test/CodeGen/pr5406.c b/test/CodeGen/pr5406.c index 2d198220a770..0f04a8e069cd 100644 --- a/test/CodeGen/pr5406.c +++ b/test/CodeGen/pr5406.c @@ -6,7 +6,7 @@ typedef struct { char x[3]; } A0; void foo (int i, ...); -// CHECK: call arm_aapcscc void (i32, ...)* @foo(i32 1, [1 x i32] {{.*}}) +// CHECK: call void (i32, ...)* @foo(i32 1, [1 x i32] {{.*}}) int main (void) { A0 a3; diff --git a/test/CodeGen/pragma-comment.c b/test/CodeGen/pragma-comment.c index 73cc5483bcf6..221cfc87f919 100644 --- a/test/CodeGen/pragma-comment.c +++ b/test/CodeGen/pragma-comment.c @@ -10,14 +10,14 @@ #pragma comment(linker," /bar=" BAR) // CHECK: !llvm.module.flags = !{{{.*}}} -// CHECK: !{{[0-9]+}} = metadata !{i32 6, metadata !"Linker Options", metadata ![[link_opts:[0-9]+]]} -// CHECK: ![[link_opts]] = metadata !{metadata ![[msvcrt:[0-9]+]], metadata ![[kernel32:[0-9]+]], metadata ![[USER32:[0-9]+]], metadata ![[bar:[0-9]+]]} -// CHECK: ![[msvcrt]] = metadata !{metadata !"/DEFAULTLIB:msvcrt.lib"} -// CHECK: ![[kernel32]] = metadata !{metadata !"/DEFAULTLIB:kernel32.lib"} -// CHECK: ![[USER32]] = metadata !{metadata !"/DEFAULTLIB:USER32.LIB"} -// CHECK: ![[bar]] = metadata !{metadata !" /bar=2"} +// CHECK: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[link_opts:[0-9]+]]} +// CHECK: ![[link_opts]] = !{![[msvcrt:[0-9]+]], ![[kernel32:[0-9]+]], ![[USER32:[0-9]+]], ![[bar:[0-9]+]]} +// CHECK: ![[msvcrt]] = !{!"/DEFAULTLIB:msvcrt.lib"} +// CHECK: ![[kernel32]] = !{!"/DEFAULTLIB:kernel32.lib"} +// CHECK: ![[USER32]] = !{!"/DEFAULTLIB:USER32.LIB"} +// CHECK: ![[bar]] = !{!" /bar=2"} -// LINUX: metadata !{metadata !"-lmsvcrt.lib"} -// LINUX: metadata !{metadata !"-lkernel32"} -// LINUX: metadata !{metadata !"-lUSER32.LIB"} -// LINUX: metadata !{metadata !" /bar=2"} +// LINUX: !{!"-lmsvcrt.lib"} +// LINUX: !{!"-lkernel32"} +// LINUX: !{!"-lUSER32.LIB"} +// LINUX: !{!" /bar=2"} diff --git a/test/CodeGen/pragma-detect_mismatch.c b/test/CodeGen/pragma-detect_mismatch.c index b223a61c9b03..c5f3af340aae 100644 --- a/test/CodeGen/pragma-detect_mismatch.c +++ b/test/CodeGen/pragma-detect_mismatch.c @@ -1,12 +1,12 @@ -// RUN: %clang_cc1 %s -triple i686-pc-win32 -fms-extensions -emit-llvm -o - | FileCheck %s
-
-#pragma detect_mismatch("test", "1")
-
-#define BAR "2"
-#pragma detect_mismatch("test2", BAR)
-
-// CHECK: !llvm.module.flags = !{{{.*}}}
-// CHECK: !{{[0-9]+}} = metadata !{i32 6, metadata !"Linker Options", metadata ![[link_opts:[0-9]+]]}
-// CHECK: ![[link_opts]] = metadata !{metadata ![[test:[0-9]+]], metadata ![[test2:[0-9]+]]}
-// CHECK: ![[test]] = metadata !{metadata !"/FAILIFMISMATCH:\22test=1\22"}
-// CHECK: ![[test2]] = metadata !{metadata !"/FAILIFMISMATCH:\22test2=2\22"}
+// RUN: %clang_cc1 %s -triple i686-pc-win32 -fms-extensions -emit-llvm -o - | FileCheck %s + +#pragma detect_mismatch("test", "1") + +#define BAR "2" +#pragma detect_mismatch("test2", BAR) + +// CHECK: !llvm.module.flags = !{{{.*}}} +// CHECK: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[link_opts:[0-9]+]]} +// CHECK: ![[link_opts]] = !{![[test:[0-9]+]], ![[test2:[0-9]+]]} +// CHECK: ![[test]] = !{!"/FAILIFMISMATCH:\22test=1\22"} +// CHECK: ![[test2]] = !{!"/FAILIFMISMATCH:\22test2=2\22"} diff --git a/test/CodeGen/pragma-loop.cpp b/test/CodeGen/pragma-loop.cpp index bdcd30426315..dd40c1d72600 100644 --- a/test/CodeGen/pragma-loop.cpp +++ b/test/CodeGen/pragma-loop.cpp @@ -8,7 +8,7 @@ void while_test(int *List, int Length) { #pragma clang loop vectorize(enable) #pragma clang loop interleave_count(4) #pragma clang loop vectorize_width(4) -#pragma clang loop unroll(enable) +#pragma clang loop unroll(full) while (i < Length) { // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_1:.*]] List[i] = i * 2; @@ -28,11 +28,13 @@ void do_test(int *List, int Length) { } while (i < Length); } +enum struct Tuner : short { Interleave = 4, Unroll = 8 }; + // Verify for loop is recognized after sequence of pragma clang loop directives. void for_test(int *List, int Length) { #pragma clang loop interleave(enable) -#pragma clang loop interleave_count(4) -#pragma clang loop unroll_count(8) +#pragma clang loop interleave_count(static_cast<int>(Tuner::Interleave)) +#pragma clang loop unroll_count(static_cast<int>(Tuner::Unroll)) for (int i = 0; i < Length; i++) { // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_3:.*]] List[i] = i * 2; @@ -74,28 +76,74 @@ void for_define_test(int *List, int Length, int Value) { } } +// Verify constant expressions are handled correctly. +void for_contant_expression_test(int *List, int Length) { +#pragma clang loop vectorize_width(1 + 4) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_7:.*]] + List[i] = i; + } + +#pragma clang loop vectorize_width(3 + VECWIDTH) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_8:.*]] + List[i] += i; + } +} + // Verify metadata is generated when template is used. template <typename A> void for_template_test(A *List, int Length, A Value) { - #pragma clang loop vectorize_width(8) interleave_count(8) unroll_count(8) for (int i = 0; i < Length; i++) { - // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_7:.*]] + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_9:.*]] List[i] = i * Value; } } // Verify define is resolved correctly when template is used. -template <typename A> +template <typename A, typename T> void for_template_define_test(A *List, int Length, A Value) { -#pragma clang loop vectorize_width(VECWIDTH) interleave_count(INTCOUNT) -#pragma clang loop unroll_count(UNROLLCOUNT) + const T VWidth = VECWIDTH; + const T ICount = INTCOUNT; + const T UCount = UNROLLCOUNT; +#pragma clang loop vectorize_width(VWidth) interleave_count(ICount) +#pragma clang loop unroll_count(UCount) for (int i = 0; i < Length; i++) { - // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_8:.*]] + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_10:.*]] List[i] = i * Value; } } +// Verify templates and constant expressions are handled correctly. +template <typename A, int V, int I, int U> +void for_template_constant_expression_test(A *List, int Length) { +#pragma clang loop vectorize_width(V) interleave_count(I) unroll_count(U) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_11:.*]] + List[i] = i; + } + +#pragma clang loop vectorize_width(V * 2 + VECWIDTH) interleave_count(I * 2 + INTCOUNT) unroll_count(U * 2 + UNROLLCOUNT) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_12:.*]] + List[i] += i; + } + + const int Scale = 4; +#pragma clang loop vectorize_width(Scale * V) interleave_count(Scale * I) unroll_count(Scale * U) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_13:.*]] + List[i] += i; + } + +#pragma clang loop vectorize_width((Scale * V) + 2) + for (int i = 0; i < Length; i++) { + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_14:.*]] + List[i] += i; + } +} + #undef VECWIDTH #undef INTCOUNT #undef UNROLLCOUNT @@ -105,25 +153,39 @@ void template_test(double *List, int Length) { double Value = 10; for_template_test<double>(List, Length, Value); - for_template_define_test<double>(List, Length, Value); + for_template_define_test<double, int>(List, Length, Value); + for_template_constant_expression_test<double, 2, 4, 8>(List, Length); } -// CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata ![[UNROLLENABLE_1:.*]], metadata ![[WIDTH_4:.*]], metadata ![[INTERLEAVE_4:.*]], metadata ![[INTENABLE_1:.*]]} -// CHECK: ![[UNROLLENABLE_1]] = metadata !{metadata !"llvm.loop.unroll.enable", i1 true} -// CHECK: ![[WIDTH_4]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 4} -// CHECK: ![[INTERLEAVE_4]] = metadata !{metadata !"llvm.loop.interleave.count", i32 4} -// CHECK: ![[INTENABLE_1]] = metadata !{metadata !"llvm.loop.vectorize.enable", i1 true} -// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]], metadata ![[UNROLLENABLE_0:.*]], metadata ![[INTERLEAVE_4:.*]], metadata ![[WIDTH_8:.*]]} -// CHECK: ![[UNROLLENABLE_0]] = metadata !{metadata !"llvm.loop.unroll.enable", i1 false} -// CHECK: ![[WIDTH_8]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 8} -// CHECK: ![[LOOP_3]] = metadata !{metadata ![[LOOP_3]], metadata ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_4:.*]], metadata ![[ENABLE_1:.*]]} -// CHECK: ![[UNROLL_8]] = metadata !{metadata !"llvm.loop.unroll.count", i32 8} -// CHECK: ![[LOOP_4]] = metadata !{metadata ![[LOOP_4]], metadata ![[INTERLEAVE_2:.*]], metadata ![[WIDTH_2:.*]]} -// CHECK: ![[INTERLEAVE_2]] = metadata !{metadata !"llvm.loop.interleave.count", i32 2} -// CHECK: ![[WIDTH_2]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 2} -// CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], metadata ![[UNROLLENABLE_0:.*]], metadata ![[WIDTH_1:.*]]} -// CHECK: ![[WIDTH_1]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 1} -// CHECK: ![[LOOP_6]] = metadata !{metadata ![[LOOP_6]], metadata ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_2:.*]], metadata ![[WIDTH_2:.*]]} -// CHECK: ![[LOOP_7]] = metadata !{metadata ![[LOOP_7]], metadata ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_8:.*]], metadata ![[WIDTH_8:.*]]} -// CHECK: ![[INTERLEAVE_8]] = metadata !{metadata !"llvm.loop.interleave.count", i32 8} -// CHECK: ![[LOOP_8]] = metadata !{metadata ![[LOOP_8]], metadata ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_2:.*]], metadata ![[WIDTH_2:.*]]} +// CHECK: ![[LOOP_1]] = distinct !{![[LOOP_1]], ![[UNROLL_FULL:.*]], ![[WIDTH_4:.*]], ![[INTERLEAVE_4:.*]], ![[INTENABLE_1:.*]]} +// CHECK: ![[UNROLL_FULL]] = !{!"llvm.loop.unroll.full"} +// CHECK: ![[WIDTH_4]] = !{!"llvm.loop.vectorize.width", i32 4} +// CHECK: ![[INTERLEAVE_4]] = !{!"llvm.loop.interleave.count", i32 4} +// CHECK: ![[INTENABLE_1]] = !{!"llvm.loop.vectorize.enable", i1 true} +// CHECK: ![[LOOP_2]] = distinct !{![[LOOP_2:.*]], ![[UNROLL_DISABLE:.*]], ![[INTERLEAVE_4:.*]], ![[WIDTH_8:.*]]} +// CHECK: ![[UNROLL_DISABLE]] = !{!"llvm.loop.unroll.disable"} +// CHECK: ![[WIDTH_8]] = !{!"llvm.loop.vectorize.width", i32 8} +// CHECK: ![[LOOP_3]] = distinct !{![[LOOP_3]], ![[UNROLL_8:.*]], ![[INTERLEAVE_4:.*]], ![[ENABLE_1:.*]]} +// CHECK: ![[UNROLL_8]] = !{!"llvm.loop.unroll.count", i32 8} +// CHECK: ![[LOOP_4]] = distinct !{![[LOOP_4]], ![[INTERLEAVE_2:.*]], ![[WIDTH_2:.*]]} +// CHECK: ![[INTERLEAVE_2]] = !{!"llvm.loop.interleave.count", i32 2} +// CHECK: ![[WIDTH_2]] = !{!"llvm.loop.vectorize.width", i32 2} +// CHECK: ![[LOOP_5]] = distinct !{![[LOOP_5]], ![[UNROLL_DISABLE:.*]], ![[WIDTH_1:.*]]} +// CHECK: ![[WIDTH_1]] = !{!"llvm.loop.vectorize.width", i32 1} +// CHECK: ![[LOOP_6]] = distinct !{![[LOOP_6]], ![[UNROLL_8:.*]], ![[INTERLEAVE_2:.*]], ![[WIDTH_2:.*]]} +// CHECK: ![[LOOP_7]] = distinct !{![[LOOP_7]], ![[WIDTH_5:.*]]} +// CHECK: ![[WIDTH_5]] = !{!"llvm.loop.vectorize.width", i32 5} +// CHECK: ![[LOOP_8]] = distinct !{![[LOOP_8]], ![[WIDTH_5:.*]]} +// CHECK: ![[LOOP_9]] = distinct !{![[LOOP_9]], ![[UNROLL_8:.*]], ![[INTERLEAVE_8:.*]], ![[WIDTH_8:.*]]} +// CHECK: ![[INTERLEAVE_8]] = !{!"llvm.loop.interleave.count", i32 8} +// CHECK: ![[LOOP_10]] = distinct !{![[LOOP_10]], ![[UNROLL_8:.*]], ![[INTERLEAVE_2:.*]], ![[WIDTH_2:.*]]} +// CHECK: ![[LOOP_11]] = distinct !{![[LOOP_11]], ![[UNROLL_8:.*]], ![[INTERLEAVE_4:.*]], ![[WIDTH_2:.*]]} +// CHECK: ![[LOOP_12]] = distinct !{![[LOOP_12]], ![[UNROLL_24:.*]], ![[INTERLEAVE_10:.*]], ![[WIDTH_6:.*]]} +// CHECK: ![[UNROLL_24]] = !{!"llvm.loop.unroll.count", i32 24} +// CHECK: ![[INTERLEAVE_10]] = !{!"llvm.loop.interleave.count", i32 10} +// CHECK: ![[WIDTH_6]] = !{!"llvm.loop.vectorize.width", i32 6} +// CHECK: ![[LOOP_13]] = distinct !{![[LOOP_13]], ![[UNROLL_32:.*]], ![[INTERLEAVE_16:.*]], ![[WIDTH_8:.*]]} +// CHECK: ![[UNROLL_32]] = !{!"llvm.loop.unroll.count", i32 32} +// CHECK: ![[INTERLEAVE_16]] = !{!"llvm.loop.interleave.count", i32 16} +// CHECK: ![[LOOP_14]] = distinct !{![[LOOP_14]], ![[WIDTH_10:.*]]} +// CHECK: ![[WIDTH_10]] = !{!"llvm.loop.vectorize.width", i32 10} diff --git a/test/CodeGen/pragma-unroll.cpp b/test/CodeGen/pragma-unroll.cpp index b321e74a1154..8b73fa6c8aab 100644 --- a/test/CodeGen/pragma-unroll.cpp +++ b/test/CodeGen/pragma-unroll.cpp @@ -17,7 +17,7 @@ void while_test(int *List, int Length) { void do_test(int *List, int Length) { int i = 0; -#pragma unroll 16 +#pragma nounroll do { // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_2:.*]] List[i] = i * 2; @@ -86,14 +86,14 @@ void template_test(double *List, int Length) { for_template_define_test<double>(List, Length, Value); } -// CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata ![[UNROLLENABLE_1:.*]]} -// CHECK: ![[UNROLLENABLE_1]] = metadata !{metadata !"llvm.loop.unroll.enable", i1 true} -// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]], metadata ![[UNROLL_16:.*]]} -// CHECK: ![[UNROLL_16]] = metadata !{metadata !"llvm.loop.unroll.count", i32 16} -// CHECK: ![[LOOP_3]] = metadata !{metadata ![[LOOP_3]], metadata ![[UNROLL_8:.*]]} -// CHECK: ![[UNROLL_8]] = metadata !{metadata !"llvm.loop.unroll.count", i32 8} -// CHECK: ![[LOOP_4]] = metadata !{metadata ![[LOOP_4]], metadata ![[UNROLL_4:.*]]} -// CHECK: ![[UNROLL_4]] = metadata !{metadata !"llvm.loop.unroll.count", i32 4} -// CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], metadata ![[UNROLL_8:.*]]} -// CHECK: ![[LOOP_6]] = metadata !{metadata ![[LOOP_6]], metadata ![[UNROLL_8:.*]]} -// CHECK: ![[LOOP_7]] = metadata !{metadata ![[LOOP_7]], metadata ![[UNROLL_8:.*]]} +// CHECK: ![[LOOP_1]] = distinct !{![[LOOP_1]], ![[UNROLL_FULL:.*]]} +// CHECK: ![[UNROLL_FULL]] = !{!"llvm.loop.unroll.full"} +// CHECK: ![[LOOP_2]] = distinct !{![[LOOP_2:.*]], ![[UNROLL_DISABLE:.*]]} +// CHECK: ![[UNROLL_DISABLE]] = !{!"llvm.loop.unroll.disable"} +// CHECK: ![[LOOP_3]] = distinct !{![[LOOP_3]], ![[UNROLL_8:.*]]} +// CHECK: ![[UNROLL_8]] = !{!"llvm.loop.unroll.count", i32 8} +// CHECK: ![[LOOP_4]] = distinct !{![[LOOP_4]], ![[UNROLL_4:.*]]} +// CHECK: ![[UNROLL_4]] = !{!"llvm.loop.unroll.count", i32 4} +// CHECK: ![[LOOP_5]] = distinct !{![[LOOP_5]], ![[UNROLL_8:.*]]} +// CHECK: ![[LOOP_6]] = distinct !{![[LOOP_6]], ![[UNROLL_8:.*]]} +// CHECK: ![[LOOP_7]] = distinct !{![[LOOP_7]], ![[UNROLL_8:.*]]} diff --git a/test/CodeGen/pragma-weak.c b/test/CodeGen/pragma-weak.c index b5d186324bf6..aba98e185b4e 100644 --- a/test/CodeGen/pragma-weak.c +++ b/test/CodeGen/pragma-weak.c @@ -7,16 +7,16 @@ // CHECK-DAG: @both = alias void ()* @__both // CHECK-DAG: @both2 = alias void ()* @__both2 -// CHECK-DAG: @weakvar_alias = alias weak i32* @__weakvar_alias -// CHECK-DAG: @foo = alias weak void ()* @__foo -// CHECK-DAG: @foo2 = alias weak void ()* @__foo2 -// CHECK-DAG: @stutter = alias weak void ()* @__stutter -// CHECK-DAG: @stutter2 = alias weak void ()* @__stutter2 -// CHECK-DAG: @declfirst = alias weak void ()* @__declfirst -// CHECK-DAG: @declfirstattr = alias weak void ()* @__declfirstattr -// CHECK-DAG: @mix2 = alias weak void ()* @__mix2 -// CHECK-DAG: @a1 = alias weak void ()* @__a1 -// CHECK-DAG: @xxx = alias weak void ()* @__xxx +// CHECK-DAG: @weakvar_alias = weak alias i32* @__weakvar_alias +// CHECK-DAG: @foo = weak alias void ()* @__foo +// CHECK-DAG: @foo2 = weak alias void ()* @__foo2 +// CHECK-DAG: @stutter = weak alias void ()* @__stutter +// CHECK-DAG: @stutter2 = weak alias void ()* @__stutter2 +// CHECK-DAG: @declfirst = weak alias void ()* @__declfirst +// CHECK-DAG: @declfirstattr = weak alias void ()* @__declfirstattr +// CHECK-DAG: @mix2 = weak alias void ()* @__mix2 +// CHECK-DAG: @a1 = weak alias void ()* @__a1 +// CHECK-DAG: @xxx = weak alias void ()* @__xxx diff --git a/test/CodeGen/predefined-expr.c b/test/CodeGen/predefined-expr.c index 6c94152b737e..3ccdeb3b4ce3 100644 --- a/test/CodeGen/predefined-expr.c +++ b/test/CodeGen/predefined-expr.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -// RUN: %clang_cc1 -fms-extensions %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -fms-extensions %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s // CHECK: @__func__.plainFunction = private unnamed_addr constant [14 x i8] c"plainFunction\00" // CHECK: @__PRETTY_FUNCTION__.plainFunction = private unnamed_addr constant [21 x i8] c"void plainFunction()\00" diff --git a/test/CodeGen/sanitize-address-field-padding.cpp b/test/CodeGen/sanitize-address-field-padding.cpp new file mode 100644 index 000000000000..d4eea1b9e69d --- /dev/null +++ b/test/CodeGen/sanitize-address-field-padding.cpp @@ -0,0 +1,237 @@ +// Test -fsanitize-address-field-padding +// RUN: echo 'type:SomeNamespace::BlacklistedByName=field-padding' > %t.type.blacklist +// RUN: echo 'src:*sanitize-address-field-padding.cpp=field-padding' > %t.file.blacklist +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsanitize=address -fsanitize-address-field-padding=1 -fsanitize-blacklist=%t.type.blacklist -Rsanitize-address -emit-llvm -o - %s 2>&1 | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsanitize=address -fsanitize-address-field-padding=1 -fsanitize-blacklist=%t.type.blacklist -Rsanitize-address -emit-llvm -o - %s -O1 -mconstructor-aliases 2>&1 | FileCheck %s --check-prefix=WITH_CTOR_ALIASES +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsanitize=address -fsanitize-address-field-padding=1 -fsanitize-blacklist=%t.file.blacklist -Rsanitize-address -emit-llvm -o - %s 2>&1 | FileCheck %s --check-prefix=FILE_BLACKLIST +// RUN: %clang_cc1 -fsanitize=address -emit-llvm -o - %s 2>&1 | FileCheck %s --check-prefix=NO_PADDING +// + +// The reasons to ignore a particular class are not set in stone and will change. +// +// CHECK: -fsanitize-address-field-padding applied to Positive1 +// CHECK: -fsanitize-address-field-padding ignored for Negative1 because it is trivially copyable +// CHECK: -fsanitize-address-field-padding ignored for Negative2 because it is trivially copyable +// CHECK: -fsanitize-address-field-padding ignored for Negative3 because it is a union +// CHECK: -fsanitize-address-field-padding ignored for Negative4 because it is trivially copyable +// CHECK: -fsanitize-address-field-padding ignored for Negative5 because it is packed +// CHECK: -fsanitize-address-field-padding ignored for SomeNamespace::BlacklistedByName because it is blacklisted +// CHECK: -fsanitize-address-field-padding ignored for ExternCStruct because it is not C++ +// +// FILE_BLACKLIST: -fsanitize-address-field-padding ignored for Positive1 because it is in a blacklisted file +// FILE_BLACKLIST-NOT: __asan_poison_intra_object_redzone +// NO_PADDING-NOT: __asan_poison_intra_object_redzone + + +class Positive1 { + public: + Positive1() {} + ~Positive1() {} + int make_it_non_standard_layout; + private: + char private1; + int private2; + short private_array[6]; + long long private3; +}; + +Positive1 positive1; +// Positive1 with extra paddings +// CHECK: type { i32, [12 x i8], i8, [15 x i8], i32, [12 x i8], [6 x i16], [12 x i8], i64, [8 x i8] } + +struct VirtualBase { + int foo; +}; + +class ClassWithVirtualBase : public virtual VirtualBase { + public: + ClassWithVirtualBase() {} + ~ClassWithVirtualBase() {} + int make_it_non_standard_layout; + private: + char x[7]; + char y[9]; +}; + +ClassWithVirtualBase class_with_virtual_base; + +class WithFlexibleArray1 { + public: + WithFlexibleArray1() {} + ~WithFlexibleArray1() {} + int make_it_non_standard_layout; + private: + char private1[33]; + int flexible[]; // Don't insert padding after this field. +}; + +WithFlexibleArray1 with_flexible_array1; +// CHECK: %class.WithFlexibleArray1 = type { i32, [12 x i8], [33 x i8], [15 x i8], [0 x i32] } + +class WithFlexibleArray2 { + public: + char x[21]; + WithFlexibleArray1 flex1; // Don't insert padding after this field. +}; + +WithFlexibleArray2 with_flexible_array2; +// CHECK: %class.WithFlexibleArray2 = type { [21 x i8], [11 x i8], %class.WithFlexibleArray1 } + +class WithFlexibleArray3 { + public: + char x[13]; + WithFlexibleArray2 flex2; // Don't insert padding after this field. +}; + +WithFlexibleArray3 with_flexible_array3; + + +class Negative1 { + public: + Negative1() {} + int public1, public2; +}; +Negative1 negative1; +// CHECK: type { i32, i32 } + +class Negative2 { + public: + Negative2() {} + private: + int private1, private2; +}; +Negative2 negative2; +// CHECK: type { i32, i32 } + +union Negative3 { + char m1[8]; + long long m2; +}; + +Negative3 negative3; +// CHECK: type { i64 } + +class Negative4 { + public: + Negative4() {} + // No DTOR + int make_it_non_standard_layout; + private: + char private1; + int private2; +}; + +Negative4 negative4; +// CHECK: type { i32, i8, i32 } + +class __attribute__((packed)) Negative5 { + public: + Negative5() {} + ~Negative5() {} + int make_it_non_standard_layout; + private: + char private1; + int private2; +}; + +Negative5 negative5; +// CHECK: type <{ i32, i8, i32 }> + + +namespace SomeNamespace { +class BlacklistedByName { + public: + BlacklistedByName() {} + ~BlacklistedByName() {} + int make_it_non_standard_layout; + private: + char private1; + int private2; +}; +} // SomeNamespace + +SomeNamespace::BlacklistedByName blacklisted_by_name; + +extern "C" { +class ExternCStruct { + public: + ExternCStruct() {} + ~ExternCStruct() {} + int make_it_non_standard_layout; + private: + char private1; + int private2; +}; +} // extern "C" + +ExternCStruct extern_C_struct; + +// CTOR +// CHECK-LABEL: define {{.*}}Positive1C1Ev +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}}15) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}}8) +// CHECK-NOT: __asan_poison_intra_object_redzone +// CHECK: ret void +// +// DTOR +// CHECK: call void @__asan_unpoison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_unpoison_intra_object_redzone({{.*}}15) +// CHECK: call void @__asan_unpoison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_unpoison_intra_object_redzone({{.*}}12) +// CHECK: call void @__asan_unpoison_intra_object_redzone({{.*}}8) +// CHECK-NOT: __asan_unpoison_intra_object_redzone +// CHECK: ret void +// +// +// CHECK-LABEL: define linkonce_odr void @_ZN20ClassWithVirtualBaseC1Ev +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}} 12) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}} 9) +// CHECK: call void @__asan_poison_intra_object_redzone({{.*}} 15) +// CHECK-NOT: __asan_poison_intra_object_redzone +// CHECK: ret void +// + +struct WithVirtualDtor { + virtual ~WithVirtualDtor(); + int x, y; +}; +struct InheritsFrom_WithVirtualDtor: WithVirtualDtor { + int a, b; + InheritsFrom_WithVirtualDtor() {} + ~InheritsFrom_WithVirtualDtor() {} +}; + +void Create_InheritsFrom_WithVirtualDtor() { + InheritsFrom_WithVirtualDtor x; +} + + +// Make sure the dtor of InheritsFrom_WithVirtualDtor remains in the code, +// i.e. we ignore -mconstructor-aliases when field paddings are added +// because the paddings in InheritsFrom_WithVirtualDtor needs to be unpoisoned +// in the dtor. +// WITH_CTOR_ALIASES-LABEL: define void @_Z35Create_InheritsFrom_WithVirtualDtor +// WITH_CTOR_ALIASES-NOT: call void @_ZN15WithVirtualDtorD2Ev +// WITH_CTOR_ALIASES: call void @_ZN28InheritsFrom_WithVirtualDtorD2Ev +// WITH_CTOR_ALIASES: ret void + +// Make sure we don't emit memcpy for operator= if paddings are inserted. +struct ClassWithTrivialCopy { + ClassWithTrivialCopy(); + ~ClassWithTrivialCopy(); + void *a; + private: + void *c; +}; + +void MakeTrivialCopy(ClassWithTrivialCopy *s1, ClassWithTrivialCopy *s2) { + *s1 = *s2; + ClassWithTrivialCopy s3(*s2); +} + +// CHECK-LABEL: define void @_Z15MakeTrivialCopyP20ClassWithTrivialCopyS0_ +// CHECK-NOT: memcpy +// CHECK: ret void diff --git a/test/CodeGen/sanitize-init-order.cpp b/test/CodeGen/sanitize-init-order.cpp index 8c662dbe0343..ee53f7b0771e 100644 --- a/test/CodeGen/sanitize-init-order.cpp +++ b/test/CodeGen/sanitize-init-order.cpp @@ -1,8 +1,9 @@ // RUN: %clang_cc1 -fsanitize=address -emit-llvm -o - %s | FileCheck %s // Test blacklist functionality. -// RUN: echo "global-init-src:%s" > %t-file.blacklist -// RUN: echo "global-init-type:struct.PODWithCtorAndDtor" > %t-type.blacklist +// RUN: echo "src:%s=init" > %t-file.blacklist +// RUN: echo "type:PODWithCtorAndDtor=init" > %t-type.blacklist +// RUN: echo "type:NS::PODWithCtor=init" >> %t-type.blacklist // RUN: %clang_cc1 -fsanitize=address -fsanitize-blacklist=%t-file.blacklist -emit-llvm -o - %s | FileCheck %s --check-prefix=BLACKLIST // RUN: %clang_cc1 -fsanitize=address -fsanitize-blacklist=%t-type.blacklist -emit-llvm -o - %s | FileCheck %s --check-prefix=BLACKLIST // REQUIRES: shell @@ -25,14 +26,25 @@ struct PODWithCtorAndDtor { }; PODWithCtorAndDtor s3; +namespace NS { +class PODWithCtor { +public: + PODWithCtor() {} +}; + +const volatile PODWithCtor array[5][5]; +} + // Check that ASan init-order checking ignores structs with trivial default // constructor. -// CHECK: !llvm.asan.globals = !{![[GLOB_1:[0-9]+]], ![[GLOB_2:[0-9]+]], ![[GLOB_3:[0-9]]]} -// CHECK: ![[GLOB_1]] = metadata !{%struct.PODStruct* {{.*}}, i1 false, i1 false} -// CHECK: ![[GLOB_2]] = metadata !{%struct.PODWithDtor* {{.*}}, i1 false, i1 false} -// CHECK: ![[GLOB_3]] = metadata !{%struct.PODWithCtorAndDtor* {{.*}}, i1 true, i1 false} - -// BLACKLIST: !llvm.asan.globals = !{![[GLOB_1:[0-9]+]], ![[GLOB_2:[0-9]+]], ![[GLOB_3:[0-9]]]} -// BLACKLIST: ![[GLOB_1]] = metadata !{%struct.PODStruct* {{.*}}, i1 false, i1 false} -// BLACKLIST: ![[GLOB_2]] = metadata !{%struct.PODWithDtor* {{.*}}, i1 false, i1 false} -// BLACKLIST: ![[GLOB_3]] = metadata !{%struct.PODWithCtorAndDtor* {{.*}}, i1 false, i1 false} +// CHECK: !llvm.asan.globals = !{![[GLOB_1:[0-9]+]], ![[GLOB_2:[0-9]+]], ![[GLOB_3:[0-9]]], ![[GLOB_4:[0-9]]]} +// CHECK: ![[GLOB_1]] = !{%struct.PODStruct* {{.*}}, i1 false, i1 false} +// CHECK: ![[GLOB_2]] = !{%struct.PODWithDtor* {{.*}}, i1 false, i1 false} +// CHECK: ![[GLOB_3]] = !{%struct.PODWithCtorAndDtor* {{.*}}, i1 true, i1 false} +// CHECK: ![[GLOB_4]] = !{{{.*}}class.NS::PODWithCtor{{.*}}, i1 true, i1 false} + +// BLACKLIST: !llvm.asan.globals = !{![[GLOB_1:[0-9]+]], ![[GLOB_2:[0-9]+]], ![[GLOB_3:[0-9]]], ![[GLOB_4:[0-9]]]} +// BLACKLIST: ![[GLOB_1]] = !{%struct.PODStruct* {{.*}}, i1 false, i1 false} +// BLACKLIST: ![[GLOB_2]] = !{%struct.PODWithDtor* {{.*}}, i1 false, i1 false} +// BLACKLIST: ![[GLOB_3]] = !{%struct.PODWithCtorAndDtor* {{.*}}, i1 false, i1 false} +// BLACKLIST: ![[GLOB_4]] = !{{{.*}}class.NS::PODWithCtor{{.*}}, i1 false, i1 false} diff --git a/test/CodeGen/sanitize-recover.c b/test/CodeGen/sanitize-recover.c index 3c9c89553813..b263f5163181 100644 --- a/test/CodeGen/sanitize-recover.c +++ b/test/CodeGen/sanitize-recover.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=unsigned-integer-overflow %s -emit-llvm -o - | FileCheck %s --check-prefix=RECOVER -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=unsigned-integer-overflow -fno-sanitize-recover %s -emit-llvm -o - | FileCheck %s --check-prefix=ABORT - +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=unsigned-integer-overflow -fsanitize-recover=unsigned-integer-overflow %s -emit-llvm -o - | FileCheck %s --check-prefix=RECOVER +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=unsigned-integer-overflow %s -emit-llvm -o - | FileCheck %s --check-prefix=ABORT +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsanitize=null,object-size,alignment -fsanitize-recover=object-size %s -emit-llvm -o - | FileCheck %s --check-prefix=PARTIAL // RECOVER: @test // ABORT: @test @@ -15,3 +15,25 @@ void test() { // ABORT: unreachable x = y + z; } + +void foo() { + union { int i; } u; + u.i=1; + // PARTIAL: %[[CHECK0:.*]] = icmp ne {{.*}}* %[[PTR:.*]], null + + // PARTIAL: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* {{.*}}, i1 false) + // PARTIAL-NEXT: %[[CHECK1:.*]] = icmp uge i64 %[[SIZE]], 4 + + // PARTIAL: %[[MISALIGN:.*]] = and i64 {{.*}}, 3 + // PARTIAL-NEXT: %[[CHECK2:.*]] = icmp eq i64 %[[MISALIGN]], 0 + + // PARTIAL: %[[CHECK02:.*]] = and i1 %[[CHECK0]], %[[CHECK2]] + // PARTIAL-NEXT: %[[CHECK012:.*]] = and i1 %[[CHECK02]], %[[CHECK1]] + + // PARTIAL: br i1 %[[CHECK012]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize + + // PARTIAL: br i1 %[[CHECK02]], {{.*}} + // PARTIAL: call void @__ubsan_handle_type_mismatch_abort( + // PARTIAL-NEXT: unreachable + // PARTIAL: call void @__ubsan_handle_type_mismatch( +} diff --git a/test/CodeGen/sse-builtins.c b/test/CodeGen/sse-builtins.c index 238454bb92e9..34c2de7d331b 100644 --- a/test/CodeGen/sse-builtins.c +++ b/test/CodeGen/sse-builtins.c @@ -255,3 +255,291 @@ __m128i test_blend_epi16(__m128i V1, __m128i V2) { // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 9, i32 2, i32 11, i32 4, i32 13, i32 6, i32 7> return _mm_blend_epi16(V1, V2, 42); } + +__m128 test_mm_cmpeq_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpeq_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 0) + return _mm_cmpeq_ss(__a, __b); +} + +__m128 test_mm_cmplt_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmplt_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 1) + return _mm_cmplt_ss(__a, __b); +} + +__m128 test_mm_cmple_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmple_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 2) + return _mm_cmple_ss(__a, __b); +} + +__m128 test_mm_cmpunord_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpunord_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 3) + return _mm_cmpunord_ss(__a, __b); +} + +__m128 test_mm_cmpneq_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpneq_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 4) + return _mm_cmpneq_ss(__a, __b); +} + +__m128 test_mm_cmpnlt_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnlt_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 5) + return _mm_cmpnlt_ss(__a, __b); +} + +__m128 test_mm_cmpnle_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnle_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 6) + return _mm_cmpnle_ss(__a, __b); +} + +__m128 test_mm_cmpord_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpord_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 7) + return _mm_cmpord_ss(__a, __b); +} + +__m128 test_mm_cmpgt_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpgt_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 1) + return _mm_cmpgt_ss(__a, __b); +} + +__m128 test_mm_cmpge_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpge_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 2) + return _mm_cmpge_ss(__a, __b); +} + +__m128 test_mm_cmpngt_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpngt_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 5) + return _mm_cmpngt_ss(__a, __b); +} + +__m128 test_mm_cmpnge_ss(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnge_ss + // CHECK: @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 6) + return _mm_cmpnge_ss(__a, __b); +} + +__m128 test_mm_cmpeq_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpeq_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 0) + return _mm_cmpeq_ps(__a, __b); +} + +__m128 test_mm_cmplt_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmplt_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 1) + return _mm_cmplt_ps(__a, __b); +} + +__m128 test_mm_cmple_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmple_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 2) + return _mm_cmple_ps(__a, __b); +} + +__m128 test_mm_cmpunord_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpunord_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 3) + return _mm_cmpunord_ps(__a, __b); +} + +__m128 test_mm_cmpneq_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpneq_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 4) + return _mm_cmpneq_ps(__a, __b); +} + +__m128 test_mm_cmpnlt_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnlt_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 5) + return _mm_cmpnlt_ps(__a, __b); +} + +__m128 test_mm_cmpnle_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnle_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 6) + return _mm_cmpnle_ps(__a, __b); +} + +__m128 test_mm_cmpord_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpord_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 7) + return _mm_cmpord_ps(__a, __b); +} + +__m128 test_mm_cmpgt_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpgt_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 1) + return _mm_cmpgt_ps(__a, __b); +} + +__m128 test_mm_cmpge_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpge_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 2) + return _mm_cmpge_ps(__a, __b); +} + +__m128 test_mm_cmpngt_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpngt_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 5) + return _mm_cmpngt_ps(__a, __b); +} + +__m128 test_mm_cmpnge_ps(__m128 __a, __m128 __b) { + // CHECK-LABEL: @test_mm_cmpnge_ps + // CHECK: @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 6) + return _mm_cmpnge_ps(__a, __b); +} + +__m128d test_mm_cmpeq_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpeq_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) + return _mm_cmpeq_sd(__a, __b); +} + +__m128d test_mm_cmplt_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmplt_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) + return _mm_cmplt_sd(__a, __b); +} + +__m128d test_mm_cmple_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmple_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) + return _mm_cmple_sd(__a, __b); +} + +__m128d test_mm_cmpunord_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpunord_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) + return _mm_cmpunord_sd(__a, __b); +} + +__m128d test_mm_cmpneq_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpneq_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) + return _mm_cmpneq_sd(__a, __b); +} + +__m128d test_mm_cmpnlt_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnlt_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) + return _mm_cmpnlt_sd(__a, __b); +} + +__m128d test_mm_cmpnle_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnle_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) + return _mm_cmpnle_sd(__a, __b); +} + +__m128d test_mm_cmpord_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpord_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) + return _mm_cmpord_sd(__a, __b); +} + +__m128d test_mm_cmpgt_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpgt_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) + return _mm_cmpgt_sd(__a, __b); +} + +__m128d test_mm_cmpge_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpge_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) + return _mm_cmpge_sd(__a, __b); +} + +__m128d test_mm_cmpngt_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpngt_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) + return _mm_cmpngt_sd(__a, __b); +} + +__m128d test_mm_cmpnge_sd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnge_sd + // CHECK: @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) + return _mm_cmpnge_sd(__a, __b); +} + +__m128d test_mm_cmpeq_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpeq_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) + return _mm_cmpeq_pd(__a, __b); +} + +__m128d test_mm_cmplt_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmplt_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) + return _mm_cmplt_pd(__a, __b); +} + +__m128d test_mm_cmple_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmple_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) + return _mm_cmple_pd(__a, __b); +} + +__m128d test_mm_cmpunord_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpunord_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) + return _mm_cmpunord_pd(__a, __b); +} + +__m128d test_mm_cmpneq_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpneq_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) + return _mm_cmpneq_pd(__a, __b); +} + +__m128d test_mm_cmpnlt_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnlt_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) + return _mm_cmpnlt_pd(__a, __b); +} + +__m128d test_mm_cmpnle_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnle_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) + return _mm_cmpnle_pd(__a, __b); +} + +__m128d test_mm_cmpord_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpord_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) + return _mm_cmpord_pd(__a, __b); +} + +__m128d test_mm_cmpgt_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpgt_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) + return _mm_cmpgt_pd(__a, __b); +} + +__m128d test_mm_cmpge_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpge_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) + return _mm_cmpge_pd(__a, __b); +} + +__m128d test_mm_cmpngt_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpngt_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) + return _mm_cmpngt_pd(__a, __b); +} + +__m128d test_mm_cmpnge_pd(__m128d __a, __m128d __b) { + // CHECK-LABEL: @test_mm_cmpnge_pd + // CHECK: @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) + return _mm_cmpnge_pd(__a, __b); +} diff --git a/test/CodeGen/target-data.c b/test/CodeGen/target-data.c index 5153be9075ed..d8e77c5352c2 100644 --- a/test/CodeGen/target-data.c +++ b/test/CodeGen/target-data.c @@ -68,7 +68,7 @@ // RUN: %clang_cc1 -triple arm-nacl-gnueabi -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=ARM-NACL -// ARM-NACL: target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S128" +// ARM-NACL: target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128" // RUN: %clang_cc1 -triple mipsel-nacl -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=MIPS-NACL @@ -118,7 +118,7 @@ // RUN: | FileCheck %s -check-prefix=R600D // R600D: target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64" -// RUN: %clang_cc1 -triple r600-unknown -target-cpu hawaii -o - -emit-llvm %s \ +// RUN: %clang_cc1 -triple amdgcn-unknown -target-cpu hawaii -o - -emit-llvm %s \ // RUN: | FileCheck %s -check-prefix=R600SI // R600SI: target datalayout = "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64" @@ -128,15 +128,15 @@ // RUN: %clang_cc1 -triple thumb-unknown-gnueabi -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=THUMB -// THUMB: target datalayout = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-v128:64:128-a:0:32-n32-S64" +// THUMB: target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" // RUN: %clang_cc1 -triple arm-unknown-gnueabi -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=ARM -// ARM: target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" +// ARM: target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" // RUN: %clang_cc1 -triple thumb-unknown -o - -emit-llvm -target-abi apcs-gnu \ // RUN: %s | FileCheck %s -check-prefix=THUMB-GNU -// THUMB-GNU: target datalayout = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" +// THUMB-GNU: target datalayout = "e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" // RUN: %clang_cc1 -triple arm-unknown -o - -emit-llvm -target-abi apcs-gnu \ // RUN: %s | FileCheck %s -check-prefix=ARM-GNU @@ -152,7 +152,7 @@ // RUN: %clang_cc1 -triple msp430-unknown -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=MSP430 -// MSP430: target datalayout = "e-m:e-p:16:16-i32:16:32-n8:16" +// MSP430: target datalayout = "e-m:e-p:16:16-i32:16:32-a:16-n8:16" // RUN: %clang_cc1 -triple tce-unknown -o - -emit-llvm %s | \ // RUN: FileCheck %s -check-prefix=TCE diff --git a/test/CodeGen/tbaa-class.cpp b/test/CodeGen/tbaa-class.cpp index bdd155d450a9..a8005d605724 100644 --- a/test/CodeGen/tbaa-class.cpp +++ b/test/CodeGen/tbaa-class.cpp @@ -198,31 +198,31 @@ uint32_t g12(StructC *C, StructD *D, uint64_t count) { return b1->a.f32; } -// CHECK: [[TYPE_char:!.*]] = metadata !{metadata !"omnipotent char", metadata [[TAG_cxx_tbaa:!.*]], -// CHECK: [[TAG_cxx_tbaa]] = metadata !{metadata !"Simple C/C++ TBAA"} -// CHECK: [[TAG_i32]] = metadata !{metadata [[TYPE_i32:!.*]], metadata [[TYPE_i32]], i64 0} -// CHECK: [[TYPE_i32]] = metadata !{metadata !"int", metadata [[TYPE_char]], -// CHECK: [[TAG_i16]] = metadata !{metadata [[TYPE_i16:!.*]], metadata [[TYPE_i16]], i64 0} -// CHECK: [[TYPE_i16]] = metadata !{metadata !"short", metadata [[TYPE_char]], - -// PATH: [[TYPE_CHAR:!.*]] = metadata !{metadata !"omnipotent char", metadata -// PATH: [[TAG_i32]] = metadata !{metadata [[TYPE_INT:!.*]], metadata [[TYPE_INT]], i64 0} -// PATH: [[TYPE_INT]] = metadata !{metadata !"int", metadata [[TYPE_CHAR]] -// PATH: [[TAG_A_f32]] = metadata !{metadata [[TYPE_A:!.*]], metadata [[TYPE_INT]], i64 4} -// PATH: [[TYPE_A]] = metadata !{metadata !"_ZTS7StructA", metadata [[TYPE_SHORT:!.*]], i64 0, metadata [[TYPE_INT]], i64 4, metadata [[TYPE_SHORT]], i64 8, metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_SHORT:!.*]] = metadata !{metadata !"short", metadata [[TYPE_CHAR]] -// PATH: [[TAG_A_f16]] = metadata !{metadata [[TYPE_A]], metadata [[TYPE_SHORT]], i64 0} -// PATH: [[TAG_B_a_f32]] = metadata !{metadata [[TYPE_B:!.*]], metadata [[TYPE_INT]], i64 8} -// PATH: [[TYPE_B]] = metadata !{metadata !"_ZTS7StructB", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_A]], i64 4, metadata [[TYPE_INT]], i64 20} -// PATH: [[TAG_B_a_f16]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_SHORT]], i64 4} -// PATH: [[TAG_B_f32]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_INT]], i64 20} -// PATH: [[TAG_B_a_f32_2]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_INT]], i64 16} -// PATH: [[TAG_S_f32]] = metadata !{metadata [[TYPE_S:!.*]], metadata [[TYPE_INT]], i64 4} -// PATH: [[TYPE_S]] = metadata !{metadata !"_ZTS7StructS", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_INT]], i64 4} -// PATH: [[TAG_S_f16]] = metadata !{metadata [[TYPE_S]], metadata [[TYPE_SHORT]], i64 0} -// PATH: [[TAG_S2_f32_2]] = metadata !{metadata [[TYPE_S2:!.*]], metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_S2]] = metadata !{metadata !"_ZTS8StructS2", metadata [[TYPE_SHORT]], i64 8, metadata [[TYPE_INT]], i64 12} -// PATH: [[TAG_C_b_a_f32]] = metadata !{metadata [[TYPE_C:!.*]], metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_C]] = metadata !{metadata !"_ZTS7StructC", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_B]], i64 4, metadata [[TYPE_INT]], i64 28} -// PATH: [[TAG_D_b_a_f32]] = metadata !{metadata [[TYPE_D:!.*]], metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_D]] = metadata !{metadata !"_ZTS7StructD", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_B]], i64 4, metadata [[TYPE_INT]], i64 28, metadata [[TYPE_CHAR]], i64 32} +// CHECK: [[TYPE_char:!.*]] = !{!"omnipotent char", [[TAG_cxx_tbaa:!.*]], +// CHECK: [[TAG_cxx_tbaa]] = !{!"Simple C/C++ TBAA"} +// CHECK: [[TAG_i32]] = !{[[TYPE_i32:!.*]], [[TYPE_i32]], i64 0} +// CHECK: [[TYPE_i32]] = !{!"int", [[TYPE_char]], +// CHECK: [[TAG_i16]] = !{[[TYPE_i16:!.*]], [[TYPE_i16]], i64 0} +// CHECK: [[TYPE_i16]] = !{!"short", [[TYPE_char]], + +// PATH: [[TYPE_CHAR:!.*]] = !{!"omnipotent char", ! +// PATH: [[TAG_i32]] = !{[[TYPE_INT:!.*]], [[TYPE_INT]], i64 0} +// PATH: [[TYPE_INT]] = !{!"int", [[TYPE_CHAR]] +// PATH: [[TAG_A_f32]] = !{[[TYPE_A:!.*]], [[TYPE_INT]], i64 4} +// PATH: [[TYPE_A]] = !{!"_ZTS7StructA", [[TYPE_SHORT:!.*]], i64 0, [[TYPE_INT]], i64 4, [[TYPE_SHORT]], i64 8, [[TYPE_INT]], i64 12} +// PATH: [[TYPE_SHORT:!.*]] = !{!"short", [[TYPE_CHAR]] +// PATH: [[TAG_A_f16]] = !{[[TYPE_A]], [[TYPE_SHORT]], i64 0} +// PATH: [[TAG_B_a_f32]] = !{[[TYPE_B:!.*]], [[TYPE_INT]], i64 8} +// PATH: [[TYPE_B]] = !{!"_ZTS7StructB", [[TYPE_SHORT]], i64 0, [[TYPE_A]], i64 4, [[TYPE_INT]], i64 20} +// PATH: [[TAG_B_a_f16]] = !{[[TYPE_B]], [[TYPE_SHORT]], i64 4} +// PATH: [[TAG_B_f32]] = !{[[TYPE_B]], [[TYPE_INT]], i64 20} +// PATH: [[TAG_B_a_f32_2]] = !{[[TYPE_B]], [[TYPE_INT]], i64 16} +// PATH: [[TAG_S_f32]] = !{[[TYPE_S:!.*]], [[TYPE_INT]], i64 4} +// PATH: [[TYPE_S]] = !{!"_ZTS7StructS", [[TYPE_SHORT]], i64 0, [[TYPE_INT]], i64 4} +// PATH: [[TAG_S_f16]] = !{[[TYPE_S]], [[TYPE_SHORT]], i64 0} +// PATH: [[TAG_S2_f32_2]] = !{[[TYPE_S2:!.*]], [[TYPE_INT]], i64 12} +// PATH: [[TYPE_S2]] = !{!"_ZTS8StructS2", [[TYPE_SHORT]], i64 8, [[TYPE_INT]], i64 12} +// PATH: [[TAG_C_b_a_f32]] = !{[[TYPE_C:!.*]], [[TYPE_INT]], i64 12} +// PATH: [[TYPE_C]] = !{!"_ZTS7StructC", [[TYPE_SHORT]], i64 0, [[TYPE_B]], i64 4, [[TYPE_INT]], i64 28} +// PATH: [[TAG_D_b_a_f32]] = !{[[TYPE_D:!.*]], [[TYPE_INT]], i64 12} +// PATH: [[TYPE_D]] = !{!"_ZTS7StructD", [[TYPE_SHORT]], i64 0, [[TYPE_B]], i64 4, [[TYPE_INT]], i64 28, [[TYPE_CHAR]], i64 32} diff --git a/test/CodeGen/tbaa-for-vptr.cpp b/test/CodeGen/tbaa-for-vptr.cpp index ded574ea9376..35e95a54dab2 100644 --- a/test/CodeGen/tbaa-for-vptr.cpp +++ b/test/CodeGen/tbaa-for-vptr.cpp @@ -30,6 +30,6 @@ void CallFoo(A *a, int (A::*fp)() const) { // CHECK-LABEL: @_ZN1AC2Ev // CHECK: store {{.*}} !tbaa ![[NUM]] // -// CHECK: [[NUM]] = metadata !{metadata [[TYPE:!.*]], metadata [[TYPE]], i64 0} -// CHECK: [[TYPE]] = metadata !{metadata !"vtable pointer", metadata !{{.*}} -// NOTBAA-NOT: = metadata !{metadata !"Simple C/C++ TBAA"} +// CHECK: [[NUM]] = !{[[TYPE:!.*]], [[TYPE]], i64 0} +// CHECK: [[TYPE]] = !{!"vtable pointer", !{{.*}} +// NOTBAA-NOT: = !{!"Simple C/C++ TBAA"} diff --git a/test/CodeGen/tbaa-ms-abi.cpp b/test/CodeGen/tbaa-ms-abi.cpp index 2a9e47e40810..878e1b610b59 100644 --- a/test/CodeGen/tbaa-ms-abi.cpp +++ b/test/CodeGen/tbaa-ms-abi.cpp @@ -16,7 +16,7 @@ StructB::StructB() { // CHECK: store i32 42, i32* {{.*}}, !tbaa [[TAG_A_i32:!.*]] } -// CHECK: [[TYPE_INT:!.*]] = metadata !{metadata !"int", metadata [[TYPE_CHAR:!.*]], i64 0} -// CHECK: [[TYPE_CHAR]] = metadata !{metadata !"omnipotent char", metadata -// CHECK: [[TAG_A_i32]] = metadata !{metadata [[TYPE_A:!.*]], metadata [[TYPE_INT]], i64 0} -// CHECK: [[TYPE_A]] = metadata !{metadata !"?AUStructA@@", metadata [[TYPE_INT]], i64 0} +// CHECK: [[TYPE_INT:!.*]] = !{!"int", [[TYPE_CHAR:!.*]], i64 0} +// CHECK: [[TYPE_CHAR]] = !{!"omnipotent char", ! +// CHECK: [[TAG_A_i32]] = !{[[TYPE_A:!.*]], [[TYPE_INT]], i64 0} +// CHECK: [[TYPE_A]] = !{!"?AUStructA@@", [[TYPE_INT]], i64 0} diff --git a/test/CodeGen/tbaa-struct.cpp b/test/CodeGen/tbaa-struct.cpp index 71d3ed11a173..2623c42c9a3f 100644 --- a/test/CodeGen/tbaa-struct.cpp +++ b/test/CodeGen/tbaa-struct.cpp @@ -62,14 +62,14 @@ void copy5(struct six *a, struct six *b) { } // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.*}}, i8* %{{.*}}, i64 6, i32 1, i1 false), !tbaa.struct [[TS5:!.*]] -// CHECK: [[TS]] = metadata !{i64 0, i64 2, metadata !{{.*}}, i64 4, i64 4, metadata !{{.*}}, i64 8, i64 1, metadata !{{.*}}, i64 12, i64 4, metadata !{{.*}}} -// CHECK: [[CHAR:!.*]] = metadata !{metadata !"omnipotent char", metadata !{{.*}}} -// CHECK: [[TAG_INT:!.*]] = metadata !{metadata [[INT:!.*]], metadata [[INT]], i64 0} -// CHECK: [[INT]] = metadata !{metadata !"int", metadata [[CHAR]] -// CHECK: [[TAG_CHAR:!.*]] = metadata !{metadata [[CHAR]], metadata [[CHAR]], i64 0} +// CHECK: [[TS]] = !{i64 0, i64 2, !{{.*}}, i64 4, i64 4, !{{.*}}, i64 8, i64 1, !{{.*}}, i64 12, i64 4, !{{.*}}} +// CHECK: [[CHAR:!.*]] = !{!"omnipotent char", !{{.*}}} +// CHECK: [[TAG_INT:!.*]] = !{[[INT:!.*]], [[INT]], i64 0} +// CHECK: [[INT]] = !{!"int", [[CHAR]] +// CHECK: [[TAG_CHAR:!.*]] = !{[[CHAR]], [[CHAR]], i64 0} // (offset, size) = (0,1) char; (4,2) short; (8,4) int; (12,1) char; (16,4) int; (20,4) int -// CHECK: [[TS2]] = metadata !{i64 0, i64 1, metadata !{{.*}}, i64 4, i64 2, metadata !{{.*}}, i64 8, i64 4, metadata !{{.*}}, i64 12, i64 1, metadata !{{.*}}, i64 16, i64 4, metadata {{.*}}, i64 20, i64 4, metadata {{.*}}} +// CHECK: [[TS2]] = !{i64 0, i64 1, !{{.*}}, i64 4, i64 2, !{{.*}}, i64 8, i64 4, !{{.*}}, i64 12, i64 1, !{{.*}}, i64 16, i64 4, {{.*}}, i64 20, i64 4, {{.*}}} // (offset, size) = (0,8) char; (0,2) char; (4,8) char -// CHECK: [[TS3]] = metadata !{i64 0, i64 8, metadata !{{.*}}, i64 0, i64 2, metadata !{{.*}}, i64 4, i64 8, metadata !{{.*}}} -// CHECK: [[TS4]] = metadata !{i64 0, i64 1, metadata [[TAG_CHAR]], i64 1, i64 4, metadata [[TAG_INT]], i64 1, i64 1, metadata [[TAG_CHAR]], i64 2, i64 1, metadata [[TAG_CHAR]]} -// CHECK: [[TS5]] = metadata !{i64 0, i64 1, metadata [[TAG_CHAR]], i64 4, i64 4, metadata [[TAG_INT]], i64 4, i64 1, metadata [[TAG_CHAR]], i64 5, i64 1, metadata [[TAG_CHAR]]} +// CHECK: [[TS3]] = !{i64 0, i64 8, !{{.*}}, i64 0, i64 2, !{{.*}}, i64 4, i64 8, !{{.*}}} +// CHECK: [[TS4]] = !{i64 0, i64 1, [[TAG_CHAR]], i64 1, i64 4, [[TAG_INT]], i64 1, i64 1, [[TAG_CHAR]], i64 2, i64 1, [[TAG_CHAR]]} +// CHECK: [[TS5]] = !{i64 0, i64 1, [[TAG_CHAR]], i64 4, i64 4, [[TAG_INT]], i64 4, i64 1, [[TAG_CHAR]], i64 5, i64 1, [[TAG_CHAR]]} diff --git a/test/CodeGen/tbaa.cpp b/test/CodeGen/tbaa.cpp index 92d31e5ae293..4a723f100ecf 100644 --- a/test/CodeGen/tbaa.cpp +++ b/test/CodeGen/tbaa.cpp @@ -236,37 +236,37 @@ uint32_t g15(StructS *S, StructS3 *S3, uint64_t count) { return S->f32; } -// CHECK: [[TYPE_char:!.*]] = metadata !{metadata !"omnipotent char", metadata [[TAG_cxx_tbaa:!.*]], -// CHECK: [[TAG_cxx_tbaa]] = metadata !{metadata !"Simple C/C++ TBAA"} -// CHECK: [[TAG_i32]] = metadata !{metadata [[TYPE_i32:!.*]], metadata [[TYPE_i32]], i64 0} -// CHECK: [[TYPE_i32]] = metadata !{metadata !"int", metadata [[TYPE_char]], -// CHECK: [[TAG_i16]] = metadata !{metadata [[TYPE_i16:!.*]], metadata [[TYPE_i16]], i64 0} -// CHECK: [[TYPE_i16]] = metadata !{metadata !"short", metadata [[TYPE_char]], -// CHECK: [[TAG_char]] = metadata !{metadata [[TYPE_char]], metadata [[TYPE_char]], i64 0} +// CHECK: [[TYPE_char:!.*]] = !{!"omnipotent char", [[TAG_cxx_tbaa:!.*]], +// CHECK: [[TAG_cxx_tbaa]] = !{!"Simple C/C++ TBAA"} +// CHECK: [[TAG_i32]] = !{[[TYPE_i32:!.*]], [[TYPE_i32]], i64 0} +// CHECK: [[TYPE_i32]] = !{!"int", [[TYPE_char]], +// CHECK: [[TAG_i16]] = !{[[TYPE_i16:!.*]], [[TYPE_i16]], i64 0} +// CHECK: [[TYPE_i16]] = !{!"short", [[TYPE_char]], +// CHECK: [[TAG_char]] = !{[[TYPE_char]], [[TYPE_char]], i64 0} -// PATH: [[TYPE_CHAR:!.*]] = metadata !{metadata !"omnipotent char", metadata -// PATH: [[TAG_i32]] = metadata !{metadata [[TYPE_INT:!.*]], metadata [[TYPE_INT]], i64 0} -// PATH: [[TYPE_INT]] = metadata !{metadata !"int", metadata [[TYPE_CHAR]] -// PATH: [[TAG_A_f32]] = metadata !{metadata [[TYPE_A:!.*]], metadata [[TYPE_INT]], i64 4} -// PATH: [[TYPE_A]] = metadata !{metadata !"_ZTS7StructA", metadata [[TYPE_SHORT:!.*]], i64 0, metadata [[TYPE_INT]], i64 4, metadata [[TYPE_SHORT]], i64 8, metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_SHORT:!.*]] = metadata !{metadata !"short", metadata [[TYPE_CHAR]] -// PATH: [[TAG_A_f16]] = metadata !{metadata [[TYPE_A]], metadata [[TYPE_SHORT]], i64 0} -// PATH: [[TAG_B_a_f32]] = metadata !{metadata [[TYPE_B:!.*]], metadata [[TYPE_INT]], i64 8} -// PATH: [[TYPE_B]] = metadata !{metadata !"_ZTS7StructB", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_A]], i64 4, metadata [[TYPE_INT]], i64 20} -// PATH: [[TAG_B_a_f16]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_SHORT]], i64 4} -// PATH: [[TAG_B_f32]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_INT]], i64 20} -// PATH: [[TAG_B_a_f32_2]] = metadata !{metadata [[TYPE_B]], metadata [[TYPE_INT]], i64 16} -// PATH: [[TAG_S_f32]] = metadata !{metadata [[TYPE_S:!.*]], metadata [[TYPE_INT]], i64 4} -// PATH: [[TYPE_S]] = metadata !{metadata !"_ZTS7StructS", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_INT]], i64 4} -// PATH: [[TAG_S_f16]] = metadata !{metadata [[TYPE_S]], metadata [[TYPE_SHORT]], i64 0} -// PATH: [[TAG_S2_f32]] = metadata !{metadata [[TYPE_S2:!.*]], metadata [[TYPE_INT]], i64 4} -// PATH: [[TYPE_S2]] = metadata !{metadata !"_ZTS8StructS2", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_INT]], i64 4} -// PATH: [[TAG_S2_f16]] = metadata !{metadata [[TYPE_S2]], metadata [[TYPE_SHORT]], i64 0} -// PATH: [[TAG_C_b_a_f32]] = metadata !{metadata [[TYPE_C:!.*]], metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_C]] = metadata !{metadata !"_ZTS7StructC", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_B]], i64 4, metadata [[TYPE_INT]], i64 28} -// PATH: [[TAG_D_b_a_f32]] = metadata !{metadata [[TYPE_D:!.*]], metadata [[TYPE_INT]], i64 12} -// PATH: [[TYPE_D]] = metadata !{metadata !"_ZTS7StructD", metadata [[TYPE_SHORT]], i64 0, metadata [[TYPE_B]], i64 4, metadata [[TYPE_INT]], i64 28, metadata [[TYPE_CHAR]], i64 32} -// PATH: [[TAG_five_b]] = metadata !{metadata [[TYPE_five:!.*]], metadata [[TYPE_CHAR]], i64 1} -// PATH: [[TYPE_five]] = metadata !{metadata !"_ZTS4five", metadata [[TYPE_CHAR]], i64 0, metadata [[TYPE_INT]], i64 1, metadata [[TYPE_CHAR]], i64 1, metadata [[TYPE_CHAR]], i64 2} -// PATH: [[TAG_six_b]] = metadata !{metadata [[TYPE_six:!.*]], metadata [[TYPE_CHAR]], i64 4} -// PATH: [[TYPE_six]] = metadata !{metadata !"_ZTS3six", metadata [[TYPE_CHAR]], i64 0, metadata [[TYPE_INT]], i64 4, metadata [[TYPE_CHAR]], i64 4, metadata [[TYPE_CHAR]], i64 5} +// PATH: [[TYPE_CHAR:!.*]] = !{!"omnipotent char", ! +// PATH: [[TAG_i32]] = !{[[TYPE_INT:!.*]], [[TYPE_INT]], i64 0} +// PATH: [[TYPE_INT]] = !{!"int", [[TYPE_CHAR]] +// PATH: [[TAG_A_f32]] = !{[[TYPE_A:!.*]], [[TYPE_INT]], i64 4} +// PATH: [[TYPE_A]] = !{!"_ZTS7StructA", [[TYPE_SHORT:!.*]], i64 0, [[TYPE_INT]], i64 4, [[TYPE_SHORT]], i64 8, [[TYPE_INT]], i64 12} +// PATH: [[TYPE_SHORT:!.*]] = !{!"short", [[TYPE_CHAR]] +// PATH: [[TAG_A_f16]] = !{[[TYPE_A]], [[TYPE_SHORT]], i64 0} +// PATH: [[TAG_B_a_f32]] = !{[[TYPE_B:!.*]], [[TYPE_INT]], i64 8} +// PATH: [[TYPE_B]] = !{!"_ZTS7StructB", [[TYPE_SHORT]], i64 0, [[TYPE_A]], i64 4, [[TYPE_INT]], i64 20} +// PATH: [[TAG_B_a_f16]] = !{[[TYPE_B]], [[TYPE_SHORT]], i64 4} +// PATH: [[TAG_B_f32]] = !{[[TYPE_B]], [[TYPE_INT]], i64 20} +// PATH: [[TAG_B_a_f32_2]] = !{[[TYPE_B]], [[TYPE_INT]], i64 16} +// PATH: [[TAG_S_f32]] = !{[[TYPE_S:!.*]], [[TYPE_INT]], i64 4} +// PATH: [[TYPE_S]] = !{!"_ZTS7StructS", [[TYPE_SHORT]], i64 0, [[TYPE_INT]], i64 4} +// PATH: [[TAG_S_f16]] = !{[[TYPE_S]], [[TYPE_SHORT]], i64 0} +// PATH: [[TAG_S2_f32]] = !{[[TYPE_S2:!.*]], [[TYPE_INT]], i64 4} +// PATH: [[TYPE_S2]] = !{!"_ZTS8StructS2", [[TYPE_SHORT]], i64 0, [[TYPE_INT]], i64 4} +// PATH: [[TAG_S2_f16]] = !{[[TYPE_S2]], [[TYPE_SHORT]], i64 0} +// PATH: [[TAG_C_b_a_f32]] = !{[[TYPE_C:!.*]], [[TYPE_INT]], i64 12} +// PATH: [[TYPE_C]] = !{!"_ZTS7StructC", [[TYPE_SHORT]], i64 0, [[TYPE_B]], i64 4, [[TYPE_INT]], i64 28} +// PATH: [[TAG_D_b_a_f32]] = !{[[TYPE_D:!.*]], [[TYPE_INT]], i64 12} +// PATH: [[TYPE_D]] = !{!"_ZTS7StructD", [[TYPE_SHORT]], i64 0, [[TYPE_B]], i64 4, [[TYPE_INT]], i64 28, [[TYPE_CHAR]], i64 32} +// PATH: [[TAG_five_b]] = !{[[TYPE_five:!.*]], [[TYPE_CHAR]], i64 1} +// PATH: [[TYPE_five]] = !{!"_ZTS4five", [[TYPE_CHAR]], i64 0, [[TYPE_INT]], i64 1, [[TYPE_CHAR]], i64 1, [[TYPE_CHAR]], i64 2} +// PATH: [[TAG_six_b]] = !{[[TYPE_six:!.*]], [[TYPE_CHAR]], i64 4} +// PATH: [[TYPE_six]] = !{!"_ZTS3six", [[TYPE_CHAR]], i64 0, [[TYPE_INT]], i64 4, [[TYPE_CHAR]], i64 4, [[TYPE_CHAR]], i64 5} diff --git a/test/CodeGen/transparent-union.c b/test/CodeGen/transparent-union.c index 21040e4da05b..2f00c2d21a05 100644 --- a/test/CodeGen/transparent-union.c +++ b/test/CodeGen/transparent-union.c @@ -1,8 +1,8 @@ -// RUN: %clang_cc1 -Werror -triple i386-unknown-unknown -emit-llvm -o %t %s -// RUN: FileCheck < %t %s -// -// FIXME: Note that we don't currently get the ABI right here. f0() should be -// f0(i8*). +// RUN: %clang_cc1 -Werror -triple x86_64-linux -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -Werror -triple i386-linux -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -Werror -triple armv7-linux -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM +// RUN: %clang_cc1 -Werror -triple powerpc64le-linux -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -Werror -triple aarch64-linux -emit-llvm -o - %s | FileCheck %s typedef union { void *f0; @@ -10,10 +10,15 @@ typedef union { void f0(transp_t0 obj); -// CHECK-LABEL: define void @f1_0(i32* %a0) -// CHECK: call void @f0(%union.transp_t0* byval align 4 %{{.*}}) +// CHECK-LABEL: define void @f1_0(i32* %a0) +// CHECK: call void @f0(i8* %{{.*}}) // CHECK: call void %{{.*}}(i8* %{{[a-z0-9]*}}) // CHECK: } + +// ARM-LABEL: define arm_aapcscc void @f1_0(i32* %a0) +// ARM: call arm_aapcscc void @f0(i8* %{{.*}}) +// ARM: call arm_aapcscc void %{{.*}}(i8* %{{[a-z0-9]*}}) +// ARM: } void f1_0(int *a0) { void (*f0p)(void *) = f0; f0(a0); diff --git a/test/CodeGen/ubsan-type-blacklist.cpp b/test/CodeGen/ubsan-type-blacklist.cpp index 7dc6fe159b51..b3137e7806c7 100644 --- a/test/CodeGen/ubsan-type-blacklist.cpp +++ b/test/CodeGen/ubsan-type-blacklist.cpp @@ -1,9 +1,7 @@ // Verify ubsan vptr does not check down-casts on blacklisted types. // RUN: echo "type:_ZTI3Foo" > %t-type.blacklist -// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=vptr -emit-llvm %s -o - | FileCheck %s --check-prefix=DEFAULT -// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=vptr -fsanitize-blacklist=%t-type.blacklist -emit-llvm %s -o - | FileCheck %s --check-prefix=TYPE - -// REQUIRES: shell +// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=vptr -fsanitize-recover=vptr -emit-llvm %s -o - | FileCheck %s --check-prefix=DEFAULT +// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=vptr -fsanitize-recover=vptr -fsanitize-blacklist=%t-type.blacklist -emit-llvm %s -o - | FileCheck %s --check-prefix=TYPE class Bar { public: diff --git a/test/CodeGen/variadic-null-win64.c b/test/CodeGen/variadic-null-win64.c new file mode 100644 index 000000000000..4f57e7b39f9f --- /dev/null +++ b/test/CodeGen/variadic-null-win64.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-windows-msvc | FileCheck %s --check-prefix=WINDOWS +// RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-linux | FileCheck %s --check-prefix=LINUX + +// Make it possible to pass NULL through variadic functions on platforms where +// NULL has an integer type that is more narrow than a pointer. On such +// platforms we widen null pointer constants to a pointer-sized integer. + +#define NULL 0 + +void v(const char *f, ...); +void f(const char *f) { + v(f, 1, 2, 3, NULL); +} +// WINDOWS: define void @f(i8* %f) +// WINDOWS: call void (i8*, ...)* @v(i8* {{.*}}, i32 1, i32 2, i32 3, i64 0) +// LINUX: define void @f(i8* %f) +// LINUX: call void (i8*, ...)* @v(i8* {{.*}}, i32 1, i32 2, i32 3, i32 0) diff --git a/test/CodeGen/vectorcall.c b/test/CodeGen/vectorcall.c new file mode 100644 index 000000000000..17927c7a3de4 --- /dev/null +++ b/test/CodeGen/vectorcall.c @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s +// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck %s --check-prefix=X64 + +void __vectorcall v1(int a, int b) {} +// CHECK: define x86_vectorcallcc void @"\01v1@@8"(i32 inreg %a, i32 inreg %b) +// X64: define x86_vectorcallcc void @"\01v1@@16"(i32 %a, i32 %b) + +void __vectorcall v2(char a, char b) {} +// CHECK: define x86_vectorcallcc void @"\01v2@@8"(i8 inreg signext %a, i8 inreg signext %b) +// X64: define x86_vectorcallcc void @"\01v2@@16"(i8 %a, i8 %b) + +struct Small { int a; }; +void __vectorcall v3(int a, struct Small b, int c) {} +// CHECK: define x86_vectorcallcc void @"\01v3@@12"(i32 inreg %a, %struct.Small* byval align 4 %b, i32 inreg %c) +// X64: define x86_vectorcallcc void @"\01v3@@24"(i32 %a, i32 %b.coerce, i32 %c) + +struct Large { int a[5]; }; +void __vectorcall v4(int a, struct Large b, int c) {} +// CHECK: define x86_vectorcallcc void @"\01v4@@28"(i32 inreg %a, %struct.Large* byval align 4 %b, i32 inreg %c) +// X64: define x86_vectorcallcc void @"\01v4@@40"(i32 %a, %struct.Large* %b, i32 %c) + +struct HFA2 { double x, y; }; +struct HFA4 { double w, x, y, z; }; +struct HFA5 { double v, w, x, y, z; }; + +void __vectorcall hfa1(int a, struct HFA4 b, int c) {} +// CHECK: define x86_vectorcallcc void @"\01hfa1@@40"(i32 inreg %a, double %b.0, double %b.1, double %b.2, double %b.3, i32 inreg %c) +// X64: define x86_vectorcallcc void @"\01hfa1@@48"(i32 %a, double %b.0, double %b.1, double %b.2, double %b.3, i32 %c) + +// HFAs that would require more than six total SSE registers are passed +// indirectly. Additional vector arguments can consume the rest of the SSE +// registers. +void __vectorcall hfa2(struct HFA4 a, struct HFA4 b, double c) {} +// CHECK: define x86_vectorcallcc void @"\01hfa2@@72"(double %a.0, double %a.1, double %a.2, double %a.3, %struct.HFA4* inreg %b, double %c) +// X64: define x86_vectorcallcc void @"\01hfa2@@72"(double %a.0, double %a.1, double %a.2, double %a.3, %struct.HFA4* align 8 %b, double %c) + +// Ensure that we pass builtin types directly while counting them against the +// SSE register usage. +void __vectorcall hfa3(double a, double b, double c, double d, double e, struct HFA2 f) {} +// CHECK: define x86_vectorcallcc void @"\01hfa3@@56"(double %a, double %b, double %c, double %d, double %e, %struct.HFA2* inreg %f) +// X64: define x86_vectorcallcc void @"\01hfa3@@56"(double %a, double %b, double %c, double %d, double %e, %struct.HFA2* align 8 %f) + +// Aggregates with more than four elements are not HFAs and are passed byval. +// Because they are not classified as homogeneous, they don't get special +// handling to ensure alignment. +void __vectorcall hfa4(struct HFA5 a) {} +// CHECK: define x86_vectorcallcc void @"\01hfa4@@40"(%struct.HFA5* byval align 4) +// X64: define x86_vectorcallcc void @"\01hfa4@@40"(%struct.HFA5* %a) + +// Return HFAs of 4 or fewer elements in registers. +static struct HFA2 g_hfa2; +struct HFA2 __vectorcall hfa5(void) { return g_hfa2; } +// CHECK: define x86_vectorcallcc %struct.HFA2 @"\01hfa5@@0"() +// X64: define x86_vectorcallcc %struct.HFA2 @"\01hfa5@@0"() + +typedef float __attribute__((vector_size(16))) v4f32; +struct HVA2 { v4f32 x, y; }; +struct HVA4 { v4f32 w, x, y, z; }; + +void __vectorcall hva1(int a, struct HVA4 b, int c) {} +// CHECK: define x86_vectorcallcc void @"\01hva1@@72"(i32 inreg %a, <4 x float> %b.0, <4 x float> %b.1, <4 x float> %b.2, <4 x float> %b.3, i32 inreg %c) +// X64: define x86_vectorcallcc void @"\01hva1@@80"(i32 %a, <4 x float> %b.0, <4 x float> %b.1, <4 x float> %b.2, <4 x float> %b.3, i32 %c) + +void __vectorcall hva2(struct HVA4 a, struct HVA4 b, v4f32 c) {} +// CHECK: define x86_vectorcallcc void @"\01hva2@@144"(<4 x float> %a.0, <4 x float> %a.1, <4 x float> %a.2, <4 x float> %a.3, %struct.HVA4* inreg %b, <4 x float> %c) +// X64: define x86_vectorcallcc void @"\01hva2@@144"(<4 x float> %a.0, <4 x float> %a.1, <4 x float> %a.2, <4 x float> %a.3, %struct.HVA4* align 16 %b, <4 x float> %c) + +void __vectorcall hva3(v4f32 a, v4f32 b, v4f32 c, v4f32 d, v4f32 e, struct HVA2 f) {} +// CHECK: define x86_vectorcallcc void @"\01hva3@@112"(<4 x float> %a, <4 x float> %b, <4 x float> %c, <4 x float> %d, <4 x float> %e, %struct.HVA2* inreg %f) +// X64: define x86_vectorcallcc void @"\01hva3@@112"(<4 x float> %a, <4 x float> %b, <4 x float> %c, <4 x float> %d, <4 x float> %e, %struct.HVA2* align 16 %f) + +typedef float __attribute__((ext_vector_type(3))) v3f32; +struct OddSizeHVA { v3f32 x, y; }; + +void __vectorcall odd_size_hva(struct OddSizeHVA a) {} +// CHECK: define x86_vectorcallcc void @"\01odd_size_hva@@32"(<3 x float> %a.0, <3 x float> %a.1) +// X64: define x86_vectorcallcc void @"\01odd_size_hva@@32"(<3 x float> %a.0, <3 x float> %a.1) diff --git a/test/CodeGen/vlt_to_pointer.c b/test/CodeGen/vlt_to_pointer.c new file mode 100644 index 000000000000..22c620aa6429 --- /dev/null +++ b/test/CodeGen/vlt_to_pointer.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s + +int c[1][3*2]; +// CHECK: @{{.+}} = {{.*}} global [1 x [6 x {{i[0-9]+}}]] zeroinitializer + +// CHECK-LABEL: @f +int f(int * const m, int (**v)[*m * 2]) +{ + return &(c[0][*m]) == &((*v)[0][*m]); + // CHECK: icmp + // CHECK: ret i{{[0-9]+}} +} + +// CHECK-LABEL: @test +int test(int n, int (*(*fn)(void))[n]) { + return (*fn())[0]; +} + +// CHECK-LABEL: @main +int main() +{ + int m = 3; + int (*d)[3*2] = c; + int (*fn[m])(void); + return f(&m, &d) + test(m, &fn); + + // CHECK: call {{.+}} @f( + // CHECK: ret i{{[0-9]+}} +} + diff --git a/test/CodeGen/wchar-const.c b/test/CodeGen/wchar-const.c index 34da249639ea..b461d605f6a9 100644 --- a/test/CodeGen/wchar-const.c +++ b/test/CodeGen/wchar-const.c @@ -7,9 +7,9 @@ typedef __WCHAR_TYPE__ wchar_t; #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \ || defined(_M_X64) || defined(SHORT_WCHAR) #define WCHAR_T_TYPE unsigned short -#elif defined(__sun) || defined(__AuroraUX__) +#elif defined(__sun) #define WCHAR_T_TYPE long -#else /* Solaris or AuroraUX. */ +#else /* Solaris. */ #define WCHAR_T_TYPE int #endif diff --git a/test/CodeGen/windows-struct-abi.c b/test/CodeGen/windows-struct-abi.c new file mode 100644 index 000000000000..4b4a6f1b5db3 --- /dev/null +++ b/test/CodeGen/windows-struct-abi.c @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -triple i686-windows-itanium -emit-llvm -o - %s | FileCheck %s + +struct f1 { + float f; +}; + +struct f1 return_f1(void) { while (1); } + +// CHECK: define i32 @return_f1() + +void receive_f1(struct f1 a0) { } + +// CHECK: define void @receive_f1(%struct.f1* byval align 4 %a0) + +struct f2 { + float f; + float g; +}; + +struct f2 return_f2(void) { while (1); } + +// CHECK: define i64 @return_f2() + +void receive_f2(struct f2 a0) { } + +// CHECK: define void @receive_f2(%struct.f2* byval align 4 %a0) + +struct f4 { + float f; + float g; + float h; + float i; +}; + +struct f4 return_f4(void) { while (1); } + +// CHECK: define void @return_f4(%struct.f4* noalias sret %agg.result) + +void receive_f4(struct f4 a0) { } + +// CHECK: define void @receive_f4(%struct.f4* byval align 4 %a0) + diff --git a/test/CodeGen/x86-atomic-long_double.c b/test/CodeGen/x86-atomic-long_double.c new file mode 100644 index 000000000000..22c7bd4b89c5 --- /dev/null +++ b/test/CodeGen/x86-atomic-long_double.c @@ -0,0 +1,469 @@ +// RUN: %clang_cc1 -triple x86_64-linux-gnu -target-cpu core2 %s -S -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -triple i686-linux-gnu -target-cpu core2 %s -S -emit-llvm -o - | FileCheck -check-prefix=CHECK32 %s + +long double testinc(_Atomic long double *addr) { + // CHECK-LABEL: @testinc + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[INC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[INC_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: ret x86_fp80 [[INC_VALUE]] + // CHECK32-LABEL: @testinc + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[INC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[INC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE:%.+]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: ret x86_fp80 [[INC_VALUE]] + + return ++*addr; +} + +long double testdec(_Atomic long double *addr) { + // CHECK-LABEL: @testdec + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[ORIG_LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[ORIG_LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[DEC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[DEC_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: ret x86_fp80 [[ORIG_LD_VALUE]] + // CHECK32-LABEL: @testdec + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[ORIG_LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[ORIG_LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[DEC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[DEC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: ret x86_fp80 [[ORIG_LD_VALUE]] + + return (*addr)--; +} + +long double testcompassign(_Atomic long double *addr) { + *addr -= 25; + // CHECK-LABEL: @testcompassign + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[SUB_VALUE:%.+]] = fsub x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[SUB_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 8 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VAL:%.+]] = load atomic i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK: [[INT_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i128* + // CHECK: store i128 [[INT_VAL]], i128* [[INT_LD_TEMP:%.+]], align 16 + // CHECK: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 16 + // CHECK: ret x86_fp80 [[RET_VAL]] + // CHECK32-LABEL: @testcompassign + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[INC_VALUE:%.+]] = fsub x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[INC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 4 + // CHECK32: [[VOID_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[VOID_GET_ADDR:%.+]] = bitcast x86_fp80* [[GET_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_ADDR]], i8* [[VOID_GET_ADDR]], i32 5) + // CHECK32: [[RET_VAL:%.+]] = load x86_fp80* [[GET_ADDR]], align 4 + // CHECK32: ret x86_fp80 [[RET_VAL]] + return *addr; +} + +long double testassign(_Atomic long double *addr) { + // CHECK-LABEL: @testassign + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[STORE_TEMP_VOID_PTR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 {{.+}}, x86_fp80* [[STORE_TEMP_PTR]], align 16 + // CHECK: [[STORE_TEMP_INT_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR]] to i128* + // CHECK: [[STORE_TEMP_INT:%.+]] = load i128* [[STORE_TEMP_INT_PTR]], align 16 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: store atomic i128 [[STORE_TEMP_INT]], i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK32-LABEL: @testassign + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[STORE_TEMP_VOID_PTR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 {{.+}}, x86_fp80* [[STORE_TEMP_PTR]], align 4 + // CHECK32: [[ADDR_VOID:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR]] to i8* + // CHECK32: call void @__atomic_store(i32 12, i8* [[ADDR_VOID]], i8* [[STORE_TEMP_VOID_PTR]], i32 5) + *addr = 115; + // CHECK: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 8 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VAL:%.+]] = load atomic i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK: [[INT_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i128* + // CHECK: store i128 [[INT_VAL]], i128* [[INT_LD_TEMP:%.+]], align 16 + // CHECK: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 16 + // CHECK: ret x86_fp80 [[RET_VAL]] + // CHECK32: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 4 + // CHECK32: [[VOID_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[VOID_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_ADDR]], i8* [[VOID_LD_TEMP]], i32 5) + // CHECK32: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 4 + // CHECK32: ret x86_fp80 [[RET_VAL]] + + return *addr; +} + +long double test_volatile_inc(volatile _Atomic long double *addr) { + // CHECK-LABEL: @test_volatile_inc + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic volatile i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[INC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[INC_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg volatile i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: ret x86_fp80 [[INC_VALUE]] + // CHECK32-LABEL: @test_volatile_inc + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[INC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[INC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: ret x86_fp80 [[INC_VALUE]] + return ++*addr; +} + +long double test_volatile_dec(volatile _Atomic long double *addr) { + // CHECK-LABEL: @test_volatile_dec + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic volatile i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[ORIG_LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[ORIG_LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[DEC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[DEC_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg volatile i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: ret x86_fp80 [[ORIG_LD_VALUE]] + // CHECK32-LABEL: @test_volatile_dec + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[ORIG_LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[ORIG_LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[DEC_VALUE:%.+]] = fadd x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[DEC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: ret x86_fp80 [[ORIG_LD_VALUE]] + return (*addr)--; +} + +long double test_volatile_compassign(volatile _Atomic long double *addr) { + *addr -= 25; + // CHECK-LABEL: @test_volatile_compassign + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VALUE:%.+]] = load atomic volatile i128* [[INT_ADDR]] seq_cst, align 16 + // CHECK: [[INT_LOAD_ADDR:%.+]] = bitcast x86_fp80* [[LD_ADDR:%.+]] to i128* + // CHECK: store i128 [[INT_VALUE]], i128* [[INT_LOAD_ADDR]], align 16 + // CHECK: [[LD_VALUE:%.+]] = load x86_fp80* [[LD_ADDR]], align 16 + // CHECK: br label %[[ATOMIC_OP:.+]] + // CHECK: [[ATOMIC_OP]] + // CHECK: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK: [[SUB_VALUE:%.+]] = fsub x86_fp80 [[OLD_VALUE]], + // CHECK: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 16 + // CHECK: [[OLD_INT_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i128* + // CHECK: [[OLD_INT:%.+]] = load i128* [[OLD_INT_ADDR]], align 16 + // CHECK: [[NEW_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[NEW_VALUE_VOID_ADDR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 [[SUB_VALUE]], x86_fp80* [[NEW_VALUE_ADDR]], align 16 + // CHECK: [[NEW_INT_ADDR:%.+]] = bitcast x86_fp80* [[NEW_VALUE_ADDR]] to i128* + // CHECK: [[NEW_INT:%.+]] = load i128* [[NEW_INT_ADDR]], align 16 + // CHECK: [[OBJ_INT_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[RES:%.+]] = cmpxchg volatile i128* [[OBJ_INT_ADDR]], i128 [[OLD_INT]], i128 [[NEW_INT]] seq_cst seq_cst + // CHECK: [[OLD_VALUE:%.+]] = extractvalue { i128, i1 } [[RES]], 0 + // CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 + // CHECK: [[OLD_VALUE_RES_INT_PTR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_RES_PTR:%.+]] to i128* + // CHECK: store i128 [[OLD_VALUE]], i128* [[OLD_VALUE_RES_INT_PTR]], align 16 + // CHECK: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_RES_PTR]], align 16 + // CHECK: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK: [[ATOMIC_CONT]] + // CHECK: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 8 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VAL:%.+]] = load atomic volatile i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK: [[INT_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i128* + // CHECK: store i128 [[INT_VAL]], i128* [[INT_LD_TEMP:%.+]], align 16 + // CHECK: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 16 + // CHECK32-LABEL: @test_volatile_compassign + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[VOID_PTR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[TEMP_LD_PTR:%.+]] = bitcast x86_fp80* [[TEMP_LD_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_PTR]], i8* [[TEMP_LD_PTR]], i32 5) + // CHECK32: [[LD_VALUE:%.+]] = load x86_fp80* [[TEMP_LD_ADDR]], align 4 + // CHECK32: br label %[[ATOMIC_OP:.+]] + // CHECK32: [[ATOMIC_OP]] + // CHECK32: [[OLD_VALUE:%.+]] = phi x86_fp80 [ [[LD_VALUE]], %{{.+}} ], [ [[LD_VALUE:%.+]], %[[ATOMIC_OP]] ] + // CHECK32: [[INC_VALUE:%.+]] = fsub x86_fp80 [[OLD_VALUE]], + // CHECK32: [[OLD_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[OLD_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[OLD_VALUE]], x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: [[DESIRED_VALUE_VOID_ADDR:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[DESIRED_VALUE_VOID_ADDR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 [[INC_VALUE]], x86_fp80* [[DESIRED_VALUE_ADDR]], align 4 + // CHECK32: [[OBJ:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[EXPECTED:%.+]] = bitcast x86_fp80* [[OLD_VALUE_ADDR]] to i8* + // CHECK32: [[DESIRED:%.+]] = bitcast x86_fp80* [[DESIRED_VALUE_ADDR]] to i8* + // CHECK32: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i32 12, i8* [[OBJ]], i8* [[EXPECTED]], i8* [[DESIRED]], i32 7, i32 7) + // CHECK32: [[LD_VALUE]] = load x86_fp80* [[OLD_VALUE_ADDR]], align 4 + // CHECK32: br i1 [[FAIL_SUCCESS]], label %[[ATOMIC_CONT:.+]], label %[[ATOMIC_OP]] + // CHECK32: [[ATOMIC_CONT]] + // CHECK32: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 4 + // CHECK32: [[VOID_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[VOID_GET_ADDR:%.+]] = bitcast x86_fp80* [[GET_ADDR:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_ADDR]], i8* [[VOID_GET_ADDR]], i32 5) + // CHECK32: [[RET_VAL:%.+]] = load x86_fp80* [[GET_ADDR]], align 4 + // CHECK32: ret x86_fp80 [[RET_VAL]] + return *addr; +} + +long double test_volatile_assign(volatile _Atomic long double *addr) { + // CHECK-LABEL: @test_volatile_assign + // CHECK: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 8 + // CHECK: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 8 + // CHECK: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR:%.+]] to i8* + // CHECK: call void @llvm.memset.p0i8.i64(i8* [[STORE_TEMP_VOID_PTR]], i8 0, i64 16, i32 16, i1 false) + // CHECK: store x86_fp80 {{.+}}, x86_fp80* [[STORE_TEMP_PTR]], align 16 + // CHECK: [[STORE_TEMP_INT_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR]] to i128* + // CHECK: [[STORE_TEMP_INT:%.+]] = load i128* [[STORE_TEMP_INT_PTR]], align 16 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: store atomic volatile i128 [[STORE_TEMP_INT]], i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK32-LABEL: @test_volatile_assign + // CHECK32: store x86_fp80* %{{.+}}, x86_fp80** [[ADDR_ADDR:%.+]], align 4 + // CHECK32: [[ADDR:%.+]] = load x86_fp80** [[ADDR_ADDR]], align 4 + // CHECK32: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR:%.+]] to i8* + // CHECK32: call void @llvm.memset.p0i8.i64(i8* [[STORE_TEMP_VOID_PTR]], i8 0, i64 12, i32 4, i1 false) + // CHECK32: store x86_fp80 {{.+}}, x86_fp80* [[STORE_TEMP_PTR]], align 4 + // CHECK32: [[ADDR_VOID:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[STORE_TEMP_VOID_PTR:%.+]] = bitcast x86_fp80* [[STORE_TEMP_PTR]] to i8* + // CHECK32: call void @__atomic_store(i32 12, i8* [[ADDR_VOID]], i8* [[STORE_TEMP_VOID_PTR]], i32 5) + *addr = 115; + // CHECK: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 8 + // CHECK: [[ADDR_INT:%.+]] = bitcast x86_fp80* [[ADDR]] to i128* + // CHECK: [[INT_VAL:%.+]] = load atomic volatile i128* [[ADDR_INT]] seq_cst, align 16 + // CHECK: [[INT_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i128* + // CHECK: store i128 [[INT_VAL]], i128* [[INT_LD_TEMP:%.+]], align 16 + // CHECK: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 16 + // CHECK: ret x86_fp80 [[RET_VAL]] + // CHECK32: [[ADDR:%.+]] = load x86_fp80** %{{.+}}, align 4 + // CHECK32: [[VOID_ADDR:%.+]] = bitcast x86_fp80* [[ADDR]] to i8* + // CHECK32: [[VOID_LD_TEMP:%.+]] = bitcast x86_fp80* [[LD_TEMP:%.+]] to i8* + // CHECK32: call void @__atomic_load(i32 12, i8* [[VOID_ADDR]], i8* [[VOID_LD_TEMP]], i32 5) + // CHECK32: [[RET_VAL:%.+]] = load x86_fp80* [[LD_TEMP]], align 4 + // CHECK32: ret x86_fp80 [[RET_VAL]] + + return *addr; +} diff --git a/test/CodeGen/x86_32-inline-asm.c b/test/CodeGen/x86_32-inline-asm.c index 473f78ebcae6..c1fba0eee942 100644 --- a/test/CodeGen/x86_32-inline-asm.c +++ b/test/CodeGen/x86_32-inline-asm.c @@ -1,5 +1,9 @@ // RUN: %clang_cc1 -triple i386-apple-darwin9 -verify %s +// RUN: %clang_cc1 -triple i386-apple-darwin9 -target-feature +avx -verify %s + // <rdar://problem/12415959> +// rdar://problem/11846140 +// rdar://problem/17476970 typedef unsigned int u_int32_t; typedef u_int32_t uint32_t; @@ -7,6 +11,14 @@ typedef u_int32_t uint32_t; typedef unsigned long long u_int64_t; typedef u_int64_t uint64_t; +typedef float __m128 __attribute__ ((vector_size (16))); +typedef float __m256 __attribute__ ((vector_size (32))); +typedef float __m512 __attribute__ ((vector_size (64))); + +__m128 val128; +__m256 val256; +__m512 val512; + int func1() { // Error out if size is > 32-bits. uint32_t msr = 0x8b; @@ -21,4 +33,40 @@ int func1() { unsigned char data; unsigned int port; __asm__ volatile("outb %0, %w1" : : "a" (data), "Nd" (port)); // No error expected. + + __asm__ volatile("outb %0, %w1" : : "R" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'R'}} + __asm__ volatile("outb %0, %w1" : : "q" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'q'}} + __asm__ volatile("outb %0, %w1" : : "Q" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'Q'}} + __asm__ volatile("outb %0, %w1" : : "b" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'b'}} + __asm__ volatile("outb %0, %w1" : : "c" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'c'}} + __asm__ volatile("outb %0, %w1" : : "d" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'd'}} + __asm__ volatile("outb %0, %w1" : : "S" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'S'}} + __asm__ volatile("outb %0, %w1" : : "D" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'D'}} + __asm__ volatile("foo1 %0" : : "A" (val128)); // expected-error {{invalid input size for constraint 'A'}} + __asm__ volatile("foo1 %0" : : "f" (val256)); // expected-error {{invalid input size for constraint 'f'}} + __asm__ volatile("foo1 %0" : : "t" (val256)); // expected-error {{invalid input size for constraint 't'}} + __asm__ volatile("foo1 %0" : : "u" (val256)); // expected-error {{invalid input size for constraint 'u'}} + __asm__ volatile("foo1 %0" : : "x" (val512)); // expected-error {{invalid input size for constraint 'x'}} + + __asm__ volatile("foo1 %0" : "=R" (val)); // expected-error {{invalid output size for constraint '=R'}} + __asm__ volatile("foo1 %0" : "=q" (val)); // expected-error {{invalid output size for constraint '=q'}} + __asm__ volatile("foo1 %0" : "=Q" (val)); // expected-error {{invalid output size for constraint '=Q'}} + __asm__ volatile("foo1 %0" : "=a" (val)); // expected-error {{invalid output size for constraint '=a'}} + __asm__ volatile("foo1 %0" : "=b" (val)); // expected-error {{invalid output size for constraint '=b'}} + __asm__ volatile("foo1 %0" : "=c" (val)); // expected-error {{invalid output size for constraint '=c'}} + __asm__ volatile("foo1 %0" : "=d" (val)); // expected-error {{invalid output size for constraint '=d'}} + __asm__ volatile("foo1 %0" : "=S" (val)); // expected-error {{invalid output size for constraint '=S'}} + __asm__ volatile("foo1 %0" : "=D" (val)); // expected-error {{invalid output size for constraint '=D'}} + __asm__ volatile("foo1 %0" : "=A" (val128)); // expected-error {{invalid output size for constraint '=A'}} + __asm__ volatile("foo1 %0" : "=t" (val256)); // expected-error {{invalid output size for constraint '=t'}} + __asm__ volatile("foo1 %0" : "=u" (val256)); // expected-error {{invalid output size for constraint '=u'}} + __asm__ volatile("foo1 %0" : "=x" (val512)); // expected-error {{invalid output size for constraint '=x'}} + +#ifdef __AVX__ + __asm__ volatile("foo1 %0" : : "x" (val256)); // No error. + __asm__ volatile("foo1 %0" : "=x" (val256)); // No error. +#else + __asm__ volatile("foo1 %0" : : "x" (val256)); // expected-error {{invalid input size for constraint 'x'}} + __asm__ volatile("foo1 %0" : "=x" (val256)); // expected-error {{invalid output size for constraint '=x'}} +#endif } diff --git a/test/CodeGen/x86_64-arguments-win32.c b/test/CodeGen/x86_64-arguments-win32.c new file mode 100644 index 000000000000..5aea7fc62368 --- /dev/null +++ b/test/CodeGen/x86_64-arguments-win32.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -w -triple x86_64-pc-win32 -emit-llvm -o - %s | FileCheck %s + +// To be ABI compatible with code generated by MSVC, there shouldn't be any +// sign/zero extensions on types smaller than 64bit. + +// CHECK-LABEL: define void @f1(i8 %a) +void f1(char a) {} + +// CHECK-LABEL: define void @f2(i8 %a) +void f2(unsigned char a) {} + +// CHECK-LABEL: define void @f3(i16 %a) +void f3(short a) {} + +// CHECK-LABEL: define void @f4(i16 %a) +void f4(unsigned short a) {} diff --git a/test/CodeGen/xcore-stringtype.c b/test/CodeGen/xcore-stringtype.c index 25589d5b2b21..1297ca0bb733 100644 --- a/test/CodeGen/xcore-stringtype.c +++ b/test/CodeGen/xcore-stringtype.c @@ -5,19 +5,27 @@ // In the tests below, some types are not supported by the ABI (_Complex, // variable length arrays) and will thus emit no meta data. -// The 33 tests that do emit typestrings are gathered into '!xcore.typestrings' +// The 38 tests that do emit typestrings are gathered into '!xcore.typestrings' // Please see 'Tools Development Guide' section 2.16.2 for format details: // <https://www.xmos.com/download/public/Tools-Development-Guide%28X9114A%29.pdf> -// CHECK: !xcore.typestrings = !{!1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, -// CHECK: !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, -// CHECK: !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38} +// CHECK: !xcore.typestrings = !{ +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, +// CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}} +// CHECK-NOT: , !{{[0-9]+}} +// CHECK: } // test BuiltinType -// CHECK: !1 = metadata !{void (i1, i8, i8, i8, i16, i16, i16, i32, i32, i32, +// CHECK: !{{[0-9]+}} = !{void (i1, i8, i8, i8, i16, i16, i16, i32, i32, i32, // CHECK: i32, i32, i32, i64, i64, i64, float, double, double)* -// CHECK: @builtinType, metadata !"f{0}(b,uc,uc,sc,ss,us,ss,si,ui,si,sl, +// CHECK: @builtinType, !"f{0}(b,uc,uc,sc,ss,us,ss,si,ui,si,sl, // CHECK: ul,sl,sll,ull,sll,ft,d,ld)"} void builtinType(_Bool B, char C, unsigned char UC, signed char SC, short S, unsigned short US, signed short SS, int I, unsigned int UI, @@ -28,14 +36,14 @@ double _Complex Complex; // not supported // test FunctionType & Qualifiers -// CHECK: !2 = metadata !{void ()* @gI, metadata !"f{0}()"} -// CHECK: !3 = metadata !{void (...)* @eI, metadata !"f{0}()"} -// CHECK: !4 = metadata !{void ()* @gV, metadata !"f{0}(0)"} -// CHECK: !5 = metadata !{void ()* @eV, metadata !"f{0}(0)"} -// CHECK: !6 = metadata !{void (i32, ...)* @gVA, metadata !"f{0}(si,va)"} -// CHECK: !7 = metadata !{void (i32, ...)* @eVA, metadata !"f{0}(si,va)"} -// CHECK: !8 = metadata !{i32* (i32*)* @gQ, metadata !"f{crv:p(cv:si)}(p(cv:si))"} -// CHECK: !9 = metadata !{i32* (i32*)* @eQ, metadata !"f{crv:p(cv:si)}(p(cv:si))"} +// CHECK: !{{[0-9]+}} = !{void ()* @gI, !"f{0}()"} +// CHECK: !{{[0-9]+}} = !{void (...)* @eI, !"f{0}()"} +// CHECK: !{{[0-9]+}} = !{void ()* @gV, !"f{0}(0)"} +// CHECK: !{{[0-9]+}} = !{void ()* @eV, !"f{0}(0)"} +// CHECK: !{{[0-9]+}} = !{void (i32, ...)* @gVA, !"f{0}(si,va)"} +// CHECK: !{{[0-9]+}} = !{void (i32, ...)* @eVA, !"f{0}(si,va)"} +// CHECK: !{{[0-9]+}} = !{i32* (i32*)* @gQ, !"f{crv:p(cv:si)}(p(cv:si))"} +// CHECK: !{{[0-9]+}} = !{i32* (i32*)* @eQ, !"f{crv:p(cv:si)}(p(cv:si))"} extern void eI(); void gI() {eI();}; extern void eV(void); @@ -49,10 +57,10 @@ const volatile int* volatile restrict const // test PointerType -// CHECK: !10 = metadata !{i32* (i32*, i32* (i32*)*)* -// CHECK: @pointerType, metadata !"f{p(si)}(p(si),p(f{p(si)}(p(si))))"} -// CHECK: !11 = metadata !{i32** @EP, metadata !"p(si)"} -// CHECK: !12 = metadata !{i32** @GP, metadata !"p(si)"} +// CHECK: !{{[0-9]+}} = !{i32* (i32*, i32* (i32*)*)* +// CHECK: @pointerType, !"f{p(si)}(p(si),p(f{p(si)}(p(si))))"} +// CHECK: !{{[0-9]+}} = !{i32** @EP, !"p(si)"} +// CHECK: !{{[0-9]+}} = !{i32** @GP, !"p(si)"} extern int* EP; int* GP; int* pointerType(int *I, int * (*FP)(int *)) { @@ -60,19 +68,19 @@ int* pointerType(int *I, int * (*FP)(int *)) { } // test ArrayType -// CHECK: !13 = metadata !{[2 x i32]* (i32*, i32*, [2 x i32]*, [2 x i32]*, i32*)* -// CHECK: @arrayType, metadata !"f{p(a(2:si))}(p(si),p(cv:si),p(a(2:si)), +// CHECK: !{{[0-9]+}} = !{[2 x i32]* (i32*, i32*, [2 x i32]*, [2 x i32]*, i32*)* +// CHECK: @arrayType, !"f{p(a(2:si))}(p(si),p(cv:si),p(a(2:si)), // CHECK: p(a(2:si)),p(si))"} -// CHECK: !14 = metadata !{[0 x i32]* @EA1, metadata !"a(*:cv:si)"} -// CHECK: !15 = metadata !{[2 x i32]* @EA2, metadata !"a(2:si)"} -// CHECK: !16 = metadata !{[0 x [2 x i32]]* @EA3, metadata !"a(*:a(2:si))"} -// CHECK: !17 = metadata !{[3 x [2 x i32]]* @EA4, metadata !"a(3:a(2:si))"} -// CHECK: !18 = metadata !{[2 x i32]* @GA1, metadata !"a(2:cv:si)"} -// CHECK: !19 = metadata !{void ([2 x i32]*)* @arrayTypeVariable1, -// CHECK: metadata !"f{0}(p(a(2:si)))"} -// CHECK: !20 = metadata !{void (void ([2 x i32]*)*)* @arrayTypeVariable2, -// CHECK: metadata !"f{0}(p(f{0}(p(a(2:si)))))"} -// CHECK: !21 = metadata !{[3 x [2 x i32]]* @GA2, metadata !"a(3:a(2:si))"} +// CHECK: !{{[0-9]+}} = !{[0 x i32]* @EA1, !"a(*:cv:si)"} +// CHECK: !{{[0-9]+}} = !{[2 x i32]* @EA2, !"a(2:si)"} +// CHECK: !{{[0-9]+}} = !{[0 x [2 x i32]]* @EA3, !"a(*:a(2:si))"} +// CHECK: !{{[0-9]+}} = !{[3 x [2 x i32]]* @EA4, !"a(3:a(2:si))"} +// CHECK: !{{[0-9]+}} = !{[2 x i32]* @GA1, !"a(2:cv:si)"} +// CHECK: !{{[0-9]+}} = !{void ([2 x i32]*)* @arrayTypeVariable1, +// CHECK: !"f{0}(p(a(2:si)))"} +// CHECK: !{{[0-9]+}} = !{void (void ([2 x i32]*)*)* @arrayTypeVariable2, +// CHECK: !"f{0}(p(f{0}(p(a(2:si)))))"} +// CHECK: !{{[0-9]+}} = !{[3 x [2 x i32]]* @GA2, !"a(3:a(2:si))"} extern int GA2[3][2]; extern const volatile int EA1[]; extern int EA2[2]; @@ -100,16 +108,16 @@ RetType* arrayType(int A1[], int const volatile A2[2], int A3[][2], // test StructureType -// CHECK: !22 = metadata !{void (%struct.S1*)* @structureType1, metadata +// CHECK: !{{[0-9]+}} = !{void (%struct.S1*)* @structureType1, // CHECK: !"f{0}(s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){m(s1){s(S1){}}})}})}})"} -// CHECK: !23 = metadata !{void (%struct.S2*)* @structureType2, metadata +// CHECK: !{{[0-9]+}} = !{void (%struct.S2*)* @structureType2, // CHECK: !"f{0}(s(S2){m(ps3){p(s(S3){m(s1){s(S1){m(ps2){p(s(S2){})}}}})}})"} -// CHECK: !24 = metadata !{void (%struct.S3*)* @structureType3, metadata +// CHECK: !{{[0-9]+}} = !{void (%struct.S3*)* @structureType3, // CHECK: !"f{0}(s(S3){m(s1){s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){})}})}}}})"} -// CHECK: !25 = metadata !{void (%struct.S4*)* @structureType4, metadata +// CHECK: !{{[0-9]+}} = !{void (%struct.S4*)* @structureType4, // CHECK: !"f{0}(s(S4){m(s1){s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){m(s1){s(S1){}}})}})}}}})"} -// CHECK: !26 = metadata !{%struct.anon* @StructAnon, metadata !"s(){m(A){si}}"} -// CHECK: !27 = metadata !{i32 (%struct.SB*)* @structureTypeB, metadata +// CHECK: !{{[0-9]+}} = !{%struct.anon* @StructAnon, !"s(){m(A){si}}"} +// CHECK: !{{[0-9]+}} = !{i32 (%struct.SB*)* @structureTypeB, // CHECK: !"f{si}(s(SB){m(){b(4:si)},m(){b(2:si)},m(N4){b(4:si)}, // CHECK: m(N2){b(2:si)},m(){b(4:ui)},m(){b(4:si)},m(){b(4:c:si)}, // CHECK: m(){b(4:c:si)},m(){b(4:cv:si)}})"} @@ -130,16 +138,16 @@ int structureTypeB(struct SB sb){return StructAnon.A;} // test UnionType -// CHECK: !28 = metadata !{void (%union.U1*)* @unionType1, metadata +// CHECK: !{{[0-9]+}} = !{void (%union.U1*)* @unionType1, // CHECK: !"f{0}(u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){m(u1){u(U1){}}})}})}})"} -// CHECK: !29 = metadata !{void (%union.U2*)* @unionType2, metadata +// CHECK: !{{[0-9]+}} = !{void (%union.U2*)* @unionType2, // CHECK: !"f{0}(u(U2){m(pu3){p(u(U3){m(u1){u(U1){m(pu2){p(u(U2){})}}}})}})"} -// CHECK: !30 = metadata !{void (%union.U3*)* @unionType3, metadata +// CHECK: !{{[0-9]+}} = !{void (%union.U3*)* @unionType3, // CHECK: !"f{0}(u(U3){m(u1){u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){})}})}}}})"} -// CHECK: !31 = metadata !{void (%union.U4*)* @unionType4, metadata +// CHECK: !{{[0-9]+}} = !{void (%union.U4*)* @unionType4, // CHECK: !"f{0}(u(U4){m(u1){u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){m(u1){u(U1){}}})}})}}}})"} -// CHECK: !32 = metadata !{%union.anon* @UnionAnon, metadata !"u(){m(A){si}}"} -// CHECK: !33 = metadata !{i32 (%union.UB*)* @unionTypeB, metadata +// CHECK: !{{[0-9]+}} = !{%union.anon* @UnionAnon, !"u(){m(A){si}}"} +// CHECK: !{{[0-9]+}} = !{i32 (%union.UB*)* @unionTypeB, // CHECK: !"f{si}(u(UB){m(N2){b(2:si)},m(N4){b(4:si)},m(){b(2:si)}, // CHECK: m(){b(4:c:si)},m(){b(4:c:si)},m(){b(4:cv:si)},m(){b(4:si)}, // CHECK: m(){b(4:si)},m(){b(4:ui)}})"} @@ -160,17 +168,17 @@ int unionTypeB(union UB ub) {return UnionAnon.A;} // test EnumType -// CHECK: !34 = metadata !{i32* @EnumAnon, metadata !"e(){m(EA){3}}"} -// CHECK: !35 = metadata !{i32 (i32)* @enumType, metadata +// CHECK: !{{[0-9]+}} = !{i32* @EnumAnon, !"e(){m(EA){3}}"} +// CHECK: !{{[0-9]+}} = !{i32 (i32)* @enumType, // CHECK: !"f{si}(e(E){m(A){7},m(B){6},m(C){5},m(D){0}})"} enum E {D, C=5, B, A}; enum {EA=3} EnumAnon = EA; int enumType(enum E e) {return EnumAnon;} -// CHECK: !36 = metadata !{i32 ()* @testReDecl, metadata !"f{si}()"} -// CHECK: !37 = metadata !{[10 x i32]* @After, metadata !"a(10:si)"} -// CHECK: !38 = metadata !{[10 x i32]* @Before, metadata !"a(10:si)"} +// CHECK: !{{[0-9]+}} = !{i32 ()* @testReDecl, !"f{si}()"} +// CHECK: !{{[0-9]+}} = !{[10 x i32]* @After, !"a(10:si)"} +// CHECK: !{{[0-9]+}} = !{[10 x i32]* @Before, !"a(10:si)"} extern int After[]; extern int Before[10]; int testReDecl() {return After[0] + Before[0];} diff --git a/test/CodeGenCUDA/launch-bounds.cu b/test/CodeGenCUDA/launch-bounds.cu index ed4c2bfc8870..6f4102ea0076 100644 --- a/test/CodeGenCUDA/launch-bounds.cu +++ b/test/CodeGenCUDA/launch-bounds.cu @@ -14,8 +14,8 @@ Kernel1() } } -// CHECK: !{{[0-9]+}} = metadata !{void ()* @Kernel1, metadata !"maxntidx", i32 256} -// CHECK: !{{[0-9]+}} = metadata !{void ()* @Kernel1, metadata !"minctasm", i32 2} +// CHECK: !{{[0-9]+}} = !{void ()* @Kernel1, !"maxntidx", i32 256} +// CHECK: !{{[0-9]+}} = !{void ()* @Kernel1, !"minctasm", i32 2} // Test only max threads per block. Min cta per sm defaults to 0, and // CodeGen doesn't output a zero value for minctasm. @@ -27,4 +27,4 @@ Kernel2() } } -// CHECK: !{{[0-9]+}} = metadata !{void ()* @Kernel2, metadata !"maxntidx", i32 256} +// CHECK: !{{[0-9]+}} = !{void ()* @Kernel2, !"maxntidx", i32 256} diff --git a/test/CodeGenCUDA/ptx-kernels.cu b/test/CodeGenCUDA/ptx-kernels.cu index 11b92b587606..658b3488fc18 100644 --- a/test/CodeGenCUDA/ptx-kernels.cu +++ b/test/CodeGenCUDA/ptx-kernels.cu @@ -13,4 +13,4 @@ __global__ void global_function() { device_function(); } -// CHECK: !{{[0-9]+}} = metadata !{void ()* @global_function, metadata !"kernel", i32 1} +// CHECK: !{{[0-9]+}} = !{void ()* @global_function, !"kernel", i32 1} diff --git a/test/CodeGenCXX/2010-07-23-DeclLoc.cpp b/test/CodeGenCXX/2010-07-23-DeclLoc.cpp index 4c689029b8a8..56c364cb485f 100644 --- a/test/CodeGenCXX/2010-07-23-DeclLoc.cpp +++ b/test/CodeGenCXX/2010-07-23-DeclLoc.cpp @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s // Require the template function declaration refer to the correct filename. // First, locate the function decl in metadata, and pluck out the file handle: -// CHECK: metadata [[filehandle:![0-9]+]], {{[^,]*}}, {{.*extract_dwarf_data_from_header.*extract_dwarf_data_from_header.*extract_dwarf_data_from_header.*[^ ]+", }} +// CHECK: !"0x2e\00extract_dwarf_data_from_header{{[^"]+}}", [[filehandle:![0-9]+]] // Second: Require that filehandle refer to the correct filename: // CHECK: [[filehandle]] = {{.*}}decl_should_be_here.hpp" typedef long unsigned int __darwin_size_t; diff --git a/test/CodeGenCXX/PR20038.cpp b/test/CodeGenCXX/PR20038.cpp index c24685d696b6..0936dfc64904 100644 --- a/test/CodeGenCXX/PR20038.cpp +++ b/test/CodeGenCXX/PR20038.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple %itanium_abi_triple -g -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -triple %itanium_abi_triple -g -mllvm -no-discriminators -emit-llvm %s -o - | FileCheck %s struct C { ~C(); @@ -8,9 +8,7 @@ extern bool b; // CHECK: call {{.*}}, !dbg [[DTOR_CALL2_LOC:![0-9]*]] // CHECK: [[FUN1:.*]] = {{.*}}; [ DW_TAG_subprogram ] {{.*}} [def] [fun1] // CHECK: [[FUN2:.*]] = {{.*}}; [ DW_TAG_subprogram ] {{.*}} [def] [fun2] -// CHECK: [[DTOR_CALL1_LOC]] = metadata !{i32 [[@LINE+2]], i32 0, metadata [[FUN1_BLOCK:.*]], null} -// CHECK: [[FUN1_BLOCK]] = metadata !{{{[^,]*}}, {{[^,]*}}, metadata [[FUN1]], +// CHECK: [[DTOR_CALL1_LOC]] = !MDLocation(line: [[@LINE+1]], scope: [[FUN1]]) void fun1() { b && (C(), 1); } -// CHECK: [[DTOR_CALL2_LOC]] = metadata !{i32 [[@LINE+2]], i32 0, metadata [[FUN2_BLOCK1:.*]], null} -// CHECK: [[FUN2_BLOCK1]] = metadata !{{{[^,]*}}, {{[^,]*}}, metadata [[FUN2]], +// CHECK: [[DTOR_CALL2_LOC]] = !MDLocation(line: [[@LINE+1]], scope: [[FUN2]]) bool fun2() { return (C(), b) && 0; } diff --git a/test/CodeGenCXX/align-avx-complete-objects.cpp b/test/CodeGenCXX/align-avx-complete-objects.cpp new file mode 100644 index 000000000000..25f4ef1099ac --- /dev/null +++ b/test/CodeGenCXX/align-avx-complete-objects.cpp @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -x c++ %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -fmax-type-align=16 -emit-llvm -o - -Werror | FileCheck %s +// rdar://16254558 + +typedef float AVX2Float __attribute__((__vector_size__(32))); + + +volatile float TestAlign(void) +{ + volatile AVX2Float *p = new AVX2Float; + *p = *p; + AVX2Float r = *p; + return r[0]; +} + +// CHECK: [[R:%.*]] = alloca <8 x float>, align 32 +// CHECK-NEXT: [[CALL:%.*]] = call noalias i8* @_Znwm(i64 32) +// CHECK-NEXT: [[ZERO:%.*]] = bitcast i8* [[CALL]] to <8 x float>* +// CHECK-NEXT: store <8 x float>* [[ZERO]], <8 x float>** [[P:%.*]], align 8 +// CHECK-NEXT: [[ONE:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: [[TWO:%.*]] = load volatile <8 x float>* [[ONE]], align 16 +// CHECK-NEXT: [[THREE:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: store volatile <8 x float> [[TWO]], <8 x float>* [[THREE]], align 16 +// CHECK-NEXT: [[FOUR:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: [[FIVE:%.*]] = load volatile <8 x float>* [[FOUR]], align 16 +// CHECK-NEXT: store <8 x float> [[FIVE]], <8 x float>* [[R]], align 32 +// CHECK-NEXT: [[SIX:%.*]] = load <8 x float>* [[R]], align 32 +// CHECK-NEXT: [[VECEXT:%.*]] = extractelement <8 x float> [[SIX]], i32 0 +// CHECK-NEXT: ret float [[VECEXT]] + +typedef float AVX2Float_Explicitly_aligned __attribute__((__vector_size__(32))) __attribute__((aligned (32))); + +typedef AVX2Float_Explicitly_aligned AVX2Float_indirect; + +typedef AVX2Float_indirect AVX2Float_use_existing_align; + +volatile float TestAlign2(void) +{ + volatile AVX2Float_use_existing_align *p = new AVX2Float_use_existing_align; + *p = *p; + AVX2Float_use_existing_align r = *p; + return r[0]; +} + +// CHECK: [[R:%.*]] = alloca <8 x float>, align 32 +// CHECK-NEXT: [[CALL:%.*]] = call noalias i8* @_Znwm(i64 32) +// CHECK-NEXT: [[ZERO:%.*]] = bitcast i8* [[CALL]] to <8 x float>* +// CHECK-NEXT: store <8 x float>* [[ZERO]], <8 x float>** [[P:%.*]], align 8 +// CHECK-NEXT: [[ONE:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: [[TWO:%.*]] = load volatile <8 x float>* [[ONE]], align 32 +// CHECK-NEXT: [[THREE:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: store volatile <8 x float> [[TWO]], <8 x float>* [[THREE]], align 32 +// CHECK-NEXT: [[FOUR:%.*]] = load <8 x float>** [[P]], align 8 +// CHECK-NEXT: [[FIVE:%.*]] = load volatile <8 x float>* [[FOUR]], align 32 +// CHECK-NEXT: store <8 x float> [[FIVE]], <8 x float>* [[R]], align 32 +// CHECK-NEXT: [[SIX:%.*]] = load <8 x float>* [[R]], align 32 +// CHECK-NEXT: [[VECEXT:%.*]] = extractelement <8 x float> [[SIX]], i32 0 +// CHECK-NEXT: ret float [[VECEXT]] diff --git a/test/CodeGenCXX/atomicinit.cpp b/test/CodeGenCXX/atomicinit.cpp index f453194468dd..982396e177ab 100644 --- a/test/CodeGenCXX/atomicinit.cpp +++ b/test/CodeGenCXX/atomicinit.cpp @@ -1,9 +1,13 @@ // RUN: %clang_cc1 %s -emit-llvm -O1 -o - -triple=i686-apple-darwin9 -std=c++11 | FileCheck %s -// CHECK-DAG: @_ZN7PR180978constant1aE = global {{.*}} { i16 1, i8 6, i8 undef }, align 4 -// CHECK-DAG: @_ZN7PR180978constant1bE = global {{.*}} { i16 2, i8 6, i8 undef }, align 4 -// CHECK-DAG: @_ZN7PR180978constant1cE = global {{.*}} { i16 3, i8 6, i8 undef }, align 4 -// CHECK-DAG: @_ZN7PR180978constant1yE = global {{.*}} { {{.*}} { i16 4, i8 6, i8 undef }, i32 5 }, align 4 +// CHECK-DAG: @PR22043 = global i32 0, align 4 +typedef _Atomic(int) AtomicInt; +AtomicInt PR22043 = AtomicInt(); + +// CHECK-DAG: @_ZN7PR180978constant1aE = global { i16, i8 } { i16 1, i8 6 }, align 4 +// CHECK-DAG: @_ZN7PR180978constant1bE = global { i16, i8 } { i16 2, i8 6 }, align 4 +// CHECK-DAG: @_ZN7PR180978constant1cE = global { i16, i8 } { i16 3, i8 6 }, align 4 +// CHECK-DAG: @_ZN7PR180978constant1yE = global { { i16, i8 }, i32 } { { i16, i8 } { i16 4, i8 6 }, i32 5 }, align 4 struct A { _Atomic(int) i; diff --git a/test/CodeGenCXX/attr-used.cpp b/test/CodeGenCXX/attr-used.cpp index 861734667357..d2a73f7d33e6 100644 --- a/test/CodeGenCXX/attr-used.cpp +++ b/test/CodeGenCXX/attr-used.cpp @@ -2,16 +2,16 @@ // <rdar://problem/8684363>: clang++ not respecting __attribute__((used)) on destructors struct X0 { - // CHECK: define linkonce_odr {{.*}} @_ZN2X0C1Ev + // CHECK-DAG: define linkonce_odr {{.*}} @_ZN2X0C1Ev __attribute__((used)) X0() {} - // CHECK: define linkonce_odr {{.*}} @_ZN2X0D1Ev + // CHECK-DAG: define linkonce_odr {{.*}} @_ZN2X0D1Ev __attribute__((used)) ~X0() {} }; // PR19743: not emitting __attribute__((used)) inline methods in nested classes. struct X1 { struct Nested { - // CHECK: define linkonce_odr {{.*}} @_ZN2X16Nested1fEv + // CHECK-DAG: define linkonce_odr {{.*}} @_ZN2X16Nested1fEv void __attribute__((used)) f() {} }; }; @@ -22,6 +22,6 @@ struct X2 { void __attribute__((used)) bar() { foo(); } void foo() { } - // CHECK: define linkonce_odr {{.*}} @_ZN2X23barEv - // CHECK: define linkonce_odr {{.*}} @_ZN2X23fooEv + // CHECK-DAG: define linkonce_odr {{.*}} @_ZN2X23barEv + // CHECK-DAG: define linkonce_odr {{.*}} @_ZN2X23fooEv }; diff --git a/test/CodeGenCXX/call-with-static-chain.cpp b/test/CodeGenCXX/call-with-static-chain.cpp new file mode 100644 index 000000000000..7cf929189f2c --- /dev/null +++ b/test/CodeGenCXX/call-with-static-chain.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o - %s | FileCheck -check-prefix=CHECK32 %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck -check-prefix=CHECK64 %s + +struct A { + long x, y; +}; + +struct B { + long x, y, z, w; +}; + +extern "C" { + +int f1(A, A, A, A); +B f2(void); +_Complex float f3(void); +A &f4(); + +} + +void test() { + A a; + + // CHECK32: call i32 bitcast (i32 (%struct.A*, %struct.A*, %struct.A*, %struct.A*)* @f1 to i32 (i8*, %struct.A*, %struct.A*, %struct.A*, %struct.A*)*)(i8* nest bitcast (i32 (%struct.A*, %struct.A*, %struct.A*, %struct.A*)* @f1 to i8*) + // CHECK64: call i32 bitcast (i32 (i64, i64, i64, i64, i64, i64, %struct.A*)* @f1 to i32 (i8*, i64, i64, i64, i64, i64, i64, %struct.A*)*)(i8* nest bitcast (i32 (i64, i64, i64, i64, i64, i64, %struct.A*)* @f1 to i8*) + __builtin_call_with_static_chain(f1(a, a, a, a), f1); + + // CHECK32: call void bitcast (void (%struct.B*)* @f2 to void (%struct.B*, i8*)*)(%struct.B* sret %{{[0-9a-z]+}}, i8* nest bitcast (void (%struct.B*)* @f2 to i8*)) + // CHECK64: call void bitcast (void (%struct.B*)* @f2 to void (%struct.B*, i8*)*)(%struct.B* sret %{{[0-9a-z]+}}, i8* nest bitcast (void (%struct.B*)* @f2 to i8*)) + __builtin_call_with_static_chain(f2(), f2); + + // CHECK32: call i64 bitcast (i64 ()* @f3 to i64 (i8*)*)(i8* nest bitcast (i64 ()* @f3 to i8*)) + // CHECK64: call <2 x float> bitcast (<2 x float> ()* @f3 to <2 x float> (i8*)*)(i8* nest bitcast (<2 x float> ()* @f3 to i8*)) + __builtin_call_with_static_chain(f3(), f3); + + // CHECK32: call dereferenceable(8) %struct.A* bitcast (%struct.A* ()* @f4 to %struct.A* (i8*)*)(i8* nest bitcast (%struct.A* ()* @f4 to i8*)) + // CHECK64: call dereferenceable(16) %struct.A* bitcast (%struct.A* ()* @f4 to %struct.A* (i8*)*)(i8* nest bitcast (%struct.A* ()* @f4 to i8*)) + __builtin_call_with_static_chain(f4(), f4); +} diff --git a/test/CodeGenCXX/catch-undef-behavior.cpp b/test/CodeGenCXX/catch-undef-behavior.cpp index 333855d0ba61..4120d0fead4d 100644 --- a/test/CodeGenCXX/catch-undef-behavior.cpp +++ b/test/CodeGenCXX/catch-undef-behavior.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -std=c++11 -fsanitize=signed-integer-overflow,integer-divide-by-zero,float-divide-by-zero,shift,unreachable,return,vla-bound,alignment,null,vptr,object-size,float-cast-overflow,bool,enum,array-bounds,function -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -// RUN: %clang_cc1 -std=c++11 -fsanitize=vptr,address -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-ASAN -// RUN: %clang_cc1 -std=c++11 -fsanitize=vptr -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=DOWNCAST-NULL +// RUN: %clang_cc1 -std=c++11 -fsanitize=signed-integer-overflow,integer-divide-by-zero,float-divide-by-zero,shift,unreachable,return,vla-bound,alignment,null,vptr,object-size,float-cast-overflow,bool,enum,array-bounds,function -fsanitize-recover=signed-integer-overflow,integer-divide-by-zero,float-divide-by-zero,shift,vla-bound,alignment,null,vptr,object-size,float-cast-overflow,bool,enum,array-bounds,function -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -fsanitize=vptr,address -fsanitize-recover=vptr,address -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK-ASAN +// RUN: %clang_cc1 -std=c++11 -fsanitize=vptr -fsanitize-recover=vptr -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=DOWNCAST-NULL struct S { double d; @@ -221,11 +221,14 @@ void bad_downcast_pointer(S *p) { void bad_downcast_reference(S &p) { // CHECK: %[[E1:.*]] = icmp ne {{.*}}, null // CHECK-NOT: br i1 + // CHECK: %[[SIZE:.*]] = call i64 @llvm.objectsize.i64.p0i8( // CHECK: %[[E2:.*]] = icmp uge i64 %[[SIZE]], 24 - // CHECK: %[[E12:.*]] = and i1 %[[E1]], %[[E2]] + // CHECK: %[[MISALIGN:.*]] = and i64 %{{.*}}, 7 // CHECK: %[[E3:.*]] = icmp eq i64 %[[MISALIGN]], 0 + + // CHECK: %[[E12:.*]] = and i1 %[[E1]], %[[E2]] // CHECK: %[[E123:.*]] = and i1 %[[E12]], %[[E3]] // CHECK: br i1 %[[E123]], @@ -382,11 +385,11 @@ void downcast_reference(B &b) { // CHECK-NEXT: [[MASKED:%[0-9]*]] = and i64 [[C_INT]], 15 // CHECK-NEXT: [[TEST:%[0-9]*]] = icmp eq i64 [[MASKED]], 0 // AND the alignment test with the objectsize test. - // CHECK-NEXT: [[AND:%[0-9]*]] = and i1 {{.*}}, [[TEST]] + // CHECK: [[AND:%[0-9]*]] = and i1 {{.*}}, [[TEST]] // CHECK-NEXT: br i1 [[AND]] } -// CHECK-LABEL: @_Z22indirect_function_callPFviE({{.*}} prefix <{ i32, i8* }> <{ i32 1413876459, i8* bitcast ({ i8*, i8* }* @_ZTIFvPFviEE to i8*) }> +// CHECK-LABEL: @_Z22indirect_function_callPFviE({{.*}} prologue <{ i32, i8* }> <{ i32 1413876459, i8* bitcast ({ i8*, i8* }* @_ZTIFvPFviEE to i8*) }> void indirect_function_call(void (*p)(int)) { // CHECK: [[PTR:%[0-9]*]] = bitcast void (i32)* {{.*}} to <{ i32, i8* }>* @@ -404,6 +407,40 @@ void indirect_function_call(void (*p)(int)) { p(42); } +namespace UpcastPointerTest { +struct S {}; +struct T : S { double d; }; +struct V : virtual S {}; + +// CHECK-LABEL: upcast_pointer +S* upcast_pointer(T* t) { + // Check for null pointer + // CHECK: %[[NONNULL:.*]] = icmp ne {{.*}}, null + // CHECK: br i1 %[[NONNULL]] + + // Check alignment + // CHECK: %[[MISALIGN:.*]] = and i64 %{{.*}}, 7 + // CHECK: icmp eq i64 %[[MISALIGN]], 0 + + // CHECK: call void @__ubsan_handle_type_mismatch + return t; +} + +V getV(); + +// CHECK-LABEL: upcast_to_vbase +void upcast_to_vbase() { + // No need to check for null here, as we have a temporary here. + + // CHECK-NOT: br i1 + + // CHECK: call i64 @llvm.objectsize + // CHECK: call void @__ubsan_handle_type_mismatch + // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss + const S& s = getV(); +} +} + namespace CopyValueRepresentation { // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S3aSERKS0_ // CHECK-NOT: call {{.*}} @__ubsan_handle_load_invalid_value diff --git a/test/CodeGenCXX/class-layout.cpp b/test/CodeGenCXX/class-layout.cpp index d7d84a86abad..610dbc5feaaf 100644 --- a/test/CodeGenCXX/class-layout.cpp +++ b/test/CodeGenCXX/class-layout.cpp @@ -14,7 +14,7 @@ namespace Test2 { namespace Test3 { // C should have a vtable pointer. - // CHECK: %"struct.Test3::A" = type { i32 (...)**, i32 } + // CHECK: %"struct.Test3::A" = type <{ i32 (...)**, i32, [4 x i8] }> struct A { virtual void f(); int a; } *a; } diff --git a/test/CodeGenCXX/compound-literals.cpp b/test/CodeGenCXX/compound-literals.cpp index f1d88027c4fa..e7710939bd2d 100644 --- a/test/CodeGenCXX/compound-literals.cpp +++ b/test/CodeGenCXX/compound-literals.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s struct X { X(); @@ -42,3 +42,16 @@ struct Z { int i[3]; }; int *p = (Z){ {1, 2, 3} }.i; // CHECK: define {{.*}}__cxx_global_var_init() // CHECK: store i32* getelementptr inbounds (%struct.Z* @.compoundliteral, i32 0, i32 0, i32 0), i32** @p + + +int *PR21912_1 = (int []){}; +// CHECK-LABEL: define {{.*}}__cxx_global_var_init1() +// CHECK: store i32* getelementptr inbounds ([0 x i32]* @.compoundliteral2, i32 0, i32 0), i32** @PR21912_1 + +union PR21912Ty { + long long l; + double d; +}; +union PR21912Ty *PR21912_2 = (union PR21912Ty[]){{.d = 2.0}, {.l = 3}}; +// CHECK-LABEL: define {{.*}}__cxx_global_var_init3() +// CHECK: store %union.PR21912Ty* getelementptr inbounds ([2 x %union.PR21912Ty]* bitcast (<{ { double }, %union.PR21912Ty }>* @.compoundliteral4 to [2 x %union.PR21912Ty]*), i32 0, i32 0), %union.PR21912Ty** @PR21912_2 diff --git a/test/CodeGenCXX/constructor-destructor-return-this.cpp b/test/CodeGenCXX/constructor-destructor-return-this.cpp index ce6ddd29f644..dcd20fe87d6f 100644 --- a/test/CodeGenCXX/constructor-destructor-return-this.cpp +++ b/test/CodeGenCXX/constructor-destructor-return-this.cpp @@ -10,7 +10,7 @@ class A { public: A(); - ~A(); + virtual ~A(); private: int x_; @@ -19,7 +19,7 @@ private: class B : public A { public: B(int *i); - ~B(); + virtual ~B(); private: int *i_; @@ -44,7 +44,7 @@ B::~B() { } // CHECKIOS5-LABEL: define %class.B* @_ZN1BD1Ev(%class.B* %this) // CHECKMS-LABEL: define x86_thiscallcc %class.B* @"\01??0B@@QAE@PAH@Z"(%class.B* returned %this, i32* %i) -// CHECKMS-LABEL: define x86_thiscallcc void @"\01??1B@@QAE@XZ"(%class.B* %this) +// CHECKMS-LABEL: define x86_thiscallcc void @"\01??1B@@UAE@XZ"(%class.B* %this) class C : public A, public B { public: @@ -61,19 +61,25 @@ C::~C() { } // CHECKGEN-LABEL: define void @_ZN1CC1EPiPc(%class.C* %this, i32* %i, i8* %c) // CHECKGEN-LABEL: define void @_ZN1CD2Ev(%class.C* %this) // CHECKGEN-LABEL: define void @_ZN1CD1Ev(%class.C* %this) +// CHECKGEN-LABEL: define void @_ZThn8_N1CD1Ev(%class.C* %this) // CHECKGEN-LABEL: define void @_ZN1CD0Ev(%class.C* %this) +// CHECKGEN-LABEL: define void @_ZThn8_N1CD0Ev(%class.C* %this) // CHECKARM-LABEL: define %class.C* @_ZN1CC2EPiPc(%class.C* returned %this, i32* %i, i8* %c) // CHECKARM-LABEL: define %class.C* @_ZN1CC1EPiPc(%class.C* returned %this, i32* %i, i8* %c) // CHECKARM-LABEL: define %class.C* @_ZN1CD2Ev(%class.C* returned %this) // CHECKARM-LABEL: define %class.C* @_ZN1CD1Ev(%class.C* returned %this) +// CHECKARM-LABEL: define %class.C* @_ZThn8_N1CD1Ev(%class.C* %this) // CHECKARM-LABEL: define void @_ZN1CD0Ev(%class.C* %this) +// CHECKARM-LABEL: define void @_ZThn8_N1CD0Ev(%class.C* %this) // CHECKIOS5-LABEL: define %class.C* @_ZN1CC2EPiPc(%class.C* %this, i32* %i, i8* %c) // CHECKIOS5-LABEL: define %class.C* @_ZN1CC1EPiPc(%class.C* %this, i32* %i, i8* %c) // CHECKIOS5-LABEL: define %class.C* @_ZN1CD2Ev(%class.C* %this) // CHECKIOS5-LABEL: define %class.C* @_ZN1CD1Ev(%class.C* %this) +// CHECKIOS5-LABEL: define %class.C* @_ZThn8_N1CD1Ev(%class.C* %this) // CHECKIOS5-LABEL: define void @_ZN1CD0Ev(%class.C* %this) +// CHECKIOS5-LABEL: define void @_ZThn8_N1CD0Ev(%class.C* %this) // CHECKMS-LABEL: define x86_thiscallcc %class.C* @"\01??0C@@QAE@PAHPAD@Z"(%class.C* returned %this, i32* %i, i8* %c) // CHECKMS-LABEL: define x86_thiscallcc void @"\01??1C@@UAE@XZ"(%class.C* %this) @@ -103,7 +109,7 @@ D::~D() { } // CHECKIOS5-LABEL: define %class.D* @_ZN1DD1Ev(%class.D* %this) // CHECKMS-LABEL: define x86_thiscallcc %class.D* @"\01??0D@@QAE@XZ"(%class.D* returned %this, i32 %is_most_derived) -// CHECKMS-LABEL: define x86_thiscallcc void @"\01??1D@@QAE@XZ"(%class.D* %this) +// CHECKMS-LABEL: define x86_thiscallcc void @"\01??1D@@UAE@XZ"(%class.D*) class E { public: diff --git a/test/CodeGenCXX/constructor-init.cpp b/test/CodeGenCXX/constructor-init.cpp index a8f483e53ab5..9d029a3696b2 100644 --- a/test/CodeGenCXX/constructor-init.cpp +++ b/test/CodeGenCXX/constructor-init.cpp @@ -94,23 +94,23 @@ namespace InitVTable { }; // CHECK-LABEL: define void @_ZN10InitVTable1BC2Ev(%"struct.InitVTable::B"* %this) unnamed_addr - // CHECK: [[T0:%.*]] = bitcast [[B:%.*]]* [[THIS:%.*]] to i8*** - // CHECK-NEXT: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2), i8*** [[T0]] + // CHECK: [[T0:%.*]] = bitcast [[B:%.*]]* [[THIS:%.*]] to i32 (...)*** + // CHECK-NEXT: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2) to i32 (...)**), i32 (...)*** [[T0]] // CHECK: [[VTBL:%.*]] = load i32 ([[B]]*)*** {{%.*}} // CHECK-NEXT: [[FNP:%.*]] = getelementptr inbounds i32 ([[B]]*)** [[VTBL]], i64 0 // CHECK-NEXT: [[FN:%.*]] = load i32 ([[B]]*)** [[FNP]] // CHECK-NEXT: [[ARG:%.*]] = call i32 [[FN]]([[B]]* [[THIS]]) // CHECK-NEXT: call void @_ZN10InitVTable1AC2Ei({{.*}}* {{%.*}}, i32 [[ARG]]) - // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* [[THIS]] to i8*** - // CHECK-NEXT: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2), i8*** [[T0]] + // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* [[THIS]] to i32 (...)*** + // CHECK-NEXT: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2) to i32 (...)**), i32 (...)*** [[T0]] // CHECK-NEXT: ret void B::B() : A(foo()) {} // CHECK-LABEL: define void @_ZN10InitVTable1BC2Ei(%"struct.InitVTable::B"* %this, i32 %x) unnamed_addr // CHECK: [[ARG:%.*]] = add nsw i32 {{%.*}}, 5 // CHECK-NEXT: call void @_ZN10InitVTable1AC2Ei({{.*}}* {{%.*}}, i32 [[ARG]]) - // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* {{%.*}} to i8*** - // CHECK-NEXT: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2), i8*** [[T0]] + // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* {{%.*}} to i32 (...)*** + // CHECK-NEXT: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN10InitVTable1BE, i64 0, i64 2) to i32 (...)**), i32 (...)*** [[T0]] // CHECK-NEXT: ret void B::B(int x) : A(x + 5) {} } diff --git a/test/CodeGenCXX/copy-constructor-synthesis-2.cpp b/test/CodeGenCXX/copy-constructor-synthesis-2.cpp index 4bb0fee25e51..8fdc4dff7feb 100644 --- a/test/CodeGenCXX/copy-constructor-synthesis-2.cpp +++ b/test/CodeGenCXX/copy-constructor-synthesis-2.cpp @@ -4,4 +4,4 @@ struct A { virtual void a(); }; A x(A& y) { return y; } // CHECK: define linkonce_odr {{.*}} @_ZN1AC1ERKS_(%struct.A* {{.*}}%this, %struct.A* dereferenceable({{[0-9]+}})) unnamed_addr -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) to i32 (...)**) diff --git a/test/CodeGenCXX/copy-constructor-synthesis.cpp b/test/CodeGenCXX/copy-constructor-synthesis.cpp index 47f8e131d62e..abbb7d05351e 100644 --- a/test/CodeGenCXX/copy-constructor-synthesis.cpp +++ b/test/CodeGenCXX/copy-constructor-synthesis.cpp @@ -148,8 +148,8 @@ void f(B b1) { // CHECK-LABEL: define linkonce_odr void @_ZN12rdar138169401AC2ERKS0_( // CHECK: [[THIS:%.*]] = load [[A]]** -// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[THIS]] to i8*** -// CHECK-NEXT: store i8** getelementptr inbounds ([4 x i8*]* @_ZTVN12rdar138169401AE, i64 0, i64 2), i8*** [[T0]] +// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[THIS]] to i32 (...)*** +// CHECK-NEXT: store i32 (...)** bitcast (i8** getelementptr inbounds ([4 x i8*]* @_ZTVN12rdar138169401AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** [[T0]] // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[A]]* [[THIS]], i32 0, i32 1 // CHECK-NEXT: [[OTHER:%.*]] = load [[A]]** // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[A]]* [[OTHER]], i32 0, i32 1 diff --git a/test/CodeGenCXX/coverage.cpp b/test/CodeGenCXX/coverage.cpp index 88f74098efa8..3931b0c6ffb3 100644 --- a/test/CodeGenCXX/coverage.cpp +++ b/test/CodeGenCXX/coverage.cpp @@ -3,5 +3,5 @@ extern "C" void test_name1() {} void test_name2() {} -// CHECK: metadata !"test_name1", metadata !"test_name1", metadata !"",{{.*}}DW_TAG_subprogram -// CHECK: metadata !"test_name2", metadata !"test_name2", metadata !"_Z10test_name2v",{{.*}}DW_TAG_subprogram +// CHECK: !"0x2e\00test_name1\00test_name1\00\00{{[^,]+}}", {{.*}} DW_TAG_subprogram +// CHECK: !"0x2e\00test_name2\00test_name2\00_Z10test_name2v\00{{[^,]+}}", {{.*}} DW_TAG_subprogram diff --git a/test/CodeGenCXX/crash.cpp b/test/CodeGenCXX/crash.cpp index 073542dd15b0..e1577a3abe37 100644 --- a/test/CodeGenCXX/crash.cpp +++ b/test/CodeGenCXX/crash.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 %s -std=c++11 -emit-llvm-only +// RUN: %clang_cc1 -emit-obj -o %t -gline-tables-only -std=c++11 %s // CHECK that we don't crash. // PR11676's example is ill-formed: @@ -33,3 +34,13 @@ template <class ELFT> void finalizeDefaultAtomValues() { void f() { finalizeDefaultAtomValues<int>(); } } + +namespace PR22096 { +template <class> struct c { + c(); + template <class U> __attribute__((__always_inline__)) c(c<U>) {} +}; +struct { + c<double> v = c<int>(); +} o; +} diff --git a/test/CodeGenCXX/ctor-dtor-alias.cpp b/test/CodeGenCXX/ctor-dtor-alias.cpp index d869a2bfd5d9..bd60cb88bb25 100644 --- a/test/CodeGenCXX/ctor-dtor-alias.cpp +++ b/test/CodeGenCXX/ctor-dtor-alias.cpp @@ -1,20 +1,33 @@ -// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-optzns | FileCheck %s // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s -// RUN: %clang_cc1 -triple x86_64--netbsd -emit-llvm \ -// RUN: -mconstructor-aliases -O2 %s -o - | FileCheck --check-prefix=CHECK-RAUW %s +// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-optzns > %t +// RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s + +// RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-optzns | FileCheck --check-prefix=COFF %s namespace test1 { -// test that we don't produce an alias when the destructor is weak_odr. The -// reason to avoid it that another TU might have no explicit template -// instantiation definition or declaration, causing it to to output only -// one of the destructors as linkonce_odr, producing a different comdat. +// Test that we produce the apropriate comdats when creating aliases to +// weak_odr constructors and destructors. -// CHECK-DAG: define weak_odr void @_ZN5test16foobarIvEC2Ev -// CHECK-DAG: define weak_odr void @_ZN5test16foobarIvEC1Ev +// CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev +// CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev +// CHECK1: define weak_odr void @_ZN5test16foobarIvEC2Ev({{.*}} comdat($_ZN5test16foobarIvEC5Ev) +// CHECK1: define weak_odr void @_ZN5test16foobarIvED2Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev) +// CHECK1: define weak_odr void @_ZN5test16foobarIvED0Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev) +// CHECK1-NOT: comdat -template <typename T> struct foobar { +// COFF doesn't support comdats with arbitrary names (C5/D5). +// COFF-NOT: comdat + +template <typename T> +struct foobar { foobar() {} + virtual ~foobar() {} }; template struct foobar<void>; @@ -24,8 +37,9 @@ namespace test2 { // test that when the destrucor is linkonce_odr we just replace every use of // C1 with C2. -// CHECK-DAG: define linkonce_odr void @_ZN5test26foobarIvEC2Ev( -// CHECK-DAG: call void @_ZN5test26foobarIvEC2Ev +// CHECK1: define internal void @__cxx_global_var_init() +// CHECK1: call void @_ZN5test26foobarIvEC2Ev +// CHECK1: define linkonce_odr void @_ZN5test26foobarIvEC2Ev( void g(); template <typename T> struct foobar { foobar() { g(); } @@ -37,8 +51,9 @@ namespace test3 { // test that instead of an internal alias we just use the other destructor // directly. -// CHECK-DAG: define internal void @_ZN5test312_GLOBAL__N_11AD2Ev( -// CHECK-DAG: call i32 @__cxa_atexit{{.*}}_ZN5test312_GLOBAL__N_11AD2Ev +// CHECK1: define internal void @__cxx_global_var_init1() +// CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test312_GLOBAL__N_11AD2Ev +// CHECK1: define internal void @_ZN5test312_GLOBAL__N_11AD2Ev( namespace { struct A { ~A() {} @@ -55,13 +70,15 @@ namespace test4 { // guarantee that they will be present in every TU. Instead, we just call // A's destructor directly. - // CHECK-DAG: define linkonce_odr void @_ZN5test41AD2Ev( - // CHECK-DAG: call i32 @__cxa_atexit{{.*}}_ZN5test41AD2Ev + // CHECK1: define internal void @__cxx_global_var_init2() + // CHECK1: call i32 @__cxa_atexit{{.*}}_ZN5test41AD2Ev + // CHECK1: define linkonce_odr void @_ZN5test41AD2Ev( // test that we don't do this optimization at -O0 so that the debugger can // see both destructors. - // NOOPT-DAG: call i32 @__cxa_atexit{{.*}}@_ZN5test41BD2Ev - // NOOPT-DAG: define linkonce_odr void @_ZN5test41BD2Ev + // NOOPT: define internal void @__cxx_global_var_init2() + // NOOPT: call i32 @__cxa_atexit{{.*}}@_ZN5test41BD2Ev + // NOOPT: define linkonce_odr void @_ZN5test41BD2Ev struct A { virtual ~A() {} }; @@ -74,8 +91,9 @@ namespace test4 { namespace test5 { // similar to test4, but with an internal B. - // CHECK-DAG: define linkonce_odr void @_ZN5test51AD2Ev( - // CHECK-DAG: call i32 @__cxa_atexit{{.*}}_ZN5test51AD2Ev + // CHECK2: define internal void @__cxx_global_var_init3() + // CHECK2: call i32 @__cxa_atexit{{.*}}_ZN5test51AD2Ev + // CHECK2: define linkonce_odr void @_ZN5test51AD2Ev( struct A { virtual ~A() {} }; @@ -99,14 +117,15 @@ namespace test6 { }; } B X; - // CHECK-DAG: call i32 @__cxa_atexit({{.*}}@_ZN5test61AD2Ev + // CHECK3: define internal void @__cxx_global_var_init4() + // CHECK3: call i32 @__cxa_atexit({{.*}}@_ZN5test61AD2Ev } namespace test7 { // Test that we don't produce an alias from ~B to ~A<int> (or crash figuring // out if we should). // pr17875. - // CHECK-DAG: define void @_ZN5test71BD2Ev + // CHECK3: define void @_ZN5test71BD2Ev template <typename> struct A { ~A() {} }; @@ -119,8 +138,9 @@ namespace test7 { namespace test8 { // Test that we replace ~zed with ~bar which is an alias to ~foo. - // CHECK-DAG: call i32 @__cxa_atexit({{.*}}@_ZN5test83barD2Ev - // CHECK-DAG: @_ZN5test83barD2Ev = alias {{.*}} @_ZN5test83fooD2Ev + // CHECK4: @_ZN5test83barD2Ev = alias {{.*}} @_ZN5test83fooD2Ev + // CHECK4: define internal void @__cxx_global_var_init5() + // CHECK4: call i32 @__cxa_atexit({{.*}}@_ZN5test83barD2Ev struct foo { ~foo(); }; @@ -144,12 +164,12 @@ struct bar : public foo {}; void zed() { // Test that we produce a call to bar's destructor. We used to call foo's, but // it has a different calling conversion. - // CHECK-DAG: call void @_ZN5test93barD2Ev + // CHECK4: call void @_ZN5test93barD2Ev bar ptr; } } -// CHECK-RAUW: @_ZTV1C = linkonce_odr unnamed_addr constant [4 x i8*] [{{[^@]*}}@_ZTI1C {{[^@]*}}@_ZN1CD2Ev {{[^@]*}}@_ZN1CD0Ev {{[^@]*}}] +// CHECK5: @_ZTV1C = linkonce_odr unnamed_addr constant [4 x i8*] [{{[^@]*}}@_ZTI1C {{[^@]*}}@_ZN1CD2Ev {{[^@]*}}@_ZN1CD0Ev {{[^@]*}}] // r194296 replaced C::~C with B::~B without emitting the later. class A { @@ -177,3 +197,38 @@ void fn1() { new C; } + +namespace test10 { +// Test that if a destructor is in a comdat, we don't try to emit is as an +// alias to a base class destructor. +struct bar { + ~bar(); +}; +bar::~bar() { +} +} // closing the namespace causes ~bar to be sent to CodeGen +namespace test10 { +template <typename T> +struct foo : public bar { + ~foo(); +}; +template <typename T> +foo<T>::~foo() {} +template class foo<int>; +// CHECK5: define weak_odr void @_ZN6test103fooIiED2Ev({{.*}} comdat($_ZN6test103fooIiED5Ev) +} + +namespace test11 { +// Test that when we don't have to worry about COMDATs we produce an alias +// from complate to base and from base to base class base. +struct bar { + ~bar(); +}; +bar::~bar() {} +struct foo : public bar { + ~foo(); +}; +foo::~foo() {} +// CHECK6: @_ZN6test113fooD2Ev = alias {{.*}} @_ZN6test113barD2Ev +// CHECK6: @_ZN6test113fooD1Ev = alias {{.*}} @_ZN6test113fooD2Ev +} diff --git a/test/CodeGenCXX/ctor-globalopt.cpp b/test/CodeGenCXX/ctor-globalopt.cpp new file mode 100644 index 000000000000..672fc9067527 --- /dev/null +++ b/test/CodeGenCXX/ctor-globalopt.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -o - %s -O1 | FileCheck %s --check-prefix=O1 +// RUN: %clang_cc1 -triple %ms_abi_triple -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple %ms_abi_triple -emit-llvm -o - %s -O1 | FileCheck %s --check-prefix=O1 + +// Check that GlobalOpt can eliminate static constructors for simple implicit +// constructors. This is a targetted integration test to make sure that LLVM's +// optimizers are able to process Clang's IR. GlobalOpt in particular is +// sensitive to the casts we emit. + +// CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] +// CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_ctor_globalopt.cpp, i8* null }] + +// CHECK-LABEL: define internal void @_GLOBAL__sub_I_ctor_globalopt.cpp() +// CHECK: call void @ +// CHECK-NOT: call + +// O1: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer + +struct A { + virtual void f(); + int a; +}; +struct B : virtual A { + virtual void g(); + int b; +}; +B b; diff --git a/test/CodeGenCXX/cxx11-exception-spec.cpp b/test/CodeGenCXX/cxx11-exception-spec.cpp index 3b1516b92536..3fb5c15c2ab5 100644 --- a/test/CodeGenCXX/cxx11-exception-spec.cpp +++ b/test/CodeGenCXX/cxx11-exception-spec.cpp @@ -22,9 +22,9 @@ template<> void S<short>::f() { h(); } // CHECK: define {{.*}} @_ZN1SIA2_sE1fEv() [[NUW]] template<> void S<short[2]>::f() noexcept { h(); } -// CHECK: define {{.*}} @_Z1fIDsEvv() [[NONE]] { +// CHECK: define {{.*}} @_Z1fIDsEvv() [[NONE]] comdat { template void f<char16_t>(); -// CHECK: define {{.*}} @_Z1fIA2_DsEvv() [[NUW]] { +// CHECK: define {{.*}} @_Z1fIA2_DsEvv() [[NUW]] comdat { template void f<char16_t[2]>(); // CHECK: define {{.*}} @_ZN1SIDsE1fEv() @@ -34,9 +34,9 @@ template void S<char16_t>::f(); template void S<char16_t[2]>::f(); void h() { - // CHECK: define {{.*}} @_Z1fIiEvv() [[NUW]] { + // CHECK: define {{.*}} @_Z1fIiEvv() [[NUW]] comdat { f<int>(); - // CHECK: define {{.*}} @_Z1fIA2_iEvv() [[NONE]] { + // CHECK: define {{.*}} @_Z1fIA2_iEvv() [[NONE]] comdat { f<int[2]>(); // CHECK: define {{.*}} @_ZN1SIiE1fEv() [[NUW]] @@ -45,9 +45,9 @@ void h() { // CHECK-NOT: [[NUW]] S<int[2]>::f(); - // CHECK: define {{.*}} @_Z1fIfEvv() [[NUW]] { + // CHECK: define {{.*}} @_Z1fIfEvv() [[NUW]] comdat { void (*f1)() = &f<float>; - // CHECK: define {{.*}} @_Z1fIdEvv() [[NONE]] { + // CHECK: define {{.*}} @_Z1fIdEvv() [[NONE]] comdat { void (*f2)() = &f<double>; // CHECK: define {{.*}} @_ZN1SIfE1fEv() [[NUW]] @@ -56,9 +56,9 @@ void h() { // CHECK-NOT: [[NUW]] void (*f4)() = &S<double>::f; - // CHECK: define {{.*}} @_Z1fIA4_cEvv() [[NUW]] { + // CHECK: define {{.*}} @_Z1fIA4_cEvv() [[NUW]] comdat { (void)&f<char[4]>; - // CHECK: define {{.*}} @_Z1fIcEvv() [[NONE]] { + // CHECK: define {{.*}} @_Z1fIcEvv() [[NONE]] comdat { (void)&f<char>; // CHECK: define {{.*}} @_ZN1SIA4_cE1fEv() [[NUW]] @@ -122,3 +122,8 @@ void j() { // CHECK: attributes [[NONE]] = { {{.*}} } // CHECK: attributes [[NUW]] = { nounwind{{.*}} } + +namespace PR19190 { +template <class T> struct DWFIterator { virtual void get() throw(int) = 0; }; +void foo(DWFIterator<int> *foo) { foo->get(); } +} diff --git a/test/CodeGenCXX/cxx11-special-members.cpp b/test/CodeGenCXX/cxx11-special-members.cpp index 59461f9e2f4b..037e59a6408f 100644 --- a/test/CodeGenCXX/cxx11-special-members.cpp +++ b/test/CodeGenCXX/cxx11-special-members.cpp @@ -28,5 +28,19 @@ void f2(B &x, B &y) { // CHECK: define {{.*}} @_ZN1BaSEOS_( // CHECK: call {{.*}} @_ZN1AaSERKS_( +// rdar://18309639 { +template<int> struct C { C() = default; }; +struct D { + C<0> c; + D() { } +}; +template struct C<0>; // was asserting +void f3() { + C<0> a; + D b; +} +// CHECK: define {{.*}} @_ZN1CILi0EEC1Ev +// CHECK: define {{.*}} @_ZN1DC1Ev + // CHECK: define {{.*}} @_ZN1BC2EOS_( // CHECK: call {{.*}} @_ZN1AC1ERKS_( diff --git a/test/CodeGenCXX/cxx11-thread-local.cpp b/test/CodeGenCXX/cxx11-thread-local.cpp index a3690b352989..a6f010626cad 100644 --- a/test/CodeGenCXX/cxx11-thread-local.cpp +++ b/test/CodeGenCXX/cxx11-thread-local.cpp @@ -44,9 +44,9 @@ int e = V<int>::m; // CHECK: @llvm.global_ctors = appending global {{.*}} @[[GLOBAL_INIT:[^ ]*]] // CHECK: @_ZTH1a = alias void ()* @__tls_init -// CHECK: @_ZTHL1d = alias internal void ()* @__tls_init +// CHECK: @_ZTHL1d = internal alias void ()* @__tls_init // CHECK: @_ZTHN1U1mE = alias void ()* @__tls_init -// CHECK: @_ZTHN1VIiE1mE = alias linkonce_odr void ()* @__tls_init +// CHECK: @_ZTHN1VIiE1mE = linkonce_odr alias void ()* @__tls_init // Individual variable initialization functions: diff --git a/test/CodeGenCXX/cxx1y-initializer-aggregate.cpp b/test/CodeGenCXX/cxx1y-initializer-aggregate.cpp index 8bdf8633d61e..098a4b945e04 100644 --- a/test/CodeGenCXX/cxx1y-initializer-aggregate.cpp +++ b/test/CodeGenCXX/cxx1y-initializer-aggregate.cpp @@ -36,6 +36,17 @@ B y {}; B z { 1 }; // CHECK: @z = global {{.*}} { i32 1 } +// Brace initialization should initialize the first field even though it is +// unnamed. +union C { + struct { + int C::*memptr; + }; +}; + +C n{}; +// CHECK: @n = global %union.C { %struct.anon { i64 -1 } }, align 8 + // Initialization of 'a': // CHECK: store i32 0, i32* getelementptr inbounds ({{.*}} @a, i32 0, i32 0) diff --git a/test/CodeGenCXX/cxx1y-variable-template-linkage.cpp b/test/CodeGenCXX/cxx1y-variable-template-linkage.cpp new file mode 100644 index 000000000000..8c0b8c22096d --- /dev/null +++ b/test/CodeGenCXX/cxx1y-variable-template-linkage.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++1y -O1 -disable-llvm-optzns %s -o - | FileCheck %s -check-prefix=CHECKA -check-prefix=CHECK +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++1y -O1 -disable-llvm-optzns -fcxx-exceptions %s -o - | FileCheck %s -check-prefix=CHECKB -check-prefix=CHECK +// expected-no-diagnostics + +// The variable template specialization x<Foo> generated in each file +// should be 'internal global' and not 'linkonce_odr global'. + +template <typename T> int x = 42; + +// CHECK-DAG: @_Z1xIZL3foovE3FooE = internal global + +// CHECK-DAG: define internal dereferenceable(4) i32* @_ZL3foov( +static int &foo() { + struct Foo { }; + + // CHECK-DAG: ret i32* @_Z1xIZL3foovE3FooE + return x<Foo>; +} + + +#if !__has_feature(cxx_exceptions) // File A +// CHECKA-DAG: define dereferenceable(4) i32* @_Z3barv( +int &bar() { + // CHECKA-DAG: call dereferenceable(4) i32* @_ZL3foov() + return foo(); +} + +#else // File B + +// CHECKB-DAG: declare dereferenceable(4) i32* @_Z3barv( +int &bar(); + +int main() { + // CHECKB-DAG: call dereferenceable(4) i32* @_Z3barv() + // CHECKB-DAG: call dereferenceable(4) i32* @_ZL3foov() + &bar() == &foo() ? throw 0 : (void)0; // Should not throw exception at runtime. +} + +#endif // end of Files A and B + diff --git a/test/CodeGenCXX/cxx1z-fold-expression.cpp b/test/CodeGenCXX/cxx1z-fold-expression.cpp new file mode 100644 index 000000000000..5dac66b497db --- /dev/null +++ b/test/CodeGenCXX/cxx1z-fold-expression.cpp @@ -0,0 +1,45 @@ +// RUN: %clang_cc1 -std=c++1z -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s + +template<int> struct A {}; +template<int ...N> void foldr(A<(N + ...)>); +template<int ...N> void foldl(A<(... + N)>); +template<int ...N> void foldr1(A<(N + ... + 1)>); +template<int ...N> void foldl1(A<(1 + ... + N)>); +void use() { + foldr<1, 2, 3>({}); + foldl<1, 2, 3>({}); + foldr1<1, 2, 3>({}); + foldl1<1, 2, 3>({}); + // CHECK-DAG: @_Z5foldrIJLi1ELi2ELi3EEEv1AIXfrplT_EE( + // CHECK-DAG: @_Z5foldlIJLi1ELi2ELi3EEEv1AIXflplT_EE( + // CHECK-DAG: @_Z6foldr1IJLi1ELi2ELi3EEEv1AIXfRplT_Li1EEE( + // CHECK-DAG: @_Z6foldl1IJLi1ELi2ELi3EEEv1AIXfLplLi1ET_EE( +} + +template<int ...N> using Foldr = A<(N + ...)>; +template<int ...N> using Foldl = A<(... + N)>; +template<int ...N> using Foldr1 = A<(N + ... + 1)>; +template<int ...N> using Foldl1 = A<(1 + ... + N)>; + +template<int ...A> struct Partial { + template<int ...B> void foldr(Foldr<A..., B..., A..., B...>); + template<int ...B> void foldl(Foldl<A..., B..., A..., B...>); + template<int ...B> void foldr1(Foldr1<A..., B..., A..., B...>); + template<int ...B> void foldl1(Foldl1<A..., B..., A..., B...>); +}; +void use(Partial<1, 2> p) { + p.foldr<3, 4>({}); + p.foldl<3, 4>({}); + p.foldr1<3, 4>({}); + p.foldl1<3, 4>({}); + // CHECK-DAG: @_ZN7PartialIJLi1ELi2EEE5foldrIJLi3ELi4EEEEv1AIXplLi1EplLi2EfRplT_plLi1EplLi2EfrplT_EE( + // CHECK-DAG: @_ZN7PartialIJLi1ELi2EEE5foldlIJLi3ELi4EEEEv1AIXfLplplplfLplplLi1ELi2ET_Li1ELi2ET_EE + // CHECK-DAG: @_ZN7PartialIJLi1ELi2EEE6foldr1IJLi3ELi4EEEEv1AIXplLi1EplLi2EfRplT_plLi1EplLi2EfRplT_Li1EEE( + // CHECK-DAG: @_ZN7PartialIJLi1ELi2EEE6foldl1IJLi3ELi4EEEEv1AIXfLplplplfLplplplLi1ELi1ELi2ET_Li1ELi2ET_EE( +} + +extern int n; +template<int ...N> void f() { + (n = ... = N); +} +template void f<>(); diff --git a/test/CodeGenCXX/debug-info-access.cpp b/test/CodeGenCXX/debug-info-access.cpp new file mode 100644 index 000000000000..d6dfd87013dd --- /dev/null +++ b/test/CodeGenCXX/debug-info-access.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple %itanium_abi_triple %s -o - | FileCheck %s +// Test the various accessibility flags in the debug info. +struct A { + // CHECK-DAG: [ DW_TAG_subprogram ] [line [[@LINE+1]]] [pub_default] + void pub_default(); + // CHECK-DAG: [ DW_TAG_member ] [pub_default_static] [line [[@LINE+1]]{{.*}}offset 0] [static] + static int pub_default_static; +}; + +// CHECK: [ DW_TAG_inheritance ] {{.*}} [public] [from {{.*}}A] +class B : public A { +public: + // CHECK-DAG: [ DW_TAG_subprogram ] [line [[@LINE+1]]] [public] [pub] + void pub(); + // CHECK-DAG: [ DW_TAG_member ] [public_static] [line [[@LINE+1]]{{.*}} [public] [static] + static int public_static; +protected: + // CHECK: [ DW_TAG_subprogram ] [line [[@LINE+1]]] [protected] [prot] + void prot(); +private: + // CHECK: [ DW_TAG_subprogram ] [line [[@LINE+1]]] [priv_default] + void priv_default(); +}; + +union U { + // CHECK-DAG: [ DW_TAG_subprogram ] [line [[@LINE+1]]] [union_pub_default] + void union_pub_default(); +private: + // CHECK-DAG: [ DW_TAG_member ] [union_priv] [line [[@LINE+1]]{{.*}} [private] + int union_priv; +}; + + +// CHECK: {{.*}}\00256\00{{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [def] [free] +void free() {} + +A a; +B b; +U u; diff --git a/test/CodeGenCXX/debug-info-alias.cpp b/test/CodeGenCXX/debug-info-alias.cpp index fb18ac5da006..dd4b00b7de62 100644 --- a/test/CodeGenCXX/debug-info-alias.cpp +++ b/test/CodeGenCXX/debug-info-alias.cpp @@ -13,15 +13,15 @@ bar = foo<T*>; } -// CHECK: metadata [[BINT:![0-9]*]], i32 0, i32 1, {{.*}} ; [ DW_TAG_variable ] [bi] +// CHECK: [[BINT:![0-9]*]], {{[^,]+, [^,]+}}} ; [ DW_TAG_variable ] [bi] // CHECK: [[BINT]] = {{.*}} ; [ DW_TAG_typedef ] [bar<int>] [line 42 x::bar<int> bi; -// CHECK: metadata [[BFLOAT:![0-9]*]], i32 0, i32 1, {{.*}} ; [ DW_TAG_variable ] [bf] +// CHECK: [[BFLOAT:![0-9]*]], {{[^,]+, [^,]+}}} ; [ DW_TAG_variable ] [bf] // CHECK: [[BFLOAT]] = {{.*}} ; [ DW_TAG_typedef ] [bar<float>] [line 42 x::bar<float> bf; using -// CHECK: metadata [[NARF:![0-9]*]], i32 0, i32 1, {{.*}} ; [ DW_TAG_variable ] [n] +// CHECK: [[NARF:![0-9]*]], {{[^,]+, [^,]+}}} ; [ DW_TAG_variable ] [n] # 142 narf // CHECK: [[NARF]] = {{.*}} ; [ DW_TAG_typedef ] [narf] [line 142 = int; diff --git a/test/CodeGenCXX/debug-info-artificial-arg.cpp b/test/CodeGenCXX/debug-info-artificial-arg.cpp index 84f496f54c37..9eb3c6f0e98d 100644 --- a/test/CodeGenCXX/debug-info-artificial-arg.cpp +++ b/test/CodeGenCXX/debug-info-artificial-arg.cpp @@ -22,8 +22,8 @@ int main(int argc, char **argv) { A reallyA (500); } -// CHECK: ![[CLASSTYPE:.*]] = {{.*}}, metadata !"_ZTS1A"} ; [ DW_TAG_class_type ] [A] +// CHECK: ![[CLASSTYPE:.*]] = {{.*}}, !"_ZTS1A"} ; [ DW_TAG_class_type ] [A] // CHECK: ![[ARTARG:.*]] = {{.*}} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [artificial] [from _ZTS1A] -// CHECK: metadata !"_ZTS1A", {{.*}} ; [ DW_TAG_subprogram ] [line 12] [A] -// CHECK: metadata [[FUNCTYPE:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: [[FUNCTYPE]] = metadata !{null, metadata ![[ARTARG]], metadata !{{.*}}, metadata !{{.*}}} +// CHECK: !"_ZTS1A", {{.*}} ; [ DW_TAG_subprogram ] [line 12] [public] [A] +// CHECK: [[FUNCTYPE:![0-9]*]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: [[FUNCTYPE]] = !{null, ![[ARTARG]], !{{.*}}, !{{.*}}} diff --git a/test/CodeGenCXX/debug-info-class.cpp b/test/CodeGenCXX/debug-info-class.cpp index 34add0432c49..55d56531609f 100644 --- a/test/CodeGenCXX/debug-info-class.cpp +++ b/test/CodeGenCXX/debug-info-class.cpp @@ -94,33 +94,29 @@ int main(int argc, char **argv) { // CHECK: DW_TAG_class_type ] [bar] // CHECK: DW_TAG_union_type ] [baz] // CHECK: DW_TAG_class_type ] [B] {{.*}} [def] -// CHECK: metadata !"_vptr$B", {{.*}}, i32 64, metadata !{{.*}}} ; [ DW_TAG_member ] +// CHECK: !"0xd\00_vptr$B\00{{.*}}\0064", {{.*}} ; [ DW_TAG_member ] -// CHECK: [[C:![0-9]*]] = {{.*}} metadata [[C_MEM:![0-9]*]], i32 0, metadata !"_ZTS1C", null, metadata !"_ZTS1C"} ; [ DW_TAG_structure_type ] [C] {{.*}} [def] -// CHECK: [[C_MEM]] = metadata !{metadata [[C_VPTR:![0-9]*]], metadata [[C_S:![0-9]*]], metadata [[C_DTOR:![0-9]*]]} +// CHECK: [[C:![0-9]*]] = {{.*}} [[C_MEM:![0-9]*]], !"_ZTS1C", null, !"_ZTS1C"} ; [ DW_TAG_structure_type ] [C] {{.*}} [def] +// CHECK: [[C_MEM]] = !{[[C_VPTR:![0-9]*]], [[C_S:![0-9]*]], [[C_DTOR:![0-9]*]]} // CHECK: [[C_VPTR]] = {{.*}} ; [ DW_TAG_member ] [_vptr$C] {{.*}} [artificial] // CHECK: [[C_S]] = {{.*}} ; [ DW_TAG_member ] [s] {{.*}} [static] [from int] // CHECK: [[C_DTOR]] = {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [~C] -// CHECK: null, i32 0, null, null, metadata !"_ZTS1D"} ; [ DW_TAG_structure_type ] [D] {{.*}} [decl] -// CHECK: null, i32 0, null, null, metadata !"_ZTS1E"} ; [ DW_TAG_structure_type ] [E] {{.*}} [decl] -// CHECK: [[F:![0-9]*]] = {{.*}} null, i32 0, null, null, metadata !"_ZTS1F"} ; [ DW_TAG_structure_type ] [F] {{.*}} [decl] +// CHECK: null, null, null, !"_ZTS1D"} ; [ DW_TAG_structure_type ] [D] {{.*}} [decl] +// CHECK: null, null, null, !"_ZTS1E"} ; [ DW_TAG_structure_type ] [E] {{.*}} [decl] +// CHECK: [[F:![0-9]*]] = {{.*}} null, null, null, !"_ZTS1F"} ; [ DW_TAG_structure_type ] [F] {{.*}} [decl] -// CHECK: null, i32 0, null, null, metadata !"_ZTS1G"} ; [ DW_TAG_structure_type ] [G] {{.*}} [decl] -// CHECK: metadata [[G_INNER_MEM:![0-9]*]], i32 0, null, null, metadata !"_ZTSN1G5innerE"} ; [ DW_TAG_structure_type ] [inner] [line 50, {{.*}} [def] -// CHECK: [[G_INNER_MEM]] = metadata !{metadata [[G_INNER_I:![0-9]*]]} +// CHECK: null, null, null, !"_ZTS1G"} ; [ DW_TAG_structure_type ] [G] {{.*}} [decl] +// CHECK: [[G_INNER_MEM:![0-9]*]], null, null, !"_ZTSN1G5innerE"} ; [ DW_TAG_structure_type ] [inner] [line 50, {{.*}} [def] +// CHECK: [[G_INNER_MEM]] = !{[[G_INNER_I:![0-9]*]]} // CHECK: [[G_INNER_I]] = {{.*}} ; [ DW_TAG_member ] [j] {{.*}} [from int] // CHECK: ; [ DW_TAG_structure_type ] [A] // CHECK: HdrSize // CHECK: ; [ DW_TAG_structure_type ] [I] {{.*}} [def] // -// CHECK: metadata !"_ZTS1D", {{.*}}, metadata [[D_FUNC_DECL:![0-9]*]], metadata {{![0-9]*}}, i32 {{[0-9]*}}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] -// CHECK: [[D_FUNC_DECL]] = {{.*}}, metadata !"_ZTS1D", {{.*}}, i32 0, null, i32 {{[0-9]*}}} ; [ DW_TAG_subprogram ] {{.*}} [func] +// CHECK: !"_ZTS1D", {{.*}}, [[D_FUNC_DECL:![0-9]*]], {{![0-9]*}}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] +// CHECK: [[D_FUNC_DECL]] = !{!"0x2e\00func\00{{.*}}\000\00{{[0-9]+}}"{{.*}}, !"_ZTS1D", {{.*}}, null} ; [ DW_TAG_subprogram ] {{.*}} [func] -// CHECK: [[F_I_DEF:![0-9]*]] = {{.*}}, metadata [[F_I:![0-9]*]]} ; [ DW_TAG_variable ] [i] - -// CHECK: [[F_I]] = {{.*}}, metadata !"_ZTS1F", {{.*}} ; [ DW_TAG_member ] [i] - -// CHECK: ![[EXCEPTLOC]] = metadata !{i32 84, -// CHECK: ![[RETLOC]] = metadata !{i32 83, +// CHECK: ![[EXCEPTLOC]] = !MDLocation(line: 84, +// CHECK: ![[RETLOC]] = !MDLocation(line: 83, diff --git a/test/CodeGenCXX/debug-info-cxx1y.cpp b/test/CodeGenCXX/debug-info-cxx1y.cpp index 3cb7e45e6985..261f9653461d 100644 --- a/test/CodeGenCXX/debug-info-cxx1y.cpp +++ b/test/CodeGenCXX/debug-info-cxx1y.cpp @@ -1,7 +1,20 @@ -// RUN: not %clang_cc1 -emit-llvm-only -std=c++1y -g %s 2>&1 | FileCheck %s +// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only -std=c++14 -emit-llvm -g %s -o - | FileCheck %s + +// CHECK: [[EMPTY:![0-9]*]] = !{} +// CHECK: \00foo\00{{.*}}, [[EMPTY]], {{.*}}} ; [ DW_TAG_structure_type ] +// FIXME: The context of this definition should be the CU/file scope, not the class. +// CHECK: !"_ZTS3foo", [[SUBROUTINE_TYPE:![0-9]*]], {{.*}}, [[FUNC_DECL:![0-9]*]], {{![0-9]*}}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] +// CHECK: [[SUBROUTINE_TYPE]] = {{.*}}, [[TYPE_LIST:![0-9]*]], +// CHECK: [[TYPE_LIST]] = !{[[INT:![0-9]*]]} +// CHECK: [[INT]] = {{.*}} ; [ DW_TAG_base_type ] [int] +// CHECK: [[FUNC_DECL]] = {{.*}}, !"_ZTS3foo", [[SUBROUTINE_TYPE]], {{.*}}} ; [ DW_TAG_subprogram ] {{.*}} [func] struct foo { - auto func(); // CHECK: error: debug information for auto is not yet supported + static auto func(); }; foo f; + +auto foo::func() { + return 1; +} diff --git a/test/CodeGenCXX/debug-info-decl-nested.cpp b/test/CodeGenCXX/debug-info-decl-nested.cpp index f79a8e9fe32d..95d32c400e18 100644 --- a/test/CodeGenCXX/debug-info-decl-nested.cpp +++ b/test/CodeGenCXX/debug-info-decl-nested.cpp @@ -17,17 +17,18 @@ class OuterClass public: InnerClass(); // Here createContextChain() generates a limited type for OuterClass. } theInnerClass; -// CHECK0: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [private] [OuterClass] +// CHECK0: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [OuterClass] OuterClass(const Foo *); // line 10 }; OuterClass::InnerClass OuterClass::theInnerClass; // This toplevel decl causes InnerClass to be generated. -// CHECK0: metadata {{.*}}, metadata ![[DECL]], metadata {{.*}}, i32 [[@LINE+1]]} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [def] [OuterClass] +// CHECK0: !"0x2e\00OuterClass\00{{.*}}\00[[@LINE+1]]"{{.*}}, ![[DECL]], {{![0-9]+}}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [def] [OuterClass] OuterClass::OuterClass(const Foo *meta) { } // line 13 + class Foo1; class OuterClass1 { @@ -35,8 +36,8 @@ class OuterClass1 public: InnerClass1(); } theInnerClass1; -// CHECK1: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+2]]] [private] [Bar] -// CHECK1: metadata {{.*}}, metadata ![[DECL]], metadata {{.*}}, i32 [[@LINE+4]]} ; [ DW_TAG_subprogram ] [line [[@LINE+4]]] [def] [Bar] +// CHECK1: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+2]]] [Bar] +// CHECK1: !"0x2e\00Bar\00{{.*}}\00[[@LINE+4]]"{{.*}}, ![[DECL]], {{![0-9]+}}} ; [ DW_TAG_subprogram ] [line [[@LINE+4]]] [def] [Bar] void Bar(const Foo1 *); }; OuterClass1::InnerClass1 OuterClass1::theInnerClass1; @@ -53,9 +54,9 @@ class OuterClass2 public: InnerClass2(); } theInnerClass2; -// CHECK2: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [private] [~OuterClass2] +// CHECK2: [[DECL:[0-9]+]] = {{.*}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [~OuterClass2] ~OuterClass2(); // line 10 }; OuterClass2::InnerClass2 OuterClass2::theInnerClass2; -// CHECK2: metadata {{.*}}, metadata ![[DECL]], metadata {{.*}}, i32 [[@LINE+1]]} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [def] [~OuterClass2] +// CHECK2: !"0x2e\00~OuterClass2\00{{.*}}\00[[@LINE+1]]"{{.*}}, ![[DECL]], {{.*}}} ; [ DW_TAG_subprogram ] [line [[@LINE+1]]] [def] [~OuterClass2] OuterClass2::~OuterClass2() { } diff --git a/test/CodeGenCXX/debug-info-enum-class.cpp b/test/CodeGenCXX/debug-info-enum-class.cpp index f0b97ccd2c8e..28ffce046c09 100644 --- a/test/CodeGenCXX/debug-info-enum-class.cpp +++ b/test/CodeGenCXX/debug-info-enum-class.cpp @@ -29,10 +29,10 @@ namespace PR14029 { namespace test2 { // FIXME: this should just be a declaration under -fno-standalone-debug -// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST2:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test21EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: !"0x4\00{{.*}}", {{[^,]*}}, [[TEST2:![0-9]*]], {{.*}}, [[TEST_ENUMS:![0-9]*]], null, null, !"_ZTSN5test21EE"} ; [ DW_TAG_enumeration_type ] [E] // CHECK: [[TEST2]] = {{.*}} ; [ DW_TAG_namespace ] [test2] -// CHECK: [[TEST_ENUMS]] = metadata !{metadata [[TEST_E:![0-9]*]]} -// CHECK: [[TEST_E]] = {{.*}}, metadata !"e", i64 0} ; [ DW_TAG_enumerator ] [e :: 0] +// CHECK: [[TEST_ENUMS]] = !{[[TEST_E:![0-9]*]]} +// CHECK: [[TEST_E]] = !{!"0x28\00e\000"} ; [ DW_TAG_enumerator ] [e :: 0] enum E : int; void func(E *) { } @@ -41,7 +41,7 @@ enum E : int { e }; namespace test3 { // FIXME: this should just be a declaration under -fno-standalone-debug -// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST3:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS]], {{[^,]*}}, null, null, metadata !"_ZTSN5test31EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: !"0x4\00{{.*}}", {{[^,]*}}, [[TEST3:![0-9]*]], {{.*}}, [[TEST_ENUMS]], null, null, !"_ZTSN5test31EE"} ; [ DW_TAG_enumeration_type ] [E] // CHECK: [[TEST3]] = {{.*}} ; [ DW_TAG_namespace ] [test3] enum E : int { e }; void func(E *) { @@ -49,7 +49,7 @@ void func(E *) { } namespace test4 { -// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST4:![0-9]*]], {{.*}}, metadata [[TEST_ENUMS]], {{[^,]*}}, null, null, metadata !"_ZTSN5test41EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: !"0x4\00{{.*}}", {{[^,]*}}, [[TEST4:![0-9]*]], {{.*}}, [[TEST_ENUMS]], null, null, !"_ZTSN5test41EE"} ; [ DW_TAG_enumeration_type ] [E] // CHECK: [[TEST4]] = {{.*}} ; [ DW_TAG_namespace ] [test4] enum E : int; void f1(E *) { @@ -62,7 +62,7 @@ void f2(E) { // CHECK: ; [ DW_TAG_enumeration_type ] [D] [line 6, size 16, align 16, offset 0] [decl] [from ] namespace test5 { -// CHECK: metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST5:![0-9]*]], {{.*}}, null, {{[^,]*}}, null, null, metadata !"_ZTSN5test51EE"} ; [ DW_TAG_enumeration_type ] [E] +// CHECK: !"0x4\00{{.*}}", {{[^,]*}}, [[TEST5:![0-9]*]], {{.*}}, null, null, null, !"_ZTSN5test51EE"} ; [ DW_TAG_enumeration_type ] [E] // CHECK: [[TEST5]] = {{.*}} ; [ DW_TAG_namespace ] [test5] enum E : int; void f1(E *) { diff --git a/test/CodeGenCXX/debug-info-enum.cpp b/test/CodeGenCXX/debug-info-enum.cpp index 810c3ee7ae9b..954f6f62e497 100644 --- a/test/CodeGenCXX/debug-info-enum.cpp +++ b/test/CodeGenCXX/debug-info-enum.cpp @@ -1,13 +1,13 @@ // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -g %s -o - | FileCheck %s -// CHECK: [[ENUMS:![0-9]*]], {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}, {{[^,]*}}} ; [ DW_TAG_compile_unit ] -// CHECK: [[ENUMS]] = metadata !{metadata [[E1:![0-9]*]], metadata [[E2:![0-9]*]], metadata [[E3:![0-9]*]]} +// CHECK: !"0x11\00{{.*}}", {{[^,]*}}, [[ENUMS:![0-9]*]], {{.*}}} ; [ DW_TAG_compile_unit ] +// CHECK: [[ENUMS]] = !{[[E1:![0-9]*]], [[E2:![0-9]*]], [[E3:![0-9]*]]} namespace test1 { -// CHECK: [[E1]] = metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST1:![0-9]*]], {{.*}}, metadata [[TEST1_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test11eE"} ; [ DW_TAG_enumeration_type ] [e] +// CHECK: [[E1]] = !{!"0x4\00{{.*}}", {{[^,]*}}, [[TEST1:![0-9]*]], {{.*}}, [[TEST1_ENUMS:![0-9]*]], null, null, !"_ZTSN5test11eE"} ; [ DW_TAG_enumeration_type ] [e] // CHECK: [[TEST1]] = {{.*}} ; [ DW_TAG_namespace ] [test1] -// CHECK: [[TEST1_ENUMS]] = metadata !{metadata [[TEST1_E:![0-9]*]]} -// CHECK: [[TEST1_E]] = {{.*}}, metadata !"E", i64 0} ; [ DW_TAG_enumerator ] [E :: 0] +// CHECK: [[TEST1_ENUMS]] = !{[[TEST1_E:![0-9]*]]} +// CHECK: [[TEST1_E]] = !{!"0x28\00E\000"} ; [ DW_TAG_enumerator ] [E :: 0] enum e { E }; void foo() { int v = E; @@ -16,7 +16,7 @@ void foo() { namespace test2 { // rdar://8195980 -// CHECK: [[E2]] = metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST2:![0-9]*]], {{.*}}, metadata [[TEST1_ENUMS]], {{[^,]*}}, null, null, metadata !"_ZTSN5test21eE"} ; [ DW_TAG_enumeration_type ] [e] +// CHECK: [[E2]] = !{!"0x4\00{{.*}}", {{[^,]*}}, [[TEST2:![0-9]*]], {{.*}}, [[TEST1_ENUMS]], null, null, !"_ZTSN5test21eE"} ; [ DW_TAG_enumeration_type ] [e] // CHECK: [[TEST2]] = {{.*}} ; [ DW_TAG_namespace ] [test2] enum e { E }; bool func(int i) { @@ -25,10 +25,10 @@ bool func(int i) { } namespace test3 { -// CHECK: [[E3]] = metadata !{i32 {{[^,]*}}, {{[^,]*}}, metadata [[TEST3:![0-9]*]], {{.*}}, metadata [[TEST3_ENUMS:![0-9]*]], {{[^,]*}}, null, null, metadata !"_ZTSN5test31eE"} ; [ DW_TAG_enumeration_type ] [e] +// CHECK: [[E3]] = !{!"0x4\00{{.*}}", {{[^,]*}}, [[TEST3:![0-9]*]], {{.*}}, [[TEST3_ENUMS:![0-9]*]], null, null, !"_ZTSN5test31eE"} ; [ DW_TAG_enumeration_type ] [e] // CHECK: [[TEST3]] = {{.*}} ; [ DW_TAG_namespace ] [test3] -// CHECK: [[TEST3_ENUMS]] = metadata !{metadata [[TEST3_E:![0-9]*]]} -// CHECK: [[TEST3_E]] = {{.*}}, metadata !"E", i64 -1} ; [ DW_TAG_enumerator ] [E :: -1] +// CHECK: [[TEST3_ENUMS]] = !{[[TEST3_E:![0-9]*]]} +// CHECK: [[TEST3_E]] = !{!"0x28\00E\00-1"} ; [ DW_TAG_enumerator ] [E :: -1] enum e { E = -1 }; void func() { e x; diff --git a/test/CodeGenCXX/debug-info-flex-member.cpp b/test/CodeGenCXX/debug-info-flex-member.cpp index 11329aa1e2b9..bc501c016847 100644 --- a/test/CodeGenCXX/debug-info-flex-member.cpp +++ b/test/CodeGenCXX/debug-info-flex-member.cpp @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s -// CHECK: metadata !{i32 {{.*}}, i64 0, i64 -1} ; [ DW_TAG_subrange_type ] +// CHECK: !"0x21\000\00-1"} ; [ DW_TAG_subrange_type ] struct StructName { int member[]; diff --git a/test/CodeGenCXX/debug-info-function-context.cpp b/test/CodeGenCXX/debug-info-function-context.cpp index e65d3289f8b1..a6c5a115fc07 100644 --- a/test/CodeGenCXX/debug-info-function-context.cpp +++ b/test/CodeGenCXX/debug-info-function-context.cpp @@ -25,12 +25,12 @@ int global_namespace_variable = 1; // functions that belong to the namespace have it as a context, and the global // function has the file as a context. -// CHECK: metadata !"_ZTS1C", metadata !"member_function"{{.*}} [ DW_TAG_subprogram ] [line 11] [def] [member_function] +// CHECK: !"0x2e\00member_function\00{{.*}}", !{{[0-9]+}}, !"_ZTS1C"{{.*}} [ DW_TAG_subprogram ] [line 11] [def] [member_function] -// CHECK: metadata !"_ZTS1C", metadata !"static_member_function"{{.*}} [ DW_TAG_subprogram ] [line 13] [def] [static_member_function] +// CHECK: !"0x2e\00static_member_function\00{{.*}}", !{{[0-9]+}}, !"_ZTS1C"{{.*}} [ DW_TAG_subprogram ] [line 13] [def] [static_member_function] -// CHECK: metadata [[FILE:![0-9]*]], metadata !"global_function"{{.*}} [ DW_TAG_subprogram ] [line 17] [def] [global_function] +// CHECK: !"0x2e\00global_function\00{{[^,]+}}", !{{[0-9]+}}, [[FILE:![0-9]*]]{{.*}} [ DW_TAG_subprogram ] [line 17] [def] [global_function] // CHECK: [[FILE]] = {{.*}} [ DW_TAG_file_type ] -// CHECK: metadata [[NS:![0-9]*]], metadata !"global_namespace_function"{{.*}} [ DW_TAG_subprogram ] [line 20] [def] [global_namespace_function] +// CHECK: !"0x2e\00global_namespace_function\00{{[^,]+}}", !{{[0-9]+}}, [[NS:![0-9]*]]{{.*}} [ DW_TAG_subprogram ] [line 20] [def] [global_namespace_function] // CHECK: [[NS]] = {{.*}} [ DW_TAG_namespace ] [ns] [line 19] diff --git a/test/CodeGenCXX/debug-info-global.cpp b/test/CodeGenCXX/debug-info-global.cpp index 8dc30c892316..5fc61c7c4d45 100644 --- a/test/CodeGenCXX/debug-info-global.cpp +++ b/test/CodeGenCXX/debug-info-global.cpp @@ -10,10 +10,10 @@ int f1() { return ns::cnst + ns::cnst; } -// CHECK: metadata [[GLOBALS:![0-9]*]], metadata {{![0-9]*}}, metadata !"{{.*}}", i32 {{[0-9]*}}} ; [ DW_TAG_compile_unit ] +// CHECK: !"0x11\00{{.*}}"{{.*}}, [[GLOBALS:![0-9]*]], {{![0-9]*}}} ; [ DW_TAG_compile_unit ] -// CHECK: [[GLOBALS]] = metadata !{metadata [[CNST:![0-9]*]]} +// CHECK: [[GLOBALS]] = !{[[CNST:![0-9]*]]} -// CHECK: [[CNST]] = {{.*}}, metadata [[NS:![0-9]*]], metadata !"cnst", {{.*}}; [ DW_TAG_variable ] [cnst] +// CHECK: [[CNST]] = !{!"0x34\00cnst\00{{.*}}", [[NS:![0-9]*]], {{[^,]+, [^,]+, [^,]+, [^,]+}}} ; [ DW_TAG_variable ] [cnst] // CHECK: [[NS]] = {{.*}}; [ DW_TAG_namespace ] [ns] diff --git a/test/CodeGenCXX/debug-info-globalinit.cpp b/test/CodeGenCXX/debug-info-globalinit.cpp index 30c8bfc680eb..efba958c9ed0 100644 --- a/test/CodeGenCXX/debug-info-globalinit.cpp +++ b/test/CodeGenCXX/debug-info-globalinit.cpp @@ -34,5 +34,5 @@ int main(void) {} // CHECK-NOT: __cxx_global_var_init // CHECK: store i32 %[[C2]], i32* @_ZL1k, align 4, !dbg // -// CHECK: ![[LINE]] = metadata !{i32 13, i32 -// CHECK: ![[LINE2]] = metadata !{i32 15, i32 +// CHECK: ![[LINE]] = !MDLocation(line: 13, +// CHECK: ![[LINE2]] = !MDLocation(line: 15, diff --git a/test/CodeGenCXX/debug-info-line-if.cpp b/test/CodeGenCXX/debug-info-line-if.cpp index e14090f03f98..d0205af92bf4 100644 --- a/test/CodeGenCXX/debug-info-line-if.cpp +++ b/test/CodeGenCXX/debug-info-line-if.cpp @@ -1,20 +1,55 @@ // RUN: %clang_cc1 -g -std=c++11 -S -emit-llvm %s -o - | FileCheck %s // PR19864 +extern int v[2]; +int a = 0, b = 0; int main() { - int v[] = {13, 21, 8, 3, 34, 1, 5, 2}; - int a = 0, b = 0; - for (int x : v) - if (x >= 3) - ++b; // CHECK: add nsw{{.*}}, 1 - else if (x >= 0) - ++a; // CHECK: add nsw{{.*}}, 1 - // The continuation block if the if statement should not share the - // location of the ++a statement. Having it point to the end of - // the condition is not ideal either, but it's less missleading. - - // CHECK: br label - // CHECK: br label - // CHECK: br label {{.*}}, !dbg ![[DBG:.*]] - // CHECK: ![[DBG]] = metadata !{i32 [[@LINE-11]], i32 0, metadata !{{.*}}, null} +#line 100 + for (int x : v) + if (x) + ++b; // CHECK: add nsw{{.*}}, 1 + else + ++a; // CHECK: add nsw{{.*}}, 1 + // The continuation block if the if statement should not share the + // location of the ++a statement. The branch back to the start of the loop + // should be attributed to the loop header line. + // CHECK: br label + // CHECK: br label + // CHECK: br label {{.*}}, !dbg [[DBG1:!.*]] + +#line 200 + while (a) + if (b) + ++b; // CHECK: add nsw{{.*}}, 1 + else + ++a; // CHECK: add nsw{{.*}}, 1 + + // CHECK: br label + // CHECK: br label {{.*}}, !dbg [[DBG2:!.*]] + +#line 300 + for (; a; ) + if (b) + ++b; // CHECK: add nsw{{.*}}, 1 + else + ++a; // CHECK: add nsw{{.*}}, 1 + + // CHECK: br label + // CHECK: br label {{.*}}, !dbg [[DBG3:!.*]] + +#line 400 + int x[] = {1, 2}; + for (int y : x) + if (b) + ++b; // CHECK: add nsw{{.*}}, 1 + else + ++a; // CHECK: add nsw{{.*}}, 1 + + // CHECK: br label + // CHECK: br label {{.*}}, !dbg [[DBG4:!.*]] + + // CHECK: [[DBG1]] = !MDLocation(line: 100, scope: !{{.*}}) + // CHECK: [[DBG2]] = !MDLocation(line: 200, scope: !{{.*}}) + // CHECK: [[DBG3]] = !MDLocation(line: 300, scope: !{{.*}}) + // CHECK: [[DBG4]] = !MDLocation(line: 401, scope: !{{.*}}) } diff --git a/test/CodeGenCXX/debug-info-line.cpp b/test/CodeGenCXX/debug-info-line.cpp new file mode 100644 index 000000000000..a5cc6392b4fc --- /dev/null +++ b/test/CodeGenCXX/debug-info-line.cpp @@ -0,0 +1,187 @@ +// RUN: %clang_cc1 -gline-tables-only -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -gline-tables-only -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - -triple i686-linux-gnu | FileCheck %s + +// XFAIL: win32 + +int &src(); +int *sink(); +extern "C" __complex float complex_src(); +extern "C" __complex float *complex_sink(); + +// CHECK-LABEL: define +void f1() { +#line 100 + * // The store for the assignment should be attributed to the start of the + // assignment expression here, regardless of the location of subexpressions. + sink() = src(); + // CHECK: store {{.*}}, !dbg [[DBG_F1:!.*]] +} + +struct foo { + int i; + int &j; + __complex float k; + foo(); +}; + +// CHECK-LABEL: define +foo::foo() + : +#line 200 + i // CHECK: store i32 {{.*}} !dbg [[DBG_FOO_VALUE:!.*]] + (src()), + j // CHECK: store i32* {{.*}} !dbg [[DBG_FOO_REF:!.*]] + (src()), + k // CHECK: store float {{.*}} !dbg [[DBG_FOO_COMPLEX:!.*]] + (complex_src()) { +} + +// CHECK-LABEL: define {{.*}}f2{{.*}} +void f2() { +#line 300 + * // CHECK: store float {{.*}} !dbg [[DBG_F2:!.*]] + complex_sink() = complex_src(); +} + +// CHECK-LABEL: define +void f3() { +#line 400 + * // CHECK: store float {{.*}} !dbg [[DBG_F3:!.*]] + complex_sink() += complex_src(); +} + +// CHECK-LABEL: define +void f4() { +#line 500 + auto x // CHECK: store {{.*}} !dbg [[DBG_F4:!.*]] + = src(); +} + +// CHECK-LABEL: define +void f5() { +#line 600 + auto x // CHECK: store float {{.*}} !dbg [[DBG_F5:!.*]] + = complex_src(); +} + +struct agg { int i; }; +agg agg_src(); + +// CHECK-LABEL: define +void f6() { + agg x; +#line 700 + x // CHECK: call void @llvm.memcpy{{.*}} !dbg [[DBG_F6:!.*]] + = agg_src(); +} + +// CHECK-LABEL: define +void f7() { + int *src1(); + int src2(); +#line 800 + int x = ( // CHECK: load {{.*}} !dbg [[DBG_F7:!.*]] + src1())[src2()]; +} + +// CHECK-LABEL: define +void f8() { + int src1[1]; + int src2(); +#line 900 + int x = ( // CHECK: load {{.*}} !dbg [[DBG_F8:!.*]] + src1)[src2()]; +} + +// CHECK-LABEL: define +void f9(int i) { + int src1[1][i]; + int src2(); +#line 1000 + auto x = ( // CHECK: getelementptr {{.*}} !dbg [[DBG_F9:!.*]] + src1)[src2()]; +} + +inline void *operator new(decltype(sizeof(1)), void *p) noexcept { return p; } + +// CHECK-LABEL: define +void f10() { + void *void_src(); + ( // CHECK: icmp {{.*}} !dbg [[DBG_F10_ICMP:.*]] + // CHECK: store {{.*}} !dbg [[DBG_F10_STORE:!.*]] +#line 1100 + new (void_src()) int(src())); +} + +// noexcept just to simplify the codegen a bit +void fn() noexcept(true); + +struct bar { + bar(); + // noexcept(false) to convolute the global dtor + ~bar() noexcept(false); +}; +// global ctor cleanup +// CHECK-LABEL: define +// CHECK: invoke{{ }} +// CHECK: invoke{{ }} +// CHECK: to label {{.*}}, !dbg [[DBG_GLBL_CTOR_B:!.*]] + +// terminate caller +// CHECK-LABEL: define + +// global dtor cleanup +// CHECK-LABEL: define +// CHECK: invoke{{ }} +// CHECK: invoke{{ }} +// CHECK: to label {{.*}}, !dbg [[DBG_GLBL_DTOR_B:!.*]] +#line 1500 +bar b[1] = { // + (fn(), // + bar())}; + +// CHECK-LABEL: define +__complex double f11() { + __complex double f; +// CHECK: store {{.*}} !dbg [[DBG_F11:!.*]] +#line 1200 + return f; +} + +// CHECK-LABEL: define +void f12() { + int f12_1(); + void f12_2(int = f12_1()); +// CHECK: call {{(signext )?}}i32 {{.*}} !dbg [[DBG_F12:!.*]] +#line 1300 + f12_2(); +} + +// CHECK-LABEL: define +void f13() { +// CHECK: call {{.*}} !dbg [[DBG_F13:!.*]] +#define F13_IMPL 1, src() + 1, +#line 1400 + F13_IMPL; +} + +// CHECK: [[DBG_F1]] = !MDLocation(line: 100, +// CHECK: [[DBG_FOO_VALUE]] = !MDLocation(line: 200, +// CHECK: [[DBG_FOO_REF]] = !MDLocation(line: 202, +// CHECK: [[DBG_FOO_COMPLEX]] = !MDLocation(line: 204, +// CHECK: [[DBG_F2]] = !MDLocation(line: 300, +// CHECK: [[DBG_F3]] = !MDLocation(line: 400, +// CHECK: [[DBG_F4]] = !MDLocation(line: 500, +// CHECK: [[DBG_F5]] = !MDLocation(line: 600, +// CHECK: [[DBG_F6]] = !MDLocation(line: 700, +// CHECK: [[DBG_F7]] = !MDLocation(line: 800, +// CHECK: [[DBG_F8]] = !MDLocation(line: 900, +// CHECK: [[DBG_F9]] = !MDLocation(line: 1000, +// CHECK: [[DBG_F10_ICMP]] = !MDLocation(line: 1100, +// CHECK: [[DBG_F10_STORE]] = !MDLocation(line: 1100, +// CHECK: [[DBG_GLBL_CTOR_B]] = !MDLocation(line: 1500, +// CHECK: [[DBG_GLBL_DTOR_B]] = !MDLocation(line: 1500, +// CHECK: [[DBG_F11]] = !MDLocation(line: 1200, +// CHECK: [[DBG_F12]] = !MDLocation(line: 1300, +// CHECK: [[DBG_F13]] = !MDLocation(line: 1400, diff --git a/test/CodeGenCXX/debug-info-method.cpp b/test/CodeGenCXX/debug-info-method.cpp index 49b8dc47855d..bb69a6516507 100644 --- a/test/CodeGenCXX/debug-info-method.cpp +++ b/test/CodeGenCXX/debug-info-method.cpp @@ -1,14 +1,14 @@ // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -g %s -o - | FileCheck %s -// CHECK: metadata !"_ZTS1A"} ; [ DW_TAG_class_type ] [A] -// CHECK: metadata !"_ZN1A3fooEiS_3$_0", {{.*}} [protected] +// CHECK: !"_ZTS1A"} ; [ DW_TAG_class_type ] [A] +// CHECK: !"{{.*}}\00_ZN1A3fooEiS_3$_0\00{{.*}}", {{.*}} [protected] // CHECK: ![[THISTYPE:[0-9]+]] = {{.*}} ; [ DW_TAG_pointer_type ] {{.*}} [artificial] [from _ZTS1A] -// CHECK: DW_TAG_ptr_to_member_type -// CHECK: {{.*}}metadata ![[MEMFUNTYPE:[0-9]+]], metadata !{{.*}}} ; [ DW_TAG_ptr_to_member_type ] {{.*}} [from ] -// CHECK: ![[MEMFUNTYPE]] = {{.*}}metadata ![[MEMFUNARGS:[0-9]+]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] {{.*}} [from ] -// CHECK: ![[MEMFUNARGS]] = {{.*}}, metadata ![[THISTYPE]], -// CHECK: ""{{.*}}DW_TAG_arg_variable -// CHECK: ""{{.*}}DW_TAG_arg_variable -// CHECK: ""{{.*}}DW_TAG_arg_variable +// CHECK: [ DW_TAG_ptr_to_member_type ] [line {{[0-9]+}}, size {{[1-9][0-9]+}}, align +// CHECK: {{.*}}![[MEMFUNTYPE:[0-9]+]], !{{.*}}} ; [ DW_TAG_ptr_to_member_type ] {{.*}} [from ] +// CHECK: ![[MEMFUNTYPE]] = {{.*}}![[MEMFUNARGS:[0-9]+]], null, null, null} ; [ DW_TAG_subroutine_type ] {{.*}} [from ] +// CHECK: ![[MEMFUNARGS]] = {{.*}}, ![[THISTYPE]], +// CHECK: !"0x101\00\00{{.*}}"{{.*}} DW_TAG_arg_variable +// CHECK: !"0x101\00\00{{.*}}"{{.*}} DW_TAG_arg_variable +// CHECK: !"0x101\00\00{{.*}}"{{.*}} DW_TAG_arg_variable union { int a; float b; diff --git a/test/CodeGenCXX/debug-info-namespace.cpp b/test/CodeGenCXX/debug-info-namespace.cpp index a1284d2d2771..60d508bcb735 100644 --- a/test/CodeGenCXX/debug-info-namespace.cpp +++ b/test/CodeGenCXX/debug-info-namespace.cpp @@ -5,12 +5,16 @@ namespace A { #line 1 "foo.cpp" namespace B { -int i; -void f1() { } +extern int i; +int f1() { return 0; } void f1(int) { } struct foo; struct bar { }; typedef bar baz; +extern int var_decl; +void func_decl(void); +extern int var_fwd; +void func_fwd(void); } } namespace A { @@ -19,7 +23,7 @@ using namespace B; using namespace A; namespace E = A; - +int B::i = f1(); int func(bool b) { if (b) { using namespace A::B; @@ -33,51 +37,65 @@ int func(bool b) { using B::baz; namespace X = A; namespace Y = X; + using B::var_decl; + using B::func_decl; + using B::var_fwd; + using B::func_fwd; return i + X::B::i + Y::B::i; } namespace A { using B::i; +namespace B { +int var_fwd = i; +} } +void B::func_fwd() {} // This should work even if 'i' and 'func' were declarations & not definitions, // but it doesn't yet. -// CHECK: [[CU:![0-9]*]] = {{.*}}[[MODULES:![0-9]*]], metadata !"", i32 1} ; [ DW_TAG_compile_unit ] +// CHECK: [[CU:![0-9]*]] = !{!"0x11\00{{.*}}\001"{{.*}}, [[MODULES:![0-9]*]]} ; [ DW_TAG_compile_unit ] // CHECK: [[FOO:![0-9]*]] {{.*}} ; [ DW_TAG_structure_type ] [foo] [line 5, size 0, align 0, offset 0] [decl] [from ] -// CHECK: [[FOOCPP:![0-9]*]] = metadata !{metadata !"foo.cpp", {{.*}} -// CHECK: [[NS:![0-9]*]] = {{.*}}, metadata [[FILE2:![0-9]*]], metadata [[CTXT:![0-9]*]], {{.*}} ; [ DW_TAG_namespace ] [B] [line 1] -// CHECK: [[CTXT]] = {{.*}}, metadata [[FILE:![0-9]*]], null, {{.*}} ; [ DW_TAG_namespace ] [A] [line 5] +// CHECK: [[FOOCPP:![0-9]*]] = !{!"foo.cpp", {{.*}} +// CHECK: [[NS:![0-9]*]] = !{!"0x39\00B\001", [[FILE2:![0-9]*]], [[CTXT:![0-9]*]]} ; [ DW_TAG_namespace ] [B] [line 1] +// CHECK: [[CTXT]] = !{!"0x39\00A\005", [[FILE:![0-9]*]], null} ; [ DW_TAG_namespace ] [A] [line 5] // CHECK: [[FILE]] {{.*}}debug-info-namespace.cpp" // CHECK: [[BAR:![0-9]*]] {{.*}} ; [ DW_TAG_structure_type ] [bar] [line 6, {{.*}}] [decl] [from ] // CHECK: [[F1:![0-9]*]] {{.*}} ; [ DW_TAG_subprogram ] [line 4] [def] [f1] -// CHECK: [[FUNC:![0-9]*]] {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] // CHECK: [[FILE2]]} ; [ DW_TAG_file_type ] [{{.*}}foo.cpp] -// CHECK: [[I:![0-9]*]] = {{.*}}, metadata [[NS]], metadata !"i", {{.*}} ; [ DW_TAG_variable ] [i] -// CHECK: [[MODULES]] = metadata !{metadata [[M1:![0-9]*]], metadata [[M2:![0-9]*]], metadata [[M3:![0-9]*]], metadata [[M4:![0-9]*]], metadata [[M5:![0-9]*]], metadata [[M6:![0-9]*]], metadata [[M7:![0-9]*]], metadata [[M8:![0-9]*]], metadata [[M9:![0-9]*]], metadata [[M10:![0-9]*]], metadata [[M11:![0-9]*]], metadata [[M12:![0-9]*]], metadata [[M13:![0-9]*]]} -// CHECK: [[M1]] = metadata !{i32 {{[0-9]*}}, metadata [[CTXT]], metadata [[NS]], i32 11} ; [ DW_TAG_imported_module ] -// CHECK: [[M2]] = metadata !{i32 {{[0-9]*}}, metadata [[CU]], metadata [[CTXT]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_module ] -// CHECK: [[M3]] = metadata !{i32 {{[0-9]*}}, metadata [[CU]], metadata [[CTXT]], i32 15, metadata !"E"} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M4]] = metadata !{i32 {{[0-9]*}}, metadata [[LEX2:![0-9]*]], metadata [[NS]], i32 19} ; [ DW_TAG_imported_module ] -// CHECK: [[LEX2]] = metadata !{i32 {{[0-9]*}}, metadata [[FILE2]], metadata [[LEX1:![0-9]+]], i32 {{[0-9]*}}, i32 0, i32 {{.*}}} ; [ DW_TAG_lexical_block ] -// CHECK: [[LEX1]] = metadata !{i32 {{[0-9]*}}, metadata [[FILE2]], metadata [[FUNC]], i32 {{[0-9]*}}, i32 0, i32 {{.*}}} ; [ DW_TAG_lexical_block ] -// CHECK: [[M5]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[CTXT]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_module ] -// CHECK: [[M6]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[FOO:!"_ZTSN1A1B3fooE"]], i32 23} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M7]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[BAR:!"_ZTSN1A1B3barE"]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M8]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[F1]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M9]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[I]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M10]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[BAZ:![0-9]*]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_declaration ] -// CHECK: [[BAZ]] = metadata !{i32 {{[0-9]*}}, metadata [[FOOCPP]], metadata [[NS]], {{.*}}, metadata !"_ZTSN1A1B3barE"} ; [ DW_TAG_typedef ] [baz] {{.*}} [from _ZTSN1A1B3barE] -// CHECK: [[M11]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[CTXT]], i32 {{[0-9]*}}, metadata !"X"} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M12]] = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], metadata [[M11]], i32 {{[0-9]*}}, metadata !"Y"} ; [ DW_TAG_imported_declaration ] -// CHECK: [[M13]] = metadata !{i32 {{[0-9]*}}, metadata [[CTXT]], metadata [[I]], i32 {{[0-9]*}}} ; [ DW_TAG_imported_declaration ] +// CHECK: [[FUNC:![0-9]*]] {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] +// CHECK: [[FUNC_FWD:![0-9]*]] {{.*}} [ DW_TAG_subprogram ] [line 47] [def] [func_fwd] +// CHECK: [[I:![0-9]*]] = !{!"0x34\00i\00{{.*}}", [[NS]], {{.*}} ; [ DW_TAG_variable ] [i] +// CHECK: [[VAR_FWD:![0-9]*]] = !{!"0x34\00var_fwd\00{{.*}}", [[NS]], {{.*}}} ; [ DW_TAG_variable ] [var_fwd] [line 44] [def] -// CHECK-GMLT: [[CU:![0-9]*]] = {{.*}}[[MODULES:![0-9]*]], metadata !"", i32 2} ; [ DW_TAG_compile_unit ] -// CHECK-GMLT: [[MODULES]] = metadata !{} +// CHECK: [[MODULES]] = !{[[M1:![0-9]*]], [[M2:![0-9]*]], [[M3:![0-9]*]], [[M4:![0-9]*]], [[M5:![0-9]*]], [[M6:![0-9]*]], [[M7:![0-9]*]], [[M8:![0-9]*]], [[M9:![0-9]*]], [[M10:![0-9]*]], [[M11:![0-9]*]], [[M12:![0-9]*]], [[M13:![0-9]*]], [[M14:![0-9]*]], [[M15:![0-9]*]], [[M16:![0-9]*]], [[M17:![0-9]*]]} +// CHECK: [[M1]] = !{!"0x3a\0015\00", [[CTXT]], [[NS]]} ; [ DW_TAG_imported_module ] +// CHECK: [[M2]] = !{!"0x3a\00{{[0-9]+}}\00", [[CU]], [[CTXT]]} ; [ DW_TAG_imported_module ] +// CHECK: [[M3]] = !{!"0x8\0019\00E", [[CU]], [[CTXT]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M4]] = !{!"0x3a\0023\00", [[LEX2:![0-9]*]], [[NS]]} ; [ DW_TAG_imported_module ] +// CHECK: [[LEX2]] = !{!"0xb\00{{[0-9]*}}\000\00{{.*}}", [[FILE2]], [[LEX1:![0-9]+]]} ; [ DW_TAG_lexical_block ] +// CHECK: [[LEX1]] = !{!"0xb\00{{[0-9]*}}\000\00{{.*}}", [[FILE2]], [[FUNC]]} ; [ DW_TAG_lexical_block ] +// CHECK: [[M5]] = !{!"0x3a\00{{[0-9]+}}\00", [[FUNC]], [[CTXT]]} ; [ DW_TAG_imported_module ] +// CHECK: [[M6]] = !{!"0x8\0027\00", [[FUNC]], [[FOO:!"_ZTSN1A1B3fooE"]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M7]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[BAR:!"_ZTSN1A1B3barE"]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M8]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[F1]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M9]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[I]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M10]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[BAZ:![0-9]*]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[BAZ]] = !{!"0x16\00baz\00{{.*}}", [[FOOCPP]], [[NS]], !"_ZTSN1A1B3barE"} ; [ DW_TAG_typedef ] [baz] {{.*}} [from _ZTSN1A1B3barE] +// CHECK: [[M11]] = !{!"0x8\00{{[0-9]+}}\00X", [[FUNC]], [[CTXT]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M12]] = !{!"0x8\00{{[0-9]+}}\00Y", [[FUNC]], [[M11]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M13]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[VAR_DECL:![0-9]*]]} ; [ DW_TAG_imported_declaration ] +// CHECK [[VAR_DECL]] = !{!"0x34\00var_decl\00{{.*}}", [[NS]], {{.*}}} ; [ DW_TAG_variable ] [var_decl] [line 8] +// CHECK: [[M14]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[FUNC_DECL:![0-9]*]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[FUNC_DECL]] = !{!"0x2e\00func_decl\00{{.*}}", [[FOOCPP]], [[NS]], {{.*}}} ; [ DW_TAG_subprogram ] [line 9] [scope 0] [func_decl] +// CHECK: [[M15]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[VAR_FWD:![0-9]*]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M16]] = !{!"0x8\00{{[0-9]+}}\00", [[FUNC]], [[FUNC_FWD:![0-9]*]]} ; [ DW_TAG_imported_declaration ] +// CHECK: [[M17]] = !{!"0x8\00{{[0-9]+}}\00", [[CTXT]], [[I]]} ; [ DW_TAG_imported_declaration ] +// CHECK-GMLT: [[CU:![0-9]*]] = !{!"0x11\00{{.*}}\002"{{.*}}, [[MODULES:![0-9]*]]} ; [ DW_TAG_compile_unit ] +// CHECK-GMLT: [[MODULES]] = !{} // CHECK-NOLIMIT: ; [ DW_TAG_structure_type ] [bar] [line 6, {{.*}}] [def] [from ] -// FIXME: It is confused on win32 to generate file entry when dosish filename is given. -// REQUIRES: shell // REQUIRES: shell-preserves-root // REQUIRES: dw2 diff --git a/test/CodeGenCXX/debug-info-ptr-to-member-function.cpp b/test/CodeGenCXX/debug-info-ptr-to-member-function.cpp new file mode 100644 index 000000000000..656e6f495880 --- /dev/null +++ b/test/CodeGenCXX/debug-info-ptr-to-member-function.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 %s -triple x86_64-apple-darwin -g -emit-llvm -o - | FileCheck %s + +struct T { + int method(); +}; + +void foo(int (T::*method)()) {} + +// A pointer to a member function is a pair of function- and this-pointer. +// CHECK: [ DW_TAG_ptr_to_member_type ] {{.*}} size 128 diff --git a/test/CodeGenCXX/debug-info-qualifiers.cpp b/test/CodeGenCXX/debug-info-qualifiers.cpp index c6b935f9039a..2655bd9d726f 100644 --- a/test/CodeGenCXX/debug-info-qualifiers.cpp +++ b/test/CodeGenCXX/debug-info-qualifiers.cpp @@ -2,25 +2,25 @@ // Test (r)value and CVR qualifiers on C++11 non-static member functions. class A { public: - // CHECK: i32 [[@LINE+2]], metadata ![[PLSR:[0-9]+]], {{.*}}[ DW_TAG_subprogram ] [line [[@LINE+2]]] [reference] [l] + // CHECK: !"0x2e\00l\00{{.*}}\00[[@LINE+2]]"{{, [^,]+, [^,]+}}, ![[PLSR:[0-9]+]], {{.*}}[ DW_TAG_subprogram ] [line [[@LINE+2]]] [public] [reference] [l] // CHECK: ![[PLSR]] ={{.*}}[ DW_TAG_subroutine_type ]{{.*}}[reference] void l() const &; - // CHECK: ![[ARGS:[0-9]+]] = metadata !{null, metadata ![[THIS:[0-9]+]]} - // CHECK: ![[THIS]] = {{.*}} metadata ![[CONST_A:.*]]} ; [ DW_TAG_pointer_type ] + // CHECK: ![[ARGS:[0-9]+]] = !{null, ![[THIS:[0-9]+]]} + // CHECK: ![[THIS]] = {{.*}} ![[CONST_A:.*]]} ; [ DW_TAG_pointer_type ] // CHECK: ![[CONST_A]] = {{.*}} [ DW_TAG_const_type ] - // CHECK: i32 [[@LINE+2]], metadata ![[PRSR:[0-9]+]], {{.*}}[ DW_TAG_subprogram ] [line [[@LINE+2]]] [rvalue reference] [r] - // CHECK: ![[PRSR]] ={{.*}}metadata ![[ARGS]], i32 0, null, null, null}{{.*}}[ DW_TAG_subroutine_type ]{{.*}}[rvalue reference] + // CHECK: !"0x2e\00r\00{{.*}}\00[[@LINE+2]]"{{, [^,]+, [^,]+}}, ![[PRSR:[0-9]+]], {{.*}}[ DW_TAG_subprogram ] [line [[@LINE+2]]] [public] [rvalue reference] [r] + // CHECK: ![[PRSR]] ={{.*}}![[ARGS]], null, null, null}{{.*}}[ DW_TAG_subroutine_type ]{{.*}}[rvalue reference] void r() const &&; }; void g() { A a; // The type of pl is "void (A::*)() const &". - // CHECK: metadata ![[PL:[0-9]+]], i32 0, i32 0} ; [ DW_TAG_auto_variable ] [pl] [line [[@LINE+2]]] - // CHECK: metadata ![[PLSR]], metadata !"{{.*}}"} ; [ DW_TAG_ptr_to_member_type ] + // CHECK: ![[PL:[0-9]+]]} ; [ DW_TAG_auto_variable ] [pl] [line [[@LINE+2]]] + // CHECK: ![[PLSR]], !"{{.*}}"} ; [ DW_TAG_ptr_to_member_type ] auto pl = &A::l; - // CHECK: metadata ![[PR:[0-9]+]], i32 0, i32 0} ; [ DW_TAG_auto_variable ] [pr] [line [[@LINE+2]]] - // CHECK: metadata ![[PRSR]], metadata !"{{.*}}"} ; [ DW_TAG_ptr_to_member_type ] + // CHECK: ![[PR:[0-9]+]]} ; [ DW_TAG_auto_variable ] [pr] [line [[@LINE+2]]] + // CHECK: ![[PRSR]], !"{{.*}}"} ; [ DW_TAG_ptr_to_member_type ] auto pr = &A::r; } diff --git a/test/CodeGenCXX/debug-info-rvalue-ref.cpp b/test/CodeGenCXX/debug-info-rvalue-ref.cpp index 142f587fc62d..36e4aa374244 100644 --- a/test/CodeGenCXX/debug-info-rvalue-ref.cpp +++ b/test/CodeGenCXX/debug-info-rvalue-ref.cpp @@ -8,4 +8,4 @@ void foo (int &&i) printf("%d\n", i); } -// CHECK: metadata !{i32 {{.*}}, null, null, null, i32 0, i64 0, i64 0, i64 0, i32 0, metadata !{{.*}}} ; [ DW_TAG_rvalue_reference_type ] +// CHECK: !"0x42\00\000\000\000\000\000", null, null, !{{.*}}} ; [ DW_TAG_rvalue_reference_type ] diff --git a/test/CodeGenCXX/debug-info-scope.cpp b/test/CodeGenCXX/debug-info-scope.cpp index 0447dc04d56b..e66588d699af 100644 --- a/test/CodeGenCXX/debug-info-scope.cpp +++ b/test/CodeGenCXX/debug-info-scope.cpp @@ -1,32 +1,55 @@ -// RUN: %clang_cc1 -g -emit-llvm %s -o -| FileCheck %s +// RUN: %clang_cc1 -g -std=c++11 -emit-llvm %s -o -| FileCheck %s // // Two variables with the same name in subsequent if staments need to be in separate scopes. // // rdar://problem/14024005 -// -int printf(const char*, ...); +int src(); -char *return_char (int input) -{ - if (input%2 == 0) - return "I am even.\n"; - else - return "I am odd.\n"; -} +void f(); -int main2() { -// CHECK: [ DW_TAG_auto_variable ] [ptr] [line [[@LINE+2]]] -// CHECK: metadata !{i32 {{.*}}, metadata !{{.*}}, i32 [[@LINE+1]], {{.*}}} ; [ DW_TAG_lexical_block ] - if (char *ptr = return_char(1)) { - printf ("%s", ptr); - } -// CHECK: [ DW_TAG_auto_variable ] [ptr] [line [[@LINE+2]]] -// CHECK: metadata !{i32 {{.*}}, metadata !{{.*}}, i32 [[@LINE+1]], {{.*}}} ; [ DW_TAG_lexical_block ] - if (char *ptr = return_char(2)) { - printf ("%s", ptr); +void func() { + // CHECK: = !{!"0x100\00{{.*}}", [[IF1:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [i] [line [[@LINE+2]]] + // CHECK: [[IF1]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + if (int i = src()) + f(); + + // CHECK: = !{!"0x100\00{{.*}}", [[IF2:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [i] [line [[@LINE+2]]] + // CHECK: [[IF2]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + if (int i = src()) { + f(); + } else + f(); + + // CHECK: = !{!"0x100\00{{.*}}", [[FOR:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [i] [line [[@LINE+2]]] + // CHECK: [[FOR]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + for (int i = 0; + // CHECK: = !{!"0x100\00{{.*}}", [[FOR_BODY:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [b] [line [[@LINE+6]]] + // The scope could be located at 'bool b', but LLVM drops line information for + // scopes anyway, so it's not terribly important. + // FIXME: change the debug info schema to not include locations of scopes, + // since they're not used. + // CHECK: [[FOR_BODY]] = !{!"0xb\00[[@LINE-6]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + bool b = i != 10; ++i) + f(); + + // CHECK: = !{!"0x100\00{{.*}}", [[FOR:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [i] [line [[@LINE+2]]] + // CHECK: [[FOR]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + for (int i = 0; i != 10; ++i) { + // FIXME: Do not include scopes that have only other scopes (and no variables + // or using declarations) as direct children, they just waste + // space/relocations/etc. + // CHECK: [[FOR_LOOP_INCLUDING_COND:!.*]] = !{!"0xb\00[[@LINE-4]]\00{{.*}}", !{{[0-9]+}}, [[FOR]]} ; [ DW_TAG_lexical_block ] + // CHECK: = !{!"0x100\00{{.*}}", [[FOR_COMPOUND:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [b] [line [[@LINE+2]]] + // CHECK: [[FOR_COMPOUND]] = !{!"0xb\00[[@LINE-6]]\00{{.*}}", !{{[0-9]+}}, [[FOR_LOOP_INCLUDING_COND]]} ; [ DW_TAG_lexical_block ] + bool b = i % 2; } - else printf ("%s", ptr); - return 0; + int x[] = {1, 2}; + // CHECK: = !{!"0x100\00{{.*}}", [[RANGE_FOR:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [__range] [line 0] + // CHECK: [[RANGE_FOR]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ; [ DW_TAG_lexical_block ] + for (int i : x) { + // CHECK: = !{!"0x100\00{{.*}}", [[RANGE_FOR_BODY:![0-9]*]], {{.*}} ; [ DW_TAG_auto_variable ] [i] [line [[@LINE-1]]] + // CHECK: [[RANGE_FOR_BODY]] = !{!"0xb\00[[@LINE-2]]\00{{.*}}", !{{[0-9]+}}, [[RANGE_FOR]]} ; [ DW_TAG_lexical_block ] + } } diff --git a/test/CodeGenCXX/debug-info-static-fns.cpp b/test/CodeGenCXX/debug-info-static-fns.cpp index 136261cdbc0d..41b713cc0674 100644 --- a/test/CodeGenCXX/debug-info-static-fns.cpp +++ b/test/CodeGenCXX/debug-info-static-fns.cpp @@ -7,4 +7,4 @@ namespace A { } // Verify that a is present and mangled. -// CHECK: metadata !"_ZN1AL1aEi", {{.*}}, i32 (i32)* @_ZN1AL1aEi, {{.*}} ; [ DW_TAG_subprogram ] [line 4] [local] [def] [a] +// CHECK: !"0x2e\00a\00a\00_ZN1AL1aEi\00{{.*}}", {{.*}}, i32 (i32)* @_ZN1AL1aEi, {{.*}} ; [ DW_TAG_subprogram ] [line 4] [local] [def] [a] diff --git a/test/CodeGenCXX/debug-info-static-member.cpp b/test/CodeGenCXX/debug-info-static-member.cpp index 1ac235c50f8e..18fd6915189a 100644 --- a/test/CodeGenCXX/debug-info-static-member.cpp +++ b/test/CodeGenCXX/debug-info-static-member.cpp @@ -33,15 +33,72 @@ int main() // why the definition of "a" comes before the declarations while // "b" and "c" come after. -// CHECK: metadata !"_ZTS1X"} ; [ DW_TAG_enumeration_type ] [X] -// CHECK: metadata !"_ZTS1C"} ; [ DW_TAG_class_type ] [C] -// CHECK: ![[DECL_A:[0-9]+]] = metadata {{.*}} [ DW_TAG_member ] [a] [line {{.*}}, size 0, align 0, offset 0] [private] [static] -// CHECK: metadata !"const_a", {{.*}}, i1 true} ; [ DW_TAG_member ] [const_a] [line {{.*}}, size 0, align 0, offset 0] [private] [static] -// CHECK: ![[DECL_B:[0-9]+]] {{.*}} metadata !"b", {{.*}} [ DW_TAG_member ] [b] [line {{.*}}, size 0, align 0, offset 0] [protected] [static] -// CHECK: metadata !"const_b", {{.*}}, float 0x{{.*}}} ; [ DW_TAG_member ] [const_b] [line {{.*}}, size 0, align 0, offset 0] [protected] [static] -// CHECK: ![[DECL_C:[0-9]+]] {{.*}} metadata !"c", {{.*}} [ DW_TAG_member ] [c] [line {{.*}}, size 0, align 0, offset 0] [static] -// CHECK: metadata !"const_c", {{.*}} [ DW_TAG_member ] [const_c] [line {{.*}}, size 0, align 0, offset 0] [static] -// CHECK: metadata !"x_a", {{.*}} [ DW_TAG_member ] [x_a] {{.*}} [static] -// CHECK: metadata !"a", {{.*}} @_ZN1C1aE, metadata ![[DECL_A]]} ; [ DW_TAG_variable ] [a] {{.*}} [def] -// CHECK: metadata !"b", {{.*}} @_ZN1C1bE, metadata ![[DECL_B]]} ; [ DW_TAG_variable ] [b] {{.*}} [def] -// CHECK: metadata !"c", {{.*}} @_ZN1C1cE, metadata ![[DECL_C]]} ; [ DW_TAG_variable ] [c] {{.*}} [def] +// CHECK: !"_ZTS1X"} ; [ DW_TAG_enumeration_type ] [X] +// CHECK: !"_ZTS1C"} ; [ DW_TAG_class_type ] [C] +// CHECK: ![[DECL_A:[0-9]+]] = {{.*}} [ DW_TAG_member ] [a] [line {{.*}}, size 0, align 0, offset 0] [static] +// CHECK: !"0xd\00const_a\00{{.*}}", {{.*}}, i1 true} ; [ DW_TAG_member ] [const_a] [line {{.*}}, size 0, align 0, offset 0] [static] +// CHECK: ![[DECL_B:[0-9]+]] = !{!"0xd\00b\00{{.*}}", {{.*}} [ DW_TAG_member ] [b] [line {{.*}}, size 0, align 0, offset 0] [protected] [static] +// CHECK: !"0xd\00const_b\00{{.*}}", {{.*}}, float 0x{{.*}}} ; [ DW_TAG_member ] [const_b] [line {{.*}}, size 0, align 0, offset 0] [protected] [static] +// CHECK: ![[DECL_C:[0-9]+]] = !{!"0xd\00c\00{{.*}}", {{.*}} [ DW_TAG_member ] [c] [line {{.*}}, size 0, align 0, offset 0] [public] [static] +// CHECK: !"0xd\00const_c\00{{.*}}", {{.*}} [ DW_TAG_member ] [const_c] [line {{.*}}, size 0, align 0, offset 0] [public] [static] +// CHECK: !"0xd\00x_a\00{{.*}}", {{.*}} [ DW_TAG_member ] [x_a] {{.*}} [public] [static] + +// CHECK: ; [ DW_TAG_structure_type ] [static_decl_templ<int>] {{.*}} [def] +// CHECK: ; [ DW_TAG_member ] [static_decl_templ_var] + +// CHECK: [[NS_X:![0-9]+]] = {{.*}} ; [ DW_TAG_namespace ] [x] + +// Test this in an anonymous namespace to ensure the type is retained even when +// it doesn't get automatically retained by the string type reference machinery. +namespace { +struct anon_static_decl_struct { + static const int anon_static_decl_var = 117; +}; +} + + +// CHECK: ; [ DW_TAG_structure_type ] [anon_static_decl_struct] {{.*}} [def] +// CHECK: ; [ DW_TAG_member ] [anon_static_decl_var] + +int ref() { + return anon_static_decl_struct::anon_static_decl_var; +} + +template<typename T> +struct static_decl_templ { + static const int static_decl_templ_var = 7; +}; + +template<typename T> +const int static_decl_templ<T>::static_decl_templ_var; + +int static_decl_templ_ref() { + return static_decl_templ<int>::static_decl_templ_var; +} + +// CHECK: !"0x34\00a\00{{.*}}", null, {{.*}} @_ZN1C1aE, ![[DECL_A]]} ; [ DW_TAG_variable ] [a] {{.*}} [def] +// CHECK: !"0x34\00b\00{{.*}}", null, {{.*}} @_ZN1C1bE, ![[DECL_B]]} ; [ DW_TAG_variable ] [b] {{.*}} [def] +// CHECK: !"0x34\00c\00{{.*}}", null, {{.*}} @_ZN1C1cE, ![[DECL_C]]} ; [ DW_TAG_variable ] [c] {{.*}} [def] + +// CHECK-NOT: ; [ DW_TAG_variable ] [anon_static_decl_var] + +// Verify that even when a static member declaration is created lazily when +// creating the definition, the declaration line is that of the canonical +// declaration, not the definition. Also, since we look at the canonical +// definition, we should also correctly emit the constant value (42) into the +// debug info. +struct V { + virtual ~V(); // cause the definition of 'V' to be omitted by no-standalone-debug optimization + static const int const_va = 42; +}; +// CHECK: i32 42} ; [ DW_TAG_member ] [const_va] [line [[@LINE-2]], +const int V::const_va; + +namespace x { +struct y { + static int z; +}; +int y::z; +} + +// CHECK: !"0x34\00z\00{{.*}}", [[NS_X]], {{.*}} ; [ DW_TAG_variable ] [z] {{.*}} [def] diff --git a/test/CodeGenCXX/debug-info-template-explicit-specialization.cpp b/test/CodeGenCXX/debug-info-template-explicit-specialization.cpp index 506c0d535751..461303884b8d 100644 --- a/test/CodeGenCXX/debug-info-template-explicit-specialization.cpp +++ b/test/CodeGenCXX/debug-info-template-explicit-specialization.cpp @@ -91,3 +91,11 @@ struct j { extern template class j<int>; j<int> jj; // CHECK: ; [ DW_TAG_structure_type ] [j<int, int>] + +template <typename T> +struct k { +}; +template <> +struct k<int>; +template struct k<int>; +// CHECK-NOT: ; [ DW_TAG_structure_type ] [k<int>] diff --git a/test/CodeGenCXX/debug-info-template-limit.cpp b/test/CodeGenCXX/debug-info-template-limit.cpp index e1f23ada21ed..8e05c7f1c81d 100644 --- a/test/CodeGenCXX/debug-info-template-limit.cpp +++ b/test/CodeGenCXX/debug-info-template-limit.cpp @@ -1,8 +1,8 @@ // RUN: %clang_cc1 -emit-llvm -fno-standalone-debug -triple %itanium_abi_triple -g %s -o - | FileCheck %s // Check that this pointer type is TC<int> -// CHECK: ![[LINE:[0-9]+]] = {{.*}}"TC<int>", {{.*}} metadata !"_ZTS2TCIiE"} ; [ DW_TAG_class_type ] -// CHECK: metadata !"_ZTS2TCIiE"} ; [ DW_TAG_pointer_type ]{{.*}}[from _ZTS2TCIiE] +// CHECK: ![[LINE:[0-9]+]] = !{!"0x2\00TC<int>\00{{.*}}", {{.*}} !"_ZTS2TCIiE"} ; [ DW_TAG_class_type ] +// CHECK: !"_ZTS2TCIiE"} ; [ DW_TAG_pointer_type ]{{.*}}[from _ZTS2TCIiE] template<typename T> class TC { diff --git a/test/CodeGenCXX/debug-info-template-member.cpp b/test/CodeGenCXX/debug-info-template-member.cpp index c9a3d9b9177c..300b6dbaccf6 100644 --- a/test/CodeGenCXX/debug-info-template-member.cpp +++ b/test/CodeGenCXX/debug-info-template-member.cpp @@ -16,29 +16,35 @@ inline int add3(int x) { return MyClass().add<3>(x); // even though add<3> is ODR used, don't emit it since we don't codegen it } -// CHECK: [[FOO_MEM:![0-9]*]], i32 0, null, null, metadata !"_ZTS3foo"} ; [ DW_TAG_structure_type ] [foo] -// CHECK: [[FOO_MEM]] = metadata !{metadata [[FOO_FUNC:![0-9]*]]} -// CHECK: [[FOO_FUNC]] = {{.*}}, metadata !"_ZN3foo4funcEN5outerIS_E5innerE", i32 {{[0-9]*}}, metadata [[FOO_FUNC_TYPE:![0-9]*]], {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [func] -// CHECK: [[FOO_FUNC_TYPE]] = {{.*}}, metadata [[FOO_FUNC_PARAMS:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: [[FOO_FUNC_PARAMS]] = metadata !{null, metadata !{{[0-9]*}}, metadata [[OUTER_FOO_INNER:![0-9]*]]} -// CHECK: [[OUTER_FOO_INNER]] = {{.*}}, null, metadata !"[[OUTER_FOO_INNER_ID:.*]]"} ; [ DW_TAG_structure_type ] [inner] - -// CHECK: metadata [[VIRT_MEM:![0-9]*]], i32 0, metadata !"_ZTS4virtI4elemE", metadata [[VIRT_TEMP_PARAM:![0-9]*]], metadata !"_ZTS4virtI4elemE"} ; [ DW_TAG_structure_type ] [virt<elem>] {{.*}} [def] -// CHECK: [[VIRT_TEMP_PARAM]] = metadata !{metadata [[VIRT_T:![0-9]*]]} -// CHECK: [[VIRT_T]] = {{.*}}, metadata !"T", metadata !"_ZTS4elem", {{.*}} ; [ DW_TAG_template_type_parameter ] - -// CHECK: [[C:![0-9]*]] = {{.*}}, metadata [[C_MEM:![0-9]*]], i32 0, metadata !"_ZTS7MyClass", null, metadata !"_ZTS7MyClass"} ; [ DW_TAG_structure_type ] [MyClass] -// CHECK: [[C_MEM]] = metadata !{metadata [[C_VPTR:![0-9]*]], metadata [[C_ADD:![0-9]*]], metadata [[C_FUNC:![0-9]*]], metadata [[C_CTOR:![0-9]*]]} +// CHECK: [[FOO_MEM:![0-9]*]], null, null, !"_ZTS3foo"} ; [ DW_TAG_structure_type ] [foo] +// CHECK: [[FOO_MEM]] = !{[[FOO_FUNC:![0-9]*]]} +// CHECK: [[FOO_FUNC]] = !{!"0x2e\00func\00func\00_ZN3foo4funcEN5outerIS_E5innerE\00{{.*}}"{{, [^,]+, [^,]+}}, [[FOO_FUNC_TYPE:![0-9]*]], {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [func] +// CHECK: [[FOO_FUNC_TYPE]] = {{.*}}, [[FOO_FUNC_PARAMS:![0-9]*]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: [[FOO_FUNC_PARAMS]] = !{null, !{{[0-9]*}}, !"[[OUTER_FOO_INNER_ID:.*]]"} +// CHECK: !{{[0-9]*}} = {{.*}}, null, !"[[OUTER_FOO_INNER_ID]]"} ; [ DW_TAG_structure_type ] [inner] + +// CHECK: [[VIRT_MEM:![0-9]*]], !"_ZTS4virtI4elemE", [[VIRT_TEMP_PARAM:![0-9]*]], !"_ZTS4virtI4elemE"} ; [ DW_TAG_structure_type ] [virt<elem>] {{.*}} [def] +// CHECK: [[VIRT_TEMP_PARAM]] = !{[[VIRT_T:![0-9]*]]} +// CHECK: [[VIRT_T]] = !{!"0x2f\00T\000\000"{{, [^,]+}}, !"_ZTS4elem", {{.*}} ; [ DW_TAG_template_type_parameter ] + +// CHECK: [[C:![0-9]*]] = {{.*}}, [[C_MEM:![0-9]*]], !"_ZTS7MyClass", null, !"_ZTS7MyClass"} ; [ DW_TAG_structure_type ] [MyClass] +// CHECK: [[C_MEM]] = !{[[C_VPTR:![0-9]*]], [[C_FUNC:![0-9]*]]} // CHECK: [[C_VPTR]] = {{.*}} ; [ DW_TAG_member ] [_vptr$MyClass] -// CHECK: [[C_ADD]] = {{.*}} ; [ DW_TAG_subprogram ] [line 4] [add<2>] // CHECK: [[C_FUNC]] = {{.*}} ; [ DW_TAG_subprogram ] [line 7] [func] -// CHECK: [[C_CTOR]] = {{.*}} ; [ DW_TAG_subprogram ] [line 0] [MyClass] -// CHECK: [[ELEM:![0-9]*]] = {{.*}}, metadata [[ELEM_MEM:![0-9]*]], i32 0, null, null, metadata !"_ZTS4elem"} ; [ DW_TAG_structure_type ] [elem] {{.*}} [def] -// CHECK: [[ELEM_MEM]] = metadata !{metadata [[ELEM_X:![0-9]*]]} +// CHECK: [[ELEM:![0-9]*]] = {{.*}}, [[ELEM_MEM:![0-9]*]], null, null, !"_ZTS4elem"} ; [ DW_TAG_structure_type ] [elem] {{.*}} [def] +// CHECK: [[ELEM_MEM]] = !{[[ELEM_X:![0-9]*]]} // CHECK: [[ELEM_X]] = {{.*}} ; [ DW_TAG_member ] [x] {{.*}} [static] [from _ZTS4virtI4elemE] +// Check that the member function template specialization and implicit special +// members (the default ctor) refer to their class by scope, even though they +// didn't appear in the class's member list (C_MEM). This prevents the functions +// from being added to type units, while still appearing in the type +// declaration/reference in the compile unit. +// CHECK: !"_ZTS7MyClass", {{.*}} ; [ DW_TAG_subprogram ] [line 4] [add<2>] +// CHECK: !"_ZTS7MyClass", {{.*}} ; [ DW_TAG_subprogram ] [line 0] [MyClass] + template<typename T> struct outer { struct inner { @@ -59,7 +65,7 @@ inline void func() { outer<foo>::inner x; -// CHECK: metadata !"[[OUTER_FOO_INNER_ID]]", i32 {{[0-9]*}}, i32 {{[0-9]*}}, %"struct.outer<foo>::inner"* @x, {{.*}} ; [ DW_TAG_variable ] [x] +// CHECK: !"0x34\00{{.*}}", {{.*}}, !"[[OUTER_FOO_INNER_ID]]", %"struct.outer<foo>::inner"* @x, {{.*}} ; [ DW_TAG_variable ] [x] template <typename T> struct virt { diff --git a/test/CodeGenCXX/debug-info-template-partial-specialization.cpp b/test/CodeGenCXX/debug-info-template-partial-specialization.cpp index cce84af4023c..6940c0fd3503 100644 --- a/test/CodeGenCXX/debug-info-template-partial-specialization.cpp +++ b/test/CodeGenCXX/debug-info-template-partial-specialization.cpp @@ -3,7 +3,7 @@ namespace __pointer_type_imp { template <class _Tp, class _Dp, bool > struct __pointer_type1 {}; - // CHECK: metadata ![[PARAMS:[0-9]+]], metadata !"_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"} ; [ DW_TAG_structure_type ] [__pointer_type1<C, default_delete<C>, false>] [line [[@LINE+1]], size 8, align 8, offset 0] [def] [from ] + // CHECK: ![[PARAMS:[0-9]+]], !"_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"} ; [ DW_TAG_structure_type ] [__pointer_type1<C, default_delete<C>, false>] [line [[@LINE+1]], size 8, align 8, offset 0] [def] [from ] template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false> { typedef _Tp* type; @@ -14,7 +14,7 @@ struct __pointer_type2 { // Test that the bool template type parameter is emitted. // - // CHECK: ![[PARAMS]] = metadata !{metadata !{{.*}}, metadata !{{.*}}, metadata ![[FALSE:[0-9]+]]} + // CHECK: ![[PARAMS]] = !{!{{.*}}, !{{.*}}, ![[FALSE:[0-9]+]]} // CHECK: ![[FALSE]] = {{.*}} i8 0, {{.*}}} ; [ DW_TAG_template_value_parameter ] typedef typename __pointer_type_imp::__pointer_type1<_Tp, _Dp, false>::type type; }; diff --git a/test/CodeGenCXX/debug-info-template-quals.cpp b/test/CodeGenCXX/debug-info-template-quals.cpp index 740f7bfa5ce5..15c096f5f94e 100644 --- a/test/CodeGenCXX/debug-info-template-quals.cpp +++ b/test/CodeGenCXX/debug-info-template-quals.cpp @@ -16,12 +16,12 @@ void foo (const char *c) { } // CHECK: [[BS:.*]] = {{.*}} ; [ DW_TAG_structure_type ] [basic_string<char>] [line 4, size 8, align 8, offset 0] [def] [from ] -// CHECK: [[TYPE:![0-9]*]] = metadata !{i32 {{.*}}, metadata [[ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: [[ARGS]] = metadata !{metadata !{{.*}}, metadata !{{.*}}, metadata [[P:![0-9]*]], metadata [[R:.*]]} -// CHECK: [[P]] = {{.*}}, metadata [[CON:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ] -// CHECK: [[CON]] = {{.*}}, metadata [[CH:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from char] +// CHECK: [[TYPE:![0-9]*]] = !{!"0x15\00{{.*}}"{{.*}}, [[ARGS:.*]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: [[ARGS]] = !{!{{.*}}, !{{.*}}, [[P:![0-9]*]], [[R:.*]]} +// CHECK: [[P]] = {{.*}}, [[CON:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ] +// CHECK: [[CON]] = {{.*}}, [[CH:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from char] // CHECK: [[CH]] = {{.*}} ; [ DW_TAG_base_type ] [char] [line 0, size 8, align 8, offset 0, enc DW_ATE_signed_char] -// CHECK: [[R]] = {{.*}}, metadata [[CON2:![0-9]*]]} ; [ DW_TAG_reference_type ] [line 0, size 0, align 0, offset 0] [from ] -// CHECK: [[CON2]] = {{.*}}, metadata !"_ZTS12basic_stringIcE"} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _ZTS12basic_stringIcE] -// CHECK: {{.*}} metadata [[TYPE]], {{.*}}, metadata !{{[0-9]*}}, metadata !{{[0-9]*}}, i32 8} ; [ DW_TAG_subprogram ] [line 7] [def] [scope 8] [assign] +// CHECK: [[R]] = {{.*}}, [[CON2:![0-9]*]]} ; [ DW_TAG_reference_type ] [line 0, size 0, align 0, offset 0] [from ] +// CHECK: [[CON2]] = {{.*}}, !"_ZTS12basic_stringIcE"} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _ZTS12basic_stringIcE] +// CHECK: !"0x2e\00assign\00{{.*}}\008"{{, [^,]+, [^,]+}}, !8, {{.*}} ; [ DW_TAG_subprogram ] [line 7] [def] [scope 8] [assign] diff --git a/test/CodeGenCXX/debug-info-template.cpp b/test/CodeGenCXX/debug-info-template.cpp index d071830eaf67..17b945018387 100644 --- a/test/CodeGenCXX/debug-info-template.cpp +++ b/test/CodeGenCXX/debug-info-template.cpp @@ -1,92 +1,106 @@ // RUN: %clang -S -emit-llvm -target x86_64-unknown_unknown -g %s -o - -std=c++11 | FileCheck %s -// CHECK: {{.*}}, i1 false, metadata !"", i32 0, metadata !{{[0-9]]*}}, metadata [[RETAIN:![0-9]*]], {{.*}} ; [ DW_TAG_compile_unit ] -// CHECK: [[EMPTY:![0-9]*]] = metadata !{} -// CHECK: [[RETAIN]] = metadata !{metadata !{{[0-9]]*}}, metadata [[FOO:![0-9]*]], +// CHECK: !"0x11\00{{.*}}"{{, [^,]+, [^,]+}}, [[RETAIN:![0-9]*]], {{.*}} ; [ DW_TAG_compile_unit ] +// CHECK: [[EMPTY:![0-9]*]] = !{} +// CHECK: [[RETAIN]] = !{!{{[0-9]]*}}, [[FOO:![0-9]*]], -// CHECK: [[TC:![0-9]*]] = {{.*}}, metadata [[TCARGS:![0-9]*]], metadata !"{{.*}}"} ; [ DW_TAG_structure_type ] [TC<unsigned int, 2, &glb, &foo::e, &foo::f, &func, tmpl_impl, 1, 2, 3>] -// CHECK: [[TCARGS]] = metadata !{metadata [[TCARG1:![0-9]*]], metadata [[TCARG2:![0-9]*]], metadata [[TCARG3:![0-9]*]], metadata [[TCARG4:![0-9]*]], metadata [[TCARG5:![0-9]*]], metadata [[TCARG6:![0-9]*]], metadata [[TCARG7:![0-9]*]], metadata [[TCARG8:![0-9]*]]} +// CHECK: [[TC:![0-9]*]] = {{.*}}, [[TCARGS:![0-9]*]], !"{{.*}}"} ; [ DW_TAG_structure_type ] [TC<unsigned int, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>] +// CHECK: [[TCARGS]] = !{[[TCARG1:![0-9]*]], [[TCARG2:![0-9]*]], [[TCARG3:![0-9]*]], [[TCARG4:![0-9]*]], [[TCARG5:![0-9]*]], [[TCARG6:![0-9]*]], [[TCARG7:![0-9]*]]} // // We seem to be missing file/line/col info on template value parameters - // metadata supports it but it's not populated. GCC doesn't emit it either, // perhaps we should just drop it from the metadata. // -// CHECK: [[TCARG1]] = {{.*}}metadata !"T", metadata [[UINT:![0-9]*]], {{.*}} ; [ DW_TAG_template_type_parameter ] +// CHECK: [[TCARG1]] = !{!"0x2f\00T\000\000", null, [[UINT:![0-9]*]], null} ; [ DW_TAG_template_type_parameter ] // CHECK: [[UINT:![0-9]*]] = {{.*}} ; [ DW_TAG_base_type ] [unsigned int] -// CHECK: [[TCARG2]] = {{.*}}metadata !"", metadata [[UINT]], i32 2, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCARG3]] = {{.*}}metadata !"x", metadata [[INTPTR:![0-9]*]], i32* @glb, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[INTPTR]] = {{.*}}, metadata [[INT:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from int] +// CHECK: [[TCARG2]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[UINT]], i32 2, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCARG3]] = !{!"0x30\00x\00{{.*}}", {{[^,]+}}, [[CINTPTR:![0-9]*]], i32* @glb, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[CINTPTR]] = {{.*}}, [[CINT:![0-9]*]]} ; [ DW_TAG_pointer_type ] {{.*}} [from ] +// CHECK: [[CINT]] = {{.*}}, [[INT:![0-9]*]]} ; [ DW_TAG_const_type ] {{.*}} [from int] // CHECK: [[INT]] = {{.*}} ; [ DW_TAG_base_type ] [int] -// CHECK: [[TCARG4]] = {{.*}}metadata !"a", metadata [[MEMINTPTR:![0-9]*]], i64 8, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[MEMINTPTR]] = {{.*}}, metadata !"_ZTS3foo"} ; [ DW_TAG_ptr_to_member_type ] {{.*}}[from int] +// CHECK: [[TCARG4]] = !{!"0x30\00a\00{{.*}}", {{[^,]+}}, [[MEMINTPTR:![0-9]*]], i64 8, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[MEMINTPTR]] = {{.*}}, !"_ZTS3foo"} ; [ DW_TAG_ptr_to_member_type ] {{.*}}[from int] // // Currently Clang emits the pointer-to-member-function value, but LLVM doesn't // use it (GCC doesn't emit a value for pointers to member functions either - so // it's not clear what, if any, format would be acceptable to GDB) // -// CHECK: [[TCARG5]] = {{.*}}metadata !"b", metadata [[MEMFUNPTR:![0-9]*]], { i64, i64 } { i64 ptrtoint (void (%struct.foo*)* @_ZN3foo1fEv to i64), i64 0 }, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[MEMFUNPTR]] = {{.*}}, metadata [[FTYPE:![0-9]*]], metadata !"_ZTS3foo"} ; [ DW_TAG_ptr_to_member_type ] -// CHECK: [[FTYPE]] = {{.*}}, metadata [[FARGS:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: [[FARGS]] = metadata !{null, metadata [[FARG1:![0-9]*]]} +// CHECK: [[TCARG5]] = !{!"0x30\00b\00{{.*}}", {{[^,]+}}, [[MEMFUNPTR:![0-9]*]], { i64, i64 } { i64 ptrtoint (void (%struct.foo*)* @_ZN3foo1fEv to i64), i64 0 }, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[MEMFUNPTR]] = {{.*}}, [[FTYPE:![0-9]*]], !"_ZTS3foo"} ; [ DW_TAG_ptr_to_member_type ] +// CHECK: [[FTYPE]] = {{.*}}, [[FARGS:![0-9]*]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: [[FARGS]] = !{null, [[FARG1:![0-9]*]]} // CHECK: [[FARG1]] = {{.*}} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [artificial] [from _ZTS3foo] // -// CHECK: [[TCARG6]] = {{.*}}metadata !"f", metadata [[FUNPTR:![0-9]*]], void ()* @_Z4funcv, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[FUNPTR]] = {{.*}}, metadata [[FUNTYPE:![0-9]*]]} ; [ DW_TAG_pointer_type ] -// CHECK: [[FUNTYPE]] = {{.*}}, metadata [[FUNARGS:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: [[FUNARGS]] = metadata !{null} -// CHECK: [[TCARG7]] = {{.*}}metadata !"tmpl", null, metadata !"tmpl_impl", {{.*}} ; [ DW_TAG_GNU_template_template_param ] -// CHECK: [[TCARG8]] = {{.*}}metadata !"Is", null, metadata [[TCARG8_VALS:![0-9]*]], {{.*}} ; [ DW_TAG_GNU_template_parameter_pack ] -// CHECK: [[TCARG8_VALS]] = metadata !{metadata [[TCARG8_1:![0-9]*]], metadata [[TCARG8_2:![0-9]*]], metadata [[TCARG8_3:![0-9]*]]} -// CHECK: [[TCARG8_1]] = {{.*}}metadata !"", metadata [[INT]], i32 1, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCARG8_2]] = {{.*}}metadata !"", metadata [[INT]], i32 2, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCARG8_3]] = {{.*}}metadata !"", metadata [[INT]], i32 3, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCARG6]] = !{!"0x30\00f\00{{.*}}", {{[^,]+}}, [[FUNPTR:![0-9]*]], void ()* @_ZN3foo1gEv, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[FUNPTR]] = {{.*}}, [[FUNTYPE:![0-9]*]]} ; [ DW_TAG_pointer_type ] +// CHECK: [[FUNTYPE]] = {{.*}}, [[FUNARGS:![0-9]*]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: [[FUNARGS]] = !{null} +// CHECK: [[TCARG7]] = !{!"0x4107\00Is\000\000", null, null, [[TCARG7_VALS:![0-9]*]], null} ; [ DW_TAG_GNU_template_parameter_pack ] +// CHECK: [[TCARG7_VALS]] = !{[[TCARG7_1:![0-9]*]], [[TCARG7_2:![0-9]*]], [[TCARG7_3:![0-9]*]]} +// CHECK: [[TCARG7_1]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[INT]], i32 1, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCARG7_2]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[INT]], i32 2, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCARG7_3]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[INT]], i32 3, {{.*}} ; [ DW_TAG_template_value_parameter ] // // We could just emit a declaration of 'foo' here, rather than the entire // definition (same goes for any time we emit a member (function or data) // pointer type) -// CHECK: [[FOO]] = {{.*}}, metadata !"_ZTS3foo"} ; [ DW_TAG_structure_type ] [foo] -// CHECK: metadata !"f", metadata !"_ZN3foo1fEv", i32 {{[0-9]*}}, metadata [[FTYPE:![0-9]*]], +// CHECK: [[FOO]] = {{.*}}, !"_ZTS3foo"} ; [ DW_TAG_structure_type ] [foo] +// CHECK: !"0x2e\00f\00f\00_ZN3foo1fEv\00{{.*}}", [[FTYPE:![0-9]*]], {{.*}} ; [ DW_TAG_subprogram ] // - -// CHECK: metadata !{i32 {{[0-9]*}}, metadata !{{[0-9]*}}, metadata !"_ZTS2TCIjLj2EXadL_Z3glbEEXadL_ZN3foo1eEEEXadL_ZNS0_1fEvEEXadL_Z4funcvEE9tmpl_implJLi1ELi2ELi3EEE", {{.*}}, metadata !"[[TCNESTED:.*]]"} ; [ DW_TAG_structure_type ] [nested] -// CHECK: metadata [[TCNARGS:![0-9]*]], metadata !"[[TCNT:.*]]"} ; [ DW_TAG_structure_type ] [TC<int, -3, nullptr, nullptr, nullptr, nullptr, tmpl_impl>] -// CHECK: [[TCNARGS]] = metadata !{metadata [[TCNARG1:![0-9]*]], metadata [[TCNARG2:![0-9]*]], metadata [[TCNARG3:![0-9]*]], metadata [[TCNARG4:![0-9]*]], metadata [[TCNARG5:![0-9]*]], metadata [[TCNARG6:![0-9]*]], metadata [[TCARG7:![0-9]*]], metadata [[TCNARG8:![0-9]*]]} -// CHECK: [[TCNARG1]] = {{.*}}metadata !"T", metadata [[INT]], {{.*}} ; [ DW_TAG_template_type_parameter ] -// CHECK: [[TCNARG2]] = {{.*}}metadata !"", metadata [[INT]], i32 -3, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCNARG3]] = {{.*}}metadata !"x", metadata [[INTPTR]], i8 0, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: !"0x13\00{{.*}}", !{{[0-9]*}}, !"_ZTS2TCIjLj2EXadL_Z3glbEEXadL_ZN3foo1eEEEXadL_ZNS0_1fEvEEXadL_ZNS0_1gEvEEJLi1ELi2ELi3EEE", {{.*}}, !"[[TCNESTED:.*]]"} ; [ DW_TAG_structure_type ] [nested] +// CHECK: [[TCNARGS:![0-9]*]], !"[[TCNT:.*]]"} ; [ DW_TAG_structure_type ] [TC<int, -3, nullptr, nullptr, nullptr, nullptr>] +// CHECK: [[TCNARGS]] = !{[[TCNARG1:![0-9]*]], [[TCNARG2:![0-9]*]], [[TCNARG3:![0-9]*]], [[TCNARG4:![0-9]*]], [[TCNARG5:![0-9]*]], [[TCNARG6:![0-9]*]], [[TCNARG7:![0-9]*]]} +// CHECK: [[TCNARG1]] = !{!"0x2f\00T\000\000", null, [[INT]], null} ; [ DW_TAG_template_type_parameter ] +// CHECK: [[TCNARG2]] = !{!"0x30\00\000\000", null, [[INT]], i32 -3, null} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCNARG3]] = !{!"0x30\00x\000\000", null, [[CINTPTR]], i8 0, null} ; [ DW_TAG_template_value_parameter ] // The interesting null pointer: -1 for member data pointers (since they are // just an offset in an object, they can be zero and non-null for the first // member) -// CHECK: [[TCNARG4]] = {{.*}}metadata !"a", metadata [[MEMINTPTR]], i64 -1, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCNARG4]] = !{!"0x30\00a\000\000", null, [[MEMINTPTR]], i64 -1, null} ; [ DW_TAG_template_value_parameter ] // // In some future iteration we could possibly emit the value of a null member // function pointer as '{ i64, i64 } zeroinitializer' as it may be handled // naturally from the LLVM CodeGen side once we decide how to handle non-null // member function pointers. For now, it's simpler just to emit the 'i8 0'. // -// CHECK: [[TCNARG5]] = {{.*}}metadata !"b", metadata [[MEMFUNPTR]], i8 0, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCNARG6]] = {{.*}}metadata !"f", metadata [[FUNPTR]], i8 0, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[TCNARG8]] = {{.*}}metadata !"Is", null, metadata [[EMPTY]], {{.*}} ; [ DW_TAG_GNU_template_parameter_pack ] - -// CHECK: metadata [[PTOARGS:![0-9]*]], metadata !"{{.*}}"} ; [ DW_TAG_structure_type ] [PaddingAtEndTemplate<&PaddedObj>] -// CHECK: [[PTOARGS]] = metadata !{metadata [[PTOARG1:![0-9]*]]} -// CHECK: [[PTOARG1]] = {{.*}}metadata !"", metadata [[CONST_PADDINGATEND_PTR:![0-9]*]], { i32, i8, [3 x i8] }* @PaddedObj, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCNARG5]] = !{!"0x30\00b\000\000", null, [[MEMFUNPTR]], i8 0, null} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCNARG6]] = !{!"0x30\00f\000\000", null, [[FUNPTR]], i8 0, null} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[TCNARG7]] = !{!"0x4107\00Is\000\000", null, null, [[EMPTY]], null} ; [ DW_TAG_GNU_template_parameter_pack ] + +// FIXME: these parameters should probably be rendered as 'glb' rather than +// '&glb', since they're references, not pointers. +// CHECK: [[NNARGS:![0-9]*]], !"[[NNT:.*]]"} ; [ DW_TAG_structure_type ] [NN<tmpl_impl, &glb, &glb>] +// CHECK: [[NNARGS]] = !{[[NNARG1:![0-9]*]], [[NNARG2:![0-9]*]], [[NNARG3:![0-9]*]]} +// CHECK: [[NNARG1]] = !{!"0x4106\00tmpl\000\000", null, null, !"tmpl_impl", null} ; [ DW_TAG_GNU_template_template_param ] +// CHECK: [[NNARG2]] = !{!"0x30\00lvr\00{{.*}}", {{[^,]+}}, [[INTLVR:![0-9]*]], i32* @glb, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[INTLVR]] = {{.*}}, [[INT]]} ; [ DW_TAG_reference_type ] {{.*}} [from int] +// CHECK: [[NNARG3]] = !{!"0x30\00rvr\00{{.*}}", {{[^,]+}}, [[INTRVR:![0-9]*]], i32* @glb, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[INTRVR]] = {{.*}}, [[INT]]} ; [ DW_TAG_rvalue_reference_type ] {{.*}} [from int] + +// CHECK: [[PTOARGS:![0-9]*]], !"{{.*}}"} ; [ DW_TAG_structure_type ] [PaddingAtEndTemplate<&PaddedObj>] +// CHECK: [[PTOARGS]] = !{[[PTOARG1:![0-9]*]]} +// CHECK: [[PTOARG1]] = !{!"0x30\00\000\000", null, [[CONST_PADDINGATEND_PTR:![0-9]*]], %struct.PaddingAtEnd* @PaddedObj, null} ; [ DW_TAG_template_value_parameter ] // CHECK: [[CONST_PADDINGATEND_PTR]] = {{.*}} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from _ZTS12PaddingAtEnd] -// CHECK: metadata !"[[TCNESTED]]", i32 0, i32 1, %"struct.TC<unsigned int, 2, &glb, &foo::e, &foo::f, &func, tmpl_impl, 1, 2, 3>::nested"* @tci, null} ; [ DW_TAG_variable ] [tci] +// CHECK: !"[[TCNESTED]]", %"struct.TC<unsigned int, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>::nested"* @tci, null} ; [ DW_TAG_variable ] [tci] -// CHECK: metadata !"[[TCNT]]", i32 0, i32 1, %struct.TC* @tcn, null} ; [ DW_TAG_variable ] [tcn] +// CHECK: !"[[TCNT]]", %struct.TC* @tcn, null} ; [ DW_TAG_variable ] [tcn] + +// CHECK: !"[[NNT]]", %struct.NN* @nn, null} ; [ DW_TAG_variable ] [nn] struct foo { char pad[8]; // make the member pointer to 'e' a bit more interesting (nonzero) int e; void f(); + static void g(); }; -template<typename T, T, int *x, int foo::*a, void (foo::*b)(), void (*f)(), template<typename> class tmpl, int ...Is> +typedef int foo::*foo_mem; + +template<typename T, T, const int *x, foo_mem a, void (foo::*b)(), void (*f)(), int ...Is> struct TC { struct nested { }; @@ -95,12 +109,18 @@ struct TC { int glb; void func(); +TC<unsigned, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>::nested tci; +TC<int, -3, nullptr, nullptr, nullptr, nullptr> tcn; + template<typename> struct tmpl_impl { }; -TC<unsigned, 2, &glb, &foo::e, &foo::f, &func, tmpl_impl, 1, 2, 3>::nested tci; -TC<int, -3, nullptr, nullptr, nullptr, nullptr, tmpl_impl> tcn; +template <template <typename> class tmpl, int &lvr, int &&rvr> +struct NN { +}; + +NN<tmpl_impl, glb, glb> nn; struct PaddingAtEnd { int i; @@ -109,7 +129,7 @@ struct PaddingAtEnd { PaddingAtEnd PaddedObj = {}; -template <const PaddingAtEnd *> +template <PaddingAtEnd *> struct PaddingAtEndTemplate { }; diff --git a/test/CodeGenCXX/debug-info-thunk.cpp b/test/CodeGenCXX/debug-info-thunk.cpp index 1d6f1a77b49a..9f187901f7ec 100644 --- a/test/CodeGenCXX/debug-info-thunk.cpp +++ b/test/CodeGenCXX/debug-info-thunk.cpp @@ -14,4 +14,4 @@ struct C : A, B { void C::f() { } -// CHECK: metadata !"_ZThn{{4|8}}_N1C1fEv", i32 15, {{.*}} ; [ DW_TAG_subprogram ] [line 15] [def]{{$}} +// CHECK: !"0x2e\00\00\00_ZThn{{[48]}}_N1C1fEv\0015\00{{.*}}", {{.*}} ; [ DW_TAG_subprogram ] [line 15] [def]{{$}} diff --git a/test/CodeGenCXX/debug-info-union-template.cpp b/test/CodeGenCXX/debug-info-union-template.cpp index 570520d03d9e..aa66e3f9de1a 100644 --- a/test/CodeGenCXX/debug-info-union-template.cpp +++ b/test/CodeGenCXX/debug-info-union-template.cpp @@ -10,6 +10,6 @@ namespace PR15637 { Value<float> f; } -// CHECK: {{.*}}, metadata !"Value<float>", {{.*}}, null, metadata [[TTPARAM:.*]], metadata !"_ZTSN7PR156375ValueIfEE"} ; [ DW_TAG_union_type ] [Value<float>] -// CHECK: [[TTPARAM]] = metadata !{metadata [[PARAMS:.*]]} -// CHECK: [[PARAMS]] = metadata !{{{.*}}metadata !"T",{{.*}}} ; [ DW_TAG_template_type_parameter ] +// CHECK: !"0x17\00Value<float>\00{{.*}}", {{.*}}, [[TTPARAM:![0-9]+]], !"_ZTSN7PR156375ValueIfEE"} ; [ DW_TAG_union_type ] [Value<float>] +// CHECK: [[TTPARAM]] = !{[[PARAMS:.*]]} +// CHECK: [[PARAMS]] = !{!"0x2f\00T\000\000", {{.*}} ; [ DW_TAG_template_type_parameter ] diff --git a/test/CodeGenCXX/debug-info-uuid.cpp b/test/CodeGenCXX/debug-info-uuid.cpp index 6137400de07c..b7e532ba2b31 100644 --- a/test/CodeGenCXX/debug-info-uuid.cpp +++ b/test/CodeGenCXX/debug-info-uuid.cpp @@ -1,14 +1,20 @@ // RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-pc-win32 -g %s -o - -std=c++11 | FileCheck %s -// RUN: not %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -g %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM +// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -g %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM -// CHECK: metadata [[TGIARGS:![0-9]*]], null} ; [ DW_TAG_structure_type ] [tmpl_guid<&__uuidof(uuid)>] -// CHECK: [[TGIARGS]] = metadata !{metadata [[TGIARG1:![0-9]*]]} -// CHECK: [[TGIARG1]] = {{.*}}metadata !"", metadata [[CONST_GUID_PTR:![0-9]*]], { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab, {{.*}} ; [ DW_TAG_template_value_parameter ] -// CHECK: [[CONST_GUID_PTR]] = {{.*}}, metadata [[CONST_GUID:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ] -// CHECK: [[CONST_GUID]] = {{.*}}, metadata [[GUID:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _GUID] +// CHECK: [[TGIARGS:![0-9]*]], null} ; [ DW_TAG_structure_type ] [tmpl_guid<&__uuidof(uuid)>] +// CHECK: [[TGIARGS]] = !{[[TGIARG1:![0-9]*]]} +// CHECK: [[TGIARG1]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[CONST_GUID_PTR:![0-9]*]], { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[CONST_GUID_PTR]] = {{.*}}, [[CONST_GUID:![0-9]*]]} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from ] +// CHECK: [[CONST_GUID]] = {{.*}}, [[GUID:![0-9]*]]} ; [ DW_TAG_const_type ] [line 0, size 0, align 0, offset 0] [from _GUID] // CHECK: [[GUID]] = {{.*}} ; [ DW_TAG_structure_type ] [_GUID] -// CHECK-ITANIUM: error: cannot yet mangle expression type CXXUuidofExpr +// CHECK: [[TGI2ARGS:![0-9]*]], null} ; [ DW_TAG_structure_type ] [tmpl_guid2<__uuidof(uuid)>] +// CHECK: [[TGI2ARGS]] = !{[[TGI2ARG1:![0-9]*]]} +// CHECK: [[TGI2ARG1]] = !{!"0x30\00\00{{.*}}", {{[^,]+}}, [[CONST_GUID_REF:![0-9]*]], { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab, {{.*}} ; [ DW_TAG_template_value_parameter ] +// CHECK: [[CONST_GUID_REF]] = {{.*}}, [[CONST_GUID:![0-9]*]]} ; [ DW_TAG_reference_type ] [line 0, size 0, align 0, offset 0] [from ] + +// CHECK-ITANIUM: !"_ZTS9tmpl_guidIXadu8__uuidoft4uuidEE"} ; [ DW_TAG_structure_type ] [tmpl_guid<&__uuidof(uuid)>] +// CHECK-ITANIUM: !"_ZTS10tmpl_guid2IXu8__uuidoft4uuidEE"} ; [ DW_TAG_structure_type ] [tmpl_guid2<__uuidof(uuid)>] struct _GUID; template <const _GUID *> @@ -17,3 +23,7 @@ struct tmpl_guid { struct __declspec(uuid("{12345678-1234-1234-1234-1234567890ab}")) uuid; tmpl_guid<&__uuidof(uuid)> tgi; + +template <const _GUID &> +struct tmpl_guid2 {}; +tmpl_guid2<__uuidof(uuid)> tgi2; diff --git a/test/CodeGenCXX/debug-info-varargs.cpp b/test/CodeGenCXX/debug-info-varargs.cpp index cc92477dbb92..25e8f350b055 100644 --- a/test/CodeGenCXX/debug-info-varargs.cpp +++ b/test/CodeGenCXX/debug-info-varargs.cpp @@ -2,21 +2,21 @@ struct A { - // CHECK-DAG: ", i32 [[@LINE+1]], metadata ![[ATY:[0-9]+]]{{.*}}[ DW_TAG_subprogram ]{{.*}}[a] + // CHECK-DAG: !"0x2e\00a\00a\00_ZN1A1aEiz\00[[@LINE+1]]\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[ATY:[0-9]+]]{{.*}}[ DW_TAG_subprogram ]{{.*}}[a] void a(int c, ...) {} - // CHECK: ![[ATY]] ={{.*}} metadata ![[AARGS:[0-9]+]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] - // CHECK: ![[AARGS]] = {{.*}} metadata ![[UNSPEC:[0-9]+]]} - // CHECK: ![[UNSPEC]] = {{.*}} [ DW_TAG_unspecified_parameters ] + // CHECK: ![[ATY]] ={{.*}} ![[AARGS:[0-9]+]], null, null, null} ; [ DW_TAG_subroutine_type ] + // We no longer use an explicit unspecified parameter. Instead we use a trailing null to mean the function is variadic. + // CHECK: ![[AARGS]] = !{null, !{{[0-9]+}}, !{{[0-9]+}}, null} }; - // CHECK: ", i32 [[@LINE+1]], metadata ![[BTY:[0-9]+]]{{.*}}[ DW_TAG_subprogram ]{{.*}}[b] + // CHECK: !"0x2e\00b\00b\00_Z1biz\00[[@LINE+1]]\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[BTY:[0-9]+]]{{.*}}[ DW_TAG_subprogram ]{{.*}}[b] void b(int c, ...) { - // CHECK: ![[BTY]] ={{.*}} metadata ![[BARGS:[0-9]+]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ] - // CHECK: ![[BARGS]] = {{.*}} metadata ![[UNSPEC:[0-9]+]]} + // CHECK: ![[BTY]] ={{.*}} ![[BARGS:[0-9]+]], null, null, null} ; [ DW_TAG_subroutine_type ] + // CHECK: ![[BARGS]] = !{null, !{{[0-9]+}}, null} A a; - // CHECK: metadata ![[PST:[0-9]+]], i32 0, i32 0} ; [ DW_TAG_auto_variable ] [fptr] [line [[@LINE+1]]] + // CHECK: !"0x100\00fptr\00[[@LINE+1]]\000"{{, [^,]+, [^,]+}}, ![[PST:[0-9]+]]} ; [ DW_TAG_auto_variable ] [fptr] [line [[@LINE+1]]] void (*fptr)(int, ...) = b; - // CHECK: ![[PST]] ={{.*}} metadata ![[BTY]]} ; [ DW_TAG_pointer_type ] + // CHECK: ![[PST]] ={{.*}} ![[BTY]]} ; [ DW_TAG_pointer_type ] } diff --git a/test/CodeGenCXX/debug-info-wchar.cpp b/test/CodeGenCXX/debug-info-wchar.cpp index 6f5384966b99..5b5fdccce14e 100644 --- a/test/CodeGenCXX/debug-info-wchar.cpp +++ b/test/CodeGenCXX/debug-info-wchar.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -emit-llvm -g %s -o -| FileCheck %s void foo() { -// CHECK: metadata !"wchar_t", +// CHECK: !"0x24\00wchar_t\00{{.*}}", null, null} ; [ DW_TAG_base_type ] [wchar_t] const wchar_t w = L'x'; } diff --git a/test/CodeGenCXX/debug-info-windows-dtor.cpp b/test/CodeGenCXX/debug-info-windows-dtor.cpp new file mode 100644 index 000000000000..a94f2b06ee72 --- /dev/null +++ b/test/CodeGenCXX/debug-info-windows-dtor.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -triple i386-unknown-windows-msvc -std=c++11 -emit-llvm -gline-tables-only %s -o - | FileCheck %s + +struct A { + virtual ~A() {} +}; + +struct B { + virtual ~B() {} +}; + +template<typename T> +struct AB: A, B { +}; + +template struct AB<int>; + +// CHECK-LABEL: define {{.*}}@"\01??_E?$AB@H@@W3AEPAXI@Z" +// CHECK: call {{.*}}@"\01??_G?$AB@H@@UAEPAXI@Z"({{.*}}) #{{[0-9]*}}, !dbg [[THUNK_LOC:![0-9]*]] +// CHECK-LABEL: define + +// CHECK: [[THUNK_VEC_DEL_DTOR:![0-9]*]] = {{.*}} @"\01??_E?$AB@H@@W3AEPAXI@Z", {{.*}}; [ DW_TAG_subprogram ] +// CHECK: [[THUNK_LOC]] = !MDLocation(line: 15, scope: [[THUNK_VEC_DEL_DTOR]]) diff --git a/test/CodeGenCXX/debug-info-zero-length-arrays.cpp b/test/CodeGenCXX/debug-info-zero-length-arrays.cpp index 101796509da3..f1ba636729bc 100644 --- a/test/CodeGenCXX/debug-info-zero-length-arrays.cpp +++ b/test/CodeGenCXX/debug-info-zero-length-arrays.cpp @@ -6,7 +6,7 @@ class A { }; A a; -// CHECK: metadata [[ARRAY_TYPE:![0-9]*]]} ; [ DW_TAG_member ] [x] -// CHECK: metadata [[ELEM_TYPE:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_array_type ] [line 0, size 0, align 32, offset 0] [from int] -// CHECK: [[ELEM_TYPE]] = metadata !{metadata [[SUBRANGE:.*]]} -// CHECK: [[SUBRANGE]] = metadata !{i32 786465, i64 0, i64 -1} ; [ DW_TAG_subrange_type ] [unbounded] +// CHECK: [[ARRAY_TYPE:![0-9]*]]} ; [ DW_TAG_member ] [x] +// CHECK: !"0x1\00\000\000\0032\000\000\000", null, null, {{![0-9]+}}, [[ELEM_TYPE:![0-9]+]], null, null, null} ; [ DW_TAG_array_type ] [line 0, size 0, align 32, offset 0] [from int] +// CHECK: [[ELEM_TYPE]] = !{[[SUBRANGE:.*]]} +// CHECK: [[SUBRANGE]] = !{!"0x21\000\00-1"} ; [ DW_TAG_subrange_type ] [unbounded] diff --git a/test/CodeGenCXX/debug-info.cpp b/test/CodeGenCXX/debug-info.cpp index 7c89dfc04ce1..f4d1f00137d6 100644 --- a/test/CodeGenCXX/debug-info.cpp +++ b/test/CodeGenCXX/debug-info.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s +// RUN: %clang_cc1 -triple i686-pc-windows-msvc -emit-llvm -g %s -o - | FileCheck %s --check-prefix=MSVC + template<typename T> struct Identity { typedef T Type; }; @@ -43,14 +45,25 @@ namespace VirtualDtor { } namespace VirtualBase { - struct A { }; - struct B : virtual A { }; + struct A { int a; }; + struct B : virtual A { int b; }; void f() { B b; } } +// MSVC: [[VBASE_B:![0-9]+]] = distinct !{!"0x13\00B\00{{[0-9]+}}\0096\0032\000\000\000", {{.*}}, null, [[VBASE_B_DEF:![0-9]+]], {{.*}}} ; [ DW_TAG_structure_type ] [B] [line 49, size 96, align 32, offset 0] [def] [from ] +// MSVC: [[VBASE_B_DEF]] = !{[[VBASE_A_IN_B:![0-9]+]], +// +// Look for the vbtable offset of A, which should be 4. +// MSVC: [[VBASE_A_IN_B]] = !{!"0x1c\00\000\000\000\004\0032", null, [[VBASE_B]], !{{[0-9]*}}} ; [ DW_TAG_inheritance ] [line 0, size 0, align 0, offset 4] [from A] + +// CHECK: !"0x13\00B\00{{[0-9]+}}\00128\0064\000\000\000", {{.*}}, null, [[VBASE_B_DEF:![0-9]+]], {{.*}}} ; [ DW_TAG_structure_type ] [B] [line 49, size 128, align 64, offset 0] [def] [from ] +// CHECK: [[VBASE_B_DEF]] = !{[[VBASE_A_IN_B:![0-9]+]], +// +// Look for the vtable offset offset, which should be -24. +// CHECK: [[VBASE_A_IN_B]] = !{!"0x1c\00\000\000\000\0024\0032", null, !"_ZTSN11VirtualBase1BE", !"_ZTSN11VirtualBase1AE"} ; [ DW_TAG_inheritance ] [line 0, size 0, align 0, offset 24] [from _ZTSN11VirtualBase1AE] namespace b5249287 { template <typename T> class A { struct B; @@ -72,15 +85,15 @@ foo func(foo f) { return f; // reference 'f' for now because otherwise we hit another bug } -// CHECK: metadata !{i32 {{[0-9]*}}, metadata !{{[0-9]*}}, metadata [[PR14763:![0-9]*]], {{.*}}, metadata !"[[FOO:.*]]"} ; [ DW_TAG_structure_type ] [foo] +// CHECK: !"0x13\00{{.*}}", !{{[0-9]*}}, [[PR14763:![0-9]*]], {{.*}}, !"[[FOO:.*]]"} ; [ DW_TAG_structure_type ] [foo] // CHECK: [[PR14763]] = {{.*}} ; [ DW_TAG_namespace ] [pr14763] // CHECK: [[INCTYPE:![0-9]*]] = {{.*}} ; [ DW_TAG_structure_type ] [incomplete]{{.*}} [decl] -// CHECK: metadata [[A_MEM:![0-9]*]], i32 0, null, null, metadata !"_ZTSN7pr162141aE"} ; [ DW_TAG_structure_type ] [a] -// CHECK: [[A_MEM]] = metadata !{metadata [[A_I:![0-9]*]]} +// CHECK: [[A_MEM:![0-9]*]], null, null, !"_ZTSN7pr162141aE"} ; [ DW_TAG_structure_type ] [a] +// CHECK: [[A_MEM]] = !{[[A_I:![0-9]*]]} // CHECK: [[A_I]] = {{.*}} ; [ DW_TAG_member ] [i] {{.*}} [from int] // CHECK: ; [ DW_TAG_structure_type ] [b] {{.*}}[decl] -// CHECK: [[FUNC:![0-9]*]] = {{.*}} metadata !"_ZN7pr147634funcENS_3fooE", i32 {{[0-9]*}}, metadata [[FUNC_TYPE:![0-9]*]], {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] +// CHECK: [[FUNC:![0-9]*]] = !{!"0x2e\00func\00func\00_ZN7pr147634funcENS_3fooE\00{{.*}}"{{, [^,]+, [^,]+}}, [[FUNC_TYPE:![0-9]*]], {{.*}} ; [ DW_TAG_subprogram ] {{.*}} [def] [func] } void foo() { @@ -93,13 +106,13 @@ void foo() { namespace pr9608 { // also pr9600 struct incomplete; incomplete (*x)[3]; -// CHECK: metadata [[INCARRAYPTR:![0-9]*]], i32 0, i32 1, [3 x i8]** @_ZN6pr96081xE, null} ; [ DW_TAG_variable ] [x] -// CHECK: [[INCARRAYPTR]] = {{.*}}metadata [[INCARRAY:![0-9]*]]} ; [ DW_TAG_pointer_type ] -// CHECK: [[INCARRAY]] = {{.*}}metadata !"_ZTSN6pr960810incompleteE", metadata {{![0-9]*}}, i32 0, null, null, null} ; [ DW_TAG_array_type ] [line 0, size 0, align 0, offset 0] [from _ZTSN6pr960810incompleteE] +// CHECK: [[INCARRAYPTR:![0-9]*]], [3 x i8]** @_ZN6pr96081xE, null} ; [ DW_TAG_variable ] [x] +// CHECK: [[INCARRAYPTR]] = {{.*}}[[INCARRAY:![0-9]*]]} ; [ DW_TAG_pointer_type ] +// CHECK: [[INCARRAY]] = !{!"0x1\00\000\000\000\000\000\000", null, null, !"_ZTSN6pr960810incompleteE", {{![0-9]+}}, null, null, null} ; [ DW_TAG_array_type ] [line 0, size 0, align 0, offset 0] [from _ZTSN6pr960810incompleteE] } // For some reason function arguments ended up down here -// CHECK: = metadata !{i32 {{[0-9]*}}, metadata [[FUNC]], {{.*}}, metadata !"[[FOO]]", i32 8192, i32 0} ; [ DW_TAG_arg_variable ] [f] +// CHECK: = !{!"0x101\00f\00{{.*}}\008192", [[FUNC]], {{![0-9]+}}, !"[[FOO]]"} ; [ DW_TAG_arg_variable ] [f] // CHECK: ; [ DW_TAG_auto_variable ] [c] diff --git a/test/CodeGenCXX/debug-lambda-expressions.cpp b/test/CodeGenCXX/debug-lambda-expressions.cpp index 0b087360f9d5..feafcff064c8 100644 --- a/test/CodeGenCXX/debug-lambda-expressions.cpp +++ b/test/CodeGenCXX/debug-lambda-expressions.cpp @@ -30,38 +30,38 @@ int d(int x) { D y[10]; return [x,y] { return y[x].x; }(); } // CHECK: [[D_FUNC:.*]] = {{.*}} [ DW_TAG_subprogram ] [line [[D_LINE:.*]]] [def] [d] // Back to D. -- 24 -// CHECK: [[LAM_D:.*]] = {{.*}}, metadata [[D_FUNC]], {{.*}}, metadata [[LAM_D_ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[D_LINE]], -// CHECK: [[LAM_D_ARGS]] = metadata !{metadata [[CAP_D_X:.*]], metadata [[CAP_D_Y:.*]], metadata [[CON_LAM_D:.*]]} -// CHECK: [[CAP_D_X]] = {{.*}}, metadata [[LAM_D]], {{.*}} [ DW_TAG_member ] [x] [line [[D_LINE]], -// CHECK: [[CAP_D_Y]] = {{.*}}, metadata [[LAM_D]], {{.*}} [ DW_TAG_member ] [y] [line [[D_LINE]], -// CHECK: [[CON_LAM_D]] = {{.*}}, metadata [[LAM_D]], {{.*}} [ DW_TAG_subprogram ] [line [[D_LINE]]] [operator()] +// CHECK: [[LAM_D:.*]] = {{.*}}, [[D_FUNC]], {{.*}}, [[LAM_D_ARGS:.*]], null, null, null} ; [ DW_TAG_class_type ] [line [[D_LINE]], +// CHECK: [[LAM_D_ARGS]] = !{[[CAP_D_X:.*]], [[CAP_D_Y:.*]], [[CON_LAM_D:.*]]} +// CHECK: [[CAP_D_X]] = {{.*}}, [[LAM_D]], {{.*}} [ DW_TAG_member ] [x] [line [[D_LINE]], +// CHECK: [[CAP_D_Y]] = {{.*}}, [[LAM_D]], {{.*}} [ DW_TAG_member ] [y] [line [[D_LINE]], +// CHECK: [[CON_LAM_D]] = {{.*}}, [[LAM_D]], {{.*}} [ DW_TAG_subprogram ] [line [[D_LINE]]] [public] [operator()] // Back to C. -- 55 -// CHECK: [[LAM_C:.*]] = {{.*}}, metadata [[C_FUNC]], {{.*}}, metadata [[LAM_C_ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[C_LINE]], -// CHECK: [[LAM_C_ARGS]] = metadata !{metadata [[CAP_C:.*]], metadata [[CON_LAM_C:.*]]} +// CHECK: [[LAM_C:.*]] = {{.*}}, [[C_FUNC]], {{.*}}, [[LAM_C_ARGS:.*]], null, null, null} ; [ DW_TAG_class_type ] [line [[C_LINE]], +// CHECK: [[LAM_C_ARGS]] = !{[[CAP_C:.*]], [[CON_LAM_C:.*]]} // Ignoring the member type for now. -// CHECK: [[CAP_C]] = {{.*}}, metadata [[LAM_C]], {{.*}}} ; [ DW_TAG_member ] [x] [line [[C_LINE]], -// CHECK: [[CON_LAM_C]] = {{.*}}, metadata [[LAM_C]], {{.*}} [ DW_TAG_subprogram ] [line [[C_LINE]]] [operator()] +// CHECK: [[CAP_C]] = {{.*}}, [[LAM_C]], {{.*}}} ; [ DW_TAG_member ] [x] [line [[C_LINE]], +// CHECK: [[CON_LAM_C]] = {{.*}}, [[LAM_C]], {{.*}} [ DW_TAG_subprogram ] [line [[C_LINE]]] [public] [operator()] // Back to B. -- 67 -// CHECK: [[LAM_B:.*]] = {{.*}}, metadata [[B_FUNC]], {{.*}}, metadata [[LAM_B_ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[B_LINE]], -// CHECK: [[LAM_B_ARGS]] = metadata !{metadata [[CAP_B:.*]], metadata [[CON_LAM_B:.*]]} -// CHECK: [[CAP_B]] = {{.*}}, metadata [[LAM_B]], {{.*}}} ; [ DW_TAG_member ] [x] [line [[B_LINE]], -// CHECK: [[CON_LAM_B]] = {{.*}}, metadata [[LAM_B]], {{.*}} [ DW_TAG_subprogram ] [line [[B_LINE]]] [operator()] +// CHECK: [[LAM_B:.*]] = {{.*}}, [[B_FUNC]], {{.*}}, [[LAM_B_ARGS:.*]], null, null, null} ; [ DW_TAG_class_type ] [line [[B_LINE]], +// CHECK: [[LAM_B_ARGS]] = !{[[CAP_B:.*]], [[CON_LAM_B:.*]]} +// CHECK: [[CAP_B]] = {{.*}}, [[LAM_B]], {{.*}}} ; [ DW_TAG_member ] [x] [line [[B_LINE]], +// CHECK: [[CON_LAM_B]] = {{.*}}, [[LAM_B]], {{.*}} [ DW_TAG_subprogram ] [line [[B_LINE]]] [public] [operator()] // Back to A. -- 78 -// CHECK: [[LAM_A:.*]] = {{.*}}, metadata [[A_FUNC]], {{.*}}, metadata [[LAM_A_ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[A_LINE]], -// CHECK: [[LAM_A_ARGS]] = metadata !{metadata [[CON_LAM_A:.*]]} -// CHECK: [[CON_LAM_A]] = {{.*}}, metadata [[LAM_A]], {{.*}} [ DW_TAG_subprogram ] [line [[A_LINE]]] [operator()] +// CHECK: [[LAM_A:.*]] = {{.*}}, [[A_FUNC]], {{.*}}, [[LAM_A_ARGS:.*]], null, null, null} ; [ DW_TAG_class_type ] [line [[A_LINE]], +// CHECK: [[LAM_A_ARGS]] = !{[[CON_LAM_A:.*]]} +// CHECK: [[CON_LAM_A]] = {{.*}}, [[LAM_A]], {{.*}} [ DW_TAG_subprogram ] [line [[A_LINE]]] [public] [operator()] // CVAR: -// CHECK: {{.*}} metadata [[CVAR_T:![0-9]*]], {{.*}} ; [ DW_TAG_variable ] [cvar] [line [[CVAR_LINE:[0-9]*]]] -// CHECK: [[CVAR_T]] = {{.*}}, metadata ![[CVAR_ARGS:.*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[CVAR_LINE]], -// CHECK: [[CVAR_ARGS]] = metadata !{metadata !{{.*}}} +// CHECK: {{.*}} [[CVAR_T:![0-9]*]], {{.*}} ; [ DW_TAG_variable ] [cvar] [line [[CVAR_LINE:[0-9]*]]] +// CHECK: [[CVAR_T]] = {{.*}}, ![[CVAR_ARGS:.*]], null, null, null} ; [ DW_TAG_class_type ] [line [[CVAR_LINE]], +// CHECK: [[CVAR_ARGS]] = !{!{{.*}}} // VAR: -// CHECK: {{.*}} metadata [[VAR_T:![0-9]*]], {{.*}} ; [ DW_TAG_variable ] [var] [line [[VAR_LINE:[0-9]*]]] -// CHECK: [[VAR_T]] = {{.*}}, metadata [[VAR_ARGS:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_class_type ] [line [[VAR_LINE]], -// CHECK: [[VAR_ARGS]] = metadata !{metadata !{{.*}}} +// CHECK: {{.*}} [[VAR_T:![0-9]*]], {{.*}} ; [ DW_TAG_variable ] [var] [line [[VAR_LINE:[0-9]*]]] +// CHECK: [[VAR_T]] = {{.*}}, [[VAR_ARGS:![0-9]*]], null, null, null} ; [ DW_TAG_class_type ] [line [[VAR_LINE]], +// CHECK: [[VAR_ARGS]] = !{!{{.*}}} diff --git a/test/CodeGenCXX/debug-lambda-this.cpp b/test/CodeGenCXX/debug-lambda-this.cpp index e7155e76a1cc..87a317db5e16 100644 --- a/test/CodeGenCXX/debug-lambda-this.cpp +++ b/test/CodeGenCXX/debug-lambda-this.cpp @@ -12,4 +12,4 @@ int D::d(int x) { }(); } -// CHECK: {{.*}} [ DW_TAG_member ] [this] [line 11, size 64, align 64, offset 0] [private] [from ] +// CHECK: {{.*}} [ DW_TAG_member ] [this] [line 11, size 64, align 64, offset 0] [from ] diff --git a/test/CodeGenCXX/destructor-debug-info.cpp b/test/CodeGenCXX/destructor-debug-info.cpp index f2e2a39bd6b6..a8abfded2c22 100644 --- a/test/CodeGenCXX/destructor-debug-info.cpp +++ b/test/CodeGenCXX/destructor-debug-info.cpp @@ -19,4 +19,4 @@ void foo() { } } // Check there is a line number entry for line 19 where b1 is destructed. -// CHECK: i32 19, i32 0, metadata +// CHECK: !MDLocation(line: 19, diff --git a/test/CodeGenCXX/destructors.cpp b/test/CodeGenCXX/destructors.cpp index 5c430480bc28..bc9a683be5d4 100644 --- a/test/CodeGenCXX/destructors.cpp +++ b/test/CodeGenCXX/destructors.cpp @@ -1,21 +1,13 @@ -// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - -mconstructor-aliases -fcxx-exceptions -fexceptions -O1 -disable-llvm-optzns | FileCheck %s - -// CHECK-DAG: @_ZN5test01AD1Ev = alias {{.*}} @_ZN5test01AD2Ev -// CHECK-DAG: @_ZN5test11MD2Ev = alias {{.*}} @_ZN5test11AD2Ev -// CHECK-DAG: @_ZN5test11ND2Ev = alias {{.*}} @_ZN5test11AD2Ev -// CHECK-DAG: @_ZN5test11OD2Ev = alias {{.*}} @_ZN5test11AD2Ev -// CHECK-DAG: @_ZN5test11SD2Ev = alias bitcast {{.*}} @_ZN5test11AD2Ev - -// WIN32-DAG: @_ZN5test01AD1Ev = alias {{.*}} @_ZN5test01AD2Ev -// WIN32-DAG: @_ZN5test11MD2Ev = alias {{.*}} @_ZN5test11AD2Ev -// WIN32-DAG: @_ZN5test11ND2Ev = alias {{.*}} @_ZN5test11AD2Ev -// WIN32-DAG: @_ZN5test11OD2Ev = alias {{.*}} @_ZN5test11AD2Ev -// WIN32-DAG: @_ZN5test11SD2Ev = alias bitcast {{.*}} @_ZN5test11AD2Ev - +// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - -mconstructor-aliases -fcxx-exceptions -fexceptions -O1 -disable-llvm-optzns > %t +// RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s +// RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s struct A { int a; - + ~A(); }; @@ -29,7 +21,7 @@ B::~B() { } // Field with non-trivial destructor struct C { A a; - + ~C(); }; @@ -43,11 +35,11 @@ namespace PR7526 { struct allocator_derived : allocator { }; - // CHECK-LABEL: define void @_ZN6PR75263fooEv() - // CHECK: call void {{.*}} @_ZN6PR75269allocatorD2Ev + // CHECK1-LABEL: define void @_ZN6PR75263fooEv() + // CHECK1: call void {{.*}} @_ZN6PR75269allocatorD2Ev - // CHECK-LABEL: define void @_ZN6PR75269allocatorD2Ev(%"struct.PR7526::allocator"* %this) unnamed_addr - // CHECK: call void @__cxa_call_unexpected + // CHECK1-LABEL: define void @_ZN6PR75269allocatorD2Ev(%"struct.PR7526::allocator"* %this) unnamed_addr + // CHECK1: call void @__cxa_call_unexpected allocator::~allocator() throw() { foo(); } void foo() { @@ -68,12 +60,12 @@ namespace PR5529 { struct A { ~A(); }; - + A::~A() { } struct B : A { virtual ~B(); }; - + B::~B() {} } @@ -96,11 +88,12 @@ namespace test0 { // complete destructor alias tested above -// CHECK-LABEL: define void @_ZN5test01AD2Ev(%"struct.test0::A"* %this) unnamed_addr -// CHECK: invoke void @_ZN5test06MemberD1Ev -// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] -// CHECK: invoke void @_ZN5test04BaseD2Ev -// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2-LABEL: @_ZN5test01AD1Ev = alias {{.*}} @_ZN5test01AD2Ev +// CHECK2-LABEL: define void @_ZN5test01AD2Ev(%"struct.test0::A"* %this) unnamed_addr +// CHECK2: invoke void @_ZN5test06MemberD1Ev +// CHECK2: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2: invoke void @_ZN5test04BaseD2Ev +// CHECK2: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] struct B : Base, virtual VBase { Member M; @@ -109,19 +102,19 @@ namespace test0 { B::~B() try { } catch (int i) {} // It will suppress the delegation optimization here, though. -// CHECK-LABEL: define void @_ZN5test01BD2Ev(%"struct.test0::B"* %this, i8** %vtt) unnamed_addr -// CHECK: invoke void @_ZN5test06MemberD1Ev -// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] -// CHECK: invoke void @_ZN5test04BaseD2Ev -// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] - -// CHECK-LABEL: define void @_ZN5test01BD1Ev(%"struct.test0::B"* %this) unnamed_addr -// CHECK: invoke void @_ZN5test06MemberD1Ev -// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] -// CHECK: invoke void @_ZN5test04BaseD2Ev -// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] -// CHECK: invoke void @_ZN5test05VBaseD2Ev -// CHECK: unwind label [[VBASE_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2-LABEL: define void @_ZN5test01BD2Ev(%"struct.test0::B"* %this, i8** %vtt) unnamed_addr +// CHECK2: invoke void @_ZN5test06MemberD1Ev +// CHECK2: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2: invoke void @_ZN5test04BaseD2Ev +// CHECK2: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] + +// CHECK2-LABEL: define void @_ZN5test01BD1Ev(%"struct.test0::B"* %this) unnamed_addr +// CHECK2: invoke void @_ZN5test06MemberD1Ev +// CHECK2: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2: invoke void @_ZN5test04BaseD2Ev +// CHECK2: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]] +// CHECK2: invoke void @_ZN5test05VBaseD2Ev +// CHECK2: unwind label [[VBASE_UNWIND:%[a-zA-Z0-9.]+]] } // Test base-class aliasing. @@ -136,33 +129,37 @@ namespace test1 { A::~A() { delete m; } struct M : A { ~M(); }; - M::~M() {} // alias tested above + M::~M() {} + // CHECK3: @_ZN5test11MD2Ev = alias {{.*}} @_ZN5test11AD2Ev struct N : A, Empty { ~N(); }; - N::~N() {} // alias tested above + N::~N() {} + // CHECK3: @_ZN5test11ND2Ev = alias {{.*}} @_ZN5test11AD2Ev struct O : Empty, A { ~O(); }; - O::~O() {} // alias tested above + O::~O() {} + // CHECK3: @_ZN5test11OD2Ev = alias {{.*}} @_ZN5test11AD2Ev struct P : NonEmpty, A { ~P(); }; - P::~P() {} // CHECK-LABEL: define void @_ZN5test11PD2Ev(%"struct.test1::P"* %this) unnamed_addr + P::~P() {} // CHECK3-LABEL: define void @_ZN5test11PD2Ev(%"struct.test1::P"* %this) unnamed_addr struct Q : A, B { ~Q(); }; - Q::~Q() {} // CHECK-LABEL: define void @_ZN5test11QD2Ev(%"struct.test1::Q"* %this) unnamed_addr + Q::~Q() {} // CHECK3-LABEL: define void @_ZN5test11QD2Ev(%"struct.test1::Q"* %this) unnamed_addr struct R : A { ~R(); }; - R::~R() { A a; } // CHECK-LABEL: define void @_ZN5test11RD2Ev(%"struct.test1::R"* %this) unnamed_addr + R::~R() { A a; } // CHECK3-LABEL: define void @_ZN5test11RD2Ev(%"struct.test1::R"* %this) unnamed_addr struct S : A { ~S(); int x; }; - S::~S() {} // alias tested above + S::~S() {} + // CHECK4: @_ZN5test11SD2Ev = alias bitcast {{.*}} @_ZN5test11AD2Ev struct T : A { ~T(); B x; }; - T::~T() {} // CHECK-LABEL: define void @_ZN5test11TD2Ev(%"struct.test1::T"* %this) unnamed_addr + T::~T() {} // CHECK4-LABEL: define void @_ZN5test11TD2Ev(%"struct.test1::T"* %this) unnamed_addr // The VTT parameter prevents this. We could still make this work // for calling conventions that are safe against extra parameters. struct U : A, virtual B { ~U(); }; - U::~U() {} // CHECK-LABEL: define void @_ZN5test11UD2Ev(%"struct.test1::U"* %this, i8** %vtt) unnamed_addr + U::~U() {} // CHECK4-LABEL: define void @_ZN5test11UD2Ev(%"struct.test1::U"* %this, i8** %vtt) unnamed_addr } // PR6471 @@ -171,8 +168,8 @@ namespace test2 { struct B : A { ~B(); }; B::~B() {} - // CHECK-LABEL: define void @_ZN5test21BD2Ev(%"struct.test2::B"* %this) unnamed_addr - // CHECK: call void @_ZN5test21AD2Ev + // CHECK4-LABEL: define void @_ZN5test21BD2Ev(%"struct.test2::B"* %this) unnamed_addr + // CHECK4: call void @_ZN5test21AD2Ev } // PR7142 @@ -187,14 +184,63 @@ namespace test3 { void test() { new D; // Force emission of D's vtable } + + // CHECK4-LABEL: define internal void @_ZN5test312_GLOBAL__N_11DD0Ev(%"struct.test3::(anonymous namespace)::D"* %this) unnamed_addr + // CHECK4: invoke void {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev + // CHECK4: call void @_ZdlPv({{.*}}) [[NUW:#[0-9]+]] + // CHECK4: ret void + // CHECK4: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK4-NEXT: cleanup + // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] + // CHECK4: resume { i8*, i32 } + + // CHECK4-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD1Ev( + // CHECK4: getelementptr inbounds i8* {{.*}}, i64 -8 + // CHECK4: call void {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev + // CHECK4: ret void + + // CHECK4-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD0Ev( + // CHECK4: getelementptr inbounds i8* {{.*}}, i64 -8 + // CHECK4: call void @_ZN5test312_GLOBAL__N_11DD0Ev( + // CHECK4: ret void + + // CHECK4-LABEL: declare void @_ZN5test31BD2Ev( + // CHECK4-LABEL: declare void @_ZN5test31AD2Ev( + + // CHECK4-LABEL: define internal void @_ZN5test312_GLOBAL__N_11CD2Ev(%"struct.test3::(anonymous namespace)::C"* %this) unnamed_addr + // CHECK4: invoke void @_ZN5test31BD2Ev( + // CHECK4: call void @_ZN5test31AD2Ev( + // CHECK4: ret void + + + // CHECK4-LABEL: define internal void @_ZN5test312_GLOBAL__N_11CD0Ev(%"struct.test3::(anonymous namespace)::C"* %this) unnamed_addr + // CHECK4: invoke void @_ZN5test312_GLOBAL__N_11CD2Ev( + // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] + // CHECK4: ret void + // CHECK4: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) + // CHECK4-NEXT: cleanup + // CHECK4: call void @_ZdlPv({{.*}}) [[NUW]] + // CHECK4: resume { i8*, i32 } + + // CHECK4-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD1Ev( + // CHECK4: getelementptr inbounds i8* {{.*}}, i64 -8 + // CHECK4: call void @_ZN5test312_GLOBAL__N_11CD2Ev( + // CHECK4: ret void + + // CHECK4-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD0Ev( + // CHECK4: getelementptr inbounds i8* {{.*}}, i64 -8 + // CHECK4: call void @_ZN5test312_GLOBAL__N_11CD0Ev( + // CHECK4: ret void + + // CHECK4: attributes [[NUW]] = {{[{].*}} nounwind {{.*[}]}} } namespace test4 { struct A { ~A(); }; - // CHECK-LABEL: define void @_ZN5test43fooEv() - // CHECK: call void @_ZN5test41AD1Ev - // CHECK: ret void + // CHECK5-LABEL: define void @_ZN5test43fooEv() + // CHECK5: call void @_ZN5test41AD1Ev + // CHECK5: ret void void foo() { { A a; @@ -205,20 +251,20 @@ namespace test4 { return; } - // CHECK-LABEL: define void @_ZN5test43barEi( - // CHECK: [[X:%.*]] = alloca i32 - // CHECK-NEXT: [[A:%.*]] = alloca - // CHECK: br label - // CHECK: [[TMP:%.*]] = load i32* [[X]] - // CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP]], 0 - // CHECK-NEXT: br i1 - // CHECK: call void @_ZN5test41AD1Ev( - // CHECK: br label - // CHECK: [[TMP:%.*]] = load i32* [[X]] - // CHECK: [[TMP2:%.*]] = add nsw i32 [[TMP]], -1 - // CHECK: store i32 [[TMP2]], i32* [[X]] - // CHECK: br label - // CHECK: ret void + // CHECK5-LABEL: define void @_ZN5test43barEi( + // CHECK5: [[X:%.*]] = alloca i32 + // CHECK5-NEXT: [[A:%.*]] = alloca + // CHECK5: br label + // CHECK5: [[TMP:%.*]] = load i32* [[X]] + // CHECK5-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP]], 0 + // CHECK5-NEXT: br i1 + // CHECK5: call void @_ZN5test41AD1Ev( + // CHECK5: br label + // CHECK5: [[TMP:%.*]] = load i32* [[X]] + // CHECK5: [[TMP2:%.*]] = add nsw i32 [[TMP]], -1 + // CHECK5: store i32 [[TMP2]], i32* [[X]] + // CHECK5: br label + // CHECK5: ret void void bar(int x) { for (A a; x; ) { x--; @@ -230,27 +276,27 @@ namespace test4 { namespace test5 { struct A { ~A(); }; - // CHECK-LABEL: define void @_ZN5test53fooEv() - // CHECK: [[ELEMS:%.*]] = alloca [5 x [[A:%.*]]], align - // CHECK-NEXT: [[EXN:%.*]] = alloca i8* - // CHECK-NEXT: [[SEL:%.*]] = alloca i32 - // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [5 x [[A]]]* [[ELEMS]], i32 0, i32 0 - // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 5 - // CHECK-NEXT: br label - // CHECK: [[POST:%.*]] = phi [[A]]* [ [[END]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ] - // CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]]* [[POST]], i64 -1 - // CHECK-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[ELT]]) - // CHECK: [[T0:%.*]] = icmp eq [[A]]* [[ELT]], [[BEGIN]] - // CHECK-NEXT: br i1 [[T0]], - // CHECK: ret void + // CHECK5-LABEL: define void @_ZN5test53fooEv() + // CHECK5: [[ELEMS:%.*]] = alloca [5 x [[A:%.*]]], align + // CHECK5-NEXT: [[EXN:%.*]] = alloca i8* + // CHECK5-NEXT: [[SEL:%.*]] = alloca i32 + // CHECK5-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [5 x [[A]]]* [[ELEMS]], i32 0, i32 0 + // CHECK5-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 5 + // CHECK5-NEXT: br label + // CHECK5: [[POST:%.*]] = phi [[A]]* [ [[END]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ] + // CHECK5-NEXT: [[ELT]] = getelementptr inbounds [[A]]* [[POST]], i64 -1 + // CHECK5-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[ELT]]) + // CHECK5: [[T0:%.*]] = icmp eq [[A]]* [[ELT]], [[BEGIN]] + // CHECK5-NEXT: br i1 [[T0]], + // CHECK5: ret void // lpad - // CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[BEGIN]], [[ELT]] - // CHECK-NEXT: br i1 [[EMPTY]] - // CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[ELT]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ] - // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]]* [[AFTER]], i64 -1 - // CHECK-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[CUR]]) - // CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[CUR]], [[BEGIN]] - // CHECK-NEXT: br i1 [[DONE]], + // CHECK5: [[EMPTY:%.*]] = icmp eq [[A]]* [[BEGIN]], [[ELT]] + // CHECK5-NEXT: br i1 [[EMPTY]] + // CHECK5: [[AFTER:%.*]] = phi [[A]]* [ [[ELT]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ] + // CHECK5-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]]* [[AFTER]], i64 -1 + // CHECK5-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[CUR]]) + // CHECK5: [[DONE:%.*]] = icmp eq [[A]]* [[CUR]], [[BEGIN]] + // CHECK5-NEXT: br i1 [[DONE]], void foo() { A elems[5]; } @@ -269,37 +315,37 @@ namespace test6 { }; C::C() { opaque(); } - // CHECK-LABEL: define void @_ZN5test61CC1Ev(%"struct.test6::C"* %this) unnamed_addr - // CHECK: call void @_ZN5test61BILj2EEC2Ev - // CHECK: invoke void @_ZN5test61BILj3EEC2Ev - // CHECK: invoke void @_ZN5test61BILj0EEC2Ev - // CHECK: invoke void @_ZN5test61BILj1EEC2Ev - // CHECK: invoke void @_ZN5test66opaqueEv - // CHECK: ret void + // CHECK5-LABEL: define void @_ZN5test61CC1Ev(%"struct.test6::C"* %this) unnamed_addr + // CHECK5: call void @_ZN5test61BILj2EEC2Ev + // CHECK5: invoke void @_ZN5test61BILj3EEC2Ev + // CHECK5: invoke void @_ZN5test61BILj0EEC2Ev + // CHECK5: invoke void @_ZN5test61BILj1EEC2Ev + // CHECK5: invoke void @_ZN5test66opaqueEv + // CHECK5: ret void // FIXME: way too much EH cleanup code follows C::~C() { opaque(); } - // CHECK-LABEL: define void @_ZN5test61CD2Ev(%"struct.test6::C"* %this, i8** %vtt) unnamed_addr - // CHECK: invoke void @_ZN5test66opaqueEv - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61BILj1EED2Ev - // CHECK: call void @_ZN5test61BILj0EED2Ev - // CHECK: ret void - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61AD1Ev - // CHECK: invoke void @_ZN5test61BILj1EED2Ev - // CHECK: invoke void @_ZN5test61BILj0EED2Ev - - // CHECK-LABEL: define void @_ZN5test61CD1Ev(%"struct.test6::C"* %this) unnamed_addr - // CHECK: invoke void @_ZN5test61CD2Ev - // CHECK: invoke void @_ZN5test61BILj3EED2Ev - // CHECK: call void @_ZN5test61BILj2EED2Ev - // CHECK: ret void - // CHECK: invoke void @_ZN5test61BILj3EED2Ev - // CHECK: invoke void @_ZN5test61BILj2EED2Ev + // CHECK5-LABEL: define void @_ZN5test61CD2Ev(%"struct.test6::C"* %this, i8** %vtt) unnamed_addr + // CHECK5: invoke void @_ZN5test66opaqueEv + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61BILj1EED2Ev + // CHECK5: call void @_ZN5test61BILj0EED2Ev + // CHECK5: ret void + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61AD1Ev + // CHECK5: invoke void @_ZN5test61BILj1EED2Ev + // CHECK5: invoke void @_ZN5test61BILj0EED2Ev + + // CHECK5-LABEL: define void @_ZN5test61CD1Ev(%"struct.test6::C"* %this) unnamed_addr + // CHECK5: invoke void @_ZN5test61CD2Ev + // CHECK5: invoke void @_ZN5test61BILj3EED2Ev + // CHECK5: call void @_ZN5test61BILj2EED2Ev + // CHECK5: ret void + // CHECK5: invoke void @_ZN5test61BILj3EED2Ev + // CHECK5: invoke void @_ZN5test61BILj2EED2Ev } // PR 9197 @@ -315,9 +361,9 @@ namespace test7 { }; // Verify that this doesn't get emitted as an alias - // CHECK-LABEL: define void @_ZN5test71BD2Ev( - // CHECK: invoke void @_ZN5test71DD1Ev( - // CHECK: call void @_ZN5test71AD2Ev( + // CHECK5-LABEL: define void @_ZN5test71BD2Ev( + // CHECK5: invoke void @_ZN5test71DD1Ev( + // CHECK5: call void @_ZN5test71AD2Ev( B::~B() {} } @@ -335,16 +381,16 @@ namespace test8 { l: die(); } - // CHECK-LABEL: define void @_ZN5test84testEv() - // CHECK: [[X:%.*]] = alloca [[A:%.*]], align 1 - // CHECK-NEXT: [[Y:%.*]] = alloca [[A:%.*]], align 1 - // CHECK: call void @_ZN5test81AC1Ev([[A]]* [[X]]) - // CHECK-NEXT: br label - // CHECK: invoke void @_ZN5test81AC1Ev([[A]]* [[Y]]) - // CHECK: invoke void @_ZN5test81AD1Ev([[A]]* [[Y]]) - // CHECK-NOT: switch - // CHECK: invoke void @_ZN5test83dieEv() - // CHECK: unreachable + // CHECK5-LABEL: define void @_ZN5test84testEv() + // CHECK5: [[X:%.*]] = alloca [[A:%.*]], align 1 + // CHECK5-NEXT: [[Y:%.*]] = alloca [[A:%.*]], align 1 + // CHECK5: call void @_ZN5test81AC1Ev([[A]]* [[X]]) + // CHECK5-NEXT: br label + // CHECK5: invoke void @_ZN5test81AC1Ev([[A]]* [[Y]]) + // CHECK5: invoke void @_ZN5test81AD1Ev([[A]]* [[Y]]) + // CHECK5-NOT: switch + // CHECK5: invoke void @_ZN5test83dieEv() + // CHECK5: unreachable } // PR12710 @@ -359,8 +405,8 @@ namespace test9 { f1<int>(); f2(); } - // CHECK: call void @_ZN5test97ArgTypeD1Ev(%"struct.test9::ArgType"* % - // CHECK: call void @_ZN5test92f2Ev() + // CHECK5: call void @_ZN5test97ArgTypeD1Ev(%"struct.test9::ArgType"* % + // CHECK5: call void @_ZN5test92f2Ev() } namespace test10 { @@ -371,60 +417,10 @@ namespace test10 { }; template <class DataType> class opt : public Option {}; template class opt<int>; - // CHECK-LABEL: define zeroext i1 @_ZN6test1016handleOccurrenceEv( + // CHECK5-LABEL: define zeroext i1 @_ZN6test1016handleOccurrenceEv( bool handleOccurrence() { - // CHECK: call void @_ZN6test106OptionD2Ev( + // CHECK5: call void @_ZN6test106OptionD2Ev( Option x; return true; } } - -// Checks from test3: - - // CHECK-LABEL: define internal void @_ZN5test312_GLOBAL__N_11DD0Ev(%"struct.test3::(anonymous namespace)::D"* %this) unnamed_addr - // CHECK: invoke void {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev - // CHECK: call void @_ZdlPv({{.*}}) [[NUW:#[0-9]+]] - // CHECK: ret void - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) - // CHECK-NEXT: cleanup - // CHECK: call void @_ZdlPv({{.*}}) [[NUW]] - // CHECK: resume { i8*, i32 } - - // CHECK-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD1Ev( - // CHECK: getelementptr inbounds i8* {{.*}}, i64 -8 - // CHECK: call void {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev - // CHECK: ret void - - // CHECK-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD0Ev( - // CHECK: getelementptr inbounds i8* {{.*}}, i64 -8 - // CHECK: call void @_ZN5test312_GLOBAL__N_11DD0Ev( - // CHECK: ret void - - // CHECK-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD1Ev( - // CHECK: getelementptr inbounds i8* {{.*}}, i64 -8 - // CHECK: call void @_ZN5test312_GLOBAL__N_11CD2Ev( - // CHECK: ret void - - // CHECK-LABEL: define internal void @_ZN5test312_GLOBAL__N_11CD2Ev(%"struct.test3::(anonymous namespace)::C"* %this) unnamed_addr - // CHECK: invoke void @_ZN5test31BD2Ev( - // CHECK: call void @_ZN5test31AD2Ev( - // CHECK: ret void - - // CHECK: declare void @_ZN5test31BD2Ev( - // CHECK: declare void @_ZN5test31AD2Ev( - - // CHECK-LABEL: define internal void @_ZN5test312_GLOBAL__N_11CD0Ev(%"struct.test3::(anonymous namespace)::C"* %this) unnamed_addr - // CHECK: invoke void @_ZN5test312_GLOBAL__N_11CD2Ev( - // CHECK: call void @_ZdlPv({{.*}}) [[NUW]] - // CHECK: ret void - // CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) - // CHECK-NEXT: cleanup - // CHECK: call void @_ZdlPv({{.*}}) [[NUW]] - // CHECK: resume { i8*, i32 } - - // CHECK-LABEL: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD0Ev( - // CHECK: getelementptr inbounds i8* {{.*}}, i64 -8 - // CHECK: call void @_ZN5test312_GLOBAL__N_11CD0Ev( - // CHECK: ret void - - // CHECK: attributes [[NUW]] = {{[{].*}} nounwind {{.*[}]}} diff --git a/test/CodeGenCXX/devirtualize-virtual-function-calls-final.cpp b/test/CodeGenCXX/devirtualize-virtual-function-calls-final.cpp index 11026e8df3e7..193ee5f80406 100644 --- a/test/CodeGenCXX/devirtualize-virtual-function-calls-final.cpp +++ b/test/CodeGenCXX/devirtualize-virtual-function-calls-final.cpp @@ -53,26 +53,32 @@ namespace Test3 { namespace Test4 { struct A { virtual void f(); + virtual int operator-(); }; struct B final : A { virtual void f(); + virtual int operator-(); }; // CHECK-LABEL: define void @_ZN5Test41fEPNS_1BE void f(B* d) { // CHECK: call void @_ZN5Test41B1fEv static_cast<A*>(d)->f(); + // CHECK: call i32 @_ZN5Test41BngEv + -static_cast<A&>(*d); } } namespace Test5 { struct A { virtual void f(); + virtual int operator-(); }; struct B : A { virtual void f(); + virtual int operator-(); }; struct C final : B { @@ -87,6 +93,15 @@ namespace Test5 { // CHECK-NEXT: call void %[[FUNC]] static_cast<A*>(d)->f(); } + // CHECK-LABEL: define void @_ZN5Test53fopEPNS_1CE + void fop(C* d) { + // FIXME: It should be possible to devirtualize this case, but that is + // not implemented yet. + // CHECK: getelementptr + // CHECK-NEXT: %[[FUNC:.*]] = load + // CHECK-NEXT: call i32 %[[FUNC]] + -static_cast<A&>(*d); + } } namespace Test6 { @@ -165,6 +180,9 @@ namespace Test9 { virtual A *f() { return 0; } + virtual A *operator-() { + return 0; + } }; struct RC final : public RA { virtual C *f() { @@ -173,15 +191,37 @@ namespace Test9 { x->b = 2; return x; } + virtual C *operator-() { + C *x = new C(); + x->a = 1; + x->b = 2; + return x; + } }; // CHECK: define {{.*}} @_ZN5Test91fEPNS_2RCE A *f(RC *x) { // FIXME: It should be possible to devirtualize this case, but that is // not implemented yet. - // CHECK: getelementptr - // CHECK-NEXT: %[[FUNC:.*]] = load - // CHECK-NEXT: bitcast + // CHECK: load + // CHECK: bitcast + // CHECK: [[F_PTR_RA:%.+]] = bitcast + // CHECK: [[VTABLE:%.+]] = load {{.+}} [[F_PTR_RA]] + // CHECK: [[VFN:%.+]] = getelementptr inbounds {{.+}} [[VTABLE]], i{{[0-9]+}} 0 + // CHECK-NEXT: %[[FUNC:.*]] = load {{.+}} [[VFN]] // CHECK-NEXT: = call {{.*}} %[[FUNC]] return static_cast<RA*>(x)->f(); } + // CHECK: define {{.*}} @_ZN5Test93fopEPNS_2RCE + A *fop(RC *x) { + // FIXME: It should be possible to devirtualize this case, but that is + // not implemented yet. + // CHECK: load + // CHECK: bitcast + // CHECK: [[F_PTR_RA:%.+]] = bitcast + // CHECK: [[VTABLE:%.+]] = load {{.+}} [[F_PTR_RA]] + // CHECK: [[VFN:%.+]] = getelementptr inbounds {{.+}} [[VTABLE]], i{{[0-9]+}} 1 + // CHECK-NEXT: %[[FUNC:.*]] = load {{.+}} [[VFN]] + // CHECK-NEXT: = call {{.*}} %[[FUNC]] + return -static_cast<RA&>(*x); + } } diff --git a/test/CodeGenCXX/dllexport-alias.cpp b/test/CodeGenCXX/dllexport-alias.cpp new file mode 100644 index 000000000000..479595d05751 --- /dev/null +++ b/test/CodeGenCXX/dllexport-alias.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple x86_64-windows-gnu -mconstructor-aliases %s -S -emit-llvm -o - | FileCheck %s + +// This test assumes that the C1 constructor will be aliased to the C2 +// constructor, and the D1 destructor to the D2. It then checks that the aliases +// are dllexport'ed. + +class __declspec(dllexport) A { +public: + A(); + ~A(); +}; + +A::A() {} + +A::~A() {} + +// CHECK: @_ZN1AC1Ev = dllexport alias void (%class.A*)* @_ZN1AC2Ev +// CHECK: @_ZN1AD1Ev = dllexport alias void (%class.A*)* @_ZN1AD2Ev diff --git a/test/CodeGenCXX/dllexport-members.cpp b/test/CodeGenCXX/dllexport-members.cpp index d913c09ec7be..5b2af1e04bd7 100644 --- a/test/CodeGenCXX/dllexport-members.cpp +++ b/test/CodeGenCXX/dllexport-members.cpp @@ -110,9 +110,9 @@ public: // MSC-DAG: @"\01?StaticField@ExportMembers@@2HA" = dllexport global i32 1, align 4 // MSC-DAG: @"\01?StaticConstField@ExportMembers@@2HB" = dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?StaticConstFieldEqualInit@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?StaticConstFieldBraceInit@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?ConstexprField@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 + // MSC-DAG: @"\01?StaticConstFieldEqualInit@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 + // MSC-DAG: @"\01?StaticConstFieldBraceInit@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 + // MSC-DAG: @"\01?ConstexprField@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 // GNU-DAG: @_ZN13ExportMembers11StaticFieldE = dllexport global i32 1, align 4 // GNU-DAG: @_ZN13ExportMembers16StaticConstFieldE = dllexport constant i32 1, align 4 // GNU-DAG: @_ZN13ExportMembers25StaticConstFieldEqualInitE = dllexport constant i32 1, align 4 @@ -233,9 +233,9 @@ public: // MSC-DAG: @"\01?StaticField@Nested@ExportMembers@@2HA" = dllexport global i32 1, align 4 // MSC-DAG: @"\01?StaticConstField@Nested@ExportMembers@@2HB" = dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?StaticConstFieldEqualInit@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?StaticConstFieldBraceInit@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 - // MSC-DAG: @"\01?ConstexprField@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, align 4 + // MSC-DAG: @"\01?StaticConstFieldEqualInit@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 + // MSC-DAG: @"\01?StaticConstFieldBraceInit@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 + // MSC-DAG: @"\01?ConstexprField@Nested@ExportMembers@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 // GNU-DAG: @_ZN13ExportMembers6Nested11StaticFieldE = dllexport global i32 1, align 4 // GNU-DAG: @_ZN13ExportMembers6Nested16StaticConstFieldE = dllexport constant i32 1, align 4 // GNU-DAG: @_ZN13ExportMembers6Nested25StaticConstFieldEqualInitE = dllexport constant i32 1, align 4 @@ -599,21 +599,21 @@ template<typename T> const int MemVarTmpl::StaticVar; template<typename T> const int MemVarTmpl::ExportedStaticVar; // Export implicit instantiation of an exported member variable template. -// MSC-DAG: @"\01??$ExportedStaticVar@UImplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, align 4 -// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ImplicitInst_ExportedEE = weak_odr dllexport constant i32 1, align 4 +// MSC-DAG: @"\01??$ExportedStaticVar@UImplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 +// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ImplicitInst_ExportedEE = weak_odr dllexport constant i32 1, comdat, align 4 int useMemVarTmpl() { return MemVarTmpl::ExportedStaticVar<ImplicitInst_Exported>; } // Export explicit instantiation declaration of an exported member variable // template. -// MSC-DAG: @"\01??$ExportedStaticVar@UExplicitDecl_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, align 4 -// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ExplicitDecl_ExportedEE = weak_odr dllexport constant i32 1, align 4 +// MSC-DAG: @"\01??$ExportedStaticVar@UExplicitDecl_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 +// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ExplicitDecl_ExportedEE = weak_odr dllexport constant i32 1, comdat, align 4 extern template const int MemVarTmpl::ExportedStaticVar<ExplicitDecl_Exported>; template const int MemVarTmpl::ExportedStaticVar<ExplicitDecl_Exported>; // Export explicit instantiation definition of an exported member variable // template. -// MSC-DAG: @"\01??$ExportedStaticVar@UExplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, align 4 -// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ExplicitInst_ExportedEE = weak_odr dllexport constant i32 1, align 4 +// MSC-DAG: @"\01??$ExportedStaticVar@UExplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 +// GNU-DAG: @_ZN10MemVarTmpl17ExportedStaticVarI21ExplicitInst_ExportedEE = weak_odr dllexport constant i32 1, comdat, align 4 template const int MemVarTmpl::ExportedStaticVar<ExplicitInst_Exported>; // Export specialization of an exported member variable template. @@ -630,15 +630,15 @@ template<> const int MemVarTmpl::ExportedStaticVar<ExplicitSpec_NotExported> = 1 // Export explicit instantiation declaration of a non-exported member variable // template. -// MSC-DAG: @"\01??$StaticVar@UExplicitDecl_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, align 4 -// GNU-DAG: @_ZN10MemVarTmpl9StaticVarI21ExplicitDecl_ExportedEE = weak_odr dllexport constant i32 1, align 4 +// MSC-DAG: @"\01??$StaticVar@UExplicitDecl_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 +// GNU-DAG: @_ZN10MemVarTmpl9StaticVarI21ExplicitDecl_ExportedEE = weak_odr dllexport constant i32 1, comdat, align 4 extern template __declspec(dllexport) const int MemVarTmpl::StaticVar<ExplicitDecl_Exported>; template __declspec(dllexport) const int MemVarTmpl::StaticVar<ExplicitDecl_Exported>; // Export explicit instantiation definition of a non-exported member variable // template. -// MSC-DAG: @"\01??$StaticVar@UExplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, align 4 -// GNU-DAG: @_ZN10MemVarTmpl9StaticVarI21ExplicitInst_ExportedEE = weak_odr dllexport constant i32 1, align 4 +// MSC-DAG: @"\01??$StaticVar@UExplicitInst_Exported@@@MemVarTmpl@@2HB" = weak_odr dllexport constant i32 1, comdat, align 4 +// GNU-DAG: @_ZN10MemVarTmpl9StaticVarI21ExplicitInst_ExportedEE = weak_odr dllexport constant i32 1, comdat, align 4 template __declspec(dllexport) const int MemVarTmpl::StaticVar<ExplicitInst_Exported>; // Export specialization of a non-exported member variable template. diff --git a/test/CodeGenCXX/dllexport.cpp b/test/CodeGenCXX/dllexport.cpp index 5097abf0c094..93bd1f5fe99c 100644 --- a/test/CodeGenCXX/dllexport.cpp +++ b/test/CodeGenCXX/dllexport.cpp @@ -1,9 +1,7 @@ -// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=MSC --check-prefix=M32 %s -// RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=MSC --check-prefix=M64 %s -// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=GNU --check-prefix=G32 %s -// RUN: %clang_cc1 -triple x86_64-windows-gnu -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=GNU --check-prefix=G64 %s - -// RUN: %clang_cc1 -triple i686-pc-win32 -O1 -mconstructor-aliases -std=c++1y -emit-llvm -o - %s | FileCheck %s --check-prefix=MSC --check-prefix=M32 +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++1y -O1 -mconstructor-aliases -disable-llvm-optzns -o - %s -w | FileCheck --check-prefix=MSC --check-prefix=M32 %s +// RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=MSC --check-prefix=M64 %s +// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=GNU --check-prefix=G32 %s +// RUN: %clang_cc1 -triple x86_64-windows-gnu -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=GNU --check-prefix=G64 %s // Helper structs to make templates more expressive. struct ImplicitInst_Exported {}; @@ -77,8 +75,8 @@ namespace ns { __declspec(dllexport) int ExternalGlobal; } __declspec(dllexport) auto ExternalAutoTypeGlobal = External(); int f(); -// MSC-DAG: @"\01?x@?0??nonInlineStaticLocalsFunc@@YAHXZ@4HA" = internal {{(unnamed_addr )*}}global i32 0 -// MSC-DAG: @"\01?$S1@?0??nonInlineStaticLocalsFunc@@YAHXZ@4IA" = internal {{(unnamed_addr )*}}global i32 0 +// MSC-DAG: @"\01?x@?1??nonInlineStaticLocalsFunc@@YAHXZ@4HA" = internal {{(unnamed_addr )*}}global i32 0 +// MSC-DAG: @"\01?$S1@?1??nonInlineStaticLocalsFunc@@YAHXZ@4IA" = internal {{(unnamed_addr )*}}global i32 0 int __declspec(dllexport) nonInlineStaticLocalsFunc() { static int x = f(); return x++; @@ -112,43 +110,43 @@ template<typename T> __declspec(dllexport) int VarTmplImplicitDef; USEVAR(VarTmplImplicitDef<ImplicitInst_Exported>) // Export definition. -// MSC-DAG: @"\01??$VarTmplInit1@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z12VarTmplInit1I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmplInit1@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z12VarTmplInit1I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template<typename T> __declspec(dllexport) int VarTmplInit1 = 1; INSTVAR(VarTmplInit1<ExplicitInst_Exported>) -// MSC-DAG: @"\01??$VarTmplInit2@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z12VarTmplInit2I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmplInit2@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z12VarTmplInit2I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template<typename T> int __declspec(dllexport) VarTmplInit2 = 1; INSTVAR(VarTmplInit2<ExplicitInst_Exported>) // Declare, then export definition. -// MSC-DAG: @"\01??$VarTmplDeclInit@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z15VarTmplDeclInitI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmplDeclInit@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z15VarTmplDeclInitI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template<typename T> __declspec(dllexport) extern int VarTmplDeclInit; template<typename T> int VarTmplDeclInit = 1; INSTVAR(VarTmplDeclInit<ExplicitInst_Exported>) // Redeclarations -// MSC-DAG: @"\01??$VarTmplRedecl1@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z14VarTmplRedecl1I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmplRedecl1@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z14VarTmplRedecl1I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template<typename T> __declspec(dllexport) extern int VarTmplRedecl1; template<typename T> __declspec(dllexport) int VarTmplRedecl1 = 1; INSTVAR(VarTmplRedecl1<ExplicitInst_Exported>) -// MSC-DAG: @"\01??$VarTmplRedecl2@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z14VarTmplRedecl2I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmplRedecl2@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z14VarTmplRedecl2I21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template<typename T> __declspec(dllexport) extern int VarTmplRedecl2; template<typename T> int VarTmplRedecl2 = 1; INSTVAR(VarTmplRedecl2<ExplicitInst_Exported>) -// MSC-DAG: @"\01??$ExternalVarTmpl@UExplicitInst_Exported@@@ns@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_ZN2ns15ExternalVarTmplI21ExplicitInst_ExportedEE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$ExternalVarTmpl@UExplicitInst_Exported@@@ns@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_ZN2ns15ExternalVarTmplI21ExplicitInst_ExportedEE = weak_odr dllexport global i32 1, comdat, align 4 namespace ns { template<typename T> __declspec(dllexport) int ExternalVarTmpl = 1; } INSTVAR(ns::ExternalVarTmpl<ExplicitInst_Exported>) -// MSC-DAG: @"\01??$ExternalAutoTypeVarTmpl@UExplicitInst_Exported@@@@3UExternal@@A" = weak_odr dllexport global %struct.External zeroinitializer, align 4 -// GNU-DAG: @_Z23ExternalAutoTypeVarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global %struct.External zeroinitializer, align 4 +// MSC-DAG: @"\01??$ExternalAutoTypeVarTmpl@UExplicitInst_Exported@@@@3UExternal@@A" = weak_odr dllexport global %struct.External zeroinitializer, comdat, align 4 +// GNU-DAG: @_Z23ExternalAutoTypeVarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global %struct.External zeroinitializer, comdat, align 4 template<typename T> __declspec(dllexport) auto ExternalAutoTypeVarTmpl = External(); template External ExternalAutoTypeVarTmpl<ExplicitInst_Exported>; @@ -157,19 +155,19 @@ template<typename T> int VarTmpl = 1; template<typename T> __declspec(dllexport) int ExportedVarTmpl = 1; // Export implicit instantiation of an exported variable template. -// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z15ExportedVarTmplI21ImplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z15ExportedVarTmplI21ImplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 USEVAR(ExportedVarTmpl<ImplicitInst_Exported>) // Export explicit instantiation declaration of an exported variable template. -// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z15ExportedVarTmplI21ExplicitDecl_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z15ExportedVarTmplI21ExplicitDecl_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 extern template int ExportedVarTmpl<ExplicitDecl_Exported>; template int ExportedVarTmpl<ExplicitDecl_Exported>; // Export explicit instantiation definition of an exported variable template. -// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z15ExportedVarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$ExportedVarTmpl@UImplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z15ExportedVarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template __declspec(dllexport) int ExportedVarTmpl<ExplicitInst_Exported>; // Export specialization of an exported variable template. @@ -189,14 +187,14 @@ template<> int ExportedVarTmpl<ExplicitSpec_NotExported>; // Export explicit instantiation declaration of a non-exported variable template. -// MSC-DAG: @"\01??$VarTmpl@UExplicitDecl_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z7VarTmplI21ExplicitDecl_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmpl@UExplicitDecl_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z7VarTmplI21ExplicitDecl_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 extern template __declspec(dllexport) int VarTmpl<ExplicitDecl_Exported>; template __declspec(dllexport) int VarTmpl<ExplicitDecl_Exported>; // Export explicit instantiation definition of a non-exported variable template. -// MSC-DAG: @"\01??$VarTmpl@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, align 4 -// GNU-DAG: @_Z7VarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, align 4 +// MSC-DAG: @"\01??$VarTmpl@UExplicitInst_Exported@@@@3HA" = weak_odr dllexport global i32 1, comdat, align 4 +// GNU-DAG: @_Z7VarTmplI21ExplicitInst_ExportedE = weak_odr dllexport global i32 1, comdat, align 4 template __declspec(dllexport) int VarTmpl<ExplicitInst_Exported>; // Export specialization of a non-exported variable template. @@ -509,11 +507,9 @@ USEVAR(T::b) int T::c; template <typename T> struct __declspec(dllexport) U { void foo() {} }; -// The U<int> specialization below must cause the following to be emitted: -// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?foo@?$U@H@@QAEXXZ" -// M32-DAG: define weak_odr dllexport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.U* @"\01??4?$U@H@@QAEAAU0@ABU0@@Z" struct __declspec(dllexport) V : public U<int> { }; - +// U<int>'s assignment operator is emitted. +// M32-DAG: define weak_odr dllexport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.U* @"\01??4?$U@H@@QAEAAU0@ABU0@@Z" struct __declspec(dllexport) W { virtual void foo() {} }; // Default ctor: @@ -521,7 +517,7 @@ struct __declspec(dllexport) W { virtual void foo() {} }; // Copy ctor: // M32-DAG: define weak_odr dllexport x86_thiscallcc %struct.W* @"\01??0W@@QAE@ABU0@@Z" // vftable: -// M32-DAG: [[W_VTABLE:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast (%rtti.CompleteObjectLocator* @"\01??_R4W@@6B@" to i8*), i8* bitcast (void (%struct.W*)* @"\01?foo@W@@UAEXXZ" to i8*)], comdat $"\01??_7W@@6B@" +// M32-DAG: [[W_VTABLE:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast (%rtti.CompleteObjectLocator* @"\01??_R4W@@6B@" to i8*), i8* bitcast (void (%struct.W*)* @"\01?foo@W@@UAEXXZ" to i8*)], comdat($"\01??_7W@@6B@") // M32-DAG: @"\01??_7W@@6B@" = dllexport unnamed_addr alias getelementptr inbounds ([2 x i8*]* [[W_VTABLE]], i32 0, i32 1) // G32-DAG: @_ZTV1W = weak_odr dllexport unnamed_addr constant [3 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1W to i8*), i8* bitcast (void (%struct.W*)* @_ZN1W3fooEv to i8*)] @@ -538,19 +534,20 @@ struct __declspec(dllexport) Y { struct __declspec(dllexport) Z { virtual ~Z() {} }; // The scalar deleting dtor does not get exported: -// M32-DAG: define linkonce_odr x86_thiscallcc void @"\01??_GZ@@UAEPAXI@Z" +// M32-DAG: define linkonce_odr x86_thiscallcc i8* @"\01??_GZ@@UAEPAXI@Z" // The user-defined dtor does get exported: // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01??1Z@@UAE@XZ" -namespace DontUseDtorAlias { +namespace UseDtorAlias { struct __declspec(dllexport) A { ~A(); }; struct __declspec(dllexport) B : A { ~B(); }; A::~A() { } B::~B() { } - // Emit a real definition of B's constructor; don't alias it to A's. - // M32-DAG: define dllexport x86_thiscallcc void @"\01??1B@DontUseDtorAlias@@QAE@XZ" + // Emit a alias definition of B's constructor. + // M32-DAG: @"\01??1B@UseDtorAlias@@QAE@XZ" = dllexport alias {{.*}} @"\01??1A@UseDtorAlias@@QAE@XZ" + } struct __declspec(dllexport) DefaultedCtorsDtors { @@ -581,106 +578,155 @@ USEMEMFUNC(PartiallySpecializedClassTemplate<void*>, f); // M32-DAG: define linkonce_odr x86_thiscallcc void @"\01?f@?$PartiallySpecializedClassTemplate@PAX@@QAEXXZ" // G32-DAG: define weak_odr dllexport x86_thiscallcc void @_ZN33PartiallySpecializedClassTemplateIPvE1fEv +// Attributes on explicit specializations are honored. template <typename T> struct ExplicitlySpecializedClassTemplate {}; template <> struct __declspec(dllexport) ExplicitlySpecializedClassTemplate<void*> { void f() {} }; USEMEMFUNC(ExplicitlySpecializedClassTemplate<void*>, f); // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$ExplicitlySpecializedClassTemplate@PAX@@QAEXXZ" // G32-DAG: define weak_odr dllexport x86_thiscallcc void @_ZN34ExplicitlySpecializedClassTemplateIPvE1fEv +// MS inherits DLL attributes to partial specializations. +template <typename T> struct __declspec(dllexport) PartiallySpecializedExportedClassTemplate {}; +template <typename T> struct PartiallySpecializedExportedClassTemplate<T*> { void f() {} }; +USEMEMFUNC(PartiallySpecializedExportedClassTemplate<void*>, f); +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$PartiallySpecializedExportedClassTemplate@PAX@@QAEXXZ" +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN41PartiallySpecializedExportedClassTemplateIPvE1fEv + +// MS ignores DLL attributes on partial specializations; inheritance still works though. +template <typename T> struct __declspec(dllexport) PartiallySpecializedExportedClassTemplate2 {}; +template <typename T> struct __declspec(dllimport) PartiallySpecializedExportedClassTemplate2<T*> { void f(); }; +template <typename T> void PartiallySpecializedExportedClassTemplate2<T*>::f() {} +USEMEMFUNC(PartiallySpecializedExportedClassTemplate2<void*>, f); +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$PartiallySpecializedExportedClassTemplate2@PAX@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN42PartiallySpecializedExportedClassTemplate2IPvE1fEv + +// Attributes on the instantiation take precedence over attributes on the template. +template <typename T> struct __declspec(dllimport) ExplicitlyInstantiatedWithDifferentAttr { void f() {} }; +template struct __declspec(dllexport) ExplicitlyInstantiatedWithDifferentAttr<int>; +USEMEMFUNC(ExplicitlyInstantiatedWithDifferentAttr<int>, f); +// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$ExplicitlyInstantiatedWithDifferentAttr@H@@QAEXXZ" + +// Don't create weak dllexport aliases. (PR21373) +struct NonExportedBaseClass { + virtual ~NonExportedBaseClass(); +}; +NonExportedBaseClass::~NonExportedBaseClass() {} + +struct __declspec(dllexport) ExportedDerivedClass : NonExportedBaseClass {}; +// M32-DAG: weak_odr dllexport x86_thiscallcc void @"\01??1ExportedDerivedClass@@UAE@XZ" + +// Do not assert about generating code for constexpr functions twice during explicit instantiation (PR21718). +template <typename T> struct ExplicitInstConstexprMembers { + // Copy assignment operator + // M32-DAG: define weak_odr dllexport x86_thiscallcc dereferenceable(1) %struct.ExplicitInstConstexprMembers* @"\01??4?$ExplicitInstConstexprMembers@X@@QAEAAU0@ABU0@@Z" + + constexpr ExplicitInstConstexprMembers() {} + // M32-DAG: define weak_odr dllexport x86_thiscallcc %struct.ExplicitInstConstexprMembers* @"\01??0?$ExplicitInstConstexprMembers@X@@QAE@XZ" + + ExplicitInstConstexprMembers(const ExplicitInstConstexprMembers&) = default; + // M32-DAG: define weak_odr dllexport x86_thiscallcc %struct.ExplicitInstConstexprMembers* @"\01??0?$ExplicitInstConstexprMembers@X@@QAE@ABU0@@Z" + + constexpr int f() const { return 42; } + // M32-DAG: define weak_odr dllexport x86_thiscallcc i32 @"\01?f@?$ExplicitInstConstexprMembers@X@@QBEHXZ" +}; +template struct __declspec(dllexport) ExplicitInstConstexprMembers<void>; + //===----------------------------------------------------------------------===// // Classes with template base classes //===----------------------------------------------------------------------===// template <typename T> struct ClassTemplate { void func() {} }; template <typename T> struct __declspec(dllexport) ExportedClassTemplate { void func() {} }; -template <typename T> struct __declspec(dllimport) ImportedClassTemplate { void func() {} }; +template <typename T> struct __declspec(dllimport) ImportedClassTemplate { void func(); }; +template <typename T> void ImportedClassTemplate<T>::func() {} template <typename T> struct ExplicitlySpecializedTemplate { void func() {} }; template <> struct ExplicitlySpecializedTemplate<int> { void func() {} }; template <typename T> struct ExplicitlyExportSpecializedTemplate { void func() {} }; template <> struct __declspec(dllexport) ExplicitlyExportSpecializedTemplate<int> { void func() {} }; -template <typename T> struct ExplicitlyImportSpecializedTemplate { void func() {} }; -template <> struct __declspec(dllimport) ExplicitlyImportSpecializedTemplate<int> { void func() {} }; +template <typename T> struct ExplicitlyImportSpecializedTemplate { void func(); }; +template <> struct __declspec(dllimport) ExplicitlyImportSpecializedTemplate<int> { void func(); }; template <typename T> struct ExplicitlyInstantiatedTemplate { void func() {} }; template struct ExplicitlyInstantiatedTemplate<int>; template <typename T> struct ExplicitlyExportInstantiatedTemplate { void func() {} }; template struct __declspec(dllexport) ExplicitlyExportInstantiatedTemplate<int>; -template <typename T> struct ExplicitlyImportInstantiatedTemplate { void func() {} }; +template <typename T> struct ExplicitlyImportInstantiatedTemplate { void func(); }; template struct __declspec(dllimport) ExplicitlyImportInstantiatedTemplate<int>; // MS: ClassTemplate<int> gets exported. struct __declspec(dllexport) DerivedFromTemplate : public ClassTemplate<int> {}; -USEMEMFUNC(ClassTemplate<int>, func) +USEMEMFUNC(DerivedFromTemplate, func) // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?func@?$ClassTemplate@H@@QAEXXZ" // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ClassTemplateIiE4funcEv // ExportedTemplate is explicitly exported. struct __declspec(dllexport) DerivedFromExportedTemplate : public ExportedClassTemplate<int> {}; +USEMEMFUNC(DerivedFromExportedTemplate, func) // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?func@?$ExportedClassTemplate@H@@QAEXXZ" // G32-DAG: define weak_odr dllexport x86_thiscallcc void @_ZN21ExportedClassTemplateIiE4funcEv // ImportedClassTemplate is explicitly imported. struct __declspec(dllexport) DerivedFromImportedTemplate : public ImportedClassTemplate<int> {}; -USEMEMFUNC(ImportedClassTemplate<int>, func) +USEMEMFUNC(DerivedFromImportedTemplate, func) // M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ImportedClassTemplate@H@@QAEXXZ" // G32-DAG: declare dllimport x86_thiscallcc void @_ZN21ImportedClassTemplateIiE4funcEv // Base class already instantiated without dll attribute. struct DerivedFromTemplateD : public ClassTemplate<double> {}; struct __declspec(dllexport) DerivedFromTemplateD2 : public ClassTemplate<double> {}; -USEMEMFUNC(ClassTemplate<double>, func) +USEMEMFUNC(DerivedFromTemplateD2, func) // M32-DAG: define linkonce_odr x86_thiscallcc void @"\01?func@?$ClassTemplate@N@@QAEXXZ" // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ClassTemplateIdE4funcEv // MS: Base class already instantiated with different dll attribute. struct __declspec(dllimport) DerivedFromTemplateB : public ClassTemplate<bool> {}; struct __declspec(dllexport) DerivedFromTemplateB2 : public ClassTemplate<bool> {}; -USEMEMFUNC(ClassTemplate<bool>, func) +USEMEMFUNC(DerivedFromTemplateB2, func) // M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ClassTemplate@_N@@QAEXXZ" // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ClassTemplateIbE4funcEv // Base class already specialized without dll attribute. struct __declspec(dllexport) DerivedFromExplicitlySpecializedTemplate : public ExplicitlySpecializedTemplate<int> {}; -USEMEMFUNC(ExplicitlySpecializedTemplate<int>, func) +USEMEMFUNC(DerivedFromExplicitlySpecializedTemplate, func) // M32-DAG: define linkonce_odr x86_thiscallcc void @"\01?func@?$ExplicitlySpecializedTemplate@H@@QAEXXZ" // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN29ExplicitlySpecializedTemplateIiE4funcEv // Base class alredy specialized with export attribute. struct __declspec(dllexport) DerivedFromExplicitlyExportSpecializedTemplate : public ExplicitlyExportSpecializedTemplate<int> {}; -USEMEMFUNC(ExplicitlyExportSpecializedTemplate<int>, func) +USEMEMFUNC(DerivedFromExplicitlyExportSpecializedTemplate, func) // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?func@?$ExplicitlyExportSpecializedTemplate@H@@QAEXXZ" // G32-DAG: define weak_odr dllexport x86_thiscallcc void @_ZN35ExplicitlyExportSpecializedTemplateIiE4funcEv // Base class already specialized with import attribute. struct __declspec(dllexport) DerivedFromExplicitlyImportSpecializedTemplate : public ExplicitlyImportSpecializedTemplate<int> {}; -USEMEMFUNC(ExplicitlyImportSpecializedTemplate<int>, func) -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportSpecializedTemplate@H@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN35ExplicitlyImportSpecializedTemplateIiE4funcEv +USEMEMFUNC(DerivedFromExplicitlyImportSpecializedTemplate, func) +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportSpecializedTemplate@H@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN35ExplicitlyImportSpecializedTemplateIiE4funcEv // Base class already instantiated without dll attribute. struct __declspec(dllexport) DerivedFromExplicitlyInstantiatedTemplate : public ExplicitlyInstantiatedTemplate<int> {}; -USEMEMFUNC(ExplicitlyInstantiatedTemplate<int>, func) +USEMEMFUNC(DerivedFromExplicitlyInstantiatedTemplate, func) // M32-DAG: define weak_odr x86_thiscallcc void @"\01?func@?$ExplicitlyInstantiatedTemplate@H@@QAEXXZ" // G32-DAG: define weak_odr x86_thiscallcc void @_ZN30ExplicitlyInstantiatedTemplateIiE4funcEv // Base class already instantiated with export attribute. struct __declspec(dllexport) DerivedFromExplicitlyExportInstantiatedTemplate : public ExplicitlyExportInstantiatedTemplate<int> {}; -USEMEMFUNC(ExplicitlyExportInstantiatedTemplate<int>, func) +USEMEMFUNC(DerivedFromExplicitlyExportInstantiatedTemplate, func) // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?func@?$ExplicitlyExportInstantiatedTemplate@H@@QAEXXZ" // G32-DAG: define weak_odr dllexport x86_thiscallcc void @_ZN36ExplicitlyExportInstantiatedTemplateIiE4funcEv // Base class already instantiated with import attribute. struct __declspec(dllexport) DerivedFromExplicitlyImportInstantiatedTemplate : public ExplicitlyImportInstantiatedTemplate<int> {}; -USEMEMFUNC(ExplicitlyImportInstantiatedTemplate<int>, func) -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportInstantiatedTemplate@H@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN36ExplicitlyImportInstantiatedTemplateIiE4funcEv +USEMEMFUNC(DerivedFromExplicitlyImportInstantiatedTemplate, func) +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportInstantiatedTemplate@H@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN36ExplicitlyImportInstantiatedTemplateIiE4funcEv // MS: A dll attribute propagates through multiple levels of instantiation. template <typename T> struct TopClass { void func() {} }; template <typename T> struct MiddleClass : public TopClass<T> { }; struct __declspec(dllexport) BottomClass : public MiddleClass<int> { }; -USEMEMFUNC(TopClass<int>, func) +USEMEMFUNC(BottomClass, func) // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?func@?$TopClass@H@@QAEXXZ" // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN8TopClassIiE4funcEv diff --git a/test/CodeGenCXX/dllimport-members.cpp b/test/CodeGenCXX/dllimport-members.cpp index 6656b92b0022..e88b7e97c3e7 100644 --- a/test/CodeGenCXX/dllimport-members.cpp +++ b/test/CodeGenCXX/dllimport-members.cpp @@ -63,64 +63,64 @@ struct ForceNonTrivial { struct ImportMembers { struct Nested; - // M32-DAG: define x86_thiscallcc void @"\01?normalDef@ImportMembers@@QAEXXZ"(%struct.ImportMembers* %this) - // M64-DAG: define void @"\01?normalDef@ImportMembers@@QEAAXXZ"(%struct.ImportMembers* %this) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalDecl@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?normalDecl@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInclass@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?normalInclass@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDef@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?normalInlineDef@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDecl@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?normalInlineDecl@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) - // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers9normalDefEv(%struct.ImportMembers* %this) - // G64-DAG: define void @_ZN13ImportMembers9normalDefEv(%struct.ImportMembers* %this) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers10normalDeclEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers10normalDeclEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers13normalInclassEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers13normalInclassEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers15normalInlineDefEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers15normalInlineDefEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers16normalInlineDeclEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers16normalInlineDeclEv(%struct.ImportMembers*) + // M32-DAG: define x86_thiscallcc void @"\01?normalDef@ImportMembers@@QAEXXZ"(%struct.ImportMembers* %this) + // M64-DAG: define void @"\01?normalDef@ImportMembers@@QEAAXXZ"(%struct.ImportMembers* %this) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalDecl@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?normalDecl@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInclass@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?normalInclass@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDef@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?normalInlineDef@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDecl@ImportMembers@@QAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?normalInlineDecl@ImportMembers@@QEAAXXZ"(%struct.ImportMembers*) + // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers9normalDefEv(%struct.ImportMembers* %this) + // G64-DAG: define void @_ZN13ImportMembers9normalDefEv(%struct.ImportMembers* %this) + // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers10normalDeclEv(%struct.ImportMembers*) + // G64-DAG: declare dllimport void @_ZN13ImportMembers10normalDeclEv(%struct.ImportMembers*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers13normalInclassEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers13normalInclassEv(%struct.ImportMembers* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers15normalInlineDefEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers15normalInlineDefEv(%struct.ImportMembers* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers16normalInlineDeclEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers16normalInlineDeclEv(%struct.ImportMembers* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInclass@ImportMembers@@QAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInlineDef@ImportMembers@@QAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInlineDecl@ImportMembers@@QAEXXZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers13normalInclassEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers15normalInlineDefEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers16normalInlineDeclEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers13normalInclassEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers15normalInlineDefEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers16normalInlineDeclEv( __declspec(dllimport) void normalDef(); // dllimport ignored __declspec(dllimport) void normalDecl(); __declspec(dllimport) void normalInclass() {} __declspec(dllimport) void normalInlineDef(); __declspec(dllimport) inline void normalInlineDecl(); - // M32-DAG: define x86_thiscallcc void @"\01?virtualDef@ImportMembers@@UAEXXZ"(%struct.ImportMembers* %this) - // M64-DAG: define void @"\01?virtualDef@ImportMembers@@UEAAXXZ"(%struct.ImportMembers* %this) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualDecl@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?virtualDecl@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInclass@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?virtualInclass@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDef@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?virtualInlineDef@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDecl@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) - // M64-DAG: declare dllimport void @"\01?virtualInlineDecl@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) - // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers10virtualDefEv(%struct.ImportMembers* %this) - // G64-DAG: define void @_ZN13ImportMembers10virtualDefEv(%struct.ImportMembers* %this) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers11virtualDeclEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers11virtualDeclEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers14virtualInclassEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers14virtualInclassEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers16virtualInlineDefEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers16virtualInlineDefEv(%struct.ImportMembers*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers17virtualInlineDeclEv(%struct.ImportMembers*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers17virtualInlineDeclEv(%struct.ImportMembers*) + // M32-DAG: define x86_thiscallcc void @"\01?virtualDef@ImportMembers@@UAEXXZ"(%struct.ImportMembers* %this) + // M64-DAG: define void @"\01?virtualDef@ImportMembers@@UEAAXXZ"(%struct.ImportMembers* %this) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualDecl@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?virtualDecl@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInclass@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?virtualInclass@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDef@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?virtualInlineDef@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDecl@ImportMembers@@UAEXXZ"(%struct.ImportMembers*) + // M64-DAG: declare dllimport void @"\01?virtualInlineDecl@ImportMembers@@UEAAXXZ"(%struct.ImportMembers*) + // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers10virtualDefEv(%struct.ImportMembers* %this) + // G64-DAG: define void @_ZN13ImportMembers10virtualDefEv(%struct.ImportMembers* %this) + // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers11virtualDeclEv(%struct.ImportMembers*) + // G64-DAG: declare dllimport void @_ZN13ImportMembers11virtualDeclEv(%struct.ImportMembers*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers14virtualInclassEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers14virtualInclassEv(%struct.ImportMembers* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers16virtualInlineDefEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers16virtualInlineDefEv(%struct.ImportMembers* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers17virtualInlineDeclEv(%struct.ImportMembers* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers17virtualInlineDeclEv(%struct.ImportMembers* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInclass@ImportMembers@@UAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInlineDef@ImportMembers@@UAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInlineDecl@ImportMembers@@UAEXXZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers14virtualInclassEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers16virtualInlineDefEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers17virtualInlineDeclEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers14virtualInclassEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers16virtualInlineDefEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers17virtualInlineDeclEv( __declspec(dllimport) virtual void virtualDef(); // dllimport ignored __declspec(dllimport) virtual void virtualDecl(); __declspec(dllimport) virtual void virtualInclass() {} @@ -134,15 +134,15 @@ struct ImportMembers { // MSC-DAG: declare dllimport void @"\01?staticInlineDecl@ImportMembers@@SAXXZ"() // GNU-DAG: define void @_ZN13ImportMembers9staticDefEv() // GNU-DAG: declare dllimport void @_ZN13ImportMembers10staticDeclEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers13staticInclassEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers15staticInlineDefEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers16staticInlineDeclEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers13staticInclassEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers15staticInlineDefEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers16staticInlineDeclEv() // MO1-DAG: define available_externally dllimport void @"\01?staticInclass@ImportMembers@@SAXXZ"() // MO1-DAG: define available_externally dllimport void @"\01?staticInlineDef@ImportMembers@@SAXXZ"() // MO1-DAG: define available_externally dllimport void @"\01?staticInlineDecl@ImportMembers@@SAXXZ"() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers13staticInclassEv() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers15staticInlineDefEv() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers16staticInlineDeclEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers13staticInclassEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers15staticInlineDefEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers16staticInlineDeclEv() __declspec(dllimport) static void staticDef(); // dllimport ignored __declspec(dllimport) static void staticDecl(); __declspec(dllimport) static void staticInclass() {} @@ -235,65 +235,65 @@ USEMV(ImportMembers, ConstexprField) // Import individual members of a nested class. struct ImportMembers::Nested { - // M32-DAG: define x86_thiscallcc void @"\01?normalDef@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"* %this) - // M64-DAG: define void @"\01?normalDef@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"* %this) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalDecl@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?normalDecl@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInclass@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?normalInclass@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDef@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?normalInlineDef@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDecl@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?normalInlineDecl@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) - // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers6Nested9normalDefEv(%"struct.ImportMembers::Nested"* %this) - // G64-DAG: define void @_ZN13ImportMembers6Nested9normalDefEv(%"struct.ImportMembers::Nested"* %this) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested10normalDeclEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested10normalDeclEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested13normalInclassEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested13normalInclassEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested15normalInlineDefEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested15normalInlineDefEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested16normalInlineDeclEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested16normalInlineDeclEv(%"struct.ImportMembers::Nested"*) + // M32-DAG: define x86_thiscallcc void @"\01?normalDef@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"* %this) + // M64-DAG: define void @"\01?normalDef@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"* %this) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalDecl@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?normalDecl@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInclass@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?normalInclass@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDef@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?normalInlineDef@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?normalInlineDecl@Nested@ImportMembers@@QAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?normalInlineDecl@Nested@ImportMembers@@QEAAXXZ"(%"struct.ImportMembers::Nested"*) + // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers6Nested9normalDefEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define void @_ZN13ImportMembers6Nested9normalDefEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested10normalDeclEv(%"struct.ImportMembers::Nested"*) + // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested10normalDeclEv(%"struct.ImportMembers::Nested"*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested13normalInclassEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested13normalInclassEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested15normalInlineDefEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested15normalInlineDefEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested16normalInlineDeclEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested16normalInlineDeclEv(%"struct.ImportMembers::Nested"* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInclass@Nested@ImportMembers@@QAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInlineDef@Nested@ImportMembers@@QAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?normalInlineDecl@Nested@ImportMembers@@QAEXXZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested13normalInclassEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested15normalInlineDefEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested16normalInlineDeclEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested13normalInclassEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested15normalInlineDefEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested16normalInlineDeclEv( __declspec(dllimport) void normalDef(); // dllimport ignored __declspec(dllimport) void normalDecl(); __declspec(dllimport) void normalInclass() {} __declspec(dllimport) void normalInlineDef(); __declspec(dllimport) inline void normalInlineDecl(); - // M32-DAG: define x86_thiscallcc void @"\01?virtualDef@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"* %this) - // M64-DAG: define void @"\01?virtualDef@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"* %this) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualDecl@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?virtualDecl@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInclass@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?virtualInclass@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDef@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?virtualInlineDef@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) - // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDecl@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) - // M64-DAG: declare dllimport void @"\01?virtualInlineDecl@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) - // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers6Nested10virtualDefEv(%"struct.ImportMembers::Nested"* %this) - // G64-DAG: define void @_ZN13ImportMembers6Nested10virtualDefEv(%"struct.ImportMembers::Nested"* %this) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested11virtualDeclEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested11virtualDeclEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested14virtualInclassEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested14virtualInclassEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested16virtualInlineDefEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested16virtualInlineDefEv(%"struct.ImportMembers::Nested"*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested17virtualInlineDeclEv(%"struct.ImportMembers::Nested"*) - // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested17virtualInlineDeclEv(%"struct.ImportMembers::Nested"*) + // M32-DAG: define x86_thiscallcc void @"\01?virtualDef@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"* %this) + // M64-DAG: define void @"\01?virtualDef@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"* %this) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualDecl@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?virtualDecl@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInclass@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?virtualInclass@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDef@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?virtualInlineDef@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01?virtualInlineDecl@Nested@ImportMembers@@UAEXXZ"(%"struct.ImportMembers::Nested"*) + // M64-DAG: declare dllimport void @"\01?virtualInlineDecl@Nested@ImportMembers@@UEAAXXZ"(%"struct.ImportMembers::Nested"*) + // G32-DAG: define x86_thiscallcc void @_ZN13ImportMembers6Nested10virtualDefEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define void @_ZN13ImportMembers6Nested10virtualDefEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: declare dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested11virtualDeclEv(%"struct.ImportMembers::Nested"*) + // G64-DAG: declare dllimport void @_ZN13ImportMembers6Nested11virtualDeclEv(%"struct.ImportMembers::Nested"*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested14virtualInclassEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested14virtualInclassEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested16virtualInlineDefEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested16virtualInlineDefEv(%"struct.ImportMembers::Nested"* %this) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested17virtualInlineDeclEv(%"struct.ImportMembers::Nested"* %this) + // G64-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested17virtualInlineDeclEv(%"struct.ImportMembers::Nested"* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInclass@Nested@ImportMembers@@UAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInlineDef@Nested@ImportMembers@@UAEXXZ"( // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01?virtualInlineDecl@Nested@ImportMembers@@UAEXXZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested14virtualInclassEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested16virtualInlineDefEv( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN13ImportMembers6Nested17virtualInlineDeclEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested14virtualInclassEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested16virtualInlineDefEv( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN13ImportMembers6Nested17virtualInlineDeclEv( __declspec(dllimport) virtual void virtualDef(); // dllimport ignored __declspec(dllimport) virtual void virtualDecl(); __declspec(dllimport) virtual void virtualInclass() {} @@ -307,15 +307,15 @@ struct ImportMembers::Nested { // MSC-DAG: declare dllimport void @"\01?staticInlineDecl@Nested@ImportMembers@@SAXXZ"() // GNU-DAG: define void @_ZN13ImportMembers6Nested9staticDefEv() // GNU-DAG: declare dllimport void @_ZN13ImportMembers6Nested10staticDeclEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers6Nested13staticInclassEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers6Nested15staticInlineDefEv() - // GNU-DAG: declare dllimport void @_ZN13ImportMembers6Nested16staticInlineDeclEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested13staticInclassEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested15staticInlineDefEv() + // GNU-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested16staticInlineDeclEv() // MO1-DAG: define available_externally dllimport void @"\01?staticInclass@Nested@ImportMembers@@SAXXZ"() // MO1-DAG: define available_externally dllimport void @"\01?staticInlineDef@Nested@ImportMembers@@SAXXZ"() // MO1-DAG: define available_externally dllimport void @"\01?staticInlineDecl@Nested@ImportMembers@@SAXXZ"() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers6Nested13staticInclassEv() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers6Nested15staticInlineDefEv() - // GO1-DAG: define available_externally dllimport void @_ZN13ImportMembers6Nested16staticInlineDeclEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested13staticInclassEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested15staticInlineDefEv() + // GO1-DAG: define linkonce_odr void @_ZN13ImportMembers6Nested16staticInlineDeclEv() __declspec(dllimport) static void staticDef(); // dllimport ignored __declspec(dllimport) static void staticDecl(); __declspec(dllimport) static void staticInclass() {} @@ -449,52 +449,52 @@ USESPECIALS(ImportSpecials) // Export inline special member functions. struct ImportInlineSpecials { - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@XZ"(%struct.ImportInlineSpecials* returned) - // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@XZ"(%struct.ImportInlineSpecials* returned) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1Ev(%struct.ImportInlineSpecials*) - // G64-DAG: declare dllimport void @_ZN20ImportInlineSpecialsC1Ev(%struct.ImportInlineSpecials*) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@XZ"(%struct.ImportInlineSpecials* returned) + // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@XZ"(%struct.ImportInlineSpecials* returned) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1Ev(%struct.ImportInlineSpecials* %this) + // G64-DAG: define linkonce_odr void @_ZN20ImportInlineSpecialsC1Ev(%struct.ImportInlineSpecials* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@XZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1Ev( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1Ev( __declspec(dllimport) ImportInlineSpecials() {} - // M32-DAG: declare dllimport x86_thiscallcc void @"\01??1ImportInlineSpecials@@QAE@XZ"(%struct.ImportInlineSpecials*) - // M64-DAG: declare dllimport void @"\01??1ImportInlineSpecials@@QEAA@XZ"(%struct.ImportInlineSpecials*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsD1Ev(%struct.ImportInlineSpecials*) - // G64-DAG: declare dllimport void @_ZN20ImportInlineSpecialsD1Ev(%struct.ImportInlineSpecials*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01??1ImportInlineSpecials@@QAE@XZ"(%struct.ImportInlineSpecials*) + // M64-DAG: declare dllimport void @"\01??1ImportInlineSpecials@@QEAA@XZ"(%struct.ImportInlineSpecials*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsD1Ev(%struct.ImportInlineSpecials* %this) + // G64-DAG: define linkonce_odr void @_ZN20ImportInlineSpecialsD1Ev(%struct.ImportInlineSpecials* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01??1ImportInlineSpecials@@QAE@XZ"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsD1Ev( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsD1Ev( __declspec(dllimport) ~ImportInlineSpecials() {} - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@ABU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@AEBU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1ERKS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport void @_ZN20ImportInlineSpecialsC1ERKS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@ABU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@AEBU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1ERKS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr void @_ZN20ImportInlineSpecialsC1ERKS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@ABU0@@Z"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1ERKS_( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1ERKS_( __declspec(dllimport) inline ImportInlineSpecials(const ImportInlineSpecials&); - // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@ABU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@ABU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@ABU0@@Z"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_( + // GO1-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSERKS_( __declspec(dllimport) ImportInlineSpecials& operator=(const ImportInlineSpecials&); - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@$$QAU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@$$QEAU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1EOS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport void @_ZN20ImportInlineSpecialsC1EOS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@$$QAU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QEAA@$$QEAU0@@Z"(%struct.ImportInlineSpecials* returned, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1EOS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr void @_ZN20ImportInlineSpecialsC1EOS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportInlineSpecials* @"\01??0ImportInlineSpecials@@QAE@$$QAU0@@Z"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN20ImportInlineSpecialsC1EOS_( + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN20ImportInlineSpecialsC1EOS_( __declspec(dllimport) ImportInlineSpecials(ImportInlineSpecials&&) {} - // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@$$QAU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QEAAAEAU0@$$QEAU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@$$QAU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QEAAAEAU0@$$QEAU0@@Z"(%struct.ImportInlineSpecials*, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_(%struct.ImportInlineSpecials* %this, %struct.ImportInlineSpecials* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @"\01??4ImportInlineSpecials@@QAEAAU0@$$QAU0@@Z"( - // GO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_( + // GO1-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportInlineSpecials* @_ZN20ImportInlineSpecialsaSEOS_( __declspec(dllimport) ImportInlineSpecials& operator=(ImportInlineSpecials&&) { return *this; } }; ImportInlineSpecials::ImportInlineSpecials(const ImportInlineSpecials&) {} @@ -504,52 +504,52 @@ USESPECIALS(ImportInlineSpecials) // Import defaulted member functions. struct ImportDefaulted { - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted* returned) - // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@XZ"(%struct.ImportDefaulted* returned) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted*) - // G64-DAG: declare dllimport void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted*) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted* returned) + // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@XZ"(%struct.ImportDefaulted* returned) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted* %this) + // G64-DAG: define linkonce_odr void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted* returned %this) - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted* %this) + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1Ev(%struct.ImportDefaulted* %this) __declspec(dllimport) ImportDefaulted() = default; - // M32-DAG: declare dllimport x86_thiscallcc void @"\01??1ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted*) - // M64-DAG: declare dllimport void @"\01??1ImportDefaulted@@QEAA@XZ"(%struct.ImportDefaulted*) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted*) - // G64-DAG: declare dllimport void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted*) + // M32-DAG: declare dllimport x86_thiscallcc void @"\01??1ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted*) + // M64-DAG: declare dllimport void @"\01??1ImportDefaulted@@QEAA@XZ"(%struct.ImportDefaulted*) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted* %this) + // G64-DAG: define linkonce_odr void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted* %this) // MO1-DAG: define available_externally dllimport x86_thiscallcc void @"\01??1ImportDefaulted@@QAE@XZ"(%struct.ImportDefaulted* %this) - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted* %this) + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedD1Ev(%struct.ImportDefaulted* %this) __declspec(dllimport) ~ImportDefaulted() = default; - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@ABU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@AEBU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@ABU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@AEBU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@ABU0@@Z"(%struct.ImportDefaulted* returned %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1ERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) __declspec(dllimport) ImportDefaulted(const ImportDefaulted&) = default; - // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@ABU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@ABU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@ABU0@@Z"(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // GO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // GO1-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSERKS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) __declspec(dllimport) ImportDefaulted& operator=(const ImportDefaulted&) = default; - // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@$$QAU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@$$QEAU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@$$QAU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QEAA@$$QEAU0@@Z"(%struct.ImportDefaulted* returned, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc %struct.ImportDefaulted* @"\01??0ImportDefaulted@@QAE@$$QAU0@@Z"(%struct.ImportDefaulted* returned %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // GO1-DAG: define available_externally dllimport x86_thiscallcc void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // GO1-DAG: define linkonce_odr x86_thiscallcc void @_ZN15ImportDefaultedC1EOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) __declspec(dllimport) ImportDefaulted(ImportDefaulted&&) = default; - // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@$$QAU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QEAAAEAU0@$$QEAU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // G64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@$$QAU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QEAAAEAU0@$$QEAU0@@Z"(%struct.ImportDefaulted*, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G32-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // G64-DAG: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) // MO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @"\01??4ImportDefaulted@@QAEAAU0@$$QAU0@@Z"(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) - // GO1-DAG: define available_externally dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) + // GO1-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaulted* @_ZN15ImportDefaultedaSEOS_(%struct.ImportDefaulted* %this, %struct.ImportDefaulted* dereferenceable({{[0-9]+}})) __declspec(dllimport) ImportDefaulted& operator=(ImportDefaulted&&) = default; ForceNonTrivial v; // ensure special members are non-trivial @@ -569,28 +569,30 @@ struct ImportDefaultedDefs { __declspec(dllimport) ImportDefaultedDefs& operator=(ImportDefaultedDefs&&); }; +#ifdef MSABI +// For MinGW, the function will not be dllimport, and we cannot add the attribute now. // M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QAE@XZ"(%struct.ImportDefaultedDefs* returned) // M64-DAG: declare dllimport %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QEAA@XZ"(%struct.ImportDefaultedDefs* returned) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN19ImportDefaultedDefsC1Ev(%struct.ImportDefaultedDefs*) -// G64-DAG: declare dllimport void @_ZN19ImportDefaultedDefsC1Ev(%struct.ImportDefaultedDefs*) __declspec(dllimport) ImportDefaultedDefs::ImportDefaultedDefs() = default; +#endif +#ifdef MSABI +// For MinGW, the function will not be dllimport, and we cannot add the attribute now. // M32-DAG: declare dllimport x86_thiscallcc void @"\01??1ImportDefaultedDefs@@QAE@XZ"(%struct.ImportDefaultedDefs*) // M64-DAG: declare dllimport void @"\01??1ImportDefaultedDefs@@QEAA@XZ"(%struct.ImportDefaultedDefs*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN19ImportDefaultedDefsD1Ev(%struct.ImportDefaultedDefs*) -// G64-DAG: declare dllimport void @_ZN19ImportDefaultedDefsD1Ev(%struct.ImportDefaultedDefs*) __declspec(dllimport) ImportDefaultedDefs::~ImportDefaultedDefs() = default; +#endif -// M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QAE@ABU0@@Z"(%struct.ImportDefaultedDefs* returned, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// M64-DAG: declare dllimport %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QEAA@AEBU0@@Z"(%struct.ImportDefaultedDefs* returned, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN19ImportDefaultedDefsC1ERKS_(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// G64-DAG: declare dllimport void @_ZN19ImportDefaultedDefsC1ERKS_(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// M32-DAG: declare dllimport x86_thiscallcc %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QAE@ABU0@@Z"(%struct.ImportDefaultedDefs* returned, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// M64-DAG: declare dllimport %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QEAA@AEBU0@@Z"(%struct.ImportDefaultedDefs* returned, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN19ImportDefaultedDefsC1ERKS_(%struct.ImportDefaultedDefs* %this, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// G64-DAG: define linkonce_odr void @_ZN19ImportDefaultedDefsC1ERKS_(%struct.ImportDefaultedDefs* %this, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) inline ImportDefaultedDefs::ImportDefaultedDefs(const ImportDefaultedDefs&) = default; -// M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @"\01??4ImportDefaultedDefs@@QAEAAU0@ABU0@@Z"(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @"\01??4ImportDefaultedDefs@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// G32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @_ZN19ImportDefaultedDefsaSERKS_(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) -// G64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @_ZN19ImportDefaultedDefsaSERKS_(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// M32-DAG: declare dllimport x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @"\01??4ImportDefaultedDefs@@QAEAAU0@ABU0@@Z"(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// M64-DAG: declare dllimport dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @"\01??4ImportDefaultedDefs@@QEAAAEAU0@AEBU0@@Z"(%struct.ImportDefaultedDefs*, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// G32-DAG: define linkonce_odr x86_thiscallcc dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @_ZN19ImportDefaultedDefsaSERKS_(%struct.ImportDefaultedDefs* %this, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) +// G64-DAG: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ImportDefaultedDefs* @_ZN19ImportDefaultedDefsaSERKS_(%struct.ImportDefaultedDefs* %this, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) inline ImportDefaultedDefs& ImportDefaultedDefs::operator=(const ImportDefaultedDefs&) = default; // M32-DAG: define x86_thiscallcc %struct.ImportDefaultedDefs* @"\01??0ImportDefaultedDefs@@QAE@$$QAU0@@Z"(%struct.ImportDefaultedDefs* returned %this, %struct.ImportDefaultedDefs* dereferenceable({{[0-9]+}})) @@ -655,14 +657,14 @@ struct MemFunTmpl { }; // Import implicit instantiation of an imported member function template. -// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UImplicitInst_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) -// M64-DAG: declare dllimport void @"\01??$importedNormal@UImplicitInst_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ImplicitInst_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl14importedNormalI21ImplicitInst_ImportedEEvv(%struct.MemFunTmpl*) +// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UImplicitInst_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) +// M64-DAG: declare dllimport void @"\01??$importedNormal@UImplicitInst_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ImplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) +// G64-DAG: define linkonce_odr void @_ZN10MemFunTmpl14importedNormalI21ImplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) USEMF(MemFunTmpl, importedNormal<ImplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$importedStatic@UImplicitInst_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl14importedStaticI21ImplicitInst_ImportedEEvv() +// GNU-DAG: define linkonce_odr void @_ZN10MemFunTmpl14importedStaticI21ImplicitInst_ImportedEEvv() USE(MemFunTmpl::importedStatic<ImplicitInst_Imported>) @@ -670,13 +672,13 @@ USE(MemFunTmpl::importedStatic<ImplicitInst_Imported>) // template. // M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UExplicitDecl_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) // M64-DAG: declare dllimport void @"\01??$importedNormal@UExplicitDecl_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl14importedNormalI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) +// G32-DAG: declare x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) +// G64-DAG: declare void @_ZN10MemFunTmpl14importedNormalI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) extern template void MemFunTmpl::importedNormal<ExplicitDecl_Imported>(); USEMF(MemFunTmpl, importedNormal<ExplicitDecl_Imported>) // MSC-DAG: declare dllimport void @"\01??$importedStatic@UExplicitDecl_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl14importedStaticI21ExplicitDecl_ImportedEEvv() +// GNU-DAG: declare void @_ZN10MemFunTmpl14importedStaticI21ExplicitDecl_ImportedEEvv() extern template void MemFunTmpl::importedStatic<ExplicitDecl_Imported>(); USE(MemFunTmpl::importedStatic<ExplicitDecl_Imported>) @@ -685,13 +687,13 @@ USE(MemFunTmpl::importedStatic<ExplicitDecl_Imported>) // template. // M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UExplicitInst_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) // M64-DAG: declare dllimport void @"\01??$importedNormal@UExplicitInst_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl14importedNormalI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl*) +// G32-DAG: define weak_odr x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) +// G64-DAG: define weak_odr void @_ZN10MemFunTmpl14importedNormalI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) template void MemFunTmpl::importedNormal<ExplicitInst_Imported>(); USEMF(MemFunTmpl, importedNormal<ExplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$importedStatic@UExplicitInst_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl14importedStaticI21ExplicitInst_ImportedEEvv() +// GNU-DAG: define weak_odr void @_ZN10MemFunTmpl14importedStaticI21ExplicitInst_ImportedEEvv() template void MemFunTmpl::importedStatic<ExplicitInst_Imported>(); USE(MemFunTmpl::importedStatic<ExplicitInst_Imported>) @@ -711,10 +713,10 @@ USEMF(MemFunTmpl, importedNormal<ExplicitSpec_Imported>) //USEMF(MemFunTmpl, importedNormal<ExplicitSpec_Def_Imported>) #endif -// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) -// M64-DAG: declare dllimport void @"\01??$importedNormal@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl14importedNormalI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl*) +// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$importedNormal@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) +// M64-DAG: declare dllimport void @"\01??$importedNormal@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN10MemFunTmpl14importedNormalI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl* %this) +// G64-DAG: define linkonce_odr void @_ZN10MemFunTmpl14importedNormalI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl* %this) template<> __declspec(dllimport) inline void MemFunTmpl::importedNormal<ExplicitSpec_InlineDef_Imported>() {} USEMF(MemFunTmpl, importedNormal<ExplicitSpec_InlineDef_Imported>) @@ -731,7 +733,7 @@ USE(MemFunTmpl::importedStatic<ExplicitSpec_Imported>) #endif // MSC-DAG: declare dllimport void @"\01??$importedStatic@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl14importedStaticI31ExplicitSpec_InlineDef_ImportedEEvv() +// GNU-DAG: define linkonce_odr void @_ZN10MemFunTmpl14importedStaticI31ExplicitSpec_InlineDef_ImportedEEvv() template<> __declspec(dllimport) inline void MemFunTmpl::importedStatic<ExplicitSpec_InlineDef_Imported>() {} USE(MemFunTmpl::importedStatic<ExplicitSpec_InlineDef_Imported>) @@ -755,13 +757,13 @@ USE(MemFunTmpl::importedStatic<ExplicitSpec_NotImported>) // template. // M32-DAG: declare dllimport x86_thiscallcc void @"\01??$normalDef@UExplicitDecl_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) // M64-DAG: declare dllimport void @"\01??$normalDef@UExplicitDecl_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl9normalDefI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) +// G32-DAG: declare x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) +// G64-DAG: declare void @_ZN10MemFunTmpl9normalDefI21ExplicitDecl_ImportedEEvv(%struct.MemFunTmpl*) extern template __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitDecl_Imported>(); USEMF(MemFunTmpl, normalDef<ExplicitDecl_Imported>) // MSC-DAG: declare dllimport void @"\01??$staticDef@UExplicitDecl_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl9staticDefI21ExplicitDecl_ImportedEEvv() +// GNU-DAG: declare void @_ZN10MemFunTmpl9staticDefI21ExplicitDecl_ImportedEEvv() extern template __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitDecl_Imported>(); USE(MemFunTmpl::staticDef<ExplicitDecl_Imported>) @@ -770,13 +772,13 @@ USE(MemFunTmpl::staticDef<ExplicitDecl_Imported>) // template. // M32-DAG: declare dllimport x86_thiscallcc void @"\01??$normalDef@UExplicitInst_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) // M64-DAG: declare dllimport void @"\01??$normalDef@UExplicitInst_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl9normalDefI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl*) +// G32-DAG: define weak_odr x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) +// G64-DAG: define weak_odr void @_ZN10MemFunTmpl9normalDefI21ExplicitInst_ImportedEEvv(%struct.MemFunTmpl* %this) template __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitInst_Imported>(); USEMF(MemFunTmpl, normalDef<ExplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$staticDef@UExplicitInst_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl9staticDefI21ExplicitInst_ImportedEEvv() +// GNU-DAG: define weak_odr void @_ZN10MemFunTmpl9staticDefI21ExplicitInst_ImportedEEvv() template __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitInst_Imported>(); USE(MemFunTmpl::staticDef<ExplicitInst_Imported>) @@ -796,10 +798,10 @@ USEMF(MemFunTmpl, normalDef<ExplicitSpec_Imported>) //USEMF(MemFunTmpl, normalDef<ExplicitSpec_Def_Imported>) #endif -// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$normalDef@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) -// M64-DAG: declare dllimport void @"\01??$normalDef@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) -// G32-DAG: declare dllimport x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl*) -// G64-DAG: declare dllimport void @_ZN10MemFunTmpl9normalDefI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl*) +// M32-DAG: declare dllimport x86_thiscallcc void @"\01??$normalDef@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QAEXXZ"(%struct.MemFunTmpl*) +// M64-DAG: declare dllimport void @"\01??$normalDef@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@QEAAXXZ"(%struct.MemFunTmpl*) +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN10MemFunTmpl9normalDefI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl* %this) +// G64-DAG: define linkonce_odr void @_ZN10MemFunTmpl9normalDefI31ExplicitSpec_InlineDef_ImportedEEvv(%struct.MemFunTmpl* %this) template<> __declspec(dllimport) inline void MemFunTmpl::normalDef<ExplicitSpec_InlineDef_Imported>() {} USEMF(MemFunTmpl, normalDef<ExplicitSpec_InlineDef_Imported>) @@ -816,7 +818,7 @@ USE(MemFunTmpl::staticDef<ExplicitSpec_Imported>) #endif // MSC-DAG: declare dllimport void @"\01??$staticDef@UExplicitSpec_InlineDef_Imported@@@MemFunTmpl@@SAXXZ"() -// GNU-DAG: declare dllimport void @_ZN10MemFunTmpl9staticDefI31ExplicitSpec_InlineDef_ImportedEEvv() +// GNU-DAG: define linkonce_odr void @_ZN10MemFunTmpl9staticDefI31ExplicitSpec_InlineDef_ImportedEEvv() template<> __declspec(dllimport) inline void MemFunTmpl::staticDef<ExplicitSpec_InlineDef_Imported>() {} USE(MemFunTmpl::staticDef<ExplicitSpec_InlineDef_Imported>) diff --git a/test/CodeGenCXX/dllimport-rtti.cpp b/test/CodeGenCXX/dllimport-rtti.cpp index 7ed7dadfe402..b5a5d543d6e2 100644 --- a/test/CodeGenCXX/dllimport-rtti.cpp +++ b/test/CodeGenCXX/dllimport-rtti.cpp @@ -1,13 +1,17 @@ -// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++1y -O1 -disable-llvm-optzns -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++1y -O1 -disable-llvm-optzns -o - %s | FileCheck %s --check-prefix=MSVC +// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -std=c++1y -O1 -disable-llvm-optzns -o - %s | FileCheck %s --check-prefix=GNU struct __declspec(dllimport) S { - virtual void f(); + virtual void f() {} } s; -// CHECK-DAG: @"\01??_7S@@6B@" = available_externally dllimport -// CHECK-DAG: @"\01??_R0?AUS@@@8" = linkonce_odr -// CHECK-DAG: @"\01??_R1A@?0A@EA@S@@8" = linkonce_odr -// CHECK-DAG: @"\01??_R2S@@8" = linkonce_odr -// CHECK-DAG: @"\01??_R3S@@8" = linkonce_odr +// MSVC-DAG: @"\01??_7S@@6B@" = available_externally dllimport +// MSVC-DAG: @"\01??_R0?AUS@@@8" = linkonce_odr +// MSVC-DAG: @"\01??_R1A@?0A@EA@S@@8" = linkonce_odr +// MSVC-DAG: @"\01??_R2S@@8" = linkonce_odr +// MSVC-DAG: @"\01??_R3S@@8" = linkonce_odr + +// GNU-DAG: @_ZTV1S = available_externally dllimport +// GNU-DAG: @_ZTI1S = external dllimport struct U : S { } u; diff --git a/test/CodeGenCXX/dllimport.cpp b/test/CodeGenCXX/dllimport.cpp index 59f8f6361619..e5b9f64dcca6 100644 --- a/test/CodeGenCXX/dllimport.cpp +++ b/test/CodeGenCXX/dllimport.cpp @@ -1,13 +1,13 @@ -// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI | FileCheck --check-prefix=MSC --check-prefix=M32 %s -// RUN: %clang_cc1 -triple x86_64-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI | FileCheck --check-prefix=MSC --check-prefix=M64 %s -// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=GNU --check-prefix=G32 %s -// RUN: %clang_cc1 -triple x86_64-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=GNU --check-prefix=G64 %s -// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O1 -o - %s -DMSABI | FileCheck --check-prefix=MO1 %s -// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O1 -o - %s | FileCheck --check-prefix=GO1 %s +// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI -w | FileCheck --check-prefix=MSC --check-prefix=M32 %s +// RUN: %clang_cc1 -triple x86_64-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI -w | FileCheck --check-prefix=MSC --check-prefix=M64 %s +// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=GNU --check-prefix=G32 %s +// RUN: %clang_cc1 -triple x86_64-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=GNU --check-prefix=G64 %s +// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O1 -o - %s -DMSABI -w | FileCheck --check-prefix=MO1 %s +// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O1 -o - %s -w | FileCheck --check-prefix=GO1 %s // CHECK-NOT doesn't play nice with CHECK-DAG, so use separate run lines. -// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI | FileCheck --check-prefix=MSC2 %s -// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s | FileCheck --check-prefix=GNU2 %s +// RUN: %clang_cc1 -triple i686-windows-msvc -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -DMSABI -w | FileCheck --check-prefix=MSC2 %s +// RUN: %clang_cc1 -triple i686-windows-gnu -fno-rtti -emit-llvm -std=c++1y -O0 -o - %s -w | FileCheck --check-prefix=GNU2 %s // Helper structs to make templates more expressive. struct ImplicitInst_Imported {}; @@ -95,7 +95,7 @@ inline int __declspec(dllimport) inlineStaticLocalsFunc() { USE(inlineStaticLocalsFunc); // The address of a dllimport global cannot be used in constant initialization. -// M32-DAG: @"\01?arr@?0??initializationFunc@@YAPAHXZ@4QBQAHB" = internal global [1 x i32*] zeroinitializer +// M32-DAG: @"\01?arr@?1??initializationFunc@@YAPAHXZ@4QBQAHB" = internal global [1 x i32*] zeroinitializer // GNU-DAG: @_ZZ18initializationFuncvE3arr = internal global [1 x i32*] zeroinitializer int *initializationFunc() { static int *const arr[] = {&ExternGlobalDecl}; @@ -214,36 +214,36 @@ USE(externC) // Import inline function. // MSC-DAG: declare dllimport void @"\01?inlineFunc@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z10inlineFuncv() +// GNU-DAG: define linkonce_odr void @_Z10inlineFuncv() // MO1-DAG: define available_externally dllimport void @"\01?inlineFunc@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z10inlineFuncv() +// GO1-DAG: define linkonce_odr void @_Z10inlineFuncv() __declspec(dllimport) inline void inlineFunc() {} USE(inlineFunc) // MSC-DAG: declare dllimport void @"\01?inlineDecl@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z10inlineDeclv() +// GNU-DAG: define linkonce_odr void @_Z10inlineDeclv() // MO1-DAG: define available_externally dllimport void @"\01?inlineDecl@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z10inlineDeclv() +// GO1-DAG: define linkonce_odr void @_Z10inlineDeclv() __declspec(dllimport) inline void inlineDecl(); void inlineDecl() {} USE(inlineDecl) // MSC-DAG: declare dllimport void @"\01?inlineDef@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z9inlineDefv() +// GNU-DAG: define linkonce_odr void @_Z9inlineDefv() // MO1-DAG: define available_externally dllimport void @"\01?inlineDef@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z9inlineDefv() +// GO1-DAG: define linkonce_odr void @_Z9inlineDefv() __declspec(dllimport) void inlineDef(); inline void inlineDef() {} USE(inlineDef) // inline attributes // MSC-DAG: declare dllimport void @"\01?noinline@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z8noinlinev() +// GNU-DAG: define linkonce_odr void @_Z8noinlinev() __declspec(dllimport) __attribute__((noinline)) inline void noinline() {} USE(noinline) // MSC2-NOT: @"\01?alwaysInline@@YAXXZ"() -// GNU2-NOT: @_Z12alwaysInlinev() +// GNU-DAG: define linkonce_odr void @_Z12alwaysInlinev() {{.*}} comdat { __declspec(dllimport) __attribute__((always_inline)) inline void alwaysInline() {} USE(alwaysInline) @@ -276,6 +276,11 @@ USE(redecl3) // GNU-DAG: declare void @_Z7friend2v() // MSC-DAG: define void @"\01?friend3@@YAXXZ"() // GNU-DAG: define void @_Z7friend3v() +// MSC-DAG: declare void @"\01?friend4@@YAXXZ"() +// GNU-DAG: declare void @_Z7friend4v() +// MSC-DAG: declare dllimport void @"\01?friend5@@YAXXZ"() +// GNU-DAG: declare dllimport void @_Z7friend5v() + struct FuncFriend { friend __declspec(dllimport) void friend1(); friend __declspec(dllimport) void friend2(); @@ -284,9 +289,18 @@ struct FuncFriend { __declspec(dllimport) void friend1(); void friend2(); // dllimport ignored void friend3() {} // dllimport ignored + +__declspec(dllimport) void friend4(); +__declspec(dllimport) void friend5(); +struct FuncFriendRedecl { + friend void friend4(); // dllimport ignored + friend void ::friend5(); +}; USE(friend1) USE(friend2) USE(friend3) +USE(friend4) +USE(friend5) // Implicit declarations can be redeclared with dllimport. // MSC-DAG: declare dllimport noalias i8* @"\01??2@{{YAPAXI|YAPEAX_K}}@Z"( @@ -315,31 +329,31 @@ USE(funcTmplDecl<ImplicitInst_Imported>) // Import inline function template. // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmpl1@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z15inlineFuncTmpl1I21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z15inlineFuncTmpl1I21ImplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmpl1@UImplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z15inlineFuncTmpl1I21ImplicitInst_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z15inlineFuncTmpl1I21ImplicitInst_ImportedEvv() template<typename T> __declspec(dllimport) inline void inlineFuncTmpl1() {} USE(inlineFuncTmpl1<ImplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmpl2@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z15inlineFuncTmpl2I21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z15inlineFuncTmpl2I21ImplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmpl2@UImplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z15inlineFuncTmpl2I21ImplicitInst_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z15inlineFuncTmpl2I21ImplicitInst_ImportedEvv() template<typename T> inline void __attribute__((dllimport)) inlineFuncTmpl2() {} USE(inlineFuncTmpl2<ImplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmplDecl@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z18inlineFuncTmplDeclI21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z18inlineFuncTmplDeclI21ImplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmplDecl@UImplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z18inlineFuncTmplDeclI21ImplicitInst_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z18inlineFuncTmplDeclI21ImplicitInst_ImportedEvv() template<typename T> __declspec(dllimport) inline void inlineFuncTmplDecl(); template<typename T> void inlineFuncTmplDecl() {} USE(inlineFuncTmplDecl<ImplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmplDef@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z17inlineFuncTmplDefI21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z17inlineFuncTmplDefI21ImplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmplDef@UImplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z17inlineFuncTmplDefI21ImplicitInst_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z17inlineFuncTmplDefI21ImplicitInst_ImportedEvv() template<typename T> __declspec(dllimport) void inlineFuncTmplDef(); template<typename T> inline void inlineFuncTmplDef() {} USE(inlineFuncTmplDef<ImplicitInst_Imported>) @@ -373,7 +387,7 @@ USE(funcTmplRedecl3<ImplicitInst_NotImported>) // MSC-DAG: define linkonce_odr void @"\01??$funcTmplFriend3@UImplicitInst_NotImported@@@@YAXXZ"() // GNU-DAG: define linkonce_odr void @_Z15funcTmplFriend3I24ImplicitInst_NotImportedEvv() // MSC-DAG: declare dllimport void @"\01??$funcTmplFriend4@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z15funcTmplFriend4I21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z15funcTmplFriend4I21ImplicitInst_ImportedEvv() struct FuncTmplFriend { template<typename T> friend __declspec(dllimport) void funcTmplFriend1(); template<typename T> friend __declspec(dllimport) void funcTmplFriend2(); @@ -406,24 +420,24 @@ template<typename T> __declspec(dllimport) inline void importedFuncTmpl() {} USE(importedFuncTmplDecl<ImplicitInst_Imported>) // MSC-DAG: declare dllimport void @"\01??$importedFuncTmpl@UImplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z16importedFuncTmplI21ImplicitInst_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z16importedFuncTmplI21ImplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$importedFuncTmpl@UImplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z16importedFuncTmplI21ImplicitInst_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z16importedFuncTmplI21ImplicitInst_ImportedEvv() USE(importedFuncTmpl<ImplicitInst_Imported>) // Import explicit instantiation declaration of an imported function template. // MSC-DAG: declare dllimport void @"\01??$importedFuncTmpl@UExplicitDecl_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z16importedFuncTmplI21ExplicitDecl_ImportedEvv() +// GNU-DAG: declare void @_Z16importedFuncTmplI21ExplicitDecl_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$importedFuncTmpl@UExplicitDecl_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z16importedFuncTmplI21ExplicitDecl_ImportedEvv() +// GO1-DAG: define available_externally void @_Z16importedFuncTmplI21ExplicitDecl_ImportedEvv() extern template void importedFuncTmpl<ExplicitDecl_Imported>(); USE(importedFuncTmpl<ExplicitDecl_Imported>) // Import explicit instantiation definition of an imported function template. // MSC-DAG: declare dllimport void @"\01??$importedFuncTmpl@UExplicitInst_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z16importedFuncTmplI21ExplicitInst_ImportedEvv() +// GNU-DAG: define weak_odr void @_Z16importedFuncTmplI21ExplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$importedFuncTmpl@UExplicitInst_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z16importedFuncTmplI21ExplicitInst_ImportedEvv() +// GO1-DAG: define weak_odr void @_Z16importedFuncTmplI21ExplicitInst_ImportedEvv() template void importedFuncTmpl<ExplicitInst_Imported>(); USE(importedFuncTmpl<ExplicitInst_Imported>) @@ -442,9 +456,9 @@ USE(importedFuncTmplDecl<ExplicitSpec_Imported>) #endif // MSC-DAG: declare dllimport void @"\01??$importedFuncTmplDecl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z20importedFuncTmplDeclI31ExplicitSpec_InlineDef_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z20importedFuncTmplDeclI31ExplicitSpec_InlineDef_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$importedFuncTmplDecl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z20importedFuncTmplDeclI31ExplicitSpec_InlineDef_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z20importedFuncTmplDeclI31ExplicitSpec_InlineDef_ImportedEvv() template<> __declspec(dllimport) inline void importedFuncTmplDecl<ExplicitSpec_InlineDef_Imported>() {} USE(importedFuncTmplDecl<ExplicitSpec_InlineDef_Imported>) @@ -462,9 +476,9 @@ USE(importedFuncTmpl<ExplicitSpec_Imported>) #endif // MSC-DAG: declare dllimport void @"\01??$importedFuncTmpl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z16importedFuncTmplI31ExplicitSpec_InlineDef_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z16importedFuncTmplI31ExplicitSpec_InlineDef_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$importedFuncTmpl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z16importedFuncTmplI31ExplicitSpec_InlineDef_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z16importedFuncTmplI31ExplicitSpec_InlineDef_ImportedEvv() template<> __declspec(dllimport) inline void importedFuncTmpl<ExplicitSpec_InlineDef_Imported>() {} USE(importedFuncTmpl<ExplicitSpec_InlineDef_Imported>) @@ -481,9 +495,9 @@ USE(importedFuncTmpl<ExplicitSpec_NotImported>) // MSC-DAG: declare dllimport void @"\01??$funcTmpl@UExplicitDecl_Imported@@@@YAXXZ"() // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmpl@UExplicitDecl_Imported@@@@YAXXZ"() // GNU-DAG: declare dllimport void @_Z8funcTmplI21ExplicitDecl_ImportedEvv() -// GNU-DAG: declare dllimport void @_Z14inlineFuncTmplI21ExplicitDecl_ImportedEvv() +// GNU-DAG: declare void @_Z14inlineFuncTmplI21ExplicitDecl_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmpl@UExplicitDecl_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z14inlineFuncTmplI21ExplicitDecl_ImportedEvv() +// GO1-DAG: define available_externally void @_Z14inlineFuncTmplI21ExplicitDecl_ImportedEvv() extern template __declspec(dllimport) void funcTmpl<ExplicitDecl_Imported>(); extern template __declspec(dllimport) void inlineFuncTmpl<ExplicitDecl_Imported>(); USE(funcTmpl<ExplicitDecl_Imported>) @@ -494,11 +508,11 @@ USE(inlineFuncTmpl<ExplicitDecl_Imported>) // MSC-DAG: declare dllimport void @"\01??$funcTmpl@UExplicitInst_Imported@@@@YAXXZ"() // MSC-DAG: declare dllimport void @"\01??$inlineFuncTmpl@UExplicitInst_Imported@@@@YAXXZ"() // GNU-DAG: declare dllimport void @_Z8funcTmplI21ExplicitInst_ImportedEvv() -// GNU-DAG: declare dllimport void @_Z14inlineFuncTmplI21ExplicitInst_ImportedEvv() +// GNU-DAG: define weak_odr void @_Z14inlineFuncTmplI21ExplicitInst_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$funcTmpl@UExplicitInst_Imported@@@@YAXXZ"() // MO1-DAG: define available_externally dllimport void @"\01??$inlineFuncTmpl@UExplicitInst_Imported@@@@YAXXZ"() // GO1-DAG: define available_externally dllimport void @_Z8funcTmplI21ExplicitInst_ImportedEvv() -// GO1-DAG: define available_externally dllimport void @_Z14inlineFuncTmplI21ExplicitInst_ImportedEvv() +// GO1-DAG: define weak_odr void @_Z14inlineFuncTmplI21ExplicitInst_ImportedEvv() template __declspec(dllimport) void funcTmpl<ExplicitInst_Imported>(); template __declspec(dllimport) void inlineFuncTmpl<ExplicitInst_Imported>(); USE(funcTmpl<ExplicitInst_Imported>) @@ -519,9 +533,9 @@ USE(funcTmpl<ExplicitSpec_Imported>) #endif // MSC-DAG: declare dllimport void @"\01??$funcTmpl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GNU-DAG: declare dllimport void @_Z8funcTmplI31ExplicitSpec_InlineDef_ImportedEvv() +// GNU-DAG: define linkonce_odr void @_Z8funcTmplI31ExplicitSpec_InlineDef_ImportedEvv() // MO1-DAG: define available_externally dllimport void @"\01??$funcTmpl@UExplicitSpec_InlineDef_Imported@@@@YAXXZ"() -// GO1-DAG: define available_externally dllimport void @_Z8funcTmplI31ExplicitSpec_InlineDef_ImportedEvv() +// GO1-DAG: define linkonce_odr void @_Z8funcTmplI31ExplicitSpec_InlineDef_ImportedEvv() template<> __declspec(dllimport) inline void funcTmpl<ExplicitSpec_InlineDef_Imported>() {} USE(funcTmpl<ExplicitSpec_InlineDef_Imported>) @@ -658,18 +672,56 @@ namespace PR19933 { // MSC-DAG: @"\01?y@?$D@$0CK@@PR19933@@2HA" = available_externally dllimport global i32 0 } +namespace PR21355 { + struct __declspec(dllimport) S { + virtual ~S(); + }; + S::~S() {} + + // S::~S is a key function, so we would ordinarily emit a strong definition for + // the vtable. However, S is imported, so the vtable should be too. + + // GNU-DAG: @_ZTVN7PR213551SE = available_externally dllimport unnamed_addr constant [4 x i8*] +} + +namespace PR21366 { + struct __declspec(dllimport) S { + void outOfLineMethod(); + void inlineMethod() {} + inline void anotherInlineMethod(); + void outOfClassInlineMethod(); + }; + void S::anotherInlineMethod() {} + inline void S::outOfClassInlineMethod() {} +} + // MS ignores DLL attributes on partial specializations. template <typename T> struct PartiallySpecializedClassTemplate {}; -template <typename T> struct __declspec(dllimport) PartiallySpecializedClassTemplate<T*> { void f() {} }; +template <typename T> struct __declspec(dllimport) PartiallySpecializedClassTemplate<T*> { void f(); }; USEMEMFUNC(PartiallySpecializedClassTemplate<void*>, f); -// M32-DAG: define linkonce_odr x86_thiscallcc void @"\01?f@?$PartiallySpecializedClassTemplate@PAX@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN33PartiallySpecializedClassTemplateIPvE1fEv +// M32-DAG: declare x86_thiscallcc void @"\01?f@?$PartiallySpecializedClassTemplate@PAX@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN33PartiallySpecializedClassTemplateIPvE1fEv +// Attributes on explicit specializations are honored. template <typename T> struct ExplicitlySpecializedClassTemplate {}; -template <> struct __declspec(dllimport) ExplicitlySpecializedClassTemplate<void*> { void f() {} }; +template <> struct __declspec(dllimport) ExplicitlySpecializedClassTemplate<void*> { void f(); }; USEMEMFUNC(ExplicitlySpecializedClassTemplate<void*>, f); -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?f@?$ExplicitlySpecializedClassTemplate@PAX@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN34ExplicitlySpecializedClassTemplateIPvE1fEv +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?f@?$ExplicitlySpecializedClassTemplate@PAX@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN34ExplicitlySpecializedClassTemplateIPvE1fEv + +// MS inherits DLL attributes to partial specializations. +template <typename T> struct __declspec(dllimport) PartiallySpecializedImportedClassTemplate {}; +template <typename T> struct PartiallySpecializedImportedClassTemplate<T*> { void f() {} }; +USEMEMFUNC(PartiallySpecializedImportedClassTemplate<void*>, f); +// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?f@?$PartiallySpecializedImportedClassTemplate@PAX@@QAEXXZ" +// G32-DAG: define linkonce_odr x86_thiscallcc void @_ZN41PartiallySpecializedImportedClassTemplateIPvE1fEv + +// Attributes on the instantiation take precedence over attributes on the template. +template <typename T> struct __declspec(dllexport) ExplicitlyInstantiatedWithDifferentAttr { void f() {} }; +template struct __declspec(dllimport) ExplicitlyInstantiatedWithDifferentAttr<int>; +USEMEMFUNC(ExplicitlyInstantiatedWithDifferentAttr<int>, f); +// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?f@?$ExplicitlyInstantiatedWithDifferentAttr@H@@QAEXXZ" + //===----------------------------------------------------------------------===// // Classes with template base classes @@ -677,20 +729,20 @@ USEMEMFUNC(ExplicitlySpecializedClassTemplate<void*>, f); template <typename T> struct ClassTemplate { void func() {} }; template <typename T> struct __declspec(dllexport) ExportedClassTemplate { void func() {} }; -template <typename T> struct __declspec(dllimport) ImportedClassTemplate { void func() {} }; +template <typename T> struct __declspec(dllimport) ImportedClassTemplate { void func(); }; template <typename T> struct ExplicitlySpecializedTemplate { void func() {} }; template <> struct ExplicitlySpecializedTemplate<int> { void func() {} }; template <typename T> struct ExplicitlyExportSpecializedTemplate { void func() {} }; template <> struct __declspec(dllexport) ExplicitlyExportSpecializedTemplate<int> { void func() {} }; template <typename T> struct ExplicitlyImportSpecializedTemplate { void func() {} }; -template <> struct __declspec(dllimport) ExplicitlyImportSpecializedTemplate<int> { void func() {} }; +template <> struct __declspec(dllimport) ExplicitlyImportSpecializedTemplate<int> { void func(); }; template <typename T> struct ExplicitlyInstantiatedTemplate { void func() {} }; template struct ExplicitlyInstantiatedTemplate<int>; template <typename T> struct ExplicitlyExportInstantiatedTemplate { void func() {} }; template struct __declspec(dllexport) ExplicitlyExportInstantiatedTemplate<int>; -template <typename T> struct ExplicitlyImportInstantiatedTemplate { void func() {} }; +template <typename T> struct ExplicitlyImportInstantiatedTemplate { void func(); }; template struct __declspec(dllimport) ExplicitlyImportInstantiatedTemplate<int>; @@ -703,7 +755,7 @@ USEMEMFUNC(ClassTemplate<int>, func) // ImportedTemplate is explicitly imported. struct __declspec(dllimport) DerivedFromImportedTemplate : public ImportedClassTemplate<int> {}; USEMEMFUNC(ImportedClassTemplate<int>, func) -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ImportedClassTemplate@H@@QAEXXZ" +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?func@?$ImportedClassTemplate@H@@QAEXXZ" // G32-DAG: declare dllimport x86_thiscallcc void @_ZN21ImportedClassTemplateIiE4funcEv // ExportedTemplate is explicitly exported. @@ -741,8 +793,8 @@ USEMEMFUNC(ExplicitlyExportSpecializedTemplate<int>, func) // Base class already specialized with import attribute. struct __declspec(dllimport) DerivedFromExplicitlyImportSpecializedTemplate : public ExplicitlyImportSpecializedTemplate<int> {}; USEMEMFUNC(ExplicitlyImportSpecializedTemplate<int>, func) -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportSpecializedTemplate@H@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN35ExplicitlyImportSpecializedTemplateIiE4funcEv +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportSpecializedTemplate@H@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN35ExplicitlyImportSpecializedTemplateIiE4funcEv // Base class already instantiated without dll attribute. struct __declspec(dllimport) DerivedFromExplicitlyInstantiatedTemplate : public ExplicitlyInstantiatedTemplate<int> {}; @@ -759,8 +811,8 @@ USEMEMFUNC(ExplicitlyExportInstantiatedTemplate<int>, func) // Base class already instantiated with import attribute. struct __declspec(dllimport) DerivedFromExplicitlyImportInstantiatedTemplate : public ExplicitlyImportInstantiatedTemplate<int> {}; USEMEMFUNC(ExplicitlyImportInstantiatedTemplate<int>, func) -// M32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportInstantiatedTemplate@H@@QAEXXZ" -// G32-DAG: {{declare|define available_externally}} dllimport x86_thiscallcc void @_ZN36ExplicitlyImportInstantiatedTemplateIiE4funcEv +// M32-DAG: declare dllimport x86_thiscallcc void @"\01?func@?$ExplicitlyImportInstantiatedTemplate@H@@QAEXXZ" +// G32-DAG: declare dllimport x86_thiscallcc void @_ZN36ExplicitlyImportInstantiatedTemplateIiE4funcEv // MS: A dll attribute propagates through multiple levels of instantiation. template <typename T> struct TopClass { void func() {} }; diff --git a/test/CodeGenCXX/duplicate-mangled-name.cpp b/test/CodeGenCXX/duplicate-mangled-name.cpp index 65bfa22ac621..e57012e8c414 100644 --- a/test/CodeGenCXX/duplicate-mangled-name.cpp +++ b/test/CodeGenCXX/duplicate-mangled-name.cpp @@ -4,7 +4,7 @@ class MyClass { static void meth(); }; -void MyClass::meth() { } +void MyClass::meth() { } // expected-note {{previous}} extern "C" { void _ZN7MyClass4methEv() { } // expected-error {{definition with same mangled name as another definition}} } diff --git a/test/CodeGenCXX/explicit-instantiation.cpp b/test/CodeGenCXX/explicit-instantiation.cpp index 5bd06784cfab..6076444c25b0 100644 --- a/test/CodeGenCXX/explicit-instantiation.cpp +++ b/test/CodeGenCXX/explicit-instantiation.cpp @@ -90,6 +90,19 @@ namespace LateInstantiation { // CHECK-OPT: define available_externally i32 @_ZN17LateInstantiation1fIiEEiv( } +namespace PR21718 { +// The linkage of a used constexpr member function can change from linkonce_odr +// to weak_odr after explicit instantiation without errors about defining the +// same function twice. +template <typename T> +struct S { +// CHECK-LABEL: define weak_odr i32 @_ZN7PR217181SIiE1fEv + __attribute__((used)) constexpr int f() { return 0; } +}; +int g() { return S<int>().f(); } +template struct S<int>; +} + // Check that we emit definitions from explicit instantiations even when they // occur prior to the definition itself. template <typename T> struct S { diff --git a/test/CodeGenCXX/extern-c.cpp b/test/CodeGenCXX/extern-c.cpp index fefb216ea1c0..7852644d2b74 100644 --- a/test/CodeGenCXX/extern-c.cpp +++ b/test/CodeGenCXX/extern-c.cpp @@ -59,10 +59,10 @@ extern "C" { // CHECK-NOT: @unused // CHECK-NOT: @duplicate_internal - // CHECK: @internal_var = alias internal i32* @_Z12internal_var + // CHECK: @internal_var = internal alias i32* @_Z12internal_var // CHECK-NOT: @unused // CHECK-NOT: @duplicate_internal - // CHECK: @internal_fn = alias internal i32 ()* @_Z11internal_fnv + // CHECK: @internal_fn = internal alias i32 ()* @_Z11internal_fnv // CHECK-NOT: @unused // CHECK-NOT: @duplicate_internal } diff --git a/test/CodeGenCXX/field-access-debug-info.cpp b/test/CodeGenCXX/field-access-debug-info.cpp index aed4ee5f3a77..2b5b53dcbd84 100644 --- a/test/CodeGenCXX/field-access-debug-info.cpp +++ b/test/CodeGenCXX/field-access-debug-info.cpp @@ -1,7 +1,7 @@ // RUN: %clang -g -S -emit-llvm %s -o - | FileCheck %s -// CHECK: [ DW_TAG_member ] [p] [{{[^]]*}}] [from int] -// CHECK: [ DW_TAG_member ] [pr] [{{[^]]*}}] [private] [from int] +// CHECK: [ DW_TAG_member ] [p] [{{[^]]*}}] [public] [from int] +// CHECK: [ DW_TAG_member ] [pr] [{{[^]]*}}] [from int] class A { public: diff --git a/test/CodeGenCXX/funcsig.cpp b/test/CodeGenCXX/funcsig.cpp index 684a796c1905..2a6e641aec9c 100644 --- a/test/CodeGenCXX/funcsig.cpp +++ b/test/CodeGenCXX/funcsig.cpp @@ -8,7 +8,7 @@ extern "C" int printf(const char *, ...); void freeFunc(int *, char) { printf("__FUNCSIG__ %s\n\n", __FUNCSIG__); } -// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __cdecl freeFunc(int *, char)\00" +// CHECK: @"\01??_C@_0CD@KLGMNNL@void?5__cdecl?5freeFunc?$CIint?5?$CK?0?5cha@" = linkonce_odr unnamed_addr constant [{{.*}} x i8] c"void __cdecl freeFunc(int *, char)\00" struct TopLevelClass { void topLevelMethod(int *, char); @@ -16,7 +16,7 @@ struct TopLevelClass { void TopLevelClass::topLevelMethod(int *, char) { printf("__FUNCSIG__ %s\n\n", __FUNCSIG__); } -// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __thiscall TopLevelClass::topLevelMethod(int *, char)\00" +// CHECK: @"\01??_C@_0DL@OBHNMDP@void?5__thiscall?5TopLevelClass?3?3t@" = linkonce_odr unnamed_addr constant [{{.*}} x i8] c"void __thiscall TopLevelClass::topLevelMethod(int *, char)\00" namespace NS { struct NamespacedClass { @@ -25,5 +25,5 @@ struct NamespacedClass { void NamespacedClass::namespacedMethod(int *, char) { printf("__FUNCSIG__ %s\n\n", __FUNCSIG__); } -// CHECK: private unnamed_addr constant [{{.*}} x i8] c"void __thiscall NS::NamespacedClass::namespacedMethod(int *, char)\00" +// CHECK: @"\01??_C@_0ED@PFDKIEBA@void?5__thiscall?5NS?3?3NamespacedCl@" = linkonce_odr unnamed_addr constant [{{.*}} x i8] c"void __thiscall NS::NamespacedClass::namespacedMethod(int *, char)\00" } diff --git a/test/CodeGenCXX/function-template-specialization.cpp b/test/CodeGenCXX/function-template-specialization.cpp index eb099df14d00..7728f3dc7462 100644 --- a/test/CodeGenCXX/function-template-specialization.cpp +++ b/test/CodeGenCXX/function-template-specialization.cpp @@ -1,4 +1,8 @@ // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - | FileCheck %s + +// CHECK-DAG: _ZZN7PR219047GetDataIiEERKibE1i = internal global i32 4 +// CHECK-DAG: _ZZN7PR219047GetDataIiEERKibE1i_0 = internal global i32 2 + template<typename T, typename U> T* next(T* ptr, const U& diff); @@ -24,3 +28,18 @@ void test2(int *iptr, double *dptr, int diff) { // CHECK: _Z4nextIdiEPT_S1_RKT0_ dptr = next(dptr, diff); } + +namespace PR21904 { +template <typename> +const int &GetData(bool); + +template <> +const int &GetData<int>(bool b) { + static int i = 4; + if (b) { + static int i = 2; + return i; + } + return i; +} +} diff --git a/test/CodeGenCXX/globalinit-loc.cpp b/test/CodeGenCXX/globalinit-loc.cpp index eb39aec94d48..583f9c75fa53 100644 --- a/test/CodeGenCXX/globalinit-loc.cpp +++ b/test/CodeGenCXX/globalinit-loc.cpp @@ -6,8 +6,8 @@ // // CHECK: define internal void @_GLOBAL__sub_I_globalinit_loc.cpp // CHECK: !dbg ![[DBG:.*]] -// CHECK: "_GLOBAL__sub_I_globalinit_loc.cpp", i32 0, {{.*}}, i32 0} ; [ DW_TAG_subprogram ] [line 0] [local] [def] -// CHECK: ![[DBG]] = metadata !{i32 0, i32 0, +// CHECK: !"0x2e\00\00\00_GLOBAL__sub_I_globalinit_loc.cpp\000\00{{.*}}\000", {{.*}} ; [ DW_TAG_subprogram ] [line 0] [local] [def] +// CHECK: ![[DBG]] = !MDLocation(line: 0, # 99 "someheader.h" class A { public: diff --git a/test/CodeGenCXX/homogeneous-aggregates.cpp b/test/CodeGenCXX/homogeneous-aggregates.cpp new file mode 100644 index 000000000000..94813f357884 --- /dev/null +++ b/test/CodeGenCXX/homogeneous-aggregates.cpp @@ -0,0 +1,106 @@ +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=PPC +// RUN: %clang_cc1 -mfloat-abi hard -triple armv7-unknown-linux-gnueabi -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM32 +// RUN: %clang_cc1 -mfloat-abi hard -triple aarch64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM64 +// RUN: %clang_cc1 -mfloat-abi hard -triple x86_64-unknown-windows-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=X64 + +#if defined(__x86_64__) +#define CC __attribute__((vectorcall)) +#else +#define CC +#endif + +// Test that C++ classes are correctly classified as homogeneous aggregates. + +struct Base1 { + int x; +}; +struct Base2 { + double x; +}; +struct Base3 { + double x; +}; +struct D1 : Base1 { // non-homogeneous aggregate + double y, z; +}; +struct D2 : Base2 { // homogeneous aggregate + double y, z; +}; +struct D3 : Base1, Base2 { // non-homogeneous aggregate + double y, z; +}; +struct D4 : Base2, Base3 { // homogeneous aggregate + double y, z; +}; + +struct I1 : Base2 {}; +struct I2 : Base2 {}; +struct I3 : Base2 {}; +struct D5 : I1, I2, I3 {}; // homogeneous aggregate + +// PPC: define void @_Z7func_D12D1(%struct.D1* noalias sret %agg.result, [3 x i64] %x.coerce) +// ARM32: define arm_aapcs_vfpcc void @_Z7func_D12D1(%struct.D1* noalias sret %agg.result, [3 x i64] %x.coerce) +// ARM64: define void @_Z7func_D12D1(%struct.D1* noalias sret %agg.result, %struct.D1* %x) +// X64: define x86_vectorcallcc void @"\01_Z7func_D12D1@@24"(%struct.D1* noalias sret %agg.result, %struct.D1* %x) +D1 CC func_D1(D1 x) { return x; } + +// PPC: define [3 x double] @_Z7func_D22D2([3 x double] %x.coerce) +// ARM32: define arm_aapcs_vfpcc %struct.D2 @_Z7func_D22D2(%struct.D2 %x.coerce) +// ARM64: define %struct.D2 @_Z7func_D22D2([3 x double] %x.coerce) +// X64: define x86_vectorcallcc %struct.D2 @"\01_Z7func_D22D2@@24"(double %x.0, double %x.1, double %x.2) +D2 CC func_D2(D2 x) { return x; } + +// PPC: define void @_Z7func_D32D3(%struct.D3* noalias sret %agg.result, [4 x i64] %x.coerce) +// ARM32: define arm_aapcs_vfpcc void @_Z7func_D32D3(%struct.D3* noalias sret %agg.result, [4 x i64] %x.coerce) +// ARM64: define void @_Z7func_D32D3(%struct.D3* noalias sret %agg.result, %struct.D3* %x) +D3 CC func_D3(D3 x) { return x; } + +// PPC: define [4 x double] @_Z7func_D42D4([4 x double] %x.coerce) +// ARM32: define arm_aapcs_vfpcc %struct.D4 @_Z7func_D42D4(%struct.D4 %x.coerce) +// ARM64: define %struct.D4 @_Z7func_D42D4([4 x double] %x.coerce) +D4 CC func_D4(D4 x) { return x; } + +D5 CC func_D5(D5 x) { return x; } +// PPC: define [3 x double] @_Z7func_D52D5([3 x double] %x.coerce) +// ARM32: define arm_aapcs_vfpcc %struct.D5 @_Z7func_D52D5(%struct.D5 %x.coerce) + +// The C++ multiple inheritance expansion case is a little more complicated, so +// do some extra checking. +// +// ARM64-LABEL: define %struct.D5 @_Z7func_D52D5([3 x double] %x.coerce) +// ARM64: bitcast %struct.D5* %{{.*}} to [3 x double]* +// ARM64: store [3 x double] %x.coerce, [3 x double]* + +void call_D5(D5 *p) { + func_D5(*p); +} + +// Check the call site. +// +// ARM64-LABEL: define void @_Z7call_D5P2D5(%struct.D5* %p) +// ARM64: load [3 x double]* +// ARM64: call %struct.D5 @_Z7func_D52D5([3 x double] %{{.*}}) + +struct Empty { }; +struct Float1 { float x; }; +struct Float2 { float y; }; +struct HVAWithEmptyBase : Float1, Empty, Float2 { float z; }; + +// PPC: define void @_Z15with_empty_base16HVAWithEmptyBase([3 x float] %a.coerce) +// ARM64: define void @_Z15with_empty_base16HVAWithEmptyBase([3 x float] %a.coerce) +// ARM32: define arm_aapcs_vfpcc void @_Z15with_empty_base16HVAWithEmptyBase(%struct.HVAWithEmptyBase %a.coerce) +void CC with_empty_base(HVAWithEmptyBase a) {} + +// FIXME: MSVC doesn't consider this an HVA becuase of the empty base. +// X64: define x86_vectorcallcc void @"\01_Z15with_empty_base16HVAWithEmptyBase@@16"(float %a.0, float %a.1, float %a.2) + +struct HVAWithEmptyBitField : Float1, Float2 { + int : 0; // Takes no space. + float z; +}; + +// PPC: define void @_Z19with_empty_bitfield20HVAWithEmptyBitField([3 x float] %a.coerce) +// ARM64: define void @_Z19with_empty_bitfield20HVAWithEmptyBitField([3 x float] %a.coerce) +// ARM32: define arm_aapcs_vfpcc void @_Z19with_empty_bitfield20HVAWithEmptyBitField(%struct.HVAWithEmptyBitField %a.coerce) +// X64: define x86_vectorcallcc void @"\01_Z19with_empty_bitfield20HVAWithEmptyBitField@@16"(float %a.0, float %a.1, float %a.2) +void CC with_empty_bitfield(HVAWithEmptyBitField a) {} diff --git a/test/CodeGenCXX/lambda-expressions.cpp b/test/CodeGenCXX/lambda-expressions.cpp index 2f9a4f2d4f55..49b9efbdaba2 100644 --- a/test/CodeGenCXX/lambda-expressions.cpp +++ b/test/CodeGenCXX/lambda-expressions.cpp @@ -81,7 +81,7 @@ int g() { }; // PR14773 -// CHECK: [[ARRVAL:%[0-9a-zA-Z]*]] = load i32* getelementptr inbounds ([0 x i32]* bitcast (<{}>* @_ZZ14staticarrayrefvE5array to [0 x i32]*), i32 0, i64 0), align 4 +// CHECK: [[ARRVAL:%[0-9a-zA-Z]*]] = load i32* getelementptr inbounds ([0 x i32]* @_ZZ14staticarrayrefvE5array, i32 0, i64 0), align 4 // CHECK-NEXT: store i32 [[ARRVAL]] void staticarrayref(){ static int array[] = {}; @@ -91,9 +91,17 @@ void staticarrayref(){ }(); } -// CHECK: define internal void @"_ZZ1hvEN3$_88__invokeEv"(%struct.A* noalias sret %agg.result) {{.*}} { +// CHECK-LABEL: define internal i32* @"_ZZ11PR22071_funvENK3$_8clEv" +// CHECK: ret i32* @PR22071_var +int PR22071_var; +int *PR22071_fun() { + constexpr int &y = PR22071_var; + return [&] { return &y; }(); +} + +// CHECK: define internal void @"_ZZ1hvEN3$_98__invokeEv"(%struct.A* noalias sret %agg.result) {{.*}} { // CHECK-NOT: = -// CHECK: call void @"_ZZ1hvENK3$_8clEv"(%struct.A* sret %agg.result, +// CHECK: call void @"_ZZ1hvENK3$_9clEv"(%struct.A* sret %agg.result, // CHECK-NEXT: ret void struct A { ~A(); }; void h() { diff --git a/test/CodeGenCXX/linetable-cleanup.cpp b/test/CodeGenCXX/linetable-cleanup.cpp index ce7f2c674ba5..3a6aa88d9464 100644 --- a/test/CodeGenCXX/linetable-cleanup.cpp +++ b/test/CodeGenCXX/linetable-cleanup.cpp @@ -24,15 +24,15 @@ int foo() C c; c.i = 42; // This breakpoint should be at/before the cleanup code. - // CHECK: ![[CLEANUP]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[CLEANUP]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return 0; - // CHECK: ![[RET]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } void bar() { if (!foo()) - // CHECK: {{.*}} = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: {{.*}} = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return; if (foo()) { @@ -40,21 +40,21 @@ void bar() c.i = foo(); } // Clang creates only a single ret instruction. Make sure it is at a useful line. - // CHECK: ![[RETBAR]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RETBAR]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } void baz() { if (!foo()) - // CHECK: ![[SCOPE1:.*]] = metadata !{{{.*}}, i32 [[@LINE-1]], {{.*}}} ; [ DW_TAG_lexical_block ] - // CHECK: {{.*}} = metadata !{i32 [[@LINE+1]], i32 0, metadata ![[SCOPE1]], null} + // CHECK: ![[SCOPE1:.*]] = !{!"0xb\00[[@LINE-1]]\00{{.*}}", {{.*}} ; [ DW_TAG_lexical_block ] + // CHECK: {{.*}} = !MDLocation(line: [[@LINE+1]], scope: ![[SCOPE1]]) return; if (foo()) { // no cleanup - // CHECK: {{.*}} = metadata !{i32 [[@LINE+2]], i32 0, metadata ![[SCOPE2:.*]], null} - // CHECK: ![[SCOPE2]] = metadata !{{{.*}}, i32 [[@LINE-3]], {{.*}}} ; [ DW_TAG_lexical_block ] + // CHECK: {{.*}} = !MDLocation(line: [[@LINE+2]], scope: ![[SCOPE2:.*]]) + // CHECK: ![[SCOPE2]] = !{!"0xb\00[[@LINE-3]]\00{{.*}}", {{.*}} ; [ DW_TAG_lexical_block ] return; } - // CHECK: ![[RETBAZ]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RETBAZ]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } diff --git a/test/CodeGenCXX/linetable-eh.cpp b/test/CodeGenCXX/linetable-eh.cpp index 14a5067cf3ea..6d9b3a968ca6 100644 --- a/test/CodeGenCXX/linetable-eh.cpp +++ b/test/CodeGenCXX/linetable-eh.cpp @@ -4,18 +4,18 @@ // entries for the code that triggered it. // CHECK: call void @llvm.dbg.declare -// CHECK: call void @llvm.dbg.declare(metadata !{{{.*}}}, metadata ![[CURRENT_ADDR:.*]]), !dbg ![[DBG1:.*]] +// CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[CURRENT_ADDR:.*]], metadata !{{.*}}), !dbg ![[DBG1:.*]] // CHECK: unwind label %{{.*}}, !dbg ![[DBG1]] // CHECK: store i64 %{{.*}}, i64* %current_address, align 8, !dbg ![[DBG4:.*]] -// CHECK-NEXT: call void @llvm.dbg.declare(metadata !{{{.*}}}, metadata ![[FOUND_IT:.*]]), !dbg ![[DBG2:.*]] +// CHECK-NEXT: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[FOUND_IT:.*]], metadata !{{.*}}), !dbg ![[DBG2:.*]] // CHECK: = landingpad // CHECK-NEXT: cleanup, !dbg ![[DBG3:.*]] // CHECK-DAG: ![[CURRENT_ADDR]] = {{.*}} [current_address] // CHECK-DAG: ![[FOUND_IT]] = {{.*}} [found_it] -// CHECK-DAG: ![[DBG1]] = metadata !{i32 256, -// CHECK-DAG: ![[DBG2]] = metadata !{i32 257, -// CHECK-DAG: ![[DBG3]] = metadata !{i32 268, -// CHECK-DAG: ![[DBG4]] = metadata !{i32 256, +// CHECK-DAG: ![[DBG1]] = !MDLocation(line: 256, +// CHECK-DAG: ![[DBG2]] = !MDLocation(line: 257, +// CHECK-DAG: ![[DBG3]] = !MDLocation(line: 268, +// CHECK-DAG: ![[DBG4]] = !MDLocation(line: 256, typedef unsigned long long uint64_t; template<class _Tp> class shared_ptr { public: diff --git a/test/CodeGenCXX/linetable-fnbegin.cpp b/test/CodeGenCXX/linetable-fnbegin.cpp index ce46306fed0d..b0a03f7c2067 100644 --- a/test/CodeGenCXX/linetable-fnbegin.cpp +++ b/test/CodeGenCXX/linetable-fnbegin.cpp @@ -4,10 +4,10 @@ // CHECK: define{{.*}}bar // CHECK-NOT: define // CHECK: ret {{.*}}, !dbg [[DBG:.*]] -// CHECK: [[HPP:.*]] = metadata !{metadata !"./template.hpp", -// CHECK: [[SP:.*]] = metadata !{i32 786478, metadata [[HPP]],{{.*}}[ DW_TAG_subprogram ] [line 22] [def] [bar] +// CHECK: [[HPP:.*]] = !{!"./template.hpp", +// CHECK: [[SP:.*]] = !{!"0x2e\00{{.*}}", [[HPP]],{{.*}}[ DW_TAG_subprogram ] [line 22] [def] [bar] // We shouldn't need a lexical block for this function. -// CHECK: [[DBG]] = metadata !{i32 23, i32 0, metadata [[SP]], null} +// CHECK: [[DBG]] = !MDLocation(line: 23, scope: [[SP]]) # 1 "./template.h" 1 diff --git a/test/CodeGenCXX/lpad-linetable.cpp b/test/CodeGenCXX/lpad-linetable.cpp index dba2ad63b2dd..c81191b9fedd 100644 --- a/test/CodeGenCXX/lpad-linetable.cpp +++ b/test/CodeGenCXX/lpad-linetable.cpp @@ -4,7 +4,7 @@ // CHECK: ret i32 // CHECK: landingpad {{.*}} // CHECK-NEXT: !dbg ![[LPAD:[0-9]+]] -// CHECK: ![[LPAD]] = metadata !{i32 24, i32 0, metadata !{{.*}}, null} +// CHECK: ![[LPAD]] = !MDLocation(line: 24, scope: !{{.*}}) # 1 "/usr/include/c++/4.2.1/vector" 1 3 typedef long unsigned int __darwin_size_t; diff --git a/test/CodeGenCXX/mangle-exprs.cpp b/test/CodeGenCXX/mangle-exprs.cpp index e935f51a46b2..ee7f24466b00 100644 --- a/test/CodeGenCXX/mangle-exprs.cpp +++ b/test/CodeGenCXX/mangle-exprs.cpp @@ -56,6 +56,18 @@ namespace Casts { void static_(typename enable_if< O <= static_cast<unsigned>(4) >::type* = 0) { } + template <unsigned O, typename T> + void reinterpret_(typename enable_if<O <= sizeof(reinterpret_cast<T *>(0))>::type * = 0) { + } + + template <typename T, T *p> + void const_(typename enable_if<0 <= sizeof(const_cast<T *>(p))>::type * = 0) { + } + + template <typename T, T *p> + void dynamic_(typename enable_if<0 <= sizeof(dynamic_cast<T *>(p))>::type * = 0) { + } + template< typename T > void auto_(decltype(new auto(T()))) { } @@ -64,11 +76,12 @@ namespace Casts { void scalar_(decltype(T(), int())) { } - // FIXME: Test const_cast, reinterpret_cast, dynamic_cast, which are - // a bit harder to use in template arguments. template <unsigned N> struct T {}; template <int N> T<N> f() { return T<N>(); } + + extern int i; + extern struct S {} s; // CHECK-LABEL: define weak_odr void @_ZN5Casts8implicitILj4EEEvPN9enable_ifIXleT_Li4EEvE4typeE template void implicit<4>(void*); @@ -76,8 +89,14 @@ namespace Casts { template void cstyle<4>(void*); // CHECK-LABEL: define weak_odr void @_ZN5Casts10functionalILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE template void functional<4>(void*); - // CHECK-LABEL: define weak_odr void @_ZN5Casts7static_ILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE + // CHECK-LABEL: define weak_odr void @_ZN5Casts7static_ILj4EEEvPN9enable_ifIXleT_scjLi4EEvE4typeE template void static_<4>(void*); + // CHECK-LABEL: define weak_odr void @_ZN5Casts12reinterpret_ILj4EiEEvPN9enable_ifIXleT_szrcPT0_Li0EEvE4typeE + template void reinterpret_<4, int>(void*); + // CHECK-LABEL: define weak_odr void @_ZN5Casts6const_IiXadL_ZNS_1iEEEEEvPN9enable_ifIXleLi0EszccPT_T0_EvE4typeE + template void const_<int, &i>(void*); + // CHECK-LABEL: define weak_odr void @_ZN5Casts8dynamic_INS_1SEXadL_ZNS_1sEEEEEvPN9enable_ifIXleLi0EszdcPT_T0_EvE4typeE + template void dynamic_<struct S, &s>(void*); // CHECK-LABEL: define weak_odr void @_ZN5Casts1fILi6EEENS_1TIXT_EEEv template T<6> f<6>(); @@ -198,3 +217,79 @@ namespace test5 { template void a<int>(decltype(noexcept(int()))); // CHECK: void @_ZN5test51aIiEEvDTnxcvT__EE( } + +namespace test6 { + struct X { + int i; + }; + + struct Y { + union { + int i; + }; + }; + + struct Z { + union { + X ua; + Y ub; + }; + + struct { + X s; + }; + + union { + union { + struct { + struct { + X uuss; + }; + }; + }; + }; + }; + + Z z, *zp; + + template<typename T> + void f1(decltype(T(z.ua.i))) {} + template void f1<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f1IiEEvDTcvT_dtdtL_ZNS_1zEE2ua1iE + + template<typename T> + void f2(decltype(T(z.ub.i))) {} + template void f2<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f2IiEEvDTcvT_dtdtL_ZNS_1zEE2ub1iE + + template<typename T> + void f3(decltype(T(z.s.i))) {} + template void f3<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f3IiEEvDTcvT_dtdtL_ZNS_1zEE1s1iE + + template<typename T> + void f4(decltype(T(z.uuss.i))) {} + template void f4<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f4IiEEvDTcvT_dtdtL_ZNS_1zEE4uuss1iE + + template<typename T> + void f5(decltype(T(zp->ua.i))) {} + template void f5<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f5IiEEvDTcvT_dtptL_ZNS_2zpEE2ua1iE + + template<typename T> + void f6(decltype(T(zp->ub.i))) {} + template void f6<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f6IiEEvDTcvT_dtptL_ZNS_2zpEE2ub1iE + + template<typename T> + void f7(decltype(T(zp->s.i))) {} + template void f7<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f7IiEEvDTcvT_dtptL_ZNS_2zpEE1s1iE + + template<typename T> + void f8(decltype(T(zp->uuss.i))) {} + template void f8<int>(int); + // CHECK-LABEL: define weak_odr void @_ZN5test62f8IiEEvDTcvT_dtptL_ZNS_2zpEE4uuss1iE +} + diff --git a/test/CodeGenCXX/mangle-literal-suffix.cpp b/test/CodeGenCXX/mangle-literal-suffix.cpp new file mode 100644 index 000000000000..ab557d5a1bfa --- /dev/null +++ b/test/CodeGenCXX/mangle-literal-suffix.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -triple mips-none-none -emit-llvm -o - %s | FileCheck %s + +template <class T> void g3(char (&buffer)[sizeof(T() + 5.0)]) {} +template void g3<int>(char (&)[sizeof(double)]); +// CHECK: _Z2g3IiEvRAszplcvT__ELd4014000000000000E_c + +template <class T> void g4(char (&buffer)[sizeof(T() + 5.0L)]) {} +template void g4<int>(char (&)[sizeof(long double)]); +// CHECK: _Z2g4IiEvRAszplcvT__ELe4014000000000000E_c + +template <class T> void g5(char (&buffer)[sizeof(T() + 5)]) {} +template void g5<int>(char (&)[sizeof(int)]); +// CHECK: _Z2g5IiEvRAszplcvT__ELi5E_c + +template <class T> void g6(char (&buffer)[sizeof(T() + 5L)]) {} +template void g6<int>(char (&)[sizeof(long int)]); +// CHECK: _Z2g6IiEvRAszplcvT__ELl5E_c diff --git a/test/CodeGenCXX/mangle-local-anonymous-unions.cpp b/test/CodeGenCXX/mangle-local-anonymous-unions.cpp new file mode 100644 index 000000000000..9187c1a5a27a --- /dev/null +++ b/test/CodeGenCXX/mangle-local-anonymous-unions.cpp @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -o - | FileCheck %s + +// CHECK-DAG: @_ZZ2f0vE1a +// CHECK-DAG: @_ZZ2f0vE1c +// CHECK-DAG: @_ZZ2f0vE1e_0 +inline int f0() { + static union { + int a; + long int b; + }; + + static union { + int c; + double d; + }; + + if (0) { + static union { + int e; + int f; + }; + } + static union { + int e; + int f; + }; + + return a+c; +} + +inline void nop() { + static union { + union { + }; + }; +} + +int f1 (int a, int c) { + nop(); + return a+c+f0(); +} + diff --git a/test/CodeGenCXX/mangle-ms-cxx11.cpp b/test/CodeGenCXX/mangle-ms-cxx11.cpp index 373d2b7b957f..fe7121ef24dc 100644 --- a/test/CodeGenCXX/mangle-ms-cxx11.cpp +++ b/test/CodeGenCXX/mangle-ms-cxx11.cpp @@ -1,8 +1,67 @@ // RUN: %clang_cc1 -std=c++11 -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s +namespace FTypeWithQuals { +template <typename T> +struct S {}; + +using A = int () const; +S<A> a; +// CHECK-DAG: @"\01?a@FTypeWithQuals@@3U?$S@$$A8@@BAHXZ@1@A" + +using B = int () volatile; +S<B> b; +// CHECK-DAG: @"\01?b@FTypeWithQuals@@3U?$S@$$A8@@CAHXZ@1@A" + +using C = int () __restrict; +S<C> c; +// CHECK-DAG: @"\01?c@FTypeWithQuals@@3U?$S@$$A8@@IAAHXZ@1@A" + +using D = int () const &; +S<D> d; +// CHECK-DAG: @"\01?d@FTypeWithQuals@@3U?$S@$$A8@@GBAHXZ@1@A" + +using E = int () volatile &; +S<E> e; +// CHECK-DAG: @"\01?e@FTypeWithQuals@@3U?$S@$$A8@@GCAHXZ@1@A" + +using F = int () __restrict &; +S<F> f; +// CHECK-DAG: @"\01?f@FTypeWithQuals@@3U?$S@$$A8@@IGAAHXZ@1@A" + +using G = int () const &&; +S<G> g; +// CHECK-DAG: @"\01?g@FTypeWithQuals@@3U?$S@$$A8@@HBAHXZ@1@A" + +using H = int () volatile &&; +S<H> h; +// CHECK-DAG: @"\01?h@FTypeWithQuals@@3U?$S@$$A8@@HCAHXZ@1@A" + +using I = int () __restrict &&; +S<I> i; +// CHECK-DAG: @"\01?i@FTypeWithQuals@@3U?$S@$$A8@@IHAAHXZ@1@A" + +using J = int (); +S<J> j; +// CHECK-DAG: @"\01?j@FTypeWithQuals@@3U?$S@$$A6AHXZ@1@A" + +using K = int () &; +S<K> k; +// CHECK-DAG: @"\01?k@FTypeWithQuals@@3U?$S@$$A8@@GAAHXZ@1@A" + +using L = int () &&; +S<L> l; +// CHECK-DAG: @"\01?l@FTypeWithQuals@@3U?$S@$$A8@@HAAHXZ@1@A" +} + // CHECK: "\01?DeducedType@@3HA" auto DeducedType = 30; +// CHECK-DAG: @"\01?Char16Var@@3_SA" +char16_t Char16Var; + +// CHECK-DAG: @"\01?Char32Var@@3_UA" +char32_t Char32Var; + // CHECK: "\01?LRef@@YAXAAH@Z" void LRef(int& a) { } @@ -98,7 +157,7 @@ namespace PR18022 { struct { } a; decltype(a) fun(decltype(a) x, decltype(a)) { return x; } -// CHECK-DAG: ?fun@PR18022@@YA?AU<unnamed-type-a>@1@U21@0@Z +// CHECK-DAG: @"\01?fun@PR18022@@YA?AU<unnamed-type-a>@1@U21@0@Z" } @@ -106,17 +165,32 @@ inline int define_lambda() { static auto lambda = [] { static int local; ++local; return local; }; // First, we have the static local variable of type "<lambda_1>" inside of // "define_lambda". -// CHECK-DAG: ?lambda@?1??define_lambda@@YAHXZ@4V<lambda_1>@@A +// CHECK-DAG: @"\01?lambda@?1??define_lambda@@YAHXZ@4V<lambda_1>@?1@YAHXZ@A" // Next, we have the "operator()" for "<lambda_1>" which is inside of // "define_lambda". -// CHECK-DAG: ??R<lambda_1>@?define_lambda@@YAHXZ@QBEHXZ +// CHECK-DAG: @"\01??R<lambda_1>@?define_lambda@@YAHXZ@QBEHXZ" // Finally, we have the local which is inside of "<lambda_1>" which is inside of // "define_lambda". Hooray. -// CHECK-DAG: ?local@?2???R<lambda_1>@?define_lambda@@YAHXZ@QBEHXZ@4HA +// CHECK-DAG: @"\01?local@?2???R<lambda_1>@?define_lambda@@YAHXZ@QBEHXZ@4HA" return lambda(); } +template <typename T> +void use_lambda_arg(T) {} + +inline void call_with_lambda_arg1() { + use_lambda_arg([]{}); + // CHECK-DAG: @"\01??$use_lambda_arg@V<lambda_1>@?call_with_lambda_arg1@@YAXXZ@@@YAXV<lambda_1>@?call_with_lambda_arg1@@YAXXZ@@Z" +} + +inline void call_with_lambda_arg2() { + use_lambda_arg([]{}); + // CHECK-DAG: @"\01??$use_lambda_arg@V<lambda_1>@?call_with_lambda_arg2@@YAXXZ@@@YAXV<lambda_1>@?call_with_lambda_arg2@@YAXXZ@@Z" +} + int call_lambda() { + call_with_lambda_arg1(); + call_with_lambda_arg2(); return define_lambda(); } @@ -139,3 +213,29 @@ void templ_fun_with_pack() {} template void templ_fun_with_pack<>(); // CHECK-DAG: @"\01??$templ_fun_with_pack@$S@@YAXXZ" + +template <typename...> +void templ_fun_with_ty_pack() {} + +template void templ_fun_with_ty_pack<>(); +// CHECK-DAG: @"\01??$templ_fun_with_ty_pack@$$V@@YAXXZ" + +template <template <class> class...> +void templ_fun_with_templ_templ_pack() {} + +template void templ_fun_with_templ_templ_pack<>(); +// CHECK-DAG: @"\01??$templ_fun_with_templ_templ_pack@$$V@@YAXXZ" + +namespace PR20047 { +template <typename T> +struct A {}; + +template <typename T> +using AliasA = A<T>; + +template <template <typename> class> +void f() {} + +template void f<AliasA>(); +// CHECK-DAG: @"\01??$f@$$YAliasA@PR20047@@@PR20047@@YAXXZ" +} diff --git a/test/CodeGenCXX/mangle-ms-cxx14.cpp b/test/CodeGenCXX/mangle-ms-cxx14.cpp index 03995611d252..c06efe2edee9 100644 --- a/test/CodeGenCXX/mangle-ms-cxx14.cpp +++ b/test/CodeGenCXX/mangle-ms-cxx14.cpp @@ -13,7 +13,7 @@ auto FunctionWithLocalType() { return LocalType{}; } -// CHECK: "\01?ValueFromFunctionWithLocalType@@3ULocalType@?0??FunctionWithLocalType@@YA?A?<auto>@@XZ@A" +// CHECK: "\01?ValueFromFunctionWithLocalType@@3ULocalType@?1??FunctionWithLocalType@@YA?A?<auto>@@XZ@A" auto ValueFromFunctionWithLocalType = FunctionWithLocalType(); // CHECK: "\01??R<lambda_0>@@QBE?A?<auto>@@XZ" @@ -22,7 +22,7 @@ auto LambdaWithLocalType = [] { return LocalType{}; }; -// CHECK: "\01?ValueFromLambdaWithLocalType@@3ULocalType@?0???R<lambda_0>@@QBE?A?<auto>@@XZ@A" +// CHECK: "\01?ValueFromLambdaWithLocalType@@3ULocalType@?1???R<lambda_0>@@QBE?A?<auto>@@XZ@A" auto ValueFromLambdaWithLocalType = LambdaWithLocalType(); template <typename T> diff --git a/test/CodeGenCXX/mangle-ms-string-literals.cpp b/test/CodeGenCXX/mangle-ms-string-literals.cpp index a77a04f71e0a..e5ebc086e148 100644 --- a/test/CodeGenCXX/mangle-ms-string-literals.cpp +++ b/test/CodeGenCXX/mangle-ms-string-literals.cpp @@ -719,3 +719,9 @@ const wchar_t *LongWideString = L"012345678901234567890123456789ABCDEF"; // CHECK: @"\01??_C@_1EK@KFPEBLPK@?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AAA?$AAB@" const wchar_t *UnicodeLiteral = L"\ud7ff"; // CHECK: @"\01??_C@_13IIHIAFKH@?W?$PP?$AA?$AA@" +const char *U8Literal = u8"hi"; +// CHECK: @"\01??_C@_02PCEFGMJL@hi?$AA@" +const char16_t *U16Literal = u"hi"; +// CHECK: @"\01??_C@_05OMLEGLOC@h?$AAi?$AA?$AA?$AA@" +const char32_t *U32Literal = U"hi"; +// CHECK: @"\01??_C@_0M@GFNAJIPG@h?$AA?$AA?$AAi?$AA?$AA?$AA?$AA?$AA?$AA?$AA@" diff --git a/test/CodeGenCXX/mangle-ms-templates.cpp b/test/CodeGenCXX/mangle-ms-templates.cpp index 31fda2046c4b..46ab251af14f 100644 --- a/test/CodeGenCXX/mangle-ms-templates.cpp +++ b/test/CodeGenCXX/mangle-ms-templates.cpp @@ -24,6 +24,12 @@ class IntTemplate { IntTemplate() {} }; +template<unsigned param> +class UnsignedIntTemplate { +public: + UnsignedIntTemplate() {} +}; + template<long long param> class LongLongTemplate { public: @@ -133,6 +139,10 @@ void template_mangling() { IntTemplate<-11> neg_11; // CHECK: call {{.*}} @"\01??0?$IntTemplate@$0?L@@@QAE@XZ" // X64: call {{.*}} @"\01??0?$IntTemplate@$0?L@@@QEAA@XZ" + + UnsignedIntTemplate<4294967295> ffffffff; +// CHECK: call {{.*}} @"\01??0?$UnsignedIntTemplate@$0PPPPPPPP@@@QAE@XZ" +// X64: call {{.*}} @"\01??0?$UnsignedIntTemplate@$0PPPPPPPP@@@QEAA@XZ" LongLongTemplate<-9223372036854775807LL-1LL> int64_min; // CHECK: call {{.*}} @"\01??0?$LongLongTemplate@$0?IAAAAAAAAAAAAAAA@@@QAE@XZ" diff --git a/test/CodeGenCXX/mangle-ms.cpp b/test/CodeGenCXX/mangle-ms.cpp index 3285c98546ec..662278b3034f 100644 --- a/test/CodeGenCXX/mangle-ms.cpp +++ b/test/CodeGenCXX/mangle-ms.cpp @@ -117,6 +117,19 @@ const volatile char foo2::*k; int (foo2::*l)(int); // CHECK-DAG: @"\01?l@@3P8foo@@AEHH@ZQ1@" +// Ensure typedef CV qualifiers are mangled correctly +typedef const int cInt; +typedef volatile int vInt; +typedef const volatile int cvInt; + +extern cInt g_cInt = 1; +vInt g_vInt = 2; +cvInt g_cvInt = 3; + +// CHECK-DAG: @"\01?g_cInt@@3HB" +// CHECK-DAG: @"\01?g_vInt@@3HC" +// CHECK-DAG: @"\01?g_cvInt@@3HD" + // Static functions are mangled, too. // Also make sure calling conventions, arglists, and throw specs work. static void __stdcall alpha(float a, double b) throw() {} @@ -365,3 +378,5 @@ void TypedefNewDelete::operator delete[](void *) { } // CHECK-DAG: ??3TypedefNewDelete@@SAXPAX@Z // CHECK-DAG: ??_VTypedefNewDelete@@SAXPAX@Z +void __vectorcall vector_func() { } +// CHECK-DAG: @"\01?vector_func@@YQXXZ" diff --git a/test/CodeGenCXX/mangle.cpp b/test/CodeGenCXX/mangle.cpp index 9bdac7f17289..9af0d9da9976 100644 --- a/test/CodeGenCXX/mangle.cpp +++ b/test/CodeGenCXX/mangle.cpp @@ -991,3 +991,25 @@ namespace test48 { template void f<S>(S::u *); // CHECK-LABEL: define weak_odr void @_ZN6test481fINS_1SEEEvPTuNT_1uE(%"union.test48::S::u"*) } + +namespace test49 { + template <int> + struct S {}; + + template <template <int> class T> + T<3> fin(T<3>); + + auto v = fin<S>; + // CHECK-LABEL: declare void @_ZN6test493finINS_1SEEET_ILi3EES3_() +} + +namespace test50 { + template <int> + struct S {}; + + template <template <int> class T> + T<3> fin(T<4>); + + auto v = fin<S>; + // CHECK-LABEL: declare void @_ZN6test503finINS_1SEEET_ILi3EES2_ILi4EE() +} diff --git a/test/CodeGenCXX/merge-functions.cpp b/test/CodeGenCXX/merge-functions.cpp new file mode 100644 index 000000000000..2137f19c409c --- /dev/null +++ b/test/CodeGenCXX/merge-functions.cpp @@ -0,0 +1,14 @@ +// REQUIRES: x86-registered-target +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -O1 -fmerge-functions -emit-llvm -o - -x c++ < %s | FileCheck %s + +// Basic functionality test. Function merging doesn't kick in on functions that +// are too simple. + +struct A { + virtual int f(int x, int *p) { return x ? *p : 1; } + virtual int g(int x, int *p) { return x ? *p : 1; } +} a; + +// CHECK: define {{.*}} @_ZN1A1gEiPi +// CHECK-NEXT: tail call i32 @_ZN1A1fEiPi +// CHECK-NEXT: ret diff --git a/test/CodeGenCXX/microsoft-abi-byval-sret.cpp b/test/CodeGenCXX/microsoft-abi-byval-sret.cpp index 985b1ce62e92..a34a2455c36f 100644 --- a/test/CodeGenCXX/microsoft-abi-byval-sret.cpp +++ b/test/CodeGenCXX/microsoft-abi-byval-sret.cpp @@ -5,25 +5,66 @@ struct A { A(const A &o) : a(o.a) {} ~A() {} int a; +}; + +struct B { A foo(A o); + A __cdecl bar(A o); + A __stdcall baz(A o); + A __fastcall qux(A o); }; -A A::foo(A x) { - A y(*this); - y.a += x.a; - return y; +A B::foo(A x) { + return x; } -// CHECK-LABEL: define x86_thiscallcc %struct.A* @"\01?foo@A@@QAE?AU1@U1@@Z" -// CHECK: (%struct.A* %this, <{ %struct.A*, %struct.A }>* inalloca) +// CHECK-LABEL: define x86_thiscallcc %struct.A* @"\01?foo@B@@QAE?AUA@@U2@@Z" +// CHECK: (%struct.B* %this, <{ %struct.A*, %struct.A }>* inalloca) // CHECK: getelementptr inbounds <{ %struct.A*, %struct.A }>* %{{.*}}, i32 0, i32 0 // CHECK: load %struct.A** // CHECK: ret %struct.A* +A B::bar(A x) { + return x; +} + +// CHECK-LABEL: define %struct.A* @"\01?bar@B@@QAA?AUA@@U2@@Z" +// CHECK: (<{ %struct.B*, %struct.A*, %struct.A }>* inalloca) +// CHECK: getelementptr inbounds <{ %struct.B*, %struct.A*, %struct.A }>* %{{.*}}, i32 0, i32 1 +// CHECK: load %struct.A** +// CHECK: ret %struct.A* + +A B::baz(A x) { + return x; +} + +// CHECK-LABEL: define x86_stdcallcc %struct.A* @"\01?baz@B@@QAG?AUA@@U2@@Z" +// CHECK: (<{ %struct.B*, %struct.A*, %struct.A }>* inalloca) +// CHECK: getelementptr inbounds <{ %struct.B*, %struct.A*, %struct.A }>* %{{.*}}, i32 0, i32 1 +// CHECK: load %struct.A** +// CHECK: ret %struct.A* + +A B::qux(A x) { + return x; +} + +// CHECK-LABEL: define x86_fastcallcc void @"\01?qux@B@@QAI?AUA@@U2@@Z" +// CHECK: (%struct.B* inreg %this, %struct.A* inreg noalias sret %agg.result, <{ %struct.A }>* inalloca) +// CHECK: ret void + int main() { - A x; - A y = x.foo(x); + B b; + A a = b.foo(A()); + a = b.bar(a); + a = b.baz(a); + a = b.qux(a); } -// CHECK: call x86_thiscallcc %struct.A* @"\01?foo@A@@QAE?AU1@U1@@Z" -// CHECK: (%struct.A* %{{[^,]*}}, <{ %struct.A*, %struct.A }>* inalloca %{{[^,]*}}) +// CHECK: call x86_thiscallcc %struct.A* @"\01?foo@B@@QAE?AUA@@U2@@Z" +// CHECK: (%struct.B* %{{[^,]*}}, <{ %struct.A*, %struct.A }>* inalloca %{{[^,]*}}) +// CHECK: call %struct.A* @"\01?bar@B@@QAA?AUA@@U2@@Z" +// CHECK: (<{ %struct.B*, %struct.A*, %struct.A }>* inalloca %{{[^,]*}}) +// CHECK: call x86_stdcallcc %struct.A* @"\01?baz@B@@QAG?AUA@@U2@@Z" +// CHECK: (<{ %struct.B*, %struct.A*, %struct.A }>* inalloca %{{[^,]*}}) +// CHECK: call x86_fastcallcc void @"\01?qux@B@@QAI?AUA@@U2@@Z" +// CHECK: (%struct.B* inreg %{{[^,]*}}, %struct.A* inreg sret %{{.*}}, <{ %struct.A }>* inalloca %{{[^,]*}}) diff --git a/test/CodeGenCXX/microsoft-abi-byval-thunks.cpp b/test/CodeGenCXX/microsoft-abi-byval-thunks.cpp new file mode 100644 index 000000000000..9bcfb9c184e5 --- /dev/null +++ b/test/CodeGenCXX/microsoft-abi-byval-thunks.cpp @@ -0,0 +1,113 @@ +// RUN: %clang_cc1 %s -fno-rtti -triple=i686-pc-win32 -emit-llvm -o - | FileCheck --check-prefix=CHECK32 %s +// RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o - | FileCheck --check-prefix=CHECK64 %s + +namespace byval_thunk { +struct Agg { + Agg(); + Agg(const Agg &); + ~Agg(); + int x; +}; + +struct A { virtual void foo(Agg x); }; +struct B { virtual void foo(Agg x); }; +struct C : A, B { C(); virtual void foo(Agg x); }; +C::C() {} // force emission + +// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01?foo@C@byval_thunk@@W3AEXUAgg@2@@Z" +// CHECK32: (%"struct.byval_thunk::C"* %this, <{ %"struct.byval_thunk::Agg" }>* inalloca) +// CHECK32: getelementptr i8* %{{.*}}, i32 -4 +// CHECK32: musttail call x86_thiscallcc void @"\01?foo@C@byval_thunk@@UAEXUAgg@2@@Z" +// CHECK32: (%"struct.byval_thunk::C"* %{{.*}}, <{ %"struct.byval_thunk::Agg" }>* inalloca %0) +// CHECK32-NEXT: ret void + +// CHECK64-LABEL: define linkonce_odr void @"\01?foo@C@byval_thunk@@W7EAAXUAgg@2@@Z" +// CHECK64: (%"struct.byval_thunk::C"* %this, %"struct.byval_thunk::Agg"* %x) +// CHECK64: getelementptr i8* %{{.*}}, i32 -8 +// CHECK64: call void @"\01?foo@C@byval_thunk@@UEAAXUAgg@2@@Z" +// CHECK64: (%"struct.byval_thunk::C"* %{{.*}}, %"struct.byval_thunk::Agg"* %x) +// CHECK64-NOT: call +// CHECK64: ret void +} + +namespace stdcall_thunk { +struct Agg { + Agg(); + Agg(const Agg &); + ~Agg(); + int x; +}; + +struct A { virtual void __stdcall foo(Agg x); }; +struct B { virtual void __stdcall foo(Agg x); }; +struct C : A, B { C(); virtual void __stdcall foo(Agg x); }; +C::C() {} // force emission + +// CHECK32-LABEL: define linkonce_odr x86_stdcallcc void @"\01?foo@C@stdcall_thunk@@W3AGXUAgg@2@@Z" +// CHECK32: (<{ %"struct.stdcall_thunk::C"*, %"struct.stdcall_thunk::Agg" }>* inalloca) +// CHECK32: %[[this_slot:[^ ]*]] = getelementptr inbounds <{ %"struct.stdcall_thunk::C"*, %"struct.stdcall_thunk::Agg" }>* %0, i32 0, i32 0 +// CHECK32: load %"struct.stdcall_thunk::C"** %[[this_slot]] +// CHECK32: getelementptr i8* %{{.*}}, i32 -4 +// CHECK32: store %"struct.stdcall_thunk::C"* %{{.*}}, %"struct.stdcall_thunk::C"** %[[this_slot]] +// CHECK32: musttail call x86_stdcallcc void @"\01?foo@C@stdcall_thunk@@UAGXUAgg@2@@Z" +// CHECK32: (<{ %"struct.stdcall_thunk::C"*, %"struct.stdcall_thunk::Agg" }>* inalloca %0) +// CHECK32-NEXT: ret void + +// CHECK64-LABEL: define linkonce_odr void @"\01?foo@C@stdcall_thunk@@W7EAAXUAgg@2@@Z" +// CHECK64: (%"struct.stdcall_thunk::C"* %this, %"struct.stdcall_thunk::Agg"* %x) +// CHECK64: getelementptr i8* %{{.*}}, i32 -8 +// CHECK64: call void @"\01?foo@C@stdcall_thunk@@UEAAXUAgg@2@@Z" +// CHECK64: (%"struct.stdcall_thunk::C"* %{{.*}}, %"struct.stdcall_thunk::Agg"* %x) +// CHECK64-NOT: call +// CHECK64: ret void +} + +namespace sret_thunk { +struct Agg { + Agg(); + Agg(const Agg &); + ~Agg(); + int x; +}; + +struct A { virtual Agg __cdecl foo(Agg x); }; +struct B { virtual Agg __cdecl foo(Agg x); }; +struct C : A, B { C(); virtual Agg __cdecl foo(Agg x); }; +C::C() {} // force emission + +// CHECK32-LABEL: define linkonce_odr %"struct.sret_thunk::Agg"* @"\01?foo@C@sret_thunk@@W3AA?AUAgg@2@U32@@Z" +// CHECK32: (<{ %"struct.sret_thunk::C"*, %"struct.sret_thunk::Agg"*, %"struct.sret_thunk::Agg" }>* inalloca) +// CHECK32: %[[this_slot:[^ ]*]] = getelementptr inbounds <{ %"struct.sret_thunk::C"*, %"struct.sret_thunk::Agg"*, %"struct.sret_thunk::Agg" }>* %0, i32 0, i32 0 +// CHECK32: load %"struct.sret_thunk::C"** %[[this_slot]] +// CHECK32: getelementptr i8* %{{.*}}, i32 -4 +// CHECK32: store %"struct.sret_thunk::C"* %{{.*}}, %"struct.sret_thunk::C"** %[[this_slot]] +// CHECK32: %[[rv:[^ ]*]] = musttail call %"struct.sret_thunk::Agg"* @"\01?foo@C@sret_thunk@@UAA?AUAgg@2@U32@@Z" +// CHECK32: (<{ %"struct.sret_thunk::C"*, %"struct.sret_thunk::Agg"*, %"struct.sret_thunk::Agg" }>* inalloca %0) +// CHECK32-NEXT: ret %"struct.sret_thunk::Agg"* %[[rv]] + +// CHECK64-LABEL: define linkonce_odr void @"\01?foo@C@sret_thunk@@W7EAA?AUAgg@2@U32@@Z" +// CHECK64: (%"struct.sret_thunk::C"* %this, %"struct.sret_thunk::Agg"* noalias sret %agg.result, %"struct.sret_thunk::Agg"* %x) +// CHECK64: getelementptr i8* %{{.*}}, i32 -8 +// CHECK64: call void @"\01?foo@C@sret_thunk@@UEAA?AUAgg@2@U32@@Z" +// CHECK64: (%"struct.sret_thunk::C"* %{{.*}}, %"struct.sret_thunk::Agg"* sret %agg.result, %"struct.sret_thunk::Agg"* %x) +// CHECK64-NOT: call +// CHECK64: ret void +} + +#if 0 +// FIXME: When we extend LLVM IR to allow forwarding of varargs through musttail +// calls, use this test. +namespace variadic_thunk { +struct Agg { + Agg(); + Agg(const Agg &); + ~Agg(); + int x; +}; + +struct A { virtual void foo(Agg x, ...); }; +struct B { virtual void foo(Agg x, ...); }; +struct C : A, B { C(); virtual void foo(Agg x, ...); }; +C::C() {} // force emission +} +#endif diff --git a/test/CodeGenCXX/microsoft-abi-dynamic-cast.cpp b/test/CodeGenCXX/microsoft-abi-dynamic-cast.cpp index 225407b7fa9c..f2e9da7cca1f 100644 --- a/test/CodeGenCXX/microsoft-abi-dynamic-cast.cpp +++ b/test/CodeGenCXX/microsoft-abi-dynamic-cast.cpp @@ -20,11 +20,10 @@ T* test1(V* x) { return &dynamic_cast<T&>(*x); } T* test2(A* x) { return &dynamic_cast<T&>(*x); } // CHECK-LABEL: define %struct.T* @"\01?test2@@YAPAUT@@PAUA@@@Z"(%struct.A* %x) // CHECK: [[CAST:%.*]] = bitcast %struct.A* %x to i8* -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast %struct.A* %x to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = getelementptr inbounds %struct.A* %x, i32 0, i32 0 +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[CAST]], i32 [[VBOFFS]] // CHECK-NEXT: [[CALL:%.*]] = tail call i8* @__RTDynamicCast(i8* [[ADJ]], i32 [[VBOFFS]], i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8" to i8*), i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUT@@@8" to i8*), i32 1) // CHECK-NEXT: [[RET:%.*]] = bitcast i8* [[CALL]] to %struct.T* @@ -34,11 +33,10 @@ T* test3(B* x) { return &dynamic_cast<T&>(*x); } // CHECK-LABEL: define %struct.T* @"\01?test3@@YAPAUT@@PAUB@@@Z"(%struct.B* %x) // CHECK: [[VOIDP:%.*]] = getelementptr inbounds %struct.B* %x, i32 0, i32 0, i32 0 // CHECK-NEXT: [[VBPTR:%.*]] = getelementptr inbounds i8* [[VOIDP]], i32 4 -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast i8* [[VBPTR:%.*]] to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = bitcast i8* [[VBPTR:%.*]] to i32** +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[DELTA:%.*]] = add nsw i32 [[VBOFFS]], 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[VOIDP]], i32 [[DELTA]] // CHECK-NEXT: [[CALL:%.*]] = tail call i8* @__RTDynamicCast(i8* [[ADJ]], i32 [[DELTA]], i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8" to i8*), i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUT@@@8" to i8*), i32 1) @@ -57,11 +55,10 @@ T* test5(A* x) { return dynamic_cast<T*>(x); } // CHECK: [[CHECK:%.*]] = icmp eq %struct.A* %x, null // CHECK-NEXT: br i1 [[CHECK]] // CHECK: [[VOIDP:%.*]] = bitcast %struct.A* %x to i8* -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast %struct.A* %x to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST:%.*]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = getelementptr inbounds %struct.A* %x, i32 0, i32 0 +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[VOIDP]], i32 [[VBOFFS]] // CHECK-NEXT: [[CALL:%.*]] = tail call i8* @__RTDynamicCast(i8* [[ADJ]], i32 [[VBOFFS]], i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUA@@@8" to i8*), i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUT@@@8" to i8*), i32 0) // CHECK-NEXT: [[RES:%.*]] = bitcast i8* [[CALL]] to %struct.T* @@ -75,11 +72,10 @@ T* test6(B* x) { return dynamic_cast<T*>(x); } // CHECK-NEXT: br i1 [[CHECK]] // CHECK: [[CAST:%.*]] = getelementptr inbounds %struct.B* %x, i32 0, i32 0, i32 0 // CHECK-NEXT: [[VBPTR:%.*]] = getelementptr inbounds i8* [[CAST]], i32 4 -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast i8* [[VBPTR]] to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST:%.*]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = bitcast i8* [[VBPTR]] to i32** +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[DELTA:%.*]] = add nsw i32 [[VBOFFS]], 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[CAST]], i32 [[DELTA]] // CHECK-NEXT: [[CALL:%.*]] = tail call i8* @__RTDynamicCast(i8* [[ADJ]], i32 [[DELTA]], i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUB@@@8" to i8*), i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUT@@@8" to i8*), i32 0) @@ -99,11 +95,10 @@ void* test8(A* x) { return dynamic_cast<void*>(x); } // CHECK: [[CHECK:%.*]] = icmp eq %struct.A* %x, null // CHECK-NEXT: br i1 [[CHECK]] // CHECK: [[VOIDP:%.*]] = bitcast %struct.A* %x to i8* -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast %struct.A* %x to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST:%.*]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = getelementptr inbounds %struct.A* %x, i32 0, i32 0 +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[VOIDP]], i32 [[VBOFFS]] // CHECK-NEXT: [[RES:%.*]] = tail call i8* @__RTCastToVoid(i8* [[ADJ]]) // CHECK-NEXT: br label @@ -116,11 +111,10 @@ void* test9(B* x) { return dynamic_cast<void*>(x); } // CHECK-NEXT: br i1 [[CHECK]] // CHECK: [[CAST:%.*]] = getelementptr inbounds %struct.B* %x, i32 0, i32 0, i32 0 // CHECK-NEXT: [[VBPTR:%.*]] = getelementptr inbounds i8* [[CAST]], i32 4 -// CHECK-NEXT: [[BITCAST:%.*]] = bitcast i8* [[VBPTR]] to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[BITCAST]], align 4 -// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBOFFPCAST:%.*]] = bitcast i8* [[VBOFFP]] to i32* -// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFPCAST:%.*]], align 4 +// CHECK-NEXT: [[VBPTRPTR:%.*]] = bitcast i8* [[VBPTR]] to i32** +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBPTRPTR]], align 4 +// CHECK-NEXT: [[VBOFFP:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBOFFS:%.*]] = load i32* [[VBOFFP]], align 4 // CHECK-NEXT: [[DELTA:%.*]] = add nsw i32 [[VBOFFS]], 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[CAST]], i32 [[DELTA]] // CHECK-NEXT: [[CALL:%.*]] = tail call i8* @__RTCastToVoid(i8* [[ADJ]]) diff --git a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp index 18e8c827eebe..719cb70679f4 100755 --- a/test/CodeGenCXX/microsoft-abi-member-pointers.cpp +++ b/test/CodeGenCXX/microsoft-abi-member-pointers.cpp @@ -1,9 +1,29 @@ -// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s -// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -triple=x86_64-pc-win32 -fms-extensions | FileCheck %s -check-prefix=X64 -// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -fms-extensions -verify -// RUN: %clang_cc1 -std=c++11 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -DMEMFUN -fms-extensions -verify -// FIXME: Test x86_64 member pointers when codegen no longer asserts on records -// with virtual bases. +// RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=x86_64-pc-win32 -fms-extensions | FileCheck %s -check-prefix=X64 +// RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -fms-extensions -verify +// RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -DMEMFUN -fms-extensions -verify + +namespace PR20947 { +struct A; +int A::**a = nullptr; +// CHECK: %[[opaque0:.*]] = type opaque +// CHECK: %[[opaque1:.*]] = type opaque +// CHECK: @"\01?a@PR20947@@3PAPQA@1@HA" = global %[[opaque0]]* null, align 4 + +struct B; +int B::*&b = b; +// CHECK: @"\01?b@PR20947@@3AAPQB@1@HA" = global %[[opaque1]]* null, align 4 +} + +namespace PR20017 { +template <typename T> +struct A { + int T::*m_fn1() { return nullptr; } +}; +struct B; +auto a = &A<B>::m_fn1; +// CHECK-DAG: @"\01?a@PR20017@@3P8?$A@UB@PR20017@@@1@AEPQB@1@HXZQ21@" = global i8* bitcast ({ i32, i32, i32 } ({{.*}}*)* @"\01?m_fn1@?$A@UB@PR20017@@@PR20017@@QAEPQB@2@HXZ" to i8*), align 4 +} #ifndef INCOMPLETE_VIRTUAL struct B1 { @@ -265,11 +285,11 @@ int loadDataMemberPointerVirtual(Virtual *o, int Virtual::*memptr) { // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 1 // CHECK: %[[v6:.*]] = bitcast %{{.*}}* %[[o]] to i8* // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[v6]], i32 0 -// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** -// CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] -// CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr1]] -// CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* -// CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] +// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** +// CHECK: %[[vbtable:.*]] = load i32** %[[vbptr_a:.*]] +// CHECK: %[[memptr1_shr:.*]] = ashr exact i32 %[[memptr1]], 2 +// CHECK: %[[v7:.*]] = getelementptr inbounds i32* %[[vbtable]], i32 %[[memptr1_shr]] +// CHECK: %[[vbase_offs:.*]] = load i32* %[[v7]] // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] // CHECK: %[[offset:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr0]] // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* @@ -299,11 +319,11 @@ int loadDataMemberPointerUnspecified(Unspecified *o, int Unspecified::*memptr) { // // CHECK: [[vadjust]] // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[base]], i32 %[[memptr1]] -// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** -// CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] -// CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] -// CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* -// CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] +// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** +// CHECK: %[[vbtable:.*]] = load i32** %[[vbptr_a:.*]] +// CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2 +// CHECK: %[[v7:.*]] = getelementptr inbounds i32* %[[vbtable]], i32 %[[memptr2_shr]] +// CHECK: %[[vbase_offs:.*]] = load i32* %[[v7]] // CHECK: %[[base_adj:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] // // CHECK: [[skip]] @@ -350,11 +370,11 @@ void callMemberPointerVirtualBase(Virtual *o, void (Virtual::*memptr)()) { // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 // CHECK: %[[memptr2:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %{{.*}}, i32 0 -// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** -// CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] -// CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] -// CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* -// CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] +// CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** +// CHECK: %[[vbtable:.*]] = load i32** %[[vbptr_a:.*]] +// CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2 +// CHECK: %[[v7:.*]] = getelementptr inbounds i32* %[[vbtable]], i32 %[[memptr2_shr]] +// CHECK: %[[vbase_offs:.*]] = load i32* %[[v7]] // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr1]] // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to void ({{.*}}) @@ -595,15 +615,15 @@ void (C::*getmp())() { return &C::g; } // CHECK-LABEL: define i64 @"\01?getmp@Test4@@YAP8C@1@AEXXZXZ"() -// CHECK: store { i8*, i32 } { i8* bitcast (void (i8*)* @"\01??_9C@Test4@@$BA@AE" to i8*), i32 4 }, { i8*, i32 }* %{{.*}} +// CHECK: store { i8*, i32 } { i8* bitcast (void (%"struct.Test4::C"*, ...)* @"\01??_9C@Test4@@$BA@AE" to i8*), i32 4 }, { i8*, i32 }* %{{.*}} // -// CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@Test4@@$BA@AE"(i8*) +// CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@Test4@@$BA@AE"(%"struct.Test4::C"* %this, ...) // CHECK-NOT: getelementptr -// CHECK: load void (i8*)*** %{{.*}} -// CHECK: getelementptr inbounds void (i8*)** %{{.*}}, i64 0 +// CHECK: load void (%"struct.Test4::C"*, ...)*** %{{.*}} +// CHECK: getelementptr inbounds void (%"struct.Test4::C"*, ...)** %{{.*}}, i64 0 // CHECK-NOT: getelementptr -// CHECK: call x86_thiscallcc void % +// CHECK: musttail call x86_thiscallcc void (%"struct.Test4::C"*, ...)* % } @@ -630,6 +650,34 @@ void test() { void (B::*a)() = &B::f; } // CHECK: store i8* bitcast (void (%"struct.pr20007_kw::A"*)* @"\01?f@A@pr20007_kw@@QAEXXZ" to i8*) } +namespace pr20007_pragma { +struct A { + void f(); + void f(int); +}; +struct B : public A {}; +void test() { (void)(void (B::*)()) &B::f; } +#pragma pointers_to_members(full_generality, virtual_inheritance) +static_assert(sizeof(int B::*) == 4, ""); +static_assert(sizeof(int A::*) == 4, ""); +#pragma pointers_to_members(best_case) +// CHECK-LABEL: define void @"\01?test@pr20007_pragma@@YAXXZ" +} + +namespace pr20007_pragma2 { +struct A { +}; +struct B : public A { + void f(); +}; +void test() { (void)&B::f; } +#pragma pointers_to_members(full_generality, virtual_inheritance) +static_assert(sizeof(int B::*) == 4, ""); +static_assert(sizeof(int A::*) == 12, ""); +#pragma pointers_to_members(best_case) +// CHECK-LABEL: define void @"\01?test@pr20007_pragma2@@YAXXZ" +} + namespace pr19987 { template <typename T> struct S { diff --git a/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp b/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp index b1c1482eff6f..b5293e0d7989 100644 --- a/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp +++ b/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp @@ -150,35 +150,35 @@ void emit_ctors() { Left l; // CHECK: define {{.*}} @"\01??0Left@@QAE@XZ" // CHECK-NOT: getelementptr - // CHECK: store [1 x i8*]* @"\01??_7Left@@6B@" + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7Left@@6B@" to i32 (...)**) // CHECK: ret Right r; // CHECK: define {{.*}} @"\01??0Right@@QAE@XZ" // CHECK-NOT: getelementptr - // CHECK: store [1 x i8*]* @"\01??_7Right@@6B@" + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7Right@@6B@" to i32 (...)**) // CHECK: ret ChildOverride co; // CHECK: define {{.*}} @"\01??0ChildOverride@@QAE@XZ" // CHECK: %[[THIS:.*]] = load %struct.ChildOverride** - // CHECK: %[[VFPTR:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7ChildOverride@@6BLeft@@@", [1 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7ChildOverride@@6BLeft@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // CHECK: %[[THIS_i8:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i8* // CHECK: %[[VFPTR_i8:.*]] = getelementptr inbounds i8* %[[THIS_i8]], i32 4 - // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7ChildOverride@@6BRight@@@", [1 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7ChildOverride@@6BRight@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // CHECK: ret GrandchildOverride gc; // CHECK: define {{.*}} @"\01??0GrandchildOverride@@QAE@XZ" // CHECK: %[[THIS:.*]] = load %struct.GrandchildOverride** - // CHECK: %[[VFPTR:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7GrandchildOverride@@6BLeft@@@", [1 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7GrandchildOverride@@6BLeft@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // CHECK: %[[THIS_i8:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to i8* // CHECK: %[[VFPTR_i8:.*]] = getelementptr inbounds i8* %[[THIS_i8]], i32 4 - // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7GrandchildOverride@@6BRight@@@", [1 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7GrandchildOverride@@6BRight@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // CHECK: ret } diff --git a/test/CodeGenCXX/microsoft-abi-nontrivial-covariant-thunk.cpp b/test/CodeGenCXX/microsoft-abi-nontrivial-covariant-thunk.cpp index d305dd83271f..cb8b5224d65b 100644 --- a/test/CodeGenCXX/microsoft-abi-nontrivial-covariant-thunk.cpp +++ b/test/CodeGenCXX/microsoft-abi-nontrivial-covariant-thunk.cpp @@ -18,7 +18,7 @@ struct B { struct C : A, B { C(); int c; - virtual C *clone(A); // expected-error {{cannot compile this non-trivial argument copy for thunk yet}} + virtual C *clone(A); // expected-error {{cannot compile this non-trivial argument copy for return-adjusting thunk yet}} }; B::B() {} // force emission C::C() {} // force emission diff --git a/test/CodeGenCXX/microsoft-abi-static-initializers.cpp b/test/CodeGenCXX/microsoft-abi-static-initializers.cpp index 5f74c54c1c45..76d7e9e19192 100644 --- a/test/CodeGenCXX/microsoft-abi-static-initializers.cpp +++ b/test/CodeGenCXX/microsoft-abi-static-initializers.cpp @@ -1,9 +1,12 @@ // RUN: %clang_cc1 -fms-extensions -emit-llvm %s -o - -mconstructor-aliases -triple=i386-pc-win32 | FileCheck %s -// CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] -// CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @"\01??__Efoo@?$B@H@@2VA@@A@YAXXZ", -// CHECK: i8* bitcast (%class.A* @"\01?foo@?$B@H@@2VA@@A" to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_microsoft_abi_static_initializers.cpp, i8* null }] +// CHECK: @llvm.global_ctors = appending global [5 x { i32, void ()*, i8* }] [ +// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @"\01??__Eselectany1@@YAXXZ", i8* getelementptr inbounds (%struct.S* @"\01?selectany1@@3US@@A", i32 0, i32 0) }, +// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @"\01??__Eselectany2@@YAXXZ", i8* getelementptr inbounds (%struct.S* @"\01?selectany2@@3US@@A", i32 0, i32 0) }, +// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @"\01??__Es@?$ExportedTemplate@H@@2US@@A@YAXXZ", i8* getelementptr inbounds (%struct.S* @"\01?s@?$ExportedTemplate@H@@2US@@A", i32 0, i32 0) }, +// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @"\01??__Efoo@?$B@H@@2VA@@A@YAXXZ", i8* bitcast (%class.A* @"\01?foo@?$B@H@@2VA@@A" to i8*) }, +// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_microsoft_abi_static_initializers.cpp, i8* null } +// CHECK: ] struct S { S(); @@ -21,8 +24,8 @@ S s; // CHECK: call x86_thiscallcc void @"\01??1S@@QAE@XZ" // CHECK: ret void -// These globals should use distinct guard variables, and not different bits of -// the same global. +// These globals should have initializers comdat associative with the global. +// See @llvm.global_ctors above. __declspec(selectany) S selectany1; __declspec(selectany) S selectany2; // CHECK: define linkonce_odr void @"\01??__Eselectany1@@YAXXZ"() @@ -34,12 +37,23 @@ __declspec(selectany) S selectany2; // CHECK: call x86_thiscallcc %struct.S* @"\01??0S@@QAE@XZ" // CHECK: ret void +// The implicitly instantiated static data member should have initializer +// comdat associative with the global. +template <typename T> struct __declspec(dllexport) ExportedTemplate { + static S s; +}; +template <typename T> S ExportedTemplate<T>::s; +void useExportedTemplate(ExportedTemplate<int> x) { + (void)x.s; +} + void StaticLocal() { static S TheS; } + // CHECK-LABEL: define void @"\01?StaticLocal@@YAXXZ"() -// CHECK: load i32* @"\01?$S1@?0??StaticLocal@@YAXXZ@4IA" -// CHECK: store i32 {{.*}}, i32* @"\01?$S1@?0??StaticLocal@@YAXXZ@4IA" +// CHECK: load i32* @"\01?$S1@?1??StaticLocal@@YAXXZ@4IA" +// CHECK: store i32 {{.*}}, i32* @"\01?$S1@?1??StaticLocal@@YAXXZ@4IA" // CHECK: ret void MultipleStatics() { @@ -80,7 +94,7 @@ void MultipleStatics() { static S S35; } // CHECK-LABEL: define void @"\01?MultipleStatics@@YAXXZ"() -// CHECK: load i32* @"\01?$S1@?0??MultipleStatics@@YAXXZ@4IA" +// CHECK: load i32* @"\01?$S1@?1??MultipleStatics@@YAXXZ@4IA" // CHECK: and i32 {{.*}}, 1 // CHECK: and i32 {{.*}}, 2 // CHECK: and i32 {{.*}}, 4 @@ -88,7 +102,7 @@ void MultipleStatics() { // CHECK: and i32 {{.*}}, 16 // ... // CHECK: and i32 {{.*}}, -2147483648 -// CHECK: load i32* @"\01?$S1@?0??MultipleStatics@@YAXXZ@4IA1" +// CHECK: load i32* @"\01?$S1@?1??MultipleStatics@@YAXXZ@4IA1" // CHECK: and i32 {{.*}}, 1 // CHECK: and i32 {{.*}}, 2 // CHECK: and i32 {{.*}}, 4 diff --git a/test/CodeGenCXX/microsoft-abi-structors-delayed-template.cpp b/test/CodeGenCXX/microsoft-abi-structors-delayed-template.cpp new file mode 100644 index 000000000000..f9e188033ca4 --- /dev/null +++ b/test/CodeGenCXX/microsoft-abi-structors-delayed-template.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -emit-llvm -fdelayed-template-parsing -std=c++11 -o - -triple=i386-pc-win32 %s > %t +// RUN: FileCheck %s < %t + +// PR20671 +namespace vtable_referenced_from_template { +struct ImplicitCtor { + virtual ~ImplicitCtor(); +}; +template <class T> void foo(T t) { new ImplicitCtor; } +void bar() { foo(0); } +// CHECK: store {{.*}} @"\01??_7ImplicitCtor@vtable_referenced_from_template@@6B@" +} diff --git a/test/CodeGenCXX/microsoft-abi-structors.cpp b/test/CodeGenCXX/microsoft-abi-structors.cpp index 7d3992b9940b..01d72e0aed57 100644 --- a/test/CodeGenCXX/microsoft-abi-structors.cpp +++ b/test/CodeGenCXX/microsoft-abi-structors.cpp @@ -46,8 +46,9 @@ B::B() { struct C { virtual ~C() { -// DTORS: define linkonce_odr x86_thiscallcc void @"\01??_GC@basic@@UAEPAXI@Z"(%"struct.basic::C"* %this, i32 %should_call_delete) +// DTORS: define linkonce_odr x86_thiscallcc i8* @"\01??_GC@basic@@UAEPAXI@Z"(%"struct.basic::C"* %this, i32 %should_call_delete) // DTORS: store i32 %should_call_delete, i32* %[[SHOULD_DELETE_VAR:[0-9a-z._]+]], align 4 +// DTORS: store i8* %{{.*}}, i8** %[[RETVAL:[0-9a-z._]+]] // DTORS: %[[SHOULD_DELETE_VALUE:[0-9a-z._]+]] = load i32* %[[SHOULD_DELETE_VAR]] // DTORS: call x86_thiscallcc void @"\01??1C@basic@@UAE@XZ"(%"struct.basic::C"* %[[THIS:[0-9a-z]+]]) // DTORS-NEXT: %[[CONDITION:[0-9]+]] = icmp eq i32 %[[SHOULD_DELETE_VALUE]], 0 @@ -59,7 +60,8 @@ struct C { // DTORS-NEXT: br label %[[CONTINUE_LABEL]] // // DTORS: [[CONTINUE_LABEL]] -// DTORS-NEXT: ret void +// DTORS-NEXT: %[[RET:.*]] = load i8** %[[RETVAL]] +// DTORS-NEXT: ret i8* %[[RET]] // Check that we do the mangling correctly on x64. // DTORS-X64: @"\01??_GC@basic@@UEAAPEAXI@Z" @@ -73,19 +75,19 @@ void C::foo() {} void check_vftable_offset() { C c; // The vftable pointer should point at the beginning of the vftable. -// CHECK: [[THIS_PTR:%[0-9]+]] = bitcast %"struct.basic::C"* {{.*}} to [2 x i8*]** -// CHECK: store [2 x i8*]* @"\01??_7C@basic@@6B@", [2 x i8*]** [[THIS_PTR]] +// CHECK: [[THIS_PTR:%[0-9]+]] = bitcast %"struct.basic::C"* {{.*}} to i32 (...)*** +// CHECK: store i32 (...)** bitcast ([2 x i8*]* @"\01??_7C@basic@@6B@" to i32 (...)**), i32 (...)*** [[THIS_PTR]] } void call_complete_dtor(C *obj_ptr) { // CHECK: define void @"\01?call_complete_dtor@basic@@YAXPAUC@1@@Z"(%"struct.basic::C"* %obj_ptr) obj_ptr->~C(); // CHECK: %[[OBJ_PTR_VALUE:.*]] = load %"struct.basic::C"** %{{.*}}, align 4 -// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i32)*** -// CHECK-NEXT: %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i32)*** %[[PVTABLE]] -// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0 -// CHECK-NEXT: %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i32)** %[[PVDTOR]] -// CHECK-NEXT: call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 0) +// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to i8* (%"struct.basic::C"*, i32)*** +// CHECK-NEXT: %[[VTABLE:.*]] = load i8* (%"struct.basic::C"*, i32)*** %[[PVTABLE]] +// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds i8* (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0 +// CHECK-NEXT: %[[VDTOR:.*]] = load i8* (%"struct.basic::C"*, i32)** %[[PVDTOR]] +// CHECK-NEXT: call x86_thiscallcc i8* %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 0) // CHECK-NEXT: ret void } @@ -96,11 +98,27 @@ void call_deleting_dtor(C *obj_ptr) { // CHECK: br i1 {{.*}}, label %[[DELETE_NULL:.*]], label %[[DELETE_NOTNULL:.*]] // CHECK: [[DELETE_NOTNULL]] -// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i32)*** -// CHECK-NEXT: %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i32)*** %[[PVTABLE]] -// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0 -// CHECK-NEXT: %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i32)** %[[PVDTOR]] -// CHECK-NEXT: call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 1) +// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to i8* (%"struct.basic::C"*, i32)*** +// CHECK-NEXT: %[[VTABLE:.*]] = load i8* (%"struct.basic::C"*, i32)*** %[[PVTABLE]] +// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds i8* (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0 +// CHECK-NEXT: %[[VDTOR:.*]] = load i8* (%"struct.basic::C"*, i32)** %[[PVDTOR]] +// CHECK-NEXT: call x86_thiscallcc i8* %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 1) +// CHECK: ret void +} + +void call_deleting_dtor_and_global_delete(C *obj_ptr) { +// CHECK: define void @"\01?call_deleting_dtor_and_global_delete@basic@@YAXPAUC@1@@Z"(%"struct.basic::C"* %obj_ptr) + ::delete obj_ptr; +// CHECK: %[[OBJ_PTR_VALUE:.*]] = load %"struct.basic::C"** %{{.*}}, align 4 +// CHECK: br i1 {{.*}}, label %[[DELETE_NULL:.*]], label %[[DELETE_NOTNULL:.*]] + +// CHECK: [[DELETE_NOTNULL]] +// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to i8* (%"struct.basic::C"*, i32)*** +// CHECK-NEXT: %[[VTABLE:.*]] = load i8* (%"struct.basic::C"*, i32)*** %[[PVTABLE]] +// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds i8* (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0 +// CHECK-NEXT: %[[VDTOR:.*]] = load i8* (%"struct.basic::C"*, i32)** %[[PVDTOR]] +// CHECK-NEXT: %[[CALL:.*]] = call x86_thiscallcc i8* %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 0) +// CHECK-NEXT: call void @"\01??3@YAXPAX@Z"(i8* %[[CALL]]) // CHECK: ret void } @@ -153,13 +171,13 @@ C::~C() { void foo() { C c; } -// DTORS2-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_EC@dtor_in_second_nvbase@@W3AEPAXI@Z" +// DTORS2-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_EC@dtor_in_second_nvbase@@W3AEPAXI@Z" // DTORS2: (%"struct.dtor_in_second_nvbase::C"* %this, i32 %should_call_delete) // Do an adjustment from B* to C*. // DTORS2: getelementptr i8* %{{.*}}, i32 -4 // DTORS2: bitcast i8* %{{.*}} to %"struct.dtor_in_second_nvbase::C"* -// DTORS2: call x86_thiscallcc void @"\01??_GC@dtor_in_second_nvbase@@UAEPAXI@Z" -// DTORS2: ret void +// DTORS2: %[[CALL:.*]] = call x86_thiscallcc i8* @"\01??_GC@dtor_in_second_nvbase@@UAEPAXI@Z" +// DTORS2: ret i8* %[[CALL]] } @@ -229,8 +247,8 @@ C::C() { // CHECK: [[INIT_VBASES]] // CHECK-NEXT: %[[this_i8:.*]] = bitcast %"struct.constructors::C"* %{{.*}} to i8* // CHECK-NEXT: %[[vbptr_off:.*]] = getelementptr inbounds i8* %[[this_i8]], i64 0 - // CHECK-NEXT: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to [2 x i32]** - // CHECK-NEXT: store [2 x i32]* @"\01??_8C@constructors@@7B@", [2 x i32]** %[[vbptr]] + // CHECK-NEXT: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** + // CHECK-NEXT: store i32* getelementptr inbounds ([2 x i32]* @"\01??_8C@constructors@@7B@", i32 0, i32 0), i32** %[[vbptr]] // CHECK-NEXT: bitcast %"struct.constructors::C"* %{{.*}} to i8* // CHECK-NEXT: getelementptr inbounds i8* %{{.*}}, i64 4 // CHECK-NEXT: bitcast i8* %{{.*}} to %"struct.constructors::A"* @@ -264,8 +282,8 @@ D::D() { // CHECK: [[INIT_VBASES]] // CHECK-NEXT: %[[this_i8:.*]] = bitcast %"struct.constructors::D"* %{{.*}} to i8* // CHECK-NEXT: %[[vbptr_off:.*]] = getelementptr inbounds i8* %[[this_i8]], i64 0 - // CHECK-NEXT: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to [2 x i32]** - // CHECK-NEXT: store [2 x i32]* @"\01??_8D@constructors@@7B@", [2 x i32]** %[[vbptr]] + // CHECK-NEXT: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** + // CHECK-NEXT: store i32* getelementptr inbounds ([2 x i32]* @"\01??_8D@constructors@@7B@", i32 0, i32 0), i32** %[[vbptr]] // CHECK-NEXT: bitcast %"struct.constructors::D"* %{{.*}} to i8* // CHECK-NEXT: getelementptr inbounds i8* %{{.*}}, i64 4 // CHECK-NEXT: bitcast i8* %{{.*}} to %"struct.constructors::A"* @@ -291,11 +309,11 @@ E::E() { // CHECK: [[INIT_VBASES]] // CHECK-NEXT: %[[this_i8:.*]] = bitcast %"struct.constructors::E"* %{{.*}} to i8* // CHECK-NEXT: %[[offs:.*]] = getelementptr inbounds i8* %[[this_i8]], i64 0 - // CHECK-NEXT: %[[vbptr_E:.*]] = bitcast i8* %[[offs]] to [3 x i32]** - // CHECK-NEXT: store [3 x i32]* @"\01??_8E@constructors@@7B01@@", [3 x i32]** %[[vbptr_E]] + // CHECK-NEXT: %[[vbptr_E:.*]] = bitcast i8* %[[offs]] to i32** + // CHECK-NEXT: store i32* getelementptr inbounds ([3 x i32]* @"\01??_8E@constructors@@7B01@@", i32 0, i32 0), i32** %[[vbptr_E]] // CHECK-NEXT: %[[offs:.*]] = getelementptr inbounds i8* %[[this_i8]], i64 4 - // CHECK-NEXT: %[[vbptr_C:.*]] = bitcast i8* %[[offs]] to [2 x i32]** - // CHECK-NEXT: store [2 x i32]* @"\01??_8E@constructors@@7BC@1@@", [2 x i32]** %[[vbptr_C]] + // CHECK-NEXT: %[[vbptr_C:.*]] = bitcast i8* %[[offs]] to i32** + // CHECK-NEXT: store i32* getelementptr inbounds ([2 x i32]* @"\01??_8E@constructors@@7BC@1@@", i32 0, i32 0), i32** %[[vbptr_C]] // CHECK-NEXT: bitcast %"struct.constructors::E"* %{{.*}} to i8* // CHECK-NEXT: getelementptr inbounds i8* %{{.*}}, i64 4 // CHECK-NEXT: bitcast i8* %{{.*}} to %"struct.constructors::A"* @@ -436,7 +454,7 @@ struct A { void *getA() { return (void*)new A(); } -// CHECK: define internal x86_thiscallcc void @"\01??_GA@?A@@UAEPAXI@Z" +// CHECK: define internal x86_thiscallcc i8* @"\01??_GA@?A@@UAEPAXI@Z" // CHECK: (%"struct.(anonymous namespace)::A"* %this, i32 %should_call_delete) // CHECK: define internal x86_thiscallcc void @"\01??1A@?A@@UAE@XZ" // CHECK: (%"struct.(anonymous namespace)::A"* %this) diff --git a/test/CodeGenCXX/microsoft-abi-thunks.cpp b/test/CodeGenCXX/microsoft-abi-thunks.cpp index c755b300067d..843bc89b0d0d 100644 --- a/test/CodeGenCXX/microsoft-abi-thunks.cpp +++ b/test/CodeGenCXX/microsoft-abi-thunks.cpp @@ -61,10 +61,10 @@ struct C : A, B { C::C() {} // Emits vftable and forces thunk generation. -// CODEGEN-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_EC@@W3AEPAXI@Z"(%struct.C* %this, i32 %should_call_delete) +// CODEGEN-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_EC@@W3AEPAXI@Z"(%struct.C* %this, i32 %should_call_delete) // CODEGEN: getelementptr i8* {{.*}}, i32 -4 // FIXME: should actually call _EC, not _GC. -// CODEGEN: call x86_thiscallcc void @"\01??_GC@@UAEPAXI@Z" +// CODEGEN: call x86_thiscallcc i8* @"\01??_GC@@UAEPAXI@Z" // CODEGEN: ret // CODEGEN-LABEL: define linkonce_odr x86_thiscallcc void @"\01?public_f@C@@W3AEXXZ"(%struct.C* @@ -128,10 +128,9 @@ I::I() {} // Emits vftable and forces thunk generation. // CODEGEN: %[[ORIG_RET:.*]] = call x86_thiscallcc %struct.F* @"\01?goo@I@@UAEPAUF@@XZ" // CODEGEN: %[[ORIG_RET_i8:.*]] = bitcast %struct.F* %[[ORIG_RET]] to i8* // CODEGEN: %[[VBPTR_i8:.*]] = getelementptr inbounds i8* %[[ORIG_RET_i8]], i32 4 -// CODEGEN: %[[VBPTR:.*]] = bitcast i8* %[[VBPTR_i8]] to i8** -// CODEGEN: %[[VBTABLE:.*]] = load i8** %[[VBPTR]] -// CODEGEN: %[[VBASE_OFFSET_PTR_i8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 8 -// CODEGEN: %[[VBASE_OFFSET_PTR:.*]] = bitcast i8* %[[VBASE_OFFSET_PTR_i8]] to i32* +// CODEGEN: %[[VBPTR:.*]] = bitcast i8* %[[VBPTR_i8]] to i32** +// CODEGEN: %[[VBTABLE:.*]] = load i32** %[[VBPTR]] +// CODEGEN: %[[VBASE_OFFSET_PTR:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 2 // CODEGEN: %[[VBASE_OFFSET:.*]] = load i32* %[[VBASE_OFFSET_PTR]] // CODEGEN: %[[RES_i8:.*]] = getelementptr inbounds i8* %[[VBPTR_i8]], i32 %[[VBASE_OFFSET]] // CODEGEN: %[[RES:.*]] = bitcast i8* %[[RES_i8]] to %struct.F* diff --git a/test/CodeGenCXX/microsoft-abi-typeid.cpp b/test/CodeGenCXX/microsoft-abi-typeid.cpp index 4ee004d51d21..1beb2118126a 100644 --- a/test/CodeGenCXX/microsoft-abi-typeid.cpp +++ b/test/CodeGenCXX/microsoft-abi-typeid.cpp @@ -31,11 +31,10 @@ const std::type_info* test3_typeid() { return &typeid(*fn()); } // CHECK: tail call i8* @__RTtypeid(i8* null) // CHECK-NEXT: unreachable // CHECK: [[THIS:%.*]] = bitcast %struct.A* [[CALL]] to i8* -// CHECK-NEXT: [[VBTBLP:%.*]] = bitcast %struct.A* [[CALL]] to i8** -// CHECK-NEXT: [[VBTBL:%.*]] = load i8** [[VBTBLP]], align 4 -// CHECK-NEXT: [[VBSLOT:%.*]] = getelementptr inbounds i8* [[VBTBL]], i32 4 -// CHECK-NEXT: [[VBITCST:%.*]] = bitcast i8* [[VBSLOT]] to i32* -// CHECK-NEXT: [[VBASE_OFFS:%.*]] = load i32* [[VBITCST]], align 4 +// CHECK-NEXT: [[VBTBLP:%.*]] = getelementptr inbounds %struct.A* [[CALL]], i32 0, i32 0 +// CHECK-NEXT: [[VBTBL:%.*]] = load i32** [[VBTBLP]], align 4 +// CHECK-NEXT: [[VBSLOT:%.*]] = getelementptr inbounds i32* [[VBTBL]], i32 1 +// CHECK-NEXT: [[VBASE_OFFS:%.*]] = load i32* [[VBSLOT]], align 4 // CHECK-NEXT: [[ADJ:%.*]] = getelementptr inbounds i8* [[THIS]], i32 [[VBASE_OFFS]] // CHECK-NEXT: [[RT:%.*]] = tail call i8* @__RTtypeid(i8* [[ADJ]]) // CHECK-NEXT: [[RET:%.*]] = bitcast i8* [[RT]] to %struct.type_info* diff --git a/test/CodeGenCXX/microsoft-abi-vftables.cpp b/test/CodeGenCXX/microsoft-abi-vftables.cpp index 825aba010f12..14bd6c388b01 100644 --- a/test/CodeGenCXX/microsoft-abi-vftables.cpp +++ b/test/CodeGenCXX/microsoft-abi-vftables.cpp @@ -9,7 +9,7 @@ struct S { virtual ~S(); } s; -// RTTI-DAG: [[VTABLE_S:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4S@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GS@@UAEPAXI@Z" to i8*)], comdat $"\01??_7S@@6B@" +// RTTI-DAG: [[VTABLE_S:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4S@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GS@@UAEPAXI@Z" to i8*)], comdat($"\01??_7S@@6B@") // RTTI-DAG: @"\01??_7S@@6B@" = unnamed_addr alias getelementptr inbounds ([2 x i8*]* [[VTABLE_S]], i32 0, i32 1) // NO-RTTI-DAG: @"\01??_7S@@6B@" = linkonce_odr unnamed_addr constant [1 x i8*] [i8* bitcast ({{.*}} @"\01??_GS@@UAEPAXI@Z" to i8*)] @@ -26,7 +26,7 @@ struct __declspec(dllexport) V { virtual ~V(); } v; -// RTTI-DAG: [[VTABLE_V:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4V@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GV@@UAEPAXI@Z" to i8*)], comdat $"\01??_7V@@6B@" +// RTTI-DAG: [[VTABLE_V:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4V@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GV@@UAEPAXI@Z" to i8*)], comdat($"\01??_7V@@6B@") // RTTI-DAG: @"\01??_7V@@6B@" = dllexport unnamed_addr alias getelementptr inbounds ([2 x i8*]* [[VTABLE_V]], i32 0, i32 1) // NO-RTTI-DAG: @"\01??_7V@@6B@" = weak_odr dllexport unnamed_addr constant [1 x i8*] [i8* bitcast ({{.*}} @"\01??_GV@@UAEPAXI@Z" to i8*)] @@ -36,7 +36,7 @@ struct W { virtual ~W(); } w; } -// RTTI-DAG: [[VTABLE_W:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4W@?A@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GW@?A@@UAEPAXI@Z" to i8*)], comdat $"\01??_7W@?A@@6B@" -// RTTI-DAG: @"\01??_7W@?A@@6B@" = unnamed_addr alias internal getelementptr inbounds ([2 x i8*]* @1, i32 0, i32 1) +// RTTI-DAG: [[VTABLE_W:@.*]] = private unnamed_addr constant [2 x i8*] [i8* bitcast ({{.*}} @"\01??_R4W@?A@@6B@" to i8*), i8* bitcast ({{.*}} @"\01??_GW@?A@@UAEPAXI@Z" to i8*)], comdat($"\01??_7W@?A@@6B@") +// RTTI-DAG: @"\01??_7W@?A@@6B@" = internal unnamed_addr alias getelementptr inbounds ([2 x i8*]* @1, i32 0, i32 1) // NO-RTTI-DAG: @"\01??_7W@?A@@6B@" = internal unnamed_addr constant [1 x i8*] [i8* bitcast ({{.*}} @"\01??_GW@?A@@UAEPAXI@Z" to i8*)] diff --git a/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp b/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp index a6fcdea749ab..26eb01205cf6 100644 --- a/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp +++ b/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp @@ -72,10 +72,9 @@ G::G() {} // Forces vftable emission. // CHECK: %[[VTORDISP_NEG:.*]] = sub i32 0, %[[VTORDISP]] // CHECK: %[[VTORDISP_ADJUSTED_i8:.*]] = getelementptr i8* %[[ECX_i8]], i32 %[[VTORDISP_NEG]] // CHECK: %[[VBPTR_i8:.*]] = getelementptr inbounds i8* %[[VTORDISP_ADJUSTED_i8]], i32 -16 -// CHECK: %[[VBPTR:.*]] = bitcast i8* %[[VBPTR_i8]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR]] -// CHECK: %[[VBOFFSET_PTR_i8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 12 -// CHECK: %[[VBOFFSET_PTR:.*]] = bitcast i8* %[[VBOFFSET_PTR_i8]] to i32* +// CHECK: %[[VBPTR:.*]] = bitcast i8* %[[VBPTR_i8]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR]] +// CHECK: %[[VBOFFSET_PTR:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 3 // CHECK: %[[VBASE_OFFSET:.*]] = load i32* %[[VBOFFSET_PTR]] // CHECK: %[[VBASE:.*]] = getelementptr inbounds i8* %[[VBPTR_i8]], i32 %[[VBASE_OFFSET]] // CHECK: %[[ARG_i8:.*]] = getelementptr i8* %[[VBASE]], i32 8 diff --git a/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp b/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp index 2f0fffee696f..7a00a731f5fa 100644 --- a/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp +++ b/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp @@ -32,8 +32,8 @@ B::B() { // ... // CHECK: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* // CHECK: %[[VFPTR_i8:.*]] = getelementptr inbounds i8* %[[THIS_i8]], i32 %{{.*}} - // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to [3 x i8*]** - // CHECK: store [3 x i8*]* @"\01??_7B@@6B@", [3 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([3 x i8*]* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // Initialize vtorDisp: // CHECK: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* @@ -65,8 +65,8 @@ B::~B() { // ... // CHECK: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* // CHECK: %[[VFPTR_i8:.*]] = getelementptr inbounds i8* %[[THIS_i8]], i32 %{{.*}} - // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to [3 x i8*]** - // CHECK: store [3 x i8*]* @"\01??_7B@@6B@", [3 x i8*]** %[[VFPTR]] + // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([3 x i8*]* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]] // Initialize vtorDisp: // CHECK: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* @@ -96,7 +96,7 @@ B::~B() { // CHECK2: call x86_thiscallcc void @"\01??1VBase@@UAE@XZ"(%struct.VBase* %[[VBASE]]) // CHECK2: ret - // CHECK2-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_GB@@UAEPAXI@Z" + // CHECK2-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_GB@@UAEPAXI@Z" // CHECK2: %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8* // CHECK2: %[[THIS_i8:.*]] = getelementptr inbounds i8* %[[THIS_PARAM_i8:.*]], i32 -8 // CHECK2: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B* @@ -122,10 +122,9 @@ void B::foo() { // CHECK: %[[THIS:.*]] = load %struct.B** %[[THIS_ADDR]] // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[THIS8]], i32 0 -// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] -// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 -// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR8]] +// CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 1 // CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8* @@ -147,10 +146,9 @@ void call_vbase_bar(B *obj) { // // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 -// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] -// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 -// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR8]] +// CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 1 // CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] @@ -161,10 +159,9 @@ void call_vbase_bar(B *obj) { // // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 -// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] -// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 -// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR8]] +// CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 1 // CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] // CHECK: %[[VBASE:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] @@ -181,30 +178,28 @@ void delete_B(B *obj) { delete obj; // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 -// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] -// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 -// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR8]] +// CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 1 // CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] -// CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to void (%struct.B*, i32)*** -// CHECK: %[[VFTABLE:.*]] = load void (%struct.B*, i32)*** %[[VFPTR]] -// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (%struct.B*, i32)** %[[VFTABLE]], i64 0 -// CHECK: %[[VFUN_VALUE:.*]] = load void (%struct.B*, i32)** %[[VFUN]] +// CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to i8* (%struct.B*, i32)*** +// CHECK: %[[VFTABLE:.*]] = load i8* (%struct.B*, i32)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds i8* (%struct.B*, i32)** %[[VFTABLE]], i64 0 +// CHECK: %[[VFUN_VALUE:.*]] = load i8* (%struct.B*, i32)** %[[VFUN]] // // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 -// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** -// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] -// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 -// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** +// CHECK: %[[VBTABLE:.*]] = load i32** %[[VBPTR8]] +// CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32* %[[VBTABLE]], i32 1 // CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] // CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.B* // -// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](%struct.B* %[[VBASE]], i32 1) +// CHECK: call x86_thiscallcc i8* %[[VFUN_VALUE]](%struct.B* %[[VBASE]], i32 1) // CHECK: ret void } @@ -250,9 +245,9 @@ struct D : virtual A, virtual B, virtual C { D::D() { // CHECK-LABEL: define x86_thiscallcc %"struct.multiple_vbases::D"* @"\01??0D@multiple_vbases@@QAE@XZ" // Just make sure we emit 3 vtordisps after initializing vfptrs. - // CHECK: store [1 x i8*]* @"\01??_7D@multiple_vbases@@6BA@1@@", [1 x i8*]** %{{.*}} - // CHECK: store [1 x i8*]* @"\01??_7D@multiple_vbases@@6BB@1@@", [1 x i8*]** %{{.*}} - // CHECK: store [1 x i8*]* @"\01??_7D@multiple_vbases@@6BC@1@@", [1 x i8*]** %{{.*}} + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BA@1@@" to i32 (...)**), i32 (...)*** %{{.*}} + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BB@1@@" to i32 (...)**), i32 (...)*** %{{.*}} + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BC@1@@" to i32 (...)**), i32 (...)*** %{{.*}} // ... // CHECK: store i32 %{{.*}}, i32* %{{.*}} // CHECK: store i32 %{{.*}}, i32* %{{.*}} @@ -401,8 +396,8 @@ C::~C() { // In this case "this" points to the most derived class, so no GEPs needed. // CHECK-NOT: getelementptr // CHECK-NOT: bitcast - // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::C"* %{{.*}} to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7C@test4@@6BB@1@@", [1 x i8*]** %[[VFPTR_i8]] + // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::C"* %{{.*}} to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7C@test4@@6BB@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]] foo(this); // CHECK: ret @@ -412,11 +407,11 @@ void destroy(C *obj) { // CHECK-LABEL: define void @"\01?destroy@test4@@YAXPAUC@1@@Z"(%"struct.test4::C"* %obj) delete obj; - // CHECK: %[[VPTR:.*]] = bitcast %"struct.test4::C"* %[[OBJ:.*]] to void (%"struct.test4::C"*, i32)*** - // CHECK: %[[VFTABLE:.*]] = load void (%"struct.test4::C"*, i32)*** %[[VPTR]] - // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds void (%"struct.test4::C"*, i32)** %[[VFTABLE]], i64 0 - // CHECK: %[[VFUN:.*]] = load void (%"struct.test4::C"*, i32)** %[[VFTENTRY]] - // CHECK: call x86_thiscallcc void %[[VFUN]](%"struct.test4::C"* %[[OBJ]], i32 1) + // CHECK: %[[VPTR:.*]] = bitcast %"struct.test4::C"* %[[OBJ:.*]] to i8* (%"struct.test4::C"*, i32)*** + // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::C"*, i32)*** %[[VPTR]] + // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::C"*, i32)** %[[VFTABLE]], i64 0 + // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::C"*, i32)** %[[VFTENTRY]] + // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::C"* %[[OBJ]], i32 1) // CHECK: ret } @@ -436,8 +431,8 @@ E::~E() { // In this case "this" points to the most derived class, so no GEPs needed. // CHECK-NOT: getelementptr // CHECK-NOT: bitcast - // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::E"* %{{.*}} to [1 x i8*]** - // CHECK: store [1 x i8*]* @"\01??_7E@test4@@6BD@1@@", [1 x i8*]** %[[VFPTR_i8]] + // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::E"* %{{.*}} to i32 (...)*** + // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7E@test4@@6BD@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]] foo(this); } @@ -447,15 +442,15 @@ void destroy(E *obj) { // CHECK-NOT: getelementptr // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ:.*]] to i8* // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 4 - // CHECK: %[[VPTR:.*]] = bitcast i8* %[[B_i8]] to void (%"struct.test4::E"*, i32)*** - // CHECK: %[[VFTABLE:.*]] = load void (%"struct.test4::E"*, i32)*** %[[VPTR]] - // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds void (%"struct.test4::E"*, i32)** %[[VFTABLE]], i64 0 - // CHECK: %[[VFUN:.*]] = load void (%"struct.test4::E"*, i32)** %[[VFTENTRY]] + // CHECK: %[[VPTR:.*]] = bitcast i8* %[[B_i8]] to i8* (%"struct.test4::E"*, i32)*** + // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::E"*, i32)*** %[[VPTR]] + // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::E"*, i32)** %[[VFTABLE]], i64 0 + // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::E"*, i32)** %[[VFTENTRY]] // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ]] to i8* // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 4 // FIXME: in fact, the call should take i8* and the bitcast is redundant. // CHECK: %[[B_as_E:.*]] = bitcast i8* %[[B_i8]] to %"struct.test4::E"* - // CHECK: call x86_thiscallcc void %[[VFUN]](%"struct.test4::E"* %[[B_as_E]], i32 1) + // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::E"* %[[B_as_E]], i32 1) delete obj; } diff --git a/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp b/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp index 974953c01444..b5db7c7881b5 100644 --- a/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp +++ b/test/CodeGenCXX/microsoft-abi-virtual-member-pointers.cpp @@ -45,92 +45,95 @@ void f() { // CHECK32-LABEL: define void @"\01?f@@YAXXZ"() -// CHECK32: store i8* bitcast (void (%struct.C*)* @"\01??_9C@@$BA@AE" to i8*), i8** %ptr -// CHECK32: store i8* bitcast (i32 (%struct.C*, i32, double)* @"\01??_9C@@$B3AE" to i8*), i8** %ptr2 -// CHECK32: store i8* bitcast (void (%struct.C*, %struct.S*, i32)* @"\01??_9C@@$B7AE" to i8*), i8** %ptr3 -// CHECK32: store i8* bitcast (void (%"struct.(anonymous namespace)::D"*)* @"\01??_9D@?A@@$BA@AE" to i8*), i8** %ptr4 +// CHECK32: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$BA@AE" to i8*), i8** %ptr +// CHECK32: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$B3AE" to i8*), i8** %ptr2 +// CHECK32: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$B7AE" to i8*), i8** %ptr3 +// CHECK32: store i8* bitcast (void (%"struct.(anonymous namespace)::D"*, ...)* @"\01??_9D@?A@@$BA@AE" to i8*), i8** %ptr4 // CHECK32: } // // CHECK64-LABEL: define void @"\01?f@@YAXXZ"() -// CHECK64: store i8* bitcast (void (%struct.C*)* @"\01??_9C@@$BA@AA" to i8*), i8** %ptr -// CHECK64: store i8* bitcast (i32 (%struct.C*, i32, double)* @"\01??_9C@@$B7AA" to i8*), i8** %ptr2 -// CHECK64: store i8* bitcast (void (%struct.C*, %struct.S*, i32)* @"\01??_9C@@$BBA@AA" to i8*), i8** %ptr3 -// CHECK64: store i8* bitcast (void (%"struct.(anonymous namespace)::D"*)* @"\01??_9D@?A@@$BA@AA" to i8*), i8** %ptr +// CHECK64: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$BA@AA" to i8*), i8** %ptr +// CHECK64: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$B7AA" to i8*), i8** %ptr2 +// CHECK64: store i8* bitcast (void (%struct.C*, ...)* @"\01??_9C@@$BBA@AA" to i8*), i8** %ptr3 +// CHECK64: store i8* bitcast (void (%"struct.(anonymous namespace)::D"*, ...)* @"\01??_9D@?A@@$BA@AA" to i8*), i8** %ptr // CHECK64: } } // Thunk for calling the 1st virtual function in C with no parameters. -// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$BA@AE"(%struct.C* %this) unnamed_addr -// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*)** %{{.*}}, i64 0 -// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*)** [[VPTR]] -// CHECK32: musttail call x86_thiscallcc void [[CALLEE]](%struct.C* %{{.*}}) -// CHECK32: ret void +// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$BA@AE"(%struct.C* %this, ...) +// CHECK32-NOT: unnamed_addr +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 0 +// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK32-NEXT: ret void // CHECK32: } // -// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BA@AA"(%struct.C* %this) unnamed_addr -// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*)** %{{.*}}, i64 0 -// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*)** [[VPTR]] -// CHECK64: musttail call void [[CALLEE]](%struct.C* %{{.*}}) -// CHECK64: ret void +// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BA@AA"(%struct.C* %this, ...) +// CHECK64-NOT: unnamed_addr +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 0 +// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK64: musttail call void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK64-NEXT: ret void // CHECK64: } // Thunk for calling the 2nd virtual function in C, taking int and double as parameters, returning int. -// CHECK32-LABEL: define linkonce_odr x86_thiscallcc i32 @"\01??_9C@@$B3AE"(%struct.C* %this, i32, double) unnamed_addr -// CHECK32: [[VPTR:%.*]] = getelementptr inbounds i32 (%struct.C*, i32, double)** %{{.*}}, i64 1 -// CHECK32: [[CALLEE:%.*]] = load i32 (%struct.C*, i32, double)** [[VPTR]] -// CHECK32: [[CALL:%.*]] = musttail call x86_thiscallcc i32 [[CALLEE]](%struct.C* %{{.*}}, i32 %{{.*}}, double %{{.*}}) -// CHECK32: ret i32 [[CALL]] +// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$B3AE"(%struct.C* %this, ...) +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 1 +// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK32-NEXT: ret void // CHECK32: } // -// CHECK64-LABEL: define linkonce_odr i32 @"\01??_9C@@$B7AA"(%struct.C* %this, i32, double) unnamed_addr -// CHECK64: [[VPTR:%.*]] = getelementptr inbounds i32 (%struct.C*, i32, double)** %{{.*}}, i64 1 -// CHECK64: [[CALLEE:%.*]] = load i32 (%struct.C*, i32, double)** [[VPTR]] -// CHECK64: [[CALL:%.*]] = musttail call i32 [[CALLEE]](%struct.C* %{{.*}}, i32 %{{.*}}, double %{{.*}}) -// CHECK64: ret i32 [[CALL]] +// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$B7AA"(%struct.C* %this, ...) +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 1 +// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK64: musttail call void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK64-NEXT: ret void // CHECK64: } // Thunk for calling the 3rd virtual function in C, taking an int parameter, returning a struct. -// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$B7AE"(%struct.C* %this, %struct.S* noalias sret %agg.result, i32) unnamed_addr -// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, %struct.S*, i32)** %{{.*}}, i64 2 -// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, %struct.S*, i32)** [[VPTR]] -// CHECK32: musttail call x86_thiscallcc void [[CALLEE]](%struct.C* %{{.*}}, %struct.S* sret %agg.result, i32 %{{.*}}) -// CHECK32: ret void +// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$B7AE"(%struct.C* %this, ...) +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 2 +// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK32-NEXT: ret void // CHECK32: } // -// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BBA@AA"(%struct.C* %this, %struct.S* noalias sret %agg.result, i32) unnamed_addr -// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, %struct.S*, i32)** %{{.*}}, i64 2 -// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, %struct.S*, i32)** [[VPTR]] -// CHECK64: musttail call void [[CALLEE]](%struct.C* %{{.*}}, %struct.S* sret %agg.result, i32 %{{.*}}) -// CHECK64: ret void +// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BBA@AA"(%struct.C* %this, ...) +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 2 +// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK64: musttail call void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK64-NEXT: ret void // CHECK64: } // Thunk for calling the virtual function in internal class D. -// CHECK32-LABEL: define internal x86_thiscallcc void @"\01??_9D@?A@@$BA@AE"(%"struct.(anonymous namespace)::D"* %this) unnamed_addr -// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%"struct.(anonymous namespace)::D"*)** %{{.*}}, i64 0 -// CHECK32: [[CALLEE:%.*]] = load void (%"struct.(anonymous namespace)::D"*)** [[VPTR]] -// CHECK32: musttail call x86_thiscallcc void [[CALLEE]](%"struct.(anonymous namespace)::D"* %{{.*}}) -// CHECK32: ret void +// CHECK32-LABEL: define internal x86_thiscallcc void @"\01??_9D@?A@@$BA@AE"(%"struct.(anonymous namespace)::D"* %this, ...) +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%"struct.(anonymous namespace)::D"*, ...)** %{{.*}}, i64 0 +// CHECK32: [[CALLEE:%.*]] = load void (%"struct.(anonymous namespace)::D"*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%"struct.(anonymous namespace)::D"*, ...)* [[CALLEE]](%"struct.(anonymous namespace)::D"* %{{.*}}, ...) +// CHECK32-NEXT: ret void // CHECK32: } // -// CHECK64-LABEL: define internal void @"\01??_9D@?A@@$BA@AA"(%"struct.(anonymous namespace)::D"* %this) unnamed_addr -// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%"struct.(anonymous namespace)::D"*)** %{{.*}}, i64 0 -// CHECK64: [[CALLEE:%.*]] = load void (%"struct.(anonymous namespace)::D"*)** [[VPTR]] -// CHECK64: musttail call void [[CALLEE]](%"struct.(anonymous namespace)::D"* %{{.*}}) -// CHECK64: ret void +// CHECK64-LABEL: define internal void @"\01??_9D@?A@@$BA@AA"(%"struct.(anonymous namespace)::D"* %this, ...) +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%"struct.(anonymous namespace)::D"*, ...)** %{{.*}}, i64 0 +// CHECK64: [[CALLEE:%.*]] = load void (%"struct.(anonymous namespace)::D"*, ...)** [[VPTR]] +// CHECK64: musttail call void (%"struct.(anonymous namespace)::D"*, ...)* [[CALLEE]](%"struct.(anonymous namespace)::D"* %{{.*}}, ...) +// CHECK64-NEXT: ret void // CHECK64: } -// Thunk for calling the fourth virtual function in C, taking a struct parameter and returning a struct. -// CHECK32-LABEL: define linkonce_odr x86_thiscallcc %struct.S* @"\01??_9C@@$BM@AE"(%struct.C* %this, <{ %struct.S*, %struct.U }>* inalloca) unnamed_addr -// CHECK32: [[VPTR:%.*]] = getelementptr inbounds %struct.S* (%struct.C*, <{ %struct.S*, %struct.U }>*)** %{{.*}}, i64 3 -// CHECK32: [[CALLEE:%.*]] = load %struct.S* (%struct.C*, <{ %struct.S*, %struct.U }>*)** [[VPTR]] -// CHECK32: [[CALL:%.*]] = musttail call x86_thiscallcc %struct.S* [[CALLEE]](%struct.C* %this, <{ %struct.S*, %struct.U }>* inalloca %{{.*}}) -// CHECK32: ret %struct.S* [[CALL]] +// Thunk for calling the fourth virtual function in C, taking a struct parameter +// and returning a struct. +// CHECK32-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@@$BM@AE"(%struct.C* %this, ...) +// CHECK32: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 3 +// CHECK32: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK32: musttail call x86_thiscallcc void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) +// CHECK32-NEXT: ret void // CHECK32: } // -// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BBI@AA"(%struct.C* %this, %struct.S* noalias sret %agg.result, %struct.U*) unnamed_addr -// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, %struct.S*, %struct.U*)** %{{.*}}, i64 3 -// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, %struct.S*, %struct.U*)** [[VPTR]] -// CHECK64: musttail call void [[CALLEE]](%struct.C* %this, %struct.S* sret %agg.result, %struct.U* %{{.*}}) +// CHECK64-LABEL: define linkonce_odr void @"\01??_9C@@$BBI@AA"(%struct.C* %this, ...) +// CHECK64: [[VPTR:%.*]] = getelementptr inbounds void (%struct.C*, ...)** %{{.*}}, i64 3 +// CHECK64: [[CALLEE:%.*]] = load void (%struct.C*, ...)** [[VPTR]] +// CHECK64: musttail call void (%struct.C*, ...)* [[CALLEE]](%struct.C* %{{.*}}, ...) // CHECK64: ret void // CHECK64: } diff --git a/test/CodeGenCXX/microsoft-abi-vmemptr-conflicts.cpp b/test/CodeGenCXX/microsoft-abi-vmemptr-conflicts.cpp new file mode 100644 index 000000000000..35ff4f3bebef --- /dev/null +++ b/test/CodeGenCXX/microsoft-abi-vmemptr-conflicts.cpp @@ -0,0 +1,101 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm -triple=i386-pc-win32 %s -o - | FileCheck %s + +// In each test case, we have two member pointers whose thunks have the same +// vtable offset and same mangling, but their prototypes conflict. The +// arguments and return type may differ. Therefore, we have to bitcast the +// function prototype. Unfortunately, if the return types differ, LLVM's +// optimizers can get upset. + +namespace num_params { +struct A { virtual void a(int); }; +struct B { virtual void b(int, int); }; +struct C : A, B { + virtual void a(int); + virtual void b(int, int); +}; +void f(C *c) { + (c->*(&C::a))(0); + (c->*(&C::b))(0, 0); +} +} + +// CHECK-LABEL: define void @"\01?f@num_params@@YAXPAUC@1@@Z"(%"struct.num_params::C"* %c) +// CHECK: call x86_thiscallcc void bitcast (void (%"struct.num_params::C"*, ...)* @"\01??_9C@num_params@@$BA@AE" to void (%"struct.num_params::C"*, i32)*)(%"struct.num_params::C"* %{{.*}}, i32 0) +// CHECK: call x86_thiscallcc void bitcast (void (%"struct.num_params::C"*, ...)* @"\01??_9C@num_params@@$BA@AE" to void (%"struct.num_params::C"*, i32, i32)*)(%"struct.num_params::C"* %{{.*}}, i32 0, i32 0) + +// CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@num_params@@$BA@AE"(%"struct.num_params::C"* %this, ...) +// CHECK: musttail call x86_thiscallcc void (%"struct.num_params::C"*, ...)* %{{.*}}(%"struct.num_params::C"* %{{.*}}, ...) +// CHECK-NEXT: ret void + +namespace i64_return { +struct A { virtual int a(); }; +struct B { virtual long long b(); }; +struct C : A, B { + virtual int a(); + virtual long long b(); +}; +long long f(C *c) { + int x = (c->*(&C::a))(); + long long y = (c->*(&C::b))(); + return x + y; +} +} + +// CHECK-LABEL: define i64 @"\01?f@i64_return@@YA_JPAUC@1@@Z"(%"struct.i64_return::C"* %c) +// CHECK: call x86_thiscallcc i32 bitcast (void (%"struct.i64_return::C"*, ...)* @"\01??_9C@i64_return@@$BA@AE" to i32 (%"struct.i64_return::C"*)*)(%"struct.i64_return::C"* %{{.*}}) +// CHECK: call x86_thiscallcc i64 bitcast (void (%"struct.i64_return::C"*, ...)* @"\01??_9C@i64_return@@$BA@AE" to i64 (%"struct.i64_return::C"*)*)(%"struct.i64_return::C"* %{{.*}}) + +// CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@i64_return@@$BA@AE"(%"struct.i64_return::C"* %this, ...) +// CHECK: musttail call x86_thiscallcc void (%"struct.i64_return::C"*, ...)* %{{.*}}(%"struct.i64_return::C"* %{{.*}}, ...) +// CHECK-NEXT: ret void + +namespace sret { +struct Big { int big[32]; }; +struct A { virtual int a(); }; +struct B { virtual Big b(); }; +struct C : A, B { + virtual int a(); + virtual Big b(); +}; +void f(C *c) { + (c->*(&C::a))(); + Big b((c->*(&C::b))()); +} +} + +// CHECK-LABEL: define void @"\01?f@sret@@YAXPAUC@1@@Z"(%"struct.sret::C"* %c) +// CHECK: call x86_thiscallcc i32 bitcast (void (%"struct.sret::C"*, ...)* @"\01??_9C@sret@@$BA@AE" to i32 (%"struct.sret::C"*)*)(%"struct.sret::C"* %{{.*}}) +// CHECK: call x86_thiscallcc void bitcast (void (%"struct.sret::C"*, ...)* @"\01??_9C@sret@@$BA@AE" to void (%"struct.sret::C"*, %"struct.sret::Big"*)*)(%"struct.sret::C"* %{{.*}}, %"struct.sret::Big"* sret %{{.*}}) + +// CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@sret@@$BA@AE"(%"struct.sret::C"* %this, ...) +// CHECK: musttail call x86_thiscallcc void (%"struct.sret::C"*, ...)* %{{.*}}(%"struct.sret::C"* %{{.*}}, ...) +// CHECK-NEXT: ret void + +namespace cdecl_inalloca { +// Fairly evil, since now we end up doing an inalloca-style call through a +// thunk that doesn't use inalloca. Hopefully the stacks line up? +struct Big { + Big(); + ~Big(); + int big[32]; +}; +struct A { virtual void __cdecl a(); }; +struct B { virtual void __cdecl b(Big); }; +struct C : A, B { + virtual void __cdecl a(); + virtual void __cdecl b(Big); +}; +void f(C *c) { + Big b; + (c->*(&C::a))(); + ((c->*(&C::b))(b)); +} +} + +// CHECK-LABEL: define void @"\01?f@cdecl_inalloca@@YAXPAUC@1@@Z"(%"struct.cdecl_inalloca::C"* %c) +// CHECK: call void bitcast (void (%"struct.cdecl_inalloca::C"*, ...)* @"\01??_9C@cdecl_inalloca@@$BA@AE" to void (%"struct.cdecl_inalloca::C"*)*)(%"struct.cdecl_inalloca::C"* %{{.*}}) +// CHECK: call void bitcast (void (%"struct.cdecl_inalloca::C"*, ...)* @"\01??_9C@cdecl_inalloca@@$BA@AE" to void (<{ %"struct.cdecl_inalloca::C"*, %"struct.cdecl_inalloca::Big" }>*)*)(<{ %"struct.cdecl_inalloca::C"*, %"struct.cdecl_inalloca::Big" }>* inalloca %{{.*}}) + +// CHECK-LABEL: define linkonce_odr void @"\01??_9C@cdecl_inalloca@@$BA@AE"(%"struct.cdecl_inalloca::C"* %this, ...) +// CHECK: musttail call void (%"struct.cdecl_inalloca::C"*, ...)* %{{.*}}(%"struct.cdecl_inalloca::C"* %{{.*}}, ...) +// CHECK-NEXT: ret void diff --git a/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp b/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp new file mode 100644 index 000000000000..6d42b8504abf --- /dev/null +++ b/test/CodeGenCXX/microsoft-abi-vmemptr-fastcall.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fms-extensions -triple i686-pc-windows-msvc %s -emit-llvm-only -verify + +// We reject this because LLVM doesn't forward the second regparm through the +// thunk. + +struct A { + virtual void __fastcall f(int a, int b); // expected-error {{cannot compile this pointer to fastcall virtual member function yet}} +}; +void (__fastcall A::*doit())(int, int) { + return &A::f; +} diff --git a/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-return-adjustment.cpp b/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-return-adjustment.cpp index 2d0bf6362296..232c0d9c4dd8 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-return-adjustment.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-return-adjustment.cpp @@ -295,3 +295,70 @@ struct X : E { void build_vftable(X *obj) { obj->foo(); } } + +namespace test7 { +struct A { + virtual A *f() = 0; +}; +struct B { + virtual void g(); +}; +struct C : B, A { + virtual void g(); + virtual C *f() = 0; + // CHECK-LABEL: VFTable for 'test7::B' in 'test7::C' (1 entry). + // CHECK-NEXT: 0 | void test7::C::g() + + // CHECK-LABEL: VFTable for 'test7::A' in 'test7::C' (2 entries). + // CHECK-NEXT: 0 | test7::C *test7::C::f() [pure] + // CHECK-NEXT: 1 | test7::C *test7::C::f() [pure] + + // No return adjusting thunks needed for pure virtual methods. + // CHECK-NOT: Thunks for 'test7::C *test7::C::f()' +}; + +void build_vftable(C *obj) { obj->g(); } +} + +namespace pr20444 { +struct A { + virtual A* f(); +}; +struct B { + virtual B* f(); +}; +struct C : A, B { + virtual C* f(); + // CHECK-LABEL: VFTable for 'pr20444::A' in 'pr20444::C' (1 entry). + // CHECK-NEXT: 0 | pr20444::C *pr20444::C::f() + + // CHECK-LABEL: VFTable for 'pr20444::B' in 'pr20444::C' (2 entries). + // CHECK-NEXT: 0 | pr20444::C *pr20444::C::f() + // CHECK-NEXT: [return adjustment (to type 'struct pr20444::B *'): 4 non-virtual] + // CHECK-NEXT: [this adjustment: -4 non-virtual] + // CHECK-NEXT: 1 | pr20444::C *pr20444::C::f() + // CHECK-NEXT: [return adjustment (to type 'struct pr20444::C *'): 0 non-virtual] + // CHECK-NEXT: [this adjustment: -4 non-virtual] +}; + +void build_vftable(C *obj) { obj->f(); } + +struct D : C { + virtual D* f(); + // CHECK-LABEL: VFTable for 'pr20444::A' in 'pr20444::C' in 'pr20444::D' (1 entry). + // CHECK-NEXT: 0 | pr20444::D *pr20444::D::f() + + // CHECK-LABEL: VFTable for 'pr20444::B' in 'pr20444::C' in 'pr20444::D' (3 entries). + // CHECK-NEXT: 0 | pr20444::D *pr20444::D::f() + // CHECK-NEXT: [return adjustment (to type 'struct pr20444::B *'): 4 non-virtual] + // CHECK-NEXT: [this adjustment: -4 non-virtual] + // CHECK-NEXT: 1 | pr20444::D *pr20444::D::f() + // CHECK-NEXT: [return adjustment (to type 'struct pr20444::C *'): 0 non-virtual] + // CHECK-NEXT: [this adjustment: -4 non-virtual] + // CHECK-NEXT: 2 | pr20444::D *pr20444::D::f() + // CHECK-NEXT: [return adjustment (to type 'struct pr20444::D *'): 0 non-virtual] + // CHECK-NEXT: [this adjustment: -4 non-virtual] +}; + +void build_vftable(D *obj) { obj->f(); } +} diff --git a/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp b/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp index 957980aa95ec..d71f40a5ecc6 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp @@ -1,6 +1,6 @@ // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t.ll -fdump-vtable-layouts >%t // RUN: FileCheck %s < %t -// RUN: FileCheck --check-prefix=MANGLING %s < %t.ll +// RUN: FileCheck --check-prefix=BITCODE %s < %t.ll namespace test1 { struct A { @@ -29,8 +29,8 @@ struct X : A, B { // CHECK-LABEL: VFTable indices for 'test1::X' (1 entry). // CHECK-NEXT: 0 | void test1::X::g() - // MANGLING-DAG: @"\01??_7X@test1@@6BA@1@@" - // MANGLING-DAG: @"\01??_7X@test1@@6BB@1@@" + // BITCODE-DAG: @"\01??_7X@test1@@6BA@1@@" + // BITCODE-DAG: @"\01??_7X@test1@@6BB@1@@" virtual void g(); } x; @@ -71,9 +71,9 @@ struct X : A, B, C { // CHECK-NEXT: via vfptr at offset 4 // CHECK-NEXT: 0 | void test2::X::g() - // MANGLING-DAG: @"\01??_7X@test2@@6BA@1@@" - // MANGLING-DAG: @"\01??_7X@test2@@6BB@1@@" - // MANGLING-DAG: @"\01??_7X@test2@@6BC@1@@" + // BITCODE-DAG: @"\01??_7X@test2@@6BA@1@@" + // BITCODE-DAG: @"\01??_7X@test2@@6BB@1@@" + // BITCODE-DAG: @"\01??_7X@test2@@6BC@1@@" virtual void g(); } x; @@ -138,3 +138,42 @@ struct X: C, D { void build_vftable(X *obj) { obj->g(); } } + +namespace test4 { +struct A { + virtual void foo(); +}; +struct B { + virtual int filler(); + virtual int operator-(); + virtual int bar(); +}; +struct C : public A, public B { + virtual int filler(); + virtual int operator-(); + virtual int bar(); +}; + +// BITCODE-LABEL: define {{.*}}\01?ffun@test4@@YAXAAUC@1@@Z +void ffun(C &c) { + // BITCODE: load + // BITCODE: bitcast + // BITCODE: bitcast + // BITCODE: [[THIS1:%.+]] = bitcast %"struct.test4::C"* {{.*}} to i8* + // BITCODE: [[THIS2:%.+]] = getelementptr inbounds i8* [[THIS1]], i32 4 + // BITCODE-NEXT: call x86_thiscallcc {{.*}}(i8* [[THIS2]]) + c.bar(); +} + +// BITCODE-LABEL: define {{.*}}\01?fop@test4@@YAXAAUC@1@@Z +void fop(C &c) { + // BITCODE: load + // BITCODE: bitcast + // BITCODE: bitcast + // BITCODE: [[THIS1:%.+]] = bitcast %"struct.test4::C"* {{.*}} to i8* + // BITCODE: [[THIS2:%.+]] = getelementptr inbounds i8* [[THIS1]], i32 4 + // BITCODE-NEXT: call x86_thiscallcc {{.*}}(i8* [[THIS2]]) + -c; +} + +} diff --git a/test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp b/test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp index a4a21106c685..072cb956035f 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-return-thunks.cpp @@ -104,3 +104,27 @@ K::K() {} // GLOBALS-LABEL: @"\01??_7K@test2@@6B@" = linkonce_odr unnamed_addr constant [3 x i8*] } + +namespace pr20479 { +struct A { + virtual A *f(); +}; + +struct B : virtual A { + virtual B *f(); +}; + +struct C : virtual A, B { +// VFTABLES-LABEL: VFTable for 'pr20479::A' in 'pr20479::B' in 'pr20479::C' (2 entries). +// VFTABLES-NEXT: 0 | pr20479::B *pr20479::B::f() +// VFTABLES-NEXT: [return adjustment (to type 'struct pr20479::A *'): vbase #1, 0 non-virtual] +// VFTABLES-NEXT: 1 | pr20479::B *pr20479::B::f() + C(); +}; + +C::C() {} + +// GLOBALS-LABEL: @"\01??_7C@pr20479@@6B@" = linkonce_odr unnamed_addr constant [2 x i8*] +// GLOBALS: @"\01?f@B@pr20479@@QAEPAUA@2@XZ" +// GLOBALS: @"\01?f@B@pr20479@@UAEPAU12@XZ" +} diff --git a/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp b/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp index d453f5c55aed..baed35145f98 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp @@ -289,3 +289,13 @@ struct R : Q { R r; void use(R *obj) { obj->foo(42l); } + +struct S { + // CHECK-LABEL: VFTable for 'S' (1 entry). + // CHECK-NEXT: 0 | void S::f() [deleted] + virtual void f() = delete; + S(); + // EMITS-VFTABLE-DAG: @"\01??_7S@@6B@" = linkonce_odr unnamed_addr constant [1 x i8*] [i8* bitcast (void ()* @_purecall to i8*)] +}; + +S::S() {} diff --git a/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp b/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp index f63808a89873..1f6d4202154a 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance-vtordisps.cpp @@ -32,8 +32,8 @@ struct V4 : Z, V1, V2 { void use_somewhere_else(void*); namespace simple { -// In case of a single-layer virtual inheritance, the "this" adjustment is done -// staically: +// In case of a single-layer virtual inheritance, the "this" adjustment for a +// virtual method is done staically: // struct A { // virtual void f(); // Expects "(A*)this" in ECX // }; @@ -48,9 +48,9 @@ namespace simple { // current class layout and the most derived class layout are different. // This is done using vtordisp thunks. // -// A simple vtordisp{A,B} thunk for Method@Class is something like: -// sub ecx, [ecx+A] // apply the vtordisp adjustment -// sub ecx, B // apply the subobject adjustment, if needed. +// A simple vtordisp{x,y} thunk for Method@Class is something like: +// sub ecx, [ecx+x] // apply the vtordisp adjustment +// sub ecx, y // apply the subobject adjustment, if needed. // jmp Method@Class struct A : virtual V1 { @@ -227,12 +227,12 @@ namespace extended { // In this case, we should use the extended form of vtordisp thunks, called // vtordispex thunks. // -// vtordispex{A,B,C,D} thunk for Method@Class is something like: -// sub ecx, [ecx+C] // apply the vtordisp adjustment -// sub ecx, A // jump to the vbtable of the most derived class +// vtordispex{x,y,z,w} thunk for Method@Class is something like: +// sub ecx, [ecx+z] // apply the vtordisp adjustment +// sub ecx, x // jump to the vbptr of the most derived class // mov eax, [ecx] // load the vbtable address -// add ecx, [eax+B] // lookup the final overrider's vbase offset -// add ecx, D // apphy the subobject offset if needed +// add ecx, [eax+y] // lookup the final overrider's vbase offset +// add ecx, w // apphy the subobject offset if needed // jmp Method@Class struct A : virtual simple::A { diff --git a/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp b/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp index 4ce4e9c2e17e..65d6a9d90e6d 100644 --- a/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp +++ b/test/CodeGenCXX/microsoft-abi-vtables-virtual-inheritance.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm -o %t.ll -fdump-vtable-layouts %s -triple=i386-pc-win32 >%t +// RUN: %clang_cc1 -std=c++11 -fms-extensions -fno-rtti -emit-llvm -o %t.ll -fdump-vtable-layouts %s -triple=i386-pc-win32 >%t // RUN: FileCheck %s < %t // RUN: FileCheck --check-prefix=MANGLING %s < %t.ll @@ -764,3 +764,46 @@ struct W : B, Y { W::W() {} } + +namespace Test13 { +struct A { + virtual void f(); +}; +struct __declspec(dllexport) B : virtual A { + virtual void f() = 0; + // MANGLING-DAG: @"\01??_7B@Test13@@6B@" = weak_odr dllexport unnamed_addr constant [1 x i8*] [i8* bitcast (void ()* @_purecall to i8*)] +}; +} + +namespace pr21031_1 { +// This ordering of base specifiers regressed in r202425. +struct A { virtual void f(void); }; +struct B : virtual A { virtual void g(void); }; +struct C : virtual A, B { C(); }; +C::C() {} + +// CHECK-LABEL: VFTable for 'pr21031_1::A' in 'pr21031_1::B' in 'pr21031_1::C' (1 entry) +// CHECK-NEXT: 0 | void pr21031_1::A::f() + +// CHECK-LABEL: VFTable for 'pr21031_1::B' in 'pr21031_1::C' (1 entry) +// CHECK-NEXT: 0 | void pr21031_1::B::g() + +// MANGLING-DAG: @"\01??_7C@pr21031_1@@6BB@1@@" = {{.*}} constant [1 x i8*] +// MANGLING-DAG: @"\01??_7C@pr21031_1@@6B@" = {{.*}} constant [1 x i8*] +} + +namespace pr21031_2 { +struct A { virtual void f(void); }; +struct B : virtual A { virtual void g(void); }; +struct C : B, virtual A { C(); }; +C::C() {} + +// CHECK-LABEL: VFTable for 'pr21031_2::B' in 'pr21031_2::C' (1 entry) +// CHECK-NEXT: 0 | void pr21031_2::B::g() + +// CHECK-LABEL: VFTable for 'pr21031_2::A' in 'pr21031_2::B' in 'pr21031_2::C' (1 entry) +// CHECK-NEXT: 0 | void pr21031_2::A::f() + +// MANGLING-DAG: @"\01??_7C@pr21031_2@@6BA@1@@" = {{.*}} constant [1 x i8*] +// MANGLING-DAG: @"\01??_7C@pr21031_2@@6BB@1@@" = {{.*}} constant [1 x i8*] +} diff --git a/test/CodeGenCXX/microsoft-interface.cpp b/test/CodeGenCXX/microsoft-interface.cpp index c030d1d0b3b5..ec558a408178 100644 --- a/test/CodeGenCXX/microsoft-interface.cpp +++ b/test/CodeGenCXX/microsoft-interface.cpp @@ -34,7 +34,7 @@ int fn() { // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @_ZN1SC2Ev(%struct.S* %this) // CHECK: call x86_thiscallcc void @_ZN1IC2Ev(%__interface.I* %{{[.0-9A-Z_a-z]+}}) -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1S, i64 0, i64 2), i8*** %{{[.0-9A-Z_a-z]+}} +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1S, i64 0, i64 2) to i32 (...)**), i32 (...)*** %{{[.0-9A-Z_a-z]+}} // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @_ZN1IC2Ev(%__interface.I* %this) -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1I, i64 0, i64 2), i8*** %{{[.0-9A-Z_a-z]+}} +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1I, i64 0, i64 2) to i32 (...)**), i32 (...)*** %{{[.0-9A-Z_a-z]+}} diff --git a/test/CodeGenCXX/microsoft-no-rtti-data.cpp b/test/CodeGenCXX/microsoft-no-rtti-data.cpp index d4002c28b1a2..fded4c91e4f1 100644 --- a/test/CodeGenCXX/microsoft-no-rtti-data.cpp +++ b/test/CodeGenCXX/microsoft-no-rtti-data.cpp @@ -1,6 +1,7 @@ // RUN: %clang_cc1 %s -fno-rtti-data -triple=i386-pc-win32 -o - -emit-llvm | FileCheck %s // vftable shouldn't have RTTI data in it. +// CHECK-NOT: @"\01??_R4S@@6B@" // CHECK: @"\01??_7S@@6B@" = linkonce_odr unnamed_addr constant [1 x i8*] [i8* bitcast ({{.*}} @"\01??_GS@@UAEPAXI@Z" to i8*)] struct type_info; diff --git a/test/CodeGenCXX/microsoft-uuidof-mangling.cpp b/test/CodeGenCXX/microsoft-uuidof-mangling.cpp new file mode 100644 index 000000000000..9019aa8c9217 --- /dev/null +++ b/test/CodeGenCXX/microsoft-uuidof-mangling.cpp @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-unknown-unknown -fms-extensions | FileCheck %s +// rdar://17784718 + +typedef struct _GUID +{ + unsigned int Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[ 8 ]; +} GUID; + + +template < typename T, const GUID & T_iid = __uuidof(T)> +class UUIDTest +{ +public: + UUIDTest() { } +}; + +struct __declspec(uuid("EAFA1952-66F8-438B-8FBA-AF1BBAE42191")) TestStruct +{ + int foo; +}; + +template <class T> void test_uuidofType(void *arg[sizeof(__uuidof(T))] = 0) {} + +template <class T> void test_uuidofExpr(void *arg[sizeof(__uuidof(T::member))] = 0) {} + +struct HasMember { typedef TestStruct member; }; + +int main(int argc, const char * argv[]) +{ + + UUIDTest<TestStruct> uuidof_test; + test_uuidofType<TestStruct>(); + test_uuidofExpr<HasMember>(); + return 0; +} + +// CHECK: define i32 @main +// CHECK: call void @_ZN8UUIDTestI10TestStructXu8__uuidoftS0_EEC1Ev +// CHECK: call void @_Z15test_uuidofTypeI10TestStructEvPPv(i8** null) +// CHECK: call void @_Z15test_uuidofExprI9HasMemberEvPPv(i8** null) + +// CHECK: define linkonce_odr void @_ZN8UUIDTestI10TestStructXu8__uuidoftS0_EEC1Ev +// CHECK: define linkonce_odr void @_Z15test_uuidofTypeI10TestStructEvPPv +// CHECK: define linkonce_odr void @_Z15test_uuidofExprI9HasMemberEvPPv +// CHECK: define linkonce_odr void @_ZN8UUIDTestI10TestStructXu8__uuidoftS0_EEC2Ev diff --git a/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp b/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp new file mode 100644 index 000000000000..bacddb2936f4 --- /dev/null +++ b/test/CodeGenCXX/mingw-w64-seh-exceptions.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 %s -fexceptions -emit-llvm -triple x86_64-w64-windows-gnu -o - | FileCheck %s --check-prefix=X64 +// RUN: %clang_cc1 %s -fexceptions -emit-llvm -triple i686-w64-windows-gnu -o - | FileCheck %s --check-prefix=X86 + +extern "C" void foo(); +extern "C" void bar(); + +struct Cleanup { + ~Cleanup() { + bar(); + } +}; + +extern "C" void test() { + Cleanup x; + foo(); +} + +// X64: define void @test() +// X64: invoke void @foo() +// X64: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_seh0 to i8*) + +// X86: define void @test() +// X86: invoke void @foo() +// X86: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) diff --git a/test/CodeGenCXX/ms-inline-asm-return.cpp b/test/CodeGenCXX/ms-inline-asm-return.cpp new file mode 100644 index 000000000000..26fc426e5fc2 --- /dev/null +++ b/test/CodeGenCXX/ms-inline-asm-return.cpp @@ -0,0 +1,100 @@ +// REQUIRES: x86-registered-target +// RUN: %clang_cc1 %s -triple i686-pc-windows-msvc -emit-llvm -o - -fasm-blocks | FileCheck %s + +// Check that we take EAX or EAX:EDX and return it from these functions for MSVC +// compatibility. + +extern "C" { + +long long f_i64() { + __asm { + mov eax, 1 + mov edx, 1 + } +} +// CHECK-LABEL: define i64 @f_i64() +// CHECK: %[[r:[^ ]*]] = call i64 asm sideeffect inteldialect "mov eax, $$1\0A\09mov edx, $$1", "=A,~{eax},{{.*}}" +// CHECK: ret i64 %[[r]] + +int f_i32() { + __asm { + mov eax, 1 + mov edx, 1 + } +} +// CHECK-LABEL: define i32 @f_i32() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "mov eax, $$1\0A\09mov edx, $$1", "={eax},~{eax},{{.*}}" +// CHECK: ret i32 %[[r]] + +short f_i16() { + __asm { + mov eax, 1 + mov edx, 1 + } +} +// CHECK-LABEL: define signext i16 @f_i16() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "mov eax, $$1\0A\09mov edx, $$1", "={eax},~{eax},{{.*}}" +// CHECK: %[[r_i16:[^ ]*]] = trunc i32 %[[r]] to i16 +// CHECK: ret i16 %[[r_i16]] + +char f_i8() { + __asm { + mov eax, 1 + mov edx, 1 + } +} +// CHECK-LABEL: define signext i8 @f_i8() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "mov eax, $$1\0A\09mov edx, $$1", "={eax},~{eax},{{.*}}" +// CHECK: %[[r_i8:[^ ]*]] = trunc i32 %[[r]] to i8 +// CHECK: ret i8 %[[r_i8]] + +bool f_i1() { + __asm { + mov eax, 1 + mov edx, 1 + } +} +// CHECK-LABEL: define zeroext i1 @f_i1() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "mov eax, $$1\0A\09mov edx, $$1", "={eax},~{eax},{{.*}}" +// CHECK: %[[r_i8:[^ ]*]] = trunc i32 %[[r]] to i8 +// CHECK: store i8 %[[r_i8]], i8* %{{.*}} +// CHECK: %[[r_i1:[^ ]*]] = load i1* %{{.*}} +// CHECK: ret i1 %[[r_i1]] + +struct FourChars { + char a, b, c, d; +}; +FourChars f_s4() { + __asm { + mov eax, 0x01010101 + } +} +// CHECK-LABEL: define i32 @f_s4() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "mov eax, $$0x01010101", "={eax},~{eax},{{.*}}" +// CHECK: store i32 %[[r]], i32* %{{.*}} +// CHECK: %[[r_i32:[^ ]*]] = load i32* %{{.*}} +// CHECK: ret i32 %[[r_i32]] + +struct EightChars { + char a, b, c, d, e, f, g, h; +}; +EightChars f_s8() { + __asm { + mov eax, 0x01010101 + mov edx, 0x01010101 + } +} +// CHECK-LABEL: define i64 @f_s8() +// CHECK: %[[r:[^ ]*]] = call i64 asm sideeffect inteldialect "mov eax, $$0x01010101\0A\09mov edx, $$0x01010101", "=A,~{eax},{{.*}}" +// CHECK: store i64 %[[r]], i64* %{{.*}} +// CHECK: %[[r_i64:[^ ]*]] = load i64* %{{.*}} +// CHECK: ret i64 %[[r_i64]] + +} // extern "C" + +int main() { + __asm xor eax, eax +} +// CHECK-LABEL: define i32 @main() +// CHECK: %[[r:[^ ]*]] = call i32 asm sideeffect inteldialect "xor eax, eax", "={eax},{{.*}}" +// CHECK: ret i32 %[[r]] diff --git a/test/CodeGenCXX/ms-integer-static-data-members-exported.cpp b/test/CodeGenCXX/ms-integer-static-data-members-exported.cpp index 3f868f36ff66..78bb3a2b1afa 100644 --- a/test/CodeGenCXX/ms-integer-static-data-members-exported.cpp +++ b/test/CodeGenCXX/ms-integer-static-data-members-exported.cpp @@ -17,6 +17,6 @@ struct __declspec(dllexport) S { }; }; -// CHECK: @"\01?x@S@@2FB" = weak_odr dllexport constant i16 42, align 2 -// CHECK: @"\01?y@S@@2W4Enum@@B" = weak_odr dllexport constant i32 2, align 4 +// CHECK: @"\01?x@S@@2FB" = weak_odr dllexport constant i16 42, comdat, align 2 +// CHECK: @"\01?y@S@@2W4Enum@@B" = weak_odr dllexport constant i32 2, comdat, align 4 // CHECK-NOT: NonExported diff --git a/test/CodeGenCXX/ms-integer-static-data-members.cpp b/test/CodeGenCXX/ms-integer-static-data-members.cpp index b02b679d71a1..4965f7319187 100644 --- a/test/CodeGenCXX/ms-integer-static-data-members.cpp +++ b/test/CodeGenCXX/ms-integer-static-data-members.cpp @@ -26,7 +26,7 @@ const int S::x = 5; // Inline initialization. -// CHECK-INLINE: @"\01?x@S@@2HB" = linkonce_odr constant i32 5, align 4 +// CHECK-INLINE: @"\01?x@S@@2HB" = linkonce_odr constant i32 5, comdat, align 4 // Out-of-line initialization. // CHECK-OUTOFLINE: @"\01?x@S@@2HB" = constant i32 5, align 4 diff --git a/test/CodeGenCXX/ms-thread_local.cpp b/test/CodeGenCXX/ms-thread_local.cpp new file mode 100644 index 000000000000..c29473fd6fca --- /dev/null +++ b/test/CodeGenCXX/ms-thread_local.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 %s -std=c++1y -triple=i686-pc-win32 -emit-llvm -o - | FileCheck %s + +struct A { + A(); + ~A(); +}; + +// CHECK-DAG: $"\01??$a@X@@3UA@@A" = comdat any +// CHECK-DAG: @"\01??$a@X@@3UA@@A" = linkonce_odr thread_local global %struct.A zeroinitializer, comdat, align 1 +// CHECK-DAG: @"\01??__E?$a@X@@YAXXZ$initializer$" = internal constant void ()* @"\01??__E?$a@X@@YAXXZ", section ".CRT$XDU", comdat($"\01??$a@X@@3UA@@A") +template <typename T> +thread_local A a = A(); + +// CHECK-DAG: @"\01?b@@3UA@@A" = thread_local global %struct.A zeroinitializer, align 1 +// CHECK-DAG: @"__tls_init$initializer$" = internal constant void ()* @__tls_init, section ".CRT$XDU" +thread_local A b; + +// CHECK-LABEL: define internal void @__tls_init() +// CHECK: call void @"\01??__Eb@@YAXXZ" + +thread_local A &c = b; +thread_local A &d = c; + +A f() { + (void)a<void>; + (void)b; + return c; +} diff --git a/test/CodeGenCXX/nrvo-noreturn.cc b/test/CodeGenCXX/nrvo-noreturn.cpp index a8259cab5f30..a8259cab5f30 100644 --- a/test/CodeGenCXX/nrvo-noreturn.cc +++ b/test/CodeGenCXX/nrvo-noreturn.cpp diff --git a/test/CodeGenCXX/optnone-def-decl.cpp b/test/CodeGenCXX/optnone-def-decl.cpp new file mode 100644 index 000000000000..ab6eb3f32e11 --- /dev/null +++ b/test/CodeGenCXX/optnone-def-decl.cpp @@ -0,0 +1,94 @@ +// RUN: %clang_cc1 %s -triple %itanium_abi_triple -fms-extensions -emit-llvm -o - | FileCheck %s + +// Test optnone on both function declarations and function definitions. +// Verify also that we don't generate invalid IR functions with +// both alwaysinline and noinline. (optnone implies noinline and wins +// over alwaysinline, in all cases.) + +// Test optnone on extern declaration only. +extern int decl_only(int a) __attribute__((optnone)); + +// This function should be marked 'optnone'. +int decl_only(int a) { + return a + a + a + a; +} + +// CHECK: define {{.*}} @_Z9decl_onlyi({{.*}}) [[OPTNONE:#[0-9]+]] + +// Test optnone on definition but not extern declaration. +extern int def_only(int a); + +__attribute__((optnone)) +int def_only(int a) { + return a + a + a + a; +} + +// Function def_only is a optnone function and therefore it should not be +// inlined inside 'user_of_def_only'. +int user_of_def_only() { + return def_only(5); +} + +// CHECK: define {{.*}} @_Z8def_onlyi({{.*}}) [[OPTNONE]] +// CHECK: define {{.*}} @_Z16user_of_def_onlyv() [[NORMAL:#[0-9]+]] + +// Test optnone on both definition and declaration. +extern int def_and_decl(int a) __attribute__((optnone)); + +__attribute__((optnone)) +int def_and_decl(int a) { + return a + a + a + a; +} + +// CHECK: define {{.*}} @_Z12def_and_decli({{.*}}) [[OPTNONE]] + +// Check that optnone wins over always_inline. + +// Test optnone on definition and always_inline on declaration. +extern int always_inline_function(int a) __attribute__((always_inline)); + +__attribute__((optnone)) +extern int always_inline_function(int a) { + return a + a + a + a; +} +// CHECK: define {{.*}} @_Z22always_inline_functioni({{.*}}) [[OPTNONE]] + +int user_of_always_inline_function() { + return always_inline_function(4); +} + +// CHECK: define {{.*}} @_Z30user_of_always_inline_functionv() [[NORMAL]] + +// Test optnone on declaration and always_inline on definition. +extern int optnone_function(int a) __attribute__((optnone)); + +__attribute__((always_inline)) +int optnone_function(int a) { + return a + a + a + a; +} +// CHECK: define {{.*}} @_Z16optnone_functioni({{.*}}) [[OPTNONE]] + +int user_of_optnone_function() { + return optnone_function(4); +} + +// CHECK: define {{.*}} @_Z24user_of_optnone_functionv() [[NORMAL]] + +// Test the combination of optnone with forceinline (optnone wins). +extern __forceinline int forceinline_optnone_function(int a, int b); + +__attribute__((optnone)) +extern int forceinline_optnone_function(int a, int b) { + return a + b; +} + +int user_of_forceinline_optnone_function() { + return forceinline_optnone_function(4,5); +} + +// CHECK: @_Z36user_of_forceinline_optnone_functionv() [[NORMAL]] +// CHECK: @_Z28forceinline_optnone_functionii({{.*}}) [[OPTNONE]] + +// CHECK: attributes [[OPTNONE]] = { noinline nounwind optnone {{.*}} } +// CHECK: attributes [[NORMAL]] = { nounwind {{.*}} } + diff --git a/test/CodeGenCXX/pod-member-memcpys.cpp b/test/CodeGenCXX/pod-member-memcpys.cpp index 31d774c5345e..a3ee990bf319 100644 --- a/test/CodeGenCXX/pod-member-memcpys.cpp +++ b/test/CodeGenCXX/pod-member-memcpys.cpp @@ -67,6 +67,13 @@ struct BitfieldMember2 { NonPOD np; }; +struct BitfieldMember3 { + virtual void f(); + int : 8; + int x : 1; + int y; +}; + struct InnerClassMember { struct { int a, b, c, d; @@ -174,6 +181,7 @@ CALL_AO(PackedMembers) CALL_CC(PackedMembers) CALL_CC(BitfieldMember2) +CALL_CC(BitfieldMember3) CALL_CC(ReferenceMember) CALL_CC(InnerClassMember) CALL_CC(BitfieldMember) @@ -243,6 +251,11 @@ CALL_CC(Basic) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 8{{.*}}) // CHECK: ret void +// BitfieldMember3 copy-constructor: +// CHECK-LABEL: define linkonce_odr void @_ZN15BitfieldMember3C2ERKS_(%struct.BitfieldMember3* %this, %struct.BitfieldMember3* dereferenceable({{[0-9]+}})) +// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 8, i32 8, i1 false) +// CHECK: ret void + // BitfieldMember2 copy-constructor: // CHECK-2-LABEL: define linkonce_odr void @_ZN15BitfieldMember2C2ERKS_(%struct.BitfieldMember2* %this, %struct.BitfieldMember2* dereferenceable({{[0-9]+}})) // CHECK-2: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4, i1 false) diff --git a/test/CodeGenCXX/pointers-to-data-members.cpp b/test/CodeGenCXX/pointers-to-data-members.cpp index 745cf18fce21..0b99fea8fc57 100644 --- a/test/CodeGenCXX/pointers-to-data-members.cpp +++ b/test/CodeGenCXX/pointers-to-data-members.cpp @@ -55,7 +55,7 @@ namespace ZeroInit { }; struct C : A, B { int j; }; - // CHECK-GLOBAL: @_ZN8ZeroInit1cE = global {{%.*}} { %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::B" { [10 x %"struct.ZeroInit::A"] [%"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }], i8 0, i64 -1 }, i32 0 }, align 8 + // CHECK-GLOBAL: @_ZN8ZeroInit1cE = global {{%.*}} <{ %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::B" { [10 x %"struct.ZeroInit::A"] [%"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }, %"struct.ZeroInit::A" { i64 -1, i32 0 }], i8 0, i64 -1 }, i32 0, [4 x i8] zeroinitializer }>, align 8 C c; } @@ -255,4 +255,26 @@ namespace PR13097 { // CHECK: call void @_ZN7PR130971XC1ERKS0_ } +namespace PR21089 { +struct A { + bool : 1; + int A::*x; + bool y; + A(); +}; +struct B : A { +}; +B b; +// CHECK-GLOBAL: @_ZN7PR210891bE = global %"struct.PR21089::B" { %"struct.PR21089::A.base" <{ i8 0, [7 x i8] zeroinitializer, i64 -1, i8 0 }>, [7 x i8] zeroinitializer }, align 8 +} + +namespace PR21282 { +union U { + int U::*x; + long y[2]; +}; +U u; +// CHECK-GLOBAL: @_ZN7PR212821uE = global %"union.PR21282::U" { i64 -1, [8 x i8] zeroinitializer }, align 8 +} + // CHECK-O3: attributes [[NUW]] = { nounwind readnone{{.*}} } diff --git a/test/CodeGenCXX/pr12251.cpp b/test/CodeGenCXX/pr12251.cpp index bb1c82dc8153..5b1ef9a31d24 100644 --- a/test/CodeGenCXX/pr12251.cpp +++ b/test/CodeGenCXX/pr12251.cpp @@ -18,14 +18,14 @@ e1 g1(e1 *x) { return *x; } // CHECK-LABEL: define i32 @_Z2g1P2e1 -// CHECK: load i32* %x, align 4, !range [[RANGE_i32_0_1:![^ ]*]] +// CHECK: ret i32 0 enum e2 { e2_a = 0 }; e2 g2(e2 *x) { return *x; } // CHECK-LABEL: define i32 @_Z2g2P2e2 -// CHECK: load i32* %x, align 4, !range [[RANGE_i32_0_1]] +// CHECK: ret i32 0 enum e3 { e3_a = 16 }; e3 g3(e3 *x) { @@ -136,11 +136,10 @@ e16 g16(e16 *x) { // CHECK: ret -// CHECK: [[RANGE_i8_0_2]] = metadata !{i8 0, i8 2} -// CHECK: [[RANGE_i32_0_1]] = metadata !{i32 0, i32 1} -// CHECK: [[RANGE_i32_0_32]] = metadata !{i32 0, i32 32} -// CHECK: [[RANGE_i32_m16_16]] = metadata !{i32 -16, i32 16} -// CHECK: [[RANGE_i32_m32_32]] = metadata !{i32 -32, i32 32} -// CHECK: [[RANGE_i32_m1_1]] = metadata !{i32 -1, i32 1} -// CHECK: [[RANGE_i32_m64_64]] = metadata !{i32 -64, i32 64} -// CHECK: [[RANGE_i64_0_2pow33]] = metadata !{i64 0, i64 8589934592} +// CHECK: [[RANGE_i8_0_2]] = !{i8 0, i8 2} +// CHECK: [[RANGE_i32_0_32]] = !{i32 0, i32 32} +// CHECK: [[RANGE_i32_m16_16]] = !{i32 -16, i32 16} +// CHECK: [[RANGE_i32_m32_32]] = !{i32 -32, i32 32} +// CHECK: [[RANGE_i32_m1_1]] = !{i32 -1, i32 1} +// CHECK: [[RANGE_i32_m64_64]] = !{i32 -64, i32 64} +// CHECK: [[RANGE_i64_0_2pow33]] = !{i64 0, i64 8589934592} diff --git a/test/CodeGenCXX/pr18635.cpp b/test/CodeGenCXX/pr18635.cpp new file mode 100644 index 000000000000..94b5e4599956 --- /dev/null +++ b/test/CodeGenCXX/pr18635.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -emit-llvm -std=c++11 -triple x86_64-pc-linux-gnu -o- %s | FileCheck %s + +// Global @x: +// CHECK: [[X_GLOBAL:@[^ ]+]]{{.*}}thread_local global + +// returned somewhere in TLS wrapper: +// CHECK: ret{{.*}}[[X_GLOBAL]] + +template <typename T> class unique_ptr { + template <typename F, typename S> struct pair { + F first; + S second; + }; + pair<T *, int> data; +public: + constexpr unique_ptr() noexcept : data() {} + explicit unique_ptr(T *p) noexcept : data() {} +}; + +thread_local unique_ptr<int> x; +int main() { x = unique_ptr<int>(new int(5)); } + diff --git a/test/CodeGenCXX/pr18962.cpp b/test/CodeGenCXX/pr18962.cpp index ab537b4928e3..9e6ef169cd10 100644 --- a/test/CodeGenCXX/pr18962.cpp +++ b/test/CodeGenCXX/pr18962.cpp @@ -26,7 +26,7 @@ fn2(C *) { // We end up using an opaque type for 'append' to avoid circular references. // CHECK: %class.A = type { {}* } -// CHECK: %class.C = type { %class.D*, %class.B } +// CHECK: %class.C = type <{ %class.D*, %class.B, [3 x i8] }> // CHECK: %class.D = type { %class.C.base, [3 x i8] } // CHECK: %class.C.base = type <{ %class.D*, %class.B }> // CHECK: %class.B = type { i8 } diff --git a/test/CodeGenCXX/pr20719.cpp b/test/CodeGenCXX/pr20719.cpp new file mode 100644 index 000000000000..208d11135847 --- /dev/null +++ b/test/CodeGenCXX/pr20719.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++11 -o - %s | FileCheck %s + +// Make sure that we emit H's constructor twice: once with the first lambda +// inside of 'lep' and again with the second lambda inside of 'lep'. +// CHECK-DAG: @"\01??0?$H@V<lambda_1>@??$lep@X@@YAXXZ@@@QAE@XZ" +// CHECK-DAG: @"\01??0?$H@V<lambda_2>@??$lep@X@@YAXXZ@@@QAE@XZ" + +template <typename> +struct H { + H() {} +}; + +template <typename Fx> +int K_void(const Fx &) { + H<Fx> callee; + return 0; +} +template <typename Fx> +int K_int(const Fx &) { + H<Fx> callee; + return 0; +} + +struct pair { + pair(int, int); +}; + +struct E1; + +template <typename> +void lep() { + pair x(K_void([] {}), K_int([] {})); +} + +auto z = lep<void>; diff --git a/test/CodeGenCXX/pr20897.cpp b/test/CodeGenCXX/pr20897.cpp new file mode 100644 index 000000000000..49d669bd7eab --- /dev/null +++ b/test/CodeGenCXX/pr20897.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -triple i686-windows-msvc -emit-llvm -std=c++1y -O0 -o - %s | FileCheck %s +struct Base {}; + +// __declspec(dllexport) causes us to export the implicit constructor. +struct __declspec(dllexport) Derived : virtual Base { +// CHECK-LABEL: define weak_odr dllexport x86_thiscallcc %struct.Derived* @"\01??0Derived@@QAE@ABU0@@Z" +// CHECK: %[[this:.*]] = load %struct.Derived** {{.*}} +// CHECK-NEXT: store %struct.Derived* %[[this]], %struct.Derived** %[[retval:.*]] +// CHECK: %[[dest_a_gep:.*]] = getelementptr inbounds %struct.Derived* %[[this]], i32 0, i32 1 +// CHECK-NEXT: %[[src_load:.*]] = load %struct.Derived** {{.*}} +// CHECK-NEXT: %[[src_a_gep:.*]] = getelementptr inbounds %struct.Derived* %[[src_load:.*]], i32 0, i32 1 +// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[dest_a_gep]], i8* %[[src_a_gep]], i64 1, i32 4, i1 false) +// CHECK-NEXT: %[[dest_this:.*]] = load %struct.Derived** %[[retval]] +// CHECK-NEXT: ret %struct.Derived* %[[dest_this]] + bool a : 1; + bool b : 1; +}; + +// __declspec(dllexport) causes us to export the implicit copy constructor. +struct __declspec(dllexport) Derived2 : virtual Base { +// CHECK-LABEL: define weak_odr dllexport x86_thiscallcc %struct.Derived2* @"\01??0Derived2@@QAE@ABU0@@Z" +// CHECK: %[[this:.*]] = load %struct.Derived2** {{.*}} +// CHECK-NEXT: store %struct.Derived2* %[[this]], %struct.Derived2** %[[retval:.*]] +// CHECK: %[[dest_a_gep:.*]] = getelementptr inbounds %struct.Derived2* %[[this]], i32 0, i32 1 +// CHECK-NEXT: %[[src_load:.*]] = load %struct.Derived2** {{.*}} +// CHECK-NEXT: %[[src_a_gep:.*]] = getelementptr inbounds %struct.Derived2* %[[src_load:.*]], i32 0, i32 1 +// CHECK-NEXT: %[[dest_a_bitcast:.*]] = bitcast [1 x i32]* %[[dest_a_gep]] to i8* +// CHECK-NEXT: %[[src_a_bitcast:.*]] = bitcast [1 x i32]* %[[src_a_gep]] to i8* +// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[dest_a_bitcast]], i8* %[[src_a_bitcast]], i32 4, i32 4, i1 false) +// CHECK-NEXT: %[[dest_this:.*]] = load %struct.Derived2** %[[retval]] +// CHECK-NEXT: ret %struct.Derived2* %[[dest_this]] + int Array[1]; +}; diff --git a/test/CodeGenCXX/pr21989.cpp b/test/CodeGenCXX/pr21989.cpp new file mode 100644 index 000000000000..0b9bccbe925b --- /dev/null +++ b/test/CodeGenCXX/pr21989.cpp @@ -0,0 +1,9 @@ +// REQUIRES: asserts +// RUN: not %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - %s 2>&1 | FileCheck %s + +struct { + void __attribute__((used)) f() {} +}; +// CHECK: 2 errors generated. + +// Emit the errors, but don't assert. diff --git a/test/CodeGenCXX/pragma-init_seg.cpp b/test/CodeGenCXX/pragma-init_seg.cpp index 3f9ff217e6b6..cc4d01875309 100644 --- a/test/CodeGenCXX/pragma-init_seg.cpp +++ b/test/CodeGenCXX/pragma-init_seg.cpp @@ -35,24 +35,24 @@ int x = f(); namespace selectany_init { int __declspec(selectany) x = f(); -// CHECK: @"\01?x@selectany_init@@3HA" = weak_odr global i32 0, comdat $"\01?x@selectany_init@@3HA", align 4 -// CHECK: @__cxx_init_fn_ptr3 = private constant void ()* @"\01??__Ex@selectany_init@@YAXXZ", section ".asdf", comdat $"\01?x@selectany_init@@3HA" +// CHECK: @"\01?x@selectany_init@@3HA" = weak_odr global i32 0, comdat, align 4 +// CHECK: @__cxx_init_fn_ptr3 = private constant void ()* @"\01??__Ex@selectany_init@@YAXXZ", section ".asdf", comdat($"\01?x@selectany_init@@3HA") } namespace explicit_template_instantiation { template <typename T> struct A { static const int x; }; template <typename T> const int A<T>::x = f(); template struct A<int>; -// CHECK: @"\01?x@?$A@H@explicit_template_instantiation@@2HB" = weak_odr global i32 0, comdat $"\01?x@?$A@H@explicit_template_instantiation@@2HB", align 4 -// CHECK: @__cxx_init_fn_ptr4 = private constant void ()* @"\01??__Ex@?$A@H@explicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat $"\01?x@?$A@H@explicit_template_instantiation@@2HB" +// CHECK: @"\01?x@?$A@H@explicit_template_instantiation@@2HB" = weak_odr global i32 0, comdat, align 4 +// CHECK: @__cxx_init_fn_ptr4 = private constant void ()* @"\01??__Ex@?$A@H@explicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat($"\01?x@?$A@H@explicit_template_instantiation@@2HB") } namespace implicit_template_instantiation { template <typename T> struct A { static const int x; }; template <typename T> const int A<T>::x = f(); int g() { return A<int>::x; } -// CHECK: @"\01?x@?$A@H@implicit_template_instantiation@@2HB" = linkonce_odr global i32 0, comdat $"\01?x@?$A@H@implicit_template_instantiation@@2HB", align 4 -// CHECK: @__cxx_init_fn_ptr5 = private constant void ()* @"\01??__Ex@?$A@H@implicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat $"\01?x@?$A@H@implicit_template_instantiation@@2HB" +// CHECK: @"\01?x@?$A@H@implicit_template_instantiation@@2HB" = linkonce_odr global i32 0, comdat, align 4 +// CHECK: @__cxx_init_fn_ptr5 = private constant void ()* @"\01??__Ex@?$A@H@implicit_template_instantiation@@2HB@YAXXZ", section ".asdf", comdat($"\01?x@?$A@H@implicit_template_instantiation@@2HB") } // ... and here's where we emitted user level ctors. diff --git a/test/CodeGenCXX/predefined-expr-cxx14.cpp b/test/CodeGenCXX/predefined-expr-cxx14.cpp new file mode 100644 index 000000000000..1f035757dea9 --- /dev/null +++ b/test/CodeGenCXX/predefined-expr-cxx14.cpp @@ -0,0 +1,105 @@ +// RUN: %clang_cc1 -std=c++14 %s -triple %itanium_abi_triple -fblocks -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -x c++ -std=c++14 -triple %itanium_abi_triple -fblocks -emit-pch -o %t %s +// RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -std=c++14 -fblocks -include-pch %t %s -emit-llvm -o - | FileCheck %s + +#ifndef HEADER +#define HEADER + +// CHECK-DAG: @__func__._ZN13ClassTemplateIiE21classTemplateFunctionERi = private unnamed_addr constant [22 x i8] c"classTemplateFunction\00" +// CHECK-DAG: @__PRETTY_FUNCTION__._ZN13ClassTemplateIiE21classTemplateFunctionERi = private unnamed_addr constant [69 x i8] c"const auto &ClassTemplate<int>::classTemplateFunction(T &) [T = int]\00" + +// CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace16functionTemplateIiEERDaRT_ = private unnamed_addr constant [17 x i8] c"functionTemplate\00" +// CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace16functionTemplateIiEERDaRT_ = private unnamed_addr constant [64 x i8] c"auto &ClassInTopLevelNamespace::functionTemplate(T &) [T = int]\00" + +// CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace16variadicFunctionEPiz = private unnamed_addr constant [17 x i8] c"variadicFunction\00" +// CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace16variadicFunctionEPiz = private unnamed_addr constant [70 x i8] c"decltype(auto) ClassInTopLevelNamespace::variadicFunction(int *, ...)\00" + +// CHECK-DAG: @__func__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [26 x i8] c"topLevelNamespaceFunction\00" +// CHECK-DAG: @__PRETTY_FUNCTION__._ZN24ClassInTopLevelNamespace25topLevelNamespaceFunctionEv = private unnamed_addr constant [60 x i8] c"auto *ClassInTopLevelNamespace::topLevelNamespaceFunction()\00" + +// CHECK-DAG: @__func__.___ZN16ClassBlockConstrD2Ev_block_invoke = private unnamed_addr constant [41 x i8] c"___ZN16ClassBlockConstrD2Ev_block_invoke\00" +// CHECK-DAG: @__func__.___ZN16ClassBlockConstrC2Ev_block_invoke = private unnamed_addr constant [41 x i8] c"___ZN16ClassBlockConstrC2Ev_block_invoke\00" + +int printf(const char * _Format, ...); + +class ClassInTopLevelNamespace { +public: + auto *topLevelNamespaceFunction() { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + return static_cast<int *>(nullptr); + } + + decltype(auto) variadicFunction(int *a, ...) { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + return a; + } + + template<typename T> + auto &functionTemplate(T &t) { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + return t; + } +}; + +template<typename T> +class ClassTemplate { +public: + const auto &classTemplateFunction(T &t) { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + return t; + } +}; + +struct ClassBlockConstr { + const char *s; + ClassBlockConstr() { + const char * (^b)() = ^() { + return __func__; + }; + s = b(); + } + ~ClassBlockConstr() { + const char * (^b)() = ^() { + return __func__; + }; + s = b(); + } +}; + +template <class T> +class FuncTemplate { + const char *Func; + +public: + FuncTemplate() : Func(__func__) {} + const char *getFunc() const { return Func; } +}; + +int +main() { + int a; + ClassInTopLevelNamespace topLevelNamespace; + ClassBlockConstr classBlockConstr; + topLevelNamespace.topLevelNamespaceFunction(); + topLevelNamespace.variadicFunction(&a); + topLevelNamespace.functionTemplate(a); + + ClassTemplate<int> t; + t.classTemplateFunction(a); + return 0; +} +#else +void Foo() { + FuncTemplate<int> FTi; + (void)FTi.getFunc(); +} +#endif + diff --git a/test/CodeGenCXX/predefined-expr.cpp b/test/CodeGenCXX/predefined-expr.cpp index f901467c4f4b..6bdc2cec4be8 100644 --- a/test/CodeGenCXX/predefined-expr.cpp +++ b/test/CodeGenCXX/predefined-expr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++11 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -fblocks %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s // CHECK: private unnamed_addr constant [15 x i8] c"externFunction\00" // CHECK: private unnamed_addr constant [26 x i8] c"void NS::externFunction()\00" @@ -537,3 +537,33 @@ int main() { return 0; } + +// rdar://19065361 +class XXX { + XXX(); + ~XXX(); +}; + +void XXLog(const char *functionName) { } + +typedef void (^notify_handler_t)(int token); + +typedef void (^dispatch_block_t)(void); + +void notify_register_dispatch(notify_handler_t handler); + +void _dispatch_once(dispatch_block_t block); + +XXX::XXX() +{ + _dispatch_once(^{ notify_register_dispatch( ^(int token) { XXLog(__FUNCTION__); }); + }); +} +// CHECK: define internal void @___ZN3XXXC2Ev_block_invoke_ + +XXX::~XXX() +{ + _dispatch_once(^{ notify_register_dispatch( ^(int token) { XXLog(__FUNCTION__); }); + }); +} +// CHECK: define internal void @___ZN3XXXD2Ev_block_invoke_ diff --git a/test/CodeGenCXX/runtimecc.cpp b/test/CodeGenCXX/runtimecc.cpp index 20448838f919..ad6dc85c360d 100644 --- a/test/CodeGenCXX/runtimecc.cpp +++ b/test/CodeGenCXX/runtimecc.cpp @@ -20,33 +20,33 @@ namespace test0 { }; A global; -// CHECK-LABEL: define internal arm_aapcscc void @__cxx_global_var_init() -// CHECK: call arm_aapcscc [[A]]* @_ZN5test01AC1Ev([[A]]* @_ZN5test06globalE) -// CHECK-NEXT: call arm_aapcscc i32 @__cxa_atexit(void (i8*)* bitcast ([[A]]* ([[A]]*)* @_ZN5test01AD1Ev to void (i8*)*), i8* bitcast ([[A]]* @_ZN5test06globalE to i8*), i8* @__dso_handle) [[NOUNWIND:#[0-9]+]] +// CHECK-LABEL: define internal void @__cxx_global_var_init() +// CHECK: call [[A]]* @_ZN5test01AC1Ev([[A]]* @_ZN5test06globalE) +// CHECK-NEXT: call i32 @__cxa_atexit(void (i8*)* bitcast ([[A]]* ([[A]]*)* @_ZN5test01AD1Ev to void (i8*)*), i8* bitcast ([[A]]* @_ZN5test06globalE to i8*), i8* @__dso_handle) [[NOUNWIND:#[0-9]+]] // CHECK-NEXT: ret void } -// CHECK: declare arm_aapcscc i32 @__cxa_atexit(void (i8*)*, i8*, i8*) [[NOUNWIND]] +// CHECK: declare i32 @__cxa_atexit(void (i8*)*, i8*, i8*) [[NOUNWIND]] namespace test1 { void test() { throw 0; } -// CHECK-LABEL: define arm_aapcscc void @_ZN5test14testEv() -// CHECK: [[T0:%.*]] = call arm_aapcscc i8* @__cxa_allocate_exception(i32 4) [[NOUNWIND]] +// CHECK-LABEL: define void @_ZN5test14testEv() +// CHECK: [[T0:%.*]] = call i8* @__cxa_allocate_exception(i32 4) [[NOUNWIND]] // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to i32* // CHECK-NEXT: store i32 0, i32* [[T1]] -// CHECK-NEXT: call arm_aapcscc void @__cxa_throw(i8* [[T0]], i8* bitcast (i8** @_ZTIi to i8*), i8* null) [[NORETURN:#[0-9]+]] +// CHECK-NEXT: call void @__cxa_throw(i8* [[T0]], i8* bitcast (i8** @_ZTIi to i8*), i8* null) [[NORETURN:#[0-9]+]] // CHECK-NEXT: unreachable } -// CHECK: declare arm_aapcscc i8* @__cxa_allocate_exception(i32) +// CHECK: declare i8* @__cxa_allocate_exception(i32) -// CHECK: declare arm_aapcscc void @__cxa_throw(i8*, i8*, i8*) +// CHECK: declare void @__cxa_throw(i8*, i8*, i8*) -// CHECK-LABEL: define internal arm_aapcscc void @_GLOBAL__sub_I_runtimecc.cpp() -// CHECK: call arm_aapcscc void @__cxx_global_var_init() +// CHECK-LABEL: define internal void @_GLOBAL__sub_I_runtimecc.cpp() +// CHECK: call void @__cxx_global_var_init() // CHECK: attributes [[NOUNWIND]] = { nounwind } diff --git a/test/CodeGen/sections.c b/test/CodeGenCXX/sections.cpp index 8d93fed480e1..f84f9d939c0b 100644 --- a/test/CodeGen/sections.c +++ b/test/CodeGenCXX/sections.cpp @@ -1,8 +1,7 @@ -// RUN: %clang_cc1 -emit-llvm -fms-extensions -xc++ -o - < %s | FileCheck %s +// RUN: %clang_cc1 -emit-llvm -triple i686-pc-win32 -fms-extensions -o - %s | FileCheck %s -#ifdef __cplusplus extern "C" { -#endif + #pragma const_seg(".my_const") #pragma bss_seg(".my_bss") int D = 1; @@ -31,9 +30,26 @@ int i; int TEST1; #pragma bss_seg(pop) int TEST2; -#ifdef __cplusplus + +#pragma section("read_flag_section", read) +// Even though they are not declared const, these become constant since they are +// in a read-only section. +__declspec(allocate("read_flag_section")) int unreferenced = 0; +extern __declspec(allocate("read_flag_section")) int referenced = 42; +int *user() { return &referenced; } + +#pragma section("no_section_attributes") +// A pragma section with no section attributes is read/write. +__declspec(allocate("no_section_attributes")) int implicitly_read_write = 42; + +#pragma section("long_section", long) +// Pragma section ignores "long". +__declspec(allocate("long_section")) long long_var = 42; + +#pragma section("short_section", short) +// Pragma section ignores "short". +__declspec(allocate("short_section")) short short_var = 42; } -#endif //CHECK: @D = global i32 1 //CHECK: @a = global i32 1, section ".data" @@ -47,5 +63,10 @@ int TEST2; //CHECK: @i = global i32 0 //CHECK: @TEST1 = global i32 0 //CHECK: @TEST2 = global i32 0, section ".bss1" +//CHECK: @unreferenced = constant i32 0, section "read_flag_section" +//CHECK: @referenced = constant i32 42, section "read_flag_section" +//CHECK: @implicitly_read_write = global i32 42, section "no_section_attributes" +//CHECK: @long_var = global i32 42, section "long_section" +//CHECK: @short_var = global i16 42, section "short_section" //CHECK: define void @g() //CHECK: define void @h() {{.*}} section ".my_code" diff --git a/test/CodeGenCXX/skip-vtable-pointer-initialization.cpp b/test/CodeGenCXX/skip-vtable-pointer-initialization.cpp index 29926b91b795..6b500751d5d4 100644 --- a/test/CodeGenCXX/skip-vtable-pointer-initialization.cpp +++ b/test/CodeGenCXX/skip-vtable-pointer-initialization.cpp @@ -11,7 +11,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test11AD2Ev -// CHECK-NOT: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test11AE, i64 0, i64 2), i8*** +// CHECK-NOT: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test11AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -27,7 +27,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test21AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test21AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test21AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { f(); } @@ -50,7 +50,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test31AD2Ev -// CHECK-NOT: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test31AE, i64 0, i64 2), i8*** +// CHECK-NOT: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test31AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -76,7 +76,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test41AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test41AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test41AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -100,7 +100,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test51AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test51AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test51AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -128,7 +128,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test61AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test61AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test61AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -154,7 +154,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test71AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test71AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test71AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } @@ -180,7 +180,7 @@ struct A { }; // CHECK-LABEL: define void @_ZN5Test81AD2Ev -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test81AE, i64 0, i64 2), i8*** +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTVN5Test81AE, i64 0, i64 2) to i32 (...)**), i32 (...)*** A::~A() { } diff --git a/test/CodeGenCXX/split-stacks.cpp b/test/CodeGenCXX/split-stacks.cpp index 3e120344d6b6..76e1b79b8f1a 100644 --- a/test/CodeGenCXX/split-stacks.cpp +++ b/test/CodeGenCXX/split-stacks.cpp @@ -18,7 +18,7 @@ int nosplit() { // CHECK-SEGSTK: define i32 @_Z3foov() [[SS:#[0-9]+]] { // CHECK-SEGSTK: define i32 @_Z7nosplitv() [[NSS1:#[0-9]+]] { -// CHECK-SEGSTK: define linkonce_odr i32 @_Z8tnosplitIiEiv() [[NSS2:#[0-9]+]] { +// CHECK-SEGSTK: define linkonce_odr i32 @_Z8tnosplitIiEiv() [[NSS2:#[0-9]+]] comdat { // CHECK-SEGSTK-NOT: [[NSS1]] = { {{.*}} "split-stack" {{.*}} } // CHECK-SEGSTK-NOT: [[NSS2]] = { {{.*}} "split-stack" {{.*}} } // CHECK-SEGSTK: [[SS]] = { {{.*}} "split-stack" {{.*}} } @@ -27,7 +27,7 @@ int nosplit() { // CHECK-NOSEGSTK: define i32 @_Z3foov() [[NSS0:#[0-9]+]] { // CHECK-NOSEGSTK: define i32 @_Z7nosplitv() [[NSS1:#[0-9]+]] { -// CHECK-NOSEGSTK: define linkonce_odr i32 @_Z8tnosplitIiEiv() [[NSS2:#[0-9]+]] { +// CHECK-NOSEGSTK: define linkonce_odr i32 @_Z8tnosplitIiEiv() [[NSS2:#[0-9]+]] comdat { // CHECK-NOSEGSTK-NOT: [[NSS1]] = { {{.*}} "split-stack" {{.*}} } // CHECK-NOSEGSTK-NOT: [[NSS2]] = { {{.*}} "split-stack" {{.*}} } // CHECK-NOSEGSTK-NOT: [[NSS3]] = { {{.*}} "split-stack" {{.*}} } diff --git a/test/CodeGenCXX/static-data-member.cpp b/test/CodeGenCXX/static-data-member.cpp index eea979494843..d41ac8fb3542 100644 --- a/test/CodeGenCXX/static-data-member.cpp +++ b/test/CodeGenCXX/static-data-member.cpp @@ -1,9 +1,13 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | \ +// RUN: FileCheck --check-prefix=MACHO %s // CHECK: @_ZN5test11A1aE = constant i32 10, align 4 // CHECK: @_ZN5test212_GLOBAL__N_11AIiE1xE = internal global i32 0, align 4 -// CHECK: @_ZN5test31AIiE1xE = weak_odr global i32 0, align 4 -// CHECK: @_ZGVN5test31AIiE1xE = weak_odr global i64 0 +// CHECK: @_ZN5test31AIiE1xE = weak_odr global i32 0, comdat, align 4 +// CHECK: @_ZGVN5test31AIiE1xE = weak_odr global i64 0, comdat($_ZN5test31AIiE1xE) +// MACHO: @_ZGVN5test31AIiE1xE = weak_odr global i64 0 +// MACHO-NOT: comdat // CHECK: _ZN5test51U2k0E = global i32 0 // CHECK: _ZN5test51U2k1E = global i32 0 @@ -60,7 +64,9 @@ namespace test3 { template <class T> int A<T>::x = foo(); template struct A<int>; - // CHECK-LABEL: define internal void @__cxx_global_var_init1() + // CHECK-LABEL: define internal void @__cxx_global_var_init1() {{.*}} comdat($_ZN5test31AIiE1xE) + // MACHO-LABEL: define internal void @__cxx_global_var_init1() + // MACHO-NOT: comdat // CHECK: [[GUARDBYTE:%.*]] = load i8* bitcast (i64* @_ZGVN5test31AIiE1xE to i8*) // CHECK-NEXT: [[UNINITIALIZED:%.*]] = icmp eq i8 [[GUARDBYTE]], 0 // CHECK-NEXT: br i1 [[UNINITIALIZED]] diff --git a/test/CodeGenCXX/static-init.cpp b/test/CodeGenCXX/static-init.cpp index d23ead47f385..66ff5b3fbabd 100644 --- a/test/CodeGenCXX/static-init.cpp +++ b/test/CodeGenCXX/static-init.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -triple=x86_64-pc-linuxs -emit-llvm -o - | FileCheck %s // CHECK: @_ZZ1hvE1i = internal global i32 0, align 4 // CHECK: @base_req = global [4 x i8] c"foo\00", align 1 @@ -6,8 +6,9 @@ // CHECK: @_ZZN5test31BC1EvE1u = internal global { i8, [3 x i8] } { i8 97, [3 x i8] undef }, align 4 // CHECK: @_ZZN5test1L6getvarEiE3var = internal constant [4 x i32] [i32 1, i32 0, i32 2, i32 4], align 16 -// CHECK: @_ZZ2h2vE1i = linkonce_odr global i32 0 -// CHECK: @_ZGVZ2h2vE1i = linkonce_odr global i64 0 + +// CHECK: @_ZZ2h2vE1i = linkonce_odr global i32 0, comdat, align +// CHECK: @_ZGVZ2h2vE1i = linkonce_odr global i64 0, comdat{{$}} struct A { A(); @@ -34,6 +35,7 @@ void h() { static const int i = a(); } +// CHECK: define linkonce_odr void @_Z2h2v() {{.*}} comdat { inline void h2() { static int i = a(); } diff --git a/test/CodeGenCXX/static-local-in-local-class.cpp b/test/CodeGenCXX/static-local-in-local-class.cpp index ebf560ab9805..729b9376ae48 100644 --- a/test/CodeGenCXX/static-local-in-local-class.cpp +++ b/test/CodeGenCXX/static-local-in-local-class.cpp @@ -1,6 +1,13 @@ -// RUN: %clang_cc1 -emit-llvm -o %t %s -// PR6769 +// RUN: %clang_cc1 -triple x86_64-linux -fblocks -emit-llvm -o - %s -std=c++1y | FileCheck %s +// CHECK: @"_ZZNK3$_2clEvE1x" = internal global i32 42 +// CHECK: @_ZZ18static_local_labelPvE1q = linkonce_odr global i8* blockaddress(@_Z18static_local_labelPv, %{{.*}}) +// CHECK: @_ZZZL20block_deduced_returnvEUb_E1n = internal global i32 42 +// CHECK: @_ZZL14deduced_returnvE1n = internal global i32 42 +// CHECK: @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2" = +// CHECK: internal global i32* @"_ZZNK17pr18020_constexpr3$_1clEvE2l1" + +namespace pr6769 { struct X { static void f(); }; @@ -19,8 +26,9 @@ void X::f() { } (void)i; } +} -// pr7101 +namespace pr7101 { void foo() { static int n = 0; struct Helper { @@ -30,4 +38,123 @@ void foo() { }; Helper::Execute(); } +} + +// These tests all break the assumption that the static var decl has to be +// emitted before use of the var decl. This happens because we defer emission +// of variables with internal linkage and no initialization side effects, such +// as 'x'. Then we hit operator()() in 'f', and emit the callee before we emit +// the arguments, so we emit the innermost function first. + +namespace pr18020_lambda { +// Referring to l1 before emitting it used to crash. +auto x = []() { + static int l1 = 0; + return [] { return l1; }; +}; +int f() { return x()(); } +} + +// CHECK-LABEL: define internal i32 @"_ZZNK14pr18020_lambda3$_0clEvENKUlvE_clEv" +// CHECK: load i32* @"_ZZNK14pr18020_lambda3$_0clEvE2l1" + +namespace pr18020_constexpr { +// Taking the address of l1 in a constant expression used to crash. +auto x = []() { + static int l1 = 0; + return [] { + static int *l2 = &l1; + return *l2; + }; +}; +int f() { return x()(); } +} + +// CHECK-LABEL: define internal i32 @"_ZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEv" +// CHECK: load i32** @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2" + +// Lambda-less reduction that references l1 before emitting it. This didn't +// crash if you put it in a namespace. +struct pr18020_class { + auto operator()() { + static int l1 = 0; + struct U { + int operator()() { return l1; } + }; + return U(); + } +}; +static pr18020_class x; +int pr18020_f() { return x()(); } + +// CHECK-LABEL: define linkonce_odr i32 @_ZZN13pr18020_classclEvEN1UclEv +// CHECK: load i32* @_ZZN13pr18020_classclEvE2l1 + +// In this test case, the function containing the static local will not be +// emitted because it is unneeded. However, the operator call of the inner class +// is called, and the static local is referenced and must be emitted. +static auto deduced_return() { + static int n = 42; + struct S { int *operator()() { return &n; } }; + return S(); +} +extern "C" int call_deduced_return_operator() { + return *decltype(deduced_return())()(); +} + +// CHECK-LABEL: define i32 @call_deduced_return_operator() +// CHECK: call i32* @_ZZL14deduced_returnvEN1SclEv( +// CHECK: load i32* % +// CHECK: ret i32 % + +// CHECK-LABEL: define internal i32* @_ZZL14deduced_returnvEN1SclEv(%struct.S* %this) +// CHECK: ret i32* @_ZZL14deduced_returnvE1n + +static auto block_deduced_return() { + auto (^b)() = ^() { + static int n = 42; + struct S { int *operator()() { return &n; } }; + return S(); + }; + return b(); +} +extern "C" int call_block_deduced_return() { + return *decltype(block_deduced_return())()(); +} + +// CHECK-LABEL: define i32 @call_block_deduced_return() +// CHECK: call i32* @_ZZZL20block_deduced_returnvEUb_EN1SclEv( +// CHECK: load i32* % +// CHECK: ret i32 % + +// CHECK-LABEL: define internal i32* @_ZZZL20block_deduced_returnvEUb_EN1SclEv(%struct.S.6* %this) #0 align 2 { +// CHECK: ret i32* @_ZZZL20block_deduced_returnvEUb_E1n + +inline auto static_local_label(void *p) { + if (p) + goto *p; + static void *q = &&label; + struct S { static void *get() { return q; } }; + return S(); +label: + __builtin_abort(); +} +void *global_label = decltype(static_local_label(0))::get(); + +// CHECK-LABEL: define linkonce_odr i8* @_ZZ18static_local_labelPvEN1S3getEv() +// CHECK: %[[lbl:[^ ]*]] = load i8** @_ZZ18static_local_labelPvE1q +// CHECK: ret i8* %[[lbl]] + +auto global_lambda = []() { + static int x = 42; + struct S { static int *get() { return &x; } }; + return S(); +}; +extern "C" int use_global_lambda() { + return *decltype(global_lambda())::get(); +} +// CHECK-LABEL: define i32 @use_global_lambda() +// CHECK: call i32* @"_ZZNK3$_2clEvEN1S3getEv"() +// CHECK-LABEL: define internal i32* @"_ZZNK3$_2clEvEN1S3getEv"() +// CHECK: ret i32* @"_ZZNK3$_2clEvE1x" diff --git a/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp b/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp index 98c09b84797d..20b409cbf996 100644 --- a/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp +++ b/test/CodeGenCXX/static-member-variable-explicit-specialization.cpp @@ -1,25 +1,42 @@ -// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -// CHECK: ; ModuleID +// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-pc-linux -emit-llvm -o - | FileCheck --check-prefix=ELF --check-prefix=ALL %s +// RUN: %clang_cc1 %s -std=c++1y -triple=x86_64-apple-darwin -emit-llvm -o - | FileCheck --check-prefix=MACHO --check-prefix=ALL %s + +// ALL: ; ModuleID extern "C" int foo(); template<typename T> struct A { static int a; }; template<typename T> int A<T>::a = foo(); -// CHECK-NOT: @_ZN1AIcE1aE +// ALLK-NOT: @_ZN1AIcE1aE template<> int A<char>::a; -// CHECK: @_ZN1AIbE1aE = global i32 10 +// ALL: @_ZN1AIbE1aE = global i32 10 template<> int A<bool>::a = 10; -// CHECK: @llvm.global_ctors = appending global [7 x { i32, void ()*, i8* }] -// CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @[[unordered1:[^,]*]], i8* bitcast (i32* @_ZN1AIsE1aE to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered2:[^,]*]], i8* bitcast (i16* @_Z1xIsE to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered3:[^,]*]], i8* bitcast (i32* @_ZN2ns1aIiE1iE to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered4:[^,]*]], i8* bitcast (i32* @_ZN2ns1b1iIiEE to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered5:[^,]*]], i8* bitcast (i32* @_ZN1AIvE1aE to i8*) }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered6:[^,]*]], i8* @_Z1xIcE }, -// CHECK: { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp, i8* null }] +// ALL: @llvm.global_ctors = appending global [8 x { i32, void ()*, i8* }] + +// ELF: [{ i32, void ()*, i8* } { i32 65535, void ()* @[[unordered1:[^,]*]], i8* bitcast (i32* @_ZN1AIsE1aE to i8*) }, +// MACHO: [{ i32, void ()*, i8* } { i32 65535, void ()* @[[unordered1:[^,]*]], i8* null }, + +// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered2:[^,]*]], i8* bitcast (i16* @_Z1xIsE to i8*) }, +// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered2:[^,]*]], i8* null }, + +// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered3:[^,]*]], i8* bitcast (i32* @_ZN2ns1aIiE1iE to i8*) }, +// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered3:[^,]*]], i8* null }, + +// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered4:[^,]*]], i8* bitcast (i32* @_ZN2ns1b1iIiEE to i8*) }, +// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered4:[^,]*]], i8* null }, + +// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered5:[^,]*]], i8* bitcast (i32* @_ZN1AIvE1aE to i8*) }, +// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered5:[^,]*]], i8* null }, + +// ELF: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered6:[^,]*]], i8* @_Z1xIcE }, +// MACHO: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered6:[^,]*]], i8* null }, + +// ALL: { i32, void ()*, i8* } { i32 65535, void ()* @[[unordered7:[^,]*]], i8* null }, + +// ALL: { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp, i8* null }] template int A<short>::a; // Unordered int b = foo(); @@ -52,45 +69,57 @@ struct b { template<typename T> T b::i = foo(); template int b::i<int>; } -// CHECK: define internal void @[[unordered1]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_ZN1AIsE1aE -// CHECK: ret - -// CHECK: define internal void @[[unordered2]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_Z1xIsE -// CHECK: ret - -// CHECK: define internal void @[[unordered3]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_ZN2ns1aIiE1iE -// CHECK: ret - -// CHECK: define internal void @[[unordered4]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_ZN2ns1b1iIiEE -// CHECK: ret - -// CHECK: define internal void @[[unordered5]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_ZN1AIvE1aE -// CHECK: ret - -// CHECK: define internal void @[[unordered6]] -// CHECK: call i32 @foo() -// CHECK: store {{.*}} @_Z1xIcE -// CHECK: ret - -// CHECK: define internal void @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp() + +namespace { +template<typename T> struct Internal { static int a; }; +template<typename T> int Internal<T>::a = foo(); +} +int *use_internal_a = &Internal<int>::a; + +// ALL: define internal void @[[unordered1]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_ZN1AIsE1aE +// ALL: ret + +// ALL: define internal void @[[unordered2]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_Z1xIsE +// ALL: ret + +// ALL: define internal void @[[unordered3]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_ZN2ns1aIiE1iE +// ALL: ret + +// ALL: define internal void @[[unordered4]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_ZN2ns1b1iIiEE +// ALL: ret + +// ALL: define internal void @[[unordered5]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_ZN1AIvE1aE +// ALL: ret + +// ALL: define internal void @[[unordered6]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_Z1xIcE +// ALL: ret + +// ALL: define internal void @[[unordered7]]( +// ALL: call i32 @foo() +// ALL: store {{.*}} @_ZN12_GLOBAL__N_18InternalIiE1aE +// ALL: ret + +// ALL: define internal void @_GLOBAL__sub_I_static_member_variable_explicit_specialization.cpp() // We call unique stubs for every ordered dynamic initializer in the TU. -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK: call -// CHECK-NOT: call -// CHECK: ret +// ALL: call +// ALL: call +// ALL: call +// ALL: call +// ALL: call +// ALL: call +// ALL: call +// ALL: call +// ALL-NOT: call +// ALL: ret diff --git a/test/CodeGenCXX/temporaries.cpp b/test/CodeGenCXX/temporaries.cpp index 7f5c7af03865..89677cb1e4e9 100644 --- a/test/CodeGenCXX/temporaries.cpp +++ b/test/CodeGenCXX/temporaries.cpp @@ -42,6 +42,13 @@ namespace PR20227 { // CHECK: @_ZGRN7PR202271cE_ = private global } +namespace BraceInit { + typedef const int &CIR; + CIR x = CIR{3}; + // CHECK: @_ZGRN9BraceInit1xE_ = private constant i32 3 + // CHECK: @_ZN9BraceInit1xE = constant i32* @_ZGRN9BraceInit1xE_ +} + struct A { A(); ~A(); diff --git a/test/CodeGenCXX/try-catch.cpp b/test/CodeGenCXX/try-catch.cpp index 89f229fee375..b50214ecdb97 100644 --- a/test/CodeGenCXX/try-catch.cpp +++ b/test/CodeGenCXX/try-catch.cpp @@ -11,3 +11,11 @@ void f() { } catch (const X x) { } } + +void h() { + try { + throw "ABC"; + // CHECK: @_ZTIPKc to i8 + } catch (char const(&)[4]) { + } +} diff --git a/test/CodeGenCXX/unknown-anytype.cpp b/test/CodeGenCXX/unknown-anytype.cpp index aacb8493ef3c..e6f887bea083 100644 --- a/test/CodeGenCXX/unknown-anytype.cpp +++ b/test/CodeGenCXX/unknown-anytype.cpp @@ -115,3 +115,11 @@ extern "C" __unknown_anytype test10_any(...); void test10() { (void) test10_any(), (void) test10_any(); } + +extern "C" __unknown_anytype malloc(...); +void test11() { + void *s = (void*)malloc(12); + // COMMON: call i8* (i32, ...)* @malloc(i32 12) + void *d = (void*)malloc(435); + // COMMON: call i8* (i32, ...)* @malloc(i32 435) +} diff --git a/test/CodeGenCXX/vararg-non-pod-ms-compat.cpp b/test/CodeGenCXX/vararg-non-pod-ms-compat.cpp new file mode 100644 index 000000000000..668fadf7b589 --- /dev/null +++ b/test/CodeGenCXX/vararg-non-pod-ms-compat.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -Wno-error=non-pod-varargs -triple i686-pc-win32 -fms-compatibility -emit-llvm -o - %s | FileCheck %s -check-prefix=X86 -check-prefix=CHECK +// RUN: %clang_cc1 -Wno-error=non-pod-varargs -triple x86_64-pc-win32 -fms-compatibility -emit-llvm -o - %s | FileCheck %s -check-prefix=X64 -check-prefix=CHECK + +struct X { + X(); + ~X(); + int data; +}; + +void vararg(...); + +void test(X x) { + // CHECK-LABEL: define void @"\01?test@@YAXUX@@@Z" + + // X86: %[[argmem:[^ ]*]] = alloca inalloca <{ %struct.X }> + // X86: call void (<{ %struct.X }>*, ...)* bitcast (void (...)* @"\01?vararg@@YAXZZ" to void (<{ %struct.X }>*, ...)*)(<{ %struct.X }>* inalloca %[[argmem]]) + + // X64: alloca %struct.X + + // X64: %[[agg:[^ ]*]] = alloca %struct.X + // X64: %[[valptr:[^ ]*]] = getelementptr %struct.X* %[[agg]], i32 0, i32 0 + // X64: %[[val:[^ ]*]] = load i32* %[[valptr]] + // X64: call void (...)* @"\01?vararg@@YAXZZ"(i32 %[[val]]) + + // CHECK-NOT: llvm.trap + vararg(x); + // CHECK: ret void +} diff --git a/test/CodeGenCXX/virtual-base-cast.cpp b/test/CodeGenCXX/virtual-base-cast.cpp index 6a4894b63b70..0dcf319d7dc2 100644 --- a/test/CodeGenCXX/virtual-base-cast.cpp +++ b/test/CodeGenCXX/virtual-base-cast.cpp @@ -20,11 +20,10 @@ A* a() { return x; } // MSVC: @"\01?a@@YAPAUA@@XZ"() [[NUW:#[0-9]+]] { // MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8* {{.*}}, i32 0 -// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i8** -// MSVC: %[[vbtable:.*]] = load i8** %[[vbptr]] -// MSVC: %[[entry:.*]] = getelementptr inbounds i8* {{.*}}, i32 4 -// MSVC: %[[entry_i32:.*]] = bitcast i8* %[[entry]] to i32* -// MSVC: %[[offset:.*]] = load i32* %[[entry_i32]] +// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** +// MSVC: %[[vbtable:.*]] = load i32** %[[vbptr]] +// MSVC: %[[entry:.*]] = getelementptr inbounds i32* {{.*}}, i32 1 +// MSVC: %[[offset:.*]] = load i32* %[[entry]] // MSVC: add nsw i32 0, %[[offset]] // MSVC: } @@ -38,11 +37,10 @@ B* b() { return x; } // Same as 'a' except we use a different vbtable offset. // MSVC: @"\01?b@@YAPAUB@@XZ"() [[NUW:#[0-9]+]] { // MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8* {{.*}}, i32 0 -// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i8** -// MSVC: %[[vbtable:.*]] = load i8** %[[vbptr]] -// MSVC: %[[entry:.*]] = getelementptr inbounds i8* {{.*}}, i32 8 -// MSVC: %[[entry_i32:.*]] = bitcast i8* %[[entry]] to i32* -// MSVC: %[[offset:.*]] = load i32* %[[entry_i32]] +// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** +// MSVC: %[[vbtable:.*]] = load i32** %[[vbptr]] +// MSVC: %[[entry:.*]] = getelementptr inbounds i32* {{.*}}, i32 2 +// MSVC: %[[offset:.*]] = load i32* %[[entry]] // MSVC: add nsw i32 0, %[[offset]] // MSVC: } @@ -58,11 +56,10 @@ BB* c() { return x; } // Same as 'a' except we use a different vbtable offset. // MSVC: @"\01?c@@YAPAUBB@@XZ"() [[NUW:#[0-9]+]] { // MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8* {{.*}}, i32 0 -// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i8** -// MSVC: %[[vbtable:.*]] = load i8** %[[vbptr]] -// MSVC: %[[entry:.*]] = getelementptr inbounds i8* {{.*}}, i32 16 -// MSVC: %[[entry_i32:.*]] = bitcast i8* %[[entry]] to i32* -// MSVC: %[[offset:.*]] = load i32* %[[entry_i32]] +// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** +// MSVC: %[[vbtable:.*]] = load i32** %[[vbptr]] +// MSVC: %[[entry:.*]] = getelementptr inbounds i32* {{.*}}, i32 4 +// MSVC: %[[offset:.*]] = load i32* %[[entry]] // MSVC: add nsw i32 0, %[[offset]] // MSVC: } @@ -78,11 +75,10 @@ BB* d() { return y; } // final add. // MSVC: @"\01?d@@YAPAUBB@@XZ"() [[NUW:#[0-9]+]] { // MSVC: %[[vbptr_off:.*]] = getelementptr inbounds i8* {{.*}}, i32 4 -// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i8** -// MSVC: %[[vbtable:.*]] = load i8** %[[vbptr]] -// MSVC: %[[entry:.*]] = getelementptr inbounds i8* {{.*}}, i32 16 -// MSVC: %[[entry_i32:.*]] = bitcast i8* %[[entry]] to i32* -// MSVC: %[[offset:.*]] = load i32* %[[entry_i32]] +// MSVC: %[[vbptr:.*]] = bitcast i8* %[[vbptr_off]] to i32** +// MSVC: %[[vbtable:.*]] = load i32** %[[vbptr]] +// MSVC: %[[entry:.*]] = getelementptr inbounds i32* {{.*}}, i32 4 +// MSVC: %[[offset:.*]] = load i32* %[[entry]] // MSVC: add nsw i32 4, %[[offset]] // MSVC: } diff --git a/test/CodeGenCXX/virtual-destructor-calls.cpp b/test/CodeGenCXX/virtual-destructor-calls.cpp index 3e7fa8293af8..f0e3dc58b641 100644 --- a/test/CodeGenCXX/virtual-destructor-calls.cpp +++ b/test/CodeGenCXX/virtual-destructor-calls.cpp @@ -17,8 +17,8 @@ struct B : A { // CHECK: @_ZN1BD1Ev = alias {{.*}} @_ZN1BD2Ev // (aliases from C) -// CHECK: @_ZN1CD1Ev = alias {{.*}} @_ZN1CD2Ev // CHECK: @_ZN1CD2Ev = alias bitcast {{.*}} @_ZN1BD2Ev +// CHECK: @_ZN1CD1Ev = alias {{.*}} @_ZN1CD2Ev // Base dtor: actually calls A's base dtor. // CHECK-LABEL: define void @_ZN1BD2Ev(%struct.B* %this) unnamed_addr diff --git a/test/CodeGenCXX/virtual-operator-call.cpp b/test/CodeGenCXX/virtual-operator-call.cpp index 72d49c230093..727c8e140fd8 100644 --- a/test/CodeGenCXX/virtual-operator-call.cpp +++ b/test/CodeGenCXX/virtual-operator-call.cpp @@ -1,10 +1,13 @@ // RUN: %clang_cc1 %s -triple i386-unknown-unknown -emit-llvm -o - | FileCheck %s struct A { - virtual int operator-() = 0; + virtual int operator-(); }; -void f(A *a) { +void f(A a, A *ap) { + // CHECK: call i32 @_ZN1AngEv(%struct.A* %a) + -a; + // CHECK: call i32 % - -*a; + -*ap; } diff --git a/test/CodeGenCXX/vla-lambda-capturing.cpp b/test/CodeGenCXX/vla-lambda-capturing.cpp new file mode 100644 index 000000000000..e8fd0a1fd3ab --- /dev/null +++ b/test/CodeGenCXX/vla-lambda-capturing.cpp @@ -0,0 +1,171 @@ +// RUN: %clang_cc1 %s -std=c++11 -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -std=c++11 -emit-pch -o %t +// RUN: %clang_cc1 %s -std=c++11 -include-pch %t -emit-llvm -o - | FileCheck %s + +#ifndef HEADER +#define HEADER + +typedef __INTPTR_TYPE__ intptr_t; + +// CHECK-DAG: [[CAP_TYPE1:%.+]] = type { [[INTPTR_T:i.+]], [[INTPTR_T]]*, [[INTPTR_T]]* } +// CHECK-DAG: [[CAP_TYPE2:%.+]] = type { [[INTPTR_T]], [[INTPTR_T]]* } +// CHECK-DAG: [[CAP_TYPE3:%.+]] = type { [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]], [[INTPTR_T]]*, [[INTPTR_T]]* } +// CHECK-DAG: [[CAP_TYPE4:%.+]] = type { [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]]*, [[INTPTR_T]], [[INTPTR_T]]* } + +// CHECK: define void [[G:@.+]]( +// CHECK: [[N_ADDR:%.+]] = alloca [[INTPTR_T]] +// CHECK: store [[INTPTR_T]] %{{.+}}, [[INTPTR_T]]* [[N_ADDR]] +// CHECK: [[N_VAL:%.+]] = load [[INTPTR_T]]* [[N_ADDR]] +// CHECK: [[CAP_EXPR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE1]]* [[CAP_ARG:%.+]], i{{.+}} 0, i{{.+}} 0 +// CHECK: store [[INTPTR_T]] [[N_VAL]], [[INTPTR_T]]* [[CAP_EXPR_REF]] +// CHECK: [[CAP_BUFFER_ADDR:%.+]] = getelementptr inbounds [[CAP_TYPE1]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 1 +// CHECK: store [[INTPTR_T]]* %{{.+}}, [[INTPTR_T]]** [[CAP_BUFFER_ADDR]] +// CHECK: [[CAP_N_REF:%.+]] = getelementptr inbounds [[CAP_TYPE1]]* [[CAP_ARG:%.+]], i{{.+}} 0, i{{.+}} 2 +// CHECK: store [[INTPTR_T]]* [[N_ADDR]], [[INTPTR_T]]** [[CAP_N_REF]] +// CHECK: call void [[G_LAMBDA:@.+]]([[CAP_TYPE1]]* [[CAP_ARG]]) +// CHECK: ret void +void g(intptr_t n) { + intptr_t buffer[n]; + [&buffer, &n]() { + __typeof(buffer) x; + }(); +} + +// CHECK: void [[G_LAMBDA]]([[CAP_TYPE1]]* +// CHECK: [[THIS:%.+]] = load [[CAP_TYPE1]]** +// CHECK: [[N_ADDR:%.+]] = getelementptr inbounds [[CAP_TYPE1]]* [[THIS]], i{{.+}} 0, i{{.+}} 0 +// CHECK: [[N:%.+]] = load [[INTPTR_T]]* [[N_ADDR]] +// CHECK: [[BUFFER_ADDR:%.+]] = getelementptr inbounds [[CAP_TYPE1]]* [[THIS]], i{{.+}} 0, i{{.+}} 1 +// CHECK: [[BUFFER:%.+]] = load [[INTPTR_T]]** [[BUFFER_ADDR]] +// CHECK: call i{{.+}}* @llvm.stacksave() +// CHECK: alloca [[INTPTR_T]], [[INTPTR_T]] [[N]] +// CHECK: call void @llvm.stackrestore( +// CHECK: ret void + +template <typename T> +void f(T n, T m) { + intptr_t buffer[n + m]; + [&buffer]() { + __typeof(buffer) x; + }(); +} + +template <typename T> +intptr_t getSize(T); + +template <typename T> +void b(intptr_t n, T arg) { + typedef intptr_t ArrTy[getSize(arg)]; + ArrTy buffer2; + ArrTy buffer1[n + arg]; + intptr_t a; + [&]() { + n = sizeof(buffer1[n]); + [&](){ + n = sizeof(buffer2); + n = sizeof(buffer1); + }(); + }(); +} + +// CHECK-LABEL: @main +int main() { + // CHECK: call void [[G]]([[INTPTR_T]] [[INTPTR_T_ATTR:(signext )?]]1) + g((intptr_t)1); + // CHECK: call void [[F_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]1, [[INTPTR_T]] [[INTPTR_T_ATTR]]2) + f((intptr_t)1, (intptr_t)2); + // CHECK: call void [[B_INT:@.+]]([[INTPTR_T]] [[INTPTR_T_ATTR]]12, [[INTPTR_T]] [[INTPTR_T_ATTR]]13) + b((intptr_t)12, (intptr_t)13); + // CHECK: ret i32 0 + return 0; +} + +// CHECK: void [[F_INT]]([[INTPTR_T]] +// CHECK: [[SIZE:%.+]] = add +// CHECK: call i{{.+}}* @llvm.stacksave() +// CHECK: [[BUFFER_ADDR:%.+]] = alloca [[INTPTR_T]], [[INTPTR_T]] [[SIZE]] +// CHECK: [[CAP_SIZE_REF:%.+]] = getelementptr inbounds [[CAP_TYPE2]]* [[CAP_ARG:%.+]], i{{.+}} 0, i{{.+}} 0 +// CHECK: store [[INTPTR_T]] [[SIZE]], [[INTPTR_T]]* [[CAP_SIZE_REF]] +// CHECK: [[CAP_BUFFER_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE2]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 1 +// CHECK: store [[INTPTR_T]]* [[BUFFER_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER_ADDR_REF]] +// CHECK: call void [[F_INT_LAMBDA:@.+]]([[CAP_TYPE2]]* [[CAP_ARG]]) +// CHECK: call void @llvm.stackrestore( +// CHECK: ret void +// CHECK: void [[B_INT]]([[INTPTR_T]] +// CHECK: [[SIZE1:%.+]] = call [[INTPTR_T]] +// CHECK: call i{{.+}}* @llvm.stacksave() +// CHECK: [[BUFFER2_ADDR:%.+]] = alloca [[INTPTR_T]], [[INTPTR_T]] [[SIZE1]] +// CHECK: [[SIZE2:%.+]] = add +// CHECK: [[BUFFER1_ADDR:%.+]] = alloca [[INTPTR_T]], [[INTPTR_T]] +// CHECK: [[CAP_N_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[CAP_ARG:%.+]], i{{.+}} 0, i{{.+}} 0 +// CHECK: store [[INTPTR_T]]* {{%.+}}, [[INTPTR_T]]** [[CAP_N_ADDR_REF]] +// CHECK: [[CAP_SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 1 +// CHECK: store i{{[0-9]+}} [[SIZE2]], i{{[0-9]+}}* [[CAP_SIZE2_REF]] +// CHECK: [[CAP_SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 2 +// CHECK: store i{{[0-9]+}} [[SIZE1]], i{{[0-9]+}}* [[CAP_SIZE1_REF]] +// CHECK: [[CAP_BUFFER1_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 3 +// CHECK: store [[INTPTR_T]]* [[BUFFER1_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER1_ADDR_REF]] +// CHECK: [[CAP_BUFFER2_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[CAP_ARG]], i{{.+}} 0, i{{.+}} 4 +// CHECK: store [[INTPTR_T]]* [[BUFFER2_ADDR]], [[INTPTR_T]]** [[CAP_BUFFER2_ADDR_REF]] +// CHECK: call void [[B_INT_LAMBDA:@.+]]([[CAP_TYPE3]]* [[CAP_ARG]]) +// CHECK: call void @llvm.stackrestore( +// CHECK: ret void + +// CHECK: define {{.*}} void [[B_INT_LAMBDA]]([[CAP_TYPE3]]* +// CHECK: [[SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 +// CHECK: [[SIZE2:%.+]] = load i{{[0-9]+}}* [[SIZE2_REF]] +// CHECK: [[SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 +// CHECK: [[SIZE1:%.+]] = load i{{[0-9]+}}* [[SIZE1_REF]] +// CHECK: [[N_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[N_ADDR:%.+]] = load [[INTPTR_T]]** [[N_ADDR_REF]] +// CHECK: [[N:%.+]] = load [[INTPTR_T]]* [[N_ADDR]] +// CHECK: [[BUFFER1_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: [[BUFFER1_ADDR:%.+]] = load [[INTPTR_T]]** [[BUFFER1_ADDR_REF]] +// CHECK: [[ELEM_OFFSET:%.+]] = mul {{.*}} i{{[0-9]+}} [[N]], [[SIZE1]] +// CHECK: [[ELEM_ADDR:%.+]] = getelementptr inbounds [[INTPTR_T]]* [[BUFFER1_ADDR]], i{{[0-9]+}} [[ELEM_OFFSET]] +// CHECK: [[SIZEOF:%.+]] = mul {{.*}} i{{[0-9]+}} {{[0-9]+}}, [[SIZE1]] +// CHECK: [[N_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[N_ADDR:%.+]] = load [[INTPTR_T]]** [[N_ADDR_REF]] +// CHECK: store [[INTPTR_T]] {{%.+}}, [[INTPTR_T]]* [[N_ADDR]] +// CHECK: [[N_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[CAP:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[N_ADDR_REF_ORIG:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[N_ADDR_ORIG:%.+]] = load [[INTPTR_T]]** [[N_ADDR_REF_ORIG]] +// CHECK: store [[INTPTR_T]]* [[N_ADDR_ORIG]], [[INTPTR_T]]** [[N_ADDR_REF]] +// CHECK: [[SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[CAP]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 +// CHECK: store i{{[0-9]+}} [[SIZE1]], i{{[0-9]+}}* [[SIZE1_REF]] +// CHECK: [[BUFFER2_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[CAP]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 +// CHECK: [[BUFFER2_ADDR_REF_ORIG:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 4 +// CHECK: [[BUFFER2_ADDR_ORIG:%.+]] = load [[INTPTR_T]]** [[BUFFER2_ADDR_REF_ORIG]] +// CHECK: store [[INTPTR_T]]* [[BUFFER2_ADDR_ORIG]], [[INTPTR_T]]** [[BUFFER2_ADDR_REF]] +// CHECK: [[SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[CAP]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: store i{{[0-9]+}} [[SIZE2]], i{{[0-9]+}}* [[SIZE2_REF]] +// CHECK: [[BUFFER1_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[CAP]], i{{[0-9]+}} 0, i{{[0-9]+}} 4 +// CHECK: [[BUFFER1_ADDR_REF_ORIG:%.+]] = getelementptr inbounds [[CAP_TYPE3]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: [[BUFFER1_ADDR_ORIG:%.+]] = load [[INTPTR_T]]** [[BUFFER1_ADDR_REF_ORIG]] +// CHECK: store [[INTPTR_T]]* [[BUFFER1_ADDR_ORIG]], [[INTPTR_T]]** [[BUFFER1_ADDR_REF]] +// CHECK: call void [[B_INT_LAMBDA_LAMBDA:@.+]]([[CAP_TYPE4]]* [[CAP]]) +// CHECK: ret void + +// CHECK: define {{.*}} void [[B_INT_LAMBDA_LAMBDA]]([[CAP_TYPE4]]* +// CHECK: [[SIZE1_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[THIS:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 +// CHECK: [[SIZE1:%.+]] = load i{{[0-9]+}}* [[SIZE1_REF]] +// CHECK: [[SIZE2_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: [[SIZE2:%.+]] = load i{{[0-9]+}}* [[SIZE2_REF]] +// CHECK: [[BUFFER2_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 +// CHECK: [[BUFFER2_ADDR:%.+]] = load [[INTPTR_T]]** [[BUFFER2_ADDR_REF]] +// CHECK: [[SIZEOF_BUFFER2:%.+]] = mul {{.*}} i{{[0-9]+}} {{[0-9]+}}, [[SIZE1]] +// CHECK: [[BUFFER1_ADDR_REF:%.+]] = getelementptr inbounds [[CAP_TYPE4]]* [[THIS]], i{{[0-9]+}} 0, i{{[0-9]+}} 4 +// CHECK: [[BUFFER1_ADDR:%.+]] = load [[INTPTR_T]]** [[BUFFER1_ADDR_REF]] +// CHECK: [[MUL:%.+]] = mul {{.*}} i{{[0-9]+}} [[SIZE2]], [[SIZE1]] +// CHECK: mul {{.*}} i{{[0-9]+}} {{[0-9]+}}, [[MUL]] +// CHECK: ret void + +// CHECK: void [[F_INT_LAMBDA]]([[CAP_TYPE2]]* +// CHECK: [[THIS:%.+]] = load [[CAP_TYPE2]]** +// CHECK: [[SIZE_REF:%.+]] = getelementptr inbounds [[CAP_TYPE2]]* [[THIS]], i{{.+}} 0, i{{.+}} 0 +// CHECK: [[SIZE:%.+]] = load [[INTPTR_T]]* [[SIZE_REF]] +// CHECK: call i{{.+}}* @llvm.stacksave() +// CHECK: alloca [[INTPTR_T]], [[INTPTR_T]] [[SIZE]] +// CHECK: call void @llvm.stackrestore( +// CHECK: ret void +#endif diff --git a/test/CodeGenCXX/vlt_to_reference.cpp b/test/CodeGenCXX/vlt_to_reference.cpp new file mode 100644 index 000000000000..49d7f1aa975f --- /dev/null +++ b/test/CodeGenCXX/vlt_to_reference.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s + +// CHECK-LABEL: @main + +struct dyn_array { + int size; + int data[]; +}; + +int foo(dyn_array **&d) { + return (*d)->data[1]; +} + +int main() +{ + dyn_array **d; + return foo(d); + + // CHECK: call {{.+}} @{{.+}}foo{{.+}}( + // CHECK: ret i{{[0-9]+}} +} + diff --git a/test/CodeGenCXX/vtable-align.cpp b/test/CodeGenCXX/vtable-align.cpp new file mode 100644 index 000000000000..f1f10c07df2d --- /dev/null +++ b/test/CodeGenCXX/vtable-align.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -triple=i386-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-32 +// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-64 + +struct A { + virtual void f(); + virtual void g(); + virtual void h(); +}; + +void A::f() {} + +// CHECK-32: @_ZTV1A = unnamed_addr constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1fEv to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1gEv to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1hEv to i8*)], align 4 + +// CHECK-64: @_ZTV1A = unnamed_addr constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1fEv to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1gEv to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A1hEv to i8*)], align 8 diff --git a/test/CodeGenCXX/vtable-holder-self-reference.cpp b/test/CodeGenCXX/vtable-holder-self-reference.cpp new file mode 100644 index 000000000000..05e6d71bae9c --- /dev/null +++ b/test/CodeGenCXX/vtable-holder-self-reference.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -emit-llvm -gdwarf-2 -x c++ -o - %s | FileCheck %s +// +// PR21941: crasher for self-referencing DW_TAG_structure_type node. If we get +// rid of self-referenceing structure_types (PR21902), then it should be safe +// to just kill this test. +// +// CHECK: ![[SELF:[0-9]+]] = distinct !{!"0x13\00B\00{{[^"]*}}", {{[^,]+}}, {{[^,]+}}, {{[^,]+}}, {{[^,]+}}, ![[SELF]], {{[^}]+}}} ; [ DW_TAG_structure_type ] [B] + +void foo() { + struct V { + int vi; + }; + struct B : virtual V {}; + B b; +} diff --git a/test/CodeGenCXX/vtable-pointer-initialization.cpp b/test/CodeGenCXX/vtable-pointer-initialization.cpp index 85e08d8f0f9b..835760d165c0 100644 --- a/test/CodeGenCXX/vtable-pointer-initialization.cpp +++ b/test/CodeGenCXX/vtable-pointer-initialization.cpp @@ -21,13 +21,13 @@ struct A : Base { // CHECK-LABEL: define void @_ZN1AC2Ev(%struct.A* %this) unnamed_addr // CHECK: call void @_ZN4BaseC2Ev( -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) to i32 (...)**) // CHECK: call void @_ZN5FieldC1Ev( // CHECK: ret void A::A() { } // CHECK-LABEL: define void @_ZN1AD2Ev(%struct.A* %this) unnamed_addr -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1A, i64 0, i64 2) to i32 (...)**) // CHECK: call void @_ZN5FieldD1Ev( // CHECK: call void @_ZN4BaseD2Ev( // CHECK: ret void @@ -45,13 +45,13 @@ void f() { B b; } // CHECK: call void @_ZN1BC2Ev( // CHECK-LABEL: define linkonce_odr void @_ZN1BD1Ev(%struct.B* %this) unnamed_addr -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1B, i64 0, i64 2) +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1B, i64 0, i64 2) to i32 (...)**) // CHECK: call void @_ZN5FieldD1Ev( // CHECK: call void @_ZN4BaseD2Ev( // CHECK: ret void // CHECK-LABEL: define linkonce_odr void @_ZN1BC2Ev(%struct.B* %this) unnamed_addr // CHECK: call void @_ZN4BaseC2Ev( -// CHECK: store i8** getelementptr inbounds ([3 x i8*]* @_ZTV1B, i64 0, i64 2) +// CHECK: store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @_ZTV1B, i64 0, i64 2) to i32 (...)**) // CHECK: call void @_ZN5FieldC1Ev // CHECK: ret void diff --git a/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp b/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp new file mode 100644 index 000000000000..bb9bd888b20f --- /dev/null +++ b/test/CodeGenCXX/x86_64-arguments-nacl-x32.cpp @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-nacl -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnux32 -emit-llvm -o - %s | FileCheck %s + +struct test_struct {}; +typedef int test_struct::* test_struct_mdp; +typedef int (test_struct::*test_struct_mfp)(); + +// CHECK-LABEL: define i32 @{{.*}}f_mdp{{.*}}(i32 %a) +test_struct_mdp f_mdp(test_struct_mdp a) { return a; } + +// CHECK-LABEL: define {{.*}} @{{.*}}f_mfp{{.*}}(i64 %a.coerce) +test_struct_mfp f_mfp(test_struct_mfp a) { return a; } + +// A struct with <= 12 bytes before a member data pointer should still +// be allowed in registers, since the member data pointer is only 4 bytes. +// CHECK-LABEL: define void @{{.*}}f_struct_with_mdp{{.*}}(i64 %a.coerce0, i64 %a.coerce1) +struct struct_with_mdp { char *a; char *b; char *c; test_struct_mdp d; }; +void f_struct_with_mdp(struct_with_mdp a) { (void)a; } + +struct struct_with_mdp_too_much { + char *a; char *b; char *c; char *d; test_struct_mdp e; +}; +// CHECK-LABEL: define void @{{.*}}f_struct_with_mdp_too_much{{.*}}({{.*}} byval {{.*}} %a) +void f_struct_with_mdp_too_much(struct_with_mdp_too_much a) { + (void)a; +} + +// A struct with <= 8 bytes before a member function pointer should still +// be allowed in registers, since the member function pointer is only 8 bytes. +// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_0{{.*}}(i64 %a.coerce0, i32 %a.coerce1) +struct struct_with_mfp_0 { char *a; test_struct_mfp b; }; +void f_struct_with_mfp_0(struct_with_mfp_0 a) { (void)a; } + +// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_1{{.*}}(i64 %a.coerce0, i64 %a.coerce1) +struct struct_with_mfp_1 { char *a; char *b; test_struct_mfp c; }; +void f_struct_with_mfp_1(struct_with_mfp_1 a) { (void)a; } + +// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_too_much{{.*}}({{.*}} byval {{.*}} %a, i32 %x) +struct struct_with_mfp_too_much { + char *a; char *b; char *c; test_struct_mfp d; +}; +void f_struct_with_mfp_too_much(struct_with_mfp_too_much a, int x) { + (void)a; +} diff --git a/test/CodeGenCXX/x86_64-arguments.cpp b/test/CodeGenCXX/x86_64-arguments.cpp index 2172e0810d75..815ef6111a9a 100644 --- a/test/CodeGenCXX/x86_64-arguments.cpp +++ b/test/CodeGenCXX/x86_64-arguments.cpp @@ -32,6 +32,21 @@ typedef int (s4::*s4_mfp)(); s4_mdp f4_0(s4_mdp a) { return a; } s4_mfp f4_1(s4_mfp a) { return a; } +// A struct with <= one eightbyte before a member data pointer should still +// be allowed in registers. +// CHECK-LABEL: define void @{{.*}}f_struct_with_mdp{{.*}}(i8* %a.coerce0, i64 %a.coerce1) +struct struct_with_mdp { char *a; s4_mdp b; }; +void f_struct_with_mdp(struct_with_mdp a) { (void)a; } + +// A struct with anything before a member function will be too big and +// goes in memory. +// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_0{{.*}}(%struct{{.*}} byval align 8 %a) +struct struct_with_mfp_0 { char a; s4_mfp b; }; +void f_struct_with_mfp_0(struct_with_mfp_0 a) { (void)a; } + +// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_1{{.*}}(%struct{{.*}} byval align 8 %a) +struct struct_with_mfp_1 { void *a; s4_mfp b; }; +void f_struct_with_mfp_1(struct_with_mfp_1 a) { (void)a; } namespace PR7523 { struct StringRef { diff --git a/test/CodeGenObjC/2010-02-09-DbgSelf.m b/test/CodeGenObjC/2010-02-09-DbgSelf.m index 9aebe3d619bc..d70b3d68e827 100644 --- a/test/CodeGenObjC/2010-02-09-DbgSelf.m +++ b/test/CodeGenObjC/2010-02-09-DbgSelf.m @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -x objective-c -emit-llvm -g < %s | FileCheck %s // Test to check that "self" argument is assigned a location. -// CHECK: call void @llvm.dbg.declare(metadata !{%0** %{{[^}]+}}}, metadata [[SELF:![0-9]*]]) +// CHECK: call void @llvm.dbg.declare(metadata %0** %{{[^,]+}}, metadata [[SELF:![0-9]*]], metadata !{{.*}}) // CHECK: [[SELF]] = {{.*}} ; [ DW_TAG_arg_variable ] [self] @interface Foo diff --git a/test/CodeGenObjC/2010-02-15-Dbg-MethodStart.m b/test/CodeGenObjC/2010-02-15-Dbg-MethodStart.m index 5186b20310a6..3fb98c54da26 100644 --- a/test/CodeGenObjC/2010-02-15-Dbg-MethodStart.m +++ b/test/CodeGenObjC/2010-02-15-Dbg-MethodStart.m @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -x objective-c -emit-llvm -g < %s | grep subprogram | grep "i32 9" +// RUN: %clang_cc1 -x objective-c -emit-llvm -g < %s | FileCheck "%s" // Test to check that subprogram start location. @interface Foo @@ -7,6 +7,7 @@ @implementation Foo -(int) barMethod { +// CHECK: [ DW_TAG_subprogram ] [line [[@LINE-1]]] int i = 0; int j = 1; int k = 1; diff --git a/test/CodeGenObjC/arc-foreach.m b/test/CodeGenObjC/arc-foreach.m index ec767d391fd6..46c5da0dd002 100644 --- a/test/CodeGenObjC/arc-foreach.m +++ b/test/CodeGenObjC/arc-foreach.m @@ -46,7 +46,7 @@ void test0(NSArray *array) { // CHECK-LP64-NEXT: [[SAVED_ARRAY:%.*]] = bitcast i8* [[T2]] to [[ARRAY_T]]* // Call the enumeration method. -// CHECK-LP64-NEXT: [[T0:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-NEXT: [[T0:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[SAVED_ARRAY]] to i8* // CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i64 (i8*, i8*, [[STATE_T]]*, [16 x i8*]*, i64)*)(i8* [[T1]], i8* [[T0]], [[STATE_T]]* [[STATE]], [16 x i8*]* [[BUFFER]], i64 16) @@ -69,7 +69,7 @@ void test0(NSArray *array) { // CHECK-LP64: call void @use_block( // CHECK-LP64-NEXT: call void @objc_storeStrong(i8** [[D0]], i8* null) -// CHECK-LP64: [[T0:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64: [[T0:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-LP64-NEXT: [[T1:%.*]] = bitcast [[ARRAY_T]]* [[SAVED_ARRAY]] to i8* // CHECK-LP64-NEXT: [[SIZE:%.*]] = call i64 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i64 (i8*, i8*, [[STATE_T]]*, [16 x i8*]*, i64)*)(i8* [[T1]], i8* [[T0]], [[STATE_T]]* [[STATE]], [16 x i8*]* [[BUFFER]], i64 16) @@ -135,7 +135,7 @@ void test2(Test2 *a) { // CHECK-LP64-NEXT: [[COLL:%.*]] = bitcast i8* [[T2]] to [[ARRAY_T]]* // Make sure it's not immediately released before starting the iteration. -// CHECK-LP64-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-LP64-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-LP64-NEXT: [[T0:%.*]] = bitcast [[ARRAY_T]]* [[COLL]] to i8* // CHECK-LP64-NEXT: @objc_msgSend diff --git a/test/CodeGenObjC/arc-linetable-autorelease.m b/test/CodeGenObjC/arc-linetable-autorelease.m index fa109154ce03..ab20f3e9baf4 100644 --- a/test/CodeGenObjC/arc-linetable-autorelease.m +++ b/test/CodeGenObjC/arc-linetable-autorelease.m @@ -32,8 +32,8 @@ NSRect NSMakeRect(CGFloat x, CGFloat y, CGFloat w, CGFloat h); // CHECK: call void @objc_storeStrong{{.*}} !dbg ![[ARC:[0-9]+]] // CHECK: call {{.*}} @objc_autoreleaseReturnValue{{.*}} !dbg ![[ARC]] // CHECK: ret {{.*}} !dbg ![[ARC]] - // CHECK: ![[RET]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return path; - // CHECK: ![[ARC]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[ARC]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } @end diff --git a/test/CodeGenObjC/arc-linetable.m b/test/CodeGenObjC/arc-linetable.m index 2d56ab3dfb55..656c34346879 100644 --- a/test/CodeGenObjC/arc-linetable.m +++ b/test/CodeGenObjC/arc-linetable.m @@ -57,52 +57,52 @@ typedef signed char BOOL; // CHECK: ![[TESTNOSIDEEFFECT:.*]] = {{.*}}[ DW_TAG_subprogram ] [line [[@LINE+1]]] [local] [def] [-[AppDelegate testNoSideEffect:]] - (int)testNoSideEffect:(NSString *)foo { int x = 1; - // CHECK: ![[ARC1]] = metadata !{i32 [[@LINE+1]], i32 0, metadata ![[TESTNOSIDEEFFECT]], null} + // CHECK: ![[ARC1]] = !MDLocation(line: [[@LINE+1]], scope: ![[TESTNOSIDEEFFECT]]) return 1; // Return expression - // CHECK: ![[RET1]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET1]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } // Cleanup + Ret - (int)testNoCleanup { - // CHECK: ![[RET2]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET2]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return 1; } - (int)testSideEffect:(NSString *)foo { - // CHECK: ![[MSG3]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[MSG3]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return [self testNoSideEffect :foo]; - // CHECK: ![[RET3]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET3]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } - (int)testMultiline:(NSString *)foo { - // CHECK: ![[MSG4]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[MSG4]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) int r = [self testSideEffect :foo]; - // CHECK: ![[EXP4]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[EXP4]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return r; - // CHECK: ![[RET4]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET4]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } - (void)testVoid:(NSString *)foo { - // CHECK: ![[ARC5]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[ARC5]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return; - // CHECK: ![[RET5]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET5]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } - (void)testVoidNoReturn:(NSString *)foo { - // CHECK: ![[MSG6]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[MSG6]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) [self testVoid :foo]; - // CHECK: ![[RET6]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET6]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) } - (int)testNoCleanupSideEffect { - // CHECK: ![[MSG7]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[MSG7]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) [self testVoid :@"foo"]; - // CHECK: ![[RET7]] = metadata !{i32 [[@LINE+1]], i32 0, metadata !{{.*}}, null} + // CHECK: ![[RET7]] = !MDLocation(line: [[@LINE+1]], scope: !{{.*}}) return 1; } - (void)testCleanupVoid:(BOOL)skip withDelegate: (AppDelegate *) delegate { static BOOL skip_all; - // CHECK: ![[SKIP1]] = metadata !{i32 [[@LINE+1]], i32 0, + // CHECK: ![[SKIP1]] = !MDLocation(line: [[@LINE+1]], scope: if (!skip_all) { if (!skip) { return; @@ -112,8 +112,8 @@ typedef signed char BOOL; [delegate testVoid :s]; } } - // CHECK: ![[RET8]] = metadata !{i32 [[@LINE+2]], i32 0, - // CHECK: ![[ARC8]] = metadata !{i32 [[@LINE+1]], i32 0, + // CHECK: ![[RET8]] = !MDLocation(line: [[@LINE+2]], scope: + // CHECK: ![[ARC8]] = !MDLocation(line: [[@LINE+1]], scope: } diff --git a/test/CodeGenObjC/arc-literals.m b/test/CodeGenObjC/arc-literals.m index 19a5516dc7ca..abeb49f9dddf 100644 --- a/test/CodeGenObjC/arc-literals.m +++ b/test/CodeGenObjC/arc-literals.m @@ -50,8 +50,8 @@ void test_array(id a, id b) { // CHECK-NEXT: [[V1:%.*]] = load i8** [[B]], // CHECK-NEXT: store i8* [[V1]], i8** [[T0]] - // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]** @"\01L_OBJC_CLASSLIST - // CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES + // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]** @"OBJC_CLASSLIST + // CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8** // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*@objc_msgSend.*}})(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 2) @@ -93,8 +93,8 @@ void test_dictionary(id k1, id o1, id k2, id o2) { // CHECK-NEXT: store i8* [[V3]], i8** [[T0]] // Constructing the dictionary - // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]** @"\01L_OBJC_CLASSLIST - // CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES + // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]** @"OBJC_CLASSLIST + // CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8** // CHECK-NEXT: [[T3:%.*]] = bitcast [2 x i8*]* [[KEYS]] to i8** @@ -127,7 +127,7 @@ void test_property(B *b) { // CHECK: [[T0:%.*]] = getelementptr inbounds [1 x i8*]* [[OBJECTS:%.*]], i32 0, i32 0 // Invoke 'prop' - // CHECK: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES + // CHECK: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast // CHECK-NEXT: [[T2:%.*]] = call [[B:%.*]]* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]]) // CHECK-NEXT: [[T3:%.*]] = bitcast [[B]]* [[T2]] to i8* @@ -139,8 +139,8 @@ void test_property(B *b) { // CHECK-NEXT: store i8* [[V1]], i8** [[T0]] // Invoke arrayWithObjects:count: - // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T]]** @"\01L_OBJC_CLASSLIST - // CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES + // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T]]** @"OBJC_CLASSLIST + // CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = bitcast [1 x i8*]* [[OBJECTS]] to i8** // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}}(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 1) diff --git a/test/CodeGenObjC/arc-loadweakretained-release.m b/test/CodeGenObjC/arc-loadweakretained-release.m index a84719d606de..4db67a97de7b 100644 --- a/test/CodeGenObjC/arc-loadweakretained-release.m +++ b/test/CodeGenObjC/arc-loadweakretained-release.m @@ -30,7 +30,7 @@ int main (int argc, const char * argv[]) { // CHECK: [[SIXTEEN:%.*]] = call i8* @objc_loadWeakRetained(i8** {{%.*}}) // CHECK-NEXT: [[SEVENTEEN:%.*]] = bitcast i8* [[SIXTEEN]] to {{%.*}} -// CHECK-NEXT: [[EIGHTEEN:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_6" +// CHECK-NEXT: [[EIGHTEEN:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_6 // CHECK-NEXT: [[NINETEEN:%.*]] = bitcast %0* [[SEVENTEEN]] to i8* // CHECK-NEXT: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: [[TWENTY:%.*]] = bitcast %0* [[SEVENTEEN]] to i8* diff --git a/test/CodeGenObjC/arc-precise-lifetime.m b/test/CodeGenObjC/arc-precise-lifetime.m index e15d5d4835ce..ddbd7041cfd2 100644 --- a/test/CodeGenObjC/arc-precise-lifetime.m +++ b/test/CodeGenObjC/arc-precise-lifetime.m @@ -41,7 +41,7 @@ void test1a(void) { // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]]) // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]* - // CHECK-NEXT: [[T4:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T4:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8* // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast // CHECK-NEXT: store i8* [[T6]], i8** @@ -61,7 +61,7 @@ void test1b(void) { // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]* // CHECK-NEXT: store [[TEST1]]* [[T3]] // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]** - // CHECK-NEXT: [[T1:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T1:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8* // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast // CHECK-NEXT: store i8* [[T3]], i8** @@ -84,7 +84,7 @@ void test1c(void) { // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]]) // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]* - // CHECK-NEXT: [[T4:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T4:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8* // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast // CHECK-NEXT: store i8* [[T6]], i8** @@ -106,7 +106,7 @@ void test1d(void) { // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8* // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retainAutorelease // CHECK-NEXT: [[SIX:%.*]] = bitcast i8* [[T3]] to [[TEST1]]* - // CHECK-NEXT: [[SEVEN:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[SEVEN:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[EIGHT:%.*]] = bitcast [[TEST1]]* [[SIX]] to i8* // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[EIGHT]], i8* [[SEVEN]]) // CHECK-NEXT: store i8* [[CALL1]], i8** diff --git a/test/CodeGenObjC/arc-property.m b/test/CodeGenObjC/arc-property.m index 8398a1b60f0d..02cd50dbf286 100644 --- a/test/CodeGenObjC/arc-property.m +++ b/test/CodeGenObjC/arc-property.m @@ -101,13 +101,13 @@ void test3(Test3 *t) { // CHECK-NEXT: [[X:%.*]] = alloca i8*, // Property access. // CHECK: [[T0:%.*]] = load [[TEST3]]** [[T]], -// CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]]) // CHECK-NEXT: store i8* [[T2]], i8** [[X]], // Message send. // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]** [[T]], -// CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]]) // CHECK-NEXT: [[T3:%.*]] = load i8** [[X]], diff --git a/test/CodeGenObjC/arc.m b/test/CodeGenObjC/arc.m index 8fc68ca2ffa8..a83fe0f24be2 100644 --- a/test/CodeGenObjC/arc.m +++ b/test/CodeGenObjC/arc.m @@ -103,8 +103,8 @@ void test3_unelided() { Test3 *x; // Call to +alloc. - // CHECK-NEXT: load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_ - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load {{.*}}* @"OBJC_CLASSLIST_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: bitcast @@ -113,7 +113,7 @@ void test3_unelided() { [Test3 alloc]; // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]** [[X]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8* // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[T1]], // CHECK-NEXT: call void @objc_release(i8* [[COPY]]) [[NUW:#[0-9]+]] @@ -132,14 +132,14 @@ void test3() { id x = [[Test3 alloc] initWith: 5]; // Call to +alloc. - // CHECK-NEXT: load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_ - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load {{.*}}* @"OBJC_CLASSLIST_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: bitcast // Call to -initWith: with elided retain of consumed argument. - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* // CHECK-NEXT: bitcast @@ -149,7 +149,7 @@ void test3() { // Call to -copy. // CHECK-NEXT: [[V:%.*]] = load i8** [[X]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[V]], // Assignment to x. @@ -169,14 +169,14 @@ void test3() { // CHECK-LABEL: define i8* @test4() id test4() { // Call to +alloc. - // CHECK: load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_ - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK: load {{.*}}* @"OBJC_CLASSLIST_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: [[ALLOC:%.*]] = bitcast // Call to -initWith: with elided retain of consumed argument. - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[ALLOC:%.*]] = bitcast // CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* [[ALLOC]], @@ -289,13 +289,13 @@ void test10() { // CHECK-NEXT: [[Y:%.*]] = alloca i8*, align // CHECK-NEXT: store [[TEST10]]* null, [[TEST10]]** [[X]] // CHECK-NEXT: load [[TEST10]]** [[X]], align - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_{{[0-9]*}}" + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_{{[0-9]*}} // CHECK-NEXT: bitcast // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]]) // CHECK-NEXT: [[V:%.*]] = bitcast i8* [[T2]] to [[TEST10]]* - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_{{[0-9]*}}" + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_{{[0-9]*}} // CHECK-NEXT: bitcast // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8* @@ -412,11 +412,11 @@ void test13(void) { // CHECK-NEXT: [[BASE2:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8* // CHECK-NEXT: [[T0:%.*]] = getelementptr // CHECK-NEXT: store i8* [[BASE2]], i8** [[T0]] - // CHECK-NEXT: load {{%.*}}** @"\01L_OBJC_CLASSLIST_SUP_REFS_$_ + // CHECK-NEXT: load {{%.*}}** @"OBJC_CLASSLIST_SUP_REFS_$_ // CHECK-NEXT: bitcast // CHECK-NEXT: getelementptr // CHECK-NEXT: store - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: call void bitcast (i8* ({{.*}})* @objc_msgSendSuper2 to void ( // CHECK-NEXT: ret void } @@ -675,7 +675,7 @@ static id _test29_allocator = 0; // CHECK-NEXT: store [[TEST29]]* null, [[TEST29]]** [[SELF]] // Actual message send. -// CHECK-NEXT: [[T2:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-NEXT: [[T2:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T3:%.*]] = bitcast [[TEST29]]* [[T0]] to i8* // CHECK-NEXT: [[CALL:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T3]], i8* [[T2]], i8* [[T1]]) @@ -782,7 +782,7 @@ char *helper; // Call. // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]** [[SELF]] -// CHECK-NEXT: [[T1:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-NEXT: [[T1:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST30]]* [[T0]] to i8* // CHECK-NEXT: [[CALL:%.*]] = call [[TEST30_HELPER:%.*]]* bitcast {{.*}} @objc_msgSend {{.*}}(i8* [[T2]], i8* [[T1]]) @@ -868,7 +868,7 @@ void test33(Test33 *ptr) { // CHECK-NEXT: load [[TEST33]]** [[PTR]] // CHECK-NEXT: [[W0:%.*]] = load [[A_T]]** [[A]] // CHECK-NEXT: store [[A_T]]* [[W0]], [[A_T]]** [[TEMP0]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP0]]) // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP0]] @@ -884,7 +884,7 @@ void test33(Test33 *ptr) { // CHECK-NEXT: load [[TEST33]]** [[PTR]] // CHECK-NEXT: [[W0:%.*]] = load [[A_T]]** [[A]] // CHECK-NEXT: store [[A_T]]* [[W0]], [[A_T]]** [[TEMP1]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP1]]) // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP1]] @@ -898,19 +898,19 @@ void test33(Test33 *ptr) { // CHECK-NEXT: call void @objc_release(i8* [[T5]]) // CHECK-NEXT: load [[TEST33]]** [[PTR]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]]) // CHECK-NEXT: load [[TEST33]]** [[PTR]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]]) // 'out' // CHECK-NEXT: load [[TEST33]]** [[PTR]] // CHECK-NEXT: store [[A_T]]* null, [[A_T]]** [[TEMP2]] - // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: bitcast // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP2]]) // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP2]] @@ -1270,16 +1270,16 @@ void test61(void) { // CHECK-NEXT: [[T0:%.*]] = call i8* @test61_make() // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]]) - // CHECK-NEXT: [[T2:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ - // CHECK-NEXT: [[T3:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T2:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T3:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T1]], i8* [[T3]], i8* [[T2]]) // CHECK-NEXT: call void @objc_release(i8* [[T1]]) [test61_make() performSelector: @selector(test61_void)]; // CHECK-NEXT: [[T0:%.*]] = call i8* @test61_make() // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]]) - // CHECK-NEXT: [[T2:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ - // CHECK-NEXT: [[T3:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T2:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ + // CHECK-NEXT: [[T3:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T1]], i8* [[T3]], i8* [[T2]]) // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T4]]) // CHECK-NEXT: store i8* [[T5]], i8** [[Y]] @@ -1372,7 +1372,7 @@ void test66(void) { // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST66]]* // CHECK-NEXT: [[T4:%.*]] = call i8* @test66_arg() // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T4]]) -// CHECK-NEXT: [[T6:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: [[T6:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T7:%.*]] = bitcast [[TEST66]]* [[T3]] to i8* // CHECK-NEXT: [[SIX:%.*]] = icmp eq i8* [[T7]], null // CHECK-NEXT: br i1 [[SIX]], label [[NULINIT:%.*]], label [[CALL:%.*]] diff --git a/test/CodeGenObjC/arm-atomic-scalar-setter-getter.m b/test/CodeGenObjC/arm-atomic-scalar-setter-getter.m index 535cbbb85c4f..6eb58906e639 100644 --- a/test/CodeGenObjC/arm-atomic-scalar-setter-getter.m +++ b/test/CodeGenObjC/arm-atomic-scalar-setter-getter.m @@ -8,6 +8,6 @@ @implementation I @synthesize LONG_PROP; @end -// CHECK-ARM: call arm_aapcscc void @objc_copyStruct(i8* %{{.*}}, i8* %{{.*}}, i32 8, i1 zeroext true, i1 zeroext false) -// CHECK-ARM: call arm_aapcscc void @objc_copyStruct(i8* %{{.*}}, i8* %{{.*}}, i32 8, i1 zeroext true, i1 zeroext false) +// CHECK-ARM: call void @objc_copyStruct(i8* %{{.*}}, i8* %{{.*}}, i32 8, i1 zeroext true, i1 zeroext false) +// CHECK-ARM: call void @objc_copyStruct(i8* %{{.*}}, i8* %{{.*}}, i32 8, i1 zeroext true, i1 zeroext false) diff --git a/test/CodeGenObjC/block-byref-debuginfo.m b/test/CodeGenObjC/block-byref-debuginfo.m index 88a8d8d50c1f..231767e99a66 100644 --- a/test/CodeGenObjC/block-byref-debuginfo.m +++ b/test/CodeGenObjC/block-byref-debuginfo.m @@ -3,7 +3,7 @@ // rdar://problem/14386148 // Test that the foo is aligned at an 8 byte boundary in the DWARF // expression (256) that locates it inside of the byref descriptor: -// CHECK: metadata !"foo", i32 0, i64 {{[0-9]+}}, i64 64, i64 256, i32 0, metadata +// CHECK: [ DW_TAG_member ] [foo] [line 0, size {{[0-9]+}}, align 64, offset 256] [from Foo] struct Foo { unsigned char *data; diff --git a/test/CodeGenObjC/block-over-align.m b/test/CodeGenObjC/block-over-align.m new file mode 100644 index 000000000000..2747040ac031 --- /dev/null +++ b/test/CodeGenObjC/block-over-align.m @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin -emit-llvm -o /dev/null %s +// rdar://17878679 + +typedef struct +{ + int i; +} GAXBackboardState __attribute__ ((aligned(32))); // minimum alignment is 32-byte boundary + +@interface GAXSpringboard @end + +@implementation GAXSpringboard +{ + GAXBackboardState _reflectedBackboardState; +} + +- (void) MyMethod +{ + GAXBackboardState newBackboardState; + ^{ + _reflectedBackboardState = newBackboardState; + return newBackboardState.i; + }(); +} +@end + diff --git a/test/CodeGenObjC/boxing.m b/test/CodeGenObjC/boxing.m index efd2b1600b36..33dc4e698f8b 100644 --- a/test/CodeGenObjC/boxing.m +++ b/test/CodeGenObjC/boxing.m @@ -53,18 +53,18 @@ typedef signed char BOOL; + (id)stringWithUTF8String:(const char *)nullTerminatedCString; @end -// CHECK: [[WithIntMeth:@".*"]] = private global [15 x i8] c"numberWithInt:\00" -// CHECK: [[WithIntSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([15 x i8]* [[WithIntMeth]] -// CHECK: [[WithCharMeth:@".*"]] = private global [16 x i8] c"numberWithChar:\00" -// CHECK: [[WithCharSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([16 x i8]* [[WithCharMeth]] -// CHECK: [[WithBoolMeth:@".*"]] = private global [16 x i8] c"numberWithBool:\00" -// CHECK: [[WithBoolSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([16 x i8]* [[WithBoolMeth]] -// CHECK: [[WithIntegerMeth:@".*"]] = private global [19 x i8] c"numberWithInteger:\00" -// CHECK: [[WithIntegerSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([19 x i8]* [[WithIntegerMeth]] -// CHECK: [[WithUnsignedIntegerMeth:@".*"]] = private global [27 x i8] c"numberWithUnsignedInteger:\00" -// CHECK: [[WithUnsignedIntegerSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([27 x i8]* [[WithUnsignedIntegerMeth]] -// CHECK: [[stringWithUTF8StringMeth:@".*"]] = private global [22 x i8] c"stringWithUTF8String:\00" -// CHECK: [[stringWithUTF8StringSEL:@".*"]] = private externally_initialized global i8* getelementptr inbounds ([22 x i8]* [[stringWithUTF8StringMeth]] +// CHECK: [[WithIntMeth:@.*]] = private global [15 x i8] c"numberWithInt:\00" +// CHECK: [[WithIntSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([15 x i8]* [[WithIntMeth]] +// CHECK: [[WithCharMeth:@.*]] = private global [16 x i8] c"numberWithChar:\00" +// CHECK: [[WithCharSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([16 x i8]* [[WithCharMeth]] +// CHECK: [[WithBoolMeth:@.*]] = private global [16 x i8] c"numberWithBool:\00" +// CHECK: [[WithBoolSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([16 x i8]* [[WithBoolMeth]] +// CHECK: [[WithIntegerMeth:@.*]] = private global [19 x i8] c"numberWithInteger:\00" +// CHECK: [[WithIntegerSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([19 x i8]* [[WithIntegerMeth]] +// CHECK: [[WithUnsignedIntegerMeth:@.*]] = private global [27 x i8] c"numberWithUnsignedInteger:\00" +// CHECK: [[WithUnsignedIntegerSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([27 x i8]* [[WithUnsignedIntegerMeth]] +// CHECK: [[stringWithUTF8StringMeth:@.*]] = private global [22 x i8] c"stringWithUTF8String:\00" +// CHECK: [[stringWithUTF8StringSEL:@.*]] = private externally_initialized global i8* getelementptr inbounds ([22 x i8]* [[stringWithUTF8StringMeth]] int main() { // CHECK: load i8** [[WithIntSEL]] diff --git a/test/CodeGenObjC/catch-lexical-block.m b/test/CodeGenObjC/catch-lexical-block.m index 618d3a223229..d5aeee143bea 100644 --- a/test/CodeGenObjC/catch-lexical-block.m +++ b/test/CodeGenObjC/catch-lexical-block.m @@ -10,6 +10,6 @@ void f0() { // We should have 3 lexical blocks here at the moment, including one // for the catch block. // CHECK: lexical_block -// CHECK: lexical_block // CHECK: auto_variable // CHECK: lexical_block +// CHECK: lexical_block diff --git a/test/CodeGenObjC/category-super-class-meth.m b/test/CodeGenObjC/category-super-class-meth.m index 5ba7adff8bbe..268f0b59711d 100644 --- a/test/CodeGenObjC/category-super-class-meth.m +++ b/test/CodeGenObjC/category-super-class-meth.m @@ -22,8 +22,8 @@ @end // CHECK: define internal i8* @"\01+[Sub2(Category) copy] -// CHECK: [[ONE:%.*]] = load %struct._class_t** @"\01L_OBJC_CLASSLIST_SUP_REFS_$_3" +// CHECK: [[ONE:%.*]] = load %struct._class_t** @"OBJC_CLASSLIST_SUP_REFS_$_3" // CHECK: [[TWO:%.*]] = bitcast %struct._class_t* [[ONE]] to i8* // CHECK: [[THREE:%.*]] = getelementptr inbounds %struct._objc_super* [[OBJC_SUPER:%.*]], i32 0, i32 1 // CHECK: store i8* [[TWO]], i8** [[THREE]] -// CHECK: [[FOUR:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" +// CHECK: [[FOUR:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ diff --git a/test/CodeGenObjC/debug-info-block-captured-self.m b/test/CodeGenObjC/debug-info-block-captured-self.m index 183e91b6ec57..f0ca1af34c8f 100644 --- a/test/CodeGenObjC/debug-info-block-captured-self.m +++ b/test/CodeGenObjC/debug-info-block-captured-self.m @@ -55,15 +55,15 @@ typedef enum { // CHECK-NEXT: %[[MEM2:.*]] = alloca i8*, align 8 // CHECK: store i8* [[BLOCK_DESC:%.*]], i8** %[[MEM1]], align 8 // CHECK: %[[TMP0:.*]] = load i8** %[[MEM1]] -// CHECK: call void @llvm.dbg.value(metadata !{i8* %[[TMP0]]}, i64 0, metadata ![[BDMD:[0-9]+]]) -// CHECK: call void @llvm.dbg.declare(metadata !{i8* [[BLOCK_DESC]]}, metadata ![[BDMD:[0-9]+]]) +// CHECK: call void @llvm.dbg.value(metadata i8* %[[TMP0]], i64 0, metadata ![[BDMD:[0-9]+]], metadata !{{.*}}) +// CHECK: call void @llvm.dbg.declare(metadata i8* [[BLOCK_DESC]], metadata ![[BDMD:[0-9]+]], metadata !{{.*}}) // CHECK: %[[TMP1:.*]] = bitcast // CHECK-NEXT: store -// CHECK: call void @llvm.dbg.declare(metadata !{<{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** {{.*}}}, metadata ![[SELF:.*]]) +// CHECK: call void @llvm.dbg.declare(metadata <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** {{[^,]*}}, metadata ![[SELF:.*]], metadata !{{.*}}) // make sure we are still in the same function // CHECK: define {{.*}}__copy_helper_block_ // Metadata -// CHECK: ![[MAIN:.*]] = {{.*}}!"Main"{{.*}}DW_TAG_structure_type{{.*}}line 23 +// CHECK: ![[MAIN:.*]] = !{!"0x13\00Main\0023\00{{.*}}", {{.*}} ; [ DW_TAG_structure_type ] [Main] [line 23, // CHECK: ![[PMAIN:.*]] = {{.*}}![[MAIN]]} ; [ DW_TAG_pointer_type ]{{.*}}from Main -// CHECK: ![[BDMD]] = metadata {{.*}}.block_descriptor +// CHECK: ![[BDMD]] = {{.*}}.block_descriptor // CHECK: ![[SELF]] = {{.*}}![[PMAIN]]{{.*}}[ DW_TAG_auto_variable ] [self] [line 40] diff --git a/test/CodeGenObjC/debug-info-block-type.m b/test/CodeGenObjC/debug-info-block-type.m new file mode 100644 index 000000000000..ef92bf35152d --- /dev/null +++ b/test/CodeGenObjC/debug-info-block-type.m @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -emit-llvm -fblocks -g -triple x86_64-apple-darwin14 -x objective-c < %s -o - | FileCheck %s +#define nil ((void*) 0) +typedef signed char BOOL; +// CHECK: ![[BOOL:[0-9]+]] = {{.*}} [ DW_TAG_typedef ] [BOOL] [line [[@LINE-1]] +// CHECK: ![[ID:[0-9]+]] = {{.*}} [ DW_TAG_typedef ] [id] + +typedef BOOL (^SomeKindOfPredicate)(id obj); +// CHECK: ![[PTR:[0-9]+]]} ; [ DW_TAG_member ] [__FuncPtr] +// CHECK: ![[PTR]] = {{.*}}, ![[FNTYPE:[0-9]+]]} ; [ DW_TAG_pointer_type ] +// CHECK: ![[FNTYPE]] = {{.*}} ![[ARGS:[0-9]+]]{{.*}} ; [ DW_TAG_subroutine_type ] +// CHECK: ![[ARGS]] = !{![[BOOL]], ![[ID]]} + +int main() +{ + SomeKindOfPredicate p = ^BOOL(id obj) { return obj != nil; }; + // CHECK: ![[PTR]]} ; [ DW_TAG_member ] [__FuncPtr] [line [[@LINE-1]], size 64, align 64, offset 128] + return p(nil); +} diff --git a/test/CodeGenObjC/debug-info-blocks.m b/test/CodeGenObjC/debug-info-blocks.m index d025ca87d560..f5f4437b7b59 100644 --- a/test/CodeGenObjC/debug-info-blocks.m +++ b/test/CodeGenObjC/debug-info-blocks.m @@ -7,8 +7,8 @@ // CHECK: define {{.*}}_block_invoke // CHECK: %[[BLOCK:.*]] = bitcast i8* %.block_descriptor to <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>*, !dbg // CHECK-NEXT: store <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>* %[[BLOCK]], <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** %[[ALLOCA:.*]], align -// CHECK-NEXT: call void @llvm.dbg.declare(metadata !{<{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** %[[ALLOCA]]}, metadata ![[SELF:[0-9]+]]) -// CHECK-NEXT: call void @llvm.dbg.declare(metadata !{%1** %d}, metadata ![[D:[0-9]+]]) +// CHECK-NEXT: call void @llvm.dbg.declare(metadata <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** %[[ALLOCA]], metadata ![[SELF:[0-9]+]], metadata !{{.*}}) +// CHECK-NEXT: call void @llvm.dbg.declare(metadata %1** %d, metadata ![[D:[0-9]+]], metadata !{{.*}}) // rdar://problem/14386148 // Test that we don't emit bogus line numbers for the helper functions. @@ -22,10 +22,10 @@ // CHECK-NOT: ret // CHECK: load {{.*}}, !dbg ![[DESTROY_LINE:[0-9]+]] -// CHECK-DAG: [[DBG_LINE]] = metadata !{i32 0, i32 0, metadata ![[COPY_SP:[0-9]+]], null} -// CHECK-DAG: [[COPY_LINE]] = metadata !{i32 0, i32 0, metadata ![[COPY_SP:[0-9]+]], null} +// CHECK-DAG: [[DBG_LINE]] = !MDLocation(line: 0, scope: ![[COPY_SP:[0-9]+]]) +// CHECK-DAG: [[COPY_LINE]] = !MDLocation(line: 0, scope: ![[COPY_SP:[0-9]+]]) // CHECK-DAG: [[COPY_SP]] = {{.*}}[ DW_TAG_subprogram ]{{.*}}[__copy_helper_block_] -// CHECK-DAG: [[DESTROY_LINE]] = metadata !{i32 0, i32 0, metadata ![[DESTROY_SP:[0-9]+]], null} +// CHECK-DAG: [[DESTROY_LINE]] = !MDLocation(line: 0, scope: ![[DESTROY_SP:[0-9]+]]) // CHECK-DAG: [[DESTROY_SP]] = {{.*}}[ DW_TAG_subprogram ]{{.*}}[__destroy_helper_block_] typedef unsigned int NSUInteger; diff --git a/test/CodeGenObjC/debug-info-getter-name.m b/test/CodeGenObjC/debug-info-getter-name.m index 70d99367cbf6..9e1e55f0f408 100644 --- a/test/CodeGenObjC/debug-info-getter-name.m +++ b/test/CodeGenObjC/debug-info-getter-name.m @@ -1,7 +1,7 @@ // REQUIRES: x86-registered-target // RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin10 -fexceptions -fobjc-exceptions -g %s -o - | FileCheck %s -// CHECK: {{.*}}, metadata !"-[InstanceVariablesEverywhereButTheInterface someString]", {{.*}}} ; [ DW_TAG_subprogram ] +// CHECK: !"0x2e\00-[InstanceVariablesEverywhereButTheInterface someString]\00{{.*}}", {{.*}} ; [ DW_TAG_subprogram ] //rdar: //8498026 diff --git a/test/CodeGenObjC/debug-info-id-with-protocol.m b/test/CodeGenObjC/debug-info-id-with-protocol.m index 7e96baffdeea..9233f6ccc859 100644 --- a/test/CodeGenObjC/debug-info-id-with-protocol.m +++ b/test/CodeGenObjC/debug-info-id-with-protocol.m @@ -36,6 +36,7 @@ int main() } } // Verify that the debug type for both variables is 'id'. -// CHECK: metadata !{i32 {{[0-9]+}}, metadata !{{[0-9]+}}, metadata !"bad_carrier", null, i32 {{[0-9]+}}, metadata ![[IDTYPE:[0-9]+]], i32 0, i32 0} ; [ DW_TAG_arg_variable ] [bad_carrier] [line 0] -// CHECK: metadata !{i32 {{[0-9]+}}, metadata !{{[0-9]+}}, metadata !"good_carrier", null, i32 {{[0-9]+}}, metadata !{{.*}}[[IDTYPE]], i32 0, i32 0} ; [ DW_TAG_arg_variable ] [good_carrier] [line 0] -// CHECK !{{.*}}[[IDTYPE]] = metadata !{i32 {{[0-9]+}}, null, metadata !"id", metadata !{{[0-9]+}}, i32 !{{[0-9]+}}, i64 0, i64 0, i64 0, i32 0, metadata !{{[0-9]+}}} ; [ DW_TAG_typedef ] [id] +// CHECK: !"0x101\00bad_carrier\00{{[0-9]+}}\000", !{{[0-9]+}}, null, ![[IDTYPE:[0-9]+]]} ; [ DW_TAG_arg_variable ] [bad_carrier] [line 0] +// +// CHECK: !"0x101\00good_carrier\00{{[0-9]+}}\000", !{{[0-9]+}}, null, ![[IDTYPE]]} ; [ DW_TAG_arg_variable ] [good_carrier] [line 0] +// CHECK !{{.*}}[[IDTYPE]] = !{!"0x16\00id\00{{[0-9]+}}\000\000\000\000", null, !{{[0-9]+}}, !{{[0-9]+}}} ; [ DW_TAG_typedef ] [id] diff --git a/test/CodeGenObjC/debug-info-instancetype.m b/test/CodeGenObjC/debug-info-instancetype.m index 1c155179a382..07fd5ca00b18 100644 --- a/test/CodeGenObjC/debug-info-instancetype.m +++ b/test/CodeGenObjC/debug-info-instancetype.m @@ -13,11 +13,11 @@ @implementation Foo +(instancetype)defaultFoo {return 0;} -// CHECK: ![[FOO:[0-9]+]] = metadata {{.*}}; [ DW_TAG_structure_type ] [Foo] -// CHECK: metadata !"+[Foo defaultFoo]", metadata !"", i32 [[@LINE-2]], metadata ![[TYPE:[0-9]+]] -// CHECK: ![[TYPE]] = {{.*}} metadata ![[RESULT:[0-9]+]], i32 {{.*}}, null, null, null} ; [ DW_TAG_subroutine_type ] -// CHECK: ![[RESULT]] = metadata {{.*}}{metadata ![[FOOPTR:[0-9]+]], -// CHECK: ![[FOOPTR]] = {{.*}}, metadata ![[FOO]]}{{.*}}[ DW_TAG_pointer_type ] {{.*}} [from Foo] +// CHECK: ![[FOO:[0-9]+]] = {{.*}}; [ DW_TAG_structure_type ] [Foo] +// CHECK: !"0x2e\00+[Foo defaultFoo]\00+[Foo defaultFoo]\00\00[[@LINE-2]]\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[TYPE:[0-9]+]] +// CHECK: ![[TYPE]] = {{.*}} ![[RESULT:[0-9]+]], null, null, null} ; [ DW_TAG_subroutine_type ] +// CHECK: ![[RESULT]] = {{.*}}{![[FOOPTR:[0-9]+]], +// CHECK: ![[FOOPTR]] = {{.*}}, ![[FOO]]}{{.*}}[ DW_TAG_pointer_type ] {{.*}} [from Foo] @end diff --git a/test/CodeGenObjC/debug-info-ivars-extension.m b/test/CodeGenObjC/debug-info-ivars-extension.m index e43b598f70ca..9dd715225272 100644 --- a/test/CodeGenObjC/debug-info-ivars-extension.m +++ b/test/CodeGenObjC/debug-info-ivars-extension.m @@ -26,8 +26,8 @@ void gorf (I* pg) { // CHECK: {{.*}} [ DW_TAG_structure_type ] [I] // Check for "a". -// CHECK: {{.*}} [ DW_TAG_member ] [a] [line 7, size 32, align 32, offset 0] [from int] +// CHECK: {{.*}} [ DW_TAG_member ] [a] [line 7, size 32, align 32, offset 0] [public] [from int] // Make sure we don't output the same type twice. // CHECK-NOT: {{.*}} [ DW_TAG_structure_type ] [I] // Check for "b". -// CHECK: {{.*}} [ DW_TAG_member ] [b] [line 18, size 32, align 32, offset 0] [from int] +// CHECK: {{.*}} [ DW_TAG_member ] [b] [line 18, size 32, align 32, offset 0] [public] [from int] diff --git a/test/CodeGenObjC/debug-info-lifetime-crash.m b/test/CodeGenObjC/debug-info-lifetime-crash.m index 81c7fbca1a80..e2e5d7e3b3b5 100644 --- a/test/CodeGenObjC/debug-info-lifetime-crash.m +++ b/test/CodeGenObjC/debug-info-lifetime-crash.m @@ -13,10 +13,10 @@ { // The debug type for these two will be identical, because we do not // actually emit the ownership qualifier. - // CHECK-DAG: metadata !"weakSelf", metadata !{{[0-9]+}}, i32 [[@LINE+1]], metadata ![[SELFTY:[0-9]+]], i32 0, i32 0, {{.*}}} ; [ DW_TAG_auto_variable ] [weakSelf] + // CHECK-DAG: !"0x100\00weakSelf\00[[@LINE+1]]\000"{{, [^,]+, [^,]+}}, ![[SELFTY:[0-9]+]]} ; [ DW_TAG_auto_variable ] [weakSelf] __attribute__((objc_ownership(weak))) __typeof(self) weakSelf = self; Block = [^{ - // CHECK-DAG: metadata !"strongSelf", metadata !{{[0-9]+}}, i32 [[@LINE+1]], metadata ![[SELFTY]], i32 0, i32 0} ; [ DW_TAG_auto_variable ] [strongSelf] + // CHECK-DAG: !"0x100\00strongSelf\00[[@LINE+1]]\000"{{, [^,]+, [^,]+}}, ![[SELFTY]]} ; [ DW_TAG_auto_variable ] [strongSelf] __attribute__((objc_ownership(strong))) __typeof(self) strongSelf = weakSelf; } copy]; } diff --git a/test/CodeGenObjC/debug-info-nested-blocks.m b/test/CodeGenObjC/debug-info-nested-blocks.m new file mode 100644 index 000000000000..5c5958cf3096 --- /dev/null +++ b/test/CodeGenObjC/debug-info-nested-blocks.m @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -emit-llvm -gdwarf-2 -fblocks -o - -x objective-c %s| FileCheck %s +// This code triggered a bug where a dbg.declare intrinsic ended up with the +// wrong parent and subsequently failed the Verifier. +void baz(id b); +void fub(id block); +int foo(void); +void bar(void) { + fub(^() { + id a; + id b = [a bar:^(int e){}]; + if (b) { + ^() { + if ((0 && foo()) ? 1 : 0) { + baz([a aMessage]); + } + }; + } + }); +} + +// Verify that debug info for BlockPointerDbgLoc is emitted for the +// innermost block. +// +// CHECK: define {{.*}}void @__bar_block_invoke_3(i8* %.block_descriptor) +// CHECK: %[[BLOCKADDR:.*]] = alloca <{{.*}}>*, align +// CHECK: call void @llvm.dbg.declare(metadata {{.*}}%[[BLOCKADDR]] diff --git a/test/CodeGenObjC/debug-info-property-accessors.m b/test/CodeGenObjC/debug-info-property-accessors.m index 4c7b98466a3e..0c7f03e6fb57 100644 --- a/test/CodeGenObjC/debug-info-property-accessors.m +++ b/test/CodeGenObjC/debug-info-property-accessors.m @@ -5,7 +5,7 @@ // Ensure we emit the names of explicit/renamed accessors even if they // are defined later in the implementation section. // -// CHECK: metadata !{i32 {{.*}}, metadata !"blah", {{.*}} metadata !"isBlah", metadata !"", {{.*}}} ; [ DW_TAG_APPLE_property ] [blah] +// CHECK: !"0x4200\00blah\00{{[0-9]+}}\00isBlah\00{{.*}}", {{.*}}} ; [ DW_TAG_APPLE_property ] [blah] @class NSString; extern void NSLog(NSString *format, ...); diff --git a/test/CodeGenObjC/debug-info-property3.m b/test/CodeGenObjC/debug-info-property3.m index f63e744066ec..a6d8daf083b0 100644 --- a/test/CodeGenObjC/debug-info-property3.m +++ b/test/CodeGenObjC/debug-info-property3.m @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -S -emit-llvm -g %s -o - | FileCheck %s -// CHECK: metadata !"p1", metadata !{{.*}}, i32 5, metadata !"", metadata !"", i32 2316, metadata !{{.*}}} ; [ DW_TAG_APPLE_property ] +// CHECK: !"0x4200\00p1\005\00\00\002316", {{.*}}} ; [ DW_TAG_APPLE_property ] @interface I1 @property int p1; @end diff --git a/test/CodeGenObjC/debug-info-self.m b/test/CodeGenObjC/debug-info-self.m index 7a484d81481a..a6e9daff916a 100644 --- a/test/CodeGenObjC/debug-info-self.m +++ b/test/CodeGenObjC/debug-info-self.m @@ -14,6 +14,6 @@ } @end -// CHECK: metadata !{i32 {{.*}}, metadata ![[CTOR:.*]], metadata !"self", null, i32 16777216, metadata !{{.*}}, i32 1088, i32 0} ; [ DW_TAG_arg_variable ] [self] [line 0] -// CHECK: metadata !{i32 {{.*}}, metadata ![[CTOR]], metadata !"_cmd", null, i32 33554432, metadata !{{.*}}, i32 64, i32 0} ; [ DW_TAG_arg_variable ] [_cmd] [line 0] -// CHECK: metadata !{i32 {{.*}}, metadata ![[CTOR]], metadata !"myarg", metadata !{{.*}}, i32 50331659, metadata !{{.*}}, i32 0, i32 0} ; [ DW_TAG_arg_variable ] [myarg] [line 11] +// CHECK: !"0x101\00self\0016777216\001088", ![[CTOR:.*]], null, !{{.*}}} ; [ DW_TAG_arg_variable ] [self] [line 0] +// CHECK: !"0x101\00_cmd\0033554432\0064", ![[CTOR]], null, !{{.*}}} ; [ DW_TAG_arg_variable ] [_cmd] [line 0] +// CHECK: !"0x101\00myarg\0050331659\000", ![[CTOR]], !{{.*}}, !{{.*}}} ; [ DW_TAG_arg_variable ] [myarg] [line 11] diff --git a/test/CodeGenObjC/debug-info-static-var.m b/test/CodeGenObjC/debug-info-static-var.m index 2c10d597797f..6828983b0830 100644 --- a/test/CodeGenObjC/debug-info-static-var.m +++ b/test/CodeGenObjC/debug-info-static-var.m @@ -2,7 +2,7 @@ // Radar 8801045 // Do not emit AT_MIPS_linkage_name for static variable i -// CHECK: metadata !"i", metadata !"i", metadata !"" +// CHECK: !"0x34\00i\00i\00\00{{.*}}" @interface A { } diff --git a/test/CodeGenObjC/debug-info-synthesis.m b/test/CodeGenObjC/debug-info-synthesis.m index 1bf7576d886f..55867b4068a2 100644 --- a/test/CodeGenObjC/debug-info-synthesis.m +++ b/test/CodeGenObjC/debug-info-synthesis.m @@ -31,4 +31,4 @@ int main(int argc, char *argv[]) { } // CHECK: ![[FILE:.*]] = {{.*}}[ DW_TAG_file_type ] [{{.*}}/foo.h] -// CHECK: metadata ![[FILE]], {{.*}} ; [ DW_TAG_subprogram ] [line 8] [local] [def] [-[Foo dict]] +// CHECK: ![[FILE]], {{.*}} ; [ DW_TAG_subprogram ] [line 8] [local] [def] [-[Foo dict]] diff --git a/test/CodeGenObjC/debug-info-variadic-method.m b/test/CodeGenObjC/debug-info-variadic-method.m new file mode 100644 index 000000000000..e895953ff6b6 --- /dev/null +++ b/test/CodeGenObjC/debug-info-variadic-method.m @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -o - -emit-llvm -g %s | FileCheck %s + +// This test verifies that variadic ObjC methods get the +// DW_TAG_unspecified_parameter marker. + +@interface Foo +- (void) Bar: (int) n, ...; +@end + +@implementation Foo +- (void) Bar: (int) n, ... +{ + // CHECK: ![[NUM:[^,]*]], null, null, null} ; [ DW_TAG_subroutine_type ] + // CHECK: ![[NUM]] = {{!{null, ![^,]*, ![^,]*, ![^,]*, null}}} +} +@end diff --git a/test/CodeGenObjC/debug-property-synth.m b/test/CodeGenObjC/debug-property-synth.m index 68fb956def80..14657249c00d 100644 --- a/test/CodeGenObjC/debug-property-synth.m +++ b/test/CodeGenObjC/debug-property-synth.m @@ -20,8 +20,8 @@ // // CHECK: [ DW_TAG_subprogram ] [line [[@LINE+4]]] [local] [def] [-[I p1]] // CHECK: [ DW_TAG_subprogram ] [line [[@LINE+3]]] [local] [def] [-[I setP1:]] -// CHECK: ![[DBG1]] = metadata !{i32 [[@LINE+2]], -// CHECK: ![[DBG2]] = metadata !{i32 [[@LINE+1]], +// CHECK: ![[DBG1]] = !MDLocation(line: [[@LINE+2]], +// CHECK: ![[DBG2]] = !MDLocation(line: [[@LINE+1]], @property int p1; @end diff --git a/test/CodeGenObjC/encode-test.m b/test/CodeGenObjC/encode-test.m index 6f2423b66874..b61fbb32eaf1 100644 --- a/test/CodeGenObjC/encode-test.m +++ b/test/CodeGenObjC/encode-test.m @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -triple i686-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -o %t %s // RUN: FileCheck < %t %s // -// CHECK: @"\01L_OBJC_METH_VAR_TYPE_34" = private global [16 x i8] c"v12@0:4[3[4@]]8\00" +// CHECK: @OBJC_METH_VAR_TYPE_34 = private global [16 x i8] c"v12@0:4[3[4@]]8\00" @class Int1; diff --git a/test/CodeGenObjC/exceptions-asm-attribute.m b/test/CodeGenObjC/exceptions-asm-attribute.m index eb369902a3c8..c5ef46724b5c 100644 --- a/test/CodeGenObjC/exceptions-asm-attribute.m +++ b/test/CodeGenObjC/exceptions-asm-attribute.m @@ -11,11 +11,11 @@ // CHECK-X86_64: @"OBJC_CLASS_$_MySecretNamespace.A" = global {{.*}}, section "__DATA, __objc_data", align 8 // CHECK-X86_64: @"OBJC_METACLASS_$_MySecretNamespace.A" = global {{.*}}, section "__DATA, __objc_data", align 8 -// CHECK-X86_64: @"\01L_OBJC_CLASS_NAME_" = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 +// CHECK-X86_64: @OBJC_CLASS_NAME_ = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 // CHECK-X86_64: @"OBJC_EHTYPE_$_MySecretNamespace.EH1" = weak global {{.*}}, section "__DATA,__datacoal_nt,coalesced", align 8 // CHECK-X86_64: @"OBJC_EHTYPE_$_MySecretNamespace.EH2" = external global // CHECK-X86_64: @"OBJC_EHTYPE_$_MySecretNamespace.EH3" = global {{.*}}, section "__DATA,__objc_const", align 8 -// CHECK-X86_64: @"\01L_OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 +// CHECK-X86_64: @"OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 // CHECK-X86_64: define internal void @"\01-[A im0]" // CHECK-X86_64: define internal void @"\01-[A(Cat) im1]" @@ -35,11 +35,11 @@ // CHECK-ARMV6: @"OBJC_CLASS_$_MySecretNamespace.A" = global {{.*}}, section "__DATA, __objc_data", align 4 // CHECK-ARMV6: @"OBJC_METACLASS_$_MySecretNamespace.A" = global {{.*}}, section "__DATA, __objc_data", align 4 -// CHECK-ARMV6: @"\01L_OBJC_CLASS_NAME_" = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 +// CHECK-ARMV6: @OBJC_CLASS_NAME_ = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 // CHECK-ARMV6: @"OBJC_EHTYPE_$_MySecretNamespace.EH1" = weak global {{.*}}, section "__DATA,__datacoal_nt,coalesced", align 4 // CHECK-ARMV6: @"OBJC_EHTYPE_$_MySecretNamespace.EH2" = external global // CHECK-ARMV6: @"OBJC_EHTYPE_$_MySecretNamespace.EH3" = global {{.*}}, section "__DATA,__objc_const", align 4 -// CHECK-ARMV6: @"\01L_OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 4 +// CHECK-ARMV6: @"OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 4 // CHECK-ARMV6: define internal void @"\01-[A im0]" // CHECK-ARMV6: define internal void @"\01-[A(Cat) im1]" diff --git a/test/CodeGenObjC/externally-initialized-selectors.m b/test/CodeGenObjC/externally-initialized-selectors.m index 0b7c24eadd84..7dcd727e5724 100644 --- a/test/CodeGenObjC/externally-initialized-selectors.m +++ b/test/CodeGenObjC/externally-initialized-selectors.m @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fobjc-runtime=macosx-fragile-10.5 -o - -emit-llvm %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-llvm %s | FileCheck %s -// CHECK: @"\01L_OBJC_SELECTOR_REFERENCES_" = private externally_initialized global +// CHECK: @OBJC_SELECTOR_REFERENCES_ = private externally_initialized global void test(id x) { [x doSomething]; diff --git a/test/CodeGenObjC/forward-protocol-metadata-symbols.m b/test/CodeGenObjC/forward-protocol-metadata-symbols.m index 2b687d19f907..2e7ee63e0160 100644 --- a/test/CodeGenObjC/forward-protocol-metadata-symbols.m +++ b/test/CodeGenObjC/forward-protocol-metadata-symbols.m @@ -23,4 +23,4 @@ int main() { // CHECK: @"\01l_OBJC_LABEL_PROTOCOL_$_P0" = weak hidden global // CHECK: @"\01l_OBJC_PROTOCOL_REFERENCE_$_P0" = weak hidden global -// CHECK: llvm.compiler.used = appending global [10 x i8*] {{[^"]*}}"\01L_OBJC_CLASS_NAME_"{{[^"]*}}"\01L_OBJC_METH_VAR_NAME_"{{[^"]*}}"\01L_OBJC_METH_VAR_TYPE_"{{[^"]*}}"\01l_OBJC_$_CLASS_METHODS_A"{{[^"]*}}"\01l_OBJC_CLASS_PROTOCOLS_$_A"{{[^"]*}}"\01L_OBJC_CLASS_NAME_1"{{[^"]*}}"\01l_OBJC_PROTOCOL_$_P0"{{[^"]*}}"\01l_OBJC_LABEL_PROTOCOL_$_P0"{{[^"]*}}"\01l_OBJC_PROTOCOL_REFERENCE_$_P0"{{[^"]*}}"\01L_OBJC_LABEL_CLASS_$"{{[^"]*}} section "llvm.metadata" +// CHECK: llvm.compiler.used = appending global [10 x i8*] {{[^"]*}}OBJC_CLASS_NAME_{{[^"]*}}OBJC_METH_VAR_NAME_{{[^"]*}}OBJC_METH_VAR_TYPE_{{[^"]*}}"\01l_OBJC_$_CLASS_METHODS_A"{{[^"]*}}"\01l_OBJC_CLASS_PROTOCOLS_$_A"{{[^"]*}}OBJC_CLASS_NAME_1{{[^"]*}}"\01l_OBJC_PROTOCOL_$_P0"{{[^"]*}}"\01l_OBJC_LABEL_PROTOCOL_$_P0"{{[^"]*}}"\01l_OBJC_PROTOCOL_REFERENCE_$_P0"{{[^"]*}}"OBJC_LABEL_CLASS_$"{{[^"]*}} section "llvm.metadata" diff --git a/test/CodeGenObjC/image-info.m b/test/CodeGenObjC/image-info.m index 49f5d90808a9..43fb125a4cc6 100644 --- a/test/CodeGenObjC/image-info.m +++ b/test/CodeGenObjC/image-info.m @@ -5,13 +5,13 @@ // RUN: FileCheck --check-prefix CHECK-NONFRAGILE < %t %s // CHECK-FRAGILE: !llvm.module.flags = !{{{.*}}} -// CHECK-FRAGILE: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Version", i32 1} -// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Image Info Version", i32 0} -// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Image Info Section", metadata !"__OBJC, __image_info,regular"} -// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 4, metadata !"Objective-C Garbage Collection", i32 0} +// CHECK-FRAGILE: !{{[0-9]+}} = !{i32 1, !"Objective-C Version", i32 1} +// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Version", i32 0} +// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Section", !"__OBJC, __image_info,regular"} +// CHECK-FRAGILE-NEXT: !{{[0-9]+}} = !{i32 4, !"Objective-C Garbage Collection", i32 0} // CHECK-NONFRAGILE: !llvm.module.flags = !{{{.*}}} -// CHECK-NONFRAGILE: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Version", i32 2} -// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Image Info Version", i32 0} -// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 1, metadata !"Objective-C Image Info Section", metadata !"__DATA, __objc_imageinfo, regular, no_dead_strip"} -// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = metadata !{i32 4, metadata !"Objective-C Garbage Collection", i32 0} +// CHECK-NONFRAGILE: !{{[0-9]+}} = !{i32 1, !"Objective-C Version", i32 2} +// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Version", i32 0} +// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Section", !"__DATA, __objc_imageinfo, regular, no_dead_strip"} +// CHECK-NONFRAGILE-NEXT: !{{[0-9]+}} = !{i32 4, !"Objective-C Garbage Collection", i32 0} diff --git a/test/CodeGenObjC/ivar-layout-64.m b/test/CodeGenObjC/ivar-layout-64.m index 068d109321fc..0dfdbb960857 100644 --- a/test/CodeGenObjC/ivar-layout-64.m +++ b/test/CodeGenObjC/ivar-layout-64.m @@ -33,9 +33,9 @@ __weak B *f2; @property int p3; @end -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"C\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"\11p\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"!`\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"C\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"\11p\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"!`\00" @implementation C @@ -48,9 +48,9 @@ __weak B *f2; @property (assign) __weak id p2; @end -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"A\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"\11q\10\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"!q\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"A\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"\11q\10\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"!q\00" @implementation A @synthesize p0 = _p0; @@ -62,9 +62,9 @@ __weak B *f2; @property int p3; @end -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"D\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"\11p\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"!`\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"D\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"\11p\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"!`\00" @implementation D @synthesize p3 = _p3; @@ -89,8 +89,8 @@ typedef unsigned int FSCatalogInfoBitmap; } @end -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"NSFileLocationComponent\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"\01\14\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"NSFileLocationComponent\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"\01\14\00" @implementation NSFileLocationComponent @end @@ -108,7 +108,7 @@ typedef unsigned int FSCatalogInfoBitmap; } @end -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"Foo\00" -// CHECK: @"\01L_OBJC_CLASS_NAME_{{.*}}" = private global {{.*}} c"\02\10\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"Foo\00" +// CHECK: @OBJC_CLASS_NAME_{{.*}} = private global {{.*}} c"\02\10\00" @implementation Foo @end diff --git a/test/CodeGenObjC/mangle-blocks.m b/test/CodeGenObjC/mangle-blocks.m new file mode 100644 index 000000000000..f0339c153084 --- /dev/null +++ b/test/CodeGenObjC/mangle-blocks.m @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -triple i386-apple-ios -fblocks -emit-llvm -o - %s -Wno-objc-root-class \ +// RUN: | FileCheck %s + +void __assert_rtn(const char *, const char *, int, const char *); + +@interface Test +- (void (^)(void)) mangle; +@end + +@implementation Test +- (void (^)(void)) mangle { + return ^() { + void (^b)(void) = ^() { + __assert_rtn(__func__, __FILE__, __LINE__, "mangle"); + }; + }; +} +@end + +// CHECK: @"__func__.__14-[Test mangle]_block_invoke_2" = private unnamed_addr constant [34 x i8] c"__14-[Test mangle]_block_invoke_2\00", align 1 +// CHECK: @.str = private unnamed_addr constant {{.*}}, align 1 +// CHECK: @.str1 = private unnamed_addr constant [7 x i8] c"mangle\00", align 1 + +// CHECK: define internal void @"__14-[Test mangle]_block_invoke"(i8* %.block_descriptor) + +// CHECK: define internal void @"__14-[Test mangle]_block_invoke_2"(i8* %.block_descriptor){{.*}}{ +// CHECK: call void @__assert_rtn(i8* getelementptr inbounds ([34 x i8]* @"__func__.__14-[Test mangle]_block_invoke_2", i32 0, i32 0), i8* getelementptr inbounds {{.*}}, i32 14, i8* getelementptr inbounds ([7 x i8]* @.str1, i32 0, i32 0)) +// CHECK: } + diff --git a/test/CodeGenObjC/metadata-symbols-32.m b/test/CodeGenObjC/metadata-symbols-32.m index 61279e1dbed9..c75f6411e874 100644 --- a/test/CodeGenObjC/metadata-symbols-32.m +++ b/test/CodeGenObjC/metadata-symbols-32.m @@ -2,30 +2,30 @@ // CHECK: .lazy_reference .objc_class_name_J0 -// CHECK: @"\01L_OBJC_METH_VAR_NAME_{{[0-9]*}}" = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 -// CHECK: @"\01L_OBJC_METH_VAR_TYPE_{{[0-9]*}}" = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 +// CHECK: @OBJC_METH_VAR_NAME_{{[0-9]*}} = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 +// CHECK: @OBJC_METH_VAR_TYPE_{{[0-9]*}} = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 // CHECK: @"\01l_OBJC_PROTOCOLEXT_P" = private global // CHECK-NOT: section -// CHECK: @"\01L_OBJC_CLASS_NAME_{{[0-9]*}}" = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 -// CHECK: @"\01L_OBJC_PROTOCOL_INSTANCE_METHODS_P" = private global {{.*}}section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_PROTOCOL_CLASS_METHODS_P" = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_PROTOCOL_P" = private global {{.*}}section "__OBJC,__protocol,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_PROTOCOLS_A" = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_METHODS_A" = private global {{.*}}section "__OBJC,__cls_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_METACLASS_A" = private global {{.*}}section "__OBJC,__meta_class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_INSTANCE_VARIABLES_A" = private global {{.*}}section "__OBJC,__instance_vars,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_INSTANCE_METHODS_A" = private global {{.*}}section "__OBJC,__inst_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_PROP_NAME_ATTR_{{[0-9]*}}" = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 +// CHECK: @OBJC_CLASS_NAME_{{[0-9]*}} = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 +// CHECK: @OBJC_PROTOCOL_INSTANCE_METHODS_P = private global {{.*}}section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_PROTOCOL_CLASS_METHODS_P = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_PROTOCOL_P = private global {{.*}}section "__OBJC,__protocol,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_PROTOCOLS_A = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_METHODS_A = private global {{.*}}section "__OBJC,__cls_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_METACLASS_A = private global {{.*}}section "__OBJC,__meta_class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_INSTANCE_VARIABLES_A = private global {{.*}}section "__OBJC,__instance_vars,regular,no_dead_strip", align 4 +// CHECK: @OBJC_INSTANCE_METHODS_A = private global {{.*}}section "__OBJC,__inst_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_PROP_NAME_ATTR_{{[0-9]*}} = private global {{.*}}section "__TEXT,__cstring,cstring_literals", align 1 // CHECK: @"\01l_OBJC_$_PROP_LIST_A" = private global {{.*}}section "__OBJC,__property,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASSEXT_A" = private global {{.*}}section "__OBJC,__class_ext,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_A" = private global {{.*}}section "__OBJC,__class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CATEGORY_INSTANCE_METHODS_A_Cat" = private global {{.*}}section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CATEGORY_CLASS_METHODS_A_Cat" = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CATEGORY_A_Cat" = private global {{.*}}section "__OBJC,__category,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_REFERENCES_{{[0-9]*}}" = private global {{.*}}section "__OBJC,__cls_refs,literal_pointers,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_SELECTOR_REFERENCES_{{[0-9]*}}" = private externally_initialized global {{.*}}section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_SYMBOLS" = private global {{.*}}section "__OBJC,__symbols,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_MODULES" = private global {{.*}}section "__OBJC,__module_info,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASSEXT_A = private global {{.*}}section "__OBJC,__class_ext,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_A = private global {{.*}}section "__OBJC,__class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CATEGORY_INSTANCE_METHODS_A_Cat = private global {{.*}}section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CATEGORY_CLASS_METHODS_A_Cat = private global {{.*}}section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CATEGORY_A_Cat = private global {{.*}}section "__OBJC,__category,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_REFERENCES_{{[0-9]*}} = private global {{.*}}section "__OBJC,__cls_refs,literal_pointers,no_dead_strip", align 4 +// CHECK: @OBJC_SELECTOR_REFERENCES_{{[0-9]*}} = private externally_initialized global {{.*}}section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4 +// CHECK: @OBJC_SYMBOLS = private global {{.*}}section "__OBJC,__symbols,regular,no_dead_strip", align 4 +// CHECK: @OBJC_MODULES = private global {{.*}}section "__OBJC,__module_info,regular,no_dead_strip", align 4 // Clang's Obj-C 32-bit doesn't emit ivars for the root class. // CHECKX: @"\01L_OBJC_CLASS_VARIABLES_A" = private global {{.*}}section "__OBJC,__class_vars,regular,no_dead_strip", align 4 diff --git a/test/CodeGenObjC/metadata-symbols-64.m b/test/CodeGenObjC/metadata-symbols-64.m index 7b9609386900..8f598f41e551 100644 --- a/test/CodeGenObjC/metadata-symbols-64.m +++ b/test/CodeGenObjC/metadata-symbols-64.m @@ -5,9 +5,9 @@ // CHECK: @_objc_empty_vtable = external global // CHECK: @"OBJC_CLASS_$_A" = global // CHECK: @"OBJC_METACLASS_$_A" = global {{.*}} section "__DATA, __objc_data", align 8 -// CHECK: @"\01L_OBJC_CLASS_NAME_{{[0-9]*}}" = private global {{.*}} section "__TEXT,__objc_classname,cstring_literals", align 1 -// CHECK: @"\01L_OBJC_METH_VAR_NAME_{{[0-9]*}}" = private global {{.*}} section "__TEXT,__objc_methname,cstring_literals", align 1 -// CHECK: @"\01L_OBJC_METH_VAR_TYPE_{{[0-9]*}}" = private global {{.*}} section "__TEXT,__objc_methtype,cstring_literals", align 1 +// CHECK: @OBJC_CLASS_NAME_{{[0-9]*}} = private global {{.*}} section "__TEXT,__objc_classname,cstring_literals", align 1 +// CHECK: @OBJC_METH_VAR_NAME_{{[0-9]*}} = private global {{.*}} section "__TEXT,__objc_methname,cstring_literals", align 1 +// CHECK: @OBJC_METH_VAR_TYPE_{{[0-9]*}} = private global {{.*}} section "__TEXT,__objc_methtype,cstring_literals", align 1 // CHECK: @"\01l_OBJC_$_CLASS_METHODS_A" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" = private global {{.*}} section "__DATA, __objc_const", align 8 @@ -17,20 +17,20 @@ // CHECK: @"\01l_OBJC_METACLASS_RO_$_A" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_INSTANCE_METHODS_A" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_INSTANCE_VARIABLES_A" = private global {{.*}} section "__DATA, __objc_const", align 8 -// CHECK: @"\01L_OBJC_PROP_NAME_ATTR_{{[0-9]*}}" = private global {{.*}} section "__TEXT,__cstring,cstring_literals", align 1 +// CHECK: @OBJC_PROP_NAME_ATTR_{{[0-9]*}} = private global {{.*}} section "__TEXT,__cstring,cstring_literals", align 1 // CHECK: @"\01l_OBJC_$_PROP_LIST_A" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_CLASS_RO_$_A" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_Cat" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_Cat" = private global {{.*}} section "__DATA, __objc_const", align 8 // CHECK: @"\01l_OBJC_$_CATEGORY_A_$_Cat" = private global {{.*}} section "__DATA, __objc_const", align 8 -// CHECK: @"\01L_OBJC_CLASSLIST_SUP_REFS_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_superrefs, regular, no_dead_strip", align 8 -// CHECK: @"\01L_OBJC_SELECTOR_REFERENCES_" = private externally_initialized global {{.*}} section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" -// CHECK: @"\01L_OBJC_CLASSLIST_SUP_REFS_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_superrefs, regular, no_dead_strip", align 8 +// CHECK: @"OBJC_CLASSLIST_SUP_REFS_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_superrefs, regular, no_dead_strip", align 8 +// CHECK: @OBJC_SELECTOR_REFERENCES_ = private externally_initialized global {{.*}} section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip" +// CHECK: @"OBJC_CLASSLIST_SUP_REFS_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_superrefs, regular, no_dead_strip", align 8 // CHECK: @"OBJC_CLASS_$_B" = external global -// CHECK: @"\01L_OBJC_CLASSLIST_REFERENCES_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 +// CHECK: @"OBJC_CLASSLIST_REFERENCES_$_{{[0-9]*}}" = private global {{.*}} section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8 // CHECK: @"\01l_objc_msgSend_fixup_alloc" = weak hidden global {{.*}} section "__DATA, __objc_msgrefs, coalesced", align 16 -// CHECK: @"\01L_OBJC_LABEL_CLASS_$" = private global {{.*}} section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 -// CHECK: @"\01L_OBJC_LABEL_CATEGORY_$" = private global {{.*}} section "__DATA, __objc_catlist, regular, no_dead_strip", align 8 +// CHECK: @"OBJC_LABEL_CLASS_$" = private global {{.*}} section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 +// CHECK: @"OBJC_LABEL_CATEGORY_$" = private global {{.*}} section "__DATA, __objc_catlist, regular, no_dead_strip", align 8 // CHECK: @objc_msgSend_fpret( // CHECK: @objc_msgSend_fixup( diff --git a/test/CodeGenObjC/metadata_symbols.m b/test/CodeGenObjC/metadata_symbols.m index 2b61c5d4bad3..2c44fb59bd2b 100644 --- a/test/CodeGenObjC/metadata_symbols.m +++ b/test/CodeGenObjC/metadata_symbols.m @@ -10,11 +10,11 @@ // CHECK-X86_64: @"OBJC_CLASS_$_A" = global {{.*}}, section "__DATA, __objc_data", align 8 // CHECK-X86_64: @"OBJC_METACLASS_$_A" = global {{.*}}, section "__DATA, __objc_data", align 8 -// CHECK-X86_64: @"\01L_OBJC_CLASS_NAME_" = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 +// CHECK-X86_64: @OBJC_CLASS_NAME_ = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 // CHECK-X86_64: @"OBJC_EHTYPE_$_EH1" = weak global {{.*}}, section "__DATA,__datacoal_nt,coalesced", align 8 // CHECK-X86_64: @"OBJC_EHTYPE_$_EH2" = external global // CHECK-X86_64: @"OBJC_EHTYPE_$_EH3" = global {{.*}}, section "__DATA,__objc_const", align 8 -// CHECK-X86_64: @"\01L_OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 +// CHECK-X86_64: @"OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 8 // CHECK-X86_64: define internal void @"\01-[A im0]" // CHECK-X86_64: define internal void @"\01-[A(Cat) im1]" @@ -34,11 +34,11 @@ // CHECK-ARMV6: @"OBJC_CLASS_$_A" = global {{.*}}, section "__DATA, __objc_data", align 4 // CHECK-ARMV6: @"OBJC_METACLASS_$_A" = global {{.*}}, section "__DATA, __objc_data", align 4 -// CHECK-ARMV6: @"\01L_OBJC_CLASS_NAME_" = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 +// CHECK-ARMV6: @OBJC_CLASS_NAME_ = {{.*}}, section "__TEXT,__objc_classname,cstring_literals", align 1 // CHECK-ARMV6: @"OBJC_EHTYPE_$_EH1" = weak global {{.*}}, section "__DATA,__datacoal_nt,coalesced", align 4 // CHECK-ARMV6: @"OBJC_EHTYPE_$_EH2" = external global // CHECK-ARMV6: @"OBJC_EHTYPE_$_EH3" = global {{.*}}, section "__DATA,__objc_const", align 4 -// CHECK-ARMV6: @"\01L_OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 4 +// CHECK-ARMV6: @"OBJC_LABEL_CLASS_$" = private global {{.*}}, section "__DATA, __objc_classlist, regular, no_dead_strip", align 4 // CHECK-ARMV6: define internal void @"\01-[A im0]" // CHECK-ARMV6: define internal void @"\01-[A(Cat) im1]" diff --git a/test/CodeGenObjC/non-lazy-classes.m b/test/CodeGenObjC/non-lazy-classes.m index 760ddad068c5..400d3e9fdf94 100644 --- a/test/CodeGenObjC/non-lazy-classes.m +++ b/test/CodeGenObjC/non-lazy-classes.m @@ -1,6 +1,7 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o %t %s -// RUN: grep '@".01L_OBJC_LABEL_NONLAZY_CLASS_$" = private global \[1 x .*\] .*@"OBJC_CLASS_$_A".*, section "__DATA, __objc_nlclslist, regular, no_dead_strip", align 8' %t -// RUN: grep '@".01L_OBJC_LABEL_NONLAZY_CATEGORY_$" = private global \[1 x .*\] .*@".01l_OBJC_$_CATEGORY_A_$_Cat".*, section "__DATA, __objc_nlcatlist, regular, no_dead_strip", align 8' %t +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o - %s | \ +// RUN: FileCheck %s +// CHECK: @"OBJC_LABEL_NONLAZY_CLASS_$" = private global [1 x {{.*}}] {{.*}}@"OBJC_CLASS_$_A"{{.*}}, section "__DATA, __objc_nlclslist, regular, no_dead_strip", align 8 +// CHECK: @"OBJC_LABEL_NONLAZY_CATEGORY_$" = private global [1 x {{.*}}] {{.*}}@"\01l_OBJC_$_CATEGORY_A_$_Cat"{{.*}}, section "__DATA, __objc_nlcatlist, regular, no_dead_strip", align 8 @interface A @end @implementation A diff --git a/test/CodeGenObjC/objc-align.m b/test/CodeGenObjC/objc-align.m index 2b2133ea59b1..427633505872 100644 --- a/test/CodeGenObjC/objc-align.m +++ b/test/CodeGenObjC/objc-align.m @@ -1,33 +1,14 @@ // 32-bit // RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -o - %s | FileCheck %s -// CHECK: @"\01L_OBJC_METACLASS_A" = private global {{.*}}, section "__OBJC,__meta_class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_A" = private global {{.*}}, section "__OBJC,__class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CATEGORY_A_Cat" = private global {{.*}}, section "__OBJC,__category,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_PROTOCOL_P" = private global {{.*}}, section "__OBJC,__protocol,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_PROTOCOLS_C" = private global {{.*}}, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_METACLASS_C" = private global {{.*}}, section "__OBJC,__meta_class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_CLASS_C" = private global {{.*}}, section "__OBJC,__class,regular,no_dead_strip", align 4 -// CHECK: @"\01L_OBJC_MODULES" = private global {{.*}}, section "__OBJC,__module_info,regular,no_dead_strip", align 4 - -// 64-bit - -// RUNX: %clang_cc1 -triple i386-apple-darwin9 -emit-llvm -o %t %s && -// RUNX: grep '@"OBJC_CLASS_$_A" = global' %t && -// RUNX: grep '@"OBJC_CLASS_$_C" = global' %t && -// RUNX: grep '@"OBJC_METACLASS_$_A" = global' %t && -// RUNX: grep '@"OBJC_METACLASS_$_C" = global' %t && -// RUNX: grep '@"\\01L_OBJC_CLASSLIST_REFERENCES_$_0" = private global .*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8' %t && -// RUNX: grep '@"\\01L_OBJC_LABEL_CATEGORY_$" = private global .*, section "__DATA, __objc_catlist, regular, no_dead_strip", align 8' %t && -// RUNX: grep '@"\\01L_OBJC_LABEL_CLASS_$" = private global .*, section "__DATA, __objc_classlist, regular, no_dead_strip", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_$_CATEGORY_A_$_Cat" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_CLASS_PROTOCOLS_$_C" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_CLASS_RO_$_A" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_CLASS_RO_$_C" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_LABEL_PROTOCOL_$_P" = weak hidden global .*, section "__DATA, __objc_protolist, coalesced, no_dead_strip", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_METACLASS_RO_$_A" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_METACLASS_RO_$_C" = private global .*, section "__DATA, __objc_const", align 8' %t && -// RUNX: grep '@"\\01l_OBJC_PROTOCOL_$_P" = weak hidden global .*, section "__DATA,__datacoal_nt,coalesced", align 8' %t && +// CHECK: @OBJC_METACLASS_A = private global {{.*}}, section "__OBJC,__meta_class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_A = private global {{.*}}, section "__OBJC,__class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CATEGORY_A_Cat = private global {{.*}}, section "__OBJC,__category,regular,no_dead_strip", align 4 +// CHECK: @OBJC_PROTOCOL_P = private global {{.*}}, section "__OBJC,__protocol,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_PROTOCOLS_C = private global {{.*}}, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4 +// CHECK: @OBJC_METACLASS_C = private global {{.*}}, section "__OBJC,__meta_class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_CLASS_C = private global {{.*}}, section "__OBJC,__class,regular,no_dead_strip", align 4 +// CHECK: @OBJC_MODULES = private global {{.*}}, section "__OBJC,__module_info,regular,no_dead_strip", align 4 @interface A @end diff --git a/test/CodeGenObjC/objc-container-subscripting-1.m b/test/CodeGenObjC/objc-container-subscripting-1.m index 91b7f468ea95..9ddfd39f63c4 100644 --- a/test/CodeGenObjC/objc-container-subscripting-1.m +++ b/test/CodeGenObjC/objc-container-subscripting-1.m @@ -19,7 +19,7 @@ int main() { id oldObject = array[10]; // CHECK: [[ARR:%.*]] = load {{%.*}} [[array:%.*]], align 8 -// CHECK-NEXT: [[SEL:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" +// CHECK-NEXT: [[SEL:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[ARRC:%.*]] = bitcast {{%.*}} [[ARR]] to i8* // CHECK-NEXT: [[CALL:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* [[ARRC]], i8* [[SEL]], i32 10) // CHECK-NEXT: store i8* [[CALL]], i8** [[OLDOBJ:%.*]], align 8 @@ -27,7 +27,7 @@ int main() { val = (array[10] = oldObject); // CHECK: [[THREE:%.*]] = load {{%.*}} [[array:%.*]], align 8 // CHECK-NEXT: [[FOUR:%.*]] = load i8** [[oldObject:%.*]], align 8 -// CHECK-NEXT: [[FIVE:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_2" +// CHECK-NEXT: [[FIVE:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_2 // CHECK-NEXT: [[SIX:%.*]] = bitcast {{%.*}} [[THREE]] to i8* // CHECK-NEXT: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i32)*)(i8* [[SIX]], i8* [[FIVE]], i8* [[FOUR]], i32 10) // CHECK-NEXT: store i8* [[FOUR]], i8** [[val:%.*]] @@ -38,7 +38,7 @@ int main() { oldObject = dictionary[key]; // CHECK: [[SEVEN:%.*]] = load {{%.*}} [[DICTIONARY:%.*]], align 8 // CHECK-NEXT: [[EIGHT:%.*]] = load i8** [[KEY:%.*]], align 8 -// CHECK-NEXT: [[TEN:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_4" +// CHECK-NEXT: [[TEN:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_4 // CHECK-NEXT: [[ELEVEN:%.*]] = bitcast {{%.*}} [[SEVEN]] to i8* // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[ELEVEN]], i8* [[TEN]], i8* [[EIGHT]]) // CHECK-NEXT: store i8* [[CALL1]], i8** [[oldObject:%.*]], align 8 @@ -48,7 +48,7 @@ int main() { // CHECK: [[TWELVE:%.*]] = load {{%.*}} [[DICTIONARY]], align 8 // CHECK-NEXT: [[THIRTEEN:%.*]] = load i8** [[KEY]], align 8 // CHECK-NEXT: [[FOURTEEN:%.*]] = load i8** [[NEWOBJECT:%.*]], align 8 -// CHECK-NEXT: [[SIXTEEN:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_6" +// CHECK-NEXT: [[SIXTEEN:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_6 // CHECK-NEXT: [[SEVENTEEN:%.*]] = bitcast {{%.*}} [[TWELVE]] to i8* // CHECK-NEXT: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* [[SEVENTEEN]], i8* [[SIXTEEN]], i8* [[FOURTEEN]], i8* [[THIRTEEN]]) // CHECK-NEXT: store i8* [[FOURTEEN]], i8** [[val:%.*]] diff --git a/test/CodeGenObjC/objc-fixed-enum.m b/test/CodeGenObjC/objc-fixed-enum.m index 55c2a7c1031e..eff317cdc513 100644 --- a/test/CodeGenObjC/objc-fixed-enum.m +++ b/test/CodeGenObjC/objc-fixed-enum.m @@ -34,13 +34,13 @@ typedef NSInteger Enum3; int main() { Enum0 e0 = Enum0One; - // CHECK: call void @llvm.dbg.declare(metadata !{{.*}}, metadata ![[ENUM0:[0-9]+]]) + // CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[ENUM0:[0-9]+]], metadata !{{.*}}) Enum1 e1 = Enum1One; - // CHECK: call void @llvm.dbg.declare(metadata !{{.*}}, metadata ![[ENUM1:[0-9]+]]) + // CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[ENUM1:[0-9]+]], metadata !{{.*}}) Enum2 e2 = Enum2One; - // CHECK: call void @llvm.dbg.declare(metadata !{{.*}}, metadata ![[ENUM2:[0-9]+]]) + // CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[ENUM2:[0-9]+]], metadata !{{.*}}) Enum3 e3 = Enum3One; - // CHECK: call void @llvm.dbg.declare(metadata !{{.*}}, metadata ![[ENUM3:[0-9]+]]) + // CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[ENUM3:[0-9]+]], metadata !{{.*}}) // -Werror and the following line ensures that these enums are not // -treated as C++11 strongly typed enums. @@ -51,14 +51,14 @@ int main() { // CHECK: ![[ENUMERATOR3:[0-9]+]] = {{.*}}; [ DW_TAG_typedef ] [NSInteger] [line 6{{.*}}] [from long int] // CHECK: ![[ENUMERATOR2:[0-9]+]] = {{.*}}; [ DW_TAG_enumeration_type ] [line 22{{.*}}] [from NSInteger] -// CHECK: ![[ENUM0]] = metadata !{{{.*}}!"e0", metadata !{{[0-9]+}}, i32 {{[0-9]+}}, metadata ![[TYPE0:[0-9]+]] -// CHECK: ![[TYPE0]] = metadata !{{{.*}}!"Enum0", {{.*}} metadata ![[ENUMERATOR0]]} ; [ DW_TAG_typedef ] [Enum0] +// CHECK: ![[ENUM0]] = !{!"0x100\00e0\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[TYPE0:[0-9]+]]} ; [ DW_TAG_auto_variable ] +// CHECK: ![[TYPE0]] = !{!"0x16\00Enum0\00{{.*}}", {{.*}}, ![[ENUMERATOR0]]} ; [ DW_TAG_typedef ] [Enum0] -// CHECK: ![[ENUM1]] = metadata !{{{.*}}!"e1", metadata !{{[0-9]+}}, i32 {{[0-9]+}}, metadata ![[TYPE1:[0-9]+]] -// CHECK: ![[TYPE1]] = metadata !{{{.*}}!"Enum1", {{.*}} metadata ![[ENUMERATOR1]]} ; [ DW_TAG_typedef ] [Enum1] +// CHECK: ![[ENUM1]] = !{!"0x100\00e1\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[TYPE1:[0-9]+]]} ; [ DW_TAG_auto_variable ] +// CHECK: ![[TYPE1]] = !{!"0x16\00Enum1\00{{.*}}", {{.*}}, ![[ENUMERATOR1]]} ; [ DW_TAG_typedef ] [Enum1] -// CHECK: ![[ENUM2]] = metadata !{{{.*}}!"e2", metadata !{{[0-9]+}}, i32 {{[0-9]+}}, metadata ![[TYPE2:[0-9]+]] -// CHECK: ![[TYPE2]] = metadata !{{{.*}}!"Enum2", {{.*}} metadata ![[ENUMERATOR2]]} ; [ DW_TAG_typedef ] [Enum2] +// CHECK: ![[ENUM2]] = !{!"0x100\00e2\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[TYPE2:[0-9]+]]} ; [ DW_TAG_auto_variable ] +// CHECK: ![[TYPE2]] = !{!"0x16\00Enum2\00{{.*}}", {{.*}}, ![[ENUMERATOR2]]} ; [ DW_TAG_typedef ] [Enum2] -// CHECK: ![[ENUM3]] = metadata !{{{.*}}!"e3", metadata !{{[0-9]+}}, i32 {{[0-9]+}}, metadata ![[TYPE3:[0-9]+]] -// CHECK: ![[TYPE3]] = metadata !{{{.*}}!"Enum3", {{.*}} metadata ![[ENUMERATOR3]]} ; [ DW_TAG_typedef ] [Enum3] +// CHECK: ![[ENUM3]] = !{!"0x100\00e3\00{{[^,]*}}"{{, [^,]+, [^,]+}}, ![[TYPE3:[0-9]+]]} ; [ DW_TAG_auto_variable ] +// CHECK: ![[TYPE3]] = !{!"0x16\00Enum3\00{{.*}}", {{.*}}, ![[ENUMERATOR3]]} ; [ DW_TAG_typedef ] [Enum3] diff --git a/test/CodeGenObjC/optimize-ivar-offset-load.m b/test/CodeGenObjC/optimize-ivar-offset-load.m index d34ac137587f..29f70bea7a63 100644 --- a/test/CodeGenObjC/optimize-ivar-offset-load.m +++ b/test/CodeGenObjC/optimize-ivar-offset-load.m @@ -44,7 +44,7 @@ extern void foo(int); } } @end -// CHECK: [[ZERO:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8, !invariant.load +// CHECK: [[ZERO:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load // CHECK: [[IVAR:%.*]] = load i64* @"OBJC_IVAR_$_SampleClass._value", align 8, !invariant.load @interface Sample : SampleClass @end @@ -59,6 +59,6 @@ extern void foo(int); } } @end -// CHECK: [[ZERO:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8, !invariant.load +// CHECK: [[ZERO:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load // CHECK: [[IVAR:%.*]] = load i64* @"OBJC_IVAR_$_SampleClass._value", align 8, !invariant.load diff --git a/test/CodeGenObjC/optimized-setter-ios-device.m b/test/CodeGenObjC/optimized-setter-ios-device.m index 6fa322ab0f5f..ae8f34c081bf 100644 --- a/test/CodeGenObjC/optimized-setter-ios-device.m +++ b/test/CodeGenObjC/optimized-setter-ios-device.m @@ -26,8 +26,8 @@ @synthesize atomicPropertyCopy; @end -// CHECK: call arm_aapcscc void @objc_setProperty_nonatomic -// CHECK: call arm_aapcscc void @objc_setProperty_nonatomic_copy -// CHECK: call arm_aapcscc void @objc_setProperty_atomic -// CHECK: call arm_aapcscc void @objc_setProperty_atomic_copy +// CHECK: call void @objc_setProperty_nonatomic +// CHECK: call void @objc_setProperty_nonatomic_copy +// CHECK: call void @objc_setProperty_atomic +// CHECK: call void @objc_setProperty_atomic_copy diff --git a/test/CodeGenObjC/private-extern-selector-reference.m b/test/CodeGenObjC/private-extern-selector-reference.m new file mode 100644 index 000000000000..c954d77027ce --- /dev/null +++ b/test/CodeGenObjC/private-extern-selector-reference.m @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple x86_64-apple-ios6.0.0 -emit-llvm -o - %s | FileCheck %s +// rdar://18150301 + +@interface Query ++ (void)_configureCI; +@end + +__attribute__((visibility("default"))) __attribute__((availability(ios,introduced=7.0))) +@interface ObserverQuery : Query @end + +@implementation ObserverQuery ++ (void)_configureCI { + [super _configureCI]; +} +@end + +// CHECK: @"OBJC_METACLASS_$_ObserverQuery" = global %struct._class_t +// CHECK: @OBJC_SELECTOR_REFERENCES_ = private externally_initialized global diff --git a/test/CodeGenObjC/property-array-type.m b/test/CodeGenObjC/property-array-type.m index 6600fd0f5965..84191ef6bfa5 100644 --- a/test/CodeGenObjC/property-array-type.m +++ b/test/CodeGenObjC/property-array-type.m @@ -26,5 +26,5 @@ typedef struct _GLKMatrix4 GLKMatrix4; // CHECK: [[M:%.*]] = getelementptr inbounds %struct._GLKMatrix4* [[TMP:%.*]], i32 0, i32 0 // CHECK: [[ARRAYDECAY:%.*]] = getelementptr inbounds [16 x float]* [[M]], i32 0, i32 0 -// CHECK: [[SIX:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK: [[SIX:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES // CHECK: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, float*)*)(i8* [[SEVEN:%.*]], i8* [[SIX]], float* [[ARRAYDECAY]]) diff --git a/test/CodeGenObjC/property-type-mismatch.m b/test/CodeGenObjC/property-type-mismatch.m index b920b45aef95..b5618cb513a8 100644 --- a/test/CodeGenObjC/property-type-mismatch.m +++ b/test/CodeGenObjC/property-type-mismatch.m @@ -13,5 +13,5 @@ void bar(Foo *x) { // CHECK: [[C1:%.*]] = call float bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK: [[I:%.*]] = fadd float [[C1]], 1.000000e+00 // CHECK: [[CONV:%.*]] = fptosi float [[I]] to i32 -// CHECK: [[T3:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_2" +// CHECK: [[T3:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_2 // CHECK: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend diff --git a/test/CodeGenObjC/property.m b/test/CodeGenObjC/property.m index e156270f66fe..0f63a0fd14b0 100644 --- a/test/CodeGenObjC/property.m +++ b/test/CodeGenObjC/property.m @@ -136,33 +136,33 @@ void test7(Test7 *t) { // CHECK: [[T:%.*]] = alloca [[TEST7]]*, // CHECK-NEXT: store // CHECK-NEXT: [[T0:%.*]] = load [[TEST7]]** [[T]], align -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call zeroext i8 bitcast // CHECK-NEXT: [[T3:%.*]] = zext i8 [[T2]] to i32 // CHECK-NEXT: [[T4:%.*]] = and i32 [[T3]], 2 // CHECK-NEXT: [[T5:%.*]] = trunc i32 [[T4]] to i8 -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T6:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: call void bitcast // CHECK-NEXT: [[T0:%.*]] = load [[TEST7]]** [[T]], align -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call zeroext i8 bitcast // CHECK-NEXT: [[T3:%.*]] = zext i8 [[T2]] to i32 // CHECK-NEXT: [[T4:%.*]] = or i32 [[T3]], 5 // CHECK-NEXT: [[T5:%.*]] = trunc i32 [[T4]] to i8 -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T6:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: call void bitcast // CHECK-NEXT: [[T0:%.*]] = load [[TEST7]]** [[T]], align -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: [[T2:%.*]] = call zeroext i8 bitcast // CHECK-NEXT: [[T3:%.*]] = zext i8 [[T2]] to i32 // CHECK-NEXT: [[T4:%.*]] = xor i32 [[T3]], 8 // CHECK-NEXT: [[T5:%.*]] = trunc i32 [[T4]] to i8 -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES // CHECK-NEXT: [[T6:%.*]] = bitcast [[TEST7]]* [[T0]] to i8* // CHECK-NEXT: call void bitcast // CHECK-NEXT: ret void diff --git a/test/CodeGenObjC/reorder-synthesized-ivars.m b/test/CodeGenObjC/reorder-synthesized-ivars.m index 8faafff2cdac..958d447b983c 100644 --- a/test/CodeGenObjC/reorder-synthesized-ivars.m +++ b/test/CodeGenObjC/reorder-synthesized-ivars.m @@ -38,21 +38,21 @@ typedef signed char BOOL; } @end -// CHECK: @"{{.*}}" = private global [10 x i8] c"_boolean1 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean2 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean3 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean4 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean5 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean6 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean7 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean8 -// CHECK-NEXT: @"{{.*}}" = private global [10 x i8] c"_boolean9 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object1 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object2 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object3 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object4 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object5 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object6 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object7 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object8 -// CHECK-NEXT: @"{{.*}}" = private global [9 x i8] c"_object9 +// CHECK: @{{.*}} = private global [10 x i8] c"_boolean1 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean2 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean3 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean4 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean5 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean6 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean7 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean8 +// CHECK-NEXT: @{{.*}} = private global [10 x i8] c"_boolean9 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object1 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object2 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object3 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object4 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object5 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object6 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object7 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object8 +// CHECK-NEXT: @{{.*}} = private global [9 x i8] c"_object9 diff --git a/test/CodeGenObjC/selector-ref-invariance.m b/test/CodeGenObjC/selector-ref-invariance.m index e356419de9e8..599bc3aa4c97 100644 --- a/test/CodeGenObjC/selector-ref-invariance.m +++ b/test/CodeGenObjC/selector-ref-invariance.m @@ -3,7 +3,7 @@ // rdar://6027699 void test(id x) { -// CHECK: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", !invariant.load +// CHECK: load i8** @OBJC_SELECTOR_REFERENCES_, !invariant.load // CHECK: @objc_msgSend [x foo]; } diff --git a/test/CodeGenObjC/super-message-fragileabi.m b/test/CodeGenObjC/super-message-fragileabi.m index b6c908624ef6..2c917d7fd6d0 100644 --- a/test/CodeGenObjC/super-message-fragileabi.m +++ b/test/CodeGenObjC/super-message-fragileabi.m @@ -24,7 +24,7 @@ { ; } -// CHECK: load %struct._objc_class** getelementptr inbounds (%struct._objc_class* @"\01L_OBJC_CLASS_BetterTable", i32 0, i32 1) +// CHECK: load %struct._objc_class** getelementptr inbounds (%struct._objc_class* @OBJC_CLASS_BetterTable, i32 0, i32 1) return self; } diff --git a/test/CodeGenObjC/tentative-cfconstantstring.m b/test/CodeGenObjC/tentative-cfconstantstring.m index 714c1a402336..2b2601a54f8e 100644 --- a/test/CodeGenObjC/tentative-cfconstantstring.m +++ b/test/CodeGenObjC/tentative-cfconstantstring.m @@ -35,8 +35,8 @@ static inline void _inlineFunction() { // CHECK: @_unnamed_cfstring_{{.*}} = private constant %struct.NSConstantString { i32* getelementptr inbounds ([24 x i32]* @__CFConstantStringClassReference, i32 0, i32 0) // CHECK-LABEL: define internal void @_inlineFunction() -// CHECK: [[ZERO:%.*]] = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_ -// CHECK-NEXT: [[ONE:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" +// CHECK: [[ZERO:%.*]] = load %struct._class_t** @"OBJC_CLASSLIST_REFERENCES_ +// CHECK-NEXT: [[ONE:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[TWO:%.*]] = bitcast %struct._class_t* [[ZERO]] to i8* // CHECK-NEXT: call void (i8*, i8*, [[T:%.*]]*, ...)* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, [[T:%.*]]*, ...)*)(i8* [[TWO]], i8* [[ONE]], [[T:%.*]]* bitcast (%struct.NSConstantString* @_unnamed_cfstring_{{.*}} to [[T:%.*]]*)) // CHECK-NEXT: ret void diff --git a/test/CodeGenObjC/undefined-protocol2.m b/test/CodeGenObjC/undefined-protocol2.m new file mode 100644 index 000000000000..f171523b042c --- /dev/null +++ b/test/CodeGenObjC/undefined-protocol2.m @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx -emit-llvm %s -o - | FileCheck %s + +// Test that we produce a declaration for the protocol. It must be matched +// by a definition in another TU, so external is the correct linkage +// (not extern_weak). +// CHECK: @"\01l_OBJC_PROTOCOL_$_p1" = external global + +@interface NSObject +@end + +@protocol p1; + +@interface I1 : NSObject <p1> +@end + +@implementation I1 +@end diff --git a/test/CodeGenObjCXX/arc-cxx11-init-list.mm b/test/CodeGenObjCXX/arc-cxx11-init-list.mm new file mode 100644 index 000000000000..da214dc38ad2 --- /dev/null +++ b/test/CodeGenObjCXX/arc-cxx11-init-list.mm @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -triple armv7-ios5.0 -std=c++11 -fobjc-arc -Os -emit-llvm -o - %s | FileCheck %s + +typedef __SIZE_TYPE__ size_t; + +namespace std { +template <typename _Ep> +class initializer_list { + const _Ep* __begin_; + size_t __size_; + + initializer_list(const _Ep* __b, size_t __s); +}; +} + +@interface I ++ (instancetype) new; +@end + +void function(std::initializer_list<I *>); + +extern "C" void single() { function({ [I new] }); } + +// CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}}) +// CHECK-NEXT: [[CAST:%.*]] = bitcast [{{[0-9]+}} x %0*]* %{{.*}} to i8** +// CHECK-NEXT: store i8* [[INSTANCE]], i8** [[CAST]], +// CHECK: call void @objc_release(i8* {{.*}}) + +extern "C" void multiple() { function({ [I new], [I new] }); } + +// CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}}) +// CHECK-NEXT: [[CAST:%.*]] = bitcast [{{[0-9]+}} x %0*]* %{{.*}} to i8** +// CHECK-NEXT: store i8* [[INSTANCE]], i8** [[CAST]], +// CHECK: call void @objc_release(i8* {{.*}}) +// CHECK-NEXT: icmp eq + +void external(); + +extern "C" void extended() { + const auto && temporary = { [I new] }; + external(); +} + +// CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}}) +// CHECK-NEXT: [[CAST:%.*]] = bitcast [1 x %0*]* %{{.*}} to i8** +// CHECK-NEXT: store i8* [[INSTANCE]], i8** [[CAST]], +// CHECK: {{.*}} call void @_Z8externalv() +// CHECK: {{.*}} call void @objc_release(i8* {{.*}}) + +std::initializer_list<I *> il = { [I new] }; + +// CHECK: [[POOL:%.*]] = {{.*}} call i8* @objc_autoreleasePoolPush() +// CHECK: [[INSTANCE:%.*]] = {{.*}} call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* {{.*}}, i8* {{.*}}) +// CHECK-NEXT: store i8* [[INSTANCE]], i8** bitcast ([1 x %0*]* @_ZGR2il_ to i8**) +// CHECK: {{.*}} call void @objc_autoreleasePoolPop(i8* [[POOL]]) + diff --git a/test/CodeGenObjCXX/arc-cxx11-member-init.mm b/test/CodeGenObjCXX/arc-cxx11-member-init.mm index 213e7a1b7b50..5129f9faca4d 100644 --- a/test/CodeGenObjCXX/arc-cxx11-member-init.mm +++ b/test/CodeGenObjCXX/arc-cxx11-member-init.mm @@ -23,10 +23,23 @@ class XClipboardDataSet @end // CHECK: [[mClipData:%.*]] = getelementptr inbounds %class.XClipboardDataSet* -// CHECK: [[ZERO:%.*]] = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_" -// CHECK: [[ONE:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" +// CHECK: [[ZERO:%.*]] = load %struct._class_t** @"OBJC_CLASSLIST_REFERENCES_$_" +// CHECK: [[ONE:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK: [[TWO:%.*]] = bitcast %struct._class_t* [[ZERO]] to i8* // CHECK: [[CALL:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[TWO]], i8* [[ONE]]) // CHECK: [[THREE:%.*]] = bitcast i8* [[CALL]] to [[T:%.*]]* // CHECK: store [[T]]* [[THREE]], [[T]]** [[mClipData]], align 8 +// rdar://18950072 +struct Butt { }; + +__attribute__((objc_root_class)) +@interface Foo { + Butt x; + Butt y; + Butt z; +} +@end +@implementation Foo +@end +// CHECK-NOT: define internal i8* @"\01-[Foo .cxx_construct diff --git a/test/CodeGenObjCXX/arc-references.mm b/test/CodeGenObjCXX/arc-references.mm index 10e7f64198db..0acb6d5659b0 100644 --- a/test/CodeGenObjCXX/arc-references.mm +++ b/test/CodeGenObjCXX/arc-references.mm @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -O2 -disable-llvm-optzns -o - %s | FileCheck %s +// RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -O2 -disable-llvm-optzns -o - %s | FileCheck %s @interface A @end diff --git a/test/CodeGenObjCXX/arc.mm b/test/CodeGenObjCXX/arc.mm index e31b0943b75e..6b42a4ca48e5 100644 --- a/test/CodeGenObjCXX/arc.mm +++ b/test/CodeGenObjCXX/arc.mm @@ -203,7 +203,7 @@ template void test37<Test37>(Test37 *a); // CHECK-NEXT: [[COLL:%.*]] = bitcast i8* [[T2]] to [[NSARRAY]]* // Make sure it's not immediately released before starting the iteration. -// CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK-NEXT: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T0:%.*]] = bitcast [[NSARRAY]]* [[COLL]] to i8* // CHECK-NEXT: @objc_msgSend diff --git a/test/CodeGenObjCXX/block-id.mm b/test/CodeGenObjCXX/block-id.mm new file mode 100644 index 000000000000..e324841b37f2 --- /dev/null +++ b/test/CodeGenObjCXX/block-id.mm @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -emit-llvm -fblocks -o - -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 %s | FileCheck %s + +// N.B. This test verifies that two blocks which are otherwise +// indistinguishable receive distinct manglings. +// We had a bug where the first two blocks in the global block map could +// get the same unqualified-block mangling because the logic to handle +// block-ids believed it was handling Itanium-style discriminators. + +template<typename T> +int tf() { + return T::value; +} +int i1 = ^int { + struct S { enum { value = 1 };}; + // CHECK-DAG: @_Z2tfIZUb_E1SEiv + return tf<S>(); +}(); +int i2 = ^int(int p1) { + struct S { enum { value = 2 };}; + // CHECK-DAG: @_Z2tfIZUb0_E1SEiv + return tf<S>() + p1; +}(1); diff --git a/test/CodeGenObjCXX/debug-info-line.mm b/test/CodeGenObjCXX/debug-info-line.mm new file mode 100644 index 000000000000..4c934f120708 --- /dev/null +++ b/test/CodeGenObjCXX/debug-info-line.mm @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -gline-tables-only -fblocks -emit-llvm %s -o - | FileCheck %s + +void fn(); + +struct foo { + ~foo(); +}; + +void f1() { + ^{ + foo f; + fn(); + // CHECK: cleanup, !dbg [[DBG_F1:![0-9]*]] +#line 100 + }(); +} + +// CHECK-LABEL: define internal i8* @"\01-[TNSObject init]" +@implementation TNSObject +- (id)init +{ + foo f; + fn(); + // CHECK: cleanup, !dbg [[DBG_TNSO:![0-9]*]] +#line 200 +} +@end + +// CHECK: [[DBG_F1]] = !MDLocation(line: 100, +// CHECK: [[DBG_TNSO]] = !MDLocation(line: 200, diff --git a/test/CodeGenObjCXX/destroy.mm b/test/CodeGenObjCXX/destroy.mm new file mode 100644 index 000000000000..c53ac393de8f --- /dev/null +++ b/test/CodeGenObjCXX/destroy.mm @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-arc -disable-llvm-optzns -o - %s | FileCheck %s +// rdar://18249673 + +@class MyObject; +struct base { + ~base() = default; +}; +struct derived : public base { + MyObject *myobject; +}; + +void test1() { + derived d1; +} +// CHECK-LABEL: define void @_Z5test1v() +// CHECK: call void @_ZN7derivedC1Ev +// CHECK: call void @_ZN7derivedD1Ev + +void test2() { + derived *d2 = new derived; + delete d2; +} +// CHECK-LABEL: define void @_Z5test2v() +// CHECK: call void @_ZN7derivedC1Ev +// CHECK: call void @_ZN7derivedD1Ev + +template <typename T> +struct tderived : public base { + MyObject *myobject; +}; +void test3() { + tderived<int> d1; +} +// CHECK-LABEL: define void @_Z5test3v() +// CHECK: call void @_ZN8tderivedIiEC1Ev +// CHECK: call void @_ZN8tderivedIiED1Ev + +void test4() { + tderived<int> *d2 = new tderived<int>; + delete d2; +} +// CHECK-LABEL: define void @_Z5test4v() +// CHECK: call void @_ZN8tderivedIiEC1Ev +// CHECK: call void @_ZN8tderivedIiED1Ev + +// CHECK-LABEL: define linkonce_odr void @_ZN8tderivedIiED2Ev +// CHECK: call void @objc_storeStrong(i8** {{.*}}, i8* null) + +// CHECK-LABEL: define linkonce_odr void @_ZN7derivedD2Ev +// CHECK: call void @objc_storeStrong(i8** {{.*}}, i8* null) diff --git a/test/CodeGenObjCXX/externally-initialized-selectors.mm b/test/CodeGenObjCXX/externally-initialized-selectors.mm index 0b7c24eadd84..7dcd727e5724 100644 --- a/test/CodeGenObjCXX/externally-initialized-selectors.mm +++ b/test/CodeGenObjCXX/externally-initialized-selectors.mm @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fobjc-runtime=macosx-fragile-10.5 -o - -emit-llvm %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-llvm %s | FileCheck %s -// CHECK: @"\01L_OBJC_SELECTOR_REFERENCES_" = private externally_initialized global +// CHECK: @OBJC_SELECTOR_REFERENCES_ = private externally_initialized global void test(id x) { [x doSomething]; diff --git a/test/CodeGenObjCXX/lambda-expressions.mm b/test/CodeGenObjCXX/lambda-expressions.mm index 435f805237c4..9129ff091ed3 100644 --- a/test/CodeGenObjCXX/lambda-expressions.mm +++ b/test/CodeGenObjCXX/lambda-expressions.mm @@ -4,8 +4,8 @@ typedef int (^fp)(); fp f() { auto x = []{ return 3; }; return x; } -// MRC: @"\01L_OBJC_METH_VAR_NAME{{.*}}" = private global [5 x i8] c"copy\00" -// MRC: @"\01L_OBJC_METH_VAR_NAME{{.*}}" = private global [12 x i8] c"autorelease\00" +// MRC: @OBJC_METH_VAR_NAME{{.*}} = private global [5 x i8] c"copy\00" +// MRC: @OBJC_METH_VAR_NAME{{.*}} = private global [12 x i8] c"autorelease\00" // MRC-LABEL: define i32 ()* @_Z1fv( // MRC-LABEL: define internal i32 ()* @"_ZZ1fvENK3$_0cvU13block_pointerFivEEv" // MRC: store i8* bitcast (i8** @_NSConcreteStackBlock to i8*) diff --git a/test/CodeGenObjCXX/lvalue-reference-getter.mm b/test/CodeGenObjCXX/lvalue-reference-getter.mm index 5205a7c378ba..87c132080aa3 100644 --- a/test/CodeGenObjCXX/lvalue-reference-getter.mm +++ b/test/CodeGenObjCXX/lvalue-reference-getter.mm @@ -23,6 +23,6 @@ static SetSection gSetSection; // CHECK: [[SELF:%.*]] = alloca [[T6:%.*]]*, align // CHECK: [[T0:%.*]] = load {{.*}}* [[SELF]], align -// CHECK: [[T1:%.*]] = load {{.*}}* @"\01L_OBJC_SELECTOR_REFERENCES_" +// CHECK: [[T1:%.*]] = load {{.*}}* @OBJC_SELECTOR_REFERENCES_ // CHECK: [[C:%.*]] = call dereferenceable({{[0-9]+}}) %struct.SetSection* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend // CHECK: call dereferenceable({{[0-9]+}}) i32* @_ZN10SetSection2atEi(%struct.SetSection* [[C]] diff --git a/test/CodeGenObjCXX/mangle-blocks.mm b/test/CodeGenObjCXX/mangle-blocks.mm index 405e5282cda7..1f3f163adb4e 100644 --- a/test/CodeGenObjCXX/mangle-blocks.mm +++ b/test/CodeGenObjCXX/mangle-blocks.mm @@ -1,9 +1,8 @@ // RUN: %clang_cc1 -emit-llvm -fblocks -o - -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 %s | FileCheck %s -// CHECK: @_ZGVZZ3foovEUb_E5value = internal global i64 0 -// CHECK: @_ZZZN26externally_visible_statics1S3fooEiEd_Ub_E1k = linkonce_odr global i32 0 -// CHECK: @_ZZ26externally_visible_statics1S1xMUb_E1j = linkonce_odr global i32 0 -// CHECK: @_ZZZN26externally_visible_statics10inlinefuncEvEUb_E1i = linkonce_odr global i32 0 +// CHECK: @_ZZZN26externally_visible_statics1S3fooEiEd_Ub0_E1k = linkonce_odr global i32 0 +// CHECK: @_ZZ26externally_visible_statics1S1xMUb0_E1j = linkonce_odr global i32 0 +// CHECK: @_ZZZN26externally_visible_statics10inlinefuncEvEUb0_E1i = linkonce_odr global i32 0 int f(); @@ -27,7 +26,7 @@ int i = ^(int x) { return x;}(i); - (void)method { // CHECK: define internal signext i8 @"__11-[A method]_block_invoke" (void)^(int x) { - // CHECK: @"_ZZZ11-[A method]EUb0_E4name" + // CHECK: @"_ZZZ11-[A method]EUb1_E4name" static const char *name = "hello"; return name[x]; }; @@ -45,7 +44,7 @@ namespace N { // CHECK-LABEL: define internal signext i8 @___Z3fooi_block_invoke void bar() { (void)^(int x) { - // CHECK: @_ZZZN1N3barEvEUb2_E4name + // CHECK: @_ZZZN1N3barEvEUb3_E4name static const char *name = "hello"; return name[x]; }; @@ -57,7 +56,7 @@ class C { }; C::C() { (void)^(int x) { - // CHECK: @_ZZZN1CC1EvEUb3_E5nameb + // CHECK: @_ZZZN1CC1EvEUb4_E5nameb static const char *nameb = "hello"; return nameb[x]; }; diff --git a/test/CodeGenObjCXX/property-lvalue-capture.mm b/test/CodeGenObjCXX/property-lvalue-capture.mm index 690ffa96b52a..1242246b24b2 100644 --- a/test/CodeGenObjCXX/property-lvalue-capture.mm +++ b/test/CodeGenObjCXX/property-lvalue-capture.mm @@ -24,10 +24,10 @@ typedef Quad2<double> Quad2d; } @end -// CHECK: [[TWO:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", !invariant.load ![[MD_NUM:[0-9]+]] +// CHECK: [[TWO:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_, !invariant.load ![[MD_NUM:[0-9]+]] // CHECK: [[THREE:%.*]] = bitcast [[ONET:%.*]]* [[ONE:%.*]] to i8* // CHECK: [[CALL:%.*]] = call nonnull %struct.Quad2* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %struct.Quad2* (i8*, i8*)*)(i8* [[THREE]], i8* [[TWO]]) -// CHECK: [[FOUR:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_2", !invariant.load ![[MD_NUM]] +// CHECK: [[FOUR:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_2, !invariant.load ![[MD_NUM]] // CHECK: [[FIVE:%.*]] = bitcast [[ONET]]* [[ZERO:%.*]] to i8* // CHECK: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, %struct.Quad2*)*)(i8* [[FIVE]], i8* [[FOUR]], %struct.Quad2* nonnull [[CALL]]) @@ -47,7 +47,7 @@ void test(C *c, const A &a) { } // CHECK: [[ONE1:%.*]] = load %struct.A** [[AADDR:%.*]], align 8 -// CHECK: [[TWO1:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_5", !invariant.load ![[MD_NUM]] +// CHECK: [[TWO1:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_5, !invariant.load ![[MD_NUM]] // CHECK: [[THREE1:%.*]] = bitcast [[TWOT:%.*]]* [[ZERO1:%.*]] to i8* // CHECK: call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, %struct.A*)*)(i8* [[THREE1]], i8* [[TWO1]], %struct.A* dereferenceable({{[0-9]+}}) [[ONE1]]) // CHECK: store %struct.A* [[ONE1]], %struct.A** [[RESULT:%.*]], align 8 diff --git a/test/CodeGenObjCXX/property-object-reference.mm b/test/CodeGenObjCXX/property-object-reference.mm index ec311f1956a4..691e6fff8d84 100644 --- a/test/CodeGenObjCXX/property-object-reference.mm +++ b/test/CodeGenObjCXX/property-object-reference.mm @@ -25,11 +25,11 @@ static Foo gFoo; @end // CHECK: [[T0:%.*]] = load {{%.*}} [[S0:%.*]] -// CHECK: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK: [[T2:%.*]] = bitcast {{%.*}} [[T0]] to i8* // CHECK: @objc_msgSend // CHECK: [[R0:%.*]] = load {{%.*}} [[U0:%.*]] -// CHECK: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_ +// CHECK: load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK: [[R2:%.*]] = bitcast {{%.*}} [[R0]] to i8* // CHECK: @objc_msgSend diff --git a/test/CodeGenObjCXX/property-objects.mm b/test/CodeGenObjCXX/property-objects.mm index c79c280eddb1..73ed21dcb7d8 100644 --- a/test/CodeGenObjCXX/property-objects.mm +++ b/test/CodeGenObjCXX/property-objects.mm @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -g -o - | FileCheck %s class S { public: @@ -35,6 +35,11 @@ struct CGRect { // CHECK: call dereferenceable({{[0-9]+}}) %class.S* @_ZN1SaSERKS_ // CHECK-NEXT: ret void +// Don't attach debug locations to the prologue instructions. These were +// leaking over from the previous function emission by accident. +// CHECK: define internal void @"\01-[I setBounds:]" +// CHECK-NOT: !dbg +// CHECK: call void @llvm.dbg.declare - (void)setFrame:(CGRect)frameRect {} - (CGRect)frame {return bounds;} diff --git a/test/CodeGenObjCXX/subst-sel.mm b/test/CodeGenObjCXX/subst-sel.mm new file mode 100644 index 000000000000..f4a2b840fe70 --- /dev/null +++ b/test/CodeGenObjCXX/subst-sel.mm @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s + +// CHECK: @_Z4bad1P8NSObjectP13objc_selectorP11objc_objectS4_ +void bad1(struct NSObject *, SEL, id, id) {} diff --git a/test/CodeGenOpenCL/addr-space-struct-arg.cl b/test/CodeGenOpenCL/addr-space-struct-arg.cl index f04923d39c58..d711f78d4ef0 100644 --- a/test/CodeGenOpenCL/addr-space-struct-arg.cl +++ b/test/CodeGenOpenCL/addr-space-struct-arg.cl @@ -1,23 +1,23 @@ -// RUN: %clang_cc1 %s -emit-llvm -o - -O0 -ffake-address-space-map -triple i686-pc-darwin | FileCheck %s
-
-typedef struct {
- int cells[9];
-} Mat3X3;
-
-typedef struct {
- int cells[16];
-} Mat4X4;
-
-Mat4X4 __attribute__((noinline)) foo(Mat3X3 in) {
- Mat4X4 out;
- return out;
-}
-
-kernel void ker(global Mat3X3 *in, global Mat4X4 *out) {
- out[0] = foo(in[1]);
-}
-
-// Expect two mem copies: one for the argument "in", and one for
-// the return value.
-// CHECK: call void @llvm.memcpy.p0i8.p1i8.i32(i8*
-// CHECK: call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)*
+// RUN: %clang_cc1 %s -emit-llvm -o - -O0 -ffake-address-space-map -triple i686-pc-darwin | FileCheck %s + +typedef struct { + int cells[9]; +} Mat3X3; + +typedef struct { + int cells[16]; +} Mat4X4; + +Mat4X4 __attribute__((noinline)) foo(Mat3X3 in) { + Mat4X4 out; + return out; +} + +kernel void ker(global Mat3X3 *in, global Mat4X4 *out) { + out[0] = foo(in[1]); +} + +// Expect two mem copies: one for the argument "in", and one for +// the return value. +// CHECK: call void @llvm.memcpy.p0i8.p1i8.i32(i8* +// CHECK: call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* diff --git a/test/CodeGenOpenCL/address-space-constant-initializers.cl b/test/CodeGenOpenCL/address-space-constant-initializers.cl index ae8cedc1ca5b..079b0706f498 100644 --- a/test/CodeGenOpenCL/address-space-constant-initializers.cl +++ b/test/CodeGenOpenCL/address-space-constant-initializers.cl @@ -12,7 +12,7 @@ typedef struct { } ConstantArrayPointerStruct; // CHECK: %struct.ConstantArrayPointerStruct = type { float addrspace(3)* } -// CHECK: addrspace(3) global %struct.ConstantArrayPointerStruct { float addrspace(3)* bitcast (i8 addrspace(3)* getelementptr (i8 addrspace(3)* bitcast (%struct.ArrayStruct addrspace(3)* @constant_array_struct to i8 addrspace(3)*), i64 4) to float addrspace(3)*) } +// CHECK: addrspace(3) constant %struct.ConstantArrayPointerStruct { float addrspace(3)* bitcast (i8 addrspace(3)* getelementptr (i8 addrspace(3)* bitcast (%struct.ArrayStruct addrspace(3)* @constant_array_struct to i8 addrspace(3)*), i64 4) to float addrspace(3)*) } // Bug 18567 __constant ConstantArrayPointerStruct constant_array_pointer_struct = { &constant_array_struct.f diff --git a/test/CodeGenOpenCL/address-spaces-conversions.cl b/test/CodeGenOpenCL/address-spaces-conversions.cl new file mode 100644 index 000000000000..bc80f47f5f42 --- /dev/null +++ b/test/CodeGenOpenCL/address-spaces-conversions.cl @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s + +// test that we generate address space casts everywhere we need conversions of +// pointers to different address spaces + +void test(global int *arg_glob, generic int *arg_gen) { + int var_priv; + arg_gen = arg_glob; // implicit cast global -> generic + // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(4)* + arg_gen = &var_priv; // implicit cast with obtaining adr, private -> generic + // CHECK: %{{[0-9]+}} = addrspacecast i32* %var_priv to i32 addrspace(4)* + arg_glob = (global int *)arg_gen; // explicit cast + // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(4)* %{{[0-9]+}} to i32 addrspace(1)* + global int *var_glob = + (global int *)arg_glob; // explicit cast in the same address space + // CHECK-NOT: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(1)* + var_priv = arg_gen - arg_glob; // arithmetic operation + // CHECK: %{{.*}} = ptrtoint i32 addrspace(4)* %{{.*}} to i64 + // CHECK: %{{.*}} = ptrtoint i32 addrspace(1)* %{{.*}} to i64 + var_priv = arg_gen > arg_glob; // comparison + // CHECK: %{{[0-9]+}} = addrspacecast i32 addrspace(1)* %{{[0-9]+}} to i32 addrspace(4)* +} diff --git a/test/CodeGenOpenCL/amdgpu-num-gpr-attr.cl b/test/CodeGenOpenCL/amdgpu-num-gpr-attr.cl new file mode 100644 index 000000000000..35bdcead3128 --- /dev/null +++ b/test/CodeGenOpenCL/amdgpu-num-gpr-attr.cl @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu tahiti -O0 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O0 -emit-llvm -verify -o - %s | FileCheck -check-prefix=X86 %s + +// Make sure this is silently accepted on other targets. + +__attribute__((amdgpu_num_vgpr(64))) // expected-no-diagnostics +kernel void test_num_vgpr64() { +// CHECK: define void @test_num_vgpr64() [[ATTR_VGPR64:#[0-9]+]] +} + +__attribute__((amdgpu_num_sgpr(32))) // expected-no-diagnostics +kernel void test_num_sgpr32() { +// CHECK: define void @test_num_sgpr32() [[ATTR_SGPR32:#[0-9]+]] +} + +__attribute__((amdgpu_num_vgpr(64), amdgpu_num_sgpr(32))) // expected-no-diagnostics +kernel void test_num_vgpr64_sgpr32() { +// CHECK: define void @test_num_vgpr64_sgpr32() [[ATTR_VGPR64_SGPR32:#[0-9]+]] + +} + +__attribute__((amdgpu_num_sgpr(20), amdgpu_num_vgpr(40))) // expected-no-diagnostics +kernel void test_num_sgpr20_vgpr40() { +// CHECK: define void @test_num_sgpr20_vgpr40() [[ATTR_SGPR20_VGPR40:#[0-9]+]] +} + +__attribute__((amdgpu_num_vgpr(0))) // expected-no-diagnostics +kernel void test_num_vgpr0() { +} + +__attribute__((amdgpu_num_sgpr(0))) // expected-no-diagnostics +kernel void test_num_sgpr0() { +} + +__attribute__((amdgpu_num_vgpr(0), amdgpu_num_sgpr(0))) // expected-no-diagnostics +kernel void test_num_vgpr0_sgpr0() { +} + + +// X86-NOT: "amdgpu_num_vgpr" +// X86-NOT: "amdgpu_num_sgpr" + +// CHECK-DAG-NOT: "amdgpu_num_vgpr"="0" +// CHECK-DAG-NOT: "amdgpu_num_sgpr"="0" +// CHECK-DAG: attributes [[ATTR_VGPR64]] = { nounwind "amdgpu_num_vgpr"="64" +// CHECK-DAG: attributes [[ATTR_SGPR32]] = { nounwind "amdgpu_num_sgpr"="32" +// CHECK-DAG: attributes [[ATTR_VGPR64_SGPR32]] = { nounwind "amdgpu_num_sgpr"="32" "amdgpu_num_vgpr"="64" +// CHECK-DAG: attributes [[ATTR_SGPR20_VGPR40]] = { nounwind "amdgpu_num_sgpr"="20" "amdgpu_num_vgpr"="40" diff --git a/test/CodeGenOpenCL/builtins-r600.cl b/test/CodeGenOpenCL/builtins-r600.cl index cebeba185ea3..3e416b0323c2 100644 --- a/test/CodeGenOpenCL/builtins-r600.cl +++ b/test/CodeGenOpenCL/builtins-r600.cl @@ -1,5 +1,6 @@ // REQUIRES: r600-registered-target // RUN: %clang_cc1 -triple r600-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple amdgcn-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s #pragma OPENCL EXTENSION cl_khr_fp64 : enable @@ -31,16 +32,16 @@ void test_div_scale_f32(global float* out, global int* flagout, float a, float b // CHECK-LABEL: @test_div_fmas_f32 // CHECK: call float @llvm.AMDGPU.div.fmas.f32 -void test_div_fmas_f32(global float* out, float a, float b, float c) +void test_div_fmas_f32(global float* out, float a, float b, float c, int d) { - *out = __builtin_amdgpu_div_fmasf(a, b, c); + *out = __builtin_amdgpu_div_fmasf(a, b, c, d); } // CHECK-LABEL: @test_div_fmas_f64 // CHECK: call double @llvm.AMDGPU.div.fmas.f64 -void test_div_fmas_f64(global double* out, double a, double b, double c) +void test_div_fmas_f64(global double* out, double a, double b, double c, int d) { - *out = __builtin_amdgpu_div_fmas(a, b, c); + *out = __builtin_amdgpu_div_fmas(a, b, c, d); } // CHECK-LABEL: @test_div_fixup_f32 @@ -112,3 +113,31 @@ void test_rsq_clamped_f64(global double* out, double a) { *out = __builtin_amdgpu_rsq_clamped(a); } + +// CHECK-LABEL: @test_ldexp_f32 +// CHECK: call float @llvm.AMDGPU.ldexp.f32 +void test_ldexp_f32(global float* out, float a, int b) +{ + *out = __builtin_amdgpu_ldexpf(a, b); +} + +// CHECK-LABEL: @test_ldexp_f64 +// CHECK: call double @llvm.AMDGPU.ldexp.f64 +void test_ldexp_f64(global double* out, double a, int b) +{ + *out = __builtin_amdgpu_ldexp(a, b); +} + +// CHECK-LABEL: @test_class_f32 +// CHECK: call i1 @llvm.AMDGPU.class.f32 +void test_class_f32(global float* out, float a, int b) +{ + *out = __builtin_amdgpu_classf(a, b); +} + +// CHECK-LABEL: @test_class_f64 +// CHECK: call i1 @llvm.AMDGPU.class.f64 +void test_class_f64(global double* out, double a, int b) +{ + *out = __builtin_amdgpu_class(a, b); +} diff --git a/test/CodeGenOpenCL/const-str-array-decay.cl b/test/CodeGenOpenCL/const-str-array-decay.cl new file mode 100644 index 000000000000..dbbe08989cb1 --- /dev/null +++ b/test/CodeGenOpenCL/const-str-array-decay.cl @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -ffake-address-space-map | FileCheck %s + +int test_func(constant char* foo); + +kernel void str_array_decy() { + test_func("Test string literal"); +} + +// CHECK: i8 addrspace(3)* getelementptr inbounds ([20 x i8] addrspace(3)* +// CHECK-NOT: addrspacecast + diff --git a/test/CodeGenOpenCL/constant-addr-space-globals.cl b/test/CodeGenOpenCL/constant-addr-space-globals.cl new file mode 100644 index 000000000000..92fb9790b5fb --- /dev/null +++ b/test/CodeGenOpenCL/constant-addr-space-globals.cl @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -ffake-address-space-map -emit-llvm -o - | FileCheck %s + +// CHECK: @array = addrspace({{[0-9]+}}) constant +__constant float array[2] = {0.0f, 1.0f}; + +kernel void test(global float *out) { + *out = array[0]; +} diff --git a/test/CodeGenOpenCL/denorms-are-zero.cl b/test/CodeGenOpenCL/denorms-are-zero.cl new file mode 100644 index 000000000000..488004fa4fc3 --- /dev/null +++ b/test/CodeGenOpenCL/denorms-are-zero.cl @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -S -cl-denorms-are-zero -o - %s 2>&1 + +// This test just checks that the -cl-denorms-are-zero argument is accepted +// by clang. This option is currently a no-op, which is allowed by the +// OpenCL specification. diff --git a/test/CodeGenOpenCL/fpmath.cl b/test/CodeGenOpenCL/fpmath.cl index 704fcd739ac4..ef4da845529c 100644 --- a/test/CodeGenOpenCL/fpmath.cl +++ b/test/CodeGenOpenCL/fpmath.cl @@ -22,4 +22,4 @@ double dpscalardiv(double a, double b) { return a / b; } -// CHECK: ![[MD]] = metadata !{float 2.500000e+00} +// CHECK: ![[MD]] = !{float 2.500000e+00} diff --git a/test/CodeGenOpenCL/kernel-arg-info.cl b/test/CodeGenOpenCL/kernel-arg-info.cl index 9832604b0459..4bc191e1d75f 100644 --- a/test/CodeGenOpenCL/kernel-arg-info.cl +++ b/test/CodeGenOpenCL/kernel-arg-info.cl @@ -1,28 +1,55 @@ -// RUN: %clang_cc1 %s -cl-kernel-arg-info -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s +// RUN: %clang_cc1 %s -cl-kernel-arg-info -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s -check-prefix ARGINFO +// RUN: %clang_cc1 %s -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s -check-prefix NO-ARGINFO kernel void foo(__global int * restrict X, const int Y, volatile int anotherArg, __constant float * restrict Z) { *X = Y + anotherArg; } -// CHECK: metadata !{metadata !"kernel_arg_addr_space", i32 1, i32 0, i32 0, i32 2} -// CHECK: metadata !{metadata !"kernel_arg_access_qual", metadata !"none", metadata !"none", metadata !"none", metadata !"none"} -// CHECK: metadata !{metadata !"kernel_arg_type", metadata !"int*", metadata !"int", metadata !"int", metadata !"float*"} -// CHECK: metadata !{metadata !"kernel_arg_type_qual", metadata !"restrict", metadata !"const", metadata !"volatile", metadata !"restrict const"} -// CHECK: metadata !{metadata !"kernel_arg_name", metadata !"X", metadata !"Y", metadata !"anotherArg", metadata !"Z"} +// CHECK: !{!"kernel_arg_addr_space", i32 1, i32 0, i32 0, i32 2} +// CHECK: !{!"kernel_arg_access_qual", !"none", !"none", !"none", !"none"} +// CHECK: !{!"kernel_arg_type", !"int*", !"int", !"int", !"float*"} +// CHECK: !{!"kernel_arg_base_type", !"int*", !"int", !"int", !"float*"} +// CHECK: !{!"kernel_arg_type_qual", !"restrict", !"const", !"volatile", !"restrict const"} +// ARGINFO: !{!"kernel_arg_name", !"X", !"Y", !"anotherArg", !"Z"} +// NO-ARGINFO-NOT: !{!"kernel_arg_name", !"X", !"Y", !"anotherArg", !"Z"} kernel void foo2(read_only image1d_t img1, image2d_t img2, write_only image2d_array_t img3) { } -// CHECK: metadata !{metadata !"kernel_arg_addr_space", i32 1, i32 1, i32 1} -// CHECK: metadata !{metadata !"kernel_arg_access_qual", metadata !"read_only", metadata !"read_only", metadata !"write_only"} -// CHECK: metadata !{metadata !"kernel_arg_type", metadata !"image1d_t", metadata !"image2d_t", metadata !"image2d_array_t"} -// CHECK: metadata !{metadata !"kernel_arg_type_qual", metadata !"", metadata !"", metadata !""} -// CHECK: metadata !{metadata !"kernel_arg_name", metadata !"img1", metadata !"img2", metadata !"img3"} +// CHECK: !{!"kernel_arg_addr_space", i32 1, i32 1, i32 1} +// CHECK: !{!"kernel_arg_access_qual", !"read_only", !"read_only", !"write_only"} +// CHECK: !{!"kernel_arg_type", !"image1d_t", !"image2d_t", !"image2d_array_t"} +// CHECK: !{!"kernel_arg_base_type", !"image1d_t", !"image2d_t", !"image2d_array_t"} +// CHECK: !{!"kernel_arg_type_qual", !"", !"", !""} +// ARGINFO: !{!"kernel_arg_name", !"img1", !"img2", !"img3"} +// NO-ARGINFO-NOT: !{!"kernel_arg_name", !"img1", !"img2", !"img3"} kernel void foo3(__global half * X) { } -// CHECK: metadata !{metadata !"kernel_arg_addr_space", i32 1} -// CHECK: metadata !{metadata !"kernel_arg_access_qual", metadata !"none"} -// CHECK: metadata !{metadata !"kernel_arg_type", metadata !"half*"} -// CHECK: metadata !{metadata !"kernel_arg_type_qual", metadata !""} -// CHECK: metadata !{metadata !"kernel_arg_name", metadata !"X"} +// CHECK: !{!"kernel_arg_addr_space", i32 1} +// CHECK: !{!"kernel_arg_access_qual", !"none"} +// CHECK: !{!"kernel_arg_type", !"half*"} +// CHECK: !{!"kernel_arg_base_type", !"half*"} +// CHECK: !{!"kernel_arg_type_qual", !""} +// ARGINFO: !{!"kernel_arg_name", !"X"} +// NO-ARGINFO-NOT: !{!"kernel_arg_name", !"X"} + +typedef unsigned int myunsignedint; +kernel void foo4(__global unsigned int * X, __global myunsignedint * Y) { +} +// CHECK: !{!"kernel_arg_addr_space", i32 1, i32 1} +// CHECK: !{!"kernel_arg_access_qual", !"none", !"none"} +// CHECK: !{!"kernel_arg_type", !"uint*", !"myunsignedint*"} +// CHECK: !{!"kernel_arg_base_type", !"uint*", !"uint*"} +// CHECK: !{!"kernel_arg_type_qual", !"", !""} +// ARGINFO: !{!"kernel_arg_name", !"X", !"Y"} +// NO-ARGINFO-NOT: !{!"kernel_arg_name", !"X", !"Y"} + +typedef image1d_t myImage; +kernel void foo5(read_only myImage img1, write_only image1d_t img2) { +} +// CHECK: !{!"kernel_arg_access_qual", !"read_only", !"write_only"} +// CHECK: !{!"kernel_arg_type", !"myImage", !"image1d_t"} +// CHECK: !{!"kernel_arg_base_type", !"image1d_t", !"image1d_t"} +// ARGINFO: !{!"kernel_arg_name", !"img1", !"img2"} +// NO-ARGINFO-NOT: !{!"kernel_arg_name", !"img1", !"img2"} diff --git a/test/CodeGenOpenCL/kernel-attributes.cl b/test/CodeGenOpenCL/kernel-attributes.cl index 0825ffc0336f..8f22d611b820 100644 --- a/test/CodeGenOpenCL/kernel-attributes.cl +++ b/test/CodeGenOpenCL/kernel-attributes.cl @@ -8,9 +8,9 @@ kernel __attribute__((vec_type_hint(uint4))) __attribute__((work_group_size_hint // CHECK: opencl.kernels = !{[[MDNODE0:![0-9]+]], [[MDNODE3:![0-9]+]]} -// CHECK: [[MDNODE0]] = metadata !{void (i32)* @kernel1, metadata [[MDNODE1:![0-9]+]], metadata [[MDNODE2:![0-9]+]]} -// CHECK: [[MDNODE1]] = metadata !{metadata !"vec_type_hint", i32 undef, i32 1} -// CHECK: [[MDNODE2]] = metadata !{metadata !"reqd_work_group_size", i32 1, i32 2, i32 4} -// CHECK: [[MDNODE3]] = metadata !{void (i32)* @kernel2, metadata [[MDNODE4:![0-9]+]], metadata [[MDNODE5:![0-9]+]]} -// CHECK: [[MDNODE4]] = metadata !{metadata !"vec_type_hint", <4 x i32> undef, i32 0} -// CHECK: [[MDNODE5]] = metadata !{metadata !"work_group_size_hint", i32 8, i32 16, i32 32} +// CHECK: [[MDNODE0]] = !{void (i32)* @kernel1, {{.*}} [[MDNODE1:![0-9]+]], [[MDNODE2:![0-9]+]]} +// CHECK: [[MDNODE1]] = !{!"vec_type_hint", i32 undef, i32 1} +// CHECK: [[MDNODE2]] = !{!"reqd_work_group_size", i32 1, i32 2, i32 4} +// CHECK: [[MDNODE3]] = !{void (i32)* @kernel2, {{.*}} [[MDNODE4:![0-9]+]], [[MDNODE5:![0-9]+]]} +// CHECK: [[MDNODE4]] = !{!"vec_type_hint", <4 x i32> undef, i32 0} +// CHECK: [[MDNODE5]] = !{!"work_group_size_hint", i32 8, i32 16, i32 32} diff --git a/test/CodeGenOpenCL/kernel-metadata.cl b/test/CodeGenOpenCL/kernel-metadata.cl index 3e10a119d044..ef3758fccaa0 100644 --- a/test/CodeGenOpenCL/kernel-metadata.cl +++ b/test/CodeGenOpenCL/kernel-metadata.cl @@ -7,4 +7,9 @@ __kernel void kernel_function() { } // CHECK: !opencl.kernels = !{!0} -// CHECK: !0 = metadata !{void ()* @kernel_function} +// CHECK: !0 = !{void ()* @kernel_function, !1, !2, !3, !4, !5} +// CHECK: !1 = !{!"kernel_arg_addr_space"} +// CHECK: !2 = !{!"kernel_arg_access_qual"} +// CHECK: !3 = !{!"kernel_arg_type"} +// CHECK: !4 = !{!"kernel_arg_base_type"} +// CHECK: !5 = !{!"kernel_arg_type_qual"} diff --git a/test/CodeGenOpenCL/local-initializer-undef.cl b/test/CodeGenOpenCL/local-initializer-undef.cl new file mode 100644 index 000000000000..5d34f56b821d --- /dev/null +++ b/test/CodeGenOpenCL/local-initializer-undef.cl @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 %s -O0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s + +typedef struct Foo { + int x; + float y; + float z; +} Foo; + +// CHECK-DAG: @test.lds_int = internal addrspace(2) global i32 undef +// CHECK-DAG: @test.lds_int_arr = internal addrspace(2) global [128 x i32] undef +// CHECK-DAG: @test.lds_struct = internal addrspace(2) global %struct.Foo undef +// CHECK-DAG: @test.lds_struct_arr = internal addrspace(2) global [64 x %struct.Foo] undef +__kernel void test() +{ + __local int lds_int; + __local int lds_int_arr[128]; + __local Foo lds_struct; + __local Foo lds_struct_arr[64]; + + lds_int = 1; + lds_int_arr[0] = 1; + lds_struct.x = 1; + lds_struct_arr[0].x = 1; +} diff --git a/test/CodeGenOpenCL/local.cl b/test/CodeGenOpenCL/local.cl index 895c8fa2717d..f1031cdfd84e 100644 --- a/test/CodeGenOpenCL/local.cl +++ b/test/CodeGenOpenCL/local.cl @@ -1,9 +1,11 @@ // RUN: %clang_cc1 %s -ffake-address-space-map -faddress-space-map-mangling=no -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s +void func(local int*); + __kernel void foo(void) { - // CHECK: @foo.i = internal unnamed_addr addrspace(2) + // CHECK: @foo.i = internal addrspace(2) global i32 undef __local int i; - ++i; + func(&i); } // CHECK-LABEL: define void @_Z3barPU7CLlocali diff --git a/test/CodeGenOpenCL/opencl_types.cl b/test/CodeGenOpenCL/opencl_types.cl index 7e99fc548ec5..71d1189e5f08 100644 --- a/test/CodeGenOpenCL/opencl_types.cl +++ b/test/CodeGenOpenCL/opencl_types.cl @@ -1,7 +1,7 @@ // RUN: %clang_cc1 %s -emit-llvm -o - -O0 | FileCheck %s constant sampler_t glb_smp = 7; -// CHECK: global i32 7 +// CHECK: constant i32 7 void fnc1(image1d_t img) {} // CHECK: @fnc1(%opencl.image1d_t* @@ -35,3 +35,6 @@ kernel void foo(image1d_t img) { fnc4smp(glb_smp); // CHECK: call void @fnc4smp(i32 } + +void __attribute__((overloadable)) bad1(image1d_t *b, image2d_t *c, image2d_t *d) {} +// CHECK-LABEL: @{{_Z4bad1P11ocl_image1dP11ocl_image2dS2_|"\\01\?bad1@@YAXPE?APAUocl_image1d@@PE?APAUocl_image2d@@1@Z"}} diff --git a/test/CodeGenOpenCL/ptx-calls.cl b/test/CodeGenOpenCL/ptx-calls.cl index 00f2a0e4c042..bde00bc3d73a 100644 --- a/test/CodeGenOpenCL/ptx-calls.cl +++ b/test/CodeGenOpenCL/ptx-calls.cl @@ -9,5 +9,5 @@ __kernel void kernel_function() { } // CHECK-LABEL: define void @kernel_function() // CHECK: call void @device_function() -// CHECK: !{{[0-9]+}} = metadata !{void ()* @kernel_function, metadata !"kernel", i32 1} +// CHECK: !{{[0-9]+}} = !{void ()* @kernel_function, !"kernel", i32 1} diff --git a/test/CodeGenOpenCL/ptx-kernels.cl b/test/CodeGenOpenCL/ptx-kernels.cl index 49d207f023c8..fc6de4f3d517 100644 --- a/test/CodeGenOpenCL/ptx-kernels.cl +++ b/test/CodeGenOpenCL/ptx-kernels.cl @@ -8,4 +8,4 @@ __kernel void kernel_function() { } // CHECK-LABEL: define void @kernel_function() -// CHECK: !{{[0-9]+}} = metadata !{void ()* @kernel_function, metadata !"kernel", i32 1} +// CHECK: !{{[0-9]+}} = !{void ()* @kernel_function, !"kernel", i32 1} diff --git a/test/CodeGenOpenCL/relaxed-fpmath.cl b/test/CodeGenOpenCL/relaxed-fpmath.cl new file mode 100644 index 000000000000..4222ea9c74b5 --- /dev/null +++ b/test/CodeGenOpenCL/relaxed-fpmath.cl @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -check-prefix=NORMAL +// RUN: %clang_cc1 %s -emit-llvm -cl-fast-relaxed-math -o - | FileCheck %s -check-prefix=FAST +// RUN: %clang_cc1 %s -emit-llvm -cl-finite-math-only -o - | FileCheck %s -check-prefix=FINITE +// RUN: %clang_cc1 %s -emit-llvm -cl-unsafe-math-optimizations -o - | FileCheck %s -check-prefix=UNSAFE +// RUN: %clang_cc1 %s -emit-llvm -cl-no-signed-zeros -o - | FileCheck %s -check-prefix=NOSZ + +typedef __attribute__(( ext_vector_type(4) )) float float4; + +float spscalardiv(float a, float b) { + // CHECK: @spscalardiv( + + // NORMAL: fdiv float + // FAST: fdiv fast float + // FINITE: fdiv nnan ninf float + // UNSAFE: fdiv nnan float + // NOSZ: fdiv nsz float + return a / b; +} +// CHECK: attributes + +// NORMAL: "no-infs-fp-math"="false" +// NORMAL: "no-nans-fp-math"="false" +// NORMAL: "unsafe-fp-math"="false" + +// FAST: "no-infs-fp-math"="true" +// FAST: "no-nans-fp-math"="true" +// FAST: "unsafe-fp-math"="true" + +// FINITE: "no-infs-fp-math"="true" +// FINITE: "no-nans-fp-math"="true" +// FINITE: "unsafe-fp-math"="false" + +// UNSAFE: "no-infs-fp-math"="false" +// UNSAFE: "no-nans-fp-math"="true" +// UNSAFE: "unsafe-fp-math"="true" + diff --git a/test/CodeGenOpenCL/str_literals.cl b/test/CodeGenOpenCL/str_literals.cl index 43c90f83f6e7..092b6372a414 100644 --- a/test/CodeGenOpenCL/str_literals.cl +++ b/test/CodeGenOpenCL/str_literals.cl @@ -5,5 +5,5 @@ __constant char * __constant y = "hello world"; // CHECK: unnamed_addr addrspace(3) constant // CHECK-NOT: addrspace(3) unnamed_addr constant -// CHECK: @x = addrspace(3) global i8 addrspace(3)* -// CHECK: @y = addrspace(3) global i8 addrspace(3)* +// CHECK: @x = addrspace(3) constant i8 addrspace(3)* +// CHECK: @y = addrspace(3) constant i8 addrspace(3)* diff --git a/test/Coverage/html-diagnostics.c b/test/Coverage/html-diagnostics.c index c7489f82dd7c..045943ae8b11 100644 --- a/test/Coverage/html-diagnostics.c +++ b/test/Coverage/html-diagnostics.c @@ -1,12 +1,9 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -analyze -analyzer-output=html -analyzer-checker=core -o %t %s -// RUN: cat %t/*.html | FileCheck %s +// RUN: find %t -name "*.html" -exec cat "{}" ";" | FileCheck %s // REQUIRES: staticanalyzer -// Because of the glob (*.html) -// REQUIRES: shell - // CHECK: <h3>Annotated Source Code</h3> // Without tweaking expr, the expr would hit to the line below diff --git a/test/CoverageMapping/Inputs/code.h b/test/CoverageMapping/Inputs/code.h new file mode 100644 index 000000000000..cd3cfb5d3fed --- /dev/null +++ b/test/CoverageMapping/Inputs/code.h @@ -0,0 +1,11 @@ +x = x; +if (x == 0) { + x = 1; +} else { + x = 2; +} +if (true) { + x = x; +} else { + x = x; +} diff --git a/test/CoverageMapping/Inputs/header1.h b/test/CoverageMapping/Inputs/header1.h new file mode 100644 index 000000000000..d01e813b40b3 --- /dev/null +++ b/test/CoverageMapping/Inputs/header1.h @@ -0,0 +1,31 @@ +#ifndef HEADER1_H +#define HEADER1_H + +inline void func(int i) { + int x = 0; + if (i == 0) { + x = 1; + } else { + x = 2; + } +} +static void static_func(int j) { + int x = 0; + if (j == x) { + x = !j; + } else { + x = 42; + } + j = x * j; +} +static void static_func2(int j) { + int x = 0; + if (j == x) { + x = !j; + } else { + x = 42; + } + j = x * j; +} + +#endif // HEADER1_H diff --git a/test/CoverageMapping/break.c b/test/CoverageMapping/break.c new file mode 100644 index 000000000000..f5a0af5097bb --- /dev/null +++ b/test/CoverageMapping/break.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name break.c %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+28]]:2 = #0 (HasCodeBefore = 0) + int cnt = 0; // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = #0 (HasCodeBefore = 0) + while(cnt < 100) { // CHECK-NEXT: File 0, [[@LINE]]:20 -> [[@LINE+3]]:4 = #1 (HasCodeBefore = 0) + break; + ++cnt; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:10 = 0 (HasCodeBefore = 0) + } // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = #0 (HasCodeBefore = 0) + while(cnt < 100) { // CHECK-NEXT: File 0, [[@LINE]]:20 -> [[@LINE+6]]:4 = #2 (HasCodeBefore = 0) + { + break; + ++cnt; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE+2]]:10 = 0 (HasCodeBefore = 0) + } + ++cnt; + } // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = ((#0 + #3) - #4) (HasCodeBefore = 0) + while(cnt < 100) { // CHECK-NEXT: File 0, [[@LINE]]:20 -> [[@LINE+6]]:4 = #3 (HasCodeBefore = 0) + if(cnt == 0) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+3]]:6 = #4 (HasCodeBefore = 0) + break; + ++cnt; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:12 = 0 (HasCodeBefore = 0) + } + ++cnt; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:10 = (#3 - #4) (HasCodeBefore = 0) + } // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = (#0 + #6) (HasCodeBefore = 0) + while(cnt < 100) { // CHECK-NEXT: File 0, [[@LINE]]:20 -> [[@LINE+7]]:4 = #5 (HasCodeBefore = 0) + if(cnt == 0) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+5]]:10 = #6 (HasCodeBefore = 0) + ++cnt; + } else { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+2]]:6 = (#5 - #6) (HasCodeBefore = 0) + break; + } + ++cnt; + } +} diff --git a/test/CoverageMapping/builtinmacro.c b/test/CoverageMapping/builtinmacro.c new file mode 100644 index 000000000000..a023abc62a40 --- /dev/null +++ b/test/CoverageMapping/builtinmacro.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name builtinmacro.c %s | FileCheck %s + +// Test the coverage mapping generation for built-in macroes. + +// CHECK: filename +const char *filename (const char *name) { // CHECK-NEXT: File 0, [[@LINE]]:41 -> [[@LINE+3]]:2 = #0 (HasCodeBefore = 0) + static const char this_file[] = __FILE__; + return this_file; +} + +int main() { // CHECK-NEXT: main + filename(__FILE__ "test.c"); + return 0; +} diff --git a/test/CoverageMapping/casts.c b/test/CoverageMapping/casts.c new file mode 100644 index 000000000000..94c13dc13cb8 --- /dev/null +++ b/test/CoverageMapping/casts.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name casts.c %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:41 -> [[@LINE+1]]:54 = #1 (HasCodeBefore = 0) + int window_size = (sizeof(int) <= 2 ? (unsigned)512 : 1024); // CHECK-NEXT: File 0, [[@LINE]]:57 -> [[@LINE]]:61 = (#0 - #1) (HasCodeBefore = 0) + return 0; +} + + + + diff --git a/test/CoverageMapping/classtemplate.cpp b/test/CoverageMapping/classtemplate.cpp new file mode 100644 index 000000000000..6062266fd47d --- /dev/null +++ b/test/CoverageMapping/classtemplate.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -triple %itanium_abi_triple -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name classtemplate.cpp %s > %tmapping +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-CONSTRUCTOR +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-GETTER +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-SETTER + +template<class TT> +class Test { +public: + enum BaseType { + A, C, G, T, Invalid + }; + const static int BaseCount = 4; + double bases[BaseCount]; + + // CHECK-CONSTRUCTOR: _ZN4TestIjEC + Test() { } // CHECK-CONSTRUCTOR: File 0, [[@LINE]]:10 -> [[@LINE]]:13 = #0 (HasCodeBefore = 0) + + // FIXME: It would be nice to emit no-coverage for get, but trying to do this + // runs afoul of cases like Test3::unmangleable below. + // FIXME-GETTER: _ZNK4TestIjE3get + double get(TT position) const { // FIXME-GETTER: File 0, [[@LINE]]:33 -> [[@LINE+2]]:4 = 0 (HasCodeBefore = 0) + return bases[position]; + } + // CHECK-SETTER: _ZN4TestIjE3set + void set(TT position, double value) { // CHECK-SETTER: File 0, [[@LINE]]:39 -> [[@LINE+2]]:4 = #0 (HasCodeBefore = 0) + bases[position] = value; + } +}; + +class Test2 { + // CHECK-CONSTRUCTOR: _ZN5Test2C + Test2() { } // CHECK-CONSTRUCTOR: File 0, [[@LINE]]:11 -> [[@LINE]]:14 = 0 (HasCodeBefore = 0) + // CHECK-GETTER: _ZNK5Test23get + double get(unsigned position) const { // CHECK-GETTER: File 0, [[@LINE]]:39 -> [[@LINE+2]]:4 = 0 (HasCodeBefore = 0) + return 0.0; + } +}; + +// Test3::unmangleable can't be mangled, since there isn't a complete type for +// the __is_final type trait expression. This would cause errors if we try to +// emit a no-coverage mapping for the method. +template <class T, bool = __is_final(T)> class UninstantiatedClassWithTraits {}; +template <class T> class Test3 { + void unmangleable(UninstantiatedClassWithTraits<T> x) {} +}; + +int main() { + Test<unsigned> t; + t.set(Test<unsigned>::A, 5.5); + t.set(Test<unsigned>::T, 5.6); + t.set(Test<unsigned>::G, 5.7); + t.set(Test<unsigned>::C, 5.8); + return 0; +} diff --git a/test/CoverageMapping/continue.c b/test/CoverageMapping/continue.c new file mode 100644 index 000000000000..b56b164d4a3f --- /dev/null +++ b/test/CoverageMapping/continue.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name continue.c %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+21]]:2 = #0 (HasCodeBefore = 0) + int j = 0; // CHECK-NEXT: File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = (#0 + #1) (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:26 -> [[@LINE+1]]:29 = #1 (HasCodeBefore = 0) + for(int i = 0; i < 20; ++i) { // CHECK-NEXT: File 0, [[@LINE]]:31 -> [[@LINE+17]]:4 = #1 (HasCodeBefore = 0) + if(i < 10) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+13]]:6 = #2 (HasCodeBefore = 0) + if(i < 5) { // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+3]]:8 = #3 (HasCodeBefore = 0) + continue; + j = 1; // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:14 = 0 (HasCodeBefore = 0) + } else { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+7]]:13 = (#2 - #3) (HasCodeBefore = 0) + j = 2; + } + j = 3; + if(i < 7) { // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+3]]:8 = #4 (HasCodeBefore = 0) + continue; + j = 4; // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:14 = 0 (HasCodeBefore = 0) + } else j = 5; // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+1]]:12 = ((#2 - #3) - #4) (HasCodeBefore = 0) + j = 6; + } else // CHECK-NEXT: File 0, [[@LINE+1]]:7 -> [[@LINE+1]]:12 = (#1 - #2) (HasCodeBefore = 0) + j = 7; + j = 8; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:10 = ((#1 - #3) - #4) (HasCodeBefore = 0) + } +} diff --git a/test/CoverageMapping/header.cpp b/test/CoverageMapping/header.cpp new file mode 100644 index 000000000000..c268191d2237 --- /dev/null +++ b/test/CoverageMapping/header.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name tu1.cpp %s > %tmapping +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-FUNC +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-STATIC-FUNC +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-STATIC-FUNC2 + +#include "Inputs/header1.h" + +int main() { + func(1); + static_func(2); +} + +// CHECK-FUNC: func +// CHECK-FUNC: File 0, 4:25 -> 11:2 = #0 (HasCodeBefore = 0) +// CHECK-FUNC: File 0, 6:15 -> 8:4 = #1 (HasCodeBefore = 0) +// CHECK-FUNC: File 0, 8:10 -> 10:4 = (#0 - #1) (HasCodeBefore = 0) +// CHECK-FUNC: Expansion,File 1, 6:10 -> 6:28 = #0 (HasCodeBefore = 0, Expanded file = 0) + +// CHECK-STATIC-FUNC: static_func +// CHECK-STATIC-FUNC: File 0, 12:32 -> 20:2 = #0 (HasCodeBefore = 0) +// CHECK-STATIC-FUNC: File 0, 14:15 -> 16:4 = #1 (HasCodeBefore = 0) +// CHECK-STATIC-FUNC: File 0, 16:10 -> 18:4 = (#0 - #1) (HasCodeBefore = 0) +// CHECK-STATIC-FUNC: Expansion,File 1, 6:10 -> 6:28 = #0 (HasCodeBefore = 0, Expanded file = 0) + +// CHECK-STATIC-FUNC2: static_func2 +// CHECK-STATIC-FUNC2: File 0, 21:33 -> 29:2 = 0 (HasCodeBefore = 0) +// CHECK-STATIC-FUNC2: Expansion,File 1, 6:10 -> 6:28 = 0 (HasCodeBefore = 0, Expanded file = 0) diff --git a/test/CoverageMapping/if.c b/test/CoverageMapping/if.c new file mode 100644 index 000000000000..4767b4039b3e --- /dev/null +++ b/test/CoverageMapping/if.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name if.c %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+21]]:2 = #0 (HasCodeBefore = 0) + int i = 0; + if(i == 0) i = 1; // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE]]:19 = #1 (HasCodeBefore = 0) + if(i == 1) + i = 2; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:10 = #2 (HasCodeBefore = 0) + if(i == 0) { i = 1; // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+2]]:4 = #3 (HasCodeBefore = 0) + i = 2; + } + if(i != 0) { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+2]]:4 = #4 (HasCodeBefore = 0) + i = 1; + } else { // CHECK-NEXT: File 0, [[@LINE]]:10 -> [[@LINE+2]]:4 = (#0 - #4) (HasCodeBefore = 0) + i = 3; + } + + i = i == 0? + i + 1 : // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:14 = #5 (HasCodeBefore = 0) + i + 2; // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:14 = (#0 - #5) (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:14 -> [[@LINE+1]]:20 = #6 (HasCodeBefore = 0) + i = i == 0?i + 12:i + 10; // CHECK-NEXT: File 0, [[@LINE]]:21 -> [[@LINE]]:27 = (#0 - #6) (HasCodeBefore = 0) + + return 0; +} diff --git a/test/CoverageMapping/includehell.cpp b/test/CoverageMapping/includehell.cpp new file mode 100644 index 000000000000..653f41464db0 --- /dev/null +++ b/test/CoverageMapping/includehell.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name includehell.cpp %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + int x = 0; + #include "Inputs/code.h" // CHECK-NEXT: Expansion,File 0, [[@LINE]]:12 -> [[@LINE]]:27 = #0 (HasCodeBefore = 0, Expanded file = 1) + return 0; +} +// CHECK-NEXT: File 1, 1:1 -> 9:7 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 2:13 -> 4:2 = #1 (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 4:8 -> 6:2 = (#0 - #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 7:11 -> 9:2 = #2 (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 9:8 -> 11:2 = (#0 - #2) (HasCodeBefore = 0) diff --git a/test/CoverageMapping/ir.c b/test/CoverageMapping/ir.c new file mode 100644 index 000000000000..a1cb57020f9a --- /dev/null +++ b/test/CoverageMapping/ir.c @@ -0,0 +1,12 @@ +// Check the data structures emitted by coverage mapping +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name ir.c %s -o - -emit-llvm -fprofile-instr-generate -fcoverage-mapping | FileCheck %s + + +void foo(void) { } + +int main(void) { + foo(); + return 0; +} + +// CHECK: @__llvm_coverage_mapping = internal constant { i32, i32, i32, i32, [2 x { i8*, i32, i32, i64 }], [{{[0-9]+}} x i8] } { i32 2, i32 {{[0-9]+}}, i32 {{[0-9]+}}, i32 0, [2 x { i8*, i32, i32, i64 }] [{ i8*, i32, i32, i64 } { i8* getelementptr inbounds ([3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i32 3, i32 9, i64 {{[0-9]+}} }, { i8*, i32, i32, i64 } { i8* getelementptr inbounds ([4 x i8]* @__llvm_profile_name_main, i32 0, i32 0), i32 4, i32 9, i64 {{[0-9]+}} }] diff --git a/test/CoverageMapping/label.cpp b/test/CoverageMapping/label.cpp new file mode 100644 index 000000000000..d93626041bce --- /dev/null +++ b/test/CoverageMapping/label.cpp @@ -0,0 +1,63 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name label.cpp %s | FileCheck %s + + // CHECK: func +void func() { // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE+18]]:2 = #0 (HasCodeBefore = 0) + int i = 0; // CHECK-NEXT: File 0, [[@LINE+2]]:14 -> [[@LINE+2]]:20 = (#0 + #3) (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:22 -> [[@LINE+1]]:25 = #3 (HasCodeBefore = 0) + for(i = 0; i < 10; ++i) { // CHECK-NEXT: File 0, [[@LINE]]:27 -> [[@LINE+10]]:4 = #1 (HasCodeBefore = 0) + if(i < 5) { // CHECK-NEXT: File 0, [[@LINE]]:15 -> [[@LINE+6]]:6 = #2 (HasCodeBefore = 0) + { + x: // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE+6]]:14 = #3 (HasCodeBefore = 0) + int j = 1; + } + int m = 2; + } else + goto x; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:13 = (#1 - #2) (HasCodeBefore = 0) + int k = 3; + } + static int j = 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:12 = ((#0 + #3) - #1) (HasCodeBefore = 0) + ++j; + if(j == 1) + goto x; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:11 = #4 (HasCodeBefore = 0) +} + + // CHECK-NEXT: test1 +void test1(int x) { // CHECK-NEXT: File 0, [[@LINE]]:19 -> [[@LINE+7]]:2 = #0 (HasCodeBefore = 0) + if(x == 0) + goto a; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:11 = #1 (HasCodeBefore = 0) + goto b; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:9 = (#0 - #1) (HasCodeBefore = 0) +a: // CHECK-NEXT: File 0, [[@LINE]]:1 -> [[@LINE]]:2 = #2 (HasCodeBefore = 0) +b: // CHECK-NEXT: File 0, [[@LINE]]:1 -> [[@LINE+1]]:12 = #3 (HasCodeBefore = 0) + x = x + 1; +} + + // CHECK-NEXT: test2 +void test2(int x) { // CHECK-NEXT: File 0, [[@LINE]]:19 -> [[@LINE+8]]:2 = #0 (HasCodeBefore = 0) + if(x == 0) + goto a; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:11 = #1 (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:8 -> [[@LINE+1]]:17 = (#0 - #1) (HasCodeBefore = 0) + else if(x == 1) goto b; // CHECK-NEXT: File 0, [[@LINE]]:19 -> [[@LINE]]:25 = #2 (HasCodeBefore = 0) +a: // CHECK-NEXT: File 0, [[@LINE]]:1 -> [[@LINE]]:2 = #3 (HasCodeBefore = 0) +b: // CHECK-NEXT: File 0, [[@LINE]]:1 -> [[@LINE+1]]:12 = #4 (HasCodeBefore = 0) + x = x + 1; +} + + // CHECK-NEXT: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+17]]:2 = #0 (HasCodeBefore = 0) + int j = 0; + for(int i = 0; i < 10; ++i) { // CHECK: File 0, [[@LINE]]:31 -> [[@LINE+11]]:4 = #1 (HasCodeBefore = 0) + a: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:13 = #2 (HasCodeBefore = 0) + if(i < 3) + goto e; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:13 = #3 (HasCodeBefore = 0) + goto c; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:11 = (#2 - #3) (HasCodeBefore = 0) + b: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #4 (HasCodeBefore = 0) + j = 2; + c: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #5 (HasCodeBefore = 0) + j = 1; + // CHECK-NEXT: File 0, [[@LINE+1]]:3 -> [[@LINE+1]]:4 = #6 (HasCodeBefore = 0) + e: f: ; // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE]]:10 = #7 (HasCodeBefore = 0) + } + func(); // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:11 = ((#0 + #7) - #1) (HasCodeBefore = 0) + test1(0); + test2(2); +} diff --git a/test/CoverageMapping/logical.cpp b/test/CoverageMapping/logical.cpp new file mode 100644 index 000000000000..0971c756b044 --- /dev/null +++ b/test/CoverageMapping/logical.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %s | FileCheck %s + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+10]]:2 = #0 (HasCodeBefore = 0) + bool bt = true; + bool bf = false; + bool a = bt && bf; // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE]]:20 = #1 (HasCodeBefore = 0) + a = bt && + bf; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #2 (HasCodeBefore = 0) + a = bf || bt; // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE]]:15 = #3 (HasCodeBefore = 0) + a = bf || + bt; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #4 (HasCodeBefore = 0) + return 0; +} diff --git a/test/CoverageMapping/loopmacro.c b/test/CoverageMapping/loopmacro.c new file mode 100644 index 000000000000..8480dbdc37e9 --- /dev/null +++ b/test/CoverageMapping/loopmacro.c @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loopmacro.c %s | FileCheck %s + +# define HASH_BITS 15 +#define MIN_MATCH 3 +#define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH) +#define WMASK 0xFFFF +#define HASH_MASK 0xFFFF +#define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK) +#define INSERT_STRING(s, match_head) \ + (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \ + prev[(s) & WMASK] = match_head = head[ins_h], \ + head[ins_h] = (s)) + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+12]]:2 = #0 (HasCodeBefore = 0) + int strstart = 0; + int hash_head = 2; + int prev_length = 5; + int ins_h = 1; + int prev[32] = { 0 }; + int head[32] = { 0 }; + int window[1024] = { 0 }; + do { // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE+3]]:30 = (#0 + #1) (HasCodeBefore = 0) + strstart++; + INSERT_STRING(strstart, hash_head); // CHECK-NEXT: Expansion,File 0, [[@LINE]]:7 -> [[@LINE]]:20 = (#0 + #1) (HasCodeBefore = 0, Expanded file = 1) + } while (--prev_length != 0); +} +// CHECK-NEXT: File 0, 24:21 -> 24:29 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 0, 24:21 -> 24:29 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 0, 24:21 -> 24:29 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 0, 24:31 -> 24:40 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 10:4 -> 12:23 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 1, 10:5 -> 10:16 = (#0 + #1) (HasCodeBefore = 0, Expanded file = 2) +// CHECK-NEXT: File 1, 10:17 -> 10:22 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 10:17 -> 10:22 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 10:24 -> 10:32 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 10:33 -> 10:36 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 10:46 -> 10:49 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: File 2, 8:26 -> 8:66 = (#0 + #1) (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 2, 8:38 -> 8:45 = (#0 + #1) (HasCodeBefore = 0, Expanded file = 3) +// CHECK-NEXT: File 3, 5:18 -> 5:53 = (#0 + #1) (HasCodeBefore = 0) diff --git a/test/CoverageMapping/loops.cpp b/test/CoverageMapping/loops.cpp new file mode 100644 index 000000000000..81fad910d9e4 --- /dev/null +++ b/test/CoverageMapping/loops.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -std=c++11 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %s | FileCheck %s + + // CHECK: rangedFor +void rangedFor() { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+6]]:2 = #0 (HasCodeBefore = 0) + int arr[] = { 1, 2, 3, 4, 5 }; + int sum = 0; + for(auto i : arr) { // CHECK-NEXT: File 0, [[@LINE]]:21 -> [[@LINE+2]]:4 = #1 (HasCodeBefore = 0) + sum += i; + } +} + + // CHECK-NEXT: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+24]]:2 = #0 (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:18 -> [[@LINE+1]]:24 = (#0 + #1) (HasCodeBefore = 0) + for(int i = 0; i < 10; ++i) // CHECK-NEXT: File 0, [[@LINE]]:26 -> [[@LINE]]:29 = #1 (HasCodeBefore = 0) + ; // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE]]:7 = #1 (HasCodeBefore = 0) + for(int i = 0; + i < 10; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:13 = (#0 + #2) (HasCodeBefore = 0) + ++i) // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:10 = #2 (HasCodeBefore = 0) + { // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:4 = #2 (HasCodeBefore = 0) + int x = 0; + } + int j = 0; // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:14 = (#0 + #3) (HasCodeBefore = 0) + while(j < 5) ++j; // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE]]:19 = #3 (HasCodeBefore = 0) + do { // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE+2]]:17 = (#0 + #4) (HasCodeBefore = 0) + ++j; + } while(j < 10); + j = 0; + while + (j < 5) // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:10 = (#0 + #5) (HasCodeBefore = 0) + ++j; // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE]]:9 = #5 (HasCodeBefore = 0) + do + ++j; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE+1]]:15 = (#0 + #6) (HasCodeBefore = 0) + while(j < 10); + rangedFor(); + return 0; +} diff --git a/test/CoverageMapping/macroception.c b/test/CoverageMapping/macroception.c new file mode 100644 index 000000000000..edbd84a017d4 --- /dev/null +++ b/test/CoverageMapping/macroception.c @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroception.c %s | FileCheck %s + +#define M2 { +#define M1 M2 +#define M22 } +#define M11 M22 + +// CHECK-LABEL: main: +int main() M1 // CHECK-NEXT: Expansion,File 0, [[@LINE]]:12 -> [[@LINE]]:14 = #0 (HasCodeBefore = 0, Expanded file = 2) + return 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:2 = #0 (HasCodeBefore = 0) +} +// CHECK-NEXT: File 1, 3:12 -> 3:13 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 2, 4:12 -> 4:14 = #0 (HasCodeBefore = 0, Expanded file = 1) + + +// CHECK-LABEL: func2: +void func2() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+1]]:12 = #0 (HasCodeBefore = 0) + int x = 0; +M11 // CHECK-NEXT: Expansion,File 0, [[@LINE]]:1 -> [[@LINE]]:4 = #0 (HasCodeBefore = 0, Expanded file = 2) +// CHECK-NEXT: File 1, 5:13 -> 5:14 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 2, 6:13 -> 6:16 = #0 (HasCodeBefore = 0, Expanded file = 1) + +// CHECK-LABEL: func3: +void func3() M1 // CHECK-NEXT: Expansion,File 0, [[@LINE]]:14 -> [[@LINE]]:16 = #0 (HasCodeBefore = 0, Expanded file = 2) + int x = 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:12 = #0 (HasCodeBefore = 0) +M11 // CHECK-NEXT: Expansion,File 0, [[@LINE]]:1 -> [[@LINE]]:4 = #0 (HasCodeBefore = 0, Expanded file = 4) + +// CHECK-NEXT: File 1, 3:12 -> 3:13 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 2, 4:12 -> 4:14 = #0 (HasCodeBefore = 0, Expanded file = 1) +// CHECK-NEXT: File 3, 5:13 -> 5:14 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 4, 6:13 -> 6:16 = #0 (HasCodeBefore = 0, Expanded file = 3) + +// CHECK-LABEL: func4: +// CHECK-NEXT: File 0, 3:12 -> 3:13 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 1, 4:12 -> 4:14 = #0 (HasCodeBefore = 0, Expanded file = 0) +void func4() M1 M11 +// CHECK-NEXT: Expansion,File 2, [[@LINE-1]]:14 -> [[@LINE-1]]:16 = #0 (HasCodeBefore = 0, Expanded file = 1) +// CHECK-NEXT: Expansion,File 2, [[@LINE-2]]:17 -> [[@LINE-2]]:20 = #0 (HasCodeBefore = 0, Expanded file = 4) +// CHECK-NEXT: File 3, 5:13 -> 5:14 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 4, 6:13 -> 6:16 = #0 (HasCodeBefore = 0, Expanded file = 3) diff --git a/test/CoverageMapping/macroparams.c b/test/CoverageMapping/macroparams.c new file mode 100644 index 000000000000..adf01ec09b8e --- /dev/null +++ b/test/CoverageMapping/macroparams.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroparams.c %s | FileCheck %s + +#define MACRO2(X2) (X2 + 2) // CHECK-DAG: File 2, [[@LINE]]:20 -> [[@LINE]]:28 = #0 (HasCodeBefore = 0) +#define MACRO(X) MACRO2(x) // CHECK-DAG: File 1, [[@LINE]]:25 -> [[@LINE]]:26 = #0 (HasCodeBefore = 0) + // CHECK-DAG: Expansion,File 1, [[@LINE-1]]:18 -> [[@LINE-1]]:24 = #0 (HasCodeBefore = 0, Expanded file = 2) + + +int main() { // CHECK-DAG: File 0, [[@LINE]]:12 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + int x = 0; + MACRO(x); // CHECK-DAG: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:8 = #0 (HasCodeBefore = 0, Expanded file = 1) + return 0; +} diff --git a/test/CoverageMapping/macroparams2.c b/test/CoverageMapping/macroparams2.c new file mode 100644 index 000000000000..0445370b0e13 --- /dev/null +++ b/test/CoverageMapping/macroparams2.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroparams2.c %s | FileCheck %s + +// A test case for when the first macro parameter is used after the second +// macro parameter. + +struct S { + int i, j; +}; + +#define MACRO(REFS, CALLS) (4 * (CALLS) < (REFS)) + +int main() { // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+7]]:2 = #0 (HasCodeBefore = 0) + struct S arr[32] = { 0 }; // CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:7 -> [[@LINE+2]]:12 = #0 (HasCodeBefore = 0, Expanded file = 1) + int n = 0; // CHECK-NEXT: File 0, [[@LINE+1]]:13 -> [[@LINE+1]]:21 = #0 (HasCodeBefore = 0) + if (MACRO(arr[n].j, arr[n].i)) { // CHECK-NEXT: File 0, [[@LINE]]:23 -> [[@LINE]]:31 = #0 (HasCodeBefore = 0) + n = 1; // CHECK-NEXT: File 0, [[@LINE-1]]:34 -> [[@LINE+1]]:4 = #1 (HasCodeBefore = 0) + } + return n; +} // CHECK-NEXT: File 1, [[@LINE-9]]:29 -> [[@LINE-9]]:51 = #0 (HasCodeBefore = 0 + diff --git a/test/CoverageMapping/macros.c b/test/CoverageMapping/macros.c new file mode 100644 index 000000000000..d3a0e6aab47b --- /dev/null +++ b/test/CoverageMapping/macros.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macros.c %s | FileCheck %s + +void bar(); +#define MACRO return; bar() +#define MACRO_2 bar() +#define MACRO_1 return; MACRO_2 + + // CHECK: func +void func() { // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + int i = 0; + MACRO; // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:8 = #0 (HasCodeBefore = 0, Expanded file = 1) + i = 2; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:8 = 0 (HasCodeBefore = 0) +} +// CHECK-NEXT: File 1, 4:15 -> 4:21 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: File 1, 4:23 -> 4:28 = 0 (HasCodeBefore = 0) + + // CHECK-NEXT: func2 +void func2() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + int i = 0; + MACRO_1; // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:10 = #0 (HasCodeBefore = 0, Expanded file = 1) + i = 2; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:8 = 0 (HasCodeBefore = 0) +} +// CHECK-NEXT: File 1, 6:17 -> 6:23 = #0 (HasCodeBefore = 0) +// CHECK-NEXT: Expansion,File 1, 6:25 -> 6:32 = 0 (HasCodeBefore = 0, Expanded file = 2) +// CHECK-NEXT: File 2, 5:17 -> 5:22 = 0 (HasCodeBefore = 0) + diff --git a/test/CoverageMapping/nestedclass.cpp b/test/CoverageMapping/nestedclass.cpp new file mode 100644 index 000000000000..aca4abf1a7f0 --- /dev/null +++ b/test/CoverageMapping/nestedclass.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name nestedclass.cpp %s > %tmapping +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-OUTER +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-INNER +// RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-INNERMOST + +struct Test { // CHECK-OUTER: emitTest + void emitTest() { // CHECK-OUTER: File 0, [[@LINE]]:19 -> [[@LINE+2]]:4 = #0 (HasCodeBefore = 0) + int i = 0; + } + struct Test2 { // CHECK-INNER: emitTest2 + void emitTest2() { // CHECK-INNER: File 0, [[@LINE]]:22 -> [[@LINE+2]]:6 = #0 (HasCodeBefore = 0) + int i = 0; + } + struct Test3 { // CHECK-INNERMOST: emitTest3 + static void emitTest3() { // CHECK-INNERMOST: File 0, [[@LINE]]:31 -> [[@LINE+2]]:8 = 0 (HasCodeBefore = 0) + int i = 0; + } + }; + }; +}; + +int main() { + Test t; + Test::Test2 t2; + t.emitTest(); + t2.emitTest2(); + return 0; +} diff --git a/test/CoverageMapping/objc.m b/test/CoverageMapping/objc.m new file mode 100644 index 000000000000..b41ab94ccf26 --- /dev/null +++ b/test/CoverageMapping/objc.m @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name objc.m -triple x86_64-apple-darwin -fobjc-runtime=macosx-fragile-10.5 %s | FileCheck %s + +@interface A +- (void)bork:(int)msg; +@end + + // CHECK: func +void func(A *a) { // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+3]]:2 = #0 (HasCodeBefore = 0) + if (a) + [a bork: 20 ]; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:20 = #1 (HasCodeBefore = 0) +} + +@interface NSArray ++ (NSArray*) arrayWithObjects: (id) first, ...; +- (unsigned) count; +@end + + // CHECK: func2 +void func2(NSArray *array) { // CHECK-NEXT: File 0, [[@LINE]]:28 -> [[@LINE+10]]:2 = #0 (HasCodeBefore = 0) + int i = 0; + for (NSArray *x in array) { // CHECK-NEXT: File 0, [[@LINE]]:29 -> [[@LINE+6]]:4 = #1 (HasCodeBefore = 0) + if (x) { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+2]]:6 = #2 (HasCodeBefore = 0) + i = 1; + } else { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+2]]:6 = (#1 - #2) (HasCodeBefore = 0) + i = -1; + } + } + i = 0; +} diff --git a/test/CoverageMapping/preprocessor.c b/test/CoverageMapping/preprocessor.c new file mode 100644 index 000000000000..a6edeb7c8241 --- /dev/null +++ b/test/CoverageMapping/preprocessor.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name preprocessor.c %s | FileCheck %s + + // CHECK: func +void func() { // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0 (HasCodeBefore = 0) + int i = 0; +#ifdef MACRO // CHECK-NEXT: Skipped,File 0, [[@LINE]]:2 -> [[@LINE+2]]:2 = 0 (HasCodeBefore = 0) + int x = i; +#endif +} + +#if 0 + int g = 0; + + void bar() { } +#endif + + // CHECK: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+19]]:2 = #0 (HasCodeBefore = 0) + int i = 0; +#if 0 // CHECK-NEXT: Skipped,File 0, [[@LINE]]:2 -> [[@LINE+4]]:2 = 0 (HasCodeBefore = 0) + if(i == 0) { + i = 1; + } +#endif + +#if 1 + if(i == 0) { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+2]]:4 = #1 (HasCodeBefore = 0) + i = 1; + } +#else // CHECK-NEXT: Skipped,File 0, [[@LINE]]:2 -> [[@LINE+5]]:2 = 0 (HasCodeBefore = 0) + if(i == 1) { + i = 0; + } +} +#endif + return 0; +} diff --git a/test/CoverageMapping/return.c b/test/CoverageMapping/return.c new file mode 100644 index 000000000000..9c68759b2fc4 --- /dev/null +++ b/test/CoverageMapping/return.c @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name return.c %s | FileCheck %s + + // CHECK: func +void func() { // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+3]]:2 = #0 (HasCodeBefore = 0) + return; + int i = 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:12 = 0 (HasCodeBefore = 0) +} + + // CHECK-NEXT: func2 +void func2() { // CHECK-NEXT: File 0, [[@LINE]]:14 -> [[@LINE+13]]:2 = #0 (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = ((#0 + #1) - #2) (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:26 -> [[@LINE+1]]:29 = (#1 - #2) (HasCodeBefore = 0) + for(int i = 0; i < 10; ++i) { // CHECK-NEXT: File 0, [[@LINE]]:31 -> [[@LINE+9]]:4 = #1 (HasCodeBefore = 0) + if(i > 2) { // CHECK-NEXT: File 0, [[@LINE]]:15 -> [[@LINE+2]]:6 = #2 (HasCodeBefore = 0) + return; + } // CHECK-NEXT: File 0, [[@LINE+1]]:5 -> [[@LINE+3]]:11 = (#1 - #2) (HasCodeBefore = 0) + if(i == 3) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> [[@LINE+2]]:6 = #3 (HasCodeBefore = 0) + int j = 1; + } else { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+2]]:6 = ((#1 - #2) - #3) (HasCodeBefore = 0) + int j = 2; + } + } +} + + // CHECK-NEXT: func3 +void func3(int x) { // CHECK-NEXT: File 0, [[@LINE]]:19 -> [[@LINE+9]]:2 = #0 (HasCodeBefore = 0) + if(x > 5) { // CHECK-NEXT: File 0, [[@LINE]]:13 -> [[@LINE+6]]:4 = #1 (HasCodeBefore = 0) + while(x >= 9) { // CHECK-NEXT: File 0, [[@LINE]]:11 -> [[@LINE]]:17 = #1 (HasCodeBefore = 0) + return; // CHECK-NEXT: File 0, [[@LINE-1]]:19 -> [[@LINE+2]]:6 = #2 (HasCodeBefore = 0) + --x; // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:10 = 0 (HasCodeBefore = 0) + } + int i = 0; // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:14 = (#1 - #2) (HasCodeBefore = 0) + } + int j = 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:12 = (#0 - #2) (HasCodeBefore = 0) +} diff --git a/test/CoverageMapping/switch.c b/test/CoverageMapping/switch.c new file mode 100644 index 000000000000..b6672258591a --- /dev/null +++ b/test/CoverageMapping/switch.c @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name switch.c %s | FileCheck %s + // CHECK: foo +void foo(int i) { // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+8]]:2 = #0 (HasCodeBefore = 0) + switch(i) { + case 1: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:11 = #2 (HasCodeBefore = 0) + return; + case 2: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #3 (HasCodeBefore = 0) + break; + } // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:12 = #1 (HasCodeBefore = 0) + int x = 0; +} + + // CHECK-NEXT: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+34]]:2 = #0 (HasCodeBefore = 0) + int i = 0; + switch(i) { + case 0: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:10 = #2 (HasCodeBefore = 0) + i = 1; + break; + case 1: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:10 = #3 (HasCodeBefore = 0) + i = 2; + break; + default: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #4 (HasCodeBefore = 0) + break; + } // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:14 = #1 (HasCodeBefore = 0) + switch(i) { + case 0: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+2]]:10 = #6 (HasCodeBefore = 0) + i = 1; + break; + case 1: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #7 (HasCodeBefore = 0) + i = 2; + default: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = (#7 + #8) (HasCodeBefore = 0) + break; + } // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+3]]:14 = #5 (HasCodeBefore = 0) + + + switch(i) { + case 1: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:10 = #10 (HasCodeBefore = 0) + case 2: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:11 = (#10 + #11) (HasCodeBefore = 0) + i = 11; + case 3: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:10 = ((#10 + #11) + #12) (HasCodeBefore = 0) + case 4: // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:11 = (((#10 + #11) + #12) + #13) (HasCodeBefore = 0) + i = 99; + } // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+3]]:11 = #9 (HasCodeBefore = 0) + + foo(1); + return 0; +} diff --git a/test/CoverageMapping/templates.cpp b/test/CoverageMapping/templates.cpp new file mode 100644 index 000000000000..fcb92e1e9f57 --- /dev/null +++ b/test/CoverageMapping/templates.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name templates.cpp %s | FileCheck %s + +template<typename T> +void unused(T x) { + return; +} + +template<typename T> +int func(T x) { // CHECK: func + if(x) // CHECK: func + return 0; + else + return 1; + int j = 1; +} + +int main() { + func<int>(0); + func<bool>(true); + return 0; +} diff --git a/test/CoverageMapping/test.c b/test/CoverageMapping/test.c new file mode 100644 index 000000000000..594bcf68bc0f --- /dev/null +++ b/test/CoverageMapping/test.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name test.c %s | FileCheck %s + +void bar(); +static void static_func(); + + // CHECK: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+7]]:2 = #0 (HasCodeBefore = 0) + // CHECK-NEXT: File 0, [[@LINE+1]]:18 -> [[@LINE+1]]:24 = (#0 + #1) (HasCodeBefore = 0) + for(int i = 0; i < 10; ++i) { // CHECK-NEXT: File 0, [[@LINE]]:26 -> [[@LINE]]:29 = #1 (HasCodeBefore = 0) + bar(); // CHECK-NEXT: File 0, [[@LINE-1]]:31 -> [[@LINE+1]]:4 = #1 (HasCodeBefore = 0) + } + static_func(); + return 0; +} + + // CHECK-NEXT: foo +void foo() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+4]]:2 = #0 (HasCodeBefore = 0) + if(1) { // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE+2]]:4 = #1 (HasCodeBefore = 0) + int i = 0; + } +} + + // CHECK-NEXT: bar +void bar() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+1]]:2 = #0 (HasCodeBefore = 0) +} + + // CHECK-NEXT: static_func +void static_func() { } // CHECK: File 0, [[@LINE]]:20 -> [[@LINE]]:23 = #0 (HasCodeBefore = 0) + + // CHECK-NEXT: func +static void func() { } // CHECK: File 0, [[@LINE]]:20 -> [[@LINE]]:23 = 0 (HasCodeBefore = 0) diff --git a/test/CoverageMapping/trycatch.cpp b/test/CoverageMapping/trycatch.cpp new file mode 100644 index 000000000000..a513845c28aa --- /dev/null +++ b/test/CoverageMapping/trycatch.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fexceptions -fcxx-exceptions -fprofile-instr-generate -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name trycatch.cpp %s | FileCheck %s + +class Error { +}; + +class ImportantError { +}; + +class Warning { +}; + + // CHECK: func +void func(int i) { // CHECK-NEXT: File 0, [[@LINE]]:18 -> [[@LINE+5]]:2 = #0 (HasCodeBefore = 0) + if(i % 2) + throw Error(); // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:16 = #1 (HasCodeBefore = 0) + else if(i == 8) // CHECK-NEXT: File 0, [[@LINE]]:8 -> [[@LINE]]:17 = (#0 - #1) (HasCodeBefore = 0) + throw ImportantError(); // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE]]:25 = #2 (HasCodeBefore = 0) +} + + // CHECK-NEXT: main +int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+13]]:2 = #0 (HasCodeBefore = 0) + int j = 0; + try { + func(j); + } catch(const Error &e) { // CHECK-NEXT: File 0, [[@LINE]]:27 -> [[@LINE+2]]:10 = #2 (HasCodeBefore = 0) + j = 1; + } catch(const ImportantError &e) { // CHECK-NEXT: File 0, [[@LINE]]:36 -> [[@LINE+3]]:8 = #3 (HasCodeBefore = 0) + j = 11; + } + catch(const Warning &w) { // CHECK-NEXT: File 0, [[@LINE]]:27 -> [[@LINE+2]]:4 = #4 (HasCodeBefore = 0) + j = 0; + } + return 0; // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE]]:11 = #1 (HasCodeBefore = 0) +} diff --git a/test/Driver/B-opt.c b/test/Driver/B-opt.c index 6759353174d0..318009413b1c 100644 --- a/test/Driver/B-opt.c +++ b/test/Driver/B-opt.c @@ -3,20 +3,20 @@ // RUN: %clang %s -### -o %t.o -target i386-unknown-linux \ // RUN: -B %S/Inputs/B_opt_tree/dir1 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-B-OPT-TRIPLE %s -// CHECK-B-OPT-TRIPLE: "{{.*}}/Inputs/B_opt_tree/dir1{{/|\\}}i386-unknown-linux-ld" +// CHECK-B-OPT-TRIPLE: "{{.*}}/Inputs/B_opt_tree/dir1{{/|\\\\}}i386-unknown-linux-ld" // // RUN: %clang %s -### -o %t.o -target i386-unknown-linux \ // RUN: -B %S/Inputs/B_opt_tree/dir2 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-B-OPT-DIR %s -// CHECK-B-OPT-DIR: "{{.*}}/Inputs/B_opt_tree/dir2{{/|\\}}ld" +// CHECK-B-OPT-DIR: "{{.*}}/Inputs/B_opt_tree/dir2{{/|\\\\}}ld" // // RUN: %clang %s -### -o %t.o -target i386-unknown-linux \ // RUN: -B %S/Inputs/B_opt_tree/dir3/prefix- 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-B-OPT-PREFIX %s -// CHECK-B-OPT-PREFIX: "{{.*}}/Inputs/B_opt_tree/dir3{{/|\\}}prefix-ld" +// CHECK-B-OPT-PREFIX: "{{.*}}/Inputs/B_opt_tree/dir3{{/|\\\\}}prefix-ld" // // RUN: %clang %s -### -o %t.o -target i386-unknown-linux \ // RUN: -B %S/Inputs/B_opt_tree/dir3/prefix- \ // RUN: -B %S/Inputs/B_opt_tree/dir2 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-B-OPT-MULT %s -// CHECK-B-OPT-MULT: "{{.*}}/Inputs/B_opt_tree/dir3{{/|\\}}prefix-ld" +// CHECK-B-OPT-MULT: "{{.*}}/Inputs/B_opt_tree/dir3{{/|\\\\}}prefix-ld" diff --git a/test/Driver/Inputs/Windows/ARM/8.1/usr/bin/armv7-windows-itanium-ld b/test/Driver/Inputs/Windows/ARM/8.1/usr/bin/armv7-windows-itanium-ld new file mode 100755 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/Windows/ARM/8.1/usr/bin/armv7-windows-itanium-ld diff --git a/test/Driver/Inputs/basic_netbsd_tree/usr/lib/eabihf/crti.o b/test/Driver/Inputs/basic_netbsd_tree/usr/lib/eabihf/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/basic_netbsd_tree/usr/lib/eabihf/crti.o diff --git a/test/Driver/Inputs/basic_netbsd_tree/usr/lib/powerpc/crti.o b/test/Driver/Inputs/basic_netbsd_tree/usr/lib/powerpc/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/basic_netbsd_tree/usr/lib/powerpc/crti.o diff --git a/test/Driver/Inputs/cc1-response.txt b/test/Driver/Inputs/cc1-response.txt new file mode 100644 index 000000000000..0236fdc6aa31 --- /dev/null +++ b/test/Driver/Inputs/cc1-response.txt @@ -0,0 +1,4 @@ + + +-cc1 +-triple i686-pc-windows-msvc diff --git a/test/Driver/Inputs/gen-response.c b/test/Driver/Inputs/gen-response.c new file mode 100644 index 000000000000..84ffb40dbece --- /dev/null +++ b/test/Driver/Inputs/gen-response.c @@ -0,0 +1,8 @@ +#define M -DTEST +#define M1 M M M M M M M M M M +#define M2 M1 M1 M1 M1 M1 M1 M1 M1 M1 M1 +#define M3 M2 M2 M2 M2 M2 M2 M2 M2 M2 M2 +#define M4 M3 M3 M3 M3 M3 M3 M3 M3 M3 M3 +#define M5 M4 M4 M4 M4 M4 M4 M4 M4 M4 M4 +#define TEXT M5 M5 M5 +TEXT diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/el/.keep b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/nan2008/el/.keep b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/nan2008/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/nan2008/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/soft-float/el/.keep b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/soft-float/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/include-fixed/uclibc/soft-float/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/el/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/nan2008/el/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtbegin.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtbegin.o diff --git a/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtend.o b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/lib/gcc/mips-linux-gnu/4.6.3/uclibc/soft-float/el/crtend.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/el/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/nan2008/el/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/nan2008/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/nan2008/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/soft-float/el/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/soft-float/el/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/lib/uclibc/soft-float/el/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/el/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/nan2008/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/lib/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/lib/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/lib/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/soft-float/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/include/.keep b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/include/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/include/.keep diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crt1.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crti.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crtn.o b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_cs_tree/mips-linux-gnu/libc/uclibc/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/nan2008/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/el/sof/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/nan2008/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtbegin.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtbegin.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtbegin.o diff --git a/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtend.o b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtend.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/lib/gcc/mips-mti-linux-gnu/4.9.0/uclibc/sof/crtend.o diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/nan2008/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/nan2008/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/nan2008/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/sof/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/sof/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/sof/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/nan2008/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/nan2008/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/nan2008/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/sof/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/sof/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/sof/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/nan2008/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/nan2008/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/nan2008/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/sof/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/sof/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/el/sof/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/nan2008/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/nan2008/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/nan2008/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/sof/.keep b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/sof/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/mips-mti-linux-gnu/lib/uclibc/sof/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/nan2008/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/sof/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/el/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/nan2008/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/sof/usr/lib/crtn.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/include/bits/.keep b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/include/bits/.keep new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/include/bits/.keep diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crt1.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crt1.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crt1.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crti.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crti.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crti.o diff --git a/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crtn.o b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crtn.o new file mode 100644 index 000000000000..e69de29bb2d1 --- /dev/null +++ b/test/Driver/Inputs/mips_fsf_tree/sysroot/uclibc/usr/lib/crtn.o diff --git a/test/Driver/aarch64-cpus.c b/test/Driver/aarch64-cpus.c index 68ad326d5edf..1627660d8130 100644 --- a/test/Driver/aarch64-cpus.c +++ b/test/Driver/aarch64-cpus.c @@ -7,7 +7,7 @@ // RUN: %clang -target arm64 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC %s // RUN: %clang -target arm64 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC %s -// RUN: %clang -target arm64_be -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC %s + // ARM64-GENERIC: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "generic" // RUN: %clang -target arm64-apple-darwin -arch arm64 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-DARWIN %s @@ -22,10 +22,8 @@ // RUN: %clang -target arm64 -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s // RUN: %clang -target arm64 -mlittle-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s -// RUN: %clang -target arm64_be -mlittle-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s // RUN: %clang -target arm64 -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s // RUN: %clang -target arm64 -mlittle-endian -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s -// RUN: %clang -target arm64_be -mlittle-endian -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53 %s // ARM64-CA53: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "cortex-a53" // RUN: %clang -target aarch64 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57 %s @@ -38,10 +36,8 @@ // RUN: %clang -target arm64 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s // RUN: %clang -target arm64 -mlittle-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s -// RUN: %clang -target arm64_be -mlittle-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s // RUN: %clang -target arm64 -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s // RUN: %clang -target arm64 -mlittle-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s -// RUN: %clang -target arm64_be -mlittle-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57 %s // ARM64-CA57: "-cc1"{{.*}} "-triple" "arm64{{.*}}" "-target-cpu" "cortex-a57" // RUN: %clang -target aarch64_be -### -c %s 2>&1 | FileCheck -check-prefix=GENERIC-BE %s @@ -49,11 +45,6 @@ // RUN: %clang -target aarch64_be -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=GENERIC-BE %s // GENERIC-BE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "generic" -// RUN: %clang -target arm64_be -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC-BE %s -// RUN: %clang -target arm64 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC-BE %s -// RUN: %clang -target arm64_be -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-GENERIC-BE %s -// ARM64-GENERIC-BE: "-cc1"{{.*}} "-triple" "arm64_be{{.*}}" "-target-cpu" "generic" - // RUN: %clang -target aarch64_be -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=CA53-BE %s // RUN: %clang -target aarch64 -mbig-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=CA53-BE %s // RUN: %clang -target aarch64_be -mbig-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=CA53-BE %s @@ -62,14 +53,6 @@ // RUN: %clang -target aarch64_be -mbig-endian -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=CA53-BE %s // CA53-BE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "cortex-a53" -// RUN: %clang -target arm64_be -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// RUN: %clang -target arm64 -mbig-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// RUN: %clang -target arm64_be -mbig-endian -mcpu=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// RUN: %clang -target arm64_be -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// RUN: %clang -target arm64 -mbig-endian -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// RUN: %clang -target arm64_be -mbig-endian -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA53-BE %s -// ARM64-CA53-BE: "-cc1"{{.*}} "-triple" "arm64_be{{.*}}" "-target-cpu" "cortex-a53" - // RUN: %clang -target aarch64_be -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s // RUN: %clang -target aarch64 -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s // RUN: %clang -target aarch64_be -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s @@ -78,14 +61,6 @@ // RUN: %clang -target aarch64_be -mbig-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=CA57-BE %s // CA57-BE: "-cc1"{{.*}} "-triple" "aarch64_be{{.*}}" "-target-cpu" "cortex-a57" -// RUN: %clang -target arm64_be -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// RUN: %clang -target arm64 -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// RUN: %clang -target arm64_be -mbig-endian -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// RUN: %clang -target arm64_be -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// RUN: %clang -target arm64 -mbig-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// RUN: %clang -target arm64_be -mbig-endian -mtune=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=ARM64-CA57-BE %s -// ARM64-CA57-BE: "-cc1"{{.*}} "-triple" "arm64_be{{.*}}" "-target-cpu" "cortex-a57" - // RUN: %clang -target aarch64 -mcpu=cortex-a57 -mtune=cortex-a53 -### -c %s 2>&1 | FileCheck -check-prefix=MCPU-MTUNE %s // RUN: %clang -target aarch64 -mtune=cortex-a53 -mcpu=cortex-a57 -### -c %s 2>&1 | FileCheck -check-prefix=MCPU-MTUNE %s // MCPU-MTUNE: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-cpu" "cortex-a53" diff --git a/test/Driver/aarch64-fix-cortex-a53-835769.c b/test/Driver/aarch64-fix-cortex-a53-835769.c new file mode 100644 index 000000000000..3fe918adec45 --- /dev/null +++ b/test/Driver/aarch64-fix-cortex-a53-835769.c @@ -0,0 +1,13 @@ +// RUN: %clang -target aarch64-linux-eabi %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-DEF %s +// RUN: %clang -target aarch64-linux-eabi -mfix-cortex-a53-835769 %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-YES %s +// RUN: %clang -target aarch64-linux-eabi -mno-fix-cortex-a53-835769 %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-NO %s + +// RUN: %clang -target aarch64-android-eabi %s -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-YES %s + +// CHECK-DEF-NOT: "-backend-option" "-aarch64-fix-cortex-a53-835769" +// CHECK-YES: "-backend-option" "-aarch64-fix-cortex-a53-835769=1" +// CHECK-NO: "-backend-option" "-aarch64-fix-cortex-a53-835769=0" diff --git a/test/Driver/arm-abi.c b/test/Driver/arm-abi.c new file mode 100644 index 000000000000..812a849110ec --- /dev/null +++ b/test/Driver/arm-abi.c @@ -0,0 +1,53 @@ +// The default ABI is aapcs +// RUN: %clang -target arm--- %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target armeb--- %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target thumb--- %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target thumbeb--- %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s + +// MachO targets default to apcs-gnu, except for m-class processors +// RUN: %clang -target arm--darwin- -arch armv7s %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-APCS-GNU %s +// RUN: %clang -target thumb--darwin- -arch armv7s %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-APCS-GNU %s +// RUN: %clang -target thumb--darwin- -arch armv7m %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s + +// Windows targets default to AAPCS, regardless of environment +// RUN: %clang -target arm--windows-gnueabi %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s + +// NetBSD defaults to apcs-gnu, but can also use aapcs +// RUN: %clang -target arm--netbsd- %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-APCS-GNU %s +// RUN: %clang -target arm--netbsd-eabi %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target arm--netbsd-eabihf %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s + +// Otherwise, ABI is celected based on environment +// RUN: %clang -target arm---android %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS-LINUX %s +// RUN: %clang -target arm---gnueabi %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS-LINUX %s +// RUN: %clang -target arm---gnueabihf %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS-LINUX %s +// RUN: %clang -target arm---eabi %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target arm---eabihf %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s + +// ABI can be overridden by the -mabi= option +// RUN: %clang -target arm---eabi -mabi=apcs-gnu %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-APCS-GNU %s +// RUN: %clang -target arm---gnueabi -mabi=aapcs %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS %s +// RUN: %clang -target arm---eabi -mabi=aapcs-linux %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-AAPCS-LINUX %s + +// CHECK-APCS-GNU: "-target-abi" "apcs-gnu" +// CHECK-AAPCS: "-target-abi" "aapcs" +// CHECK-AAPCS-LINUX: "-target-abi" "aapcs-linux" diff --git a/test/Driver/arm-alignment.c b/test/Driver/arm-alignment.c index 98046d7edf1d..3fe595143f7d 100644 --- a/test/Driver/arm-alignment.c +++ b/test/Driver/arm-alignment.c @@ -44,5 +44,17 @@ // RUN: %clang -target aarch64-none-gnueabi -munaligned-access -mstrict-align -### %s 2> %t // RUN: FileCheck --check-prefix=CHECK-ALIGNED-AARCH64 < %t %s +// RUN: %clang -target aarch64-none-gnueabi -mkernel -mno-unaligned-access -### %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-ALIGNED-AARCH64 < %t %s + // CHECK-ALIGNED-ARM: "-backend-option" "-arm-strict-align" // CHECK-ALIGNED-AARCH64: "-backend-option" "-aarch64-strict-align" + +// Make sure that v6M cores always trigger the unsupported aligned accesses error +// for all supported architecture triples. +// RUN: not %clang -c -target thumbv6m-none-gnueabi -mcpu=cortex-m0 -munaligned-access %s 2>&1 | \ +// RUN: FileCheck --check-prefix CHECK-UNALIGN-NOT-SUPPORTED %s +// RUN: not %clang -c -target thumb-none-gnueabi -mcpu=cortex-m0 -munaligned-access %s 2>&1 | \ +// RUN: FileCheck --check-prefix CHECK-UNALIGN-NOT-SUPPORTED %s + +// CHECK-UNALIGN-NOT-SUPPORTED: error: the v6m sub-architecture does not support unaligned accesses diff --git a/test/Driver/arm-cortex-cpus.c b/test/Driver/arm-cortex-cpus.c index 224ba575dddd..b1f253341ef4 100644 --- a/test/Driver/arm-cortex-cpus.c +++ b/test/Driver/arm-cortex-cpus.c @@ -14,7 +14,7 @@ // CHECK-V5: "-cc1"{{.*}} "-triple" "armv5-{{.*}} "-target-cpu" "arm10tdmi" // RUN: %clang -target armv5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V5-THUMB %s -// RUN: %clang -target armv -march=armv5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V5-THUMB %s +// RUN: %clang -target arm -march=armv5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V5-THUMB %s // RUN: %clang -target armv5t -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V5-THUMB %s // RUN: %clang -target arm -march=armv5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-V5-THUMB %s // CHECK-V5-THUMB: "-cc1"{{.*}} "-triple" "thumbv5-{{.*}} "-target-cpu" "arm10tdmi" @@ -169,12 +169,14 @@ // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a5 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a7 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a8 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A %s // CHECK-CPUV7A: "-cc1"{{.*}} "-triple" "armv7-{{.*}} // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a5 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s @@ -183,12 +185,14 @@ // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a9 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a12 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a15 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s +// RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a17 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a5 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a7 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a8 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A %s // CHECK-BE-CPUV7A: "-cc1"{{.*}} "-triple" "armebv7-{{.*}} // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s @@ -197,12 +201,14 @@ // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a5 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a7 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a8 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -mlittle-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7A-THUMB %s // CHECK-CPUV7A-THUMB: "-cc1"{{.*}} "-triple" "thumbv7-{{.*}} // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a5 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s @@ -211,12 +217,14 @@ // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a9 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a12 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a15 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s +// RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-a17 -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a5 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a7 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a8 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a9 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a12 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a15 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-a17 -mbig-endian -mthumb -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7A-THUMB %s // CHECK-BE-CPUV7A-THUMB: "-cc1"{{.*}} "-triple" "thumbebv7-{{.*}} // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m0 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV6M %s @@ -231,11 +239,15 @@ // CHECK-BE-CPUV7M: "-cc1"{{.*}} "-triple" "thumbebv7m-{{.*}} // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m4 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7EM %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m7 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7EM %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m4 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7EM %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m7 -mlittle-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7EM %s // CHECK-CPUV7EM: "-cc1"{{.*}} "-triple" "thumbv7em-{{.*}} // RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-m4 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7EM %s +// RUN: %clang -target armeb-linux-gnueabi -mcpu=cortex-m7 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7EM %s // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m4 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7EM %s +// RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-m7 -mbig-endian -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-BE-CPUV7EM %s // CHECK-BE-CPUV7EM: "-cc1"{{.*}} "-triple" "thumbebv7em-{{.*}} // RUN: %clang -target arm-linux-gnueabi -mcpu=cortex-r4 -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-CPUV7R %s diff --git a/test/Driver/arm-fixed-r9.c b/test/Driver/arm-fixed-r9.c index 0a95d8779780..2cec8b4c4fc8 100644 --- a/test/Driver/arm-fixed-r9.c +++ b/test/Driver/arm-fixed-r9.c @@ -1,4 +1,4 @@ -// RUN: %clang -target arm-none-gnueeabi -ffixed-r9 -### %s 2> %t +// RUN: %clang -target arm-none-gnueabi -ffixed-r9 -### %s 2> %t // RUN: FileCheck --check-prefix=CHECK-FIXED-R9 < %t %s // CHECK-FIXED-R9: "-backend-option" "-arm-reserve-r9" diff --git a/test/Driver/arm-mfpu.c b/test/Driver/arm-mfpu.c index 89c203542259..64d7d0bb630f 100644 --- a/test/Driver/arm-mfpu.c +++ b/test/Driver/arm-mfpu.c @@ -19,14 +19,6 @@ // CHECK-FPA: "-target-feature" "-vfp3" // CHECK-FPA: "-target-feature" "-neon" -// RUN: %clang -target arm-linux-eabi -mfpu=vfp3-d16 %s -### -o %t.o 2>&1 \ -// RUN: | FileCheck --check-prefix=CHECK-VFP3-D16 %s -// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3-d16 %s -### -o %t.o 2>&1 \ -// RUN: | FileCheck --check-prefix=CHECK-VFP3-D16 %s -// CHECK-VFP3-D16: "-target-feature" "+vfp3" -// CHECK-VFP3-D16: "-target-feature" "+d16" -// CHECK-VFP3-D16: "-target-feature" "-neon" - // RUN: %clang -target arm-linux-eabi -mfpu=vfp %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-VFP %s // CHECK-VFP: "-target-feature" "+vfp2" @@ -39,6 +31,14 @@ // CHECK-VFP3: "-target-feature" "+vfp3" // CHECK-VFP3: "-target-feature" "-neon" +// RUN: %clang -target arm-linux-eabi -mfpu=vfp3-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3-D16 %s +// RUN: %clang -target arm-linux-eabi -mfpu=vfpv3-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-VFP3-D16 %s +// CHECK-VFP3-D16: "-target-feature" "+vfp3" +// CHECK-VFP3-D16: "-target-feature" "+d16" +// CHECK-VFP3-D16: "-target-feature" "-neon" + // RUN: %clang -target arm-linux-eabi -mfpu=vfp4 %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-VFP4 %s // RUN: %clang -target arm-linux-eabi -mfpu=vfpv4 %s -### -o %t.o 2>&1 \ @@ -63,10 +63,39 @@ // CHECK-FP4-SP-D16: "-target-feature" "+fp-only-sp" // CHECK-FP4-SP-D16: "-target-feature" "-neon" +// RUN: %clang -target arm-linux-eabi -mfpu=fp5-sp-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-FP5-SP-D16 %s +// RUN: %clang -target arm-linux-eabi -mfpu=fpv5-sp-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-FP5-SP-D16 %s +// CHECK-FP5-SP-D16: "-target-feature" "+fp-armv8" +// CHECK-FP5-SP-D16: "-target-feature" "+fp-only-sp" +// CHECK-FP5-SP-D16: "-target-feature" "+d16" +// CHECK-FP5-SP-D16: "-target-feature" "-neon" +// CHECK-FP5-SP-D16: "-target-feature" "-crypto" + +// RUN: %clang -target arm-linux-eabi -mfpu=fp5-dp-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-FP5-DP-D16 %s +// RUN: %clang -target arm-linux-eabi -mfpu=fpv5-dp-d16 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-FP5-DP-D16 %s +// CHECK-FP5-DP-D16: "-target-feature" "+fp-armv8" +// CHECK-FP5-DP-D16: "-target-feature" "+d16" +// CHECK-FP5-DP-D16: "-target-feature" "-neon" +// CHECK-FP5-DP-D16: "-target-feature" "-crypto" + // RUN: %clang -target arm-linux-eabi -mfpu=neon %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NEON %s // CHECK-NEON: "-target-feature" "+neon" +// RUN: %clang -target arm-linux-eabi -mfpu=neon-vfpv3 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-NEON-VFPV3 %s +// CHECK-NEON-VFPV3: "-target-feature" "+vfp3" +// CHECK-NEON-VFPV3: "-target-feature" "+neon" + +// RUN: %clang -target arm-linux-eabi -mfpu=neon-vfpv4 %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-NEON-VFPV4 %s +// CHECK-NEON-VFPV4: "-target-feature" "+neon" +// CHECK-NEON-VFPV4: "-target-feature" "+vfp4" + // RUN: %clang -target arm-linux-eabi -msoft-float %s -### -o %t.o 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-SOFT-FLOAT %s // CHECK-SOFT-FLOAT: "-target-feature" "-neon" diff --git a/test/Driver/ast.c b/test/Driver/ast.c index 83dfcc37a9c8..c1d7b1a6d7b0 100644 --- a/test/Driver/ast.c +++ b/test/Driver/ast.c @@ -16,9 +16,10 @@ // COMPILE-AST-PHASES: 0: input, // COMPILE-AST-PHASES: , ast -// COMPILE-AST-PHASES: 1: compiler, {0}, assembler -// COMPILE-AST-PHASES: 2: assembler, {1}, object -// COMPILE-AST-PHASES-NOT: 3: +// COMPILE-AST-PHASES: 1: compiler, {0}, ir +// COMPILE-AST-PHASES: 2: backend, {1}, assembler +// COMPILE-AST-PHASES: 3: assembler, {2}, object +// COMPILE-AST-PHASES-NOT: 4: // COMPILE-AST-PHASES: END // FIXME: There is a problem with compiling AST's in that the input language is diff --git a/test/Driver/biarch.c b/test/Driver/biarch.c new file mode 100644 index 000000000000..1f0982e3c5d2 --- /dev/null +++ b/test/Driver/biarch.c @@ -0,0 +1,41 @@ +// RUN: %clang -target i386--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "i386--netbsd"' %t + +// RUN: %clang -target i386--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "x86_64--netbsd"' %t + +// RUN: %clang -target x86_64--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "i386--netbsd"' %t + +// RUN: %clang -target x86_64--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "x86_64--netbsd"' %t + +// RUN: %clang -target armv6--netbsd-eabihf -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "armv6--netbsd-eabihf"' %t + +// RUN: %clang -target sparcv9--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "sparc--netbsd"' %t + +// RUN: %clang -target sparcv9--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "sparcv9--netbsd"' %t + +// RUN: %clang -target sparc64--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "sparc64--netbsd"' %t + +// RUN: %clang -target sparc--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "sparc--netbsd"' %t + +// RUN: %clang -target sparc--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "sparcv9--netbsd"' %t + +// RUN: %clang -target mips64--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "mips--netbsd"' %t + +// RUN: %clang -target mips64--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "mips64--netbsd"' %t + +// RUN: %clang -target mips--netbsd -m32 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "mips--netbsd"' %t + +// RUN: %clang -target mips--netbsd -m64 %s -### 2> %t +// RUN: grep '"-cc1" "-triple" "mips64--netbsd"' %t diff --git a/test/Driver/cc1-response-files.c b/test/Driver/cc1-response-files.c new file mode 100644 index 000000000000..f47e6448a6ca --- /dev/null +++ b/test/Driver/cc1-response-files.c @@ -0,0 +1,2 @@ +// RUN: %clang @%S/Inputs/cc1-response.txt -fsyntax-only -disable-llvm-optzns +int main() {} diff --git a/test/Driver/cl-inputs.c b/test/Driver/cl-inputs.c index 029aeadaec42..b0265df52f05 100644 --- a/test/Driver/cl-inputs.c +++ b/test/Driver/cl-inputs.c @@ -34,6 +34,16 @@ // WARN: note: The last /TC or /TP option takes precedence over earlier instances // WARN-NOT: note +// RUN: env LIB=%S/Inputs/cl-libs %clang_cl /c /TP cl-test.lib -### 2>&1 | FileCheck -check-prefix=TPlib %s +// TPlib: warning: cl-test.lib: 'linker' input unused +// TPlib: warning: argument unused during compilation: '/TP' +// TPlib-NOT: cl-test.lib + +// RUN: env LIB=%S/Inputs/cl-libs %clang_cl /c /TC cl-test.lib -### 2>&1 | FileCheck -check-prefix=TClib %s +// TClib: warning: cl-test.lib: 'linker' input unused +// TClib: warning: argument unused during compilation: '/TC' +// TClib-NOT: cl-test.lib + // RUN: not %clang_cl - 2>&1 | FileCheck -check-prefix=STDIN %s // STDIN: error: use /Tc or /Tp diff --git a/test/Driver/cl-link-at-file.c b/test/Driver/cl-link-at-file.c new file mode 100644 index 000000000000..f817ce523ad7 --- /dev/null +++ b/test/Driver/cl-link-at-file.c @@ -0,0 +1,22 @@ +// PR17239 - The /link option, when inside a response file, should only extend +// until the end of the response file (and not the entire command line) + +// Don't attempt slash switches on msys bash. +// REQUIRES: shell-preserves-root + +// Note: %s must be preceded by -- or bound to another option, otherwise it may +// be interpreted as a command-line option, e.g. on Mac where %s is commonly +// under /Users. + +// RUN: echo /link bar.lib baz.lib > %t.args +// RUN: touch %t.obj +// RUN: %clang_cl -### @%t.args -- %t.obj 2>&1 | FileCheck %s -check-prefix=ARGS +// If the "/link" option captures all remaining args beyond its response file, +// it will also capture "--" and our input argument. In this case, Clang will +// be clueless and will emit "argument unused" warnings. If PR17239 is properly +// fixed, this should not happen because the "/link" option is restricted to +// consume only remaining args in its response file. +// ARGS-NOT: warning +// ARGS-NOT: argument unused during compilation +// Identify the linker command +// ARGS: link.exe diff --git a/test/Driver/cl-link.c b/test/Driver/cl-link.c index f4717465d3ec..5bd200117967 100644 --- a/test/Driver/cl-link.c +++ b/test/Driver/cl-link.c @@ -19,6 +19,15 @@ // ASAN: "{{.*}}clang_rt.asan_cxx-i386.lib" // ASAN: "{{.*}}cl-link{{.*}}.obj" +// RUN: %clang_cl /MD /Tc%s -### -fsanitize=address 2>&1 | FileCheck --check-prefix=ASAN-MD %s +// ASAN-MD: link.exe +// ASAN-MD: "-debug" +// ASAN-MD: "-incremental:no" +// ASAN-MD: "{{.*}}clang_rt.asan_dynamic-i386.lib" +// ASAN-MD: "{{.*}}clang_rt.asan_dynamic_runtime_thunk-i386.lib" +// ASAN-MD: "-include:___asan_seh_interceptor" +// ASAN-MD: "{{.*}}cl-link{{.*}}.obj" + // RUN: %clang_cl /LD -### /Tc%s 2>&1 | FileCheck --check-prefix=DLL %s // RUN: %clang_cl /LDd -### /Tc%s 2>&1 | FileCheck --check-prefix=DLL %s // DLL: link.exe diff --git a/test/Driver/cl-options.c b/test/Driver/cl-options.c index 26cd7e9eb4c6..d9fcaf46692e 100644 --- a/test/Driver/cl-options.c +++ b/test/Driver/cl-options.c @@ -135,6 +135,12 @@ // RUN: %clang_cl /w -### -- %s 2>&1 | FileCheck -check-prefix=w %s // w: -w +// RUN: %clang_cl /Zp -### -- %s 2>&1 | FileCheck -check-prefix=ZP %s +// ZP: -fpack-struct=1 + +// RUN: %clang_cl /Zp2 -### -- %s 2>&1 | FileCheck -check-prefix=ZP2 %s +// ZP2: -fpack-struct=2 + // RUN: %clang_cl /Zs -### -- %s 2>&1 | FileCheck -check-prefix=Zs %s // Zs: -fsyntax-only @@ -166,8 +172,12 @@ // (/Zs is for syntax-only) // RUN: %clang_cl /Zs \ // RUN: /analyze- \ +// RUN: /cgthreads4 \ +// RUN: /cgthreads8 \ +// RUN: /d2Zi+ \ // RUN: /errorReport:foo \ // RUN: /FS \ +// RUN: /Gd \ // RUN: /GF \ // RUN: /GS- \ // RUN: /kernel- \ @@ -178,14 +188,14 @@ // RUN: /sdl \ // RUN: /sdl- \ // RUN: /vmg \ +// RUN: /volatile:iso \ // RUN: /w12345 \ // RUN: /wd1234 \ -// RUN: /Zc:forScope \ -// RUN: /Zc:wchar_t \ -// RUN: /Zc:inline \ -// RUN: /Zc:rvalueCast \ +// RUN: /Zo \ +// RUN: /Zo- \ // RUN: -### -- %s 2>&1 | FileCheck -check-prefix=IGNORED %s // IGNORED-NOT: argument unused during compilation +// IGNORED-NOT: no such file or directory // Ignored options and compile-only options are ignored for link jobs. // RUN: touch %t.obj @@ -204,7 +214,6 @@ // RUN: /AIfoo \ // RUN: /clr:pure \ // RUN: /docname \ -// RUN: /d2Zi+ \ // RUN: /EHsc \ // RUN: /F \ // RUN: /FA \ @@ -239,6 +248,7 @@ // RUN: /Gs1000 \ // RUN: /GT \ // RUN: /GX \ +// RUN: /Gv \ // RUN: /Gz \ // RUN: /GZ \ // RUN: /H \ @@ -257,7 +267,7 @@ // RUN: /Qvec-report:2 \ // RUN: /u \ // RUN: /V \ -// RUN: /volatile \ +// RUN: /volatile:ms \ // RUN: /wfoo \ // RUN: /WL \ // RUN: /Wp64 \ @@ -271,15 +281,11 @@ // RUN: /Yustdafx.h \ // RUN: /Z7 \ // RUN: /Za \ -// RUN: /Zc:auto \ -// RUN: /Zc:wchar_t- \ // RUN: /Ze \ // RUN: /Zg \ // RUN: /Zi \ // RUN: /ZI \ // RUN: /Zl \ -// RUN: /Zp \ -// RUN: /Zp1 \ // RUN: /ZW:nostdlib \ // RUN: -- %s 2>&1 diff --git a/test/Driver/cl-outputs.c b/test/Driver/cl-outputs.c index 46502f6427d6..be1172f30fce 100644 --- a/test/Driver/cl-outputs.c +++ b/test/Driver/cl-outputs.c @@ -7,6 +7,9 @@ // RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=DEFAULT %s // DEFAULT: "-o" "cl-outputs.obj" +// RUN: %clang_cl /Fo -### -- %s 2>&1 | FileCheck -check-prefix=FoEMPTY %s +// FoEMPTY: "-o" "cl-outputs.obj" + // RUN: %clang_cl /Foa -### -- %s 2>&1 | FileCheck -check-prefix=FoNAME %s // FoNAME: "-o" "a.obj" @@ -25,15 +28,68 @@ // RUN: %clang_cl /Fo.. -### -- %s 2>&1 | FileCheck -check-prefix=FoCRAZY %s // FoCRAZY: "-o" "..obj" -// RUN: %clang_cl /Fo -### 2>&1 | FileCheck -check-prefix=FoMISSINGARG %s -// FoMISSINGARG: error: argument to '/Fo' is missing (expected 1 value) - // RUN: %clang_cl /Foa.obj -### -- %s %s 2>&1 | FileCheck -check-prefix=CHECK-MULTIPLESOURCEERROR %s // CHECK-MULTIPLESOURCEERROR: error: cannot specify '/Foa.obj' when compiling multiple source files // RUN: %clang_cl /Fomydir/ -### -- %s %s 2>&1 | FileCheck -check-prefix=CHECK-MULTIPLESOURCEOK %s // CHECK-MULTIPLESOURCEOK: "-o" "mydir{{[/\\]+}}cl-outputs.obj" +// RUN: %clang_cl /Fo -### -- %s %s 2>&1 | FileCheck -check-prefix=CHECK-MULTIPLESOURCEOK2 %s +// CHECK-MULTIPLESOURCEOK2: "-o" "cl-outputs.obj" +// CHECK-MULTIPLESOURCEOK2: "-o" "cl-outputs.obj" + +// RUN: %clang_cl /c /oa -### -- %s 2>&1 | FileCheck -check-prefix=oNAME1 %s +// oNAME1: "-o" "a.obj" + +// RUN: %clang_cl /c /o a -### -- %s 2>&1 | FileCheck -check-prefix=oNAME2 %s +// oNAME2: "-o" "a.obj" + +// RUN: %clang_cl /c /oa.ext /ob.ext -### -- %s 2>&1 | FileCheck -check-prefix=oNAMEEXT1 %s +// oNAMEEXT1: "-o" "b.ext" + +// RUN: %clang_cl /c /o a.ext /ob.ext -### -- %s 2>&1 | FileCheck -check-prefix=oNAMEEXT2 %s +// oNAMEEXT2: "-o" "b.ext" + +// RUN: %clang_cl /c /ofoo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=oDIR1 %s +// oDIR1: "-o" "foo.dir{{[/\\]+}}cl-outputs.obj" + +// RUN: %clang_cl /c /o foo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=oDIR2 %s +// oDIR2: "-o" "foo.dir{{[/\\]+}}cl-outputs.obj" + +// RUN: %clang_cl /c /ofoo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=oDIRNAME1 %s +// oDIRNAME1: "-o" "foo.dir{{[/\\]+}}a.obj" + +// RUN: %clang_cl /c /o foo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=oDIRNAME2 %s +// oDIRNAME2: "-o" "foo.dir{{[/\\]+}}a.obj" + +// RUN: %clang_cl /c /ofoo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=oDIRNAMEEXT1 %s +// oDIRNAMEEXT1: "-o" "foo.dir{{[/\\]+}}a.ext" + +// RUN: %clang_cl /c /o foo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=oDIRNAMEEXT2 %s +// oDIRNAMEEXT2: "-o" "foo.dir{{[/\\]+}}a.ext" + +// RUN: %clang_cl /c /o.. -### -- %s 2>&1 | FileCheck -check-prefix=oCRAZY1 %s +// oCRAZY1: "-o" "..obj" + +// RUN: %clang_cl /c /o .. -### -- %s 2>&1 | FileCheck -check-prefix=oCRAZY2 %s +// oCRAZY2: "-o" "..obj" + +// RUN: %clang_cl /c %s -### /o 2>&1 | FileCheck -check-prefix=oMISSINGARG %s +// oMISSINGARG: error: argument to '/o' is missing (expected 1 value) + +// RUN: %clang_cl /c /omydir/ -### -- %s %s 2>&1 | FileCheck -check-prefix=CHECK-oMULTIPLESOURCEOK1 %s +// CHECK-oMULTIPLESOURCEOK1: "-o" "mydir{{[/\\]+}}cl-outputs.obj" + +// RUN: %clang_cl /c /o mydir/ -### -- %s %s 2>&1 | FileCheck -check-prefix=CHECK-oMULTIPLESOURCEOK2 %s +// CHECK-oMULTIPLESOURCEOK2: "-o" "mydir{{[/\\]+}}cl-outputs.obj" + + +// RUN: %clang_cl /c /obar /Fofoo -### -- %s 2>&1 | FileCheck -check-prefix=FooRACE1 %s +// FooRACE1: "-o" "foo.obj" + +// RUN: %clang_cl /c /Fofoo /obar -### -- %s 2>&1 | FileCheck -check-prefix=FooRACE2 %s +// FooRACE2: "-o" "bar.obj" + // RUN: %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=DEFAULTEXE %s // DEFAULTEXE: cl-outputs.exe @@ -46,6 +102,10 @@ // RUN: %clang_cl /Fefoo -### -- %s 2>&1 | FileCheck -check-prefix=FeNOEXT %s // FeNOEXT: "-out:foo.exe" +// RUN: %clang_cl /Fe -### -- %s 2>&1 | FileCheck -check-prefix=FeEMPTY %s +// FeEMPTY-NOT: argument to '/Fe' is missing +// FeEMPTY: "-out:cl-outputs.exe" + // RUN: %clang_cl /Fefoo /LD -### -- %s 2>&1 | FileCheck -check-prefix=FeNOEXTDLL %s // RUN: %clang_cl /Fefoo /LDd -### -- %s 2>&1 | FileCheck -check-prefix=FeNOEXTDLL %s // FeNOEXTDLL: "-out:foo.dll" @@ -83,15 +143,83 @@ // FeDIRNAMEEXTDLL: "-out:foo.dir{{[/\\]+}}a.ext" // FeDIRNAMEEXTDLL: "-implib:foo.dir{{[/\\]+}}a.lib" -// RUN: %clang_cl /Fe -### 2>&1 | FileCheck -check-prefix=FeMISSINGARG %s -// FeMISSINGARG: error: argument to '/Fe' is missing (expected 1 value) - // RUN: %clang_cl /Fefoo /Febar -### -- %s 2>&1 | FileCheck -check-prefix=FeOVERRIDE %s // FeOVERRIDE: "-out:bar.exe" +// RUN: %clang_cl /obar /Fefoo -### -- %s 2>&1 | FileCheck -check-prefix=FeoRACE1 %s +// FeoRACE1: "-out:foo.exe" + +// RUN: %clang_cl /Fefoo /obar -### -- %s 2>&1 | FileCheck -check-prefix=FeoRACE2 %s +// FeoRACE2: "-out:bar.exe" + + +// RUN: %clang_cl /ofoo -### -- %s 2>&1 | FileCheck -check-prefix=FeoNOEXT1 %s +// FeoNOEXT1: "-out:foo.exe" + +// RUN: %clang_cl /o foo -### -- %s 2>&1 | FileCheck -check-prefix=FeoNOEXT2 %s +// FeoNOEXT2: "-out:foo.exe" + +// RUN: %clang_cl /o foo /LD -### -- %s 2>&1 | FileCheck -check-prefix=FeoNOEXTDLL %s +// RUN: %clang_cl /ofoo /LDd -### -- %s 2>&1 | FileCheck -check-prefix=FeoNOEXTDLL %s +// FeoNOEXTDLL: "-out:foo.dll" +// FeoNOEXTDLL: "-implib:foo.lib" + +// RUN: %clang_cl /ofoo.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoEXT1 %s +// FeoEXT1: "-out:foo.ext" + +// RUN: %clang_cl /o foo.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoEXT2 %s +// FeoEXT2: "-out:foo.ext" + +// RUN: %clang_cl /LD /o foo.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoEXTDLL %s +// RUN: %clang_cl /LDd /ofoo.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoEXTDLL %s +// FeoEXTDLL: "-out:foo.ext" +// FeoEXTDLL: "-implib:foo.lib" + +// RUN: %clang_cl /ofoo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIR1 %s +// FeoDIR1: "-out:foo.dir{{[/\\]+}}cl-outputs.exe" + +// RUN: %clang_cl /o foo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIR2 %s +// FeoDIR2: "-out:foo.dir{{[/\\]+}}cl-outputs.exe" + +// RUN: %clang_cl /LD /o foo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRDLL %s +// RUN: %clang_cl /LDd /ofoo.dir/ -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRDLL %s +// FeoDIRDLL: "-out:foo.dir{{[/\\]+}}cl-outputs.dll" +// FeoDIRDLL: "-implib:foo.dir{{[/\\]+}}cl-outputs.lib" + +// RUN: %clang_cl /ofoo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAME1 %s +// FeoDIRNAME1: "-out:foo.dir{{[/\\]+}}a.exe" + +// RUN: %clang_cl /o foo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAME2 %s +// FeoDIRNAME2: "-out:foo.dir{{[/\\]+}}a.exe" + +// RUN: %clang_cl /LD /o foo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEDLL %s +// RUN: %clang_cl /LDd /ofoo.dir/a -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEDLL %s +// FeoDIRNAMEDLL: "-out:foo.dir{{[/\\]+}}a.dll" +// FeoDIRNAMEDLL: "-implib:foo.dir{{[/\\]+}}a.lib" + +// RUN: %clang_cl /ofoo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEEXT1 %s +// FeoDIRNAMEEXT1: "-out:foo.dir{{[/\\]+}}a.ext" + +// RUN: %clang_cl /o foo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEEXT2 %s +// FeoDIRNAMEEXT2: "-out:foo.dir{{[/\\]+}}a.ext" + +// RUN: %clang_cl /LD /o foo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEEXTDLL %s +// RUN: %clang_cl /LDd /ofoo.dir/a.ext -### -- %s 2>&1 | FileCheck -check-prefix=FeoDIRNAMEEXTDLL %s +// FeoDIRNAMEEXTDLL: "-out:foo.dir{{[/\\]+}}a.ext" +// FeoDIRNAMEEXTDLL: "-implib:foo.dir{{[/\\]+}}a.lib" + +// RUN: %clang_cl -### /o 2>&1 | FileCheck -check-prefix=FeoMISSINGARG %s +// FeoMISSINGARG: error: argument to '/o' is missing (expected 1 value) + +// RUN: %clang_cl /ofoo /o bar -### -- %s 2>&1 | FileCheck -check-prefix=FeoOVERRIDE %s +// FeoOVERRIDE: "-out:bar.exe" + + // RUN: %clang_cl /FA -### -- %s 2>&1 | FileCheck -check-prefix=FA %s // FA: "-o" "cl-outputs.asm" +// RUN: %clang_cl /FA /Fa -### -- %s 2>&1 | FileCheck -check-prefix=FaEMPTY %s +// FaEMPTY: "-o" "cl-outputs.asm" // RUN: %clang_cl /FA /Fafoo -### -- %s 2>&1 | FileCheck -check-prefix=FaNAME %s // RUN: %clang_cl /Fafoo -### -- %s 2>&1 | FileCheck -check-prefix=FaNAME %s // FaNAME: "-o" "foo.asm" @@ -105,6 +233,9 @@ // FaDIRNAMEEXT: "-o" "foo.dir{{[/\\]+}}a.ext" // RUN: %clang_cl /Faa.asm -### -- %s %s 2>&1 | FileCheck -check-prefix=FaMULTIPLESOURCE %s // FaMULTIPLESOURCE: error: cannot specify '/Faa.asm' when compiling multiple source files +// RUN: %clang_cl /Fa -### -- %s %s 2>&1 | FileCheck -check-prefix=FaMULTIPLESOURCEOK %s +// FaMULTIPLESOURCEOK: "-o" "cl-outputs.asm" +// FaMULTIPLESOURCEOK: "-o" "cl-outputs.asm" // RUN: %clang_cl /P -### -- %s 2>&1 | FileCheck -check-prefix=P %s // P: "-E" @@ -117,3 +248,28 @@ // RUN: %clang_cl /P /Fifoo.x -### -- %s 2>&1 | FileCheck -check-prefix=Fi2 %s // Fi2: "-E" // Fi2: "-o" "foo.x" + +// RUN: %clang_cl /P /ofoo -### -- %s 2>&1 | FileCheck -check-prefix=Fio1 %s +// Fio1: "-E" +// Fio1: "-o" "foo.i" + +// RUN: %clang_cl /P /o foo -### -- %s 2>&1 | FileCheck -check-prefix=Fio2 %s +// Fio2: "-E" +// Fio2: "-o" "foo.i" + +// RUN: %clang_cl /P /ofoo.x -### -- %s 2>&1 | FileCheck -check-prefix=Fio3 %s +// Fio3: "-E" +// Fio3: "-o" "foo.x" + +// RUN: %clang_cl /P /o foo.x -### -- %s 2>&1 | FileCheck -check-prefix=Fio4 %s +// Fio4: "-E" +// Fio4: "-o" "foo.x" + + +// RUN: %clang_cl /P /obar.x /Fifoo.x -### -- %s 2>&1 | FileCheck -check-prefix=FioRACE1 %s +// FioRACE1: "-E" +// FioRACE1: "-o" "foo.x" + +// RUN: %clang_cl /P /Fifoo.x /obar.x -### -- %s 2>&1 | FileCheck -check-prefix=FioRACE2 %s +// FioRACE2: "-E" +// FioRACE2: "-o" "bar.x" diff --git a/test/Driver/cl-zc.cpp b/test/Driver/cl-zc.cpp new file mode 100644 index 000000000000..639095fded80 --- /dev/null +++ b/test/Driver/cl-zc.cpp @@ -0,0 +1,59 @@ +// Don't attempt slash switches on msys bash. +// REQUIRES: shell-preserves-root + +// Note: %s must be preceded by --, otherwise it may be interpreted as a +// command-line option, e.g. on Mac where %s is commonly under /Users. + +// RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=TRIGRAPHS-DEFAULT %s +// cc1 will disable trigraphs for -fms-compatibility as long as -ftrigraphs +// isn't explicitly passed. +// TRIGRAPHS-DEFAULT-NOT: "-ftrigraphs" + +// RUN: %clang_cl /c -### /Zc:trigraphs -- %s 2>&1 | FileCheck -check-prefix=TRIGRAPHS-ON %s +// TRIGRAPHS-ON: "-ftrigraphs" + +// RUN: %clang_cl /c -### /Zc:trigraphs- -- %s 2>&1 | FileCheck -check-prefix=TRIGRAPHS-OFF %s +// TRIGRAPHS-OFF: "-fno-trigraphs" + +// RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-DEFAULT %s +// STRICTSTRINGS-DEFAULT-NOT: -Werror=c++11-compat-deprecated-writable-strings +// RUN: %clang_cl /c -### /Zc:strictStrings -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-ON %s +// STRICTSTRINGS-ON: -Werror=c++11-compat-deprecated-writable-strings +// RUN: %clang_cl /c -### /Zc:strictStrings- -- %s 2>&1 | FileCheck -check-prefix=STRICTSTRINGS-OFF %s +// STRICTSTRINGS-OFF: argument unused during compilation + + +// RUN: %clang_cl /c -### /Zc:foobar -- %s 2>&1 | FileCheck -check-prefix=FOOBAR-ON %s +// FOOBAR-ON: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:foobar- -- %s 2>&1 | FileCheck -check-prefix=FOOBAR-ON %s +// FOOBAR-OFF: argument unused during compilation + +// These are ignored if enabled, and warn if disabled. + +// RUN: %clang_cl /c -### /Zc:forScope -- %s 2>&1 | FileCheck -check-prefix=FORSCOPE-ON %s +// FORSCOPE-ON-NOT: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:forScope- -- %s 2>&1 | FileCheck -check-prefix=FORSCOPE-OFF %s +// FORSCOPE-OFF: argument unused during compilation + +// RUN: %clang_cl /c -### /Zc:wchar_t -- %s 2>&1 | FileCheck -check-prefix=WCHAR_T-ON %s +// WCHAR_T-ON-NOT: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:wchar_t- -- %s 2>&1 | FileCheck -check-prefix=WCHAR_T-OFF %s +// WCHAR_T-OFF: argument unused during compilation + +// RUN: %clang_cl /c -### /Zc:auto -- %s 2>&1 | FileCheck -check-prefix=AUTO-ON %s +// AUTO-ON-NOT: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:auto- -- %s 2>&1 | FileCheck -check-prefix=AUTO-OFF %s +// AUTO-OFF: argument unused during compilation + +// RUN: %clang_cl /c -### /Zc:inline -- %s 2>&1 | FileCheck -check-prefix=INLINE-ON %s +// INLINE-ON-NOT: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:inline- -- %s 2>&1 | FileCheck -check-prefix=INLINE-OFF %s +// INLINE-OFF: argument unused during compilation + + +// These never warn, but don't have an effect yet. + +// RUN: %clang_cl /c -### /Zc:rvalueCast -- %s 2>&1 | FileCheck -check-prefix=RVALUECAST-ON %s +// RVALUECAST-ON-NOT: argument unused during compilation +// RUN: %clang_cl /c -### /Zc:rvalueCast- -- %s 2>&1 | FileCheck -check-prefix=RVALUECAST-OFF %s +// RVALUECAST-OFF: argument unused during compilation diff --git a/test/Driver/clang-g-opts.c b/test/Driver/clang-g-opts.c index a9566b7ee1d5..4a1e71908b9c 100644 --- a/test/Driver/clang-g-opts.c +++ b/test/Driver/clang-g-opts.c @@ -17,6 +17,8 @@ // RUN: | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s // RUN: %clang -### -S %s -g0 -g -target x86_64-pc-freebsd10.0 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s +// RUN: %clang -### -S %s -g0 -g -target i386-pc-solaris 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s // CHECK-WITHOUT-G-NOT: "-g" // CHECK-WITH-G: "-g" diff --git a/test/Driver/clang-s-opts.s b/test/Driver/clang-s-opts.s new file mode 100644 index 000000000000..f29270882f0a --- /dev/null +++ b/test/Driver/clang-s-opts.s @@ -0,0 +1,4 @@ +// RUN: %clang -### -c -flto -fno-lto %s 2>&1 | FileCheck %s +// RUN: %clang -### -c -flto -fno-lto -fno-integrated-as %s 2>&1 | FileCheck %s + +// CHECK-NOT: argument unused during compilation diff --git a/test/Driver/clang_f_opts.c b/test/Driver/clang_f_opts.c index 796da768769e..3ca9f2847523 100644 --- a/test/Driver/clang_f_opts.c +++ b/test/Driver/clang_f_opts.c @@ -59,6 +59,13 @@ // RUN: %clang -### -S -fauto-profile=%S/Inputs/file.prof %s 2>&1 | FileCheck -check-prefix=CHECK-AUTO-PROFILE %s // CHECK-AUTO-PROFILE: "-fprofile-sample-use={{.*}}/file.prof" +// RUN: %clang -### -S -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-PROFILE-ARCS %s +// RUN: %clang -### -S -fno-profile-arcs -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-PROFILE-ARCS %s +// RUN: %clang -### -S -fno-profile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-NO-PROFILE-ARCS %s +// RUN: %clang -### -S -fprofile-arcs -fno-profile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-NO-PROFILE-ARCS %s +// CHECK-PROFILE-ARCS: "-femit-coverage-data" +// CHECK-NO-PROFILE-ARCS-NOT: "-femit-coverage-data" + // RUN: %clang -### -S -fvectorize %s 2>&1 | FileCheck -check-prefix=CHECK-VECTORIZE %s // RUN: %clang -### -S -fno-vectorize -fvectorize %s 2>&1 | FileCheck -check-prefix=CHECK-VECTORIZE %s // RUN: %clang -### -S -fno-vectorize %s 2>&1 | FileCheck -check-prefix=CHECK-NO-VECTORIZE %s @@ -132,6 +139,9 @@ // RUN: %clang -### -S -finput-charset=iso-8859-1 -o /dev/null %s 2>&1 | FileCheck -check-prefix=CHECK-INVALID-CHARSET %s // CHECK-INVALID-CHARSET: error: invalid value 'iso-8859-1' in '-finput-charset=iso-8859-1' +// RUN: %clang -### -S -fexec-charset=iso-8859-1 -o /dev/null %s 2>&1 | FileCheck -check-prefix=CHECK-INVALID-INPUT-CHARSET %s +// CHECK-INVALID-INPUT-CHARSET: error: invalid value 'iso-8859-1' in '-fexec-charset=iso-8859-1' + // Test that we don't error on these. // RUN: %clang -### -S -Werror \ // RUN: -falign-functions -falign-functions=2 -fno-align-functions \ @@ -144,6 +154,7 @@ // RUN: -fident -fno-ident \ // RUN: -fimplicit-templates -fno-implicit-templates \ // RUN: -finput-charset=UTF-8 \ +// RUN: -fexec-charset=UTF-8 \ // RUN: -fivopts -fno-ivopts \ // RUN: -fnon-call-exceptions -fno-non-call-exceptions \ // RUN: -fpermissive -fno-permissive \ @@ -166,6 +177,56 @@ // RUN: -fstrength-reduce -fno-strength-reduce \ // RUN: -finline-limit=1000 \ // RUN: -finline-limit \ +// RUN: -flto=1 \ +// RUN: -falign-labels \ +// RUN: -falign-labels=100 \ +// RUN: -falign-loops \ +// RUN: -falign-loops=100 \ +// RUN: -falign-jumps \ +// RUN: -falign-jumps=100 \ +// RUN: -fexcess-precision=100 \ +// RUN: -fbranch-count-reg \ +// RUN: -fcaller-saves \ +// RUN: -fno-default-inline -fdefault-inline \ +// RUN: -fgcse-after-reload \ +// RUN: -fgcse-las \ +// RUN: -fgcse-sm \ +// RUN: -fipa-cp \ +// RUN: -finline-functions-called-once \ +// RUN: -fmodulo-sched \ +// RUN: -fmodulo-sched-allow-regmoves \ +// RUN: -fpeel-loops \ +// RUN: -frename-registers \ +// RUN: -fschedule-insns2 \ +// RUN: -fsingle-precision-constant \ +// RUN: -ftree_loop_im \ +// RUN: -ftree_loop_ivcanon \ +// RUN: -ftree_loop_linear \ +// RUN: -funsafe-loop-optimizations \ +// RUN: -fuse-linker-plugin \ +// RUN: -fvect-cost-model \ +// RUN: -fvariable-expansion-in-unroller \ +// RUN: -fweb \ +// RUN: -fwhole-program \ +// RUN: -fno-tree-dce -ftree-dce \ +// RUN: -fno-tree-ter -ftree-ter \ +// RUN: -fno-tree-vrp -ftree-vrp \ +// RUN: -fno-delete-null-pointer-checks -fdelete-null-pointer-checks \ +// RUN: -fno-inline-small-functions -finline-small-functions \ +// RUN: -fno-fat-lto-objects -ffat-lto-objects \ +// RUN: -fno-merge-constants -fmerge-constants \ +// RUN: -fno-caller-saves -fcaller-saves \ +// RUN: -fno-reorder-blocks -freorder-blocks \ +// RUN: -fno-schedule-insns2 -fschedule-insns2 \ +// RUN: -fno-stack-check \ +// RUN: -fno-check-new -fcheck-new \ +// RUN: -ffriend-injection \ +// RUN: -fno-implement-inlines -fimplement-inlines \ +// RUN: -fstack-check \ +// RUN: -fforce-addr \ +// RUN: -malign-functions=100 \ +// RUN: -malign-loops=100 \ +// RUN: -malign-jumps=100 \ // RUN: %s 2>&1 | FileCheck --check-prefix=IGNORE %s // IGNORE-NOT: error: unknown argument @@ -177,6 +238,7 @@ // RUN: -fno-expensive-optimizations \ // RUN: -fno-defer-pop \ // RUN: -finline-functions \ +// RUN: -fkeep-inline-functions \ // RUN: -fno-keep-inline-functions \ // RUN: -freorder-blocks \ // RUN: -fprofile-dir=/rand/dir \ @@ -197,6 +259,48 @@ // RUN: -ftracer \ // RUN: -funroll-all-loops \ // RUN: -funswitch-loops \ +// RUN: -flto=1 \ +// RUN: -falign-labels \ +// RUN: -falign-labels=100 \ +// RUN: -falign-loops \ +// RUN: -falign-loops=100 \ +// RUN: -falign-jumps \ +// RUN: -falign-jumps=100 \ +// RUN: -fexcess-precision=100 \ +// RUN: -fbranch-count-reg \ +// RUN: -fcaller-saves \ +// RUN: -fno-default-inline \ +// RUN: -fgcse-after-reload \ +// RUN: -fgcse-las \ +// RUN: -fgcse-sm \ +// RUN: -fipa-cp \ +// RUN: -finline-functions-called-once \ +// RUN: -fmodulo-sched \ +// RUN: -fmodulo-sched-allow-regmoves \ +// RUN: -fpeel-loops \ +// RUN: -frename-registers \ +// RUN: -fschedule-insns2 \ +// RUN: -fsingle-precision-constant \ +// RUN: -ftree_loop_im \ +// RUN: -ftree_loop_ivcanon \ +// RUN: -ftree_loop_linear \ +// RUN: -funsafe-loop-optimizations \ +// RUN: -fuse-linker-plugin \ +// RUN: -fvect-cost-model \ +// RUN: -fvariable-expansion-in-unroller \ +// RUN: -fweb \ +// RUN: -fwhole-program \ +// RUN: -fcaller-saves \ +// RUN: -freorder-blocks \ +// RUN: -fdelete-null-pointer-checks \ +// RUN: -ffat-lto-objects \ +// RUN: -fmerge-constants \ +// RUN: -finline-small-functions \ +// RUN: -ftree-dce \ +// RUN: -ftree-ter \ +// RUN: -ftree-vrp \ +// RUN: -fno-devirtualize \ +// RUN: -fno-devirtualize-speculatively \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING %s // CHECK-WARNING-DAG: optimization flag '-finline-limit=1000' is not supported // CHECK-WARNING-DAG: optimization flag '-finline-limit' is not supported @@ -204,6 +308,7 @@ // CHECK-WARNING-DAG: optimization flag '-fno-expensive-optimizations' is not supported // CHECK-WARNING-DAG: optimization flag '-fno-defer-pop' is not supported // CHECK-WARNING-DAG: optimization flag '-finline-functions' is not supported +// CHECK-WARNING-DAG: optimization flag '-fkeep-inline-functions' is not supported // CHECK-WARNING-DAG: optimization flag '-fno-keep-inline-functions' is not supported // CHECK-WARNING-DAG: optimization flag '-freorder-blocks' is not supported // CHECK-WARNING-DAG: optimization flag '-fprofile-dir=/rand/dir' is not supported @@ -224,12 +329,57 @@ // CHECK-WARNING-DAG: optimization flag '-ftracer' is not supported // CHECK-WARNING-DAG: optimization flag '-funroll-all-loops' is not supported // CHECK-WARNING-DAG: optimization flag '-funswitch-loops' is not supported +// CHECK-WARNING-DAG: optimization flag '-flto=1' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-labels' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-labels=100' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-loops' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-loops=100' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-jumps' is not supported +// CHECK-WARNING-DAG: optimization flag '-falign-jumps=100' is not supported +// CHECK-WARNING-DAG: optimization flag '-fexcess-precision=100' is not supported +// CHECK-WARNING-DAG: optimization flag '-fbranch-count-reg' is not supported +// CHECK-WARNING-DAG: optimization flag '-fcaller-saves' is not supported +// CHECK-WARNING-DAG: optimization flag '-fno-default-inline' is not supported +// CHECK-WARNING-DAG: optimization flag '-fgcse-after-reload' is not supported +// CHECK-WARNING-DAG: optimization flag '-fgcse-las' is not supported +// CHECK-WARNING-DAG: optimization flag '-fgcse-sm' is not supported +// CHECK-WARNING-DAG: optimization flag '-fipa-cp' is not supported +// CHECK-WARNING-DAG: optimization flag '-finline-functions-called-once' is not supported +// CHECK-WARNING-DAG: optimization flag '-fmodulo-sched' is not supported +// CHECK-WARNING-DAG: optimization flag '-fmodulo-sched-allow-regmoves' is not supported +// CHECK-WARNING-DAG: optimization flag '-fpeel-loops' is not supported +// CHECK-WARNING-DAG: optimization flag '-frename-registers' is not supported +// CHECK-WARNING-DAG: optimization flag '-fschedule-insns2' is not supported +// CHECK-WARNING-DAG: optimization flag '-fsingle-precision-constant' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree_loop_im' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree_loop_ivcanon' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree_loop_linear' is not supported +// CHECK-WARNING-DAG: optimization flag '-funsafe-loop-optimizations' is not supported +// CHECK-WARNING-DAG: optimization flag '-fuse-linker-plugin' is not supported +// CHECK-WARNING-DAG: optimization flag '-fvect-cost-model' is not supported +// CHECK-WARNING-DAG: optimization flag '-fvariable-expansion-in-unroller' is not supported +// CHECK-WARNING-DAG: optimization flag '-fweb' is not supported +// CHECK-WARNING-DAG: optimization flag '-fwhole-program' is not supported +// CHECK-WARNING-DAG: optimization flag '-fcaller-saves' is not supported +// CHECK-WARNING-DAG: optimization flag '-freorder-blocks' is not supported +// CHECK-WARNING-DAG: optimization flag '-fdelete-null-pointer-checks' is not supported +// CHECK-WARNING-DAG: optimization flag '-ffat-lto-objects' is not supported +// CHECK-WARNING-DAG: optimization flag '-fmerge-constants' is not supported +// CHECK-WARNING-DAG: optimization flag '-finline-small-functions' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree-dce' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree-ter' is not supported +// CHECK-WARNING-DAG: optimization flag '-ftree-vrp' is not supported +// CHECK-WARNING-DAG: optimization flag '-fno-devirtualize' is not supported +// CHECK-WARNING-DAG: optimization flag '-fno-devirtualize-speculatively' is not supported // Test that we mute the warning on these // RUN: %clang -### -finline-limit=1000 -Wno-invalid-command-line-argument \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-NO-WARNING1 %s // RUN: %clang -### -finline-limit -Wno-invalid-command-line-argument \ // RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-NO-WARNING2 %s +// RUN: %clang -### -finline-limit \ +// RUN: -Winvalid-command-line-argument -Wno-ignored-optimization-argument \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-NO-WARNING2 %s // CHECK-NO-WARNING1-NOT: optimization flag '-finline-limit=1000' is not supported // CHECK-NO-WARNING2-NOT: optimization flag '-finline-limit' is not supported diff --git a/test/Driver/constructors.c b/test/Driver/constructors.c index a8b0942f01f4..cd14ed736a28 100644 --- a/test/Driver/constructors.c +++ b/test/Driver/constructors.c @@ -7,49 +7,58 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/fake_install_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -fno-use-init-array \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/fake_install_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-NO-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -fno-use-init-array -fuse-init-array \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/fake_install_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-NO-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -fuse-init-array \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target arm-unknown-linux-androideabi \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target mipsel-unknown-linux-android \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target i386-unknown-linux-android \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target aarch64-none-linux-gnu \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ @@ -59,6 +68,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target arm64-none-linux-gnu \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-INIT-ARRAY %s // // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ diff --git a/test/Driver/coverage_no_integrated_as.c b/test/Driver/coverage_no_integrated_as.c new file mode 100644 index 000000000000..6f85b422d994 --- /dev/null +++ b/test/Driver/coverage_no_integrated_as.c @@ -0,0 +1,23 @@ +// REQUIRES: clang-driver +// XFAIL: win32,win64 + +// RUN: %clang -### -S -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s +// RUN: %clang -### -S -fprofile-arcs -no-integrated-as %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s +// RUN: %clang -### -c -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s +// RUN: %clang -### -c -fprofile-arcs -no-integrated-as %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s + +// RUN: %clang -### -S -fprofile-arcs %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s +// RUN: %clang -### -S -fprofile-arcs -no-integrated-as %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s +// RUN: %clang -### -c -fprofile-arcs %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s +// RUN: %clang -### -c -fprofile-arcs -no-integrated-as %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s + +// RUN: %clang -### -S -fprofile-arcs %s -o foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION-REL-PATH %s +// RUN: %clang -### -S -fprofile-arcs -no-integrated-as %s -o foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION-REL-PATH %s +// RUN: %clang -### -c -fprofile-arcs %s -o foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION-REL-PATH %s +// RUN: %clang -### -c -fprofile-arcs -no-integrated-as %s -o foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION-REL-PATH %s + + +// CHECK-GCNO-DEFAULT-LOCATION: "-coverage-file" "{{.*}}/coverage_no_integrated_as.c" +// CHECK-GCNO-DEFAULT-LOCATION-NOT: "-coverage-file" "/tmp/{{.*}}/coverage_no_integrated_as.c" +// CHECK-GCNO-LOCATION: "-coverage-file" "/foo/bar.o" +// CHECK-GCNO-LOCATION-REL-PATH: "-coverage-file" "{{.*}}/foo/bar.o" diff --git a/test/Driver/crash report spaces.c b/test/Driver/crash report spaces.c new file mode 100644 index 000000000000..9bc4626b48b8 --- /dev/null +++ b/test/Driver/crash report spaces.c @@ -0,0 +1,18 @@ +// RUN: rm -rf "%t" +// RUN: mkdir "%t" +// RUN: not env TMPDIR="%t" TEMP="%t" TMP="%t" RC_DEBUG_OPTIONS=1 %clang -fsyntax-only "%s" 2>&1 | FileCheck "%s" +// RUN: cat "%t/crash report spaces"-*.c | FileCheck --check-prefix=CHECKSRC "%s" +// RUN: cat "%t/crash report spaces"-*.sh | FileCheck --check-prefix=CHECKSH "%s" +// REQUIRES: crash-recovery + +// because of the glob (*.c, *.sh) +// REQUIRES: shell + +#pragma clang __debug parser_crash +// CHECK: Preprocessed source(s) and associated run script(s) are located at: +// CHECK-NEXT: note: diagnostic msg: {{.*}}.c +FOO +// CHECKSRC: FOO +// CHECKSH: "-cc1" +// CHECKSH: "-main-file-name" "crash report spaces.c" +// CHECKSH: "crash report spaces-{{[^ ]*}}.c" diff --git a/test/Driver/crash-report-modules.m b/test/Driver/crash-report-modules.m index d1c7832019cf..84b16044486b 100644 --- a/test/Driver/crash-report-modules.m +++ b/test/Driver/crash-report-modules.m @@ -25,8 +25,8 @@ const int x = MODULE_MACRO; // CHECKSRC: @import simple; // CHECKSRC: const int x = 10; -// CHECKSH: -cc1 -// CHECKSH: -D "FOO=BAR" -// CHECKSH-NOT: -fmodules-cache-path=/tmp/ -// CHECKSH: crash-report-modules-{{[^ ]*}}.m -// CHECKSH: -ivfsoverlay crash-report-modules-{{[^ ]*}}.cache/vfs/vfs.yaml +// CHECKSH: "-cc1" +// CHECKSH: "-D" "FOO=BAR" +// CHECKSH-NOT: "-fmodules-cache-path=/tmp/" +// CHECKSH: "crash-report-modules-{{[^ ]*}}.m" +// CHECKSH: "-ivfsoverlay" "crash-report-modules-{{[^ ]*}}.cache/vfs/vfs.yaml" diff --git a/test/Driver/crash-report-null.test b/test/Driver/crash-report-null.test new file mode 100644 index 000000000000..477dd28df3ed --- /dev/null +++ b/test/Driver/crash-report-null.test @@ -0,0 +1,7 @@ +// RUN: not env FORCE_CLANG_DIAGNOSTICS_CRASH=1 %clang -fsyntax-only -x c /dev/null -lstdc++ 2>&1 | FileCheck %s + +// FIXME: Investigating. "fatal error: file 'nul' modified since it was first processed" +// XFAIL: mingw32 + +// CHECK: Preprocessed source(s) and associated run script(s) are located at: +// CHECK-NEXT: note: diagnostic msg: {{.*}}null-{{.*}}.c diff --git a/test/Driver/crash-report.c b/test/Driver/crash-report.c index da1ff950fb9a..3370da88692f 100644 --- a/test/Driver/crash-report.c +++ b/test/Driver/crash-report.c @@ -13,27 +13,23 @@ // because of the glob (*.c, *.sh) // REQUIRES: shell -// RUN: not env FORCE_CLANG_DIAGNOSTICS_CRASH=1 %clang -fsyntax-only -x c /dev/null -lstdc++ 2>&1 | FileCheck %s - -// FIXME: Investigating. "fatal error: file 'nul' modified since it was first processed" -// XFAIL: mingw32 - #pragma clang __debug parser_crash // CHECK: Preprocessed source(s) and associated run script(s) are located at: -// CHECK-NEXT: note: diagnostic msg: {{.*}}.c +// CHECK-NEXT: note: diagnostic msg: {{.*}}crash-report-{{.*}}.c FOO // CHECKSRC: FOO -// CHECKSH: -cc1 -// CHECKSH: -D "FOO=BAR" -// CHECKSH-NOT: -F/tmp/ -// CHECKSH-NOT: -I /tmp/ -// CHECKSH-NOT: -idirafter /tmp/ -// CHECKSH-NOT: -iquote /tmp/ -// CHECKSH-NOT: -isystem /tmp/ -// CHECKSH-NOT: -iprefix /the/prefix -// CHECKSH-NOT: -iwithprefix /tmp/ -// CHECKSH-NOT: -iwithprefixbefore /tmp/ -// CHECKSH-NOT: -internal-isystem /tmp/ -// CHECKSH-NOT: -internal-externc-isystem /tmp/ -// CHECKSH-NOT: -dwarf-debug-flags -// CHECKSH: crash-report-{{[^ ]*}}.c +// CHECKSH: "-cc1" +// CHECKSH: "-main-file-name" "crash-report.c" +// CHECKSH: "-D" "FOO=BAR" +// CHECKSH-NOT: "-F/tmp/" +// CHECKSH-NOT: "-I" "/tmp/" +// CHECKSH-NOT: "-idirafter" "/tmp/" +// CHECKSH-NOT: "-iquote" "/tmp/" +// CHECKSH-NOT: "-isystem" "/tmp/" +// CHECKSH-NOT: "-iprefix" "/the/prefix" +// CHECKSH-NOT: "-iwithprefix" "/tmp/" +// CHECKSH-NOT: "-iwithprefixbefore" "/tmp/" +// CHECKSH-NOT: "-internal-isystem" "/tmp/" +// CHECKSH-NOT: "-internal-externc-isystem" "/tmp/" +// CHECKSH-NOT: "-dwarf-debug-flags" +// CHECKSH: "crash-report-{{[^ ]*}}.c" diff --git a/test/Driver/cross-linux.c b/test/Driver/cross-linux.c index ade8d8f62f33..3b1350489294 100644 --- a/test/Driver/cross-linux.c +++ b/test/Driver/cross-linux.c @@ -3,24 +3,24 @@ // RUN: --target=i386-unknown-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-I386 %s // CHECK-I386: "-cc1" "-triple" "i386-unknown-linux-gnu" -// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\}}as" "--32" -// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\}}ld" {{.*}} "-m" "elf_i386" +// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\\\}}as" "--32" +// CHECK-I386: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/i386-unknown-linux-gnu/4.6.0/../../../../i386-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf_i386" // // RUN: %clang -### -o %t %s 2>&1 -no-integrated-as \ // RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \ // RUN: --target=x86_64-unknown-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-X86-64 %s // CHECK-X86-64: "-cc1" "-triple" "x86_64-unknown-linux-gnu" -// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\}}as" "--64" -// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\}}ld" {{.*}} "-m" "elf_x86_64" +// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}as" "--64" +// CHECK-X86-64: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf_x86_64" // // RUN: %clang -### -o %t %s 2>&1 -no-integrated-as \ // RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \ // RUN: --target=x86_64-unknown-linux-gnux32 \ // RUN: | FileCheck --check-prefix=CHECK-X32 %s // CHECK-X32: "-cc1" "-triple" "x86_64-unknown-linux-gnux32" -// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\}}as" "--x32" -// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\}}ld" {{.*}} "-m" "elf32_x86_64" +// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}as" "--x32" +// CHECK-X32: "{{.*}}/Inputs/basic_cross_linux_tree/usr/lib/gcc/x86_64-unknown-linux-gnu/4.6.0/../../../../x86_64-unknown-linux-gnu/bin{{/|\\\\}}ld" {{.*}} "-m" "elf32_x86_64" // // RUN: %clang -### -o %t %s 2>&1 -no-integrated-as \ // RUN: --gcc-toolchain=%S/Inputs/basic_cross_linux_tree/usr \ @@ -38,8 +38,8 @@ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-MULTI32-I386 %s // CHECK-MULTI32-I386: "-cc1" "-triple" "i386-unknown-linux" -// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\}}as" "--32" -// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\}}ld" +// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}as" "--32" +// CHECK-MULTI32-I386: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}ld" // CHECK-MULTI32-I386: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]" // CHECK-MULTI32-I386: "-m" "elf_i386" // CHECK-MULTI32-I386: "crti.o" "[[gcc_install:.*/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0]]{{/|\\\\}}crtbegin.o" @@ -55,8 +55,8 @@ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-MULTI32-X86-64 %s // CHECK-MULTI32-X86-64: "-cc1" "-triple" "x86_64-unknown-linux" -// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\}}as" "--64" -// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\}}ld" +// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}as" "--64" +// CHECK-MULTI32-X86-64: "{{.*}}/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/bin{{/|\\\\}}ld" // CHECK-MULTI32-X86-64: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]" // CHECK-MULTI32-X86-64: "-m" "elf_x86_64" // CHECK-MULTI32-X86-64: "crti.o" "[[gcc_install:.*/Inputs/multilib_32bit_linux_tree/usr/lib/gcc/i386-unknown-linux/4.6.0]]/64{{/|\\\\}}crtbegin.o" @@ -73,8 +73,8 @@ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-MULTI64-I386 %s // CHECK-MULTI64-I386: "-cc1" "-triple" "i386-unknown-linux" -// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\}}as" "--32" -// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\}}ld" +// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}as" "--32" +// CHECK-MULTI64-I386: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}ld" // CHECK-MULTI64-I386: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]" // CHECK-MULTI64-I386: "-m" "elf_i386" // CHECK-MULTI64-I386: "crti.o" "[[gcc_install:.*/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0]]/32{{/|\\\\}}crtbegin.o" @@ -91,8 +91,8 @@ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-MULTI64-X86-64 %s // CHECK-MULTI64-X86-64: "-cc1" "-triple" "x86_64-unknown-linux" -// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\}}as" "--64" -// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\}}ld" +// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}as" "--64" +// CHECK-MULTI64-X86-64: "{{.*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/bin{{/|\\\\}}ld" // CHECK-MULTI64-X86-64: "--sysroot=[[sysroot:.*/Inputs/basic_linux_tree]]" // CHECK-MULTI64-X86-64: "-m" "elf_x86_64" // CHECK-MULTI64-X86-64: "crti.o" "[[gcc_install:.*/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0]]{{/|\\\\}}crtbegin.o" diff --git a/test/Driver/darwin-arch-default.c b/test/Driver/darwin-arch-default.c index 60bf61de8a34..e7e5e89ed085 100644 --- a/test/Driver/darwin-arch-default.c +++ b/test/Driver/darwin-arch-default.c @@ -2,6 +2,42 @@ // // RUN: %clang -target powerpc-apple-darwin8 -### \ // RUN: -ccc-print-phases %s 2> %t -// RUN: FileCheck --check-prefix=CHECK-POWERPC < %t %s +// RUN: FileCheck --check-prefix=CHECK-BIND-PPC < %t %s // -// CHECK-POWERPC: bind-arch, "ppc" +// CHECK-BIND-PPC: bind-arch, "ppc" +// +// RUN: %clang -target powerpc64-apple-darwin8 -### \ +// RUN: -ccc-print-phases %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-BIND-PPC64 < %t %s +// +// CHECK-BIND-PPC64: bind-arch, "ppc64" + +// Check that the correct arch name is passed to the external assembler +// +// RUN: %clang -target powerpc-apple-darwin8 -### \ +// RUN: -no-integrated-as -c %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-AS-PPC < %t %s +// +// CHECK-AS-PPC: {{as(.exe)?"}} +// CHECK-AS-PPC: "-arch" "ppc" +// +// RUN: %clang -target powerpc64-apple-darwin8 -### \ +// RUN: -no-integrated-as -c %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-AS-PPC64 < %t %s +// +// CHECK-AS-PPC64: {{as(.exe)?"}} +// CHECK-AS-PPC64: "-arch" "ppc64" + +// Check that the correct arch name is passed to the external linker +// +// RUN: %clang -target powerpc-apple-darwin8 -### %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-LD-PPC < %t %s +// +// CHECK-LD-PPC: {{ld(.exe)?"}} +// CHECK-LD-PPC: "-arch" "ppc" +// +// RUN: %clang -target powerpc64-apple-darwin8 -### %s 2> %t +// RUN: FileCheck --check-prefix=CHECK-LD-PPC64 < %t %s +// +// CHECK-LD-PPC64: {{ld(.exe)?"}} +// CHECK-LD-PPC64: "-arch" "ppc64" diff --git a/test/Driver/darwin-debug-flags.c b/test/Driver/darwin-debug-flags.c index f98e9ce7bd8c..abe3f6953e32 100644 --- a/test/Driver/darwin-debug-flags.c +++ b/test/Driver/darwin-debug-flags.c @@ -1,11 +1,12 @@ -// RUN: env RC_DEBUG_OPTIONS=1 %clang -target i386-apple-darwin9 -g -Os %s -emit-llvm -S -o - | FileCheck %s +// RUN: env RC_DEBUG_OPTIONS=1 %clang -target i386-apple-darwin9 -I "path with \spaces" -g -Os %s -emit-llvm -S -o - | FileCheck %s // <rdar://problem/7256886> // RUN: touch %t.s // RUN: env RC_DEBUG_OPTIONS=1 %clang -### -target i386-apple-darwin9 -c -g %t.s 2>&1 | FileCheck -check-prefix=S %s // <rdar://problem/12955296> // RUN: %clang -### -target i386-apple-darwin9 -c -g %t.s 2>&1 | FileCheck -check-prefix=P %s -// CHECK: !0 = metadata !{ +// CHECK: !0 = !{ +// CHECK: -I path\5C with\5C \5C\5Cspaces // CHECK: -g -Os // CHECK: -mmacosx-version-min=10.5.0 // CHECK: [ DW_TAG_compile_unit ] @@ -15,3 +16,6 @@ int x; // S: "-dwarf-debug-flags" // P: "-dwarf-debug-producer" + +// This depends on shell quoting. +// REQUIRES: shell diff --git a/test/Driver/darwin-dsymutil.c b/test/Driver/darwin-dsymutil.c index 59084a2c85ed..0e2c4907104e 100644 --- a/test/Driver/darwin-dsymutil.c +++ b/test/Driver/darwin-dsymutil.c @@ -6,13 +6,14 @@ // // CHECK-MULTIARCH-ACTIONS: 0: input, "{{.*}}darwin-dsymutil.c", c // CHECK-MULTIARCH-ACTIONS: 1: preprocessor, {0}, cpp-output -// CHECK-MULTIARCH-ACTIONS: 2: compiler, {1}, assembler -// CHECK-MULTIARCH-ACTIONS: 3: assembler, {2}, object -// CHECK-MULTIARCH-ACTIONS: 4: linker, {3}, image -// CHECK-MULTIARCH-ACTIONS: 5: bind-arch, "i386", {4}, image -// CHECK-MULTIARCH-ACTIONS: 6: bind-arch, "x86_64", {4}, image -// CHECK-MULTIARCH-ACTIONS: 7: lipo, {5, 6}, image -// CHECK-MULTIARCH-ACTIONS: 8: dsymutil, {7}, dSYM +// CHECK-MULTIARCH-ACTIONS: 2: compiler, {1}, ir +// CHECK-MULTIARCH-ACTIONS: 3: backend, {2}, assembler +// CHECK-MULTIARCH-ACTIONS: 4: assembler, {3}, object +// CHECK-MULTIARCH-ACTIONS: 5: linker, {4}, image +// CHECK-MULTIARCH-ACTIONS: 6: bind-arch, "i386", {5}, image +// CHECK-MULTIARCH-ACTIONS: 7: bind-arch, "x86_64", {5}, image +// CHECK-MULTIARCH-ACTIONS: 8: lipo, {6, 7}, image +// CHECK-MULTIARCH-ACTIONS: 9: dsymutil, {8}, dSYM // // RUN: %clang -target x86_64-apple-darwin10 -ccc-print-bindings \ // RUN: -arch i386 -arch x86_64 %s -g 2> %t diff --git a/test/Driver/darwin-ld-demangle.c b/test/Driver/darwin-ld-demangle.c new file mode 100644 index 000000000000..1eef3c70322f --- /dev/null +++ b/test/Driver/darwin-ld-demangle.c @@ -0,0 +1,8 @@ +// REQUIRES: system-darwin + +// On Darwin, -demangle is passed to the linker of HOST_LINK_VERSION +// is high enough. It is assumed to be high enough on systems where +// this test gets run. + +// RUN: %clang -### %s 2>&1 | FileCheck %s +// CHECK: -demangle diff --git a/test/Driver/darwin-ld.c b/test/Driver/darwin-ld.c index 2da0d30b5008..d3d0f1da197b 100644 --- a/test/Driver/darwin-ld.c +++ b/test/Driver/darwin-ld.c @@ -17,6 +17,8 @@ // RUN: FileCheck -check-prefix=LINK_IPHONE_3_0 %s < %t.log // LINK_IPHONE_3_0: {{ld(.exe)?"}} +// LINK_IPHONE_3_0: -iphoneos_version_min +// LINK_IPHONE_3_0: 3.0.0 // LINK_IPHONE_3_0-NOT: -lcrt1.3.1.o // LINK_IPHONE_3_0: -lcrt1.o // LINK_IPHONE_3_0: -lSystem @@ -34,6 +36,8 @@ // RUN: FileCheck -check-prefix=LINK_IPHONE_3_1 %s < %t.log // LINK_IPHONE_3_1: {{ld(.exe)?"}} +// LINK_IPHONE_3_1: -iphoneos_version_min +// LINK_IPHONE_3_1: 3.1.0 // LINK_IPHONE_3_1-NOT: -lcrt1.o // LINK_IPHONE_3_1: -lcrt1.3.1.o // LINK_IPHONE_3_1: -lSystem @@ -51,6 +55,8 @@ // RUN: FileCheck -check-prefix=LINK_IOSSIM_3_0 %s < %t.log // LINK_IOSSIM_3_0: {{ld(.exe)?"}} +// LINK_IOSSIM_3_0: -ios_simulator_version_min +// LINK_IOSSIM_3_0: 3.0.0 // LINK_IOSSIM_3_0-NOT: -lcrt1.o // LINK_IOSSIM_3_0: -lSystem // LINK_IOSSIM_3_0: {{ld(.exe)?"}} @@ -187,10 +193,14 @@ // LINK_X86_64H_MULTIARCH: {{ld(.exe)?"}} // LINK_X86_64H_MULTIARCH: "x86_64h" -// Check that clang passes -iphoneos_version_min to the linker when building -// for the iOS simulator but when -mios-simulator-version-min is not -// explicitly specified (<rdar://problem/15959009>). +// Check for the linker options to specify the iOS version when the +// IPHONEOS_DEPLOYMENT_TARGET variable is used instead of the command-line +// deployment target options. // RUN: env IPHONEOS_DEPLOYMENT_TARGET=7.0 \ -// RUN: %clang -target i386-apple-darwin -### %t.o 2> %t.log +// RUN: %clang -target arm64-apple-darwin -### %t.o 2> %t.log // RUN: FileCheck -check-prefix=LINK_IPHONEOS_VERSION_MIN %s < %t.log +// RUN: env IPHONEOS_DEPLOYMENT_TARGET=7.0 \ +// RUN: %clang -target i386-apple-darwin -### %t.o 2> %t.log +// RUN: FileCheck -check-prefix=LINK_IOS_SIMULATOR_VERSION_MIN %s < %t.log // LINK_IPHONEOS_VERSION_MIN: -iphoneos_version_min +// LINK_IOS_SIMULATOR_VERSION_MIN: -ios_simulator_version_min diff --git a/test/Driver/darwin-max-type-align.c b/test/Driver/darwin-max-type-align.c new file mode 100644 index 000000000000..6532f4aeeb91 --- /dev/null +++ b/test/Driver/darwin-max-type-align.c @@ -0,0 +1,15 @@ +// Check the -fmax-type-align=N flag +// rdar://16254558 +// +// RUN: %clang -no-canonical-prefixes -target x86_64-apple-macosx10.7.0 %s -o - -### 2>&1 | \ +// RUN: FileCheck -check-prefix=TEST0 %s +// TEST0: -fmax-type-align=16 +// RUN: %clang -no-canonical-prefixes -fmax-type-align=32 -target x86_64-apple-macosx10.7.0 %s -o - -### 2>&1 | \ +// RUN: FileCheck -check-prefix=TEST1 %s +// TEST1: -fmax-type-align=32 +// RUN: %clang -no-canonical-prefixes -fmax-type-align=32 -fno-max-type-align -target x86_64-apple-macosx10.7.0 %s -o - -### 2>&1 | \ +// RUN: FileCheck -check-prefix=TEST2 %s +// TEST2-NOT: -fmax-type-align +// RUN: %clang -no-canonical-prefixes -fno-max-type-align -target x86_64-apple-macosx10.7.0 %s -o - -### 2>&1 | \ +// RUN: FileCheck -check-prefix=TEST3 %s +// TEST3-NOT: -fmax-type-align diff --git a/test/Driver/darwin-sanitizer-ld.c b/test/Driver/darwin-sanitizer-ld.c index 85cfb73c4a34..500fec4b2fcf 100644 --- a/test/Driver/darwin-sanitizer-ld.c +++ b/test/Driver/darwin-sanitizer-ld.c @@ -7,6 +7,8 @@ // CHECK-ASAN: "{{.*}}ld{{(.exe)?}}" // CHECK-ASAN: stdc++ // CHECK-ASAN: libclang_rt.asan_osx_dynamic.dylib" +// CHECK-ASAN: "-rpath" "@executable_path" +// CHECK-ASAN: "-rpath" "{{.*}}lib{{.*}}darwin" // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \ // RUN: -fsanitize=address -mios-simulator-version-min=7.0 %s -o %t.o 2>&1 \ @@ -15,6 +17,8 @@ // CHECK-ASAN-IOSSIM: "{{.*}}ld{{(.exe)?}}" // CHECK-ASAN-IOSSIM: lc++ // CHECK-ASAN-IOSSIM: libclang_rt.asan_iossim_dynamic.dylib" +// CHECK-ASAN-IOSSIM: "-rpath" "@executable_path" +// CHECK-ASAN-IOSSIM: "-rpath" "{{.*}}lib{{.*}}darwin" // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \ // RUN: -fPIC -shared -fsanitize=address %s -o %t.so 2>&1 \ @@ -22,7 +26,9 @@ // CHECK-DYN-ASAN: "{{.*}}ld{{(.exe)?}}" // CHECK-DYN-ASAN: "-dylib" -// CHECK-DYN-ASAN: libclang_rt.asan_osx_dynamic.dylib +// CHECK-DYN-ASAN: libclang_rt.asan_osx_dynamic.dylib" +// CHECK-DYN-ASAN: "-rpath" "@executable_path" +// CHECK-DYN-ASAN: "-rpath" "{{.*}}lib{{.*}}darwin" // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \ // RUN: -fsanitize=undefined %s -o %t.o 2>&1 \ diff --git a/test/Driver/darwin-sdkroot.c b/test/Driver/darwin-sdkroot.c index b727fa6bb0ce..58bc683320ff 100644 --- a/test/Driver/darwin-sdkroot.c +++ b/test/Driver/darwin-sdkroot.c @@ -33,3 +33,10 @@ // // It doesn't make sense on msys bash. // REQUIRES: shell-preserves-root +// +// This test will fail with MSYS env.exe, since it does not preserve root, +// expanding / into C:/MINGW/MSYS/1.0. To see the problem, from cmd.exe run: +// +// env SDKROOT=/ cmd //c echo %SDKROOT% +// +// This test passes using env.exe from GnuWin32. diff --git a/test/Driver/darwin-verify-debug.c b/test/Driver/darwin-verify-debug.c index 4878c746e07e..ebbf89a4d636 100644 --- a/test/Driver/darwin-verify-debug.c +++ b/test/Driver/darwin-verify-debug.c @@ -1,13 +1,12 @@ // Check that we verify debug output properly with multiple -arch options. // -// REQUIRES: asserts // RUN: %clang -target x86_64-apple-darwin10 -ccc-print-phases \ // RUN: --verify-debug-info -arch i386 -arch x86_64 %s -g 2> %t // RUN: FileCheck -check-prefix=CHECK-MULTIARCH-ACTIONS < %t %s // // CHECK-MULTIARCH-ACTIONS: 0: input, "{{.*}}darwin-verify-debug.c", c -// CHECK-MULTIARCH-ACTIONS: 8: dsymutil, {7}, dSYM -// CHECK-MULTIARCH-ACTIONS: 9: verify-debug-info, {8}, none +// CHECK-MULTIARCH-ACTIONS: 9: dsymutil, {8}, dSYM +// CHECK-MULTIARCH-ACTIONS: 10: verify-debug-info, {9}, none // // RUN: %clang -target x86_64-apple-darwin10 -ccc-print-bindings \ // RUN: --verify-debug-info -arch i386 -arch x86_64 %s -g 2> %t diff --git a/test/Driver/debug-options.c b/test/Driver/debug-options.c index a8fadb36e74b..50461798efd0 100644 --- a/test/Driver/debug-options.c +++ b/test/Driver/debug-options.c @@ -33,6 +33,8 @@ // RUN: %clang -### -c -g -g0 %s 2>&1 | FileCheck -check-prefix=G_NO %s // RUN: %clang -### -c -ggdb0 %s 2>&1 | FileCheck -check-prefix=G_NO %s // +// RUN: %clang -### -c -g1 %s 2>&1 \ +// RUN: | FileCheck -check-prefix=GLTO_ONLY %s // RUN: %clang -### -c -gmlt %s 2>&1 \ // RUN: | FileCheck -check-prefix=GLTO_ONLY %s // RUN: %clang -### -c -gline-tables-only %s 2>&1 \ @@ -51,6 +53,8 @@ // RUN: | FileCheck -check-prefix=G_ONLY_DWARF2 %s // RUN: %clang -### -c -gline-tables-only -g %s -target x86_64-pc-freebsd10.0 2>&1 \ // RUN: | FileCheck -check-prefix=G_ONLY_DWARF2 %s +// RUN: %clang -### -c -gline-tables-only -g %s -target i386-pc-solaris 2>&1 \ +// RUN: | FileCheck -check-prefix=G_ONLY_DWARF2 %s // RUN: %clang -### -c -gline-tables-only -g0 %s 2>&1 \ // RUN: | FileCheck -check-prefix=GLTO_NO %s // diff --git a/test/Driver/default-image-name.c b/test/Driver/default-image-name.c new file mode 100644 index 000000000000..00cf7dfbd95d --- /dev/null +++ b/test/Driver/default-image-name.c @@ -0,0 +1,7 @@ +// RUN: %clang -target i386-unknown-linux-gnu %s -### 2>&1 | FileCheck -check-prefix=LINUX %s +// LINUX: a.out + +// RUN: %clang -target i686-pc-windows-msvc %s -### 2>&1 | FileCheck -check-prefix=WIN %s +// RUN: %clang -target i686-pc-windows-gnu %s -### 2>&1 | FileCheck -check-prefix=WIN %s +// RUN: %clang -target i686-windows-gnu %s -### 2>&1 | FileCheck -check-prefix=WIN %s +// WIN: a.exe diff --git a/test/Driver/env.c b/test/Driver/env.c new file mode 100644 index 000000000000..f243fa641c76 --- /dev/null +++ b/test/Driver/env.c @@ -0,0 +1,28 @@ +// These tests try to ensure that the driver operates reasonably when run with +// a strange environment. Unfortunately, it requires a normal shell and the +// 'env' command. +// +// REQUIRES: shell +// The PATH variable is heavily used when trying to find a linker. +// RUN: env -i LC_ALL=C LD_LIBRARY_PATH="$LD_LIBRARY_PATH" \ +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=i386-unknown-linux \ +// RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ +// RUN: | FileCheck --check-prefix=CHECK-LD-32 %s +// +// RUN: env -i LC_ALL=C PATH="" LD_LIBRARY_PATH="$LD_LIBRARY_PATH" \ +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=i386-unknown-linux \ +// RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: --gcc-toolchain="" \ +// RUN: | FileCheck --check-prefix=CHECK-LD-32 %s +// +// CHECK-LD-32-NOT: warning: +// CHECK-LD-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" +// CHECK-LD-32: "{{.*}}/usr/lib/gcc/i386-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o" +// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0" +// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib" +// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../.." +// CHECK-LD-32: "-L[[SYSROOT]]/lib" +// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib" diff --git a/test/Driver/fatal-warnings.c b/test/Driver/fatal-warnings.c new file mode 100644 index 000000000000..6239b25e8917 --- /dev/null +++ b/test/Driver/fatal-warnings.c @@ -0,0 +1,8 @@ +// RUN: %clang -### %s -c -o tmp.o -target i686-pc-linux-gnu -integrated-as -Wa,--fatal-warnings 2>&1 | FileCheck %s +// RUN: not %clang %s -c -o %t.o -target i686-pc-linux-gnu -integrated-as -Wa,--fatal-warnings 2>&1 %t.log +// FileCheck --check-prefix=CHECK-AS %s -input-file %t.log + +// CHECK: "-cc1" {{.*}} "-massembler-fatal-warnings" +// CHECK-AS: error: .warning argument must be a string + +__asm(".warning 1"); diff --git a/test/Driver/fortran.f95 b/test/Driver/fortran.f95 new file mode 100644 index 000000000000..9334cbec442a --- /dev/null +++ b/test/Driver/fortran.f95 @@ -0,0 +1,9 @@ +// Check that the clang driver can invoke gcc to compile Fortran. + +// RUN: %clang -target x86_64-unknown-linux-gnu -integrated-as -c %s -### 2>&1 \ +// RUN: | FileCheck %s +// CHECK: gcc +// CHECK: "-S" +// CHECK: "-x" "f95" +// CHECK: clang +// CHECK: "-cc1as" diff --git a/test/Driver/freebsd.c b/test/Driver/freebsd.c index f0275d0156f7..a7448c11bfe6 100644 --- a/test/Driver/freebsd.c +++ b/test/Driver/freebsd.c @@ -1,4 +1,12 @@ // RUN: %clang -no-canonical-prefixes \ +// RUN: -target aarch64-pc-freebsd11 %s \ +// RUN: --sysroot=%S/Inputs/basic_freebsd64_tree -### 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-ARM64 %s +// CHECK-ARM64: "-cc1" "-triple" "aarch64-pc-freebsd11" +// CHECK-ARM64: ld{{.*}}" "--sysroot=[[SYSROOT:[^"]+]]" +// CHECK-ARM64: "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "-L[[SYSROOT]]/usr/lib" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o" +// +// RUN: %clang -no-canonical-prefixes \ // RUN: -target powerpc-pc-freebsd8 %s \ // RUN: --sysroot=%S/Inputs/basic_freebsd_tree -### 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-PPC %s @@ -120,11 +128,11 @@ // RUN: | FileCheck --check-prefix=CHECK-LTO %s // CHECK-LTO: ld{{.*}}" "-plugin{{.*}}LLVMgold.so -// RUN: %clang -target sparc-unknown-freebsd8 %s -### -fpic 2>&1 \ +// RUN: %clang -target sparc-unknown-freebsd8 %s -### -fpic -no-integrated-as 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-SPARC-PIE %s // CHECK-SPARC-PIE: as{{.*}}" "-KPIC -// RUN: %clang -mcpu=ultrasparc -target sparc64-unknown-freebsd8 %s -### 2>&1 \ +// RUN: %clang -mcpu=ultrasparc -target sparc64-unknown-freebsd8 %s -### -no-integrated-as 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-SPARC-CPU %s // CHECK-SPARC-CPU: cc1{{.*}}" "-target-cpu" "ultrasparc" // CHECK-SPARC-CPU: as{{.*}}" "-Av9a diff --git a/test/Driver/freebsd.cc b/test/Driver/freebsd.cpp index dea3267233cc..dea3267233cc 100644 --- a/test/Driver/freebsd.cc +++ b/test/Driver/freebsd.cpp diff --git a/test/Driver/fsanitize.c b/test/Driver/fsanitize.c index 57ea5a243fe4..1988503f677c 100644 --- a/test/Driver/fsanitize.c +++ b/test/Driver/fsanitize.c @@ -1,13 +1,13 @@ // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined-trap -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP // RUN: %clang -target x86_64-linux-gnu -fsanitize-undefined-trap-on-error -fsanitize=undefined-trap %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP -// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|array-bounds|enum|bool),?){14}"}} +// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){16}"}} // CHECK-UNDEFINED-TRAP: "-fsanitize-undefined-trap-on-error" // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED -// CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool),?){16}"}} +// CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){18}"}} // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-DARWIN -// CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool),?){15}"}} +// CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){17}"}} // RUN: %clang -target x86_64-linux-gnu -fsanitize=integer %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INTEGER // CHECK-INTEGER: "-fsanitize={{((signed-integer-overflow|unsigned-integer-overflow|integer-divide-by-zero|shift),?){4}"}} @@ -15,8 +15,14 @@ // RUN: %clang -fsanitize=bounds -### -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=CHECK-BOUNDS // CHECK-BOUNDS: "-fsanitize={{((array-bounds|local-bounds),?){2}"}} +// RUN: %clang -target x86_64-linux-gnu -fsanitize=all %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSANITIZE-ALL +// CHECK-FSANITIZE-ALL: error: unsupported argument 'all' to option 'fsanitize=' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address,undefined -fno-sanitize=all -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FNO-SANITIZE-ALL +// CHECK-FNO-SANITIZE-ALL: "-fsanitize=thread" + // RUN: %clang -target x86_64-linux-gnu -fsanitize=thread,undefined -fno-sanitize=thread -fno-sanitize=float-cast-overflow,vptr,bool,enum %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-PARTIAL-UNDEFINED -// CHECK-PARTIAL-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|object-size|array-bounds),?){12}"}} +// CHECK-PARTIAL-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|object-size|array-bounds|returns-nonnull-attribute|nonnull-attribute),?){14}"}} // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP-ON-ERROR-UNDEF // CHECK-UNDEFINED-TRAP-ON-ERROR-UNDEF: '-fsanitize=undefined' not allowed with '-fsanitize-undefined-trap-on-error' @@ -80,12 +86,40 @@ // RUN: %clang -target x86_64-linux-gnu -fsanitize=memory -fsanitize-memory-track-origins=3 -pie %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TRACK-ORIGINS-3 // CHECK-TRACK-ORIGINS-3: error: invalid value '3' in '-fsanitize-memory-track-origins=3' +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-coverage=0 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-0 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-0 +// CHECK-SANITIZE-COVERAGE-0-NOT: fsanitize-coverage +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=memory -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=leak -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=bool -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-1 +// CHECK-SANITIZE-COVERAGE-1: fsanitize-coverage=1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-coverage=4 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-4 +// CHECK-SANITIZE-COVERAGE-4: fsanitize-coverage=4 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-coverage=5 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-5 +// CHECK-SANITIZE-COVERAGE-5: error: invalid value '5' in '-fsanitize-coverage=5' +// RUN: %clang -target x86_64-linux-gnu -fsanitize=thread -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-UNUSED +// RUN: %clang -target x86_64-linux-gnu -fsanitize=dataflow -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-UNUSED +// RUN: %clang -target x86_64-linux-gnu -fsanitize-coverage=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANITIZE-COVERAGE-UNUSED +// CHECK-SANITIZE-COVERAGE-UNUSED: argument unused during compilation: '-fsanitize-coverage=1' + +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-address-field-padding=0 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FIELD-PADDING-0 +// CHECK-ASAN-FIELD-PADDING-0-NOT: -fsanitize-address-field-padding +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-address-field-padding=1 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FIELD-PADDING-1 +// CHECK-ASAN-FIELD-PADDING-1: -fsanitize-address-field-padding=1 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-address-field-padding=2 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FIELD-PADDING-2 +// CHECK-ASAN-FIELD-PADDING-2: -fsanitize-address-field-padding=2 +// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-address-field-padding=3 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FIELD-PADDING-3 +// CHECK-ASAN-FIELD-PADDING-3: error: invalid value '3' in '-fsanitize-address-field-padding=3' +// RUN: %clang -target x86_64-linux-gnu -fsanitize-address-field-padding=2 %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FIELD-PADDING-NO-ASAN +// CHECK-ASAN-FIELD-PADDING-NO-ASAN: warning: argument unused during compilation: '-fsanitize-address-field-padding=2' + // RUN: %clang -target x86_64-linux-gnu -fsanitize=vptr -fno-sanitize=vptr -fsanitize=undefined,address %s -### 2>&1 // OK // RUN: %clang -target x86_64-linux-gnu -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-NO-PIE -// CHECK-TSAN-NO-PIE: "-mrelocation-model" "pic" "-pic-level" "2" "-pie-level" "2" -// CHECK-TSAN-NO-PIE: "-pie" +// CHECK-TSAN-NO-PIE: "-mrelocation-model" "static" // RUN: %clang -target x86_64-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-NO-PIE // CHECK-MSAN-NO-PIE: "-mrelocation-model" "pic" "-pic-level" "2" "-pie-level" "2" @@ -98,13 +132,22 @@ // RUN: %clang -target arm-linux-androideabi %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ANDROID-NO-ASAN // CHECK-ANDROID-NO-ASAN: "-mrelocation-model" "pic" -// RUN: %clang -target x86_64-linux-gnu %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER -// RUN: %clang -target x86_64-linux-gnu %s -fsanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER -// RUN: %clang -target x86_64-linux-gnu %s -fno-sanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-RECOVER -// RUN: %clang -target x86_64-linux-gnu %s -fno-sanitize-recover -fsanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER -// RUN: %clang -target x86_64-linux-gnu %s -fsanitize-recover -fno-sanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-RECOVER -// CHECK-RECOVER-NOT: sanitize-recover -// CHECK-NO-RECOVER: "-fno-sanitize-recover" +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fsanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fsanitize-recover=all -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fno-sanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fno-sanitize-recover=all -fsanitize-recover=thread -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fno-sanitize-recover -fsanitize-recover=undefined -### 2>&1 | FileCheck %s --check-prefix=CHECK-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fsanitize-recover -fno-sanitize-recover -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-RECOVER +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fno-sanitize-recover=all -fsanitize-recover=object-size -### 2>&1 | FileCheck %s --check-prefix=CHECK-PARTIAL-RECOVER + +// CHECK-RECOVER: "-fsanitize-recover={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|array-bounds|enum|bool|returns-nonnull-attribute|nonnull-attribute),?){16}"}} +// CHECK-NO-RECOVER-NOT: sanitize-recover +// CHECK-PARTIAL-RECOVER: "-fsanitize-recover=object-size" + +// RUN: %clang -target x86_64-linux-gnu %s -fsanitize=undefined -fsanitize-recover=address,foobar,object-size,unreachable -### 2>&1 | FileCheck %s --check-prefix=CHECK-DIAG-RECOVER +// CHECK-DIAG-RECOVER: unsupported argument 'foobar' to option 'fsanitize-recover=' +// CHECK-DIAG-RECOVER: unsupported argument 'address,unreachable' to option 'fsanitize-recover=' // RUN: %clang -target x86_64-linux-gnu -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANL // CHECK-SANL: "-fsanitize=leak" @@ -142,3 +185,21 @@ // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=function -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSAN-UBSAN-DARWIN // CHECK-FSAN-UBSAN-DARWIN: unsupported option '-fsanitize=function' for target 'x86_64-apple-darwin10' + +// RUN: %clang_cl -fsanitize=address -c -MDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// RUN: %clang_cl -fsanitize=address -c -MTd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// RUN: %clang_cl -fsanitize=address -c -LDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// RUN: %clang_cl -fsanitize=address -c -MD -MDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// RUN: %clang_cl -fsanitize=address -c -MT -MTd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// RUN: %clang_cl -fsanitize=address -c -LD -LDd -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-DEBUGRTL +// CHECK-ASAN-DEBUGRTL: error: invalid argument +// CHECK-ASAN-DEBUGRTL: not allowed with '-fsanitize=address' +// CHECK-ASAN-DEBUGRTL: note: AddressSanitizer doesn't support linking with debug runtime libraries yet + +// RUN: %clang_cl -fsanitize=address -c -MT -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// RUN: %clang_cl -fsanitize=address -c -MD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// RUN: %clang_cl -fsanitize=address -c -LD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// RUN: %clang_cl -fsanitize=address -c -MTd -MT -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// RUN: %clang_cl -fsanitize=address -c -MDd -MD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// RUN: %clang_cl -fsanitize=address -c -LDd -LD -### -- %s 2>&1 | FileCheck %s -check-prefix=CHECK-ASAN-RELEASERTL +// CHECK-ASAN-RELEASERTL-NOT: error: invalid argument diff --git a/test/Driver/gcc-version-debug.c b/test/Driver/gcc-version-debug.c index ff38c2805238..daa9606ef7a5 100644 --- a/test/Driver/gcc-version-debug.c +++ b/test/Driver/gcc-version-debug.c @@ -1,4 +1,5 @@ // RUN: %clang -v --target=i386-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree 2>&1 | FileCheck %s // CHECK: Found candidate GCC installation: {{.*}}Inputs{{.}}debian_multiarch_tree{{.}}usr{{.}}lib{{.}}gcc{{.}}i686-linux-gnu{{.}}4.5 diff --git a/test/Driver/gcc_forward.c b/test/Driver/gcc_forward.c index 3bc413193f16..4892bd92ac69 100644 --- a/test/Driver/gcc_forward.c +++ b/test/Driver/gcc_forward.c @@ -11,10 +11,6 @@ // // clang-cc1 // CHECK: "-Wall" "-Wdocumentation" -// CHECK: "-o" "{{[^"]+}}.s" -// -// gnu-as -// CHECK: as{{[^"]*}}" // CHECK: "-o" "{{[^"]+}}.o" // // gcc-ld diff --git a/test/Driver/hexagon-toolchain-elf.c b/test/Driver/hexagon-toolchain-elf.c index 87c33c755fc7..984dc0439ddb 100644 --- a/test/Driver/hexagon-toolchain-elf.c +++ b/test/Driver/hexagon-toolchain-elf.c @@ -4,22 +4,24 @@ // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK001 %s // CHECK001: "-cc1" {{.*}} "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK001: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK001: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK001-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK001-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK002 %s // CHECK002: "-cc1" {{.*}} "-internal-isystem" "[[INSTALL_DIR:.*]]/Inputs/hexagon_tree/qc/bin/../../gnu{{/|\\\\}}hexagon/include/c++/4.4.0" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK002-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK002-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // ----------------------------------------------------------------------------- // Test -nostdinc, -nostdlibinc, -nostdinc++ @@ -27,6 +29,7 @@ // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK003 %s @@ -34,10 +37,11 @@ // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK003-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK003-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlibinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK004 %s @@ -45,10 +49,11 @@ // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK004-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK004-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlibinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK005 %s @@ -57,54 +62,59 @@ // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK005-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK005-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdinc++ \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK006 %s // CHECK006: "-cc1" // CHECK006-NOT: "-internal-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include/c++/4.4.0" -// CHECK006-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK006-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // ----------------------------------------------------------------------------- // Test -march=<archname> -mcpu=<archname> -mv<number> // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -march=hexagonv3 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK007 %s // CHECK007: "-cc1" {{.*}} "-target-cpu" "hexagonv3" -// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v3" -// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv3" +// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v3" +// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv3" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -mcpu=hexagonv5 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK008 %s // CHECK008: "-cc1" {{.*}} "-target-cpu" "hexagonv5" -// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v5" -// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv5" +// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v5" +// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv5" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -mv2 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK009 %s // CHECK009: "-cc1" {{.*}} "-target-cpu" "hexagonv2" -// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v2" -// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv2" +// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v2" +// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv2" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK010 %s // CHECK010: "-cc1" {{.*}} "-target-cpu" "hexagonv4" -// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v4" -// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv4" +// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v4" +// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv4" // RUN: not %clang -march=hexagonv2 -target hexagon-unknown-elf \ // RUN: %s 2>&1 | FileCheck -check-prefix=CHECK-UNKNOWN-V2 %s @@ -131,11 +141,12 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK011 %s // CHECK011: "-cc1" -// CHECK011-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK011-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK011-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK011-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK011-NOT: "-static" // CHECK011-NOT: "-shared" // CHECK011: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -155,11 +166,12 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK012 %s // CHECK012: "-cc1" -// CHECK012-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK012-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK012-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK012-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK012-NOT: "-static" // CHECK012-NOT: "-shared" // CHECK012: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -180,12 +192,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -Lone -L two -L three \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK013 %s // CHECK013: "-cc1" -// CHECK013-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK013-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK013-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK013-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK013: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK013: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK013: "{{.*}}/hexagon/lib/v4/init.o" @@ -204,12 +217,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -static \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK014 %s // CHECK014: "-cc1" -// CHECK014-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK014-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK014-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK014-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK014: "-static" // CHECK014: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK014: "{{.*}}/hexagon/lib/v4/crt0.o" @@ -225,12 +239,13 @@ // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -shared \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK015 %s // CHECK015: "-cc1" -// CHECK015-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK015-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK015-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK015-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK015: "-shared" "-call_shared" // CHECK015-NOT: crt0_standalone.o // CHECK015-NOT: crt0.o @@ -254,13 +269,14 @@ // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -shared \ // RUN: -static \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK016 %s // CHECK016: "-cc1" -// CHECK016-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK016-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK016-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK016-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK016: "-shared" "-call_shared" "-static" // CHECK016-NOT: crt0_standalone.o // CHECK016-NOT: crt0.o @@ -287,12 +303,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlib \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK017 %s // CHECK017: "-cc1" -// CHECK017-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK017-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK017-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK017-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK017-NOT: crt0_standalone.o // CHECK017-NOT: crt0.o // CHECK017-NOT: init.o @@ -313,12 +330,13 @@ // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostartfiles \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK018 %s // CHECK018: "-cc1" -// CHECK018-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK018-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK018-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK018-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK018-NOT: crt0_standalone.o // CHECK018-NOT: crt0.o // CHECK018-NOT: init.o @@ -339,12 +357,13 @@ // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nodefaultlibs \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK019 %s // CHECK019: "-cc1" -// CHECK019-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK019-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK019-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK019-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK019: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK019: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK019: "{{.*}}/hexagon/lib/v4/init.o" @@ -368,12 +387,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -moslib=first -moslib=second \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK020 %s // CHECK020: "-cc1" -// CHECK020-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK020-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK020-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK020-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK020-NOT: "-static" // CHECK020-NOT: "-shared" // CHECK020-NOT: crt0_standalone.o @@ -393,12 +413,13 @@ // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -moslib=first -moslib=second -moslib=standalone\ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK021 %s // CHECK021: "-cc1" -// CHECK021-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK021-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK021-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK021-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK021-NOT: "-static" // CHECK021-NOT: "-shared" // CHECK021: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -421,6 +442,7 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -s \ // RUN: -Tbss 0xdead -Tdata 0xbeef -Ttext 0xcafe \ // RUN: -t \ @@ -429,8 +451,8 @@ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK022 %s // CHECK022: "-cc1" -// CHECK022-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK022-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK022-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK022-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK022: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK022: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK022: "{{.*}}/hexagon/lib/v4/init.o" @@ -453,27 +475,31 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK023 %s // CHECK023: "-cc1" // CHECK023: "-mrelocation-model" "static" -// CHECK023-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK023-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK023-NOT: "-G{{[0-9]+}}" -// CHECK023-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK023-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK023-NOT: "-G{{[0-9]+}}" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fpic \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK024 %s // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fPIC \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK024 %s // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fPIC \ // RUN: -msmall-data-threshold=8 \ // RUN: %s 2>&1 \ @@ -482,32 +508,35 @@ // CHECK024-NOT: "-mrelocation-model" "static" // CHECK024: "-pic-level" "{{[12]}}" // CHECK024: "-mllvm" "-hexagon-small-data-threshold=0" -// CHECK024-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK024-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK024: "-G0" -// CHECK024-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK024-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK024: "-G0" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -G=8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -G 8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -msmall-data-threshold=8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // CHECK025: "-cc1" // CHECK025: "-mrelocation-model" "static" // CHECK025: "-mllvm" "-hexagon-small-data-threshold=8" -// CHECK025-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK025-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK025: "-G8" -// CHECK025-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK025-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK025: "-G8" // ----------------------------------------------------------------------------- @@ -515,22 +544,24 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -pie \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK026 %s // CHECK026: "-cc1" -// CHECK026-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK026-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK026-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK026-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK026: "-pie" // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -pie -shared \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK027 %s // CHECK027: "-cc1" -// CHECK027-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK027-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK027-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK027-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK027-NOT: "-pie" // ----------------------------------------------------------------------------- @@ -538,25 +569,27 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK028 %s // CHECK028: "-cc1" // CHECK028: "-mqdsp6-compat" // CHECK028: "-Wreturn-type" -// CHECK028-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK028-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK028-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK028-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // ----------------------------------------------------------------------------- // Test Assembler related args // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-elf \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -gdwarf-2 \ // RUN: -Wa,--noexecstack,--trap \ // RUN: -Xassembler --keep-locals \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK029 %s // CHECK029: "-cc1" -// CHECK029-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK029-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK029: "--noexecstack" "--trap" "--keep-locals" -// CHECK029-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK029-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" diff --git a/test/Driver/hexagon-toolchain.c b/test/Driver/hexagon-toolchain.c index 88440f8d9d9b..391b78a13ea6 100644 --- a/test/Driver/hexagon-toolchain.c +++ b/test/Driver/hexagon-toolchain.c @@ -4,22 +4,24 @@ // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK001 %s // CHECK001: "-cc1" {{.*}} "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK001: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK001: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK001-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK001-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK002 %s // CHECK002: "-cc1" {{.*}} "-internal-isystem" "[[INSTALL_DIR:.*]]/Inputs/hexagon_tree/qc/bin/../../gnu{{/|\\\\}}hexagon/include/c++/4.4.0" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK002: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK002-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK002-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // ----------------------------------------------------------------------------- // Test -nostdinc, -nostdlibinc, -nostdinc++ @@ -27,6 +29,7 @@ // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK003 %s @@ -34,10 +37,11 @@ // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK003-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK003-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK003-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlibinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK004 %s @@ -45,10 +49,11 @@ // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK004-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK004-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK004-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlibinc \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK005 %s @@ -57,54 +62,59 @@ // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include" // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/lib/gcc/hexagon/4.4.0/include-fixed" // CHECK005-NOT: "-internal-externc-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include" -// CHECK005-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK005-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdinc++ \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK006 %s // CHECK006: "-cc1" // CHECK006-NOT: "-internal-isystem" "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/hexagon/include/c++/4.4.0" -// CHECK006-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as" +// CHECK006-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as" // ----------------------------------------------------------------------------- // Test -march=<archname> -mcpu=<archname> -mv<number> // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -march=hexagonv3 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK007 %s // CHECK007: "-cc1" {{.*}} "-target-cpu" "hexagonv3" -// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v3" -// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv3" +// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v3" +// CHECK007-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv3" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -mcpu=hexagonv5 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK008 %s // CHECK008: "-cc1" {{.*}} "-target-cpu" "hexagonv5" -// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v5" -// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv5" +// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v5" +// CHECK008-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv5" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -mv2 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK009 %s // CHECK009: "-cc1" {{.*}} "-target-cpu" "hexagonv2" -// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v2" -// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv2" +// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v2" +// CHECK009-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv2" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK010 %s // CHECK010: "-cc1" {{.*}} "-target-cpu" "hexagonv4" -// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-as"{{.*}} "-march=v4" -// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\}}hexagon-ld"{{.*}} "-mv4" +// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-as"{{.*}} "-march=v4" +// CHECK010-NEXT: "{{.*}}/Inputs/hexagon_tree/qc/bin/../../gnu/bin{{/|\\\\}}hexagon-ld"{{.*}} "-mv4" // RUN: not %clang -march=hexagonv2 -target hexagon-unknown-linux \ // RUN: %s 2>&1 | FileCheck -check-prefix=CHECK-UNKNOWN-V2 %s @@ -131,11 +141,12 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK011 %s // CHECK011: "-cc1" -// CHECK011-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK011-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK011-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK011-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK011-NOT: "-static" // CHECK011-NOT: "-shared" // CHECK011: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -155,11 +166,12 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK012 %s // CHECK012: "-cc1" -// CHECK012-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK012-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK012-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK012-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK012-NOT: "-static" // CHECK012-NOT: "-shared" // CHECK012: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -180,12 +192,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -Lone -L two -L three \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK013 %s // CHECK013: "-cc1" -// CHECK013-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK013-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK013-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK013-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK013: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK013: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK013: "{{.*}}/hexagon/lib/v4/init.o" @@ -204,12 +217,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -static \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK014 %s // CHECK014: "-cc1" -// CHECK014-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK014-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK014-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK014-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK014: "-static" // CHECK014: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK014: "{{.*}}/hexagon/lib/v4/crt0.o" @@ -225,12 +239,13 @@ // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -shared \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK015 %s // CHECK015: "-cc1" -// CHECK015-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK015-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK015-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK015-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK015: "-shared" "-call_shared" // CHECK015-NOT: crt0_standalone.o // CHECK015-NOT: crt0.o @@ -254,13 +269,14 @@ // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -shared \ // RUN: -static \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK016 %s // CHECK016: "-cc1" -// CHECK016-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK016-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK016-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK016-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK016: "-shared" "-call_shared" "-static" // CHECK016-NOT: crt0_standalone.o // CHECK016-NOT: crt0.o @@ -287,12 +303,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostdlib \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK017 %s // CHECK017: "-cc1" -// CHECK017-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK017-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK017-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK017-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK017-NOT: crt0_standalone.o // CHECK017-NOT: crt0.o // CHECK017-NOT: init.o @@ -313,12 +330,13 @@ // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nostartfiles \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK018 %s // CHECK018: "-cc1" -// CHECK018-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK018-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK018-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK018-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK018-NOT: crt0_standalone.o // CHECK018-NOT: crt0.o // CHECK018-NOT: init.o @@ -339,12 +357,13 @@ // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -nodefaultlibs \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK019 %s // CHECK019: "-cc1" -// CHECK019-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK019-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK019-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK019-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK019: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK019: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK019: "{{.*}}/hexagon/lib/v4/init.o" @@ -368,12 +387,13 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -moslib=first -moslib=second \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK020 %s // CHECK020: "-cc1" -// CHECK020-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK020-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK020-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK020-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK020-NOT: "-static" // CHECK020-NOT: "-shared" // CHECK020-NOT: crt0_standalone.o @@ -393,12 +413,13 @@ // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -moslib=first -moslib=second -moslib=standalone\ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK021 %s // CHECK021: "-cc1" -// CHECK021-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK021-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK021-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK021-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK021-NOT: "-static" // CHECK021-NOT: "-shared" // CHECK021: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" @@ -421,6 +442,7 @@ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RUN: %clangxx -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -s \ // RUN: -Tbss 0xdead -Tdata 0xbeef -Ttext 0xcafe \ // RUN: -t \ @@ -429,8 +451,8 @@ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK022 %s // CHECK022: "-cc1" -// CHECK022-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as"{{.*}} -// CHECK022-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK022-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as"{{.*}} +// CHECK022-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK022: "{{.*}}/hexagon/lib/v4/crt0_standalone.o" // CHECK022: "{{.*}}/hexagon/lib/v4/crt0.o" // CHECK022: "{{.*}}/hexagon/lib/v4/init.o" @@ -453,27 +475,31 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK023 %s // CHECK023: "-cc1" // CHECK023: "-mrelocation-model" "static" -// CHECK023-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK023-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK023-NOT: "-G{{[0-9]+}}" -// CHECK023-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK023-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK023-NOT: "-G{{[0-9]+}}" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fpic \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK024 %s // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fPIC \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK024 %s // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -fPIC \ // RUN: -msmall-data-threshold=8 \ // RUN: %s 2>&1 \ @@ -482,32 +508,35 @@ // CHECK024-NOT: "-mrelocation-model" "static" // CHECK024: "-pic-level" "{{[12]}}" // CHECK024: "-mllvm" "-hexagon-small-data-threshold=0" -// CHECK024-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK024-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK024: "-G0" -// CHECK024-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK024-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK024: "-G0" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -G=8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -G 8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -msmall-data-threshold=8 \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK025 %s // CHECK025: "-cc1" // CHECK025: "-mrelocation-model" "static" // CHECK025: "-mllvm" "-hexagon-small-data-threshold=8" -// CHECK025-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK025-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK025: "-G8" -// CHECK025-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK025-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK025: "-G8" // ----------------------------------------------------------------------------- @@ -515,22 +544,24 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -pie \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK026 %s // CHECK026: "-cc1" -// CHECK026-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK026-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK026-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK026-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK026: "-pie" // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -pie -shared \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK027 %s // CHECK027: "-cc1" -// CHECK027-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK027-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK027-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK027-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // CHECK027-NOT: "-pie" // ----------------------------------------------------------------------------- @@ -538,25 +569,27 @@ // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK028 %s // CHECK028: "-cc1" // CHECK028: "-mqdsp6-compat" // CHECK028: "-Wreturn-type" -// CHECK028-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" -// CHECK028-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK028-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" +// CHECK028-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" // ----------------------------------------------------------------------------- // Test Assembler related args // ----------------------------------------------------------------------------- // RUN: %clang -### -target hexagon-unknown-linux \ // RUN: -ccc-install-dir %S/Inputs/hexagon_tree/qc/bin \ +// RUN: --gcc-toolchain="" \ // RUN: -gdwarf-2 \ // RUN: -Wa,--noexecstack,--trap \ // RUN: -Xassembler --keep-locals \ // RUN: %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHECK029 %s // CHECK029: "-cc1" -// CHECK029-NEXT: "{{.*}}/bin{{/|\\}}hexagon-as" +// CHECK029-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-as" // CHECK029: "--noexecstack" "--trap" "--keep-locals" -// CHECK029-NEXT: "{{.*}}/bin{{/|\\}}hexagon-ld" +// CHECK029-NEXT: "{{.*}}/bin{{/|\\\\}}hexagon-ld" diff --git a/test/Driver/ident_md.c b/test/Driver/ident_md.c index 7b2b2f6a7dee..0e664c2e1ea6 100644 --- a/test/Driver/ident_md.c +++ b/test/Driver/ident_md.c @@ -2,5 +2,5 @@ // Verify that clang version appears in the llvm.ident metadata. // CHECK: !llvm.ident = !{{{.*}}} -// CHECK: !{{[0-9]+}} = metadata !{metadata !{{.*}} +// CHECK: !{{[0-9]+}} = !{!{{.*}} diff --git a/test/Driver/instrprof-ld.c b/test/Driver/instrprof-ld.c index f70ae474d0db..f16fa8f0ed34 100644 --- a/test/Driver/instrprof-ld.c +++ b/test/Driver/instrprof-ld.c @@ -35,7 +35,7 @@ // RUN: | FileCheck --check-prefix=CHECK-LINUX-I386-SHARED %s // // CHECK-LINUX-I386-SHARED: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" -// CHECK-LINUX-I386-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}linux{{/|\\\\}}libclang_rt.profile-pic-i386.a" {{.*}} "-lc" +// CHECK-LINUX-I386-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}linux{{/|\\\\}}libclang_rt.profile-i386.a" {{.*}} "-lc" // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -shared \ @@ -45,7 +45,7 @@ // RUN: | FileCheck --check-prefix=CHECK-LINUX-X86-64-SHARED %s // // CHECK-LINUX-X86-64-SHARED: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" -// CHECK-LINUX-X86-64-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}linux{{/|\\\\}}libclang_rt.profile-pic-x86_64.a" {{.*}} "-lc" +// CHECK-LINUX-X86-64-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}linux{{/|\\\\}}libclang_rt.profile-x86_64.a" {{.*}} "-lc" // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -shared \ @@ -55,4 +55,4 @@ // RUN: | FileCheck --check-prefix=CHECK-FREEBSD-X86-64-SHARED %s // // CHECK-FREEBSD-X86-64-SHARED: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" -// CHECK-FREEBSD-X86-64-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}freebsd{{/|\\\\}}libclang_rt.profile-pic-x86_64.a" +// CHECK-FREEBSD-X86-64-SHARED: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}freebsd{{/|\\\\}}libclang_rt.profile-x86_64.a" diff --git a/test/Driver/le32-unknown-nacl.cpp b/test/Driver/le32-unknown-nacl.cpp index e029f667a192..379ddb6c63d8 100644 --- a/test/Driver/le32-unknown-nacl.cpp +++ b/test/Driver/le32-unknown-nacl.cpp @@ -4,9 +4,9 @@ // ECHO: {{.*}} "-cc1" {{.*}}le32-unknown-nacl.c -// Check platform defines -#include <stdarg.h> -#include <stddef.h> +typedef __builtin_va_list va_list; +typedef __SIZE_TYPE__ size_t; +typedef __PTRDIFF_TYPE__ ptrdiff_t; extern "C" { diff --git a/test/Driver/le64-unknown-unknown.cpp b/test/Driver/le64-unknown-unknown.cpp new file mode 100644 index 000000000000..d0a58598ffe7 --- /dev/null +++ b/test/Driver/le64-unknown-unknown.cpp @@ -0,0 +1,137 @@ +// RUN: %clang -target le64-unknown-unknown -### %s -emit-llvm-only -c 2>&1 | FileCheck %s -check-prefix=ECHO +// RUN: %clang -target le64-unknown-unknown %s -emit-llvm -S -c -o - | FileCheck %s + +// ECHO: {{.*}} "-cc1" {{.*}}le64-unknown-unknown.c + +typedef __builtin_va_list va_list; +typedef __SIZE_TYPE__ size_t; +typedef __PTRDIFF_TYPE__ ptrdiff_t; + +extern "C" { + +// CHECK: @align_c = global i32 1 +int align_c = __alignof(char); + +// CHECK: @align_s = global i32 2 +int align_s = __alignof(short); + +// CHECK: @align_i = global i32 4 +int align_i = __alignof(int); + +// CHECK: @align_l = global i32 8 +int align_l = __alignof(long); + +// CHECK: @align_ll = global i32 8 +int align_ll = __alignof(long long); + +// CHECK: @align_p = global i32 8 +int align_p = __alignof(void*); + +// CHECK: @align_f = global i32 4 +int align_f = __alignof(float); + +// CHECK: @align_d = global i32 8 +int align_d = __alignof(double); + +// CHECK: @align_ld = global i32 8 +int align_ld = __alignof(long double); + +// CHECK: @align_vl = global i32 4 +int align_vl = __alignof(va_list); + +// CHECK: __LITTLE_ENDIAN__defined +#ifdef __LITTLE_ENDIAN__ +void __LITTLE_ENDIAN__defined() {} +#endif + +// CHECK: __le64defined +#ifdef __le64 +void __le64defined() {} +#endif + +// CHECK: __le64__defined +#ifdef __le64__ +void __le64__defined() {} +#endif + +// CHECK: unixdefined +#ifdef unix +void unixdefined() {} +#endif + +// CHECK: __unixdefined +#ifdef __unix +void __unixdefined() {} +#endif + +// CHECK: __unix__defined +#ifdef __unix__ +void __unix__defined() {} +#endif + +// CHECK: __ELF__defined +#ifdef __ELF__ +void __ELF__defined() {} +#endif + +// Check types + +// CHECK: signext i8 @check_char() +char check_char() { return 0; } + +// CHECK: signext i16 @check_short() +short check_short() { return 0; } + +// CHECK: i32 @check_int() +int check_int() { return 0; } + +// CHECK: i64 @check_long() +long check_long() { return 0; } + +// CHECK: i64 @check_longlong() +long long check_longlong() { return 0; } + +// CHECK: zeroext i8 @check_uchar() +unsigned char check_uchar() { return 0; } + +// CHECK: zeroext i16 @check_ushort() +unsigned short check_ushort() { return 0; } + +// CHECK: i32 @check_uint() +unsigned int check_uint() { return 0; } + +// CHECK: i64 @check_ulong() +unsigned long check_ulong() { return 0; } + +// CHECK: i64 @check_ulonglong() +unsigned long long check_ulonglong() { return 0; } + +// CHECK: i64 @check_size_t() +size_t check_size_t() { return 0; } + +// CHECK: i64 @check_ptrdiff_t() +ptrdiff_t check_ptrdiff_t() { return 0; } + +// CHECK: float @check_float() +float check_float() { return 0; } + +// CHECK: double @check_double() +double check_double() { return 0; } + +// CHECK: double @check_longdouble() +long double check_longdouble() { return 0; } + +} + +template<int> void Switch(); +template<> void Switch<4>(); +template<> void Switch<8>(); +template<> void Switch<16>(); + +void check_pointer_size() { + // CHECK: SwitchILi8 + Switch<sizeof(void*)>(); + + // CHECK: SwitchILi16 + Switch<sizeof(va_list)>(); +} diff --git a/test/Driver/linux-header-search.cpp b/test/Driver/linux-header-search.cpp index 309ece28db77..c62c4941f5ec 100644 --- a/test/Driver/linux-header-search.cpp +++ b/test/Driver/linux-header-search.cpp @@ -8,6 +8,7 @@ // RUN: -stdlib=libc++ \ // RUN: -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \ // RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-SYSROOT %s // CHECK-BASIC-LIBCXX-SYSROOT: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-BASIC-LIBCXX-SYSROOT: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -18,6 +19,7 @@ // RUN: -stdlib=libc++ \ // RUN: -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \ // RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-INSTALL %s // CHECK-BASIC-LIBCXX-INSTALL: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-BASIC-LIBCXX-INSTALL: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -28,6 +30,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: --sysroot=%S/Inputs/ubuntu_11.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-11-04 %s // CHECK-UBUNTU-11-04: "{{.*}}clang{{.*}}" "-cc1" // CHECK-UBUNTU-11-04: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -42,6 +45,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu \ // RUN: --sysroot=%S/Inputs/ubuntu_13.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-13-04 %s // CHECK-UBUNTU-13-04: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-13-04: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -57,6 +61,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnux32 \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04 %s // CHECK-UBUNTU-14-04: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-14-04: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -72,6 +77,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target arm-linux-gnueabihf \ // RUN: --sysroot=%S/Inputs/ubuntu_13.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-13-04-CROSS %s // CHECK-UBUNTU-13-04-CROSS: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-13-04-CROSS: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -87,6 +93,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu -m32 \ // RUN: --sysroot=%S/Inputs/ubuntu_13.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-13-04-M32 %s // CHECK-UBUNTU-13-04-M32: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-13-04-M32: "-triple" "i386-unknown-linux-gnu" @@ -100,6 +107,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu -m32 \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-M32 %s // CHECK-UBUNTU-14-04-M32: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-14-04-M32: "-triple" "i386-unknown-linux-gnu" @@ -114,6 +122,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu -m32 \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree2 \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-I686 %s // CHECK-UBUNTU-14-04-I686: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-14-04-I686: "-triple" "i386-unknown-linux-gnu" @@ -126,6 +135,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target powerpc64le-unknown-linux-gnu -m32 \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-PPC64LE %s // CHECK-UBUNTU-14-04-PPC64LE: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-UBUNTU-14-04-PPC64LE: "-triple" "powerpc64le-unknown-linux-gnu" @@ -141,6 +151,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target i686-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86 %s // CHECK-DEBIAN-X86: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-DEBIAN-X86: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -155,6 +166,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86-64 %s // CHECK-DEBIAN-X86-64: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-DEBIAN-X86-64: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -169,6 +181,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target powerpc-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC %s // CHECK-DEBIAN-PPC: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-DEBIAN-PPC: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -183,6 +196,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target powerpc64-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC64 %s // CHECK-DEBIAN-PPC64: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-DEBIAN-PPC64: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -200,6 +214,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu \ // RUN: --sysroot=%S/Inputs/gentoo_linux_gcc_4.6.2_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-GENTOO-4-6-2 %s // CHECK-GENTOO-4-6-2: "{{.*}}clang{{.*}}" "-cc1" // CHECK-GENTOO-4-6-2: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -213,6 +228,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target x86_64-unknown-linux-gnu \ // RUN: --sysroot=%S/Inputs/gentoo_linux_gcc_4.6.4_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-GENTOO-4-6-4 %s // CHECK-GENTOO-4-6-4: "{{.*}}clang{{.*}}" "-cc1" // CHECK-GENTOO-4-6-4: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -228,6 +244,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target mips64-unknown-linux-gnuabi64 \ // RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-MIPS64-GNUABI %s // CHECK-MIPS64-GNUABI: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-MIPS64-GNUABI: "-isysroot" "[[SYSROOT:[^"]+]]" @@ -244,6 +261,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -fsyntax-only 2>&1 \ // RUN: -target mips64el-unknown-linux-gnuabi64 \ // RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-MIPS64EL-GNUABI %s // CHECK-MIPS64EL-GNUABI: "{{[^"]*}}clang{{[^"]*}}" "-cc1" // CHECK-MIPS64EL-GNUABI: "-isysroot" "[[SYSROOT:[^"]+]]" diff --git a/test/Driver/linux-ld.c b/test/Driver/linux-ld.c index 6a47d08274d2..1ce923b61ac3 100644 --- a/test/Driver/linux-ld.c +++ b/test/Driver/linux-ld.c @@ -3,6 +3,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-32 %s // CHECK-LD-32-NOT: warning: @@ -16,6 +17,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-64 %s // CHECK-LD-64-NOT: warning: @@ -35,6 +37,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux-gnux32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-X32 %s // CHECK-LD-X32-NOT: warning: @@ -48,6 +51,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --rtlib=compiler-rt \ // RUN: | FileCheck --check-prefix=CHECK-LD-RT %s @@ -68,6 +72,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: --rtlib=libgcc \ // RUN: | FileCheck --check-prefix=CHECK-LD-GCC %s @@ -89,6 +94,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ // RUN: -static-libgcc \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC-LIBGCC %s // CHECK-LD-64-STATIC-LIBGCC-NOT: warning: @@ -109,6 +115,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ // RUN: -static \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC %s // CHECK-LD-64-STATIC-NOT: warning: @@ -129,11 +136,13 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux \ // RUN: -static-libgcc -static \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC %s // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-32-TO-32 %s // CHECK-32-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -150,6 +159,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m64 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-32-TO-64 %s // CHECK-32-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -167,6 +177,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux -m64 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-64-TO-64 %s // CHECK-64-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -183,6 +194,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux -m32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-64-TO-32 %s // CHECK-64-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -200,6 +212,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux-gnux32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-X32 %s // CHECK-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -217,6 +230,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux -mx32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-64-TO-X32 %s // CHECK-64-TO-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -234,6 +248,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -mx32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-32-TO-X32 %s // CHECK-32-TO-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -250,6 +265,41 @@ // CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib" // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=x86_64-unknown-linux-gnux32 -m64 \ +// RUN: --gcc-toolchain="" \ +// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ +// RUN: | FileCheck --check-prefix=CHECK-X32-TO-64 %s +// CHECK-X32-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" +// CHECK-X32-TO-64: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib64" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib64" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/lib/../lib64" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/../lib64" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.." +// CHECK-X32-TO-64: "-L[[SYSROOT]]/lib" +// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=x86_64-unknown-linux-gnux32 -m32 \ +// RUN: --gcc-toolchain="" \ +// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \ +// RUN: | FileCheck --check-prefix=CHECK-X32-TO-32 %s +// CHECK-X32-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" +// CHECK-X32-TO-32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32{{/|\\\\}}crtbegin.o" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib32" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib32" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/lib/../lib32" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/../lib32" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.." +// CHECK-X32-TO-32: "-L[[SYSROOT]]/lib" +// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux -m32 \ // RUN: --gcc-toolchain=%S/Inputs/multilib_64bit_linux_tree/usr \ // RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \ @@ -266,6 +316,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ // RUN: -ccc-install-dir %S/Inputs/fake_install_tree/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-INSTALL-DIR-32 %s // CHECK-INSTALL-DIR-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -277,6 +328,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux -m64 \ // RUN: -ccc-install-dir %S/Inputs/fake_install_tree/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-INSTALL-DIR-64 %s // CHECK-INSTALL-DIR-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -288,6 +340,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ // RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing1/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION1 %s // CHECK-GCC-VERSION1: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -296,6 +349,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ // RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing2/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION2 %s // CHECK-GCC-VERSION2: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -304,6 +358,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ // RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing3/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION3 %s // CHECK-GCC-VERSION3: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -312,6 +367,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux -m32 \ // RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing4/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree \ // RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION4 %s // CHECK-GCC-VERSION4: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -324,6 +380,7 @@ // RUN: -target x86_64-unknown-linux-gnu \ // RUN: -stdlib=libc++ \ // RUN: -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \ // RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-SYSROOT %s // CHECK-BASIC-LIBCXX-SYSROOT: "{{[^"]*}}clang{{[^"]*}}" "-cc1" @@ -335,6 +392,7 @@ // RUN: -target x86_64-unknown-linux-gnu \ // RUN: -stdlib=libc++ \ // RUN: -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \ // RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-INSTALL %s // CHECK-BASIC-LIBCXX-INSTALL: "{{[^"]*}}clang{{[^"]*}}" "-cc1" @@ -347,6 +405,7 @@ // Test a very broken version of multiarch that shipped in Ubuntu 11.04. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i386-unknown-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/ubuntu_11.04_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-11-04 %s // CHECK-UBUNTU-11-04: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -361,6 +420,7 @@ // Check multi arch support on Ubuntu 12.04 LTS. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-unknown-linux-gnueabihf \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/ubuntu_12.04_LTS_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-12-04-ARM-HF %s // CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -378,6 +438,7 @@ // Check Ubuntu 13.10 on x86-64 targeting arm-linux-gnueabihf. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-gnueabihf \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/x86-64_ubuntu_13.10 \ // RUN: | FileCheck --check-prefix=CHECK-X86-64-UBUNTU-13-10-ARM-HF %s // CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -396,6 +457,7 @@ // Check Ubuntu 13.10 on x86-64 targeting arm-linux-gnueabi. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-gnueabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/x86-64_ubuntu_13.10 \ // RUN: | FileCheck --check-prefix=CHECK-X86-64-UBUNTU-13-10-ARM %s // CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -414,6 +476,7 @@ // Check Ubuntu 14.04 on powerpc64le. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64le-unknown-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-PPC64LE %s // CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -432,6 +495,7 @@ // "/usr/lib/gcc/x86_64-linux-gnu/4.8/x32/crtend.o" "/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32/crtn.o" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-unknown-linux-gnux32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-X32 %s // CHECK-UBUNTU-14-04-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -451,6 +515,7 @@ // Check fedora 18 on arm. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=armv7-unknown-linux-gnueabihf \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/fedora_18_tree \ // RUN: | FileCheck --check-prefix=CHECK-FEDORA-18-ARM-HF %s // CHECK-FEDORA-18-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -465,10 +530,12 @@ // Check Fedora 21 on AArch64. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-unknown-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/fedora_21_tree \ // RUN: | FileCheck --check-prefix=CHECK-FEDORA-21-AARCH64 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-unknown-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/fedora_21_tree \ // RUN: | FileCheck --check-prefix=CHECK-FEDORA-21-AARCH64 %s // CHECK-FEDORA-21-AARCH64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -482,6 +549,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-unknown-linux-gnueabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/ubuntu_12.04_LTS_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-UBUNTU-12-04-ARM %s // CHECK-UBUNTU-12-04-ARM: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -499,6 +567,7 @@ // Test the setup that shipped in SUSE 10.3 on ppc64. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64-suse-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/suse_10.3_ppc64_tree \ // RUN: | FileCheck --check-prefix=CHECK-SUSE-10-3-PPC64 %s // CHECK-SUSE-10-3-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -524,12 +593,47 @@ // CHECK-ARM-HF: "-dynamic-linker" "{{.*}}/lib/ld-linux-armhf.so.3" // // RUN: %clang %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64-linux-gnu \ +// RUN: | FileCheck --check-prefix=CHECK-PPC64 %s +// CHECK-PPC64: "{{.*}}ld{{(.exe)?}}" +// CHECK-PPC64: "-m" "elf64ppc" +// CHECK-PPC64: "-dynamic-linker" "{{.*}}/lib64/ld64.so.1" +// +// RUN: %clang %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64-linux-gnu -mabi=elfv1 \ +// RUN: | FileCheck --check-prefix=CHECK-PPC64-ELFv1 %s +// CHECK-PPC64-ELFv1: "{{.*}}ld{{(.exe)?}}" +// CHECK-PPC64-ELFv1: "-m" "elf64ppc" +// CHECK-PPC64-ELFv1: "-dynamic-linker" "{{.*}}/lib64/ld64.so.1" +// +// RUN: %clang %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64-linux-gnu -mabi=elfv2 \ +// RUN: | FileCheck --check-prefix=CHECK-PPC64-ELFv2 %s +// CHECK-PPC64-ELFv2: "{{.*}}ld{{(.exe)?}}" +// CHECK-PPC64-ELFv2: "-m" "elf64ppc" +// CHECK-PPC64-ELFv2: "-dynamic-linker" "{{.*}}/lib64/ld64.so.2" +// +// RUN: %clang %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64le-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-PPC64LE %s // CHECK-PPC64LE: "{{.*}}ld{{(.exe)?}}" // CHECK-PPC64LE: "-m" "elf64lppc" // CHECK-PPC64LE: "-dynamic-linker" "{{.*}}/lib64/ld64.so.2" // +// RUN: %clang %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64le-linux-gnu -mabi=elfv1 \ +// RUN: | FileCheck --check-prefix=CHECK-PPC64LE-ELFv1 %s +// CHECK-PPC64LE-ELFv1: "{{.*}}ld{{(.exe)?}}" +// CHECK-PPC64LE-ELFv1: "-m" "elf64lppc" +// CHECK-PPC64LE-ELFv1: "-dynamic-linker" "{{.*}}/lib64/ld64.so.1" +// +// RUN: %clang %s -### -o %t.o 2>&1 \ +// RUN: --target=powerpc64le-linux-gnu -mabi=elfv2 \ +// RUN: | FileCheck --check-prefix=CHECK-PPC64LE-ELFv2 %s +// CHECK-PPC64LE-ELFv2: "{{.*}}ld{{(.exe)?}}" +// CHECK-PPC64LE-ELFv2: "-m" "elf64lppc" +// CHECK-PPC64LE-ELFv2: "-dynamic-linker" "{{.*}}/lib64/ld64.so.2" +// // Check that we do not pass --hash-style=gnu and --hash-style=both to linker // and provide correct path to the dynamic linker and emulation mode when build // for MIPS platforms. @@ -633,6 +737,7 @@ // Thoroughly exercise the Debian multiarch environment. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86 %s // CHECK-DEBIAN-X86: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -645,6 +750,7 @@ // CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86-64 %s // CHECK-DEBIAN-X86-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -657,6 +763,7 @@ // CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC %s // CHECK-DEBIAN-PPC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -669,6 +776,7 @@ // CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC64 %s // CHECK-DEBIAN-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -681,6 +789,7 @@ // CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS %s // CHECK-DEBIAN-MIPS: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -693,6 +802,7 @@ // CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPSEL %s // CHECK-DEBIAN-MIPSEL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -705,6 +815,7 @@ // CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64 %s // CHECK-DEBIAN-MIPS64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -716,6 +827,7 @@ // CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64EL %s // CHECK-DEBIAN-MIPS64EL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -727,6 +839,7 @@ // CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64-linux-gnu -mabi=n32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64-N32 %s // CHECK-DEBIAN-MIPS64-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -738,6 +851,7 @@ // CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-gnu -mabi=n32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_multiarch_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64EL-N32 %s // CHECK-DEBIAN-MIPS64EL-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -751,34 +865,42 @@ // Test linker invocation on Android. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID %s // CHECK-ANDROID: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -791,16 +913,19 @@ // CHECK-ANDROID: "{{.*}}{{/|\\\\}}crtend_android.o" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s @@ -811,21 +936,25 @@ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s @@ -840,6 +969,7 @@ // CHECK-ANDROID-SO: "{{.*}}{{/|\\\\}}crtend_so.o" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s @@ -850,6 +980,7 @@ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s @@ -860,21 +991,25 @@ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ -// RUN: --target=x86-linux-android \ +// RUN: --target=x86_64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -static \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s @@ -888,41 +1023,49 @@ // CHECK-ANDROID-STATIC: "{{.*}}{{/|\\\\}}crtend_android.o" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -pie \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s @@ -935,34 +1078,42 @@ // CHECK-ANDROID-PIE: "{{.*}}{{/|\\\\}}crtend_android.o" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s // CHECK-ANDROID-32: "-dynamic-linker" "/system/bin/linker" @@ -971,18 +1122,22 @@ // Test that -pthread does not add -lpthread on Android. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ @@ -991,53 +1146,64 @@ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-androideabi -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=aarch64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=arm64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=i686-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=x86_64-linux-android -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: -shared \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s @@ -1045,6 +1211,7 @@ // // RUN: %clang -no-canonical-prefixes %t.o -### -o %t 2>&1 \ // RUN: --target=arm-linux-androideabi -pthread \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \ // RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD-LINK %s // CHECK-ANDROID-PTHREAD-LINK-NOT: argument unused during compilation: '-pthread' @@ -1052,6 +1219,7 @@ // Check linker invocation on Debian 6 MIPS 32/64-bit. // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_6_mips_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPSEL %s // CHECK-DEBIAN-ML-MIPSEL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1068,6 +1236,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-gnu \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_6_mips_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL %s // CHECK-DEBIAN-ML-MIPS64EL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1084,6 +1253,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-gnu -mabi=n32 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_6_mips_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL-N32 %s // CHECK-DEBIAN-ML-MIPS64EL-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1100,6 +1270,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64-linux-gnuabi64 -mabi=n64 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64-GNUABI %s // CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1119,6 +1290,7 @@ // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips64el-linux-gnuabi64 -mabi=n64 \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL-GNUABI %s // CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1139,6 +1311,7 @@ // Test linker invocation for Freescale SDK (OpenEmbedded). // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc-fsl-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/freescale_ppc_tree \ // RUN: | FileCheck --check-prefix=CHECK-FSL-PPC %s // CHECK-FSL-PPC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1148,6 +1321,7 @@ // CHECK-FSL-PPC: "-L[[SYSROOT]]/usr/lib" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=powerpc64-fsl-linux \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/freescale_ppc64_tree \ // RUN: | FileCheck --check-prefix=CHECK-FSL-PPC64 %s // CHECK-FSL-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" @@ -1158,41 +1332,53 @@ // // Check that crtfastmath.o is linked with -ffast-math and with -Ofast. // RUN: %clang --target=x86_64-unknown-linux -### %s \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -ffast-math \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -funsafe-math-optimizations\ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast\ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -O3\ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -O3 -Ofast\ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -ffast-math -fno-fast-math \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -fno-fast-math \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -fno-unsafe-math-optimizations \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -fno-fast-math -Ofast \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // RUN: %clang --target=x86_64-unknown-linux -### %s -fno-unsafe-math-optimizations -Ofast \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s // We don't have crtfastmath.o in the i386 tree, use it to check that file // detection works. // RUN: %clang --target=i386-unknown-linux -### %s -ffast-math \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s // CHECK-CRTFASTMATH: usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtfastmath.o @@ -1200,12 +1386,14 @@ // Check that we link in gcrt1.o when compiling with -pg // RUN: %clang -pg --target=x86_64-unknown-linux -### %s \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \ // RUN: | FileCheck --check-prefix=CHECK-PG %s // CHECK-PG: gcrt1.o // GCC forwards -u to the linker. // RUN: %clang -u asdf --target=x86_64-unknown-linux -### %s \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \ // RUN: | FileCheck --check-prefix=CHECK-u %s // CHECK-u: "-u" "asdf" diff --git a/test/Driver/lto.c b/test/Driver/lto.c index 91524bf78b1d..62300bd8fac1 100644 --- a/test/Driver/lto.c +++ b/test/Driver/lto.c @@ -1,19 +1,22 @@ // -flto causes a switch to llvm-bc object files. // RUN: %clang -ccc-print-phases -c %s -flto 2> %t.log -// RUN: grep '2: compiler, {1}, lto-bc' %t.log +// RUN: grep '2: compiler, {1}, ir' %t.log +// RUN: grep '3: backend, {2}, lto-bc' %t.log // RUN: %clang -ccc-print-phases %s -flto 2> %t.log // RUN: grep '0: input, ".*lto.c", c' %t.log // RUN: grep '1: preprocessor, {0}, cpp-output' %t.log -// RUN: grep '2: compiler, {1}, lto-bc' %t.log -// RUN: grep '3: linker, {2}, image' %t.log +// RUN: grep '2: compiler, {1}, ir' %t.log +// RUN: grep '3: backend, {2}, lto-bc' %t.log +// RUN: grep '4: linker, {3}, image' %t.log // llvm-bc and llvm-ll outputs need to match regular suffixes // (unfortunately). // RUN: %clang %s -flto -save-temps -### 2> %t.log // RUN: grep '"-o" ".*lto\.i" "-x" "c" ".*lto\.c"' %t.log -// RUN: grep '"-o" ".*lto\.o" .*".*lto\.i"' %t.log -// RUN: grep '".*a.out" .*".*lto\.o"' %t.log +// RUN: grep '"-o" ".*lto\.bc" .*".*lto\.i"' %t.log +// RUN: grep '"-o" ".*lto\.o" .*".*lto\.bc"' %t.log +// RUN: grep '".*a\.\(out\|exe\)" .*".*lto\.o"' %t.log // RUN: %clang %s -flto -S -### 2> %t.log // RUN: grep '"-o" ".*lto\.s" "-x" "c" ".*lto\.c"' %t.log diff --git a/test/Driver/mips-as.c b/test/Driver/mips-as.c index ecbe7d668f96..12f184437417 100644 --- a/test/Driver/mips-as.c +++ b/test/Driver/mips-as.c @@ -51,7 +51,7 @@ // RUN: %clang -target mips64el-linux-gnu -mabi=64 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=MIPS64R2-EL-AS %s -// MIPS64R2-EL-AS: as{{(.exe)?}}" "-march" "mips64r2" "-mabi" "64" "-mno-shared" "-KPIC" "-EL" +// MIPS64R2-EL-AS: as{{(.exe)?}}" "-march" "mips64r2" "-mabi" "64" "-mno-shared" "-KPIC" "-EL" // // RUN: %clang -target mips-linux-gnu -march=mips32r2 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ @@ -61,7 +61,7 @@ // RUN: %clang -target mips64-linux-gnu -march=octeon -### \ // RUN: -no-integrated-as -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=MIPS-OCTEON %s -// MIPS-OCTEON: as{{(.exe)?}}" "-march" "octeon" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS-OCTEON: as{{(.exe)?}}" "-march" "octeon" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips-linux-gnu -mips1 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ @@ -106,17 +106,17 @@ // RUN: %clang -target mips64-linux-gnu -mips64 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=MIPS-ALIAS-64 %s -// MIPS-ALIAS-64: as{{(.exe)?}}" "-march" "mips64" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS-ALIAS-64: as{{(.exe)?}}" "-march" "mips64" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips64-linux-gnu -mips64r2 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=MIPS-ALIAS-64R2 %s -// MIPS-ALIAS-64R2: as{{(.exe)?}}" "-march" "mips64r2" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS-ALIAS-64R2: as{{(.exe)?}}" "-march" "mips64r2" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips64-linux-gnu -mips64r6 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=MIPS-ALIAS-64R6 %s -// MIPS-ALIAS-64R6: as{{(.exe)?}}" "-march" "mips64r6" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS-ALIAS-64R6: as{{(.exe)?}}" "-march" "mips64r6" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips-linux-gnu -mno-mips16 -mips16 -### \ // RUN: -no-integrated-as -c %s 2>&1 \ @@ -214,15 +214,15 @@ // // RUN: %clang -target mips64-linux-gnu -### -no-integrated-as -c %s -mcpu=mips3 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS3-EB-AS %s -// MIPS3-EB-AS: as{{(.exe)?}}" "-march" "mips3" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS3-EB-AS: as{{(.exe)?}}" "-march" "mips3" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips64-linux-gnu -### -no-integrated-as -c %s -mcpu=mips4 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS4-EB-AS %s -// MIPS4-EB-AS: as{{(.exe)?}}" "-march" "mips4" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS4-EB-AS: as{{(.exe)?}}" "-march" "mips4" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips64-linux-gnu -### -no-integrated-as -c %s -mcpu=mips5 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS5-EB-AS %s -// MIPS5-EB-AS: as{{(.exe)?}}" "-march" "mips5" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS5-EB-AS: as{{(.exe)?}}" "-march" "mips5" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips-linux-gnu -### -no-integrated-as -c %s -mcpu=mips32 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS32-EB-AS %s @@ -236,11 +236,11 @@ // // RUN: %clang -target mips64-linux-gnu -### -no-integrated-as -c %s -mcpu=mips64 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS64-EB-AS %s -// MIPS64-EB-AS: as{{(.exe)?}}" "-march" "mips64" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS64-EB-AS: as{{(.exe)?}}" "-march" "mips64" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips64-linux-gnu -### -no-integrated-as -c %s -mcpu=mips64r6 \ // RUN: 2>&1 | FileCheck -check-prefix=MIPS64R6-EB-AS %s -// MIPS64R6-EB-AS: as{{(.exe)?}}" "-march" "mips64r6" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" +// MIPS64R6-EB-AS: as{{(.exe)?}}" "-march" "mips64r6" "-mabi" "64" "-mno-shared" "-KPIC" "-EB" // // RUN: %clang -target mips-linux-gnu -### -no-integrated-as -msoft-float -mhard-float -c %s 2>&1 \ // RUN: | FileCheck -check-prefix=HARDFLOAT --implicit-check-not=-msoft-float %s diff --git a/test/Driver/mips-cs.cpp b/test/Driver/mips-cs.cpp index ad031a935de3..62a90f0b9110 100644 --- a/test/Driver/mips-cs.cpp +++ b/test/Driver/mips-cs.cpp @@ -28,6 +28,35 @@ // CHECK-BE-HF-32: "[[TC]]{{/|\\\\}}crtend.o" // CHECK-BE-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, hard float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-HF-32 %s +// CHECK-BE-UC-HF-32: "-internal-isystem" +// CHECK-BE-UC-HF-32: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-BE-UC-HF-32: "-internal-isystem" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc" +// CHECK-BE-UC-HF-32: "-internal-isystem" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-BE-UC-HF-32: "-internal-externc-isystem" +// CHECK-BE-UC-HF-32: "[[TC]]/include" +// CHECK-BE-UC-HF-32: "-internal-externc-isystem" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-BE-UC-HF-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-HF-32: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc" +// CHECK-BE-UC-HF-32: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-HF-32: "[[TC]]/uclibc{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-HF-32: "-L[[TC]]/uclibc" +// CHECK-BE-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc" +// CHECK-BE-UC-HF-32-NOT: "-L[[TC]]" +// CHECK-BE-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/lib/../lib" +// CHECK-BE-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/lib/../lib" +// CHECK-BE-UC-HF-32: "[[TC]]/uclibc{{/|\\\\}}crtend.o" +// CHECK-BE-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, hard float, mips16 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -mips16 \ @@ -115,6 +144,35 @@ // CHECK-BE-HF-NAN: "[[TC]]/nan2008{{/|\\\\}}crtend.o" // CHECK-BE-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, hard float, uclibc, nan2008 +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -muclibc -mnan=2008 \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-HF-NAN %s +// CHECK-BE-UC-HF-NAN: "-internal-isystem" +// CHECK-BE-UC-HF-NAN: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-BE-UC-HF-NAN: "-internal-isystem" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc/nan2008" +// CHECK-BE-UC-HF-NAN: "-internal-isystem" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-BE-UC-HF-NAN: "-internal-externc-isystem" +// CHECK-BE-UC-HF-NAN: "[[TC]]/include" +// CHECK-BE-UC-HF-NAN: "-internal-externc-isystem" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-BE-UC-HF-NAN: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-HF-NAN: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008" +// CHECK-BE-UC-HF-NAN: "-dynamic-linker" "/lib/ld-uClibc-mipsn8.so.0" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-HF-NAN: "[[TC]]/uclibc/nan2008{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-HF-NAN: "-L[[TC]]/uclibc/nan2008" +// CHECK-BE-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc/nan2008" +// CHECK-BE-UC-HF-NAN-NOT: "-L[[TC]]" +// CHECK-BE-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/lib/../lib" +// CHECK-BE-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/usr/lib/../lib" +// CHECK-BE-UC-HF-NAN: "[[TC]]/uclibc/nan2008{{/|\\\\}}crtend.o" +// CHECK-BE-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, soft float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -msoft-float \ @@ -144,6 +202,35 @@ // CHECK-BE-SF-32: "[[TC]]/soft-float{{/|\\\\}}crtend.o" // CHECK-BE-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/soft-float/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, soft float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -muclibc -msoft-float \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-SF-32 %s +// CHECK-BE-UC-SF-32: "-internal-isystem" +// CHECK-BE-UC-SF-32: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-BE-UC-SF-32: "-internal-isystem" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc/soft-float" +// CHECK-BE-UC-SF-32: "-internal-isystem" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-BE-UC-SF-32: "-internal-externc-isystem" +// CHECK-BE-UC-SF-32: "[[TC]]/include" +// CHECK-BE-UC-SF-32: "-internal-externc-isystem" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-BE-UC-SF-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-SF-32: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float" +// CHECK-BE-UC-SF-32: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-SF-32: "[[TC]]/uclibc/soft-float{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-SF-32: "-L[[TC]]/uclibc/soft-float" +// CHECK-BE-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc/soft-float" +// CHECK-BE-UC-SF-32-NOT: "-L[[TC]]" +// CHECK-BE-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/lib/../lib" +// CHECK-BE-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/usr/lib/../lib" +// CHECK-BE-UC-SF-32: "[[TC]]/uclibc/soft-float{{/|\\\\}}crtend.o" +// CHECK-BE-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, soft float, mips16 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -msoft-float -mips16 \ @@ -289,6 +376,35 @@ // CHECK-EL-HF-32: "[[TC]]/el{{/|\\\\}}crtend.o" // CHECK-EL-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/el/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, hard float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -mhard-float -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-HF-32 %s +// CHECK-EL-UC-HF-32: "-internal-isystem" +// CHECK-EL-UC-HF-32: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-EL-UC-HF-32: "-internal-isystem" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc/el" +// CHECK-EL-UC-HF-32: "-internal-isystem" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-EL-UC-HF-32: "-internal-externc-isystem" +// CHECK-EL-UC-HF-32: "[[TC]]/include" +// CHECK-EL-UC-HF-32: "-internal-externc-isystem" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-EL-UC-HF-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-HF-32: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el" +// CHECK-EL-UC-HF-32: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-HF-32: "[[TC]]/uclibc/el{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-HF-32: "-L[[TC]]/uclibc/el" +// CHECK-EL-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc/el" +// CHECK-EL-UC-HF-32-NOT: "-L[[TC]]" +// CHECK-EL-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el/lib/../lib" +// CHECK-EL-UC-HF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el/usr/lib/../lib" +// CHECK-EL-UC-HF-32: "[[TC]]/uclibc/el{{/|\\\\}}crtend.o" +// CHECK-EL-UC-HF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/el/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, hard float, mips16 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mips16 \ @@ -376,6 +492,35 @@ // CHECK-EL-HF-NAN: "[[TC]]/nan2008/el{{/|\\\\}}crtend.o" // CHECK-EL-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/nan2008/el/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, hard float, uclibc, nan2008 +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -muclibc -mnan=2008 \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-HF-NAN %s +// CHECK-EL-UC-HF-NAN: "-internal-isystem" +// CHECK-EL-UC-HF-NAN: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-EL-UC-HF-NAN: "-internal-isystem" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc/nan2008/el" +// CHECK-EL-UC-HF-NAN: "-internal-isystem" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-EL-UC-HF-NAN: "-internal-externc-isystem" +// CHECK-EL-UC-HF-NAN: "[[TC]]/include" +// CHECK-EL-UC-HF-NAN: "-internal-externc-isystem" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-EL-UC-HF-NAN: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-HF-NAN: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el" +// CHECK-EL-UC-HF-NAN: "-dynamic-linker" "/lib/ld-uClibc-mipsn8.so.0" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-HF-NAN: "[[TC]]/uclibc/nan2008/el{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-HF-NAN: "-L[[TC]]/uclibc/nan2008/el" +// CHECK-EL-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc/nan2008/el" +// CHECK-EL-UC-HF-NAN-NOT: "-L[[TC]]" +// CHECK-EL-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el/lib/../lib" +// CHECK-EL-UC-HF-NAN: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/../lib" +// CHECK-EL-UC-HF-NAN: "[[TC]]/uclibc/nan2008/el{{/|\\\\}}crtend.o" +// CHECK-EL-UC-HF-NAN: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/nan2008/el/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, soft float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mfloat-abi=soft \ @@ -405,6 +550,35 @@ // CHECK-EL-SF-32: "[[TC]]/soft-float/el{{/|\\\\}}crtend.o" // CHECK-EL-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/soft-float/el/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, soft float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -mfloat-abi=soft -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_cs_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-SF-32 %s +// CHECK-EL-UC-SF-32: "-internal-isystem" +// CHECK-EL-UC-SF-32: "[[TC:[^"]+/lib/gcc/mips-linux-gnu/4.6.3]]/../../../../mips-linux-gnu/include/c++/4.6.3" +// CHECK-EL-UC-SF-32: "-internal-isystem" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/mips-linux-gnu/uclibc/soft-float/el" +// CHECK-EL-UC-SF-32: "-internal-isystem" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/include/c++/4.6.3/backward" +// CHECK-EL-UC-SF-32: "-internal-externc-isystem" +// CHECK-EL-UC-SF-32: "[[TC]]/include" +// CHECK-EL-UC-SF-32: "-internal-externc-isystem" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/usr/include" +// CHECK-EL-UC-SF-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-SF-32: "--sysroot=[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el" +// CHECK-EL-UC-SF-32: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-SF-32: "[[TC]]/uclibc/soft-float/el{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-SF-32: "-L[[TC]]/uclibc/soft-float/el" +// CHECK-EL-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/lib/../lib/uclibc/soft-float/el" +// CHECK-EL-UC-SF-32-NOT: "-L[[TC]]" +// CHECK-EL-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el/lib/../lib" +// CHECK-EL-UC-SF-32: "-L[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/../lib" +// CHECK-EL-UC-SF-32: "[[TC]]/uclibc/soft-float/el{{/|\\\\}}crtend.o" +// CHECK-EL-UC-SF-32: "[[TC]]/../../../../mips-linux-gnu/libc/uclibc/soft-float/el/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, soft float, mips16 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mips16 -msoft-float \ diff --git a/test/Driver/mips-features.c b/test/Driver/mips-features.c index 03cc0fd7e368..f7022306fc11 100644 --- a/test/Driver/mips-features.c +++ b/test/Driver/mips-features.c @@ -1,5 +1,15 @@ // Check handling MIPS specific features options. // +// -mabicalls +// RUN: %clang -target mips-linux-gnu -### -c %s -mno-abicalls -mabicalls 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MABICALLS %s +// CHECK-MABICALLS: "-target-feature" "-noabicalls" +// +// -mno-abicalls +// RUN: %clang -target mips-linux-gnu -### -c %s -mabicalls -mno-abicalls 2>&1 \ +// RUN: | FileCheck --check-prefix=CHECK-MNOABICALLS %s +// CHECK-MNOABICALLS: "-target-feature" "+noabicalls" +// // -mips16 // RUN: %clang -target mips-linux-gnu -### -c %s \ // RUN: -mno-mips16 -mips16 2>&1 \ diff --git a/test/Driver/mips-fsf.cpp b/test/Driver/mips-fsf.cpp index 34ad91456e12..07b95c8fe9de 100644 --- a/test/Driver/mips-fsf.cpp +++ b/test/Driver/mips-fsf.cpp @@ -297,6 +297,33 @@ // CHECK-BE-HF-32R2: "[[TC]]{{/|\\\\}}crtend.o" // CHECK-BE-HF-32R2: "[[TC]]/../../../../sysroot/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, mips32r2, hard float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -mips32r2 -mhard-float -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-HF-32R2 %s +// CHECK-BE-UC-HF-32R2: "-internal-isystem" +// CHECK-BE-UC-HF-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-BE-UC-HF-32R2: "-internal-isystem" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc" +// CHECK-BE-UC-HF-32R2: "-internal-isystem" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-BE-UC-HF-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-HF-32R2: "[[TC]]/include" +// CHECK-BE-UC-HF-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-BE-UC-HF-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-HF-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc" +// CHECK-BE-UC-HF-32R2: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-HF-32R2: "[[TC]]/uclibc{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-HF-32R2: "-L[[TC]]/uclibc" +// CHECK-BE-UC-HF-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc" +// CHECK-BE-UC-HF-32R2: "-L[[TC]]/../../../../sysroot/uclibc/usr/lib/../lib" +// CHECK-BE-UC-HF-32R2: "[[TC]]/uclibc{{/|\\\\}}crtend.o" +// CHECK-BE-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, mips32r2, fp64, hard float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -mips32r2 -mfp64 -mhard-float \ @@ -351,6 +378,33 @@ // CHECK-BE-SF-32R2: "[[TC]]/sof{{/|\\\\}}crtend.o" // CHECK-BE-SF-32R2: "[[TC]]/../../../../sysroot/sof/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, mips32r2, soft float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -mips32r2 -msoft-float -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-SF-32R2 %s +// CHECK-BE-UC-SF-32R2: "-internal-isystem" +// CHECK-BE-UC-SF-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-BE-UC-SF-32R2: "-internal-isystem" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/sof" +// CHECK-BE-UC-SF-32R2: "-internal-isystem" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-BE-UC-SF-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-SF-32R2: "[[TC]]/include" +// CHECK-BE-UC-SF-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-BE-UC-SF-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-SF-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc/sof" +// CHECK-BE-UC-SF-32R2: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/sof/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/sof/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-SF-32R2: "[[TC]]/uclibc/sof{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-SF-32R2: "-L[[TC]]/uclibc/sof" +// CHECK-BE-UC-SF-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc/sof" +// CHECK-BE-UC-SF-32R2: "-L[[TC]]/../../../../sysroot/uclibc/sof/usr/lib/../lib" +// CHECK-BE-UC-SF-32R2: "[[TC]]/uclibc/sof{{/|\\\\}}crtend.o" +// CHECK-BE-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/sof/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, mips32r2 / mips16, hard float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -mips32r2 -mips16 -mhard-float \ @@ -513,6 +567,33 @@ // CHECK-BE-NAN-32R2: "[[TC]]/nan2008{{/|\\\\}}crtend.o" // CHECK-BE-NAN-32R2: "[[TC]]/../../../../sysroot/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Big-endian, mips32r2, nan2008, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-linux-gnu -mips32r2 -mnan=2008 -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-BE-UC-NAN-32R2 %s +// CHECK-BE-UC-NAN-32R2: "-internal-isystem" +// CHECK-BE-UC-NAN-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-BE-UC-NAN-32R2: "-internal-isystem" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/nan2008" +// CHECK-BE-UC-NAN-32R2: "-internal-isystem" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-BE-UC-NAN-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/include" +// CHECK-BE-UC-NAN-32R2: "-internal-externc-isystem" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-BE-UC-NAN-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-BE-UC-NAN-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc/nan2008" +// CHECK-BE-UC-NAN-32R2: "-dynamic-linker" "/lib/ld-uClibc-mipsn8.so.0" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/uclibc/nan2008{{/|\\\\}}crtbegin.o" +// CHECK-BE-UC-NAN-32R2: "-L[[TC]]/uclibc/nan2008" +// CHECK-BE-UC-NAN-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc/nan2008" +// CHECK-BE-UC-NAN-32R2: "-L[[TC]]/../../../../sysroot/uclibc/nan2008/usr/lib/../lib" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/uclibc/nan2008{{/|\\\\}}crtend.o" +// CHECK-BE-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Big-endian, mips32r2, fp64, nan2008 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu -mips32r2 -mfp64 -mnan=2008 \ @@ -1566,6 +1647,33 @@ // CHECK-EL-HF-32R2: "[[TC]]/el{{/|\\\\}}crtend.o" // CHECK-EL-HF-32R2: "[[TC]]/../../../../sysroot/el/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, mips32r2, hard float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -mips32r2 -mhard-float -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-HF-32R2 %s +// CHECK-EL-UC-HF-32R2: "-internal-isystem" +// CHECK-EL-UC-HF-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-EL-UC-HF-32R2: "-internal-isystem" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el" +// CHECK-EL-UC-HF-32R2: "-internal-isystem" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-EL-UC-HF-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-HF-32R2: "[[TC]]/include" +// CHECK-EL-UC-HF-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-EL-UC-HF-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-HF-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc/el" +// CHECK-EL-UC-HF-32R2: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-HF-32R2: "[[TC]]/uclibc/el{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-HF-32R2: "-L[[TC]]/uclibc/el" +// CHECK-EL-UC-HF-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc/el" +// CHECK-EL-UC-HF-32R2: "-L[[TC]]/../../../../sysroot/uclibc/el/usr/lib/../lib" +// CHECK-EL-UC-HF-32R2: "[[TC]]/uclibc/el{{/|\\\\}}crtend.o" +// CHECK-EL-UC-HF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, mips32r2, fp64, hard float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mips32r2 -mfp64 -mhard-float \ @@ -1620,6 +1728,33 @@ // CHECK-EL-SF-32R2: "[[TC]]/el/sof{{/|\\\\}}crtend.o" // CHECK-EL-SF-32R2: "[[TC]]/../../../../sysroot/el/sof/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, mips32r2, soft float, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -mips32r2 -msoft-float -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-SF-32R2 %s +// CHECK-EL-UC-SF-32R2: "-internal-isystem" +// CHECK-EL-UC-SF-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-EL-UC-SF-32R2: "-internal-isystem" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/sof" +// CHECK-EL-UC-SF-32R2: "-internal-isystem" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-EL-UC-SF-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-SF-32R2: "[[TC]]/include" +// CHECK-EL-UC-SF-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-EL-UC-SF-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-SF-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc/el/sof" +// CHECK-EL-UC-SF-32R2: "-dynamic-linker" "/lib/ld-uClibc.so.0" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/sof/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/sof/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-SF-32R2: "[[TC]]/uclibc/el/sof{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-SF-32R2: "-L[[TC]]/uclibc/el/sof" +// CHECK-EL-UC-SF-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc/el/sof" +// CHECK-EL-UC-SF-32R2: "-L[[TC]]/../../../../sysroot/uclibc/el/sof/usr/lib/../lib" +// CHECK-EL-UC-SF-32R2: "[[TC]]/uclibc/el/sof{{/|\\\\}}crtend.o" +// CHECK-EL-UC-SF-32R2: "[[TC]]/../../../../sysroot/uclibc/el/sof/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, mips32r2 / mips16, hard float // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mips32r2 -mips16 -mhard-float \ @@ -1782,6 +1917,33 @@ // CHECK-EL-NAN-32R2: "[[TC]]/el/nan2008{{/|\\\\}}crtend.o" // CHECK-EL-NAN-32R2: "[[TC]]/../../../../sysroot/el/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" // +// = Little-endian, mips32r2, nan2008, uclibc +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mipsel-linux-gnu -mips32r2 -mnan=2008 -muclibc \ +// RUN: --gcc-toolchain=%S/Inputs/mips_fsf_tree \ +// RUN: | FileCheck --check-prefix=CHECK-EL-UC-NAN-32R2 %s +// CHECK-EL-UC-NAN-32R2: "-internal-isystem" +// CHECK-EL-UC-NAN-32R2: "[[TC:[^"]+/lib/gcc/mips-mti-linux-gnu/4.9.0]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0" +// CHECK-EL-UC-NAN-32R2: "-internal-isystem" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/mips-mti-linux-gnu/uclibc/el/nan2008" +// CHECK-EL-UC-NAN-32R2: "-internal-isystem" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../mips-mti-linux-gnu/include/c++/4.9.0/backward" +// CHECK-EL-UC-NAN-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/include" +// CHECK-EL-UC-NAN-32R2: "-internal-externc-isystem" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/usr/include" +// CHECK-EL-UC-NAN-32R2: "{{.*}}ld{{(.exe)?}}" +// CHECK-EL-UC-NAN-32R2: "--sysroot=[[TC]]/../../../../sysroot/uclibc/el/nan2008" +// CHECK-EL-UC-NAN-32R2: "-dynamic-linker" "/lib/ld-uClibc-mipsn8.so.0" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/el/nan2008/usr/lib/../lib{{/|\\\\}}crt1.o" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/el/nan2008/usr/lib/../lib{{/|\\\\}}crti.o" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/uclibc/el/nan2008{{/|\\\\}}crtbegin.o" +// CHECK-EL-UC-NAN-32R2: "-L[[TC]]/uclibc/el/nan2008" +// CHECK-EL-UC-NAN-32R2: "-L[[TC]]/../../../../mips-mti-linux-gnu/lib/../lib/uclibc/el/nan2008" +// CHECK-EL-UC-NAN-32R2: "-L[[TC]]/../../../../sysroot/uclibc/el/nan2008/usr/lib/../lib" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/uclibc/el/nan2008{{/|\\\\}}crtend.o" +// CHECK-EL-UC-NAN-32R2: "[[TC]]/../../../../sysroot/uclibc/el/nan2008/usr/lib/../lib{{/|\\\\}}crtn.o" +// // = Little-endian, mips32r2, fp64, nan2008 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu -mips32r2 -mfp64 -mnan=2008 \ diff --git a/test/Driver/mips-integrated-as.s b/test/Driver/mips-integrated-as.s index c3b1db391e0f..b648650e4be9 100644 --- a/test/Driver/mips-integrated-as.s +++ b/test/Driver/mips-integrated-as.s @@ -205,3 +205,13 @@ // FPXX-ODDSPREG: -cc1as // FPXX-ODDSPREG: "-target-feature" "+fpxx" // FPXX-ODDSPREG: "-target-feature" "-nooddspreg" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -c %s -mabicalls 2>&1 | \ +// RUN: FileCheck -check-prefix=ABICALLS-ON %s +// ABICALLS-ON: -cc1as +// ABICALLS-ON: "-target-feature" "-noabicalls" + +// RUN: %clang -target mips-linux-gnu -### -fintegrated-as -c %s -mno-abicalls 2>&1 | \ +// RUN: FileCheck -check-prefix=ABICALLS-OFF %s +// ABICALLS-OFF: -cc1as +// ABICALLS-OFF: "-target-feature" "+noabicalls" diff --git a/test/Driver/mips-reduced-toolchain.cpp b/test/Driver/mips-reduced-toolchain.cpp index fe7ed8ae045d..894bdb5a756b 100644 --- a/test/Driver/mips-reduced-toolchain.cpp +++ b/test/Driver/mips-reduced-toolchain.cpp @@ -4,6 +4,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mips-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_reduced_mips_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS %s // CHECK-DEBIAN-MIPS: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" // CHECK-DEBIAN-MIPS: "{{.*}}/usr/lib/gcc/mips-linux-gnu/4.7{{/|\\\\}}crtbegin.o" @@ -17,6 +18,7 @@ // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: --target=mipsel-linux-gnu \ // RUN: --sysroot=%S/Inputs/debian_reduced_mips_tree \ +// RUN: --gcc-toolchain="" \ // RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPSEL %s // CHECK-DEBIAN-MIPSEL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]" // CHECK-DEBIAN-MIPSEL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.7{{/|\\\\}}crtbegin.o" diff --git a/test/Driver/modules.m b/test/Driver/modules.m index d8e20e4148e9..8a0c8ba4d88f 100644 --- a/test/Driver/modules.m +++ b/test/Driver/modules.m @@ -4,18 +4,36 @@ // RUN: %clang -fmodules -fno-modules -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s // CHECK-HAS-MODULES: -fmodules -// RUN: %clang -fbuild-session-timestamp=123 -### %s 2>&1 | FileCheck -check-prefix=TIMESTAMP_ONLY %s -// TIMESTAMP_ONLY: -fbuild-session-timestamp=123 +// RUN: %clang -fbuild-session-file=doesntexist -### %s 2>&1 | FileCheck -check-prefix=NOFILE %s +// NOFILE: no such file or directory: 'doesntexist' + +// RUN: touch -m -a -t 201008011501 %t.build-session-file +// RUN: %clang -fbuild-session-file=%t.build-session-file -### %s 2>&1 | FileCheck -check-prefix=TIMESTAMP_ONLY %s + +// RUN: %clang -fbuild-session-timestamp=1280703457 -### %s 2>&1 | FileCheck -check-prefix=TIMESTAMP_ONLY %s +// TIMESTAMP_ONLY: -fbuild-session-timestamp=128 + +// RUN: %clang -fbuild-session-file=%t.build-session-file -fbuild-session-timestamp=123 -### %s 2>&1 | FileCheck -check-prefix=CONFLICT %s +// CONFLICT: error: invalid argument '-fbuild-session-file={{.*}}.build-session-file' not allowed with '-fbuild-session-timestamp' // RUN: %clang -fbuild-session-timestamp=123 -fmodules-validate-once-per-build-session -### %s 2>&1 | FileCheck -check-prefix=MODULES_VALIDATE_ONCE %s // MODULES_VALIDATE_ONCE: -fbuild-session-timestamp=123 // MODULES_VALIDATE_ONCE: -fmodules-validate-once-per-build-session +// RUN: %clang -fbuild-session-file=%t.build-session-file -fmodules-validate-once-per-build-session -### %s 2>&1 | FileCheck -check-prefix=MODULES_VALIDATE_ONCE_FILE %s +// MODULES_VALIDATE_ONCE_FILE: -fbuild-session-timestamp=128 +// MODULES_VALIDATE_ONCE_FILE: -fmodules-validate-once-per-build-session + // RUN: %clang -fmodules-validate-once-per-build-session -### %s 2>&1 | FileCheck -check-prefix=MODULES_VALIDATE_ONCE_ERR %s -// MODULES_VALIDATE_ONCE_ERR: option '-fmodules-validate-once-per-build-session' requires '-fbuild-session-timestamp=<seconds since Epoch>' +// MODULES_VALIDATE_ONCE_ERR: option '-fmodules-validate-once-per-build-session' requires '-fbuild-session-timestamp=<seconds since Epoch>' or '-fbuild-session-file=<file>' // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=MODULES_VALIDATE_SYSTEM_HEADERS_DEFAULT %s // MODULES_VALIDATE_SYSTEM_HEADERS_DEFAULT-NOT: -fmodules-validate-system-headers // RUN: %clang -fmodules-validate-system-headers -### %s 2>&1 | FileCheck -check-prefix=MODULES_VALIDATE_SYSTEM_HEADERS %s // MODULES_VALIDATE_SYSTEM_HEADERS: -fmodules-validate-system-headers + +// RUN: %clang -fmodules -fmodule-map-file=foo.map -fmodule-map-file=bar.map -### %s 2>&1 | FileCheck -check-prefix=CHECK-MODULE-MAP-FILES %s +// CHECK-MODULE-MAP-FILES: "-fmodules" +// CHECK-MODULE-MAP-FILES: "-fmodule-map-file=foo.map" +// CHECK-MODULE-MAP-FILES: "-fmodule-map-file=bar.map" diff --git a/test/Driver/modules.mm b/test/Driver/modules.mm index b2948c4b3d96..63db69956e45 100644 --- a/test/Driver/modules.mm +++ b/test/Driver/modules.mm @@ -1,6 +1,8 @@ -// RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s +// RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s // RUN: %clang -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s +// RUN: %clang -fmodules -fno-cxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s // CHECK-NO-MODULES-NOT: -fmodules -// RUN: %clang -fcxx-modules -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s +// RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s +// RUN: %clang -fmodules -fno-cxx-modules -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s // CHECK-HAS-MODULES: -fmodules diff --git a/test/Driver/msvc_forward.c b/test/Driver/msvc_forward.c index fe0ae84790e0..15f941ef95de 100644 --- a/test/Driver/msvc_forward.c +++ b/test/Driver/msvc_forward.c @@ -1,5 +1,7 @@ -// RUN: %clang -target i686-pc-win32 -lkernel32.lib -luser32.lib -### %s 2>&1 | FileCheck %s +// RUN: %clang -target i686-pc-win32 -loldnames -lkernel32.lib -luser32.lib -### %s 2>&1 | FileCheck %s +// CHECK-NOT: "-loldnames.lib" // CHECK-NOT: "-lkernel32.lib" // CHECK-NOT: "-luser32.lib" +// CHECK: "oldnames.lib" // CHECK: "kernel32.lib" // CHECK: "user32.lib" diff --git a/test/Driver/netbsd.c b/test/Driver/netbsd.c index 0e3ebf3c9a28..eded7f52df7e 100644 --- a/test/Driver/netbsd.c +++ b/test/Driver/netbsd.c @@ -13,36 +13,42 @@ // RUN: %clang -no-canonical-prefixes -target aarch64--netbsd7.0.0 \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=AARCH64-7 %s -// RUN: %clang -no-canonical-prefixes -target arm64--netbsd \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=ARM64 %s -// RUN: %clang -no-canonical-prefixes -target arm64--netbsd7.0.0 \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=ARM64-7 %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd-eabi \ // RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=ARM %s +// RUN: %clang -no-canonical-prefixes -target armeb--netbsd-eabi \ +// RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=ARMEB %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd \ // RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=ARM-APCS %s +// RUN: %clang -no-canonical-prefixes -target arm--netbsd-eabihf \ +// RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=ARM-HF %s // RUN: %clang -no-canonical-prefixes -target thumb--netbsd-eabi \ // RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=THUMB %s +// RUN: %clang -no-canonical-prefixes -target thumbeb--netbsd-eabi \ +// RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=THUMBEB %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd7.0.0-eabi \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=ARM-7 %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd6.0.0-eabi \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=ARM-6 %s -// RUN: %clang -no-canonical-prefixes -target arm--netbsd-eabihf \ -// RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=ARM-HF %s // RUN: %clang -no-canonical-prefixes -target sparc--netbsd \ // RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=SPARC %s // RUN: %clang -no-canonical-prefixes -target sparc64--netbsd \ // RUN: -no-integrated-as --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=SPARC64 %s +// RUN: %clang -no-canonical-prefixes -target powerpc--netbsd \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=POWERPC %s +// RUN: %clang -no-canonical-prefixes -target powerpc64--netbsd \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=POWERPC64 %s // RUN: %clang -no-canonical-prefixes -target x86_64--netbsd -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ @@ -59,15 +65,12 @@ // RUN: %clang -no-canonical-prefixes -target aarch64--netbsd7.0.0 -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-AARCH64-7 %s -// RUN: %clang -no-canonical-prefixes -target arm64--netbsd -static \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=S-ARM64 %s -// RUN: %clang -no-canonical-prefixes -target arm64--netbsd7.0.0 -static \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=S-ARM64-7 %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd-eabi -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-ARM %s +// RUN: %clang -no-canonical-prefixes -target armeb--netbsd-eabi -static \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=S-ARMEB %s // RUN: %clang -no-canonical-prefixes -target arm--netbsd7.0.0-eabi -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-ARM-7 %s @@ -80,6 +83,12 @@ // RUN: %clang -no-canonical-prefixes -target sparc64--netbsd -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-SPARC64 %s +// RUN: %clang -no-canonical-prefixes -target powerpc--netbsd -static \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=S-POWERPC %s +// RUN: %clang -no-canonical-prefixes -target powerpc64--netbsd -static \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=S-POWERPC64 %s // X86_64: clang{{.*}}" "-cc1" "-triple" "x86_64--netbsd" // X86_64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -103,30 +112,14 @@ // AARCH64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // AARCH64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" // AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// AARCH64: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" // AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" // AARCH64-7: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd7.0.0" // AARCH64-7: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // AARCH64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" // AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// AARCH64-7: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" // AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" -// ARM64: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd" -// ARM64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" -// ARM64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// ARM64: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" -// ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - -// ARM64-7: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd7.0.0" -// ARM64-7: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" -// ARM64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// ARM64-7: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" -// ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - // ARM: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd-eabi" // ARM: as{{.*}}" "-mcpu=arm926ej-s" "-o" // ARM: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -136,6 +129,15 @@ // ARM: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // ARM: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// ARMEB: clang{{.*}}" "-cc1" "-triple" "armebv5e--netbsd-eabi" +// ARMEB: as{{.*}}" "-mcpu=arm926ej-s" "-o" +// ARMEB: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// ARMEB: "-m" "armelfb_nbsd_eabi" +// ARMEB: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// ARMEB: "{{.*}}/usr/lib{{/|\\\\}}eabi{{/|\\\\}}crti.o" +// ARMEB: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// ARMEB: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // ARM-APCS: clang{{.*}}" "-cc1" "-triple" "armv4--netbsd" // ARM-APCS: as{{.*}}" "-mcpu=strongarm" "-o" // ARM-APCS: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -145,6 +147,15 @@ // ARM-APCS: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // ARM-APCS: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// ARM-HF: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd-eabihf" +// ARM-HF: as{{.*}}" "-mcpu=arm926ej-s" "-o" +// ARM-HF: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// ARM-HF: "-m" "armelf_nbsd_eabihf" +// ARM-HF: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// ARM-HF: "{{.*}}/usr/lib{{/|\\\\}}eabihf{{/|\\\\}}crti.o" +// ARM-HF: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// ARM-HF: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // THUMB: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd-eabi" // THUMB: as{{.*}}" "-mcpu=arm926ej-s" "-o" // THUMB: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -154,6 +165,15 @@ // THUMB: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // THUMB: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// THUMBEB: clang{{.*}}" "-cc1" "-triple" "armebv5e--netbsd-eabi" +// THUMBEB: as{{.*}}" "-mcpu=arm926ej-s" "-o" +// THUMBEB: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// THUMBEB: "-m" "armelfb_nbsd_eabi" +// THUMBEB: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// THUMBEB: "{{.*}}/usr/lib{{/|\\\\}}eabi{{/|\\\\}}crti.o" +// THUMBEB: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// THUMBEB: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // ARM-7: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd7.0.0-eabi" // ARM-7: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // ARM-7: "-m" "armelf_nbsd_eabi" @@ -170,9 +190,6 @@ // ARM-6: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // ARM-6: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" -// ARM-HF: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd-eabihf" -// ARM-HF: ld{{.*}}" "-m" "armelf_nbsd_eabihf" - // SPARC: clang{{.*}}" "-cc1" "-triple" "sparc--netbsd" // SPARC: as{{.*}}" "-32" "-o" // SPARC: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -190,6 +207,22 @@ // SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// POWERPC: clang{{.*}}" "-cc1" "-triple" "powerpc--netbsd" +// POWERPC: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// POWERPC: "-m" "elf32ppc_nbsd" +// POWERPC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// POWERPC: "{{.*}}/usr/lib{{/|\\\\}}powerpc{{/|\\\\}}crti.o" +// POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// POWERPC64: clang{{.*}}" "-cc1" "-triple" "powerpc64--netbsd" +// POWERPC64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// POWERPC64: "-m" "elf64ppc" +// POWERPC64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crti.o" +// POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // S-X86_64: clang{{.*}}" "-cc1" "-triple" "x86_64--netbsd" // S-X86_64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-X86_64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" @@ -213,30 +246,14 @@ // S-AARCH64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-AARCH64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" // S-AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// S-AARCH64: "-lgcc_eh" "-lc" "-lgcc" // S-AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" // S-AARCH64-7: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd7.0.0" // S-AARCH64-7: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-AARCH64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" // S-AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// S-AARCH64-7: "-lgcc_eh" "-lc" "-lgcc" // S-AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" -// S-ARM64: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd" -// S-ARM64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" -// S-ARM64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// S-ARM64: "-lgcc_eh" "-lc" "-lgcc" -// S-ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - -// S-ARM64-7: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd7.0.0" -// S-ARM64-7: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" -// S-ARM64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" -// S-ARM64-7: "-lgcc_eh" "-lc" "-lgcc" -// S-ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - // S-ARM: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd-eabi" // S-ARM: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-ARM: "-m" "armelf_nbsd_eabi" @@ -245,6 +262,14 @@ // S-ARM: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // S-ARM: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// S-ARMEB: clang{{.*}}" "-cc1" "-triple" "armebv5e--netbsd-eabi" +// S-ARMEB: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" +// S-ARMEB: "-m" "armelfb_nbsd_eabi" +// S-ARMEB: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// S-ARMEB: "{{.*}}/usr/lib{{/|\\\\}}eabi{{/|\\\\}}crti.o" +// S-ARMEB: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// S-ARMEB: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // S-ARM-7: clang{{.*}}" "-cc1" "-triple" "armv5e--netbsd7.0.0-eabi" // S-ARM-7: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-ARM-7: "-m" "armelf_nbsd_eabi" @@ -278,3 +303,19 @@ // S-SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" // S-SPARC64: "-lgcc_eh" "-lc" "-lgcc" // S-SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// S-POWERPC: clang{{.*}}" "-cc1" "-triple" "powerpc--netbsd" +// S-POWERPC: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" +// S-POWERPC: "-m" "elf32ppc_nbsd" +// S-POWERPC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// S-POWERPC: "{{.*}}/usr/lib{{/|\\\\}}powerpc{{/|\\\\}}crti.o" +// S-POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// S-POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// S-POWERPC64: clang{{.*}}" "-cc1" "-triple" "powerpc64--netbsd" +// S-POWERPC64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" +// S-POWERPC64: "-m" "elf64ppc" +// S-POWERPC64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crti.o" +// S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc" +// S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" diff --git a/test/Driver/netbsd.cpp b/test/Driver/netbsd.cpp index 43b9fdeaa587..e386a212de2c 100644 --- a/test/Driver/netbsd.cpp +++ b/test/Driver/netbsd.cpp @@ -19,18 +19,18 @@ // RUN: %clangxx -no-canonical-prefixes -target aarch64--netbsd7.0.0 \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=AARCH64-7 %s -// RUN: %clangxx -no-canonical-prefixes -target arm64--netbsd \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=ARM64 %s -// RUN: %clangxx -no-canonical-prefixes -target arm64--netbsd7.0.0 \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=ARM64-7 %s // RUN: %clangxx -no-canonical-prefixes -target sparc--netbsd \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=SPARC %s // RUN: %clangxx -no-canonical-prefixes -target sparc64--netbsd \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=SPARC64 %s +// RUN: %clangxx -no-canonical-prefixes -target powerpc--netbsd \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=POWERPC %s +// RUN: %clangxx -no-canonical-prefixes -target powerpc64--netbsd \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=POWERPC64 %s // RUN: %clangxx -no-canonical-prefixes -target x86_64--netbsd -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ @@ -53,18 +53,18 @@ // RUN: %clangxx -no-canonical-prefixes -target aarch64--netbsd7.0.0 -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-AARCH64-7 %s -// RUN: %clangxx -no-canonical-prefixes -target arm64--netbsd -static \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=S-ARM64 %s -// RUN: %clangxx -no-canonical-prefixes -target arm64--netbsd7.0.0 -static \ -// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=S-ARM64-7 %s // RUN: %clangxx -no-canonical-prefixes -target sparc--netbsd -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-SPARC %s // RUN: %clangxx -no-canonical-prefixes -target sparc64--netbsd -static \ // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ // RUN: | FileCheck -check-prefix=S-SPARC64 %s +// RUN: %clangxx -no-canonical-prefixes -target powerpc--netbsd -static \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=S-POWERPC %s +// RUN: %clangxx -no-canonical-prefixes -target powerpc64--netbsd -static \ +// RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \ +// RUN: | FileCheck -check-prefix=S-POWERPC64 %s // X86_64: clang{{.*}}" "-cc1" "-triple" "x86_64--netbsd" // X86_64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" @@ -101,31 +101,17 @@ // AARCH64: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd" // AARCH64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // AARCH64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// AARCH64: "-lm" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" +// AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// AARCH64: "-lm" "-lc" // AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" // AARCH64-7: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd7.0.0" // AARCH64-7: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // AARCH64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// AARCH64-7: "-lm" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" +// AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// AARCH64-7: "-lm" "-lc" // AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" -// ARM64: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd" -// ARM64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" -// ARM64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// ARM64: "-lm" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" -// ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - -// ARM64-7: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd7.0.0" -// ARM64-7: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" -// ARM64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// ARM64-7: "-lm" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" -// ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - // SPARC: clang{{.*}}" "-cc1" "-triple" "sparc--netbsd" // SPARC: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" // SPARC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" @@ -141,6 +127,20 @@ // SPARC64: "-lm" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" // SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" +// POWERPC: clang{{.*}}" "-cc1" "-triple" "powerpc--netbsd" +// POWERPC: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// POWERPC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// POWERPC: "{{.*}}/usr/lib{{/|\\\\}}powerpc{{/|\\\\}}crti.o" +// POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// POWERPC: "-lm" "-lc" "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// POWERPC64: clang{{.*}}" "-cc1" "-triple" "powerpc64--netbsd" +// POWERPC64: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "/libexec/ld.elf_so" +// POWERPC64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crti.o" +// POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// POWERPC64: "-lm" "-lc" "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + // S-X86_64: clang{{.*}}" "-cc1" "-triple" "x86_64--netbsd" // S-X86_64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-X86_64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" @@ -176,31 +176,17 @@ // S-AARCH64: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd" // S-AARCH64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-AARCH64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// S-AARCH64: "-lm" "-lc" "-lgcc_eh" "-lc" "-lgcc" +// S-AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// S-AARCH64: "-lm" "-lc" // S-AARCH64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" // S-AARCH64-7: clang{{.*}}" "-cc1" "-triple" "aarch64--netbsd7.0.0" // S-AARCH64-7: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-AARCH64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// S-AARCH64-7: "-lm" "-lc" "-lgcc_eh" "-lc" "-lgcc" +// S-AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// S-AARCH64-7: "-lm" "-lc" // S-AARCH64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" -// S-ARM64: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd" -// S-ARM64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" -// S-ARM64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// S-ARM64: "-lm" "-lc" "-lgcc_eh" "-lc" "-lgcc" -// S-ARM64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - -// S-ARM64-7: clang{{.*}}" "-cc1" "-triple" "arm64--netbsd7.0.0" -// S-ARM64-7: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" -// S-ARM64-7: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" "{{.*}}/usr/lib{{/|\\\\}}crti.o" -// S-ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" -// S-ARM64-7: "-lm" "-lc" "-lgcc_eh" "-lc" "-lgcc" -// S-ARM64-7: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" - // S-SPARC: clang{{.*}}" "-cc1" "-triple" "sparc--netbsd" // S-SPARC: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" // S-SPARC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" @@ -215,3 +201,17 @@ // S-SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lstdc++" // S-SPARC64: "-lm" "-lc" "-lgcc_eh" "-lc" "-lgcc" // S-SPARC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// S-POWERPC: clang{{.*}}" "-cc1" "-triple" "powerpc--netbsd" +// S-POWERPC: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" +// S-POWERPC: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// S-POWERPC: "{{.*}}/usr/lib{{/|\\\\}}powerpc{{/|\\\\}}crti.o" +// S-POWERPC: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// S-POWERPC: "-lm" "-lc" "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" + +// S-POWERPC64: clang{{.*}}" "-cc1" "-triple" "powerpc64--netbsd" +// S-POWERPC64: ld{{.*}}" "--eh-frame-hdr" "-Bstatic" +// S-POWERPC64: "-o" "a.out" "{{.*}}/usr/lib{{/|\\\\}}crt0.o" +// S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crti.o" +// S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc++" +// S-POWERPC64: "-lm" "-lc" "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o" diff --git a/test/Driver/no-canonical-prefixes.c b/test/Driver/no-canonical-prefixes.c new file mode 100644 index 000000000000..1aef9f40a9a7 --- /dev/null +++ b/test/Driver/no-canonical-prefixes.c @@ -0,0 +1,10 @@ +// REQUIRES: shell +// RUN: mkdir -p %t +// RUN: cd %t +// RUN: ln -sf %clang test-clang +// RUN: ./test-clang -v -S %s 2>&1 | FileCheck %s +// RUN: ./test-clang -v -S %s -no-canonical-prefixes 2>&1 | FileCheck --check-prefix=NCP %s + + +// CHECK: /clang{{.*}}" -cc1 +// NCP: test-clang" -cc1 diff --git a/test/Driver/openbsd.c b/test/Driver/openbsd.c index d263f485bf2f..74fef5092a96 100644 --- a/test/Driver/openbsd.c +++ b/test/Driver/openbsd.c @@ -8,6 +8,14 @@ // CHECK-PG: clang{{.*}}" "-cc1" "-triple" "i686-pc-openbsd" // CHECK-PG: ld{{.*}}" "-e" "__start" "--eh-frame-hdr" "-Bdynamic" "-dynamic-linker" "{{.*}}ld.so" "-o" "a.out" "{{.*}}gcrt0.o" "{{.*}}crtbegin.o" "{{.*}}.o" "-lgcc" "-lpthread_p" "-lc_p" "-lgcc" "{{.*}}crtend.o" +// Check CPU type for MIPS64 +// RUN: %clang -target mips64-unknown-openbsd -### -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-MIPS64-CPU %s +// RUN: %clang -target mips64el-unknown-openbsd -### -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-MIPS64EL-CPU %s +// CHECK-MIPS64-CPU: "-target-cpu" "mips3" +// CHECK-MIPS64EL-CPU: "-target-cpu" "mips3" + // Check that the new linker flags are passed to OpenBSD // RUN: %clang -no-canonical-prefixes -target i686-pc-openbsd -r %s -### 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-LD-R %s @@ -59,12 +67,3 @@ // CHECK-MIPS64-PIC: as{{.*}}" "-mabi" "64" "-EB" "-KPIC" // CHECK-MIPS64EL: as{{.*}}" "-mabi" "64" "-EL" // CHECK-MIPS64EL-PIC: as{{.*}}" "-mabi" "64" "-EL" "-KPIC" - -// Check that the integrated assembler is enabled for PowerPC and SPARC -// RUN: %clang -target powerpc-unknown-openbsd -### -c %s 2>&1 \ -// RUN: | FileCheck -check-prefix=CHECK-IAS %s -// RUN: %clang -target sparc-unknown-openbsd -### -c %s 2>&1 \ -// RUN: | FileCheck -check-prefix=CHECK-IAS %s -// RUN: %clang -target sparc64-unknown-openbsd -### -c %s 2>&1 \ -// RUN: | FileCheck -check-prefix=CHECK-IAS %s -// CHECK-IAS-NOT: "-no-integrated-as" diff --git a/test/Driver/parse-progname.c b/test/Driver/parse-progname.c new file mode 100644 index 000000000000..33c637822348 --- /dev/null +++ b/test/Driver/parse-progname.c @@ -0,0 +1,58 @@ +// REQUIRES: shell, arm-registered-target + + + +// RUN: ln -fs %clang %T/clang++ +// RUN: ln -fs %clang %T/clang++3.5.0 +// RUN: ln -fs %clang %T/clang++-3.5 +// RUN: ln -fs %clang %T/clang++-tot +// RUN: ln -fs %clang %T/clang-c++ +// RUN: ln -fs %clang %T/clang-g++ +// RUN: ln -fs %clang %T/c++ +// RUN: ln -fs %clang %T/foo-clang++ +// RUN: ln -fs %clang %T/foo-clang++-3.5 +// RUN: ln -fs %clang %T/foo-clang++3.5 +// RUN: %T/clang++ -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/clang++3.5.0 -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/clang++-3.5 -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/clang++-tot -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/clang-c++ -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/clang-g++ -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/c++ -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/foo-clang++ -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/foo-clang++-3.5 -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// RUN: %T/foo-clang++3.5 -### %s 2>&1 | FileCheck -check-prefix=CXXMODE %s +// CXXMODE: "-x" "c++" + + +// RUN: ln -fs %clang %T/clang-cl +// RUN: ln -fs %clang %T/cl +// RUN: ln -fs %clang %T/cl.exe +// RUN: ln -fs %clang %T/clang-cl3.5 +// RUN: ln -fs %clang %T/clang-cl-3.5 +// Note: use -- in front of the filename so it's not mistaken for an option on +// filesystems that use slashes for dir separators. +// RUN: %T/clang-cl -### -- %s 2>&1 | FileCheck -check-prefix=CLMODE %s +// RUN: %T/cl -### -- %s 2>&1 | FileCheck -check-prefix=CLMODE %s +// RUN: %T/cl.exe -### -- %s 2>&1 | FileCheck -check-prefix=CLMODE %s +// RUN: %T/clang-cl3.5 -### -- %s 2>&1 | FileCheck -check-prefix=CLMODE %s +// RUN: %T/clang-cl-3.5 -### -- %s 2>&1 | FileCheck -check-prefix=CLMODE %s +// CLMODE: "-fdiagnostics-format" "msvc" + + +// RUN: ln -fs %clang %T/clang-cpp +// RUN: ln -fs %clang %T/cpp +// RUN: %T/clang-cpp -### %s 2>&1 | FileCheck -check-prefix=CPPMODE %s +// RUN: %T/cpp -### %s 2>&1 | FileCheck -check-prefix=CPPMODE %s +// CPPMODE: "-E" + + +// RUN: ln -fs %clang %T/cl-clang +// RUN: %T/cl-clang -### %s 2>&1 | FileCheck -check-prefix=CMODE %s +// CMODE: "-x" "c" +// CMODE-NOT: "-fdiagnostics-format" "msvc" + + +// RUN: ln -fs %clang %T/arm-linux-gnueabi-clang +// RUN: %T/arm-linux-gnueabi-clang -### %s 2>&1 | FileCheck -check-prefix=TARGET %s +// TARGET: Target: arm--linux-gnueabi diff --git a/test/Driver/phases.c b/test/Driver/phases.c index 4c480d59c14a..0283800825ac 100644 --- a/test/Driver/phases.c +++ b/test/Driver/phases.c @@ -2,47 +2,53 @@ // RUN: %clang -target 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: 2: compiler, {1}, ir +// BASIC: 3: backend, {2}, assembler +// BASIC: 4: assembler, {3}, object +// BASIC: 5: input, "{{.*}}phases.c", objective-c +// BASIC: 6: preprocessor, {5}, objective-c-cpp-output +// BASIC: 7: compiler, {6}, ir +// BASIC: 8: backend, {7}, assembler +// BASIC: 9: assembler, {8}, object +// BASIC: 10: input, "{{.*}}phases.c", c++ +// BASIC: 11: preprocessor, {10}, c++-cpp-output +// BASIC: 12: compiler, {11}, ir +// BASIC: 13: backend, {12}, assembler +// BASIC: 14: assembler, {13}, object +// BASIC: 15: input, "{{.*}}phases.c", 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 +// BASIC: 17: input, "{{.*}}phases.c", assembler-with-cpp +// BASIC: 18: preprocessor, {17}, assembler +// BASIC: 19: assembler, {18}, object +// BASIC: 20: input, "{{.*}}phases.c", c +// BASIC: 21: preprocessor, {20}, cpp-output +// BASIC: 22: compiler, {21}, ir +// BASIC: 23: backend, {22}, assembler +// BASIC: 24: assembler, {23}, object +// BASIC: 25: linker, {4, 9, 14, 16, 19, 24}, image // Universal linked image. // RUN: %clang -target 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 +// ULI: 2: compiler, {1}, ir +// ULI: 3: backend, {2}, assembler +// ULI: 4: assembler, {3}, object +// ULI: 5: linker, {4}, image +// ULI: 6: bind-arch, "ppc", {5}, image +// ULI: 7: bind-arch, "i386", {5}, image +// ULI: 8: lipo, {6, 7}, image // Universal object file. // RUN: %clang -target 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 +// UOF: 2: compiler, {1}, ir +// UOF: 3: backend, {2}, assembler +// UOF: 4: assembler, {3}, object +// UOF: 5: bind-arch, "ppc", {4}, object +// UOF: 6: bind-arch, "i386", {4}, object +// UOF: 7: lipo, {5, 6}, object // Arch defaulting // RUN: %clang -target i386-apple-darwin9 -ccc-print-phases -c -x assembler %s 2>&1 | FileCheck -check-prefix=ARCH1 %s diff --git a/test/Driver/pic.c b/test/Driver/pic.c index 3629cc473574..a3d989c8b4f4 100644 --- a/test/Driver/pic.c +++ b/test/Driver/pic.c @@ -118,12 +118,15 @@ // Make sure -pie is passed to along to ld and that the right *crt* files // are linked in. // RUN: %clang %s -target i386-unknown-freebsd -fPIE -pie -### \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_freebsd_tree 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-PIE-LD // RUN: %clang %s -target i386-linux-gnu -fPIE -pie -### \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-PIE-LD // RUN: %clang %s -target i386-linux-gnu -fPIC -pie -### \ +// RUN: --gcc-toolchain="" \ // RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-PIE-LD // @@ -195,6 +198,8 @@ // RUN: | FileCheck %s --check-prefix=CHECK-PIC2 // RUN: %clang -c %s -target armv7-apple-ios -mkernel -miphoneos-version-min=6.0.0 -### 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-PIC2 +// RUN: %clang -c %s -target arm64-apple-ios -mkernel -miphoneos-version-min=7.0.0 -### 2>&1 \ +// RUN: | FileCheck %s --check-prefix=CHECK-PIC2 // RUN: %clang -c %s -target armv7-apple-ios -fapple-kext -miphoneos-version-min=5.0.0 -### 2>&1 \ // RUN: | FileCheck %s --check-prefix=CHECK-NO-PIC // RUN: %clang -c %s -target armv7-apple-ios -fapple-kext -miphoneos-version-min=6.0.0 -static -### 2>&1 \ diff --git a/test/Driver/ppc-abi.c b/test/Driver/ppc-abi.c new file mode 100644 index 000000000000..6fee63a303cf --- /dev/null +++ b/test/Driver/ppc-abi.c @@ -0,0 +1,19 @@ +// Check passing PowerPC ABI options to the backend. + +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-ELFv1 %s +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: -mabi=elfv1 | FileCheck -check-prefix=CHECK-ELFv1 %s +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: -mabi=elfv2 | FileCheck -check-prefix=CHECK-ELFv2 %s + +// RUN: %clang -target powerpc64le-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-ELFv2 %s +// RUN: %clang -target powerpc64le-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: -mabi=elfv1 | FileCheck -check-prefix=CHECK-ELFv1 %s +// RUN: %clang -target powerpc64le-unknown-linux-gnu %s -### -o %t.o 2>&1 \ +// RUN: -mabi=elfv2 | FileCheck -check-prefix=CHECK-ELFv2 %s + +// CHECK-ELFv1: "-target-abi" "elfv1" +// CHECK-ELFv2: "-target-abi" "elfv2" + diff --git a/test/Driver/ppc-features.cpp b/test/Driver/ppc-features.cpp index fa9a7ecd4d2f..f7cc879f39ac 100644 --- a/test/Driver/ppc-features.cpp +++ b/test/Driver/ppc-features.cpp @@ -89,12 +89,24 @@ // RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-fprnd -mfprnd -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-FPRND %s // CHECK-FPRND: "-target-feature" "+fprnd" +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-cmpb -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-NOCMPB %s +// CHECK-NOCMPB: "-target-feature" "-cmpb" + +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-cmpb -mcmpb -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-CMPB %s +// CHECK-CMPB: "-target-feature" "+cmpb" + // RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-vsx -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-NOVSX %s // CHECK-NOVSX: "-target-feature" "-vsx" // RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-vsx -mvsx -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-VSX %s // CHECK-VSX: "-target-feature" "+vsx" +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-power8-vector -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-NOP8VECTOR %s +// CHECK-NOP8VECTOR: "-target-feature" "-power8-vector" + +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-power8-vector -mpower8-vector -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-P8VECTOR %s +// CHECK-P8VECTOR: "-target-feature" "+power8-vector" + // RUN: %clang -target powerpc64-unknown-linux-gnu %s -mno-crbits -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK-NOCRBITS %s // CHECK-NOCRBITS: "-target-feature" "-crbits" @@ -102,11 +114,11 @@ // CHECK-CRBITS: "-target-feature" "+crbits" // Assembler features -// RUN: %clang -target powerpc64-unknown-linux-gnu %s -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK_BE_AS_ARGS %s +// RUN: %clang -target powerpc64-unknown-linux-gnu %s -### -o %t.o -no-integrated-as 2>&1 | FileCheck -check-prefix=CHECK_BE_AS_ARGS %s // CHECK_BE_AS_ARGS: "-mppc64" // CHECK_BE_AS_ARGS: "-many" -// RUN: %clang -target powerpc64le-unknown-linux-gnu %s -### -o %t.o 2>&1 | FileCheck -check-prefix=CHECK_LE_AS_ARGS %s +// RUN: %clang -target powerpc64le-unknown-linux-gnu %s -### -o %t.o -no-integrated-as 2>&1 | FileCheck -check-prefix=CHECK_LE_AS_ARGS %s // CHECK_LE_AS_ARGS: "-mppc64" // CHECK_LE_AS_ARGS: "-many" // CHECK_LE_AS_ARGS: "-mlittle-endian" diff --git a/test/Driver/prefixed-tools.c b/test/Driver/prefixed-tools.c index d7c342a8a94b..cdd59dae133d 100644 --- a/test/Driver/prefixed-tools.c +++ b/test/Driver/prefixed-tools.c @@ -6,7 +6,7 @@ // RUN: -m32 -target x86_64--linux %s 2>&1 | \ // RUN: FileCheck --check-prefix=CHECK-M32 %s -// CHECK-M64: "{{.*}}{{[/\\]}}prefixed_tools_tree{{[/\\]}}x86_64--linux-as" -// CHECK-M64: "{{.*}}{{[/\\]}}prefixed_tools_tree{{[/\\]}}x86_64--linux-ld" -// CHECK-M32: "{{.*}}{{[/\\]}}prefixed_tools_tree{{[/\\]}}x86_64--linux-as" -// CHECK-M32: "{{.*}}{{[/\\]}}prefixed_tools_tree{{[/\\]}}x86_64--linux-ld" +// CHECK-M64: "{{.*}}{{/|\\\\}}prefixed_tools_tree{{/|\\\\}}x86_64--linux-as" +// CHECK-M64: "{{.*}}{{/|\\\\}}prefixed_tools_tree{{/|\\\\}}x86_64--linux-ld" +// CHECK-M32: "{{.*}}{{/|\\\\}}prefixed_tools_tree{{/|\\\\}}x86_64--linux-as" +// CHECK-M32: "{{.*}}{{/|\\\\}}prefixed_tools_tree{{/|\\\\}}x86_64--linux-ld" diff --git a/test/Driver/r600-mcpu.cl b/test/Driver/r600-mcpu.cl index 47c018512bed..94a77346e877 100644 --- a/test/Driver/r600-mcpu.cl +++ b/test/Driver/r600-mcpu.cl @@ -26,15 +26,15 @@ // RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=caicos %s -o - 2>&1 | FileCheck --check-prefix=CAICOS-CHECK %s // RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=cayman %s -o - 2>&1 | FileCheck --check-prefix=CAYMAN-CHECK %s // RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=aruba %s -o - 2>&1 | FileCheck --check-prefix=CAYMAN-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=tahiti %s -o - 2>&1 | FileCheck --check-prefix=TAHITI-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=pitcairn %s -o - 2>&1 | FileCheck --check-prefix=PITCAIRN-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=verde %s -o - 2>&1 | FileCheck --check-prefix=VERDE-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=oland %s -o - 2>&1 | FileCheck --check-prefix=OLAND-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=bonaire %s -o - 2>&1 | FileCheck --check-prefix=BONAIRE-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=kabini %s -o - 2>&1 | FileCheck --check-prefix=KABINI-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=kaveri %s -o - 2>&1 | FileCheck --check-prefix=KAVERI-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=hawaii %s -o - 2>&1 | FileCheck --check-prefix=HAWAII-CHECK %s -// RUN: %clang -### -target r600 -x cl -S -emit-llvm -mcpu=mullins %s -o - 2>&1 | FileCheck --check-prefix=MULLINS-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=tahiti %s -o - 2>&1 | FileCheck --check-prefix=TAHITI-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=pitcairn %s -o - 2>&1 | FileCheck --check-prefix=PITCAIRN-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=verde %s -o - 2>&1 | FileCheck --check-prefix=VERDE-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=oland %s -o - 2>&1 | FileCheck --check-prefix=OLAND-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=bonaire %s -o - 2>&1 | FileCheck --check-prefix=BONAIRE-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=kabini %s -o - 2>&1 | FileCheck --check-prefix=KABINI-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=kaveri %s -o - 2>&1 | FileCheck --check-prefix=KAVERI-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=hawaii %s -o - 2>&1 | FileCheck --check-prefix=HAWAII-CHECK %s +// RUN: %clang -### -target amdgcn -x cl -S -emit-llvm -mcpu=mullins %s -o - 2>&1 | FileCheck --check-prefix=MULLINS-CHECK %s // R600-CHECK: "-target-cpu" "r600" // RS880-CHECK: "-target-cpu" "rs880" diff --git a/test/Driver/response-file.c b/test/Driver/response-file.c new file mode 100644 index 000000000000..208a941e8723 --- /dev/null +++ b/test/Driver/response-file.c @@ -0,0 +1,23 @@ +// REQUIRES: long_tests + +// Check that clang is able to process short response files +// Since this is a short response file, clang must not use a response file +// to pass its parameters to other tools. This is only necessary for a large +// number of parameters. +// RUN: echo "-DTEST" >> %t.0.txt +// RUN: %clang -E @%t.0.txt %s -v 2>&1 | FileCheck %s -check-prefix=SHORT +// SHORT-NOT: Arguments passed via response file +// SHORT: extern int it_works; + +// Check that clang is able to process long response files, routing a long +// sequence of arguments to other tools by using response files as well. +// We generate a 2MB response file to be big enough to surpass any system +// limit. +// RUN: %clang -E %S/Inputs/gen-response.c | grep DTEST > %t.1.txt +// RUN: %clang -E @%t.1.txt %s -v 2>&1 | FileCheck %s -check-prefix=LONG +// LONG: Arguments passed via response file +// LONG: extern int it_works; + +#ifdef TEST +extern int it_works; +#endif diff --git a/test/Driver/rewrite-legacy-objc.m b/test/Driver/rewrite-legacy-objc.m index 0c6404e323de..b0b78d00817a 100644 --- a/test/Driver/rewrite-legacy-objc.m +++ b/test/Driver/rewrite-legacy-objc.m @@ -3,11 +3,11 @@ // TEST0: clang{{.*}}" "-cc1" // TEST0: "-rewrite-objc" // FIXME: CHECK-NOT is broken somehow, it doesn't work here. Check adjacency instead. -// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fdiagnostics-show-option" +// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option" // TEST0: rewrite-legacy-objc.m" // RUN: %clang -no-canonical-prefixes -target i386-apple-macosx10.9.0 -rewrite-legacy-objc %s -o - -### 2>&1 | \ // RUN: FileCheck -check-prefix=TEST1 %s // RUN: %clang -no-canonical-prefixes -target i386-apple-macosx10.6.0 -rewrite-legacy-objc %s -o - -### 2>&1 | \ // RUN: FileCheck -check-prefix=TEST2 %s -// TEST1: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fobjc-subscripting-legacy-runtime" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fdiagnostics-show-option" -// TEST2: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fdiagnostics-show-option" +// TEST1: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fobjc-subscripting-legacy-runtime" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option" +// TEST2: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx-fragile" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option" diff --git a/test/Driver/rewrite-map-in-diagnostics.c b/test/Driver/rewrite-map-in-diagnostics.c new file mode 100644 index 000000000000..984e0d6e8ce6 --- /dev/null +++ b/test/Driver/rewrite-map-in-diagnostics.c @@ -0,0 +1,12 @@ +// RUN: rm -rf "%t" +// RUN: mkdir -p "%t" +// RUN: not env TMPDIR="%t" TEMP="%t" TMP="%t" RC_DEBUG_OPTION=1 \ +// RUN: %clang -fsyntax-only -frewrite-map-file %p/Inputs/rewrite.map %s 2>&1 \ +// RUN: | FileCheck %s + +#pragma clang __debug parser_crash + +// CHECK: note: diagnostic msg: {{.*}}rewrite.map + +// FIXME: This doesn't fail on "env clang". Investigating. +// REQUIRES: shell diff --git a/test/Driver/rewrite-objc.m b/test/Driver/rewrite-objc.m index 95db58294d2a..ba5f835ed8f5 100644 --- a/test/Driver/rewrite-objc.m +++ b/test/Driver/rewrite-objc.m @@ -3,4 +3,4 @@ // TEST0: clang{{.*}}" "-cc1" // TEST0: "-rewrite-objc" // FIXME: CHECK-NOT is broken somehow, it doesn't work here. Check adjacency instead. -// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fdiagnostics-show-option" +// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-mstackrealign" "-fblocks" "-fobjc-runtime=macosx" "-fencode-extended-block-signature" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option" diff --git a/test/Driver/sanitizer-ld.c b/test/Driver/sanitizer-ld.c index 786262c68b84..dc8e93e50f26 100644 --- a/test/Driver/sanitizer-ld.c +++ b/test/Driver/sanitizer-ld.c @@ -9,11 +9,12 @@ // CHECK-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-LINUX-NOT: "-lc" // CHECK-ASAN-LINUX: libclang_rt.asan-i386.a" +// CHECK-ASAN-LINUX-NOT: "-export-dynamic" +// CHECK-ASAN-LINUX: "--dynamic-list={{.*}}libclang_rt.asan-i386.a.syms" +// CHECK-ASAN-LINUX-NOT: "-export-dynamic" // CHECK-ASAN-LINUX: "-lpthread" // CHECK-ASAN-LINUX: "-lrt" // CHECK-ASAN-LINUX: "-ldl" -// CHECK-ASAN-LINUX-NOT: "-export-dynamic" -// CHECK-ASAN-LINUX: "--dynamic-list={{.*}}libclang_rt.asan-i386.a.syms" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux -fsanitize=address -shared-libasan \ @@ -24,8 +25,8 @@ // CHECK-SHARED-ASAN-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-SHARED-ASAN-LINUX-NOT: "-lc" // CHECK-SHARED-ASAN-LINUX-NOT: libclang_rt.asan-i386.a" -// CHECK-SHARED-ASAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.asan-preinit-i386.a" "-no-whole-archive" // CHECK-SHARED-ASAN-LINUX: libclang_rt.asan-i386.so" +// CHECK-SHARED-ASAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.asan-preinit-i386.a" "-no-whole-archive" // CHECK-SHARED-ASAN-LINUX-NOT: "-lpthread" // CHECK-SHARED-ASAN-LINUX-NOT: "-lrt" // CHECK-SHARED-ASAN-LINUX-NOT: "-ldl" @@ -60,10 +61,10 @@ // CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx // CHECK-ASAN-FREEBSD: freebsd{{/|\\+}}libclang_rt.asan-i386.a" // CHECK-ASAN-FREEBSD-NOT: libclang_rt.asan_cxx +// CHECK-ASAN-FREEBSD-NOT: "--dynamic-list" +// CHECK-ASAN-FREEBSD: "-export-dynamic" // CHECK-ASAN-FREEBSD: "-lpthread" // CHECK-ASAN-FREEBSD: "-lrt" -// CHECK-ASAN-FREEBSD: "-export-dynamic" -// CHECK-ASAN-FREEBSD-NOT: "--dynamic-list" // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-freebsd -fsanitize=address \ @@ -82,14 +83,14 @@ // // CHECK-ASAN-LINUX-CXX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-LINUX-CXX-NOT: "-lc" -// CHECK-ASAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "-no-whole-archive" // CHECK-ASAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.asan-i386.a" "-no-whole-archive" +// CHECK-ASAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.asan_cxx-i386.a" "-no-whole-archive" +// CHECK-ASAN-LINUX-CXX-NOT: "--dynamic-list" +// CHECK-ASAN-LINUX-CXX: "-export-dynamic" +// CHECK-ASAN-LINUX-CXX: stdc++ // CHECK-ASAN-LINUX-CXX: "-lpthread" // CHECK-ASAN-LINUX-CXX: "-lrt" // CHECK-ASAN-LINUX-CXX: "-ldl" -// CHECK-ASAN-LINUX-CXX: "-export-dynamic" -// CHECK-ASAN-LINUX-CXX-NOT: "--dynamic-list" -// CHECK-ASAN-LINUX-CXX: stdc++ // RUN: %clang -no-canonical-prefixes %s -### -o /dev/null -fsanitize=address \ // RUN: -target i386-unknown-linux --sysroot=%S/Inputs/basic_linux_tree \ @@ -126,10 +127,10 @@ // // CHECK-ASAN-ANDROID: "{{(.*[^.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-ASAN-ANDROID-NOT: "-lc" -// CHECK-ASAN-ANDROID: libclang_rt.asan-arm-android.so" -// CHECK-ASAN-ANDROID-NOT: "-lpthread" // CHECK-ASAN-ANDROID: "-pie" // CHECK-ASAN-ANDROID-NOT: "-lpthread" +// CHECK-ASAN-ANDROID: libclang_rt.asan-arm-android.so" +// CHECK-ASAN-ANDROID-NOT: "-lpthread" // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -target arm-linux-androideabi -fsanitize=address \ @@ -159,12 +160,13 @@ // CHECK-TSAN-LINUX-CXX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-TSAN-LINUX-CXX-NOT: stdc++ // CHECK-TSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.tsan-x86_64.a" "-no-whole-archive" -// CHECK-TSAN-LINUX-CXX: "-lpthread" -// CHECK-TSAN-LINUX-CXX: "-lrt" -// CHECK-TSAN-LINUX-CXX: "-ldl" // CHECK-TSAN-LINUX-CXX-NOT: "-export-dynamic" // CHECK-TSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.tsan-x86_64.a.syms" +// CHECK-TSAN-LINUX-CXX-NOT: "-export-dynamic" // CHECK-TSAN-LINUX-CXX: stdc++ +// CHECK-TSAN-LINUX-CXX: "-lpthread" +// CHECK-TSAN-LINUX-CXX: "-lrt" +// CHECK-TSAN-LINUX-CXX: "-ldl" // RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -target x86_64-unknown-linux -lstdc++ -fsanitize=memory \ @@ -175,12 +177,13 @@ // CHECK-MSAN-LINUX-CXX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}" // CHECK-MSAN-LINUX-CXX-NOT: stdc++ // CHECK-MSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.msan-x86_64.a" "-no-whole-archive" -// CHECK-MSAN-LINUX-CXX: "-lpthread" -// CHECK-MSAN-LINUX-CXX: "-lrt" -// CHECK-MSAN-LINUX-CXX: "-ldl" // CHECK-MSAN-LINUX-CXX-NOT: "-export-dynamic" // CHECK-MSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.msan-x86_64.a.syms" +// CHECK-MSAN-LINUX-CXX-NOT: "-export-dynamic" // CHECK-MSAN-LINUX-CXX: stdc++ +// CHECK-MSAN-LINUX-CXX: "-lpthread" +// CHECK-MSAN-LINUX-CXX: "-lrt" +// CHECK-MSAN-LINUX-CXX: "-ldl" // RUN: %clang -fsanitize=undefined %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux \ @@ -188,12 +191,23 @@ // RUN: | FileCheck --check-prefix=CHECK-UBSAN-LINUX %s // CHECK-UBSAN-LINUX: "{{.*}}ld{{(.exe)?}}" // CHECK-UBSAN-LINUX-NOT: libclang_rt.asan +// CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_cxx // CHECK-UBSAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.san-i386.a" "-no-whole-archive" // CHECK-UBSAN-LINUX-NOT: libclang_rt.asan +// CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_cxx // CHECK-UBSAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.ubsan-i386.a" "-no-whole-archive" +// CHECK-UBSAN-LINUX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-NOT: libclang_rt.ubsan_cxx -// CHECK-UBSAN-LINUX: "-lpthread" // CHECK-UBSAN-LINUX-NOT: "-lstdc++" +// CHECK-UBSAN-LINUX: "-lpthread" + +// RUN: %clang -fsanitize=undefined -fsanitize-link-c++-runtime %s -### -o %t.o 2>&1 \ +// RUN: -target i386-unknown-linux \ +// RUN: --sysroot=%S/Inputs/basic_linux_tree \ +// RUN: | FileCheck --check-prefix=CHECK-UBSAN-LINUX-LINK-CXX %s +// CHECK-UBSAN-LINUX-LINK-CXX-NOT: "-lstdc++" +// CHECK-UBSAN-LINUX-LINK-CXX: "-whole-archive" "{{.*}}libclang_rt.ubsan_cxx-i386.a" "-no-whole-archive" +// CHECK-UBSAN-LINUX-LINK-CXX-NOT: "-lstdc++" // RUN: %clangxx -fsanitize=undefined %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux \ @@ -205,11 +219,16 @@ // CHECK-UBSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.san-i386.a" "-no-whole-archive" // CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.ubsan-i386.a" "-no-whole-archive" +// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.ubsan-i386.a.syms" +// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.ubsan_cxx-i386.a" "-no-whole-archive" -// CHECK-UBSAN-LINUX-CXX: "-lpthread" +// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX: "--dynamic-list={{.*}}libclang_rt.ubsan_cxx-i386.a.syms" +// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan // CHECK-UBSAN-LINUX-CXX: "-lstdc++" +// CHECK-UBSAN-LINUX-CXX-NOT: libclang_rt.asan +// CHECK-UBSAN-LINUX-CXX: "-lpthread" // RUN: %clang -fsanitize=address,undefined %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux \ @@ -221,8 +240,8 @@ // CHECK-ASAN-UBSAN-LINUX-NOT: libclang_rt.san // CHECK-ASAN-UBSAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.ubsan-i386.a" "-no-whole-archive" // CHECK-ASAN-UBSAN-LINUX-NOT: libclang_rt.ubsan_cxx -// CHECK-ASAN-UBSAN-LINUX: "-lpthread" // CHECK-ASAN-UBSAN-LINUX-NOT: "-lstdc++" +// CHECK-ASAN-UBSAN-LINUX: "-lpthread" // RUN: %clangxx -fsanitize=address,undefined %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux \ @@ -234,8 +253,8 @@ // CHECK-ASAN-UBSAN-LINUX-CXX-NOT: libclang_rt.san // CHECK-ASAN-UBSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.ubsan-i386.a" "-no-whole-archive" // CHECK-ASAN-UBSAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.ubsan_cxx-i386.a" "-no-whole-archive" -// CHECK-ASAN-UBSAN-LINUX-CXX: "-lpthread" // CHECK-ASAN-UBSAN-LINUX-CXX: "-lstdc++" +// CHECK-ASAN-UBSAN-LINUX-CXX: "-lpthread" // RUN: %clang -fsanitize=undefined %s -### -o %t.o 2>&1 \ // RUN: -target i386-unknown-linux \ @@ -271,8 +290,8 @@ // CHECK-LSAN-UBSAN-LINUX-NOT: libclang_rt.san // CHECK-LSAN-UBSAN-LINUX: "-whole-archive" "{{.*}}libclang_rt.ubsan-x86_64.a" "-no-whole-archive" // CHECK-LSAN-UBSAN-LINUX-NOT: libclang_rt.ubsan_cxx -// CHECK-LSAN-UBSAN-LINUX: "-lpthread" // CHECK-LSAN-UBSAN-LINUX-NOT: "-lstdc++" +// CHECK-LSAN-UBSAN-LINUX: "-lpthread" // RUN: %clang -fsanitize=leak,address %s -### -o %t.o 2>&1 \ // RUN: -target x86_64-unknown-linux \ diff --git a/test/Driver/save-temps.c b/test/Driver/save-temps.c index a4ca3b26649e..a157aeaaff4a 100644 --- a/test/Driver/save-temps.c +++ b/test/Driver/save-temps.c @@ -1,17 +1,28 @@ // RUN: %clang -target x86_64-apple-darwin -save-temps -arch x86_64 %s -### 2>&1 \ // RUN: | FileCheck %s // CHECK: "-o" "save-temps.i" +// CHECK: "-disable-llvm-optzns" +// CHECK: "-o" "save-temps.bc" // CHECK: "-o" "save-temps.s" // CHECK: "-o" "save-temps.o" // CHECK: "-o" "a.out" +// Check for a single clang cc1 invocation when NOT using -save-temps. +// RUN: %clang -target x86_64-apple-darwin -arch x86_64 -S %s -### 2>&1 \ +// RUN: | FileCheck %s -check-prefix=NO-TEMPS +// NO-TEMPS: "-cc1" +// NO-TEMPS: "-S" +// NO-TEMPS: "-x" "c" + // RUN: %clang -target x86_64-apple-darwin -save-temps -arch i386 -arch x86_64 %s -### 2>&1 \ // RUN: | FileCheck %s -check-prefix=MULT-ARCH // MULT-ARCH: "-o" "save-temps-i386.i" +// MULT-ARCH: "-o" "save-temps-i386.bc" // MULT-ARCH: "-o" "save-temps-i386.s" // MULT-ARCH: "-o" "save-temps-i386.o" // MULT-ARCH: "-o" "a.out-i386" // MULT-ARCH: "-o" "save-temps-x86_64.i" +// MULT-ARCH: "-o" "save-temps-x86_64.bc" // MULT-ARCH: "-o" "save-temps-x86_64.s" // MULT-ARCH: "-o" "save-temps-x86_64.o" // MULT-ARCH: "-o" "a.out-x86_64" diff --git a/test/Driver/sparc-float.c b/test/Driver/sparc-float.c index 15050d2c4ea4..e84c487c73c9 100644 --- a/test/Driver/sparc-float.c +++ b/test/Driver/sparc-float.c @@ -5,6 +5,7 @@ // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-DEF %s +// CHECK-DEF: "-target-feature" "+soft-float" // CHECK-DEF: "-msoft-float" // // -mhard-float @@ -17,12 +18,14 @@ // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc-linux-gnu -msoft-float \ // RUN: | FileCheck --check-prefix=CHECK-SOFT %s +// CHECK-SOFT: "-target-feature" "+soft-float" // CHECK-SOFT: "-msoft-float" // // Default sparc64 // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc64-linux-gnu \ // RUN: | FileCheck --check-prefix=CHECK-DEF-SPARC64 %s +// CHECK-DEF-SPARC64: "-target-feature" "+soft-float" // CHECK-DEF-SPARC64: "-msoft-float" // // -mhard-float @@ -35,4 +38,5 @@ // RUN: %clang -c %s -### -o %t.o 2>&1 \ // RUN: -target sparc64-linux-gnu -msoft-float \ // RUN: | FileCheck --check-prefix=CHECK-SOFT-SPARC64 %s +// CHECK-SOFT-SPARC64: "-target-feature" "+soft-float" // CHECK-SOFT-SPARC64: "-msoft-float" diff --git a/test/Driver/split-debug.c b/test/Driver/split-debug.c index 792abbd55259..6296c4672e5c 100644 --- a/test/Driver/split-debug.c +++ b/test/Driver/split-debug.c @@ -1,6 +1,5 @@ // Check that we split debug output properly // -// REQUIRES: asserts // RUN: %clang -target x86_64-unknown-linux-gnu -gsplit-dwarf -c -### %s 2> %t // RUN: FileCheck -check-prefix=CHECK-ACTIONS < %t %s // diff --git a/test/Driver/split-debug.s b/test/Driver/split-debug.s index d5f077af1346..64e8f2fa03d2 100644 --- a/test/Driver/split-debug.s +++ b/test/Driver/split-debug.s @@ -1,6 +1,5 @@ // Check that we split debug output properly // -// REQUIRES: asserts // RUN: %clang -target x86_64-unknown-linux-gnu -gsplit-dwarf -c -### %s 2> %t // RUN: FileCheck -check-prefix=CHECK-ACTIONS < %t %s // diff --git a/test/Driver/std.c b/test/Driver/std.c index c82e9f15c7da..02dca6698d34 100644 --- a/test/Driver/std.c +++ b/test/Driver/std.c @@ -1,8 +1,18 @@ -// RUN: %clang -std=c99 -trigraphs -std=gnu99 %s -E -o - | FileCheck -check-prefix=OVERRIDE %s +// RUN: %clang -w -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 +// RUN: %clang -w -std=c99 -trigraphs -std=gnu99 %s -E -o - | FileCheck -check-prefix=FOVERRIDE %s +// FOVERRIDE: ??(??) +// RUN: %clang -w -ansi %s -E -o - | FileCheck -check-prefix=ANSI %s // ANSI: [] -// RUN: %clang -std=gnu99 -trigraphs %s -E -o - | FileCheck -check-prefix=EXPLICIT %s +// RUN: %clang -w -ansi %s -fno-trigraphs -E -o - | FileCheck -check-prefix=ANSI-OVERRIDE %s +// ANSI-OVERRIDE: ??(??) +// RUN: %clang -w -std=gnu99 -trigraphs %s -E -o - | FileCheck -check-prefix=EXPLICIT %s // EXPLICIT: [] +// RUN: %clang -w -std=gnu99 -ftrigraphs %s -E -o - | FileCheck -check-prefix=FEXPLICIT %s +// FEXPLICIT: [] +// RUN: %clang -w -ftrigraphs -fno-trigraphs %s -E -o - | FileCheck -check-prefix=ONOFF %s +// ONOFF: ??(??) +// RUN: %clang -w -fno-trigraphs -trigraphs %s -E -o - | FileCheck -check-prefix=OFFFON %s +// OFFFON: [] ??(??) diff --git a/test/Driver/symbol-rewriter.c b/test/Driver/symbol-rewriter.c new file mode 100644 index 000000000000..3cfdb9d09cd9 --- /dev/null +++ b/test/Driver/symbol-rewriter.c @@ -0,0 +1,21 @@ +// RUN: %clang -frewrite-map-file %S/Inputs/rewrite.map -### %s 2>&1 | FileCheck %s -check-prefix CHECK-SINGLE + +// CHECK-SINGLE: "-frewrite-map-file" "{{.*[\\/]}}rewrite.map" + +// RUN: %clang -frewrite-map-file %S/Inputs/rewrite-1.map -frewrite-map-file %S/Inputs/rewrite-2.map -### %s 2>&1 | FileCheck %s -check-prefix CHECK-MULTIPLE + +// CHECK-MULTIPLE: "-frewrite-map-file" "{{.*[\\/]}}rewrite-1.map" "-frewrite-map-file" "{{.*[\\/]}}rewrite-2.map" + +// RUN: %clang -frewrite-map-file=%S/Inputs/rewrite.map -### %s 2>&1 | FileCheck %s -check-prefix CHECK-SINGLE-EQ + +// CHECK-SINGLE-EQ: "-frewrite-map-file" "{{.*[\\/]}}rewrite.map" + +// RUN: %clang -frewrite-map-file=%S/Inputs/rewrite-1.map -frewrite-map-file=%S/Inputs/rewrite-2.map -### %s 2>&1 | FileCheck %s -check-prefix CHECK-MULTIPLE-EQ + +// CHECK-MULTIPLE-EQ: "-frewrite-map-file" "{{.*[\\/]}}rewrite-1.map" +// CHECK-MULTIPLE-EQ: "-frewrite-map-file" "{{.*[\\/]}}rewrite-2.map" + +// RUN: %clang -frewrite-map-file %S/Inputs/rewrite-1.map -frewrite-map-file=%S/Inputs/rewrite-2.map -### %s 2>&1 | FileCheck %s -check-prefix CHECK-MIXED + +// CHECK-MIXED: "-frewrite-map-file" "{{.*[\\/]}}rewrite-1.map" "-frewrite-map-file" "{{.*[\\/]}}rewrite-2.map" + diff --git a/test/Driver/systemz-as.s b/test/Driver/systemz-as.s new file mode 100644 index 000000000000..34ad9c41eaf3 --- /dev/null +++ b/test/Driver/systemz-as.s @@ -0,0 +1,14 @@ +// Make sure SystemZ defaults to using the integrated assembler + +// RUN: %clang -target s390x-ibm-linux -### -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IAS %s + +// RUN: %clang -target s390x-ibm-linux -integrated-as -### -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=IAS %s +// IAS: "-cc1as"{{.*}} "-target-cpu" "z10" + +// RUN: %clang -target s390x-ibm-linux -no-integrated-as -### -c %s 2>&1 \ +// RUN: | FileCheck -check-prefix=NO-IAS %s +// NO-IAS-NOT: -cc1as +// NO-IAS: "-march=z10" + diff --git a/test/Driver/thread-model.c b/test/Driver/thread-model.c new file mode 100644 index 000000000000..9702c2231a26 --- /dev/null +++ b/test/Driver/thread-model.c @@ -0,0 +1,15 @@ +// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -mthread-model posix -v 2>&1 | FileCheck -check-prefix=CHECK-POSIX %s +// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -mthread-model single -v 2>&1 | FileCheck -check-prefix=CHECK-SINGLE %s +// RUN: not %clang -target arm-unknown-linux-gnu -c %s -mthread-model silly -v 2>&1 | FileCheck -check-prefix=CHECK-INVALID %s +// CHECK-POSIX: "-mthread-model" "posix" +// CHECK-SINGLE: "-mthread-model" "single" +// CHECK-INVALID: error: invalid thread model 'silly' in '-mthread-model silly' for this target + +// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-LINUX-POSIX %s +// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -v -mthread-model single 2>&1 | FileCheck -check-prefix=CHECK-LINUX-SINGLE %s +// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -v -mthread-model silly 2>&1 | FileCheck -check-prefix=CHECK-LINUX-INVALID %s +// CHECK-LINUX-POSIX: Thread model: posix +// CHECK-LINUX-POSIX: "-mthread-model" "posix" +// CHECK-LINUX-SINGLE: Thread model: single +// CHECK-LINUX-SINGLE: "-mthread-model" "single" +// CHECK-LINUX-INVALID-NOT: Thread model: diff --git a/test/Driver/unknown-gcc-arch.c b/test/Driver/unknown-gcc-arch.c index 6317e13ec486..2aba50d53202 100644 --- a/test/Driver/unknown-gcc-arch.c +++ b/test/Driver/unknown-gcc-arch.c @@ -14,23 +14,23 @@ // RUN: -no-integrated-as 2>&1 | FileCheck -check-prefix=I386-M64 %s // I386-M64: {{.*as.*--64}} - -// RUN: %clang -target powerpc64-unknown-unknown -c -x assembler %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=PPC64 %s +// RUN: %clang -target powerpc64-unknown-unknown -c -x assembler %s -### \ +// RUN: -no-integrated-as 2>&1 | FileCheck -check-prefix=PPC64 %s // PPC64: {{.*as.*-a64}} -// RUN: %clang -target powerpc64-unknown-unknown -c -x assembler %s -### -m32 2>&1 \ -// RUN: | FileCheck -check-prefix=PPC64-M32 %s +// RUN: %clang -target powerpc-unknown-unknown -c -x assembler %s -### -m64 \ +// RUN: -no-integrated-as 2>&1 | FileCheck -check-prefix=PPC-M64 %s +// PPC-M64: {{.*as.*-a64}} + + +// RUN: %clang -target powerpc64-unknown-unknown -c -x assembler %s -### -m32 \ +// RUN: -no-integrated-as 2>&1 | FileCheck -check-prefix=PPC64-M32 %s // PPC64-M32: {{.*as.*-a32}} // RUN: %clang -target powerpc-unknown-unknown -c -x assembler %s -### 2>&1 \ -// RUN: | FileCheck -check-prefix=PPC %s +// RUN: -no-integrated-as | FileCheck -check-prefix=PPC %s // PPC: {{.*as.*-a32}} -// RUN: %clang -target powerpc-unknown-unknown -c -x assembler %s -### -m64 2>&1 \ -// RUN: | FileCheck -check-prefix=PPC-M64 %s -// PPC-M64: {{.*as.*-a64}} - // RUN: %clang -target sparc64-unknown-unknown -no-integrated-as -c -x assembler %s -### -m32 2>&1 \ // RUN: | FileCheck -check-prefix=SPARCV8 %s // SPARCV8: {{.*as.*-32}} diff --git a/test/Driver/warning-options.cpp b/test/Driver/warning-options.cpp index f1a335d2139d..4d9e1f7466de 100644 --- a/test/Driver/warning-options.cpp +++ b/test/Driver/warning-options.cpp @@ -3,11 +3,6 @@ // RUN: %clang -### -Wlarge-by-value-copy=128 %s 2>&1 | FileCheck -check-prefix=LARGE_VALUE_COPY_JOINED %s // LARGE_VALUE_COPY_JOINED: -Wlarge-by-value-copy=128 -// FIXME: Remove this together with -Warc-abi once an Xcode is released that doesn't pass this flag. -// RUN: %clang -### -Warc-abi -Wno-arc-abi %s 2>&1 | FileCheck -check-prefix=ARCABI %s -// ARCABI-NOT: unknown warning option '-Warc-abi' -// ARCABI-NOT: unknown warning option '-Wno-arc-abi' - // Check that -isysroot warns on nonexistent paths. // RUN: %clang -### -c -target i386-apple-darwin10 -isysroot /FOO %s 2>&1 | FileCheck --check-prefix=CHECK-ISYSROOT %s // CHECK-ISYSROOT: warning: no such sysroot directory: '{{([A-Za-z]:.*)?}}/FOO' diff --git a/test/Driver/windows-cross.c b/test/Driver/windows-cross.c new file mode 100644 index 000000000000..979f68539c01 --- /dev/null +++ b/test/Driver/windows-cross.c @@ -0,0 +1,40 @@ +// RUN: %clang -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -o /dev/null %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-BASIC + +// CHECK-BASIC: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-Bdynamic" "--entry" "mainCRTStartup" "--allow-multiple-definition" "-o" "{{[^"]*}}" "{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/crtbegin.obj" "-L{{.*}}/Inputs/Windows/ARM/8.1/usr/lib" "-L{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/gcc" "{{.*}}.o" "-lmsvcrt" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %s/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -rtlib=compiler-rt -o /dev/null %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-RTLIB + +// CHECK-RTLIB: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-Bdynamic" "--entry" "mainCRTStartup" "--allow-multiple-definition" "-o" "{{[^"]*}}" "{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/crtbegin.obj" "-L{{.*}}/Inputs/Windows/ARM/8.1/usr/lib" "-L{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/gcc" "{{.*}}.o" "-lmsvcrt" "{{.*[\\/]}}clang_rt.builtins-arm.lib" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -rtlib=compiler-rt -stdlib=libc++ -o /dev/null %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-C-LIBCXX + +// CHECK-C-LIBCXX: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-Bdynamic" "--entry" "mainCRTStartup" "--allow-multiple-definition" "-o" "{{[^"]*}}" "{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/crtbegin.obj" "{{.*}}.o" "-lmsvcrt" "{{.*[\\/]}}clang_rt.builtins-arm.lib" + +// RUN: %clangxx -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -rtlib=compiler-rt -stdlib=libc++ -o /dev/null %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-LIBCXX + +// CHECK-LIBCXX: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-Bdynamic" "--entry" "mainCRTStartup" "--allow-multiple-definition" "-o" "{{[^"]*}}" "{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/crtbegin.obj" "{{.*}}.o" "-lc++" "-lmsvcrt" "{{.*[\\/]}}clang_rt.builtins-arm.lib" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -shared -rtlib=compiler-rt -stdlib=libc++ -o shared.dll %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-SHARED + +// CHECK-SHARED: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-shared" "-Bdynamic" "--enable-auto-image-base" "--entry" "_DllMainCRTStartup" "--allow-multiple-definition" "-o" "shared.dll" "--out-implib" "shared.lib" "{{.*}}/Inputs/Windows/ARM/8.1/usr/lib/crtbeginS.obj" "{{.*}}.o" "-lmsvcrt" "{{.*[\\/]}}clang_rt.builtins-arm.lib" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %s/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -shared -rtlib=compiler-rt -stdlib=libc++ -nostartfiles -o shared.dll %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-NOSTARTFILES + +// CHECK-NOSTARTFILES: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-shared" "-Bdynamic" "--enable-auto-image-base" "--entry" "_DllMainCRTStartup" "--allow-multiple-definition" "-o" "shared.dll" "--out-implib" "shared.lib" "{{.*}}.o" "-lmsvcrt" "{{.*[\\/]}}clang_rt.builtins-arm.lib" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %S/Inputs/Windows/ARM/8.1/usr/bin -shared -rtlib=compiler-rt -stdlib=libc++ -nostartfiles -nodefaultlibs -o shared.dll %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-STANDALONE + +// CHECK-STANDALONE: armv7-windows-itanium-ld" "--sysroot={{.*}}/Inputs/Windows/ARM/8.1" "-m" "thumb2pe" "-shared" "-Bdynamic" "--enable-auto-image-base" "--entry" "_DllMainCRTStartup" "--allow-multiple-definition" "-o" "shared.dll" "--out-implib" "shared.lib" "{{.*}}.o" + +// RUN: %clang -### -target armv7-windows-itanium --sysroot %S/Inputs/Windows/ARM/8.1 -B %/Inputs/Windows/ARM/8.1/usr/bin -shared -o shared.dll -x c++ %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-LIBSTDCXX + +// CHECK-LIBSTDCXX: "-internal-isystem" "{{.*}}/usr/include/c++" "-internal-isystem" "{{.*}}/usr/include/c++/armv7--windows-itanium" "-internal-isystem" "{{.*}}/usr/include/c++/backwards" + diff --git a/test/Driver/x86-march.c b/test/Driver/x86-march.c new file mode 100644 index 000000000000..fd6e30b01593 --- /dev/null +++ b/test/Driver/x86-march.c @@ -0,0 +1,105 @@ +// Ensure we support the various CPU architecture names. +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=nocona 2>&1 \ +// RUN: | FileCheck %s -check-prefix=nocona +// nocona: "-target-cpu" "nocona" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=core2 2>&1 \ +// RUN: | FileCheck %s -check-prefix=core2 +// core2: "-target-cpu" "core2" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=penryn 2>&1 \ +// RUN: | FileCheck %s -check-prefix=penryn +// penryn: "-target-cpu" "penryn" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=nehalem 2>&1 \ +// RUN: | FileCheck %s -check-prefix=nehalem +// nehalem: "-target-cpu" "nehalem" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=westmere 2>&1 \ +// RUN: | FileCheck %s -check-prefix=westmere +// westmere: "-target-cpu" "westmere" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=sandybridge 2>&1 \ +// RUN: | FileCheck %s -check-prefix=sandybridge +// sandybridge: "-target-cpu" "sandybridge" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=ivybridge 2>&1 \ +// RUN: | FileCheck %s -check-prefix=ivybridge +// ivybridge: "-target-cpu" "ivybridge" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=haswell 2>&1 \ +// RUN: | FileCheck %s -check-prefix=haswell +// haswell: "-target-cpu" "haswell" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=broadwell 2>&1 \ +// RUN: | FileCheck %s -check-prefix=broadwell +// broadwell: "-target-cpu" "broadwell" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=bonnell 2>&1 \ +// RUN: | FileCheck %s -check-prefix=bonnell +// bonnell: "-target-cpu" "bonnell" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=silvermont 2>&1 \ +// RUN: | FileCheck %s -check-prefix=silvermont +// silvermont: "-target-cpu" "silvermont" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=k8 2>&1 \ +// RUN: | FileCheck %s -check-prefix=k8 +// k8: "-target-cpu" "k8" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=opteron 2>&1 \ +// RUN: | FileCheck %s -check-prefix=opteron +// opteron: "-target-cpu" "opteron" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=athlon64 2>&1 \ +// RUN: | FileCheck %s -check-prefix=athlon64 +// athlon64: "-target-cpu" "athlon64" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=athlon-fx 2>&1 \ +// RUN: | FileCheck %s -check-prefix=athlon-fx +// athlon-fx: "-target-cpu" "athlon-fx" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=k8-sse3 2>&1 \ +// RUN: | FileCheck %s -check-prefix=k8-sse3 +// k8-sse3: "-target-cpu" "k8-sse3" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=opteron-sse3 2>&1 \ +// RUN: | FileCheck %s -check-prefix=opteron-sse3 +// opteron-sse3: "-target-cpu" "opteron-sse3" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=athlon64-sse3 2>&1 \ +// RUN: | FileCheck %s -check-prefix=athlon64-sse3 +// athlon64-sse3: "-target-cpu" "athlon64-sse3" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=amdfam10 2>&1 \ +// RUN: | FileCheck %s -check-prefix=amdfam10 +// amdfam10: "-target-cpu" "amdfam10" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=barcelona 2>&1 \ +// RUN: | FileCheck %s -check-prefix=barcelona +// barcelona: "-target-cpu" "barcelona" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=bdver1 2>&1 \ +// RUN: | FileCheck %s -check-prefix=bdver1 +// bdver1: "-target-cpu" "bdver1" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=bdver2 2>&1 \ +// RUN: | FileCheck %s -check-prefix=bdver2 +// bdver2: "-target-cpu" "bdver2" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=bdver3 2>&1 \ +// RUN: | FileCheck %s -check-prefix=bdver3 +// bdver3: "-target-cpu" "bdver3" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=bdver4 2>&1 \ +// RUN: | FileCheck %s -check-prefix=bdver4 +// bdver4: "-target-cpu" "bdver4" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=btver1 2>&1 \ +// RUN: | FileCheck %s -check-prefix=btver1 +// btver1: "-target-cpu" "btver1" +// +// RUN: %clang -target x86_64-unknown-unknown -c -### %s -march=btver2 2>&1 \ +// RUN: | FileCheck %s -check-prefix=btver2 +// btver2: "-target-cpu" "btver2" diff --git a/test/FixIt/fixit-class-method-messaging.m b/test/FixIt/fixit-class-method-messaging.m new file mode 100644 index 000000000000..e2592d0c87f8 --- /dev/null +++ b/test/FixIt/fixit-class-method-messaging.m @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s +// rdar://16263395 + +@interface NSObject @end + +@interface I : NSObject // expected-note 3 {{receiver is instance of class declared here}} ++ (id) ClassMeth; +- (I*) MethInstPI; +@end + +I* pi; + +I* foobar(); + +@implementation I +- (id) PrivInstMeth { + [ foobar() ClassMeth]; // expected-warning {{instance method '-ClassMeth' not found (return type defaults to 'id')}} \ + // expected-note {{receiver expression is here}} +// CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:5-[[@LINE-2]]:13}:"I + [[self MethInstPI] ClassMeth]; // expected-warning {{instance method '-ClassMeth' not found (return type defaults to 'id')}} \ + // expected-note {{receiver expression is here}} +// CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:4-[[@LINE-2]]:21}:"I + return [pi ClassMeth]; // expected-warning {{instance method '-ClassMeth' not found (return type defaults to 'id')}} \ + // expected-note {{receiver expression is here}} +// CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:11-[[@LINE-2]]:13}:"I +} ++ (id) ClassMeth { return 0; } +- (I*) MethInstPI { return 0; } +@end diff --git a/test/FixIt/fixit-cxx1y-compat.cpp b/test/FixIt/fixit-cxx1y-compat.cpp index 9fd5ff26e558..819e3984c352 100644 --- a/test/FixIt/fixit-cxx1y-compat.cpp +++ b/test/FixIt/fixit-cxx1y-compat.cpp @@ -7,6 +7,6 @@ // This is a test of the code modification hints for C++1y-compatibility problems. struct S { - constexpr int &f(); // expected-warning {{'constexpr' non-static member function will not be implicitly 'const' in C++1y; add 'const' to avoid a change in behavior}} + constexpr int &f(); // expected-warning {{'constexpr' non-static member function will not be implicitly 'const' in C++14; add 'const' to avoid a change in behavior}} int &f(); }; diff --git a/test/FixIt/fixit-errors.c b/test/FixIt/fixit-errors.c index c425fc8a2d95..d727adb6fdfb 100644 --- a/test/FixIt/fixit-errors.c +++ b/test/FixIt/fixit-errors.c @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s // RUN: cp %s %t // RUN: not %clang_cc1 -pedantic -fixit -x c %t -// RUN: %clang_cc1 -pedantic -Werror -x c %t +// RUN: %clang_cc1 -pedantic -Werror -Wno-invalid-noreturn -x c %t /* This is a test of the various code modification hints that are provided as part of warning or extension diagnostics. All of the @@ -21,3 +21,11 @@ struct Point *get_origin(); void test_point() { (void)get_origin->x; // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments?}} } + +void noreturn_1() _Noreturn; // expected-error {{must precede function declarator}} +void noreturn_1() { + return; // expected-warning {{should not return}} +} +void noreturn_2() _Noreturn { // expected-error {{must precede function declarator}} + return; // expected-warning {{should not return}} +} diff --git a/test/FixIt/fixit-unrecoverable.cpp b/test/FixIt/fixit-unrecoverable.cpp index 1e1f1b8db210..f555792ed39b 100644 --- a/test/FixIt/fixit-unrecoverable.cpp +++ b/test/FixIt/fixit-unrecoverable.cpp @@ -6,7 +6,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s float f(int y) { - return static_cst<float>(y); // expected-error{{use of undeclared identifier 'static_cst'; did you mean 'static_cast'?}} \ - // expected-error{{for function-style cast or type construction}} + return static_cst<float>(y); // expected-error{{use of undeclared identifier 'static_cst'; did you mean 'static_cast'?}} } - diff --git a/test/FixIt/fixit.cpp b/test/FixIt/fixit.cpp index f26493856560..585c216f90de 100644 --- a/test/FixIt/fixit.cpp +++ b/test/FixIt/fixit.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ %s -// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ %s 2>&1 | FileCheck %s +// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ -std=c++11 %s 2>&1 | FileCheck %s // RUN: cp %s %t // RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ %t // RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ %t @@ -308,6 +308,13 @@ namespace dtor_fixit { ~bar() { } // expected-error {{expected the class name after '~' to name a destructor}} // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:6-[[@LINE-1]]:9}:"foo" }; + + class bar { + ~bar(); + }; + ~bar::bar() {} // expected-error {{'~' in destructor name should be after nested name specifier}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:4}:"" + // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:9-[[@LINE-2]]:9}:"~" } namespace PR5066 { @@ -340,3 +347,43 @@ namespace PR15045 { return c->a; // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; maybe you meant to use '.'?}} } } + +namespace curly_after_base_clause { +struct A { void f(); }; +struct B : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + int i; +}; +struct C : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + using A::f; +}; +struct D : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + protected: +}; +struct E : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + template<typename T> struct inner { }; +}; +struct F : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + F() { } +}; +#if __cplusplus >= 201103L +struct G : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + constexpr G(int) { } +}; +struct H : A // expected-error{{expected '{' after base class list}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:13-[[@LINE-1]]:13}:" {" + static_assert(true, ""); +}; +#endif +} + +struct conversion_operator { + conversion_operator::* const operator int(); // expected-error {{put the complete type after 'operator'}} + // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:3-[[@LINE-1]]:32}:"" + // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:44-[[@LINE-2]]:44}:" conversion_operator::* const" +}; diff --git a/test/FixIt/multiarg-selector-fixit.m b/test/FixIt/multiarg-selector-fixit.m new file mode 100644 index 000000000000..d60d31282ce7 --- /dev/null +++ b/test/FixIt/multiarg-selector-fixit.m @@ -0,0 +1,15 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -x objective-c -fixit %t +// RUN: diff %t %s +// rdar://15756038 + +#define nil (void *)0 + +@interface NSObject +- (void)testDataSource:(id)object withMultipleArguments:(id)arguments; +@end + +int main() { + id obj; + [obj TestDataSource:nil withMultipleArguments:nil]; +} diff --git a/test/FixIt/property-access-fixit.m b/test/FixIt/property-access-fixit.m new file mode 100644 index 000000000000..8623d29b9629 --- /dev/null +++ b/test/FixIt/property-access-fixit.m @@ -0,0 +1,31 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -x objective-c -fixit %t +// RUN: %clang_cc1 -x objective-c -Werror %t +//rdar://17911746 + +@class BridgeFormatter; + +@interface NSObject ++ (id)new; +@end + +@interface X : NSObject +@property int x; +@property int Y; +@property(assign, readwrite, getter=formatter, setter=setFormatter:) BridgeFormatter* cppFormatter; +@end + +@implementation X +- (void) endit +{ + self.formatter = 0; +} +@end + +int main() +{ + X *obj = [X new]; + obj.X = 3; + obj.y = 4; + return obj.x + obj.Y; +} diff --git a/test/Frontend/Inputs/profile-sample-use-loc-tracking.prof b/test/Frontend/Inputs/profile-sample-use-loc-tracking.prof new file mode 100644 index 000000000000..ba9a678a4526 --- /dev/null +++ b/test/Frontend/Inputs/profile-sample-use-loc-tracking.prof @@ -0,0 +1,2 @@ +bar:100:100 +1: 2000 diff --git a/test/Frontend/exceptions.c b/test/Frontend/exceptions.c index 4bbaaa39bfa6..981b5b9045b5 100644 --- a/test/Frontend/exceptions.c +++ b/test/Frontend/exceptions.c @@ -1,6 +1,9 @@ -// RUN: %clang_cc1 -fms-compatibility -fexceptions -fcxx-exceptions -verify %s +// RUN: %clang_cc1 -fms-compatibility -fexceptions -fcxx-exceptions -DMS_MODE -verify %s // expected-no-diagnostics -#if defined(__EXCEPTIONS) +// RUN: %clang_cc1 -fms-compatibility -fexceptions -verify %s +// expected-no-diagnostics + +#if defined(MS_MODE) && defined(__EXCEPTIONS) #error __EXCEPTIONS should not be defined. #endif diff --git a/test/Frontend/invalid-o-level.c b/test/Frontend/invalid-o-level.c index 73be9b1c21ff..0314448b0ff2 100644 --- a/test/Frontend/invalid-o-level.c +++ b/test/Frontend/invalid-o-level.c @@ -1,4 +1,5 @@ -// RUN: %clang_cc1 %s -O900 -o /dev/null 2> %t.log -// RUN: FileCheck %s -input-file=%t.log +// RUN: %clang_cc1 %s -O900 -o /dev/null 2>&1 | FileCheck %s -// CHECK: warning: optimization level '-O900' is not supported; using '-O3' instead +// RUN: %clang_cc1 %s -O8 -o /dev/null 2>&1 | FileCheck %s + +// CHECK: warning: optimization level '-O{{.*}}' is not supported; using '-O3' instead diff --git a/test/Frontend/output-failures.c b/test/Frontend/output-failures.c index e2af7c7ddc90..362deb5e4629 100644 --- a/test/Frontend/output-failures.c +++ b/test/Frontend/output-failures.c @@ -1,4 +1,4 @@ // RUN: not %clang_cc1 -emit-llvm -o %S/doesnotexist/somename %s 2> %t // RUN: FileCheck -check-prefix=OUTPUTFAIL -input-file=%t %s -// OUTPUTFAIL: Error opening output file '{{.*}}doesnotexist{{.*}}' +// OUTPUTFAIL: error: unable to open output file '{{.*}}{{[/\\]}}test{{[/\\]}}Frontend{{[/\\]}}doesnotexist{{[/\\]}}somename': '{{[nN]}}o such file or directory' diff --git a/test/Frontend/print-header-includes.c b/test/Frontend/print-header-includes.c index e248c76f9776..6fde00cbbe5b 100644 --- a/test/Frontend/print-header-includes.c +++ b/test/Frontend/print-header-includes.c @@ -1,3 +1,6 @@ +// REQUIRES: shell + +// RUN: cd %S // RUN: %clang_cc1 -include Inputs/test3.h -E -H -o %t.out %s 2> %t.stderr // RUN: FileCheck < %t.stderr %s diff --git a/test/Frontend/profile-sample-use-loc-tracking.c b/test/Frontend/profile-sample-use-loc-tracking.c new file mode 100644 index 000000000000..31faad68d39e --- /dev/null +++ b/test/Frontend/profile-sample-use-loc-tracking.c @@ -0,0 +1,19 @@ +// This file tests that -fprofile-sample-use enables location tracking +// generation in the same way that -Rpass does. The sample profiler needs +// to associate line locations in the profile to the code, so it needs the +// frontend to emit source location annotations. + +// RUN: %clang_cc1 %s -fprofile-sample-use=%S/Inputs/profile-sample-use-loc-tracking.prof -emit-llvm -o - 2>/dev/null | FileCheck %s + +// -fprofile-sample-use should produce source location annotations, exclusively +// (just like -gmlt). +// CHECK: , !dbg ! +// CHECK-NOT: DW_TAG_base_type + +// But llvm.dbg.cu should be missing (to prevent writing debug info to +// the final output). +// CHECK-NOT: !llvm.dbg.cu = !{ + +int bar(int j) { + return (j + j - 2) * (j - 2) * j; +} diff --git a/test/Frontend/source-col-map.c b/test/Frontend/source-col-map.c new file mode 100644 index 000000000000..a14023bc82a8 --- /dev/null +++ b/test/Frontend/source-col-map.c @@ -0,0 +1,37 @@ +// RUN: not %clang_cc1 %s -fsyntax-only -fmessage-length 75 -o /dev/null 2>&1 | FileCheck %s -strict-whitespace + +// Test case for the text diagnostics source column conversion crash. + +// This test case tries to check the error diagnostic message printer, which is +// responsible to create the code snippet shorter than the message-length (in +// number of columns.) +// +// The error diagnostic message printer should be able to handle the non-ascii +// characters without any segmentation fault or assertion failure. If your +// changes to clang frontend crashes this case, it is likely that you are mixing +// column index with byte index which are two totally different concepts. + +// NOTE: This file is encoded in UTF-8 and intentionally contains some +// non-ASCII characters. + +__attribute__((format(printf, 1, 2))) +extern int printf(const char *fmt, ...); + +void test1(Unknown* b); // αααα αααα αααα αααα αααα αααα αααα αααα αααα αααα αααα +// CHECK: unknown type name 'Unknown' +// CHECK-NEXT: void test1(Unknown* b); // αααα αααα αααα αααα αααα αααα αααα ααα... +// CHECK-NEXT: {{^ \^$}} + +void test2(Unknown* b); // αααα αααα αααα αααα αααα αααα αααα αααα αααα + +// CHECK: unknown type name 'Unknown' +// CHECK-NEXT: void test2(Unknown* b); // αααα αααα αααα αααα αααα αααα αααα αααα αααα +// CHECK-NEXT: {{^ \^$}} + +void test3() { + /* αααα αααα αααα αααα αααα αααα αααα αααα αααα αααα */ printf("%d", "s"); +} +// CHECK: format specifies type 'int' but the argument has type 'char *' +// CHECK-NEXT: ...αααα αααα αααα αααα αααα αααα αααα αααα αααα */ printf("%d", "s"); +// CHECK-NEXT: {{^ ~~ \^~~$}} +// CHECK-NEXT: {{^ %s$}} diff --git a/test/Frontend/std.cl b/test/Frontend/std.cl new file mode 100644 index 000000000000..b811b64dabcb --- /dev/null +++ b/test/Frontend/std.cl @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL +// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL1.1 +// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL1.2 +// RUN: %clang_cc1 %s -fsyntax-only -cl-std=CL2.0 +// RUN: not %clang_cc1 %s -fsyntax-only -cl-std=invalid -DINVALID 2>&1 | FileCheck %s + +#ifdef INVALID +// CHECK: invalid value 'invalid' in '-cl-std=invalid' +#endif diff --git a/test/Frontend/trigraphs.cpp b/test/Frontend/trigraphs.cpp new file mode 100644 index 000000000000..552078951aee --- /dev/null +++ b/test/Frontend/trigraphs.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -DSTDCPP11 -std=c++11 -verify -fsyntax-only %s +// RUN: %clang_cc1 -DSTDGNU11 -std=gnu++11 -verify -fsyntax-only %s +// RUN: %clang_cc1 -DSTDGNU11TRI -ftrigraphs -std=gnu++11 -verify -fsyntax-only %s +// RUN: %clang_cc1 -DSTDCPP17 -std=c++1z -verify -fsyntax-only %s +// RUN: %clang_cc1 -DSTDCPP17TRI -ftrigraphs -std=c++1z -verify -fsyntax-only %s +// RUN: %clang_cc1 -DMSCOMPAT -fms-compatibility -std=c++11 -verify -fsyntax-only %s + +void foo() { +#if defined(NOFLAGS) || defined(STDCPP11) || defined(STDGNU11TRI) || \ + defined(STDCPP17TRI) + const char c[] = "??/n"; // expected-warning{{trigraph converted to '\' character}} +#elif defined(STDGNU11) || defined(STDCPP17) || defined(MSCOMPAT) + const char c[] = "??/n"; // expected-warning{{trigraph ignored}} +#else +#error Not handled. +#endif +} diff --git a/test/Frontend/verify-unknown-arg.c b/test/Frontend/verify-unknown-arg.c new file mode 100644 index 000000000000..5767daedca3c --- /dev/null +++ b/test/Frontend/verify-unknown-arg.c @@ -0,0 +1,6 @@ +// RUN: not %clang_cc1 -asdf -verify %s 2>&1 | FileCheck %s + +// expected-no-diagnostics + +// CHECK: error: 'error' diagnostics seen but not expected: +// CHECK-NEXT: (frontend): unknown argument: '-asdf' diff --git a/test/Frontend/x86-target-cpu.c b/test/Frontend/x86-target-cpu.c new file mode 100644 index 000000000000..769c40a016e3 --- /dev/null +++ b/test/Frontend/x86-target-cpu.c @@ -0,0 +1,30 @@ +// Ensure we support the various CPU names. +// +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu nocona -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu core2 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu penryn -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu nehalem -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu westmere -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu sandybridge -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu ivybridge -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu haswell -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu broadwell -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu bonnell -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu silvermont -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu k8 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu opteron -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu athlon64 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu athlon-fx -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu k8-sse3 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu opteron-sse3 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu athlon64-sse3 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu amdfam10 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu barcelona -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu bdver1 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu bdver2 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu bdver3 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu bdver4 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu btver1 -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-cpu btver2 -verify %s +// +// expected-no-diagnostics diff --git a/test/Headers/altivec-header.c b/test/Headers/altivec-header.c index 3d8595734893..7b6c5168b01e 100644 --- a/test/Headers/altivec-header.c +++ b/test/Headers/altivec-header.c @@ -12,4 +12,5 @@ // CHECK-NEXT: .file // CHECK-NEXT: {{^$}} // CHECK-NEXT: .ident{{.*$}} +// CHECK-NEXT: .section ".note.GNU-stack","",@progbits // CHECK-NOT: . diff --git a/test/Headers/altivec-intrin.c b/test/Headers/altivec-intrin.c new file mode 100644 index 000000000000..a4de7e75966b --- /dev/null +++ b/test/Headers/altivec-intrin.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -target-cpu power8 \ +// RUN: -faltivec -verify %s + +// Test special behavior of Altivec intrinsics in this file. + +#include <altivec.h> + +__attribute__((__aligned__(16))) float x[20]; + +int main() +{ + vector unsigned char l = vec_lvsl (0, &x[1]); // expected-warning {{is deprecated: use assignment for unaligned little endian loads/stores}} + vector unsigned char r = vec_lvsr (0, &x[1]); // expected-warning {{is deprecated: use assignment for unaligned little endian loads/stores}} +} +// FIXME: As noted in ms-intrin.cpp, it would be nice if we didn't have to +// hard-code the line number from altivec.h here. +// expected-note@altivec.h:2389 {{deprecated here}} +// expected-note@altivec.h:2524 {{deprecated here}} diff --git a/test/Headers/c11.c b/test/Headers/c11.c index b7b15011f3ce..6594823c2733 100644 --- a/test/Headers/c11.c +++ b/test/Headers/c11.c @@ -1,6 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -fsyntax-only -verify -std=c11 %s -// RUN: %clang_cc1 -fsyntax-only -verify -std=c11 -fmodules -fmodules-cache-path=%t %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c11 -fmodules -fmodules-cache-path=%t %s -D__STDC_WANT_LIB_EXT1__=1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c11 -ffreestanding %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c11 -triple i686-pc-win32 -fms-compatibility-version=17.00 %s diff --git a/test/Headers/cpuid.c b/test/Headers/cpuid.c new file mode 100644 index 000000000000..b0ba07af2f2a --- /dev/null +++ b/test/Headers/cpuid.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 %s -ffreestanding -triple x86_64-apple-darwin -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-64 +// RUN: %clang_cc1 %s -ffreestanding -triple i386 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-32 + +#include <cpuid.h> + +// CHECK-64: {{.*}} call { i32, i32, i32, i32 } asm " xchgq %rbx,${1:q}\0A cpuid\0A xchgq %rbx,${1:q}", "={ax},=r,={cx},={dx},0,~{dirflag},~{fpsr},~{flags}"(i32 %{{[a-z0-9]+}}) +// CHECK-64: {{.*}} call { i32, i32, i32, i32 } asm " xchgq %rbx,${1:q}\0A cpuid\0A xchgq %rbx,${1:q}", "={ax},=r,={cx},={dx},0,2,~{dirflag},~{fpsr},~{flags}"(i32 %{{[a-z0-9]+}}, i32 %{{[a-z0-9]+}}) + +// CHECK-32: {{.*}} call { i32, i32, i32, i32 } asm "cpuid", "={ax},={bx},={cx},={dx},0,~{dirflag},~{fpsr},~{flags}"(i32 %{{[a-z0-9]+}}) +// CHECK-32: {{.*}} call { i32, i32, i32, i32 } asm "cpuid", "={ax},={bx},={cx},={dx},0,2,~{dirflag},~{fpsr},~{flags}"(i32 %{{[a-z0-9]+}}, i32 %{{[a-z0-9]+}}) + +unsigned eax0, ebx0, ecx0, edx0; +unsigned eax1, ebx1, ecx1, edx1; + +void test_cpuid(unsigned level, unsigned count) { + __cpuid(level, eax1, ebx1, ecx1, edx1); + __cpuid_count(level, count, eax0, ebx0, ecx0, edx0); +} diff --git a/test/Headers/cxx11.cpp b/test/Headers/cxx11.cpp index 5b0ec0b79ccb..0b35a7c2bdfa 100644 --- a/test/Headers/cxx11.cpp +++ b/test/Headers/cxx11.cpp @@ -1,5 +1,6 @@ +// RUN: rm -rf %t // RUN: %clang_cc1 -ffreestanding -fsyntax-only -std=c++11 %s -// RUN: %clang_cc1 -ffreestanding -fsyntax-only -std=c++11 -fmodules %s +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -std=c++11 -fmodules -fmodules-cache-path=%t %s // This test fails on systems with older OS X 10.9 SDK headers, see PR18322. diff --git a/test/Headers/ms-intrin.cpp b/test/Headers/ms-intrin.cpp index 68f436cf2479..a83225e37f8e 100644 --- a/test/Headers/ms-intrin.cpp +++ b/test/Headers/ms-intrin.cpp @@ -3,6 +3,11 @@ // RUN: -ffreestanding -fsyntax-only -Werror \ // RUN: -isystem %S/Inputs/include %s +// RUN: %clang_cc1 -triple i386-pc-win32 -target-cpu broadwell \ +// RUN: -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \ +// RUN: -ffreestanding -fsyntax-only -Werror \ +// RUN: -isystem %S/Inputs/include %s + // RUN: %clang_cc1 -triple x86_64-pc-win32 \ // RUN: -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \ // RUN: -ffreestanding -fsyntax-only -Werror \ diff --git a/test/Headers/x86intrin.c b/test/Headers/x86intrin.c index d095c00674e0..6a1608b756a0 100644 --- a/test/Headers/x86intrin.c +++ b/test/Headers/x86intrin.c @@ -84,6 +84,45 @@ #ifndef __RDRND__ #define __RDRND__ #endif +#ifndef __SHA__ +#define __SHA__ +#endif +#ifndef __ADX__ +#define __ADX__ +#endif +#ifndef __TBM__ +#define __TBM__ +#endif +#ifndef __RTM__ +#define __RTM__ +#endif +#ifndef __PCLMUL__ +#define __PCLMUL__ +#endif +#ifndef __FSGSBASE__ +#define __FSGSBASE__ +#endif +#ifndef __AVX512F__ +#define __AVX512F__ +#endif +#ifndef __AVX512VL__ +#define __AVX512VL__ +#endif +#ifndef __AVX512BW__ +#define __AVX512BW__ +#endif +#ifndef __AVX512ER__ +#define __AVX512ER__ +#endif +#ifndef __AVX512PF__ +#define __AVX512PF__ +#endif +#ifndef __AVX512DQ__ +#define __AVX512DQ__ +#endif +#ifndef __AVX512CD__ +#define __AVX512CD__ +#endif // Now include the metaheader that includes all x86 intrinsic headers. #include <x86intrin.h> diff --git a/test/Index/Inputs/complete-at-EOF.c b/test/Index/Inputs/complete-at-EOF.c new file mode 100644 index 000000000000..8207f7205518 --- /dev/null +++ b/test/Index/Inputs/complete-at-EOF.c @@ -0,0 +1,3 @@ +#define CAKE 1 + +typedef int foo; diff --git a/test/Index/Inputs/declare-objc-predef.h b/test/Index/Inputs/declare-objc-predef.h new file mode 100644 index 000000000000..6a03c4f88d21 --- /dev/null +++ b/test/Index/Inputs/declare-objc-predef.h @@ -0,0 +1,3 @@ +@class Protocol; +typedef struct objc_class *Class +@class id; diff --git a/test/Index/Inputs/module-undef.h b/test/Index/Inputs/module-undef.h new file mode 100644 index 000000000000..8212d755a0ff --- /dev/null +++ b/test/Index/Inputs/module-undef.h @@ -0,0 +1,2 @@ +#define MY_MACRO 1 +#undef MY_MACRO diff --git a/test/Index/Inputs/module.map b/test/Index/Inputs/module.map index 8f24840c81f9..4bfc109a8b13 100644 --- a/test/Index/Inputs/module.map +++ b/test/Index/Inputs/module.map @@ -4,3 +4,5 @@ module ModuleNeedsVFS { export * } framework module * { } + +module ModuleUndef { header "module-undef.h" } diff --git a/test/Index/annotate-deep-statements.cpp b/test/Index/annotate-deep-statements.cpp index c0a55f25e49d..1803c2bacf5e 100644 --- a/test/Index/annotate-deep-statements.cpp +++ b/test/Index/annotate-deep-statements.cpp @@ -3,8 +3,8 @@ // rdar://11979525 // Check that we don't get stack overflow trying to annotate an extremely deep AST. -// AddressSanitizer increases stack usage. -// REQUIRES: not_asan +// AddressSanitizer and UndefinedBehaviorSanitizer increases stack usage. +// REQUIRES: not_asan, not_ubsan struct S { S &operator()(); diff --git a/test/Index/attributes-cuda.cu b/test/Index/attributes-cuda.cu index 953ef3d51fee..824bdb4c883f 100644 --- a/test/Index/attributes-cuda.cu +++ b/test/Index/attributes-cuda.cu @@ -3,6 +3,7 @@ __attribute__((device)) void f_device(); __attribute__((global)) void f_global(); __attribute__((constant)) int* g_constant; +__attribute__((shared)) float *g_shared; __attribute__((host)) void f_host(); // CHECK: attributes-cuda.cu:3:30: FunctionDecl=f_device:3:30 @@ -11,5 +12,7 @@ __attribute__((host)) void f_host(); // CHECK-NEXT: attributes-cuda.cu:4:16: attribute(global) // CHECK: attributes-cuda.cu:5:32: VarDecl=g_constant:5:32 (Definition) // CHECK-NEXT: attributes-cuda.cu:5:16: attribute(constant) -// CHECK: attributes-cuda.cu:6:28: FunctionDecl=f_host:6:28 -// CHECK-NEXT: attributes-cuda.cu:6:16: attribute(host) +// CHECK: attributes-cuda.cu:6:32: VarDecl=g_shared:6:32 (Definition) +// CHECK-NEXT: attributes-cuda.cu:6:16: attribute(shared) +// CHECK: attributes-cuda.cu:7:28: FunctionDecl=f_host:7:28 +// CHECK-NEXT: attributes-cuda.cu:7:16: attribute(host) diff --git a/test/Index/comment-c-decls.c b/test/Index/comment-c-decls.c index 371e453bef4f..2a99b36ea820 100644 --- a/test/Index/comment-c-decls.c +++ b/test/Index/comment-c-decls.c @@ -101,4 +101,4 @@ int (^Block) (int i, int j); *\brief block declaration */ int (^Block1) (int i, int j) = ^(int i, int j) { return i + j; }; -// CHECK: <Declaration>int (^Block1)(int, int) = ^(int i, int j) {}</Declaration> +// CHECK: <Declaration>int (^Block1)(int, int) = ^(int i, int j) {\n}</Declaration> diff --git a/test/Index/comment-lots-of-unknown-commands.c b/test/Index/comment-lots-of-unknown-commands.c new file mode 100644 index 000000000000..f0640effebcb --- /dev/null +++ b/test/Index/comment-lots-of-unknown-commands.c @@ -0,0 +1,295 @@ +// RUN: c-index-test -test-load-source-reparse 1 local %s | FileCheck %s + +// See PR 21254. We had too few bits to encode command IDs so if you created +// enough of them the ID codes would wrap around. This test creates commands up +// to an ID of 258. Ideally we should check for large numbers, but that would +// require a test source file which is megabytes in size. This is the test case +// from the PR. + +/** +@s +@tr +@y +@tt +@tg +@alu +@U +@I +@r +@t0 +@t1 +@ur +@S +@E +@pb +@f +@pe +@lue +@re +@oa +@l +@x +@R +@ute +@am +@ei +@oun +@ou +@nl +@ien +@fr +@en +@tet +@le +@L +@os +@A +@ro +@o +@ho +@ca +@Tie +@tl +@g +@hr +@et +@fro +@ast +@ae +@nN +@pc +@tae +@ws +@ia +@N +@lc +@psg +@ta +@t2 +@D +@str +@ra +@t3 +@t +@xt +@eN +@fe +@rU +@ar +@eD +@iE +@se +@st1 +@rr +@ime +@ft +@lm +@wD +@wne +@h +@otn +@use +@roi +@ldc +@ln +@d +@ee +@ep +@us +@ut +@u +@n +@Nme +@min +@ma +@pct +@hd +@be +@It +@id +@cm +@ua +@fs +@Al +@axn +@rt +@to +@is +@fo +@i +@an +@de +@tel +@nd +@dic +@Lo +@il +@tle +@axt +@ba +@ust +@ac +@tpe +@tpl +@ctG +@ru +@m +@tG +@it +@rh +@G +@rpc +@el +@er +@w +@eo +@tx +@oo +@dD +@dD +*/ +void f(); + +// CHECK: CommentAST=[ +// CHECK: (CXComment_FullComment +// CHECK: (CXComment_Paragraph +// CHECK: (CXComment_InlineCommand CommandName=[s] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tr] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[y] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tt] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tg] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[alu] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[U] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[I] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[r] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[t0] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[t1] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ur] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[S] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[E] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[pb] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[f] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[pe] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[lue] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[re] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[oa] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[l] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[x] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[R] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ute] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[am] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ei] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[oun] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ou] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[nl] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ien] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[fr] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[en] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tet] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[le] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[L] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[os] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[A] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ro] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[o] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ho] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ca] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[Tie] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tl] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[g] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[hr] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[et] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[fro] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ast] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ae] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[nN] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[pc] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tae] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ws] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ia] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[N] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[lc] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[psg] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ta] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[t2] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[D] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[str] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ra] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[t3] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[t] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[xt] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[eN] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[fe] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[rU] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ar] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[eD] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[iE] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[se] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[st1] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[rr] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ime] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ft] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[lm] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[wD] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[wne] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[h] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[otn] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[use] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[roi] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ldc] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ln] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[d] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ee] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ep] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[us] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ut] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[u] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[n] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[Nme] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[min] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ma] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[pct] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[hd] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[be] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[It] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[id] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[cm] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ua] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[fs] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[Al] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[axn] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[rt] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[to] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[is] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[fo] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[i] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[an] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[de] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tel] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[nd] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[dic] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[Lo] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[il] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tle] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[axt] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ba] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ust] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ac] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tpe] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tpl] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ctG] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[ru] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[m] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tG] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[it] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[rh] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[G] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[rpc] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[el] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[er] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[w] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[eo] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[tx] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[oo] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[dD] RenderNormal HasTrailingNewline) +// CHECK: (CXComment_InlineCommand CommandName=[dD] RenderNormal)))] diff --git a/test/Index/comment-to-html-xml-conversion.cpp b/test/Index/comment-to-html-xml-conversion.cpp index 95e11c3bc348..f31061aa12ab 100644 --- a/test/Index/comment-to-html-xml-conversion.cpp +++ b/test/Index/comment-to-html-xml-conversion.cpp @@ -325,7 +325,7 @@ void test_cmd_param_6(int x1, ...); template<typename T> void test_cmd_tparam_1(T aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_1:{{.*}} FullCommentAsHTML=[<dl><dt class="param-name-index-0">aaa</dt><dd class="param-descr-index-0"> Blah blah</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_1</Name><USR>c:@FT@>1#Ttest_cmd_tparam_1#t0.0#</USR><Declaration>template <typename T> void test_cmd_tparam_1(T aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_1:{{.*}} FullCommentAsHTML=[<dl><dt class="param-name-index-0">aaa</dt><dd class="param-descr-index-0"> Blah blah</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_1</Name><USR>c:@FT@>1#Ttest_cmd_tparam_1#t0.0#v#</USR><Declaration>template <typename T> void test_cmd_tparam_1(T aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] // CHECK-NEXT: CommentAST=[ // CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_Paragraph IsWhitespace @@ -342,7 +342,7 @@ void test_cmd_tparam_1(T aaa); template<typename T> void test_cmd_tparam_2(T aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_2:{{.*}} FullCommentAsHTML=[<dl><dt class="param-name-index-0">aaa</dt><dd class="param-descr-index-0"> Blah blah</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_2</Name><USR>c:@FT@>1#Ttest_cmd_tparam_2#t0.0#</USR><Declaration>template <typename T> void test_cmd_tparam_2(T aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_2:{{.*}} FullCommentAsHTML=[<dl><dt class="param-name-index-0">aaa</dt><dd class="param-descr-index-0"> Blah blah</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_2</Name><USR>c:@FT@>1#Ttest_cmd_tparam_2#t0.0#v#</USR><Declaration>template <typename T> void test_cmd_tparam_2(T aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] // CHECK-NEXT: CommentAST=[ // CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_Paragraph IsWhitespace @@ -359,7 +359,7 @@ void test_cmd_tparam_2(T aaa); template<typename T1, typename T2> void test_cmd_tparam_3(T1 aaa, T2 bbb); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_3:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">T1</dt><dd class="tparam-descr-index-0"> Aaa</dd><dt class="tparam-name-index-1">T2</dt><dd class="tparam-descr-index-1"> Bbb </dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_3</Name><USR>c:@FT@>2#T#Ttest_cmd_tparam_3#t0.0#t0.1#</USR><Declaration>template <typename T1, typename T2> void test_cmd_tparam_3(T1 aaa, T2 bbb)</Declaration><TemplateParameters><Parameter><Name>T1</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>T2</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_3:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">T1</dt><dd class="tparam-descr-index-0"> Aaa</dd><dt class="tparam-name-index-1">T2</dt><dd class="tparam-descr-index-1"> Bbb </dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_3</Name><USR>c:@FT@>2#T#Ttest_cmd_tparam_3#t0.0#t0.1#v#</USR><Declaration>template <typename T1, typename T2> void test_cmd_tparam_3(T1 aaa, T2 bbb)</Declaration><TemplateParameters><Parameter><Name>T1</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>T2</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] // CHECK-NEXT: CommentAST=[ // CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_Paragraph IsWhitespace @@ -379,7 +379,7 @@ void test_cmd_tparam_3(T1 aaa, T2 bbb); template<typename T1, typename T2, int V> void test_cmd_tparam_4(T1 aaa, T2 bbb); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_4:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">T1</dt><dd class="tparam-descr-index-0"> Aaa</dd><dt class="tparam-name-index-1">T2</dt><dd class="tparam-descr-index-1"> Bbb </dd><dt class="tparam-name-index-2">V</dt><dd class="tparam-descr-index-2"> Ccc </dd><dt class="tparam-name-index-invalid">U</dt><dd class="tparam-descr-index-invalid"> Zzz </dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_4</Name><USR>c:@FT@>3#T#T#NItest_cmd_tparam_4#t0.0#t0.1#</USR><Declaration>template <typename T1, typename T2, int V>\nvoid test_cmd_tparam_4(T1 aaa, T2 bbb)</Declaration><TemplateParameters><Parameter><Name>T1</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>T2</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>V</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>U</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_4:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">T1</dt><dd class="tparam-descr-index-0"> Aaa</dd><dt class="tparam-name-index-1">T2</dt><dd class="tparam-descr-index-1"> Bbb </dd><dt class="tparam-name-index-2">V</dt><dd class="tparam-descr-index-2"> Ccc </dd><dt class="tparam-name-index-invalid">U</dt><dd class="tparam-descr-index-invalid"> Zzz </dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_4</Name><USR>c:@FT@>3#T#T#NItest_cmd_tparam_4#t0.0#t0.1#v#</USR><Declaration>template <typename T1, typename T2, int V>\nvoid test_cmd_tparam_4(T1 aaa, T2 bbb)</Declaration><TemplateParameters><Parameter><Name>T1</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>T2</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>V</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>U</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] // CHECK-NEXT: CommentAST=[ // CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_Paragraph IsWhitespace @@ -407,7 +407,7 @@ void test_cmd_tparam_4(T1 aaa, T2 bbb); template<template<template<typename T> class TT, class C> class TTT> void test_cmd_tparam_5(); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_5:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">TTT</dt><dd class="tparam-descr-index-0"> Ddd </dd><dt class="tparam-name-index-other">C</dt><dd class="tparam-descr-index-other"> Ccc </dd><dt class="tparam-name-index-other">T</dt><dd class="tparam-descr-index-other"> Aaa </dd><dt class="tparam-name-index-other">TT</dt><dd class="tparam-descr-index-other"> Bbb</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_5</Name><USR>c:@FT@>1#t>2#t>1#T#Ttest_cmd_tparam_5#</USR><Declaration>template <template <template <typename T> class TT, class C> class TTT>\nvoid test_cmd_tparam_5()</Declaration><TemplateParameters><Parameter><Name>TTT</Name><Index>0</Index><Discussion><Para> Ddd </Para></Discussion></Parameter><Parameter><Name>C</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>T</Name><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>TT</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=test_cmd_tparam_5:{{.*}} FullCommentAsHTML=[<dl><dt class="tparam-name-index-0">TTT</dt><dd class="tparam-descr-index-0"> Ddd </dd><dt class="tparam-name-index-other">C</dt><dd class="tparam-descr-index-other"> Ccc </dd><dt class="tparam-name-index-other">T</dt><dd class="tparam-descr-index-other"> Aaa </dd><dt class="tparam-name-index-other">TT</dt><dd class="tparam-descr-index-other"> Bbb</dd></dl>] FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>test_cmd_tparam_5</Name><USR>c:@FT@>1#t>2#t>1#T#Ttest_cmd_tparam_5#v#</USR><Declaration>template <template <template <typename T> class TT, class C> class TTT>\nvoid test_cmd_tparam_5()</Declaration><TemplateParameters><Parameter><Name>TTT</Name><Index>0</Index><Discussion><Para> Ddd </Para></Discussion></Parameter><Parameter><Name>C</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>T</Name><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>TT</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] // CHECK-NEXT: CommentAST=[ // CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_Paragraph IsWhitespace @@ -736,47 +736,47 @@ void comment_to_html_conversion_36(); /// Aaa. class comment_to_xml_conversion_01 { -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>comment_to_xml_conversion_01</Name><USR>c:@C@comment_to_xml_conversion_01</USR><Declaration>class comment_to_xml_conversion_01 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>comment_to_xml_conversion_01</Name><USR>c:@S@comment_to_xml_conversion_01</USR><Declaration>class comment_to_xml_conversion_01 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] /// \param aaa Blah blah. comment_to_xml_conversion_01(int aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXConstructor=comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>comment_to_xml_conversion_01</Name><USR>c:@C@comment_to_xml_conversion_01@F@comment_to_xml_conversion_01#I#</USR><Declaration>comment_to_xml_conversion_01(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXConstructor=comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>comment_to_xml_conversion_01</Name><USR>c:@S@comment_to_xml_conversion_01@F@comment_to_xml_conversion_01#I#</USR><Declaration>comment_to_xml_conversion_01(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] /// Aaa. ~comment_to_xml_conversion_01(); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXDestructor=~comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>~comment_to_xml_conversion_01</Name><USR>c:@C@comment_to_xml_conversion_01@F@~comment_to_xml_conversion_01#</USR><Declaration>~comment_to_xml_conversion_01()</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXDestructor=~comment_to_xml_conversion_01:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>~comment_to_xml_conversion_01</Name><USR>c:@S@comment_to_xml_conversion_01@F@~comment_to_xml_conversion_01#</USR><Declaration>~comment_to_xml_conversion_01()</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] /// \param aaa Blah blah. int comment_to_xml_conversion_02(int aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: CXXMethod=comment_to_xml_conversion_02:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_02</Name><USR>c:@C@comment_to_xml_conversion_01@F@comment_to_xml_conversion_02#I#</USR><Declaration>int comment_to_xml_conversion_02(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: CXXMethod=comment_to_xml_conversion_02:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_02</Name><USR>c:@S@comment_to_xml_conversion_01@F@comment_to_xml_conversion_02#I#</USR><Declaration>int comment_to_xml_conversion_02(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] /// \param aaa Blah blah. static int comment_to_xml_conversion_03(int aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:14: CXXMethod=comment_to_xml_conversion_03:{{.*}} FullCommentAsXML=[<Function isClassMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="14"><Name>comment_to_xml_conversion_03</Name><USR>c:@C@comment_to_xml_conversion_01@F@comment_to_xml_conversion_03#I#S</USR><Declaration>static int comment_to_xml_conversion_03(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:14: CXXMethod=comment_to_xml_conversion_03:{{.*}} FullCommentAsXML=[<Function isClassMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="14"><Name>comment_to_xml_conversion_03</Name><USR>c:@S@comment_to_xml_conversion_01@F@comment_to_xml_conversion_03#I#S</USR><Declaration>static int comment_to_xml_conversion_03(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] /// Aaa. int comment_to_xml_conversion_04; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: FieldDecl=comment_to_xml_conversion_04:{{.*}} FullCommentAsXML=[<Variable file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_04</Name><USR>c:@C@comment_to_xml_conversion_01@FI@comment_to_xml_conversion_04</USR><Declaration>int comment_to_xml_conversion_04</Declaration><Abstract><Para> Aaa.</Para></Abstract></Variable>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: FieldDecl=comment_to_xml_conversion_04:{{.*}} FullCommentAsXML=[<Variable file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_04</Name><USR>c:@S@comment_to_xml_conversion_01@FI@comment_to_xml_conversion_04</USR><Declaration>int comment_to_xml_conversion_04</Declaration><Abstract><Para> Aaa.</Para></Abstract></Variable>] /// Aaa. static int comment_to_xml_conversion_05; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:14: VarDecl=comment_to_xml_conversion_05:{{.*}} FullCommentAsXML=[<Variable file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="14"><Name>comment_to_xml_conversion_05</Name><USR>c:@C@comment_to_xml_conversion_01@comment_to_xml_conversion_05</USR><Declaration>static int comment_to_xml_conversion_05</Declaration><Abstract><Para> Aaa.</Para></Abstract></Variable>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:14: VarDecl=comment_to_xml_conversion_05:{{.*}} FullCommentAsXML=[<Variable file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="14"><Name>comment_to_xml_conversion_05</Name><USR>c:@S@comment_to_xml_conversion_01@comment_to_xml_conversion_05</USR><Declaration>static int comment_to_xml_conversion_05</Declaration><Abstract><Para> Aaa.</Para></Abstract></Variable>] /// \param aaa Blah blah. void operator()(int aaa); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:8: CXXMethod=operator():{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="8"><Name>operator()</Name><USR>c:@C@comment_to_xml_conversion_01@F@operator()#I#</USR><Declaration>void operator()(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:8: CXXMethod=operator():{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="8"><Name>operator()</Name><USR>c:@S@comment_to_xml_conversion_01@F@operator()#I#</USR><Declaration>void operator()(int aaa)</Declaration><Parameters><Parameter><Name>aaa</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah.</Para></Discussion></Parameter></Parameters></Function>] /// Aaa. operator bool(); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXConversion=operator bool:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>operator bool</Name><USR>c:@C@comment_to_xml_conversion_01@F@operator bool#</USR><Declaration>operator bool()</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: CXXConversion=operator bool:{{.*}} FullCommentAsXML=[<Function isInstanceMethod="1" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>operator bool</Name><USR>c:@S@comment_to_xml_conversion_01@F@operator bool#</USR><Declaration>operator bool()</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] /// Aaa. typedef int comment_to_xml_conversion_06; @@ -787,26 +787,26 @@ class comment_to_xml_conversion_01 { /// Aaa. using comment_to_xml_conversion_07 = int; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:9: TypeAliasDecl=comment_to_xml_conversion_07:{{.*}} FullCommentAsXML=[<Typedef file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="9"><Name>comment_to_xml_conversion_07</Name><USR>c:@C@comment_to_xml_conversion_01@comment_to_xml_conversion_07</USR><Declaration>using comment_to_xml_conversion_07 = int</Declaration><Abstract><Para> Aaa.</Para></Abstract></Typedef>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:9: TypeAliasDecl=comment_to_xml_conversion_07:{{.*}} FullCommentAsXML=[<Typedef file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="9"><Name>comment_to_xml_conversion_07</Name><USR>c:@S@comment_to_xml_conversion_01@comment_to_xml_conversion_07</USR><Declaration>using comment_to_xml_conversion_07 = int</Declaration><Abstract><Para> Aaa.</Para></Abstract></Typedef>] /// Aaa. template<typename T, typename U> class comment_to_xml_conversion_08 { }; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:9: ClassTemplate=comment_to_xml_conversion_08:{{.*}} FullCommentAsXML=[<Class templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="9"><Name>comment_to_xml_conversion_08</Name><USR>c:@C@comment_to_xml_conversion_01@CT>2#T#T@comment_to_xml_conversion_08</USR><Declaration>template <typename T, typename U> class comment_to_xml_conversion_08 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:9: ClassTemplate=comment_to_xml_conversion_08:{{.*}} FullCommentAsXML=[<Class templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="9"><Name>comment_to_xml_conversion_08</Name><USR>c:@S@comment_to_xml_conversion_01@ST>2#T#T@comment_to_xml_conversion_08</USR><Declaration>template <typename T, typename U> class comment_to_xml_conversion_08 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] /// Aaa. template<typename T> using comment_to_xml_conversion_09 = comment_to_xml_conversion_08<T, int>; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: UnexposedDecl=comment_to_xml_conversion_09:{{.*}} FullCommentAsXML=[<Typedef file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>comment_to_xml_conversion_09</Name><USR>c:@C@comment_to_xml_conversion_01@comment_to_xml_conversion_09</USR><Declaration>template <typename T>\nusing comment_to_xml_conversion_09 = comment_to_xml_conversion_08<T, int></Declaration><Abstract><Para> Aaa.</Para></Abstract></Typedef>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:3: UnexposedDecl=comment_to_xml_conversion_09:{{.*}} FullCommentAsXML=[<Typedef file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="3"><Name>comment_to_xml_conversion_09</Name><USR>c:@S@comment_to_xml_conversion_01@comment_to_xml_conversion_09</USR><Declaration>template <typename T>\nusing comment_to_xml_conversion_09 = comment_to_xml_conversion_08<T, int></Declaration><Abstract><Para> Aaa.</Para></Abstract></Typedef>] }; /// Aaa. template<typename T, typename U> void comment_to_xml_conversion_10(T aaa, U bbb); -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=comment_to_xml_conversion_10:{{.*}} FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_xml_conversion_10</Name><USR>c:@FT@>2#T#Tcomment_to_xml_conversion_10#t0.0#t0.1#</USR><Declaration>template <typename T, typename U>\nvoid comment_to_xml_conversion_10(T aaa, U bbb)</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:6: FunctionTemplate=comment_to_xml_conversion_10:{{.*}} FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_xml_conversion_10</Name><USR>c:@FT@>2#T#Tcomment_to_xml_conversion_10#t0.0#t0.1#v#</USR><Declaration>template <typename T, typename U>\nvoid comment_to_xml_conversion_10(T aaa, U bbb)</Declaration><Abstract><Para> Aaa.</Para></Abstract></Function>] /// Aaa. template<> @@ -818,19 +818,19 @@ void comment_to_xml_conversion_10(int aaa, int bbb); template<typename T, typename U> class comment_to_xml_conversion_11 { }; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassTemplate=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@CT>2#T#T@comment_to_xml_conversion_11</USR><Declaration>template <typename T, typename U> class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassTemplate=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="template" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@ST>2#T#T@comment_to_xml_conversion_11</USR><Declaration>template <typename T, typename U> class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] /// Aaa. template<typename T> class comment_to_xml_conversion_11<T, int> { }; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassTemplatePartialSpecialization=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="partialSpecialization" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@CP>1#T@comment_to_xml_conversion_11>#t0.0#I</USR><Declaration>class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassTemplatePartialSpecialization=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="partialSpecialization" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@SP>1#T@comment_to_xml_conversion_11>#t0.0#I</USR><Declaration>class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] /// Aaa. template<> class comment_to_xml_conversion_11<int, int> { }; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassDecl=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="specialization" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@C@comment_to_xml_conversion_11>#I#I</USR><Declaration>class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-2]]:7: ClassDecl=comment_to_xml_conversion_11:{{.*}} FullCommentAsXML=[<Class templateKind="specialization" file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-2]]" column="7"><Name>comment_to_xml_conversion_11</Name><USR>c:@S@comment_to_xml_conversion_11>#I#I</USR><Declaration>class comment_to_xml_conversion_11 {}</Declaration><Abstract><Para> Aaa.</Para></Abstract></Class>] /// Aaa. int comment_to_xml_conversion_12; @@ -902,7 +902,7 @@ void comment_to_xml_conversion_unsafe_html_07(); class BaseToSuper1_Base {}; class BaseToSuper1_Derived : public BaseToSuper1_Base {}; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper1_Derived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper1_Base</Name><USR>c:@C@BaseToSuper1_Base</USR><Declaration>class BaseToSuper1_Derived : public BaseToSuper1_Base {}</Declaration><Abstract><Para> BaseToSuper1_Base</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper1_Derived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper1_Base</Name><USR>c:@S@BaseToSuper1_Base</USR><Declaration>class BaseToSuper1_Derived : public BaseToSuper1_Base {}</Declaration><Abstract><Para> BaseToSuper1_Base</Para></Abstract></Class>] /// BaseToSuper2_Base @@ -910,10 +910,10 @@ class BaseToSuper2_Base {}; /// BaseToSuper2_Derived class BaseToSuper2_Derived : public BaseToSuper2_Base {}; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper2_Derived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper2_Derived</Name><USR>c:@C@BaseToSuper2_Derived</USR><Declaration>class BaseToSuper2_Derived : public BaseToSuper2_Base {}</Declaration><Abstract><Para> BaseToSuper2_Derived</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper2_Derived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper2_Derived</Name><USR>c:@S@BaseToSuper2_Derived</USR><Declaration>class BaseToSuper2_Derived : public BaseToSuper2_Base {}</Declaration><Abstract><Para> BaseToSuper2_Derived</Para></Abstract></Class>] class BaseToSuper2_MoreDerived : public BaseToSuper2_Derived {}; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper2_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper2_Derived</Name><USR>c:@C@BaseToSuper2_Derived</USR><Declaration>class BaseToSuper2_MoreDerived : public BaseToSuper2_Derived {}</Declaration><Abstract><Para> BaseToSuper2_Derived</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper2_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper2_Derived</Name><USR>c:@S@BaseToSuper2_Derived</USR><Declaration>class BaseToSuper2_MoreDerived : public BaseToSuper2_Derived {}</Declaration><Abstract><Para> BaseToSuper2_Derived</Para></Abstract></Class>] /// BaseToSuper3_Base @@ -924,7 +924,7 @@ class BaseToSuper3_DerivedA : public virtual BaseToSuper3_Base {}; class BaseToSuper3_DerivedB : public virtual BaseToSuper3_Base {}; class BaseToSuper3_MoreDerived : public BaseToSuper3_DerivedA, public BaseToSuper3_DerivedB {}; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper3_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper3_Base</Name><USR>c:@C@BaseToSuper3_Base</USR><Declaration>class BaseToSuper3_MoreDerived : public BaseToSuper3_DerivedA,\n public BaseToSuper3_DerivedB {}</Declaration><Abstract><Para> BaseToSuper3_Base</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper3_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper3_Base</Name><USR>c:@S@BaseToSuper3_Base</USR><Declaration>class BaseToSuper3_MoreDerived : public BaseToSuper3_DerivedA,\n public BaseToSuper3_DerivedB {}</Declaration><Abstract><Para> BaseToSuper3_Base</Para></Abstract></Class>] // Check that we propagate comments only through public inheritance. @@ -938,7 +938,7 @@ class BaseToSuper4_DerivedA : virtual BaseToSuper4_Base {}; class BaseToSuper4_DerivedB : public virtual BaseToSuper4_Base {}; class BaseToSuper4_MoreDerived : BaseToSuper4_DerivedA, public BaseToSuper4_DerivedB {}; -// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper4_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper4_Base</Name><USR>c:@C@BaseToSuper4_Base</USR><Declaration>class BaseToSuper4_MoreDerived : BaseToSuper4_DerivedA,\n public BaseToSuper4_DerivedB {}</Declaration><Abstract><Para> BaseToSuper4_Base</Para></Abstract></Class>] +// CHECK: comment-to-html-xml-conversion.cpp:[[@LINE-1]]:7: ClassDecl=BaseToSuper4_MoreDerived:{{.*}} FullCommentAsXML=[<Class file="{{[^"]+}}comment-to-html-xml-conversion.cpp" line="[[@LINE-1]]" column="7"><Name>BaseToSuper4_Base</Name><USR>c:@S@BaseToSuper4_Base</USR><Declaration>class BaseToSuper4_MoreDerived : BaseToSuper4_DerivedA,\n public BaseToSuper4_DerivedB {}</Declaration><Abstract><Para> BaseToSuper4_Base</Para></Abstract></Class>] //===--- // Check the representation of \todo in XML. diff --git a/test/Index/complete-at-EOF.c b/test/Index/complete-at-EOF.c new file mode 100644 index 000000000000..d039aaa1af18 --- /dev/null +++ b/test/Index/complete-at-EOF.c @@ -0,0 +1,9 @@ + +// RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test \ +// RUN: -code-completion-at=%S/Inputs/complete-at-EOF.c:4:1 %S/Inputs/complete-at-EOF.c | FileCheck -check-prefix=CHECK-EOF %s +// CHECK-EOF: macro definition:{TypedText CAKE} +// CHECK-EOF: TypedefDecl:{TypedText foo} + +// RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test \ +// RUN: -code-completion-at=%S/Inputs/complete-at-EOF.c:2:1 %S/Inputs/complete-at-EOF.c | FileCheck -check-prefix=CHECK-AFTER-PREAMBLE %s +// CHECK-AFTER-PREAMBLE: macro definition:{TypedText CAKE} diff --git a/test/Index/complete-module-undef.m b/test/Index/complete-module-undef.m new file mode 100644 index 000000000000..a9dd00096411 --- /dev/null +++ b/test/Index/complete-module-undef.m @@ -0,0 +1,8 @@ +// RUN: rm -rf %t +// RUN: env CINDEXTEST_COMPLETION_CACHING=1 \ +// RUN: c-index-test -test-load-source-reparse 2 local %s -fmodules -fmodules-cache-path=%t -I %S/Inputs \ +// RUN: | FileCheck %s + +// rdar://18416901 (used to crash) +// CHECK: complete-module-undef.m:8:1: ModuleImport=ModuleUndef:8:1 (Definition) Extent=[8:1 - 8:20] +@import ModuleUndef; diff --git a/test/Index/cursor-dynamic-call.mm b/test/Index/cursor-dynamic-call.mm index ac9e6d351a0a..a926c3d03d47 100644 --- a/test/Index/cursor-dynamic-call.mm +++ b/test/Index/cursor-dynamic-call.mm @@ -37,6 +37,18 @@ void foo(SS *ss, IS* is, Class cls) { [cls ClsMeth]; } +@interface NSObject ++(id)alloc; +-(id)init; +@end + +@interface Test : NSObject +@end + +void test2() { + id o = [[Test alloc] init]; +} + // RUN: c-index-test -cursor-at=%s:8:11 \ // RUN: -cursor-at=%s:9:11 \ // RUN: -cursor-at=%s:25:11 \ @@ -46,6 +58,7 @@ void foo(SS *ss, IS* is, Class cls) { // RUN: -cursor-at=%s:35:9 \ // RUN: -cursor-at=%s:36:9 \ // RUN: -cursor-at=%s:37:9 \ +// RUN: -cursor-at=%s:49:26 \ // RUN: %s | FileCheck %s // CHECK: 8:11 MemberRefExpr=meth:3:16 {{.*}} Dynamic-call @@ -59,3 +72,4 @@ void foo(SS *ss, IS* is, Class cls) { // CHECK-NOT: 36:3 {{.*}} Dynamic-call // CHECK: 36:3 {{.*}} Receiver-type=ObjCInterface // CHECK: 37:3 ObjCMessageExpr=ClsMeth:15:8 {{.*}} Dynamic-call Receiver-type=ObjCClass +// CHECK-NOT: 49:10 {{.*}} Dynamic-call diff --git a/test/Index/cxx11-lambdas.cpp b/test/Index/cxx11-lambdas.cpp index afb540a84d5f..d0ee908059fa 100644 --- a/test/Index/cxx11-lambdas.cpp +++ b/test/Index/cxx11-lambdas.cpp @@ -30,4 +30,4 @@ struct X { // CHECK-INDEX: [indexEntityReference]: kind: typedef | name: Integer | USR: c:cxx11-lambdas.cpp@T@Integer | lang: C | cursor: TypeRef=Integer:3:13 | loc: 7:38 // CHECK-INDEX: [indexEntityReference]: kind: variable | name: localA | USR: c:cxx11-lambdas.cpp@100@S@X@F@f#@localA | lang: C | cursor: DeclRefExpr=localA:6:9 | loc: 8:14 // CHECK-INDEX: [indexEntityReference]: kind: variable | name: localB | USR: c:cxx11-lambdas.cpp@100@S@X@F@f#@localB | lang: C | cursor: DeclRefExpr=localB:6:17 | loc: 8:23 -// CHECK-INDEX: [indexEntityReference]: kind: variable | name: x | USR: c:cxx11-lambdas.cpp@157@S@X@F@f#@Ca@F@operator()#I#1@x | lang: C | cursor: DeclRefExpr=x:7:46 | loc: 8:32 +// CHECK-INDEX: [indexEntityReference]: kind: variable | name: x | USR: c:cxx11-lambdas.cpp@157@S@X@F@f#@Sa@F@operator()#I#1@x | lang: C | cursor: DeclRefExpr=x:7:46 | loc: 8:32 diff --git a/test/Index/format-comment-cdecls.c b/test/Index/format-comment-cdecls.c index 471be2baf234..34cedfdb16b3 100644 --- a/test/Index/format-comment-cdecls.c +++ b/test/Index/format-comment-cdecls.c @@ -96,4 +96,4 @@ int (^Block) (int i, int j); *\brief block declaration */ int (^Block1) (int i, int j) = ^(int i, int j) { return i + j; }; -// CHECK: <Declaration>int (^Block1)(int, int) = ^(int i, int j) {}</Declaration> +// CHECK: <Declaration>int (^Block1)(int, int) = ^(int i, int j) {\n}</Declaration> diff --git a/test/Index/get-cursor.cpp b/test/Index/get-cursor.cpp index 996ecc25ef42..60aab5f7ed79 100644 --- a/test/Index/get-cursor.cpp +++ b/test/Index/get-cursor.cpp @@ -65,6 +65,84 @@ template<> void TC<char>::init(); #define EXTERN_TEMPLATE(...) extern template __VA_ARGS__; EXTERN_TEMPLATE(class TC<char>) +class A { + A(); + virtual ~A(); + + // Assignment operators + A& operator=(const A&); + A& operator=(A&&) noexcept; + + // Unary operators + A operator+() const; + A operator-() const; + A operator~() const; + A operator*() const; + A operator&() const; + bool operator!() const; + + // (pre-|post-) increment and decrement + A& operator++(); + A& operator--(); + A operator++(int); + A operator--(int); + + // Arithmetic operators + A operator+(const A&) const; + A operator-(const A&) const; + A operator*(const A&) const; + A operator/(const A&) const; + A operator%(const A&) const; + A operator&(const A&) const; + A operator|(const A&) const; + A operator^(const A&) const; + + A operator<<(const A&) const; + A operator>>(const A&) const; + + // Arithmetic-assignment operators + A& operator+=(const A&); + A& operator-=(const A&); + A& operator*=(const A&); + A& operator/=(const A&); + A& operator%=(const A&); + A& operator&=(const A&); + A& operator|=(const A&); + A& operator^=(const A&); + + A& operator<<=(const A&); + A& operator>>=(const A&); + + // Logical operators + bool operator<(const A&) const; + bool operator>(const A&) const; + + bool operator&&(const A&) const; + bool operator||(const A&) const; + bool operator<=(const A&) const; + bool operator>=(const A&) const; + bool operator!=(const A&) const; + bool operator==(const A&) const; + + // Special operators + A& operator[](unsigned long long); + A* operator->(); + A operator()(unsigned, int) const; + + explicit operator bool() const; +}; + +struct TestColl { + int* begin(); + int* end(); +}; + +void test(TestColl coll) { + for (auto lv : coll) { + (void)lv; + } +} + // RUN: c-index-test -cursor-at=%s:6:4 %s | FileCheck -check-prefix=CHECK-COMPLETION-1 %s // CHECK-COMPLETION-1: CXXConstructor=X:6:3 // CHECK-COMPLETION-1-NEXT: Completion string: {TypedText X}{LeftParen (}{Placeholder int}{Comma , }{Placeholder int}{RightParen )} @@ -128,3 +206,56 @@ EXTERN_TEMPLATE(class TC<char>) // RUN: c-index-test -cursor-at=%s:66:23 %s | FileCheck -check-prefix=CHECK-TEMPLSPEC %s // CHECK-TEMPLSPEC: 66:23 ClassDecl=TC:66:23 (Definition) [Specialization of TC:59:7] Extent=[66:1 - 66:31] Spelling=TC ([66:23 - 66:25]) + +// RUN: c-index-test -cursor-at=%s:69:3 -cursor-at=%s:70:11 -cursor-at=%s:73:6 -cursor-at=%s:74:6 -cursor-at=%s:77:8 -cursor-at=%s:78:8 -cursor-at=%s:79:8 -cursor-at=%s:80:8 -cursor-at=%s:81:8 -cursor-at=%s:82:8 -cursor-at=%s:85:6 -cursor-at=%s:86:6 -cursor-at=%s:87:6 -cursor-at=%s:88:6 -cursor-at=%s:91:5 -cursor-at=%s:92:5 -cursor-at=%s:93:5 -cursor-at=%s:94:5 -cursor-at=%s:95:5 -cursor-at=%s:96:5 -cursor-at=%s:97:5 -cursor-at=%s:98:5 -cursor-at=%s:100:5 -cursor-at=%s:101:5 -cursor-at=%s:104:6 -cursor-at=%s:105:6 -cursor-at=%s:106:6 -cursor-at=%s:107:6 -cursor-at=%s:108:6 -cursor-at=%s:109:6 -cursor-at=%s:110:6 -cursor-at=%s:111:6 -cursor-at=%s:113:6 -cursor-at=%s:114:6 -cursor-at=%s:117:8 -cursor-at=%s:118:8 -cursor-at=%s:120:8 -cursor-at=%s:121:8 -cursor-at=%s:122:8 -cursor-at=%s:123:8 -cursor-at=%s:124:8 -cursor-at=%s:125:8 -cursor-at=%s:128:6 -cursor-at=%s:129:6 -cursor-at=%s:130:6 -cursor-at=%s:132:3 -std=c++11 %s | FileCheck -check-prefix=CHECK-SPELLING %s +// CHECK-SPELLING: 69:3 CXXConstructor=A:69:3 Extent=[69:3 - 69:6] Spelling=A ([69:3 - 69:4]) +// CHECK-SPELLING: 70:11 CXXDestructor=~A:70:11 (virtual) Extent=[70:3 - 70:15] Spelling=~A ([70:11 - 70:13]) +// CHECK-SPELLING: 73:6 CXXMethod=operator=:73:6 Extent=[73:3 - 73:25] Spelling=operator= ([73:6 - 73:15]) +// CHECK-SPELLING: 74:6 CXXMethod=operator=:74:6 Extent=[74:3 - 74:29] Spelling=operator= ([74:6 - 74:15]) +// CHECK-SPELLING: 77:8 CXXMethod=operator+:77:8 (const) Extent=[77:3 - 77:25] Spelling=operator+ ([77:8 - 77:17]) +// CHECK-SPELLING: 78:8 CXXMethod=operator-:78:8 (const) Extent=[78:3 - 78:25] Spelling=operator- ([78:8 - 78:17]) +// CHECK-SPELLING: 79:8 CXXMethod=operator~:79:8 (const) Extent=[79:3 - 79:25] Spelling=operator~ ([79:8 - 79:17]) +// CHECK-SPELLING: 80:8 CXXMethod=operator*:80:8 (const) Extent=[80:3 - 80:25] Spelling=operator* ([80:8 - 80:17]) +// CHECK-SPELLING: 81:8 CXXMethod=operator&:81:8 (const) Extent=[81:3 - 81:25] Spelling=operator& ([81:8 - 81:17]) +// CHECK-SPELLING: 82:8 CXXMethod=operator!:82:8 (const) Extent=[82:3 - 82:25] Spelling=operator! ([82:8 - 82:17]) +// CHECK-SPELLING: 85:6 CXXMethod=operator++:85:6 Extent=[85:3 - 85:18] Spelling=operator++ ([85:6 - 85:16]) +// CHECK-SPELLING: 86:6 CXXMethod=operator--:86:6 Extent=[86:3 - 86:18] Spelling=operator-- ([86:6 - 86:16]) +// CHECK-SPELLING: 87:6 CXXMethod=operator++:87:6 Extent=[87:3 - 87:21] Spelling=operator++ ([87:6 - 87:16]) +// CHECK-SPELLING: 88:6 CXXMethod=operator--:88:6 Extent=[88:3 - 88:21] Spelling=operator-- ([88:6 - 88:16]) +// CHECK-SPELLING: 91:5 CXXMethod=operator+:91:5 (const) Extent=[91:3 - 91:30] Spelling=operator+ ([91:5 - 91:14]) +// CHECK-SPELLING: 92:5 CXXMethod=operator-:92:5 (const) Extent=[92:3 - 92:30] Spelling=operator- ([92:5 - 92:14]) +// CHECK-SPELLING: 93:5 CXXMethod=operator*:93:5 (const) Extent=[93:3 - 93:30] Spelling=operator* ([93:5 - 93:14]) +// CHECK-SPELLING: 94:5 CXXMethod=operator/:94:5 (const) Extent=[94:3 - 94:30] Spelling=operator/ ([94:5 - 94:14]) +// CHECK-SPELLING: 95:5 CXXMethod=operator%:95:5 (const) Extent=[95:3 - 95:30] Spelling=operator% ([95:5 - 95:14]) +// CHECK-SPELLING: 96:5 CXXMethod=operator&:96:5 (const) Extent=[96:3 - 96:30] Spelling=operator& ([96:5 - 96:14]) +// CHECK-SPELLING: 97:5 CXXMethod=operator|:97:5 (const) Extent=[97:3 - 97:30] Spelling=operator| ([97:5 - 97:14]) +// CHECK-SPELLING: 98:5 CXXMethod=operator^:98:5 (const) Extent=[98:3 - 98:30] Spelling=operator^ ([98:5 - 98:14]) +// CHECK-SPELLING: 100:5 CXXMethod=operator<<:100:5 (const) Extent=[100:3 - 100:31] Spelling=operator<< ([100:5 - 100:15]) +// CHECK-SPELLING: 101:5 CXXMethod=operator>>:101:5 (const) Extent=[101:3 - 101:31] Spelling=operator>> ([101:5 - 101:15]) +// CHECK-SPELLING: 104:6 CXXMethod=operator+=:104:6 Extent=[104:3 - 104:26] Spelling=operator+= ([104:6 - 104:16]) +// CHECK-SPELLING: 105:6 CXXMethod=operator-=:105:6 Extent=[105:3 - 105:26] Spelling=operator-= ([105:6 - 105:16]) +// CHECK-SPELLING: 106:6 CXXMethod=operator*=:106:6 Extent=[106:3 - 106:26] Spelling=operator*= ([106:6 - 106:16]) +// CHECK-SPELLING: 107:6 CXXMethod=operator/=:107:6 Extent=[107:3 - 107:26] Spelling=operator/= ([107:6 - 107:16]) +// CHECK-SPELLING: 108:6 CXXMethod=operator%=:108:6 Extent=[108:3 - 108:26] Spelling=operator%= ([108:6 - 108:16]) +// CHECK-SPELLING: 109:6 CXXMethod=operator&=:109:6 Extent=[109:3 - 109:26] Spelling=operator&= ([109:6 - 109:16]) +// CHECK-SPELLING: 110:6 CXXMethod=operator|=:110:6 Extent=[110:3 - 110:26] Spelling=operator|= ([110:6 - 110:16]) +// CHECK-SPELLING: 111:6 CXXMethod=operator^=:111:6 Extent=[111:3 - 111:26] Spelling=operator^= ([111:6 - 111:16]) +// CHECK-SPELLING: 113:6 CXXMethod=operator<<=:113:6 Extent=[113:3 - 113:27] Spelling=operator<<= ([113:6 - 113:17]) +// CHECK-SPELLING: 114:6 CXXMethod=operator>>=:114:6 Extent=[114:3 - 114:27] Spelling=operator>>= ([114:6 - 114:17]) +// CHECK-SPELLING: 117:8 CXXMethod=operator<:117:8 (const) Extent=[117:3 - 117:33] Spelling=operator< ([117:8 - 117:17]) +// CHECK-SPELLING: 118:8 CXXMethod=operator>:118:8 (const) Extent=[118:3 - 118:33] Spelling=operator> ([118:8 - 118:17]) +// CHECK-SPELLING: 120:8 CXXMethod=operator&&:120:8 (const) Extent=[120:3 - 120:34] Spelling=operator&& ([120:8 - 120:18]) +// CHECK-SPELLING: 121:8 CXXMethod=operator||:121:8 (const) Extent=[121:3 - 121:34] Spelling=operator|| ([121:8 - 121:18]) +// CHECK-SPELLING: 122:8 CXXMethod=operator<=:122:8 (const) Extent=[122:3 - 122:34] Spelling=operator<= ([122:8 - 122:18]) +// CHECK-SPELLING: 123:8 CXXMethod=operator>=:123:8 (const) Extent=[123:3 - 123:34] Spelling=operator>= ([123:8 - 123:18]) +// CHECK-SPELLING: 124:8 CXXMethod=operator!=:124:8 (const) Extent=[124:3 - 124:34] Spelling=operator!= ([124:8 - 124:18]) +// CHECK-SPELLING: 125:8 CXXMethod=operator==:125:8 (const) Extent=[125:3 - 125:34] Spelling=operator== ([125:8 - 125:18]) +// CHECK-SPELLING: 128:6 CXXMethod=operator[]:128:6 Extent=[128:3 - 128:36] Spelling=operator[] ([128:6 - 128:16]) +// CHECK-SPELLING: 129:6 CXXMethod=operator->:129:6 Extent=[129:3 - 129:18] Spelling=operator-> ([129:6 - 129:16]) +// CHECK-SPELLING: 130:6 CXXMethod=operator():130:6 (const) Extent=[130:3 - 130:37] Spelling=operator() ([130:6 - 130:16]) +// CHECK-SPELLING: 132:12 CXXConversion=operator bool:132:12 (const) Extent=[132:3 - 132:33] Spelling=operator bool ([132:12 - 132:25]) + +// RUN: c-index-test -cursor-at=%s:141:13 -cursor-at=%s:141:18 -cursor-at=%s:142:11 -std=c++11 %s | FileCheck -check-prefix=CHECK-FORRANGE %s +// CHECK-FORRANGE: 141:13 VarDecl=lv:141:13 (Definition) Extent=[141:8 - 141:17] Spelling=lv ([141:13 - 141:15]) +// CHECK-FORRANGE: 141:18 DeclRefExpr=coll:140:20 Extent=[141:18 - 141:22] Spelling=coll ([141:18 - 141:22]) +// CHECK-FORRANGE: 142:11 DeclRefExpr=lv:141:13 Extent=[142:11 - 142:13] Spelling=lv ([142:11 - 142:13]) diff --git a/test/Index/index-many-call-ops.cpp b/test/Index/index-many-call-ops.cpp index e732b5f188ae..7644697d4e7c 100644 --- a/test/Index/index-many-call-ops.cpp +++ b/test/Index/index-many-call-ops.cpp @@ -4,6 +4,9 @@ // Check that we don't get stack overflow trying to index a huge number of // call operators. +// UBSan increses stack usage. +// REQUIRES: not_ubsan + struct S { S &operator()(); }; diff --git a/test/Index/index-many-logical-ops.c b/test/Index/index-many-logical-ops.c index 67017decb777..0fd4e75236f1 100644 --- a/test/Index/index-many-logical-ops.c +++ b/test/Index/index-many-logical-ops.c @@ -4,6 +4,9 @@ // Check that we don't get stack overflow trying to index a huge number of // logical operators. +// UBSan increses stack usage. +// REQUIRES: not_ubsan + // CHECK: [indexDeclaration]: kind: function | name: foo int foo(int x) { return diff --git a/test/Index/index-module.m b/test/Index/index-module.m index 8e0155607dda..8ed7a84e2e1a 100644 --- a/test/Index/index-module.m +++ b/test/Index/index-module.m @@ -40,7 +40,7 @@ int glob; // CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMOD_MODULE_H:.*/Modules/Inputs/Module\.framework[/\\]Headers[/\\]Module\.h]] | {{.*}} | hash loc: <invalid> // CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMODHDR:.*/Modules/Inputs/Module.framework[/\\]Headers.]]Sub.h | name: "Module/Sub.h" | hash loc: [[TMOD_MODULE_H]]:23:1 | isImport: 0 | isAngled: 1 // CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMODHDR]]Sub2.h | name: "Module/Sub2.h" | hash loc: [[TMODHDR]]Sub.h:1:1 | isImport: 0 | isAngled: 1 -// CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMODHDR]]Buried/Treasure.h | name: "Module/Buried/Treasure.h" | hash loc: [[TMOD_MODULE_H]]:24:1 | isImport: 0 | isAngled: 1 +// CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMODHDR]]Buried{{[/\\]}}Treasure.h | name: "Module/Buried/Treasure.h" | hash loc: [[TMOD_MODULE_H]]:24:1 | isImport: 0 | isAngled: 1 // CHECK-TMOD-NEXT: [ppIncludedFile]: [[TMOD_SUB_H:.*[/\\]Modules[/\\]Inputs[/\\]Module\.framework[/\\]Frameworks[/\\]SubFramework\.framework[/\\]Headers[/\\]SubFramework\.h]] | {{.*}} | hash loc: <invalid> // CHECK-TMOD-NEXT: [indexDeclaration]: kind: function | name: getModuleVersion | {{.*}} | loc: [[TMOD_MODULE_H]]:9:13 // CHECK-TMOD-NEXT: [indexDeclaration]: kind: objc-class | name: Module | {{.*}} | loc: [[TMOD_MODULE_H]]:15:12 @@ -52,6 +52,6 @@ int glob; // CHECK-TMOD-NEXT: [importedASTFile]: [[PCM]] | loc: [[TMODHDR]]Sub.h:1:2 | name: "Module.Sub2" | isImplicit: 1 // CHECK-TMOD-NEXT: [indexDeclaration]: kind: variable | name: Module_Sub | {{.*}} | loc: [[TMODHDR]]Sub.h:2:6 // CHECK-TMOD-NEXT: [indexDeclaration]: kind: variable | name: Module_Sub2 | USR: c:@Module_Sub2 | {{.*}} | loc: [[TMODHDR]]Sub2.h:1:6 -// CHECK-TMOD-NEXT: [indexDeclaration]: kind: variable | name: Buried_Treasure | {{.*}} | loc: [[TMODHDR]]Buried/Treasure.h:1:11 +// CHECK-TMOD-NEXT: [indexDeclaration]: kind: variable | name: Buried_Treasure | {{.*}} | loc: [[TMODHDR]]Buried{{[/\\]}}Treasure.h:1:11 // CHECK-TMOD-NEXT: [indexDeclaration]: kind: variable | name: module_subframework | {{.*}} | loc: [[TMOD_SUB_H]]:4:7 // CHECK-TMOD-NOT: [indexDeclaration] diff --git a/test/Index/index-templates.cpp b/test/Index/index-templates.cpp index 5fcb652cea1a..570d7cf15d4d 100644 --- a/test/Index/index-templates.cpp +++ b/test/Index/index-templates.cpp @@ -100,6 +100,16 @@ template class Pair<int, int>; template<typename T, typename U> struct SuperPair : Pair<int, int>, Pair<T, U> { }; +enum FxnTmplEnum { + FxnTmplEnum_A, FxnTmplEnum_B, FxnTmplEnum_C, +}; +template <typename T, int I, FxnTmplEnum, int E> +void foo(T Value) {} + +static const int FxnTmpl_Var = 7; +template <> +void foo<float, 9, FxnTmplEnum_B, FxnTmpl_Var + 7>(float Value); + // RUN: c-index-test -test-load-source all -fno-delayed-template-parsing %s | FileCheck -check-prefix=CHECK-LOAD %s // CHECK-LOAD: index-templates.cpp:4:6: FunctionTemplate=f:4:6 Extent=[3:1 - 4:22] // CHECK-LOAD: index-templates.cpp:3:19: TemplateTypeParameter=T:3:19 (Definition) Extent=[3:10 - 3:20] @@ -178,30 +188,30 @@ struct SuperPair : Pair<int, int>, Pair<T, U> { }; // CHECK-LOAD: index-templates.cpp:100:31: TemplateTypeParameter=U:100:31 (Definition) Extent=[100:22 - 100:32] // CHECK-LOAD: index-templates.cpp:101:20: C++ base class specifier=Pair<int, int>:98:16 [access=public isVirtual=false] Extent=[101:20 - 101:34] // CHECK-LOAD: index-templates.cpp:101:36: C++ base class specifier=Pair<T, U>:76:8 [access=public isVirtual=false] Extent=[101:36 - 101:46] - +// CHECK-LOAD: index-templates.cpp:111:6: FunctionDecl=foo:111:6 [Specialization of foo:107:6] [Template arg 0: kind: 1, type: float] [Template arg 1: kind: 4, intval: 9] [Template arg 2: kind: 4, intval: 1] [Template arg 3: kind: 4, intval: 14] Extent=[110:1 - 111:64] // RUN: c-index-test -test-load-source-usrs all -fno-delayed-template-parsing %s | FileCheck -check-prefix=CHECK-USRS %s -// CHECK-USRS: index-templates.cpp c:@FT@>3#T#Nt0.0#t>2#T#Nt1.0f#>t0.22S0_# Extent=[3:1 - 4:22] +// CHECK-USRS: index-templates.cpp c:@FT@>3#T#Nt0.0#t>2#T#Nt1.0f#>t0.22S0_#v# Extent=[3:1 - 4:22] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@70 Extent=[3:10 - 3:20] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@82 Extent=[3:22 - 3:29] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@91 Extent=[3:31 - 3:67] -// CHECK-USRS: index-templates.cpp c:index-templates.cpp@136@FT@>3#T#Nt0.0#t>2#T#Nt1.0f#>t0.22S0_#@x Extent=[4:8 - 4:21] -// CHECK-USRS: index-templates.cpp c:@CT>1#T@allocator Extent=[6:1 - 6:37] +// CHECK-USRS: index-templates.cpp c:index-templates.cpp@136@FT@>3#T#Nt0.0#t>2#T#Nt1.0f#>t0.22S0_#v#@x Extent=[4:8 - 4:21] +// CHECK-USRS: index-templates.cpp c:@ST>1#T@allocator Extent=[6:1 - 6:37] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@162 Extent=[6:10 - 6:20] -// CHECK-USRS: index-templates.cpp c:@CT>2#T#T@vector Extent=[8:1 - 11:2] +// CHECK-USRS: index-templates.cpp c:@ST>2#T#T@vector Extent=[8:1 - 11:2] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@201 Extent=[8:10 - 8:20] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@213 Extent=[8:22 - 8:51] -// CHECK-USRS: index-templates.cpp c:@CT>2#T#T@vector@F@clear# Extent=[10:3 - 10:15] -// CHECK-USRS: index-templates.cpp c:@CP>1#T@vector>#*t0.0#>@CT>1#T@allocator1S0_ Extent=[13:1 - 14:21] +// CHECK-USRS: index-templates.cpp c:@ST>2#T#T@vector@F@clear# Extent=[10:3 - 10:15] +// CHECK-USRS: index-templates.cpp c:@SP>1#T@vector>#*t0.0#>@ST>1#T@allocator1S0_ Extent=[13:1 - 14:21] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@289 Extent=[13:10 - 13:20] // CHECK-USRS: index-templates.cpp c:@S@Z1 Extent=[16:1 - 16:14] -// CHECK-USRS: index-templates.cpp c:@C@vector>#$@S@Z1#$@C@allocator>#S0_ Extent=[18:1 - 18:26] +// CHECK-USRS: index-templates.cpp c:@S@vector>#$@S@Z1#$@S@allocator>#S0_ Extent=[18:1 - 18:26] // CHECK-USRS: index-templates.cpp c:@S@Z2 Extent=[20:1 - 20:14] -// CHECK-USRS: index-templates.cpp c:@C@vector>#$@S@Z2#$@C@allocator>#S0_ Extent=[22:1 - 25:2] -// CHECK-USRS: index-templates.cpp c:@C@vector>#$@S@Z2#$@C@allocator>#S0_@F@clear# Extent=[24:3 - 24:15] +// CHECK-USRS: index-templates.cpp c:@S@vector>#$@S@Z2#$@S@allocator>#S0_ Extent=[22:1 - 25:2] +// CHECK-USRS: index-templates.cpp c:@S@vector>#$@S@Z2#$@S@allocator>#S0_@F@clear# Extent=[24:3 - 24:15] // CHECK-USRS: index-templates.cpp c:@ST>2#T#T@Y Extent=[27:1 - 31:2] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@443 Extent=[27:10 - 27:20] // CHECK-USRS: index-templates.cpp c:index-templates.cpp@455 Extent=[27:22 - 27:32] // CHECK-USRS-NOT: type // CHECK-USRS: index-templates.cpp c:@S@Z3 Extent=[33:1 - 33:14] -// CHECK-USRS: index-templates.cpp c:@F@f#$@S@map>#$@S@Z4#$@S@Pair>#I#S1_#$@S@compare>#$@S@Pair>#S1_#S2_#$@C@allocator>#S4_# +// CHECK-USRS: index-templates.cpp c:@F@f#$@S@map>#$@S@Z4#$@S@Pair>#I#S1_#$@S@compare>#$@S@Pair>#S1_#S2_#$@S@allocator>#S4_# diff --git a/test/Index/overriding-ftemplate-comments.cpp b/test/Index/overriding-ftemplate-comments.cpp index 0bc3c2f0ae8e..7fc15f0b00bd 100644 --- a/test/Index/overriding-ftemplate-comments.cpp +++ b/test/Index/overriding-ftemplate-comments.cpp @@ -13,12 +13,12 @@ template<typename T> void comment_to_html_conversion_17(T AAA); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_17</Name><USR>c:@FT@>1#Tcomment_to_html_conversion_17#t0.0#</USR><Declaration>template <typename T> void comment_to_html_conversion_17(T AAA)</Declaration><Parameters><Parameter><Name>AAA</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_17</Name><USR>c:@FT@>1#Tcomment_to_html_conversion_17#t0.0#v#</USR><Declaration>template <typename T> void comment_to_html_conversion_17(T AAA)</Declaration><Parameters><Parameter><Name>AAA</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] template<typename T> void comment_to_html_conversion_17(T PPP); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_17</Name><USR>c:@FT@>1#Tcomment_to_html_conversion_17#t0.0#</USR><Declaration>template <typename T> void comment_to_html_conversion_17(T PPP)</Declaration><Parameters><Parameter><Name>PPP</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_17</Name><USR>c:@FT@>1#Tcomment_to_html_conversion_17#t0.0#v#</USR><Declaration>template <typename T> void comment_to_html_conversion_17(T PPP)</Declaration><Parameters><Parameter><Name>PPP</Name><Index>0</Index><Direction isExplicit="0">in</Direction><Discussion><Para> Blah blah</Para></Discussion></Parameter></Parameters></Function>] //===----------------------------------------------------------------------===// @@ -27,12 +27,12 @@ void comment_to_html_conversion_17(T PPP); template<typename AAA, typename BBB> void comment_to_html_conversion_19(AAA aaa, BBB bbb); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_19</Name><USR>c:@FT@>2#T#Tcomment_to_html_conversion_19#t0.0#t0.1#</USR><Declaration>template <typename AAA, typename BBB>\nvoid comment_to_html_conversion_19(AAA aaa, BBB bbb)</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_19</Name><USR>c:@FT@>2#T#Tcomment_to_html_conversion_19#t0.0#t0.1#v#</USR><Declaration>template <typename AAA, typename BBB>\nvoid comment_to_html_conversion_19(AAA aaa, BBB bbb)</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] template<typename PPP, typename QQQ> void comment_to_html_conversion_19(PPP aaa, QQQ bbb); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_19</Name><USR>c:@FT@>2#T#Tcomment_to_html_conversion_19#t0.0#t0.1#</USR><Declaration>template <typename PPP, typename QQQ>\nvoid comment_to_html_conversion_19(PPP aaa, QQQ bbb)</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_19</Name><USR>c:@FT@>2#T#Tcomment_to_html_conversion_19#t0.0#t0.1#v#</USR><Declaration>template <typename PPP, typename QQQ>\nvoid comment_to_html_conversion_19(PPP aaa, QQQ bbb)</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter></TemplateParameters></Function>] //===----------------------------------------------------------------------===// @@ -43,12 +43,12 @@ void comment_to_html_conversion_19(PPP aaa, QQQ bbb); template<typename AAA, typename BBB, int CCC> void comment_to_html_conversion_20(AAA aaa, BBB bbb); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_20</Name><USR>c:@FT@>3#T#T#NIcomment_to_html_conversion_20#t0.0#t0.1#</USR><Declaration>template <typename AAA, typename BBB, int CCC>\nvoid comment_to_html_conversion_20(AAA aaa, BBB bbb)</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>CCC</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>UUU</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_20</Name><USR>c:@FT@>3#T#T#NIcomment_to_html_conversion_20#t0.0#t0.1#v#</USR><Declaration>template <typename AAA, typename BBB, int CCC>\nvoid comment_to_html_conversion_20(AAA aaa, BBB bbb)</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>CCC</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>UUU</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] template<typename PPP, typename QQQ, int RRR> void comment_to_html_conversion_20(PPP aaa, QQQ bbb); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_20</Name><USR>c:@FT@>3#T#T#NIcomment_to_html_conversion_20#t0.0#t0.1#</USR><Declaration>template <typename PPP, typename QQQ, int RRR>\nvoid comment_to_html_conversion_20(PPP aaa, QQQ bbb)</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>RRR</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>UUU</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_20</Name><USR>c:@FT@>3#T#T#NIcomment_to_html_conversion_20#t0.0#t0.1#v#</USR><Declaration>template <typename PPP, typename QQQ, int RRR>\nvoid comment_to_html_conversion_20(PPP aaa, QQQ bbb)</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>RRR</Name><Index>2</Index><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>UUU</Name><Discussion><Para> Zzz </Para></Discussion></Parameter></TemplateParameters></Function>] //===----------------------------------------------------------------------===// @@ -59,12 +59,12 @@ void comment_to_html_conversion_20(PPP aaa, QQQ bbb); template<template<template<typename CCC> class DDD, class BBB> class AAA> void comment_to_html_conversion_21(); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_21</Name><USR>c:@FT@>1#t>2#t>1#T#Tcomment_to_html_conversion_21#</USR><Declaration>template <template <template <typename CCC> class DDD, class BBB> class AAA>\nvoid comment_to_html_conversion_21()</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>BBB</Name><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>CCC</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>DDD</Name><Discussion><Para> Ddd</Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_21</Name><USR>c:@FT@>1#t>2#t>1#T#Tcomment_to_html_conversion_21#v#</USR><Declaration>template <template <template <typename CCC> class DDD, class BBB> class AAA>\nvoid comment_to_html_conversion_21()</Declaration><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>BBB</Name><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>CCC</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>DDD</Name><Discussion><Para> Ddd</Para></Discussion></Parameter></TemplateParameters></Function>] template<template<template<typename RRR> class SSS, class QQQ> class PPP> void comment_to_html_conversion_21(); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_21</Name><USR>c:@FT@>1#t>2#t>1#T#Tcomment_to_html_conversion_21#</USR><Declaration>template <template <template <typename RRR> class SSS, class QQQ> class PPP>\nvoid comment_to_html_conversion_21()</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>RRR</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>SSS</Name><Discussion><Para> Ddd</Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_21</Name><USR>c:@FT@>1#t>2#t>1#T#Tcomment_to_html_conversion_21#v#</USR><Declaration>template <template <template <typename RRR> class SSS, class QQQ> class PPP>\nvoid comment_to_html_conversion_21()</Declaration><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> Aaa </Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Discussion><Para> Bbb </Para></Discussion></Parameter><Parameter><Name>RRR</Name><Discussion><Para> Ccc </Para></Discussion></Parameter><Parameter><Name>SSS</Name><Discussion><Para> Ddd</Para></Discussion></Parameter></TemplateParameters></Function>] //===----------------------------------------------------------------------===// @@ -77,10 +77,10 @@ void comment_to_html_conversion_21(); template <class C1, template <class C2, template <class C3, class C4> class BBB > class AAA> void comment_to_html_conversion_22(); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_22</Name><USR>c:@FT@>2#T#t>2#T#t>2#T#Tcomment_to_html_conversion_22#</USR><Declaration>template <class C1, template <class C2, template <class C3, class C4> class BBB>\n class AAA>\nvoid comment_to_html_conversion_22()</Declaration><TemplateParameters><Parameter><Name>C1</Name><Index>0</Index><Discussion><Para> Ccc 1 </Para></Discussion></Parameter><Parameter><Name>AAA</Name><Index>1</Index><Discussion><Para> Zzz </Para></Discussion></Parameter><Parameter><Name>C2</Name><Discussion><Para> Ccc 2 </Para></Discussion></Parameter><Parameter><Name>C3</Name><Discussion><Para> Ccc 3 </Para></Discussion></Parameter><Parameter><Name>C4</Name><Discussion><Para> Ccc 4 </Para></Discussion></Parameter><Parameter><Name>BBB</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_22</Name><USR>c:@FT@>2#T#t>2#T#t>2#T#Tcomment_to_html_conversion_22#v#</USR><Declaration>template <class C1, template <class C2, template <class C3, class C4> class BBB>\n class AAA>\nvoid comment_to_html_conversion_22()</Declaration><TemplateParameters><Parameter><Name>C1</Name><Index>0</Index><Discussion><Para> Ccc 1 </Para></Discussion></Parameter><Parameter><Name>AAA</Name><Index>1</Index><Discussion><Para> Zzz </Para></Discussion></Parameter><Parameter><Name>C2</Name><Discussion><Para> Ccc 2 </Para></Discussion></Parameter><Parameter><Name>C3</Name><Discussion><Para> Ccc 3 </Para></Discussion></Parameter><Parameter><Name>C4</Name><Discussion><Para> Ccc 4 </Para></Discussion></Parameter><Parameter><Name>BBB</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] template<class CCC1, template<class CCC2, template<class CCC3, class CCC4> class QQQ> class PPP> void comment_to_html_conversion_22(); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_22</Name><USR>c:@FT@>2#T#t>2#T#t>2#T#Tcomment_to_html_conversion_22#</USR><Declaration>template <class CCC1, template <class CCC2, template <class CCC3, class CCC4>\n class QQQ> class PPP>\nvoid comment_to_html_conversion_22()</Declaration><TemplateParameters><Parameter><Name>CCC1</Name><Index>0</Index><Discussion><Para> Ccc 1 </Para></Discussion></Parameter><Parameter><Name>PPP</Name><Index>1</Index><Discussion><Para> Zzz </Para></Discussion></Parameter><Parameter><Name>CCC2</Name><Discussion><Para> Ccc 2 </Para></Discussion></Parameter><Parameter><Name>CCC3</Name><Discussion><Para> Ccc 3 </Para></Discussion></Parameter><Parameter><Name>CCC4</Name><Discussion><Para> Ccc 4 </Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-ftemplate-comments.cpp" line="[[@LINE-2]]" column="6"><Name>comment_to_html_conversion_22</Name><USR>c:@FT@>2#T#t>2#T#t>2#T#Tcomment_to_html_conversion_22#v#</USR><Declaration>template <class CCC1, template <class CCC2, template <class CCC3, class CCC4>\n class QQQ> class PPP>\nvoid comment_to_html_conversion_22()</Declaration><TemplateParameters><Parameter><Name>CCC1</Name><Index>0</Index><Discussion><Para> Ccc 1 </Para></Discussion></Parameter><Parameter><Name>PPP</Name><Index>1</Index><Discussion><Para> Zzz </Para></Discussion></Parameter><Parameter><Name>CCC2</Name><Discussion><Para> Ccc 2 </Para></Discussion></Parameter><Parameter><Name>CCC3</Name><Discussion><Para> Ccc 3 </Para></Discussion></Parameter><Parameter><Name>CCC4</Name><Discussion><Para> Ccc 4 </Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Discussion><Para> Bbb</Para></Discussion></Parameter></TemplateParameters></Function>] diff --git a/test/Index/overriding-method-comments.mm b/test/Index/overriding-method-comments.mm index 9285693396e0..d995e0eca782 100644 --- a/test/Index/overriding-method-comments.mm +++ b/test/Index/overriding-method-comments.mm @@ -116,10 +116,10 @@ void foo1(int TTT); template<typename AAA, typename BBB> void foo(AAA, BBB); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-method-comments.mm" line="[[@LINE-2]]" column="6"><Name>foo</Name><USR>c:@FT@>2#T#Tfoo#t0.0#t0.1#</USR><Declaration>template <typename AAA, typename BBB> void foo(AAA, BBB)</Declaration><Abstract><Para> Documentation </Para></Abstract><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> The type, silly as well.</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> The type, silly. </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-method-comments.mm" line="[[@LINE-2]]" column="6"><Name>foo</Name><USR>c:@FT@>2#T#Tfoo#t0.0#t0.1#v#</USR><Declaration>template <typename AAA, typename BBB> void foo(AAA, BBB)</Declaration><Abstract><Para> Documentation </Para></Abstract><TemplateParameters><Parameter><Name>AAA</Name><Index>0</Index><Discussion><Para> The type, silly as well.</Para></Discussion></Parameter><Parameter><Name>BBB</Name><Index>1</Index><Discussion><Para> The type, silly. </Para></Discussion></Parameter></TemplateParameters></Function>] template<typename PPP, typename QQQ> void foo(PPP, QQQ); -// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-method-comments.mm" line="[[@LINE-2]]" column="6"><Name>foo</Name><USR>c:@FT@>2#T#Tfoo#t0.0#t0.1#</USR><Declaration>template <typename PPP, typename QQQ> void foo(PPP, QQQ)</Declaration><Abstract><Para> Documentation </Para></Abstract><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> The type, silly as well.</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> The type, silly. </Para></Discussion></Parameter></TemplateParameters></Function>] +// CHECK: FullCommentAsXML=[<Function templateKind="template" file="{{[^"]+}}overriding-method-comments.mm" line="[[@LINE-2]]" column="6"><Name>foo</Name><USR>c:@FT@>2#T#Tfoo#t0.0#t0.1#v#</USR><Declaration>template <typename PPP, typename QQQ> void foo(PPP, QQQ)</Declaration><Abstract><Para> Documentation </Para></Abstract><TemplateParameters><Parameter><Name>PPP</Name><Index>0</Index><Discussion><Para> The type, silly as well.</Para></Discussion></Parameter><Parameter><Name>QQQ</Name><Index>1</Index><Discussion><Para> The type, silly. </Para></Discussion></Parameter></TemplateParameters></Function>] diff --git a/test/Index/preamble_macro_template.cpp b/test/Index/preamble_macro_template.cpp index 20f16b5df2eb..0771caba2377 100644 --- a/test/Index/preamble_macro_template.cpp +++ b/test/Index/preamble_macro_template.cpp @@ -4,7 +4,7 @@ int main() { } // RUN: c-index-test -write-pch %t.pch -fno-delayed-template-parsing -x c++-header %S/Inputs/preamble_macro_template.h // RUN: env CINDEXTEST_EDITING=1 c-index-test -test-load-source-reparse 5 local -fno-delayed-template-parsing -I %S/Inputs -include %t %s 2>&1 | tee %t.check.txt | FileCheck %s -// CHECK: preamble_macro_template.h:4:6: FunctionDecl=foo:4:6 (Definition) [Specialization of foo:4:6] Extent=[4:1 - 6:2] +// CHECK: preamble_macro_template.h:4:6: FunctionDecl=foo:4:6 (Definition) [Specialization of foo:4:6] [Template arg 0: kind: 1, type: int] Extent=[4:1 - 6:2] // CHECK: preamble_macro_template.h:4:13: ParmDecl=p:4:13 (Definition) Extent=[4:10 - 4:14] // CHECK: preamble_macro_template.h:4:16: CompoundStmt= Extent=[4:16 - 6:2] // CHECK: preamble_macro_template.h:5:3: CStyleCastExpr= Extent=[5:3 - 5:27] diff --git a/test/Index/print-mangled-name.cpp b/test/Index/print-mangled-name.cpp new file mode 100644 index 000000000000..b7e79c3f6d65 --- /dev/null +++ b/test/Index/print-mangled-name.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-pch %s -o %t_linux.ast +// RUN: c-index-test -test-print-mangle %t_linux.ast | FileCheck %s --check-prefix=ITANIUM + +// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-pch %s -o %t_macho.ast +// RUN: c-index-test -test-print-mangle %t_macho.ast | FileCheck %s --check-prefix=MACHO + +// RUN: %clang_cc1 -triple i686-pc-win32 -emit-pch %s -o %t_msft.ast +// RUN: c-index-test -test-print-mangle %t_msft.ast | FileCheck %s --check-prefix=MICROSOFT + +int foo(int, int); +// ITANIUM: mangled=_Z3fooii +// MACHO: mangled=__Z3fooii +// MICROSOFT: mangled=?foo@@YAHHH + +int foo(float, int); +// ITANIUM: mangled=_Z3foofi +// MACHO: mangled=__Z3foofi +// MICROSOFT: mangled=?foo@@YAHMH + +struct S { + int x, y; +}; +// ITANIUM: StructDecl{{.*}}mangled=] +// MACHO: StructDecl{{.*}}mangled=] +// MICROSOFT: StructDecl{{.*}}mangled=] + +int foo(S, S&); +// ITANIUM: mangled=_Z3foo1SRS_ +// MACHO: mangled=__Z3foo1SRS_ +// MICROSOFT: mangled=?foo@@YAHUS diff --git a/test/Index/reparse-predef-objc-protocol.m b/test/Index/reparse-predef-objc-protocol.m new file mode 100644 index 000000000000..fc9d8572e0c1 --- /dev/null +++ b/test/Index/reparse-predef-objc-protocol.m @@ -0,0 +1,9 @@ +// RUN: env CINDEXTEST_EDITING=1 c-index-test -test-load-source-reparse 3 local %s -I %S/Inputs +#import "declare-objc-predef.h" +// PR20633 + +// CHECK: declare-objc-predef.h:1:8: ObjCInterfaceDecl=Protocol:1:8 Extent=[1:1 - 1:16] +// CHECK: declare-objc-predef.h:1:8: ObjCClassRef=Protocol:1:8 Extent=[1:8 - 1:16] +// CHECK: declare-objc-predef.h:2:16: StructDecl=objc_class:2:16 Extent=[2:9 - 2:26] +// CHECK: declare-objc-predef.h:2:28: TypedefDecl=Class:2:28 (Definition) Extent=[2:1 - 2:33] +// CHECK: declare-objc-predef.h:2:16: TypeRef=struct objc_class:2:16 Extent=[2:16 - 2:26] diff --git a/test/Index/skip-parsed-bodies/compile_commands.json b/test/Index/skip-parsed-bodies/compile_commands.json index da5e777d8181..6707e84d2642 100644 --- a/test/Index/skip-parsed-bodies/compile_commands.json +++ b/test/Index/skip-parsed-bodies/compile_commands.json @@ -16,7 +16,7 @@ } ] -// XFAIL: mingw32,win32 +// XFAIL: mingw32,win32,windows-gnu // RUN: c-index-test -index-compile-db %s | FileCheck %s // CHECK: [enteredMainFile]: t1.cpp diff --git a/test/Index/usrs-cxx0x.cpp b/test/Index/usrs-cxx0x.cpp index a48b4467b731..b40bc4c12c7b 100644 --- a/test/Index/usrs-cxx0x.cpp +++ b/test/Index/usrs-cxx0x.cpp @@ -3,6 +3,16 @@ struct tuple { }; void f(tuple<int, float, double>); +class TestCls { + void meth() &; + void meth() &&; + void meth(int&&); +}; + // RUN: c-index-test -test-load-source-usrs all -std=c++11 %s | FileCheck %s // CHECK: usrs-cxx0x.cpp c:@ST>1#pT@tuple Extent=[1:1 - 2:17] // CHECK: usrs-cxx0x.cpp c:@F@f#$@S@tuple>#p3Ifd# Extent=[4:1 - 4:34] + +// CHECK: usrs-cxx0x.cpp c:@S@TestCls@F@meth#& Extent=[7:3 - 7:16] +// CHECK: usrs-cxx0x.cpp c:@S@TestCls@F@meth#&& Extent=[8:3 - 8:17] +// CHECK: usrs-cxx0x.cpp c:@S@TestCls@F@meth#&&I# Extent=[9:3 - 9:19] diff --git a/test/Index/usrs.cpp b/test/Index/usrs.cpp index 909ce75922a9..8ad17021b50d 100644 --- a/test/Index/usrs.cpp +++ b/test/Index/usrs.cpp @@ -79,7 +79,23 @@ void rdar9371763() { foo.bar(); } -// RUN: c-index-test -test-load-source-usrs all %s | FileCheck %s +template <class T> typename T::A someTemplFn() {} +template <class T> typename T::B someTemplFn() {} +template <class T> int someTemplFn() {} + +void funWithChar(char c) {} +void funWithChar(unsigned char c) {} +void funWithChar(signed char c) {} + +struct { int x; } embedS1; +struct { int x; } embedS2; + +template <typename T> +class TC1 { + void meth(TC1); +}; + +// RUN: c-index-test -test-load-source-usrs all -fno-delayed-template-parsing %s | FileCheck %s // CHECK: usrs.cpp c:@N@foo Extent=[1:1 - 4:2] // CHECK: usrs.cpp c:@N@foo@x Extent=[2:3 - 2:8] // CHECK: usrs.cpp c:@N@foo@F@bar#I# Extent=[3:3 - 3:18] @@ -88,20 +104,20 @@ void rdar9371763() { // CHECK: usrs.cpp c:usrs.cpp@N@bar@T@QType Extent=[6:3 - 6:20] // CHECK: usrs.cpp c:@N@bar@F@bar#I# Extent=[7:3 - 7:20] // CHECK: usrs.cpp c:usrs.cpp@94@N@bar@F@bar#I#@z Extent=[7:12 - 7:19] -// CHECK: usrs.cpp c:@C@ClsA Extent=[10:1 - 14:2] +// CHECK: usrs.cpp c:@S@ClsA Extent=[10:1 - 14:2] // CHECK: usrs.cpp c: Extent=[11:1 - 11:8] -// CHECK: usrs.cpp c:@C@ClsA@FI@a Extent=[12:3 - 12:8] -// CHECK: usrs.cpp c:@C@ClsA@FI@b Extent=[12:3 - 12:11] -// CHECK: usrs.cpp c:@C@ClsA@F@ClsA#I#I# Extent=[13:3 - 13:37] -// CHECK: usrs.cpp c:usrs.cpp@147@C@ClsA@F@ClsA#I#I#@A Extent=[13:8 - 13:13] -// CHECK: usrs.cpp c:usrs.cpp@154@C@ClsA@F@ClsA#I#I#@B Extent=[13:15 - 13:20] +// CHECK: usrs.cpp c:@S@ClsA@FI@a Extent=[12:3 - 12:8] +// CHECK: usrs.cpp c:@S@ClsA@FI@b Extent=[12:3 - 12:11] +// CHECK: usrs.cpp c:@S@ClsA@F@ClsA#I#I# Extent=[13:3 - 13:37] +// CHECK: usrs.cpp c:usrs.cpp@147@S@ClsA@F@ClsA#I#I#@A Extent=[13:8 - 13:13] +// CHECK: usrs.cpp c:usrs.cpp@154@S@ClsA@F@ClsA#I#I#@B Extent=[13:15 - 13:20] // CHECK: usrs.cpp c:@N@foo Extent=[16:1 - 22:2] -// CHECK: usrs.cpp c:@N@foo@C@ClsB Extent=[17:3 - 21:4] +// CHECK: usrs.cpp c:@N@foo@S@ClsB Extent=[17:3 - 21:4] // CHECK: usrs.cpp c: Extent=[18:3 - 18:10] -// CHECK: usrs.cpp c:@N@foo@C@ClsB@F@ClsB# Extent=[19:5 - 19:27] -// CHECK: usrs.cpp c:@N@foo@C@ClsB@F@result#1 Extent=[20:5 - 20:23] -// CHECK: usrs.cpp c:@N@foo@C@ClsB@F@result#1 Extent=[24:1 - 26:2] -// CHECK: usrs.cpp c:usrs.cpp@aN@C@ClsC Extent=[29:3 - 29:35] +// CHECK: usrs.cpp c:@N@foo@S@ClsB@F@ClsB# Extent=[19:5 - 19:27] +// CHECK: usrs.cpp c:@N@foo@S@ClsB@F@result#1 Extent=[20:5 - 20:23] +// CHECK: usrs.cpp c:@N@foo@S@ClsB@F@result#1 Extent=[24:1 - 26:2] +// CHECK: usrs.cpp c:usrs.cpp@aN@S@ClsC Extent=[29:3 - 29:35] // CHECK: usrs.cpp c:usrs.cpp@aN@w Extent=[30:3 - 30:8] // CHECK: usrs.cpp c:@z Extent=[33:1 - 33:6] // CHECK: usrs.cpp c:@N@foo Extent=[35:1 - 40:2] @@ -115,19 +131,19 @@ void rdar9371763() { // CHECK: usrs.cpp c:usrs.cpp@529@N@foo@N@taz@F@sub#I#I#@b Extent=[38:19 - 38:24] // CHECK: usrs.cpp c:@N@foo Extent=[42:1 - 52:3] // CHECK: usrs.cpp c:@N@foo@N@taz Extent=[42:17 - 52:2] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD Extent=[43:3 - 51:4] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD Extent=[43:3 - 51:4] // CHECK: usrs.cpp c: Extent=[44:3 - 44:10] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@operator=#I# Extent=[45:5 - 45:52] -// CHECK: usrs.cpp c:usrs.cpp@638@N@foo@N@taz@C@ClsD@F@operator=#I#@x Extent=[45:21 - 45:26] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@operator=#d# Extent=[46:5 - 46:61] -// CHECK: usrs.cpp c:usrs.cpp@690@N@foo@N@taz@C@ClsD@F@operator=#d#@x Extent=[46:21 - 46:29] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@operator=#&1$@N@foo@N@taz@C@ClsD# Extent=[47:5 - 47:62] -// CHECK: usrs.cpp c:usrs.cpp@751@N@foo@N@taz@C@ClsD@F@operator=#&1$@N@foo@N@taz@C@ClsD#@x Extent=[47:21 - 47:34] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@qux#S Extent=[48:5 - 48:21] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@uz#I.#S Extent=[49:5 - 49:30] -// CHECK: usrs.cpp c:usrs.cpp@833@N@foo@N@taz@C@ClsD@F@uz#I.#S@z Extent=[49:19 - 49:24] -// CHECK: usrs.cpp c:@N@foo@N@taz@C@ClsD@F@operator==#&1$@N@foo@N@taz@C@ClsD#1 Extent=[50:5 - 50:62] -// CHECK: usrs.cpp c:usrs.cpp@866@N@foo@N@taz@C@ClsD@F@operator==#&1$@N@foo@N@taz@C@ClsD#1@x Extent=[50:21 - 50:34] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@operator=#I# Extent=[45:5 - 45:52] +// CHECK: usrs.cpp c:usrs.cpp@638@N@foo@N@taz@S@ClsD@F@operator=#I#@x Extent=[45:21 - 45:26] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@operator=#d# Extent=[46:5 - 46:61] +// CHECK: usrs.cpp c:usrs.cpp@690@N@foo@N@taz@S@ClsD@F@operator=#d#@x Extent=[46:21 - 46:29] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@operator=#&1$@N@foo@N@taz@S@ClsD# Extent=[47:5 - 47:62] +// CHECK: usrs.cpp c:usrs.cpp@751@N@foo@N@taz@S@ClsD@F@operator=#&1$@N@foo@N@taz@S@ClsD#@x Extent=[47:21 - 47:34] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@qux#S Extent=[48:5 - 48:21] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@uz#I.#S Extent=[49:5 - 49:30] +// CHECK: usrs.cpp c:usrs.cpp@833@N@foo@N@taz@S@ClsD@F@uz#I.#S@z Extent=[49:19 - 49:24] +// CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@operator==#&1$@N@foo@N@taz@S@ClsD#1 Extent=[50:5 - 50:62] +// CHECK: usrs.cpp c:usrs.cpp@866@N@foo@N@taz@S@ClsD@F@operator==#&1$@N@foo@N@taz@S@ClsD#1@x Extent=[50:21 - 50:34] // CHECK: usrs.cpp c:@F@rez Extent=[55:3 - 55:25] // CHECK: usrs.cpp c:usrs.cpp@941@F@rez@a Extent=[55:12 - 55:17] // CHECK: usrs.cpp c:usrs.cpp@948@F@rez@b Extent=[55:19 - 55:24] @@ -137,10 +153,22 @@ void rdar9371763() { // CHECK-NOT: ClsB // CHECK: usrs.cpp c:@NA@foo_alias3 // CHECK: usrs.cpp c:@aN Extent=[68:1 - 73:2] -// CHECK: usrs.cpp c:usrs.cpp@aN@C@RDar9371763_Foo Extent=[69:1 - 72:2] +// CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo Extent=[69:1 - 72:2] // CHECK: usrs.cpp c: Extent=[70:1 - 70:8] -// CHECK: usrs.cpp c:usrs.cpp@aN@C@RDar9371763_Foo@F@bar# Extent=[71:3 - 71:13] -// CHECK: usrs.cpp c:usrs.cpp@aN@C@RDar9371763_Foo@F@bar# Extent=[75:1 - 75:31] +// CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo@F@bar# Extent=[71:3 - 71:13] +// CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo@F@bar# Extent=[75:1 - 75:31] // CHECK: usrs.cpp c:@F@rdar9371763# Extent=[77:1 - 80:2] // CHECK: usrs.cpp c:usrs.cpp@1204@F@rdar9371763#@foo Extent=[78:3 - 78:22] +// CHECK: usrs.cpp c:@FT@>1#TsomeTemplFn#^type-parameter-0-0:::A# Extent=[82:1 - 82:50] +// CHECK: usrs.cpp c:@FT@>1#TsomeTemplFn#^type-parameter-0-0:::B# Extent=[83:1 - 83:50] +// CHECK: usrs.cpp c:@FT@>1#TsomeTemplFn#I# Extent=[84:1 - 84:40] + +// CHECK: usrs.cpp c:@F@funWithChar#C# Extent=[86:1 - 86:28] +// CHECK: usrs.cpp c:@F@funWithChar#c# Extent=[87:1 - 87:37] +// CHECK: usrs.cpp c:@F@funWithChar#r# Extent=[88:1 - 88:35] + +// CHECK: usrs.cpp c:usrs.cpp@S@usrs.cpp@1483@FI@x Extent=[90:10 - 90:15] +// CHECK: usrs.cpp c:usrs.cpp@S@usrs.cpp@1510@FI@x Extent=[91:10 - 91:15] + +// CHECK: usrs.cpp c:@ST>1#T@TC1@F@meth#>@ST>1#T@TC11t0.0# Extent=[95:3 - 95:17] diff --git a/test/Layout/itanium-union-bitfield.cpp b/test/Layout/itanium-union-bitfield.cpp new file mode 100644 index 000000000000..b06fd36071e9 --- /dev/null +++ b/test/Layout/itanium-union-bitfield.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -emit-llvm-only -triple %itanium_abi_triple -fdump-record-layouts %s 2>/dev/null \ +// RUN: | FileCheck %s + +union A { + int f1: 3; + A(); +}; + +A::A() {} + +union B { + char f1: 35; + B(); +}; + +B::B() {} + +// CHECK:*** Dumping AST Record Layout +// CHECK-NEXT: 0 | union A +// CHECK-NEXT: 0 | int f1 +// CHECK-NEXT: | [sizeof=4, dsize=1, align=4 +// CHECK-NEXT: | nvsize=1, nvalign=4] + +// CHECK:*** Dumping AST Record Layout +// CHECK-NEXT: 0 | union B +// CHECK-NEXT: 0 | char f1 +// CHECK-NEXT: | [sizeof=8, dsize=5, align=4 +// CHECK-NEXT: | nvsize=5, nvalign=4] + diff --git a/test/Layout/ms-x86-basic-layout.cpp b/test/Layout/ms-x86-basic-layout.cpp index b6ffeee7114a..aac7aed06019 100644 --- a/test/Layout/ms-x86-basic-layout.cpp +++ b/test/Layout/ms-x86-basic-layout.cpp @@ -816,6 +816,36 @@ struct RecordArrayTypedef { // CHECK-X64-NEXT: | [sizeof=16, align=4 // CHECK-X64-NEXT: | nvsize=16, nvalign=4] +struct EmptyIntMemb { + int FlexArrayMemb[0]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct EmptyIntMemb +// CHECK-NEXT: 0 | int [0] FlexArrayMemb +// CHECK-NEXT: | [sizeof=1, align=4 +// CHECK-NEXT: | nvsize=0, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct EmptyIntMemb +// CHECK-X64-NEXT: 0 | int [0] FlexArrayMemb +// CHECK-X64-NEXT: | [sizeof=4, align=4 +// CHECK-X64-NEXT: | nvsize=0, nvalign=4] + +struct EmptyLongLongMemb { + long long FlexArrayMemb[0]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct EmptyLongLongMemb +// CHECK-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-NEXT: | [sizeof=1, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct EmptyLongLongMemb +// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-X64-NEXT: | [sizeof=8, align=8 +// CHECK-X64-NEXT: | nvsize=0, nvalign=8] + int a[ sizeof(TestF0)+ sizeof(TestF1)+ @@ -840,4 +870,6 @@ sizeof(F6)+ sizeof(ArrayFieldOfRecords)+ sizeof(ArrayOfArrayFieldOfRecords)+ sizeof(RecordArrayTypedef)+ +sizeof(EmptyIntMemb)+ +sizeof(EmptyLongLongMemb)+ 0]; diff --git a/test/Layout/ms-x86-empty-layout.c b/test/Layout/ms-x86-empty-layout.c new file mode 100644 index 000000000000..faca0be0a9c0 --- /dev/null +++ b/test/Layout/ms-x86-empty-layout.c @@ -0,0 +1,88 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ +// RUN: | FileCheck %s +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \ +// RUN: | FileCheck %s + +struct EmptyIntMemb { + int FlexArrayMemb[0]; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyIntMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:32 +// CHECK: Alignment:32 +// CHECK: FieldOffsets: [0]> + +struct EmptyLongLongMemb { + long long FlexArrayMemb[0]; +}; +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyLongLongMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:32 +// CHECK: Alignment:64 +// CHECK: FieldOffsets: [0]> + +struct EmptyAligned2LongLongMemb { + long long __declspec(align(2)) FlexArrayMemb[0]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyAligned2LongLongMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:32 +// CHECK: Alignment:64 +// CHECK: FieldOffsets: [0]> + +struct EmptyAligned8LongLongMemb { + long long __declspec(align(8)) FlexArrayMemb[0]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyAligned8LongLongMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:64 +// CHECK: Alignment:64 +// CHECK: FieldOffsets: [0]> + +#pragma pack(1) +struct __declspec(align(4)) EmptyPackedAligned4LongLongMemb { + long long FlexArrayMemb[0]; +}; +#pragma pack() + +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyPackedAligned4LongLongMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:32 +// CHECK: Alignment:32 +// CHECK: FieldOffsets: [0]> + +#pragma pack(1) +struct EmptyPackedAligned8LongLongMemb { + long long __declspec(align(8)) FlexArrayMemb[0]; +}; +#pragma pack() + +// CHECK: *** Dumping AST Record Layout +// CHECK: Type: struct EmptyPackedAligned8LongLongMemb +// CHECK: Record: +// CHECK: Layout: <ASTRecordLayout +// CHECK: Size:64 +// CHECK: Alignment:64 +// CHECK: FieldOffsets: [0]> + + +int a[ +sizeof(struct EmptyIntMemb)+ +sizeof(struct EmptyLongLongMemb)+ +sizeof(struct EmptyAligned2LongLongMemb)+ +sizeof(struct EmptyAligned8LongLongMemb)+ +sizeof(struct EmptyPackedAligned4LongLongMemb)+ +sizeof(struct EmptyPackedAligned8LongLongMemb)+ +0]; diff --git a/test/Layout/ms-x86-pack-and-align.cpp b/test/Layout/ms-x86-pack-and-align.cpp index 5e1aae1ca757..9783233d66ac 100644 --- a/test/Layout/ms-x86-pack-and-align.cpp +++ b/test/Layout/ms-x86-pack-and-align.cpp @@ -652,7 +652,154 @@ struct OD : OC {}; // CHECK-X64-NEXT: | [sizeof=12, align=1 // CHECK-X64-NEXT: | nvsize=8, nvalign=1] +struct __declspec(align(4)) PA { + int c; +}; + +typedef __declspec(align(8)) PA PB; +#pragma pack(push, 1) +struct PC { + char a; + PB x; +}; +#pragma pack(pop) + +// CHECK: *** Dumping AST Record Layout +// CHECK: 0 | struct PC +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | struct PA x +// CHECK-NEXT: 8 | int c +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-NEXT: | [sizeof=16, align=8 +// CHECK-NEXT: | nvsize=12, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: 0 | struct PC +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 8 | struct PA x +// CHECK-X64-NEXT: 8 | int c +// CHECK-X64-NEXT: | [sizeof=4, align=4 +// CHECK-X64-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=12, nvalign=8] + +typedef PB PD; + +#pragma pack(push, 1) +struct PE { + char a; + PD x; +}; +#pragma pack(pop) + +// CHECK: *** Dumping AST Record Layout +// CHECK: 0 | struct PE +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 8 | struct PA x +// CHECK-NEXT: 8 | int c +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-NEXT: | [sizeof=16, align=8 +// CHECK-NEXT: | nvsize=12, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: 0 | struct PE +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 8 | struct PA x +// CHECK-X64-NEXT: 8 | int c +// CHECK-X64-NEXT: | [sizeof=4, align=4 +// CHECK-X64-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=12, nvalign=8] + +typedef int __declspec(align(2)) QA; +#pragma pack(push, 1) +struct QB { + char a; + QA b; +}; +#pragma pack(pop) + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct QB +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 2 | QA b +// CHECK-NEXT: | [sizeof=6, align=2 +// CHECK-NEXT: | nvsize=6, nvalign=2] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct QB +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 2 | QA b +// CHECK-X64-NEXT: | [sizeof=6, align=2 +// CHECK-X64-NEXT: | nvsize=6, nvalign=2] + +struct QC { + char a; + QA b; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct QC +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 4 | QA b +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct QC +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 4 | QA b +// CHECK-X64-NEXT: | [sizeof=8, align=4 +// CHECK-X64-NEXT: | nvsize=8, nvalign=4] + +struct QD { + char a; + QA b : 3; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct QD +// CHECK-NEXT: 0 | char a +// CHECK-NEXT: 4 | QA b +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=8, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct QD +// CHECK-X64-NEXT: 0 | char a +// CHECK-X64-NEXT: 4 | QA b +// CHECK-X64-NEXT: | [sizeof=8, align=4 +// CHECK-X64-NEXT: | nvsize=8, nvalign=4] + +struct __declspec(align(4)) EmptyAlignedLongLongMemb { + long long FlexArrayMemb[0]; +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct EmptyAlignedLongLongMemb +// CHECK-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-NEXT: | [sizeof=8, align=8 +// CHECK-NEXT: | nvsize=0, nvalign=8] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct EmptyAlignedLongLongMemb +// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-X64-NEXT: | [sizeof=8, align=8 +// CHECK-X64-NEXT: | nvsize=0, nvalign=8] + +#pragma pack(1) +struct __declspec(align(4)) EmptyPackedAlignedLongLongMemb { + long long FlexArrayMemb[0]; +}; +#pragma pack() + +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct EmptyPackedAlignedLongLongMemb +// CHECK-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-NEXT: | [sizeof=4, align=4 +// CHECK-NEXT: | nvsize=0, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct EmptyPackedAlignedLongLongMemb +// CHECK-X64-NEXT: 0 | long long [0] FlexArrayMemb +// CHECK-X64-NEXT: | [sizeof=4, align=4 +// CHECK-X64-NEXT: | nvsize=0, nvalign=4] int a[ sizeof(X)+ @@ -680,4 +827,11 @@ sizeof(RC)+ sizeof(RE)+ sizeof(ND)+ sizeof(OD)+ +sizeof(PC)+ +sizeof(PE)+ +sizeof(QB)+ +sizeof(QC)+ +sizeof(QD)+ +sizeof(EmptyAlignedLongLongMemb)+ +sizeof(EmptyPackedAlignedLongLongMemb)+ 0]; diff --git a/test/Layout/ms-x86-vtordisp.cpp b/test/Layout/ms-x86-vtordisp.cpp index 60779fb1975b..1b78d9fe8435 100644 --- a/test/Layout/ms-x86-vtordisp.cpp +++ b/test/Layout/ms-x86-vtordisp.cpp @@ -416,6 +416,31 @@ struct HC : virtual HB {}; // CHECK-X64-NEXT: | [sizeof=32, align=8 // CHECK-X64-NEXT: | nvsize=8, nvalign=8] +struct IA { + virtual void f(); +}; +struct __declspec(dllexport) IB : virtual IA { + virtual void f() = 0; + IB() {} +}; + +// CHECK: *** Dumping AST Record Layout +// CHECK: *** Dumping AST Record Layout +// CHECK-NEXT: 0 | struct IB +// CHECK-NEXT: 0 | (IB vbtable pointer) +// CHECK-NEXT: 4 | struct IA (virtual base) +// CHECK-NEXT: 4 | (IA vftable pointer) +// CHECK-NEXT: | [sizeof=8, align=4 +// CHECK-NEXT: | nvsize=4, nvalign=4] +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64: *** Dumping AST Record Layout +// CHECK-X64-NEXT: 0 | struct IB +// CHECK-X64-NEXT: 0 | (IB vbtable pointer) +// CHECK-X64-NEXT: 8 | struct IA (virtual base) +// CHECK-X64-NEXT: 8 | (IA vftable pointer) +// CHECK-X64-NEXT: | [sizeof=16, align=8 +// CHECK-X64-NEXT: | nvsize=8, nvalign=8] + int a[ sizeof(A)+ sizeof(C)+ @@ -428,4 +453,5 @@ sizeof(pragma_test3::C)+ sizeof(pragma_test4::C)+ sizeof(GD)+ sizeof(HC)+ +sizeof(IB)+ 0]; diff --git a/test/Lexer/bcpl-escaped-newline.c b/test/Lexer/bcpl-escaped-newline.c index 05d4773b87eb..0883173b224f 100644 --- a/test/Lexer/bcpl-escaped-newline.c +++ b/test/Lexer/bcpl-escaped-newline.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -Eonly -trigraphs %s +// RUN: %clang_cc1 -Eonly -ftrigraphs %s // RUN: %clang_cc1 -Eonly -verify %s //\ diff --git a/test/Lexer/block_cmt_end.c b/test/Lexer/block_cmt_end.c index f54b6a4a21a8..1d00137644c3 100644 --- a/test/Lexer/block_cmt_end.c +++ b/test/Lexer/block_cmt_end.c @@ -1,9 +1,9 @@ /* - RUN: %clang_cc1 -E -trigraphs %s | grep bar - RUN: %clang_cc1 -E -trigraphs %s | grep foo - RUN: %clang_cc1 -E -trigraphs %s | not grep qux - RUN: %clang_cc1 -E -trigraphs %s | not grep xyz - RUN: %clang_cc1 -fsyntax-only -trigraphs -verify %s + RUN: %clang_cc1 -E -ftrigraphs %s | grep bar + RUN: %clang_cc1 -E -ftrigraphs %s | grep foo + RUN: %clang_cc1 -E -ftrigraphs %s | not grep qux + RUN: %clang_cc1 -E -ftrigraphs %s | not grep xyz + RUN: %clang_cc1 -fsyntax-only -ftrigraphs -verify %s */ // This is a simple comment, /*/ does not end a comment, the trailing */ does. diff --git a/test/Lexer/constants.c b/test/Lexer/constants.c index f0cd4d7cf29c..9c84ddc01929 100644 --- a/test/Lexer/constants.c +++ b/test/Lexer/constants.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -trigraphs %s +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -ftrigraphs %s int x = 000000080; // expected-error {{invalid digit}} @@ -15,9 +15,9 @@ float Y = 08.123456; #endif #if -01000000000000000000000 // should not warn. #endif -#if 9223372036854775808 // expected-warning {{integer constant is larger than the largest signed integer type}} +#if 9223372036854775808 // expected-warning {{integer literal is too large to be represented in a signed integer type, interpreting as unsigned}} #endif -#if 0x10000000000000000 // expected-error {{integer constant is larger than the largest unsigned integer type}} +#if 0x10000000000000000 // expected-error {{integer literal is too large to be represented in any integer type}} #endif int c[] = { diff --git a/test/Lexer/cxx-features.cpp b/test/Lexer/cxx-features.cpp index 1202ecb18349..670a105aa40c 100644 --- a/test/Lexer/cxx-features.cpp +++ b/test/Lexer/cxx-features.cpp @@ -16,6 +16,10 @@ #error "wrong value for __cpp_binary_literals" #endif +#if check(digit_separators, 0, 0, 201309) +#error "wrong value for __cpp_digit_separators" +#endif + #if check(init_captures, 0, 0, 201304) #error "wrong value for __cpp_init_captures" #endif @@ -24,6 +28,10 @@ #error "wrong value for __cpp_generic_lambdas" #endif +#if check(sized_deallocation, 0, 0, 201309) +#error "wrong value for __cpp_sized_deallocation" +#endif + #if check(constexpr, 0, 200704, 201304) #error "wrong value for __cpp_constexpr" #endif @@ -68,6 +76,10 @@ #error "wrong value for __cpp_lambdas" #endif +#if check(range_based_for, 0, 200907, 200907) +#error "wrong value for __cpp_range_based_for" +#endif + #if check(static_assert, 0, 200410, 200410) #error "wrong value for __cpp_static_assert" #endif @@ -87,3 +99,27 @@ #if check(variadic_templates, 0, 200704, 200704) #error "wrong value for __cpp_variadic_templates" #endif + +#if check(initializer_lists, 0, 200806, 200806) +#error "wrong value for __cpp_initializer_lists" +#endif + +#if check(delegating_constructors, 0, 200604, 200604) +#error "wrong value for __cpp_delegating_constructors" +#endif + +#if check(nsdmi, 0, 200809, 200809) +#error "wrong value for __cpp_nsdmi" +#endif + +#if check(inheriting_constructors, 0, 200802, 200802) +#error "wrong value for __cpp_inheriting_constructors" +#endif + +#if check(ref_qualifiers, 0, 200710, 200710) +#error "wrong value for __cpp_ref_qualifiers" +#endif + +#if check(alias_templates, 0, 200704, 200704) +#error "wrong value for __cpp_alias_templates" +#endif diff --git a/test/Lexer/cxx1z-trigraphs.cpp b/test/Lexer/cxx1z-trigraphs.cpp index 410626fd7bb8..0ea2adbe1e03 100644 --- a/test/Lexer/cxx1z-trigraphs.cpp +++ b/test/Lexer/cxx1z-trigraphs.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -std=c++1z %s -verify -// RUN: %clang_cc1 -std=c++1z %s -trigraphs -fsyntax-only +// RUN: %clang_cc1 -std=c++1z %s -ftrigraphs -fsyntax-only ??= define foo ; // expected-error {{}} expected-warning {{trigraph ignored}} diff --git a/test/Lexer/escape_newline.c b/test/Lexer/escape_newline.c index d0f27dffdf71..9fc73dc7a429 100644 --- a/test/Lexer/escape_newline.c +++ b/test/Lexer/escape_newline.c @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -E -trigraphs %s | grep -- ' ->' -// RUN: %clang_cc1 -E -trigraphs %s 2>&1 | grep 'backslash and newline separated by space' -// RUN: %clang_cc1 -E -trigraphs %s 2>&1 | grep 'trigraph converted' -// RUN: %clang_cc1 -E -CC -trigraphs %s +// RUN: %clang_cc1 -E -ftrigraphs %s | grep -- ' ->' +// RUN: %clang_cc1 -E -ftrigraphs %s 2>&1 | grep 'backslash and newline separated by space' +// RUN: %clang_cc1 -E -ftrigraphs %s 2>&1 | grep 'trigraph converted' +// RUN: %clang_cc1 -E -CC -ftrigraphs %s // This is an ugly way to spell a -> token. -??/ diff --git a/test/Lexer/has_extension.c b/test/Lexer/has_extension.c index 3b08510aa440..b7efece64e83 100644 --- a/test/Lexer/has_extension.c +++ b/test/Lexer/has_extension.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -E %s -o - | FileCheck --check-prefix=CHECK-PED-NONE %s -// RUN: %clang_cc1 -pedantic-errors -E %s -o - | FileCheck --check-prefix=CHECK-PED-ERR %s +// RUN: %clang_cc1 -std=c99 -E %s -o - | FileCheck --check-prefix=CHECK-PED-NONE %s +// RUN: %clang_cc1 -std=c99 -pedantic-errors -E %s -o - | FileCheck --check-prefix=CHECK-PED-ERR %s // CHECK-PED-NONE: no_dummy_extension #if !__has_extension(dummy_extension) @@ -36,6 +36,14 @@ int has_c_alignas(); int no_c_alignas(); #endif +// CHECK-PED-NONE: has_c_alignof +// CHECK-PED-ERR: no_c_alignof +#if __has_extension(c_alignof) +int has_c_alignof(); +#else +int no_c_alignof(); +#endif + // Arbitrary feature to test that the extension name can be surrounded with // double underscores. // CHECK-PED-NONE: has_double_underscores diff --git a/test/Lexer/has_feature_c1x.c b/test/Lexer/has_feature_c1x.c index e26e309c0371..ff1778010b75 100644 --- a/test/Lexer/has_feature_c1x.c +++ b/test/Lexer/has_feature_c1x.c @@ -1,12 +1,17 @@ -// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c1x %s -o - | FileCheck --check-prefix=CHECK-1X %s -// RUN: %clang_cc1 -E %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c89 %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=iso9899:199409 %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c99 %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=c11 %s -o - | FileCheck --check-prefix=CHECK-1X %s +// +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=gnu89 %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=gnu99 %s -o - | FileCheck --check-prefix=CHECK-NO-1X %s +// RUN: %clang_cc1 -E -triple x86_64-linux-gnu -std=gnu11 %s -o - | FileCheck --check-prefix=CHECK-1X %s #if __has_feature(c_atomic) int has_atomic(); #else int no_atomic(); #endif - // CHECK-1X: has_atomic // CHECK-NO-1X: no_atomic @@ -15,7 +20,6 @@ int has_static_assert(); #else int no_static_assert(); #endif - // CHECK-1X: has_static_assert // CHECK-NO-1X: no_static_assert @@ -24,7 +28,6 @@ int has_generic_selections(); #else int no_generic_selections(); #endif - // CHECK-1X: has_generic_selections // CHECK-NO-1X: no_generic_selections @@ -33,10 +36,17 @@ int has_alignas(); #else int no_alignas(); #endif - // CHECK-1X: has_alignas // CHECK-NO-1X: no_alignas +#if __has_feature(c_alignof) +int has_alignof(); +#else +int no_alignof(); +#endif +// CHECK-1X: has_alignof +// CHECK-NO-1X: no_alignof + #if __has_feature(c_thread_local) int has_thread_local(); #else diff --git a/test/Lexer/has_feature_cxx0x.cpp b/test/Lexer/has_feature_cxx0x.cpp index e558f8804b22..9fb05de31a23 100644 --- a/test/Lexer/has_feature_cxx0x.cpp +++ b/test/Lexer/has_feature_cxx0x.cpp @@ -234,6 +234,16 @@ int no_alignas(); // CHECK-11: has_alignas // CHECK-NO-11: no_alignas +#if __has_feature(cxx_alignof) +int has_alignof(); +#else +int no_alignof(); +#endif + +// CHECK-1Y: has_alignof +// CHECK-11: has_alignof +// CHECK-NO-11: no_alignof + #if __has_feature(cxx_raw_string_literals) int has_raw_string_literals(); #else diff --git a/test/Lexer/ms-compatibility.c b/test/Lexer/ms-compatibility.c new file mode 100644 index 000000000000..d159ad1b8d92 --- /dev/null +++ b/test/Lexer/ms-compatibility.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -E -fms-compatibility %s | FileCheck --check-prefix=CHECK-MS-COMPAT %s +// RUN: %clang_cc1 -fsyntax-only -E %s | FileCheck --check-prefix=CHECK-NO-MS-COMPAT %s + +#define FN(x) L#x +#define F L "aaa" +void *v1 = FN(aaa); +void *v2 = F; +// CHECK-MS-COMPAT: void *v1 = L"aaa"; +// CHECK-MS-COMPAT: void *v2 = L "aaa"; +// CHECK-NO-MS-COMPAT: void *v1 = L "aaa"; +// CHECK-NO-MS-COMPAT: void *v2 = L "aaa"; diff --git a/test/Lexer/string-literal-errors.cpp b/test/Lexer/string-literal-errors.cpp index d8e29934f367..223dca4b94f6 100644 --- a/test/Lexer/string-literal-errors.cpp +++ b/test/Lexer/string-literal-errors.cpp @@ -23,3 +23,5 @@ void foo() { // CHECK: {{^ \^~$}} // CHECK: {{^ \^~$}} } + +#define foo() lots and lots of tokens, need at least 8 to fill up the smallvector buffer #BadThingsHappenNow diff --git a/test/Lexer/utf8-char-literal.cpp b/test/Lexer/utf8-char-literal.cpp index 7a4d126097a7..0ddaabc84225 100644 --- a/test/Lexer/utf8-char-literal.cpp +++ b/test/Lexer/utf8-char-literal.cpp @@ -1,6 +1,15 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c++11 -fsyntax-only -verify %s // RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c11 -x c -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c++1z -fsyntax-only -verify %s int array0[u'ñ' == u'\xf1'? 1 : -1]; int array1['\xF1' != u'\xf1'? 1 : -1]; int array1['ñ' != u'\xf1'? 1 : -1]; // expected-error {{character too large for enclosing character literal type}} +#if __cplusplus > 201402L +char a = u8'ñ'; // expected-error {{character too large for enclosing character literal type}} +char b = u8'\x80'; // ok +char c = u8'\u0080'; // expected-error {{character too large for enclosing character literal type}} +char d = u8'\u1234'; // expected-error {{character too large for enclosing character literal type}} +char e = u8'ሴ'; // expected-error {{character too large for enclosing character literal type}} +char f = u8'ab'; // expected-error {{Unicode character literals may not contain multiple characters}} +#endif diff --git a/test/Lexer/wchar-signedness.c b/test/Lexer/wchar-signedness.c index b5d4ac8f000c..1d8bc4d5dd03 100644 --- a/test/Lexer/wchar-signedness.c +++ b/test/Lexer/wchar-signedness.c @@ -1,5 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple x86_64-none-linux-gnu | FileCheck %s --check-prefix=CHECK-X86 // RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple armv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM +// RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple thumbv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM // CHECK-X86-NOT: #define __WCHAR_UNSIGNED__ // CHECK-X86: #define __WINT_UNSIGNED__ 1 diff --git a/test/Misc/ast-dump-arm-attr.c b/test/Misc/ast-dump-arm-attr.c index bec3531828b1..41328165d210 100644 --- a/test/Misc/ast-dump-arm-attr.c +++ b/test/Misc/ast-dump-arm-attr.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -triple arm-apple-darwin -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s
-
-__attribute__((interrupt)) void Test(void);
-// CHECK: FunctionDecl{{.*}}Test
-// CHECK-NEXT: ARMInterruptAttr
+// RUN: %clang_cc1 -triple arm-apple-darwin -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s + +__attribute__((interrupt)) void Test(void); +// CHECK: FunctionDecl{{.*}}Test +// CHECK-NEXT: ARMInterruptAttr diff --git a/test/Misc/ast-dump-attr.cpp b/test/Misc/ast-dump-attr.cpp index 1aa6adf79b09..446f0fa692f9 100644 --- a/test/Misc/ast-dump-attr.cpp +++ b/test/Misc/ast-dump-attr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++11 -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s +// RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++11 -Wno-deprecated-declarations -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s int TestLocation __attribute__((unused)); @@ -135,3 +135,18 @@ void func() { // CHECK-NOT: NoReturnAttr // CHECK: CXXConversionDecl{{.*}}operator void (*)() __attribute__((noreturn)) } + +namespace PR20930 { +struct S { + struct { int Test __attribute__((deprecated)); }; + // CHECK: FieldDecl{{.*}}Test 'int' + // CHECK-NEXT: DeprecatedAttr +}; + +void f() { + S s; + s.Test = 1; + // CHECK: IndirectFieldDecl{{.*}}Test 'int' + // CHECK: DeprecatedAttr +} +} diff --git a/test/Misc/ast-dump-color.cpp b/test/Misc/ast-dump-color.cpp index b4660b4a724e..479467df7160 100644 --- a/test/Misc/ast-dump-color.cpp +++ b/test/Misc/ast-dump-color.cpp @@ -29,8 +29,8 @@ struct Invalid { __attribute__((noinline)) Invalid(error); } Invalid; -//CHECK: {{^}}[[Blue:.\[0;34m]][[RESET:.\[0m]][[GREEN:.\[0;1;32m]]TranslationUnitDecl[[RESET]][[Yellow:.\[0;33m]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]]{{$}} -//CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN:.\[0;1;36m]] __int128_t[[RESET]] [[Green:.\[0;32m]]'__int128'[[RESET]]{{$}} +//CHECK: {{^}}[[GREEN:.\[0;1;32m]]TranslationUnitDecl[[RESET:.\[0m]][[Yellow:.\[0;33m]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]]{{$}} +//CHECK: {{^}}[[Blue:.\[0;34m]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN:.\[0;1;36m]] __int128_t[[RESET]] [[Green:.\[0;32m]]'__int128'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN]] __uint128_t[[RESET]] [[Green]]'unsigned __int128'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]TypedefDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]<invalid sloc>[[RESET]] implicit[[CYAN]] __builtin_va_list[[RESET]] [[Green]]'__va_list_tag [1]'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]{{.*}}ast-dump-color.cpp:6:1[[RESET]], [[Yellow]]col:5[[RESET]]> [[Yellow]]col:5[[RESET]][[CYAN]] Test[[RESET]] [[Green]]'int'[[RESET]] @@ -75,29 +75,29 @@ struct Invalid { //CHECK: {{^}}[[Blue]]| | | `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:22[[RESET]]> Text=" Another variable"{{$}} //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:23:6[[RESET]], [[Yellow]]col:44[[RESET]]>{{$}} //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:44[[RESET]]> Text=" Like the other variable, but different"{{$}} -//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit used[[CYAN]] Mutex[[RESET]] [[Green]]'void (void)'[[RESET]] inline{{.*$}} +//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit used[[CYAN]] Mutex[[RESET]] [[Green]]'void (void) noexcept'[[RESET]] inline{{.*$}} //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]>{{$}} -//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit[[CYAN]] Mutex[[RESET]] [[Green]]'void (const class Mutex &)'[[RESET]] inline{{ .*$}} +//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit constexpr[[CYAN]] Mutex[[RESET]] [[Green]]'void (const class Mutex &)'[[RESET]] inline{{ .*$}} //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] [[Green]]'const class Mutex &'[[RESET]]{{$}} -//CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit[[CYAN]] Mutex[[RESET]] [[Green]]'void (class Mutex &&)'[[RESET]] inline{{ .*$}} +//CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit constexpr[[CYAN]] Mutex[[RESET]] [[Green]]'void (class Mutex &&)'[[RESET]] inline{{ .*$}} //CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] [[Green]]'class Mutex &&'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]line:25:3[[RESET]]> [[Yellow]]col:3[[RESET]] referenced[[CYAN]] mu1[[RESET]] [[Green]]'class Mutex':'class Mutex'[[RESET]] -//CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'class Mutex':'class Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void)'[[RESET]]{{$}} +//CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'class Mutex':'class Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void) noexcept'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:1[[RESET]], [[Yellow]]line:25:8[[RESET]]> [[Yellow]]col:8[[RESET]][[CYAN]] mu2[[RESET]] [[Green]]'class Mutex':'class Mutex'[[RESET]] -//CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'class Mutex':'class Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void)'[[RESET]]{{$}} +//CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'class Mutex':'class Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void) noexcept'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:26:1[[RESET]], [[Yellow]]col:5[[RESET]]> [[Yellow]]col:5[[RESET]][[CYAN]] TestExpr[[RESET]] [[Green]]'int'[[RESET]] //CHECK: {{^}}[[Blue]]| `-[[RESET]][[BLUE]]GuardedByAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:29[[RESET]], [[Yellow]]col:43[[RESET]]>{{$}} //CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]DeclRefExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:40[[RESET]]> [[Green]]'class Mutex':'class Mutex'[[RESET]][[Cyan]] lvalue[[RESET]][[Cyan]][[RESET]] [[GREEN]]Var[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]][[CYAN]] 'mu1'[[RESET]] [[Green]]'class Mutex':'class Mutex'[[RESET]]{{$}} //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:1[[RESET]], [[Yellow]]line:30:1[[RESET]]> [[Yellow]]line:28:8[[RESET]] struct[[CYAN]] Invalid[[RESET]] definition -//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit struct[[CYAN]] Invalid[[RESET]] +//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit referenced struct[[CYAN]] Invalid[[RESET]] //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:29:3[[RESET]], [[Yellow]]col:42[[RESET]]> [[Yellow]]col:29[[RESET]] invalid[[CYAN]] Invalid[[RESET]] [[Green]]'void (int)'[[RESET]] //CHECK: {{^}}[[Blue]]| | |-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:37[[RESET]], [[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]col:42[[RESET]] invalid [[Green]]'int'[[RESET]] //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[BLUE]]NoInlineAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:18[[RESET]]> -//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit used[[CYAN]] Invalid[[RESET]] [[Green]]'void (void)'[[RESET]] inline noexcept-unevaluated 0x{{[0-9a-fA-F]*}} +//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit used constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void (void) noexcept'[[RESET]] inline //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> -//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit[[CYAN]] Invalid[[RESET]] [[Green]]'void (const struct Invalid &)'[[RESET]] inline noexcept-unevaluated 0x{{[0-9a-fA-F]*}} +//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void (const struct Invalid &)'[[RESET]] inline noexcept-unevaluated 0x{{[0-9a-fA-F]*}} //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] [[Green]]'const struct Invalid &'[[RESET]] -//CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit[[CYAN]] Invalid[[RESET]] [[Green]]'void (struct Invalid &&)'[[RESET]] inline noexcept-unevaluated 0x{{[0-9a-fA-F]*}} +//CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void (struct Invalid &&)'[[RESET]] inline noexcept-unevaluated 0x{{[0-9a-fA-F]*}} //CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] [[Green]]'struct Invalid &&'[[RESET]] //CHECK: {{^}}[[Blue]]`-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]line:30:3[[RESET]]> [[Yellow]]col:3[[RESET]][[CYAN]] Invalid[[RESET]] [[Green]]'struct Invalid':'struct Invalid'[[RESET]] -//CHECK: {{^}}[[Blue]] `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'struct Invalid':'struct Invalid'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void)'[[RESET]] +//CHECK: {{^}}[[Blue]] `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'struct Invalid':'struct Invalid'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void (void) noexcept'[[RESET]] diff --git a/test/Misc/ast-dump-decl.cpp b/test/Misc/ast-dump-decl.cpp index b41e4ee3d0f0..fe7ea7503df3 100644 --- a/test/Misc/ast-dump-decl.cpp +++ b/test/Misc/ast-dump-decl.cpp @@ -116,6 +116,7 @@ namespace testCXXConstructorDecl { class TestCXXConstructorDecl : public A { int I; TestCXXConstructorDecl(A &a, int i) : A(a), I(i) { } + TestCXXConstructorDecl(A &a) : TestCXXConstructorDecl(a, 0) { } }; } // CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' @@ -126,6 +127,10 @@ namespace testCXXConstructorDecl { // CHECK: CXXCtorInitializer{{.*}}I // CHECK-NEXT: Expr // CHECK: CompoundStmt +// CHECK: CXXConstructorDecl{{.*}} TestCXXConstructorDecl 'void {{.*}}' +// CHECK-NEXT: ParmVarDecl{{.*}} a +// CHECK-NEXT: CXXCtorInitializer{{.*}}TestCXXConstructorDecl +// CHECK-NEXT: CXXConstructExpr{{.*}}TestCXXConstructorDecl class TestCXXDestructorDecl { ~TestCXXDestructorDecl() { } diff --git a/test/Misc/ast-dump-invalid.cpp b/test/Misc/ast-dump-invalid.cpp new file mode 100644 index 000000000000..3b97cc65409b --- /dev/null +++ b/test/Misc/ast-dump-invalid.cpp @@ -0,0 +1,20 @@ +// RUN: not %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -fms-extensions -ast-dump -ast-dump-filter Test %s | FileCheck -check-prefix CHECK -strict-whitespace %s + +namespace TestInvalidRParenOnCXXUnresolvedConstructExpr { +template <class T> +void f(T i, T j) { + return T (i, j; +} +} + +// CHECK: NamespaceDecl {{.*}} <{{.*}}> {{.*}} TestInvalidRParenOnCXXUnresolvedConstructExpr +// CHECK-NEXT: `-FunctionTemplateDecl +// CHECK-NEXT: |-TemplateTypeParmDecl +// CHECK-NEXT: `-FunctionDecl +// CHECK-NEXT: |-ParmVarDecl +// CHECK-NEXT: |-ParmVarDecl +// CHECK-NEXT: `-CompoundStmt +// CHECK-NEXT: `-ReturnStmt +// CHECK-NEXT: `-CXXUnresolvedConstructExpr {{.*}} <col:10, col:16> 'T' +// CHECK-NEXT: |-DeclRefExpr {{.*}} <col:13> 'T' lvalue ParmVar {{.*}} 'i' 'T' +// CHECK-NEXT: `-DeclRefExpr {{.*}} <col:16> 'T' lvalue ParmVar {{.*}} 'j' 'T' diff --git a/test/Misc/ast-dump-lookups.cpp b/test/Misc/ast-dump-lookups.cpp new file mode 100644 index 000000000000..5c6da48b3afb --- /dev/null +++ b/test/Misc/ast-dump-lookups.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -std=c++11 -ast-dump -ast-dump-filter Test %s | FileCheck -check-prefix DECLS %s +// RUN: %clang_cc1 -std=c++11 -ast-dump-lookups -ast-dump-filter Test %s | FileCheck -check-prefix LOOKUPS %s +// RUN: %clang_cc1 -std=c++11 -ast-dump -ast-dump-lookups -ast-dump-filter Test %s | FileCheck -check-prefix DECLS-LOOKUPS %s + +namespace Test { + extern int a; + int a = 0; +} + +namespace Test { } + +// DECLS: Dumping Test: +// DECLS-NEXT: NamespaceDecl {{.*}} Test +// DECLS-NEXT: |-VarDecl [[EXTERN_A:0x[^ ]*]] {{.*}} a 'int' extern +// DECLS-NEXT: `-VarDecl {{.*}} prev [[EXTERN_A]] {{.*}} a 'int' cinit +// DECLS-NEXT: `-IntegerLiteral {{.*}} 'int' 0 +// +// DECLS: Dumping Test: +// DECLS-NEXT: NamespaceDecl {{.*}} Test + +// LOOKUPS: Dumping Test: +// LOOKUPS-NEXT: StoredDeclsMap Namespace {{.*}} 'Test' +// LOOKUPS-NEXT: `-DeclarationName 'a' +// LOOKUPS-NEXT: `-Var {{.*}} 'a' 'int' +// +// LOOKUPS: Dumping Test: +// LOOKUPS-NEXT: Lookup map is in primary DeclContext + +// DECLS-LOOKUPS: Dumping Test: +// DECLS-LOOKUPS-NEXT: StoredDeclsMap Namespace {{.*}} 'Test' +// DECLS-LOOKUPS-NEXT: `-DeclarationName 'a' +// DECLS-LOOKUPS-NEXT: `-Var [[A:[^ ]*]] 'a' 'int' +// DECLS-LOOKUPS-NEXT: |-VarDecl [[EXTERN_A:0x[^ ]*]] {{.*}} a 'int' extern +// DECLS-LOOKUPS-NEXT: `-VarDecl [[A]] prev [[EXTERN_A]] {{.*}} a 'int' cinit +// DECLS-LOOKUPS-NEXT: `-IntegerLiteral {{.*}} 'int' 0 +// +// DECLS-LOOKUPS: Dumping Test: +// DECLS-LOOKUPS-NEXT: Lookup map is in primary DeclContext diff --git a/test/Misc/ast-dump-msp430-attr.c b/test/Misc/ast-dump-msp430-attr.c index 170e0bef9d99..3ccb3bdb705f 100644 --- a/test/Misc/ast-dump-msp430-attr.c +++ b/test/Misc/ast-dump-msp430-attr.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -triple msp430-unknown-unknown -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s
-
-__attribute__((interrupt(12))) void Test(void);
-// CHECK: FunctionDecl{{.*}}Test
-// CHECK-NEXT: MSP430InterruptAttr
+// RUN: %clang_cc1 -triple msp430-unknown-unknown -ast-dump -ast-dump-filter Test %s | FileCheck --strict-whitespace %s + +__attribute__((interrupt(12))) void Test(void); +// CHECK: FunctionDecl{{.*}}Test +// CHECK-NEXT: MSP430InterruptAttr diff --git a/test/Misc/ast-dump-templates.cpp b/test/Misc/ast-dump-templates.cpp index b7aeca8d55df..022d5c41127c 100644 --- a/test/Misc/ast-dump-templates.cpp +++ b/test/Misc/ast-dump-templates.cpp @@ -39,6 +39,18 @@ void baz() { // CHECK1: template <int A, typename B> B bar() // CHECK2: template <int A, typename B> B bar() +// CHECK1-LABEL: template <typename ...T> struct A { +// CHECK1-NEXT: template <T ...x[3]> struct B { +template <typename ...T> struct A { + template <T ...x[3]> struct B {}; +}; + +// CHECK1-LABEL: template <typename ...T> void f(T ...[3]) { +// CHECK1-NEXT: A<T [3]...> a; +template <typename ...T> void f(T ...[3]) { + A<T [3]...> a; +} + namespace test2 { void func(int); void func(float); diff --git a/test/Misc/ast-print-objectivec.m b/test/Misc/ast-print-objectivec.m new file mode 100644 index 000000000000..ef0fcaa9e32f --- /dev/null +++ b/test/Misc/ast-print-objectivec.m @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s + +@interface NSObject @end + +@protocol P +- (void)MethP __attribute__((availability(macosx,introduced=10.1.0,deprecated=10.2))); +@end + +@interface I : NSObject <P> +- (void)MethI __attribute__((availability(macosx,introduced=10.1.0,deprecated=10.2))); +@end + +@interface I(CAT) +- (void)MethCAT __attribute__((availability(macosx,introduced=10_1_0,deprecated=10_2))); +@end + +@implementation I +- (void)MethP __attribute__((availability(macosx,introduced=10.1.0,deprecated=10.2))) {} +- (void)MethI __attribute__((availability(macosx,introduced=10.1.0,deprecated=10.2))) {} +@end + +// CHECK: @protocol P +// CHECK: - (void) MethP __attribute__((availability(macosx, introduced=10.1.0, deprecated=10.2))); +// CHECK: @end + +// CHECK: @interface I : NSObject<P> +// CHECK: - (void) MethI __attribute__((availability(macosx, introduced=10.1.0, deprecated=10.2))); +// CHECK: @end + +// CHECK: @interface I(CAT) +// CHECK: - (void) MethCAT __attribute__((availability(macosx, introduced=10_1_0, deprecated=10_2))); +// CHECK: @end + +// CHECK: @implementation I +// CHECK: - (void) MethP __attribute__((availability(macosx, introduced=10.1.0, deprecated=10.2))) { +// CHECK: } + +// CHECK: - (void) MethI __attribute__((availability(macosx, introduced=10.1.0, deprecated=10.2))) { +// CHECK: } + +// CHECK: @end diff --git a/test/Misc/ast-print-pragmas.cpp b/test/Misc/ast-print-pragmas.cpp index 25421fcd0c3e..23f533fc3766 100644 --- a/test/Misc/ast-print-pragmas.cpp +++ b/test/Misc/ast-print-pragmas.cpp @@ -38,3 +38,18 @@ void test(int *List, int Length) { i++; } } + +template <int V, int I> +void test_nontype_template_param(int *List, int Length) { +#pragma clang loop vectorize_width(V) interleave_count(I) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +// CHECK: #pragma clang loop interleave_count(I) +// CHECK: #pragma clang loop vectorize_width(V) + +void test_templates(int *List, int Length) { + test_nontype_template_param<2, 4>(List, Length); +} diff --git a/test/Misc/attr-source-range.cpp b/test/Misc/attr-source-range.cpp new file mode 100644 index 000000000000..d5540ad64fa5 --- /dev/null +++ b/test/Misc/attr-source-range.cpp @@ -0,0 +1,16 @@ +// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-print-source-range-info %s 2>&1 | FileCheck %s + +void f(int i) __attribute__((format_arg(1))); +// CHECK: attr-source-range.cpp:3:30:{3:41-3:42}{3:8-3:13} + +void g(int i, ...) __attribute__((format(printf, 1, 1))); +// CHECK: attr-source-range.cpp:6:35:{6:50-6:51}{6:8-6:13} + +int h(void) __attribute__((returns_nonnull)); +// CHECK: attr-source-range.cpp:9:28:{9:1-9:4} + +void i(int j) __attribute__((nonnull(1))); +// CHECK: attr-source-range.cpp:12:30:{12:38-12:39}{12:8-12:13} + +void j(__attribute__((nonnull)) int i); +// CHECK: attr-source-range.cpp:15:23:{15:8-15:38} diff --git a/test/Misc/diag-special-chars.c b/test/Misc/diag-special-chars.c new file mode 100644 index 000000000000..e656a09b4279 --- /dev/null +++ b/test/Misc/diag-special-chars.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 %s -verify +// RUN: not %clang_cc1 %s 2>&1 | FileCheck %s + +// There is a special characters on the following line, which is used as a +// marker character for diagnostic printing. Ensure diagnostics involving +// this character does not cause problems with the diagnostic printer. +#error Hi Bye +//expected-error@-1 {{Hi Bye}} + +// CHECK: error: Hi Bye +// CHECK: #error Hi <U+007F> Bye diff --git a/test/Misc/serialized-diags-driver.c b/test/Misc/serialized-diags-driver.c new file mode 100644 index 000000000000..ad07d666c8c1 --- /dev/null +++ b/test/Misc/serialized-diags-driver.c @@ -0,0 +1,20 @@ +// Test that the driver correctly combines its own diagnostics with CC1's in the +// serialized diagnostics. To test this, we need to trigger diagnostics from +// both processes, so we compile code that has a warning (with an associated +// note) and then force the driver to crash. We compile stdin so that the crash +// doesn't litter the user's system with preprocessed output. + +// RUN: rm -f %t +// RUN: %clang -Wx-unknown-warning -Wall -fsyntax-only --serialize-diagnostics %t.diag %s +// RUN: c-index-test -read-diagnostics %t.diag 2>&1 | FileCheck %s + +// CHECK: warning: unknown warning option '-Wx-unknown-warning' [-Wunknown-warning-option] [] + +// CHECK: warning: variable 'voodoo' is uninitialized when used here [-Wuninitialized] +// CHECK: note: initialize the variable 'voodoo' to silence this warning [] +// CHECK: Number of diagnostics: 2 + +void foo() { + int voodoo; + voodoo = voodoo + 1; +} diff --git a/test/Misc/serialized-diags.m b/test/Misc/serialized-diags.m index aac791e9e287..71c983b88385 100644 --- a/test/Misc/serialized-diags.m +++ b/test/Misc/serialized-diags.m @@ -21,7 +21,7 @@ // CHECK: Range: {{.*[/\\]}}serialized-diags.m:8:4 {{.*[/\\]}}serialized-diags.m:8:9 // CHECK: Number FIXITs = 1 // CHECK: FIXIT: ({{.*[/\\]}}serialized-diags.m:8:4 - {{.*[/\\]}}serialized-diags.m:8:9): "self" -// CHECK: +-(null):0:0: note: 'self' is an implicit parameter [] [] +// CHECK: +-(null):0:0: note: 'self' is an implicit parameter [] [Semantic Issue] // CHECK: Number FIXITs = 0 // CHECK: {{.*[/\\]}}serialized-diags.m:1:12: warning: class 'Foo' defined without specifying a base class [-Wobjc-root-class] [Semantic Issue] // CHECK: Number FIXITs = 0 diff --git a/test/Misc/warning-flags.c b/test/Misc/warning-flags.c index f58d2bf52b1f..74ab56667c94 100644 --- a/test/Misc/warning-flags.c +++ b/test/Misc/warning-flags.c @@ -18,8 +18,7 @@ This test serves two purposes: The list of warnings below should NEVER grow. It should gradually shrink to 0. -CHECK: Warnings without flags (103): -CHECK-NEXT: ext_delete_void_ptr_operand +CHECK: Warnings without flags (96): CHECK-NEXT: ext_excess_initializers CHECK-NEXT: ext_excess_initializers_in_char_array_initializer CHECK-NEXT: ext_expected_semi_decl_list @@ -90,7 +89,6 @@ CHECK-NEXT: warn_missing_dependent_template_keyword CHECK-NEXT: warn_missing_exception_specification CHECK-NEXT: warn_missing_whitespace_after_macro_name CHECK-NEXT: warn_mt_message -CHECK-NEXT: warn_multiple_method_decl CHECK-NEXT: warn_no_constructor_for_refconst CHECK-NEXT: warn_not_compound_assign CHECK-NEXT: warn_objc_property_copy_missing_on_block @@ -103,12 +101,7 @@ CHECK-NEXT: warn_pp_expr_overflow CHECK-NEXT: warn_pp_line_decimal CHECK-NEXT: warn_pragma_pack_pop_identifer_and_alignment CHECK-NEXT: warn_pragma_pack_show -CHECK-NEXT: warn_property_attr_mismatch -CHECK-NEXT: warn_property_attribute CHECK-NEXT: warn_property_getter_owning_mismatch -CHECK-NEXT: warn_property_types_are_incompatible -CHECK-NEXT: warn_readonly_property -CHECK-NEXT: warn_redeclaration_without_attribute_prev_attribute_ignored CHECK-NEXT: warn_register_objc_catch_parm CHECK-NEXT: warn_related_result_type_compatibility_class CHECK-NEXT: warn_related_result_type_compatibility_protocol diff --git a/test/Modules/Inputs/AddRemovePrivate.framework/Headers/AddRemovePrivate.h b/test/Modules/Inputs/AddRemovePrivate.framework/Headers/AddRemovePrivate.h new file mode 100644 index 000000000000..3ab77431aa2c --- /dev/null +++ b/test/Modules/Inputs/AddRemovePrivate.framework/Headers/AddRemovePrivate.h @@ -0,0 +1 @@ +// AddRemovePrivate.h diff --git a/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.modulemap b/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.modulemap new file mode 100644 index 000000000000..7d84297a970f --- /dev/null +++ b/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.modulemap @@ -0,0 +1 @@ +framework module AddRemovePrivate { umbrella header "AddRemovePrivate.h" } diff --git a/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.private.modulemap b/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.private.modulemap new file mode 100644 index 000000000000..69b67c2cee7a --- /dev/null +++ b/test/Modules/Inputs/AddRemovePrivate.framework/Modules/module.private.modulemap @@ -0,0 +1 @@ +explicit module AddRemovePrivate.Private { } diff --git a/test/Modules/Inputs/PR20399/FirstHeader.h b/test/Modules/Inputs/PR20399/FirstHeader.h new file mode 100644 index 000000000000..43adf3d847ed --- /dev/null +++ b/test/Modules/Inputs/PR20399/FirstHeader.h @@ -0,0 +1,14 @@ +#ifndef FIRSTHEADER +#define FIRSTHEADER + +#include "SecondHeader.h" // Just a class which gets in the lazy deserialization chain + +#include "stl_map.h" +#include "vector" +typedef std::map<int>::iterator el; + +inline void func() { + std::vector<int>::func(); +} + +#endif diff --git a/test/Modules/Inputs/PR20399/SecondHeader.h b/test/Modules/Inputs/PR20399/SecondHeader.h new file mode 100644 index 000000000000..92815e996482 --- /dev/null +++ b/test/Modules/Inputs/PR20399/SecondHeader.h @@ -0,0 +1,13 @@ +#ifndef SECONDHEADER +#define SECONDHEADER + +#include "vector" + +template <class T> +struct Address {}; + +template <> +struct Address<std::vector<bool>> + : Address<std::vector<bool>::iterator> {}; + +#endif diff --git a/test/Modules/Inputs/PR20399/module.modulemap b/test/Modules/Inputs/PR20399/module.modulemap new file mode 100644 index 000000000000..223434adba19 --- /dev/null +++ b/test/Modules/Inputs/PR20399/module.modulemap @@ -0,0 +1,18 @@ +module stdlib [system] { + header "stl_map.h" + header "vector" + } + +module libCore { + header "SecondHeader.h" + use stdlib + export * +} + +module libGdml { + header "FirstHeader.h" + use libCore + use stdlib + export * +} + diff --git a/test/Modules/Inputs/PR20399/stl_map.h b/test/Modules/Inputs/PR20399/stl_map.h new file mode 100644 index 000000000000..334f8b308f40 --- /dev/null +++ b/test/Modules/Inputs/PR20399/stl_map.h @@ -0,0 +1,13 @@ +namespace std { +struct reverse_iterator {}; + +inline void +operator-(int __x, reverse_iterator __y) {} + +template <typename _Key> +struct map { + typedef int iterator; + + friend bool operator<(const map &, const map &); +}; +} // namespace std diff --git a/test/Modules/Inputs/PR20399/vector b/test/Modules/Inputs/PR20399/vector new file mode 100644 index 000000000000..1e1b6705f51b --- /dev/null +++ b/test/Modules/Inputs/PR20399/vector @@ -0,0 +1,17 @@ +namespace std { +template <typename _Tp, typename _Alloc = int> +struct vector { + static void func() { vector *i, *j; i - j; } +}; + +struct bit_iterator { ~bit_iterator() {} }; + +inline void operator-(int __x, const bit_iterator &__y) { +} + +template <typename _Alloc> +struct vector<bool, _Alloc> : bit_iterator { + typedef bit_iterator iterator; +}; + +} // namespace std diff --git a/test/Modules/Inputs/PR20786/TBranchProxy.h b/test/Modules/Inputs/PR20786/TBranchProxy.h new file mode 100644 index 000000000000..91f3730c3b88 --- /dev/null +++ b/test/Modules/Inputs/PR20786/TBranchProxy.h @@ -0,0 +1,2 @@ +#include "random.h" +#include "TFormula.h" diff --git a/test/Modules/Inputs/PR20786/TFormula.h b/test/Modules/Inputs/PR20786/TFormula.h new file mode 100644 index 000000000000..316e3ad7222b --- /dev/null +++ b/test/Modules/Inputs/PR20786/TFormula.h @@ -0,0 +1 @@ +#include "TMath.h" diff --git a/test/Modules/Inputs/PR20786/TMath.h b/test/Modules/Inputs/PR20786/TMath.h new file mode 100644 index 000000000000..b7dba620f7d1 --- /dev/null +++ b/test/Modules/Inputs/PR20786/TMath.h @@ -0,0 +1 @@ +#include "random.h" diff --git a/test/Modules/Inputs/PR20786/module.modulemap b/test/Modules/Inputs/PR20786/module.modulemap new file mode 100644 index 000000000000..daf78cd0cd3f --- /dev/null +++ b/test/Modules/Inputs/PR20786/module.modulemap @@ -0,0 +1,3 @@ +module TMath { header "TMath.h" } +module TFormula { header "TFormula.h" } +module TBranchProxy { header "TBranchProxy.h" } diff --git a/test/Modules/Inputs/PR20786/random.h b/test/Modules/Inputs/PR20786/random.h new file mode 100644 index 000000000000..86a7d83c19c0 --- /dev/null +++ b/test/Modules/Inputs/PR20786/random.h @@ -0,0 +1,12 @@ +namespace std { + template<typename> struct mersenne_twister_engine { + friend bool operator==(const mersenne_twister_engine &, + const mersenne_twister_engine &) { + return false; + } + }; + struct random_device { + mersenne_twister_engine<int> mt; // require complete type + }; +} + diff --git a/test/Modules/Inputs/StdDef/include_again.h b/test/Modules/Inputs/StdDef/include_again.h new file mode 100644 index 000000000000..f29f6366cc69 --- /dev/null +++ b/test/Modules/Inputs/StdDef/include_again.h @@ -0,0 +1,2 @@ +#include <stddef.h> + diff --git a/test/Modules/Inputs/StdDef/module.map b/test/Modules/Inputs/StdDef/module.map index 69c69eac35b5..5c4e0dae7ba6 100644 --- a/test/Modules/Inputs/StdDef/module.map +++ b/test/Modules/Inputs/StdDef/module.map @@ -8,4 +8,14 @@ module StdDef { header "other.h" export * } + + module PtrDiffT { + header "ptrdiff_t.h" + export * + } + + module IncludeAgain { + header "include_again.h" + export * + } } diff --git a/test/Modules/Inputs/StdDef/ptrdiff_t.h b/test/Modules/Inputs/StdDef/ptrdiff_t.h new file mode 100644 index 000000000000..acb0ab81ffc7 --- /dev/null +++ b/test/Modules/Inputs/StdDef/ptrdiff_t.h @@ -0,0 +1,2 @@ +#define __need_ptrdiff_t +#include <stddef.h> diff --git a/test/Modules/Inputs/attr-unavailable/module.modulemap b/test/Modules/Inputs/attr-unavailable/module.modulemap new file mode 100644 index 000000000000..a5159420c22c --- /dev/null +++ b/test/Modules/Inputs/attr-unavailable/module.modulemap @@ -0,0 +1,4 @@ +module two { header "two.h" } +module oneA { header "oneA.h" } +module oneB { header "oneB.h" export oneA } +module oneC { header "oneC.h" } diff --git a/test/Modules/Inputs/attr-unavailable/oneA.h b/test/Modules/Inputs/attr-unavailable/oneA.h new file mode 100644 index 000000000000..a4e572ffacd9 --- /dev/null +++ b/test/Modules/Inputs/attr-unavailable/oneA.h @@ -0,0 +1,4 @@ +@interface C +-(void)method2 __attribute__((unavailable)); +-(void)method3 __attribute__((unavailable)); +@end diff --git a/test/Modules/Inputs/attr-unavailable/oneB.h b/test/Modules/Inputs/attr-unavailable/oneB.h new file mode 100644 index 000000000000..b9536ad15ba7 --- /dev/null +++ b/test/Modules/Inputs/attr-unavailable/oneB.h @@ -0,0 +1,5 @@ +@import oneA; + +@interface D +-(void)method2; +@end diff --git a/test/Modules/Inputs/attr-unavailable/oneC.h b/test/Modules/Inputs/attr-unavailable/oneC.h new file mode 100644 index 000000000000..9dc305e70fb4 --- /dev/null +++ b/test/Modules/Inputs/attr-unavailable/oneC.h @@ -0,0 +1,3 @@ +@interface E +-(void)method3; +@end diff --git a/test/Modules/Inputs/attr-unavailable/two.h b/test/Modules/Inputs/attr-unavailable/two.h new file mode 100644 index 000000000000..0423f610108d --- /dev/null +++ b/test/Modules/Inputs/attr-unavailable/two.h @@ -0,0 +1,6 @@ +@interface A +-(void)method1; +@end +@interface B +-(void)method1 __attribute__((unavailable)); +@end diff --git a/test/Modules/Inputs/cxx-decls-imported.h b/test/Modules/Inputs/cxx-decls-imported.h index 38cc00d863f2..8c1e74f17c3c 100644 --- a/test/Modules/Inputs/cxx-decls-imported.h +++ b/test/Modules/Inputs/cxx-decls-imported.h @@ -23,3 +23,27 @@ void *operator new[](__SIZE_TYPE__); extern int mergeUsedFlag; inline int getMergeUsedFlag() { return mergeUsedFlag; } + +typedef struct { + int n; + int m; +} NameForLinkage; + +struct HasVirtualFunctions { + virtual void f(); +}; +struct OverridesVirtualFunctions : HasVirtualFunctions { + void f(); +}; +extern "C" void ExternCFunction(); + +typedef struct { + struct Inner { + int n; + }; +} NameForLinkage2; +auto name_for_linkage2_inner_a = NameForLinkage2::Inner(); +typedef decltype(name_for_linkage2_inner_a) NameForLinkage2Inner; + +namespace Aliased { extern int a; } +namespace Alias = Aliased; diff --git a/test/Modules/Inputs/cxx-decls-merged.h b/test/Modules/Inputs/cxx-decls-merged.h index ccc3b0154872..86e81a9bb681 100644 --- a/test/Modules/Inputs/cxx-decls-merged.h +++ b/test/Modules/Inputs/cxx-decls-merged.h @@ -1 +1,27 @@ extern int mergeUsedFlag; + +typedef struct { + int n; + int m; +} NameForLinkage; +extern NameForLinkage name_for_linkage; + +struct HasVirtualFunctions { + virtual void f(); +}; +struct OverridesVirtualFunctions : HasVirtualFunctions { + void f(); +}; +extern OverridesVirtualFunctions overrides_virtual_functions; +extern "C" void ExternCFunction(); + +typedef struct { + struct Inner { + int n; + }; +} NameForLinkage2; +auto name_for_linkage2_inner_b = NameForLinkage2::Inner(); +typedef decltype(name_for_linkage2_inner_b) NameForLinkage2Inner; + +namespace Aliased { extern int b; } +namespace Alias = Aliased; diff --git a/test/Modules/Inputs/cxx-decls-premerged.h b/test/Modules/Inputs/cxx-decls-premerged.h new file mode 100644 index 000000000000..064fb9ea67bb --- /dev/null +++ b/test/Modules/Inputs/cxx-decls-premerged.h @@ -0,0 +1,3 @@ +extern "C" void ExternCFunction(); + +#include "cxx-decls-imported.h" diff --git a/test/Modules/Inputs/cxx-irgen-left.h b/test/Modules/Inputs/cxx-irgen-left.h index ceb50846bbf4..31ae805c9a19 100644 --- a/test/Modules/Inputs/cxx-irgen-left.h +++ b/test/Modules/Inputs/cxx-irgen-left.h @@ -9,3 +9,18 @@ inline int instantiate_min() { inline int instantiate_CtorInit(CtorInit<int> i = CtorInit<int>()) { return i.a; } + +namespace ImplicitSpecialMembers { + inline void create_left() { + // Trigger declaration, but not definition, of special members. + B b(0); C c(0); D d(0); + // Trigger definition of copy constructor. + C c2(c); D d2(d); + } +} + +namespace OperatorDeleteLookup { + // Trigger definition of A::~A() and lookup of operator delete. + // Likewise for B<int>::~B(). + inline void f() { A a; B<int> b; } +} diff --git a/test/Modules/Inputs/cxx-irgen-right.h b/test/Modules/Inputs/cxx-irgen-right.h index 4400c760f07a..30686a12479a 100644 --- a/test/Modules/Inputs/cxx-irgen-right.h +++ b/test/Modules/Inputs/cxx-irgen-right.h @@ -1,3 +1,13 @@ #include "cxx-irgen-top.h" inline int h() { return S<int>::f(); } + +namespace ImplicitSpecialMembers { + inline void create_right() { + // Trigger declaration, but not definition, of special members. + B b(0); C c(0); D d(0); + // Trigger definition of move constructor. + B b2(static_cast<B&&>(b)); + D d2(static_cast<D&&>(d)); + } +} diff --git a/test/Modules/Inputs/cxx-irgen-top.h b/test/Modules/Inputs/cxx-irgen-top.h index 8753d8daa3dc..f1a0bee21250 100644 --- a/test/Modules/Inputs/cxx-irgen-top.h +++ b/test/Modules/Inputs/cxx-irgen-top.h @@ -14,3 +14,38 @@ template<typename T> struct CtorInit { int a; CtorInit() : a(f()) {} }; + +namespace ImplicitSpecialMembers { + struct A { + A(const A&); + }; + struct B { + A a; + B(int); + }; + struct C { + A a; + C(int); + }; + struct D { + A a; + D(int); + }; +} + +namespace OperatorDeleteLookup { + struct A { void operator delete(void*); virtual ~A() = default; }; + template<typename T> struct B { void operator delete(void*); virtual ~B() {} typedef int t; }; + typedef B<int>::t b_int_instantated; +} + +namespace EmitInlineMethods { + struct A { + void f() {} + void g(); + }; + struct B { + void f(); + void g() {} + }; +} diff --git a/test/Modules/Inputs/cxx-lookup/a.h b/test/Modules/Inputs/cxx-lookup/a.h new file mode 100644 index 000000000000..25f614fe50b9 --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/a.h @@ -0,0 +1,2 @@ +// a +namespace llvm { class GlobalValue; } diff --git a/test/Modules/Inputs/cxx-lookup/b.h b/test/Modules/Inputs/cxx-lookup/b.h new file mode 100644 index 000000000000..c2ede9f28dc2 --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/b.h @@ -0,0 +1,3 @@ +// b +namespace llvm { class GlobalValue; } +#include "y.h" diff --git a/test/Modules/Inputs/cxx-lookup/c1.h b/test/Modules/Inputs/cxx-lookup/c1.h new file mode 100644 index 000000000000..dba4a4c0a00e --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/c1.h @@ -0,0 +1,3 @@ +// c1 +#include "a.h" +#include "b.h" diff --git a/test/Modules/Inputs/cxx-lookup/c2.h b/test/Modules/Inputs/cxx-lookup/c2.h new file mode 100644 index 000000000000..463e270e267a --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/c2.h @@ -0,0 +1,2 @@ +// c2 +namespace llvm { class GlobalValue; } diff --git a/test/Modules/Inputs/cxx-lookup/module.modulemap b/test/Modules/Inputs/cxx-lookup/module.modulemap new file mode 100644 index 000000000000..6d397af250c8 --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/module.modulemap @@ -0,0 +1,8 @@ +module A { header "a.h" export * } +module B { header "b.h" export * } +module C { + module C2 { header "c2.h" export * } + module C1 { header "c1.h" export * } +} +module X { header "x.h" export * } +module Y { header "y.h" export * } diff --git a/test/Modules/Inputs/cxx-lookup/x.h b/test/Modules/Inputs/cxx-lookup/x.h new file mode 100644 index 000000000000..a8826e005817 --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/x.h @@ -0,0 +1,2 @@ +template <class T> class allocator; +struct X { virtual allocator<char> f(); }; diff --git a/test/Modules/Inputs/cxx-lookup/y.h b/test/Modules/Inputs/cxx-lookup/y.h new file mode 100644 index 000000000000..8867e8a8becd --- /dev/null +++ b/test/Modules/Inputs/cxx-lookup/y.h @@ -0,0 +1,5 @@ +#include "x.h" +namespace llvm { + struct ulittle32_t; + extern allocator<ulittle32_t> *x; +} diff --git a/test/Modules/Inputs/cxx-templates-a.h b/test/Modules/Inputs/cxx-templates-a.h index c95dc6325e49..4340910d1e2a 100644 --- a/test/Modules/Inputs/cxx-templates-a.h +++ b/test/Modules/Inputs/cxx-templates-a.h @@ -29,6 +29,8 @@ void use_some_template_a() { SomeTemplate<char[2]> a; SomeTemplate<char[1]> b, c; b = c; + + (void)&WithImplicitSpecialMembers<int>::n; } template<int> struct MergeTemplates; @@ -56,6 +58,7 @@ template<typename T> struct WithPartialSpecialization<T*> { T &f() { static T t; return t; } }; typedef WithPartialSpecializationUse::type WithPartialSpecializationInstantiate; +typedef WithPartialSpecialization<void(int)>::type WithPartialSpecializationInstantiate2; template<> struct WithExplicitSpecialization<int> { int n; @@ -73,3 +76,31 @@ template<typename T> struct MergeTemplateDefinitions { static constexpr int g(); }; template<typename T> constexpr int MergeTemplateDefinitions<T>::f() { return 1; } + +template<typename T> using AliasTemplate = T; + +template<typename T> struct PartiallyInstantiatePartialSpec {}; +template<typename T> struct PartiallyInstantiatePartialSpec<T*> { + static T *foo() { return reinterpret_cast<T*>(0); } + static T *bar() { return reinterpret_cast<T*>(0); } +}; +typedef PartiallyInstantiatePartialSpec<int*> PartiallyInstantiatePartialSpecHelper; + +void InstantiateWithAliasTemplate(WithAliasTemplate<int>::X<char>); +inline int InstantiateWithAnonymousDeclsA(WithAnonymousDecls<int> x) { return (x.k ? x.a : x.b) + (x.k ? x.s.c : x.s.d) + x.e; } +inline int InstantiateWithAnonymousDeclsB2(WithAnonymousDecls<char> x); + + +template<typename T1 = int> +struct MergeAnonUnionMember { + MergeAnonUnionMember() { (void)values.t1; } + union { int t1; } values; +}; +inline MergeAnonUnionMember<> maum_a() { return {}; } + +template<typename T> struct DontWalkPreviousDeclAfterMerging { struct Inner { typedef T type; }; }; + +namespace TestInjectedClassName { + template<typename T> struct X { X(); }; + typedef X<char[1]> A; +} diff --git a/test/Modules/Inputs/cxx-templates-b.h b/test/Modules/Inputs/cxx-templates-b.h index efd07c617e52..d763c8040ba3 100644 --- a/test/Modules/Inputs/cxx-templates-b.h +++ b/test/Modules/Inputs/cxx-templates-b.h @@ -24,6 +24,11 @@ template<typename T> template<typename U> constexpr int Outer<T>::Inner<U>::g() { return 2; } static_assert(Outer<int>::Inner<int>::g() == 2, ""); +namespace TestInjectedClassName { + template<typename T> struct X { X(); }; + typedef X<char[2]> B; +} + @import cxx_templates_b_impl; template<typename T, typename> struct Identity { typedef T type; }; @@ -46,6 +51,8 @@ void use_some_template_b() { SomeTemplate<char[1]> a; SomeTemplate<char[2]> b, c; b = c; + + WithImplicitSpecialMembers<int> wism1, wism2(wism1); } auto enum_b_from_b = CommonTemplate<int>::b; @@ -55,6 +62,8 @@ template<int> struct UseInt; template<typename T> void UseRedeclaredEnum(UseInt<T() + CommonTemplate<char>::a>); constexpr void (*UseRedeclaredEnumB)(UseInt<1>) = UseRedeclaredEnum<int>; +typedef WithPartialSpecialization<void(int)>::type WithPartialSpecializationInstantiate3; + template<typename> struct MergeSpecializations; template<typename T> struct MergeSpecializations<T&> { typedef int partially_specialized_in_b; @@ -63,6 +72,16 @@ template<> struct MergeSpecializations<double> { typedef int explicitly_specialized_in_b; }; +template<typename U> using AliasTemplate = U; + +void InstantiateWithAliasTemplate(WithAliasTemplate<int>::X<char>); +inline int InstantiateWithAnonymousDeclsB(WithAnonymousDecls<int> x) { + return (x.k ? x.a : x.b) + (x.k ? x.s.c : x.s.d) + x.e; +} +inline int InstantiateWithAnonymousDeclsB2(WithAnonymousDecls<char> x) { + return (x.k ? x.a : x.b) + (x.k ? x.s.c : x.s.d) + x.e; +} + @import cxx_templates_a; template<typename T> void UseDefinedInBImplIndirectly(T &v) { PerformDelayedLookup(v); @@ -71,4 +90,6 @@ template<typename T> void UseDefinedInBImplIndirectly(T &v) { void TriggerInstantiation() { UseDefinedInBImpl<void>(); Std::f<int>(); + PartiallyInstantiatePartialSpec<int*>::foo(); + WithPartialSpecialization<void(int)>::type x; } diff --git a/test/Modules/Inputs/cxx-templates-c.h b/test/Modules/Inputs/cxx-templates-c.h index 6daffadc6ced..e5395b6c7ed8 100644 --- a/test/Modules/Inputs/cxx-templates-c.h +++ b/test/Modules/Inputs/cxx-templates-c.h @@ -11,3 +11,18 @@ template<typename T> struct MergeTemplateDefinitions { static constexpr int g(); }; template<typename T> constexpr int MergeTemplateDefinitions<T>::g() { return 2; } + +template<typename T1 = int> +struct MergeAnonUnionMember { + MergeAnonUnionMember() { (void)values.t1; } + union { int t1; } values; +}; +inline MergeAnonUnionMember<> maum_c() { return {}; } + +template<typename T> struct DontWalkPreviousDeclAfterMerging { struct Inner { typedef T type; }; }; +typedef DontWalkPreviousDeclAfterMerging<char>::Inner dwpdam_typedef; + +namespace TestInjectedClassName { + template<typename T> struct X { X(); }; + typedef X<char[3]> C; +} diff --git a/test/Modules/Inputs/cxx-templates-common.h b/test/Modules/Inputs/cxx-templates-common.h index 682ef939cec0..a9ca62448671 100644 --- a/test/Modules/Inputs/cxx-templates-common.h +++ b/test/Modules/Inputs/cxx-templates-common.h @@ -32,7 +32,25 @@ template<typename T> struct Outer { }; template<typename T> struct WithPartialSpecialization {}; +template<typename T> struct WithPartialSpecialization<void(T)> { typedef int type; }; typedef WithPartialSpecialization<int*> WithPartialSpecializationUse; +typedef WithPartialSpecialization<void(int)> WithPartialSpecializationUse2; template<typename T> struct WithExplicitSpecialization; typedef WithExplicitSpecialization<int> WithExplicitSpecializationUse; + +template<typename T> struct WithImplicitSpecialMembers { int n; }; + +template<typename T> struct WithAliasTemplate { + template<typename> using X = T; +}; + +template<typename T> struct WithAnonymousDecls { + struct { bool k; }; + union { int a, b; }; + struct { int c, d; } s; + enum { e = 123 }; + typedef int X; +}; + +#include "cxx-templates-textual.h" diff --git a/test/Modules/Inputs/cxx-templates-d.h b/test/Modules/Inputs/cxx-templates-d.h new file mode 100644 index 000000000000..1fb1a2282b96 --- /dev/null +++ b/test/Modules/Inputs/cxx-templates-d.h @@ -0,0 +1,9 @@ +@import cxx_templates_common; + +inline int InstantiateWithAnonymousDeclsD(WithAnonymousDecls<char> x) { return (x.k ? x.a : x.b) + (x.k ? x.s.c : x.s.d) + x.e; } + +namespace TestInjectedClassName { + template<typename T> struct X { X(); }; + typedef X<int> D; + inline D UseD() { return D(); } +} diff --git a/test/Modules/Inputs/cxx-templates-textual.h b/test/Modules/Inputs/cxx-templates-textual.h new file mode 100644 index 000000000000..8bffb8eddc28 --- /dev/null +++ b/test/Modules/Inputs/cxx-templates-textual.h @@ -0,0 +1,2 @@ +template<typename T> struct MergeClassTemplateSpecializations_basic_string {}; +typedef MergeClassTemplateSpecializations_basic_string<char> MergeClassTemplateSpecializations_string; diff --git a/test/Modules/Inputs/declare-use/k.h b/test/Modules/Inputs/declare-use/k.h new file mode 100644 index 000000000000..338178e86cb3 --- /dev/null +++ b/test/Modules/Inputs/declare-use/k.h @@ -0,0 +1,8 @@ +#ifdef GIMME_A_K + +#ifndef K_H +#define K_H +const int k = 42; +#endif + +#endif diff --git a/test/Modules/Inputs/declare-use/l.h b/test/Modules/Inputs/declare-use/l.h new file mode 100644 index 000000000000..a43fd1a3d063 --- /dev/null +++ b/test/Modules/Inputs/declare-use/l.h @@ -0,0 +1,8 @@ +#ifdef GIMME_AN_L + +#ifndef L_H +#define L_H +const int l = 42; +#endif + +#endif diff --git a/test/Modules/Inputs/declare-use/m.h b/test/Modules/Inputs/declare-use/m.h new file mode 100644 index 000000000000..e9089ab725d5 --- /dev/null +++ b/test/Modules/Inputs/declare-use/m.h @@ -0,0 +1,8 @@ +#ifdef GIMME_AN_M + +#ifndef M_H +#define M_H +const int m = 42; +#endif + +#endif diff --git a/test/Modules/Inputs/declare-use/m2.h b/test/Modules/Inputs/declare-use/m2.h new file mode 100644 index 000000000000..9e72835c3bce --- /dev/null +++ b/test/Modules/Inputs/declare-use/m2.h @@ -0,0 +1 @@ +#include "m.h" diff --git a/test/Modules/Inputs/declare-use/module.map b/test/Modules/Inputs/declare-use/module.map index a176fb3a141f..ae8615278aca 100644 --- a/test/Modules/Inputs/declare-use/module.map +++ b/test/Modules/Inputs/declare-use/module.map @@ -38,6 +38,7 @@ module XG { use XC use XE use XJ + use XK } module XH { @@ -52,5 +53,18 @@ module XJ { header "j.h" } +module XK { + textual header "k.h" +} + +module XL { + textual header "l.h" +} + +module XM { + private textual header "m.h" + textual header "m2.h" +} + module XS { } diff --git a/test/Modules/Inputs/dependency-gen-base.modulemap b/test/Modules/Inputs/dependency-gen-base.modulemap new file mode 100644 index 000000000000..8b30ffa67455 --- /dev/null +++ b/test/Modules/Inputs/dependency-gen-base.modulemap @@ -0,0 +1,6 @@ +module "test-base" { + export * + header "Inputs/dependency-gen-included.h" + use "test-base2" +} +extern module "test-base2" "Inputs/dependency-gen-base2.modulemap" diff --git a/test/Modules/Inputs/dependency-gen-base2.modulemap b/test/Modules/Inputs/dependency-gen-base2.modulemap new file mode 100644 index 000000000000..7808c8041aec --- /dev/null +++ b/test/Modules/Inputs/dependency-gen-base2.modulemap @@ -0,0 +1,4 @@ +module "test-base2" { + export * + textual header "Inputs/dependency-gen-included2.h" +} diff --git a/test/Modules/Inputs/dependency-gen-included.h b/test/Modules/Inputs/dependency-gen-included.h new file mode 100644 index 000000000000..0e1cdfcd1e18 --- /dev/null +++ b/test/Modules/Inputs/dependency-gen-included.h @@ -0,0 +1,9 @@ +//#ifndef DEPENDENCY_GEN_INCLUDED_H +//#define DEPENDENCY_GEN_INCLUDED_H + +#include "Inputs/dependency-gen-included2.h" + +void g() { +} + +//#endif diff --git a/test/Modules/Inputs/dependency-gen-included2.h b/test/Modules/Inputs/dependency-gen-included2.h new file mode 100644 index 000000000000..fcd8f12ba5ad --- /dev/null +++ b/test/Modules/Inputs/dependency-gen-included2.h @@ -0,0 +1,7 @@ +#ifndef DEPENDENCY_GEN_INCLUDED2_H +#define DEPENDENCY_GEN_INCLUDED2_H + +void h() { +} + +#endif diff --git a/test/Modules/Inputs/dependency-gen.h b/test/Modules/Inputs/dependency-gen.h new file mode 100644 index 000000000000..2671e262c6ac --- /dev/null +++ b/test/Modules/Inputs/dependency-gen.h @@ -0,0 +1,11 @@ +//#ifndef DEPENDENCY_GEN_H +//#define DEPENDENCY_GEN_H + +#include "dependency-gen-included.h" + +void f() { + g(); + h(); +} + +//#endif diff --git a/test/Modules/Inputs/diamond_left.h b/test/Modules/Inputs/diamond_left.h index fce2e48882f8..6494551e4bfa 100644 --- a/test/Modules/Inputs/diamond_left.h +++ b/test/Modules/Inputs/diamond_left.h @@ -1,3 +1,5 @@ +int top_left_before(void *); + @import diamond_top; float left(float *); diff --git a/test/Modules/Inputs/diamond_top.h b/test/Modules/Inputs/diamond_top.h index 34998cd4324b..30da14f6449b 100644 --- a/test/Modules/Inputs/diamond_top.h +++ b/test/Modules/Inputs/diamond_top.h @@ -2,3 +2,4 @@ int top(int *); int top_left(char *c); +int top_left_before(void *); diff --git a/test/Modules/Inputs/explicit-build/a.h b/test/Modules/Inputs/explicit-build/a.h new file mode 100644 index 000000000000..5e3602f58ffe --- /dev/null +++ b/test/Modules/Inputs/explicit-build/a.h @@ -0,0 +1,5 @@ +#if !__building_module(a) +#error "should only get here when building module a" +#endif + +const int a = 1; diff --git a/test/Modules/Inputs/explicit-build/b.h b/test/Modules/Inputs/explicit-build/b.h new file mode 100644 index 000000000000..449b3859ab45 --- /dev/null +++ b/test/Modules/Inputs/explicit-build/b.h @@ -0,0 +1,7 @@ +#include "a.h" + +#if !__building_module(b) +#error "should only get here when building module b" +#endif + +const int b = 2; diff --git a/test/Modules/Inputs/explicit-build/c.h b/test/Modules/Inputs/explicit-build/c.h new file mode 100644 index 000000000000..2c66a23e8927 --- /dev/null +++ b/test/Modules/Inputs/explicit-build/c.h @@ -0,0 +1,7 @@ +#include "b.h" + +#if !__building_module(c) +#error "should only get here when building module c" +#endif + +const int c = 3; diff --git a/test/Modules/Inputs/explicit-build/module.modulemap b/test/Modules/Inputs/explicit-build/module.modulemap new file mode 100644 index 000000000000..bd6ea830c2d4 --- /dev/null +++ b/test/Modules/Inputs/explicit-build/module.modulemap @@ -0,0 +1,3 @@ +module a { header "a.h" } +module b { header "b.h" export * } +module c { header "c.h" export * } diff --git a/test/Modules/Inputs/filename/a.h b/test/Modules/Inputs/filename/a.h new file mode 100644 index 000000000000..8f896a9ba8f4 --- /dev/null +++ b/test/Modules/Inputs/filename/a.h @@ -0,0 +1 @@ +const char *p = __FILE__; diff --git a/test/Modules/Inputs/filename/module.map b/test/Modules/Inputs/filename/module.map new file mode 100644 index 000000000000..ff164ad7bac8 --- /dev/null +++ b/test/Modules/Inputs/filename/module.map @@ -0,0 +1,3 @@ +module "A" { + header "a.h" +} diff --git a/test/Modules/Inputs/include_next/x/a.h b/test/Modules/Inputs/include_next/x/a.h new file mode 100644 index 000000000000..71822876313a --- /dev/null +++ b/test/Modules/Inputs/include_next/x/a.h @@ -0,0 +1,2 @@ +#include_next "a.h" +enum { ax = 1 }; diff --git a/test/Modules/Inputs/include_next/x/module.modulemap b/test/Modules/Inputs/include_next/x/module.modulemap new file mode 100644 index 000000000000..d0956d98ab84 --- /dev/null +++ b/test/Modules/Inputs/include_next/x/module.modulemap @@ -0,0 +1,2 @@ +module xa { header "a.h" export * } +module xb { header "subdir/b.h" export * } diff --git a/test/Modules/Inputs/include_next/x/subdir/b.h b/test/Modules/Inputs/include_next/x/subdir/b.h new file mode 100644 index 000000000000..d9449e11a32f --- /dev/null +++ b/test/Modules/Inputs/include_next/x/subdir/b.h @@ -0,0 +1,2 @@ +#include_next <b.h> +enum { bx = 3 }; diff --git a/test/Modules/Inputs/include_next/y/a.h b/test/Modules/Inputs/include_next/y/a.h new file mode 100644 index 000000000000..703ec958785d --- /dev/null +++ b/test/Modules/Inputs/include_next/y/a.h @@ -0,0 +1 @@ +enum { ay = 2 }; diff --git a/test/Modules/Inputs/include_next/y/b.h b/test/Modules/Inputs/include_next/y/b.h new file mode 100644 index 000000000000..629e7fde1fe2 --- /dev/null +++ b/test/Modules/Inputs/include_next/y/b.h @@ -0,0 +1 @@ +enum { by = 4 }; diff --git a/test/Modules/Inputs/include_next/y/module.modulemap b/test/Modules/Inputs/include_next/y/module.modulemap new file mode 100644 index 000000000000..5dc3c535cefc --- /dev/null +++ b/test/Modules/Inputs/include_next/y/module.modulemap @@ -0,0 +1,2 @@ +module ya { header "a.h" export * } +module yb { header "b.h" export * } diff --git a/test/Modules/Inputs/inferred-attr/InferredExternC.framework/Headers/InferredExternC.h b/test/Modules/Inputs/inferred-attr/InferredExternC.framework/Headers/InferredExternC.h new file mode 100644 index 000000000000..63242fae9a11 --- /dev/null +++ b/test/Modules/Inputs/inferred-attr/InferredExternC.framework/Headers/InferredExternC.h @@ -0,0 +1 @@ +// InferredExternC.h diff --git a/test/Modules/Inputs/inferred-attr/module.modulemap b/test/Modules/Inputs/inferred-attr/module.modulemap new file mode 100644 index 000000000000..beb6ea159de3 --- /dev/null +++ b/test/Modules/Inputs/inferred-attr/module.modulemap @@ -0,0 +1 @@ +framework module * [extern_c] { } diff --git a/test/Modules/Inputs/macros_bottom.h b/test/Modules/Inputs/macros_bottom.h new file mode 100644 index 000000000000..fc0a78e46207 --- /dev/null +++ b/test/Modules/Inputs/macros_bottom.h @@ -0,0 +1,3 @@ +@import macros_right; + +extern TOP_DEF_RIGHT_UNDEF *TDRUp; diff --git a/test/Modules/Inputs/macros_right_undef.h b/test/Modules/Inputs/macros_right_undef.h index 15a83666a136..5084561e108b 100644 --- a/test/Modules/Inputs/macros_right_undef.h +++ b/test/Modules/Inputs/macros_right_undef.h @@ -2,3 +2,4 @@ @import macros_top; #undef TOP_OTHER_DEF_RIGHT_UNDEF +#undef TOP_DEF_RIGHT_UNDEF diff --git a/test/Modules/Inputs/macros_top.h b/test/Modules/Inputs/macros_top.h index 10935043e2a1..e063133a172d 100644 --- a/test/Modules/Inputs/macros_top.h +++ b/test/Modules/Inputs/macros_top.h @@ -22,3 +22,4 @@ #define TOP_OTHER_DEF_RIGHT_UNDEF void #define TOP_REDEF_IN_SUBMODULES 0 +#define TOP_DEF_RIGHT_UNDEF void diff --git a/test/Modules/Inputs/malformed/c.h b/test/Modules/Inputs/malformed/c.h new file mode 100644 index 000000000000..2cce2ca9caa2 --- /dev/null +++ b/test/Modules/Inputs/malformed/c.h @@ -0,0 +1 @@ +template<typename T> void f() { T::error; } diff --git a/test/Modules/Inputs/malformed/module.map b/test/Modules/Inputs/malformed/module.map index 5277ffa41edd..3f088d1431d9 100644 --- a/test/Modules/Inputs/malformed/module.map +++ b/test/Modules/Inputs/malformed/module.map @@ -6,3 +6,4 @@ module malformed_b { module b1 { header "b1.h" } module b2 { header "b2.h" } } +module c { header "c.h" } diff --git a/test/Modules/Inputs/merge-typedefs/a1.h b/test/Modules/Inputs/merge-typedefs/a1.h new file mode 100644 index 000000000000..cacc530c3d0a --- /dev/null +++ b/test/Modules/Inputs/merge-typedefs/a1.h @@ -0,0 +1,11 @@ +#ifndef A1_H +#define A1_H +namespace llvm { +class MachineBasicBlock; +template <class NodeT> class DomTreeNodeBase; +typedef DomTreeNodeBase<MachineBasicBlock> MachineDomTreeNode; +} + +typedef struct {} foo_t; +typedef foo_t foo2_t; +#endif diff --git a/test/Modules/Inputs/merge-typedefs/a2.h b/test/Modules/Inputs/merge-typedefs/a2.h new file mode 100644 index 000000000000..ba306663e3b5 --- /dev/null +++ b/test/Modules/Inputs/merge-typedefs/a2.h @@ -0,0 +1,3 @@ +#ifndef A2_H +#define A2_H +#endif diff --git a/test/Modules/Inputs/merge-typedefs/b1.h b/test/Modules/Inputs/merge-typedefs/b1.h new file mode 100644 index 000000000000..8dde5f6fbadd --- /dev/null +++ b/test/Modules/Inputs/merge-typedefs/b1.h @@ -0,0 +1,11 @@ +#ifndef B1_H +#define B1_H +typedef struct {} foo_t; +typedef foo_t foo2_t; +#include "a2.h" +namespace llvm { +class MachineBasicBlock; +template <class NodeT> class DomTreeNodeBase; +typedef DomTreeNodeBase<MachineBasicBlock> MachineDomTreeNode; +} +#endif diff --git a/test/Modules/Inputs/merge-typedefs/b2.h b/test/Modules/Inputs/merge-typedefs/b2.h new file mode 100644 index 000000000000..75bd63affb16 --- /dev/null +++ b/test/Modules/Inputs/merge-typedefs/b2.h @@ -0,0 +1,3 @@ +#ifndef B2_H +#define B2_H +#endif diff --git a/test/Modules/Inputs/merge-typedefs/module.modulemap b/test/Modules/Inputs/merge-typedefs/module.modulemap new file mode 100644 index 000000000000..4858f1be63ac --- /dev/null +++ b/test/Modules/Inputs/merge-typedefs/module.modulemap @@ -0,0 +1,9 @@ +module A { + module A1 { header "a1.h" export * } + module A2 { header "a2.h" export * } +} + +module B { + module B1 { header "b1.h" export * } + module B2 { header "b2.h" export * } +} diff --git a/test/Modules/Inputs/merge-using-decls/a.h b/test/Modules/Inputs/merge-using-decls/a.h new file mode 100644 index 000000000000..0fe0067bf23c --- /dev/null +++ b/test/Modules/Inputs/merge-using-decls/a.h @@ -0,0 +1,43 @@ +struct X { + int v; + typedef int t; +}; + +struct YA { + int value; + typedef int type; +}; + +template<typename T> struct C : X, T { + using T::value; + using typename T::type; + using X::v; + using typename X::t; +}; + +template<typename T> struct D : X, T { + using T::value; + using typename T::type; + using X::v; + using typename X::t; +}; + +template<typename T> struct E : X, T { + using T::value; + using typename T::type; + using X::v; + using typename X::t; +}; + +template<typename T> struct F : X, T { + using T::value; + using typename T::type; + using X::v; + using typename X::t; +}; + +// Force instantiation. +typedef C<YA>::type I; +typedef D<YA>::type I; +typedef E<YA>::type I; +typedef F<YA>::type I; diff --git a/test/Modules/Inputs/merge-using-decls/b.h b/test/Modules/Inputs/merge-using-decls/b.h new file mode 100644 index 000000000000..359555570a43 --- /dev/null +++ b/test/Modules/Inputs/merge-using-decls/b.h @@ -0,0 +1,50 @@ +struct X { + int v; + typedef int t; +}; + +struct YB { + typedef YB Y; + int value; + typedef int type; +}; + +struct YBRev { + typedef int value; + int type; +}; + +template<typename T> struct C : X, T { + using T::value; + using typename T::type; + using X::v; + using typename X::t; +}; + +template<typename T> struct D : X, T { + // Mismatch in type/non-type-ness. + using typename T::value; + using T::type; + using X::v; + using typename X::t; +}; + +template<typename T> struct E : X, T { + // Mismatch in using/access-declaration-ness. + T::value; + X::v; +}; + +template<typename T> struct F : X, T { + // Mismatch in nested-name-specifier. + using T::Y::value; + using typename T::Y::type; + using ::X::v; + using typename ::X::t; +}; + +// Force instantiation. +typedef C<YB>::type I; +typedef D<YBRev>::t I; +typedef E<YB>::type I; +typedef F<YB>::type I; diff --git a/test/Modules/Inputs/merge-using-decls/module.modulemap b/test/Modules/Inputs/merge-using-decls/module.modulemap new file mode 100644 index 000000000000..a415527813c7 --- /dev/null +++ b/test/Modules/Inputs/merge-using-decls/module.modulemap @@ -0,0 +1,2 @@ +module A { header "a.h" } +module B { header "b.h" } diff --git a/test/Modules/Inputs/modular_maps-moduleb-cwd.map b/test/Modules/Inputs/modular_maps-moduleb-cwd.map new file mode 100644 index 000000000000..1ff307f4b3df --- /dev/null +++ b/test/Modules/Inputs/modular_maps-moduleb-cwd.map @@ -0,0 +1,4 @@ +module B { + header "Inputs/modular_maps/common.h" + private header "Inputs/modular_maps/b.h" +} diff --git a/test/Modules/Inputs/modular_maps/c.h b/test/Modules/Inputs/modular_maps/c.h new file mode 100644 index 000000000000..6e3468e72602 --- /dev/null +++ b/test/Modules/Inputs/modular_maps/c.h @@ -0,0 +1,4 @@ +#ifndef C_H +#define C_H +const int c = 5; +#endif diff --git a/test/Modules/Inputs/modular_maps/common.h b/test/Modules/Inputs/modular_maps/common.h index f690bcbd399b..349bf5f7c473 100644 --- a/test/Modules/Inputs/modular_maps/common.h +++ b/test/Modules/Inputs/modular_maps/common.h @@ -1,4 +1,4 @@ #ifndef COMMON_H #define COMMON_H -const int c = 2; +const int x = 2; #endif diff --git a/test/Modules/Inputs/modular_maps/modulea-cwd.map b/test/Modules/Inputs/modular_maps/modulea-cwd.map new file mode 100644 index 000000000000..10be5237fc7a --- /dev/null +++ b/test/Modules/Inputs/modular_maps/modulea-cwd.map @@ -0,0 +1,7 @@ +module A { + header "Inputs/modular_maps/common.h" + header "Inputs/modular_maps/a.h" +} + +extern module B "Inputs/modular_maps-moduleb-cwd.map" + diff --git a/test/Modules/Inputs/modular_maps/modulec-cwd.map b/test/Modules/Inputs/modular_maps/modulec-cwd.map new file mode 100644 index 000000000000..ca38b542df4a --- /dev/null +++ b/test/Modules/Inputs/modular_maps/modulec-cwd.map @@ -0,0 +1,3 @@ +module C { + header "Inputs/modular_maps/c.h" +} diff --git a/test/Modules/Inputs/modular_maps/modulec.map b/test/Modules/Inputs/modular_maps/modulec.map new file mode 100644 index 000000000000..c5a1ffe4577c --- /dev/null +++ b/test/Modules/Inputs/modular_maps/modulec.map @@ -0,0 +1,3 @@ +module C { + header "c.h" +} diff --git a/test/Modules/Inputs/module.map b/test/Modules/Inputs/module.map index fea12015233b..7040ee7e5ab6 100644 --- a/test/Modules/Inputs/module.map +++ b/test/Modules/Inputs/module.map @@ -40,6 +40,10 @@ module macros_right { header "macros_right_undef.h" } } +module macros_bottom { + header "macros_bottom.h" + export * +} module macros { header "macros.h" } module macros_other { header "macros_other.h" } module category_top { header "category_top.h" } @@ -229,6 +233,10 @@ module cxx_templates_c { header "cxx-templates-c.h" } +module cxx_templates_d { + header "cxx-templates-d.h" +} + module cxx_decls { module unimported { header "cxx-decls-unimported.h" @@ -238,6 +246,10 @@ module cxx_decls { } } +module cxx_decls_premerged { + header "cxx-decls-premerged.h" +} + module cxx_decls_merged { header "cxx-decls-merged.h" } @@ -280,6 +292,10 @@ module warning { header "warning.h" } +module warn_unused_local_typedef { + header "warn-unused-local-typedef.h" +} + module initializer_list { header "initializer_list" } diff --git a/test/Modules/Inputs/odr/a.h b/test/Modules/Inputs/odr/a.h index 26144b86e8d1..5a3f52409486 100644 --- a/test/Modules/Inputs/odr/a.h +++ b/test/Modules/Inputs/odr/a.h @@ -8,6 +8,12 @@ struct X { int n; } x1; +template<typename T> +struct F { + int n; + friend bool operator==(const F &a, const F &b) { return a.n == b.n; } +}; + int f() { return y1.n + e1 + y1.f + x1.n; } diff --git a/test/Modules/Inputs/odr/b.h b/test/Modules/Inputs/odr/b.h index b4063979474f..a4a693df2bf1 100644 --- a/test/Modules/Inputs/odr/b.h +++ b/test/Modules/Inputs/odr/b.h @@ -4,6 +4,12 @@ struct Y { } y2; enum E { e2 }; +template<typename T> +struct F { + int n; + friend bool operator==(const F &a, const F &b) { return a.n == b.n; } +}; + int g() { - return y2.m + e2 + y2.f; + return y2.m + e2 + y2.f + (F<int>{0} == F<int>{1}); } diff --git a/test/Modules/Inputs/pch-used.h b/test/Modules/Inputs/pch-used.h index 60e0097ea909..bc53bb37a9df 100644 --- a/test/Modules/Inputs/pch-used.h +++ b/test/Modules/Inputs/pch-used.h @@ -1,2 +1,3 @@ @import cstd.stdio; +@import other_constants.dbl_max; static inline void SPXTrace() { fprintf(__stderrp, ""); } diff --git a/test/Modules/Inputs/pr19692/AIX.h b/test/Modules/Inputs/pr19692/AIX.h new file mode 100644 index 000000000000..710871e21f21 --- /dev/null +++ b/test/Modules/Inputs/pr19692/AIX.h @@ -0,0 +1,2 @@ + #undef INT64_MAX + diff --git a/test/Modules/Inputs/pr19692/Blah.h b/test/Modules/Inputs/pr19692/Blah.h new file mode 100644 index 000000000000..bdaa83a5a363 --- /dev/null +++ b/test/Modules/Inputs/pr19692/Blah.h @@ -0,0 +1,2 @@ + #include "stdint.h" + diff --git a/test/Modules/Inputs/pr19692/TBlah.h b/test/Modules/Inputs/pr19692/TBlah.h new file mode 100644 index 000000000000..a045a8bd7377 --- /dev/null +++ b/test/Modules/Inputs/pr19692/TBlah.h @@ -0,0 +1,3 @@ +#include "Blah.h" + int use = INT64_MAX; + diff --git a/test/Modules/Inputs/pr19692/TFoo.h b/test/Modules/Inputs/pr19692/TFoo.h new file mode 100644 index 000000000000..8b137891791f --- /dev/null +++ b/test/Modules/Inputs/pr19692/TFoo.h @@ -0,0 +1 @@ + diff --git a/test/Modules/Inputs/pr19692/module.map b/test/Modules/Inputs/pr19692/module.map new file mode 100644 index 000000000000..f4120dce6f8c --- /dev/null +++ b/test/Modules/Inputs/pr19692/module.map @@ -0,0 +1,3 @@ +module cstd { module stdint { header "stdint.h" } } +module LLVMSupport { module Blah { header "Blah.h" export * } module AIX { header "AIX.h" } } +module LLVMTarget { module Blah { header "TBlah.h" export * } module Foo { header "TFoo.h" } } diff --git a/test/Modules/Inputs/pr19692/stdint.h b/test/Modules/Inputs/pr19692/stdint.h new file mode 100644 index 000000000000..7615e832495d --- /dev/null +++ b/test/Modules/Inputs/pr19692/stdint.h @@ -0,0 +1,2 @@ + #define INT64_MAX 42 + diff --git a/test/Modules/Inputs/preprocess-prefix.h b/test/Modules/Inputs/preprocess-prefix.h new file mode 100644 index 000000000000..04d01758320b --- /dev/null +++ b/test/Modules/Inputs/preprocess-prefix.h @@ -0,0 +1,2 @@ +int left_and_right(int *); +#import "diamond_left.h" diff --git a/test/Modules/Inputs/relative-dep-gen-1.h b/test/Modules/Inputs/relative-dep-gen-1.h new file mode 100644 index 000000000000..deb56982bb82 --- /dev/null +++ b/test/Modules/Inputs/relative-dep-gen-1.h @@ -0,0 +1 @@ +// empty 1 diff --git a/test/Modules/Inputs/relative-dep-gen-2.h b/test/Modules/Inputs/relative-dep-gen-2.h new file mode 100644 index 000000000000..2b9517d9787d --- /dev/null +++ b/test/Modules/Inputs/relative-dep-gen-2.h @@ -0,0 +1 @@ +// empty 2 diff --git a/test/Modules/Inputs/relative-dep-gen-cwd.modulemap b/test/Modules/Inputs/relative-dep-gen-cwd.modulemap new file mode 100644 index 000000000000..b8678d309d6b --- /dev/null +++ b/test/Modules/Inputs/relative-dep-gen-cwd.modulemap @@ -0,0 +1,4 @@ +module "relative-dep-gen" { + header "Inputs/relative-dep-gen-1.h" + header "Inputs/relative-dep-gen-2.h" +} diff --git a/test/Modules/Inputs/relative-dep-gen.modulemap b/test/Modules/Inputs/relative-dep-gen.modulemap new file mode 100644 index 000000000000..4c821e19ae55 --- /dev/null +++ b/test/Modules/Inputs/relative-dep-gen.modulemap @@ -0,0 +1,4 @@ +module "relative-dep-gen" { + header "relative-dep-gen-1.h" + header "relative-dep-gen-2.h" +} diff --git a/test/Modules/Inputs/templates-left.h b/test/Modules/Inputs/templates-left.h index 2bd79be94584..cbe89434f9f3 100644 --- a/test/Modules/Inputs/templates-left.h +++ b/test/Modules/Inputs/templates-left.h @@ -60,3 +60,13 @@ template<typename T> void testDelayUpdates(DelayUpdates<T> *p = 0) {} void outOfLineInlineUseLeftF(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::f); void outOfLineInlineUseLeftG(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::g); void outOfLineInlineUseLeftH(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::h); + +namespace EmitDefaultedSpecialMembers { + inline void f() { + SmallString<256> SS; + }; +} + +inline int *getStaticDataMemberLeft() { + return WithUndefinedStaticDataMember<int[]>::undefined; +} diff --git a/test/Modules/Inputs/templates-right.h b/test/Modules/Inputs/templates-right.h index 5907cbca73ee..daea97b86b88 100644 --- a/test/Modules/Inputs/templates-right.h +++ b/test/Modules/Inputs/templates-right.h @@ -43,3 +43,7 @@ template<typename T> struct MergePatternDecl; void outOfLineInlineUseRightF(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::f); void outOfLineInlineUseRightG(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::g); void outOfLineInlineUseRightH(void (OutOfLineInline<int>::*)() = &OutOfLineInline<int>::h); + +inline int *getStaticDataMemberRight() { + return WithUndefinedStaticDataMember<int[]>::undefined; +} diff --git a/test/Modules/Inputs/templates-top.h b/test/Modules/Inputs/templates-top.h index 1216266f34fb..31f5e4199281 100644 --- a/test/Modules/Inputs/templates-top.h +++ b/test/Modules/Inputs/templates-top.h @@ -40,3 +40,20 @@ template<typename T> struct OutOfLineInline { template<typename T> inline void OutOfLineInline<T>::f() {} template<typename T> inline void OutOfLineInline<T>::g() {} template<typename T> inline void OutOfLineInline<T>::h() {} + +namespace EmitDefaultedSpecialMembers { + template<typename T> struct SmallVectorImpl { + SmallVectorImpl() {} + ~SmallVectorImpl() {} // non-trivial dtor + }; + template<typename T, unsigned N> struct SmallVector : SmallVectorImpl<T> { + // trivial dtor + }; + template<unsigned N> struct SmallString : SmallVector<char, N> { + // trivial dtor + }; +} + +template<typename T> struct WithUndefinedStaticDataMember { + static T undefined; +}; diff --git a/test/Modules/Inputs/va_list/module.modulemap b/test/Modules/Inputs/va_list/module.modulemap new file mode 100644 index 000000000000..870f38bb0ecd --- /dev/null +++ b/test/Modules/Inputs/va_list/module.modulemap @@ -0,0 +1,2 @@ +module va_list_a { header "va_list_a.h" } +module va_list_b { header "va_list_b.h" } diff --git a/test/Modules/Inputs/va_list/va_list_a.h b/test/Modules/Inputs/va_list/va_list_a.h new file mode 100644 index 000000000000..7193ca2ec340 --- /dev/null +++ b/test/Modules/Inputs/va_list/va_list_a.h @@ -0,0 +1 @@ +int vprintf(const char * __restrict, va_list); diff --git a/test/Modules/Inputs/va_list/va_list_b.h b/test/Modules/Inputs/va_list/va_list_b.h new file mode 100644 index 000000000000..b7f9b3d367c5 --- /dev/null +++ b/test/Modules/Inputs/va_list/va_list_b.h @@ -0,0 +1,2 @@ +@import va_list_a; +void NSLogv(id, va_list); diff --git a/test/Modules/Inputs/warn-unused-local-typedef.h b/test/Modules/Inputs/warn-unused-local-typedef.h new file mode 100644 index 000000000000..6006de0cc8cc --- /dev/null +++ b/test/Modules/Inputs/warn-unused-local-typedef.h @@ -0,0 +1 @@ +inline void myfun() { typedef int a; } diff --git a/test/Modules/Rmodule-build.m b/test/Modules/Rmodule-build.m index b8abc01c2c1a..e8f293535178 100644 --- a/test/Modules/Rmodule-build.m +++ b/test/Modules/Rmodule-build.m @@ -1,34 +1,41 @@ -// REQUIRES: shell // RUN: rm -rf %t // RUN: mkdir %t // RUN: echo '// A' > %t/A.h -// RUN: echo '// B' > %t/B.h +// RUN: echo '#include "C.h"' > %t/B.h +// RUN: echo '// C' > %t/C.h // RUN: echo 'module A { header "A.h" }' > %t/module.modulemap // RUN: echo 'module B { header "B.h" }' >> %t/module.modulemap +// RUN: echo 'module C { header "C.h" }' >> %t/module.modulemap // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -verify \ // RUN: -I %t -Rmodule-build -@import A; // expected-remark{{building module 'A' as}} -@import B; // expected-remark{{building module 'B' as}} +@import A; // expected-remark{{building module 'A' as}} expected-remark {{finished building module 'A'}} +@import B; // expected-remark{{building module 'B' as}} expected-remark {{finished building module 'B'}} @import A; // no diagnostic @import B; // no diagnostic -// RUN: echo ' ' >> %t/B.h +// RUN: echo ' ' >> %t/C.h // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: -Rmodule-build 2>&1 | FileCheck %s -// RUN: echo ' ' >> %t/B.h +// RUN: echo ' ' >> %t/C.h // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ // RUN: -Reverything 2>&1 | FileCheck %s // RUN: echo ' ' >> %t/B.h // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ -// RUN: 2>&1 | count 0 +// RUN: 2>&1 | FileCheck -allow-empty -check-prefix=NO-REMARKS %s // RUN: echo ' ' >> %t/B.h // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fsyntax-only %s -I %t \ -// RUN: -Rmodule-build -Rno-everything 2>&1 | count 0 +// RUN: -Rmodule-build -Rno-everything 2>&1 | \ +// RUN: FileCheck -allow-empty -check-prefix=NO-REMARKS %s // CHECK-NOT: building module 'A' // CHECK: building module 'B' +// CHECK: building module 'C' +// CHECK: finished building module 'C' +// CHECK: finished building module 'B' +// NO-REMARKS-NOT: building module 'A' +// NO-REMARKS-NOT: building module 'B' diff --git a/test/Modules/Werror-Wsystem-headers.m b/test/Modules/Werror-Wsystem-headers.m index c4cd1a6378cc..4391aa027977 100644 --- a/test/Modules/Werror-Wsystem-headers.m +++ b/test/Modules/Werror-Wsystem-headers.m @@ -1,21 +1,20 @@ -// REQUIRES: shell // RUN: rm -rf %t // RUN: rm -rf %t-saved // RUN: mkdir %t-saved // Initial module build // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ -// RUN: -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -fsyntax-only %s -verify +// RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify // RUN: cp %t/cstd.pcm %t-saved/cstd.pcm // Even with -Werror don't rebuild a system module // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ -// RUN: -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -fsyntax-only %s -verify -Werror +// RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify -Werror // RUN: diff %t/cstd.pcm %t-saved/cstd.pcm // Unless -Wsystem-headers is on // RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash \ -// RUN: -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -fsyntax-only %s -verify \ +// RUN: -isystem %S/Inputs/System/usr/include -fsyntax-only %s -verify \ // RUN: -Werror=unused -Wsystem-headers // RUN: not diff %t/cstd.pcm %t-saved/cstd.pcm diff --git a/test/Modules/Werror.m b/test/Modules/Werror.m index 94a98a5a198d..6444ea513b81 100644 --- a/test/Modules/Werror.m +++ b/test/Modules/Werror.m @@ -1,4 +1,3 @@ -// REQUIRES: shell // RUN: rm -rf %t // RUN: rm -rf %t-saved // RUN: mkdir -p %t-saved diff --git a/test/Modules/add-remove-private.m b/test/Modules/add-remove-private.m new file mode 100644 index 000000000000..49e81e11141d --- /dev/null +++ b/test/Modules/add-remove-private.m @@ -0,0 +1,28 @@ +// RUN: rm -rf %t +// RUN: rm -rf %t.mcp +// RUN: mkdir -p %t +// RUN: cp -r %S/Inputs/AddRemovePrivate.framework %t/AddRemovePrivate.framework + +// Build with module.private.modulemap +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP +// RUN: cp %t.mcp/AddRemovePrivate.pcm %t/with.pcm + +// Build without module.private.modulemap +// RUN: rm %t/AddRemovePrivate.framework/Modules/module.private.modulemap +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify +// RUN: not diff %t.mcp/AddRemovePrivate.pcm %t/with.pcm +// RUN: cp %t.mcp/AddRemovePrivate.pcm %t/without.pcm +// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -DP 2>&1 | FileCheck %s +// CHECK: no submodule named 'Private' + +// Build with module.private.modulemap (again) +// RUN: cp %S/Inputs/AddRemovePrivate.framework/Modules/module.private.modulemap %t/AddRemovePrivate.framework/Modules/module.private.modulemap +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fdisable-module-hash -F %t %s -verify -DP +// RUN: not diff %t.mcp/AddRemovePrivate.pcm %t/without.pcm + +// expected-no-diagnostics + +@import AddRemovePrivate; +#ifdef P +@import AddRemovePrivate.Private; +#endif diff --git a/test/Modules/attr-unavailable.m b/test/Modules/attr-unavailable.m new file mode 100644 index 000000000000..0188a84d9816 --- /dev/null +++ b/test/Modules/attr-unavailable.m @@ -0,0 +1,25 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/attr-unavailable %s -fsyntax-only -verify + +@import two; +void f(id x) { + [x method1]; +} + +@import oneA; +void g(id x) { + [x method2]; // expected-error{{'method2' is unavailable}} + // expected-note@oneA.h:2 {{'method2' has been explicitly marked unavailable here}} + [x method3]; // expected-error{{'method3' is unavailable}} + // expected-note@oneA.h:3 {{'method3' has been explicitly marked unavailable here}} +} + +@import oneB; +void h(id x) { + [x method2]; // could be from interface D in module oneB +} + +@import oneC; +void i(id x) { + [x method3]; // could be from interface E in module oncC +} diff --git a/test/Modules/autolink.m b/test/Modules/autolink.m index 47eda3f80e01..5f2e9bd20208 100644 --- a/test/Modules/autolink.m +++ b/test/Modules/autolink.m @@ -37,14 +37,14 @@ int use_autolink_sub3() { // NOTE: "autolink_sub" is intentionally not linked. // CHECK: !llvm.module.flags = !{{{.*}}} -// CHECK: !{{[0-9]+}} = metadata !{i32 6, metadata !"Linker Options", metadata ![[AUTOLINK_OPTIONS:[0-9]+]]} -// CHECK: ![[AUTOLINK_OPTIONS]] = metadata !{metadata ![[AUTOLINK_PCH:[0-9]+]], metadata ![[AUTOLINK_FRAMEWORK:[0-9]+]], metadata ![[AUTOLINK:[0-9]+]], metadata ![[DEPENDSONMODULE:[0-9]+]], metadata ![[MODULE:[0-9]+]], metadata ![[NOUMBRELLA:[0-9]+]]} -// CHECK: ![[AUTOLINK_PCH]] = metadata !{metadata !"{{(-l|/DEFAULTLIB:)}}autolink_from_pch{{(\.lib)?}}"} -// CHECK: ![[AUTOLINK_FRAMEWORK]] = metadata !{metadata !"-framework", metadata !"autolink_framework"} -// CHECK: ![[AUTOLINK]] = metadata !{metadata !"{{(-l|/DEFAULTLIB:)}}autolink{{(\.lib)?}}"} -// CHECK: ![[DEPENDSONMODULE]] = metadata !{metadata !"-framework", metadata !"DependsOnModule"} -// CHECK: ![[MODULE]] = metadata !{metadata !"-framework", metadata !"Module"} -// CHECK: ![[NOUMBRELLA]] = metadata !{metadata !"-framework", metadata !"NoUmbrella"} +// CHECK: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[AUTOLINK_OPTIONS:[0-9]+]]} +// CHECK: ![[AUTOLINK_OPTIONS]] = !{![[AUTOLINK_PCH:[0-9]+]], ![[AUTOLINK_FRAMEWORK:[0-9]+]], ![[AUTOLINK:[0-9]+]], ![[DEPENDSONMODULE:[0-9]+]], ![[MODULE:[0-9]+]], ![[NOUMBRELLA:[0-9]+]]} +// CHECK: ![[AUTOLINK_PCH]] = !{!"{{(-l|/DEFAULTLIB:)}}autolink_from_pch{{(\.lib)?}}"} +// CHECK: ![[AUTOLINK_FRAMEWORK]] = !{!"-framework", !"autolink_framework"} +// CHECK: ![[AUTOLINK]] = !{!"{{(-l|/DEFAULTLIB:)}}autolink{{(\.lib)?}}"} +// CHECK: ![[DEPENDSONMODULE]] = !{!"-framework", !"DependsOnModule"} +// CHECK: ![[MODULE]] = !{!"-framework", !"Module"} +// CHECK: ![[NOUMBRELLA]] = !{!"-framework", !"NoUmbrella"} // CHECK-AUTOLINK-DISABLED: !llvm.module.flags // CHECK-AUTOLINK-DISABLED-NOT: "Linker Options" diff --git a/test/Modules/cstd.m b/test/Modules/cstd.m index 3d1dcf38e33c..24bca19b7aa9 100644 --- a/test/Modules/cstd.m +++ b/test/Modules/cstd.m @@ -1,5 +1,5 @@ // RUN: rm -rf %t -// RUN: %clang -fsyntax-only -isystem %S/Inputs/System/usr/include -fmodules -fmodules-cache-path=%t -D__need_wint_t -Werror=implicit-function-declaration %s +// RUN: %clang -fsyntax-only -isystem %S/Inputs/System/usr/include -ffreestanding -fmodules -fmodules-cache-path=%t -D__need_wint_t -Werror=implicit-function-declaration %s @import uses_other_constants; const double other_value = DBL_MAX; diff --git a/test/Modules/cxx-decls.cpp b/test/Modules/cxx-decls.cpp index 5498b47fc9fe..109306ed79df 100644 --- a/test/Modules/cxx-decls.cpp +++ b/test/Modules/cxx-decls.cpp @@ -30,7 +30,27 @@ void use_implicit_new_again() { operator new[](3); } int importMergeUsedFlag = getMergeUsedFlag(); +int use_name_for_linkage(NameForLinkage &nfl) { + return nfl.n + nfl.m; +} +int use_overrides_virtual_functions(OverridesVirtualFunctions ovf) { return 0; } + @import cxx_decls_merged; +NameForLinkage2Inner use_name_for_linkage2_inner; +NameForLinkage2 use_name_for_linkage2; + +int name_for_linkage_test = use_name_for_linkage(name_for_linkage); +int overrides_virtual_functions_test = + use_overrides_virtual_functions(overrides_virtual_functions); + +void use_extern_c_function() { ExternCFunction(); } + +int use_namespace_alias() { return Alias::a + Alias::b; } + +@import cxx_decls_premerged; + +void use_extern_c_function_2() { ExternCFunction(); } + // CHECK: VarDecl [[mergeUsedFlag:0x[0-9a-f]*]] {{.*}} in cxx_decls.imported used mergeUsedFlag // CHECK: VarDecl {{0x[0-9a-f]*}} prev [[mergeUsedFlag]] {{.*}} in cxx_decls_merged used mergeUsedFlag diff --git a/test/Modules/cxx-irgen.cpp b/test/Modules/cxx-irgen.cpp index 4c61a3a3583b..ecaf704b87bb 100644 --- a/test/Modules/cxx-irgen.cpp +++ b/test/Modules/cxx-irgen.cpp @@ -1,5 +1,6 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -fmodules -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fmodules -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -g -o - %s | FileCheck %s // FIXME: When we have a syntax for modules in C++, use that. @import cxx_irgen_top; @@ -10,13 +11,66 @@ CtorInit<int> x; @import cxx_irgen_left; @import cxx_irgen_right; +// Keep these two namespace definitions separate; merging them hides the bug. +namespace EmitInlineMethods { + // CHECK-DAG: define linkonce_odr [[CC:(x86_thiscallcc[ ]+)?]]void @_ZN17EmitInlineMethods1C1fEPNS_1AE( + // CHECK-DAG: declare [[CC]]void @_ZN17EmitInlineMethods1A1gEv( + struct C { + __attribute__((used)) void f(A *p) { p->g(); } + }; +} +namespace EmitInlineMethods { + // CHECK-DAG: define linkonce_odr [[CC]]void @_ZN17EmitInlineMethods1D1fEPNS_1BE( + // CHECK-DAG: define linkonce_odr [[CC]]void @_ZN17EmitInlineMethods1B1gEv( + struct D { + __attribute__((used)) void f(B *p) { p->g(); } + }; +} + // CHECK-DAG: define available_externally hidden {{signext i32|i32}} @_ZN1SIiE1gEv({{.*}} #[[ALWAYS_INLINE:.*]] align int a = S<int>::g(); -// CHECK-DAG: define available_externally {{signext i32|i32}} @_ZN1SIiE1fEv({{.*}} #[[ALWAYS_INLINE]] align int b = h(); // CHECK-DAG: define linkonce_odr {{signext i32|i32}} @_Z3minIiET_S0_S0_(i32 int c = min(1, 2); +// CHECK-LABEL: define {{.*}} @_ZN20OperatorDeleteLookup1AD0Ev( +// CHECK: call void @_ZN20OperatorDeleteLookup1AdlEPv( + +namespace ImplicitSpecialMembers { + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1DC2EOS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1DC2ERKS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1CC2EOS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1CC2ERKS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1BC2EOS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + // CHECK-LABEL: define {{.*}} @_ZN22ImplicitSpecialMembers1BC2ERKS0_( + // CHECK: call {{.*}} @_ZN22ImplicitSpecialMembers1AC1ERKS0_( + + extern B b1; + B b2(b1); + B b3(static_cast<B&&>(b1)); + + extern C c1; + C c2(c1); + C c3(static_cast<C&&>(c1)); + + extern D d1; + D d2(d1); + D d3(static_cast<D&&>(d1)); +} + +namespace OperatorDeleteLookup { + // Trigger emission of B's vtable and deleting dtor. + // This requires us to know what operator delete was selected. + void g() { f(); } +} + +// CHECK: define available_externally {{signext i32|i32}} @_ZN1SIiE1fEv({{.*}} #[[ALWAYS_INLINE]] align + // CHECK: attributes #[[ALWAYS_INLINE]] = {{.*}} alwaysinline diff --git a/test/Modules/cxx-lookup.cpp b/test/Modules/cxx-lookup.cpp new file mode 100644 index 000000000000..47c879dbb636 --- /dev/null +++ b/test/Modules/cxx-lookup.cpp @@ -0,0 +1,6 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t %s -I%S/Inputs/cxx-lookup -verify +// expected-no-diagnostics +namespace llvm {} +#include "c2.h" +llvm::GlobalValue *p; diff --git a/test/Modules/cxx-templates.cpp b/test/Modules/cxx-templates.cpp index cbe9f3508951..d9c8a8c27d0d 100644 --- a/test/Modules/cxx-templates.cpp +++ b/test/Modules/cxx-templates.cpp @@ -1,12 +1,18 @@ // RUN: rm -rf %t -// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-lookups | FileCheck %s --check-prefix=CHECK-GLOBAL -// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-lookups -ast-dump-filter N | FileCheck %s --check-prefix=CHECK-NAMESPACE-N +// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups | FileCheck %s --check-prefix=CHECK-GLOBAL +// RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump-lookups -ast-dump-filter N | FileCheck %s --check-prefix=CHECK-NAMESPACE-N // RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump | FileCheck %s --check-prefix=CHECK-DUMP // RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 +// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DEARLY_IMPORT + +#ifdef EARLY_IMPORT +#include "cxx-templates-textual.h" +#endif @import cxx_templates_a; @import cxx_templates_b; @import cxx_templates_c; +@import cxx_templates_d; @import cxx_templates_common; template<typename, char> struct Tmpl_T_C {}; @@ -22,15 +28,21 @@ void g() { f<double>(1.0); f<int>(); f(); // expected-error {{no matching function}} +#ifdef EARLY_IMPORT + // FIXME: The textual inclusion above shouldn't affect this! + // expected-note@Inputs/cxx-templates-a.h:3 {{couldn't infer template argument}} + // expected-note@Inputs/cxx-templates-a.h:4 {{requires 1 argument}} +#else // expected-note@Inputs/cxx-templates-b.h:3 {{couldn't infer template argument}} // expected-note@Inputs/cxx-templates-b.h:4 {{requires single argument}} +#endif N::f(0); N::f<double>(1.0); N::f<int>(); N::f(); // expected-error {{no matching function}} - // expected-note@Inputs/cxx-templates-a.h:6 {{couldn't infer template argument}} - // expected-note@Inputs/cxx-templates-a.h:7 {{requires 1 argument}} + // expected-note@Inputs/cxx-templates-b.h:6 {{couldn't infer template argument}} + // expected-note@Inputs/cxx-templates-b.h:7 {{requires single argument}} template_param_kinds_1<0>(); // ok, from cxx-templates-a.h template_param_kinds_1<int>(); // ok, from cxx-templates-b.h @@ -105,11 +117,22 @@ void g() { int &p = WithPartialSpecializationUse().f(); int &q = WithExplicitSpecializationUse().inner_template<int>(); + int *r = PartiallyInstantiatePartialSpec<int*>::bar(); + + (void)&WithImplicitSpecialMembers<int>::n; + + MergeClassTemplateSpecializations_string s; + + extern TestInjectedClassName::A *use_a; + extern TestInjectedClassName::C *use_c; + TestInjectedClassName::UseD(); } static_assert(Outer<int>::Inner<int>::f() == 1, ""); static_assert(Outer<int>::Inner<int>::g() == 2, ""); +#ifndef EARLY_IMPORT +// FIXME: The textual inclusion above shouldn't cause this to fail! static_assert(MergeTemplateDefinitions<int>::f() == 1, ""); static_assert(MergeTemplateDefinitions<int>::g() == 2, ""); @@ -123,6 +146,21 @@ MergeSpecializations<int[]>::partially_specialized_in_c spec_in_c_1; MergeSpecializations<char>::explicitly_specialized_in_a spec_in_a_2; MergeSpecializations<double>::explicitly_specialized_in_b spec_in_b_2; MergeSpecializations<bool>::explicitly_specialized_in_c spec_in_c_2; +#endif + +MergeAnonUnionMember<> maum_main; +typedef DontWalkPreviousDeclAfterMerging<int> dwpdam_typedef_2; +dwpdam_typedef::type dwpdam_typedef_use; +DontWalkPreviousDeclAfterMerging<int>::Inner::type dwpdam; + +using AliasTemplateMergingTest = WithAliasTemplate<int>::X<char>; + +int AnonymousDeclsMergingTest(WithAnonymousDecls<int> WAD, WithAnonymousDecls<char> WADC) { + return InstantiateWithAnonymousDeclsA(WAD) + + InstantiateWithAnonymousDeclsB(WAD) + + InstantiateWithAnonymousDeclsB2(WADC) + + InstantiateWithAnonymousDeclsD(WADC); +} @import cxx_templates_common; diff --git a/test/Modules/dependency-gen.m b/test/Modules/dependency-gen.m index dec83848f061..d3d66bfaab21 100644 --- a/test/Modules/dependency-gen.m +++ b/test/Modules/dependency-gen.m @@ -1,7 +1,7 @@ // RUN: rm -rf %t-mcp // RUN: mkdir -p %t-mcp -// RUN: %clang_cc1 -x objective-c -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -dependency-file %t.d.1 -MT %s.o -I %S/Inputs -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s +// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.1 -MT %s.o -I %S/Inputs -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s // RUN: FileCheck %s < %t.d.1 // CHECK: dependency-gen.m // CHECK: Inputs{{.}}diamond_top.h @@ -10,7 +10,7 @@ // CHECK-NOT: stdint.h -// RUN: %clang_cc1 -x objective-c -isysroot %S/Inputs/System -triple x86_64-apple-darwin10 -dependency-file %t.d.2 -MT %s.o -I %S/Inputs -sys-header-deps -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s +// RUN: %clang_cc1 -x objective-c -isystem %S/Inputs/System/usr/include -dependency-file %t.d.2 -MT %s.o -I %S/Inputs -sys-header-deps -fsyntax-only -fmodules -fmodules-cache-path=%t-mcp %s // RUN: FileCheck %s -check-prefix=CHECK-SYS < %t.d.2 // CHECK-SYS: dependency-gen.m // CHECK-SYS: Inputs{{.}}diamond_top.h diff --git a/test/Modules/dependency-gen.modulemap.cpp b/test/Modules/dependency-gen.modulemap.cpp new file mode 100644 index 000000000000..c49714c14ed9 --- /dev/null +++ b/test/Modules/dependency-gen.modulemap.cpp @@ -0,0 +1,18 @@ +// REQUIRES: shell +// +// RUN: cd %S +// RUN: rm -f %t.cpm %t-base.pcm %t-base.d %t.d +// RUN: %clang_cc1 -I. -x c++ -fmodule-maps -fmodule-name=test-base -fno-modules-implicit-maps -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse Inputs/dependency-gen-base.modulemap -dependency-file %t-base.d -MT %t-base.pcm -o %t-base.pcm -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -I. -x c++ -fmodule-maps -fmodule-name=test -fno-modules-implicit-maps -fmodules -emit-module -fno-validate-pch -fmodules-strict-decluse -fmodule-file=%t-base.pcm dependency-gen.modulemap.cpp -dependency-file %t.d -MT %t.pcm -o %t.pcm -fmodule-map-file-home-is-cwd +// RUN: FileCheck %s < %t.d +module "test" { + export * + header "Inputs/dependency-gen.h" + use "test-base" + use "test-base2" +} +extern module "test-base2" "Inputs/dependency-gen-base2.modulemap" +extern module "test-base" "Inputs/dependency-gen-base.modulemap" + +// CHECK: {{ |\./}}Inputs/dependency-gen-included2.h +// CHECK: {{ |\./}}Inputs/dependency-gen-base.modulemap diff --git a/test/Modules/explicit-build-flags.cpp b/test/Modules/explicit-build-flags.cpp new file mode 100644 index 000000000000..6ced215a06d1 --- /dev/null +++ b/test/Modules/explicit-build-flags.cpp @@ -0,0 +1,49 @@ +// RUN: rm -rf %t +// RUN: mkdir %t +// RUN: echo 'module tmp { header "tmp.h" }' > %t/map +// RUN: touch %t/tmp.h +// RUN: %clang_cc1 -fmodules -DFOO=1 -x c++ -fmodule-name=tmp %t/map -emit-module -o %t/tmp.pcm + +// Can use the module. +// RUN: %clang_cc1 -fmodules -DFOO=1 -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s + +// Can use the module if an input file is newer. (This happens on +// remote file systems.) +// RUN: sleep 1 +// RUN: touch %t/tmp.h +// RUN: %clang_cc1 -fmodules -DFOO=1 -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s + +// Can use the module if -D flags change. +// RUN: %clang_cc1 -fmodules -DFOO=2 -DBAR=1 -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s +// RUN: %clang_cc1 -fmodules -DBAR=2 -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s + +// Can use the module if -W flags change. +// RUN: %clang_cc1 -fmodules -DBAR=2 -Wextra -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s + +// Can use the module if -I flags change. +// RUN: %clang_cc1 -fmodules -DBAR=2 -I. -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s + +// Can use the module if -O flags change. +// RUN: %clang_cc1 -fmodules -DBAR=2 -Os -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp.pcm -verify -I%t %s +// +// RUN: %clang_cc1 -fmodules -DFOO=1 -O2 -x c++ -fmodule-name=tmp %t/map -emit-module -o %t/tmp-O2.pcm +// RUN: %clang_cc1 -fmodules -DBAR=2 -O0 -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp-O2.pcm -verify -I%t %s +// RUN: %clang_cc1 -fmodules -DBAR=2 -Os -x c++ -fmodule-map-file=%t/map -fmodule-file=%t/tmp-O2.pcm -verify -I%t %s + +#include "tmp.h" // expected-no-diagnostics + +#ifndef BAR +#if FOO != 1 +#error bad FOO from command line and module +#endif +#elif BAR == 1 +#if FOO != 2 +#error bad FOO from command line overriding module +#endif +#elif BAR == 2 +#ifdef FOO +#error FOO leaked from module +#endif +#else +#error bad BAR +#endif diff --git a/test/Modules/explicit-build-relpath.cpp b/test/Modules/explicit-build-relpath.cpp new file mode 100644 index 000000000000..d9c15660b6ad --- /dev/null +++ b/test/Modules/explicit-build-relpath.cpp @@ -0,0 +1,49 @@ +// REQUIRES: shell +// +// RUN: rm -rf %t +// RUN: mkdir %t +// RUN: cd %t + +// ---------------------- +// Build modules A and B. +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o a.pcm +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=a.pcm \ +// RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o b-rel.pcm +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o b-abs.pcm + +// ------------------------------------------ +// Mix and match relative and absolute paths. +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=a.pcm \ +// RUN: -verify %s +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=b-rel.pcm \ +// RUN: -verify %s +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=a.pcm \ +// RUN: -fmodule-file=b-abs.pcm \ +// RUN: -verify %s +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=b-rel.pcm \ +// RUN: -fmodule-file=b-abs.pcm \ +// RUN: -verify %s 2>&1 | FileCheck %s +// CHECK: module 'b' is defined in both '{{.*}}b-rel.pcm' and '{{.*}}b-abs.pcm' + +#include "a.h" +static_assert(a == 1, ""); +// expected-no-diagnostics diff --git a/test/Modules/explicit-build.cpp b/test/Modules/explicit-build.cpp new file mode 100644 index 000000000000..ce3a1af41626 --- /dev/null +++ b/test/Modules/explicit-build.cpp @@ -0,0 +1,175 @@ +// RUN: rm -rf %t + +// ------------------------------- +// Build chained modules A, B, and C +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/a.pcm \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/b.pcm \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/b.pcm \ +// RUN: -fmodule-name=c -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/c.pcm \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty +// +// CHECK-NO-IMPLICIT-BUILD-NOT: building module + +// ------------------------------- +// Build B with an implicit build of A +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-name=b -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/b-not-a.pcm \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-B-NO-A %s +// +// CHECK-B-NO-A: While building module 'b': +// CHECK-B-NO-A: building module 'a' as + +// ------------------------------- +// Check that we can use the explicitly-built A, B, and C modules. +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -verify %s -DHAVE_A +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -verify %s -DHAVE_A +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/b.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/b.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/b.pcm \ +// RUN: -fmodule-file=%t/c.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B -DHAVE_C +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/c.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B -DHAVE_C + +#if HAVE_A + #include "a.h" + static_assert(a == 1, ""); +#else + const int use_a = a; // expected-error {{undeclared identifier}} +#endif + +#if HAVE_B + #include "b.h" + static_assert(b == 2, ""); +#else + const int use_b = b; // expected-error {{undeclared identifier}} +#endif + +#if HAVE_C + #include "c.h" + static_assert(c == 3, ""); +#else + const int use_c = c; // expected-error {{undeclared identifier}} +#endif + +#if HAVE_A && HAVE_B && HAVE_C +// expected-no-diagnostics +#endif + +// ------------------------------- +// Check that we can use a mixture of implicit and explicit modules. +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/b-not-a.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B + +// ------------------------------- +// Try to use two different flavors of the 'a' module. +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/b-not-a.pcm \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/b-not-a.pcm \ +// RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-name=a -emit-module %S/Inputs/explicit-build/module.modulemap -o %t/a-alt.pcm \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-file=%t/a-alt.pcm \ +// RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a-alt.pcm \ +// RUN: -fmodule-file=%t/a.pcm \ +// RUN: -fmodule-map-file=%S/Inputs/explicit-build/module.modulemap \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-MULTIPLE-AS %s +// +// CHECK-MULTIPLE-AS: error: module 'a' is defined in both '{{.*}}/a{{.*}}.pcm' and '{{.*[/\\]}}a{{.*}}.pcm' + +// ------------------------------- +// Try to import a PCH with -fmodule-file= +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-name=a -emit-pch %S/Inputs/explicit-build/a.h -o %t/a.pch \ +// RUN: 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLICIT-BUILD %s --allow-empty +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/a.pch \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-A-AS-PCH %s +// +// CHECK-A-AS-PCH: fatal error: AST file '{{.*}}a.pch' was not built as a module + +// ------------------------------- +// Try to import a non-AST file with -fmodule-file= +// +// RUN: touch %t/not.pcm +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/not.pcm \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-BAD-FILE %s +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -fmodule-file=%t/nonexistent.pcm \ +// RUN: %s 2>&1 | FileCheck --check-prefix=CHECK-BAD-FILE %s +// +// CHECK-BAD-FILE: fatal error: file '{{.*}}t.pcm' is not a precompiled module file + +// ------------------------------- +// Check that we don't get upset if B's timestamp is newer than C's. +// RUN: touch %t/b.pcm +// +// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/c.pcm \ +// RUN: -verify %s -DHAVE_A -DHAVE_B -DHAVE_C +// +// ... but that we do get upset if our B is different from the B that C expects. +// +// RUN: cp %t/b-not-a.pcm %t/b.pcm +// +// RUN: not %clang_cc1 -x c++ -std=c++11 -fmodules -fmodules-cache-path=%t -Rmodule-build -fno-modules-error-recovery \ +// RUN: -I%S/Inputs/explicit-build \ +// RUN: -fmodule-file=%t/c.pcm \ +// RUN: %s -DHAVE_A -DHAVE_B -DHAVE_C 2>&1 | FileCheck --check-prefix=CHECK-MISMATCHED-B %s +// +// CHECK-MISMATCHED-B: fatal error: malformed or corrupted AST file: {{.*}}b.pcm": module file out of date diff --git a/test/Modules/filename.cpp b/test/Modules/filename.cpp new file mode 100644 index 000000000000..66891a04b744 --- /dev/null +++ b/test/Modules/filename.cpp @@ -0,0 +1,9 @@ +// RUN: cd %S +// RUN: %clang_cc1 -I. -fmodule-maps -fmodule-name=A -fmodule-map-file=%S/Inputs/filename/module.map %s -E | FileCheck %s +// REQUIRES: shell + +#include "Inputs/filename/a.h" + +// Make sure that headers that are referenced by module maps have __FILE__ +// reflect the include path they were found with. +// CHECK: const char *p = "./Inputs/filename/a.h" diff --git a/test/Modules/fmodules-validate-once-per-build-session.c b/test/Modules/fmodules-validate-once-per-build-session.c index 346d5a72c3e8..dcbd0db3cbfe 100644 --- a/test/Modules/fmodules-validate-once-per-build-session.c +++ b/test/Modules/fmodules-validate-once-per-build-session.c @@ -6,39 +6,53 @@ // RUN: mkdir -p %t/modules-to-compare // === -// Create a module with system headers. +// Create a module. We will use -I or -isystem to determine whether to treat +// foo.h as a system header. // RUN: echo 'void meow(void);' > %t/Inputs/foo.h -// RUN: echo 'module Foo [system] { header "foo.h" }' > %t/Inputs/module.map +// RUN: echo 'module Foo { header "foo.h" }' > %t/Inputs/module.map // === // Compile the module. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp +// RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-before.pcm +// RUN: cp %t/modules-cache-user/Foo.pcm %t/modules-to-compare/Foo-before-user.pcm // === // Use it, and make sure that we did not recompile it. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp +// RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm +// RUN: cp %t/modules-cache-user/Foo.pcm %t/modules-to-compare/Foo-after-user.pcm // RUN: diff %t/modules-to-compare/Foo-before.pcm %t/modules-to-compare/Foo-after.pcm +// RUN: diff %t/modules-to-compare/Foo-before-user.pcm %t/modules-to-compare/Foo-after-user.pcm // === // Change the sources. // RUN: echo 'void meow2(void);' > %t/Inputs/foo.h // === -// Use the module, and make sure that we did not recompile it, even though the sources changed. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// Use the module, and make sure that we did not recompile it if foo.h is a +// system header, even though the sources changed. +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache-user -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp +// RUN: ls -R %t/modules-cache-user | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm +// RUN: cp %t/modules-cache-user/Foo.pcm %t/modules-to-compare/Foo-after-user.pcm // RUN: diff %t/modules-to-compare/Foo-before.pcm %t/modules-to-compare/Foo-after.pcm +// When foo.h is a user header, we will always validate it. +// RUN: not diff %t/modules-to-compare/Foo-before-user.pcm %t/modules-to-compare/Foo-after-user.pcm // === // Recompile the module if the today's date is before 01 January 2030. -// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -I %t/Inputs -fbuild-session-timestamp=1893456000 -fmodules-validate-once-per-build-session %s +// RUN: %clang_cc1 -cc1 -fmodules -fdisable-module-hash -fmodules-cache-path=%t/modules-cache -fsyntax-only -isystem %t/Inputs -fbuild-session-timestamp=1893456000 -fmodules-validate-once-per-build-session %s // RUN: ls -R %t/modules-cache | grep Foo.pcm.timestamp // RUN: cp %t/modules-cache/Foo.pcm %t/modules-to-compare/Foo-after.pcm diff --git a/test/Modules/implementation-of-module.m b/test/Modules/implementation-of-module.m new file mode 100644 index 000000000000..b39840420156 --- /dev/null +++ b/test/Modules/implementation-of-module.m @@ -0,0 +1,29 @@ +// RUN: not %clang_cc1 -fmodule-implementation-of Foo -fmodule-name=Bar %s 2>&1 \ +// RUN: | FileCheck -check-prefix=CHECK-IMPL-OF-ERR %s +// CHECK-IMPL-OF-ERR: conflicting module names specified: '-fmodule-name=Bar' and '-fmodule-implementation-of Foo' + +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: -fmodule-implementation-of category_right -fsyntax-only + +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: -fmodule-implementation-of category_right -dM -E -o - 2>&1 | FileCheck %s +// CHECK-NOT: __building_module + +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: -fmodule-implementation-of category_left -verify + +// RUN: %clang_cc1 -x objective-c-header -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: -fmodule-implementation-of category_right -emit-pch -o %t.pch +// RUN: %clang_cc1 -x objective-c-header -fmodules -fmodules-cache-path=%t -w -Werror=auto-import %s -I %S/Inputs \ +// RUN: -DWITH_PREFIX -include-pch %t.pch -fmodule-implementation-of category_right + +#ifndef WITH_PREFIX + +@import category_left; // expected-error{{@import of module 'category_left' in implementation of 'category_left'; use #import}} +@import category_left.sub; // expected-error{{@import of module 'category_left.sub' in implementation of 'category_left'; use #import}} +#import "category_right.h" // expected-error{{treating}} +#import "category_right_sub.h" // expected-error{{treating}} + +#endif + diff --git a/test/Modules/include_next.c b/test/Modules/include_next.c new file mode 100644 index 000000000000..f2dafb4a91de --- /dev/null +++ b/test/Modules/include_next.c @@ -0,0 +1,11 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -I%S/Inputs/include_next/x -I%S/Inputs/include_next/y -verify %s +// RUN: %clang_cc1 -I%S/Inputs/include_next/x -I%S/Inputs/include_next/y -verify %s -fmodules -fmodules-cache-path=%t + +// expected-no-diagnostics +#include "a.h" +#include "subdir/b.h" +_Static_assert(ax == 1, ""); +_Static_assert(ay == 2, ""); +_Static_assert(bx == 3, ""); +_Static_assert(by == 4, ""); diff --git a/test/Modules/incomplete-module.m b/test/Modules/incomplete-module.m index 8edaea983cb9..8181ae863de9 100644 --- a/test/Modules/incomplete-module.m +++ b/test/Modules/incomplete-module.m @@ -2,4 +2,8 @@ // RUN: rm -rf %t // RUN: %clang_cc1 -fmodules-cache-path=%t -Wincomplete-module -fmodules -I %S/Inputs %s 2>&1 | FileCheck %s -// CHECK: {{warning: header '.*incomplete_mod_missing.h' is included in module 'incomplete_mod' but not listed in module map}} +// CHECK: warning: include of non-modular header inside module 'incomplete_mod' + +// RUN: rm -rf %t +// RUN: not %clang_cc1 -fmodules-cache-path=%t -fmodules-strict-decluse -fmodules -I %S/Inputs %s 2>&1 | FileCheck %s -check-prefix=DECLUSE +// DECLUSE: error: module incomplete_mod does not depend on a module exporting {{'.*incomplete_mod_missing.h'}} diff --git a/test/Modules/inferred-attributes.mm b/test/Modules/inferred-attributes.mm new file mode 100644 index 000000000000..5fc1d623f396 --- /dev/null +++ b/test/Modules/inferred-attributes.mm @@ -0,0 +1,6 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -F %S/Inputs/inferred-attr -fsyntax-only -verify %s +// expected-no-diagnostics +extern "C" { +@import InferredExternC; +} diff --git a/test/Modules/load-after-failure.m b/test/Modules/load-after-failure.m index f471fd88d505..38d4a3653205 100644 --- a/test/Modules/load-after-failure.m +++ b/test/Modules/load-after-failure.m @@ -1,4 +1,3 @@ -// REQUIRES: shell // RUN: rm -rf %t // RUN: mkdir -p %t diff --git a/test/Modules/macro-reexport/c1.h b/test/Modules/macro-reexport/c1.h index d6a20e7419c1..b63c278577f6 100644 --- a/test/Modules/macro-reexport/c1.h +++ b/test/Modules/macro-reexport/c1.h @@ -1,2 +1,4 @@ +#pragma once + #include "b1.h" #define assert(x) c diff --git a/test/Modules/macro-reexport/d1.h b/test/Modules/macro-reexport/d1.h index fbd68d5de582..99abd2481597 100644 --- a/test/Modules/macro-reexport/d1.h +++ b/test/Modules/macro-reexport/d1.h @@ -1,2 +1,5 @@ +#pragma once + #include "c1.h" +#undef assert #define assert(x) d diff --git a/test/Modules/macro-reexport/e1.h b/test/Modules/macro-reexport/e1.h new file mode 100644 index 000000000000..6c6829df3654 --- /dev/null +++ b/test/Modules/macro-reexport/e1.h @@ -0,0 +1,2 @@ +#include "c1.h" +#undef assert diff --git a/test/Modules/macro-reexport/e2.h b/test/Modules/macro-reexport/e2.h new file mode 100644 index 000000000000..7bc0b4972d2c --- /dev/null +++ b/test/Modules/macro-reexport/e2.h @@ -0,0 +1,2 @@ +#include "d1.h" +#undef assert diff --git a/test/Modules/macro-reexport/f1.h b/test/Modules/macro-reexport/f1.h new file mode 100644 index 000000000000..f8f6502a90c6 --- /dev/null +++ b/test/Modules/macro-reexport/f1.h @@ -0,0 +1,3 @@ +#include "e1.h" +#include "d1.h" + diff --git a/test/Modules/macro-reexport/macro-reexport.cpp b/test/Modules/macro-reexport/macro-reexport.cpp index 47b15c2740bd..af2ec847ce07 100644 --- a/test/Modules/macro-reexport/macro-reexport.cpp +++ b/test/Modules/macro-reexport/macro-reexport.cpp @@ -1,13 +1,30 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -fsyntax-only -DD2 -I. %s -fmodules-cache-path=%t -verify -// RUN: %clang_cc1 -fsyntax-only -DD2 -I. -fmodules %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fsyntax-only -DC1 -I. %s -fmodules-cache-path=%t -verify // RUN: %clang_cc1 -fsyntax-only -DC1 -I. -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD1 -I. %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD1 -I. -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD2 -I. %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DD2 -I. -fmodules %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DF1 -I. %s -fmodules-cache-path=%t -verify +// RUN: %clang_cc1 -fsyntax-only -DF1 -I. -fmodules %s -fmodules-cache-path=%t -verify -#ifdef D2 +#if defined(F1) +#include "f1.h" +void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}} +#include "e2.h" // undefines d1's macro +void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} +#elif defined(D1) +#include "e1.h" // undefines c1's macro but not d1's macro +#include "d1.h" +void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}} +#include "e2.h" // undefines d1's macro +void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} +#elif defined(D2) #include "d2.h" void f() { return assert(true); } // expected-error {{undeclared identifier 'b'}} #else +// e2 undefines d1's macro, which overrides c1's macro. +#include "e2.h" #include "c1.h" -void f() { return assert(true); } // expected-error {{undeclared identifier 'c'}} +void f() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} #endif diff --git a/test/Modules/macro-reexport/module.modulemap b/test/Modules/macro-reexport/module.modulemap index 21585b692e3f..896bda041c30 100644 --- a/test/Modules/macro-reexport/module.modulemap +++ b/test/Modules/macro-reexport/module.modulemap @@ -13,3 +13,11 @@ module d { module d1 { header "d1.h" export * } module d2 { header "d2.h" export * } } +module e { + module e1 { header "e1.h" export * } + module e2 { header "e2.h" export * } +} +module f { + module f1 { header "f1.h" export * } + module f2 { header "f2.h" export * } +} diff --git a/test/Modules/macros.c b/test/Modules/macros.c index 7a7e570ca256..92ea88a48020 100644 --- a/test/Modules/macros.c +++ b/test/Modules/macros.c @@ -130,8 +130,14 @@ void test3() { # error TOP_RIGHT_UNDEF should still be defined #endif +@import macros_bottom; + +TOP_DEF_RIGHT_UNDEF *TDRUf() { return TDRUp; } + @import macros_right.undef; +int TOP_DEF_RIGHT_UNDEF; // ok, no longer defined + // FIXME: When macros_right.undef is built, macros_top is visible because // the state from building macros_right leaks through, so macros_right.undef // undefines macros_top's macro. diff --git a/test/Modules/malformed.cpp b/test/Modules/malformed.cpp index cd7b33493998..2554c3a8729f 100644 --- a/test/Modules/malformed.cpp +++ b/test/Modules/malformed.cpp @@ -1,23 +1,37 @@ +// This test explicitly cd's to the test/Modules directory so that we can test +// that filenames found via relative -I paths are printed correctly. +// +// REQUIRES: shell +// // RUN: rm -rf %t -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/malformed -DHEADER="a1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-A -// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/malformed -DHEADER="b1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-B +// RUN: cd %S +// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="a1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-A +// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="b1.h" %s 2>&1 | FileCheck %s --check-prefix=CHECK-B +// RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I Inputs/malformed -DHEADER="c.h" malformed.cpp 2>&1 | FileCheck %s --check-prefix=CHECK-C #define STR2(x) #x #define STR(x) STR2(x) #include STR(HEADER) // CHECK-A: While building module 'malformed_a' -// CHECK-A: a1.h:1:{{.*}} error: expected '}' -// CHECK-A: a1.h:1:{{.*}} note: to match this '{' +// CHECK-A: {{^}}Inputs/malformed/a1.h:1:{{.*}} error: expected '}' +// CHECK-A: {{^}}Inputs/malformed/a1.h:1:{{.*}} note: to match this '{' // // CHECK-A: While building module 'malformed_a' -// CHECK-A: a2.h:1:{{.*}} error: extraneous closing brace +// CHECK-A: {{^}}Inputs/malformed/a2.h:1:{{.*}} error: extraneous closing brace // CHECK-B: While building module 'malformed_b' -// CHECK-B: b1.h:2:{{.*}} error: expected '}' -// CHECK-B: b1.h:1:{{.*}} note: to match this '{' -// CHECK-B: b1.h:3:{{.*}} error: extraneous closing brace ('}') +// CHECK-B: {{^}}Inputs/malformed/b1.h:2:{{.*}} error: expected '}' +// CHECK-B: {{^}}Inputs/malformed/b1.h:1:{{.*}} note: to match this '{' +// CHECK-B: {{^}}Inputs/malformed/b1.h:3:{{.*}} error: extraneous closing brace ('}') // // CHECK-B: While building module 'malformed_b' -// CHECK-B: b2.h:1:{{.*}} error: redefinition of 'g' -// CHECK-B: b2.h:1:{{.*}} note: previous definition is here +// CHECK-B: {{^}}Inputs/malformed/b2.h:1:{{.*}} error: redefinition of 'g' +// CHECK-B: {{^}}Inputs/malformed/b2.h:1:{{.*}} note: previous definition is here + +void test() { f<int>(); } +// Test that we use relative paths to name files within an imported module. +// +// CHECK-C: In module 'c' imported from malformed.cpp:14: +// CHECK-C: {{^}}Inputs/malformed/c.h:1:33: error: type 'int' cannot be used prior to '::' +// CHECK-C: {{^}}malformed.cpp:[[@LINE-5]]:15: note: in instantiation of diff --git a/test/Modules/merge-typedefs.cpp b/test/Modules/merge-typedefs.cpp new file mode 100644 index 000000000000..607f8c5ad0ec --- /dev/null +++ b/test/Modules/merge-typedefs.cpp @@ -0,0 +1,10 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -x c++ -I%S/Inputs/merge-typedefs -verify %s +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-typedefs -verify %s + +#include "b2.h" +#include "a1.h" + +// expected-no-diagnostics +llvm::MachineDomTreeNode *p; +foo2_t f2t; diff --git a/test/Modules/merge-using-decls.cpp b/test/Modules/merge-using-decls.cpp new file mode 100644 index 000000000000..3b84d0e5a3a0 --- /dev/null +++ b/test/Modules/merge-using-decls.cpp @@ -0,0 +1,69 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=1 +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -x c++ -I%S/Inputs/merge-using-decls -verify %s -DORDER=2 + +#if ORDER == 1 +#include "a.h" +#include "b.h" +#else +#include "b.h" +#include "a.h" +#endif + +struct Y { + int value; // expected-note 0-1{{target of using}} + typedef int type; // expected-note 0-1{{target of using}} +}; + +template<typename T> int Use() { + int k = T().v + T().value; // expected-note 0-2{{instantiation of}} + typedef typename T::type I; + typedef typename T::t I; + typedef int I; + return k; +} + +template<typename T> int UseAll() { + return Use<C<T> >() + Use<D<T> >() + Use<E<T> >() + Use<F<T> >(); // expected-note 0-2{{instantiation of}} +} + +template int UseAll<YA>(); +template int UseAll<YB>(); +template int UseAll<Y>(); + +#if ORDER == 1 +// Here, we're instantiating the definition from 'A' and merging the definition +// from 'B' into it. + +// expected-error@b.h:* {{'E::value' from module 'B' is not present in definition of 'E<T>' in module 'A'}} +// expected-error@b.h:* {{'E::v' from module 'B' is not present in definition of 'E<T>' in module 'A'}} + +// expected-error@b.h:* {{'F::type' from module 'B' is not present in definition of 'F<T>' in module 'A'}} +// expected-error@b.h:* {{'F::t' from module 'B' is not present in definition of 'F<T>' in module 'A'}} +// expected-error@b.h:* {{'F::value' from module 'B' is not present in definition of 'F<T>' in module 'A'}} +// expected-error@b.h:* {{'F::v' from module 'B' is not present in definition of 'F<T>' in module 'A'}} + +// expected-note@a.h:* +{{does not match}} +#else +// Here, we're instantiating the definition from 'B' and merging the definition +// from 'A' into it. + +// expected-error@a.h:* {{'D::type' from module 'A' is not present in definition of 'D<T>' in module 'B'}} +// expected-error@a.h:* {{'D::value' from module 'A' is not present in definition of 'D<T>' in module 'B'}} +// expected-error@b.h:* 2{{'typename' keyword used on a non-type}} +// expected-error@b.h:* 2{{dependent using declaration resolved to type without 'typename'}} + +// expected-error@a.h:* {{'E::type' from module 'A' is not present in definition of 'E<T>' in module 'B'}} +// expected-error@a.h:* {{'E::t' from module 'A' is not present in definition of 'E<T>' in module 'B'}} +// expected-error@a.h:* {{'E::value' from module 'A' is not present in definition of 'E<T>' in module 'B'}} +// expected-error@a.h:* {{'E::v' from module 'A' is not present in definition of 'E<T>' in module 'B'}} +// expected-note@b.h:* 2{{definition has no member}} + +// expected-error@a.h:* {{'F::type' from module 'A' is not present in definition of 'F<T>' in module 'B'}} +// expected-error@a.h:* {{'F::t' from module 'A' is not present in definition of 'F<T>' in module 'B'}} +// expected-error@a.h:* {{'F::value' from module 'A' is not present in definition of 'F<T>' in module 'B'}} +// expected-error@a.h:* {{'F::v' from module 'A' is not present in definition of 'F<T>' in module 'B'}} + +// expected-note@b.h:* +{{does not match}} +// expected-note@b.h:* +{{target of using}} +#endif diff --git a/test/Modules/modular_maps.cpp b/test/Modules/modular_maps.cpp index 9c9aba85a918..606c979c4c2f 100644 --- a/test/Modules/modular_maps.cpp +++ b/test/Modules/modular_maps.cpp @@ -1,8 +1,22 @@ // RUN: rm -rf %t -// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -I %S/Inputs/modular_maps %s -verify +// +// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -I %S/Inputs/modular_maps %s -verify +// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=%S/Inputs/modular_maps/modulec.map -fmodule-map-file=%S/Inputs/modular_maps/modulea.map -I %S/Inputs/modular_maps %s -verify +// +// RxN: cd %S +// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulea.map -fmodule-map-file=Inputs/modular_maps/modulec.map -I Inputs/modular_maps %s -verify +// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec.map -fmodule-map-file=Inputs/modular_maps/modulea.map -I Inputs/modular_maps %s -verify +// +// RUN: cd %S +// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulea-cwd.map -fmodule-map-file=Inputs/modular_maps/modulec-cwd.map -I Inputs/modular_maps %s -verify -fmodule-map-file-home-is-cwd +// RxN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fmodule-map-file=Inputs/modular_maps/modulec-cwd.map -fmodule-map-file=Inputs/modular_maps/modulea-cwd.map -I Inputs/modular_maps %s -verify -fmodule-map-file-home-is-cwd + +// chdir is unsupported on Lit internal runner. +// REQUIRES: shell #include "common.h" #include "a.h" #include "b.h" // expected-error {{private header}} -const int v = a + c; -const int val = a + b + c; // expected-error {{undeclared identifier}} +@import C; +const int v = a + c + x; +const int val = a + b + c + x; // expected-error {{undeclared identifier}} diff --git a/test/Modules/module_file_info.m b/test/Modules/module_file_info.m index 2447a747e3dd..1b0a838bf823 100644 --- a/test/Modules/module_file_info.m +++ b/test/Modules/module_file_info.m @@ -17,8 +17,8 @@ // CHECK: Target options: // CHECK: Triple: -// CHECK: CPU: -// CHECK: ABI: +// CHECK: CPU: +// CHECK: ABI: // CHECK: Diagnostic options: // CHECK: IgnoreWarnings: Yes @@ -28,7 +28,7 @@ // CHECK: Header search options: // CHECK: System root [-isysroot=]: '/' // CHECK: Use builtin include directories [-nobuiltininc]: Yes -// CHECK: Use standard system include directories [-nostdinc]: Yes +// CHECK: Use standard system include directories [-nostdinc]: No // CHECK: Use standard C++ include directories [-nostdinc++]: Yes // CHECK: Use libc++ (rather than libstdc++) [-stdlib=]: diff --git a/test/Modules/modules-with-same-name.m b/test/Modules/modules-with-same-name.m index c90aa5d7d842..d362f756a60a 100644 --- a/test/Modules/modules-with-same-name.m +++ b/test/Modules/modules-with-same-name.m @@ -1,4 +1,3 @@ -// REQUIRES: shell // RUN: rm -rf %t // A from path 1 diff --git a/test/Modules/no-implicit-maps.cpp b/test/Modules/no-implicit-maps.cpp new file mode 100644 index 000000000000..cb270a05014e --- /dev/null +++ b/test/Modules/no-implicit-maps.cpp @@ -0,0 +1,3 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -x objective-c -fno-modules-implicit-maps -fmodules-cache-path=%t -fmodules -I %S/Inputs/private %s -verify +@import libPrivate1; // expected-error {{not found}} diff --git a/test/Modules/no-stale-modtime.m b/test/Modules/no-stale-modtime.m index 1bff2b017a43..53512126a1b6 100644 --- a/test/Modules/no-stale-modtime.m +++ b/test/Modules/no-stale-modtime.m @@ -1,7 +1,6 @@ // Ensure that when rebuilding a module we don't save its old modtime when // building modules that depend on it. -// REQUIRES: shell // RUN: rm -rf %t // RUN: mkdir -p %t // This could be replaced by diamond_*, except we want to modify the top header diff --git a/test/Modules/odr.cpp b/test/Modules/odr.cpp index 5ab10d2ce419..120ca20e0a87 100644 --- a/test/Modules/odr.cpp +++ b/test/Modules/odr.cpp @@ -6,6 +6,9 @@ struct X { // expected-note {{definition has no member 'n'}} }; @import a; + +bool b = F<int>{0} == F<int>{1}; + @import b; // Trigger the declarations from a and b to be imported. diff --git a/test/Modules/pch-used.m b/test/Modules/pch-used.m index 56961ba404cc..74f21f5dac0f 100644 --- a/test/Modules/pch-used.m +++ b/test/Modules/pch-used.m @@ -4,5 +4,6 @@ // RUN: %clang_cc1 %s -include-pch %t/pch-used.h.pch -fmodules -fmodules-cache-path=%t/cache -O0 -isystem %S/Inputs/System/usr/include -emit-llvm -o - | FileCheck %s void f() { SPXTrace(); } +void g() { double x = DBL_MAX; } // CHECK: define internal void @SPXTrace diff --git a/test/Modules/pr19692.cpp b/test/Modules/pr19692.cpp new file mode 100644 index 000000000000..6cc515312f00 --- /dev/null +++ b/test/Modules/pr19692.cpp @@ -0,0 +1,7 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -I%S/Inputs/pr19692 -verify %s +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/pr19692 -verify %s +#include "TFoo.h" +#include "stdint.h" + +int k = INT64_MAX; // expected-no-diagnostics diff --git a/test/Modules/pr20399.cpp b/test/Modules/pr20399.cpp new file mode 100644 index 000000000000..4f4a02561fc2 --- /dev/null +++ b/test/Modules/pr20399.cpp @@ -0,0 +1,2 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodule-name=libGdml -emit-module -x c++ -std=c++11 %S/Inputs/PR20399/module.modulemap diff --git a/test/Modules/pr20786.cpp b/test/Modules/pr20786.cpp new file mode 100644 index 000000000000..4c0426ed5e58 --- /dev/null +++ b/test/Modules/pr20786.cpp @@ -0,0 +1,2 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodule-name=TBranchProxy -emit-module -x c++ %S/Inputs/PR20786/module.modulemap diff --git a/test/Modules/pr21217.cpp b/test/Modules/pr21217.cpp new file mode 100644 index 000000000000..a439c97e9577 --- /dev/null +++ b/test/Modules/pr21217.cpp @@ -0,0 +1,3 @@ +// RUN: not %clang_cc1 -fmodules -fmodule-map-file=does-not-exist.modulemap -verify %s 2>&1 | FileCheck %s + +// CHECK: module map file 'does-not-exist.modulemap' not found diff --git a/test/Modules/preprocess.m b/test/Modules/preprocess.m new file mode 100644 index 000000000000..5c32997f62fb --- /dev/null +++ b/test/Modules/preprocess.m @@ -0,0 +1,21 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -include %S/Inputs/preprocess-prefix.h -E %s | FileCheck -strict-whitespace %s +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -x objective-c-header -emit-pch %S/Inputs/preprocess-prefix.h -o %t.pch +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs -include-pch %t.pch -E %s | FileCheck -strict-whitespace %s +#import "diamond_right.h" +#import "diamond_right.h" // to check that imports get their own line +void test() { + top_left_before(); + left_and_right(); +} + + +// CHECK: int left_and_right(int *);{{$}} +// CHECK-NEXT: @import diamond_left; /* clang -E: implicit import for "{{.*}}diamond_left.h" */{{$}} + +// CHECK: @import diamond_right; /* clang -E: implicit import for "{{.*}}diamond_right.h" */{{$}} +// CHECK: @import diamond_right; /* clang -E: implicit import for "{{.*}}diamond_right.h" */{{$}} +// CHECK-NEXT: void test() {{{$}} +// CHECK-NEXT: top_left_before();{{$}} +// CHECK-NEXT: left_and_right();{{$}} +// CHECK-NEXT: }{{$}} diff --git a/test/Modules/rebuild.m b/test/Modules/rebuild.m new file mode 100644 index 000000000000..4d4d05529e7d --- /dev/null +++ b/test/Modules/rebuild.m @@ -0,0 +1,45 @@ +// RUN: rm -rf %t + +// Build Module and set its timestamp +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: touch -m -a -t 201101010000 %t/Module.pcm +// RUN: cp %t/Module.pcm %t/Module.pcm.saved +// RUN: wc -c %t/Module.pcm > %t/Module.size.saved + +// Build DependsOnModule +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: diff %t/Module.pcm %t/Module.pcm.saved +// RUN: cp %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved + +// Rebuild Module, reset its timestamp, and verify its size hasn't changed +// RUN: rm %t/Module.pcm +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: touch -m -a -t 201101010000 %t/Module.pcm +// RUN: wc -c %t/Module.pcm > %t/Module.size +// RUN: diff %t/Module.size %t/Module.size.saved +// RUN: cp %t/Module.pcm %t/Module.pcm.saved.2 + +// But the signature at least is expected to change, so we rebuild DependsOnModule. +// NOTE: if we change how the signature is created, this test may need updating. +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: diff %t/Module.pcm %t/Module.pcm.saved.2 +// RUN: not diff %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved + +// Rebuild Module, reset its timestamp, and verify its size hasn't changed +// RUN: rm %t/Module.pcm +// RUN: echo '@import Module;' | %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs -x objective-c - +// RUN: touch -m -a -t 201101010000 %t/Module.pcm +// RUN: wc -c %t/Module.pcm > %t/Module.size +// RUN: diff %t/Module.size %t/Module.size.saved +// RUN: cp %t/Module.pcm %t/Module.pcm.saved.2 + +// Verify again with Module pre-imported. +// NOTE: if we change how the signature is created, this test may need updating. +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fdisable-module-hash -fsyntax-only -F %S/Inputs %s +// RUN: diff %t/Module.pcm %t/Module.pcm.saved.2 +// RUN: not diff %t/DependsOnModule.pcm %t/DependsOnModule.pcm.saved + +#ifdef PREIMPORT +@import Module; +#endif +@import DependsOnModule; diff --git a/test/Modules/relative-dep-gen.cpp b/test/Modules/relative-dep-gen.cpp new file mode 100644 index 000000000000..c8171777154a --- /dev/null +++ b/test/Modules/relative-dep-gen.cpp @@ -0,0 +1,26 @@ +// REQUIRES: shell +// +// RUN: cd %S +// RUN: rm -rf %t +// RUN: mkdir %t +// +// RUN: %clang_cc1 -cc1 -fmodule-name=relative-dep-gen -emit-module -x c++ Inputs/relative-dep-gen.modulemap -dependency-file %t/build.d -MT mod.pcm -o %t/mod.pcm +// RUN: %clang_cc1 -cc1 -fmodule-map-file=Inputs/relative-dep-gen.modulemap -fmodule-file=%t/mod.pcm -dependency-file %t/use-explicit.d -MT use.o relative-dep-gen.cpp -fsyntax-only +// RUN: %clang_cc1 -cc1 -fmodule-map-file=Inputs/relative-dep-gen.modulemap -dependency-file %t/use-implicit.d relative-dep-gen.cpp -MT use.o -fsyntax-only +// +// RUN: FileCheck --check-prefix=CHECK-BUILD %s < %t/build.d +// RUN: FileCheck --check-prefix=CHECK-USE %s < %t/use-explicit.d +// RUN: FileCheck --check-prefix=CHECK-USE %s < %t/use-implicit.d +// +// RUN: %clang_cc1 -cc1 -fmodule-name=relative-dep-gen -emit-module -x c++ Inputs/relative-dep-gen-cwd.modulemap -dependency-file %t/build-cwd.d -MT mod.pcm -o %t/mod-cwd.pcm -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -cc1 -fmodule-map-file=Inputs/relative-dep-gen-cwd.modulemap -fmodule-file=%t/mod-cwd.pcm -dependency-file %t/use-explicit-cwd.d -MT use.o relative-dep-gen.cpp -fsyntax-only -fmodule-map-file-home-is-cwd +// RUN: %clang_cc1 -cc1 -fmodule-map-file=Inputs/relative-dep-gen-cwd.modulemap -dependency-file %t/use-implicit-cwd.d relative-dep-gen.cpp -MT use.o -fsyntax-only -fmodule-map-file-home-is-cwd +// +// RUN: FileCheck --check-prefix=CHECK-BUILD %s < %t/build-cwd.d +// RUN: FileCheck --check-prefix=CHECK-USE %s < %t/use-explicit-cwd.d +// RUN: FileCheck --check-prefix=CHECK-USE %s < %t/use-implicit-cwd.d + +#include "Inputs/relative-dep-gen-1.h" + +// CHECK-BUILD: mod.pcm: Inputs/relative-dep-gen-1.h Inputs/relative-dep-gen-2.h +// CHECK-USE: use.o: relative-dep-gen.cpp Inputs/relative-dep-gen-1.h diff --git a/test/Modules/require-modular-includes.m b/test/Modules/require-modular-includes.m index 835a35243396..302e4cd191cd 100644 --- a/test/Modules/require-modular-includes.m +++ b/test/Modules/require-modular-includes.m @@ -1,5 +1,4 @@ // RUN: rm -rf %t -// REQUIRES: shell // Including a header from the imported module // RUN: echo '@import FromImportedModuleOK;' | \ diff --git a/test/Modules/resolution-change.m b/test/Modules/resolution-change.m index 011782eec2bf..6882fe44c5cb 100644 --- a/test/Modules/resolution-change.m +++ b/test/Modules/resolution-change.m @@ -11,15 +11,15 @@ // Use the PCH with no way to resolve DependsOnA // RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NODOA %s -// CHECK-NODOA: module 'DependsOnA' imported by AST file '{{.*A.pch}}' not found +// CHECK-NODOA: module 'DependsOnA' in AST file '{{.*DependsOnA.*pcm}}' (imported by AST file '{{.*A.pch}}') is not defined in any loaded module map // Use the PCH with no way to resolve A // RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NOA %s -// CHECK-NOA: module 'A' imported by AST file '{{.*DependsOnA.*pcm}}' not found +// CHECK-NOA: module 'A' in AST file '{{.*A.*pcm}}' (imported by AST file '{{.*DependsOnA.*pcm}}') is not defined in any loaded module map -// Use the PCH and have it resolve the the other A +// Use the PCH and have it resolve to the other A // RUN: not %clang_cc1 -fmodules -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path2/A -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-WRONGA %s -// CHECK-WRONGA: module 'A' imported by AST file '{{.*DependsOnA.*pcm}}' found in a different module map file ({{.*path2.*}}) than when the importing AST file was built ({{.*path1.*}}) +// CHECK-WRONGA: module 'A' was built in directory '{{.*Inputs.modules-with-same-name.path1.A}}' but now resides in directory '{{.*Inputs.modules-with-same-name.path2.A}}' #ifndef HEADER #define HEADER diff --git a/test/Modules/stddef.c b/test/Modules/stddef.c new file mode 100644 index 000000000000..aefc90f9a117 --- /dev/null +++ b/test/Modules/stddef.c @@ -0,0 +1,13 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -I%S/Inputs/StdDef %s -verify -fno-modules-error-recovery + +#include "ptrdiff_t.h" + +ptrdiff_t pdt; + +size_t st; // expected-error {{must be imported}} +// expected-note@stddef.h:* {{previous}} + +#include "include_again.h" + +size_t st2; diff --git a/test/Modules/system_headers.m b/test/Modules/system_headers.m index 39b13ca5fc4a..8adc7e857699 100644 --- a/test/Modules/system_headers.m +++ b/test/Modules/system_headers.m @@ -1,8 +1,13 @@ // Test that system-headerness works for building modules. // RUN: rm -rf %t -// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t/cache -isystem %S/Inputs -pedantic -Werror %s -verify +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t/cache -isystem %S/Inputs -pedantic -Werror %s -verify -std=c11 // expected-no-diagnostics @import warning; int i = bigger_than_int; + +#include <stddef.h> + +#define __need_size_t +#include <stddef.h> diff --git a/test/Modules/system_version.m b/test/Modules/system_version.m index bc82bf8bc17b..55174ef1506c 100644 --- a/test/Modules/system_version.m +++ b/test/Modules/system_version.m @@ -1,6 +1,5 @@ // Test checking that we're hashing a system version file in the // module hash. -// REQUIRES: shell // First, build a system root. // RUN: rm -rf %t diff --git a/test/Modules/templates-2.mm b/test/Modules/templates-2.mm new file mode 100644 index 000000000000..b7ceafbbc5ba --- /dev/null +++ b/test/Modules/templates-2.mm @@ -0,0 +1,36 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -verify %s -Wno-objc-root-class +// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs -emit-llvm %s -o - -Wno-objc-root-class | FileCheck %s +// expected-no-diagnostics + +@import templates_top; + +struct TestEmitDefaultedSpecialMembers { + EmitDefaultedSpecialMembers::SmallVector<char, 256> V; +}; + +@import templates_left; + +void testEmitDefaultedSpecialMembers() { + EmitDefaultedSpecialMembers::SmallString<256> V; + // CHECK: call {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EEC1Ev( + // CHECK: call {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EED1Ev( +} + +// CHECK-LABEL: define {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EEC1Ev( +// CHECK: call {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EEC2Ev( + +// CHECK-LABEL: define {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EED1Ev( +// CHECK: call {{.*}} @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EED2Ev( + +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EED2Ev( +// CHECK: call void @_ZN27EmitDefaultedSpecialMembers11SmallVectorIcLj256EED2Ev( +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers11SmallVectorIcLj256EED2Ev( +// CHECK: call void @_ZN27EmitDefaultedSpecialMembers15SmallVectorImplIcED2Ev( +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers15SmallVectorImplIcED2Ev( + +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers11SmallStringILj256EEC2Ev( +// CHECK: call void @_ZN27EmitDefaultedSpecialMembers11SmallVectorIcLj256EEC2Ev( +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers11SmallVectorIcLj256EEC2Ev( +// CHECK: call void @_ZN27EmitDefaultedSpecialMembers15SmallVectorImplIcEC2Ev( +// CHECK-LABEL: define linkonce_odr void @_ZN27EmitDefaultedSpecialMembers15SmallVectorImplIcEC2Ev( diff --git a/test/Modules/templates.mm b/test/Modules/templates.mm index 78348af41e77..d60b873d0f38 100644 --- a/test/Modules/templates.mm +++ b/test/Modules/templates.mm @@ -12,10 +12,11 @@ void testInlineRedeclEarly() { @import templates_right; -// CHECK: @list_left = global { %{{.*}}*, i32, [4 x i8] } { %{{.*}}* null, i32 8, -// CHECK: @list_right = global { %{{.*}}*, i32, [4 x i8] } { %{{.*}}* null, i32 12, -// CHECK: @_ZZ15testMixedStructvE1l = {{.*}} constant { %{{.*}}*, i32, [4 x i8] } { %{{.*}}* null, i32 1, -// CHECK: @_ZZ15testMixedStructvE1r = {{.*}} constant { %{{.*}}*, i32, [4 x i8] } { %{{.*}}* null, i32 2, +// CHECK-DAG: @list_left = global %class.List { %"struct.List<int>::node"* null, i32 8 }, align 8 +// CHECK-DAG: @list_right = global %class.List { %"struct.List<int>::node"* null, i32 12 }, align 8 +// CHECK-DAG: @_ZZ15testMixedStructvE1l = {{.*}} constant %class.List { %{{.*}}* null, i32 1 }, align 8 +// CHECK-DAG: @_ZZ15testMixedStructvE1r = {{.*}} constant %class.List { %{{.*}}* null, i32 2 }, align 8 +// CHECK-DAG: @_ZN29WithUndefinedStaticDataMemberIA_iE9undefinedE = external global void testTemplateClasses() { Vector<int> vec_int; @@ -100,3 +101,17 @@ template struct ExplicitInstantiation<false, true>; template struct ExplicitInstantiation<true, true>; void testDelayUpdatesImpl() { testDelayUpdates<int>(); } + +void testStaticDataMember() { + WithUndefinedStaticDataMember<int[]> load_it; + + // CHECK-LABEL: define linkonce_odr i32* @_Z23getStaticDataMemberLeftv( + // CHECK: ret i32* getelementptr inbounds ([0 x i32]* @_ZN29WithUndefinedStaticDataMemberIA_iE9undefinedE, i32 0, i32 0) + (void) getStaticDataMemberLeft(); + + // CHECK-LABEL: define linkonce_odr i32* @_Z24getStaticDataMemberRightv( + // CHECK: ret i32* getelementptr inbounds ([0 x i32]* @_ZN29WithUndefinedStaticDataMemberIA_iE9undefinedE, i32 0, i32 0) + (void) getStaticDataMemberRight(); +} + + diff --git a/test/Modules/textual-headers.cpp b/test/Modules/textual-headers.cpp new file mode 100644 index 000000000000..cab9991e3291 --- /dev/null +++ b/test/Modules/textual-headers.cpp @@ -0,0 +1,18 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodule-maps -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify +// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodules-strict-decluse -fmodule-name=XG -I %S/Inputs/declare-use %s -verify -fno-modules-error-recovery + +#define GIMME_A_K +#include "k.h" + +#define GIMME_AN_L +#include "l.h" // expected-error {{module XG does not depend on a module exporting 'l.h'}} + +#include "m2.h" // expected-error {{module XG does not depend on a module exporting 'm2.h'}} +const int use_m = m; // expected-error {{undeclared identifier}} + +#define GIMME_AN_M +#include "m.h" // expected-error {{use of private header from outside its module: 'm.h'}} +const int use_m_2 = m; + +const int g = k + l; diff --git a/test/Modules/va_list.m b/test/Modules/va_list.m new file mode 100644 index 000000000000..5a305180fcfa --- /dev/null +++ b/test/Modules/va_list.m @@ -0,0 +1,27 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \ +// RUN: -x objective-c-header %s -o %t.pch -emit-pch + +// Include the pch, as a sanity check. +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \ +// RUN: -x objective-c %s -fsyntax-only + +// Repeat the previous emit-pch, but not we will have a global module index. +// For some reason, this results in an identifier for __va_list_tag being +// emitted into the pch. +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: -fmodules-ignore-macro=PREFIX -DPREFIX -I %S/Inputs/va_list \ +// RUN: -x objective-c-header %s -o %t.pch -emit-pch + +// Include the pch, which now has __va_list_tag in it, which needs to be merged. +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -fmodules -fmodules-cache-path=%t \ +// RUN: -fmodules-ignore-macro=PREFIX -I %S/Inputs/va_list -include-pch %t.pch \ +// RUN: -x objective-c %s -fsyntax-only + +// rdar://18039719 + +#ifdef PREFIX +@import va_list_b; +#endif diff --git a/test/Modules/validate-system-headers.m b/test/Modules/validate-system-headers.m index 48ea64c5a938..8cdc886322bd 100644 --- a/test/Modules/validate-system-headers.m +++ b/test/Modules/validate-system-headers.m @@ -5,39 +5,37 @@ //// // Build a module using a system header -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: cp %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // Modify the system header, and confirm that we don't notice without -fmodules-validate-system-headers. // The pcm file in the cache should fail to validate. // RUN: echo ' ' >> %t/Inputs/usr/include/foo.h -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // Now make sure we rebuild the module when -fmodules-validate-system-headers is set. -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s // RUN: not diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved //// // This should override -fmodules-validate-once-per-build-session // RUN: cp %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved // Modify the system header... // RUN: echo ' ' >> %t/Inputs/usr/include/foo.h // Don't recompile due to -fmodules-validate-once-per-build-session -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved // Now add -fmodules-validate-system-headers and rebuild -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t/Inputs -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session +// RUN: %clang_cc1 -isystem %t/Inputs/usr/include -fmodules -fmodules-validate-system-headers -fmodules-cache-path=%t/ModuleCache -fdisable-module-hash -x objective-c-header -fsyntax-only %s -fbuild-session-timestamp=1390000000 -fmodules-validate-once-per-build-session // RUN: not diff %t/ModuleCache/Foo.pcm %t/Foo.pcm.saved -// REQUIRES: shell - @import Foo; diff --git a/test/Modules/warn-unused-local-typedef.cpp b/test/Modules/warn-unused-local-typedef.cpp new file mode 100644 index 000000000000..60e0612d6ce7 --- /dev/null +++ b/test/Modules/warn-unused-local-typedef.cpp @@ -0,0 +1,9 @@ +// RUN: rm -rf %t +// RUN: %clang -Wunused-local-typedef -c -x objective-c++ -fcxx-modules -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK_1 +// RUN: %clang -Wunused-local-typedef -c -x objective-c++ -fcxx-modules -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=CHECK_2 -allow-empty + +// For modules, the warning should only fire the first time, when the module is +// built. +// CHECK_1: warning: unused typedef +// CHECK_2-NOT: warning: unused typedef +@import warn_unused_local_typedef; diff --git a/test/OpenMP/atomic_ast_print.cpp b/test/OpenMP/atomic_ast_print.cpp new file mode 100644 index 000000000000..e75d291eab51 --- /dev/null +++ b/test/OpenMP/atomic_ast_print.cpp @@ -0,0 +1,176 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +template <class T> +T foo(T argc) { + T b = T(); + T a = T(); +#pragma omp atomic + a++; +#pragma omp atomic read + a = argc; +#pragma omp atomic write + a = argc + argc; +#pragma omp atomic update + a = a + argc; +#pragma omp atomic capture + a = b++; +#pragma omp atomic capture + { + a = b; + b++; + } +#pragma omp atomic seq_cst + a++; +#pragma omp atomic read seq_cst + a = argc; +#pragma omp atomic seq_cst write + a = argc + argc; +#pragma omp atomic update seq_cst + a = a + argc; +#pragma omp atomic seq_cst capture + a = b++; +#pragma omp atomic capture seq_cst + { + a = b; + b++; + } + return T(); +} + +// CHECK: int a = int(); +// CHECK-NEXT: #pragma omp atomic +// CHECK-NEXT: a++; +// CHECK-NEXT: #pragma omp atomic read +// CHECK-NEXT: a = argc; +// CHECK-NEXT: #pragma omp atomic write +// CHECK-NEXT: a = argc + argc; +// CHECK-NEXT: #pragma omp atomic update +// CHECK-NEXT: a = a + argc; +// CHECK-NEXT: #pragma omp atomic capture +// CHECK-NEXT: a = b++; +// CHECK-NEXT: #pragma omp atomic capture +// CHECK-NEXT: { +// CHECK-NEXT: a = b; +// CHECK-NEXT: b++; +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp atomic seq_cst +// CHECK-NEXT: a++; +// CHECK-NEXT: #pragma omp atomic read seq_cst +// CHECK-NEXT: a = argc; +// CHECK-NEXT: #pragma omp atomic seq_cst write +// CHECK-NEXT: a = argc + argc; +// CHECK-NEXT: #pragma omp atomic update seq_cst +// CHECK-NEXT: a = a + argc; +// CHECK-NEXT: #pragma omp atomic seq_cst capture +// CHECK-NEXT: a = b++; +// CHECK-NEXT: #pragma omp atomic capture seq_cst +// CHECK-NEXT: { +// CHECK-NEXT: a = b; +// CHECK-NEXT: b++; +// CHECK-NEXT: } +// CHECK: T a = T(); +// CHECK-NEXT: #pragma omp atomic +// CHECK-NEXT: a++; +// CHECK-NEXT: #pragma omp atomic read +// CHECK-NEXT: a = argc; +// CHECK-NEXT: #pragma omp atomic write +// CHECK-NEXT: a = argc + argc; +// CHECK-NEXT: #pragma omp atomic update +// CHECK-NEXT: a = a + argc; +// CHECK-NEXT: #pragma omp atomic capture +// CHECK-NEXT: a = b++; +// CHECK-NEXT: #pragma omp atomic capture +// CHECK-NEXT: { +// CHECK-NEXT: a = b; +// CHECK-NEXT: b++; +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp atomic seq_cst +// CHECK-NEXT: a++; +// CHECK-NEXT: #pragma omp atomic read seq_cst +// CHECK-NEXT: a = argc; +// CHECK-NEXT: #pragma omp atomic seq_cst write +// CHECK-NEXT: a = argc + argc; +// CHECK-NEXT: #pragma omp atomic update seq_cst +// CHECK-NEXT: a = a + argc; +// CHECK-NEXT: #pragma omp atomic seq_cst capture +// CHECK-NEXT: a = b++; +// CHECK-NEXT: #pragma omp atomic capture seq_cst +// CHECK-NEXT: { +// CHECK-NEXT: a = b; +// CHECK-NEXT: b++; +// CHECK-NEXT: } + +int main(int argc, char **argv) { + int b = 0; + int a = 0; +// CHECK: int a = 0; +#pragma omp atomic + a++; +#pragma omp atomic read + a = argc; +#pragma omp atomic write + a = argc + argc; +#pragma omp atomic update + a = a + argc; +#pragma omp atomic capture + a = b++; +#pragma omp atomic capture + { + a = b; + b++; + } +#pragma omp atomic seq_cst + a++; +#pragma omp atomic read seq_cst + a = argc; +#pragma omp atomic seq_cst write + a = argc + argc; +#pragma omp atomic update seq_cst + a = a + argc; +#pragma omp atomic seq_cst capture + a = b++; +#pragma omp atomic capture seq_cst + { + a = b; + b++; + } + // CHECK-NEXT: #pragma omp atomic + // CHECK-NEXT: a++; + // CHECK-NEXT: #pragma omp atomic read + // CHECK-NEXT: a = argc; + // CHECK-NEXT: #pragma omp atomic write + // CHECK-NEXT: a = argc + argc; + // CHECK-NEXT: #pragma omp atomic update + // CHECK-NEXT: a = a + argc; + // CHECK-NEXT: #pragma omp atomic capture + // CHECK-NEXT: a = b++; + // CHECK-NEXT: #pragma omp atomic capture + // CHECK-NEXT: { + // CHECK-NEXT: a = b; + // CHECK-NEXT: b++; + // CHECK-NEXT: } + // CHECK-NEXT: #pragma omp atomic seq_cst + // CHECK-NEXT: a++; + // CHECK-NEXT: #pragma omp atomic read seq_cst + // CHECK-NEXT: a = argc; + // CHECK-NEXT: #pragma omp atomic seq_cst write + // CHECK-NEXT: a = argc + argc; + // CHECK-NEXT: #pragma omp atomic update seq_cst + // CHECK-NEXT: a = a + argc; + // CHECK-NEXT: #pragma omp atomic seq_cst capture + // CHECK-NEXT: a = b++; + // CHECK-NEXT: #pragma omp atomic capture seq_cst + // CHECK-NEXT: { + // CHECK-NEXT: a = b; + // CHECK-NEXT: b++; + // CHECK-NEXT: } + return foo(a); +} + +#endif diff --git a/test/OpenMP/atomic_messages.c b/test/OpenMP/atomic_messages.c new file mode 100644 index 000000000000..ae490ee0841a --- /dev/null +++ b/test/OpenMP/atomic_messages.c @@ -0,0 +1,102 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +int foo() { +L1: + foo(); +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { + foo(); + L2: + foo(); + } + + return 0; +} + +struct S { + int a; +}; + +int readint() { + int a = 0, b = 0; +// Test for atomic read +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected lvalue expression}} + a = 0; +#pragma omp atomic read + a = b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} +#pragma omp atomic read read + a = b; + + return 0; +} + +int readS() { + struct S a, b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} +#pragma omp atomic read read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected expression of scalar type}} + a = b; + + return a.a; +} + +int writeint() { + int a = 0, b = 0; +// Test for atomic write +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic write + a = 0; +#pragma omp atomic write + a = b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} +#pragma omp atomic write write + a = b; + + return 0; +} + +int writeS() { + struct S a, b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} +#pragma omp atomic write write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected expression of scalar type}} + a = b; + + return a.a; +} diff --git a/test/OpenMP/atomic_messages.cpp b/test/OpenMP/atomic_messages.cpp new file mode 100644 index 000000000000..a6c07ad9e289 --- /dev/null +++ b/test/OpenMP/atomic_messages.cpp @@ -0,0 +1,297 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +int foo() { +L1: + foo(); +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { + foo(); + L2: + foo(); + } + + return 0; +} + +struct S { + int a; + S &operator=(int v) { + a = v; + return *this; + } + S &operator+=(const S &s) { + a += s.a; + return *this; + } +}; + +template <class T> +T read() { + T a = T(), b = T(); +// Test for atomic read +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected lvalue expression}} + a = 0; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a = b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} +#pragma omp atomic read read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a = b; + + return a; +} + +int read() { + int a = 0, b = 0; +// Test for atomic read +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic read + // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}} + // expected-note@+1 {{expected lvalue expression}} + a = 0; +#pragma omp atomic read + a = b; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} +#pragma omp atomic read read + a = b; + + // expected-note@+1 {{in instantiation of function template specialization 'read<S>' requested here}} + return read<int>() + read<S>().a; +} + +template <class T> +T write() { + T a, b = 0; +// Test for atomic write +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} +#pragma omp atomic write write + a = b; +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic write + a = 0; +#pragma omp atomic write + a = b; + + return T(); +} + +int write() { + int a, b = 0; +// Test for atomic write +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} +#pragma omp atomic write write + a = b; +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + foo(); +#pragma omp atomic write + // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}} + // expected-note@+1 {{expected built-in assignment operator}} + a += b; +#pragma omp atomic write + a = 0; +#pragma omp atomic write + a = foo(); + + return write<int>(); +} + +template <class T> +T update() { + T a, b = 0; +// Test for atomic update +#pragma omp atomic update + // expected-error@+1 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}} +#pragma omp atomic update update + a += b; + +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; + + return T(); +} + +int update() { + int a, b = 0; +// Test for atomic update +#pragma omp atomic update + // expected-error@+1 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}} +#pragma omp atomic update update + a += b; + +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; + + return update<int>(); +} + +template <class T> +T capture() { + T a, b = 0; +// Test for atomic capture +#pragma omp atomic capture + // expected-error@+1 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both l-value expressions with scalar type}} + ++a; +#pragma omp atomic capture + // expected-error@+1 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} +#pragma omp atomic capture capture + a = ++b; + + return T(); +} + +int capture() { + int a, b = 0; +// Test for atomic capture +#pragma omp atomic capture + // expected-error@+1 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both l-value expressions with scalar type}} + ++a; +#pragma omp atomic capture + // expected-error@+1 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} +#pragma omp atomic capture capture + a = ++b; + + return capture<int>(); +} + +template <class T> +T seq_cst() { + T a, b = 0; +// Test for atomic seq_cst +#pragma omp atomic seq_cst + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}} +#pragma omp atomic seq_cst seq_cst + a += b; + +#pragma omp atomic update seq_cst + // expected-error@+1 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; + + return T(); +} + +int seq_cst() { + int a, b = 0; +// Test for atomic seq_cst +#pragma omp atomic seq_cst + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; +// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}} +#pragma omp atomic seq_cst seq_cst + a += b; + +#pragma omp atomic update seq_cst + // expected-error@+1 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + ; + + return seq_cst<int>(); +} + +template <class T> +T mixed() { + T a, b = T(); +// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 2 {{'read' clause used here}} +#pragma omp atomic read write + a = b; +// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 2 {{'write' clause used here}} +#pragma omp atomic write read + a = b; +// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 2 {{'update' clause used here}} +#pragma omp atomic update read + a += b; +// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 2 {{'capture' clause used here}} +#pragma omp atomic capture read + a = ++b; + return T(); +} + +int mixed() { + int a, b = 0; +// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 {{'read' clause used here}} +#pragma omp atomic read write + a = b; +// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 {{'write' clause used here}} +#pragma omp atomic write read + a = b; +// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 {{'write' clause used here}} +#pragma omp atomic write update + a = b; +// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update' or 'capture' clause}} +// expected-note@+1 {{'write' clause used here}} +#pragma omp atomic write capture + a = b; + // expected-note@+1 {{in instantiation of function template specialization 'mixed<int>' requested here}} + return mixed<int>(); +} + diff --git a/test/OpenMP/barrier_codegen.cpp b/test/OpenMP/barrier_codegen.cpp new file mode 100644 index 000000000000..2e817c138c3c --- /dev/null +++ b/test/OpenMP/barrier_codegen.cpp @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +// CHECK: [[IDENT_T:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-DAG: [[EXPLICIT_BARRIER_LOC:@.+]] = {{.+}} [[IDENT_T]] { i32 0, i32 34, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]+}} x i8]* @{{.+}}, i32 0, i32 0) } +// CHECK-DAG: [[LOC:@.+]] = {{.+}} [[IDENT_T]] { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]+}} x i8]* @{{.+}}, i32 0, i32 0) } + +void foo() {} + +template <class T> +T tmain(T argc) { + static T a; +#pragma omp barrier + return a + argc; +} + +// CHECK-LABEL: @main +int main(int argc, char **argv) { + static int a; +#pragma omp barrier + // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) + // CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) + // CHECK: call {{.+}} [[TMAIN_INT:@.+]](i{{[0-9][0-9]}} + // CHECK: call {{.+}} [[TMAIN_CHAR:@.+]](i{{[0-9]}} + return tmain(argc) + tmain(argv[0][0]) + a; +} + +// CHECK: define {{.+}} [[TMAIN_INT]]( +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) +// CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) + +// CHECK: define {{.+}} [[TMAIN_CHAR]]( +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T]]* [[LOC]]) +// CHECK: call i32 @__kmpc_cancel_barrier([[IDENT_T]]* [[EXPLICIT_BARRIER_LOC]], i32 [[GTID]]) + +#endif diff --git a/test/OpenMP/critical_codegen.cpp b/test/OpenMP/critical_codegen.cpp new file mode 100644 index 000000000000..dda532ca369b --- /dev/null +++ b/test/OpenMP/critical_codegen.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK: [[UNNAMED_LOCK:@.+]] = common global [8 x i32] zeroinitializer +// CHECK: [[THE_NAME_LOCK:@.+]] = common global [8 x i32] zeroinitializer + +// CHECK: define void [[FOO:@.+]]() + +void foo() {} + +// CHECK-LABEL: @main +int main() { +// CHECK: [[A_ADDR:%.+]] = alloca i8 + char a; + +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) +// CHECK: call void @__kmpc_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) +// CHECK-NEXT: store i8 2, i8* [[A_ADDR]] +// CHECK-NEXT: call void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[UNNAMED_LOCK]]) +#pragma omp critical + a = 2; +// CHECK: call void @__kmpc_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) +// CHECK-NEXT: call void [[FOO]]() +// CHECK-NEXT: call void @__kmpc_end_critical([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], [8 x i32]* [[THE_NAME_LOCK]]) +#pragma omp critical(the_name) + foo(); +// CHECK-NOT: call void @__kmpc_critical +// CHECK-NOT: call void @__kmpc_end_critical + return a; +} + +#endif diff --git a/test/OpenMP/flush_codegen.cpp b/test/OpenMP/flush_codegen.cpp new file mode 100644 index 000000000000..eb9c721e3508 --- /dev/null +++ b/test/OpenMP/flush_codegen.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +template <class T> +T tmain(T argc) { + static T a; +#pragma omp flush +#pragma omp flush(a) + return a + argc; +} + +// CHECK-LABEL: @main +int main() { + static int a; +#pragma omp flush +#pragma omp flush(a) + // CHECK: call void (%{{.+}}*, ...)* @__kmpc_flush(%{{.+}}* {{(@|%).+}}, i32 0) + // CHECK: call void (%{{.+}}*, ...)* @__kmpc_flush(%{{.+}}* {{(@|%).+}}, i32 0) + return tmain(a); + // CHECK: call {{.*}} [[TMAIN:@.+]]( + // CHECK: ret +} + +// CHECK: [[TMAIN]] +// CHECK: call void (%{{.+}}*, ...)* @__kmpc_flush(%{{.+}}* {{(@|%).+}}, i32 0) +// CHECK: call void (%{{.+}}*, ...)* @__kmpc_flush(%{{.+}}* {{(@|%).+}}, i32 0) +// CHECK: ret + +#endif diff --git a/test/OpenMP/for_codegen.cpp b/test/OpenMP/for_codegen.cpp new file mode 100644 index 000000000000..757de65df46a --- /dev/null +++ b/test/OpenMP/for_codegen.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-LABEL: define {{.*void}} @{{.*}}without_schedule_clause{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}}) +void without_schedule_clause(float *a, float *b, float *c, float *d) { +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]]) + #pragma omp for +// CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1) +// UB = min(UB, GlobalUB) +// CHECK-NEXT: [[UB:%.+]] = load i32* [[OMP_UB]] +// CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423 +// CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]] +// CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ] +// CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]] +// CHECK-NEXT: [[LB:%.+]] = load i32* [[OMP_LB]] +// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]] +// Loop header +// CHECK: [[IV:%.+]] = load i32* [[OMP_IV]] +// CHECK-NEXT: [[UB:%.+]] = load i32* [[OMP_UB]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]] +// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]] + for (int i = 33; i < 32000000; i += 7) { +// CHECK: [[LOOP1_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV1_1:%.+]] = load i32* [[OMP_IV]] +// CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 33, [[CALC_I_1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* {{%.+}} + a[i] = b[i] * c[i] * d[i]; +// CHECK: [[IV1_2:%.+]] = load i32* [[OMP_IV]]{{.*}} +// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1 +// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]] +// CHECK-NEXT: br label %{{.+}} + } +// CHECK: [[LOOP1_END]] +// CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: ret void +} + +// CHECK-LABEL: define {{.*void}} @{{.*}}static_not_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}}) +void static_not_chunked(float *a, float *b, float *c, float *d) { +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]]) + #pragma omp for schedule(static) +// CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1) +// UB = min(UB, GlobalUB) +// CHECK-NEXT: [[UB:%.+]] = load i32* [[OMP_UB]] +// CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423 +// CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]] +// CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ] +// CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]] +// CHECK-NEXT: [[LB:%.+]] = load i32* [[OMP_LB]] +// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]] +// Loop header +// CHECK: [[IV:%.+]] = load i32* [[OMP_IV]] +// CHECK-NEXT: [[UB:%.+]] = load i32* [[OMP_UB]] +// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]] +// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]] + for (int i = 32000000; i > 33; i += -7) { +// CHECK: [[LOOP1_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV1_1:%.+]] = load i32* [[OMP_IV]] +// CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7 +// CHECK-NEXT: [[CALC_I_2:%.+]] = sub nsw i32 32000000, [[CALC_I_1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* {{%.+}} + a[i] = b[i] * c[i] * d[i]; +// CHECK: [[IV1_2:%.+]] = load i32* [[OMP_IV]]{{.*}} +// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1 +// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]] +// CHECK-NEXT: br label %{{.+}} + } +// CHECK: [[LOOP1_END]] +// CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[DEFAULT_LOC_BARRIER:[@%].+]], i32 [[GTID]]) +// CHECK: ret void +} + +#endif // HEADER + diff --git a/test/OpenMP/for_firstprivate_messages.cpp b/test/OpenMP/for_firstprivate_messages.cpp index f1d21b8ce5af..6aa977b65d92 100644 --- a/test/OpenMP/for_firstprivate_messages.cpp +++ b/test/OpenMP/for_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -26,23 +26,23 @@ class S3 { S3 &operator=(const S3 &s3); public: - S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3() : a(0) {} // expected-note {{candidate constructor not viable: requires 0 arguments, but 1 was provided}} + S3(S3 &s3) : a(s3.a) {} // expected-note {{candidate constructor not viable: 1st argument ('const S3') would lose const qualifier}} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note 2 {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note 4 {{'S5' declared here}} +class S5 { int a; - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} public: S5() : a(0) {} @@ -62,8 +62,8 @@ S3 h; template <class I, class C> int foomain(int argc, char **argv) { - I e(4); // expected-note {{'e' defined here}} - C g(5); // expected-note 2 {{'g' defined here}} + I e(4); + C g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel @@ -107,7 +107,7 @@ int foomain(int argc, char **argv) { for (int k = 0; k < argc; ++k) ++k; #pragma omp parallel -#pragma omp for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp for firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (int k = 0; k < argc; ++k) ++k; #pragma omp parallel @@ -138,7 +138,7 @@ int foomain(int argc, char **argv) { for (int k = 0; k < argc; ++k) ++k; #pragma omp parallel -#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel private(i) // expected-note {{defined as private}} @@ -155,8 +155,8 @@ int foomain(int argc, char **argv) { int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note 2 {{'g' defined here}} + S4 e(4); + S5 g(5); S3 m; S6 n(2); int i; @@ -194,7 +194,7 @@ int main(int argc, char **argv) { for (i = 0; i < argc; ++i) foo(); #pragma omp parallel -#pragma omp for firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} +#pragma omp for firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} expected-error {{no matching constructor for initialization of 'const S3'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel @@ -235,7 +235,7 @@ int main(int argc, char **argv) { for (i = 0; i < argc; ++i) foo(); #pragma omp parallel -#pragma omp for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp for firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel @@ -263,7 +263,7 @@ int main(int argc, char **argv) { for (i = 0; i < argc; ++i) foo(); #pragma omp parallel -#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel @@ -291,3 +291,4 @@ int main(int argc, char **argv) { return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} } + diff --git a/test/OpenMP/for_loop_messages.cpp b/test/OpenMP/for_loop_messages.cpp index 8cc882e13a9f..cb32484e43fb 100644 --- a/test/OpenMP/for_loop_messages.cpp +++ b/test/OpenMP/for_loop_messages.cpp @@ -11,6 +11,7 @@ public: static int sii; #pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} +static int globalii; int test_iteration_spaces() { const int N = 100; @@ -311,6 +312,23 @@ int test_iteration_spaces() { } #pragma omp parallel + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be a variable with global storage without being explicitly marked as private}} +#pragma omp for + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] = a[globalii]; + } + +#pragma omp parallel + { +// expected-error@+3 {{loop iteration variable in the associated loop of 'omp for' directive may not be a variable with global storage without being explicitly marked as private}} +#pragma omp for collapse(2) + for (ii = 0; ii < 10; ii += 1) + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] += a[globalii] + ii; + } + +#pragma omp parallel // expected-error@+2 {{statement after '#pragma omp for' must be a for loop}} #pragma omp for for (auto &item : a) { @@ -360,6 +378,8 @@ public: Iter0 operator--() { return *this; } bool operator<(Iter0 a) { return true; } }; +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'Iter0' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}} int operator-(Iter0 a, Iter0 b) { return 0; } class Iter1 { public: @@ -378,6 +398,7 @@ public: GoodIter &operator=(const GoodIter &that) { return *this; } GoodIter &operator=(const Iter0 &that) { return *this; } GoodIter &operator+=(int x) { return *this; } + GoodIter &operator-=(int x) { return *this; } explicit GoodIter(void *) {} GoodIter operator++() { return *this; } GoodIter operator--() { return *this; } @@ -388,11 +409,20 @@ public: typedef int difference_type; typedef std::random_access_iterator_tag iterator_category; }; +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'GoodIter' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} int operator-(GoodIter a, GoodIter b) { return 0; } +// expected-note@+1 3 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}} GoodIter operator-(GoodIter a) { return a; } +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'int' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'GoodIter' for 1st argument}} GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'int' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}} GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'int' for 1st argument}} GoodIter operator+(int v, GoodIter a) { return GoodIter(); } int test_with_random_access_iterator() { @@ -435,6 +465,8 @@ int test_with_random_access_iterator() { #pragma omp for for (begin = GoodIter(0); begin < end; ++begin) ++begin; +// expected-error@+4 {{invalid operands to binary expression ('GoodIter' and 'const Iter0')}} +// expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} #pragma omp parallel #pragma omp for for (begin = begin0; begin < end; ++begin) @@ -489,17 +521,22 @@ int test_with_random_access_iterator() { #pragma omp for for (GoodIter I = begin; I >= end; I = 2 - I) ++I; +// In the following example, we cannot update the loop variable using '+=' +// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}} #pragma omp parallel #pragma omp for for (Iter0 I = begin0; I < end0; ++I) ++I; #pragma omp parallel // Initializer is constructor without params. +// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}} // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp for for (Iter0 I; I < end0; ++I) ++I; Iter1 begin1, end1; +// expected-error@+4 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} #pragma omp parallel #pragma omp for for (Iter1 I = begin1; I < end1; ++I) @@ -511,6 +548,8 @@ int test_with_random_access_iterator() { for (Iter1 I = begin1; I >= end1; ++I) ++I; #pragma omp parallel +// expected-error@+5 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+4 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} // Initializer is constructor with all default params. // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp for diff --git a/test/OpenMP/for_misc_messages.c b/test/OpenMP/for_misc_messages.c index 854898c04432..8a721807d8dc 100644 --- a/test/OpenMP/for_misc_messages.c +++ b/test/OpenMP/for_misc_messages.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -triple x86_64-unknown-unknown -verify %s // expected-error@+1 {{unexpected OpenMP directive '#pragma omp for'}} #pragma omp for @@ -190,6 +190,16 @@ void test_collapse() { #pragma omp for collapse(5 - 5) for (i = 0; i < 16; ++i) ; +#pragma omp parallel +#pragma omp for collapse(2) + for (i = 0; i < 16; ++i) +// expected-note@+1 {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for' directive into a parallel or another task region?}} + for (int j = 0; j < 16; ++j) +// expected-error@+2 {{private variable cannot be reduction}} +// expected-error@+1 {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} +#pragma omp for reduction(+ : i, j) + for (int k = 0; k < 16; ++k) + i += j; } void test_private() { @@ -359,5 +369,11 @@ void test_loop_messages() { for (double fi = 0; fi < 10.0; fi++) { c[(int)fi] = a[(int)fi] + b[(int)fi]; } + + // expected-warning@+2 {{OpenMP loop iteration variable cannot have more than 64 bits size and will be narrowed}} + #pragma omp for + for (__int128 ii = 0; ii < 10; ii++) { + c[ii] = a[ii] + b[ii]; + } } diff --git a/test/OpenMP/for_private_messages.cpp b/test/OpenMP/for_private_messages.cpp index f7a497930d01..45c8683cfa8e 100644 --- a/test/OpenMP/for_private_messages.cpp +++ b/test/OpenMP/for_private_messages.cpp @@ -24,16 +24,16 @@ public: S3() : a(0) {} }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -109,8 +109,8 @@ int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp for private // expected-error {{expected '(' after 'private'}} @@ -143,7 +143,7 @@ int main(int argc, char **argv) { #pragma omp for private(argv[1]) // expected-error {{expected variable name}} for (int k = 0; k < argc; ++k) ++k; -#pragma omp for private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp for private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (int k = 0; k < argc; ++k) ++k; #pragma omp for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} diff --git a/test/OpenMP/for_simd_aligned_messages.cpp b/test/OpenMP/for_simd_aligned_messages.cpp new file mode 100644 index 000000000000..70131d5e5a35 --- /dev/null +++ b/test/OpenMP/for_simd_aligned_messages.cpp @@ -0,0 +1,202 @@ +// RUN: %clang_cc1 -x c++ -std=c++11 -verify -fopenmp=libiomp5 %s + +struct B { + static int ib[20]; // expected-note 0 {{'B::ib' declared here}} + static constexpr int bfoo() { return 8; } +}; +namespace X { + B x; // expected-note {{'x' defined here}} +}; +constexpr int bfoo() { return 4; } + +int **z; +const int C1 = 1; +const int C2 = 2; +void test_aligned_colons(int *&rp) +{ + int *B = 0; + #pragma omp for simd aligned(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp for simd aligned(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp for simd aligned(z:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'int **'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'B'}} + #pragma omp for simd aligned(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}} + #pragma omp for simd aligned(B,rp,::z: X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd aligned(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp for simd aligned(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}} + #pragma omp for simd aligned(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +// expected-note@+1 {{'num' defined here}} +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; + // Negative number is passed as L. + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp for simd aligned(arr:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp for simd aligned(num:4) + for (i = 0; i < num; ++i); + return T(); +} + +template<int LEN> int test_warn() { + int *ind2 = 0; + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp for simd aligned(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return 0; +} + +struct S1; // expected-note 2 {{declared here}} +extern S1 a; // expected-note {{'a' declared here}} +class S2 { + mutable int a; +public: + S2():a(0) { } +}; +const S2 b; // expected-note 1 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} +public: + S5(int v):a(v) { } +}; + +S3 h; // expected-note 2 {{'h' defined here}} +#pragma omp threadprivate(h) + +template<class I, class C> int foomain(I argc, C **argv) { + I e(argc); + I g(argc); + int i; // expected-note {{declared here}} expected-note {{'i' defined here}} + // expected-note@+2 {{declared here}} + // expected-note@+1 {{reference to 'i' is not a constant expression}} + int &j = i; + #pragma omp for simd aligned // expected-error {{expected '(' after 'aligned'}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned () // expected-error {{expected expression}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argv[1]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned(e, g) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp for simd aligned(h) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp for simd aligned(i) + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int *v = 0; + I i; + #pragma omp for simd aligned(v:16) + for (I k = 0; k < argc; ++k) { i = k; v += 2; } + } + float *f; + #pragma omp for simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + int v = 0; + // expected-note@+2 {{initializer of 'j' is not a constant expression}} + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp for simd aligned(f:j) + for (I k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp for simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + return 0; +} + +// expected-note@+1 2 {{'argc' defined here}} +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + test_warn<4>(); // ok + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + int i; + int &j = i; + #pragma omp for simd aligned // expected-error {{expected '(' after 'aligned'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argv // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp for simd aligned (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S1'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S2'}} + #pragma omp for simd aligned (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd aligned (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp for simd aligned(h) + for (int k = 0; k < argc; ++k) ++k; + int *pargc = &argc; + foomain<int*,char>(pargc,argv); + return 0; +} + diff --git a/test/OpenMP/for_simd_ast_print.cpp b/test/OpenMP/for_simd_ast_print.cpp new file mode 100644 index 000000000000..759706424692 --- /dev/null +++ b/test/OpenMP/for_simd_ast_print.cpp @@ -0,0 +1,128 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} +int g_ind = 1; +template<class T, class N> T reduct(T* arr, N num) { + N i; + N ind; + N myind; + T sum = (T)0; +// CHECK: T sum = (T)0; +#pragma omp for simd private(myind, g_ind), linear(ind), aligned(arr) +// CHECK-NEXT: #pragma omp for simd private(myind,g_ind) linear(ind) aligned(arr) + for (i = 0; i < num; ++i) { + myind = ind; + T cur = arr[myind]; + ind += g_ind; + sum += cur; + } +} + +template<class T> struct S { + S(const T &a) + :m_a(a) + {} + T result(T *v) const { + T res; + T val; + T lin = 0; +// CHECK: T res; +// CHECK: T val; +// CHECK: T lin = 0; + #pragma omp for simd private(val) safelen(7) linear(lin : -5) lastprivate(res) +// CHECK-NEXT: #pragma omp for simd private(val) safelen(7) linear(lin: -5) lastprivate(res) + for (T i = 7; i < m_a; ++i) { + val = v[i-7] + m_a; + res = val; + lin -= 5; + } + const T clen = 3; +// CHECK: T clen = 3; + #pragma omp for simd safelen(clen-1) +// CHECK-NEXT: #pragma omp for simd safelen(clen - 1) + for(T i = clen+2; i < 20; ++i) { +// CHECK-NEXT: for (T i = clen + 2; i < 20; ++i) { + v[i] = v[v-clen] + 1; +// CHECK-NEXT: v[i] = v[v - clen] + 1; + } +// CHECK-NEXT: } + return res; + } + ~S() + {} + T m_a; +}; + +template<int LEN> struct S2 { + static void func(int n, float *a, float *b, float *c) { + int k1 = 0, k2 = 0; +#pragma omp for simd safelen(LEN) linear(k1,k2:LEN) aligned(a:LEN) + for(int i = 0; i < n; i++) { + c[i] = a[i] + b[i]; + c[k1] = a[k1] + b[k1]; + c[k2] = a[k2] + b[k2]; + k1 = k1 + LEN; + k2 = k2 + LEN; + } + } +}; + +// S2<4>::func is called below in main. +// CHECK: template <int LEN = 4> struct S2 { +// CHECK-NEXT: static void func(int n, float *a, float *b, float *c) { +// CHECK-NEXT: int k1 = 0, k2 = 0; +// CHECK-NEXT: #pragma omp for simd safelen(4) linear(k1,k2: 4) aligned(a: 4) +// CHECK-NEXT: for (int i = 0; i < n; i++) { +// CHECK-NEXT: c[i] = a[i] + b[i]; +// CHECK-NEXT: c[k1] = a[k1] + b[k1]; +// CHECK-NEXT: c[k2] = a[k2] + b[k2]; +// CHECK-NEXT: k1 = k1 + 4; +// CHECK-NEXT: k2 = k2 + 4; +// CHECK-NEXT: } +// CHECK-NEXT: } + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + int k1=0,k2=0; + static int *a; +// CHECK: static int *a; +#pragma omp for simd +// CHECK-NEXT: #pragma omp for simd + for (int i=0; i < 2; ++i)*a=2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: *a = 2; +#pragma omp parallel +#pragma omp for simd private(argc, b),lastprivate(d,f) collapse(2) aligned(a : 4) ,firstprivate( g ) + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) {foo(); k1 += 8; k2 += 8;} +// CHECK-NEXT: #pragma omp parallel +// CHECK-NEXT: #pragma omp for simd private(argc,b) lastprivate(d,f) collapse(2) aligned(a: 4) firstprivate(g) +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: for (int j = 0; j < 10; ++j) { +// CHECK-NEXT: foo(); +// CHECK-NEXT: k1 += 8; +// CHECK-NEXT: k2 += 8; +// CHECK-NEXT: } + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + const int CLEN = 4; +// CHECK-NEXT: const int CLEN = 4; + #pragma omp for simd aligned(a:CLEN) linear(a:CLEN) safelen(CLEN) collapse( 1 ) +// CHECK-NEXT: #pragma omp for simd aligned(a: CLEN) linear(a: CLEN) safelen(CLEN) collapse(1) + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + + float arr[16]; + S2<4>::func(0,arr,arr,arr); + return (0); +} + +#endif diff --git a/test/OpenMP/for_simd_collapse_messages.cpp b/test/OpenMP/for_simd_collapse_messages.cpp new file mode 100644 index 000000000000..3b43f1f5d29e --- /dev/null +++ b/test/OpenMP/for_simd_collapse_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp for simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp for simd collapse (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp for simd collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp for simd', but found only 1}} + // expected-error@+3 2 {{directive '#pragma omp for simd' cannot contain more than one 'collapse' clause}} + // expected-error@+2 2 {{argument to 'collapse' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse (1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse (N) // expected-error {{argument to 'collapse' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp for simd'}} + return argc; +} + +int main(int argc, char **argv) { + #pragma omp for simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd collapse () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} + #pragma omp for simd collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} + #pragma omp for simd collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp for simd' cannot contain more than one 'collapse' clause}} + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp for simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd collapse (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp for simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp for simd collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + #pragma omp for simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp for simd'}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/for_simd_firstprivate_messages.cpp b/test/OpenMP/for_simd_firstprivate_messages.cpp new file mode 100644 index 000000000000..1345bfc9886a --- /dev/null +++ b/test/OpenMP/for_simd_firstprivate_messages.cpp @@ -0,0 +1,293 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(const S2 &s2) : a(s2.a) {} + static float S2s; + static const float S2sc; +}; +const float S2::S2sc = 0; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} + +public: + S5() : a(0) {} + S5(int v) : a(v) {} +}; +class S6 { + int a; + S6() : a(0) {} + +public: + S6(const S6 &s6) : a(s6.a) {} + S6(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(int argc, char **argv) { + I e(4); + C g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for simd firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(a, b) // expected-error {{a firstprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd linear(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for simd' directive into a parallel or another task region?}} +#pragma omp for simd firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for simd firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd firstprivate(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp for simd firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp for simd firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); + S5 g(5); + S3 m; + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for simd firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(ba) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(ca) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(da) // OK + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel +#pragma omp for simd firstprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(S2::S2s) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(S2::S2sc) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd safelen(5) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(m) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp for simd' directive may not be firstprivate, predetermined as linear}} + foo(); +#pragma omp parallel shared(xa) +#pragma omp for simd firstprivate(xa) // OK: may be firstprivate + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel + { + int v = 0; + int i; // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for simd' directive into a parallel or another task region?}} +#pragma omp for simd firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp for simd firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp for simd firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); + + return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} +} diff --git a/test/OpenMP/for_simd_lastprivate_messages.cpp b/test/OpenMP/for_simd_lastprivate_messages.cpp new file mode 100644 index 000000000000..38651e5c8e27 --- /dev/null +++ b/test/OpenMP/for_simd_lastprivate_messages.cpp @@ -0,0 +1,266 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + S5(int v) : a(v) {} +}; +class S6 { + int a; + S6() : a(0) {} + +public: + S6(const S6 &s6) : a(s6.a) {} + S6(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(int argc, char **argv) { + I e(4); // expected-note {{'e' defined here}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for simd' directive into a parallel or another task region?}} +#pragma omp for simd lastprivate(i) // expected-error {{lastprivate variable must be shared}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for simd lastprivate(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(ba) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel +#pragma omp for simd lastprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(i) // expected-note {{defined as lastprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp for simd' directive may not be lastprivate, predetermined as linear}} + foo(); +#pragma omp parallel private(xa) // expected-note {{defined as private}} +#pragma omp for simd lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : xa) // expected-note {{defined as reduction}} +#pragma omp for simd lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + foo(); + return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} +} diff --git a/test/OpenMP/for_simd_linear_messages.cpp b/test/OpenMP/for_simd_linear_messages.cpp new file mode 100644 index 000000000000..9a935c3fdf28 --- /dev/null +++ b/test/OpenMP/for_simd_linear_messages.cpp @@ -0,0 +1,206 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +namespace X { + int x; +}; + +struct B { + static int ib; // expected-note {{'B::ib' declared here}} + static int bfoo() { return 8; } +}; + +int bfoo() { return 4; } + +int z; +const int C1 = 1; +const int C2 = 2; +void test_linear_colons() +{ + int B = 0; + #pragma omp for simd linear(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp for simd linear(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{use of undeclared identifier 'ib'; did you mean 'B::ib'}} + #pragma omp for simd linear(B:ib) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp for simd linear(z:B:ib) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd linear(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd linear(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd linear(B,::z, X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd linear(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp for simd linear(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp for simd linear(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; // expected-note {{'ind2' defined here}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type}} +#pragma omp for simd linear(ind2:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + return T(); +} + +template<int LEN> int test_warn() { + int ind2 = 0; + // expected-warning@+1 {{zero linear step (ind2 should probably be const)}} + #pragma omp for simd linear(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return ind2; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; +public: + S2():a(0) { } +}; +const S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} +public: + S5(int v):a(v) { } +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template<class I, class C> int foomain(I argc, C **argv) { + I e(4); + I g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} + #pragma omp for simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc : 5) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp for simd linear (a, b:B::ib) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int v = 0; + int i; + #pragma omp for simd linear(v:i) + for (int k = 0; k < argc; ++k) { i = k; v += i; } + } + #pragma omp for simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type}} + for (int k = 0; k < argc; ++k) ++k; + int v = 0; + #pragma omp for simd linear(v:j) + for (int k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + return 0; +} + +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} + #pragma omp for simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp for simd linear (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of a linear clause should be of integral or pointer type, not 'S4'}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S5'}} + #pragma omp for simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int i; + #pragma omp for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(i : 4) + for (int k = 0; k < argc; ++k) { ++k; i += 4; } + } + #pragma omp for simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type 'int &'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + + foomain<int,char>(argc,argv); + return 0; +} + diff --git a/test/OpenMP/for_simd_loop_messages.cpp b/test/OpenMP/for_simd_loop_messages.cpp new file mode 100644 index 000000000000..403709f3453e --- /dev/null +++ b/test/OpenMP/for_simd_loop_messages.cpp @@ -0,0 +1,734 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s + +class S { + int a; + S() : a(0) {} + +public: + S(int v) : a(v) {} + S(const S &s) : a(s.a) {} +}; + +static int sii; +#pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} +static int globalii; + +int test_iteration_spaces() { + const int N = 100; + float a[N], b[N], c[N]; + int ii, jj, kk; + float fii; + double dii; +#pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; i += 1) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for simd + for (char i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for simd + for (char i = 0; i < 10; i += '\1') { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for simd + for (long long i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}} +#pragma omp for simd + for (long long i = 0; i < 10; i += 1.5) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for simd + for (long long i = 0; i < 'z'; i += 1u) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for simd + for (int &ref = ii; ref < 10; ref++) { + } +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (int i; i < 10; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (int i = 0, j = 0; i < 10; ++i) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (ii + 1; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (c[ii] = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok to skip parenthesises. +#pragma omp for simd + for (((ii)) = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for simd + for (int i = 0; i; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}} +#pragma omp for simd + for (int i = 0; jj < kk; ii++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for simd + for (int i = 0; !!i; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for simd + for (int i = 0; i != 1; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for simd + for (int i = 0;; i++) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for simd + for (int i = 11; i > 10; i--) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for simd + for (int i = 0; i < 10; ++i) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for simd + for (ii = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; ++jj) + c[ii] = a[jj]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; ++++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok but undefined behavior (in general, cannot check that incr +// is really loop-invariant). +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii + ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}} +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii + 1.0f) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok - step was converted to integer type. +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii + (int)1.1f) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; jj = ii + 2) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{relational comparison result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii<10; jj> kk + 2) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10;) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; !ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; ii ? ++ii : ++jj) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii < 10) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii + 0) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; (ii) < 10; ii -= 25) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; (ii < 10); ii -= 0) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; ii > 10; (ii += 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; ii < 10; (ii) = (1 - 1) + (ii)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for ((ii = 0); ii > 10; (ii -= 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (ii = 0; (ii < 10); (ii -= 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+2 {{defined as firstprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be firstprivate, predetermined as linear}} +#pragma omp for simd firstprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +#pragma omp for simd linear(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+2 {{defined as private}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be private, predetermined as linear}} +#pragma omp for simd private(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+2 {{defined as lastprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be lastprivate, predetermined as linear}} +#pragma omp for simd lastprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be threadprivate or thread local, predetermined as linear}} +#pragma omp for simd + for (sii = 0; sii < 10; sii += 1) + c[sii] = a[sii]; + } + +#pragma omp parallel + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be a variable with global storage without being explicitly marked as linear}} +#pragma omp for simd + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] = a[globalii]; + } + +#pragma omp parallel + { +// expected-error@+3 {{loop iteration variable in the associated loop of 'omp for simd' directive may not be a variable with global storage without being explicitly marked as lastprivate}} +#pragma omp for simd collapse(2) + for (ii = 0; ii < 10; ii += 1) + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] += a[globalii] + ii; + } + +#pragma omp parallel +// expected-error@+2 {{statement after '#pragma omp for simd' must be a for loop}} +#pragma omp for simd + for (auto &item : a) { + item = item + 1; + } + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (unsigned i = 9; i < 10; i--) { + c[i] = a[i] + b[i]; + } + + int(*lb)[4] = nullptr; +#pragma omp parallel +#pragma omp for simd + for (int(*p)[4] = lb; p < lb + 8; ++p) { + } + +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (int a{0}; a < 10; ++a) { + } + + return 0; +} + +// Iterators allowed in openmp for-loops. +namespace std { +struct random_access_iterator_tag {}; +template <class Iter> +struct iterator_traits { + typedef typename Iter::difference_type difference_type; + typedef typename Iter::iterator_category iterator_category; +}; +template <class Iter> +typename iterator_traits<Iter>::difference_type +distance(Iter first, Iter last) { return first - last; } +} +class Iter0 { +public: + Iter0() {} + Iter0(const Iter0 &) {} + Iter0 operator++() { return *this; } + Iter0 operator--() { return *this; } + bool operator<(Iter0 a) { return true; } +}; +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'Iter0' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}} +int operator-(Iter0 a, Iter0 b) { return 0; } +class Iter1 { +public: + Iter1(float f = 0.0f, double d = 0.0) {} + Iter1(const Iter1 &) {} + Iter1 operator++() { return *this; } + Iter1 operator--() { return *this; } + bool operator<(Iter1 a) { return true; } + bool operator>=(Iter1 a) { return false; } +}; +class GoodIter { +public: + GoodIter() {} + GoodIter(const GoodIter &) {} + GoodIter(int fst, int snd) {} + GoodIter &operator=(const GoodIter &that) { return *this; } + GoodIter &operator=(const Iter0 &that) { return *this; } + GoodIter &operator+=(int x) { return *this; } + explicit GoodIter(void *) {} + GoodIter operator++() { return *this; } + GoodIter operator--() { return *this; } + bool operator!() { return true; } + bool operator<(GoodIter a) { return true; } + bool operator<=(GoodIter a) { return true; } + bool operator>=(GoodIter a) { return false; } + typedef int difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'GoodIter' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} +int operator-(GoodIter a, GoodIter b) { return 0; } +// expected-note@+1 3 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}} +GoodIter operator-(GoodIter a) { return a; } +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'int' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} +GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'GoodIter' for 1st argument}} +GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'int' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}} +GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'int' for 1st argument}} +GoodIter operator+(int v, GoodIter a) { return GoodIter(); } + +int test_with_random_access_iterator() { + GoodIter begin, end; + Iter0 begin0, end0; +#pragma omp parallel +#pragma omp for simd + for (GoodIter I = begin; I < end; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for simd + for (GoodIter &I = begin; I < end; ++I) + ++I; +#pragma omp parallel +#pragma omp for simd + for (GoodIter I = begin; I >= end; --I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (GoodIter I(begin); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (GoodIter I(nullptr); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (GoodIter I(0); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (GoodIter I(1, 2); I < end; ++I) + ++I; +#pragma omp parallel +#pragma omp for simd + for (begin = GoodIter(0); begin < end; ++begin) + ++begin; +#pragma omp parallel +// expected-error@+3 {{invalid operands to binary expression ('GoodIter' and 'const Iter0')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +#pragma omp for simd + for (begin = begin0; begin < end; ++begin) + ++begin; +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for simd + for (++begin; begin < end; ++begin) + ++begin; +#pragma omp parallel +#pragma omp for simd + for (begin = end; begin < end; ++begin) + ++begin; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for simd + for (GoodIter I = begin; I - I; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for simd + for (GoodIter I = begin; begin < end; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for simd + for (GoodIter I = begin; !I; ++I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (GoodIter I = begin; I >= end; I = I + 1) + ++I; +#pragma omp parallel +#pragma omp for simd + for (GoodIter I = begin; I >= end; I = I - 1) + ++I; +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp for simd + for (GoodIter I = begin; I >= end; I = -I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (GoodIter I = begin; I >= end; I = 2 + I) + ++I; +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp for simd + for (GoodIter I = begin; I >= end; I = 2 - I) + ++I; +#pragma omp parallel +// expected-error@+2 {{invalid operands to binary expression ('Iter0' and 'int')}} +#pragma omp for simd + for (Iter0 I = begin0; I < end0; ++I) + ++I; +#pragma omp parallel +// Initializer is constructor without params. +// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}} +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (Iter0 I; I < end0; ++I) + ++I; + Iter1 begin1, end1; +#pragma omp parallel +// expected-error@+3 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +#pragma omp for simd + for (Iter1 I = begin1; I < end1; ++I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (Iter1 I = begin1; I >= end1; ++I) + ++I; +#pragma omp parallel +// expected-error@+5 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+4 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +// Initializer is constructor with all default params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for simd + for (Iter1 I; I < end1; ++I) { + } + return 0; +} + +template <typename IT, int ST> +class TC { +public: + int dotest_lt(IT begin, IT end) { +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (IT I = begin; I < end; I = I + ST) { + ++I; + } +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp for simd + for (IT I = begin; I <= end; I += ST) { + ++I; + } +#pragma omp parallel +#pragma omp for simd + for (IT I = begin; I < end; ++I) { + ++I; + } + } + + static IT step() { + return IT(ST); + } +}; +template <typename IT, int ST = 0> +int dotest_gt(IT begin, IT end) { +#pragma omp parallel +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (IT I = begin; I >= end; I = I + ST) { + ++I; + } +#pragma omp parallel +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (IT I = begin; I >= end; I += ST) { + ++I; + } + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for simd + for (IT I = begin; I >= end; ++I) { + ++I; + } + +#pragma omp parallel +#pragma omp for simd + for (IT I = begin; I < end; I += TC<int, ST>::step()) { + ++I; + } +} + +void test_with_template() { + GoodIter begin, end; + TC<GoodIter, 100> t1; + TC<GoodIter, -100> t2; + t1.dotest_lt(begin, end); + t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}} + dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}} + dotest_gt<unsigned, -10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, -10>' requested here}} +} + +void test_loop_break() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + break; // OK in nested loop + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + if (c[i] > 10) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + + if (c[i] > 11) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + } + +#pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + c[i] = a[i] + b[i]; + if (c[i] > 10) { + if (c[i] < 20) { + break; // OK + } + } + } + } +} + +void test_loop_eh() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + try { // expected-error {{'try' statement cannot be used in OpenMP simd region}} + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + catch (float f) { + if (f > 0.1) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + return; // expected-error {{cannot return from OpenMP region}} + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + for (int j = 0; j < 10; j++) { + if (c[i] > 10) + throw c[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + } + if (c[9] > 10) + throw c[9]; // OK + +#pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; ++i) { + struct S { + void g() { throw 0; } + }; + } +} + +void test_loop_firstprivate_lastprivate() { + S s(4); +#pragma omp parallel +#pragma omp for simd lastprivate(s) firstprivate(s) + for (int i = 0; i < 16; ++i) + ; +} + +void test_ordered() { +#pragma omp parallel +// expected-error@+1 2 {{unexpected OpenMP clause 'ordered' in directive '#pragma omp for simd'}} +#pragma omp for simd ordered ordered // expected-error {{directive '#pragma omp for simd' cannot contain more than one 'ordered' clause}} + for (int i = 0; i < 16; ++i) + ; +} + +void test_nowait() { +#pragma omp parallel +#pragma omp for simd nowait nowait // expected-error {{directive '#pragma omp for simd' cannot contain more than one 'nowait' clause}} + for (int i = 0; i < 16; ++i) + ; +} diff --git a/test/OpenMP/for_simd_misc_messages.c b/test/OpenMP/for_simd_misc_messages.c new file mode 100644 index 000000000000..870c37df20aa --- /dev/null +++ b/test/OpenMP/for_simd_misc_messages.c @@ -0,0 +1,659 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp for simd'}} +#pragma omp for simd + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp for simd'}} +#pragma omp for simd foo + +void test_no_clause() { + int i; +#pragma omp for simd + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{statement after '#pragma omp for simd' must be a for loop}} +#pragma omp for simd + ++i; +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel +#pragma omp for simd + for (i = 0; i < 16; ++i) { + if (i == 5) + goto L1; // expected-error {{use of undeclared label 'L1'}} + else if (i == 6) + return; // expected-error {{cannot return from OpenMP region}} + else if (i == 7) + goto L2; + else if (i == 8) { + L2: + x[i]++; + } + } + + if (x[0] == 0) + goto L2; // expected-error {{use of undeclared label 'L2'}} + else if (x[1] == 1) + goto L1; +} + +void test_invalid_clause() { + int i; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +#pragma omp for simd foo bar + for (i = 0; i < 16; ++i) + ; +} + +void test_non_identifiers() { + int i, x; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +#pragma omp for simd; + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +#pragma omp for simd linear(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +#pragma omp for simd private(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +#pragma omp for simd, private(x); + for (i = 0; i < 16; ++i) + ; +} + +extern int foo(); +void test_safelen() { + int i; +// expected-error@+1 {{expected '('}} +#pragma omp for simd safelen + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen( + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd safelen() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(, ) + for (i = 0; i < 16; ++i) + ; +// expected-warning@+2 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp for simd safelen 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4 + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4, , 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp for simd safelen(4, 8) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for simd safelen(2.5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for simd safelen(foo()) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp for simd safelen(-5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp for simd safelen(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp for simd safelen(5 - 5) + for (i = 0; i < 16; ++i) + ; +} + +void test_collapse() { + int i; +#pragma omp parallel +// expected-error@+1 {{expected '('}} +#pragma omp for simd collapse + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd collapse( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd collapse() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd collapse(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd collapse(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-warning@+2 {{extra tokens at the end of '#pragma omp for simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp for simd collapse 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4 + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4, + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4, ) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4, , 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +#pragma omp for simd collapse(4) + for (int i1 = 0; i1 < 16; ++i1) + for (int i2 = 0; i2 < 16; ++i2) + for (int i3 = 0; i3 < 16; ++i3) + for (int i4 = 0; i4 < 16; ++i4) + foo(); +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for simd collapse(4, 8) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for simd', but found only 1}} +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for simd collapse(2.5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for simd collapse(foo()) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for simd collapse(-5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for simd collapse(0) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for simd collapse(5 - 5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd collapse(2) + for (i = 0; i < 16; ++i) +// expected-note@+1 {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for simd' directive into a parallel or another task region?}} + for (int j = 0; j < 16; ++j) +// expected-error@+2 {{private variable cannot be reduction}} +// expected-error@+1 {{OpenMP constructs may not be nested inside a simd region}} +#pragma omp for simd reduction(+ : i, j) + for (int k = 0; k < 16; ++k) + i += j; +} + +void test_linear() { + int i; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd linear( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd linear(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp for simd linear(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd linear() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd linear(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp for simd linear(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp for simd linear(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp for simd linear(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp for simd linear(x, y, z) + for (i = 0; i < 16; ++i) + ; + + int x, y; +// expected-error@+1 {{expected expression}} +#pragma omp for simd linear(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd linear(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd linear(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd linear(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd linear(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd linear(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be linear}} +#pragma omp for simd linear(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as private}} +// expected-error@+1 {{private variable cannot be linear}} +#pragma omp for simd private(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be private}} +#pragma omp for simd linear(x) private(x) + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}} +#pragma omp for simd linear(x, y : 0) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be lastprivate}} +#pragma omp for simd linear(x) lastprivate(x) + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-note@+2 {{defined as lastprivate}} +// expected-error@+1 {{lastprivate variable cannot be linear}} +#pragma omp for simd lastprivate(x) linear(x) + for (i = 0; i < 16; ++i) + ; +} + +void test_aligned() { + int i; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd aligned( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd aligned(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp for simd aligned(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd aligned() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd aligned(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp for simd aligned(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp for simd aligned(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp for simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp for simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; + + int *x, y, z[25]; // expected-note 4 {{'y' defined here}} +#pragma omp for simd aligned(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd aligned(z) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp for simd aligned(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd aligned(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd aligned(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp for simd aligned(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd aligned(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd aligned(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp for simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp for simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as aligned}} +// expected-error@+1 {{a variable cannot appear in more than one aligned clause}} +#pragma omp for simd aligned(x) aligned(z, x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+3 {{defined as aligned}} +// expected-error@+2 {{a variable cannot appear in more than one aligned clause}} +// expected-error@+1 2 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp for simd aligned(x, y, z) aligned(y, z) + for (i = 0; i < 16; ++i) + ; +} + + +void test_private() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for simd private( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd private(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd private(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd private() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd private(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for simd private(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for simd private(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd private(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd private(x, y, z) + for (i = 0; i < 16; ++i) { + x = y * i + z; + } +} + +void test_lastprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp for simd lastprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd lastprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd lastprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd lastprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd lastprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for simd lastprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for simd lastprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd lastprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd lastprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_firstprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp for simd firstprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd firstprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for simd firstprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd firstprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for simd firstprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for simd firstprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for simd lastprivate(x) firstprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd lastprivate(x, y) firstprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for simd lastprivate(x, y, z) firstprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_loop_messages() { + float a[100], b[100], c[100]; +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp for simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp for simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +} + diff --git a/test/OpenMP/for_simd_private_messages.cpp b/test/OpenMP/for_simd_private_messages.cpp new file mode 100644 index 000000000000..016a5ec6b581 --- /dev/null +++ b/test/OpenMP/for_simd_private_messages.cpp @@ -0,0 +1,173 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} +}; +const S3 ca[5]; +class S4 { + int a; + S4(); // expected-note {{implicitly declared private here}} + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5() : a(0) {} // expected-note {{implicitly declared private here}} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(I argc, C **argv) { + I e(4); + I g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp for simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(e, g) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp for simd'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp for simd private(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + S4 e(4); + S5 g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp for simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp for simd'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int i; +#pragma omp for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + + return 0; +} + diff --git a/test/OpenMP/for_simd_reduction_messages.cpp b/test/OpenMP/for_simd_reduction_messages.cpp new file mode 100644 index 000000000000..708973be51ba --- /dev/null +++ b/test/OpenMP/for_simd_reduction_messages.cpp @@ -0,0 +1,350 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp for simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(^ : T) // expected-error {{'T' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp for simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp for simd reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) // expected-note 2 {{defined as private}} +#pragma omp for simd reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) // expected-note 2 {{defined as reduction}} +#pragma omp for simd reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp for simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(~ : argc) // expected-error {{expected unqualified-id}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(max : argv[1]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp for simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for simd reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) // expected-note {{defined as private}} +#pragma omp for simd reduction(+ : fl) // expected-error {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}} +#pragma omp for simd reduction(+ : fl) // expected-error {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/for_simd_safelen_messages.cpp b/test/OpenMP/for_simd_safelen_messages.cpp new file mode 100644 index 000000000000..1a72964ce4e9 --- /dev/null +++ b/test/OpenMP/for_simd_safelen_messages.cpp @@ -0,0 +1,79 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp for simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp for simd safelen (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp for simd safelen (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen (1)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen ((ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 2 {{directive '#pragma omp for simd' cannot contain more than one 'safelen' clause}} + // expected-error@+2 2 {{argument to 'safelen' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen (4) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd safelen (N) // expected-error {{argument to 'safelen' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp for simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp for simd' cannot contain more than one 'safelen' clause}} + // expected-error@+1 2 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp for simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd safelen (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp for simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp for simd safelen(safelen(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 12, 4>' requested here}} + return tmain<int, char, 12, 4>(argc, argv); +} + diff --git a/test/OpenMP/for_simd_schedule_messages.cpp b/test/OpenMP/for_simd_schedule_messages.cpp new file mode 100644 index 000000000000..8624359eb420 --- /dev/null +++ b/test/OpenMP/for_simd_schedule_messages.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp for simd schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp for simd schedule (guided argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for simd schedule (static, ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (dynamic, 1)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (guided, (ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+2 2 {{directive '#pragma omp for simd' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for simd schedule (static, foobool(argc)), schedule (dynamic, true), schedule (guided, -5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (static, S) // expected-error {{'S' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp for simd schedule (guided, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (dynamic, 1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for simd schedule (static, N) // expected-error {{argument to 'schedule' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp for simd schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (guided, 4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (static, 2+2)) // expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (dynamic, foobool(1) > 0 ? 1 : 2) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+2 2 {{directive '#pragma omp for simd' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for simd schedule (guided, foobool(argc)), schedule (static, true), schedule (dynamic, -5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for simd schedule (guided, S1) // expected-error {{'S1' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp for simd schedule (static, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp for simd schedule(dynamic, schedule(tmain<int, char, -1, -2>(argc, argv) // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/master_codegen.cpp b/test/OpenMP/master_codegen.cpp new file mode 100644 index 000000000000..d354bae2d7ee --- /dev/null +++ b/test/OpenMP/master_codegen.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } + +// CHECK: define void [[FOO:@.+]]() + +void foo() {} + +// CHECK-LABEL: @main +int main() { + // CHECK: [[A_ADDR:%.+]] = alloca i8 + char a; + +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]]) +// CHECK: [[RES:%.+]] = call i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] +// CHECK: [[THEN]] +// CHECK-NEXT: store i8 2, i8* [[A_ADDR]] +// CHECK-NEXT: call void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: br label {{%?}}[[EXIT]] +// CHECK: [[EXIT]] +#pragma omp master + a = 2; +// CHECK: [[RES:%.+]] = call i32 @__kmpc_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 +// CHECK-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] +// CHECK: [[THEN]] +// CHECK-NEXT: call void [[FOO]]() +// CHECK-NEXT: call void @__kmpc_end_master([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]]) +// CHECK-NEXT: br label {{%?}}[[EXIT]] +// CHECK: [[EXIT]] +#pragma omp master + foo(); +// CHECK-NOT: call i32 @__kmpc_master +// CHECK-NOT: call void @__kmpc_end_master + return a; +} + +#endif diff --git a/test/OpenMP/nesting_of_regions.cpp b/test/OpenMP/nesting_of_regions.cpp index d8dcec5edf2e..a948ca3e3bcb 100644 --- a/test/OpenMP/nesting_of_regions.cpp +++ b/test/OpenMP/nesting_of_regions.cpp @@ -4,6 +4,7 @@ void bar(); template <class T> void foo() { + T a = T(); // PARALLEL DIRECTIVE #pragma omp parallel #pragma omp for @@ -14,6 +15,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel #pragma omp sections { bar(); @@ -42,6 +47,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp parallel +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel #pragma omp parallel sections { bar(); @@ -71,6 +80,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp parallel + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel + { +#pragma omp atomic + ++a; + } +#pragma omp parallel + { +#pragma omp target + ++a; + } +#pragma omp parallel + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // SIMD DIRECTIVE #pragma omp simd @@ -87,6 +116,12 @@ void foo() { } #pragma omp simd for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} for (int i = 0; i < 10; ++i) ; @@ -134,6 +169,12 @@ void foo() { } #pragma omp simd for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} { bar(); @@ -166,6 +207,26 @@ void foo() { #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} bar(); } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // FOR DIRECTIVE #pragma omp for @@ -182,6 +243,12 @@ void foo() { } #pragma omp for for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -217,7 +284,7 @@ void foo() { } #pragma omp for for (int i = 0; i < 10; ++i) { -#pragma omp critical +#pragma omp critical { bar(); } @@ -247,6 +314,12 @@ void foo() { } #pragma omp for for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections { bar(); @@ -279,6 +352,158 @@ void foo() { #pragma omp flush bar(); } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp for ordered + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // OK + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp atomic + ++a; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp target + ++a; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// FOR SIMD DIRECTIVE +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // SECTIONS DIRECTIVE #pragma omp sections @@ -295,6 +520,12 @@ void foo() { } #pragma omp sections { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -376,6 +607,12 @@ void foo() { } #pragma omp sections { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { #pragma omp parallel sections { bar(); @@ -404,6 +641,26 @@ void foo() { { #pragma omp flush } +#pragma omp sections + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp sections + { +#pragma omp atomic + ++a; + } +#pragma omp sections + { +#pragma omp target + ++a; + } +#pragma omp sections + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // SECTION DIRECTIVE #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} @@ -432,6 +689,15 @@ void foo() { { #pragma omp section { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -482,6 +748,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -502,6 +771,15 @@ void foo() { { #pragma omp section { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { #pragma omp parallel sections { bar(); @@ -550,6 +828,32 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp section + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } + } +#pragma omp sections + { +#pragma omp section +#pragma omp atomic + ++a; + } +#pragma omp sections + { +#pragma omp section +#pragma omp target + ++a; + } +#pragma omp sections + { +#pragma omp section +#pragma omp teams // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // SINGLE DIRECTIVE #pragma omp single @@ -566,6 +870,12 @@ void foo() { } #pragma omp single { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -609,6 +919,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -623,6 +936,12 @@ void foo() { } #pragma omp single { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { #pragma omp parallel sections { bar(); @@ -655,6 +974,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp single + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp single + { +#pragma omp atomic + ++a; + } +#pragma omp single + { +#pragma omp target + ++a; + } +#pragma omp single + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // MASTER DIRECTIVE #pragma omp master @@ -671,6 +1010,12 @@ void foo() { } #pragma omp master { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -714,6 +1059,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -728,6 +1076,12 @@ void foo() { } #pragma omp master { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { #pragma omp parallel sections { bar(); @@ -760,6 +1114,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp master + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp master + { +#pragma omp atomic + ++a; + } +#pragma omp master + { +#pragma omp target + ++a; + } +#pragma omp master + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // CRITICAL DIRECTIVE #pragma omp critical @@ -776,6 +1150,12 @@ void foo() { } #pragma omp critical { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -819,6 +1199,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -833,6 +1216,12 @@ void foo() { } #pragma omp critical { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { #pragma omp parallel sections { bar(); @@ -865,7 +1254,7 @@ void foo() { #pragma omp critical(grelka) bar(); } -#pragma omp critical(Belka)// expected-note {{previous 'critical' region starts here}} +#pragma omp critical(Belka) // expected-note {{previous 'critical' region starts here}} { #pragma omp critical(Belka) // expected-error {{cannot nest 'critical' regions having the same name 'Belka'}} { @@ -879,6 +1268,26 @@ void foo() { } } } +#pragma omp critical + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp critical + { +#pragma omp atomic + ++a; + } +#pragma omp critical + { +#pragma omp target + ++a; + } +#pragma omp critical + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // PARALLEL FOR DIRECTIVE #pragma omp parallel for @@ -895,6 +1304,12 @@ void foo() { } #pragma omp parallel for for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -948,6 +1363,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -962,6 +1380,12 @@ void foo() { } #pragma omp parallel for for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections { bar(); @@ -994,6 +1418,186 @@ void foo() { #pragma omp flush bar(); } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel for ordered + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // OK + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp atomic + ++a; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp target + ++a; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// PARALLEL FOR SIMD DIRECTIVE +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd// expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { +#pragma omp single + { + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections + { + bar(); + } + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd// expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // PARALLEL SECTIONS DIRECTIVE #pragma omp parallel sections @@ -1010,6 +1614,12 @@ void foo() { } #pragma omp parallel sections { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1063,6 +1673,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1077,6 +1690,12 @@ void foo() { } #pragma omp parallel sections { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { #pragma omp parallel sections { bar(); @@ -1105,6 +1724,26 @@ void foo() { { #pragma omp flush } +#pragma omp parallel sections + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel sections + { +#pragma omp atomic + ++a; + } +#pragma omp parallel sections + { +#pragma omp target + ++a; + } +#pragma omp parallel sections + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // TASK DIRECTIVE #pragma omp task @@ -1116,6 +1755,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp task +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp task #pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} { bar(); @@ -1140,6 +1783,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp task +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp task #pragma omp parallel sections { bar(); @@ -1169,9 +1816,543 @@ void foo() { #pragma omp flush bar(); } +#pragma omp task + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp task + { +#pragma omp atomic + ++a; + } +#pragma omp task + { +#pragma omp target + ++a; + } +#pragma omp task + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// ORDERED DIRECTIVE +#pragma omp ordered + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp master // OK, though second 'ordered' is redundant + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp critical + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp parallel for ordered + for (int j = 0; j < 10; ++j) { +#pragma omp ordered // OK + { + bar(); + } + } + } +#pragma omp ordered + { +#pragma omp parallel for simd ordered //expected-error {{unexpected OpenMP clause 'ordered' in directive '#pragma omp parallel for simd'}} + for (int j = 0; j < 10; ++j) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + } +#pragma omp ordered + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp ordered + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp task + { + bar(); + } + } +#pragma omp ordered + { +#pragma omp taskyield + bar(); + } +#pragma omp ordered + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'ordered' region}} + bar(); + } +#pragma omp ordered + { +#pragma omp taskwait + bar(); + } +#pragma omp ordered + { +#pragma omp flush + bar(); + } +#pragma omp ordered + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp ordered + { +#pragma omp atomic + ++a; + } +#pragma omp ordered + { +#pragma omp target + ++a; + } +#pragma omp ordered + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// ATOMIC DIRECTIVE +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } + +// TARGET DIRECTIVE +#pragma omp target +#pragma omp parallel + bar(); +#pragma omp target +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp sections + { + bar(); + } +#pragma omp target +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a target region}} + { + bar(); + } +#pragma omp target +#pragma omp single + bar(); + +#pragma omp target +#pragma omp master + { + bar(); + } +#pragma omp target +#pragma omp critical + { + bar(); + } +#pragma omp target +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp parallel sections + { + bar(); + } +#pragma omp target +#pragma omp task + { + bar(); + } +#pragma omp target + { +#pragma omp taskyield + bar(); + } +#pragma omp target + { +#pragma omp barrier + bar(); + } +#pragma omp target + { +#pragma omp taskwait + bar(); + } +#pragma omp target + { +#pragma omp flush + bar(); + } +#pragma omp target + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'target' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp target + { +#pragma omp atomic + ++a; + } +#pragma omp target + { +#pragma omp target + ++a; + } +#pragma omp target + { +#pragma omp teams + ++a; + } +#pragma omp target // expected-error {{target construct with nested teams region contains statements outside of the teams construct}} + { + ++a; // expected-note {{statement outside teams construct here}} +#pragma omp teams // expected-note {{nested teams construct here}} + ++a; + } + +// TEAMS DIRECTIVE +#pragma omp target +#pragma omp teams +#pragma omp parallel + bar(); +#pragma omp target +#pragma omp teams +#pragma omp for // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp sections // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a teams region}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp single // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); + +#pragma omp target +#pragma omp teams +#pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp parallel sections + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp task // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp task' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp taskyield // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskyield' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp barrier' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp taskwait // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskwait' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp flush // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp flush' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp atomic // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp atomic' directive into a parallel region?}} + ++a; + } +#pragma omp target +#pragma omp teams + { +#pragma omp target // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp target' directive into a parallel region?}} + ++a; + } +#pragma omp target +#pragma omp teams + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } } void foo() { + int a = 0; // PARALLEL DIRECTIVE #pragma omp parallel #pragma omp for @@ -1182,6 +2363,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp parallel +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel #pragma omp sections { bar(); @@ -1210,6 +2395,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp parallel +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel #pragma omp parallel sections { bar(); @@ -1239,6 +2428,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp parallel + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel + { +#pragma omp atomic + ++a; + } +#pragma omp parallel + { +#pragma omp target + ++a; + } +#pragma omp parallel + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // SIMD DIRECTIVE #pragma omp simd @@ -1255,6 +2464,12 @@ void foo() { } #pragma omp simd for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} for (int i = 0; i < 10; ++i) ; @@ -1295,6 +2510,12 @@ void foo() { } #pragma omp simd for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} { bar(); @@ -1327,6 +2548,26 @@ void foo() { #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} bar(); } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // FOR DIRECTIVE #pragma omp for @@ -1343,6 +2584,12 @@ void foo() { } #pragma omp for for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1381,6 +2628,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1395,6 +2645,12 @@ void foo() { } #pragma omp for for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections { bar(); @@ -1427,6 +2683,151 @@ void foo() { #pragma omp flush bar(); } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp for ordered + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // OK + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp atomic + ++a; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp target + ++a; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// FOR SIMD DIRECTIVE +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp for simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // SECTIONS DIRECTIVE #pragma omp sections @@ -1443,6 +2844,12 @@ void foo() { } #pragma omp sections { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1481,6 +2888,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1495,6 +2905,12 @@ void foo() { } #pragma omp sections { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { #pragma omp parallel sections { bar(); @@ -1524,6 +2940,26 @@ void foo() { { #pragma omp flush } +#pragma omp sections + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp sections + { +#pragma omp atomic + ++a; + } +#pragma omp sections + { +#pragma omp target + ++a; + } +#pragma omp sections + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // SECTION DIRECTIVE #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} @@ -1552,6 +2988,15 @@ void foo() { { #pragma omp section { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1602,6 +3047,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1622,6 +3070,15 @@ void foo() { { #pragma omp section { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { #pragma omp parallel sections { bar(); @@ -1670,6 +3127,38 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp section + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp atomic + ++a; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp target + ++a; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + } // SINGLE DIRECTIVE #pragma omp single @@ -1686,6 +3175,12 @@ void foo() { } #pragma omp single { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1719,6 +3214,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1733,6 +3231,12 @@ void foo() { } #pragma omp single { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { #pragma omp parallel sections { bar(); @@ -1765,6 +3269,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp single + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp single + { +#pragma omp atomic + ++a; + } +#pragma omp single + { +#pragma omp target + ++a; + } +#pragma omp single + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // MASTER DIRECTIVE #pragma omp master @@ -1781,6 +3305,12 @@ void foo() { } #pragma omp master { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1824,6 +3354,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1838,6 +3371,12 @@ void foo() { } #pragma omp master { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { #pragma omp parallel sections { bar(); @@ -1870,6 +3409,26 @@ void foo() { #pragma omp flush bar(); } +#pragma omp master + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp master + { +#pragma omp atomic + ++a; + } +#pragma omp master + { +#pragma omp target + ++a; + } +#pragma omp master + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // CRITICAL DIRECTIVE #pragma omp critical @@ -1886,6 +3445,12 @@ void foo() { } #pragma omp critical { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -1929,6 +3494,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -1943,6 +3511,12 @@ void foo() { } #pragma omp critical { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { #pragma omp parallel sections { bar(); @@ -1975,7 +3549,7 @@ void foo() { #pragma omp critical(Strelka) bar(); } -#pragma omp critical(Tuzik)// expected-note {{previous 'critical' region starts here}} +#pragma omp critical(Tuzik) // expected-note {{previous 'critical' region starts here}} { #pragma omp critical(grelka) // expected-note {{previous 'critical' region starts here}} { @@ -1989,6 +3563,31 @@ void foo() { } } } +#pragma omp critical + { +#pragma omp flush + bar(); + } +#pragma omp critical + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp critical + { +#pragma omp atomic + ++a; + } +#pragma omp critical + { +#pragma omp target + ++a; + } +#pragma omp critical + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // PARALLEL FOR DIRECTIVE #pragma omp parallel for @@ -2005,6 +3604,13 @@ void foo() { } #pragma omp parallel for for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } + +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -2057,6 +3663,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -2071,6 +3680,12 @@ void foo() { } #pragma omp parallel for for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { #pragma omp parallel sections { bar(); @@ -2103,6 +3718,186 @@ void foo() { #pragma omp flush bar(); } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel for ordered + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // OK + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp atomic + ++a; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp target + ++a; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// PARALLEL FOR SIMD DIRECTIVE +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd// expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { +#pragma omp single + { + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections + { + bar(); + } + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for simd// expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}} + ++a; + } // PARALLEL SECTIONS DIRECTIVE #pragma omp parallel sections @@ -2119,6 +3914,12 @@ void foo() { } #pragma omp parallel sections { +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { #pragma omp parallel for (int i = 0; i < 10; ++i) ; @@ -2168,6 +3969,9 @@ void foo() { #pragma omp for // OK for (int i = 0; i < 10; ++i) ; +#pragma omp for simd // OK + for (int i = 0; i < 10; ++i) + ; #pragma omp sections // OK { bar(); @@ -2182,6 +3986,12 @@ void foo() { } #pragma omp parallel sections { +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { #pragma omp parallel sections { bar(); @@ -2210,6 +4020,26 @@ void foo() { { #pragma omp flush } +#pragma omp parallel sections + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp parallel sections + { +#pragma omp atomic + ++a; + } +#pragma omp parallel sections + { +#pragma omp target + ++a; + } +#pragma omp parallel sections + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } // TASK DIRECTIVE #pragma omp task @@ -2221,6 +4051,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp task +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp task #pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} { bar(); @@ -2244,6 +4078,10 @@ void foo() { for (int i = 0; i < 10; ++i) ; #pragma omp task +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp task #pragma omp parallel sections { bar(); @@ -2273,6 +4111,399 @@ void foo() { #pragma omp flush bar(); } +#pragma omp task + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp task + { +#pragma omp atomic + ++a; + } +#pragma omp task + { +#pragma omp target + ++a; + } +#pragma omp task + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } + +// ATOMIC DIRECTIVE +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp for // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + { + bar(); + } + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + bar(); + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp target // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } +#pragma omp atomic + // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}} + { +#pragma omp teams // expected-error {{OpenMP constructs may not be nested inside an atomic region}} + ++a; + } + +// TARGET DIRECTIVE +#pragma omp target +#pragma omp parallel + bar(); +#pragma omp target +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp sections + { + bar(); + } +#pragma omp target +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a target region}} + { + bar(); + } +#pragma omp target +#pragma omp single + bar(); + +#pragma omp target +#pragma omp master + { + bar(); + } +#pragma omp target +#pragma omp critical + { + bar(); + } +#pragma omp target +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp parallel sections + { + bar(); + } +#pragma omp target +#pragma omp task + { + bar(); + } +#pragma omp target + { +#pragma omp taskyield + bar(); + } +#pragma omp target + { +#pragma omp barrier + bar(); + } +#pragma omp target + { +#pragma omp taskwait + bar(); + } +#pragma omp target + { +#pragma omp flush + bar(); + } +#pragma omp target + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'target' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp target + { +#pragma omp atomic + ++a; + } +#pragma omp target + { +#pragma omp target + ++a; + } +#pragma omp target + { +#pragma omp teams + ++a; + } +#pragma omp target // expected-error {{target construct with nested teams region contains statements outside of the teams construct}} + { + ++a; // expected-note {{statement outside teams construct here}} +#pragma omp teams // expected-note {{nested teams construct here}} + ++a; + } + +// TEAMS DIRECTIVE +#pragma omp target +#pragma omp teams +#pragma omp parallel + bar(); +#pragma omp target +#pragma omp teams +#pragma omp for // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp for simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp sections // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a teams region}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp single // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); + +#pragma omp target +#pragma omp teams +#pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp target +#pragma omp teams +#pragma omp parallel sections + { + bar(); + } +#pragma omp target +#pragma omp teams +#pragma omp task // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp task' directive into a parallel region?}} + { + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp taskyield // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskyield' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp barrier' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp taskwait // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskwait' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp flush // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp flush' directive into a parallel region?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp ordered // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + bar(); + } +#pragma omp target +#pragma omp teams + { +#pragma omp atomic // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp atomic' directive into a parallel region?}} + ++a; + } +#pragma omp target +#pragma omp teams + { +#pragma omp target // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp target' directive into a parallel region?}} + ++a; + } +#pragma omp target +#pragma omp teams + { +#pragma omp teams // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp teams' directive into a target region?}} + ++a; + } return foo<int>(); } diff --git a/test/OpenMP/ordered_ast_print.cpp b/test/OpenMP/ordered_ast_print.cpp new file mode 100644 index 000000000000..a44350070356 --- /dev/null +++ b/test/OpenMP/ordered_ast_print.cpp @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} + +template <class T> +T tmain (T argc) { + T b = argc, c, d, e, f, g; + static T a; + #pragma omp for ordered + for (int i =0 ; i < argc; ++i) + #pragma omp ordered + { + a=2; + } + return (0); +} + +// CHECK: static int a; +// CHECK-NEXT: #pragma omp for ordered +// CHECK-NEXT: for (int i = 0; i < argc; ++i) +// CHECK-NEXT: #pragma omp ordered +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } + +// CHECK: static T a; +// CHECK-NEXT: #pragma omp for ordered +// CHECK-NEXT: for (int i = 0; i < argc; ++i) +// CHECK-NEXT: #pragma omp ordered +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + static int a; +// CHECK: static int a; + #pragma omp for ordered + for (int i =0 ; i < argc; ++i) + #pragma omp ordered + { + a=2; + } +// CHECK-NEXT: #pragma omp for ordered +// CHECK-NEXT: for (int i = 0; i < argc; ++i) +// CHECK-NEXT: #pragma omp ordered +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } + return tmain(argc); +} + +#endif diff --git a/test/OpenMP/ordered_messages.cpp b/test/OpenMP/ordered_messages.cpp new file mode 100644 index 000000000000..3f79df649895 --- /dev/null +++ b/test/OpenMP/ordered_messages.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +int foo(); + +template <class T> +T foo() { + #pragma omp for ordered + for (int i = 0; i < 10; ++i) { + L1: + foo(); + #pragma omp ordered + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + } + #pragma omp for ordered + for (int i = 0; i < 10; ++i) { + foo(); + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp ordered + { + L2: + foo(); + } + } + + return T(); +} + +int foo() { + #pragma omp for ordered + for (int i = 0; i < 10; ++i) { + L1: + foo(); + #pragma omp ordered + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + } + #pragma omp for ordered + for (int i = 0; i < 10; ++i) { + foo(); + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp ordered + { + L2: + foo(); + } + } + + return foo<int>(); +} diff --git a/test/OpenMP/parallel_codegen.cpp b/test/OpenMP/parallel_codegen.cpp index d9ff5ac02333..e50ab43c2808 100644 --- a/test/OpenMP/parallel_codegen.cpp +++ b/test/OpenMP/parallel_codegen.cpp @@ -39,7 +39,7 @@ int main (int argc, char **argv) { // CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon* [[AGG_CAPTURED]], i32 0, i32 0 // CHECK-NEXT: store i32* {{%[a-z0-9.]+}}, i32** [[ARGC_REF]] // CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon* [[AGG_CAPTURED]] to i8* -// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @__captured_stmt to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @.omp_outlined. to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-NEXT: [[ARGV:%.+]] = load i8*** {{%[a-z0-9.]+}} // CHECK-NEXT: [[RET:%.+]] = call {{[a-z]*[ ]?i32}} [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) // CHECK-NEXT: ret i32 [[RET]] @@ -55,13 +55,13 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: [[KMPC_LOC_PSOURCE_REF:%.+]] = getelementptr inbounds %ident_t* [[LOC_2_ADDR]], i32 0, i32 4 // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.+}} x i8]* [[LOC1]], i32 0, i32 0), i8** [[KMPC_LOC_PSOURCE_REF]] // CHECK-DEBUG-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon* [[AGG_CAPTURED]] to i8* -// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @__captured_stmt to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @.omp_outlined. to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-DEBUG-NEXT: [[ARGV:%.+]] = load i8*** {{%[a-z0-9.]+}} // CHECK-DEBUG-NEXT: [[RET:%.+]] = call i32 [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) // CHECK-DEBUG-NEXT: ret i32 [[RET]] // CHECK-DEBUG-NEXT: } -// CHECK-LABEL: define internal void @__captured_stmt(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) +// CHECK-LABEL: define internal void @.omp_outlined.(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) // CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon* // CHECK: store %struct.anon* %__context, %struct.anon** [[CONTEXT_ADDR]] // CHECK: [[CONTEXT_PTR:%.+]] = load %struct.anon** [[CONTEXT_ADDR]] @@ -73,7 +73,7 @@ int main (int argc, char **argv) { // CHECK: call void @{{.+terminate.*}}( // CHECK-NEXT: unreachable // CHECK-NEXT: } -// CHECK-DEBUG-LABEL: define internal void @__captured_stmt(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) +// CHECK-DEBUG-LABEL: define internal void @.omp_outlined.(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) // CHECK-DEBUG: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon* // CHECK-DEBUG: store %struct.anon* %__context, %struct.anon** [[CONTEXT_ADDR]] // CHECK-DEBUG: [[CONTEXT_PTR:%.+]] = load %struct.anon** [[CONTEXT_ADDR]] @@ -96,7 +96,7 @@ int main (int argc, char **argv) { // CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon.0* [[AGG_CAPTURED]], i32 0, i32 0 // CHECK-NEXT: store i8*** {{%[a-z0-9.]+}}, i8**** [[ARGC_REF]] // CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon.0* [[AGG_CAPTURED]] to i8* -// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @__captured_stmt1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @.omp_outlined.1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-NEXT: ret i32 0 // CHECK-NEXT: } // CHECK-DEBUG: define linkonce_odr i32 [[TMAIN]](i8** %argc) @@ -110,11 +110,11 @@ int main (int argc, char **argv) { // CHECK-DEBUG-NEXT: [[KMPC_LOC_PSOURCE_REF:%.+]] = getelementptr inbounds %ident_t* [[LOC_2_ADDR]], i32 0, i32 4 // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.+}} x i8]* [[LOC2]], i32 0, i32 0), i8** [[KMPC_LOC_PSOURCE_REF]] // CHECK-DEBUG-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon.0* [[AGG_CAPTURED]] to i8* -// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @__captured_stmt1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @.omp_outlined.1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) // CHECK-DEBUG-NEXT: ret i32 0 // CHECK-DEBUG-NEXT: } -// CHECK-LABEL: define internal void @__captured_stmt1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) +// CHECK-LABEL: define internal void @.omp_outlined.1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) // CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon.0* // CHECK: store %struct.anon.0* %__context, %struct.anon.0** [[CONTEXT_ADDR]] // CHECK: [[CONTEXT_PTR:%.+]] = load %struct.anon.0** [[CONTEXT_ADDR]] @@ -126,7 +126,7 @@ int main (int argc, char **argv) { // CHECK: call void @{{.+terminate.*}}( // CHECK-NEXT: unreachable // CHECK-NEXT: } -// CHECK-DEBUG-LABEL: define internal void @__captured_stmt1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) +// CHECK-DEBUG-LABEL: define internal void @.omp_outlined.1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) // CHECK-DEBUG: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon.0* // CHECK-DEBUG: store %struct.anon.0* %__context, %struct.anon.0** [[CONTEXT_ADDR]] // CHECK-DEBUG: [[CONTEXT_PTR:%.+]] = load %struct.anon.0** [[CONTEXT_ADDR]] diff --git a/test/OpenMP/parallel_firstprivate_codegen.cpp b/test/OpenMP/parallel_firstprivate_codegen.cpp new file mode 100644 index 000000000000..811f2df9df35 --- /dev/null +++ b/test/OpenMP/parallel_firstprivate_codegen.cpp @@ -0,0 +1,255 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple %itanium_abi_triple -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -std=c++11 -DLAMBDA -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck -check-prefix=LAMBDA %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -fblocks -DBLOCKS -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck -check-prefix=BLOCKS %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +struct St { + int a, b; + St() : a(0), b(0) {} + St(const St &st) : a(st.a + st.b), b(0) {} + ~St() {} +}; + +volatile int g = 1212; + +template <class T> +struct S { + T f; + S(T a) : f(a + g) {} + S() : f(g) {} + S(const S &s, St t = St()) : f(s.f + t.a) {} + operator T() { return T(); } + ~S() {} +}; + +// CHECK-DAG: [[S_FLOAT_TY:%.+]] = type { float } +// CHECK-DAG: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } +// CHECK-DAG: [[ST_TY:%.+]] = type { i{{[0-9]+}}, i{{[0-9]+}} } +// CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK-DAG: [[CAP_TMAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8* + +template <typename T> +T tmain() { + S<T> test; + T t_var = T(); + T vec[] = {1, 2}; + S<T> s_arr[] = {1, 2}; + S<T> var(3); +#pragma omp parallel firstprivate(t_var, vec, s_arr, var) + { + vec[0] = t_var; + s_arr[0] = var; + } + return T(); +} + +int main() { +#ifdef LAMBDA + // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, + // LAMBDA-LABEL: @main + // LAMBDA: call void [[OUTER_LAMBDA:@.+]]( + [&]() { + // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( + // LAMBDA: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] + // LAMBDA: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* + // LAMBDA: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) +#pragma omp parallel firstprivate(g) + { + // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) + // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, + // LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], + // LAMBDA: [[ARG:%.+]] = load %{{.+}}** [[ARG_REF]] + // LAMBDA: [[G_REF_ADDR:%.+]] = getelementptr inbounds %{{.+}}* [[ARG]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}** [[G_REF_ADDR]] + // LAMBDA: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}* [[G_REF]] + // LAMBDA: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] + // LAMBDA: call i32 @__kmpc_cancel_barrier( + g = 1; + // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], + // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]] + // LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + [&]() { + // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) + // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], + g = 2; + // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}** [[ARG_PTR_REF]] + // LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}** [[G_PTR_REF]] + // LAMBDA: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* [[G_REF]] + }(); + } + }(); + return 0; +#elif defined(BLOCKS) + // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, + // BLOCKS-LABEL: @main + // BLOCKS: call void {{%.+}}(i8* + ^{ + // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* + // BLOCKS: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // BLOCKS: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] + // BLOCKS: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* + // BLOCKS: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) +#pragma omp parallel firstprivate(g) + { + // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) + // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, + // BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], + // BLOCKS: [[ARG:%.+]] = load %{{.+}}** [[ARG_REF]] + // BLOCKS: [[G_REF_ADDR:%.+]] = getelementptr inbounds %{{.+}}* [[ARG]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // BLOCKS: [[G_REF:%.+]] = load i{{[0-9]+}}** [[G_REF_ADDR]] + // BLOCKS: [[G_VAL:%.+]] = load volatile i{{[0-9]+}}* [[G_REF]] + // BLOCKS: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G_PRIVATE_ADDR]] + // BLOCKS: call i32 @__kmpc_cancel_barrier( + g = 1; + // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]] + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: call void {{%.+}}(i8* + ^{ + // BLOCKS: define {{.+}} void {{@.+}}(i8* + g = 2; + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: ret + }(); + } + }(); + return 0; +#else + S<float> test; + int t_var = 0; + int vec[] = {1, 2}; + S<float> s_arr[] = {1, 2}; + S<float> var(3); +#pragma omp parallel firstprivate(t_var, vec, s_arr, var) + { + vec[0] = t_var; + s_arr[0] = var; + } + return tmain<int>(); +#endif +} + +// CHECK: define {{.*}}i{{[0-9]+}} @main() +// CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]], +// CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]]) +// CHECK: %{{.+}} = bitcast [[CAP_MAIN_TY]]* +// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_MAIN_TY]]*)* [[MAIN_MICROTASK:@.+]] to void +// CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]() +// CHECK: call {{.*}} [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]* +// CHECK: ret +// +// CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_MAIN_TY]]* %{{.+}}) +// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, +// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], +// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]], +// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]], +// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], +// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1 +// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}** [[T_VAR_PTR_REF]], +// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}* [[T_VAR_REF]], +// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]], +// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}]** [[VEC_PTR_REF:%.+]], +// CHECK: br label %[[VEC_PRIV_INIT:.+]] +// CHECK: [[VEC_PRIV_INIT]] +// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8* +// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8* +// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]], +// CHECK: br label %[[VEC_PRIV_INIT_END:.+]] +// CHECK: [[VEC_PRIV_INIT_END]] +// CHECK: [[S_ARR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 +// CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_FLOAT_TY]]]** [[S_ARR_REF_PTR]], +// CHECK: br label %[[S_ARR_PRIV_INIT:.+]] +// CHECK: [[S_ARR_PRIV_INIT]] +// CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2 +// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2 +// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]] +// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]] +// CHECK: [[S_ARR_BODY]] +// CHECK: call {{.*}} [[ST_TY_DEFAULT_CONSTR:@.+]]([[ST_TY]]* [[ST_TY_TEMP:%.+]]) +// CHECK: call {{.*}} [[S_FLOAT_TY_COPY_CONSTR:@.+]]([[S_FLOAT_TY]]* {{.+}}, [[S_FLOAT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: call {{.*}} [[ST_TY_DESTR:@.+]]([[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]] +// CHECK: br label %[[S_ARR_PRIV_INIT_END:.+]] +// CHECK: [[S_ARR_PRIV_INIT_END]] +// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]]** [[VAR_REF_PTR]], +// CHECK: call {{.*}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]]* [[ST_TY_TEMP:%.+]]) +// CHECK: call {{.*}} [[S_FLOAT_TY_COPY_CONSTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]], [[S_FLOAT_TY]]* {{.*}} [[VAR_REF]], [[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_ADDR]] +// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}* [[GTID_REF]] +// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) +// CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* +// CHECK: ret void + +// CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]() +// CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]], +// CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]]) +// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_TMAIN_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void +// CHECK: call {{.*}} [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]* +// CHECK: ret +// +// CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_TMAIN_TY]]* %{{.+}}) +// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, +// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], +// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]], +// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]], +// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]], +// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1 +// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}** [[T_VAR_PTR_REF]], +// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}* [[T_VAR_REF]], +// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]], +// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}]** [[VEC_PTR_REF:%.+]], +// CHECK: br label %[[VEC_PRIV_INIT:.+]] +// CHECK: [[VEC_PRIV_INIT]] +// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8* +// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8* +// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]], +// CHECK: br label %[[VEC_PRIV_INIT_END:.+]] +// CHECK: [[VEC_PRIV_INIT_END]] +// CHECK: [[S_ARR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2 +// CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_INT_TY]]]** [[S_ARR_REF_PTR]], +// CHECK: br label %[[S_ARR_PRIV_INIT:.+]] +// CHECK: [[S_ARR_PRIV_INIT]] +// CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 +// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2 +// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2 +// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]] +// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]] +// CHECK: [[S_ARR_BODY]] +// CHECK: call {{.*}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]]* [[ST_TY_TEMP:%.+]]) +// CHECK: call {{.*}} [[S_INT_TY_COPY_CONSTR:@.+]]([[S_INT_TY]]* {{.+}}, [[S_INT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]] +// CHECK: br label %[[S_ARR_PRIV_INIT_END:.+]] +// CHECK: [[S_ARR_PRIV_INIT_END]] +// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3 +// CHECK: [[VAR_REF:%.+]] = load [[S_INT_TY]]** [[VAR_REF_PTR]], +// CHECK: call {{.*}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]]* [[ST_TY_TEMP:%.+]]) +// CHECK: call {{.*}} [[S_INT_TY_COPY_CONSTR]]([[S_INT_TY]]* [[VAR_PRIV]], [[S_INT_TY]]* {{.*}} [[VAR_REF]], [[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: call {{.*}} [[ST_TY_DESTR]]([[ST_TY]]* [[ST_TY_TEMP]]) +// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_ADDR]] +// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}* [[GTID_REF]] +// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]]) +// CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]* +// CHECK: ret void +#endif + diff --git a/test/OpenMP/parallel_firstprivate_messages.cpp b/test/OpenMP/parallel_firstprivate_messages.cpp index 9df45c60e708..7d1e3593500e 100644 --- a/test/OpenMP/parallel_firstprivate_messages.cpp +++ b/test/OpenMP/parallel_firstprivate_messages.cpp @@ -13,7 +13,7 @@ class S2 { mutable int a; public: S2():a(0) { } - S2(S2 &s2):a(s2.a) { } + S2(const S2 &s2):a(s2.a) { } static float S2s; static const float S2sc; }; @@ -24,22 +24,22 @@ class S3 { int a; public: S3():a(0) { } - S3(S3 &s3):a(s3.a) { } + S3(const S3 &s3):a(s3.a) { } }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note {{implicitly declared private here}} public: S4(int v):a(v) { } }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; S5():a(0) {} - S5(const S5 &s5):a(s5.a) { } + S5(const S5 &s5):a(s5.a) { } // expected-note {{implicitly declared private here}} public: S5(int v):a(v) { } }; @@ -50,8 +50,8 @@ S3 h; int main(int argc, char **argv) { const int d = 5; const int da[5] = { 0 }; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel firstprivate // expected-error {{expected '(' after 'firstprivate'}} @@ -69,7 +69,7 @@ int main(int argc, char **argv) { #pragma omp parallel firstprivate(da) #pragma omp parallel firstprivate(S2::S2s) #pragma omp parallel firstprivate(S2::S2sc) - #pragma omp parallel firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + #pragma omp parallel firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} #pragma omp parallel firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} #pragma omp parallel private(i), firstprivate(i) // expected-error {{private variable cannot be firstprivate}} expected-note{{defined as private}} foo(); diff --git a/test/OpenMP/parallel_for_firstprivate_messages.cpp b/test/OpenMP/parallel_for_firstprivate_messages.cpp index 99dd68f3cbfa..b4958733deca 100644 --- a/test/OpenMP/parallel_for_firstprivate_messages.cpp +++ b/test/OpenMP/parallel_for_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -27,22 +27,22 @@ class S3 { public: S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3(const S3 &s3) : a(s3.a) {} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note 2 {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note 4 {{'S5' declared here}} +class S5 { int a; - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} public: S5() : a(0) {} @@ -62,8 +62,8 @@ S3 h; template <class I, class C> int foomain(int argc, char **argv) { - I e(4); // expected-note {{'e' defined here}} - C g(5); // expected-note 2 {{'g' defined here}} + I e(4); + C g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel for firstprivate // expected-error {{expected '(' after 'firstprivate'}} @@ -96,7 +96,7 @@ int foomain(int argc, char **argv) { #pragma omp parallel for firstprivate(argv[1]) // expected-error {{expected variable name}} for (int k = 0; k < argc; ++k) ++k; -#pragma omp parallel for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel for firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (int k = 0; k < argc; ++k) ++k; #pragma omp parallel for firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} @@ -123,7 +123,7 @@ int foomain(int argc, char **argv) { #pragma omp parallel for firstprivate(i) for (int k = 0; k < argc; ++k) ++k; -#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel private(i) @@ -140,8 +140,8 @@ int foomain(int argc, char **argv) { int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note 2 {{'g' defined here}} + S4 e(4); + S5 g(5); S3 m; S6 n(2); int i; @@ -201,7 +201,7 @@ int main(int argc, char **argv) { #pragma omp parallel for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel for'}} for (i = 0; i < argc; ++i) foo(); -#pragma omp parallel for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel for firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel for firstprivate(m) // OK @@ -223,7 +223,7 @@ int main(int argc, char **argv) { #pragma omp parallel for firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} for (i = 0; i < argc; ++i) foo(); -#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} for (i = 0; i < argc; ++i) foo(); #pragma omp parallel for lastprivate(n) firstprivate(n) // OK diff --git a/test/OpenMP/parallel_for_loop_messages.cpp b/test/OpenMP/parallel_for_loop_messages.cpp index f029ef4d76cb..c3299976bd06 100644 --- a/test/OpenMP/parallel_for_loop_messages.cpp +++ b/test/OpenMP/parallel_for_loop_messages.cpp @@ -11,6 +11,7 @@ public: static int sii; #pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} +static int globalii; int test_iteration_spaces() { const int N = 100; @@ -263,6 +264,21 @@ int test_iteration_spaces() { c[sii] = a[sii]; } + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be a variable with global storage without being explicitly marked as private}} +#pragma omp parallel for + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] = a[globalii]; + } + + { +// expected-error@+3 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be a variable with global storage without being explicitly marked as private}} +#pragma omp parallel for collapse(2) + for (ii = 0; ii < 10; ii += 1) + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] += a[globalii] + ii; + } + // expected-error@+2 {{statement after '#pragma omp parallel for' must be a for loop}} #pragma omp parallel for for (auto &item : a) { @@ -309,6 +325,8 @@ public: Iter0 operator--() { return *this; } bool operator<(Iter0 a) { return true; } }; +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'Iter0' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}} int operator-(Iter0 a, Iter0 b) { return 0; } class Iter1 { public: @@ -327,6 +345,7 @@ public: GoodIter &operator=(const GoodIter &that) { return *this; } GoodIter &operator=(const Iter0 &that) { return *this; } GoodIter &operator+=(int x) { return *this; } + GoodIter &operator-=(int x) { return *this; } explicit GoodIter(void *) {} GoodIter operator++() { return *this; } GoodIter operator--() { return *this; } @@ -337,11 +356,20 @@ public: typedef int difference_type; typedef std::random_access_iterator_tag iterator_category; }; +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'GoodIter' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} int operator-(GoodIter a, GoodIter b) { return 0; } +// expected-note@+1 3 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}} GoodIter operator-(GoodIter a) { return a; } +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'int' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'GoodIter' for 1st argument}} GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'int' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}} GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'int' for 1st argument}} GoodIter operator+(int v, GoodIter a) { return GoodIter(); } int test_with_random_access_iterator() { @@ -376,6 +404,8 @@ int test_with_random_access_iterator() { #pragma omp parallel for for (begin = GoodIter(0); begin < end; ++begin) ++begin; +// expected-error@+3 {{invalid operands to binary expression ('GoodIter' and 'const Iter0')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} #pragma omp parallel for for (begin = begin0; begin < end; ++begin) ++begin; @@ -419,15 +449,19 @@ int test_with_random_access_iterator() { #pragma omp parallel for for (GoodIter I = begin; I >= end; I = 2 - I) ++I; +// expected-error@+2 {{invalid operands to binary expression ('Iter0' and 'int')}} #pragma omp parallel for for (Iter0 I = begin0; I < end0; ++I) ++I; // Initializer is constructor without params. +// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}} // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp parallel for for (Iter0 I; I < end0; ++I) ++I; Iter1 begin1, end1; +// expected-error@+3 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} #pragma omp parallel for for (Iter1 I = begin1; I < end1; ++I) ++I; @@ -436,6 +470,8 @@ int test_with_random_access_iterator() { #pragma omp parallel for for (Iter1 I = begin1; I >= end1; ++I) ++I; +// expected-error@+5 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+4 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} // Initializer is constructor with all default params. // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp parallel for diff --git a/test/OpenMP/parallel_for_misc_messages.c b/test/OpenMP/parallel_for_misc_messages.c index b236a613c319..f07a0f2a4c4c 100644 --- a/test/OpenMP/parallel_for_misc_messages.c +++ b/test/OpenMP/parallel_for_misc_messages.c @@ -165,6 +165,17 @@ void test_collapse() { #pragma omp parallel for collapse(5 - 5) for (i = 0; i < 16; ++i) ; +// expected-note@+1 {{defined as firstprivate}} +#pragma omp parallel for collapse(2) firstprivate(i) + for (i = 0; i < 16; ++i) +// expected-note@+1 {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for' directive into a parallel or another task region?}} + for (int j = 0; j < 16; ++j) +// expected-error@+3 {{reduction variable must be shared}} +// expected-error@+2 {{private variable cannot be reduction}} +// expected-error@+1 {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} +#pragma omp for reduction(+ : i, j) + for (int k = 0; k < 16; ++k) + i += j; } void test_private() { diff --git a/test/OpenMP/parallel_for_private_messages.cpp b/test/OpenMP/parallel_for_private_messages.cpp index 7366fe8c47c5..31b84588de0b 100644 --- a/test/OpenMP/parallel_for_private_messages.cpp +++ b/test/OpenMP/parallel_for_private_messages.cpp @@ -24,16 +24,16 @@ public: S3() : a(0) {} }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -109,8 +109,8 @@ int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel for private // expected-error {{expected '(' after 'private'}} @@ -143,7 +143,7 @@ int main(int argc, char **argv) { #pragma omp parallel for private(argv[1]) // expected-error {{expected variable name}} for (int k = 0; k < argc; ++k) ++k; -#pragma omp parallel for private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp parallel for private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (int k = 0; k < argc; ++k) ++k; #pragma omp parallel for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} diff --git a/test/OpenMP/parallel_for_simd_aligned_messages.cpp b/test/OpenMP/parallel_for_simd_aligned_messages.cpp new file mode 100644 index 000000000000..ea4ec21f28a9 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_aligned_messages.cpp @@ -0,0 +1,202 @@ +// RUN: %clang_cc1 -x c++ -std=c++11 -verify -fopenmp=libiomp5 %s + +struct B { + static int ib[20]; // expected-note 0 {{'B::ib' declared here}} + static constexpr int bfoo() { return 8; } +}; +namespace X { + B x; // expected-note {{'x' defined here}} +}; +constexpr int bfoo() { return 4; } + +int **z; +const int C1 = 1; +const int C2 = 2; +void test_aligned_colons(int *&rp) +{ + int *B = 0; + #pragma omp parallel for simd aligned(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp parallel for simd aligned(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp parallel for simd aligned(z:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'int **'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'B'}} + #pragma omp parallel for simd aligned(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}} + #pragma omp parallel for simd aligned(B,rp,::z: X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd aligned(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp parallel for simd aligned(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}} + #pragma omp parallel for simd aligned(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +// expected-note@+1 {{'num' defined here}} +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; + // Negative number is passed as L. + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp parallel for simd aligned(arr:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp parallel for simd aligned(num:4) + for (i = 0; i < num; ++i); + return T(); +} + +template<int LEN> int test_warn() { + int *ind2 = 0; + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp parallel for simd aligned(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return 0; +} + +struct S1; // expected-note 2 {{declared here}} +extern S1 a; // expected-note {{'a' declared here}} +class S2 { + mutable int a; +public: + S2():a(0) { } +}; +const S2 b; // expected-note 1 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} +public: + S5(int v):a(v) { } +}; + +S3 h; // expected-note 2 {{'h' defined here}} +#pragma omp threadprivate(h) + +template<class I, class C> int foomain(I argc, C **argv) { + I e(argc); + I g(argc); + int i; // expected-note {{declared here}} expected-note {{'i' defined here}} + // expected-note@+2 {{declared here}} + // expected-note@+1 {{reference to 'i' is not a constant expression}} + int &j = i; + #pragma omp parallel for simd aligned // expected-error {{expected '(' after 'aligned'}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned () // expected-error {{expected expression}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argv[1]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned(e, g) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp parallel for simd aligned(h) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp parallel for simd aligned(i) + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int *v = 0; + I i; + #pragma omp parallel for simd aligned(v:16) + for (I k = 0; k < argc; ++k) { i = k; v += 2; } + } + float *f; + #pragma omp parallel for simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + int v = 0; + // expected-note@+2 {{initializer of 'j' is not a constant expression}} + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp parallel for simd aligned(f:j) + for (I k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp parallel for simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + return 0; +} + +// expected-note@+1 2 {{'argc' defined here}} +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + test_warn<4>(); // ok + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + int i; + int &j = i; + #pragma omp parallel for simd aligned // expected-error {{expected '(' after 'aligned'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argv // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp parallel for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp parallel for simd aligned (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S1'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S2'}} + #pragma omp parallel for simd aligned (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd aligned (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp parallel for simd aligned(h) + for (int k = 0; k < argc; ++k) ++k; + int *pargc = &argc; + foomain<int*,char>(pargc,argv); + return 0; +} + diff --git a/test/OpenMP/parallel_for_simd_ast_print.cpp b/test/OpenMP/parallel_for_simd_ast_print.cpp new file mode 100644 index 000000000000..4192695cf037 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_ast_print.cpp @@ -0,0 +1,128 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} +int g_ind = 1; +template<class T, class N> T reduct(T* arr, N num) { + N i; + N ind; + N myind; + T sum = (T)0; +// CHECK: T sum = (T)0; +#pragma omp parallel for simd private(myind, g_ind), linear(ind), aligned(arr) +// CHECK-NEXT: #pragma omp parallel for simd private(myind,g_ind) linear(ind) aligned(arr) + for (i = 0; i < num; ++i) { + myind = ind; + T cur = arr[myind]; + ind += g_ind; + sum += cur; + } +} + +template<class T> struct S { + S(const T &a) + :m_a(a) + {} + T result(T *v) const { + T res; + T val; + T lin = 0; +// CHECK: T res; +// CHECK: T val; +// CHECK: T lin = 0; + #pragma omp parallel for simd private(val) safelen(7) linear(lin : -5) lastprivate(res) +// CHECK-NEXT: #pragma omp parallel for simd private(val) safelen(7) linear(lin: -5) lastprivate(res) + for (T i = 7; i < m_a; ++i) { + val = v[i-7] + m_a; + res = val; + lin -= 5; + } + const T clen = 3; +// CHECK: T clen = 3; + #pragma omp parallel for simd safelen(clen-1) +// CHECK-NEXT: #pragma omp parallel for simd safelen(clen - 1) + for(T i = clen+2; i < 20; ++i) { +// CHECK-NEXT: for (T i = clen + 2; i < 20; ++i) { + v[i] = v[v-clen] + 1; +// CHECK-NEXT: v[i] = v[v - clen] + 1; + } +// CHECK-NEXT: } + return res; + } + ~S() + {} + T m_a; +}; + +template<int LEN> struct S2 { + static void func(int n, float *a, float *b, float *c) { + int k1 = 0, k2 = 0; +#pragma omp parallel for simd safelen(LEN) linear(k1,k2:LEN) aligned(a:LEN) + for(int i = 0; i < n; i++) { + c[i] = a[i] + b[i]; + c[k1] = a[k1] + b[k1]; + c[k2] = a[k2] + b[k2]; + k1 = k1 + LEN; + k2 = k2 + LEN; + } + } +}; + +// S2<4>::func is called below in main. +// CHECK: template <int LEN = 4> struct S2 { +// CHECK-NEXT: static void func(int n, float *a, float *b, float *c) { +// CHECK-NEXT: int k1 = 0, k2 = 0; +// CHECK-NEXT: #pragma omp parallel for simd safelen(4) linear(k1,k2: 4) aligned(a: 4) +// CHECK-NEXT: for (int i = 0; i < n; i++) { +// CHECK-NEXT: c[i] = a[i] + b[i]; +// CHECK-NEXT: c[k1] = a[k1] + b[k1]; +// CHECK-NEXT: c[k2] = a[k2] + b[k2]; +// CHECK-NEXT: k1 = k1 + 4; +// CHECK-NEXT: k2 = k2 + 4; +// CHECK-NEXT: } +// CHECK-NEXT: } + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + int k1=0,k2=0; + static int *a; +// CHECK: static int *a; +#pragma omp parallel for simd +// CHECK-NEXT: #pragma omp parallel for simd + for (int i=0; i < 2; ++i)*a=2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: *a = 2; +#pragma omp parallel +#pragma omp parallel for simd private(argc, b),lastprivate(d,f) collapse(2) aligned(a : 4) ,firstprivate( g ) + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) {foo(); k1 += 8; k2 += 8;} +// CHECK-NEXT: #pragma omp parallel +// CHECK-NEXT: #pragma omp parallel for simd private(argc,b) lastprivate(d,f) collapse(2) aligned(a: 4) firstprivate(g) +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: for (int j = 0; j < 10; ++j) { +// CHECK-NEXT: foo(); +// CHECK-NEXT: k1 += 8; +// CHECK-NEXT: k2 += 8; +// CHECK-NEXT: } + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + const int CLEN = 4; +// CHECK-NEXT: const int CLEN = 4; + #pragma omp parallel for simd aligned(a:CLEN) linear(a:CLEN) safelen(CLEN) collapse( 1 ) +// CHECK-NEXT: #pragma omp parallel for simd aligned(a: CLEN) linear(a: CLEN) safelen(CLEN) collapse(1) + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + + float arr[16]; + S2<4>::func(0,arr,arr,arr); + return (0); +} + +#endif diff --git a/test/OpenMP/parallel_for_simd_collapse_messages.cpp b/test/OpenMP/parallel_for_simd_collapse_messages.cpp new file mode 100644 index 000000000000..b829497e17f3 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_collapse_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp parallel for simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp parallel for simd collapse (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp parallel for simd collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp parallel for simd', but found only 1}} + // expected-error@+3 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'collapse' clause}} + // expected-error@+2 2 {{argument to 'collapse' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse (1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse (N) // expected-error {{argument to 'collapse' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp parallel for simd'}} + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel for simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd collapse () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} + #pragma omp parallel for simd collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} + #pragma omp parallel for simd collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'collapse' clause}} + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp parallel for simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd collapse (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp parallel for simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp parallel for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp parallel for simd collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + #pragma omp parallel for simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp parallel for simd'}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/parallel_for_simd_copyin_messages.cpp b/test/OpenMP/parallel_for_simd_copyin_messages.cpp new file mode 100644 index 000000000000..e0b7e6354ebb --- /dev/null +++ b/test/OpenMP/parallel_for_simd_copyin_messages.cpp @@ -0,0 +1,93 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2 &operator=(S2 &s2) { return *this; } +}; +class S3 { + int a; + +public: + S3() : a(0) {} + S3 &operator=(S3 &s3) { return *this; } +}; +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4 &operator=(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + S5 &operator=(const S5 &s5) { return *this; } + +public: + S5(int v) : a(v) {} +}; +template <class T> +class ST { +public: + static T s; +}; + +S2 k; +S3 h; +S4 l(3); // expected-note {{'l' defined here}} +S5 m(4); // expected-note {{'m' defined here}} +#pragma omp threadprivate(h, k, l, m) + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for simd copyin // expected-error {{expected '(' after 'copyin'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(k // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(l) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(i) // expected-error {{copyin variable must be threadprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(m) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd copyin(ST < int > ::s) // expected-error {{copyin variable must be threadprivate}} + for (i = 0; i < argc; ++i) + foo(); + + return 0; +} diff --git a/test/OpenMP/parallel_for_simd_default_messages.cpp b/test/OpenMP/parallel_for_simd_default_messages.cpp new file mode 100644 index 000000000000..6675029abe50 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_default_messages.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo(); + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for simd default // expected-error {{expected '(' after 'default'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd default( // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd default() // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd default(none // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + foo(); +#pragma omp parallel for simd default(shared), default(shared) // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'default' clause}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd default(x) // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel for simd default(none) + for (i = 0; i < argc; ++i) // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + foo(); + +#pragma omp parallel default(none) +#pragma omp parallel for simd default(shared) + for (i = 0; i < argc; ++i) + foo(); + + return 0; +} diff --git a/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp b/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp new file mode 100644 index 000000000000..876d422e634d --- /dev/null +++ b/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp @@ -0,0 +1,250 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(const S2 &s2) : a(s2.a) {} + static float S2s; + static const float S2sc; +}; +const float S2::S2sc = 0; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} + +public: + S5() : a(0) {} + S5(int v) : a(v) {} +}; +class S6 { + int a; + S6() : a(0) {} + +public: + S6(const S6 &s6) : a(s6.a) {} + S6(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(int argc, char **argv) { + I e(4); + C g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) + ++k; + { + int v = 0; + int i; +#pragma omp parallel for simd firstprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for simd firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd firstprivate(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(i) +#pragma omp parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} + foo(); +#pragma omp parallel reduction(+ : i) +#pragma omp parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} + foo(); + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); + S5 g(5); + S3 m; + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(ba) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(ca) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(da) // OK + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel for simd firstprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(S2::S2s) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(S2::S2sc) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd safelen(5) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(m) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} + foo(); +#pragma omp parallel for simd firstprivate(xa) // OK: may be firstprivate + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for simd firstprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel private(i) +#pragma omp parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} + foo(); +#pragma omp parallel reduction(+ : i) +#pragma omp parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} + foo(); + + return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} +} diff --git a/test/OpenMP/parallel_for_simd_if_messages.cpp b/test/OpenMP/parallel_for_simd_if_messages.cpp new file mode 100644 index 000000000000..b91dd18635bd --- /dev/null +++ b/test/OpenMP/parallel_for_simd_if_messages.cpp @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + T i; + #pragma omp parallel for simd if // expected-error {{expected '(' after 'if'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc > 0 ? argv[1] : argv[2]) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'if' clause}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (S) // expected-error {{'S' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if(argc) + for (i = 0; i < argc; ++i) foo(); + + return 0; +} + +int main(int argc, char **argv) { + int i; + #pragma omp parallel for simd if // expected-error {{expected '(' after 'if'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc > 0 ? argv[1] : argv[2]) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'if' clause}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/parallel_for_simd_lastprivate_messages.cpp b/test/OpenMP/parallel_for_simd_lastprivate_messages.cpp new file mode 100644 index 000000000000..b620c7fc010b --- /dev/null +++ b/test/OpenMP/parallel_for_simd_lastprivate_messages.cpp @@ -0,0 +1,226 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + S5(int v) : a(v) {} +}; +class S6 { + int a; + S6() : a(0) {} + +public: + S6(const S6 &s6) : a(s6.a) {} + S6(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(int argc, char **argv) { + I e(4); // expected-note {{'e' defined here}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for simd lastprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd lastprivate(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(ba) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel for simd lastprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd safelen(5) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(i) // expected-note {{defined as lastprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be lastprivate, predetermined as linear}} + foo(); +#pragma omp parallel private(xa) +#pragma omp parallel for simd lastprivate(xa) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : xa) +#pragma omp parallel for simd lastprivate(xa) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + foo(); + return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} +} diff --git a/test/OpenMP/parallel_for_simd_linear_messages.cpp b/test/OpenMP/parallel_for_simd_linear_messages.cpp new file mode 100644 index 000000000000..3918de2681db --- /dev/null +++ b/test/OpenMP/parallel_for_simd_linear_messages.cpp @@ -0,0 +1,206 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +namespace X { + int x; +}; + +struct B { + static int ib; // expected-note {{'B::ib' declared here}} + static int bfoo() { return 8; } +}; + +int bfoo() { return 4; } + +int z; +const int C1 = 1; +const int C2 = 2; +void test_linear_colons() +{ + int B = 0; + #pragma omp parallel for simd linear(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp parallel for simd linear(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{use of undeclared identifier 'ib'; did you mean 'B::ib'}} + #pragma omp parallel for simd linear(B:ib) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp parallel for simd linear(z:B:ib) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd linear(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd linear(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd linear(B,::z, X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd linear(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp parallel for simd linear(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp parallel for simd linear(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; // expected-note {{'ind2' defined here}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type}} +#pragma omp parallel for simd linear(ind2:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + return T(); +} + +template<int LEN> int test_warn() { + int ind2 = 0; + // expected-warning@+1 {{zero linear step (ind2 should probably be const)}} + #pragma omp parallel for simd linear(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return ind2; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; +public: + S2():a(0) { } +}; +const S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} +public: + S5(int v):a(v) { } +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template<class I, class C> int foomain(I argc, C **argv) { + I e(4); + I g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} + #pragma omp parallel for simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc : 5) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp parallel for simd linear (a, b:B::ib) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int v = 0; + int i; + #pragma omp parallel for simd linear(v:i) + for (int k = 0; k < argc; ++k) { i = k; v += i; } + } + #pragma omp parallel for simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type}} + for (int k = 0; k < argc; ++k) ++k; + int v = 0; + #pragma omp parallel for simd linear(v:j) + for (int k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + return 0; +} + +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} + #pragma omp parallel for simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp parallel for simd linear (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of a linear clause should be of integral or pointer type, not 'S4'}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S5'}} + #pragma omp parallel for simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int i; + #pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(i : 4) + for (int k = 0; k < argc; ++k) { ++k; i += 4; } + } + #pragma omp parallel for simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type 'int &'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel for simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + + foomain<int,char>(argc,argv); + return 0; +} + diff --git a/test/OpenMP/parallel_for_simd_loop_messages.cpp b/test/OpenMP/parallel_for_simd_loop_messages.cpp new file mode 100644 index 000000000000..50acb10feed9 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_loop_messages.cpp @@ -0,0 +1,644 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s + +class S { + int a; + S() : a(0) {} + +public: + S(int v) : a(v) {} + S(const S &s) : a(s.a) {} +}; + +static int sii; +#pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} +static int globalii; + +int test_iteration_spaces() { + const int N = 100; + float a[N], b[N], c[N]; + int ii, jj, kk; + float fii; + double dii; +#pragma omp parallel for simd + for (int i = 0; i < 10; i += 1) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for simd + for (char i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for simd + for (char i = 0; i < 10; i += '\1') { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for simd + for (long long i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}} +#pragma omp parallel for simd + for (long long i = 0; i < 10; i += 1.5) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for simd + for (long long i = 0; i < 'z'; i += 1u) { + c[i] = a[i] + b[i]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for simd + for (int &ref = ii; ref < 10; ref++) { + } +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (int i; i < 10; i++) + c[i] = a[i]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (int i = 0, j = 0; i < 10; ++i) + c[i] = a[i]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (ii + 1; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (c[ii] = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// Ok to skip parenthesises. +#pragma omp parallel for simd + for (((ii)) = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for simd + for (int i = 0; i; i++) + c[i] = a[i]; + +// expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}} +#pragma omp parallel for simd + for (int i = 0; jj < kk; ii++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for simd + for (int i = 0; !!i; i++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for simd + for (int i = 0; i != 1; i++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for simd + for (int i = 0;; i++) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for simd + for (int i = 11; i > 10; i--) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for simd + for (ii = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ++jj) + c[ii] = a[jj]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ++++ii) + c[ii] = a[ii]; + +// Ok but undefined behavior (in general, cannot check that incr +// is really loop-invariant). +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii + ii) + c[ii] = a[ii]; + +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii + 1.0f) + c[ii] = a[ii]; + +// Ok - step was converted to integer type. +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii + (int)1.1f) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; jj = ii + 2) + c[ii] = a[ii]; + +// expected-warning@+3 {{relational comparison result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii<10; jj> kk + 2) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10;) + c[ii] = a[ii]; + +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; !ii) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii ? ++ii : ++jj) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii < 10) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii + 0) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; (ii) < 10; ii -= 25) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; (ii < 10); ii -= 0) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; ii > 10; (ii += 0)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; ii < 10; (ii) = (1 - 1) + (ii)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for ((ii = 0); ii > 10; (ii -= 0)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (ii = 0; (ii < 10); (ii -= 0)) + c[ii] = a[ii]; + +// expected-note@+2 {{defined as firstprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be firstprivate, predetermined as linear}} +#pragma omp parallel for simd firstprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel for simd linear(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +// expected-note@+2 {{defined as private}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be private, predetermined as linear}} +#pragma omp parallel for simd private(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +// expected-note@+2 {{defined as lastprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be lastprivate, predetermined as linear}} +#pragma omp parallel for simd lastprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be threadprivate or thread local, predetermined as linear}} +#pragma omp parallel for simd + for (sii = 0; sii < 10; sii += 1) + c[sii] = a[sii]; + } + + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be a variable with global storage without being explicitly marked as linear}} +#pragma omp parallel for simd + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] = a[globalii]; + } + + { +// expected-error@+3 {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be a variable with global storage without being explicitly marked as lastprivate}} +#pragma omp parallel for simd collapse(2) + for (ii = 0; ii < 10; ii += 1) + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] += a[globalii] + ii; + } + +// expected-error@+2 {{statement after '#pragma omp parallel for simd' must be a for loop}} +#pragma omp parallel for simd + for (auto &item : a) { + item = item + 1; + } + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (unsigned i = 9; i < 10; i--) { + c[i] = a[i] + b[i]; + } + + int(*lb)[4] = nullptr; +#pragma omp parallel for simd + for (int(*p)[4] = lb; p < lb + 8; ++p) { + } + +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (int a{0}; a < 10; ++a) { + } + + return 0; +} + +// Iterators allowed in openmp for-loops. +namespace std { +struct random_access_iterator_tag {}; +template <class Iter> +struct iterator_traits { + typedef typename Iter::difference_type difference_type; + typedef typename Iter::iterator_category iterator_category; +}; +template <class Iter> +typename iterator_traits<Iter>::difference_type +distance(Iter first, Iter last) { return first - last; } +} +class Iter0 { +public: + Iter0() {} + Iter0(const Iter0 &) {} + Iter0 operator++() { return *this; } + Iter0 operator--() { return *this; } + bool operator<(Iter0 a) { return true; } +}; +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'Iter0' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}} +int operator-(Iter0 a, Iter0 b) { return 0; } +class Iter1 { +public: + Iter1(float f = 0.0f, double d = 0.0) {} + Iter1(const Iter1 &) {} + Iter1 operator++() { return *this; } + Iter1 operator--() { return *this; } + bool operator<(Iter1 a) { return true; } + bool operator>=(Iter1 a) { return false; } +}; +class GoodIter { +public: + GoodIter() {} + GoodIter(const GoodIter &) {} + GoodIter(int fst, int snd) {} + GoodIter &operator=(const GoodIter &that) { return *this; } + GoodIter &operator=(const Iter0 &that) { return *this; } + GoodIter &operator+=(int x) { return *this; } + explicit GoodIter(void *) {} + GoodIter operator++() { return *this; } + GoodIter operator--() { return *this; } + bool operator!() { return true; } + bool operator<(GoodIter a) { return true; } + bool operator<=(GoodIter a) { return true; } + bool operator>=(GoodIter a) { return false; } + typedef int difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'GoodIter' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} +int operator-(GoodIter a, GoodIter b) { return 0; } +// expected-note@+1 3 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}} +GoodIter operator-(GoodIter a) { return a; } +// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'int' for 2nd argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} +GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'GoodIter' for 1st argument}} +GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'int' for 1st argument}} +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}} +GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'int' for 1st argument}} +GoodIter operator+(int v, GoodIter a) { return GoodIter(); } + +int test_with_random_access_iterator() { + GoodIter begin, end; + Iter0 begin0, end0; +#pragma omp parallel for simd + for (GoodIter I = begin; I < end; ++I) + ++I; +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for simd + for (GoodIter &I = begin; I < end; ++I) + ++I; +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; --I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (GoodIter I(begin); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (GoodIter I(nullptr); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (GoodIter I(0); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (GoodIter I(1, 2); I < end; ++I) + ++I; +#pragma omp parallel for simd + for (begin = GoodIter(0); begin < end; ++begin) + ++begin; +// expected-error@+3 {{invalid operands to binary expression ('GoodIter' and 'const Iter0')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +#pragma omp parallel for simd + for (begin = begin0; begin < end; ++begin) + ++begin; +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for simd + for (++begin; begin < end; ++begin) + ++begin; +#pragma omp parallel for simd + for (begin = end; begin < end; ++begin) + ++begin; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for simd + for (GoodIter I = begin; I - I; ++I) + ++I; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for simd + for (GoodIter I = begin; begin < end; ++I) + ++I; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for simd + for (GoodIter I = begin; !I; ++I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; I = I + 1) + ++I; +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; I = I - 1) + ++I; +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; I = -I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; I = 2 + I) + ++I; +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp parallel for simd + for (GoodIter I = begin; I >= end; I = 2 - I) + ++I; +// expected-error@+2 {{invalid operands to binary expression ('Iter0' and 'int')}} +#pragma omp parallel for simd + for (Iter0 I = begin0; I < end0; ++I) + ++I; +// Initializer is constructor without params. +// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}} +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (Iter0 I; I < end0; ++I) + ++I; + Iter1 begin1, end1; +// expected-error@+3 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +#pragma omp parallel for simd + for (Iter1 I = begin1; I < end1; ++I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (Iter1 I = begin1; I >= end1; ++I) + ++I; +// expected-error@+5 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} +// expected-error@+4 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} +// Initializer is constructor with all default params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for simd + for (Iter1 I; I < end1; ++I) { + } + return 0; +} + +template <typename IT, int ST> +class TC { +public: + int dotest_lt(IT begin, IT end) { +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (IT I = begin; I < end; I = I + ST) { + ++I; + } +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (IT I = begin; I <= end; I += ST) { + ++I; + } +#pragma omp parallel for simd + for (IT I = begin; I < end; ++I) { + ++I; + } + } + + static IT step() { + return IT(ST); + } +}; +template <typename IT, int ST = 0> +int dotest_gt(IT begin, IT end) { +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (IT I = begin; I >= end; I = I + ST) { + ++I; + } +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (IT I = begin; I >= end; I += ST) { + ++I; + } + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for simd + for (IT I = begin; I >= end; ++I) { + ++I; + } + +#pragma omp parallel for simd + for (IT I = begin; I < end; I += TC<int, ST>::step()) { + ++I; + } +} + +void test_with_template() { + GoodIter begin, end; + TC<GoodIter, 100> t1; + TC<GoodIter, -100> t2; + t1.dotest_lt(begin, end); + t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}} + dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}} + dotest_gt<unsigned, -10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, -10>' requested here}} +} + +void test_loop_break() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel for simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + break; // OK in nested loop + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + if (c[i] > 10) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + + if (c[i] > 11) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + } + +#pragma omp parallel for simd + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + c[i] = a[i] + b[i]; + if (c[i] > 10) { + if (c[i] < 20) { + break; // OK + } + } + } + } +} + +void test_loop_eh() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel for simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + try { // expected-error {{'try' statement cannot be used in OpenMP simd region}} + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } catch (float f) { + if (f > 0.1) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + return; // expected-error {{cannot return from OpenMP region}} + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + for (int j = 0; j < 10; j++) { + if (c[i] > 10) + throw c[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + } + if (c[9] > 10) + throw c[9]; // OK + +#pragma omp parallel for simd + for (int i = 0; i < 10; ++i) { + struct S { + void g() { throw 0; } + }; + } +} + +void test_loop_firstprivate_lastprivate() { + S s(4); +#pragma omp parallel for simd lastprivate(s) firstprivate(s) + for (int i = 0; i < 16; ++i) + ; +} + +void test_ordered() { +// expected-error@+1 2 {{unexpected OpenMP clause 'ordered' in directive '#pragma omp parallel for simd'}} +#pragma omp parallel for simd ordered ordered // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'ordered' clause}} + for (int i = 0; i < 16; ++i) + ; +} + +void test_nowait() { +// expected-error@+1 2 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp parallel for simd'}} +#pragma omp parallel for simd nowait nowait // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'nowait' clause}} + for (int i = 0; i < 16; ++i) + ; +} + diff --git a/test/OpenMP/parallel_for_simd_messages.cpp b/test/OpenMP/parallel_for_simd_messages.cpp new file mode 100644 index 000000000000..67a025c5e6a6 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_messages.cpp @@ -0,0 +1,87 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp parallel for simd // expected-error {{unexpected OpenMP directive '#pragma omp parallel for simd'}} + +int main(int argc, char **argv) { +#pragma omp parallel for simd { // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd ( // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd[ // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd] // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd } // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) + foo(); +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd unknown() + for (int i = 0; i < argc; ++i) + foo(); +L1: + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) { + goto L1; // expected-error {{use of undeclared label 'L1'}} + argc++; + } + + for (int i = 0; i < 10; ++i) { + switch (argc) { + case (0): +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) { + foo(); + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + continue; + } + default: + break; + } + } +#pragma omp parallel for simd default(none) + for (int i = 0; i < 10; ++i) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) + L2: + foo(); +#pragma omp parallel for simd + for (int i = 0; i < argc; ++i) { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} +#pragma omp parallel for simd + for (int n = 0; n < 100; ++n) { + } + + return 0; +} + +void test_ordered() { +// expected-error@+1 2 {{unexpected OpenMP clause 'ordered' in directive '#pragma omp parallel for simd'}} +#pragma omp parallel for simd ordered ordered // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'ordered' clause}} + for (int i = 0; i < 16; ++i) + ; +} + diff --git a/test/OpenMP/parallel_for_simd_misc_messages.c b/test/OpenMP/parallel_for_simd_misc_messages.c new file mode 100644 index 000000000000..4cb084318309 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_misc_messages.c @@ -0,0 +1,657 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel for simd'}} +#pragma omp parallel for simd + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel for simd'}} +#pragma omp parallel for simd foo + +void test_no_clause() { + int i; +#pragma omp parallel for simd + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{statement after '#pragma omp parallel for simd' must be a for loop}} +#pragma omp parallel for simd + ++i; +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel +#pragma omp parallel for simd + for (i = 0; i < 16; ++i) { + if (i == 5) + goto L1; // expected-error {{use of undeclared label 'L1'}} + else if (i == 6) + return; // expected-error {{cannot return from OpenMP region}} + else if (i == 7) + goto L2; + else if (i == 8) { + L2: + x[i]++; + } + } + + if (x[0] == 0) + goto L2; // expected-error {{use of undeclared label 'L2'}} + else if (x[1] == 1) + goto L1; +} + +void test_invalid_clause() { + int i; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd foo bar + for (i = 0; i < 16; ++i) + ; +} + +void test_non_identifiers() { + int i, x; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd; + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd linear(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd private(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +#pragma omp parallel for simd, private(x); + for (i = 0; i < 16; ++i) + ; +} + +extern int foo(); +void test_safelen() { + int i; +// expected-error@+1 {{expected '('}} +#pragma omp parallel for simd safelen + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen( + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd safelen() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(, ) + for (i = 0; i < 16; ++i) + ; +// expected-warning@+2 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp parallel for simd safelen 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4 + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4, , 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd safelen(4, 8) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for simd safelen(2.5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for simd safelen(foo()) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp parallel for simd safelen(-5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp parallel for simd safelen(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp parallel for simd safelen(5 - 5) + for (i = 0; i < 16; ++i) + ; +} + +void test_collapse() { + int i; +#pragma omp parallel +// expected-error@+1 {{expected '('}} +#pragma omp parallel for simd collapse + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd collapse( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd collapse() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd collapse(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd collapse(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-warning@+2 {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp parallel for simd collapse 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4 + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4, + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4, ) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4, , 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +#pragma omp parallel for simd collapse(4) + for (int i1 = 0; i1 < 16; ++i1) + for (int i2 = 0; i2 < 16; ++i2) + for (int i3 = 0; i3 < 16; ++i3) + for (int i4 = 0; i4 < 16; ++i4) + foo(); +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for simd collapse(4, 8) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for simd', but found only 1}} +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for simd collapse(2.5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for simd collapse(foo()) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for simd collapse(-5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for simd collapse(0) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for simd collapse(5 - 5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd collapse(2) + for (i = 0; i < 16; ++i) + for (int j = 0; j < 16; ++j) +// expected-error@+1 {{OpenMP constructs may not be nested inside a simd region}} +#pragma omp parallel for simd reduction(+ : i, j) + for (int k = 0; k < 16; ++k) + i += j; +} + +void test_linear() { + int i; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd linear( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd linear(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd linear(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd linear() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd linear(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for simd linear(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp parallel for simd linear(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp parallel for simd linear(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp parallel for simd linear(x, y, z) + for (i = 0; i < 16; ++i) + ; + + int x, y; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd linear(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd linear(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd linear(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd linear(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd linear(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd linear(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be linear}} +#pragma omp parallel for simd linear(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as private}} +// expected-error@+1 {{private variable cannot be linear}} +#pragma omp parallel for simd private(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be private}} +#pragma omp parallel for simd linear(x) private(x) + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}} +#pragma omp parallel for simd linear(x, y : 0) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be lastprivate}} +#pragma omp parallel for simd linear(x) lastprivate(x) + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-note@+2 {{defined as lastprivate}} +// expected-error@+1 {{lastprivate variable cannot be linear}} +#pragma omp parallel for simd lastprivate(x) linear(x) + for (i = 0; i < 16; ++i) + ; +} + +void test_aligned() { + int i; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd aligned( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd aligned(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd aligned(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd aligned() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd aligned(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for simd aligned(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp parallel for simd aligned(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp parallel for simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp parallel for simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; + + int *x, y, z[25]; // expected-note 4 {{'y' defined here}} +#pragma omp parallel for simd aligned(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd aligned(z) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd aligned(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd aligned(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd aligned(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for simd aligned(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd aligned(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd aligned(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp parallel for simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp parallel for simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as aligned}} +// expected-error@+1 {{a variable cannot appear in more than one aligned clause}} +#pragma omp parallel for simd aligned(x) aligned(z, x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+3 {{defined as aligned}} +// expected-error@+2 {{a variable cannot appear in more than one aligned clause}} +// expected-error@+1 2 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp parallel for simd aligned(x, y, z) aligned(y, z) + for (i = 0; i < 16; ++i) + ; +} + + +void test_private() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for simd private( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd private(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd private(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd private() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd private(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for simd private(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp parallel for simd private(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd private(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd private(x, y, z) + for (i = 0; i < 16; ++i) { + x = y * i + z; + } +} + +void test_lastprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd lastprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd lastprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd lastprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd lastprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd lastprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for simd lastprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_firstprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd firstprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd firstprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for simd firstprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd firstprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp parallel for simd firstprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for simd firstprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x) firstprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x, y) firstprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp parallel for simd lastprivate(x, y, z) firstprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_loop_messages() { + float a[100], b[100], c[100]; +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp parallel for simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp parallel for simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +} + diff --git a/test/OpenMP/parallel_for_simd_num_threads_messages.cpp b/test/OpenMP/parallel_for_simd_num_threads_messages.cpp new file mode 100644 index 000000000000..3d11d4f59cf6 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_num_threads_messages.cpp @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + T i; + #pragma omp parallel for simd num_threads // expected-error {{expected '(' after 'num_threads'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (S) // expected-error {{'S' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (N) // expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + + return argc; +} + +int main(int argc, char **argv) { + int i; + #pragma omp parallel for simd num_threads // expected-error {{expected '(' after 'num_threads'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argc > 0 ? argv[1] : argv[2]) // expected-error {{integral }} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for simd num_threads (num_threads(tmain<int, char, -1>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} expected-note {{in instantiation of function template specialization 'tmain<int, char, -1>' requested here}} + for (i = 0; i < argc; ++i) foo(); + + return tmain<int, char, 3>(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char, 3>' requested here}} +} diff --git a/test/OpenMP/parallel_for_simd_private_messages.cpp b/test/OpenMP/parallel_for_simd_private_messages.cpp new file mode 100644 index 000000000000..67d881318645 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_private_messages.cpp @@ -0,0 +1,173 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} +}; +const S3 ca[5]; +class S4 { + int a; + S4(); // expected-note {{implicitly declared private here}} + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5() : a(0) {} // expected-note {{implicitly declared private here}} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(I argc, C **argv) { + I e(4); + I g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(e, g) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp parallel for simd'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for simd private(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + S4 e(4); + S5 g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp parallel for simd'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int i; +#pragma omp parallel for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for simd private(i) + for (int k = 0; k < argc; ++k) + ++k; + + return 0; +} + diff --git a/test/OpenMP/parallel_for_simd_proc_bind_messages.cpp b/test/OpenMP/parallel_for_simd_proc_bind_messages.cpp new file mode 100644 index 000000000000..bc1e0d2b243b --- /dev/null +++ b/test/OpenMP/parallel_for_simd_proc_bind_messages.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo(); + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for simd proc_bind // expected-error {{expected '(' after 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd proc_bind( // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd proc_bind() // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd proc_bind(master // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd proc_bind(close), proc_bind(spread) // expected-error {{directive '#pragma omp parallel for simd' cannot contain more than one 'proc_bind' clause}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for simd proc_bind(x) // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel for simd proc_bind(master) + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel proc_bind(close) +#pragma omp parallel for simd proc_bind(spread) + for (i = 0; i < argc; ++i) + foo(); + return 0; +} diff --git a/test/OpenMP/parallel_for_simd_reduction_messages.cpp b/test/OpenMP/parallel_for_simd_reduction_messages.cpp new file mode 100644 index 000000000000..61690ddd42c1 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_reduction_messages.cpp @@ -0,0 +1,295 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel for simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(^ : T) // expected-error {{'T' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel for simd reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp parallel for simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp parallel for simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel for simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(~ : argc) // expected-error {{expected unqualified-id}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(max : argv[1]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for simd reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp parallel for simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp parallel for simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/parallel_for_simd_safelen_messages.cpp b/test/OpenMP/parallel_for_simd_safelen_messages.cpp new file mode 100644 index 000000000000..3fef81c74735 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_safelen_messages.cpp @@ -0,0 +1,79 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp parallel for simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp parallel for simd safelen (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp parallel for simd safelen (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen (1)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen ((ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'safelen' clause}} + // expected-error@+2 2 {{argument to 'safelen' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen (4) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd safelen (N) // expected-error {{argument to 'safelen' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel for simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'safelen' clause}} + // expected-error@+1 2 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp parallel for simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd safelen (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp parallel for simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp parallel for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp parallel for simd safelen(safelen(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 12, 4>' requested here}} + return tmain<int, char, 12, 4>(argc, argv); +} + diff --git a/test/OpenMP/parallel_for_simd_schedule_messages.cpp b/test/OpenMP/parallel_for_simd_schedule_messages.cpp new file mode 100644 index 000000000000..9e153d99a0a4 --- /dev/null +++ b/test/OpenMP/parallel_for_simd_schedule_messages.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp parallel for simd schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp parallel for simd schedule (guided argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for simd schedule (static, ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (dynamic, 1)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (guided, (ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+2 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for simd schedule (static, foobool(argc)), schedule (dynamic, true), schedule (guided, -5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (static, S) // expected-error {{'S' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel for simd schedule (guided, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (dynamic, 1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for simd schedule (static, N) // expected-error {{argument to 'schedule' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel for simd schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (guided, 4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (static, 2+2)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (dynamic, foobool(1) > 0 ? 1 : 2) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+2 2 {{directive '#pragma omp parallel for simd' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for simd schedule (guided, foobool(argc)), schedule (static, true), schedule (dynamic, -5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for simd schedule (guided, S1) // expected-error {{'S1' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp parallel for simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel for simd schedule (static, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp parallel for simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp parallel for simd schedule(dynamic, schedule(tmain<int, char, -1, -2>(argc, argv) // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/parallel_if_codegen.cpp b/test/OpenMP/parallel_if_codegen.cpp new file mode 100644 index 000000000000..44c874f1fb06 --- /dev/null +++ b/test/OpenMP/parallel_if_codegen.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple %itanium_abi_triple -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +void fn1(); +void fn2(); +void fn3(); +void fn4(); +void fn5(); +void fn6(); + +int Arg; + +// CHECK-LABEL: define void @{{.+}}gtid_test +void gtid_test() { +// CHECK: call void {{.+}}* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, {{.+}}* [[GTID_TEST_REGION1:@.+]] to void +#pragma omp parallel +#pragma omp parallel if (false) + gtid_test(); +// CHECK: ret void +} + +// CHECK: define internal void [[GTID_TEST_REGION1]](i{{.+}}* [[GTID_PARAM:%.+]], i +// CHECK: store i{{[0-9]+}}* [[GTID_PARAM]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]], +// CHECK: [[GTID_ADDR:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_REF]] +// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}* [[GTID_ADDR]] +// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) +// CHECK: [[GTID_ADDR:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_REF]] +// CHECK: call void [[GTID_TEST_REGION2:@.+]](i{{[0-9]+}}* [[GTID_ADDR]] +// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i{{.+}} [[GTID]]) +// CHECK: ret void + +// CHECK: define internal void [[GTID_TEST_REGION2]]( +// CHECK: call void @{{.+}}gtid_test +// CHECK: ret void + +template <typename T> +int tmain(T Arg) { +#pragma omp parallel if (true) + fn1(); +#pragma omp parallel if (false) + fn2(); +#pragma omp parallel if (Arg) + fn3(); + return 0; +} + +// CHECK-LABEL: define {{.*}}i{{[0-9]+}} @main() +int main() { +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( +// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN4:@.+]] to void +#pragma omp parallel if (true) + fn4(); +// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], +// CHECK: call void [[CAP_FN5:@.+]](i32* [[GTID_ADDR]], +// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +#pragma omp parallel if (false) + fn5(); + +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN6:@.+]] to void +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], +// CHECK: call void [[CAP_FN6]](i32* [[GTID_ADDR]], +// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] +#pragma omp parallel if (Arg) + fn6(); + // CHECK: = call {{.*}}i{{.+}} @{{.+}}tmain + return tmain(Arg); +} + +// CHECK: define internal void [[CAP_FN4]] +// CHECK: call void @{{.+}}fn4 +// CHECK: ret void + +// CHECK: define internal void [[CAP_FN5]] +// CHECK: call void @{{.+}}fn5 +// CHECK: ret void + +// CHECK: define internal void [[CAP_FN6]] +// CHECK: call void @{{.+}}fn6 +// CHECK: ret void + +// CHECK-LABEL: define {{.+}} @{{.+}}tmain +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num( +// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN1:@.+]] to void +// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], +// CHECK: call void [[CAP_FN2:@.+]](i32* [[GTID_ADDR]], +// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]] +// CHECK: [[OMP_THEN]] +// CHECK: call void {{.+}} @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{.+}} 1, void {{.+}}* [[CAP_FN3:@.+]] to void +// CHECK: br label %[[OMP_END:.+]] +// CHECK: [[OMP_ELSE]] +// CHECK: call void @__kmpc_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: store i32 [[GTID]], i32* [[GTID_ADDR:%.+]], +// CHECK: call void [[CAP_FN3]](i32* [[GTID_ADDR]], +// CHECK: call void @__kmpc_end_serialized_parallel(%{{.+}}* @{{.+}}, i32 [[GTID]]) +// CHECK: br label %[[OMP_END]] +// CHECK: [[OMP_END]] + +// CHECK: define internal void [[CAP_FN1]] +// CHECK: call void @{{.+}}fn1 +// CHECK: ret void + +// CHECK: define internal void [[CAP_FN2]] +// CHECK: call void @{{.+}}fn2 +// CHECK: ret void + +// CHECK: define internal void [[CAP_FN3]] +// CHECK: call void @{{.+}}fn3 +// CHECK: ret void + +#endif diff --git a/test/OpenMP/parallel_num_threads_codegen.cpp b/test/OpenMP/parallel_num_threads_codegen.cpp new file mode 100644 index 000000000000..c095e430b60b --- /dev/null +++ b/test/OpenMP/parallel_num_threads_codegen.cpp @@ -0,0 +1,84 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple %itanium_abi_triple -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple %itanium_abi_triple -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +typedef __INTPTR_TYPE__ intptr_t; + +// CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-DAG: [[S_TY:%.+]] = type { [[INTPTR_T_TY:i[0-9]+]], [[INTPTR_T_TY]], [[INTPTR_T_TY]] } +// CHECK-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00" +// CHECK-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant [[IDENT_T_TY]] { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8]* [[STR]], i32 0, i32 0) } + +void foo(); + +struct S { + intptr_t a, b, c; + S(intptr_t a) : a(a) {} + operator char() { return a; } + ~S() {} +}; + +template <typename T, int C> +int tmain() { +#pragma omp parallel num_threads(C) + foo(); +#pragma omp parallel num_threads(T(23)) + foo(); + return 0; +} + +int main() { + S s(0); + char a = s; +#pragma omp parallel num_threads(2) + foo(); +#pragma omp parallel num_threads(a) + foo(); + return a + tmain<char, 5>() + tmain<S, 1>(); +} + +// CHECK-LABEL: define {{.*}}i{{[0-9]+}} @main() +// CHECK-DAG: [[S_ADDR:%.+]] = alloca [[S_TY]] +// CHECK-DAG: [[A_ADDR:%.+]] = alloca i8 +// CHECK-DAG: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK-DAG: call {{.*}} [[S_TY_CONSTR:@.+]]([[S_TY]]* [[S_ADDR]], [[INTPTR_T_TY]] [[INTPTR_T_TY_ATTR:(signext )?]]0) +// CHECK: [[S_CHAR_OP:%.+]] = invoke{{.*}} i8 [[S_TY_CHAR_OP:@.+]]([[S_TY]]* [[S_ADDR]]) +// CHECK: store i8 [[S_CHAR_OP]], i8* [[A_ADDR]] +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 2) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: [[A_VAL:%.+]] = load i8* [[A_ADDR]] +// CHECK: [[RES:%.+]] = sext i8 [[A_VAL]] to i32 +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: invoke{{.*}} [[INT_TY:i[0-9]+]] [[TMAIN_CHAR_5:@.+]]() +// CHECK: invoke{{.*}} [[INT_TY]] [[TMAIN_S_1:@.+]]() +// CHECK: call {{.*}} [[S_TY_DESTR:@.+]]([[S_TY]]* [[S_ADDR]]) +// CHECK: ret [[INT_TY]] +// CHECK: } + +// CHECK: define{{.*}} [[INT_TY]] [[TMAIN_CHAR_5]]() +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 5) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 23) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: ret [[INT_TY]] 0 +// CHECK-NEXT: } + +// CHECK: define{{.*}} [[INT_TY]] [[TMAIN_S_1]]() +// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEF_LOC_2]]) +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 1) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: call {{.*}} [[S_TY_CONSTR]]([[S_TY]]* [[S_TEMP:%.+]], [[INTPTR_T_TY]] [[INTPTR_T_TY_ATTR]]23) +// CHECK: [[S_CHAR_OP:%.+]] = invoke{{.*}} i8 [[S_TY_CHAR_OP]]([[S_TY]]* [[S_TEMP]]) +// CHECK: [[RES:%.+]] = sext {{.*}}i8 [[S_CHAR_OP]] to i32 +// CHECK: call void @__kmpc_push_num_threads([[IDENT_T_TY]]* [[DEF_LOC_2]], i32 [[GTID]], i32 [[RES]]) +// CHECK: call {{.*}} [[S_TY_DESTR]]([[S_TY]]* [[S_TEMP]]) +// CHECK: call void {{.*}}* @__kmpc_fork_call( +// CHECK: ret [[INT_TY]] 0 +// CHECK: } + +#endif diff --git a/test/OpenMP/parallel_private_codegen.cpp b/test/OpenMP/parallel_private_codegen.cpp new file mode 100644 index 000000000000..6911068250f5 --- /dev/null +++ b/test/OpenMP/parallel_private_codegen.cpp @@ -0,0 +1,181 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -std=c++11 -DLAMBDA -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck -check-prefix=LAMBDA %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -fblocks -DBLOCKS -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck -check-prefix=BLOCKS %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +template <class T> +struct S { + T f; + S(T a) : f(a) {} + S() : f() {} + operator T() { return T(); } + ~S() {} +}; + +volatile int g = 1212; + +// CHECK: [[S_FLOAT_TY:%.+]] = type { float } +// CHECK: [[CAP_MAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]* } +// CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} } +// CHECK: [[CAP_TMAIN_TY:%.+]] = type { [2 x i{{[0-9]+}}]*, i{{[0-9]+}}*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]* } +// CHECK: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8* +template <typename T> +T tmain() { + S<T> test; + T t_var = T(); + T vec[] = {1, 2}; + S<T> s_arr[] = {1, 2}; + S<T> var(3); +#pragma omp parallel private(t_var, vec, s_arr, var) + { + vec[0] = t_var; + s_arr[0] = var; + } + return T(); +} + +int main() { +#ifdef LAMBDA + // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, + // LAMBDA-LABEL: @main + // LAMBDA: call void [[OUTER_LAMBDA:@.+]]( + [&]() { + // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( + // LAMBDA: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] + // LAMBDA: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* + // LAMBDA: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) +#pragma omp parallel private(g) + { + // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) + // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, + // LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], + // LAMBDA: call i32 @__kmpc_cancel_barrier( + g = 1; + // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], + // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]] + // LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) + [&]() { + // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) + // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], + g = 2; + // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}** [[ARG_PTR_REF]] + // LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}** [[G_PTR_REF]] + // LAMBDA: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* [[G_REF]] + }(); + } + }(); + return 0; +#elif defined(BLOCKS) + // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, + // BLOCKS-LABEL: @main + // BLOCKS: call void {{%.+}}(i8* + ^{ + // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* + // BLOCKS: [[G_LOCAL_REF:%.+]] = getelementptr inbounds %{{.+}}* [[AGG_CAPTURED:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 + // BLOCKS: store i{{[0-9]+}}* [[G]], i{{[0-9]+}}** [[G_LOCAL_REF]] + // BLOCKS: [[ARG:%.+]] = bitcast %{{.+}}* [[AGG_CAPTURED]] to i8* + // BLOCKS: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* [[ARG]]) +#pragma omp parallel private(g) + { + // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]]) + // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, + // BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]], + // BLOCKS: call i32 @__kmpc_cancel_barrier( + g = 1; + // BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]] + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: call void {{%.+}}(i8* + ^{ + // BLOCKS: define {{.+}} void {{@.+}}(i8* + g = 2; + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* + // BLOCKS-NOT: [[G]]{{[[^:word:]]}} + // BLOCKS: ret + }(); + } + }(); + return 0; +#else + S<float> test; + int t_var = 0; + int vec[] = {1, 2}; + S<float> s_arr[] = {1, 2}; + S<float> var(3); +#pragma omp parallel private(t_var, vec, s_arr, var) + { + vec[0] = t_var; + s_arr[0] = var; + } + return tmain<int>(); +#endif +} + +// CHECK: define i{{[0-9]+}} @main() +// CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]], +// CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]]) +// CHECK: %{{.+}} = bitcast [[CAP_MAIN_TY]]* +// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_MAIN_TY]]*)* [[MAIN_MICROTASK:@.+]] to void +// CHECK: = call i{{.+}} [[TMAIN_INT:@.+]]() +// CHECK: call void [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]* +// CHECK: ret +// +// CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_MAIN_TY]]* %{{.+}}) +// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, +// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], +// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]], +// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]], +// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]] +// CHECK-NOT: [[T_VAR_PRIV]] +// CHECK-NOT: [[VEC_PRIV]] +// CHECK: {{.+}}: +// CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_FLOAT_TY]]* +// CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[S_ARR_PRIV_ITEM]]) +// CHECK-NOT: [[T_VAR_PRIV]] +// CHECK-NOT: [[VEC_PRIV]] +// CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) +// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_REF]] +// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}* [[GTID_REF]] +// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) +// CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* +// CHECK: ret void + +// CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]() +// CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]], +// CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]]) +// CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[CAP_TMAIN_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void +// CHECK: call void [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]* +// CHECK: ret +// +// CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_TMAIN_TY]]* %{{.+}}) +// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, +// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], +// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]], +// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]], +// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]] +// CHECK-NOT: [[T_VAR_PRIV]] +// CHECK-NOT: [[VEC_PRIV]] +// CHECK: {{.+}}: +// CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_INT_TY]]* +// CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[S_ARR_PRIV_ITEM]]) +// CHECK-NOT: [[T_VAR_PRIV]] +// CHECK-NOT: [[VEC_PRIV]] +// CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[VAR_PRIV]]) +// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}** [[GTID_ADDR_REF]] +// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}* [[GTID_REF]] +// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) +// CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]]) +// CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* +// CHECK: ret void +#endif + diff --git a/test/OpenMP/parallel_private_messages.cpp b/test/OpenMP/parallel_private_messages.cpp index 1cd86d2b5fbc..14c5cbdb8aea 100644 --- a/test/OpenMP/parallel_private_messages.cpp +++ b/test/OpenMP/parallel_private_messages.cpp @@ -25,15 +25,15 @@ public: const S3 c; // expected-note {{global variable is predetermined as shared}} const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} extern const int f; // expected-note {{global variable is predetermined as shared}} -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v):a(v) { } }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5():a(0) {} + S5():a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v):a(v) { } }; @@ -44,8 +44,8 @@ int threadvar; int main(int argc, char **argv) { const int d = 5; // expected-note {{constant variable is predetermined as shared}} const int da[5] = { 0 }; // expected-note {{constant variable is predetermined as shared}} - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g[] = {5, 6}; int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel private // expected-error {{expected '(' after 'private'}} @@ -62,7 +62,7 @@ int main(int argc, char **argv) { #pragma omp parallel private(ca) // expected-error {{shared variable cannot be private}} #pragma omp parallel private(da) // expected-error {{shared variable cannot be private}} #pragma omp parallel private(S2::S2s) // expected-error {{shared variable cannot be private}} - #pragma omp parallel private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + #pragma omp parallel private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} #pragma omp parallel private(threadvar) // expected-error {{threadprivate or thread local variable cannot be private}} #pragma omp parallel shared(i), private(i) // expected-error {{shared variable cannot be private}} expected-note {{defined as shared}} foo(); diff --git a/test/OpenMP/parallel_sections_firstprivate_messages.cpp b/test/OpenMP/parallel_sections_firstprivate_messages.cpp index ffd2b0cfd5e5..2d27b1a600da 100644 --- a/test/OpenMP/parallel_sections_firstprivate_messages.cpp +++ b/test/OpenMP/parallel_sections_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -27,22 +27,22 @@ class S3 { public: S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3(const S3 &s3) : a(s3.a) {} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note 2 {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note 4 {{'S5' declared here}} +class S5 { int a; - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} public: S5() : a(0) {} @@ -62,8 +62,8 @@ S3 h; template <class I, class C> int foomain(int argc, char **argv) { - I e(4); // expected-note {{'e' defined here}} - C g(5); // expected-note 2 {{'g' defined here}} + I e(4); + C g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel sections firstprivate // expected-error {{expected '(' after 'firstprivate'}} @@ -106,7 +106,7 @@ int foomain(int argc, char **argv) { { foo(); } -#pragma omp parallel sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel sections firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -138,7 +138,7 @@ int foomain(int argc, char **argv) { { foo(); } -#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -158,8 +158,8 @@ int foomain(int argc, char **argv) { int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note 2 {{'g' defined here}} + S4 e(4); + S5 g(5); S3 m; S6 n(2); int i; @@ -237,7 +237,7 @@ int main(int argc, char **argv) { { foo(); } -#pragma omp parallel sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel sections firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -262,7 +262,7 @@ int main(int argc, char **argv) { { foo(); } -#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} { foo(); } diff --git a/test/OpenMP/parallel_sections_private_messages.cpp b/test/OpenMP/parallel_sections_private_messages.cpp index 7d39c7e2c5bb..e0b7488e5162 100644 --- a/test/OpenMP/parallel_sections_private_messages.cpp +++ b/test/OpenMP/parallel_sections_private_messages.cpp @@ -24,16 +24,16 @@ public: S3() : a(0) {} }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -124,8 +124,8 @@ int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel sections private // expected-error {{expected '(' after 'private'}} @@ -168,7 +168,7 @@ int main(int argc, char **argv) { { foo(); } -#pragma omp parallel sections private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp parallel sections private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } diff --git a/test/OpenMP/sections_firstprivate_messages.cpp b/test/OpenMP/sections_firstprivate_messages.cpp index b030ce549d33..ecee45900fea 100644 --- a/test/OpenMP/sections_firstprivate_messages.cpp +++ b/test/OpenMP/sections_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -27,22 +27,22 @@ class S3 { public: S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3(const S3 &s3) : a(s3.a) {} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note 2 {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note 4 {{'S5' declared here}} +class S5 { int a; - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} public: S5() : a(0) {} @@ -62,8 +62,8 @@ S3 h; template <class I, class C> int foomain(int argc, char **argv) { - I e(4); // expected-note {{'e' defined here}} - C g(5); // expected-note 2 {{'g' defined here}} + I e(4); + C g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel @@ -117,7 +117,7 @@ int foomain(int argc, char **argv) { foo(); } #pragma omp parallel -#pragma omp sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp sections firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -153,7 +153,7 @@ int foomain(int argc, char **argv) { foo(); } #pragma omp parallel -#pragma omp sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp sections lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -173,8 +173,8 @@ int foomain(int argc, char **argv) { int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note 2 {{'g' defined here}} + S4 e(4); + S5 g(5); S3 m; S6 n(2); int i; @@ -271,7 +271,7 @@ int main(int argc, char **argv) { foo(); } #pragma omp parallel -#pragma omp sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp sections firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } @@ -301,7 +301,7 @@ int main(int argc, char **argv) { foo(); } #pragma omp parallel -#pragma omp sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp sections lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} { foo(); } diff --git a/test/OpenMP/sections_private_messages.cpp b/test/OpenMP/sections_private_messages.cpp index 7f5aa849682a..8b330bf71052 100644 --- a/test/OpenMP/sections_private_messages.cpp +++ b/test/OpenMP/sections_private_messages.cpp @@ -24,16 +24,16 @@ public: S3() : a(0) {} }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -124,8 +124,8 @@ int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp sections private // expected-error {{expected '(' after 'private'}} @@ -168,7 +168,7 @@ int main(int argc, char **argv) { { foo(); } -#pragma omp sections private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp sections private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} { foo(); } diff --git a/test/OpenMP/simd_aligned_messages.cpp b/test/OpenMP/simd_aligned_messages.cpp index 84cf40c1731b..dfa6b541c909 100644 --- a/test/OpenMP/simd_aligned_messages.cpp +++ b/test/OpenMP/simd_aligned_messages.cpp @@ -39,6 +39,7 @@ void test_aligned_colons(int *&rp) // expected-error@+1 {{expected variable name}} #pragma omp simd aligned(B::bfoo()) for (int i = 0; i < 10; ++i) ; + // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}} #pragma omp simd aligned(B::ib,B:C1+C2) for (int i = 0; i < 10; ++i) ; } @@ -122,7 +123,7 @@ template<class I, class C> int foomain(I argc, C **argv) { for (I k = 0; k < argc; ++k) ++k; #pragma omp simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} for (I k = 0; k < argc; ++k) ++k; - #pragma omp simd aligned (argc : 5) + #pragma omp simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}} for (I k = 0; k < argc; ++k) ++k; #pragma omp simd aligned (S1) // expected-error {{'S1' does not refer to a value}} for (I k = 0; k < argc; ++k) ++k; diff --git a/test/OpenMP/simd_codegen.cpp b/test/OpenMP/simd_codegen.cpp new file mode 100644 index 000000000000..b8073c2948e0 --- /dev/null +++ b/test/OpenMP/simd_codegen.cpp @@ -0,0 +1,407 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s +// +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +// CHECK-LABEL: define {{.*void}} @{{.*}}simple{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}}) +void simple(float *a, float *b, float *c, float *d) { + #pragma omp simd +// CHECK: store i32 0, i32* [[OMP_IV:%[^,]+]] + +// CHECK: [[IV:%.+]] = load i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID:[0-9]+]] +// CHECK-NEXT: [[CMP:%.+]] = icmp slt i32 [[IV]], 6 +// CHECK-NEXT: br i1 [[CMP]], label %[[SIMPLE_LOOP1_BODY:.+]], label %[[SIMPLE_LOOP1_END:[^,]+]] + for (int i = 3; i < 32; i += 5) { +// CHECK: [[SIMPLE_LOOP1_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV1_1:%.+]] = load i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 5 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 3, [[CALC_I_1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] + a[i] = b[i] * c[i] * d[i]; +// CHECK: [[IV1_2:%.+]] = load i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1 +// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP1_ID]] +// br label %{{.+}}, !llvm.loop !{{.+}} + } +// CHECK: [[SIMPLE_LOOP1_END]] + + #pragma omp simd +// CHECK: store i32 0, i32* [[OMP_IV2:%[^,]+]] + +// CHECK: [[IV2:%.+]] = load i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID:[0-9]+]] +// CHECK-NEXT: [[CMP2:%.+]] = icmp slt i32 [[IV2]], 9 +// CHECK-NEXT: br i1 [[CMP2]], label %[[SIMPLE_LOOP2_BODY:.+]], label %[[SIMPLE_LOOP2_END:[^,]+]] + for (int i = 10; i > 1; i--) { +// CHECK: [[SIMPLE_LOOP2_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV2_0:%.+]] = load i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// FIXME: It is interesting, why the following "mul 1" was not constant folded? +// CHECK-NEXT: [[IV2_1:%.+]] = mul nsw i32 [[IV2_0]], 1 +// CHECK-NEXT: [[LC_I_1:%.+]] = sub nsw i32 10, [[IV2_1]] +// CHECK-NEXT: store i32 [[LC_I_1]], i32* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] + a[i]++; +// CHECK: [[IV2_2:%.+]] = load i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// CHECK-NEXT: [[ADD2_2:%.+]] = add nsw i32 [[IV2_2]], 1 +// CHECK-NEXT: store i32 [[ADD2_2]], i32* [[OMP_IV2]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP2_ID]] +// br label {{.+}}, !llvm.loop ![[SIMPLE_LOOP2_ID]] + } +// CHECK: [[SIMPLE_LOOP2_END]] + + #pragma omp simd +// CHECK: store i64 0, i64* [[OMP_IV3:%[^,]+]] + +// CHECK: [[IV3:%.+]] = load i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID:[0-9]+]] +// CHECK-NEXT: [[CMP3:%.+]] = icmp ult i64 [[IV3]], 4 +// CHECK-NEXT: br i1 [[CMP3]], label %[[SIMPLE_LOOP3_BODY:.+]], label %[[SIMPLE_LOOP3_END:[^,]+]] + for (unsigned long long it = 2000; it >= 600; it-=400) { +// CHECK: [[SIMPLE_LOOP3_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV3_0:%.+]] = load i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul i64 [[IV3_0]], 400 +// CHECK-NEXT: [[LC_IT_2:%.+]] = sub i64 2000, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + a[it]++; +// CHECK: [[IV3_2:%.+]] = load i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] +// CHECK-NEXT: [[ADD3_2:%.+]] = add i64 [[IV3_2]], 1 +// CHECK-NEXT: store i64 [[ADD3_2]], i64* [[OMP_IV3]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP3_ID]] + } +// CHECK: [[SIMPLE_LOOP3_END]] + + #pragma omp simd +// CHECK: store i32 0, i32* [[OMP_IV4:%[^,]+]] + +// CHECK: [[IV4:%.+]] = load i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID:[0-9]+]] +// CHECK-NEXT: [[CMP4:%.+]] = icmp slt i32 [[IV4]], 4 +// CHECK-NEXT: br i1 [[CMP4]], label %[[SIMPLE_LOOP4_BODY:.+]], label %[[SIMPLE_LOOP4_END:[^,]+]] + for (short it = 6; it <= 20; it-=-4) { +// CHECK: [[SIMPLE_LOOP4_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV4_0:%.+]] = load i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i32 [[IV4_0]], 4 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i32 6, [[LC_IT_1]] +// CHECK-NEXT: [[LC_IT_3:%.+]] = trunc i32 [[LC_IT_2]] to i16 +// CHECK-NEXT: store i16 [[LC_IT_3]], i16* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + +// CHECK: [[IV4_2:%.+]] = load i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] +// CHECK-NEXT: [[ADD4_2:%.+]] = add nsw i32 [[IV4_2]], 1 +// CHECK-NEXT: store i32 [[ADD4_2]], i32* [[OMP_IV4]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP4_ID]] + } +// CHECK: [[SIMPLE_LOOP4_END]] + + #pragma omp simd +// CHECK: store i32 0, i32* [[OMP_IV5:%[^,]+]] + +// CHECK: [[IV5:%.+]] = load i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID:[0-9]+]] +// CHECK-NEXT: [[CMP5:%.+]] = icmp slt i32 [[IV5]], 26 +// CHECK-NEXT: br i1 [[CMP5]], label %[[SIMPLE_LOOP5_BODY:.+]], label %[[SIMPLE_LOOP5_END:[^,]+]] + for (unsigned char it = 'z'; it >= 'a'; it+=-1) { +// CHECK: [[SIMPLE_LOOP5_BODY]] +// Start of body: calculate it from IV: +// CHECK: [[IV5_0:%.+]] = load i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[IV5_1:%.+]] = mul nsw i32 [[IV5_0]], 1 +// CHECK-NEXT: [[LC_IT_1:%.+]] = sub nsw i32 122, [[IV5_1]] +// CHECK-NEXT: [[LC_IT_2:%.+]] = trunc i32 [[LC_IT_1]] to i8 +// CHECK-NEXT: store i8 [[LC_IT_2]], i8* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + +// CHECK: [[IV5_2:%.+]] = load i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] +// CHECK-NEXT: [[ADD5_2:%.+]] = add nsw i32 [[IV5_2]], 1 +// CHECK-NEXT: store i32 [[ADD5_2]], i32* [[OMP_IV5]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP5_ID]] + } +// CHECK: [[SIMPLE_LOOP5_END]] + + #pragma omp simd +// FIXME: I think we would get wrong result using 'unsigned' in the loop below. +// So we'll need to add zero trip test for 'unsigned' counters. +// +// CHECK: store i32 0, i32* [[OMP_IV6:%[^,]+]] + +// CHECK: [[IV6:%.+]] = load i32* [[OMP_IV6]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP6_ID:[0-9]+]] +// CHECK-NEXT: [[CMP6:%.+]] = icmp slt i32 [[IV6]], -8 +// CHECK-NEXT: br i1 [[CMP6]], label %[[SIMPLE_LOOP6_BODY:.+]], label %[[SIMPLE_LOOP6_END:[^,]+]] + for (int i=100; i<10; i+=10) { +// CHECK: [[SIMPLE_LOOP6_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV6_0:%.+]] = load i32* [[OMP_IV6]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP6_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i32 [[IV6_0]], 10 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i32 100, [[LC_IT_1]] +// CHECK-NEXT: store i32 [[LC_IT_2]], i32* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP6_ID]] + +// CHECK: [[IV6_2:%.+]] = load i32* [[OMP_IV6]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP6_ID]] +// CHECK-NEXT: [[ADD6_2:%.+]] = add nsw i32 [[IV6_2]], 1 +// CHECK-NEXT: store i32 [[ADD6_2]], i32* [[OMP_IV6]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP6_ID]] + } +// CHECK: [[SIMPLE_LOOP6_END]] + + int A; + #pragma omp simd lastprivate(A) +// Clause 'lastprivate' implementation is not completed yet. +// Test checks that one iteration is separated in presence of lastprivate. +// +// CHECK: store i64 0, i64* [[OMP_IV7:%[^,]+]] +// CHECK: br i1 true, label %[[SIMPLE_IF7_THEN:.+]], label %[[SIMPLE_IF7_END:[^,]+]] +// CHECK: [[SIMPLE_IF7_THEN]] +// CHECK: br label %[[SIMD_LOOP7_COND:[^,]+]] +// CHECK: [[SIMD_LOOP7_COND]] +// CHECK-NEXT: [[IV7:%.+]] = load i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID:[0-9]+]] +// CHECK-NEXT: [[CMP7:%.+]] = icmp slt i64 [[IV7]], 6 +// CHECK-NEXT: br i1 [[CMP7]], label %[[SIMPLE_LOOP7_BODY:.+]], label %[[SIMPLE_LOOP7_END:[^,]+]] + for (long long i = -10; i < 10; i += 3) { +// CHECK: [[SIMPLE_LOOP7_BODY]] +// Start of body: calculate i from IV: +// CHECK: [[IV7_0:%.+]] = load i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[LC_IT_1:%.+]] = mul nsw i64 [[IV7_0]], 3 +// CHECK-NEXT: [[LC_IT_2:%.+]] = add nsw i64 -10, [[LC_IT_1]] +// CHECK-NEXT: store i64 [[LC_IT_2]], i64* {{.+}}, !llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + A = i; +// CHECK: [[IV7_2:%.+]] = load i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] +// CHECK-NEXT: [[ADD7_2:%.+]] = add nsw i64 [[IV7_2]], 1 +// CHECK-NEXT: store i64 [[ADD7_2]], i64* [[OMP_IV7]]{{.*}}!llvm.mem.parallel_loop_access ![[SIMPLE_LOOP7_ID]] + } +// CHECK: [[SIMPLE_LOOP7_END]] +// Separated last iteration. +// CHECK: [[IV7_4:%.+]] = load i64* [[OMP_IV7]] +// CHECK-NEXT: [[LC_FIN_1:%.+]] = mul nsw i64 [[IV7_4]], 3 +// CHECK-NEXT: [[LC_FIN_2:%.+]] = add nsw i64 -10, [[LC_FIN_1]] +// CHECK-NEXT: store i64 [[LC_FIN_2]], i64* [[ADDR_I:%[^,]+]] +// CHECK: [[LOAD_I:%.+]] = load i64* [[ADDR_I]] +// CHECK-NEXT: [[CONV_I:%.+]] = trunc i64 [[LOAD_I]] to i32 +// +// CHECK: br label %[[SIMPLE_IF7_END]] +// CHECK: [[SIMPLE_IF7_END]] +// + +// CHECK: ret void +} + +template <class T, unsigned K> T tfoo(T a) { return a + K; } + +template <typename T, unsigned N> +int templ1(T a, T *z) { + #pragma omp simd collapse(N) + for (int i = 0; i < N * 2; i++) { + for (long long j = 0; j < (N + N + N + N); j += 2) { + z[i + j] = a + tfoo<T, N>(i + j); + } + } + return 0; +} + +// Instatiation templ1<float,2> +// CHECK-LABEL: define {{.*i32}} @{{.*}}templ1{{.*}}(float {{.+}}, float* {{.+}}) +// CHECK: store i64 0, i64* [[T1_OMP_IV:[^,]+]] +// ... +// CHECK: [[IV:%.+]] = load i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID:[0-9]+]] +// CHECK-NEXT: [[CMP1:%.+]] = icmp slt i64 [[IV]], 16 +// CHECK-NEXT: br i1 [[CMP1]], label %[[T1_BODY:.+]], label %[[T1_END:[^,]+]] +// CHECK: [[T1_BODY]] +// Loop counters i and j updates: +// CHECK: [[IV1:%.+]] = load i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[I_1:%.+]] = sdiv i64 [[IV1]], 4 +// CHECK-NEXT: [[I_1_MUL1:%.+]] = mul nsw i64 [[I_1]], 1 +// CHECK-NEXT: [[I_1_ADD0:%.+]] = add nsw i64 0, [[I_1_MUL1]] +// CHECK-NEXT: [[I_2:%.+]] = trunc i64 [[I_1_ADD0]] to i32 +// CHECK-NEXT: store i32 [[I_2]], i32* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK: [[IV2:%.+]] = load i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[J_1:%.+]] = srem i64 [[IV2]], 4 +// CHECK-NEXT: [[J_2:%.+]] = mul nsw i64 [[J_1]], 2 +// CHECK-NEXT: [[J_2_ADD0:%.+]] = add nsw i64 0, [[J_2]] +// CHECK-NEXT: store i64 [[J_2_ADD0]], i64* {{%.+}}{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// simd.for.inc: +// CHECK: [[IV3:%.+]] = load i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: [[INC:%.+]] = add nsw i64 [[IV3]], 1 +// CHECK-NEXT: store i64 [[INC]], i64* [[T1_OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[T1_ID]] +// CHECK-NEXT: br label {{%.+}} +// CHECK: [[T1_END]] +// CHECK: ret i32 0 +// +void inst_templ1() { + float a; + float z[100]; + templ1<float,2> (a, z); +} + + +typedef int MyIdx; + +class IterDouble { + double *Ptr; +public: + IterDouble operator++ () const { + IterDouble n; + n.Ptr = Ptr + 1; + return n; + } + bool operator < (const IterDouble &that) const { + return Ptr < that.Ptr; + } + double & operator *() const { + return *Ptr; + } + MyIdx operator - (const IterDouble &that) const { + return (MyIdx) (Ptr - that.Ptr); + } + IterDouble operator + (int Delta) { + IterDouble re; + re.Ptr = Ptr + Delta; + return re; + } + + ///~IterDouble() {} +}; + +// CHECK-LABEL: define {{.*void}} @{{.*}}iter_simple{{.*}} +void iter_simple(IterDouble ia, IterDouble ib, IterDouble ic) { +// +// CHECK: store i32 0, i32* [[IT_OMP_IV:%[^,]+]] +// Calculate number of iterations before the loop body. +// CHECK: [[DIFF1:%.+]] = call {{.*}}i32 @{{.*}}IterDouble{{.*}} +// CHECK-NEXT: [[DIFF2:%.+]] = sub nsw i32 [[DIFF1]], 1 +// CHECK-NEXT: [[DIFF3:%.+]] = add nsw i32 [[DIFF2]], 1 +// CHECK-NEXT: [[DIFF4:%.+]] = sdiv i32 [[DIFF3]], 1 +// CHECK-NEXT: [[DIFF5:%.+]] = sub nsw i32 [[DIFF4]], 1 +// CHECK-NEXT: store i32 [[DIFF5]], i32* [[OMP_LAST_IT:%[^,]+]]{{.+}} + #pragma omp simd + +// CHECK: [[IV:%.+]] = load i32* [[IT_OMP_IV]]{{.+}} !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID:[0-9]+]] +// CHECK-NEXT: [[LAST_IT:%.+]] = load i32* [[OMP_LAST_IT]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[NUM_IT:%.+]] = add nsw i32 [[LAST_IT]], 1 +// CHECK-NEXT: [[CMP:%.+]] = icmp slt i32 [[IV]], [[NUM_IT]] +// CHECK-NEXT: br i1 [[CMP]], label %[[IT_BODY:[^,]+]], label %[[IT_END:[^,]+]] + for (IterDouble i = ia; i < ib; ++i) { +// CHECK: [[IT_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// Call of operator+ (i, IV). +// CHECK: {{%.+}} = call {{.+}} @{{.*}}IterDouble{{.*}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// ... loop body ... + *i = *ic * 0.5; +// Float multiply and save result. +// CHECK: [[MULR:%.+]] = fmul double {{%.+}}, 5.000000e-01 +// CHECK-NEXT: call {{.+}} @{{.*}}IterDouble{{.*}} +// CHECK: store double [[MULR:%.+]], double* [[RESULT_ADDR:%.+]], !llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] + ++ic; +// +// CHECK: [[IV2:%.+]] = load i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[IT_OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[ITER_LOOP_ID]] +// br label %{{.*}}, !llvm.loop ![[ITER_LOOP_ID]] + } +// CHECK: [[IT_END]] +// CHECK: ret void +} + + +// CHECK-LABEL: define {{.*void}} @{{.*}}collapsed{{.*}} +void collapsed(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + unsigned j; // middle loop couter, leads to unsigned icmp in loop header. + // k declared in the loop init below + short l; // inner loop counter +// CHECK: store i32 0, i32* [[OMP_IV:[^,]+]] +// + #pragma omp simd collapse(4) + +// CHECK: [[IV:%.+]] = load i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID:[0-9]+]] +// CHECK-NEXT: [[CMP:%.+]] = icmp ult i32 [[IV]], 120 +// CHECK-NEXT: br i1 [[CMP]], label %[[COLL1_BODY:[^,]+]], label %[[COLL1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 2u; j < 5u; j++) //3 iterations + for (int k = 3; k <= 6; k++) // 4 iterations + for (l = 4; l < 9; ++l) // 5 iterations + { +// CHECK: [[COLL1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// Calculation of the loop counters values. +// CHECK: [[CALC_I_1:%.+]] = udiv i32 [[IV1]], 60 +// CHECK-NEXT: [[CALC_I_1_MUL1:%.+]] = mul i32 [[CALC_I_1]], 1 +// CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 1, [[CALC_I_1_MUL1]] +// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_J_1:%.+]] = udiv i32 [[IV1_2]], 20 +// CHECK-NEXT: [[CALC_J_2:%.+]] = urem i32 [[CALC_J_1]], 3 +// CHECK-NEXT: [[CALC_J_2_MUL1:%.+]] = mul i32 [[CALC_J_2]], 1 +// CHECK-NEXT: [[CALC_J_3:%.+]] = add i32 2, [[CALC_J_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_J_3]], i32* [[LC_J:.+]] +// CHECK: [[IV1_3:%.+]] = load i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_K_1:%.+]] = udiv i32 [[IV1_3]], 5 +// CHECK-NEXT: [[CALC_K_2:%.+]] = urem i32 [[CALC_K_1]], 4 +// CHECK-NEXT: [[CALC_K_2_MUL1:%.+]] = mul i32 [[CALC_K_2]], 1 +// CHECK-NEXT: [[CALC_K_3:%.+]] = add i32 3, [[CALC_K_2_MUL1]] +// CHECK-NEXT: store i32 [[CALC_K_3]], i32* [[LC_K:.+]] +// CHECK: [[IV1_4:%.+]] = load i32* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[CALC_L_1:%.+]] = urem i32 [[IV1_4]], 5 +// CHECK-NEXT: [[CALC_L_1_MUL1:%.+]] = mul i32 [[CALC_L_1]], 1 +// CHECK-NEXT: [[CALC_L_2:%.+]] = add i32 4, [[CALC_L_1_MUL1]] +// CHECK-NEXT: [[CALC_L_3:%.+]] = trunc i32 [[CALC_L_2]] to i16 +// CHECK-NEXT: store i16 [[CALC_L_3]], i16* [[LC_L:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] + float res = b[j] * c[k]; + a[i] = res * d[l]; +// CHECK: [[IV2:%.+]] = load i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add i32 [[IV2]], 1 +// CHECK-NEXT: store i32 [[ADD2]], i32* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[COLL1_LOOP_ID]] +// br label %{{[^,]+}}, !llvm.loop ![[COLL1_LOOP_ID]] +// CHECK: [[COLL1_END]] + } +// i,j,l are updated; k is not updated. +// CHECK: store i32 3, i32* [[I:%[^,]+]] +// CHECK-NEXT: store i32 5, i32* [[I:%[^,]+]] +// CHECK-NEXT: store i16 9, i16* [[I:%[^,]+]] +// CHECK: ret void +} + +extern char foo(); + +// CHECK-LABEL: define {{.*void}} @{{.*}}widened{{.*}} +void widened(float *a, float *b, float *c, float *d) { + int i; // outer loop counter + short j; // inner loop counter +// Counter is widened to 64 bits. +// CHECK: store i64 0, i64* [[OMP_IV:[^,]+]] +// + #pragma omp simd collapse(2) + +// CHECK: [[IV:%.+]] = load i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID:[0-9]+]] +// CHECK-NEXT: [[LI:%.+]] = load i64* [[OMP_LI:%[^,]+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[NUMIT:%.+]] = add nsw i64 [[LI]], 1 +// CHECK-NEXT: [[CMP:%.+]] = icmp slt i64 [[IV]], [[NUMIT]] +// CHECK-NEXT: br i1 [[CMP]], label %[[WIDE1_BODY:[^,]+]], label %[[WIDE1_END:[^,]+]] + for (i = 1; i < 3; i++) // 2 iterations + for (j = 0; j < foo(); j++) // foo() iterations + { +// CHECK: [[WIDE1_BODY]] +// Start of body: calculate i from index: +// CHECK: [[IV1:%.+]] = load i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// Calculation of the loop counters values... +// CHECK: store i32 {{[^,]+}}, i32* [[LC_I:.+]] +// CHECK: [[IV1_2:%.+]] = load i64* [[OMP_IV]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK: store i16 {{[^,]+}}, i16* [[LC_J:.+]] +// ... loop body ... +// End of body: store into a[i]: +// CHECK: store float [[RESULT:%.+]], float* [[RESULT_ADDR:%.+]]{{.+}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] + float res = b[j] * c[j]; + a[i] = res * d[i]; +// CHECK: [[IV2:%.+]] = load i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// CHECK-NEXT: [[ADD2:%.+]] = add nsw i64 [[IV2]], 1 +// CHECK-NEXT: store i64 [[ADD2]], i64* [[OMP_IV]]{{.*}}!llvm.mem.parallel_loop_access ![[WIDE1_LOOP_ID]] +// br label %{{[^,]+}}, !llvm.loop ![[WIDE1_LOOP_ID]] +// CHECK: [[WIDE1_END]] + } +// i,j are updated. +// CHECK: store i32 3, i32* [[I:%[^,]+]] +// CHECK: store i16 +// CHECK: ret void +} + +#endif // HEADER + diff --git a/test/OpenMP/simd_loop_messages.cpp b/test/OpenMP/simd_loop_messages.cpp index ea663fddd9cf..ce64842d68a9 100644 --- a/test/OpenMP/simd_loop_messages.cpp +++ b/test/OpenMP/simd_loop_messages.cpp @@ -2,6 +2,7 @@ static int sii; #pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} +static int globalii; int test_iteration_spaces() { const int N = 100; @@ -257,6 +258,23 @@ int test_iteration_spaces() { c[sii] = a[sii]; } + #pragma omp parallel + { + // expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be a variable with global storage without being explicitly marked as linear}} + #pragma omp simd + for (globalii = 0; globalii < 10; globalii+=1) + c[globalii] = a[globalii]; + } + + #pragma omp parallel + { +// expected-error@+3 {{loop iteration variable in the associated loop of 'omp simd' directive may not be a variable with global storage without being explicitly marked as lastprivate}} +#pragma omp simd collapse(2) + for (ii = 0; ii < 10; ii += 1) + for (globalii = 0; globalii < 10; globalii += 1) + c[globalii] += a[globalii] + ii; + } + // expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}} #pragma omp simd for (auto &item : a) { @@ -300,8 +318,10 @@ class Iter0 { Iter0(const Iter0 &) { } Iter0 operator ++() { return *this; } Iter0 operator --() { return *this; } + Iter0 operator + (int delta) { return *this; } bool operator <(Iter0 a) { return true; } }; +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}} int operator -(Iter0 a, Iter0 b) { return 0; } class Iter1 { public: @@ -330,10 +350,14 @@ class GoodIter { typedef int difference_type; typedef std::random_access_iterator_tag iterator_category; }; +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} int operator -(GoodIter a, GoodIter b) { return 0; } +// expected-note@+1 2 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}} GoodIter operator -(GoodIter a) { return a; } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}} GoodIter operator -(GoodIter a, int v) { return GoodIter(); } GoodIter operator +(GoodIter a, int v) { return GoodIter(); } +// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}} GoodIter operator -(int v, GoodIter a) { return GoodIter(); } GoodIter operator +(int v, GoodIter a) { return GoodIter(); } @@ -370,7 +394,7 @@ int test_with_random_access_iterator() { for (begin = GoodIter(0); begin < end; ++begin) ++begin; #pragma omp simd - for (begin = begin0; begin < end; ++begin) + for (begin = GoodIter(1,2); begin < end; ++begin) ++begin; // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} #pragma omp simd @@ -415,12 +439,16 @@ int test_with_random_access_iterator() { #pragma omp simd for (Iter0 I = begin0; I < end0; ++I) ++I; + // Initializer is constructor without params. // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp simd for (Iter0 I; I < end0; ++I) ++I; + Iter1 begin1, end1; + // expected-error@+3 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} + // expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} #pragma omp simd for (Iter1 I = begin1; I < end1; ++I) ++I; @@ -429,11 +457,15 @@ int test_with_random_access_iterator() { #pragma omp simd for (Iter1 I = begin1; I >= end1; ++I) ++I; + // Initializer is constructor with all default params. + // expected-error@+4 {{invalid operands to binary expression ('Iter1' and 'Iter1')}} + // expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}} // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} #pragma omp simd for (Iter1 I; I < end1; ++I) { } + return 0; } diff --git a/test/OpenMP/simd_metadata.c b/test/OpenMP/simd_metadata.c index a0588adf7dad..4552669c80b7 100644 --- a/test/OpenMP/simd_metadata.c +++ b/test/OpenMP/simd_metadata.c @@ -1,10 +1,23 @@ -// RUN: %clang_cc1 -fopenmp=libiomp5 -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -triple powerpc64-unknown-unknown -emit-llvm %s -o - | FileCheck %s -void h1(float *c, float *a, float *b, int size) +void h1(float *c, float *a, double b[], int size) { // CHECK-LABEL: define void @h1 int t = 0; -#pragma omp simd safelen(16) linear(t) +#pragma omp simd safelen(16) linear(t) aligned(c:32) aligned(a,b) +// CHECK: [[C_PTRINT:%.+]] = ptrtoint +// CHECK-NEXT: [[C_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[C_PTRINT]], 31 +// CHECK-NEXT: [[C_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[C_MASKEDPTR]], 0 +// CHECK-NEXT: call void @llvm.assume(i1 [[C_MASKCOND]]) +// CHECK: [[A_PTRINT:%.+]] = ptrtoint +// CHECK-NEXT: [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 15 +// CHECK-NEXT: [[A_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[A_MASKEDPTR]], 0 +// CHECK-NEXT: call void @llvm.assume(i1 [[A_MASKCOND]]) +// CHECK: [[B_PTRINT:%.+]] = ptrtoint +// CHECK-NEXT: [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 15 +// CHECK-NEXT: [[B_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[B_MASKEDPTR]], 0 +// CHECK-NEXT: call void @llvm.assume(i1 [[B_MASKCOND]]) for (int i = 0; i < size; ++i) { c[i] = a[i] * a[i] + b[i] * b[t]; ++t; @@ -39,13 +52,13 @@ void h3(float *c, float *a, float *b, int size) } // Metadata for h1: -// CHECK: [[LOOP_H1_HEADER:![0-9]+]] = metadata !{metadata [[LOOP_H1_HEADER]], metadata [[LOOP_WIDTH_16:![0-9]+]], metadata [[LOOP_VEC_ENABLE:![0-9]+]]} -// CHECK: [[LOOP_WIDTH_16]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 16} -// CHECK: [[LOOP_VEC_ENABLE]] = metadata !{metadata !"llvm.loop.vectorize.enable", i1 true} +// CHECK: [[LOOP_H1_HEADER:![0-9]+]] = distinct !{[[LOOP_H1_HEADER]], [[LOOP_WIDTH_16:![0-9]+]], [[LOOP_VEC_ENABLE:![0-9]+]]} +// CHECK: [[LOOP_WIDTH_16]] = !{!"llvm.loop.vectorize.width", i32 16} +// CHECK: [[LOOP_VEC_ENABLE]] = !{!"llvm.loop.vectorize.enable", i1 true} // // Metadata for h2: -// CHECK: [[LOOP_H2_HEADER]] = metadata !{metadata [[LOOP_H2_HEADER]], metadata [[LOOP_VEC_ENABLE]]} +// CHECK: [[LOOP_H2_HEADER]] = distinct !{[[LOOP_H2_HEADER]], [[LOOP_VEC_ENABLE]]} // // Metadata for h3: -// CHECK: [[LOOP_H3_HEADER:![0-9]+]] = metadata !{metadata [[LOOP_H3_HEADER]], metadata [[LOOP_VEC_ENABLE]]} +// CHECK: [[LOOP_H3_HEADER:![0-9]+]] = distinct !{[[LOOP_H3_HEADER]], [[LOOP_VEC_ENABLE]]} // diff --git a/test/OpenMP/simd_misc_messages.c b/test/OpenMP/simd_misc_messages.c index 67edc6d1f867..f94bb3870ca2 100644 --- a/test/OpenMP/simd_misc_messages.c +++ b/test/OpenMP/simd_misc_messages.c @@ -9,26 +9,25 @@ // expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}} #pragma omp simd safelen(4) -void test_no_clause() -{ +void test_no_clause() { int i; - #pragma omp simd - for (i = 0; i < 16; ++i) ; +#pragma omp simd + for (i = 0; i < 16; ++i) + ; - // expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}} - #pragma omp simd +// expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}} +#pragma omp simd ++i; } -void test_branch_protected_scope() -{ +void test_branch_protected_scope() { int i = 0; L1: ++i; int x[24]; - #pragma omp simd +#pragma omp simd for (i = 0; i < 16; ++i) { if (i == 5) goto L1; // expected-error {{use of undeclared label 'L1'}} @@ -37,7 +36,7 @@ L1: else if (i == 7) goto L2; else if (i == 8) { -L2: + L2: x[i]++; } } @@ -48,506 +47,632 @@ L2: goto L1; } -void test_invalid_clause() -{ +void test_invalid_clause() { int i; - // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} - #pragma omp simd foo bar - for (i = 0; i < 16; ++i) ; +// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} +#pragma omp simd foo bar + for (i = 0; i < 16; ++i) + ; } -void test_non_identifiers() -{ +void test_non_identifiers() { int i, x; - // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} - #pragma omp simd; - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} - // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} - #pragma omp simd firstprivate(x); - for (i = 0; i < 16; ++i) ; - - // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} - #pragma omp simd private(x); - for (i = 0; i < 16; ++i) ; - - // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} - #pragma omp simd , private(x); - for (i = 0; i < 16; ++i) ; +// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} +#pragma omp simd; + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} +#pragma omp simd firstprivate(x); + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} +#pragma omp simd private(x); + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} +#pragma omp simd, private(x); + for (i = 0; i < 16; ++i) + ; } extern int foo(); -void test_safelen() -{ +void test_safelen() { int i; - // expected-error@+1 {{expected '('}} - #pragma omp simd safelen - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd safelen( - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd safelen() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(, - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(,) - for (i = 0; i < 16; ++i) ; - // expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} - // expected-error@+1 {{expected '('}} - #pragma omp simd safelen 4) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4 - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4, - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4,) - for (i = 0; i < 16; ++i) ; - // xxpected-error@+1 {{expected expression}} - #pragma omp simd safelen(4) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4 4) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4,,4) - for (i = 0; i < 16; ++i) ; - #pragma omp simd safelen(4) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} - #pragma omp simd safelen(4,8) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expression is not an integer constant expression}} - #pragma omp simd safelen(2.5) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{expression is not an integer constant expression}} - #pragma omp simd safelen(foo()) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} - #pragma omp simd safelen(-5) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} - #pragma omp simd safelen(0) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} - #pragma omp simd safelen(5-5) - for (i = 0; i < 16; ++i); +// expected-error@+1 {{expected '('}} +#pragma omp simd safelen + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd safelen( + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd safelen() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(, ) + for (i = 0; i < 16; ++i) + ; +// expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp simd safelen 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4 + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4, ) + for (i = 0; i < 16; ++i) + ; +// xxpected-error@+1 {{expected expression}} +#pragma omp simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4, , 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd safelen(4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} +#pragma omp simd safelen(4, 8) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp simd safelen(2.5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp simd safelen(foo()) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp simd safelen(-5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp simd safelen(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} +#pragma omp simd safelen(5 - 5) + for (i = 0; i < 16; ++i) + ; } -void test_collapse() -{ +void test_collapse() { int i; - // expected-error@+1 {{expected '('}} - #pragma omp simd collapse - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd collapse( - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd collapse() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd collapse(, - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd collapse(,) - for (i = 0; i < 16; ++i) ; - // expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} - // expected-error@+1 {{expected '('}} - #pragma omp simd collapse 4) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4 - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4, - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4,) - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // xxpected-error@+1 {{expected expression}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4) - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4 4) - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4,,4) - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - #pragma omp simd collapse(4) +// expected-error@+1 {{expected '('}} +#pragma omp simd collapse + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd collapse( + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd collapse() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd collapse(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd collapse(, ) + for (i = 0; i < 16; ++i) + ; +// expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp simd collapse 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4 + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4, + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4, ) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// xxpected-error@+1 {{expected expression}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4, , 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +#pragma omp simd collapse(4) for (int i1 = 0; i1 < 16; ++i1) for (int i2 = 0; i2 < 16; ++i2) for (int i3 = 0; i3 < 16; ++i3) for (int i4 = 0; i4 < 16; ++i4) foo(); - // expected-error@+2 {{expected ')'}} - // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} - #pragma omp simd collapse(4,8) - for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} - // expected-error@+1 {{expression is not an integer constant expression}} - #pragma omp simd collapse(2.5) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{expression is not an integer constant expression}} - #pragma omp simd collapse(foo()) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} - #pragma omp simd collapse(-5) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} - #pragma omp simd collapse(0) - for (i = 0; i < 16; ++i); - // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} - #pragma omp simd collapse(5-5) - for (i = 0; i < 16; ++i); +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp simd collapse(4, 8) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp simd collapse(2.5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp simd collapse(foo()) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp simd collapse(-5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp simd collapse(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp simd collapse(5 - 5) + for (i = 0; i < 16; ++i) + ; +// expected-note@+2 {{defined as reduction}} +#pragma omp parallel +#pragma omp simd collapse(2) reduction(+ : i) + for (i = 0; i < 16; ++i) + // expected-note@+1 {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp for' directive into a parallel or another task region?}} + for (int j = 0; j < 16; ++j) +// expected-error@+3 {{reduction variable must be shared}} +// expected-error@+2 {{private variable cannot be reduction}} +// expected-error@+1 {{OpenMP constructs may not be nested inside a simd region}} +#pragma omp for reduction(+ : i, j) + for (int k = 0; k < 16; ++k) + i += j; } -void test_linear() -{ +void test_linear() { int i; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd linear( - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected expression}} - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd linear(, - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected expression}} - // expected-error@+1 {{expected expression}} - #pragma omp simd linear(,) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd linear() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd linear(int) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected variable name}} - #pragma omp simd linear(0) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{use of undeclared identifier 'x'}} - #pragma omp simd linear(x) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{use of undeclared identifier 'x'}} - // expected-error@+1 {{use of undeclared identifier 'y'}} - #pragma omp simd linear(x, y) - for (i = 0; i < 16; ++i) ; - // expected-error@+3 {{use of undeclared identifier 'x'}} - // expected-error@+2 {{use of undeclared identifier 'y'}} - // expected-error@+1 {{use of undeclared identifier 'z'}} - #pragma omp simd linear(x, y, z) - for (i = 0; i < 16; ++i) ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd linear( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd linear(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp simd linear(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd linear() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd linear(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd linear(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp simd linear(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp simd linear(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp simd linear(x, y, z) + for (i = 0; i < 16; ++i) + ; int x, y; - // expected-error@+1 {{expected expression}} - #pragma omp simd linear(x:) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd linear(x:,) - for (i = 0; i < 16; ++i) ; - #pragma omp simd linear(x:1) - for (i = 0; i < 16; ++i) ; - #pragma omp simd linear(x:2*2) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd linear(x:1,y) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd linear(x:1,y,z:1) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as linear}} - // expected-error@+1 {{linear variable cannot be linear}} - #pragma omp simd linear(x) linear(x) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as private}} - // expected-error@+1 {{private variable cannot be linear}} - #pragma omp simd private(x) linear(x) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as linear}} - // expected-error@+1 {{linear variable cannot be private}} - #pragma omp simd linear(x) private(x) - for (i = 0; i < 16; ++i) ; - - // expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}} - #pragma omp simd linear(x,y:0) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as linear}} - // expected-error@+1 {{linear variable cannot be lastprivate}} - #pragma omp simd linear(x) lastprivate(x) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as lastprivate}} - // expected-error@+1 {{lastprivate variable cannot be linear}} - #pragma omp simd lastprivate(x) linear(x) - for (i = 0; i < 16; ++i) ; - +// expected-error@+1 {{expected expression}} +#pragma omp simd linear(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd linear(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd linear(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd linear(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd linear(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd linear(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be linear}} +#pragma omp simd linear(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as private}} +// expected-error@+1 {{private variable cannot be linear}} +#pragma omp simd private(x) linear(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be private}} +#pragma omp simd linear(x) private(x) + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}} +#pragma omp simd linear(x, y : 0) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as linear}} +// expected-error@+1 {{linear variable cannot be lastprivate}} +#pragma omp simd linear(x) lastprivate(x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as lastprivate}} +// expected-error@+1 {{lastprivate variable cannot be linear}} +#pragma omp simd lastprivate(x) linear(x) + for (i = 0; i < 16; ++i) + ; } -void test_aligned() -{ +void test_aligned() { int i; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd aligned( - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected expression}} - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd aligned(, - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected expression}} - // expected-error@+1 {{expected expression}} - #pragma omp simd aligned(,) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd aligned() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd aligned(int) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected variable name}} - #pragma omp simd aligned(0) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{use of undeclared identifier 'x'}} - #pragma omp simd aligned(x) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{use of undeclared identifier 'x'}} - // expected-error@+1 {{use of undeclared identifier 'y'}} - #pragma omp simd aligned(x, y) - for (i = 0; i < 16; ++i) ; - // expected-error@+3 {{use of undeclared identifier 'x'}} - // expected-error@+2 {{use of undeclared identifier 'y'}} - // expected-error@+1 {{use of undeclared identifier 'z'}} - #pragma omp simd aligned(x, y, z) - for (i = 0; i < 16; ++i) ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd aligned( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd aligned(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected expression}} +#pragma omp simd aligned(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd aligned() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd aligned(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd aligned(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{use of undeclared identifier 'x'}} +#pragma omp simd aligned(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{use of undeclared identifier 'x'}} +// expected-error@+1 {{use of undeclared identifier 'y'}} +#pragma omp simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{use of undeclared identifier 'x'}} +// expected-error@+2 {{use of undeclared identifier 'y'}} +// expected-error@+1 {{use of undeclared identifier 'z'}} +#pragma omp simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; int *x, y, z[25]; // expected-note 4 {{'y' defined here}} - #pragma omp simd aligned(x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd aligned(z) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd aligned(x:) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd aligned(x:,) - for (i = 0; i < 16; ++i) ; - #pragma omp simd aligned(x:1) - for (i = 0; i < 16; ++i) ; - #pragma omp simd aligned(x:2*2) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd aligned(x:1,y) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd aligned(x:1,y,z:1) - for (i = 0; i < 16; ++i) ; - - // expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} - #pragma omp simd aligned(x, y) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} - #pragma omp simd aligned(x, y, z) - for (i = 0; i < 16; ++i) ; - - // expected-note@+2 {{defined as aligned}} - // expected-error@+1 {{a variable cannot appear in more than one aligned clause}} - #pragma omp simd aligned(x) aligned(z,x) - for (i = 0; i < 16; ++i) ; - - // expected-note@+3 {{defined as aligned}} - // expected-error@+2 {{a variable cannot appear in more than one aligned clause}} - // expected-error@+1 2 {{argument of aligned clause should be array or pointer, not 'int'}} - #pragma omp simd aligned(x,y,z) aligned(y,z) - for (i = 0; i < 16; ++i) ; +#pragma omp simd aligned(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd aligned(z) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd aligned(x :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd aligned(x :, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd aligned(x : 1) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd aligned(x : 2 * 2) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd aligned(x : 1, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd aligned(x : 1, y, z : 1) + for (i = 0; i < 16; ++i) + ; + +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp simd aligned(x, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp simd aligned(x, y, z) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+2 {{defined as aligned}} +// expected-error@+1 {{a variable cannot appear in more than one aligned clause}} +#pragma omp simd aligned(x) aligned(z, x) + for (i = 0; i < 16; ++i) + ; + +// expected-note@+3 {{defined as aligned}} +// expected-error@+2 {{a variable cannot appear in more than one aligned clause}} +// expected-error@+1 2 {{argument of aligned clause should be array or pointer, not 'int'}} +#pragma omp simd aligned(x, y, z) aligned(y, z) + for (i = 0; i < 16; ++i) + ; } -void test_private() -{ +void test_private() { int i; - // expected-error@+2 {{expected expression}} - // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} - #pragma omp simd private( - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} - // expected-error@+1 2 {{expected expression}} - #pragma omp simd private(, - for (i = 0; i < 16; ++i) ; - // expected-error@+1 2 {{expected expression}} - #pragma omp simd private(,) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd private() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd private(int) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected variable name}} - #pragma omp simd private(0) - for (i = 0; i < 16; ++i) ; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp simd private( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp simd private(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 2 {{expected expression}} +#pragma omp simd private(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd private() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd private(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd private(0) + for (i = 0; i < 16; ++i) + ; int x, y, z; - #pragma omp simd private(x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd private(x, y) - for (i = 0; i < 16; ++i) ; - #pragma omp simd private(x, y, z) +#pragma omp simd private(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd private(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd private(x, y, z) for (i = 0; i < 16; ++i) { x = y * i + z; } } -void test_firstprivate() -{ +void test_firstprivate() { int i; - // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} - // expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} - // expected-error@+1 {{expected expression}} - #pragma omp simd firstprivate( - for (i = 0; i < 16; ++i) ; +// expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} +// expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} +// expected-error@+1 {{expected expression}} +#pragma omp simd firstprivate( + for (i = 0; i < 16; ++i) + ; } -void test_lastprivate() -{ +void test_lastprivate() { int i; - // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} - // expected-error@+1 {{expected expression}} - #pragma omp simd lastprivate( - for (i = 0; i < 16; ++i) ; - - // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} - // expected-error@+1 2 {{expected expression}} - #pragma omp simd lastprivate(, - for (i = 0; i < 16; ++i) ; - // expected-error@+1 2 {{expected expression}} - #pragma omp simd lastprivate(,) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd lastprivate() - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd lastprivate(int) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected variable name}} - #pragma omp simd lastprivate(0) - for (i = 0; i < 16; ++i) ; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp simd lastprivate( + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp simd lastprivate(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 2 {{expected expression}} +#pragma omp simd lastprivate(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd lastprivate() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd lastprivate(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd lastprivate(0) + for (i = 0; i < 16; ++i) + ; int x, y, z; - #pragma omp simd lastprivate(x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd lastprivate(x, y) - for (i = 0; i < 16; ++i) ; - #pragma omp simd lastprivate(x, y, z) - for (i = 0; i < 16; ++i) ; +#pragma omp simd lastprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd lastprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd lastprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; } -void test_reduction() -{ +void test_reduction() { int i, x, y; - // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} - // expected-error@+2 {{expected identifier}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction( - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected identifier}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction() - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected expression}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction(x) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected identifier}} - #pragma omp simd reduction(:x) - for (i = 0; i < 16; ++i) ; - // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} - // expected-error@+2 {{expected identifier}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction(, - for (i = 0; i < 16; ++i) ; - // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} - // expected-error@+2 {{expected expression}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction(+ - for (i = 0; i < 16; ++i) ; - - // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} - // - // expected-error@+1 {{expected expression}} - #pragma omp simd reduction(+: - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd reduction(+:) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd reduction(+:,y) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected expression}} - #pragma omp simd reduction(+:x,+:y) - for (i = 0; i < 16; ++i) ; - // expected-error@+2 {{expected identifier}} - // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} - #pragma omp simd reduction(%:x) - for (i = 0; i < 16; ++i) ; - - #pragma omp simd reduction(+:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(*:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(-:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(&:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(|:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(^:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(&&:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(||:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(max:x) - for (i = 0; i < 16; ++i) ; - #pragma omp simd reduction(min:x) - for (i = 0; i < 16; ++i) ; - struct X { int x; }; +// expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} +// expected-error@+2 {{expected identifier}} +// expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} +#pragma omp simd reduction( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected identifier}} +// expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} +#pragma omp simd reduction() + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected expression}} +// expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} +#pragma omp simd reduction(x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected identifier}} +#pragma omp simd reduction( : x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} +// expected-error@+2 {{expected identifier}} +// expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} +#pragma omp simd reduction(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} +// expected-error@+2 {{expected expression}} +// expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} +#pragma omp simd reduction(+ + for (i = 0; i < 16; ++i) + ; + +// expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} +// +// expected-error@+1 {{expected expression}} +#pragma omp simd reduction(+: + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd reduction(+ :) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd reduction(+ :, y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp simd reduction(+ : x, + : y) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected identifier}} +#pragma omp simd reduction(% : x) + for (i = 0; i < 16; ++i) + ; + +#pragma omp simd reduction(+ : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(* : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(- : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(& : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(| : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(^ : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(&& : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(|| : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(max : x) + for (i = 0; i < 16; ++i) + ; +#pragma omp simd reduction(min : x) + for (i = 0; i < 16; ++i) + ; + struct X { + int x; + }; struct X X; - // expected-error@+1 {{expected variable name}} - #pragma omp simd reduction(+:X.x) - for (i = 0; i < 16; ++i) ; - // expected-error@+1 {{expected variable name}} - #pragma omp simd reduction(+:x+x) - for (i = 0; i < 16; ++i) ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd reduction(+ : X.x) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp simd reduction(+ : x + x) + for (i = 0; i < 16; ++i) + ; } -void test_loop_messages() -{ +void test_loop_messages() { float a[100], b[100], c[100]; - // expected-error@+2 {{variable must be of integer or pointer type}} - #pragma omp simd +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp simd for (float fi = 0; fi < 10.0; fi++) { c[(int)fi] = a[(int)fi] + b[(int)fi]; } - // expected-error@+2 {{variable must be of integer or pointer type}} - #pragma omp simd +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp simd for (double fi = 0; fi < 10.0; fi++) { c[(int)fi] = a[(int)fi] + b[(int)fi]; } diff --git a/test/OpenMP/simd_private_messages.cpp b/test/OpenMP/simd_private_messages.cpp index e5e4fe5b8b39..56922e888b99 100644 --- a/test/OpenMP/simd_private_messages.cpp +++ b/test/OpenMP/simd_private_messages.cpp @@ -22,15 +22,15 @@ public: S3():a(0) { } }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v):a(v) { } }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5():a(0) {} + S5():a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v):a(v) { } }; @@ -86,8 +86,8 @@ template<class I, class C> int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp simd private // expected-error {{expected '(' after 'private'}} @@ -110,7 +110,7 @@ int main(int argc, char **argv) { for (int k = 0; k < argc; ++k) ++k; #pragma omp simd private (argv[1]) // expected-error {{expected variable name}} for (int k = 0; k < argc; ++k) ++k; - #pragma omp simd private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + #pragma omp simd private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} for (int k = 0; k < argc; ++k) ++k; #pragma omp simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} for (int k = 0; k < argc; ++k) ++k; diff --git a/test/OpenMP/single_copyprivate_messages.cpp b/test/OpenMP/single_copyprivate_messages.cpp index f07ab12bfb46..7bb145c6d325 100644 --- a/test/OpenMP/single_copyprivate_messages.cpp +++ b/test/OpenMP/single_copyprivate_messages.cpp @@ -155,3 +155,23 @@ int main(int argc, char **argv) { return tmain(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char>' requested here}} } + +extern void abort(void); + +void +single(int a, int b) { +#pragma omp single copyprivate(a) copyprivate(b) + { + a = b = 5; + } + + if (a != b) + abort(); +} + +int parallel() { +#pragma omp parallel + single(1, 2); + + return 0; +} diff --git a/test/OpenMP/single_firstprivate_messages.cpp b/test/OpenMP/single_firstprivate_messages.cpp index 6d4988254fb6..9f6f16083544 100644 --- a/test/OpenMP/single_firstprivate_messages.cpp +++ b/test/OpenMP/single_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -27,22 +27,22 @@ class S3 { public: S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3(const S3 &s3) : a(s3.a) {} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note 2 {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note 4 {{'S5' declared here}} +class S5 { int a; - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}} public: S5() : a(0) {} @@ -62,8 +62,8 @@ S3 h; template <class I, class C> int foomain(int argc, char **argv) { - I e(4); // expected-note {{'e' defined here}} - C g(5); // expected-note 2 {{'g' defined here}} + I e(4); + C g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp parallel @@ -97,7 +97,7 @@ int foomain(int argc, char **argv) { #pragma omp single firstprivate(argv[1]) // expected-error {{expected variable name}} foo(); #pragma omp parallel -#pragma omp single firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp single firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} foo(); #pragma omp parallel #pragma omp single firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} @@ -121,7 +121,7 @@ int foomain(int argc, char **argv) { #pragma omp single firstprivate(i) foo(); #pragma omp parallel -#pragma omp single firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp single firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} foo(); #pragma omp parallel private(i) // expected-note {{defined as private}} #pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}} @@ -135,8 +135,8 @@ int foomain(int argc, char **argv) { int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note 2 {{'g' defined here}} + S4 e(4); + S5 g(5); S3 m; S6 n(2); int i; @@ -197,7 +197,7 @@ int main(int argc, char **argv) { #pragma omp single safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp single'}} foo(); #pragma omp parallel -#pragma omp single firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp single firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} foo(); #pragma omp parallel #pragma omp single firstprivate(m) // OK @@ -215,7 +215,7 @@ int main(int argc, char **argv) { #pragma omp single firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} foo(); #pragma omp parallel -#pragma omp single firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp single firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}} foo(); #pragma omp parallel #pragma omp single firstprivate(n) // OK diff --git a/test/OpenMP/single_private_messages.cpp b/test/OpenMP/single_private_messages.cpp index 1414a92ee030..8bdc48f1a506 100644 --- a/test/OpenMP/single_private_messages.cpp +++ b/test/OpenMP/single_private_messages.cpp @@ -24,16 +24,16 @@ public: S3() : a(0) {} }; const S3 ca[5]; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -92,8 +92,8 @@ int foomain(I argc, C **argv) { } int main(int argc, char **argv) { - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp single private // expected-error {{expected '(' after 'private'}} @@ -116,7 +116,7 @@ int main(int argc, char **argv) { foo(); #pragma omp single private(argv[1]) // expected-error {{expected variable name}} foo(); -#pragma omp single private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp single private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} foo(); #pragma omp single private(h) // expected-error {{threadprivate or thread local variable cannot be private}} foo(); diff --git a/test/OpenMP/target_ast_print.cpp b/test/OpenMP/target_ast_print.cpp new file mode 100644 index 000000000000..c57c04955f8d --- /dev/null +++ b/test/OpenMP/target_ast_print.cpp @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} + +template <typename T, int C> +T tmain(T argc, T *argv) { +#pragma omp target + foo(); +#pragma omp target if (argc > 0) + foo(); +#pragma omp target if (C) + foo(); + return 0; +} + +// CHECK: template <typename T = int, int C = 5> int tmain(int argc, int *argv) { +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp target if(argc > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target if(5) +// CHECK-NEXT: foo() +// CHECK: template <typename T = char, int C = 1> char tmain(char argc, char *argv) { +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp target if(argc > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target if(1) +// CHECK-NEXT: foo() +// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp target if(argc > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target if(C) +// CHECK-NEXT: foo() + +// CHECK-LABEL: int main(int argc, char **argv) { +int main (int argc, char **argv) { +#pragma omp target +// CHECK-NEXT: #pragma omp target + foo(); +// CHECK-NEXT: foo(); +#pragma omp target if (argc > 0) +// CHECK-NEXT: #pragma omp target if(argc > 0) + foo(); +// CHECK-NEXT: foo(); + return tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0]); +} + +#endif diff --git a/test/OpenMP/target_if_messages.cpp b/test/OpenMP/target_if_messages.cpp new file mode 100644 index 000000000000..50a9ed2a202f --- /dev/null +++ b/test/OpenMP/target_if_messages.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + #pragma omp target if // expected-error {{expected '(' after 'if'}} + #pragma omp target if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if () // expected-error {{expected expression}} + #pragma omp target if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + #pragma omp target if (argc > 0 ? argv[1] : argv[2]) + #pragma omp target if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp target' cannot contain more than one 'if' clause}} + #pragma omp target if (S) // expected-error {{'S' does not refer to a value}} + #pragma omp target if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if(argc) + foo(); + + return 0; +} + +int main(int argc, char **argv) { + #pragma omp target if // expected-error {{expected '(' after 'if'}} + #pragma omp target if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if () // expected-error {{expected expression}} + #pragma omp target if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + #pragma omp target if (argc > 0 ? argv[1] : argv[2]) + #pragma omp target if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp target' cannot contain more than one 'if' clause}} + #pragma omp target if (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp target if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp target if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/target_messages.cpp b/test/OpenMP/target_messages.cpp new file mode 100644 index 000000000000..fb492281e2b4 --- /dev/null +++ b/test/OpenMP/target_messages.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp target // expected-error {{unexpected OpenMP directive '#pragma omp target'}} + +int main(int argc, char **argv) { + #pragma omp target { // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target ( // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target [ // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target ] // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target ) // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target } // expected-warning {{extra tokens at the end of '#pragma omp target' are ignored}} + foo(); + #pragma omp target + // expected-warning@+1 {{extra tokens at the end of '#pragma omp target' are ignored}} + #pragma omp target unknown() + foo(); + L1: + foo(); + #pragma omp target + ; + #pragma omp target + { + goto L1; // expected-error {{use of undeclared label 'L1'}} + argc++; + } + + for (int i = 0; i < 10; ++i) { + switch(argc) { + case (0): + #pragma omp target + { + foo(); + break; // expected-error {{'break' statement not in loop or switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + } + default: + break; + } + } + + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp target + L2: + foo(); + #pragma omp target + { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} + #pragma omp target + for (int n = 0; n < 100; ++n) {} + + return 0; +} + diff --git a/test/OpenMP/task_firstprivate_messages.cpp b/test/OpenMP/task_firstprivate_messages.cpp index 85d3f9f46144..6c5ccfca57bf 100644 --- a/test/OpenMP/task_firstprivate_messages.cpp +++ b/test/OpenMP/task_firstprivate_messages.cpp @@ -14,7 +14,7 @@ class S2 { public: S2() : a(0) {} - S2(S2 &s2) : a(s2.a) {} + S2(const S2 &s2) : a(s2.a) {} static float S2s; static const float S2sc; }; @@ -26,23 +26,23 @@ class S3 { public: S3() : a(0) {} - S3(S3 &s3) : a(s3.a) {} + S3(const S3 &s3) : a(s3.a) {} }; const S3 c; const S3 ca[5]; extern const int f; -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; S4(); - S4(const S4 &s4); + S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; S5() : a(0) {} - S5(const S5 &s5) : a(s5.a) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note 2 {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -54,8 +54,8 @@ S3 h; int main(int argc, char **argv) { const int d = 5; const int da[5] = {0}; - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp task firstprivate // expected-error {{expected '(' after 'firstprivate'}} @@ -73,7 +73,7 @@ int main(int argc, char **argv) { #pragma omp task firstprivate(da) #pragma omp task firstprivate(S2::S2s) #pragma omp task firstprivate(S2::S2sc) -#pragma omp task firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp task firstprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}} expected-error 2 {{calling a private constructor of class 'S5'}} #pragma omp task firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} #pragma omp task private(i), firstprivate(i) // expected-error {{private variable cannot be firstprivate}} expected-note{{defined as private}} foo(); diff --git a/test/OpenMP/task_messages.cpp b/test/OpenMP/task_messages.cpp index 88c339afc117..b02b43c2b395 100644 --- a/test/OpenMP/task_messages.cpp +++ b/test/OpenMP/task_messages.cpp @@ -5,8 +5,8 @@ void foo() { #pragma omp task // expected-error {{unexpected OpenMP directive '#pragma omp task'}} -class S { // expected-note 6 {{'S' declared here}} - S(const S &s) { a = s.a + 12; } +class S { + S(const S &s) { a = s.a + 12; } // expected-note 6 {{implicitly declared private here}} int a; public: @@ -17,23 +17,35 @@ public: S operator+(const S &) { return *this; } }; +class S1 { + int a; + +public: + S1() : a(0) {} + S1 &operator++() { return *this; } + S1(const S1 &) = delete; // expected-note 2 {{'S1' has been explicitly marked deleted here}} +}; + template <class T> int foo() { - T a; // expected-note 3 {{'a' defined here}} + T a; T &b = a; // expected-note 4 {{'b' defined here}} int r; + S1 s1; +// expected-error@+1 2 {{call to deleted constructor of 'S1'}} +#pragma omp task +// expected-note@+1 2 {{predetermined as a firstprivate in a task construct here}} + ++s1; #pragma omp task default(none) #pragma omp task default(shared) ++a; -// expected-error@+2 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} #pragma omp task default(none) #pragma omp task -// expected-note@+1 {{used here}} + // expected-error@+1 {{calling a private constructor of class 'S'}} ++a; #pragma omp task -// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} #pragma omp task - // expected-note@+1 {{used here}} + // expected-error@+1 {{calling a private constructor of class 'S'}} ++a; #pragma omp task default(shared) #pragma omp task @@ -46,11 +58,11 @@ int foo() { #pragma omp task // expected-note@+1 2 {{used here}} ++b; -// expected-error@+3 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} -// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} -// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} #pragma omp task -// expected-note@+1 3 {{used here}} +// expected-error@+2 {{calling a private constructor of class 'S'}} +// expected-note@+1 2 {{used here}} #pragma omp parallel shared(a, b) ++a, ++b; // expected-note@+1 3 {{defined as reduction}} @@ -109,7 +121,7 @@ int foo() { int main(int argc, char **argv) { int a; int &b = a; // expected-note 2 {{'b' defined here}} - S sa; // expected-note 3 {{'sa' defined here}} + S sa; S &sb = sa; // expected-note 2 {{'sb' defined here}} int r; #pragma omp task { // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} @@ -193,14 +205,12 @@ L2: #pragma omp task default(shared) ++sa; #pragma omp task default(none) -// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} #pragma omp task -// expected-note@+1 {{used here}} + // expected-error@+1 {{calling a private constructor of class 'S'}} ++sa; #pragma omp task -// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} #pragma omp task -// expected-note@+1 {{used here}} + // expected-error@+1 {{calling a private constructor of class 'S'}} ++sa; #pragma omp task default(shared) #pragma omp task @@ -212,10 +222,10 @@ L2: #pragma omp task // expected-note@+1 {{used here}} ++sb; -// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} -// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} #pragma omp task -// expected-note@+1 2 {{used here}} +// expected-error@+2 {{calling a private constructor of class 'S'}} +// expected-note@+1 {{used here}} #pragma omp parallel shared(sa, sb) ++sa, ++sb; // expected-note@+1 2 {{defined as reduction}} diff --git a/test/OpenMP/task_private_messages.cpp b/test/OpenMP/task_private_messages.cpp index 0be238dd90c4..9a3bb757681c 100644 --- a/test/OpenMP/task_private_messages.cpp +++ b/test/OpenMP/task_private_messages.cpp @@ -27,16 +27,16 @@ public: const S3 c; // expected-note {{global variable is predetermined as shared}} const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} extern const int f; // expected-note {{global variable is predetermined as shared}} -class S4 { // expected-note {{'S4' declared here}} +class S4 { int a; - S4(); + S4(); // expected-note {{implicitly declared private here}} public: S4(int v) : a(v) {} }; -class S5 { // expected-note {{'S5' declared here}} +class S5 { int a; - S5() : a(0) {} + S5() : a(0) {} // expected-note {{implicitly declared private here}} public: S5(int v) : a(v) {} @@ -48,8 +48,8 @@ int threadvar; int main(int argc, char **argv) { const int d = 5; // expected-note {{constant variable is predetermined as shared}} const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} - S4 e(4); // expected-note {{'e' defined here}} - S5 g(5); // expected-note {{'g' defined here}} + S4 e(4); + S5 g(5); int i; int &j = i; // expected-note {{'j' defined here}} #pragma omp task private // expected-error {{expected '(' after 'private'}} @@ -66,7 +66,7 @@ int main(int argc, char **argv) { #pragma omp task private(ca) // expected-error {{shared variable cannot be private}} #pragma omp task private(da) // expected-error {{shared variable cannot be private}} #pragma omp task private(S2::S2s) // expected-error {{shared variable cannot be private}} -#pragma omp task private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp task private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} #pragma omp task private(threadvar) // expected-error {{threadprivate or thread local variable cannot be private}} #pragma omp task shared(i), private(i) // expected-error {{shared variable cannot be private}} expected-note {{defined as shared}} foo(); diff --git a/test/OpenMP/teams_ast_print.cpp b/test/OpenMP/teams_ast_print.cpp new file mode 100644 index 000000000000..394ec73a841c --- /dev/null +++ b/test/OpenMP/teams_ast_print.cpp @@ -0,0 +1,112 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} + +template <class T> +struct S { + operator T() {return T();} + static T TS; + #pragma omp threadprivate(TS) +}; + +// CHECK: template <class T = int> struct S { +// CHECK: static int TS; +// CHECK-NEXT: #pragma omp threadprivate(S<int>::TS) +// CHECK-NEXT: } +// CHECK: template <class T = long> struct S { +// CHECK: static long TS; +// CHECK-NEXT: #pragma omp threadprivate(S<long>::TS) +// CHECK-NEXT: } +// CHECK: template <class T> struct S { +// CHECK: static T TS; +// CHECK-NEXT: #pragma omp threadprivate(S::TS) +// CHECK: }; + +template <typename T, int C> +T tmain(T argc, T *argv) { + T b = argc, c, d, e, f, g; + static T a; + S<T> s; +#pragma omp target +#pragma omp teams + a=2; +#pragma omp target +#pragma omp teams default(none), private(argc,b) firstprivate(argv) shared (d) reduction(+:c) reduction(max:e) + foo(); +#pragma omp target +#pragma omp teams reduction(^:e, f) reduction(&& : g) + foo(); + return 0; +} + +// CHECK: template <typename T = int, int C = 5> int tmain(int argc, int *argv) { +// CHECK-NEXT: int b = argc, c, d, e, f, g; +// CHECK-NEXT: static int a; +// CHECK-NEXT: S<int> s; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams default(none) private(argc,b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams reduction(^: e,f) reduction(&&: g) +// CHECK-NEXT: foo() +// CHECK: template <typename T = long, int C = 1> long tmain(long argc, long *argv) { +// CHECK-NEXT: long b = argc, c, d, e, f, g; +// CHECK-NEXT: static long a; +// CHECK-NEXT: S<long> s; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams default(none) private(argc,b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams reduction(^: e,f) reduction(&&: g) +// CHECK-NEXT: foo() +// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { +// CHECK-NEXT: T b = argc, c, d, e, f, g; +// CHECK-NEXT: static T a; +// CHECK-NEXT: S<T> s; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams default(none) private(argc,b) firstprivate(argv) shared(d) reduction(+: c) reduction(max: e) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams reduction(^: e,f) reduction(&&: g) +// CHECK-NEXT: foo() + +enum Enum { }; + +int main (int argc, char **argv) { + long x; + int b = argc, c, d, e, f, g; + static int a; + #pragma omp threadprivate(a) + Enum ee; +// CHECK: Enum ee; +#pragma omp target +#pragma omp teams +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams + a=2; +// CHECK-NEXT: a = 2; +#pragma omp target +#pragma omp teams default(none), private(argc,b) firstprivate(argv) reduction(| : c, d) reduction(* : e) +// CHECK-NEXT: #pragma omp target +// CHECK-NEXT: #pragma omp teams default(none) private(argc,b) firstprivate(argv) reduction(|: c,d) reduction(*: e) + foo(); +// CHECK-NEXT: foo(); + return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x); +} + +#endif diff --git a/test/OpenMP/teams_default_messages.cpp b/test/OpenMP/teams_default_messages.cpp new file mode 100644 index 000000000000..4f5a267150f9 --- /dev/null +++ b/test/OpenMP/teams_default_messages.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo(); + +int main(int argc, char **argv) { + #pragma omp target + #pragma omp teams default // expected-error {{expected '(' after 'default'}} + foo(); + #pragma omp target + #pragma omp teams default ( // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams default () // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + foo(); + #pragma omp target + #pragma omp teams default (none // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams default (shared), default(shared) // expected-error {{directive '#pragma omp teams' cannot contain more than one 'default' clause}} + foo(); + #pragma omp target + #pragma omp teams default (x) // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + foo(); + + #pragma omp target + #pragma omp teams default(none) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + + #pragma omp target + #pragma omp teams default(none) + #pragma omp parallel default(shared) + ++argc; + return 0; +} diff --git a/test/OpenMP/teams_firstprivate_messages.cpp b/test/OpenMP/teams_firstprivate_messages.cpp new file mode 100644 index 000000000000..3d4a21999eea --- /dev/null +++ b/test/OpenMP/teams_firstprivate_messages.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(const S2 &s2) : a(s2.a) {} + static float S2s; + static const float S2sc; +}; +const float S2::S2sc = 0; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); // expected-note {{implicitly declared private here}} +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} // expected-note {{implicitly declared private here}} +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); + S5 g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp target +#pragma omp teams firstprivate // expected-error {{expected '(' after 'firstprivate'}} + foo(); +#pragma omp target +#pragma omp teams firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams firstprivate() // expected-error {{expected expression}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(argc) + foo(); +#pragma omp target +#pragma omp teams firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(ba) + foo(); +#pragma omp target +#pragma omp teams firstprivate(ca) + foo(); +#pragma omp target +#pragma omp teams firstprivate(da) + foo(); +#pragma omp target +#pragma omp teams firstprivate(S2::S2s) + foo(); +#pragma omp target +#pragma omp teams firstprivate(S2::S2sc) + foo(); +#pragma omp target +#pragma omp teams firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + foo(); +#pragma omp target +#pragma omp teams firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + foo(); +#pragma omp target +#pragma omp teams private(i), firstprivate(i) // expected-error {{private variable cannot be firstprivate}} expected-note{{defined as private}} + foo(); +#pragma omp target +#pragma omp teams shared(i) + foo(); +#pragma omp target +#pragma omp teams firstprivate(i) + foo(); +#pragma omp target +#pragma omp teams firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + foo(); + + return 0; +} diff --git a/test/OpenMP/teams_messages.cpp b/test/OpenMP/teams_messages.cpp new file mode 100644 index 000000000000..56ed548a0377 --- /dev/null +++ b/test/OpenMP/teams_messages.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp teams // expected-error {{unexpected OpenMP directive '#pragma omp teams'}} + +int main(int argc, char **argv) { + #pragma omp target + #pragma omp teams { // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams ( // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams [ // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams ] // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams ) // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams } // expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); + #pragma omp target + #pragma omp teams + foo(); + // expected-warning@+2 {{extra tokens at the end of '#pragma omp teams' are ignored}} + #pragma omp target + #pragma omp teams unknown() + foo(); + L1: + foo(); + #pragma omp target + #pragma omp teams + ; + #pragma omp target + #pragma omp teams + { + goto L1; // expected-error {{use of undeclared label 'L1'}} + argc++; + } + + for (int i = 0; i < 10; ++i) { + switch(argc) { + case (0): + #pragma omp target + #pragma omp teams + { + foo(); + break; // expected-error {{'break' statement not in loop or switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + } + default: + break; + } + } + #pragma omp target + #pragma omp teams default(none) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp target + #pragma omp teams + L2: + foo(); + #pragma omp target + #pragma omp teams + { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} + #pragma omp target + #pragma omp teams + for (int n = 0; n < 100; ++n) {} + + return 0; +} + diff --git a/test/OpenMP/teams_private_messages.cpp b/test/OpenMP/teams_private_messages.cpp new file mode 100644 index 000000000000..16ecb74ea0cb --- /dev/null +++ b/test/OpenMP/teams_private_messages.cpp @@ -0,0 +1,119 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; +public: + S2():a(0) { } + static float S2s; // expected-note {{static data member is predetermined as shared}} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { + int a; + S4(); // expected-note {{implicitly declared private here}} +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} // expected-note {{implicitly declared private here}} +public: + S5(int v):a(v) { } +}; + +int threadvar; +#pragma omp threadprivate(threadvar) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = { 0 }; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); + S5 g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} + #pragma omp target + #pragma omp teams private // expected-error {{expected '(' after 'private'}} + foo(); + #pragma omp target + #pragma omp teams private ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams private () // expected-error {{expected expression}} + foo(); + #pragma omp target + #pragma omp teams private (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams private (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams private (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); + #pragma omp target + #pragma omp teams private (argc argv) // expected-error {{expected ',' or ')' in 'private' clause}} + foo(); + #pragma omp target + #pragma omp teams private (S1) // expected-error {{'S1' does not refer to a value}} + foo(); + #pragma omp target + #pragma omp teams private (a, b, c, d, f) // expected-error {{a private variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be private}} + foo(); + #pragma omp target + #pragma omp teams private (argv[1]) // expected-error {{expected variable name}} + foo(); + #pragma omp target + #pragma omp teams private(ba) + foo(); + #pragma omp target + #pragma omp teams private(ca) // expected-error {{shared variable cannot be private}} + foo(); + #pragma omp target + #pragma omp teams private(da) // expected-error {{shared variable cannot be private}} + foo(); + #pragma omp target + #pragma omp teams private(S2::S2s) // expected-error {{shared variable cannot be private}} + foo(); + #pragma omp target + #pragma omp teams private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} + foo(); + #pragma omp target + #pragma omp teams private(threadvar) // expected-error {{threadprivate or thread local variable cannot be private}} + foo(); + #pragma omp target + #pragma omp teams shared(i), private(i) // expected-error {{shared variable cannot be private}} expected-note {{defined as shared}} + foo(); + #pragma omp target + #pragma omp teams firstprivate(i) private(i) // expected-error {{firstprivate variable cannot be private}} expected-note {{defined as firstprivate}} + foo(); + #pragma omp target + #pragma omp teams private(i) + foo(); + #pragma omp target + #pragma omp teams private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type 'int &'}} + foo(); + #pragma omp target + #pragma omp teams firstprivate(i) + for (int k = 0; k < 10; ++k) { + #pragma omp parallel private(i) + foo(); + } + + return 0; +} diff --git a/test/OpenMP/teams_reduction_messages.cpp b/test/OpenMP/teams_reduction_messages.cpp new file mode 100644 index 000000000000..afedfc3e46fd --- /dev/null +++ b/test/OpenMP/teams_reduction_messages.cpp @@ -0,0 +1,307 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp target +#pragma omp teams reduction // expected-error {{expected '(' after 'reduction'}} + foo(); +#pragma omp target +#pragma omp teams reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); +#pragma omp target +#pragma omp teams reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp target +#pragma omp teams reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + foo(); +#pragma omp target +#pragma omp teams reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp target +#pragma omp teams reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : argc) + foo(); +#pragma omp target +#pragma omp teams reduction(^ : T) // expected-error {{'T' does not refer to a value}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel private(k) +#pragma omp target +#pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp target +#pragma omp teams reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp target +#pragma omp teams +#pragma omp parallel for private(fl) + for (int i = 0; i < 10; ++i) +#pragma omp target +#pragma omp teams reduction(+ : fl) + foo(); +#pragma omp target +#pragma omp teams +#pragma omp parallel for reduction(- : fl) + for (int i = 0; i < 10; ++i) +#pragma omp target +#pragma omp teams reduction(+ : fl) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp target +#pragma omp teams reduction // expected-error {{expected '(' after 'reduction'}} + foo(); +#pragma omp target +#pragma omp teams reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp teams' are ignored}} + foo(); +#pragma omp target +#pragma omp teams reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp target +#pragma omp teams reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + foo(); +#pragma omp target +#pragma omp teams reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp target +#pragma omp teams reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + foo(); +#pragma omp target +#pragma omp teams reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp target +#pragma omp teams reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams reduction(~ : argc) // expected-error {{expected unqualified-id}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : argc) + foo(); +#pragma omp target +#pragma omp teams reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(max : argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + foo(); +#pragma omp target +#pragma omp teams reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + foo(); +#pragma omp target +#pragma omp teams private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel private(k) +#pragma omp target +#pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + foo(); +#pragma omp target +#pragma omp teams reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp target +#pragma omp teams reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp target +#pragma omp teams +#pragma omp parallel for private(fl) + for (int i = 0; i < 10; ++i) +#pragma omp target +#pragma omp teams reduction(+ : fl) + foo(); +#pragma omp target +#pragma omp teams +#pragma omp parallel for reduction(- : fl) + for (int i = 0; i < 10; ++i) +#pragma omp target +#pragma omp teams reduction(+ : fl) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/teams_shared_messages.cpp b/test/OpenMP/teams_shared_messages.cpp new file mode 100644 index 000000000000..ce2f917e207c --- /dev/null +++ b/test/OpenMP/teams_shared_messages.cpp @@ -0,0 +1,125 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +extern S1 a; +class S2 { + mutable int a; +public: + S2():a(0) { } + S2(S2 &s2):a(s2.a) { } +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } + S3(S3 &s3):a(s3.a) { } +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} + S5(const S5 &s5):a(s5.a) { } +public: + S5(int v):a(v) { } +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = { 0 }; + S4 e(4); + S5 g(5); + int i; + int &j = i; + #pragma omp target + #pragma omp teams shared // expected-error {{expected '(' after 'shared'}} + foo(); + #pragma omp target + #pragma omp teams shared ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams shared () // expected-error {{expected expression}} + foo(); + #pragma omp target + #pragma omp teams shared (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams shared (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + #pragma omp target + #pragma omp teams shared (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); + #pragma omp target + #pragma omp teams shared (argc) + foo(); + #pragma omp target + #pragma omp teams shared (S1) // expected-error {{'S1' does not refer to a value}} + foo(); + #pragma omp target + #pragma omp teams shared (a, b, c, d, f) + foo(); + #pragma omp target + #pragma omp teams shared (argv[1]) // expected-error {{expected variable name}} + foo(); + #pragma omp target + #pragma omp teams shared(ba) + foo(); + #pragma omp target + #pragma omp teams shared(ca) + foo(); + #pragma omp target + #pragma omp teams shared(da) + foo(); + #pragma omp target + #pragma omp teams shared(e, g) + foo(); + #pragma omp target + #pragma omp teams shared(h) // expected-error {{threadprivate or thread local variable cannot be shared}} + foo(); + #pragma omp target + #pragma omp teams private(i), shared(i) // expected-error {{private variable cannot be shared}} expected-note {{defined as private}} + foo(); + #pragma omp target + #pragma omp teams firstprivate(i), shared(i) // expected-error {{firstprivate variable cannot be shared}} expected-note {{defined as firstprivate}} + foo(); + #pragma omp target + #pragma omp teams private(i) + foo(); + #pragma omp target + #pragma omp teams shared(i) + foo(); + #pragma omp target + #pragma omp teams shared(j) + foo(); + #pragma omp target + #pragma omp teams firstprivate(i) + foo(); + #pragma omp target + #pragma omp teams shared(i) + foo(); + #pragma omp target + #pragma omp teams shared(j) + foo(); + + return 0; +} diff --git a/test/OpenMP/threadprivate_codegen.cpp b/test/OpenMP/threadprivate_codegen.cpp new file mode 100644 index 000000000000..98b7917714b8 --- /dev/null +++ b/test/OpenMP/threadprivate_codegen.cpp @@ -0,0 +1,707 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -DBODY -triple x86_64-unknown-unknown -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -DBODY -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER +// CHECK-DAG: [[IDENT:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-DAG: [[S1:%.+]] = type { [[INT:i[0-9]+]] } +// CHECK-DAG: [[S2:%.+]] = type { [[INT]], double } +// CHECK-DAG: [[S3:%.+]] = type { [[INT]], float } +// CHECK-DAG: [[S4:%.+]] = type { [[INT]], [[INT]] } +// CHECK-DAG: [[S5:%.+]] = type { [[INT]], [[INT]], [[INT]] } +// CHECK-DAG: [[SMAIN:%.+]] = type { [[INT]], double, double } +// CHECK-DEBUG-DAG: [[IDENT:%.+]] = type { i32, i32, i32, i32, i8* } +// CHECK-DEBUG-DAG: [[S1:%.+]] = type { [[INT:i[0-9]+]] } +// CHECK-DEBUG-DAG: [[S2:%.+]] = type { [[INT]], double } +// CHECK-DEBUG-DAG: [[S3:%.+]] = type { [[INT]], float } +// CHECK-DEBUG-DAG: [[S4:%.+]] = type { [[INT]], [[INT]] } +// CHECK-DEBUG-DAG: [[S5:%.+]] = type { [[INT]], [[INT]], [[INT]] } +// CHECK-DEBUG-DAG: [[SMAIN:%.+]] = type { [[INT]], double, double } + +struct S1 { + int a; + S1() + : a(0) { + } + S1(int a) + : a(a) { + } + S1(const S1 &s) { + a = 12 + s.a; + } + ~S1() { + a = 0; + } +}; + +struct S2 { + int a; + double b; + S2() + : a(0) { + } + S2(int a) + : a(a) { + } + S2(const S2 &s) { + a = 12 + s.a; + } + ~S2() { + a = 0; + } +}; + +struct S3 { + int a; + float b; + S3() + : a(0) { + } + S3(int a) + : a(a) { + } + S3(const S3 &s) { + a = 12 + s.a; + } + ~S3() { + a = 0; + } +}; + +struct S4 { + int a, b; + S4() + : a(0) { + } + S4(int a) + : a(a) { + } + S4(const S4 &s) { + a = 12 + s.a; + } + ~S4() { + a = 0; + } +}; + +struct S5 { + int a, b, c; + S5() + : a(0) { + } + S5(int a) + : a(a) { + } + S5(const S5 &s) { + a = 12 + s.a; + } + ~S5() { + a = 0; + } +}; + +// CHECK-DAG: [[GS1:@.+]] = internal global [[S1]] zeroinitializer +// CHECK-DAG: [[GS1]].cache. = common global i8** null +// CHECK-DAG: [[DEFAULT_LOC:@.+]] = private unnamed_addr constant [[IDENT]] { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]+}} x i8]* {{@.+}}, i32 0, i32 0) } +// CHECK-DAG: [[GS2:@.+]] = internal global [[S2]] zeroinitializer +// CHECK-DAG: [[ARR_X:@.+]] = global [2 x [3 x [[S1]]]] zeroinitializer +// CHECK-DAG: [[ARR_X]].cache. = common global i8** null +// CHECK-DAG: [[SM:@.+]] = internal global [[SMAIN]] zeroinitializer +// CHECK-DAG: [[SM]].cache. = common global i8** null +// CHECK-DAG: [[STATIC_S:@.+]] = external global [[S3]] +// CHECK-DAG: [[STATIC_S]].cache. = common global i8** null +// CHECK-DAG: [[GS3:@.+]] = external global [[S5]] +// CHECK-DAG: [[GS3]].cache. = common global i8** null +// CHECK-DAG: [[ST_INT_ST:@.+]] = linkonce_odr global i32 23 +// CHECK-DAG: [[ST_INT_ST]].cache. = common global i8** null +// CHECK-DAG: [[ST_FLOAT_ST:@.+]] = linkonce_odr global float 2.300000e+01 +// CHECK-DAG: [[ST_FLOAT_ST]].cache. = common global i8** null +// CHECK-DAG: [[ST_S4_ST:@.+]] = linkonce_odr global %struct.S4 zeroinitializer +// CHECK-DAG: [[ST_S4_ST]].cache. = common global i8** null +// CHECK-NOT: .cache. = common global i8** null +// There is no cache for gs2 - it is not threadprivate. Check that there is only +// 8 caches created (for Static::s, gs1, gs3, arr_x, main::sm, ST<int>::st, +// ST<float>::st, ST<S4>::st) +// CHECK-DEBUG-DAG: [[GS1:@.+]] = internal global [[S1]] zeroinitializer +// CHECK-DEBUG-DAG: [[GS2:@.+]] = internal global [[S2]] zeroinitializer +// CHECK-DEBUG-DAG: [[ARR_X:@.+]] = global [2 x [3 x [[S1]]]] zeroinitializer +// CHECK-DEBUG-DAG: [[SM:@.+]] = internal global [[SMAIN]] zeroinitializer +// CHECK-DEBUG-DAG: [[STATIC_S:@.+]] = external global [[S3]] +// CHECK-DEBUG-DAG: [[GS3:@.+]] = external global [[S5]] +// CHECK-DEBUG-DAG: [[ST_INT_ST:@.+]] = linkonce_odr global i32 23 +// CHECK-DEBUG-DAG: [[ST_FLOAT_ST:@.+]] = linkonce_odr global float 2.300000e+01 +// CHECK-DEBUG-DAG: [[ST_S4_ST:@.+]] = linkonce_odr global %struct.S4 zeroinitializer +// CHECK-DEBUG-DAG: [[LOC1:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;;162;9;;\00" +// CHECK-DEBUG-DAG: [[LOC2:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;;216;9;;\00" +// CHECK-DEBUG-DAG: [[LOC3:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;;303;19;;\00" +// CHECK-DEBUG-DAG: [[LOC4:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;328;9;;\00" +// CHECK-DEBUG-DAG: [[LOC5:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;341;9;;\00" +// CHECK-DEBUG-DAG: [[LOC6:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;358;10;;\00" +// CHECK-DEBUG-DAG: [[LOC7:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;375;10;;\00" +// CHECK-DEBUG-DAG: [[LOC8:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;401;10;;\00" +// CHECK-DEBUG-DAG: [[LOC9:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;422;10;;\00" +// CHECK-DEBUG-DAG: [[LOC10:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;437;10;;\00" +// CHECK-DEBUG-DAG: [[LOC11:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;454;27;;\00" +// CHECK-DEBUG-DAG: [[LOC12:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;main;471;10;;\00" +// CHECK-DEBUG-DAG: [[LOC13:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;550;9;;\00" +// CHECK-DEBUG-DAG: [[LOC14:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;567;10;;\00" +// CHECK-DEBUG-DAG: [[LOC15:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;593;10;;\00" +// CHECK-DEBUG-DAG: [[LOC16:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;614;10;;\00" +// CHECK-DEBUG-DAG: [[LOC17:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;629;10;;\00" +// CHECK-DEBUG-DAG: [[LOC18:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;646;27;;\00" +// CHECK-DEBUG-DAG: [[LOC19:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;foobar;663;10;;\00" +// CHECK-DEBUG-DAG: [[LOC20:@.*]] = private unnamed_addr constant [{{[0-9]+}} x i8] c";{{.*}}threadprivate_codegen.cpp;;275;9;;\00" + +struct Static { + static S3 s; +#pragma omp threadprivate(s) +}; + +static S1 gs1(5); +#pragma omp threadprivate(gs1) +// CHECK: define {{.*}} [[S1_CTOR:@.*]]([[S1]]* {{.*}}, +// CHECK: define {{.*}} [[S1_DTOR:@.*]]([[S1]]* {{.*}}) +// CHECK: define internal {{.*}}i8* [[GS1_CTOR:@\.__kmpc_global_ctor_\..*]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S1]]* +// CHECK-NEXT: call {{.*}} [[S1_CTOR]]([[S1]]* [[RES]], {{.*}} 5) +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: ret i8* [[ARG]] +// CHECK-NEXT: } +// CHECK: define internal {{.*}}void [[GS1_DTOR:@\.__kmpc_global_dtor_\..*]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S1]]* +// CHECK-NEXT: call {{.*}} [[S1_DTOR]]([[S1]]* [[RES]]) +// CHECK-NEXT: ret void +// CHECK-NEXT: } +// CHECK: define internal {{.*}}void [[GS1_INIT:@\.__omp_threadprivate_init_\..*]]() +// CHECK: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[DEFAULT_LOC]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i8* (i8*)* [[GS1_CTOR]], i8* (i8*, i8*)* null, void (i8*)* [[GS1_DTOR]]) +// CHECK-NEXT: ret void +// CHECK-NEXT: } +// CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC1]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG: @__kmpc_global_thread_num +// CHECK-DEBUG: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[KMPC_LOC_ADDR]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i8* (i8*)* [[GS1_CTOR:@\.__kmpc_global_ctor_\..*]], i8* (i8*, i8*)* null, void (i8*)* [[GS1_DTOR:@\.__kmpc_global_dtor_\..*]]) +// CHECK-DEBUG: define internal {{.*}}i8* [[GS1_CTOR]](i8*) +// CHECK-DEBUG: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK-DEBUG: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-DEBUG: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S1]]* +// CHECK-DEBUG-NEXT: call {{.*}} [[S1_CTOR:@.+]]([[S1]]* [[RES]], {{.*}} 5) +// CHECK-DEBUG: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-DEBUG: ret i8* [[ARG]] +// CHECK-DEBUG-NEXT: } +// CHECK-DEBUG: define {{.*}} [[S1_CTOR]]([[S1]]* {{.*}}, +// CHECK-DEBUG: define internal {{.*}}void [[GS1_DTOR]](i8*) +// CHECK-DEBUG: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK-DEBUG: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-DEBUG: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S1]]* +// CHECK-DEBUG-NEXT: call {{.*}} [[S1_DTOR:@.+]]([[S1]]* [[RES]]) +// CHECK-DEBUG-NEXT: ret void +// CHECK-DEBUG-NEXT: } +// CHECK-DEBUG: define {{.*}} [[S1_DTOR]]([[S1]]* {{.*}}) +static S2 gs2(27); +// CHECK: define {{.*}} [[S2_CTOR:@.*]]([[S2]]* {{.*}}, +// CHECK: define {{.*}} [[S2_DTOR:@.*]]([[S2]]* {{.*}}) +// No another call for S2 constructor because it is not threadprivate +// CHECK-NOT: call {{.*}} [[S2_CTOR]]([[S2]]* +// CHECK-DEBUG: define {{.*}} [[S2_CTOR:@.*]]([[S2]]* {{.*}}, +// CHECK-DEBUG: define {{.*}} [[S2_DTOR:@.*]]([[S2]]* {{.*}}) +// No another call for S2 constructor because it is not threadprivate +// CHECK-DEBUG-NOT: call {{.*}} [[S2_CTOR]]([[S2]]* +S1 arr_x[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; +#pragma omp threadprivate(arr_x) +// CHECK: define internal {{.*}}i8* [[ARR_X_CTOR:@\.__kmpc_global_ctor_\..*]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [2 x [3 x [[S1]]]]* +// CHECK: [[ARR1:%.*]] = getelementptr inbounds [2 x [3 x [[S1]]]]* [[RES]], i{{.*}} 0, i{{.*}} 0 +// CHECK: [[ARR:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR1]], i{{.*}} 0, i{{.*}} 0 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR]], [[INT]] {{.*}}1) +// CHECK: [[ARR_ELEMENT:%.*]] = getelementptr inbounds [[S1]]* [[ARR]], i{{.*}} 1 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR_ELEMENT]], [[INT]] {{.*}}2) +// CHECK: [[ARR_ELEMENT2:%.*]] = getelementptr inbounds [[S1]]* [[ARR_ELEMENT]], i{{.*}} 1 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR_ELEMENT2]], [[INT]] {{.*}}3) +// CHECK: [[ARR_ELEMENT3:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR1]], i{{.*}} 1 +// CHECK: [[ARR_:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR_ELEMENT3]], i{{.*}} 0, i{{.*}} 0 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR_]], [[INT]] {{.*}}4) +// CHECK: [[ARR_ELEMENT:%.*]] = getelementptr inbounds [[S1]]* [[ARR_]], i{{.*}} 1 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR_ELEMENT]], [[INT]] {{.*}}5) +// CHECK: [[ARR_ELEMENT2:%.*]] = getelementptr inbounds [[S1]]* [[ARR_ELEMENT]], i{{.*}} 1 +// CHECK: invoke {{.*}} [[S1_CTOR]]([[S1]]* [[ARR_ELEMENT2]], [[INT]] {{.*}}6) +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: ret i8* [[ARG]] +// CHECK: } +// CHECK: define internal {{.*}}void [[ARR_X_DTOR:@\.__kmpc_global_dtor_\..*]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[ARR_BEGIN:%.*]] = bitcast i8* [[ARG]] to [[S1]]* +// CHECK-NEXT: [[ARR_CUR:%.*]] = getelementptr inbounds [[S1]]* [[ARR_BEGIN]], i{{.*}} 6 +// CHECK-NEXT: br label %[[ARR_LOOP:.*]] +// CHECK: {{.*}}[[ARR_LOOP]]{{.*}} +// CHECK-NEXT: [[ARR_ELEMENTPAST:%.*]] = phi [[S1]]* [ [[ARR_CUR]], {{.*}} ], [ [[ARR_ELEMENT:%.*]], {{.*}} ] +// CHECK-NEXT: [[ARR_ELEMENT:%.*]] = getelementptr inbounds [[S1]]* [[ARR_ELEMENTPAST]], i{{.*}} -1 +// CHECK-NEXT: invoke {{.*}} [[S1_DTOR]]([[S1]]* [[ARR_ELEMENT]]) +// CHECK: [[ARR_DONE:%.*]] = icmp eq [[S1]]* [[ARR_ELEMENT]], [[ARR_BEGIN]] +// CHECK-NEXT: br i1 [[ARR_DONE]], label %[[ARR_EXIT:.*]], label %[[ARR_LOOP]] +// CHECK: {{.*}}[[ARR_EXIT]]{{.*}} +// CHECK-NEXT: ret void +// CHECK: } +// CHECK: define internal {{.*}}void [[ARR_X_INIT:@\.__omp_threadprivate_init_\..*]]() +// CHECK: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[DEFAULT_LOC]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i8* (i8*)* [[ARR_X_CTOR]], i8* (i8*, i8*)* null, void (i8*)* [[ARR_X_DTOR]]) +// CHECK-NEXT: ret void +// CHECK-NEXT: } +// CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC2]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG: @__kmpc_global_thread_num +// CHECK-DEBUG: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[KMPC_LOC_ADDR]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i8* (i8*)* [[ARR_X_CTOR:@\.__kmpc_global_ctor_\..*]], i8* (i8*, i8*)* null, void (i8*)* [[ARR_X_DTOR:@\.__kmpc_global_dtor_\..*]]) +// CHECK-DEBUG: define internal {{.*}}i8* [[ARR_X_CTOR]](i8*) +// CHECK-DEBUG: } +// CHECK-DEBUG: define internal {{.*}}void [[ARR_X_DTOR]](i8*) +// CHECK-DEBUG: } +extern S5 gs3; +#pragma omp threadprivate(gs3) +// No call for S5 constructor because gs3 has just declaration, not a definition. +// CHECK-NOT: call {{.*}}([[S5]]* +// CHECK-DEBUG-NOT: call {{.*}}([[S5]]* + +template <class T> +struct ST { + static T st; +#pragma omp threadprivate(st) +}; + +template <class T> +T ST<T>::st(23); + +// CHECK-LABEL: @main() +// CHECK-DEBUG-LABEL: @main() +int main() { + // CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] + int Res; + struct Smain { + int a; + double b, c; + Smain() + : a(0) { + } + Smain(int a) + : a(a) { + } + Smain(const Smain &s) { + a = 12 + s.a; + } + ~Smain() { + a = 0; + } + }; + + static Smain sm(gs1.a); +// CHECK: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[DEFAULT_LOC]]) +// CHECK: call {{.*}}i{{.*}} @__cxa_guard_acquire +// CHECK: call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[DEFAULT_LOC]]) +// CHECK: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[DEFAULT_LOC]], i8* bitcast ([[SMAIN]]* [[SM]] to i8*), i8* (i8*)* [[SM_CTOR:@\.__kmpc_global_ctor_\..+]], i8* (i8*, i8*)* null, void (i8*)* [[SM_DTOR:@\.__kmpc_global_dtor_\..+]]) +// CHECK: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS1]].cache.) +// CHECK-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* +// CHECK-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 +// CHECK-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] +// CHECK-NEXT: invoke {{.*}} [[SMAIN_CTOR:.*]]([[SMAIN]]* [[SM]], [[INT]] {{.*}}[[GS1_A]]) +// CHECK: call {{.*}}void @__cxa_guard_release +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC3]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG-NEXT: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[KMPC_LOC_ADDR]]) +// CHECK-DEBUG: call {{.*}}i{{.*}} @__cxa_guard_acquire +// CHECK-DEBUG: call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[KMPC_LOC_ADDR]]) +// CHECK-DEBUG: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[KMPC_LOC_ADDR]], i8* bitcast ([[SMAIN]]* [[SM]] to i8*), i8* (i8*)* [[SM_CTOR:@\.__kmpc_global_ctor_\..+]], i8* (i8*, i8*)* null, void (i8*)* [[SM_DTOR:@\.__kmpc_global_dtor_\..+]]) +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC3]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** +// CHECK-DEBUG-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* +// CHECK-DEBUG-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 +// CHECK-DEBUG-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] +// CHECK-DEBUG-NEXT: invoke {{.*}} [[SMAIN_CTOR:.*]]([[SMAIN]]* [[SM]], [[INT]] {{.*}}[[GS1_A]]) +// CHECK-DEBUG: call {{.*}}void @__cxa_guard_release +#pragma omp threadprivate(sm) + // CHECK: [[STATIC_S_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S3]]* [[STATIC_S]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[STATIC_S]].cache.) + // CHECK-NEXT: [[STATIC_S_ADDR:%.*]] = bitcast i8* [[STATIC_S_TEMP_ADDR]] to [[S3]]* + // CHECK-NEXT: [[STATIC_S_A_ADDR:%.*]] = getelementptr inbounds [[S3]]* [[STATIC_S_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[STATIC_S_A:%.*]] = load [[INT]]* [[STATIC_S_A_ADDR]] + // CHECK-NEXT: store [[INT]] [[STATIC_S_A]], [[INT]]* [[RES_ADDR:[^,]+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC5]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[STATIC_S_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S3]]* [[STATIC_S]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[STATIC_S_ADDR:%.*]] = bitcast i8* [[STATIC_S_TEMP_ADDR]] to [[S3]]* + // CHECK-DEBUG-NEXT: [[STATIC_S_A_ADDR:%.*]] = getelementptr inbounds [[S3]]* [[STATIC_S_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[STATIC_S_A:%.*]] = load [[INT]]* [[STATIC_S_A_ADDR]] + // CHECK-DEBUG-NEXT: store [[INT]] [[STATIC_S_A]], [[INT]]* [[RES_ADDR:[^,]+]] + Res = Static::s.a; + // CHECK: [[SM_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[SMAIN]]* [[SM]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[SM]].cache.) + // CHECK-NEXT: [[SM_ADDR:%.*]] = bitcast i8* [[SM_TEMP_ADDR]] to [[SMAIN]]* + // CHECK-NEXT: [[SM_A_ADDR:%.*]] = getelementptr inbounds [[SMAIN]]* [[SM_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[SM_A:%.*]] = load [[INT]]* [[SM_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[SM_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC6]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[SM_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[SMAIN]]* [[SM]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[SM_ADDR:%.*]] = bitcast i8* [[SM_TEMP_ADDR]] to [[SMAIN]]* + // CHECK-DEBUG-NEXT: [[SM_A_ADDR:%.*]] = getelementptr inbounds [[SMAIN]]* [[SM_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[SM_A:%.*]] = load [[INT]]* [[SM_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[SM_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += sm.a; + // CHECK: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS1]].cache.) + // CHECK-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* + // CHECK-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS1_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC7]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* + // CHECK-DEBUG-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS1_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs1.a; + // CHECK: [[GS2_A:%.*]] = load [[INT]]* getelementptr inbounds ([[S2]]* [[GS2]], i{{.*}} 0, i{{.*}} 0) + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS2_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[GS2_A:%.*]] = load [[INT]]* getelementptr inbounds ([[S2]]* [[GS2]], i{{.*}} 0, i{{.*}} 0) + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS2_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs2.a; + // CHECK: [[GS3_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S5]]* [[GS3]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS3]].cache.) + // CHECK-NEXT: [[GS3_ADDR:%.*]] = bitcast i8* [[GS3_TEMP_ADDR]] to [[S5]]* + // CHECK-NEXT: [[GS3_A_ADDR:%.*]] = getelementptr inbounds [[S5]]* [[GS3_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[GS3_A:%.*]] = load [[INT]]* [[GS3_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS3_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC8]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[GS3_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S5]]* [[GS3]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[GS3_ADDR:%.*]] = bitcast i8* [[GS3_TEMP_ADDR]] to [[S5]]* + // CHECK-DEBUG-NEXT: [[GS3_A_ADDR:%.*]] = getelementptr inbounds [[S5]]* [[GS3_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[GS3_A:%.*]] = load [[INT]]* [[GS3_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS3_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs3.a; + // CHECK: [[ARR_X_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ARR_X]].cache.) + // CHECK-NEXT: [[ARR_X_ADDR:%.*]] = bitcast i8* [[ARR_X_TEMP_ADDR]] to [2 x [3 x [[S1]]]]* + // CHECK-NEXT: [[ARR_X_1_ADDR:%.*]] = getelementptr inbounds [2 x [3 x [[S1]]]]* [[ARR_X_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-NEXT: [[ARR_X_1_1_ADDR:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR_X_1_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-NEXT: [[ARR_X_1_1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[ARR_X_1_1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[ARR_X_1_1_A:%.*]] = load [[INT]]* [[ARR_X_1_1_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ARR_X_1_1_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC9]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ARR_X_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ARR_X_ADDR:%.*]] = bitcast i8* [[ARR_X_TEMP_ADDR]] to [2 x [3 x [[S1]]]]* + // CHECK-DEBUG-NEXT: [[ARR_X_1_ADDR:%.*]] = getelementptr inbounds [2 x [3 x [[S1]]]]* [[ARR_X_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_ADDR:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR_X_1_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[ARR_X_1_1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_A:%.*]] = load [[INT]]* [[ARR_X_1_1_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ARR_X_1_1_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += arr_x[1][1].a; + // CHECK: [[ST_INT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[INT]]* [[ST_INT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_INT_ST]].cache.) + // CHECK-NEXT: [[ST_INT_ST_ADDR:%.*]] = bitcast i8* [[ST_INT_ST_TEMP_ADDR]] to [[INT]]* + // CHECK-NEXT: [[ST_INT_ST_VAL:%.*]] = load [[INT]]* [[ST_INT_ST_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_INT_ST_VAL]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC10]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_INT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[INT]]* [[ST_INT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_INT_ST_ADDR:%.*]] = bitcast i8* [[ST_INT_ST_TEMP_ADDR]] to [[INT]]* + // CHECK-DEBUG-NEXT: [[ST_INT_ST_VAL:%.*]] = load [[INT]]* [[ST_INT_ST_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_INT_ST_VAL]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += ST<int>::st; + // CHECK: [[ST_FLOAT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast (float* [[ST_FLOAT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_FLOAT_ST]].cache.) + // CHECK-NEXT: [[ST_FLOAT_ST_ADDR:%.*]] = bitcast i8* [[ST_FLOAT_ST_TEMP_ADDR]] to float* + // CHECK-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float* [[ST_FLOAT_ST_ADDR]] + // CHECK-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float [[ST_FLOAT_ST_VAL]] to [[INT]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[FLOAT_TO_INT_CONV]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC11]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast (float* [[ST_FLOAT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_ADDR:%.*]] = bitcast i8* [[ST_FLOAT_ST_TEMP_ADDR]] to float* + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float* [[ST_FLOAT_ST_ADDR]] + // CHECK-DEBUG-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float [[ST_FLOAT_ST_VAL]] to [[INT]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[FLOAT_TO_INT_CONV]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += static_cast<int>(ST<float>::st); + // CHECK: [[ST_S4_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_S4_ST]].cache.) + // CHECK-NEXT: [[ST_S4_ST_ADDR:%.*]] = bitcast i8* [[ST_S4_ST_TEMP_ADDR]] to [[S4]]* + // CHECK-NEXT: [[ST_S4_ST_A_ADDR:%.*]] = getelementptr inbounds [[S4]]* [[ST_S4_ST_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[ST_S4_ST_A:%.*]] = load [[INT]]* [[ST_S4_ST_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_S4_ST_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC12]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_S4_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_S4_ST_ADDR:%.*]] = bitcast i8* [[ST_S4_ST_TEMP_ADDR]] to [[S4]]* + // CHECK-DEBUG-NEXT: [[ST_S4_ST_A_ADDR:%.*]] = getelementptr inbounds [[S4]]* [[ST_S4_ST_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[ST_S4_ST_A:%.*]] = load [[INT]]* [[ST_S4_ST_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_S4_ST_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += ST<S4>::st.a; + // CHECK: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: ret [[INT]] [[RES]] + // CHECK-DEBUG: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: ret [[INT]] [[RES]] + return Res; +} +// CHECK: } + +// CHECK: define internal {{.*}}i8* [[SM_CTOR]](i8*) +// CHECK: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[DEFAULT_LOC]]) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[SMAIN]]* +// CHECK: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS1]].cache.) +// CHECK-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* +// CHECK-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 +// CHECK-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] +// CHECK-NEXT: call {{.*}} [[SMAIN_CTOR:@.+]]([[SMAIN]]* [[RES]], [[INT]] {{.*}}[[GS1_A]]) +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-NEXT: ret i8* [[ARG]] +// CHECK-NEXT: } +// CHECK: define {{.*}} [[SMAIN_CTOR]]([[SMAIN]]* {{.*}}, +// CHECK: define internal {{.*}}void [[SM_DTOR]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[SMAIN]]* +// CHECK-NEXT: call {{.*}} [[SMAIN_DTOR:@.+]]([[SMAIN]]* [[RES]]) +// CHECK-NEXT: ret void +// CHECK-NEXT: } +// CHECK: define {{.*}} [[SMAIN_DTOR]]([[SMAIN]]* {{.*}}) +// CHECK-DEBUG: define internal {{.*}}i8* [[SM_CTOR]](i8*) +// CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC3]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG-NEXT: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[KMPC_LOC_ADDR]]) +// CHECK-DEBUG: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK-DEBUG: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-DEBUG: [[RES:%.*]] = bitcast i8* [[ARG]] to [[SMAIN]]* +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC3]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** +// CHECK-DEBUG-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* +// CHECK-DEBUG-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 +// CHECK-DEBUG-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] +// CHECK-DEBUG-NEXT: call {{.*}} [[SMAIN_CTOR:@.+]]([[SMAIN]]* [[RES]], [[INT]] {{.*}}[[GS1_A]]) +// CHECK-DEBUG: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-DEBUG-NEXT: ret i8* [[ARG]] +// CHECK-DEBUG-NEXT: } +// CHECK-DEBUG: define {{.*}} [[SMAIN_CTOR]]([[SMAIN]]* {{.*}}, +// CHECK-DEBUG: define internal {{.*}} [[SM_DTOR:@.+]](i8*) +// CHECK-DEBUG: call {{.*}} [[SMAIN_DTOR:@.+]]([[SMAIN]]* +// CHECK-DEBUG: } +// CHECK-DEBUG: define {{.*}} [[SMAIN_DTOR]]([[SMAIN]]* {{.*}}) + +#endif + +#ifdef BODY +// CHECK-LABEL: @{{.*}}foobar{{.*}}() +// CHECK-DEBUG-LABEL: @{{.*}}foobar{{.*}}() +int foobar() { + // CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] + int Res; + // CHECK: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[DEFAULT_LOC]]) + // CHECK: [[STATIC_S_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S3]]* [[STATIC_S]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[STATIC_S]].cache.) + // CHECK-NEXT: [[STATIC_S_ADDR:%.*]] = bitcast i8* [[STATIC_S_TEMP_ADDR]] to [[S3]]* + // CHECK-NEXT: [[STATIC_S_A_ADDR:%.*]] = getelementptr inbounds [[S3]]* [[STATIC_S_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[STATIC_S_A:%.*]] = load [[INT]]* [[STATIC_S_A_ADDR]] + // CHECK-NEXT: store [[INT]] [[STATIC_S_A]], [[INT]]* [[RES_ADDR:[^,]+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC13]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[THREAD_NUM:%.+]] = call {{.*}}i32 @__kmpc_global_thread_num([[IDENT]]* [[KMPC_LOC_ADDR]]) + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC13]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[STATIC_S_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S3]]* [[STATIC_S]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[STATIC_S_ADDR:%.*]] = bitcast i8* [[STATIC_S_TEMP_ADDR]] to [[S3]]* + // CHECK-DEBUG-NEXT: [[STATIC_S_A_ADDR:%.*]] = getelementptr inbounds [[S3]]* [[STATIC_S_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[STATIC_S_A:%.*]] = load [[INT]]* [[STATIC_S_A_ADDR]] + // CHECK-DEBUG-NEXT: store [[INT]] [[STATIC_S_A]], [[INT]]* [[RES_ADDR:[^,]+]] + Res = Static::s.a; + // CHECK: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS1]].cache.) + // CHECK-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* + // CHECK-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS1_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC14]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[GS1_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S1]]* [[GS1]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[GS1_ADDR:%.*]] = bitcast i8* [[GS1_TEMP_ADDR]] to [[S1]]* + // CHECK-DEBUG-NEXT: [[GS1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[GS1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[GS1_A:%.*]] = load [[INT]]* [[GS1_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS1_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs1.a; + // CHECK: [[GS2_A:%.*]] = load [[INT]]* getelementptr inbounds ([[S2]]* [[GS2]], i{{.*}} 0, i{{.*}} 0) + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS2_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[GS2_A:%.*]] = load [[INT]]* getelementptr inbounds ([[S2]]* [[GS2]], i{{.*}} 0, i{{.*}} 0) + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS2_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs2.a; + // CHECK: [[GS3_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S5]]* [[GS3]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[GS3]].cache.) + // CHECK-NEXT: [[GS3_ADDR:%.*]] = bitcast i8* [[GS3_TEMP_ADDR]] to [[S5]]* + // CHECK-NEXT: [[GS3_A_ADDR:%.*]] = getelementptr inbounds [[S5]]* [[GS3_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[GS3_A:%.*]] = load [[INT]]* [[GS3_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS3_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC15]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[GS3_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S5]]* [[GS3]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[GS3_ADDR:%.*]] = bitcast i8* [[GS3_TEMP_ADDR]] to [[S5]]* + // CHECK-DEBUG-NEXT: [[GS3_A_ADDR:%.*]] = getelementptr inbounds [[S5]]* [[GS3_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[GS3_A:%.*]] = load [[INT]]* [[GS3_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[GS3_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += gs3.a; + // CHECK: [[ARR_X_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ARR_X]].cache.) + // CHECK-NEXT: [[ARR_X_ADDR:%.*]] = bitcast i8* [[ARR_X_TEMP_ADDR]] to [2 x [3 x [[S1]]]]* + // CHECK-NEXT: [[ARR_X_1_ADDR:%.*]] = getelementptr inbounds [2 x [3 x [[S1]]]]* [[ARR_X_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-NEXT: [[ARR_X_1_1_ADDR:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR_X_1_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-NEXT: [[ARR_X_1_1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[ARR_X_1_1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[ARR_X_1_1_A:%.*]] = load [[INT]]* [[ARR_X_1_1_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ARR_X_1_1_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC16]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ARR_X_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([2 x [3 x [[S1]]]]* [[ARR_X]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ARR_X_ADDR:%.*]] = bitcast i8* [[ARR_X_TEMP_ADDR]] to [2 x [3 x [[S1]]]]* + // CHECK-DEBUG-NEXT: [[ARR_X_1_ADDR:%.*]] = getelementptr inbounds [2 x [3 x [[S1]]]]* [[ARR_X_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_ADDR:%.*]] = getelementptr inbounds [3 x [[S1]]]* [[ARR_X_1_ADDR]], i{{.*}} 0, i{{.*}} 1 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_A_ADDR:%.*]] = getelementptr inbounds [[S1]]* [[ARR_X_1_1_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[ARR_X_1_1_A:%.*]] = load [[INT]]* [[ARR_X_1_1_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ARR_X_1_1_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += arr_x[1][1].a; + // CHECK: [[ST_INT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[INT]]* [[ST_INT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_INT_ST]].cache.) + // CHECK-NEXT: [[ST_INT_ST_ADDR:%.*]] = bitcast i8* [[ST_INT_ST_TEMP_ADDR]] to [[INT]]* + // CHECK-NEXT: [[ST_INT_ST_VAL:%.*]] = load [[INT]]* [[ST_INT_ST_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_INT_ST_VAL]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC17]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_INT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[INT]]* [[ST_INT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_INT_ST_ADDR:%.*]] = bitcast i8* [[ST_INT_ST_TEMP_ADDR]] to [[INT]]* + // CHECK-DEBUG-NEXT: [[ST_INT_ST_VAL:%.*]] = load [[INT]]* [[ST_INT_ST_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_INT_ST_VAL]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += ST<int>::st; + // CHECK: [[ST_FLOAT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast (float* [[ST_FLOAT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_FLOAT_ST]].cache.) + // CHECK-NEXT: [[ST_FLOAT_ST_ADDR:%.*]] = bitcast i8* [[ST_FLOAT_ST_TEMP_ADDR]] to float* + // CHECK-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float* [[ST_FLOAT_ST_ADDR]] + // CHECK-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float [[ST_FLOAT_ST_VAL]] to [[INT]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[FLOAT_TO_INT_CONV]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC18]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast (float* [[ST_FLOAT_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_ADDR:%.*]] = bitcast i8* [[ST_FLOAT_ST_TEMP_ADDR]] to float* + // CHECK-DEBUG-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float* [[ST_FLOAT_ST_ADDR]] + // CHECK-DEBUG-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float [[ST_FLOAT_ST_VAL]] to [[INT]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[FLOAT_TO_INT_CONV]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += static_cast<int>(ST<float>::st); + // CHECK: [[ST_S4_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[DEFAULT_LOC]], i32 [[THREAD_NUM]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** [[ST_S4_ST]].cache.) + // CHECK-NEXT: [[ST_S4_ST_ADDR:%.*]] = bitcast i8* [[ST_S4_ST_TEMP_ADDR]] to [[S4]]* + // CHECK-NEXT: [[ST_S4_ST_A_ADDR:%.*]] = getelementptr inbounds [[S4]]* [[ST_S4_ST_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-NEXT: [[ST_S4_ST_A:%.*]] = load [[INT]]* [[ST_S4_ST_A_ADDR]] + // CHECK-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_S4_ST_A]] + // CHECK-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + // CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 + // CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC19]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] + // CHECK-DEBUG-NEXT: [[ST_S4_ST_TEMP_ADDR:%.*]] = call {{.*}}i8* @__kmpc_threadprivate_cached([[IDENT]]* [[KMPC_LOC_ADDR]], i32 [[THREAD_NUM]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i{{.*}} {{[0-9]+}}, i8*** + // CHECK-DEBUG-NEXT: [[ST_S4_ST_ADDR:%.*]] = bitcast i8* [[ST_S4_ST_TEMP_ADDR]] to [[S4]]* + // CHECK-DEBUG-NEXT: [[ST_S4_ST_A_ADDR:%.*]] = getelementptr inbounds [[S4]]* [[ST_S4_ST_ADDR]], i{{.*}} 0, i{{.*}} 0 + // CHECK-DEBUG-NEXT: [[ST_S4_ST_A:%.*]] = load [[INT]]* [[ST_S4_ST_A_ADDR]] + // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], [[ST_S4_ST_A]] + // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] + Res += ST<S4>::st.a; + // CHECK: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-NEXT: ret [[INT]] [[RES]] + // CHECK-DEBUG: [[RES:%.*]] = load [[INT]]* [[RES_ADDR]] + // CHECK-DEBUG-NEXT: ret [[INT]] [[RES]] + return Res; +} +#endif + +// CHECK: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[DEFAULT_LOC]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i8* (i8*)* [[ST_S4_ST_CTOR:@\.__kmpc_global_ctor_\..+]], i8* (i8*, i8*)* null, void (i8*)* [[ST_S4_ST_DTOR:@\.__kmpc_global_dtor_\..+]]) +// CHECK: define internal {{.*}}i8* [[ST_S4_ST_CTOR]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S4]]* +// CHECK-NEXT: call {{.*}} [[S4_CTOR:@.+]]([[S4]]* [[RES]], {{.*}} 23) +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK-NEXT: ret i8* [[ARG]] +// CHECK-NEXT: } +// CHECK: define {{.*}} [[S4_CTOR]]([[S4]]* {{.*}}, +// CHECK: define internal {{.*}}void [[ST_S4_ST_DTOR]](i8*) +// CHECK: store i8* %0, i8** [[ARG_ADDR:%.*]], +// CHECK: [[ARG:%.+]] = load i8** [[ARG_ADDR]] +// CHECK: [[RES:%.*]] = bitcast i8* [[ARG]] to [[S4]]* +// CHECK-NEXT: call {{.*}} [[S4_DTOR:@.+]]([[S4]]* [[RES]]) +// CHECK-NEXT: ret void +// CHECK-NEXT: } +// CHECK: define {{.*}} [[S4_DTOR]]([[S4]]* {{.*}}) +// CHECK-DEBUG: [[KMPC_LOC_ADDR:%.*]] = alloca [[IDENT]] +// CHECK-DEBUG: [[KMPC_LOC_ADDR_PSOURCE:%.*]] = getelementptr inbounds [[IDENT]]* [[KMPC_LOC_ADDR]], i{{.*}} 0, i{{.*}} 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.*}} x i8]* [[LOC20]], i{{.*}} 0, i{{.*}} 0), i8** [[KMPC_LOC_ADDR_PSOURCE]] +// CHECK-DEBUG: @__kmpc_global_thread_num +// CHECK-DEBUG: call {{.*}}void @__kmpc_threadprivate_register([[IDENT]]* [[KMPC_LOC_ADDR]], i8* bitcast ([[S4]]* [[ST_S4_ST]] to i8*), i8* (i8*)* [[ST_S4_ST_CTOR:@\.__kmpc_global_ctor_\..+]], i8* (i8*, i8*)* null, void (i8*)* [[ST_S4_ST_DTOR:@\.__kmpc_global_dtor_\..+]]) +// CHECK-DEBUG: define internal {{.*}}i8* [[ST_S4_ST_CTOR]](i8*) +// CHECK-DEBUG: } +// CHECK-DEBUG: define {{.*}} [[S4_CTOR:@.*]]([[S4]]* {{.*}}, +// CHECK-DEBUG: define internal {{.*}}void [[ST_S4_ST_DTOR]](i8*) +// CHECK-DEBUG: } +// CHECK-DEBUG: define {{.*}} [[S4_DTOR:@.*]]([[S4]]* {{.*}}) + +// CHECK: define internal {{.*}}void {{@.*}}() +// CHECK-DAG: call {{.*}}void [[GS1_INIT]]() +// CHECK-DAG: call {{.*}}void [[ARR_X_INIT]]() +// CHECK: ret void +// CHECK-DEBUG: define internal {{.*}}void {{@.*}}() +// CHECK-DEBUG: ret void diff --git a/test/OpenMP/threadprivate_messages.cpp b/test/OpenMP/threadprivate_messages.cpp index 491f30ad041f..27b36fbe024c 100644 --- a/test/OpenMP/threadprivate_messages.cpp +++ b/test/OpenMP/threadprivate_messages.cpp @@ -96,6 +96,9 @@ class TempClass { static __thread int t; // expected-note {{'t' defined here}} #pragma omp threadprivate (t) // expected-error {{variable 't' cannot be threadprivate because it is thread-local}} +register int reg0 __asm__("0"); // expected-note {{'reg0' defined here}} +#pragma omp threadprivate (reg0) // expected-error {{variable 'reg0' cannot be threadprivate because it is a global named register variable}} + int o; // expected-note {{candidate found by name lookup is 'o'}} #pragma omp threadprivate (o) namespace { diff --git a/test/PCH/chain-openmp-threadprivate.cpp b/test/PCH/chain-openmp-threadprivate.cpp new file mode 100644 index 000000000000..5187257b06ed --- /dev/null +++ b/test/PCH/chain-openmp-threadprivate.cpp @@ -0,0 +1,26 @@ +// no PCH +// RUN: %clang_cc1 -fopenmp=libiomp5 -emit-llvm -include %s -include %s %s -o - | FileCheck %s +// with PCH +// RUN: %clang_cc1 -fopenmp=libiomp5 -emit-llvm -chain-include %s -chain-include %s %s -o - | FileCheck %s +#if !defined(PASS1) +#define PASS1 + +extern "C" int* malloc (int size); +int *a = malloc(20); + +#elif !defined(PASS2) +#define PASS2 + +#pragma omp threadprivate(a) + +#else + +// CHECK: call {{.*}} @__kmpc_threadprivate_register( + +// CHECK-LABEL: foo +int foo() { + return *a; + // CHECK: call {{.*}} @__kmpc_global_thread_num( + // CHECK: call {{.*}} @__kmpc_threadprivate_cached( +} +#endif diff --git a/test/PCH/cxx-namespaces.cpp b/test/PCH/cxx-namespaces.cpp index e0feaab6910a..d1bf98b4ca17 100644 --- a/test/PCH/cxx-namespaces.cpp +++ b/test/PCH/cxx-namespaces.cpp @@ -4,12 +4,12 @@ // Test with pch. // RUN: %clang_cc1 -x c++-header -emit-pch -o %t %S/cxx-namespaces.h // RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify %s -// RUN: %clang_cc1 -include-pch %t -fsyntax-only -ast-dump -ast-dump-lookups -ast-dump-filter N %s | FileCheck %s +// RUN: %clang_cc1 -include-pch %t -fsyntax-only -ast-dump-lookups -ast-dump-filter N %s | FileCheck %s // Test with modules. // RUN: %clang_cc1 -fmodules -x c++-header -emit-pch -o %t %S/cxx-namespaces.h // RUN: %clang_cc1 -fmodules -include-pch %t -fsyntax-only -verify %s -// RUN: %clang_cc1 -fmodules -include-pch %t -fsyntax-only -ast-dump -ast-dump-lookups -ast-dump-filter N %s | FileCheck %s +// RUN: %clang_cc1 -fmodules -include-pch %t -fsyntax-only -ast-dump-lookups -ast-dump-filter N %s | FileCheck %s // expected-no-diagnostics diff --git a/test/PCH/cxx-traits.cpp b/test/PCH/cxx-traits.cpp index ffdfccc6f47f..fc3e1335dd60 100644 --- a/test/PCH/cxx-traits.cpp +++ b/test/PCH/cxx-traits.cpp @@ -1,15 +1,66 @@ // Test this without pch. -// RUN: %clang_cc1 -include %S/cxx-traits.h -std=c++11 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fms-extensions -include %S/cxx-traits.h -std=c++11 -fsyntax-only -verify %s -// RUN: %clang_cc1 -x c++-header -std=c++11 -emit-pch -o %t %S/cxx-traits.h -// RUN: %clang_cc1 -std=c++11 -include-pch %t -DPCH -fsyntax-only -verify %s +// RUN: %clang_cc1 -fms-extensions -x c++-header -std=c++11 -emit-pch -o %t %S/cxx-traits.h +// RUN: %clang_cc1 -fms-extensions -std=c++11 -include-pch %t -DPCH -fsyntax-only -verify %s #ifdef PCH // expected-no-diagnostics #endif -bool _Is_pod_comparator = __is_pod<int>::__value; -bool _Is_empty_check = __is_empty<int>::__value; +bool _Is_pod_comparator = n::__is_pod<int>::__value; +bool _Is_empty_check = n::__is_empty<int>::__value; -bool default_construct_int = is_trivially_constructible<int>::value; -bool copy_construct_int = is_trivially_constructible<int, const int&>::value; +bool default_construct_int = n::is_trivially_constructible<int>::value; +bool copy_construct_int = n::is_trivially_constructible<int, const int&>::value; + +// The built-ins should still work too: +bool _is_abstract_result = __is_abstract(int); +bool _is_arithmetic_result = __is_arithmetic(int); +bool _is_array_result = __is_array(int); +bool _is_base_of_result = __is_base_of(int, int); +bool _is_class_result = __is_class(int); +bool _is_complete_type_result = __is_complete_type(int); +bool _is_compound_result = __is_compound(int); +bool _is_const_result = __is_const(int); +bool _is_constructible_result = __is_constructible(int); +bool _is_convertible_result = __is_convertible(int, int); +bool _is_convertible_to_result = __is_convertible_to(int, int); +bool _is_destructible_result = __is_destructible(int); +bool _is_empty_result = __is_empty(int); +bool _is_enum_result = __is_enum(int); +bool _is_floating_point_result = __is_floating_point(int); +bool _is_final_result = __is_final(int); +bool _is_function_result = __is_function(int); +bool _is_fundamental_result = __is_fundamental(int); +bool _is_integral_result = __is_integral(int); +bool _is_interface_class_result = __is_interface_class(int); +bool _is_literal_result = __is_literal(int); +bool _is_lvalue_expr_result = __is_lvalue_expr(0); +bool _is_lvalue_reference_result = __is_lvalue_reference(int); +bool _is_member_function_pointer_result = __is_member_function_pointer(int); +bool _is_member_object_pointer_result = __is_member_object_pointer(int); +bool _is_member_pointer_result = __is_member_pointer(int); +bool _is_nothrow_assignable_result = __is_nothrow_assignable(int, int); +bool _is_nothrow_constructible_result = __is_nothrow_constructible(int); +bool _is_nothrow_destructible_result = __is_nothrow_destructible(int); +bool _is_object_result = __is_object(int); +bool _is_pod_result = __is_pod(int); +bool _is_pointer_result = __is_pointer(int); +bool _is_polymorphic_result = __is_polymorphic(int); +bool _is_reference_result = __is_reference(int); +bool _is_rvalue_expr_result = __is_rvalue_expr(0); +bool _is_rvalue_reference_result = __is_rvalue_reference(int); +bool _is_same_result = __is_same(int, int); +bool _is_scalar_result = __is_scalar(int); +bool _is_sealed_result = __is_sealed(int); +bool _is_signed_result = __is_signed(int); +bool _is_standard_layout_result = __is_standard_layout(int); +bool _is_trivial_result = __is_trivial(int); +bool _is_trivially_assignable_result = __is_trivially_assignable(int, int); +bool _is_trivially_constructible_result = __is_trivially_constructible(int); +bool _is_trivially_copyable_result = __is_trivially_copyable(int); +bool _is_union_result = __is_union(int); +bool _is_unsigned_result = __is_unsigned(int); +bool _is_void_result = __is_void(int); +bool _is_volatile_result = __is_volatile(int); diff --git a/test/PCH/cxx-traits.h b/test/PCH/cxx-traits.h index e6f2feb1d116..21324768186e 100644 --- a/test/PCH/cxx-traits.h +++ b/test/PCH/cxx-traits.h @@ -1,5 +1,7 @@ // Header for PCH test cxx-traits.cpp +namespace n { + template<typename _Tp> struct __is_pod { // expected-warning {{keyword '__is_pod' will be made available as an identifier for the remainder of the translation unit}} enum { __value }; @@ -14,3 +16,54 @@ template<typename T, typename ...Args> struct is_trivially_constructible { static const bool value = __is_trivially_constructible(T, Args...); }; + +struct __is_abstract {}; // expected-warning {{made available}} +struct __is_arithmetic {}; // expected-warning {{made available}} +struct __is_array {}; // expected-warning {{made available}} +struct __is_base_of {}; // expected-warning {{made available}} +struct __is_class {}; // expected-warning {{made available}} +struct __is_complete_type {}; // expected-warning {{made available}} +struct __is_compound {}; // expected-warning {{made available}} +struct __is_const {}; // expected-warning {{made available}} +struct __is_constructible {}; // expected-warning {{made available}} +struct __is_convertible {}; // expected-warning {{made available}} +struct __is_convertible_to {}; // expected-warning {{made available}} +struct __is_destructible {}; // expected-warning {{made available}} +struct __is_enum {}; // expected-warning {{made available}} +struct __is_floating_point {}; // expected-warning {{made available}} +struct __is_final {}; // expected-warning {{made available}} +struct __is_function {}; // expected-warning {{made available}} +struct __is_fundamental {}; // expected-warning {{made available}} +struct __is_integral {}; // expected-warning {{made available}} +struct __is_interface_class {}; // expected-warning {{made available}} +struct __is_literal {}; // expected-warning {{made available}} +struct __is_lvalue_expr {}; // expected-warning {{made available}} +struct __is_lvalue_reference {}; // expected-warning {{made available}} +struct __is_member_function_pointer {}; // expected-warning {{made available}} +struct __is_member_object_pointer {}; // expected-warning {{made available}} +struct __is_member_pointer {}; // expected-warning {{made available}} +struct __is_nothrow_assignable {}; // expected-warning {{made available}} +struct __is_nothrow_constructible {}; // expected-warning {{made available}} +struct __is_nothrow_destructible {}; // expected-warning {{made available}} +struct __is_object {}; // expected-warning {{made available}} +struct __is_pointer {}; // expected-warning {{made available}} +struct __is_polymorphic {}; // expected-warning {{made available}} +struct __is_reference {}; // expected-warning {{made available}} +struct __is_rvalue_expr {}; // expected-warning {{made available}} +struct __is_rvalue_reference {}; // expected-warning {{made available}} +struct __is_same {}; // expected-warning {{made available}} +struct __is_scalar {}; // expected-warning {{made available}} +struct __is_sealed {}; // expected-warning {{made available}} +struct __is_signed {}; // expected-warning {{made available}} +struct __is_standard_layout {}; // expected-warning {{made available}} +struct __is_trivial {}; // expected-warning {{made available}} +struct __is_trivially_assignable {}; // expected-warning {{made available}} +struct __is_trivially_constructible {}; // expected-warning {{made available}} +struct __is_trivially_copyable {}; // expected-warning {{made available}} +struct __is_union {}; // expected-warning {{made available}} +struct __is_unsigned {}; // expected-warning {{made available}} +struct __is_void {}; // expected-warning {{made available}} +struct __is_volatile {}; // expected-warning {{made available}} + + +} diff --git a/test/PCH/cxx1y-lambdas.mm b/test/PCH/cxx1y-lambdas.mm index ee4a2ba3ecc9..becf6cb64222 100644 --- a/test/PCH/cxx1y-lambdas.mm +++ b/test/PCH/cxx1y-lambdas.mm @@ -50,7 +50,7 @@ int add(int x, int y) { }
// CHECK-PRINT: inline int add_int_slowly_twice
-// CHECK-PRINT: lambda = [] ($auto-0-0 z
+// CHECK-PRINT: lambda = [] (type-parameter-0-0 z
// CHECK-PRINT: init_capture
// CHECK-PRINT: [&, x( t )]
diff --git a/test/PCH/pragma-loop.cpp b/test/PCH/pragma-loop.cpp index 1456a2778f33..2640020f0007 100644 --- a/test/PCH/pragma-loop.cpp +++ b/test/PCH/pragma-loop.cpp @@ -10,11 +10,14 @@ // CHECK: #pragma clang loop unroll(disable) // CHECK: #pragma clang loop interleave(disable) // CHECK: #pragma clang loop vectorize(enable) -// CHECK: #pragma clang loop unroll(enable) +// CHECK: #pragma clang loop unroll(full) // CHECK: #pragma clang loop interleave(enable) // CHECK: #pragma clang loop vectorize(disable) // CHECK: #pragma unroll // CHECK: #pragma unroll (32) +// CHECK: #pragma nounroll +// CHECK: #pragma clang loop interleave_count(I) +// CHECK: #pragma clang loop vectorize_width(V) #ifndef HEADER #define HEADER @@ -47,7 +50,7 @@ public: int i = 0; #pragma clang loop vectorize(disable) #pragma clang loop interleave(enable) -#pragma clang loop unroll(enable) +#pragma clang loop unroll(full) while (i - 3 < Length) { List[i] = i; i++; @@ -71,8 +74,25 @@ public: i++; } } -}; + inline void run6(int *List, int Length) { + int i = 0; +#pragma nounroll + while (i - 3 < Length) { + List[i] = i; + i++; + } + } + + template <int V, int I> + inline void run7(int *List, int Length) { +#pragma clang loop vectorize_width(V) +#pragma clang loop interleave_count(I) + for (int i = 0; i < Length; i++) { + List[i] = i; + } + } +}; #else void test() { @@ -85,6 +105,8 @@ void test() { pt.run3(List, 100); pt.run4(List, 100); pt.run5(List, 100); + pt.run6(List, 100); + pt.run7<2, 4>(List, 100); } #endif diff --git a/test/PCH/pragma-optimize.c b/test/PCH/pragma-optimize.c index 2206fe75cd82..9570117448e2 100644 --- a/test/PCH/pragma-optimize.c +++ b/test/PCH/pragma-optimize.c @@ -5,6 +5,12 @@ // RUN: %clang_cc1 %s -emit-pch -o %t // RUN: %clang_cc1 %s -emit-llvm -include-pch %t -o - | FileCheck %s +// The first run line creates a pch, and since at that point HEADER is not +// defined, the only thing contained in the pch is the pragma. The second line +// then includes that pch, so HEADER is defined and the actual code is compiled. +// The check then makes sure that the pragma is in effect in the file that +// includes the pch. + // expected-no-diagnostics #ifndef HEADER diff --git a/test/PCH/stmt-attrs.cpp b/test/PCH/stmt-attrs.cpp index 3d7c7a27a7e2..170e34975e62 100644 --- a/test/PCH/stmt-attrs.cpp +++ b/test/PCH/stmt-attrs.cpp @@ -1,24 +1,24 @@ -// RUN: %clang_cc1 -std=c++11 -emit-pch -o %t.a %s
-// RUN: %clang_cc1 -std=c++11 -include-pch %t.a %s -ast-print -o - | FileCheck %s
-
-#ifndef HEADER
-#define HEADER
-
-inline void test(int i) {
- switch (i) {
- case 1:
- // Notice that the NullStmt has two attributes.
- // CHECK: {{\[\[clang::fallthrough\]\] \[\[clang::fallthrough\]\]}}
- [[clang::fallthrough]] [[clang::fallthrough]];
- case 2:
- break;
- }
-}
-
-#else
-
-void foo(void) {
- test(1);
-}
-
-#endif
+// RUN: %clang_cc1 -std=c++11 -emit-pch -o %t.a %s +// RUN: %clang_cc1 -std=c++11 -include-pch %t.a %s -ast-print -o - | FileCheck %s + +#ifndef HEADER +#define HEADER + +inline void test(int i) { + switch (i) { + case 1: + // Notice that the NullStmt has two attributes. + // CHECK: {{\[\[clang::fallthrough\]\] \[\[clang::fallthrough\]\]}} + [[clang::fallthrough]] [[clang::fallthrough]]; + case 2: + break; + } +} + +#else + +void foo(void) { + test(1); +} + +#endif diff --git a/test/PCH/verify_pch.m b/test/PCH/verify_pch.m index dcfb286e2a11..e905f2537c7f 100644 --- a/test/PCH/verify_pch.m +++ b/test/PCH/verify_pch.m @@ -5,25 +5,25 @@ // RUN: cp %s %t.h // // Precompile -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -x objective-c-header -emit-pch -o %t.pch %t.h +// RUN: %clang_cc1 -isystem %t/usr/include -x objective-c-header -emit-pch -o %t.pch %t.h // Verify successfully -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -verify-pch %t.pch +// RUN: %clang_cc1 -isystem %t/usr/include -verify-pch %t.pch // Incompatible lang options ignored -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -x objective-c -fno-builtin -verify-pch %t.pch +// RUN: %clang_cc1 -isystem %t/usr/include -x objective-c -fno-builtin -verify-pch %t.pch // Stale dependency // RUN: echo ' ' >> %t.h -// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -verify-pch %t.pch 2> %t.log.2 +// RUN: not %clang_cc1 -isystem %t/usr/include -verify-pch %t.pch 2> %t.log.2 // RUN: FileCheck -check-prefix=CHECK-STALE-DEP %s < %t.log.2 // CHECK-STALE-DEP: file '{{.*}}.h' has been modified since the precompiled header '{{.*}}.pch' was built // Stale dependency in system header -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -x objective-c-header -emit-pch -o %t.pch %t.h -// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -verify-pch %t.pch +// RUN: %clang_cc1 -isystem %t/usr/include -x objective-c-header -emit-pch -o %t.pch %t.h +// RUN: %clang_cc1 -isystem %t/usr/include -verify-pch %t.pch // RUN: echo ' ' >> %t/usr/include/sys_header.h -// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -isysroot %t -verify-pch %t.pch 2> %t.log.3 +// RUN: not %clang_cc1 -isystem %t/usr/include -verify-pch %t.pch 2> %t.log.3 // RUN: FileCheck -check-prefix=CHECK-STALE-SYS-H %s < %t.log.3 // CHECK-STALE-SYS-H: file '{{.*}}sys_header.h' has been modified since the precompiled header '{{.*}}.pch' was built diff --git a/test/Parser/MicrosoftExtensions.c b/test/Parser/MicrosoftExtensions.c index d7ea20bca01c..ea25ccd1af33 100644 --- a/test/Parser/MicrosoftExtensions.c +++ b/test/Parser/MicrosoftExtensions.c @@ -85,3 +85,11 @@ int * __uptr __ptr64 pup64; /* Legal to have nested pointer attributes */ int * __sptr * __ptr32 ppsp32; + +// Ignored type qualifiers after comma in declarator lists +typedef int ignored_quals_dummy1, const volatile __ptr32 __ptr64 __w64 __unaligned __sptr __uptr ignored_quals1; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy2)(), __fastcall ignored_quals2; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy3)(), __stdcall ignored_quals3; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy4)(), __thiscall ignored_quals4; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy5)(), __cdecl ignored_quals5; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy6)(), __vectorcall ignored_quals6; // expected-warning {{qualifiers after comma in declarator list are ignored}} diff --git a/test/Parser/MicrosoftExtensions.cpp b/test/Parser/MicrosoftExtensions.cpp index 0174ec2f292d..73a1bb57af36 100644 --- a/test/Parser/MicrosoftExtensions.cpp +++ b/test/Parser/MicrosoftExtensions.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple i386-mingw32 -std=c++11 -fsyntax-only -Wno-unused-value -Wmicrosoft -verify -fms-extensions -fms-compatibility -fdelayed-template-parsing +// RUN: %clang_cc1 %s -triple i386-mingw32 -std=c++11 -fsyntax-only -Wno-unused-getter-return-value -Wno-unused-value -Wmicrosoft -verify -fms-extensions -fms-compatibility -fdelayed-template-parsing /* Microsoft attribute tests */ [repeatable][source_annotation_attribute( Parameter|ReturnValue )] @@ -208,12 +208,12 @@ extern TypenameWrongPlace<AAAA> PR16925; __interface MicrosoftInterface; __interface MicrosoftInterface { - void foo1() = 0; + void foo1() = 0; // expected-note {{overridden virtual function is here}} virtual void foo2() = 0; }; __interface MicrosoftDerivedInterface : public MicrosoftInterface { - void foo1(); + void foo1(); // expected-warning {{'foo1' overrides a member function but is not marked 'override'}} void foo2() override; void foo3(); }; @@ -226,6 +226,11 @@ void interface_test() { } __int64 x7 = __int64(0); +_int64 x8 = _int64(0); +static_assert(sizeof(_int64) == 8, ""); +static_assert(sizeof(_int32) == 4, ""); +static_assert(sizeof(_int16) == 2, ""); +static_assert(sizeof(_int8) == 1, ""); int __identifier(generic) = 3; int __identifier(int) = 4; @@ -315,6 +320,7 @@ struct StructWithProperty { __declspec(property(get=GetV,)) int V10; // expected-error {{expected 'get' or 'put' in property declaration}} __declspec(property(get=GetV,put=SetV)) int V11; // no-warning __declspec(property(get=GetV,put=SetV,get=GetV)) int V12; // expected-error {{property declaration specifies 'get' accessor twice}} + __declspec(property(get=GetV)) int V13 = 3; // expected-error {{property declaration cannot have an in-class initializer}} int GetV() { return 123; } void SetV(int v) {} @@ -361,3 +367,11 @@ void foo(void) { template <int *> struct NullptrArg {}; NullptrArg<nullptr> a; + +// Ignored type qualifiers after comma in declarator lists +typedef int ignored_quals_dummy1, const volatile __ptr32 __ptr64 __w64 __unaligned __sptr __uptr ignored_quals1; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy2)(), __fastcall ignored_quals2; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy3)(), __stdcall ignored_quals3; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy4)(), __thiscall ignored_quals4; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy5)(), __cdecl ignored_quals5; // expected-warning {{qualifiers after comma in declarator list are ignored}} +typedef void(*ignored_quals_dummy6)(), __vectorcall ignored_quals6; // expected-warning {{qualifiers after comma in declarator list are ignored}} diff --git a/test/Parser/PR21872.cpp b/test/Parser/PR21872.cpp new file mode 100644 index 000000000000..ae0a13d9c1ea --- /dev/null +++ b/test/Parser/PR21872.cpp @@ -0,0 +1,4 @@ +// RUN: not %clang_cc1 -fsyntax-only %s +template <typename T> struct S { + int k = (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( +int f; diff --git a/test/Parser/access-spec-attrs.cpp b/test/Parser/access-spec-attrs.cpp index 4fa597581165..2958e385f8b5 100644 --- a/test/Parser/access-spec-attrs.cpp +++ b/test/Parser/access-spec-attrs.cpp @@ -5,6 +5,7 @@ public __attribute__((unavailable)): // expected-error {{access specifier can on void foo(); private __attribute__((annotate("foobar"))): void bar(); +private __attribute__((annotate())): // expected-error {{'annotate' attribute takes one argument}} }; void f(X x) { diff --git a/test/Parser/altivec.c b/test/Parser/altivec.c index 0b8147a3b7b0..d852511fc06d 100644 --- a/test/Parser/altivec.c +++ b/test/Parser/altivec.c @@ -18,6 +18,9 @@ __vector float vv_f; __vector bool char vv_bc; __vector bool short vv_bs; __vector bool int vv_bi; +__vector __bool char vv___bc; +__vector __bool short vv___bs; +__vector __bool int vv_bi; __vector __pixel vv_p; __vector pixel vv__p; __vector int vf__r(); @@ -40,6 +43,9 @@ vector float v_f; vector bool char v_bc; vector bool short v_bs; vector bool int v_bi; +vector __bool char v___bc; +vector __bool short v___bs; +vector __bool int v___bi; vector __pixel v_p; vector pixel v__p; vector int f__r(); @@ -61,15 +67,16 @@ vector unsigned long v_ul; // expected-warning {{Use of 'long' with '__ vector long int v_li; // expected-warning {{Use of 'long' with '__vector' is deprecated}} vector signed long int v_sli; // expected-warning {{Use of 'long' with '__vector' is deprecated}} vector unsigned long int v_uli; // expected-warning {{Use of 'long' with '__vector' is deprecated}} -__vector long double vv_ld; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} -vector long double v_ld; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} +__vector long double vv_ld; // expected-error {{cannot use 'long double' with '__vector'}} +vector long double v_ld; // expected-error {{cannot use 'long double' with '__vector'}} vector bool v_b; // expected-warning {{type specifier missing, defaults to 'int'}} +vector __bool v___b; // expected-warning {{type specifier missing, defaults to 'int'}} // These should have errors. -__vector double vv_d1; // expected-error {{cannot use 'double' with '__vector'}} -vector double v_d2; // expected-error {{cannot use 'double' with '__vector'}} -__vector long double vv_ld3; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} -vector long double v_ld4; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} +__vector double vv_d1; // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on the POWER7 or later)}} +vector double v_d2; // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on the POWER7 or later)}} +__vector long double vv_ld3; // expected-error {{cannot use 'long double' with '__vector'}} +vector long double v_ld4; // expected-error {{cannot use 'long double' with '__vector'}} vector bool float v_bf; // expected-error {{cannot use 'float' with '__vector bool'}} vector bool double v_bd; // expected-error {{cannot use 'double' with '__vector bool'}} vector bool pixel v_bp; // expected-error {{cannot use '__pixel' with '__vector bool'}} @@ -77,6 +84,18 @@ vector bool signed char v_bsc; // expected-error {{cannot use 'signed' wit vector bool unsigned int v_bsc2; // expected-error {{cannot use 'unsigned' with '__vector bool'}} vector bool long v_bl; // expected-error {{cannot use 'long' with '__vector bool'}} vector bool long long v_bll; // expected-error {{cannot use 'long long' with '__vector bool'}} +vector __bool float v___bf; // expected-error {{cannot use 'float' with '__vector bool'}} +vector __bool double v___bd; // expected-error {{cannot use 'double' with '__vector bool'}} +vector __bool pixel v___bp; // expected-error {{cannot use '__pixel' with '__vector bool'}} +vector __bool signed char v___bsc; // expected-error {{cannot use 'signed' with '__vector bool'}} +vector __bool unsigned int v___bsc2; // expected-error {{cannot use 'unsigned' with '__vector bool'}} +vector __bool long v___bl; // expected-error {{cannot use 'long' with '__vector bool'}} +vector __bool long long v___bll; // expected-error {{cannot use 'long long' with '__vector bool'}} + +// vector long is deprecated, but vector long long is not. +vector long long v_ll; +vector signed long long v_sll; +vector unsigned long long v_ull; typedef char i8; typedef short i16; diff --git a/test/Parser/asm.cpp b/test/Parser/asm.cpp index 35a497c83a1e..9f64dfea476e 100644 --- a/test/Parser/asm.cpp +++ b/test/Parser/asm.cpp @@ -6,3 +6,4 @@ int foo3 asm (u8"bar3"); // expected-error {{cannot use unicode string literal i int foo4 asm (u"bar4"); // expected-error {{cannot use unicode string literal in 'asm'}} int foo5 asm (U"bar5"); // expected-error {{cannot use unicode string literal in 'asm'}} int foo6 asm ("bar6"_x); // expected-error {{string literal with user-defined suffix cannot be used here}} +int foo6 asm ("" L"bar7"); // expected-error {{cannot use wide string literal in 'asm'}} diff --git a/test/Parser/atomic.c b/test/Parser/atomic.c index 432deeb59c12..07a83dddcd3c 100644 --- a/test/Parser/atomic.c +++ b/test/Parser/atomic.c @@ -33,3 +33,6 @@ typedef _Atomic(int) __attribute__((address_space(1))) atomic_addr_space_int; typedef _Atomic int __attribute__((vector_size(16))) atomic_vector_int; typedef _Atomic(int __attribute__((vector_size(16)))) atomic_vector_int; + +struct S +_Atomic atomic_s_no_missing_semicolon; diff --git a/test/Parser/attributes.c b/test/Parser/attributes.c index 3d69c72c322c..b815b8da3dc6 100644 --- a/test/Parser/attributes.c +++ b/test/Parser/attributes.c @@ -95,3 +95,13 @@ void testFundef5() __attribute__(()) { } __attribute__((pure)) int testFundef6(int a) { return a; } void deprecatedTestFun(void) __attribute__((deprecated())); + +struct s { + int a; +}; + +// This test ensure compatibility with parsing GNU-style attributes +// where the attribute is on a separate line from the elaborated type +// specifier. +struct s +__attribute__((used)) bar; diff --git a/test/Parser/c11-noreturn.c b/test/Parser/c11-noreturn.c index e61901dfb791..9b932abeaff2 100644 --- a/test/Parser/c11-noreturn.c +++ b/test/Parser/c11-noreturn.c @@ -1,10 +1,10 @@ // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify %s -// RUN: not %clang_cc1 -pedantic -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-EXT %s +// RUN: not %clang_cc1 -std=c99 -pedantic -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-EXT %s _Noreturn int f(); int _Noreturn f(); // expected-note {{previous}} int f _Noreturn(); // expected-error {{expected ';'}} expected-error 2{{}} -int f() _Noreturn; // expected-error {{expected ';'}} expected-warning {{does not declare anything}} expected-error {{'_Noreturn' can only appear on functions}} +int f() _Noreturn; // expected-error {{'_Noreturn' keyword must precede function declarator}} _Noreturn char c1; // expected-error {{'_Noreturn' can only appear on functions}} char _Noreturn c2; // expected-error {{'_Noreturn' can only appear on functions}} diff --git a/test/Parser/c1x-alignas.c b/test/Parser/c1x-alignas.c index 5b29df262d3c..ce8436c12fbb 100644 --- a/test/Parser/c1x-alignas.c +++ b/test/Parser/c1x-alignas.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify %s -// RUN: not %clang_cc1 -pedantic -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-EXT %s +// RUN: not %clang_cc1 -std=c99 -pedantic -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-EXT %s _Alignas(4) char c1; unsigned _Alignas(long) char c2; diff --git a/test/Parser/colon-colon-parentheses.cpp b/test/Parser/colon-colon-parentheses.cpp index 55948fdb0051..e031ce2e9045 100644 --- a/test/Parser/colon-colon-parentheses.cpp +++ b/test/Parser/colon-colon-parentheses.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify +// RUN: %clang_cc1 %s -fsyntax-only -verify -DPR21815 // RUN: cp %s %t // RUN: not %clang_cc1 -x c++ -fixit %t // RUN: %clang_cc1 -x c++ %t @@ -20,3 +20,11 @@ void foo() { a = ::(h; // expected-error{{unexpected parenthesis after '::'}} a = ::i; } + +#ifdef PR21815 +// expected-error@+4{{C++ requires a type specifier for all declarations}} +// expected-error@+3{{expected unqualified-id}} +// expected-error@+3{{expected expression}} +// expected-error@+1{{expected ';' after top level declarator}} +a (::( +#endif diff --git a/test/Parser/cxx-altivec.cpp b/test/Parser/cxx-altivec.cpp index 565decc601f8..f2ba28b641a6 100644 --- a/test/Parser/cxx-altivec.cpp +++ b/test/Parser/cxx-altivec.cpp @@ -61,14 +61,14 @@ vector unsigned long v_ul; // expected-warning {{Use of 'long' with '__ vector long int v_li; // expected-warning {{Use of 'long' with '__vector' is deprecated}} vector signed long int v_sli; // expected-warning {{Use of 'long' with '__vector' is deprecated}} vector unsigned long int v_uli; // expected-warning {{Use of 'long' with '__vector' is deprecated}} -__vector long double vv_ld; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} -vector long double v_ld; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} +__vector long double vv_ld; // expected-error {{cannot use 'long double' with '__vector'}} +vector long double v_ld; // expected-error {{cannot use 'long double' with '__vector'}} // These should have errors. -__vector double vv_d1; // expected-error {{cannot use 'double' with '__vector'}} -vector double v_d2; // expected-error {{cannot use 'double' with '__vector'}} -__vector long double vv_ld3; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} -vector long double v_ld4; // expected-warning {{Use of 'long' with '__vector' is deprecated}} expected-error {{cannot use 'double' with '__vector'}} +__vector double vv_d1; // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on the POWER7 or later)}} +vector double v_d2; // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on the POWER7 or later)}} +__vector long double vv_ld3; // expected-error {{cannot use 'long double' with '__vector'}} +vector long double v_ld4; // expected-error {{cannot use 'long double' with '__vector'}} vector bool v_b; // expected-error {{C++ requires a type specifier for all declarations}} vector bool float v_bf; // expected-error {{cannot use 'float' with '__vector bool'}} vector bool double v_bd; // expected-error {{cannot use 'double' with '__vector bool'}} @@ -78,6 +78,11 @@ vector bool unsigned int v_bsc2; // expected-error {{cannot use 'unsigned' vector bool long v_bl; // expected-error {{cannot use 'long' with '__vector bool'}} vector bool long long v_bll; // expected-error {{cannot use 'long long' with '__vector bool'}} +// vector long is deprecated, but vector long long is not. +vector long long v_ll; +vector signed long long v_sll; +vector unsigned long long v_ull; + void f() { __vector unsigned int v = {0,0,0,0}; __vector int v__cast = (__vector int)v; diff --git a/test/Parser/cxx-ambig-init-templ.cpp b/test/Parser/cxx-ambig-init-templ.cpp index ac79f77e152d..1f692664137c 100644 --- a/test/Parser/cxx-ambig-init-templ.cpp +++ b/test/Parser/cxx-ambig-init-templ.cpp @@ -169,3 +169,9 @@ namespace ElaboratedTypeSpecifiers { enum E {}; }; } + +namespace PR20459 { + template <typename EncTraits> struct A { + void foo(int = EncTraits::template TypeEnc<int, int>::val); // ok + }; +} diff --git a/test/Parser/cxx-attributes.cpp b/test/Parser/cxx-attributes.cpp index 6fd7f4f68a46..6591532a91a2 100644 --- a/test/Parser/cxx-attributes.cpp +++ b/test/Parser/cxx-attributes.cpp @@ -20,3 +20,5 @@ namespace PR17666 { typedef int __attribute__((aligned(int(1)))) T1; typedef int __attribute__((aligned(int))) T2; // expected-error {{expected '(' for function-style cast}} } + +__attribute((typename)) int x; // expected-warning {{unknown attribute 'typename' ignored}} diff --git a/test/Parser/cxx-class.cpp b/test/Parser/cxx-class.cpp index 80cd8288011d..0e9a3b9d54d3 100644 --- a/test/Parser/cxx-class.cpp +++ b/test/Parser/cxx-class.cpp @@ -139,6 +139,54 @@ namespace CtorErrors { }; } +namespace DtorErrors { + struct A { ~A(); } a; + ~A::A() {} // expected-error {{'~' in destructor name should be after nested name specifier}} expected-note {{previous}} + A::~A() {} // expected-error {{redefinition}} + + struct B { ~B(); } *b; + DtorErrors::~B::B() {} // expected-error {{'~' in destructor name should be after nested name specifier}} + + void f() { + a.~A::A(); // expected-error {{'~' in destructor name should be after nested name specifier}} + b->~DtorErrors::~B::B(); // expected-error {{'~' in destructor name should be after nested name specifier}} + } +} + +namespace BadFriend { + struct A { + friend int : 3; // expected-error {{friends can only be classes or functions}} + friend void f() = 123; // expected-error {{illegal initializer}} + friend virtual void f(); // expected-error {{'virtual' is invalid in friend declarations}} + friend void f() final; // expected-error {{'final' is invalid in friend declarations}} + friend void f() override; // expected-error {{'override' is invalid in friend declarations}} + }; +} + +class PR20760_a { + int a = ); // expected-warning {{extension}} expected-error {{expected expression}} + int b = }; // expected-warning {{extension}} expected-error {{expected expression}} + int c = ]; // expected-warning {{extension}} expected-error {{expected expression}} +}; +class PR20760_b { + int d = d); // expected-warning {{extension}} expected-error {{expected ';'}} + int e = d]; // expected-warning {{extension}} expected-error {{expected ';'}} + int f = d // expected-warning {{extension}} expected-error {{expected ';'}} +}; + +namespace PR20887 { +class X1 { a::operator=; }; // expected-error {{undeclared identifier 'a'}} +class X2 { a::a; }; // expected-error {{undeclared identifier 'a'}} +} + +class BadExceptionSpec { + void f() throw(int; // expected-error {{expected ')'}} expected-note {{to match}} + void g() throw( // expected-note {{to match}} + int( // expected-note {{to match}} + ; // expected-error 2{{expected ')'}} expected-error {{unexpected end of exception specification}} + )); +}; + // PR11109 must appear at the end of the source file class pr11109r3 { // expected-note{{to match this '{'}} public // expected-error{{expected ':'}} expected-error{{expected '}'}} expected-error{{expected ';' after class}} diff --git a/test/Parser/cxx-default-args.cpp b/test/Parser/cxx-default-args.cpp index 36abf0d8cb38..0095a2f04dc4 100644 --- a/test/Parser/cxx-default-args.cpp +++ b/test/Parser/cxx-default-args.cpp @@ -31,3 +31,13 @@ struct T { void f7(bool a = T1<int, bool>::V < 3); void f8(int = func<0,1<2>(0), int = 1<0, T1<int,int>(int) = 0); }; + +// rdar://18508589 +struct S { + void f(int &r = error); // expected-error {{use of undeclared identifier 'error'}} +}; + +struct U { + void i(int x = ) {} // expected-error{{expected expression}} + typedef int *fp(int x = ); // expected-error{{default arguments can only be specified for parameters in a function declaration}} +}; diff --git a/test/Parser/cxx-member-initializers.cpp b/test/Parser/cxx-member-initializers.cpp index ff8c880a1849..8e52adbbfd33 100644 --- a/test/Parser/cxx-member-initializers.cpp +++ b/test/Parser/cxx-member-initializers.cpp @@ -66,12 +66,12 @@ namespace PR16480 { struct T { int n; }; template<typename> struct A { int n; }; - }; // expected-error +{{}} + }; // FIXME: This is valid now, but may be made ill-formed by DR1607. struct G : X<0> { G() : X<0 && [](){return 0;}()>{} // expected-error +{{}} - }; // expected-error +{{}} + }; struct Errs : X<0> { Errs(X<0>) : decltype X<0>() {} // expected-error {{expected '(' after 'decltype'}} @@ -79,3 +79,29 @@ namespace PR16480 { Errs(X<2>) : decltype(X<0> // expected-note {{to match this '('}} }; // expected-error {{expected ')'}} } + +template <class U, class V> struct C { + int f() { return 4; } + class C1 {}; +}; + +class D {}; +namespace N { +struct E { + class F {}; +}; +} + +class G { + // These are all valid: + void f(int x = C<int, D>().f()) {} + void g(int x = C<int, ::D>().f()) {} + void h(int x = C<int, N::E>().f()) {} + void i(int x = C<int, ::N::E>().f()) {} + void j(int x = C<int, decltype(N::E())::F>().f()) {} + void k(int x = C<int, C<int, int>>().f()) {} + void l(int x = C<int, C<int, int>::C1>().f()) {} + + // This isn't, but it shouldn't crash. The diagnostics don't matter much. + void m(int x = C<int, union int>().f()) {} // expected-error {{declaration of anonymous union must be a definition}} expected-error {{expected a type}} +}; diff --git a/test/Parser/cxx-template-argument.cpp b/test/Parser/cxx-template-argument.cpp index bbd53b2bdd69..c9cc6b807902 100644 --- a/test/Parser/cxx-template-argument.cpp +++ b/test/Parser/cxx-template-argument.cpp @@ -106,3 +106,8 @@ namespace pr16225add { { }; } + +namespace PR18793 { + template<typename T, T> struct S {}; + template<typename T> int g(S<T, (T())> *); +} diff --git a/test/Parser/cxx-template-decl.cpp b/test/Parser/cxx-template-decl.cpp index 8b2b12037b3c..efa42ad30d04 100644 --- a/test/Parser/cxx-template-decl.cpp +++ b/test/Parser/cxx-template-decl.cpp @@ -210,3 +210,31 @@ void Instantiate() { } } + +namespace func_tmpl_spec_def_in_func { +// We failed to diagnose function template specialization definitions inside +// functions during recovery previously. +template <class> void FuncTemplate() {} +void TopLevelFunc() { + // expected-error@+2 {{expected a qualified name after 'typename'}} + // expected-error@+1 {{function definition is not allowed here}} + typename template <> void FuncTemplate<void>() { } + // expected-error@+1 {{function definition is not allowed here}} + void NonTemplateInner() { } +} +} + +namespace broken_baseclause { +template<typename T> +struct base { }; + +struct t1 : base<int, + public: // expected-error {{expected expression}} +}; // expected-error {{expected class name}} +// expected-error@-1 {{expected '{' after base class list}} +struct t2 : base<int, + public // expected-error {{expected expression}} +}; // expected-error {{expected class name}} +// expected-error@-1 {{expected '{' after base class list}} + +} diff --git a/test/Parser/cxx-variadic-func.cpp b/test/Parser/cxx-variadic-func.cpp index b9360d6ed10a..98a34d3e1bf6 100644 --- a/test/Parser/cxx-variadic-func.cpp +++ b/test/Parser/cxx-variadic-func.cpp @@ -1,5 +1,8 @@ -// RUN: %clang_cc1 -fsyntax-only %s +// RUN: %clang_cc1 -fsyntax-only -verify %s void f(...) { - int g(int(...)); + // FIXME: There's no disambiguation here; this is unambiguous. + int g(int(...)); // expected-warning {{disambiguated}} expected-note {{paren}} } + +void h(int n..., int m); // expected-error {{expected ')'}} expected-note {{to match}} diff --git a/test/Parser/cxx0x-attributes.cpp b/test/Parser/cxx0x-attributes.cpp index f8abc76fb2f3..c68a119fc740 100644 --- a/test/Parser/cxx0x-attributes.cpp +++ b/test/Parser/cxx0x-attributes.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat %s // Need std::initializer_list namespace std { @@ -86,6 +86,10 @@ class [[]] [[]] final_class_another [[]] [[]] alignas(16) final // expected-error {{an attribute list cannot appear here}} [[]] [[]] alignas(16) [[]]{}; // expected-error {{an attribute list cannot appear here}} +// The diagnostics here don't matter much, this just shouldn't crash: +class C final [[deprecated(l]] {}); // expected-error {{use of undeclared identifier}} expected-error {{expected ']'}} expected-error {{an attribute list cannot appear here}} expected-error {{expected unqualified-id}} +class D final alignas ([l) {}]{}); // expected-error {{expected ',' or ']' in lambda capture list}} expected-error {{an attribute list cannot appear here}} + [[]] struct with_init_declarators {} init_declarator; [[]] struct no_init_declarators; // expected-error {{an attribute list cannot appear here}} template<typename> [[]] struct no_init_declarators_template; // expected-error {{an attribute list cannot appear here}} @@ -121,6 +125,7 @@ extern "C++" [[]] { } // expected-error {{an attribute list cannot appear here}} [[]] using ns::i; // expected-error {{an attribute list cannot appear here}} [[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}} [[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}} +namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are incompatible with C++ standards before C++1z}} using [[]] alignas(4) [[]] ns::i; // expected-error {{an attribute list cannot appear here}} using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}} @@ -172,7 +177,7 @@ enum [[]] E2; // expected-error {{forbids forward references}} enum [[]] E1; enum [[]] E3 : int; enum [[]] { - k_123 [[]] = 123 // expected-error {{an attribute list cannot appear here}} + k_123 [[]] = 123 // expected-warning {{attributes on an enumerator declaration are incompatible with C++ standards before C++1z}} }; enum [[]] E1 e; // expected-error {{an attribute list cannot appear here}} enum [[]] class E4 { }; // expected-error {{an attribute list cannot appear here}} @@ -329,3 +334,10 @@ namespace { [[deprecated()]] void foo(); // expected-error {{parentheses must be omitted if 'deprecated' attribute's argument list is empty}} [[gnu::deprecated()]] void quux(); } + +namespace { +[[ // expected-error {{expected ']'}} +#pragma pack(pop) +deprecated +]] void bad(); +} diff --git a/test/Parser/cxx0x-decl.cpp b/test/Parser/cxx0x-decl.cpp index a0334cdde292..994104fc9dfb 100644 --- a/test/Parser/cxx0x-decl.cpp +++ b/test/Parser/cxx0x-decl.cpp @@ -116,9 +116,19 @@ namespace DuplicateSpecifier { }; } +namespace ColonColonDecltype { + struct S { struct T {}; }; + ::decltype(S())::T invalid; // expected-error {{expected unqualified-id}} +} + struct Base { virtual void f() = 0; virtual void g() = 0; virtual void h() = 0; }; struct MemberComponentOrder : Base { void f() override __asm__("foobar") __attribute__(( )) {} void g() __attribute__(( )) override; void h() __attribute__(( )) override {} }; + +void NoMissingSemicolonHere(struct S + [3]); +template<int ...N> void NoMissingSemicolonHereEither(struct S + ... [N]); diff --git a/test/Parser/cxx0x-in-cxx98.cpp b/test/Parser/cxx0x-in-cxx98.cpp index 724993811631..10cb4d2fa53a 100644 --- a/test/Parser/cxx0x-in-cxx98.cpp +++ b/test/Parser/cxx0x-in-cxx98.cpp @@ -28,3 +28,7 @@ struct Auto { auto Auto::n = 0; // expected-warning {{'auto' type specifier is a C++11 extension}} auto Auto::m = 0; // expected-error {{no member named 'm' in 'Auto'}} // expected-warning@-1 {{'auto' type specifier is a C++11 extension}} + +struct Conv { template<typename T> operator T(); }; +bool pr21367_a = new int && false; +bool pr21367_b = &Conv::operator int && false; diff --git a/test/Parser/cxx0x-lambda-expressions.cpp b/test/Parser/cxx0x-lambda-expressions.cpp index 8cfe7f3b02da..6f69d8096e22 100644 --- a/test/Parser/cxx0x-lambda-expressions.cpp +++ b/test/Parser/cxx0x-lambda-expressions.cpp @@ -91,3 +91,20 @@ class C { __attribute__((noreturn)) { while(1); }; // expected-error {{expected body of lambda expression}} } }; + +template <typename> +void PR22122() { + [](int) -> {}; // expected-error {{expected a type}} +} + +template void PR22122<int>(); + +struct S { + template <typename T> + void m (T x =[0); // expected-error{{expected variable name or 'this' in lambda capture list}} +} s; + +struct U { + template <typename T> + void m_fn1(T x = 0[0); // expected-error{{expected ']'}} expected-note{{to match this '['}} +} *U; diff --git a/test/Parser/cxx11-templates.cpp b/test/Parser/cxx11-templates.cpp new file mode 100644 index 000000000000..ed0495281c17 --- /dev/null +++ b/test/Parser/cxx11-templates.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct S { + template <typename Ty = char> + static_assert(sizeof(Ty) != 1, "Not a char"); // expected-error {{a static_assert declaration cannot be a template}} +}; + +template <typename Ty = char> +static_assert(sizeof(Ty) != 1, "Not a char"); // expected-error {{a static_assert declaration cannot be a template}} + +namespace Ellipsis { + template<typename ...T> void f(T t..., int n); // expected-error {{must immediately precede declared identifier}} + template<typename ...T> void f(int n, T t...); // expected-error {{must immediately precede declared identifier}} + template<typename ...T> void f(int n, T t, ...); // expected-error {{unexpanded parameter pack}} + template<typename ...T> void f() { + f([]{ + void g(T + t // expected-note {{place '...' immediately before declared identifier to declare a function parameter pack}} + ... // expected-warning {{'...' in this location creates a C-style varargs function, not a function parameter pack}} + // expected-note@-1 {{insert ',' before '...' to silence this warning}} + ); + void h(T (& + ) // expected-note {{place '...' here to declare a function parameter pack}} + ... // expected-warning {{'...' in this location creates a C-style varargs function, not a function parameter pack}} + // expected-note@-1 {{insert ',' before '...' to silence this warning}} + ); + void i(T (&), ...); + }...); + } + template<typename ...T> struct S { + void f(T t...); // expected-error {{must immediately precede declared identifier}} + void f(T ... // expected-note {{preceding '...' declares a function parameter pack}} + t...); // expected-warning-re {{'...' in this location creates a C-style varargs function{{$}}}} + // expected-note@-1 {{insert ',' before '...' to silence this warning}} + }; + + // FIXME: We should just issue a single error in this case pointing out where + // the '...' goes. It's tricky to recover correctly in this case, though, + // because the parameter is in scope in the default argument, so must be + // passed to Sema before we reach the ellipsis. + template<typename...T> void f(T n = 1 ...); + // expected-warning@-1 {{creates a C-style varargs}} + // expected-note@-2 {{place '...' immediately before declared identifier}} + // expected-note@-3 {{insert ','}} + // expected-error@-4 {{unexpanded parameter pack}} +} diff --git a/test/Parser/cxx1z-attributes.cpp b/test/Parser/cxx1z-attributes.cpp new file mode 100644 index 000000000000..1267091ab253 --- /dev/null +++ b/test/Parser/cxx1z-attributes.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s + +namespace [[]] foo {} +namespace [[]] {} +namespace [[]] bad = foo; // expected-error {{attributes cannot be specified on namespace alias}} + +namespace [[]] A::B {} // expected-error {{attributes cannot be specified on a nested namespace definition}} + +enum test { + bing [[]], + bar [[]] = 1, + baz [[]][[]], + quux [[]][[]] = 4 +}; diff --git a/test/Parser/cxx1z-fold-expressions.cpp b/test/Parser/cxx1z-fold-expressions.cpp new file mode 100644 index 000000000000..a908311ea316 --- /dev/null +++ b/test/Parser/cxx1z-fold-expressions.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -std=c++1z -verify %s + +template<typename ...T> constexpr auto sum(T ...t) { return (... + t); } +template<typename ...T> constexpr auto product(T ...t) { return (t * ...); } +template<typename ...T> constexpr auto all(T ...t) { return (true && ... && t); } +template<typename ...T> constexpr auto all2(T ...t) { return (t && ... && true); } + +int k1 = (1 + ... + 2); // expected-error {{does not contain any unexpanded parameter packs}} +int k2 = (1 + ...); // expected-error {{does not contain any unexpanded parameter packs}} +int k3 = (... + 2); // expected-error {{does not contain any unexpanded parameter packs}} + +template<int ...N> void bad1() { (N + ... + N); } // expected-error {{unexpanded parameter packs in both operands}} +// FIXME: it would be reasonable to support this as an extension. +template<int ...N> void bad2() { (2 * N + ... + 1); } // expected-error {{expression not permitted as operand}} +template<int ...N> void bad3() { (2 + N * ... * 1); } // expected-error {{expression not permitted as operand}} +template<int ...N, int ...M> void bad4(int (&...x)[N]) { (N + M * ... * 1); } // expected-error {{expression not permitted as operand}} +template<int ...N, int ...M> void fixed4(int (&...x)[N]) { ((N + M) * ... * 1); } + +// Parens are mandatory. +template<int ...N> void bad5() { N + ...; } // expected-error {{expected expression}} expected-error +{{}} +template<int ...N> void bad6() { ... + N; } // expected-error {{expected expression}} +template<int ...N> void bad7() { N + ... + N; } // expected-error {{expected expression}} expected-error +{{}} + +// Must have a fold-operator in the relevant places. +template<int ...N> int bad8() { return (N + ... * 3); } // expected-error {{operators in fold expression must be the same}} +template<int ...N> int bad9() { return (3 + ... * N); } // expected-error {{operators in fold expression must be the same}} +template<int ...N> int bad10() { return (3 ? ... : N); } // expected-error +{{}} expected-note {{to match}} +template<int ...N> int bad11() { return (N + ... 0); } // expected-error {{expected a foldable binary operator}} expected-error {{expected expression}} +template<int ...N> int bad12() { return (... N); } // expected-error {{expected expression}} diff --git a/test/Parser/cxx1z-nested-namespace-definition.cpp b/test/Parser/cxx1z-nested-namespace-definition.cpp new file mode 100644 index 000000000000..96f34c540acc --- /dev/null +++ b/test/Parser/cxx1z-nested-namespace-definition.cpp @@ -0,0 +1,38 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: not %clang_cc1 -x c++ -fixit %t -Werror -DFIXIT +// RUN: %clang_cc1 -x c++ %t -DFIXIT +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1z -Wc++14-compat + +namespace foo1::foo2::foo3 { +#if __cplusplus <= 201400L +// expected-warning@-2 {{nested namespace definition is a C++1z extension; define each namespace separately}} +#else +// expected-warning@-4 {{nested namespace definition is incompatible with C++ standards before C++1z}} +#endif + int foo(int x) { return x; } +} + +#ifndef FIXIT +inline namespace goo::bar { // expected-error {{nested namespace definition cannot be 'inline'}} expected-warning 0-1{{C++11 feature}} + int n; +} + +int m = goo::bar::n; +#endif + +int foo(int x) { + return foo1::foo2::foo3::foo(x); +} + +namespace bar1 { + namespace bar2 { + namespace bar3 { + int bar(int x) { return x; } + } + } +} + +int bar(int x) { + return bar1::bar2::bar3::bar(x); +} diff --git a/test/Parser/debugger-import-module.m b/test/Parser/debugger-import-module.m new file mode 100644 index 000000000000..b6001aed6a89 --- /dev/null +++ b/test/Parser/debugger-import-module.m @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -fdebugger-support -verify %s +// expected-no-diagnostics + +void importAModule() { + @import AModuleThatDoesntExist +} diff --git a/test/Parser/declarators.c b/test/Parser/declarators.c index 39d9dc94490d..48936d592269 100644 --- a/test/Parser/declarators.c +++ b/test/Parser/declarators.c @@ -7,6 +7,7 @@ void f1(int [*]); void f2(int [const *]); void f3(int [volatile const*]); int f4(*XX)(void); /* expected-error {{cannot return}} expected-warning {{type specifier missing, defaults to 'int'}} */ +int f5(int [static]); /* expected-error {{'static' may not be used without an array size}} */ char ((((*X)))); @@ -112,6 +113,7 @@ enum E1 { e1 }: // expected-error {{expected ';'}} struct EnumBitfield { // expected-warning {{struct without named members is a GNU extension}} enum E2 { e2 } : 4; // ok struct S { int n; }: // expected-error {{expected ';'}} + // expected-warning@-1 {{declaration does not declare anything}} }; @@ -148,3 +150,5 @@ enum E16 { A6; // expected-error{{expected '= constant-expression' or end of enumerator definition}} A6a }; + +int PR20634 = sizeof(struct { int n; } [5]); diff --git a/test/Parser/eof2.cpp b/test/Parser/eof2.cpp new file mode 100644 index 000000000000..6a8b862e6099 --- /dev/null +++ b/test/Parser/eof2.cpp @@ -0,0 +1,15 @@ +// RUN: not %clang_cc1 %s -fsyntax-only 2>&1 | FileCheck %s + +// CHECK: error: expected expression +// CHECK: error: expected member name or ';' after declaration specifiers +// CHECK: error: expected '}' +// CHECK: note: to match this '{' +// CHECK: error: expected ';' after class +// CHECK: 4 errors generated. + +// Do not add anything to the end of this file. This requires the whitespace +// plus EOF after the '<' token. + +template <typename T> +class a { + a< diff --git a/test/Parser/ms-if-exists.c b/test/Parser/ms-if-exists.c new file mode 100644 index 000000000000..7dd20544a6b4 --- /dev/null +++ b/test/Parser/ms-if-exists.c @@ -0,0 +1,87 @@ +// RUN: %clang_cc1 %s -fsyntax-only -Wmicrosoft -verify -fms-extensions +// expected-no-diagnostics + +struct Type { +}; + +void test_if_exists_stmts() { + int b = 0; + __if_exists(Type) { + b++; + b++; + } + __if_exists(Type_not) { + this will not compile. + } + __if_not_exists(Type) { + this will not compile. + } + __if_not_exists(Type_not) { + b++; + b++; + } +} + +int if_exists_creates_no_scope() { + __if_exists(Type) { + int x; // 'x' is declared in the parent scope. + } + __if_not_exists(Type_not) { + x++; + } + return x; +} + +__if_exists(Type) { + int var23; +} + +__if_exists(Type_not) { + this will not compile. +} + +__if_not_exists(Type) { + this will not compile. +} + +__if_not_exists(Type_not) { + int var244; +} + +void test_if_exists_init_list() { + + int array1[] = { + 0, + __if_exists(Type) {2, } + 3 + }; + + int array2[] = { + 0, + __if_exists(Type_not) { this will not compile } + 3 + }; + + int array3[] = { + 0, + __if_not_exists(Type_not) {2, } + 3 + }; + + int array4[] = { + 0, + __if_not_exists(Type) { this will not compile } + 3 + }; + +} + + +void test_nested_if_exists() { + __if_exists(Type) { + int x = 42; + __if_not_exists(Type_not) { + x++; + } + } +} diff --git a/test/Parser/ms-inline-asm.c b/test/Parser/ms-inline-asm.c index 00508f5cf098..72c96c3715d9 100644 --- a/test/Parser/ms-inline-asm.c +++ b/test/Parser/ms-inline-asm.c @@ -48,6 +48,9 @@ void t10() { void t11() { do { __asm mov eax, 0 __asm { __asm mov edx, 1 } } while(0); } +void t12() { + __asm jmp label // expected-error {{use of undeclared label 'label'}} +} int t_fail() { // expected-note {{to match this}} __asm - __asm { // expected-error 3 {{expected}} expected-note {{to match this}} + __asm { // expected-error 2 {{expected}} expected-note {{to match this}} diff --git a/test/Parser/namespaces.cpp b/test/Parser/namespaces.cpp index 6491cfd446b3..25ff73b8ec01 100644 --- a/test/Parser/namespaces.cpp +++ b/test/Parser/namespaces.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s // PR6596 namespace g { enum { o = 0 }; } @@ -10,3 +10,7 @@ void foo() { // PR14085 namespace PR14085 {} namespace = PR14085; // expected-error {{expected identifier}} + +struct namespace_nested_in_record { + int k = ({namespace {}}); // expected-error {{statement expression not allowed at file scope}} +}; diff --git a/test/Parser/nested-namespaces-recovery.cpp b/test/Parser/nested-namespaces-recovery.cpp deleted file mode 100644 index d45938bb3e67..000000000000 --- a/test/Parser/nested-namespaces-recovery.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// RUN: cp %s %t -// RUN: %clang_cc1 -fsyntax-only -verify %s -// RUN: not %clang_cc1 -x c++ -fixit %t -// RUN: %clang_cc1 -x c++ %t - -namespace foo1::foo2::foo3 { // expected-error {{nested namespace definition must define each namespace separately}} - int foo(int x) { return x; } -} - -int foo(int x) { - return foo1::foo2::foo3::foo(x); -} - -namespace bar1 { - namespace bar2 { - namespace bar3 { - int bar(int x) { return x; } - } - } -} - -int bar(int x) { - return bar1::bar2::bar3::bar(x); -} diff --git a/test/Parser/opencl-cl20.cl b/test/Parser/opencl-cl20.cl new file mode 100644 index 000000000000..b71869919ba9 --- /dev/null +++ b/test/Parser/opencl-cl20.cl @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DCL20 + +#ifdef CL20 +// expected-no-diagnostics +#endif + +__generic int * __generic_test(__generic int *arg) { + __generic int *var; + return var; +} +#ifndef CL20 +// expected-error@-5 {{OpenCL does not support the '__generic' type qualifier}} +// expected-error@-6 {{OpenCL does not support the '__generic' type qualifier}} +// expected-error@-6 {{OpenCL does not support the '__generic' type qualifier}} +#endif + +generic int * generic_test(generic int *arg) { + generic int *var; + return var; +} +#ifndef CL20 +// expected-error@-5 {{OpenCL does not support the 'generic' type qualifier}} +// expected-error@-6 {{OpenCL does not support the 'generic' type qualifier}} +// expected-error@-6 {{OpenCL does not support the 'generic' type qualifier}} +#endif diff --git a/test/Parser/pragma-loop.cpp b/test/Parser/pragma-loop.cpp index 23f185d52284..547d87395ef5 100644 --- a/test/Parser/pragma-loop.cpp +++ b/test/Parser/pragma-loop.cpp @@ -3,12 +3,85 @@ // Note that this puts the expected lines before the directives to work around // limitations in the -verify mode. +template <int V, int I> +void test_nontype_template_param(int *List, int Length) { +#pragma clang loop vectorize_width(V) interleave_count(I) + for (int i = 0; i < Length; i++) { + List[i] = i; + } + +#pragma clang loop vectorize_width(V + 4) interleave_count(I + 4) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +template <int V> +void test_nontype_template_vectorize(int *List, int Length) { + /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop vectorize_width(V) + for (int i = 0; i < Length; i++) { + List[i] = i; + } + + /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop vectorize_width(V / 2) + for (int i = 0; i < Length; i++) { + List[i] += i; + } +} + +template <int I> +void test_nontype_template_interleave(int *List, int Length) { + /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop interleave_count(I) + for (int i = 0; i < Length; i++) { + List[i] = i; + } + + /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(2 % I) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +template <char V> +void test_nontype_template_char(int *List, int Length) { + /* expected-error {{invalid argument of type 'char'; expected an integer type}} */ #pragma clang loop vectorize_width(V) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +template <bool V> +void test_nontype_template_bool(int *List, int Length) { + /* expected-error {{invalid argument of type 'bool'; expected an integer type}} */ #pragma clang loop vectorize_width(V) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +template <int V, int I> +void test_nontype_template_badarg(int *List, int Length) { + /* expected-error {{use of undeclared identifier 'Vec'}} */ #pragma clang loop vectorize_width(Vec) interleave_count(I) + /* expected-error {{use of undeclared identifier 'Int'}} */ #pragma clang loop vectorize_width(V) interleave_count(Int) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + +template <typename T> +void test_type_template_vectorize(int *List, int Length) { + const T Value = -1; + /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop vectorize_width(Value) + for (int i = 0; i < Length; i++) { + List[i] = i; + } +} + void test(int *List, int Length) { int i = 0; #pragma clang loop vectorize(enable) #pragma clang loop interleave(enable) -#pragma clang loop unroll(enable) +#pragma clang loop unroll(full) while (i + 1 < Length) { List[i] = i; } @@ -43,68 +116,89 @@ void test(int *List, int Length) { VList[j] = List[j]; } + test_nontype_template_param<4, 8>(List, Length); + /* expected-error {{expected '('}} */ #pragma clang loop vectorize /* expected-error {{expected '('}} */ #pragma clang loop interleave /* expected-error {{expected '('}} */ #pragma clang loop unroll /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(enable /* expected-error {{expected ')'}} */ #pragma clang loop interleave(enable -/* expected-error {{expected ')'}} */ #pragma clang loop unroll(enable +/* expected-error {{expected ')'}} */ #pragma clang loop unroll(full /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(4 /* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4 /* expected-error {{expected ')'}} */ #pragma clang loop unroll_count(4 -/* expected-error {{missing argument to '#pragma clang loop vectorize'; expected a positive integer value}} */ #pragma clang loop vectorize() -/* expected-error {{missing argument to '#pragma clang loop interleave_count'; expected a positive integer value}} */ #pragma clang loop interleave_count() -/* expected-error {{missing argument to '#pragma clang loop unroll'; expected a positive integer value}} */ #pragma clang loop unroll() +/* expected-error {{missing argument; expected 'enable' or 'disable'}} */ #pragma clang loop vectorize() +/* expected-error {{missing argument; expected an integer value}} */ #pragma clang loop interleave_count() +/* expected-error {{missing argument; expected 'enable' or 'disable'}} */ #pragma clang loop unroll() -/* expected-error {{missing option}} */ #pragma clang loop +/* expected-error {{missing option; expected vectorize, vectorize_width, interleave, interleave_count, unroll, or unroll_count}} */ #pragma clang loop /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword(enable) /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop vectorize(enable) badkeyword(4) /* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize(enable) , - while (i-4 < Length) { List[i] = i; } -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop vectorize_width(0) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop interleave_count(0) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop unroll_count(0) +/* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop vectorize_width(0) +/* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(0) +/* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop unroll_count(0) + +/* expected-error {{expression is not an integral constant expression}} expected-note {{division by zero}} */ #pragma clang loop vectorize_width(10 / 0) +/* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(10 / 5 - 2) while (i-5 < Length) { List[i] = i; } -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop vectorize_width(3000000000) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop interleave_count(3000000000) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop unroll_count(3000000000) +test_nontype_template_vectorize<4>(List, Length); +/* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_vectorize<-1>(List, Length); +test_nontype_template_interleave<8>(List, Length); +/* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_interleave<-1>(List, Length); + +/* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_char<'A'>(List, Length); // Loop hint arg cannot be a char. +/* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_bool<true>(List, Length); // Or a bool. +/* expected-note {{in instantiation of function template specialization}} */ test_type_template_vectorize<int>(List, Length); // Or a template type. + +/* expected-error {{value '3000000000' is too large}} */ #pragma clang loop vectorize_width(3000000000) +/* expected-error {{value '3000000000' is too large}} */ #pragma clang loop interleave_count(3000000000) +/* expected-error {{value '3000000000' is too large}} */ #pragma clang loop unroll_count(3000000000) while (i-6 < Length) { List[i] = i; } -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop vectorize_width(badvalue) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop interleave_count(badvalue) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop unroll_count(badvalue) +/* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize_width(1 +) 1 +/* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize_width(1) +1 +const int VV = 4; +/* expected-error {{expected expression}} */ #pragma clang loop vectorize_width(VV +/ 2) +/* expected-error {{use of undeclared identifier 'undefined'}} */ #pragma clang loop vectorize_width(VV+undefined) +/* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(1+(^*/2 * () +/* expected-warning {{extra tokens at end of '#pragma clang loop' - ignored}} */ #pragma clang loop vectorize_width(1+(-0[0])))))) + +/* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop vectorize_width(badvalue) +/* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop interleave_count(badvalue) +/* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop unroll_count(badvalue) while (i-6 < Length) { List[i] = i; } /* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop vectorize(badidentifier) /* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop interleave(badidentifier) -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop unroll(badidentifier) +/* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(badidentifier) while (i-7 < Length) { List[i] = i; } // PR20069 - Loop pragma arguments that are not identifiers or numeric // constants crash FE. -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop vectorize(() +/* expected-error {{expected ')'}} */ #pragma clang loop vectorize(() /* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop interleave(*) -/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop unroll(=) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop vectorize_width(^) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop interleave_count(/) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma clang loop unroll_count(==) +/* expected-error {{invalid argument; expected 'full' or 'disable'}} */ #pragma clang loop unroll(=) +/* expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}} */ #pragma clang loop vectorize_width(^) +/* expected-error {{expected expression}} expected-error {{expected expression}} */ #pragma clang loop interleave_count(/) +/* expected-error {{expected expression}} expected-error {{expected expression}} */ #pragma clang loop unroll_count(==) while (i-8 < Length) { List[i] = i; } @@ -136,7 +230,7 @@ void test(int *List, int Length) { #pragma clang loop vectorize(disable) /* expected-error {{duplicate directives 'interleave(disable)' and 'interleave(enable)'}} */ #pragma clang loop interleave(enable) #pragma clang loop interleave(disable) -/* expected-error {{duplicate directives 'unroll(disable)' and 'unroll(enable)'}} */ #pragma clang loop unroll(enable) +/* expected-error {{duplicate directives 'unroll(disable)' and 'unroll(full)'}} */ #pragma clang loop unroll(full) #pragma clang loop unroll(disable) while (i-9 < Length) { List[i] = i; @@ -162,5 +256,12 @@ void test(int *List, int Length) { List[i] = i; } + +/* expected-error {{incompatible directives 'unroll(full)' and 'unroll_count(4)'}} */ #pragma clang loop unroll(full) +#pragma clang loop unroll_count(4) + while (i-11 < Length) { + List[i] = i; + } + #pragma clang loop interleave(enable) /* expected-error {{expected statement}} */ } diff --git a/test/Parser/pragma-unroll.cpp b/test/Parser/pragma-unroll.cpp index 1d89e63028c4..260945756f2f 100644 --- a/test/Parser/pragma-unroll.cpp +++ b/test/Parser/pragma-unroll.cpp @@ -11,47 +11,39 @@ void test(int *List, int Length) { List[i] = i; } -#pragma unroll 4 - while (i - 1 < Length) { - List[i] = i; - } - -#pragma unroll(8) - while (i - 2 < Length) { +#pragma nounroll + while (i < Length) { List[i] = i; } -#pragma unroll -#pragma unroll(8) - while (i - 3 < Length) { +#pragma unroll 4 + while (i - 1 < Length) { List[i] = i; } -#pragma clang loop unroll(enable) #pragma unroll(8) - while (i - 4 < Length) { - List[i] = i; - } - -#pragma unroll -#pragma clang loop unroll_count(4) - while (i - 5 < Length) { + while (i - 2 < Length) { List[i] = i; } /* expected-error {{expected ')'}} */ #pragma unroll(4 -/* expected-error {{missing argument to '#pragma unroll'; expected a positive integer value}} */ #pragma unroll() +/* expected-error {{missing argument; expected an integer value}} */ #pragma unroll() /* expected-warning {{extra tokens at end of '#pragma unroll'}} */ #pragma unroll 1 2 while (i-6 < Length) { List[i] = i; } -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(() -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll - -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(0) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll 0 -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(3000000000) -/* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll 3000000000 +/* expected-warning {{extra tokens at end of '#pragma nounroll'}} */ #pragma nounroll 1 + while (i-7 < Length) { + List[i] = i; + } + +/* expected-error {{expected ')'}} */ #pragma unroll(() +/* expected-error {{expected expression}} */ #pragma unroll - +/* expected-error {{invalid value '0'; must be positive}} */ #pragma unroll(0) +/* expected-error {{invalid value '0'; must be positive}} */ #pragma unroll 0 +/* expected-error {{value '3000000000' is too large}} */ #pragma unroll(3000000000) +/* expected-error {{value '3000000000' is too large}} */ #pragma unroll 3000000000 while (i-8 < Length) { List[i] = i; } @@ -60,6 +52,8 @@ void test(int *List, int Length) { /* expected-error {{expected a for, while, or do-while loop to follow '#pragma unroll'}} */ int j = Length; #pragma unroll 4 /* expected-error {{expected a for, while, or do-while loop to follow '#pragma unroll'}} */ int k = Length; +#pragma nounroll +/* expected-error {{expected a for, while, or do-while loop to follow '#pragma nounroll'}} */ int l = Length; /* expected-error {{incompatible directives 'unroll(disable)' and '#pragma unroll(4)'}} */ #pragma unroll 4 #pragma clang loop unroll(disable) @@ -67,14 +61,38 @@ void test(int *List, int Length) { List[i] = i; } +/* expected-error {{incompatible directives 'unroll(full)' and '#pragma unroll(4)'}} */ #pragma unroll(4) +#pragma clang loop unroll(full) + while (i-11 < Length) { + List[i] = i; + } + +/* expected-error {{incompatible directives '#pragma unroll' and '#pragma unroll(4)'}} */ #pragma unroll(4) +#pragma unroll + while (i-11 < Length) { + List[i] = i; + } + +/* expected-error {{incompatible directives '#pragma nounroll' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) +#pragma nounroll + while (i-12 < Length) { + List[i] = i; + } + +/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma nounroll'}} */ #pragma nounroll +#pragma nounroll + while (i-13 < Length) { + List[i] = i; + } + /* expected-error {{duplicate directives '#pragma unroll' and '#pragma unroll'}} */ #pragma unroll #pragma unroll while (i-14 < Length) { List[i] = i; } -/* expected-error {{duplicate directives 'unroll(enable)' and '#pragma unroll'}} */ #pragma unroll -#pragma clang loop unroll(enable) +/* expected-error {{duplicate directives 'unroll(full)' and '#pragma unroll'}} */ #pragma unroll +#pragma clang loop unroll(full) while (i-15 < Length) { List[i] = i; } diff --git a/test/Parser/switch-recovery.cpp b/test/Parser/switch-recovery.cpp index 534517018267..4b06d55ba594 100644 --- a/test/Parser/switch-recovery.cpp +++ b/test/Parser/switch-recovery.cpp @@ -220,3 +220,12 @@ bool bar0() { case bar5: ; // expected-error{{use of undeclared identifier 'bar5'}} } } + +namespace pr21841 { +void fn1() { + switch (0) + switch (0 // expected-note{{to match this '('}} + { // expected-error{{expected ')'}} + } +} // expected-error{{expected statement}} +} diff --git a/test/Parser/vsx.c b/test/Parser/vsx.c new file mode 100644 index 000000000000..ead09814c8c1 --- /dev/null +++ b/test/Parser/vsx.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -faltivec -target-feature +vsx -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -faltivec -target-feature +vsx -fsyntax-only -verify %s + +// Legitimate for VSX. +__vector double vv_d1; +vector double v_d2; + +// These should have errors. +__vector long double vv_ld3; // expected-error {{cannot use 'long double' with '__vector'}} +vector long double v_ld4; // expected-error {{cannot use 'long double' with '__vector'}} diff --git a/test/Preprocessor/_Pragma.c b/test/Preprocessor/_Pragma.c index 15725a422299..120e754cb986 100644 --- a/test/Preprocessor/_Pragma.c +++ b/test/Preprocessor/_Pragma.c @@ -11,3 +11,5 @@ _Pragma("message(\"foo \\\\\\\\ bar\")") // expected-warning {{foo \\ bar}} #ifdef macro #error #define invalid #endif + +_Pragma( // expected-error{{_Pragma takes a parenthesized string literal}} diff --git a/test/Preprocessor/aarch64-target-features.c b/test/Preprocessor/aarch64-target-features.c index 137a1d81920a..4e9e6c7fde95 100644 --- a/test/Preprocessor/aarch64-target-features.c +++ b/test/Preprocessor/aarch64-target-features.c @@ -12,8 +12,11 @@ // CHECK: __ARM_FEATURE_CLZ 1 // CHECK-NOT: __ARM_FEATURE_CRC32 1 // CHECK-NOT: __ARM_FEATURE_CRYPTO 1 +// CHECK: __ARM_FEATURE_DIRECTED_ROUNDING 1 // CHECK: __ARM_FEATURE_DIV 1 // CHECK: __ARM_FEATURE_FMA 1 +// CHECK: __ARM_FEATURE_IDIV 1 +// CHECK: __ARM_FEATURE_NUMERIC_MAXMIN 1 // CHECK: __ARM_FEATURE_UNALIGNED 1 // CHECK: __ARM_FP 0xe // CHECK: __ARM_FP16_FORMAT_IEEE 1 @@ -70,6 +73,9 @@ // CHECK-MCPU-A53: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+crc" "-target-feature" "+crypto" // CHECK-MCPU-A57: "-cc1"{{.*}} "-triple" "aarch64{{.*}}" "-target-feature" "+neon" "-target-feature" "+crc" "-target-feature" "+crypto" +// RUN: %clang -target x86_64-apple-macosx -arch arm64 -### -c %s 2>&1 | FileCheck --check-prefix=CHECK-ARCH-ARM64 %s +// CHECK-ARCH-ARM64: "-target-cpu" "cyclone" "-target-feature" "+neon" "-target-feature" "+crc" "-target-feature" "+crypto" "-target-feature" "+zcm" "-target-feature" "+zcz" + // RUN: %clang -target aarch64 -march=armv8-a+fp+simd+crc+crypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MARCH-1 %s // RUN: %clang -target aarch64 -march=armv8-a+nofp+nosimd+nocrc+nocrypto+fp+simd+crc+crypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MARCH-1 %s // RUN: %clang -target aarch64 -march=armv8-a+nofp+nosimd+nocrc+nocrypto -### -c %s 2>&1 | FileCheck -check-prefix=CHECK-MARCH-2 %s diff --git a/test/Preprocessor/arm-acle-6.4.c b/test/Preprocessor/arm-acle-6.4.c index a656f7608c0f..fc228d093c8c 100644 --- a/test/Preprocessor/arm-acle-6.4.c +++ b/test/Preprocessor/arm-acle-6.4.c @@ -5,6 +5,8 @@ // CHECK-CORTEX-M0-NOT: __ARM_ARCH_ISA_ARM // CHECK-CORTEX-M0: __ARM_ARCH_ISA_THUMB 1 // CHECK-CORTEX-M0: __ARM_ARCH_PROFILE 'M' +// CHECK-CORTEX-M0-NOT: __ARM_FEATURE_NUMERIC_MAXMIN +// CHECK-CORTEX-M0-NOT: __ARM_FEATURE_DIRECTED_ROUNDING // RUN: %clang -target arm-eabi -mcpu=arm810 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-ARM810 @@ -13,6 +15,8 @@ // CHECK-ARM810: __ARM_ARCH_ISA_ARM 1 // CHECK-ARM810-NOT: __ARM_ARCH_ISA_THUMB // CHECK-ARM810-NOT: __ARM_ARCH_PROFILE +// CHECK-ARM810-NOT: __ARM_FEATURE_NUMERIC_MAXMIN +// CHECK-ARM810-NOT: __ARM_FEATURE_DIRECTED_ROUNDING // RUN: %clang -target arm-eabi -mcpu=arm7tdmi -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-ARM7TDMI @@ -29,6 +33,8 @@ // CHECK-CORTEX-A7: __ARM_ARCH_ISA_ARM 1 // CHECK-CORTEX-A7: __ARM_ARCH_ISA_THUMB 2 // CHECK-CORTEX-A7: __ARM_ARCH_PROFILE 'A' +// CHECK-CORTEX-A7-NOT: __ARM_FEATURE_NUMERIC_MAXMIN +// CHECK-CORTEX-A7-NOT: __ARM_FEATURE_DIRECTED_ROUNDING // RUN: %clang -target arm-eabi -mcpu=cortex-r4 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-CORTEX-R4 diff --git a/test/Preprocessor/arm-acle-6.5.c b/test/Preprocessor/arm-acle-6.5.c new file mode 100644 index 000000000000..9db83b774b0c --- /dev/null +++ b/test/Preprocessor/arm-acle-6.5.c @@ -0,0 +1,22 @@ +// RUN: %clang -target arm-eabi -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-DEFAULT + +// CHECK-DEFAULT-NOT: __ARM_FP + +// RUN: %clang -target arm-eabi -mfpu=vfp -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP +// RUN: %clang -target arm-eabi -mfpu=vfp3 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP +// RUN: %clang -target arm-eabi -mfpu=vfp3-d16 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP +// RUN: %clang -target arm-eabi -mfpu=neon -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP +// RUN: %clang -target arm-eabi -mfpu=vfp3 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP +// RUN: %clang -target armv7-eabi -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP + +// CHECK-SP-DP: __ARM_FP 0xC + +// RUN: %clang -target arm-eabi -mfpu=vfpv4 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP +// RUN: %clang -target arm-eabi -mfpu=vfpv4-d16 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP +// RUN: %clang -target arm-eabi -mfpu=fp-armv8 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP +// RUN: %clang -target arm-eabi -mfpu=neon-fp-armv8 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP +// RUN: %clang -target arm-eabi -mfpu=crypto-neon-fp-armv8 -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP +// RUN: %clang -target armv8-eabi -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-SP-DP-HP + +// CHECK-SP-DP-HP: __ARM_FP 0xE + diff --git a/test/Preprocessor/arm-target-features.c b/test/Preprocessor/arm-target-features.c index 08fe29a72502..e95a50d02277 100644 --- a/test/Preprocessor/arm-target-features.c +++ b/test/Preprocessor/arm-target-features.c @@ -3,18 +3,24 @@ // CHECK: __ARM_ARCH 8 // CHECK: __ARM_ARCH_8A__ 1 // CHECK: __ARM_FEATURE_CRC32 1 +// CHECK: __ARM_FEATURE_DIRECTED_ROUNDING 1 +// CHECK: __ARM_FEATURE_NUMERIC_MAXMIN 1 // RUN: %clang -target armv7a-none-linux-gnu -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-V7 %s // CHECK-V7: __ARMEL__ 1 // CHECK-V7: __ARM_ARCH 7 // CHECK-V7: __ARM_ARCH_7A__ 1 // CHECK-V7-NOT: __ARM_FEATURE_CRC32 +// CHECK-V7-NOT: __ARM_FEATURE_NUMERIC_MAXMIN +// CHECK-V7-NOT: __ARM_FEATURE_DIRECTED_ROUNDING // RUN: %clang -target armv8a -mfloat-abi=hard -x c -E -dM %s | FileCheck --check-prefix=CHECK-V8-BAREHF %s // CHECK-V8-BAREHF: __ARMEL__ 1 // CHECK-V8-BAREHF: __ARM_ARCH 8 // CHECK-V8-BAREHF: __ARM_ARCH_8A__ 1 // CHECK-V8-BAREHF: __ARM_FEATURE_CRC32 1 +// CHECK-V8-BAREHF: __ARM_FEATURE_DIRECTED_ROUNDING 1 +// CHECK-V8-BAREHF: __ARM_FEATURE_NUMERIC_MAXMIN 1 // CHECK-V8-BAREHF: __ARM_NEON__ 1 // CHECK-V8-BAREHF: __VFP_FP__ 1 @@ -137,18 +143,31 @@ // NONEON-A5:#define __ARM_VFPV4__ 1 // FIXME: add check for further predefines +// Test whether predefines are as expected when targeting ep9312. +// RUN: %clang -target armv4t -mcpu=ep9312 -x c -E -dM %s -o - | FileCheck --check-prefix=A4T %s +// A4T-NOT:#define __ARM_FEATURE_DSP + +// Test whether predefines are as expected when targeting arm10tdmi. +// RUN: %clang -target armv5 -mcpu=arm10tdmi -x c -E -dM %s -o - | FileCheck --check-prefix=A5T %s +// A5T-NOT:#define __ARM_FEATURE_DSP + // Test whether predefines are as expected when targeting cortex-a5. // RUN: %clang -target armv7 -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck --check-prefix=A5-ARM %s // A5-ARM-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A5-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck --check-prefix=A5-THUMB %s // A5-THUMB-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A5-THUMB:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck --check-prefix=A5 %s // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck --check-prefix=A5 %s // A5:#define __ARM_ARCH 7 // A5:#define __ARM_ARCH_7A__ 1 // A5:#define __ARM_ARCH_PROFILE 'A' +// A5-NOT: #define __ARM_FEATURE_NUMERIC_MAXMIN +// A5-NOT: #define __ARM_FEATURE_DIRECTED_ROUNDING +// A5:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-a7. // RUN: %clang -target armv7 -mcpu=cortex-a7 -x c -E -dM %s -o - | FileCheck --check-prefix=A7 %s @@ -157,20 +176,25 @@ // A7:#define __ARM_ARCH_7A__ 1 // A7:#define __ARM_ARCH_EXT_IDIV__ 1 // A7:#define __ARM_ARCH_PROFILE 'A' +// A7:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-a8. // RUN: %clang -target armv7 -mcpu=cortex-a8 -x c -E -dM %s -o - | FileCheck --check-prefix=A8-ARM %s // A8-ARM-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A8-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a8 -x c -E -dM %s -o - | FileCheck --check-prefix=A8-THUMB %s // A8-THUMB-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A8-THUMB:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-a9. // RUN: %clang -target armv7 -mcpu=cortex-a9 -x c -E -dM %s -o - | FileCheck --check-prefix=A9-ARM %s // A9-ARM-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A9-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a9 -x c -E -dM %s -o - | FileCheck --check-prefix=A9-THUMB %s // A9-THUMB-NOT:#define __ARM_ARCH_EXT_IDIV__ +// A9-THUMB:#define __ARM_FEATURE_DSP // Check that -mfpu works properly for Cortex-A12 (enabled by default). @@ -191,53 +215,91 @@ // A12:#define __ARM_ARCH_7A__ 1 // A12:#define __ARM_ARCH_EXT_IDIV__ 1 // A12:#define __ARM_ARCH_PROFILE 'A' +// A12:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-a15. // RUN: %clang -target armv7 -mcpu=cortex-a15 -x c -E -dM %s -o - | FileCheck --check-prefix=A15-ARM %s // A15-ARM:#define __ARM_ARCH_EXT_IDIV__ 1 +// A15-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a15 -x c -E -dM %s -o - | FileCheck --check-prefix=A15-THUMB %s // A15-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// A15-THUMB:#define __ARM_FEATURE_DSP + +// Check that -mfpu works properly for Cortex-A17 (enabled by default). +// RUN: %clang -target armv7-none-linux-gnueabi -mcpu=cortex-a17 -x c -E -dM %s -o - | FileCheck --check-prefix=DEFAULTFPU-A17 %s +// RUN: %clang -target armv7-none-linux-gnueabi -mthumb -mcpu=cortex-a17 -x c -E -dM %s -o - | FileCheck --check-prefix=DEFAULTFPU-A17 %s +// DEFAULTFPU-A17:#define __ARM_NEON__ 1 +// DEFAULTFPU-A17:#define __ARM_VFPV4__ 1 + +// RUN: %clang -target armv7-none-linux-gnueabi -mcpu=cortex-a17 -mfpu=none -x c -E -dM %s -o - | FileCheck --check-prefix=FPUNONE-A17 %s +// RUN: %clang -target armv7-none-linux-gnueabi -mthumb -mcpu=cortex-a17 -mfpu=none -x c -E -dM %s -o - | FileCheck --check-prefix=FPUNONE-A17 %s +// FPUNONE-A17-NOT:#define __ARM_NEON__ 1 +// FPUNONE-A17-NOT:#define __ARM_VFPV4__ 1 + +// Test whether predefines are as expected when targeting cortex-a17. +// RUN: %clang -target armv7 -mcpu=cortex-a17 -x c -E -dM %s -o - | FileCheck --check-prefix=A17 %s +// RUN: %clang -target armv7 -mthumb -mcpu=cortex-a17 -x c -E -dM %s -o - | FileCheck --check-prefix=A17 %s +// A17:#define __ARM_ARCH 7 +// A17:#define __ARM_ARCH_7A__ 1 +// A17:#define __ARM_ARCH_EXT_IDIV__ 1 +// A17:#define __ARM_ARCH_PROFILE 'A' +// A17:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting swift. // RUN: %clang -target armv7s -mcpu=swift -x c -E -dM %s -o - | FileCheck --check-prefix=SWIFT-ARM %s // SWIFT-ARM:#define __ARM_ARCH_EXT_IDIV__ 1 +// SWIFT:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7s -mthumb -mcpu=swift -x c -E -dM %s -o - | FileCheck --check-prefix=SWIFT-THUMB %s // SWIFT-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// SWIFT-THUMB:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-a53. // RUN: %clang -target armv8 -mcpu=cortex-a53 -x c -E -dM %s -o - | FileCheck --check-prefix=A53-ARM %s // A53-ARM:#define __ARM_ARCH_EXT_IDIV__ 1 +// A53-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv8 -mthumb -mcpu=cortex-a53 -x c -E -dM %s -o - | FileCheck --check-prefix=A53-THUMB %s // A53-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// A53-THUMB:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-r5. // RUN: %clang -target armv7 -mcpu=cortex-r5 -x c -E -dM %s -o - | FileCheck --check-prefix=R5-ARM %s // R5-ARM:#define __ARM_ARCH_EXT_IDIV__ 1 +// R5-ARM:#define __ARM_FEATURE_DSP // RUN: %clang -target armv7 -mthumb -mcpu=cortex-r5 -x c -E -dM %s -o - | FileCheck --check-prefix=R5-THUMB %s // R5-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// R5-THUMB:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-m0. // RUN: %clang -target armv7 -mthumb -mcpu=cortex-m0 -x c -E -dM %s -o - | FileCheck --check-prefix=M0-THUMB %s // M0-THUMB-NOT:#define __ARM_ARCH_EXT_IDIV__ +// M0-THUMB-NOT:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-m3. // RUN: %clang -target armv7 -mthumb -mcpu=cortex-m3 -x c -E -dM %s -o - | FileCheck --check-prefix=M3-THUMB %s // M3-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// M3-THUMB-NOT:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting cortex-m4. // RUN: %clang -target armv7 -mthumb -mcpu=cortex-m4 -x c -E -dM %s -o - | FileCheck --check-prefix=M4-THUMB %s // M4-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// M4-THUMB:#define __ARM_FEATURE_DSP + +// Test whether predefines are as expected when targeting cortex-m7. +// RUN: %clang -target armv7 -mthumb -mcpu=cortex-m7 -x c -E -dM %s -o - | FileCheck --check-prefix=M7-THUMB %s +// M7-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// M7-THUMB:#define __ARM_FEATURE_DSP // Test whether predefines are as expected when targeting krait. // RUN: %clang -target armv7 -mcpu=krait -x c -E -dM %s -o - | FileCheck --check-prefix=KRAIT-ARM %s // KRAIT-ARM:#define __ARM_ARCH_EXT_IDIV__ 1 +// KRAIT-ARM:#define __ARM_FEATURE_DSP // KRAIT-ARM:#define __ARM_VFPV4__ 1 // RUN: %clang -target armv7 -mthumb -mcpu=krait -x c -E -dM %s -o - | FileCheck --check-prefix=KRAIT-THUMB %s // KRAIT-THUMB:#define __ARM_ARCH_EXT_IDIV__ 1 +// KRAIT-THUMB:#define __ARM_FEATURE_DSP // KRAIT-THUMB:#define __ARM_VFPV4__ 1 - diff --git a/test/Preprocessor/cxx_oper_keyword_ms_compat.cpp b/test/Preprocessor/cxx_oper_keyword_ms_compat.cpp index 8e1351e34728..24a3898437f0 100644 --- a/test/Preprocessor/cxx_oper_keyword_ms_compat.cpp +++ b/test/Preprocessor/cxx_oper_keyword_ms_compat.cpp @@ -1,6 +1,8 @@ // RUN: %clang_cc1 %s -E -verify -fms-extensions // expected-no-diagnostics +#pragma clang diagnostic ignored "-Wkeyword-macro" + bool f() { // Check that operators still work before redefining them. #if compl 0 bitand 1 diff --git a/test/Preprocessor/feature_tests.c b/test/Preprocessor/feature_tests.c index 5a2c300e6ee1..fbde6a65476e 100644 --- a/test/Preprocessor/feature_tests.c +++ b/test/Preprocessor/feature_tests.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple=i686-apple-darwin9 +// RUN: %clang_cc1 %s -triple=i686-apple-darwin9 -verify -DVERIFY // RUN: %clang_cc1 %s -E -triple=i686-apple-darwin9 #ifndef __has_feature #error Should have __has_feature @@ -53,3 +53,10 @@ #if !HAS_BUILTIN(MY_ALIAS_BUILTIN) || !HAS_FEATURE(MY_ALIAS_FEATURE) #error Expansion should have occurred #endif + +#ifdef VERIFY +// expected-error@+2 {{builtin feature check macro requires a parenthesized identifier}} +// expected-error@+1 {{expected value in expression}} +#if __has_feature('x') +#endif +#endif diff --git a/test/Preprocessor/has_attribute.c b/test/Preprocessor/has_attribute.c index 5fe060e68d3c..0ef5b4857a38 100644 --- a/test/Preprocessor/has_attribute.c +++ b/test/Preprocessor/has_attribute.c @@ -48,3 +48,8 @@ int has_no_volatile_attribute(); #if !__has_attribute(dllexport) int does_not_have_dllexport(); #endif + +// CHECK: does_not_have_uuid +#if !__has_attribute(uuid) + int does_not_have_uuid +#endif diff --git a/test/Preprocessor/has_attribute.cpp b/test/Preprocessor/has_attribute.cpp new file mode 100644 index 000000000000..1ab45020b444 --- /dev/null +++ b/test/Preprocessor/has_attribute.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -triple i386-unknown-unknown -fms-compatibility -std=c++11 -E %s -o - | FileCheck %s + +// CHECK: has_cxx11_carries_dep +#if __has_cpp_attribute(carries_dependency) + int has_cxx11_carries_dep(); +#endif + +// CHECK: has_clang_fallthrough_1 +#if __has_cpp_attribute(clang::fallthrough) + int has_clang_fallthrough_1(); +#endif + +// CHECK: does_not_have_selectany +#if !__has_cpp_attribute(selectany) + int does_not_have_selectany(); +#endif + +// The attribute name can be bracketed with double underscores. +// CHECK: has_clang_fallthrough_2 +#if __has_cpp_attribute(clang::__fallthrough__) + int has_clang_fallthrough_2(); +#endif + +// The scope cannot be bracketed with double underscores. +// CHECK: does_not_have___clang___fallthrough +#if !__has_cpp_attribute(__clang__::fallthrough) + int does_not_have___clang___fallthrough(); +#endif + +// Test that C++11, target-specific attributes behave properly. + +// CHECK: does_not_have_mips16 +#if !__has_cpp_attribute(gnu::mips16) + int does_not_have_mips16(); +#endif + +// Test that the version numbers of attributes listed in SD-6 are supported +// correctly. + +// CHECK: has_cxx11_carries_dep_vers +#if __has_cpp_attribute(carries_dependency) == 200809 + int has_cxx11_carries_dep_vers(); +#endif + +// CHECK: has_cxx11_noreturn_vers +#if __has_cpp_attribute(noreturn) == 200809 + int has_cxx11_noreturn_vers(); +#endif + +// CHECK: has_cxx14_deprecated_vers +#if __has_cpp_attribute(deprecated) == 201309 + int has_cxx14_deprecated_vers(); +#endif + +// CHECK: has_declspec_uuid +#if __has_declspec_attribute(uuid) + int has_declspec_uuid(); +#endif + +// CHECK: has_declspec_uuid2 +#if __has_declspec_attribute(__uuid__) + int has_declspec_uuid2(); +#endif + +// CHECK: does_not_have_declspec_fallthrough +#if !__has_declspec_attribute(fallthrough) + int does_not_have_declspec_fallthrough(); +#endif diff --git a/test/Preprocessor/headermap-rel2.c b/test/Preprocessor/headermap-rel2.c index 430854de0679..d61f3385b22d 100644 --- a/test/Preprocessor/headermap-rel2.c +++ b/test/Preprocessor/headermap-rel2.c @@ -1,8 +1,8 @@ // This uses a headermap with this entry: // someheader.h -> Product/someheader.h -// RUN: %clang_cc1 -triple x86_64-apple-darwin13 -v -fsyntax-only %s -iquote %S/Inputs/headermap-rel2/project-headers.hmap -isysroot %S/Inputs/headermap-rel2/system -I %S/Inputs/headermap-rel2 -H -// RUN: %clang_cc1 -triple x86_64-apple-darwin13 -fsyntax-only %s -iquote %S/Inputs/headermap-rel2/project-headers.hmap -isysroot %S/Inputs/headermap-rel2/system -I %S/Inputs/headermap-rel2 -H 2> %t.out +// RUN: %clang_cc1 -v -fsyntax-only %s -iquote %S/Inputs/headermap-rel2/project-headers.hmap -isystem %S/Inputs/headermap-rel2/system/usr/include -I %S/Inputs/headermap-rel2 -H +// RUN: %clang_cc1 -fsyntax-only %s -iquote %S/Inputs/headermap-rel2/project-headers.hmap -isystem %S/Inputs/headermap-rel2/system/usr/include -I %S/Inputs/headermap-rel2 -H 2> %t.out // RUN: FileCheck %s -input-file %t.out // CHECK: Product/someheader.h diff --git a/test/Preprocessor/init.c b/test/Preprocessor/init.c index 7b73ce0fa60d..4f321140c6b2 100644 --- a/test/Preprocessor/init.c +++ b/test/Preprocessor/init.c @@ -80,7 +80,7 @@ // COMMON:#define __ORDER_LITTLE_ENDIAN__ 1234 // COMMON:#define __ORDER_PDP_ENDIAN__ 3412 // COMMON:#define __STDC_HOSTED__ 1 -// COMMON:#define __STDC_VERSION__ +// COMMON:#define __STDC_VERSION__ 201112L // COMMON:#define __STDC__ 1 // COMMON:#define __VERSION__ // COMMON:#define __clang__ 1 @@ -422,7 +422,6 @@ // AARCH64:#define __aarch64__ 1 // // RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64_be-none-none < /dev/null | FileCheck -check-prefix AARCH64-BE %s -// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm64_be-none-none < /dev/null | FileCheck -check-prefix AARCH64-BE %s // // AARCH64-BE:#define _LP64 1 // AARCH64-BE:#define __AARCH64EB__ 1 @@ -802,6 +801,199 @@ // AARCH64-NETBSD:#define __WINT_TYPE__ int // AARCH64-NETBSD:#define __WINT_WIDTH__ 32 // AARCH64-NETBSD:#define __aarch64__ 1 +// +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64-freebsd11 < /dev/null | FileCheck -check-prefix AARCH64-FREEBSD %s +// +// AARCH64-FREEBSD:#define _LP64 1 +// AARCH64-FREEBSD-NOT:#define __AARCH64EB__ 1 +// AARCH64-FREEBSD:#define __AARCH64EL__ 1 +// AARCH64-FREEBSD-NOT:#define __AARCH_BIG_ENDIAN 1 +// AARCH64-FREEBSD:#define __ARM_64BIT_STATE 1 +// AARCH64-FREEBSD:#define __ARM_ARCH 8 +// AARCH64-FREEBSD:#define __ARM_ARCH_ISA_A64 1 +// AARCH64-FREEBSD-NOT:#define __ARM_BIG_ENDIAN 1 +// AARCH64-FREEBSD:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ +// AARCH64-FREEBSD:#define __CHAR16_TYPE__ unsigned short +// AARCH64-FREEBSD:#define __CHAR32_TYPE__ unsigned int +// AARCH64-FREEBSD:#define __CHAR_BIT__ 8 +// AARCH64-FREEBSD:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +// AARCH64-FREEBSD:#define __DBL_DIG__ 15 +// AARCH64-FREEBSD:#define __DBL_EPSILON__ 2.2204460492503131e-16 +// AARCH64-FREEBSD:#define __DBL_HAS_DENORM__ 1 +// AARCH64-FREEBSD:#define __DBL_HAS_INFINITY__ 1 +// AARCH64-FREEBSD:#define __DBL_HAS_QUIET_NAN__ 1 +// AARCH64-FREEBSD:#define __DBL_MANT_DIG__ 53 +// AARCH64-FREEBSD:#define __DBL_MAX_10_EXP__ 308 +// AARCH64-FREEBSD:#define __DBL_MAX_EXP__ 1024 +// AARCH64-FREEBSD:#define __DBL_MAX__ 1.7976931348623157e+308 +// AARCH64-FREEBSD:#define __DBL_MIN_10_EXP__ (-307) +// AARCH64-FREEBSD:#define __DBL_MIN_EXP__ (-1021) +// AARCH64-FREEBSD:#define __DBL_MIN__ 2.2250738585072014e-308 +// AARCH64-FREEBSD:#define __DECIMAL_DIG__ 36 +// AARCH64-FREEBSD:#define __ELF__ 1 +// AARCH64-FREEBSD:#define __FLT_DENORM_MIN__ 1.40129846e-45F +// AARCH64-FREEBSD:#define __FLT_DIG__ 6 +// AARCH64-FREEBSD:#define __FLT_EPSILON__ 1.19209290e-7F +// AARCH64-FREEBSD:#define __FLT_EVAL_METHOD__ 0 +// AARCH64-FREEBSD:#define __FLT_HAS_DENORM__ 1 +// AARCH64-FREEBSD:#define __FLT_HAS_INFINITY__ 1 +// AARCH64-FREEBSD:#define __FLT_HAS_QUIET_NAN__ 1 +// AARCH64-FREEBSD:#define __FLT_MANT_DIG__ 24 +// AARCH64-FREEBSD:#define __FLT_MAX_10_EXP__ 38 +// AARCH64-FREEBSD:#define __FLT_MAX_EXP__ 128 +// AARCH64-FREEBSD:#define __FLT_MAX__ 3.40282347e+38F +// AARCH64-FREEBSD:#define __FLT_MIN_10_EXP__ (-37) +// AARCH64-FREEBSD:#define __FLT_MIN_EXP__ (-125) +// AARCH64-FREEBSD:#define __FLT_MIN__ 1.17549435e-38F +// AARCH64-FREEBSD:#define __FLT_RADIX__ 2 +// AARCH64-FREEBSD:#define __FreeBSD__ 11 +// AARCH64-FREEBSD:#define __INT16_C_SUFFIX__ {{$}} +// AARCH64-FREEBSD:#define __INT16_FMTd__ "hd" +// AARCH64-FREEBSD:#define __INT16_FMTi__ "hi" +// AARCH64-FREEBSD:#define __INT16_MAX__ 32767 +// AARCH64-FREEBSD:#define __INT16_TYPE__ short +// AARCH64-FREEBSD:#define __INT32_C_SUFFIX__ {{$}} +// AARCH64-FREEBSD:#define __INT32_FMTd__ "d" +// AARCH64-FREEBSD:#define __INT32_FMTi__ "i" +// AARCH64-FREEBSD:#define __INT32_MAX__ 2147483647 +// AARCH64-FREEBSD:#define __INT32_TYPE__ int +// AARCH64-FREEBSD:#define __INT64_C_SUFFIX__ L +// AARCH64-FREEBSD:#define __INT64_FMTd__ "ld" +// AARCH64-FREEBSD:#define __INT64_FMTi__ "li" +// AARCH64-FREEBSD:#define __INT64_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __INT64_TYPE__ long int +// AARCH64-FREEBSD:#define __INT8_C_SUFFIX__ {{$}} +// AARCH64-FREEBSD:#define __INT8_FMTd__ "hhd" +// AARCH64-FREEBSD:#define __INT8_FMTi__ "hhi" +// AARCH64-FREEBSD:#define __INT8_MAX__ 127 +// AARCH64-FREEBSD:#define __INT8_TYPE__ signed char +// AARCH64-FREEBSD:#define __INTMAX_C_SUFFIX__ L +// AARCH64-FREEBSD:#define __INTMAX_FMTd__ "ld" +// AARCH64-FREEBSD:#define __INTMAX_FMTi__ "li" +// AARCH64-FREEBSD:#define __INTMAX_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __INTMAX_TYPE__ long int +// AARCH64-FREEBSD:#define __INTMAX_WIDTH__ 64 +// AARCH64-FREEBSD:#define __INTPTR_FMTd__ "ld" +// AARCH64-FREEBSD:#define __INTPTR_FMTi__ "li" +// AARCH64-FREEBSD:#define __INTPTR_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __INTPTR_TYPE__ long int +// AARCH64-FREEBSD:#define __INTPTR_WIDTH__ 64 +// AARCH64-FREEBSD:#define __INT_FAST16_FMTd__ "hd" +// AARCH64-FREEBSD:#define __INT_FAST16_FMTi__ "hi" +// AARCH64-FREEBSD:#define __INT_FAST16_MAX__ 32767 +// AARCH64-FREEBSD:#define __INT_FAST16_TYPE__ short +// AARCH64-FREEBSD:#define __INT_FAST32_FMTd__ "d" +// AARCH64-FREEBSD:#define __INT_FAST32_FMTi__ "i" +// AARCH64-FREEBSD:#define __INT_FAST32_MAX__ 2147483647 +// AARCH64-FREEBSD:#define __INT_FAST32_TYPE__ int +// AARCH64-FREEBSD:#define __INT_FAST64_FMTd__ "ld" +// AARCH64-FREEBSD:#define __INT_FAST64_FMTi__ "li" +// AARCH64-FREEBSD:#define __INT_FAST64_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __INT_FAST64_TYPE__ long int +// AARCH64-FREEBSD:#define __INT_FAST8_FMTd__ "hhd" +// AARCH64-FREEBSD:#define __INT_FAST8_FMTi__ "hhi" +// AARCH64-FREEBSD:#define __INT_FAST8_MAX__ 127 +// AARCH64-FREEBSD:#define __INT_FAST8_TYPE__ signed char +// AARCH64-FREEBSD:#define __INT_LEAST16_FMTd__ "hd" +// AARCH64-FREEBSD:#define __INT_LEAST16_FMTi__ "hi" +// AARCH64-FREEBSD:#define __INT_LEAST16_MAX__ 32767 +// AARCH64-FREEBSD:#define __INT_LEAST16_TYPE__ short +// AARCH64-FREEBSD:#define __INT_LEAST32_FMTd__ "d" +// AARCH64-FREEBSD:#define __INT_LEAST32_FMTi__ "i" +// AARCH64-FREEBSD:#define __INT_LEAST32_MAX__ 2147483647 +// AARCH64-FREEBSD:#define __INT_LEAST32_TYPE__ int +// AARCH64-FREEBSD:#define __INT_LEAST64_FMTd__ "ld" +// AARCH64-FREEBSD:#define __INT_LEAST64_FMTi__ "li" +// AARCH64-FREEBSD:#define __INT_LEAST64_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __INT_LEAST64_TYPE__ long int +// AARCH64-FREEBSD:#define __INT_LEAST8_FMTd__ "hhd" +// AARCH64-FREEBSD:#define __INT_LEAST8_FMTi__ "hhi" +// AARCH64-FREEBSD:#define __INT_LEAST8_MAX__ 127 +// AARCH64-FREEBSD:#define __INT_LEAST8_TYPE__ signed char +// AARCH64-FREEBSD:#define __INT_MAX__ 2147483647 +// AARCH64-FREEBSD:#define __LDBL_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966L +// AARCH64-FREEBSD:#define __LDBL_DIG__ 33 +// AARCH64-FREEBSD:#define __LDBL_EPSILON__ 1.92592994438723585305597794258492732e-34L +// AARCH64-FREEBSD:#define __LDBL_HAS_DENORM__ 1 +// AARCH64-FREEBSD:#define __LDBL_HAS_INFINITY__ 1 +// AARCH64-FREEBSD:#define __LDBL_HAS_QUIET_NAN__ 1 +// AARCH64-FREEBSD:#define __LDBL_MANT_DIG__ 113 +// AARCH64-FREEBSD:#define __LDBL_MAX_10_EXP__ 4932 +// AARCH64-FREEBSD:#define __LDBL_MAX_EXP__ 16384 +// AARCH64-FREEBSD:#define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L +// AARCH64-FREEBSD:#define __LDBL_MIN_10_EXP__ (-4931) +// AARCH64-FREEBSD:#define __LDBL_MIN_EXP__ (-16381) +// AARCH64-FREEBSD:#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L +// AARCH64-FREEBSD:#define __LITTLE_ENDIAN__ 1 +// AARCH64-FREEBSD:#define __LONG_LONG_MAX__ 9223372036854775807LL +// AARCH64-FREEBSD:#define __LONG_MAX__ 9223372036854775807L +// AARCH64-FREEBSD:#define __LP64__ 1 +// AARCH64-FREEBSD:#define __POINTER_WIDTH__ 64 +// AARCH64-FREEBSD:#define __PTRDIFF_TYPE__ long int +// AARCH64-FREEBSD:#define __PTRDIFF_WIDTH__ 64 +// AARCH64-FREEBSD:#define __SCHAR_MAX__ 127 +// AARCH64-FREEBSD:#define __SHRT_MAX__ 32767 +// AARCH64-FREEBSD:#define __SIG_ATOMIC_MAX__ 2147483647 +// AARCH64-FREEBSD:#define __SIG_ATOMIC_WIDTH__ 32 +// AARCH64-FREEBSD:#define __SIZEOF_DOUBLE__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_FLOAT__ 4 +// AARCH64-FREEBSD:#define __SIZEOF_INT128__ 16 +// AARCH64-FREEBSD:#define __SIZEOF_INT__ 4 +// AARCH64-FREEBSD:#define __SIZEOF_LONG_DOUBLE__ 16 +// AARCH64-FREEBSD:#define __SIZEOF_LONG_LONG__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_LONG__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_POINTER__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_PTRDIFF_T__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_SHORT__ 2 +// AARCH64-FREEBSD:#define __SIZEOF_SIZE_T__ 8 +// AARCH64-FREEBSD:#define __SIZEOF_WCHAR_T__ 4 +// AARCH64-FREEBSD:#define __SIZEOF_WINT_T__ 4 +// AARCH64-FREEBSD:#define __SIZE_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __SIZE_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __SIZE_WIDTH__ 64 +// AARCH64-FREEBSD:#define __UINT16_C_SUFFIX__ {{$}} +// AARCH64-FREEBSD:#define __UINT16_MAX__ 65535 +// AARCH64-FREEBSD:#define __UINT16_TYPE__ unsigned short +// AARCH64-FREEBSD:#define __UINT32_C_SUFFIX__ U +// AARCH64-FREEBSD:#define __UINT32_MAX__ 4294967295U +// AARCH64-FREEBSD:#define __UINT32_TYPE__ unsigned int +// AARCH64-FREEBSD:#define __UINT64_C_SUFFIX__ UL +// AARCH64-FREEBSD:#define __UINT64_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __UINT64_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __UINT8_C_SUFFIX__ {{$}} +// AARCH64-FREEBSD:#define __UINT8_MAX__ 255 +// AARCH64-FREEBSD:#define __UINT8_TYPE__ unsigned char +// AARCH64-FREEBSD:#define __UINTMAX_C_SUFFIX__ UL +// AARCH64-FREEBSD:#define __UINTMAX_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __UINTMAX_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __UINTMAX_WIDTH__ 64 +// AARCH64-FREEBSD:#define __UINTPTR_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __UINTPTR_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __UINTPTR_WIDTH__ 64 +// AARCH64-FREEBSD:#define __UINT_FAST16_MAX__ 65535 +// AARCH64-FREEBSD:#define __UINT_FAST16_TYPE__ unsigned short +// AARCH64-FREEBSD:#define __UINT_FAST32_MAX__ 4294967295U +// AARCH64-FREEBSD:#define __UINT_FAST32_TYPE__ unsigned int +// AARCH64-FREEBSD:#define __UINT_FAST64_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __UINT_FAST64_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __UINT_FAST8_MAX__ 255 +// AARCH64-FREEBSD:#define __UINT_FAST8_TYPE__ unsigned char +// AARCH64-FREEBSD:#define __UINT_LEAST16_MAX__ 65535 +// AARCH64-FREEBSD:#define __UINT_LEAST16_TYPE__ unsigned short +// AARCH64-FREEBSD:#define __UINT_LEAST32_MAX__ 4294967295U +// AARCH64-FREEBSD:#define __UINT_LEAST32_TYPE__ unsigned int +// AARCH64-FREEBSD:#define __UINT_LEAST64_MAX__ 18446744073709551615UL +// AARCH64-FREEBSD:#define __UINT_LEAST64_TYPE__ long unsigned int +// AARCH64-FREEBSD:#define __UINT_LEAST8_MAX__ 255 +// AARCH64-FREEBSD:#define __UINT_LEAST8_TYPE__ unsigned char +// AARCH64-FREEBSD:#define __USER_LABEL_PREFIX__ +// AARCH64-FREEBSD:#define __WCHAR_MAX__ 4294967295U +// AARCH64-FREEBSD:#define __WCHAR_TYPE__ unsigned int +// AARCH64-FREEBSD:#define __WCHAR_UNSIGNED__ 1 +// AARCH64-FREEBSD:#define __WCHAR_WIDTH__ 32 +// AARCH64-FREEBSD:#define __WINT_TYPE__ int +// AARCH64-FREEBSD:#define __WINT_WIDTH__ 32 +// AARCH64-FREEBSD:#define __aarch64__ 1 // RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm-none-none < /dev/null | FileCheck -check-prefix ARM %s // @@ -1765,12 +1957,13 @@ // ARM-NETBSD:#define __arm 1 // ARM-NETBSD:#define __arm__ 1 -// RUN: %clang -target arm -arch armv7s -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s -// RUN: %clang -target arm -arch armv6m -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s -// RUN: %clang -target arm -arch armv7m -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s -// RUN: %clang -target arm -arch armv7em -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s +// RUN: %clang -target arm-apple-darwin-eabi -arch armv7s -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s +// RUN: %clang -target arm-apple-darwin-eabi -arch armv6m -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-EABI %s +// RUN: %clang -target arm-apple-darwin-eabi -arch armv7m -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-EABI %s +// RUN: %clang -target arm-apple-darwin-eabi -arch armv7em -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-EABI %s // RUN: %clang -target thumbv7-apple-darwin-eabi -arch armv7 -x c -E -dM %s -o - | FileCheck --check-prefix=ARM-DARWIN-NO-EABI %s // ARM-DARWIN-NO-EABI-NOT: #define __ARM_EABI__ 1 +// ARM-DARWIN-EABI: #define __ARM_EABI__ 1 // Check that -mhwdiv works properly for targets which don't have the hwdiv feature enabled by default. @@ -2546,7 +2739,7 @@ // MIPS32BE:#define __SIZE_TYPE__ unsigned int // MIPS32BE:#define __SIZE_WIDTH__ 32 // MIPS32BE:#define __STDC_HOSTED__ 0 -// MIPS32BE:#define __STDC_VERSION__ 199901L +// MIPS32BE:#define __STDC_VERSION__ 201112L // MIPS32BE:#define __STDC__ 1 // MIPS32BE:#define __UINT16_C_SUFFIX__ {{$}} // MIPS32BE:#define __UINT16_MAX__ 65535 @@ -2945,6 +3138,7 @@ // MIPS64BE:#define __SIG_ATOMIC_WIDTH__ 32 // MIPS64BE:#define __SIZEOF_DOUBLE__ 8 // MIPS64BE:#define __SIZEOF_FLOAT__ 4 +// MIPS64BE-NOT:#define __SIZEOF_INT128__ 16 // MIPS64BE:#define __SIZEOF_INT__ 4 // MIPS64BE:#define __SIZEOF_LONG_DOUBLE__ 16 // MIPS64BE:#define __SIZEOF_LONG_LONG__ 8 @@ -3152,6 +3346,7 @@ // MIPS64EL:#define __SIG_ATOMIC_WIDTH__ 32 // MIPS64EL:#define __SIZEOF_DOUBLE__ 8 // MIPS64EL:#define __SIZEOF_FLOAT__ 4 +// MIPS64EL-NOT:#define __SIZEOF_INT128__ 16 // MIPS64EL:#define __SIZEOF_INT__ 4 // MIPS64EL:#define __SIZEOF_LONG_DOUBLE__ 16 // MIPS64EL:#define __SIZEOF_LONG_LONG__ 8 @@ -4917,6 +5112,15 @@ // PPC64-LINUX:#define __powerpc__ 1 // PPC64-LINUX:#define __ppc64__ 1 // PPC64-LINUX:#define __ppc__ 1 + +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64-unknown-linux-gnu < /dev/null | FileCheck -check-prefix PPC64-ELFv1 %s +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64-unknown-linux-gnu -target-abi elfv1 < /dev/null | FileCheck -check-prefix PPC64-ELFv1 %s +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64-unknown-linux-gnu -target-abi elfv2 < /dev/null | FileCheck -check-prefix PPC64-ELFv2 %s +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64le-unknown-linux-gnu < /dev/null | FileCheck -check-prefix PPC64-ELFv2 %s +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64le-unknown-linux-gnu -target-abi elfv1 < /dev/null | FileCheck -check-prefix PPC64-ELFv1 %s +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64le-unknown-linux-gnu -target-abi elfv2 < /dev/null | FileCheck -check-prefix PPC64-ELFv2 %s +// PPC64-ELFv1:#define _CALL_ELF 1 +// PPC64-ELFv2:#define _CALL_ELF 2 // // RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc-none-none -fno-signed-char < /dev/null | FileCheck -check-prefix PPC %s // @@ -5449,7 +5653,7 @@ // PPC-DARWIN:#define __SIZE_TYPE__ long unsigned int // PPC-DARWIN:#define __SIZE_WIDTH__ 32 // PPC-DARWIN:#define __STDC_HOSTED__ 0 -// PPC-DARWIN:#define __STDC_VERSION__ 199901L +// PPC-DARWIN:#define __STDC_VERSION__ 201112L // PPC-DARWIN:#define __STDC__ 1 // PPC-DARWIN:#define __UINT16_C_SUFFIX__ {{$}} // PPC-DARWIN:#define __UINT16_MAX__ 65535 @@ -6222,6 +6426,13 @@ // X86_64:#define __x86_64 1 // X86_64:#define __x86_64__ 1 // +// RUN: %clang_cc1 -E -dM -ffreestanding -triple=x86_64h-none-none < /dev/null | FileCheck -check-prefix X86_64H %s +// +// X86_64H:#define __x86_64 1 +// X86_64H:#define __x86_64__ 1 +// X86_64H:#define __x86_64h 1 +// X86_64H:#define __x86_64h__ 1 + // RUN: %clang_cc1 -E -dM -ffreestanding -triple=x86_64-none-none-gnux32 < /dev/null | FileCheck -check-prefix X32 %s // // X32:#define _ILP32 1 diff --git a/test/Preprocessor/iwithprefix.c b/test/Preprocessor/iwithprefix.c index 59935ac1b8b5..a65a8043aa71 100644 --- a/test/Preprocessor/iwithprefix.c +++ b/test/Preprocessor/iwithprefix.c @@ -9,7 +9,7 @@ // CHECK: #include <...> search starts here: // CHECK: {{.*}}.tmps/first -// CHECK: {{/|\\}}lib{{/|\\}}clang{{/|\\}}{{[.0-9]+}}{{/|\\}}include +// CHECK: {{/|\\}}lib{{(32|64)?}}{{/|\\}}clang{{/|\\}}{{[.0-9]+}}{{/|\\}}include // CHECK: {{.*}}.tmps/second // CHECK-NOT: {{.*}}.tmps diff --git a/test/Preprocessor/line-directive.c b/test/Preprocessor/line-directive.c index 0dd658f7f1a1..2ebe87e4680d 100644 --- a/test/Preprocessor/line-directive.c +++ b/test/Preprocessor/line-directive.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s +// RUN: %clang_cc1 -std=c99 -fsyntax-only -verify -pedantic %s // RUN: not %clang_cc1 -E %s 2>&1 | grep 'blonk.c:92:2: error: ABC' // RUN: not %clang_cc1 -E %s 2>&1 | grep 'blonk.c:93:2: error: DEF' diff --git a/test/Preprocessor/macro-reserved-cxx11.cpp b/test/Preprocessor/macro-reserved-cxx11.cpp new file mode 100644 index 000000000000..a740ff612954 --- /dev/null +++ b/test/Preprocessor/macro-reserved-cxx11.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -pedantic -verify %s + +#define for 0 // expected-warning {{keyword is hidden by macro definition}} +#define final 1 // expected-warning {{keyword is hidden by macro definition}} +#define override // expected-warning {{keyword is hidden by macro definition}} + +int x; diff --git a/test/Preprocessor/macro-reserved-ms.c b/test/Preprocessor/macro-reserved-ms.c new file mode 100644 index 000000000000..c533ee36bde4 --- /dev/null +++ b/test/Preprocessor/macro-reserved-ms.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -fms-extensions -verify %s +// expected-no-diagnostics + +#define inline _inline +#undef inline + +int x; diff --git a/test/Preprocessor/macro-reserved.c b/test/Preprocessor/macro-reserved.c new file mode 100644 index 000000000000..84b9262cb82e --- /dev/null +++ b/test/Preprocessor/macro-reserved.c @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +#define for 0 // expected-warning {{keyword is hidden by macro definition}} +#define final 1 +#define __HAVE_X 0 +#define __cplusplus +#define _HAVE_X 0 +#define X__Y + +#undef for +#undef final +#undef __HAVE_X +#undef __cplusplus +#undef _HAVE_X +#undef X__Y + +// whitelisted definitions +#define while while +#define const +#define static +#define extern +#define inline + +#undef while +#undef const +#undef static +#undef extern +#undef inline + +#define inline __inline +#undef inline +#define inline __inline__ +#undef inline + +#define inline inline__ // expected-warning {{keyword is hidden by macro definition}} +#undef inline +#define extern __inline // expected-warning {{keyword is hidden by macro definition}} +#undef extern +#define extern __extern // expected-warning {{keyword is hidden by macro definition}} +#undef extern +#define extern __extern__ // expected-warning {{keyword is hidden by macro definition}} +#undef extern + +#define inline _inline // expected-warning {{keyword is hidden by macro definition}} +#undef inline +#define volatile // expected-warning {{keyword is hidden by macro definition}} +#undef volatile + +#pragma clang diagnostic warning "-Wreserved-id-macro" + +#define switch if // expected-warning {{keyword is hidden by macro definition}} +#define final 1 +#define __clusplus // expected-warning {{macro name is a reserved identifier}} +#define __HAVE_X 0 // expected-warning {{macro name is a reserved identifier}} +#define _HAVE_X 0 // expected-warning {{macro name is a reserved identifier}} +#define X__Y + +#undef switch +#undef final +#undef __cplusplus // expected-warning {{macro name is a reserved identifier}} +#undef _HAVE_X // expected-warning {{macro name is a reserved identifier}} +#undef X__Y + +int x; diff --git a/test/Preprocessor/macro-reserved.cpp b/test/Preprocessor/macro-reserved.cpp new file mode 100644 index 000000000000..ba1594a0af49 --- /dev/null +++ b/test/Preprocessor/macro-reserved.cpp @@ -0,0 +1,63 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +#define for 0 // expected-warning {{keyword is hidden by macro definition}} +#define final 1 +#define __HAVE_X 0 +#define _HAVE_X 0 +#define X__Y + +#undef for +#undef final +#undef __HAVE_X +#undef _HAVE_X +#undef X__Y + +#undef __cplusplus +#define __cplusplus + +// whitelisted definitions +#define while while +#define const +#define static +#define extern +#define inline + +#undef while +#undef const +#undef static +#undef extern +#undef inline + +#define inline __inline +#undef inline +#define inline __inline__ +#undef inline + +#define inline inline__ // expected-warning {{keyword is hidden by macro definition}} +#undef inline +#define extern __inline // expected-warning {{keyword is hidden by macro definition}} +#undef extern +#define extern __extern // expected-warning {{keyword is hidden by macro definition}} +#undef extern +#define extern __extern__ // expected-warning {{keyword is hidden by macro definition}} +#undef extern + +#define inline _inline // expected-warning {{keyword is hidden by macro definition}} +#undef inline +#define volatile // expected-warning {{keyword is hidden by macro definition}} +#undef volatile + + +#pragma clang diagnostic warning "-Wreserved-id-macro" + +#define switch if // expected-warning {{keyword is hidden by macro definition}} +#define final 1 +#define __HAVE_X 0 // expected-warning {{macro name is a reserved identifier}} +#define _HAVE_X 0 // expected-warning {{macro name is a reserved identifier}} +#define X__Y // expected-warning {{macro name is a reserved identifier}} + +#undef __cplusplus // expected-warning {{macro name is a reserved identifier}} +#undef _HAVE_X // expected-warning {{macro name is a reserved identifier}} +#undef X__Y // expected-warning {{macro name is a reserved identifier}} + +int x; diff --git a/test/Preprocessor/macro_arg_directive.c b/test/Preprocessor/macro_arg_directive.c index 5bc2236f0c45..21d1b20acf66 100644 --- a/test/Preprocessor/macro_arg_directive.c +++ b/test/Preprocessor/macro_arg_directive.c @@ -7,6 +7,11 @@ a(n = a); _Static_assert(n == 5, ""); +#define M(A) +M( +#pragma pack(pop) // expected-error {{embedding a #pragma directive within macro arguments is not supported}} +) + // header1.h void fail(const char *); #define MUNCH(...) \ diff --git a/test/Preprocessor/macro_paste_bad.c b/test/Preprocessor/macro_paste_bad.c index ec10006ae3d7..23777240cbf7 100644 --- a/test/Preprocessor/macro_paste_bad.c +++ b/test/Preprocessor/macro_paste_bad.c @@ -34,3 +34,11 @@ int VA; // expected-warning {{__VA_ARGS__ can only appear in the expansion of #define LOG_ON_ERROR(x) x ## #y; // expected-error {{'#' is not followed by a macro parameter}} LOG_ON_ERROR(0); + +#define PR21379A(x) printf ##x // expected-note {{macro 'PR21379A' defined here}} +PR21379A(0 {, }) // expected-error {{too many arguments provided to function-like macro invocation}} + // expected-note@-1 {{parentheses are required around macro argument containing braced initializer list}} + +#define PR21379B(x) printf #x // expected-note {{macro 'PR21379B' defined here}} +PR21379B(0 {, }) // expected-error {{too many arguments provided to function-like macro invocation}} + // expected-note@-1 {{parentheses are required around macro argument containing braced initializer list}} diff --git a/test/Preprocessor/predefined-arch-macros.c b/test/Preprocessor/predefined-arch-macros.c index cba458e7267f..5bdbdbc622b0 100644 --- a/test/Preprocessor/predefined-arch-macros.c +++ b/test/Preprocessor/predefined-arch-macros.c @@ -562,6 +562,70 @@ // CHECK_CORE_AVX2_M64: #define __x86_64 1 // CHECK_CORE_AVX2_M64: #define __x86_64__ 1 // +// RUN: %clang -march=broadwell -m32 -E -dM %s -o - 2>&1 \ +// RUN: -target i386-unknown-linux \ +// RUN: | FileCheck %s -check-prefix=CHECK_BROADWELL_M32 +// CHECK_BROADWELL_M32: #define __ADX__ 1 +// CHECK_BROADWELL_M32: #define __AES__ 1 +// CHECK_BROADWELL_M32: #define __AVX2__ 1 +// CHECK_BROADWELL_M32: #define __AVX__ 1 +// CHECK_BROADWELL_M32: #define __BMI2__ 1 +// CHECK_BROADWELL_M32: #define __BMI__ 1 +// CHECK_BROADWELL_M32: #define __F16C__ 1 +// CHECK_BROADWELL_M32: #define __FMA__ 1 +// CHECK_BROADWELL_M32: #define __LZCNT__ 1 +// CHECK_BROADWELL_M32: #define __MMX__ 1 +// CHECK_BROADWELL_M32: #define __PCLMUL__ 1 +// CHECK_BROADWELL_M32: #define __POPCNT__ 1 +// CHECK_BROADWELL_M32: #define __RDRND__ 1 +// CHECK_BROADWELL_M32: #define __RDSEED__ 1 +// CHECK_BROADWELL_M32: #define __RTM__ 1 +// CHECK_BROADWELL_M32: #define __SSE2__ 1 +// CHECK_BROADWELL_M32: #define __SSE3__ 1 +// CHECK_BROADWELL_M32: #define __SSE4_1__ 1 +// CHECK_BROADWELL_M32: #define __SSE4_2__ 1 +// CHECK_BROADWELL_M32: #define __SSE__ 1 +// CHECK_BROADWELL_M32: #define __SSSE3__ 1 +// CHECK_BROADWELL_M32: #define __corei7 1 +// CHECK_BROADWELL_M32: #define __corei7__ 1 +// CHECK_BROADWELL_M32: #define __i386 1 +// CHECK_BROADWELL_M32: #define __i386__ 1 +// CHECK_BROADWELL_M32: #define __tune_corei7__ 1 +// CHECK_BROADWELL_M32: #define i386 1 +// RUN: %clang -march=broadwell -m64 -E -dM %s -o - 2>&1 \ +// RUN: -target i386-unknown-linux \ +// RUN: | FileCheck %s -check-prefix=CHECK_BROADWELL_M64 +// CHECK_BROADWELL_M64: #define __ADX__ 1 +// CHECK_BROADWELL_M64: #define __AES__ 1 +// CHECK_BROADWELL_M64: #define __AVX2__ 1 +// CHECK_BROADWELL_M64: #define __AVX__ 1 +// CHECK_BROADWELL_M64: #define __BMI2__ 1 +// CHECK_BROADWELL_M64: #define __BMI__ 1 +// CHECK_BROADWELL_M64: #define __F16C__ 1 +// CHECK_BROADWELL_M64: #define __FMA__ 1 +// CHECK_BROADWELL_M64: #define __LZCNT__ 1 +// CHECK_BROADWELL_M64: #define __MMX__ 1 +// CHECK_BROADWELL_M64: #define __PCLMUL__ 1 +// CHECK_BROADWELL_M64: #define __POPCNT__ 1 +// CHECK_BROADWELL_M64: #define __RDRND__ 1 +// CHECK_BROADWELL_M64: #define __RDSEED__ 1 +// CHECK_BROADWELL_M64: #define __RTM__ 1 +// CHECK_BROADWELL_M64: #define __SSE2_MATH__ 1 +// CHECK_BROADWELL_M64: #define __SSE2__ 1 +// CHECK_BROADWELL_M64: #define __SSE3__ 1 +// CHECK_BROADWELL_M64: #define __SSE4_1__ 1 +// CHECK_BROADWELL_M64: #define __SSE4_2__ 1 +// CHECK_BROADWELL_M64: #define __SSE_MATH__ 1 +// CHECK_BROADWELL_M64: #define __SSE__ 1 +// CHECK_BROADWELL_M64: #define __SSSE3__ 1 +// CHECK_BROADWELL_M64: #define __amd64 1 +// CHECK_BROADWELL_M64: #define __amd64__ 1 +// CHECK_BROADWELL_M64: #define __corei7 1 +// CHECK_BROADWELL_M64: #define __corei7__ 1 +// CHECK_BROADWELL_M64: #define __tune_corei7__ 1 +// CHECK_BROADWELL_M64: #define __x86_64 1 +// CHECK_BROADWELL_M64: #define __x86_64__ 1 +// // RUN: %clang -march=knl -m32 -E -dM %s -o - 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: | FileCheck %s -check-prefix=CHECK_KNL_M32 @@ -594,6 +658,7 @@ // CHECK_KNL_M32: #define __knl__ 1 // CHECK_KNL_M32: #define __tune_knl__ 1 // CHECK_KNL_M32: #define i386 1 + // RUN: %clang -march=knl -m64 -E -dM %s -o - 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: | FileCheck %s -check-prefix=CHECK_KNL_M64 @@ -630,6 +695,77 @@ // CHECK_KNL_M64: #define __x86_64 1 // CHECK_KNL_M64: #define __x86_64__ 1 // +// RUN: %clang -march=skx -m32 -E -dM %s -o - 2>&1 \ +// RUN: -target i386-unknown-linux \ +// RUN: | FileCheck %s -check-prefix=CHECK_SKX_M32 +// CHECK_SKX_M32: #define __AES__ 1 +// CHECK_SKX_M32: #define __AVX2__ 1 +// CHECK_SKX_M32: #define __AVX512BW__ 1 +// CHECK_SKX_M32: #define __AVX512CD__ 1 +// CHECK_SKX_M32: #define __AVX512DQ__ 1 +// CHECK_SKX_M32: #define __AVX512F__ 1 +// CHECK_SKX_M32: #define __AVX512VL__ 1 +// CHECK_SKX_M32: #define __AVX__ 1 +// CHECK_SKX_M32: #define __BMI2__ 1 +// CHECK_SKX_M32: #define __BMI__ 1 +// CHECK_SKX_M32: #define __F16C__ 1 +// CHECK_SKX_M32: #define __FMA__ 1 +// CHECK_SKX_M32: #define __LZCNT__ 1 +// CHECK_SKX_M32: #define __MMX__ 1 +// CHECK_SKX_M32: #define __PCLMUL__ 1 +// CHECK_SKX_M32: #define __POPCNT__ 1 +// CHECK_SKX_M32: #define __RDRND__ 1 +// CHECK_SKX_M32: #define __RTM__ 1 +// CHECK_SKX_M32: #define __SSE2__ 1 +// CHECK_SKX_M32: #define __SSE3__ 1 +// CHECK_SKX_M32: #define __SSE4_1__ 1 +// CHECK_SKX_M32: #define __SSE4_2__ 1 +// CHECK_SKX_M32: #define __SSE__ 1 +// CHECK_SKX_M32: #define __SSSE3__ 1 +// CHECK_SKX_M32: #define __i386 1 +// CHECK_SKX_M32: #define __i386__ 1 +// CHECK_SKX_M32: #define __skx 1 +// CHECK_SKX_M32: #define __skx__ 1 +// CHECK_SKX_M32: #define __tune_skx__ 1 +// CHECK_SKX_M32: #define i386 1 + +// RUN: %clang -march=skx -m64 -E -dM %s -o - 2>&1 \ +// RUN: -target i386-unknown-linux \ +// RUN: | FileCheck %s -check-prefix=CHECK_SKX_M64 +// CHECK_SKX_M64: #define __AES__ 1 +// CHECK_SKX_M64: #define __AVX2__ 1 +// CHECK_SKX_M64: #define __AVX512BW__ 1 +// CHECK_SKX_M64: #define __AVX512CD__ 1 +// CHECK_SKX_M64: #define __AVX512DQ__ 1 +// CHECK_SKX_M64: #define __AVX512F__ 1 +// CHECK_SKX_M64: #define __AVX512VL__ 1 +// CHECK_SKX_M64: #define __AVX__ 1 +// CHECK_SKX_M64: #define __BMI2__ 1 +// CHECK_SKX_M64: #define __BMI__ 1 +// CHECK_SKX_M64: #define __F16C__ 1 +// CHECK_SKX_M64: #define __FMA__ 1 +// CHECK_SKX_M64: #define __LZCNT__ 1 +// CHECK_SKX_M64: #define __MMX__ 1 +// CHECK_SKX_M64: #define __PCLMUL__ 1 +// CHECK_SKX_M64: #define __POPCNT__ 1 +// CHECK_SKX_M64: #define __RDRND__ 1 +// CHECK_SKX_M64: #define __RTM__ 1 +// CHECK_SKX_M64: #define __SSE2_MATH__ 1 +// CHECK_SKX_M64: #define __SSE2__ 1 +// CHECK_SKX_M64: #define __SSE3__ 1 +// CHECK_SKX_M64: #define __SSE4_1__ 1 +// CHECK_SKX_M64: #define __SSE4_2__ 1 +// CHECK_SKX_M64: #define __SSE_MATH__ 1 +// CHECK_SKX_M64: #define __SSE__ 1 +// CHECK_SKX_M64: #define __SSSE3__ 1 +// CHECK_SKX_M64: #define __amd64 1 +// CHECK_SKX_M64: #define __amd64__ 1 +// CHECK_SKX_M64: #define __skx 1 +// CHECK_SKX_M64: #define __skx__ 1 +// CHECK_SKX_M64: #define __tune_skx__ 1 +// CHECK_SKX_M64: #define __x86_64 1 +// CHECK_SKX_M64: #define __x86_64__ 1 +// // RUN: %clang -march=atom -m32 -E -dM %s -o - 2>&1 \ // RUN: -target i386-unknown-linux \ // RUN: | FileCheck %s -check-prefix=CHECK_ATOM_M32 @@ -1206,8 +1342,11 @@ // CHECK_BTVER2_M32-NOT: #define __3dNOW__ 1 // CHECK_BTVER2_M32: #define __AES__ 1 // CHECK_BTVER2_M32: #define __AVX__ 1 +// CHECK_BTVER2_M32: #define __BMI__ 1 +// CHECK_BTVER2_M32: #define __F16C__ 1 // CHECK_BTVER2_M32: #define __LZCNT__ 1 // CHECK_BTVER2_M32: #define __MMX__ 1 +// CHECK_BTVER2_M32: #define __PCLMUL__ 1 // CHECK_BTVER2_M32: #define __POPCNT__ 1 // CHECK_BTVER2_M32: #define __PRFCHW__ 1 // CHECK_BTVER2_M32: #define __SSE2_MATH__ 1 @@ -1229,8 +1368,11 @@ // CHECK_BTVER2_M64-NOT: #define __3dNOW__ 1 // CHECK_BTVER2_M64: #define __AES__ 1 // CHECK_BTVER2_M64: #define __AVX__ 1 +// CHECK_BTVER2_M64: #define __BMI__ 1 +// CHECK_BTVER2_M64: #define __F16C__ 1 // CHECK_BTVER2_M64: #define __LZCNT__ 1 // CHECK_BTVER2_M64: #define __MMX__ 1 +// CHECK_BTVER2_M64: #define __PCLMUL__ 1 // CHECK_BTVER2_M64: #define __POPCNT__ 1 // CHECK_BTVER2_M64: #define __PRFCHW__ 1 // CHECK_BTVER2_M64: #define __SSE2_MATH__ 1 @@ -1382,6 +1524,7 @@ // CHECK_BDVER3_M32: #define __F16C__ 1 // CHECK_BDVER3_M32: #define __FMA4__ 1 // CHECK_BDVER3_M32: #define __FMA__ 1 +// CHECK_BDVER3_M32: #define __FSGSBASE__ 1 // CHECK_BDVER3_M32: #define __LZCNT__ 1 // CHECK_BDVER3_M32: #define __MMX__ 1 // CHECK_BDVER3_M32: #define __PCLMUL__ 1 @@ -1414,6 +1557,7 @@ // CHECK_BDVER3_M64: #define __F16C__ 1 // CHECK_BDVER3_M64: #define __FMA4__ 1 // CHECK_BDVER3_M64: #define __FMA__ 1 +// CHECK_BDVER3_M64: #define __FSGSBASE__ 1 // CHECK_BDVER3_M64: #define __LZCNT__ 1 // CHECK_BDVER3_M64: #define __MMX__ 1 // CHECK_BDVER3_M64: #define __PCLMUL__ 1 @@ -1450,6 +1594,7 @@ // CHECK_BDVER4_M32: #define __F16C__ 1 // CHECK_BDVER4_M32: #define __FMA4__ 1 // CHECK_BDVER4_M32: #define __FMA__ 1 +// CHECK_BDVER4_M32: #define __FSGSBASE__ 1 // CHECK_BDVER4_M32: #define __LZCNT__ 1 // CHECK_BDVER4_M32: #define __MMX__ 1 // CHECK_BDVER4_M32: #define __PCLMUL__ 1 @@ -1484,6 +1629,7 @@ // CHECK_BDVER4_M64: #define __F16C__ 1 // CHECK_BDVER4_M64: #define __FMA4__ 1 // CHECK_BDVER4_M64: #define __FMA__ 1 +// CHECK_BDVER4_M64: #define __FSGSBASE__ 1 // CHECK_BDVER4_M64: #define __LZCNT__ 1 // CHECK_BDVER4_M64: #define __MMX__ 1 // CHECK_BDVER4_M64: #define __PCLMUL__ 1 @@ -1516,3 +1662,10 @@ // RUN: | FileCheck %s -check-prefix=CHECK_PPC_VSX_M64 // // CHECK_PPC_VSX_M64: #define __VSX__ +// +// RUN: %clang -mpower8-vector -E -dM %s -o - 2>&1 \ +// RUN: -target powerpc64-unknown-linux \ +// RUN: | FileCheck %s -check-prefix=CHECK_PPC_POWER8_VECTOR_M64 +// +// CHECK_PPC_POWER8_VECTOR_M64: #define __POWER8_VECTOR__ +// diff --git a/test/Preprocessor/predefined-exceptions.m b/test/Preprocessor/predefined-exceptions.m index c13f429e3763..0791075dfc75 100644 --- a/test/Preprocessor/predefined-exceptions.m +++ b/test/Preprocessor/predefined-exceptions.m @@ -1,6 +1,6 @@ // RUN: %clang_cc1 -x objective-c -fobjc-exceptions -fexceptions -E -dM %s | FileCheck -check-prefix=CHECK-OBJC-NOCXX %s // CHECK-OBJC-NOCXX: #define OBJC_ZEROCOST_EXCEPTIONS 1 -// CHECK-OBJC-NOCXX-NOT: #define __EXCEPTIONS 1 +// CHECK-OBJC-NOCXX: #define __EXCEPTIONS 1 // RUN: %clang_cc1 -x objective-c++ -fobjc-exceptions -fexceptions -fcxx-exceptions -E -dM %s | FileCheck -check-prefix=CHECK-OBJC-CXX %s // CHECK-OBJC-CXX: #define OBJC_ZEROCOST_EXCEPTIONS 1 diff --git a/test/Preprocessor/predefined-macros.c b/test/Preprocessor/predefined-macros.c index 1db9080ac34c..a32f4a158c9b 100644 --- a/test/Preprocessor/predefined-macros.c +++ b/test/Preprocessor/predefined-macros.c @@ -28,59 +28,59 @@ // // RUN: %clang_cc1 %s -E -dM -triple i686-pc-win32 -fms-compatibility \ // RUN: -o - | FileCheck %s --check-prefix=CHECK-MS-STDINT -// CHECK-MS-STDINT-NOT:#define __INT16_MAX__ 32767 -// CHECK-MS-STDINT-NOT:#define __INT32_MAX__ 2147483647 -// CHECK-MS-STDINT-NOT:#define __INT64_MAX__ 9223372036854775807LL -// CHECK-MS-STDINT-NOT:#define __INT8_MAX__ 127 -// CHECK-MS-STDINT-NOT:#define __INTPTR_MAX__ 2147483647 -// CHECK-MS-STDINT-NOT:#define __INT_FAST16_MAX__ 32767 -// CHECK-MS-STDINT-NOT:#define __INT_FAST16_TYPE__ short -// CHECK-MS-STDINT-NOT:#define __INT_FAST32_MAX__ 2147483647 -// CHECK-MS-STDINT-NOT:#define __INT_FAST32_TYPE__ int -// CHECK-MS-STDINT-NOT:#define __INT_FAST64_MAX__ 9223372036854775807LL -// CHECK-MS-STDINT-NOT:#define __INT_FAST64_TYPE__ long long int -// CHECK-MS-STDINT-NOT:#define __INT_FAST8_MAX__ 127 -// CHECK-MS-STDINT-NOT:#define __INT_FAST8_TYPE__ char -// CHECK-MS-STDINT-NOT:#define __INT_LEAST16_MAX__ 32767 -// CHECK-MS-STDINT-NOT:#define __INT_LEAST16_TYPE__ short -// CHECK-MS-STDINT-NOT:#define __INT_LEAST32_MAX__ 2147483647 -// CHECK-MS-STDINT-NOT:#define __INT_LEAST32_TYPE__ int -// CHECK-MS-STDINT-NOT:#define __INT_LEAST64_MAX__ 9223372036854775807LL -// CHECK-MS-STDINT-NOT:#define __INT_LEAST64_TYPE__ long long int -// CHECK-MS-STDINT-NOT:#define __INT_LEAST8_MAX__ 127 -// CHECK-MS-STDINT-NOT:#define __INT_LEAST8_TYPE__ char +// CHECK-MS-STDINT:#define __INT16_MAX__ 32767 +// CHECK-MS-STDINT:#define __INT32_MAX__ 2147483647 +// CHECK-MS-STDINT:#define __INT64_MAX__ 9223372036854775807LL +// CHECK-MS-STDINT:#define __INT8_MAX__ 127 +// CHECK-MS-STDINT:#define __INTPTR_MAX__ 2147483647 +// CHECK-MS-STDINT:#define __INT_FAST16_MAX__ 32767 +// CHECK-MS-STDINT:#define __INT_FAST16_TYPE__ short +// CHECK-MS-STDINT:#define __INT_FAST32_MAX__ 2147483647 +// CHECK-MS-STDINT:#define __INT_FAST32_TYPE__ int +// CHECK-MS-STDINT:#define __INT_FAST64_MAX__ 9223372036854775807LL +// CHECK-MS-STDINT:#define __INT_FAST64_TYPE__ long long int +// CHECK-MS-STDINT:#define __INT_FAST8_MAX__ 127 +// CHECK-MS-STDINT:#define __INT_FAST8_TYPE__ signed char +// CHECK-MS-STDINT:#define __INT_LEAST16_MAX__ 32767 +// CHECK-MS-STDINT:#define __INT_LEAST16_TYPE__ short +// CHECK-MS-STDINT:#define __INT_LEAST32_MAX__ 2147483647 +// CHECK-MS-STDINT:#define __INT_LEAST32_TYPE__ int +// CHECK-MS-STDINT:#define __INT_LEAST64_MAX__ 9223372036854775807LL +// CHECK-MS-STDINT:#define __INT_LEAST64_TYPE__ long long int +// CHECK-MS-STDINT:#define __INT_LEAST8_MAX__ 127 +// CHECK-MS-STDINT:#define __INT_LEAST8_TYPE__ signed char // CHECK-MS-STDINT-NOT:#define __UINT16_C_SUFFIX__ U -// CHECK-MS-STDINT-NOT:#define __UINT16_MAX__ 65535U -// CHECK-MS-STDINT-NOT:#define __UINT16_TYPE__ unsigned short -// CHECK-MS-STDINT-NOT:#define __UINT32_C_SUFFIX__ U -// CHECK-MS-STDINT-NOT:#define __UINT32_MAX__ 4294967295U -// CHECK-MS-STDINT-NOT:#define __UINT32_TYPE__ unsigned int -// CHECK-MS-STDINT-NOT:#define __UINT64_C_SUFFIX__ ULL -// CHECK-MS-STDINT-NOT:#define __UINT64_MAX__ 18446744073709551615ULL -// CHECK-MS-STDINT-NOT:#define __UINT64_TYPE__ long long unsigned int +// CHECK-MS-STDINT:#define __UINT16_MAX__ 65535 +// CHECK-MS-STDINT:#define __UINT16_TYPE__ unsigned short +// CHECK-MS-STDINT:#define __UINT32_C_SUFFIX__ U +// CHECK-MS-STDINT:#define __UINT32_MAX__ 4294967295U +// CHECK-MS-STDINT:#define __UINT32_TYPE__ unsigned int +// CHECK-MS-STDINT:#define __UINT64_C_SUFFIX__ ULL +// CHECK-MS-STDINT:#define __UINT64_MAX__ 18446744073709551615ULL +// CHECK-MS-STDINT:#define __UINT64_TYPE__ long long unsigned int // CHECK-MS-STDINT-NOT:#define __UINT8_C_SUFFIX__ U -// CHECK-MS-STDINT-NOT:#define __UINT8_MAX__ 255U -// CHECK-MS-STDINT-NOT:#define __UINT8_TYPE__ unsigned char -// CHECK-MS-STDINT-NOT:#define __UINTMAX_MAX__ 18446744073709551615ULL -// CHECK-MS-STDINT-NOT:#define __UINTPTR_MAX__ 4294967295U -// CHECK-MS-STDINT-NOT:#define __UINTPTR_TYPE__ unsigned int -// CHECK-MS-STDINT-NOT:#define __UINTPTR_WIDTH__ 32 -// CHECK-MS-STDINT-NOT:#define __UINT_FAST16_MAX__ 65535U -// CHECK-MS-STDINT-NOT:#define __UINT_FAST16_TYPE__ unsigned short -// CHECK-MS-STDINT-NOT:#define __UINT_FAST32_MAX__ 4294967295U -// CHECK-MS-STDINT-NOT:#define __UINT_FAST32_TYPE__ unsigned int -// CHECK-MS-STDINT-NOT:#define __UINT_FAST64_MAX__ 18446744073709551615ULL -// CHECK-MS-STDINT-NOT:#define __UINT_FAST64_TYPE__ long long unsigned int -// CHECK-MS-STDINT-NOT:#define __UINT_FAST8_MAX__ 255U -// CHECK-MS-STDINT-NOT:#define __UINT_FAST8_TYPE__ unsigned char -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST16_MAX__ 65535U -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST16_TYPE__ unsigned short -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST32_MAX__ 4294967295U -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST32_TYPE__ unsigned int -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST64_MAX__ 18446744073709551615ULL -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST64_TYPE__ long long unsigned int -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST8_MAX__ 255U -// CHECK-MS-STDINT-NOT:#define __UINT_LEAST8_TYPE__ unsigned char +// CHECK-MS-STDINT:#define __UINT8_MAX__ 255 +// CHECK-MS-STDINT:#define __UINT8_TYPE__ unsigned char +// CHECK-MS-STDINT:#define __UINTMAX_MAX__ 18446744073709551615ULL +// CHECK-MS-STDINT:#define __UINTPTR_MAX__ 4294967295U +// CHECK-MS-STDINT:#define __UINTPTR_TYPE__ unsigned int +// CHECK-MS-STDINT:#define __UINTPTR_WIDTH__ 32 +// CHECK-MS-STDINT:#define __UINT_FAST16_MAX__ 65535 +// CHECK-MS-STDINT:#define __UINT_FAST16_TYPE__ unsigned short +// CHECK-MS-STDINT:#define __UINT_FAST32_MAX__ 4294967295U +// CHECK-MS-STDINT:#define __UINT_FAST32_TYPE__ unsigned int +// CHECK-MS-STDINT:#define __UINT_FAST64_MAX__ 18446744073709551615ULL +// CHECK-MS-STDINT:#define __UINT_FAST64_TYPE__ long long unsigned int +// CHECK-MS-STDINT:#define __UINT_FAST8_MAX__ 255 +// CHECK-MS-STDINT:#define __UINT_FAST8_TYPE__ unsigned char +// CHECK-MS-STDINT:#define __UINT_LEAST16_MAX__ 65535 +// CHECK-MS-STDINT:#define __UINT_LEAST16_TYPE__ unsigned short +// CHECK-MS-STDINT:#define __UINT_LEAST32_MAX__ 4294967295U +// CHECK-MS-STDINT:#define __UINT_LEAST32_TYPE__ unsigned int +// CHECK-MS-STDINT:#define __UINT_LEAST64_MAX__ 18446744073709551615ULL +// CHECK-MS-STDINT:#define __UINT_LEAST64_TYPE__ long long unsigned int +// CHECK-MS-STDINT:#define __UINT_LEAST8_MAX__ 255 +// CHECK-MS-STDINT:#define __UINT_LEAST8_TYPE__ unsigned char // // RUN: %clang_cc1 %s -E -dM -ffast-math -o - \ // RUN: | FileCheck %s --check-prefix=CHECK-FAST-MATH diff --git a/test/Preprocessor/stdint.c b/test/Preprocessor/stdint.c index 94d5b0b0b337..c7189f607cfd 100644 --- a/test/Preprocessor/stdint.c +++ b/test/Preprocessor/stdint.c @@ -634,6 +634,113 @@ // PPC64:INTMAX_C_(0) 0L // PPC64:UINTMAX_C_(0) 0UL // +// RUN: %clang_cc1 -E -ffreestanding -triple=powerpc64-none-netbsd %s | FileCheck -check-prefix PPC64-NETBSD %s +// +// PPC64-NETBSD:typedef long long int int64_t; +// PPC64-NETBSD:typedef long long unsigned int uint64_t; +// PPC64-NETBSD:typedef int64_t int_least64_t; +// PPC64-NETBSD:typedef uint64_t uint_least64_t; +// PPC64-NETBSD:typedef int64_t int_fast64_t; +// PPC64-NETBSD:typedef uint64_t uint_fast64_t; +// +// PPC64-NETBSD:typedef int int32_t; +// PPC64-NETBSD:typedef unsigned int uint32_t; +// PPC64-NETBSD:typedef int32_t int_least32_t; +// PPC64-NETBSD:typedef uint32_t uint_least32_t; +// PPC64-NETBSD:typedef int32_t int_fast32_t; +// PPC64-NETBSD:typedef uint32_t uint_fast32_t; +// +// PPC64-NETBSD:typedef short int16_t; +// PPC64-NETBSD:typedef unsigned short uint16_t; +// PPC64-NETBSD:typedef int16_t int_least16_t; +// PPC64-NETBSD:typedef uint16_t uint_least16_t; +// PPC64-NETBSD:typedef int16_t int_fast16_t; +// PPC64-NETBSD:typedef uint16_t uint_fast16_t; +// +// PPC64-NETBSD:typedef signed char int8_t; +// PPC64-NETBSD:typedef unsigned char uint8_t; +// PPC64-NETBSD:typedef int8_t int_least8_t; +// PPC64-NETBSD:typedef uint8_t uint_least8_t; +// PPC64-NETBSD:typedef int8_t int_fast8_t; +// PPC64-NETBSD:typedef uint8_t uint_fast8_t; +// +// PPC64-NETBSD:typedef int64_t intptr_t; +// PPC64-NETBSD:typedef uint64_t uintptr_t; +// +// PPC64-NETBSD:typedef long long int intmax_t; +// PPC64-NETBSD:typedef long long unsigned int uintmax_t; +// +// PPC64-NETBSD:INT8_MAX_ 127 +// PPC64-NETBSD:INT8_MIN_ (-127 -1) +// PPC64-NETBSD:UINT8_MAX_ 255 +// PPC64-NETBSD:INT_LEAST8_MIN_ (-127 -1) +// PPC64-NETBSD:INT_LEAST8_MAX_ 127 +// PPC64-NETBSD:UINT_LEAST8_MAX_ 255 +// PPC64-NETBSD:INT_FAST8_MIN_ (-127 -1) +// PPC64-NETBSD:INT_FAST8_MAX_ 127 +// PPC64-NETBSD:UINT_FAST8_MAX_ 255 +// +// PPC64-NETBSD:INT16_MAX_ 32767 +// PPC64-NETBSD:INT16_MIN_ (-32767 -1) +// PPC64-NETBSD:UINT16_MAX_ 65535 +// PPC64-NETBSD:INT_LEAST16_MIN_ (-32767 -1) +// PPC64-NETBSD:INT_LEAST16_MAX_ 32767 +// PPC64-NETBSD:UINT_LEAST16_MAX_ 65535 +// PPC64-NETBSD:INT_FAST16_MIN_ (-32767 -1) +// PPC64-NETBSD:INT_FAST16_MAX_ 32767 +// PPC64-NETBSD:UINT_FAST16_MAX_ 65535 +// +// PPC64-NETBSD:INT32_MAX_ 2147483647 +// PPC64-NETBSD:INT32_MIN_ (-2147483647 -1) +// PPC64-NETBSD:UINT32_MAX_ 4294967295U +// PPC64-NETBSD:INT_LEAST32_MIN_ (-2147483647 -1) +// PPC64-NETBSD:INT_LEAST32_MAX_ 2147483647 +// PPC64-NETBSD:UINT_LEAST32_MAX_ 4294967295U +// PPC64-NETBSD:INT_FAST32_MIN_ (-2147483647 -1) +// PPC64-NETBSD:INT_FAST32_MAX_ 2147483647 +// PPC64-NETBSD:UINT_FAST32_MAX_ 4294967295U +// +// PPC64-NETBSD:INT64_MAX_ 9223372036854775807LL +// PPC64-NETBSD:INT64_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:UINT64_MAX_ 18446744073709551615ULL +// PPC64-NETBSD:INT_LEAST64_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:INT_LEAST64_MAX_ 9223372036854775807LL +// PPC64-NETBSD:UINT_LEAST64_MAX_ 18446744073709551615ULL +// PPC64-NETBSD:INT_FAST64_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:INT_FAST64_MAX_ 9223372036854775807LL +// PPC64-NETBSD:UINT_FAST64_MAX_ 18446744073709551615ULL +// +// PPC64-NETBSD:INTPTR_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:INTPTR_MAX_ 9223372036854775807LL +// PPC64-NETBSD:UINTPTR_MAX_ 18446744073709551615ULL +// PPC64-NETBSD:PTRDIFF_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:PTRDIFF_MAX_ 9223372036854775807LL +// PPC64-NETBSD:SIZE_MAX_ 18446744073709551615ULL +// +// PPC64-NETBSD:INTMAX_MIN_ (-9223372036854775807LL -1) +// PPC64-NETBSD:INTMAX_MAX_ 9223372036854775807LL +// PPC64-NETBSD:UINTMAX_MAX_ 18446744073709551615ULL +// +// PPC64-NETBSD:SIG_ATOMIC_MIN_ (-2147483647 -1) +// PPC64-NETBSD:SIG_ATOMIC_MAX_ 2147483647 +// PPC64-NETBSD:WINT_MIN_ (-2147483647 -1) +// PPC64-NETBSD:WINT_MAX_ 2147483647 +// +// PPC64-NETBSD:WCHAR_MAX_ 2147483647 +// PPC64-NETBSD:WCHAR_MIN_ (-2147483647 -1) +// +// PPC64-NETBSD:INT8_C_(0) 0 +// PPC64-NETBSD:UINT8_C_(0) 0U +// PPC64-NETBSD:INT16_C_(0) 0 +// PPC64-NETBSD:UINT16_C_(0) 0U +// PPC64-NETBSD:INT32_C_(0) 0 +// PPC64-NETBSD:UINT32_C_(0) 0U +// PPC64-NETBSD:INT64_C_(0) 0LL +// PPC64-NETBSD:UINT64_C_(0) 0ULL +// +// PPC64-NETBSD:INTMAX_C_(0) 0LL +// PPC64-NETBSD:UINTMAX_C_(0) 0ULL +// // RUN: %clang_cc1 -E -ffreestanding -triple=powerpc-none-none %s | FileCheck -check-prefix PPC %s // // diff --git a/test/Preprocessor/x86_target_features.c b/test/Preprocessor/x86_target_features.c index 7bc5cd8b2c1b..806eeec961d6 100644 --- a/test/Preprocessor/x86_target_features.c +++ b/test/Preprocessor/x86_target_features.c @@ -114,6 +114,51 @@ // AVX512PF: #define __SSE__ 1 // AVX512PF: #define __SSSE3__ 1 +// RUN: %clang -target i386-unknown-unknown -march=atom -mavx512dq -x c -E -dM -o - %s | FileCheck --check-prefix=AVX512DQ %s + +// AVX512DQ: #define __AVX2__ 1 +// AVX512DQ: #define __AVX512DQ__ 1 +// AVX512DQ: #define __AVX512F__ 1 +// AVX512DQ: #define __AVX__ 1 +// AVX512DQ: #define __SSE2_MATH__ 1 +// AVX512DQ: #define __SSE2__ 1 +// AVX512DQ: #define __SSE3__ 1 +// AVX512DQ: #define __SSE4_1__ 1 +// AVX512DQ: #define __SSE4_2__ 1 +// AVX512DQ: #define __SSE_MATH__ 1 +// AVX512DQ: #define __SSE__ 1 +// AVX512DQ: #define __SSSE3__ 1 + +// RUN: %clang -target i386-unknown-unknown -march=atom -mavx512bw -x c -E -dM -o - %s | FileCheck --check-prefix=AVX512BW %s + +// AVX512BW: #define __AVX2__ 1 +// AVX512BW: #define __AVX512BW__ 1 +// AVX512BW: #define __AVX512F__ 1 +// AVX512BW: #define __AVX__ 1 +// AVX512BW: #define __SSE2_MATH__ 1 +// AVX512BW: #define __SSE2__ 1 +// AVX512BW: #define __SSE3__ 1 +// AVX512BW: #define __SSE4_1__ 1 +// AVX512BW: #define __SSE4_2__ 1 +// AVX512BW: #define __SSE_MATH__ 1 +// AVX512BW: #define __SSE__ 1 +// AVX512BW: #define __SSSE3__ 1 + +// RUN: %clang -target i386-unknown-unknown -march=atom -mavx512vl -x c -E -dM -o - %s | FileCheck --check-prefix=AVX512VL %s + +// AVX512VL: #define __AVX2__ 1 +// AVX512VL: #define __AVX512F__ 1 +// AVX512VL: #define __AVX512VL__ 1 +// AVX512VL: #define __AVX__ 1 +// AVX512VL: #define __SSE2_MATH__ 1 +// AVX512VL: #define __SSE2__ 1 +// AVX512VL: #define __SSE3__ 1 +// AVX512VL: #define __SSE4_1__ 1 +// AVX512VL: #define __SSE4_2__ 1 +// AVX512VL: #define __SSE_MATH__ 1 +// AVX512VL: #define __SSE__ 1 +// AVX512VL: #define __SSSE3__ 1 + // RUN: %clang -target i386-unknown-unknown -march=atom -mavx512pf -mno-avx512f -x c -E -dM -o - %s | FileCheck --check-prefix=AVX512F2 %s // AVX512F2: #define __AVX2__ 1 @@ -236,3 +281,11 @@ // NO3DNOWPRFCHW: #define __PRFCHW__ 1 +// RUN: %clang -target i386-unknown-unknown -march=atom -madx -x c -E -dM -o - %s | FileCheck --check-prefix=ADX %s + +// ADX: #define __ADX__ 1 + +// RUN: %clang -target i386-unknown-unknown -march=atom -mrdseed -x c -E -dM -o - %s | FileCheck --check-prefix=RDSEED %s + +// RDSEED: #define __RDSEED__ 1 + diff --git a/test/Profile/Inputs/c-general.profdata.v1 b/test/Profile/Inputs/c-general.profdata.v1 Binary files differnew file mode 100644 index 000000000000..e7dedcbf97f7 --- /dev/null +++ b/test/Profile/Inputs/c-general.profdata.v1 diff --git a/test/Profile/c-captured.c b/test/Profile/c-captured.c index ef7fb318508d..8a9e069ec535 100644 --- a/test/Profile/c-captured.c +++ b/test/Profile/c-captured.c @@ -4,8 +4,8 @@ // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-captured.c %s -o - -emit-llvm -fprofile-instr-use=%t.profdata | FileCheck -check-prefix=PGOUSE -check-prefix=PGOALL %s // PGOGEN: @[[DCC:__llvm_profile_counters_debug_captured]] = hidden global [3 x i64] zeroinitializer -// PGOGEN: @[[CSC:__llvm_profile_counters___captured_stmt]] = internal global [2 x i64] zeroinitializer -// PGOGEN: @[[C1C:__llvm_profile_counters___captured_stmt1]] = internal global [3 x i64] zeroinitializer +// PGOGEN: @[[CSC:"__llvm_profile_counters_c-captured.c:__captured_stmt"]] = internal global [2 x i64] zeroinitializer +// PGOGEN: @[[C1C:"__llvm_profile_counters_c-captured.c:__captured_stmt1"]] = internal global [3 x i64] zeroinitializer // PGOALL-LABEL: define void @debug_captured() // PGOGEN: store {{.*}} @[[DCC]], i64 0, i64 0 @@ -47,11 +47,11 @@ void debug_captured() { if (x) {} // This is DC2. Checked above. } -// PGOUSE-DAG: ![[DC1]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[DC2]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[CS1]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[C11]] = metadata !{metadata !"branch_weights", i32 11, i32 2} -// PGOUSE-DAG: ![[C12]] = metadata !{metadata !"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[DC1]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[DC2]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[CS1]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[C11]] = !{!"branch_weights", i32 11, i32 2} +// PGOUSE-DAG: ![[C12]] = !{!"branch_weights", i32 2, i32 1} int main(int argc, const char *argv[]) { debug_captured(); diff --git a/test/Profile/c-counter-overflows.c b/test/Profile/c-counter-overflows.c index f6f8f73fd949..18a3d33d3ab9 100644 --- a/test/Profile/c-counter-overflows.c +++ b/test/Profile/c-counter-overflows.c @@ -44,6 +44,6 @@ int main(int argc, const char *argv[]) { return 0; } -// CHECK-DAG: ![[FOR]] = metadata !{metadata !"branch_weights", i32 -252645135, i32 1} -// CHECK-DAG: ![[IF]] = metadata !{metadata !"branch_weights", i32 -268435456, i32 268435456} -// CHECK-DAG: ![[SWITCH]] = metadata !{metadata !"branch_weights", i32 715827883, i32 -715827883, i32 -715827883, i32 -715827883} +// CHECK-DAG: ![[FOR]] = !{!"branch_weights", i32 -252645135, i32 1} +// CHECK-DAG: ![[IF]] = !{!"branch_weights", i32 -268435456, i32 268435456} +// CHECK-DAG: ![[SWITCH]] = !{!"branch_weights", i32 715827883, i32 -715827883, i32 -715827883, i32 -715827883} diff --git a/test/Profile/c-general.c b/test/Profile/c-general.c index 442fdd336c7c..981fd983582c 100644 --- a/test/Profile/c-general.c +++ b/test/Profile/c-general.c @@ -5,6 +5,9 @@ // RUN: llvm-profdata merge %S/Inputs/c-general.proftext -o %t.profdata // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-general.c %s -o - -emit-llvm -fprofile-instr-use=%t.profdata | FileCheck -check-prefix=PGOUSE %s +// Also check compatibility with older profiles. +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-general.c %s -o - -emit-llvm -fprofile-instr-use=%S/Inputs/c-general.profdata.v1 | FileCheck -check-prefix=PGOUSE %s + // PGOGEN: @[[SLC:__llvm_profile_counters_simple_loops]] = hidden global [4 x i64] zeroinitializer // PGOGEN: @[[IFC:__llvm_profile_counters_conditionals]] = hidden global [11 x i64] zeroinitializer // PGOGEN: @[[EEC:__llvm_profile_counters_early_exits]] = hidden global [9 x i64] zeroinitializer @@ -15,7 +18,7 @@ // PGOGEN: @[[BLC:__llvm_profile_counters_boolop_loops]] = hidden global [9 x i64] zeroinitializer // PGOGEN: @[[COC:__llvm_profile_counters_conditional_operator]] = hidden global [3 x i64] zeroinitializer // PGOGEN: @[[MAC:__llvm_profile_counters_main]] = hidden global [1 x i64] zeroinitializer -// PGOGEN: @[[STC:__llvm_profile_counters_static_func]] = internal global [2 x i64] zeroinitializer +// PGOGEN: @[[STC:"__llvm_profile_counters_c-general.c:static_func"]] = internal global [2 x i64] zeroinitializer // PGOGEN-LABEL: @simple_loops() // PGOUSE-LABEL: @simple_loops() @@ -456,77 +459,77 @@ static void static_func() { } } -// PGOUSE-DAG: ![[SL1]] = metadata !{metadata !"branch_weights", i32 101, i32 2} -// PGOUSE-DAG: ![[SL2]] = metadata !{metadata !"branch_weights", i32 101, i32 2} -// PGOUSE-DAG: ![[SL3]] = metadata !{metadata !"branch_weights", i32 76, i32 2} - -// PGOUSE-DAG: ![[EE1]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[EE2]] = metadata !{metadata !"branch_weights", i32 52, i32 1} -// PGOUSE-DAG: ![[EE3]] = metadata !{metadata !"branch_weights", i32 2, i32 51} -// PGOUSE-DAG: ![[EE4]] = metadata !{metadata !"branch_weights", i32 26, i32 26} -// PGOUSE-DAG: ![[EE5]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[EE6]] = metadata !{metadata !"branch_weights", i32 2, i32 26} -// PGOUSE-DAG: ![[EE7]] = metadata !{metadata !"branch_weights", i32 26, i32 1} - -// PGOUSE-DAG: ![[IF1]] = metadata !{metadata !"branch_weights", i32 101, i32 2} -// PGOUSE-DAG: ![[IF2]] = metadata !{metadata !"branch_weights", i32 51, i32 51} -// PGOUSE-DAG: ![[IF3]] = metadata !{metadata !"branch_weights", i32 51, i32 1} -// PGOUSE-DAG: ![[IF4]] = metadata !{metadata !"branch_weights", i32 34, i32 18} -// PGOUSE-DAG: ![[IF5]] = metadata !{metadata !"branch_weights", i32 34, i32 1} -// PGOUSE-DAG: ![[IF6]] = metadata !{metadata !"branch_weights", i32 17, i32 2} -// PGOUSE-DAG: ![[IF7]] = metadata !{metadata !"branch_weights", i32 100, i32 2} -// PGOUSE-DAG: ![[IF8]] = metadata !{metadata !"branch_weights", i32 100, i32 2} - -// PGOUSE-DAG: ![[JM1]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[JM2]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[JM3]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[JM4]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[JM5]] = metadata !{metadata !"branch_weights", i32 3, i32 2} -// PGOUSE-DAG: ![[JM6]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[JM7]] = metadata !{metadata !"branch_weights", i32 1, i32 2, i32 2, i32 2} -// PGOUSE-DAG: ![[JM8]] = metadata !{metadata !"branch_weights", i32 11, i32 2} -// PGOUSE-DAG: ![[JM9]] = metadata !{metadata !"branch_weights", i32 10, i32 2} - -// PGOUSE-DAG: ![[SW1]] = metadata !{metadata !"branch_weights", i32 16, i32 1} -// PGOUSE-DAG: ![[SW2]] = metadata !{metadata !"branch_weights", i32 6, i32 2, i32 3, i32 4, i32 5} -// PGOUSE-DAG: ![[SW3]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[SW4]] = metadata !{metadata !"branch_weights", i32 3, i32 2} -// PGOUSE-DAG: ![[SW5]] = metadata !{metadata !"branch_weights", i32 4, i32 1} -// PGOUSE-DAG: ![[SW6]] = metadata !{metadata !"branch_weights", i32 5, i32 1} -// PGOUSE-DAG: ![[SW7]] = metadata !{metadata !"branch_weights", i32 1, i32 2, i32 2, i32 2, i32 2} -// PGOUSE-DAG: ![[SW8]] = metadata !{metadata !"branch_weights", i32 5, i32 1} -// PGOUSE-DAG: ![[SW9]] = metadata !{metadata !"branch_weights", i32 2, i32 5} - -// PGOUSE-DAG: ![[BS1]] = metadata !{metadata !"branch_weights", i32 33, i32 2} -// PGOUSE-DAG: ![[BS2]] = metadata !{metadata !"branch_weights", i32 29, i32 2, i32 2, i32 2, i32 2, i32 1} -// PGOUSE-DAG: ![[BS3]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[BS4]] = metadata !{metadata !"branch_weights", i32 2, i32 2} -// PGOUSE-DAG: ![[BS5]] = metadata !{metadata !"branch_weights", i32 12, i32 1} -// PGOUSE-DAG: ![[BS6]] = metadata !{metadata !"branch_weights", i32 12, i32 3} -// PGOUSE-DAG: ![[BS7]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[BS8]] = metadata !{metadata !"branch_weights", i32 16, i32 1} -// PGOUSE-DAG: ![[BS9]] = metadata !{metadata !"branch_weights", i32 16, i32 14} -// PGOUSE-DAG: ![[BS10]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[BS11]] = metadata !{metadata !"branch_weights", i32 3, i32 1} - -// PGOUSE-DAG: ![[BO1]] = metadata !{metadata !"branch_weights", i32 101, i32 2} -// PGOUSE-DAG: ![[BO2]] = metadata !{metadata !"branch_weights", i32 67, i32 35} -// PGOUSE-DAG: ![[BO3]] = metadata !{metadata !"branch_weights", i32 67, i32 35} -// PGOUSE-DAG: ![[BO4]] = metadata !{metadata !"branch_weights", i32 67, i32 35} -// PGOUSE-DAG: ![[BO5]] = metadata !{metadata !"branch_weights", i32 18, i32 18} -// PGOUSE-DAG: ![[BO6]] = metadata !{metadata !"branch_weights", i32 51, i32 51} -// PGOUSE-DAG: ![[BO7]] = metadata !{metadata !"branch_weights", i32 34, i32 18} -// PGOUSE-DAG: ![[BL1]] = metadata !{metadata !"branch_weights", i32 52, i32 1} -// PGOUSE-DAG: ![[BL2]] = metadata !{metadata !"branch_weights", i32 51, i32 2} -// PGOUSE-DAG: ![[BL3]] = metadata !{metadata !"branch_weights", i32 26, i32 27} -// PGOUSE-DAG: ![[BL4]] = metadata !{metadata !"branch_weights", i32 51, i32 2} -// PGOUSE-DAG: ![[BL5]] = metadata !{metadata !"branch_weights", i32 52, i32 1} -// PGOUSE-DAG: ![[BL6]] = metadata !{metadata !"branch_weights", i32 51, i32 2} -// PGOUSE-DAG: ![[BL7]] = metadata !{metadata !"branch_weights", i32 26, i32 27} -// PGOUSE-DAG: ![[BL8]] = metadata !{metadata !"branch_weights", i32 51, i32 2} -// PGOUSE-DAG: ![[CO1]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// PGOUSE-DAG: ![[CO2]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[ST1]] = metadata !{metadata !"branch_weights", i32 11, i32 2} +// PGOUSE-DAG: ![[SL1]] = !{!"branch_weights", i32 101, i32 2} +// PGOUSE-DAG: ![[SL2]] = !{!"branch_weights", i32 101, i32 2} +// PGOUSE-DAG: ![[SL3]] = !{!"branch_weights", i32 76, i32 2} + +// PGOUSE-DAG: ![[EE1]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[EE2]] = !{!"branch_weights", i32 52, i32 1} +// PGOUSE-DAG: ![[EE3]] = !{!"branch_weights", i32 2, i32 51} +// PGOUSE-DAG: ![[EE4]] = !{!"branch_weights", i32 26, i32 26} +// PGOUSE-DAG: ![[EE5]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[EE6]] = !{!"branch_weights", i32 2, i32 26} +// PGOUSE-DAG: ![[EE7]] = !{!"branch_weights", i32 26, i32 1} + +// PGOUSE-DAG: ![[IF1]] = !{!"branch_weights", i32 101, i32 2} +// PGOUSE-DAG: ![[IF2]] = !{!"branch_weights", i32 51, i32 51} +// PGOUSE-DAG: ![[IF3]] = !{!"branch_weights", i32 51, i32 1} +// PGOUSE-DAG: ![[IF4]] = !{!"branch_weights", i32 34, i32 18} +// PGOUSE-DAG: ![[IF5]] = !{!"branch_weights", i32 34, i32 1} +// PGOUSE-DAG: ![[IF6]] = !{!"branch_weights", i32 17, i32 2} +// PGOUSE-DAG: ![[IF7]] = !{!"branch_weights", i32 100, i32 2} +// PGOUSE-DAG: ![[IF8]] = !{!"branch_weights", i32 100, i32 2} + +// PGOUSE-DAG: ![[JM1]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[JM2]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[JM3]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[JM4]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[JM5]] = !{!"branch_weights", i32 3, i32 2} +// PGOUSE-DAG: ![[JM6]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[JM7]] = !{!"branch_weights", i32 1, i32 2, i32 2, i32 2} +// PGOUSE-DAG: ![[JM8]] = !{!"branch_weights", i32 11, i32 2} +// PGOUSE-DAG: ![[JM9]] = !{!"branch_weights", i32 10, i32 2} + +// PGOUSE-DAG: ![[SW1]] = !{!"branch_weights", i32 16, i32 1} +// PGOUSE-DAG: ![[SW2]] = !{!"branch_weights", i32 6, i32 2, i32 3, i32 4, i32 5} +// PGOUSE-DAG: ![[SW3]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[SW4]] = !{!"branch_weights", i32 3, i32 2} +// PGOUSE-DAG: ![[SW5]] = !{!"branch_weights", i32 4, i32 1} +// PGOUSE-DAG: ![[SW6]] = !{!"branch_weights", i32 5, i32 1} +// PGOUSE-DAG: ![[SW7]] = !{!"branch_weights", i32 1, i32 2, i32 2, i32 2, i32 2} +// PGOUSE-DAG: ![[SW8]] = !{!"branch_weights", i32 5, i32 1} +// PGOUSE-DAG: ![[SW9]] = !{!"branch_weights", i32 2, i32 5} + +// PGOUSE-DAG: ![[BS1]] = !{!"branch_weights", i32 33, i32 2} +// PGOUSE-DAG: ![[BS2]] = !{!"branch_weights", i32 29, i32 2, i32 2, i32 2, i32 2, i32 1} +// PGOUSE-DAG: ![[BS3]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[BS4]] = !{!"branch_weights", i32 2, i32 2} +// PGOUSE-DAG: ![[BS5]] = !{!"branch_weights", i32 12, i32 1} +// PGOUSE-DAG: ![[BS6]] = !{!"branch_weights", i32 12, i32 3} +// PGOUSE-DAG: ![[BS7]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[BS8]] = !{!"branch_weights", i32 16, i32 1} +// PGOUSE-DAG: ![[BS9]] = !{!"branch_weights", i32 16, i32 14} +// PGOUSE-DAG: ![[BS10]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[BS11]] = !{!"branch_weights", i32 3, i32 1} + +// PGOUSE-DAG: ![[BO1]] = !{!"branch_weights", i32 101, i32 2} +// PGOUSE-DAG: ![[BO2]] = !{!"branch_weights", i32 67, i32 35} +// PGOUSE-DAG: ![[BO3]] = !{!"branch_weights", i32 67, i32 35} +// PGOUSE-DAG: ![[BO4]] = !{!"branch_weights", i32 67, i32 35} +// PGOUSE-DAG: ![[BO5]] = !{!"branch_weights", i32 18, i32 18} +// PGOUSE-DAG: ![[BO6]] = !{!"branch_weights", i32 51, i32 51} +// PGOUSE-DAG: ![[BO7]] = !{!"branch_weights", i32 34, i32 18} +// PGOUSE-DAG: ![[BL1]] = !{!"branch_weights", i32 52, i32 1} +// PGOUSE-DAG: ![[BL2]] = !{!"branch_weights", i32 51, i32 2} +// PGOUSE-DAG: ![[BL3]] = !{!"branch_weights", i32 26, i32 27} +// PGOUSE-DAG: ![[BL4]] = !{!"branch_weights", i32 51, i32 2} +// PGOUSE-DAG: ![[BL5]] = !{!"branch_weights", i32 52, i32 1} +// PGOUSE-DAG: ![[BL6]] = !{!"branch_weights", i32 51, i32 2} +// PGOUSE-DAG: ![[BL7]] = !{!"branch_weights", i32 26, i32 27} +// PGOUSE-DAG: ![[BL8]] = !{!"branch_weights", i32 51, i32 2} +// PGOUSE-DAG: ![[CO1]] = !{!"branch_weights", i32 1, i32 2} +// PGOUSE-DAG: ![[CO2]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[ST1]] = !{!"branch_weights", i32 11, i32 2} int main(int argc, const char *argv[]) { simple_loops(); diff --git a/test/Profile/c-linkage-available_externally.c b/test/Profile/c-linkage-available_externally.c index aa1080b2b443..e89632ad3604 100644 --- a/test/Profile/c-linkage-available_externally.c +++ b/test/Profile/c-linkage-available_externally.c @@ -2,8 +2,9 @@ // get thrown out. // RUN: %clang_cc1 -O2 -triple x86_64-apple-macosx10.9 -main-file-name c-linkage-available_externally.c %s -o - -emit-llvm -fprofile-instr-generate | FileCheck %s -// CHECK: @__llvm_profile_counters_foo = linkonce_odr hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_name_foo = linkonce_odr hidden constant [3 x i8] c"foo", section "__DATA,__llvm_prf_names", align 1 + +// CHECK: @__llvm_profile_counters_foo = linkonce_odr hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_data_foo = linkonce_odr hidden constant { i32, i32, i64, i8*, i64* } { i32 3, i32 1, i64 {{[0-9]+}}, i8* getelementptr inbounds ([3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64]* @__llvm_profile_counters_foo, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 inline int foo(void) { return 1; } diff --git a/test/Profile/c-linkage.c b/test/Profile/c-linkage.c index 3b0fa1a5a6ba..94393a42e0a0 100644 --- a/test/Profile/c-linkage.c +++ b/test/Profile/c-linkage.c @@ -1,20 +1,21 @@ // Check the data structures emitted by instrumentation. // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-linkage.c %s -o - -emit-llvm -fprofile-instr-generate | FileCheck %s -// CHECK: @__llvm_profile_runtime = external global i32 -// CHECK: @__llvm_profile_counters_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_name_foo = hidden constant [3 x i8] c"foo", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @__llvm_profile_name_foo_weak = weak hidden constant [8 x i8] c"foo_weak", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @__llvm_profile_name_main = hidden constant [4 x i8] c"main", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @"__llvm_profile_name_c-linkage.c:foo_internal" = internal constant [24 x i8] c"c-linkage.c:foo_internal", section "__DATA,__llvm_prf_names", align 1 + +// CHECK: @__llvm_profile_counters_foo = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_data_foo = hidden constant { i32, i32, i64, i8*, i64* } { i32 3, i32 1, i64 {{[0-9]+}}, i8* getelementptr inbounds ([3 x i8]* @__llvm_profile_name_foo, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64]* @__llvm_profile_counters_foo, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 void foo(void) { } // CHECK: @__llvm_profile_counters_foo_weak = weak hidden global [5 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name_foo_weak = weak hidden constant [8 x i8] c"foo_weak", section "__DATA,__llvm_prf_names", align 1 // CHECK: @__llvm_profile_data_foo_weak = weak hidden constant { i32, i32, i64, i8*, i64* } { i32 8, i32 5, i64 {{[0-9]+}}, i8* getelementptr inbounds ([8 x i8]* @__llvm_profile_name_foo_weak, i32 0, i32 0), i64* getelementptr inbounds ([5 x i64]* @__llvm_profile_counters_foo_weak, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 void foo_weak(void) __attribute__((weak)); void foo_weak(void) { if (0){} if (0){} if (0){} if (0){} } // CHECK: @__llvm_profile_counters_main = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name_main = hidden constant [4 x i8] c"main", section "__DATA,__llvm_prf_names", align 1 // CHECK: @__llvm_profile_data_main = hidden constant { i32, i32, i64, i8*, i64* } { i32 4, i32 1, i64 {{[0-9]+}}, i8* getelementptr inbounds ([4 x i8]* @__llvm_profile_name_main, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64]* @__llvm_profile_counters_main, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 static void foo_internal(void); int main(void) { @@ -24,12 +25,12 @@ int main(void) { return 0; } -// CHECK: @__llvm_profile_counters_foo_internal = internal global [3 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name_foo_internal = internal constant [24 x i8] c"c-linkage.c:foo_internal", section "__DATA,__llvm_prf_names", align 1 -// CHECK: @__llvm_profile_data_foo_internal = internal constant { i32, i32, i64, i8*, i64* } { i32 24, i32 3, i64 {{[0-9]+}}, i8* getelementptr inbounds ([24 x i8]* @__llvm_profile_name_foo_internal, i32 0, i32 0), i64* getelementptr inbounds ([3 x i64]* @__llvm_profile_counters_foo_internal, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 +// CHECK: @"__llvm_profile_counters_c-linkage.c:foo_internal" = internal global [3 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 +// CHECK: @"__llvm_profile_data_c-linkage.c:foo_internal" = internal constant { i32, i32, i64, i8*, i64* } { i32 24, i32 3, i64 {{[0-9]+}}, i8* getelementptr inbounds ([24 x i8]* @"__llvm_profile_name_c-linkage.c:foo_internal", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64]* @"__llvm_profile_counters_c-linkage.c:foo_internal", i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 static void foo_internal(void) { if (0){} if (0){} } -// CHECK: @llvm.used = appending global [5 x i8*] [i8* bitcast (i32 ()* @__llvm_profile_runtime_user to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_foo to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_foo_weak to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_main to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_foo_internal to i8*)], section "llvm.metadata" +// CHECK: @__llvm_profile_runtime = external global i32 +// CHECK: @llvm.used = appending global [5 x i8*] [i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_foo to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_foo_weak to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_main to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @"__llvm_profile_data_c-linkage.c:foo_internal" to i8*), i8* bitcast (i32 ()* @__llvm_profile_runtime_user to i8*)], section "llvm.metadata" // CHECK: define linkonce_odr i32 @__llvm_profile_runtime_user() {{.*}} { // CHECK: %[[REG:.*]] = load i32* @__llvm_profile_runtime diff --git a/test/Profile/c-unreachable-after-switch.c b/test/Profile/c-unreachable-after-switch.c new file mode 100644 index 000000000000..077043751058 --- /dev/null +++ b/test/Profile/c-unreachable-after-switch.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -O3 -triple x86_64-apple-macosx10.10 -main-file-name c-unreachable-after-switch.c %s -o - -emit-llvm -fprofile-instr-generate | FileCheck %s + +// CHECK: @[[C:__llvm_profile_counters_foo]] = hidden global [3 x i64] zeroinitializer + +// CHECK-LABEL: @foo() +// CHECK: store {{.*}} @[[C]], i64 0, i64 0 +void foo() { + // CHECK: store {{.*}} @[[C]], i64 0, i64 2 + switch (0) { + default: + return; + } + // We shouldn't emit the unreachable counter. This used to crash in GlobalDCE. + // CHECK-NOT: store {{.*}} @[[SWC]], i64 0, i64 1} +} diff --git a/test/Profile/cxx-class.cpp b/test/Profile/cxx-class.cpp index 1a0c84bdccea..21cbbd68320a 100644 --- a/test/Profile/cxx-class.cpp +++ b/test/Profile/cxx-class.cpp @@ -27,7 +27,7 @@ public: // CTRUSE-NOT: br {{.*}} !prof ![0-9]+ // CTRUSE: ret } - // CTRUSE: ![[SC1]] = metadata !{metadata !"branch_weights", i32 100, i32 2} + // CTRUSE: ![[SC1]] = !{!"branch_weights", i32 100, i32 2} // DTRGEN-LABEL: define {{.*}} @_ZN6SimpleD2Ev( // DTRUSE-LABEL: define {{.*}} @_ZN6SimpleD2Ev( @@ -40,7 +40,7 @@ public: // DTRUSE-NOT: br {{.*}} !prof ![0-9]+ // DTRUSE: ret } - // DTRUSE: ![[SD1]] = metadata !{metadata !"branch_weights", i32 100, i32 2} + // DTRUSE: ![[SD1]] = !{!"branch_weights", i32 100, i32 2} // MTHGEN-LABEL: define {{.*}} @_ZN6Simple6methodEv( // MTHUSE-LABEL: define {{.*}} @_ZN6Simple6methodEv( @@ -53,7 +53,7 @@ public: // MTHUSE-NOT: br {{.*}} !prof ![0-9]+ // MTHUSE: ret } - // MTHUSE: ![[SM1]] = metadata !{metadata !"branch_weights", i32 100, i32 2} + // MTHUSE: ![[SM1]] = !{!"branch_weights", i32 100, i32 2} }; // WRPGEN-LABEL: define {{.*}} @_Z14simple_wrapperv( @@ -70,7 +70,7 @@ void simple_wrapper() { // WRPUSE-NOT: br {{.*}} !prof ![0-9]+ // WRPUSE: ret } -// WRPUSE: ![[SW1]] = metadata !{metadata !"branch_weights", i32 101, i32 2} +// WRPUSE: ![[SW1]] = !{!"branch_weights", i32 101, i32 2} int main(int argc, const char *argv[]) { simple_wrapper(); diff --git a/test/Profile/cxx-lambda.cpp b/test/Profile/cxx-lambda.cpp index 6c37a863e5c1..ebf7f4c55f4d 100644 --- a/test/Profile/cxx-lambda.cpp +++ b/test/Profile/cxx-lambda.cpp @@ -11,7 +11,7 @@ // PGOGEN: @[[LWC:__llvm_profile_counters__Z7lambdasv]] = hidden global [4 x i64] zeroinitializer // PGOGEN: @[[MAC:__llvm_profile_counters_main]] = hidden global [1 x i64] zeroinitializer -// LMBGEN: @[[LFC:"__llvm_profile_counters__ZZ7lambdasvENK3\$_0clEi"]] = internal global [3 x i64] zeroinitializer +// LMBGEN: @[[LFC:"__llvm_profile_counters_cxx-lambda.cpp:_ZZ7lambdasvENK3\$_0clEi"]] = internal global [3 x i64] zeroinitializer // PGOGEN-LABEL: define void @_Z7lambdasv() // PGOUSE-LABEL: define void @_Z7lambdasv() @@ -45,12 +45,12 @@ void lambdas() { if (i) {} } -// PGOUSE-DAG: ![[LW1]] = metadata !{metadata !"branch_weights", i32 2, i32 1} -// PGOUSE-DAG: ![[LW2]] = metadata !{metadata !"branch_weights", i32 11, i32 2} -// PGOUSE-DAG: ![[LW3]] = metadata !{metadata !"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[LW1]] = !{!"branch_weights", i32 2, i32 1} +// PGOUSE-DAG: ![[LW2]] = !{!"branch_weights", i32 11, i32 2} +// PGOUSE-DAG: ![[LW3]] = !{!"branch_weights", i32 2, i32 1} -// LMBUSE-DAG: ![[LF1]] = metadata !{metadata !"branch_weights", i32 10, i32 2} -// LMBUSE-DAG: ![[LF2]] = metadata !{metadata !"branch_weights", i32 10, i32 2} +// LMBUSE-DAG: ![[LF1]] = !{!"branch_weights", i32 10, i32 2} +// LMBUSE-DAG: ![[LF2]] = !{!"branch_weights", i32 10, i32 2} int main(int argc, const char *argv[]) { lambdas(); diff --git a/test/Profile/cxx-linkage.cpp b/test/Profile/cxx-linkage.cpp index df896e7a78f2..e410218c4826 100644 --- a/test/Profile/cxx-linkage.cpp +++ b/test/Profile/cxx-linkage.cpp @@ -1,19 +1,20 @@ // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9.0 -emit-llvm -main-file-name cxx-linkage.cpp %s -o - -fprofile-instr-generate | FileCheck %s -// CHECK: @__llvm_profile_runtime = external global i32 -// CHECK: @__llvm_profile_counters__Z3foov = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_name__Z3foov = hidden constant [7 x i8] c"_Z3foov", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @__llvm_profile_name__Z8foo_weakv = weak hidden constant [12 x i8] c"_Z8foo_weakv", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @__llvm_profile_name_main = hidden constant [4 x i8] c"main", section "__DATA,__llvm_prf_names", align 1 +// CHECK: @__llvm_profile_name__Z10foo_inlinev = linkonce_odr hidden constant [15 x i8] c"_Z10foo_inlinev", section "__DATA,__llvm_prf_names", align 1 + +// CHECK: @__llvm_profile_counters__Z3foov = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 // CHECK: @__llvm_profile_data__Z3foov = hidden constant { i32, i32, i64, i8*, i64* } { i32 7, i32 1, i64 {{[0-9]+}}, i8* getelementptr inbounds ([7 x i8]* @__llvm_profile_name__Z3foov, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64]* @__llvm_profile_counters__Z3foov, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 void foo(void) { } // CHECK: @__llvm_profile_counters__Z8foo_weakv = weak hidden global [5 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name__Z8foo_weakv = weak hidden constant [12 x i8] c"_Z8foo_weakv", section "__DATA,__llvm_prf_names", align 1 // CHECK: @__llvm_profile_data__Z8foo_weakv = weak hidden constant { i32, i32, i64, i8*, i64* } { i32 12, i32 5, i64 {{[0-9]+}}, i8* getelementptr inbounds ([12 x i8]* @__llvm_profile_name__Z8foo_weakv, i32 0, i32 0), i64* getelementptr inbounds ([5 x i64]* @__llvm_profile_counters__Z8foo_weakv, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 void foo_weak(void) __attribute__((weak)); void foo_weak(void) { if (0){} if (0){} if (0){} if (0){} } // CHECK: @__llvm_profile_counters_main = hidden global [1 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name_main = hidden constant [4 x i8] c"main", section "__DATA,__llvm_prf_names", align 1 // CHECK: @__llvm_profile_data_main = hidden constant { i32, i32, i64, i8*, i64* } { i32 4, i32 1, i64 {{[0-9]+}}, i8* getelementptr inbounds ([4 x i8]* @__llvm_profile_name_main, i32 0, i32 0), i64* getelementptr inbounds ([1 x i64]* @__llvm_profile_counters_main, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 inline void foo_inline(void); int main(void) { @@ -24,11 +25,11 @@ int main(void) { } // CHECK: @__llvm_profile_counters__Z10foo_inlinev = linkonce_odr hidden global [7 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8 -// CHECK: @__llvm_profile_name__Z10foo_inlinev = linkonce_odr hidden constant [15 x i8] c"_Z10foo_inlinev", section "__DATA,__llvm_prf_names", align 1 // CHECK: @__llvm_profile_data__Z10foo_inlinev = linkonce_odr hidden constant { i32, i32, i64, i8*, i64* } { i32 15, i32 7, i64 {{[0-9]+}}, i8* getelementptr inbounds ([15 x i8]* @__llvm_profile_name__Z10foo_inlinev, i32 0, i32 0), i64* getelementptr inbounds ([7 x i64]* @__llvm_profile_counters__Z10foo_inlinev, i32 0, i32 0) }, section "__DATA,__llvm_prf_data", align 8 inline void foo_inline(void) { if (0){} if (0){} if (0){} if (0){} if (0){} if (0){}} -// CHECK: @llvm.used = appending global [5 x i8*] [i8* bitcast (i32 ()* @__llvm_profile_runtime_user to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z3foov to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z8foo_weakv to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_main to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z10foo_inlinev to i8*)], section "llvm.metadata" +// CHECK: @__llvm_profile_runtime = external global i32 +// CHECK: @llvm.used = appending global [5 x i8*] [i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z3foov to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z8foo_weakv to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data_main to i8*), i8* bitcast ({ i32, i32, i64, i8*, i64* }* @__llvm_profile_data__Z10foo_inlinev to i8*), i8* bitcast (i32 ()* @__llvm_profile_runtime_user to i8*)], section "llvm.metadata" // CHECK: define linkonce_odr i32 @__llvm_profile_runtime_user() {{.*}} { // CHECK: %[[REG:.*]] = load i32* @__llvm_profile_runtime diff --git a/test/Profile/cxx-templates.cpp b/test/Profile/cxx-templates.cpp index 55ab36fe560d..ce5651a25006 100644 --- a/test/Profile/cxx-templates.cpp +++ b/test/Profile/cxx-templates.cpp @@ -32,8 +32,8 @@ template <unsigned N> void loop() { // ALL: ret } -// T0USE-DAG: ![[T01]] = metadata !{metadata !"branch_weights", i32 1, i32 2} -// T100USE-DAG: ![[T1001]] = metadata !{metadata !"branch_weights", i32 101, i32 2} +// T0USE-DAG: ![[T01]] = !{!"branch_weights", i32 1, i32 2} +// T100USE-DAG: ![[T1001]] = !{!"branch_weights", i32 101, i32 2} int main(int argc, const char *argv[]) { loop<0>(); diff --git a/test/Profile/cxx-throws.cpp b/test/Profile/cxx-throws.cpp index 9ea5ace4b74a..e28b37ded55f 100644 --- a/test/Profile/cxx-throws.cpp +++ b/test/Profile/cxx-throws.cpp @@ -60,12 +60,12 @@ void throws() { // PGOUSE: ret void } -// PGOUSE-DAG: ![[TH1]] = metadata !{metadata !"branch_weights", i32 101, i32 2} -// PGOUSE-DAG: ![[TH2]] = metadata !{metadata !"branch_weights", i32 67, i32 35} -// PGOUSE-DAG: ![[TH3]] = metadata !{metadata !"branch_weights", i32 34, i32 34} -// PGOUSE-DAG: ![[TH4]] = metadata !{metadata !"branch_weights", i32 18, i32 18} -// PGOUSE-EXC: ![[TH5]] = metadata !{metadata !"branch_weights", i32 34, i32 18} -// PGOUSE-DAG: ![[TH6]] = metadata !{metadata !"branch_weights", i32 101, i32 1} +// PGOUSE-DAG: ![[TH1]] = !{!"branch_weights", i32 101, i32 2} +// PGOUSE-DAG: ![[TH2]] = !{!"branch_weights", i32 67, i32 35} +// PGOUSE-DAG: ![[TH3]] = !{!"branch_weights", i32 34, i32 34} +// PGOUSE-DAG: ![[TH4]] = !{!"branch_weights", i32 18, i32 18} +// PGOUSE-EXC: ![[TH5]] = !{!"branch_weights", i32 34, i32 18} +// PGOUSE-DAG: ![[TH6]] = !{!"branch_weights", i32 101, i32 1} int main(int argc, const char *argv[]) { throws(); diff --git a/test/Profile/objc-general.m b/test/Profile/objc-general.m index ba06f91a7f98..9a3666786672 100644 --- a/test/Profile/objc-general.m +++ b/test/Profile/objc-general.m @@ -31,8 +31,8 @@ struct NSFastEnumerationState; @end; #endif -// PGOGEN: @[[FRC:"__llvm_profile_counters_\+\[A foreach:\]"]] = internal global [2 x i64] zeroinitializer -// PGOGEN: @[[BLC:"__llvm_profile_counters___13\+\[A foreach:\]_block_invoke"]] = internal global [2 x i64] zeroinitializer +// PGOGEN: @[[FRC:"__llvm_profile_counters_objc-general.m:\+\[A foreach:\]"]] = internal global [2 x i64] zeroinitializer +// PGOGEN: @[[BLC:"__llvm_profile_counters_objc-general.m:__13\+\[A foreach:\]_block_invoke"]] = internal global [2 x i64] zeroinitializer // PGOGEN: @[[MAC:__llvm_profile_counters_main]] = hidden global [1 x i64] zeroinitializer @interface A : NSObject @@ -63,9 +63,9 @@ struct NSFastEnumerationState; } @end -// PGOUSE-DAG: ![[FR1]] = metadata !{metadata !"branch_weights", i32 2, i32 3} -// PGOUSE-DAG: ![[FR2]] = metadata !{metadata !"branch_weights", i32 3, i32 2} -// PGOUSE-DAG: ![[BL1]] = metadata !{metadata !"branch_weights", i32 2, i32 2} +// PGOUSE-DAG: ![[FR1]] = !{!"branch_weights", i32 2, i32 3} +// PGOUSE-DAG: ![[FR2]] = !{!"branch_weights", i32 3, i32 2} +// PGOUSE-DAG: ![[BL1]] = !{!"branch_weights", i32 2, i32 2} int main(int argc, const char *argv[]) { A *a = [[A alloc] init]; diff --git a/test/Rewriter/rewrite-block-literal.mm b/test/Rewriter/rewrite-block-literal.mm index 43f581125ba0..cde6efcbf29d 100644 --- a/test/Rewriter/rewrite-block-literal.mm +++ b/test/Rewriter/rewrite-block-literal.mm @@ -70,7 +70,7 @@ static int global_x = 10; void (^global_block)(void) = ^{ printf("global x is %d\n", global_x); }; // CHECK: static __global_block_block_impl_0 __global_global_block_block_impl_0((void *)__global_block_block_func_0, &__global_block_block_desc_0_DATA); -// CHECK: void (*global_block)(void) = (void (*)())&__global_global_block_block_impl_0; +// CHECK: void (*global_block)(void) = ((void (*)())&__global_global_block_block_impl_0); typedef void (^void_block_t)(void); diff --git a/test/Rewriter/rewrite-modern-block.mm b/test/Rewriter/rewrite-modern-block.mm index 23029654c984..926ee36f1a4a 100644 --- a/test/Rewriter/rewrite-modern-block.mm +++ b/test/Rewriter/rewrite-modern-block.mm @@ -63,3 +63,6 @@ z w(int loc, int len); options &= ~(1 | 2); } @end + +// rdar://18799145 +int Test18799145() { return ^(){return 0;}(); } diff --git a/test/Rewriter/rewrite-modern-captured-nested-bvar.mm b/test/Rewriter/rewrite-modern-captured-nested-bvar.mm index a8fd18073372..be7548c778ab 100644 --- a/test/Rewriter/rewrite-modern-captured-nested-bvar.mm +++ b/test/Rewriter/rewrite-modern-captured-nested-bvar.mm @@ -32,4 +32,4 @@ int main() { // CHECK 2: (__Block_byref_BYREF_VAR_CHECK_0 *)BYREF_VAR_CHECK // CHECK: {(void*)0,(__Block_byref_BYREF_VAR_CHECK_0 *)&BYREF_VAR_CHECK, 0, sizeof(__Block_byref_BYREF_VAR_CHECK_0), 'a'} -// CHECK: __Block_byref_BYREF_VAR_CHECK_0 *)&BYREF_VAR_CHECK, (__Block_byref_d_1 *)&d, 570425344)); +// CHECK: __Block_byref_BYREF_VAR_CHECK_0 *)&BYREF_VAR_CHECK, (__Block_byref_d_1 *)&d, 570425344))); diff --git a/test/Sema/128bitfloat.cc b/test/Sema/128bitfloat.cpp index cb76dac96001..cb76dac96001 100644 --- a/test/Sema/128bitfloat.cc +++ b/test/Sema/128bitfloat.cpp diff --git a/test/Sema/128bitint.c b/test/Sema/128bitint.c index 4272b2d1391e..6469d84c7cc5 100644 --- a/test/Sema/128bitint.c +++ b/test/Sema/128bitint.c @@ -16,10 +16,10 @@ __uint128_t b = (__uint128_t)-1; __int128 i = (__int128)0; unsigned __int128 u = (unsigned __int128)-1; -long long SignedTooBig = 123456789012345678901234567890; // expected-error {{constant is larger than the largest unsigned integer type}} +long long SignedTooBig = 123456789012345678901234567890; // expected-error {{integer literal is too large to be represented in any integer type}} __int128_t Signed128 = 123456789012345678901234567890i128; long long Signed64 = 123456789012345678901234567890i128; // expected-warning {{implicit conversion from '__int128' to 'long long' changes value from 123456789012345678901234567890 to -4362896299872285998}} -unsigned long long UnsignedTooBig = 123456789012345678901234567890; // expected-error {{constant is larger than the largest unsigned integer type}} +unsigned long long UnsignedTooBig = 123456789012345678901234567890; // expected-error {{integer literal is too large to be represented in any integer type}} __uint128_t Unsigned128 = 123456789012345678901234567890Ui128; unsigned long long Unsigned64 = 123456789012345678901234567890Ui128; // expected-warning {{implicit conversion from 'unsigned __int128' to 'unsigned long long' changes value from 123456789012345678901234567890 to 14083847773837265618}} diff --git a/test/Sema/MicrosoftExtensions.c b/test/Sema/MicrosoftExtensions.c index 429dd943a746..e7032305fc07 100644 --- a/test/Sema/MicrosoftExtensions.c +++ b/test/Sema/MicrosoftExtensions.c @@ -39,9 +39,26 @@ struct nested2 { NESTED1; // expected-warning {{anonymous structs are a Microsoft extension}} }; +struct nested2 PR20573 = { .a = 3 }; + +struct nested3 { + long d; + struct nested4 { // expected-warning {{anonymous structs are a Microsoft extension}} + long e; + }; + union nested5 { // expected-warning {{anonymous unions are a Microsoft extension}} + long f; + }; +}; + +typedef union nested6 { + long f; +} NESTED6; + struct test { int c; struct nested2; // expected-warning {{anonymous structs are a Microsoft extension}} + NESTED6; // expected-warning {{anonymous unions are a Microsoft extension}} }; void foo() @@ -87,6 +104,14 @@ typedef struct { AA; // expected-warning {{anonymous structs are a Microsoft extension}} } BB; +struct anon_fault { + struct undefined; // expected-warning {{anonymous structs are a Microsoft extension}} + // expected-error@-1 {{field has incomplete type 'struct undefined'}} + // expected-note@-2 {{forward declaration of 'struct undefined'}} +}; + +const int anon_falt_size = sizeof(struct anon_fault); + __declspec(deprecated("This is deprecated")) enum DE1 { one, two } e1; // expected-note {{'e1' has been explicitly marked deprecated here}} struct __declspec(deprecated) DS1 { int i; float f; }; // expected-note {{'DS1' has been explicitly marked deprecated here}} diff --git a/test/Sema/align_value.c b/test/Sema/align_value.c new file mode 100644 index 000000000000..92b84dbee165 --- /dev/null +++ b/test/Sema/align_value.c @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef double * __attribute__((align_value(64))) aligned_double; + +void foo(aligned_double x, double * y __attribute__((align_value(32)))) { }; + +// expected-error@+1 {{requested alignment is not a power of 2}} +typedef double * __attribute__((align_value(63))) aligned_double1; + +// expected-error@+1 {{requested alignment is not a power of 2}} +typedef double * __attribute__((align_value(-2))) aligned_double2; + +// expected-error@+1 {{attribute takes one argument}} +typedef double * __attribute__((align_value(63, 4))) aligned_double3; + +// expected-error@+1 {{attribute takes one argument}} +typedef double * __attribute__((align_value())) aligned_double3a; + +// expected-error@+1 {{attribute takes one argument}} +typedef double * __attribute__((align_value)) aligned_double3b; + +// expected-error@+1 {{'align_value' attribute requires integer constant}} +typedef double * __attribute__((align_value(4.5))) aligned_double4; + +// expected-warning@+1 {{'align_value' attribute only applies to a pointer or reference ('int' is invalid)}} +typedef int __attribute__((align_value(32))) aligned_int; + +typedef double * __attribute__((align_value(32*2))) aligned_double5; + +// expected-warning@+1 {{'align_value' attribute only applies to variables and typedefs}} +void foo() __attribute__((align_value(32))); + diff --git a/test/Sema/anonymous-struct-union-c11.c b/test/Sema/anonymous-struct-union-c11.c index 229ee520575e..712e29e5496a 100644 --- a/test/Sema/anonymous-struct-union-c11.c +++ b/test/Sema/anonymous-struct-union-c11.c @@ -1,8 +1,8 @@ // Check for warnings in non-C11 mode: -// RUN: %clang_cc1 -fsyntax-only -verify -Wc11-extensions %s +// RUN: %clang_cc1 -fsyntax-only -std=c99 -verify -Wc11-extensions %s // Expect no warnings in C11 mode: -// RUN: %clang_cc1 -fsyntax-only -pedantic -Werror -std=c11 %s +// RUN: %clang_cc1 -fsyntax-only -std=c11 -pedantic -Werror %s struct s { int a; diff --git a/test/Sema/anonymous-struct-union.c b/test/Sema/anonymous-struct-union.c index 35d31754162a..652383eabb72 100644 --- a/test/Sema/anonymous-struct-union.c +++ b/test/Sema/anonymous-struct-union.c @@ -37,7 +37,7 @@ void test_unqual_references(struct X x, const struct X xc) { struct Redecl { int x; // expected-note{{previous declaration is here}} - struct y { }; + struct y { }; // expected-warning{{declaration does not declare anything}} union { int x; // expected-error{{member of anonymous union redeclares 'x'}} @@ -108,3 +108,13 @@ struct s { struct { int i; }; int a[]; }; + +// PR20930 +struct s3 { + struct { int A __attribute__((deprecated)); }; // expected-note {{'A' has been explicitly marked deprecated here}} +}; + +void deprecated_anonymous_struct_member(void) { + struct s3 s; + s.A = 1; // expected-warning {{'A' is deprecated}} +} diff --git a/test/Sema/arm-darwin-aapcs.cpp b/test/Sema/arm-darwin-aapcs.cpp index 1359a1dc15aa..3a6082ae40e2 100644 --- a/test/Sema/arm-darwin-aapcs.cpp +++ b/test/Sema/arm-darwin-aapcs.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 %s -triple thumbv7-apple-ios -target-abi aapcs -verify -fsyntax-only +// RUN: %clang_cc1 %s -triple thumbv7m-apple-macho -target-abi aapcs -verify -fsyntax-only // expected-no-diagnostics // ARM's AAPCS normally has size_t defined as unsigned int, but on Darwin diff --git a/test/Sema/arm64-inline-asm.c b/test/Sema/arm64-inline-asm.c index 08eb669265f7..d8e16a6872cc 100644 --- a/test/Sema/arm64-inline-asm.c +++ b/test/Sema/arm64-inline-asm.c @@ -1,9 +1,9 @@ // RUN: %clang_cc1 -triple arm64-apple-ios7.1 -fsyntax-only -verify %s -// expected-no-diagnostics void foo() { asm volatile("USE(%0)" :: "z"(0LL)); asm volatile("USE(%x0)" :: "z"(0LL)); asm volatile("USE(%w0)" :: "z"(0)); + asm volatile("USE(%0)" :: "z"(0)); // expected-warning {{value size does not match register size specified by the constraint and modifier}} expected-note {{use constraint modifier "w"}} } diff --git a/test/Sema/arm64-neon-args.c b/test/Sema/arm64-neon-args.c index 315a7044040e..a6c4f13a4316 100644 --- a/test/Sema/arm64-neon-args.c +++ b/test/Sema/arm64-neon-args.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -triple arm64-apple-darwin -target-feature +neon -fsyntax-only -ffreestanding -verify %s -// RUN: %clang_cc1 -triple arm64_be-none-linux-gnu -target-feature +neon -fsyntax-only -ffreestanding -verify %s +// RUN: %clang_cc1 -triple aarch64_be-none-linux-gnu -target-feature +neon -fsyntax-only -ffreestanding -verify %s #include <arm_neon.h> diff --git a/test/Sema/arm_acle.c b/test/Sema/arm_acle.c index 866626fc38cb..ec0d55854eeb 100644 --- a/test/Sema/arm_acle.c +++ b/test/Sema/arm_acle.c @@ -30,3 +30,19 @@ int32_t test_ssat_const_diag(int32_t t, const int32_t v) { int32_t test_usat_const_diag(int32_t t, const int32_t v) { return __usat(t, v); // expected-error-re {{argument to {{.*}} must be a constant integer}} } + +/* + * Prefetch intrinsics + */ +void test_pldx_const_diag(int32_t i) { + __pldx(i, 0, 0, 0); // expected-error-re {{argument to {{.*}} must be a constant integer}} +} + +/* + * DBG intrinsic + * First argument for DBG intrinsic must be compile-time constant, + * otherwise an error should be raised. + */ +void test_dbg_const_diag(unsigned int t) { + __dbg(t); // expected-error-re {{argument to {{.*}} must be a constant integer}} +} diff --git a/test/Sema/array-init.c b/test/Sema/array-init.c index 4cc5e412c2d5..7cb48153168f 100644 --- a/test/Sema/array-init.c +++ b/test/Sema/array-init.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s -// RUN: %clang_cc1 -fsyntax-only -Wgnu -Wc11-extensions -verify %s +// RUN: %clang_cc1 -std=gnu99 -fsyntax-only -pedantic -verify %s +// RUN: %clang_cc1 -std=gnu99 -fsyntax-only -Wgnu -Wc11-extensions -verify %s // REQUIRES: LP64 extern int foof() = 1; // expected-error{{illegal initializer (only variables can be initialized)}} diff --git a/test/Sema/asm.c b/test/Sema/asm.c index 89c8c574eb5a..6c6f3f398e33 100644 --- a/test/Sema/asm.c +++ b/test/Sema/asm.c @@ -107,6 +107,7 @@ void test10(void){ register int r asm ("cx"); register int rr asm ("rr_asm"); // expected-error{{unknown register name 'rr_asm' in asm}} + register int rrr asm ("%"); // expected-error{{unknown register name '%' in asm}} } // This is just an assert because of the boolean conversion. @@ -163,3 +164,43 @@ double f_output_constraint(void) { __asm("foo1": "=f" (result)); // expected-error {{invalid output constraint '=f' in asm}} return result; } + +void fn1() { + int l; + __asm__("" + : [l] "=r"(l) + : "[l],m"(l)); // expected-error {{asm constraint has an unexpected number of alternatives: 1 vs 2}} +} + +void fn2() { + int l; + __asm__("" + : "+&m"(l)); // expected-error {{invalid output constraint '+&m' in asm}} +} + +void fn3() { + int l; + __asm__("" + : "+#r"(l)); // expected-error {{invalid output constraint '+#r' in asm}} +} + +void fn4() { + int l; + __asm__("" + : "=r"(l) + : "m#"(l)); +} + +void fn5() { + int l; + __asm__("" + : [g] "+r"(l) + : "[g]"(l)); // expected-error {{invalid input constraint '[g]' in asm}} +} + +void fn6() { + int a; + __asm__("" + : "=rm"(a), "=rm"(a) + : "11m"(a)) // expected-error {{invalid input constraint '11m' in asm}} +} diff --git a/test/Sema/ast-print.c b/test/Sema/ast-print.c index 382f0d389627..4b2b43190d42 100644 --- a/test/Sema/ast-print.c +++ b/test/Sema/ast-print.c @@ -39,3 +39,9 @@ int rvarr(int n, int a[restrict static n]) { return a[2]; } +typedef struct { + int f; +} T __attribute__ ((__aligned__)); + +// CHECK: struct __attribute__((visibility("default"))) S; +struct __attribute__((visibility("default"))) S; diff --git a/test/Sema/atomic-ops.c b/test/Sema/atomic-ops.c index 320abc5ad479..e21c3fd58e80 100644 --- a/test/Sema/atomic-ops.c +++ b/test/Sema/atomic-ops.c @@ -1,11 +1,8 @@ -// RUN: %clang_cc1 %s -verify -fsyntax-only -triple=i686-linux-gnu -std=c11 +// RUN: %clang_cc1 %s -verify -ffreestanding -fsyntax-only -triple=i686-linux-gnu -std=c11 // Basic parsing/Sema tests for __c11_atomic_* -typedef enum memory_order { - memory_order_relaxed, memory_order_consume, memory_order_acquire, - memory_order_release, memory_order_acq_rel, memory_order_seq_cst -} memory_order; +#include <stdatomic.h> struct S { char c[3]; }; @@ -40,6 +37,14 @@ _Static_assert(__atomic_is_lock_free(8, 0), ""); _Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-error {{not an integral constant expression}} _Static_assert(__atomic_is_lock_free(17, 0), ""); // expected-error {{not an integral constant expression}} +_Static_assert(atomic_is_lock_free((atomic_char*)0), ""); +_Static_assert(atomic_is_lock_free((atomic_short*)0), ""); +_Static_assert(atomic_is_lock_free((atomic_int*)0), ""); +_Static_assert(atomic_is_lock_free((atomic_long*)0), ""); +// expected-error@+1 {{__int128 is not supported on this target}} +_Static_assert(atomic_is_lock_free((_Atomic(__int128)*)0), ""); // expected-error {{not an integral constant expression}} +_Static_assert(atomic_is_lock_free(0 + (atomic_char*)0), ""); + char i8; short i16; int i32; @@ -171,6 +176,62 @@ void f(_Atomic(int) *i, _Atomic(int*) *p, _Atomic(float) *d, __c11_atomic_init(&const_atomic, 0); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}} __c11_atomic_store(&const_atomic, 0, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}} __c11_atomic_load(&const_atomic, memory_order_acquire); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}} + + // Ensure the <stdatomic.h> macros behave appropriately. + atomic_int n = ATOMIC_VAR_INIT(123); + atomic_init(&n, 456); + atomic_init(&n, (void*)0); // expected-warning {{passing 'void *' to parameter of type 'int'}} + + const atomic_wchar_t cawt; + atomic_init(&cawt, L'x'); // expected-error {{non-const}} + atomic_wchar_t awt; + atomic_init(&awt, L'x'); + + int x = kill_dependency(12); + + atomic_thread_fence(); // expected-error {{too few arguments to function call}} + atomic_thread_fence(memory_order_seq_cst); + atomic_signal_fence(memory_order_seq_cst); + void (*pfn)(memory_order) = &atomic_thread_fence; + pfn = &atomic_signal_fence; + + int k = atomic_load_explicit(&n, memory_order_relaxed); + atomic_store_explicit(&n, k, memory_order_relaxed); + atomic_store(&n, atomic_load(&n)); + + k = atomic_exchange(&n, 72); + k = atomic_exchange_explicit(&n, k, memory_order_release); + + atomic_compare_exchange_strong(&n, k, k); // expected-warning {{take the address with &}} + atomic_compare_exchange_weak(&n, &k, k); + atomic_compare_exchange_strong_explicit(&n, &k, k, memory_order_seq_cst); // expected-error {{too few arguments}} + atomic_compare_exchange_weak_explicit(&n, &k, k, memory_order_seq_cst, memory_order_acquire); + + atomic_fetch_add(&k, n); // expected-error {{must be a pointer to _Atomic}} + k = atomic_fetch_add(&n, k); + k = atomic_fetch_sub(&n, k); + k = atomic_fetch_and(&n, k); + k = atomic_fetch_or(&n, k); + k = atomic_fetch_xor(&n, k); + k = atomic_fetch_add_explicit(&n, k, memory_order_acquire); + k = atomic_fetch_sub_explicit(&n, k, memory_order_release); + k = atomic_fetch_and_explicit(&n, k, memory_order_acq_rel); + k = atomic_fetch_or_explicit(&n, k, memory_order_consume); + k = atomic_fetch_xor_explicit(&n, k, memory_order_relaxed); + + // C11 7.17.1/4: atomic_flag is a structure type. + struct atomic_flag must_be_struct = ATOMIC_FLAG_INIT; + // C11 7.17.8/5 implies that it is also a typedef type. + atomic_flag guard = ATOMIC_FLAG_INIT; + _Bool old_val = atomic_flag_test_and_set(&guard); + if (old_val) atomic_flag_clear(&guard); + + old_val = (atomic_flag_test_and_set)(&guard); + if (old_val) (atomic_flag_clear)(&guard); + + const atomic_flag const_guard; + atomic_flag_test_and_set(&const_guard); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const atomic_bool *' (aka 'const _Atomic(_Bool) *') invalid)}} + atomic_flag_clear(&const_guard); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const atomic_bool *' (aka 'const _Atomic(_Bool) *') invalid)}} } _Atomic(int*) PR12527_a; @@ -403,3 +464,5 @@ void memory_checks(_Atomic(int) *Ap, int *p, int val) { (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_acq_rel, memory_order_relaxed); (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_relaxed); } + + diff --git a/test/Sema/attr-bounded.c b/test/Sema/attr-bounded.c index bf71fedf2d3f..3108fbdc4015 100644 --- a/test/Sema/attr-bounded.c +++ b/test/Sema/attr-bounded.c @@ -1,15 +1,15 @@ -// RUN: %clang_cc1 -fsyntax-only %s
-// Make sure OpenBSD's bounded extension is accepted.
-
-typedef long ssize_t;
-typedef unsigned long size_t;
-typedef struct FILE FILE;
-
-ssize_t read(int, void *, size_t)
- __attribute__((__bounded__(__buffer__,2,3)));
-int readlink(const char *, char *, size_t)
- __attribute__((__bounded__(__string__,2,3)));
-size_t fread(void *, size_t, size_t, FILE *)
- __attribute__((__bounded__(__size__,1,3,2)));
-char *getwd(char *)
- __attribute__((__bounded__(__minbytes__,1,1024)));
\ No newline at end of file +// RUN: %clang_cc1 -fsyntax-only %s +// Make sure OpenBSD's bounded extension is accepted. + +typedef long ssize_t; +typedef unsigned long size_t; +typedef struct FILE FILE; + +ssize_t read(int, void *, size_t) + __attribute__((__bounded__(__buffer__,2,3))); +int readlink(const char *, char *, size_t) + __attribute__((__bounded__(__string__,2,3))); +size_t fread(void *, size_t, size_t, FILE *) + __attribute__((__bounded__(__size__,1,3,2))); +char *getwd(char *) + __attribute__((__bounded__(__minbytes__,1,1024))); diff --git a/test/Sema/attr-deprecated.c b/test/Sema/attr-deprecated.c index c9e3dd546c58..2e3e722942a0 100644 --- a/test/Sema/attr-deprecated.c +++ b/test/Sema/attr-deprecated.c @@ -121,6 +121,6 @@ struct test22 { __attribute((deprecated)) foo_dep e, f; }; -typedef int test23_ty __attribute((deprecated)); // expected-note {{previous definition is here}} -typedef int test23_ty; // expected-note {{'test23_ty' has been explicitly marked deprecated here}} expected-warning {{redefinition of typedef 'test23_ty' is a C11 feature}} +typedef int test23_ty __attribute((deprecated)); +typedef int test23_ty; // expected-note {{'test23_ty' has been explicitly marked deprecated here}} test23_ty test23_v; // expected-warning {{'test23_ty' is deprecated}} diff --git a/test/Sema/attr-flag-enum.c b/test/Sema/attr-flag-enum.c new file mode 100644 index 000000000000..a53c1dc8e7d1 --- /dev/null +++ b/test/Sema/attr-flag-enum.c @@ -0,0 +1,73 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -std=c11 -Wassign-enum %s + +enum __attribute__((flag_enum)) flag { + ea = 0x1, + eb = 0x2, + ec = 0x8, +}; + +enum __attribute__((flag_enum)) flag2 { + ga = 0x1, + gb = 0x4, + + gc = 0x5, // no-warning + gd = 0x7, // expected-warning {{enumeration value 'gd' is out of range}} + ge = ~0x2, // expected-warning {{enumeration value 'ge' is out of range}} + gf = ~0x4, // no-warning + gg = ~0x1, // no-warning + gh = ~0x5, // no-warning + gi = ~0x11, // expected-warning {{enumeration value 'gi' is out of range}} +}; + +enum __attribute__((flag_enum)) flag3 { + fa = 0x1, + fb = ~0x1u, // no-warning +}; + +// What happens here is that ~0x2 is negative, and so the enum must be signed. +// But ~0x1u is unsigned and has the high bit set, so the enum must be 64-bit. +// The result is that ~0x1u does not have high bits set, and so it is considered +// to be an invalid value. See Sema::IsValueInFlagEnum in SemaDecl.cpp for more +// discussion. +enum __attribute__((flag_enum)) flag4 { + ha = 0x1, + hb = 0x2, + + hc = ~0x1u, // expected-warning {{enumeration value 'hc' is out of range}} + hd = ~0x2, // no-warning +}; + +void f(void) { + enum flag e = 0; // no-warning + e = 0x1; // no-warning + e = 0x3; // no-warning + e = 0xa; // no-warning + e = 0x4; // expected-warning {{integer constant not in range of enumerated type}} + e = 0xf; // expected-warning {{integer constant not in range of enumerated type}} + e = ~0; // no-warning + e = ~0x1; // no-warning + e = ~0x2; // no-warning + e = ~0x3; // no-warning + e = ~0x4; // expected-warning {{integer constant not in range of enumerated type}} + + switch (e) { + case 0: break; // no-warning + case 0x1: break; // no-warning + case 0x3: break; // no-warning + case 0xa: break; // no-warning + case 0x4: break; // expected-warning {{case value not in enumerated type}} + case 0xf: break; // expected-warning {{case value not in enumerated type}} + case ~0: break; // expected-warning {{case value not in enumerated type}} + case ~0x1: break; // expected-warning {{case value not in enumerated type}} + case ~0x2: break; // expected-warning {{case value not in enumerated type}} + case ~0x3: break; // expected-warning {{case value not in enumerated type}} + case ~0x4: break; // expected-warning {{case value not in enumerated type}} + default: break; + } + + enum flag2 f = ~0x1; // no-warning + f = ~0x1u; // no-warning + + enum flag4 h = ~0x1; // no-warning + h = ~0x1u; // expected-warning {{integer constant not in range of enumerated type}} +} diff --git a/test/Sema/attr-msp430.c b/test/Sema/attr-msp430.c index d08cd8ecc9ef..26b2d8fcfd65 100644 --- a/test/Sema/attr-msp430.c +++ b/test/Sema/attr-msp430.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -triple msp430-unknown-unknown -fsyntax-only -verify %s
-
-int i;
-void f(void) __attribute__((interrupt(i))); /* expected-error {{'interrupt' attribute requires an integer constant}} */
-
-void f2(void) __attribute__((interrupt(12)));
+// RUN: %clang_cc1 -triple msp430-unknown-unknown -fsyntax-only -verify %s + +int i; +void f(void) __attribute__((interrupt(i))); /* expected-error {{'interrupt' attribute requires an integer constant}} */ + +void f2(void) __attribute__((interrupt(12))); diff --git a/test/Sema/attr-naked.c b/test/Sema/attr-naked.c index 55c6b326ef15..6b1344a9860b 100644 --- a/test/Sema/attr-naked.c +++ b/test/Sema/attr-naked.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -verify -fsyntax-only +// RUN: %clang_cc1 %s -verify -fsyntax-only -triple i686-pc-linux int a __attribute__((naked)); // expected-warning {{'naked' attribute only applies to functions}} @@ -10,3 +10,41 @@ void t1() __attribute__((naked)); void t2() __attribute__((naked(2))); // expected-error {{'naked' attribute takes no arguments}} +__attribute__((naked)) int t3() { // expected-note{{attribute is here}} + return 42; // expected-error{{non-ASM statement in naked function is not supported}} +} + +__attribute__((naked)) int t4() { + asm("movl $42, %eax"); + asm("retl"); +} + +__attribute__((naked)) int t5(int x) { + asm("movl x, %eax"); + asm("retl"); +} + +__attribute__((naked)) void t6() { + ; +} + +__attribute__((naked)) void t7() { + asm("movl $42, %eax"); + ; +} + +extern int x, y; + +__attribute__((naked)) void t8(int z) { // expected-note{{attribute is here}} + __asm__ ("movl $42, %1" + : "=r"(x), + "=r"(z) // expected-error{{parameter references not allowed in naked functions}} + ); +} + +__attribute__((naked)) void t9(int z) { // expected-note{{attribute is here}} + __asm__ ("movl %eax, %1" + : : "r"(x), + "r"(z) // expected-error{{parameter references not allowed in naked functions}} + ); +} diff --git a/test/Sema/attr-nonnull.c b/test/Sema/attr-nonnull.c new file mode 100644 index 000000000000..f8de31716a80 --- /dev/null +++ b/test/Sema/attr-nonnull.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +void f1(int *a1, int *a2, int *a3, int *a4, int *a5, int *a6, int *a7, + int *a8, int *a9, int *a10, int *a11, int *a12, int *a13, int *a14, + int *a15, int *a16) __attribute__((nonnull(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))); + +void f2(void) __attribute__((nonnull())); // expected-warning {{'nonnull' attribute applied to function with no pointer arguments}} diff --git a/test/Sema/attr-ownership.c b/test/Sema/attr-ownership.c index 2aa9f9f27cc9..d2e48c65a23c 100644 --- a/test/Sema/attr-ownership.c +++ b/test/Sema/attr-ownership.c @@ -17,3 +17,8 @@ void *f12(float i, int k, int f, int *j) __attribute__((ownership_returns(foo, 4 void f13(int *i, int *j) __attribute__((ownership_holds(foo, 1))) __attribute__((ownership_takes(foo, 2))); void f14(int i, int j, int *k) __attribute__((ownership_holds(foo, 3))) __attribute__((ownership_takes(foo, 3))); // expected-error {{'ownership_holds' and 'ownership_takes' attributes are not compatible}} + +void f15(int, int) + __attribute__((ownership_returns(foo, 1))) // expected-note {{declared with index 1 here}} + __attribute__((ownership_returns(foo, 2))); // expected-error {{'ownership_returns' attribute index does not match; here it is 2}} +void f16(int *i, int *j) __attribute__((ownership_holds(foo, 1))) __attribute__((ownership_holds(foo, 1))); // OK, same index diff --git a/test/Sema/big-endian-neon-initializers.c b/test/Sema/big-endian-neon-initializers.c index ffe310903bcf..c706d007509c 100644 --- a/test/Sema/big-endian-neon-initializers.c +++ b/test/Sema/big-endian-neon-initializers.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple arm64_be -target-feature +neon -verify -fsyntax-only -ffreestanding +// RUN: %clang_cc1 %s -triple aarch64_be -target-feature +neon -verify -fsyntax-only -ffreestanding // RUN: %clang_cc1 %s -triple armebv7 -target-cpu cortex-a8 -verify -fsyntax-only -ffreestanding #include <arm_neon.h> diff --git a/test/Sema/bitfield.c b/test/Sema/bitfield.c index ab05a7773d94..fb72213475ae 100644 --- a/test/Sema/bitfield.c +++ b/test/Sema/bitfield.c @@ -1,4 +1,5 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify +// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c11 -Wno-unused-value + enum e0; // expected-note{{forward declaration of 'enum e0'}} struct a { @@ -54,3 +55,22 @@ void test4(struct Test4 *t) { (void) sizeof(t->var ? t->bitX : t->bitY); // not a bitfield designator in C (void) sizeof(t->var ? t->bitX : t->bitX); // not a bitfield designator in C } + +typedef unsigned Unsigned; +typedef signed Signed; + +struct Test5 { unsigned n : 2; } t5; +typedef __typeof__(t5.n) Unsigned; // Bitfield is unsigned +typedef __typeof__(+t5.n) Signed; // ... but promotes to signed. + +typedef __typeof__(t5.n + 0) Signed; // Arithmetic promotes. + +typedef __typeof__(+(t5.n = 0)) Signed; // FIXME: Assignment should not; the result +typedef __typeof__(+(t5.n += 0)) Signed; // is a non-bit-field lvalue of type unsigned. +typedef __typeof__(+(t5.n *= 0)) Signed; + +typedef __typeof__(+(++t5.n)) Signed; // FIXME: Increment is equivalent to compound-assignment. +typedef __typeof__(+(--t5.n)) Signed; // This should not promote to signed. + +typedef __typeof__(+(t5.n++)) Unsigned; // Post-increment is underspecified, but seems to +typedef __typeof__(+(t5.n--)) Unsigned; // also act like compound-assignment. diff --git a/test/Sema/block-misc.c b/test/Sema/block-misc.c index b4732b599c85..0ca4f20f3695 100644 --- a/test/Sema/block-misc.c +++ b/test/Sema/block-misc.c @@ -190,7 +190,7 @@ void test18() { // rdar://7072507 int test19() { - goto L0; // expected-error {{goto into protected scope}} + goto L0; // expected-error {{cannot jump}} __block int x; // expected-note {{jump bypasses setup of __block variable}} L0: diff --git a/test/Sema/builtin-assume-aligned.c b/test/Sema/builtin-assume-aligned.c new file mode 100644 index 000000000000..33c1b74488e1 --- /dev/null +++ b/test/Sema/builtin-assume-aligned.c @@ -0,0 +1,60 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int test1(int *a) { + a = __builtin_assume_aligned(a, 32, 0ull); + return a[0]; +} + +int test2(int *a) { + a = __builtin_assume_aligned(a, 32, 0); + return a[0]; +} + +int test3(int *a) { + a = __builtin_assume_aligned(a, 32); + return a[0]; +} + +int test4(int *a) { + a = __builtin_assume_aligned(a, -32); // expected-error {{requested alignment is not a power of 2}} + // FIXME: The line below produces {{requested alignment is not a power of 2}} + // on i386-freebsd, but not on x86_64-linux (for example). + // a = __builtin_assume_aligned(a, 1ULL << 63); + return a[0]; +} + +int test5(int *a, unsigned *b) { + a = __builtin_assume_aligned(a, 32, b); // expected-warning {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of type}} + return a[0]; +} + +int test6(int *a) { + a = __builtin_assume_aligned(a, 32, 0, 0); // expected-error {{too many arguments to function call, expected at most 3, have 4}} + return a[0]; +} + +int test7(int *a) { + a = __builtin_assume_aligned(a, 31); // expected-error {{requested alignment is not a power of 2}} + return a[0]; +} + +int test8(int *a, int j) { + a = __builtin_assume_aligned(a, j); // expected-error {{must be a constant integer}} + return a[0]; +} + +void test_void_assume_aligned(void) __attribute__((assume_aligned(32))); // expected-warning {{'assume_aligned' attribute only applies to return values that are pointers}} +int test_int_assume_aligned(void) __attribute__((assume_aligned(16))); // expected-warning {{'assume_aligned' attribute only applies to return values that are pointers}} +void *test_ptr_assume_aligned(void) __attribute__((assume_aligned(64))); // no-warning + +int j __attribute__((assume_aligned(8))); // expected-warning {{'assume_aligned' attribute only applies to functions and methods}} +void *test_no_fn_proto() __attribute__((assume_aligned(32))); // no-warning +void *test_with_fn_proto(void) __attribute__((assume_aligned(128))); // no-warning + +void *test_no_fn_proto() __attribute__((assume_aligned(31))); // expected-error {{requested alignment is not a power of 2}} +void *test_no_fn_proto() __attribute__((assume_aligned(32, 73))); // no-warning + +void *test_no_fn_proto() __attribute__((assume_aligned)); // expected-error {{'assume_aligned' attribute takes at least 1 argument}} +void *test_no_fn_proto() __attribute__((assume_aligned())); // expected-error {{'assume_aligned' attribute takes at least 1 argument}} +void *test_no_fn_proto() __attribute__((assume_aligned(32, 45, 37))); // expected-error {{'assume_aligned' attribute takes no more than 2 arguments}} + diff --git a/test/Sema/builtin-assume.c b/test/Sema/builtin-assume.c index 1f6a3a0cd910..512eeeccdc4a 100644 --- a/test/Sema/builtin-assume.c +++ b/test/Sema/builtin-assume.c @@ -1,11 +1,18 @@ // RUN: %clang_cc1 -triple i386-mingw32 -fms-extensions -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -verify %s int foo(int *a, int i) { +#ifdef _MSC_VER __assume(i != 4); - __assume(++i > 2); //expected-warning {{the argument to __assume has side effects that will be discarded}} + __assume(++i > 2); //expected-warning {{the argument to '__assume' has side effects that will be discarded}} int test = sizeof(struct{char qq[(__assume(i != 5), 7)];}); +#else + __builtin_assume(i != 4); + __builtin_assume(++i > 2); //expected-warning {{the argument to '__builtin_assume' has side effects that will be discarded}} + int test = sizeof(struct{char qq[(__builtin_assume(i != 5), 7)];}); +#endif return a[i]; } diff --git a/test/Sema/builtin-object-size.c b/test/Sema/builtin-object-size.c index 0abc27ba187a..b1bda0652c14 100644 --- a/test/Sema/builtin-object-size.c +++ b/test/Sema/builtin-object-size.c @@ -23,6 +23,32 @@ int f3() { // rdar://6252231 - cannot call vsnprintf with va_list on x86_64 void f4(const char *fmt, ...) { __builtin_va_list args; - __builtin___vsnprintf_chk (0, 42, 0, 11, fmt, args); + __builtin___vsnprintf_chk (0, 42, 0, 11, fmt, args); // expected-warning {{'__builtin___vsnprintf_chk' will always overflow destination buffer}} } +// rdar://18334276 +typedef __typeof__(sizeof(int)) size_t; +void * memcset(void *restrict dst, int src, size_t n); +void * memcpy(void *restrict dst, const void *restrict src, size_t n); + +#define memset(dest, src, len) __builtin___memset_chk(dest, src, len, __builtin_object_size(dest, 0)) +#define memcpy(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 0)) +#define memcpy1(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 4)) +#define NULL ((void *)0) + +void f5(void) +{ + char buf[10]; + memset((void *)0x100000000ULL, 0, 0x1000); + memcpy((char *)NULL + 0x10000, buf, 0x10); + memcpy1((char *)NULL + 0x10000, buf, 0x10); // expected-error {{argument should be a value from 0 to 3}} +} + +// rdar://18431336 +void f6(void) +{ + char b[5]; + char buf[10]; + __builtin___memccpy_chk (buf, b, '\0', sizeof(b), __builtin_object_size (buf, 0)); + __builtin___memccpy_chk (b, buf, '\0', sizeof(buf), __builtin_object_size (b, 0)); // expected-warning {{'__builtin___memccpy_chk' will always overflow destination buffer}} +} diff --git a/test/Sema/builtins-arm.c b/test/Sema/builtins-arm.c index 6c367d35a5f5..37604dc8bd43 100644 --- a/test/Sema/builtins-arm.c +++ b/test/Sema/builtins-arm.c @@ -30,6 +30,7 @@ void test2() { __builtin_va_list ptr = "x"; *ptr = '0'; // expected-error {{incomplete type 'void' is not assignable}} } +#endif void test3() { __builtin_arm_dsb(16); // expected-error {{argument should be a value from 0 to 15}} @@ -37,4 +38,11 @@ void test3() { __builtin_arm_isb(18); // expected-error {{argument should be a value from 0 to 15}} } -#endif +void test4() { + __builtin_arm_prefetch(0, 2, 0); // expected-error {{argument should be a value from 0 to 1}} + __builtin_arm_prefetch(0, 0, 2); // expected-error {{argument should be a value from 0 to 1}} +} + +void test5() { + __builtin_arm_dbg(16); // expected-error {{argument should be a value from 0 to 15}} +} diff --git a/test/Sema/builtins-arm64.c b/test/Sema/builtins-arm64.c index 113f4fc302da..2779984680f4 100644 --- a/test/Sema/builtins-arm64.c +++ b/test/Sema/builtins-arm64.c @@ -22,3 +22,10 @@ void test_memory_barriers() { __builtin_arm_dsb(17); // expected-error {{argument should be a value from 0 to 15}} __builtin_arm_isb(18); // expected-error {{argument should be a value from 0 to 15}} } + +void test_prefetch() { + __builtin_arm_prefetch(0, 2, 0, 0, 0); // expected-error {{argument should be a value from 0 to 1}} + __builtin_arm_prefetch(0, 0, 3, 0, 0); // expected-error {{argument should be a value from 0 to 2}} + __builtin_arm_prefetch(0, 0, 0, 2, 0); // expected-error {{argument should be a value from 0 to 1}} + __builtin_arm_prefetch(0, 0, 0, 0, 2); // expected-error {{argument should be a value from 0 to 1}} +} diff --git a/test/Sema/builtins-x86.c b/test/Sema/builtins-x86.c new file mode 100644 index 000000000000..9929e6135c00 --- /dev/null +++ b/test/Sema/builtins-x86.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -triple=x86_64-apple-darwin -fsyntax-only -verify %s + +typedef float __m128 __attribute__((__vector_size__(16))); +typedef double __m128d __attribute__((__vector_size__(16))); + +__m128 test__builtin_ia32_cmpps(__m128 __a, __m128 __b) { + __builtin_ia32_cmpps(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}} +} + +__m128d test__builtin_ia32_cmppd(__m128d __a, __m128d __b) { + __builtin_ia32_cmppd(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}} +} + +__m128 test__builtin_ia32_cmpss(__m128 __a, __m128 __b) { + __builtin_ia32_cmpss(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}} +} + +__m128d test__builtin_ia32_cmpsd(__m128d __a, __m128d __b) { + __builtin_ia32_cmpsd(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}} +} diff --git a/test/Sema/builtins.c b/test/Sema/builtins.c index 7647100bc270..0e2925e0748d 100644 --- a/test/Sema/builtins.c +++ b/test/Sema/builtins.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wno-string-plus-int -triple=i686-apple-darwin9 +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wstrlcpy-strlcat-size -Wno-string-plus-int -triple=i686-apple-darwin9 // This test needs to set the target because it uses __builtin_ia32_vec_ext_v4si int test1(float a, int b) { @@ -66,6 +66,11 @@ void test9_3(volatile int* ptr, int val) { __sync_fetch_and_add_4(ptr, val); } +void test9_4(volatile int* ptr, int val) { + // expected-warning@+1 {{the semantics of this intrinsic changed with GCC version 4.4 - the newer semantics are provided here}} + __sync_fetch_and_nand(ptr, val); +} + // rdar://7236819 void test10(void) __attribute__((noreturn)); @@ -184,12 +189,12 @@ void test18() { void *ptr; ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src), sizeof(dst)); - result = __builtin___strlcpy_chk(dst, src, sizeof(src), sizeof(dst)); - result = __builtin___strlcat_chk(dst, src, sizeof(src), sizeof(dst)); + result = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); + result = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src)); // expected-error {{too few arguments to function call}} - ptr = __builtin___strlcpy_chk(dst, src, sizeof(src), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}} - ptr = __builtin___strlcat_chk(dst, src, sizeof(src), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}} + ptr = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}} + ptr = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}} } void no_ms_builtins() { @@ -202,3 +207,44 @@ void unavailable() { __builtin_operator_new(0); // expected-error {{'__builtin_operator_new' is only available in C++}} __builtin_operator_delete(0); // expected-error {{'__builtin_operator_delete' is only available in C++}} } + +// rdar://18259539 +size_t strlcpy(char * restrict dst, const char * restrict src, size_t size); +size_t strlcat(char * restrict dst, const char * restrict src, size_t size); + +void Test19(void) +{ + static char b[40]; + static char buf[20]; + + strlcpy(buf, b, sizeof(b)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} \\ + // expected-note {{change size argument to be the size of the destination}} + __builtin___strlcpy_chk(buf, b, sizeof(b), __builtin_object_size(buf, 0)); // expected-warning {{size argument in '__builtin___strlcpy_chk' call appears to be size of the source; expected the size of the destination}} \ + // expected-note {{change size argument to be the size of the destination}} \ + // expected-warning {{'__builtin___strlcpy_chk' will always overflow destination buffer}} + + strlcat(buf, b, sizeof(b)); // expected-warning {{size argument in 'strlcat' call appears to be size of the source; expected the size of the destination}} \ + // expected-note {{change size argument to be the size of the destination}} + + __builtin___strlcat_chk(buf, b, sizeof(b), __builtin_object_size(buf, 0)); // expected-warning {{size argument in '__builtin___strlcat_chk' call appears to be size of the source; expected the size of the destination}} \ + // expected-note {{change size argument to be the size of the destination}} \ + // expected-warning {{'__builtin___strlcat_chk' will always overflow destination buffer}} +} + +// rdar://11076881 +char * Test20(char *p, const char *in, unsigned n) +{ + static char buf[10]; + + __builtin___memcpy_chk (&buf[6], in, 5, __builtin_object_size (&buf[6], 0)); // expected-warning {{'__builtin___memcpy_chk' will always overflow destination buffer}} + + __builtin___memcpy_chk (p, "abcde", n, __builtin_object_size (p, 0)); + + __builtin___memcpy_chk (&buf[5], "abcde", 5, __builtin_object_size (&buf[5], 0)); + + __builtin___memcpy_chk (&buf[5], "abcde", n, __builtin_object_size (&buf[5], 0)); + + __builtin___memcpy_chk (&buf[6], "abcde", 5, __builtin_object_size (&buf[6], 0)); // expected-warning {{'__builtin___memcpy_chk' will always overflow destination buffer}} + + return buf; +} diff --git a/test/Sema/call-with-static-chain.c b/test/Sema/call-with-static-chain.c new file mode 100644 index 000000000000..4a076d2ecf9b --- /dev/null +++ b/test/Sema/call-with-static-chain.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -verify %s + +void f(); + +void g() { + __builtin_call_with_static_chain(f(), f); + __builtin_call_with_static_chain(f, f); // expected-error {{first argument to __builtin_call_with_static_chain must be a non-member call expression}} + __builtin_call_with_static_chain(^{}(), f); // expected-error {{first argument to __builtin_call_with_static_chain must not be a block call}} + __builtin_call_with_static_chain(__builtin_unreachable(), f); // expected-error {{first argument to __builtin_call_with_static_chain must not be a builtin call}} + __builtin_call_with_static_chain(f(), 42); // expected-error {{second argument to __builtin_call_with_static_chain must be of pointer type}} +} diff --git a/test/Sema/callingconv.c b/test/Sema/callingconv.c index f9fa9fef2b36..6a8be5ae050f 100644 --- a/test/Sema/callingconv.c +++ b/test/Sema/callingconv.c @@ -10,7 +10,7 @@ void __attribute__((stdcall)) bar(float *a) { void __attribute__((fastcall(1))) baz(float *a) { // expected-error {{'fastcall' attribute takes no arguments}} } -void __attribute__((fastcall)) test0() { // expected-error {{function with no prototype cannot use fastcall calling convention}} +void __attribute__((fastcall)) test0() { } void __attribute__((fastcall)) test1(void) { diff --git a/test/Sema/constructor-attribute.c b/test/Sema/constructor-attribute.c index 1bb69fc4aa56..3a537d424ba0 100644 --- a/test/Sema/constructor-attribute.c +++ b/test/Sema/constructor-attribute.c @@ -5,6 +5,7 @@ int f() __attribute__((constructor)); int f() __attribute__((constructor(1))); int f() __attribute__((constructor(1,2))); // expected-error {{'constructor' attribute takes no more than 1 argument}} int f() __attribute__((constructor(1.0))); // expected-error {{'constructor' attribute requires an integer constant}} +int f() __attribute__((constructor(0x100000000))); // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} int x __attribute__((destructor)); // expected-warning {{'destructor' attribute only applies to functions}} int f() __attribute__((destructor)); diff --git a/test/Sema/decl-microsoft-call-conv.c b/test/Sema/decl-microsoft-call-conv.c new file mode 100644 index 000000000000..5a83b38b192f --- /dev/null +++ b/test/Sema/decl-microsoft-call-conv.c @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -triple i686-pc-win32 -verify %s + +// It's important that this is a .c file. + +// This is fine, as CrcGenerateTable*() has a prototype. +void __fastcall CrcGenerateTableFastcall(void); +void __fastcall CrcGenerateTableFastcall(); +void __fastcall CrcGenerateTableFastcall() {} +void __stdcall CrcGenerateTableStdcall(void); +void __stdcall CrcGenerateTableStdcall(); +void __stdcall CrcGenerateTableStdcall() {} +void __thiscall CrcGenerateTableThiscall(void); +void __thiscall CrcGenerateTableThiscall(); +void __thiscall CrcGenerateTableThiscall() {} +void __pascal CrcGenerateTablePascal(void); +void __pascal CrcGenerateTablePascal(); +void __pascal CrcGenerateTablePascal() {} +void __vectorcall CrcGenerateTableVectorcall(void); +void __vectorcall CrcGenerateTableVectorcall(); +void __vectorcall CrcGenerateTableVectorcall() {} + +void __fastcall CrcGenerateTableNoProtoFastcall(); // expected-error{{function with no prototype cannot use the fastcall calling convention}} +void __stdcall CrcGenerateTableNoProtoStdcall(); // expected-warning{{function with no prototype cannot use the stdcall calling convention}} +void __thiscall CrcGenerateTableNoProtoThiscall(); // expected-error{{function with no prototype cannot use the thiscall calling convention}} +void __pascal CrcGenerateTableNoProtoPascal(); // expected-error{{function with no prototype cannot use the pascal calling convention}} +void __vectorcall CrcGenerateTableNoProtoVectorcall(); // expected-error{{function with no prototype cannot use the vectorcall calling convention}} + +void __fastcall CrcGenerateTableNoProtoDefFastcall() {} +void __stdcall CrcGenerateTableNoProtoDefStdcall() {} +void __thiscall CrcGenerateTableNoProtoDefThiscall() {} +void __pascal CrcGenerateTableNoProtoDefPascal() {} +void __vectorcall CrcGenerateTableNoProtoDefVectorcall() {} + +// Regular calling convention is fine. +void CrcGenerateTableNoProto() {} diff --git a/test/Sema/dllexport.c b/test/Sema/dllexport.c index 6c71ad82987b..76b6f6dc5a0e 100644 --- a/test/Sema/dllexport.c +++ b/test/Sema/dllexport.c @@ -49,6 +49,9 @@ __declspec(dllexport) extern int GlobalRedecl4; // expected-warning{{redeclarati // External linkage is required. __declspec(dllexport) static int StaticGlobal; // expected-error{{'StaticGlobal' must have external linkage when declared 'dllexport'}} +// Thread local variables are invalid. +__declspec(dllexport) __thread int ThreadLocalGlobal; // expected-error{{'ThreadLocalGlobal' cannot be thread local when declared 'dllexport'}} + // Export in local scope. void functionScope() { __declspec(dllexport) int LocalVarDecl; // expected-error{{'LocalVarDecl' must have external linkage when declared 'dllexport'}} diff --git a/test/Sema/dllimport.c b/test/Sema/dllimport.c index 706b0b697707..ac883822dea1 100644 --- a/test/Sema/dllimport.c +++ b/test/Sema/dllimport.c @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c99 %s -// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c11 %s -// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c11 %s -// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c99 %s +// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c99 -DMS %s +// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c11 -DMS %s +// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c11 -DGNU %s +// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c99 -DGNU %s // Invalid usage. __declspec(dllimport) typedef int typedef1; // expected-warning{{'dllimport' attribute only applies to variables and functions}} @@ -77,10 +77,14 @@ __declspec(dllimport) extern int GlobalRedecl5; // expected-warning{{redeclarati // External linkage is required. __declspec(dllimport) static int StaticGlobal; // expected-error{{'StaticGlobal' must have external linkage when declared 'dllimport'}} +// Thread local variables are invalid. +__declspec(dllimport) __thread int ThreadLocalGlobal; // expected-error{{'ThreadLocalGlobal' cannot be thread local when declared 'dllimport'}} + // Import in local scope. __declspec(dllimport) float LocalRedecl1; // expected-note{{previous definition is here}} __declspec(dllimport) float LocalRedecl2; // expected-note{{previous definition is here}} __declspec(dllimport) float LocalRedecl3; // expected-note{{previous definition is here}} +__declspec(dllimport) float LocalRedecl4; void functionScope() { __declspec(dllimport) int LocalRedecl1; // expected-error{{redefinition of 'LocalRedecl1' with a different type: 'int' vs 'float'}} int *__attribute__((dllimport)) LocalRedecl2; // expected-error{{redefinition of 'LocalRedecl2' with a different type: 'int *' vs 'float'}} @@ -91,6 +95,9 @@ void functionScope() { __declspec(dllimport) extern int ExternLocalVarDecl; __declspec(dllimport) extern int ExternLocalVarDef = 1; // expected-error{{definition of dllimport data}} __declspec(dllimport) static int StaticLocalVar; // expected-error{{'StaticLocalVar' must have external linkage when declared 'dllimport'}} + + // Local extern redeclaration does not drop the attribute. + extern float LocalRedecl4; } @@ -115,6 +122,10 @@ void (*FunForInit)() = &decl2A; __declspec(dllimport) void def() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} // Import inline function. +#ifdef GNU +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) inline void inlineFunc1() {} inline void __attribute__((dllimport)) inlineFunc2() {} @@ -139,12 +150,21 @@ __declspec(dllimport) void redecl4(); // expected-error{{redeclaration of 'redec __declspec(dllimport) void redecl5(); // expected-warning{{redeclaration of 'redecl5' should not add 'dllimport' attribute}} -// Inline redeclarations are fine. +// Inline redeclarations. +#ifdef GNU +// expected-warning@+3{{'redecl6' redeclared inline; 'dllimport' attribute ignored}} +#endif __declspec(dllimport) void redecl6(); inline void redecl6() {} - void redecl7(); // expected-note{{previous declaration is here}} -__declspec(dllimport) inline void redecl7() {} // expected-warning{{redeclaration of 'redecl7' should not add 'dllimport' attribute}} +#ifdef MS +// expected-note@+5{{previous declaration is here}} +// expected-warning@+5{{redeclaration of 'redecl7' should not add 'dllimport' attribute}} +#else +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +#endif + void redecl7(); +__declspec(dllimport) inline void redecl7() {} // External linkage is required. __declspec(dllimport) static int staticFunc(); // expected-error{{'staticFunc' must have external linkage when declared 'dllimport'}} diff --git a/test/Sema/expr-comma-c99.c b/test/Sema/expr-comma-c99.c index 02886bff053f..934c81cfa0b0 100644 --- a/test/Sema/expr-comma-c99.c +++ b/test/Sema/expr-comma-c99.c @@ -1,5 +1,4 @@ // RUN: %clang_cc1 %s -fsyntax-only -verify -std=c99 -Wno-sizeof-array-decay -// expected-no-diagnostics // rdar://6095180 struct s { char c[17]; }; @@ -14,5 +13,5 @@ int B[sizeof((a.c)) == 17 ? 1 : -1]; // comma does array/function promotion in c99. int X[sizeof(0, (foo().c)) == sizeof(char*) ? 1 : -1]; int Y[sizeof(0, (a,b).c) == sizeof(char*) ? 1 : -1]; -int Z[sizeof(0, (a=b).c) == sizeof(char*) ? 1 : -1]; +int Z[sizeof(0, (a=b).c) == sizeof(char*) ? 1 : -1]; // expected-warning {{expression with side effects has no effect in an unevaluated context}} diff --git a/test/Sema/expr-comma.c b/test/Sema/expr-comma.c index e2beafe236c2..04e57dec3acc 100644 --- a/test/Sema/expr-comma.c +++ b/test/Sema/expr-comma.c @@ -1,5 +1,4 @@ // RUN: %clang_cc1 %s -fsyntax-only -verify -std=c89 -Wno-sizeof-array-decay -// expected-no-diagnostics // rdar://6095180 struct s { char c[17]; }; @@ -15,4 +14,4 @@ int B[sizeof((a.c)) == 17 ? 1 : -1]; int W[sizeof(0, a.c) == sizeof(char*) ? 1 : -1]; int X[sizeof(0, (foo().c)) == 17 ? 1 : -1]; int Y[sizeof(0, (a,b).c) == 17 ? 1 : -1]; -int Z[sizeof(0, (a=b).c) == 17 ? 1 : -1]; +int Z[sizeof(0, (a=b).c) == 17 ? 1 : -1]; // expected-warning {{expression with side effects has no effect in an unevaluated context}} diff --git a/test/Sema/exprs.c b/test/Sema/exprs.c index 2fb17e4880c6..17b1aa2851b0 100644 --- a/test/Sema/exprs.c +++ b/test/Sema/exprs.c @@ -244,6 +244,10 @@ void test22() { if ("help") (void) 0; - if (test22) + if (test22) // expected-warning {{address of function 'test22' will always evaluate to 'true'}} \ + // expected-note {{prefix with the address-of operator to silence this warning}} + (void) 0; + + if (&test22) (void) 0; } diff --git a/test/Sema/format-strings-gnu.c b/test/Sema/format-strings-gnu.c index f4910856b00f..fc524e93ed48 100644 --- a/test/Sema/format-strings-gnu.c +++ b/test/Sema/format-strings-gnu.c @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -verify -triple i386-apple-darwin9 %s // RUN: %clang_cc1 -fsyntax-only -verify -triple thumbv6-apple-ios4.0 %s -// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-mingw32 %s -// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-pc-win32 %s +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-mingw32 -DMS %s +// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-pc-win32 -DMS %s // RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-gnu -DALLOWED %s // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-unknown-freebsd -DALLOWED %s @@ -23,6 +23,10 @@ void test() { // expected-warning@-6 {{length modifier 'L' results in undefined behavior or no effect with 'd' conversion specifier}} // expected-note@-7 {{did you mean to use 'll'?}} #endif + +#ifndef MS + printf("%Z\n", quiteLong); // expected-warning{{invalid conversion specifier 'Z'}} +#endif } void testAlwaysInvalid() { diff --git a/test/Sema/format-strings-ms.c b/test/Sema/format-strings-ms.c index 2ad8eae033d5..42676e7a4e06 100644 --- a/test/Sema/format-strings-ms.c +++ b/test/Sema/format-strings-ms.c @@ -1,25 +1,88 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -triple=i386-pc-win32 -Wformat-non-iso %s +// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -triple=i386-pc-win32 %s +// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -triple=i386-pc-win32 -Wformat-non-iso -DNON_ISO_WARNING %s int printf(const char *format, ...) __attribute__((format(printf, 1, 2))); +int scanf(const char * restrict, ...) ; +typedef unsigned short wchar_t; + +#ifdef NON_ISO_WARNING + +// Split off this test to reduce the warning noise in the rest of the file. +void non_iso_warning_test(__int32 i32, __int64 i64, wchar_t c, void *p) { + printf("%Id", i32); // expected-warning{{'I' length modifier is not supported by ISO C}} + printf("%I32d", i32); // expected-warning{{'I32' length modifier is not supported by ISO C}} + printf("%I64d", i64); // expected-warning{{'I64' length modifier is not supported by ISO C}} + printf("%wc", c); // expected-warning{{'w' length modifier is not supported by ISO C}} + printf("%Z", p); // expected-warning{{'Z' conversion specifier is not supported by ISO C}} +} + +#else void signed_test() { short val = 30; - printf("val = %I64d\n", val); // expected-warning{{'I64' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type '__int64' (aka 'long long') but the argument has type 'short'}} + printf("val = %I64d\n", val); // expected-warning{{format specifies type '__int64' (aka 'long long') but the argument has type 'short'}} long long bigval = 30; - printf("val = %I32d\n", bigval); // expected-warning{{'I32' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}} - printf("val = %Id\n", bigval); // expected-warning{{'I' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}} + printf("val = %I32d\n", bigval); // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}} + printf("val = %Id\n", bigval); // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}} } void unsigned_test() { unsigned short val = 30; - printf("val = %I64u\n", val); // expected-warning{{'I64' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type 'unsigned __int64' (aka 'unsigned long long') but the argument has type 'unsigned short'}} + printf("val = %I64u\n", val); // expected-warning{{format specifies type 'unsigned __int64' (aka 'unsigned long long') but the argument has type 'unsigned short'}} unsigned long long bigval = 30; - printf("val = %I32u\n", bigval); // expected-warning{{'I32' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}} - printf("val = %Iu\n", bigval); // expected-warning{{'I' length modifier is not supported by ISO C}} \ - // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}} + printf("val = %I32u\n", bigval); // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}} + printf("val = %Iu\n", bigval); // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}} } + +void w_test(wchar_t c, wchar_t *s) { + printf("%wc", c); + printf("%wC", c); + printf("%C", c); + printf("%ws", s); + printf("%wS", s); + printf("%S", s); + scanf("%wc", &c); + scanf("%wC", &c); + scanf("%C", &c); + scanf("%ws", s); + scanf("%wS", s); + scanf("%S", s); + + double bad; + printf("%wc", bad); // expected-warning{{format specifies type 'wint_t' (aka 'int') but the argument has type 'double'}} + printf("%wC", bad); // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}} + printf("%C", bad); // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}} + printf("%ws", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}} + printf("%wS", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}} + printf("%S", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}} + scanf("%wc", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + scanf("%wC", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + scanf("%C", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + scanf("%ws", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + scanf("%wS", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + scanf("%S", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}} + +} + +void h_test(char c, char* s) { + double bad; + printf("%hc", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}} + printf("%hC", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}} + printf("%hs", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}} + printf("%hS", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}} + scanf("%hc", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}} + scanf("%hC", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}} + scanf("%hs", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}} + scanf("%hS", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}} +} + +void z_test(void *p) { + printf("%Z", p); + printf("%hZ", p); + printf("%lZ", p); + printf("%wZ", p); + printf("%hhZ", p); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 'Z' conversion specifier}} + scanf("%Z", p); // expected-warning{{invalid conversion specifier 'Z'}} +} + +#endif diff --git a/test/Sema/format-strings.c b/test/Sema/format-strings.c index e31644a98756..0d827e400d7e 100644 --- a/test/Sema/format-strings.c +++ b/test/Sema/format-strings.c @@ -217,7 +217,7 @@ void test10(int x, float f, int i, long long lli) { printf("%**\n"); // expected-warning{{invalid conversion specifier '*'}} printf("%d%d\n", x); // expected-warning{{more '%' conversions than data arguments}} printf("%d\n", x, x); // expected-warning{{data argument not used by format string}} - printf("%W%d%Z\n", x, x, x); // expected-warning{{invalid conversion specifier 'W'}} expected-warning{{invalid conversion specifier 'Z'}} + printf("%W%d\n", x, x); // expected-warning{{invalid conversion specifier 'W'}} printf("%"); // expected-warning{{incomplete format specifier}} printf("%.d", x); // no-warning printf("%.", x); // expected-warning{{incomplete format specifier}} diff --git a/test/Sema/gnu-attributes.c b/test/Sema/gnu-attributes.c new file mode 100644 index 000000000000..653fae826a74 --- /dev/null +++ b/test/Sema/gnu-attributes.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// expected-no-diagnostics + +struct s {}; + +// FIXME: should warn that declaration attribute in type position is +// being applied to the declaration instead? +struct s __attribute__((used)) foo; + +// FIXME: Should warn that type attribute in declaration position is +// being applied to the type instead? +struct s *bar __attribute__((address_space(1))); + +// Should not warn because type attribute is in type position. +struct s *__attribute__((address_space(1))) baz; + +// Should not warn because declaration attribute is in declaration position. +struct s *quux __attribute__((used)); diff --git a/test/Sema/inline-asm-validate-aarch64.c b/test/Sema/inline-asm-validate-aarch64.c new file mode 100644 index 000000000000..1364b6421eb0 --- /dev/null +++ b/test/Sema/inline-asm-validate-aarch64.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -triple arm64-apple-darwin -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s + +typedef unsigned char uint8_t; + +uint8_t constraint_r(uint8_t *addr) { + uint8_t byte; + + __asm__ volatile("ldrb %0, [%1]" : "=r" (byte) : "r" (addr) : "memory"); +// CHECK: warning: value size does not match register size specified by the constraint and modifier +// CHECK: note: use constraint modifier "w" +// CHECK: fix-it:{{.*}}:{8:26-8:28}:"%w0" + + return byte; +} + +uint8_t constraint_r_symbolic(uint8_t *addr) { + uint8_t byte; + + __asm__ volatile("ldrb %[s0], [%[s1]]" : [s0] "=r" (byte) : [s1] "r" (addr) : "memory"); +// CHECK: warning: value size does not match register size specified by the constraint and modifier +// CHECK: note: use constraint modifier "w" +// CHECK: fix-it:{{.*}}:{19:26-19:31}:"%w[s0]" + + return byte; +} + +#define PERCENT "%" + +uint8_t constraint_r_symbolic_macro(uint8_t *addr) { + uint8_t byte; + + __asm__ volatile("ldrb "PERCENT"[s0], [%[s1]]" : [s0] "=r" (byte) : [s1] "r" (addr) : "memory"); +// CHECK: warning: value size does not match register size specified by the constraint and modifier +// CHECK: note: use constraint modifier "w" +// CHECK-NOT: fix-it + + return byte; +} diff --git a/test/Sema/inline-asm-validate-x86.c b/test/Sema/inline-asm-validate-x86.c new file mode 100644 index 000000000000..174deca80b43 --- /dev/null +++ b/test/Sema/inline-asm-validate-x86.c @@ -0,0 +1,105 @@ +// RUN: %clang_cc1 -triple i686 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64 -fsyntax-only -verify %s + +void I(int i, int j) { + static const int BelowMin = -1; + static const int AboveMax = 32; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "I"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'I'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "I"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'I'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "I"(AboveMax)); // expected-error{{value '32' out of range for constraint 'I'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "I"(16)); // expected-no-error +} + +void J(int i, int j) { + static const int BelowMin = -1; + static const int AboveMax = 64; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "J"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'J'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "J"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'J'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "J"(AboveMax)); // expected-error{{value '64' out of range for constraint 'J'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "J"(32)); // expected-no-error +} + +void K(int i, int j) { + static const int BelowMin = -129; + static const int AboveMax = 128; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "K"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'K'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "K"(BelowMin)); // expected-error{{value '-129' out of range for constraint 'K'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "K"(AboveMax)); // expected-error{{value '128' out of range for constraint 'K'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "K"(96)); // expected-no-error +} + +void M(int i, int j) { + static const int BelowMin = -1; + static const int AboveMax = 4; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "M"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'M'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "M"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'M'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "M"(AboveMax)); // expected-error{{value '4' out of range for constraint 'M'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "M"(2)); // expected-no-error +} + +void N(int i, int j) { + static const int BelowMin = -1; + static const int AboveMax = 256; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "N"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'N'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "N"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'N'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "N"(AboveMax)); // expected-error{{value '256' out of range for constraint 'N'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "N"(128)); // expected-no-error +} + +void O(int i, int j) { + static const int BelowMin = -1; + static const int AboveMax = 128; + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "O"(j)); // expected-error{{invalid type 'int' in asm input for constraint 'O'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "O"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'O'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "O"(AboveMax)); // expected-error{{value '128' out of range for constraint 'O'}} + __asm__("xorl %0,%2" + : "=r"(i) + : "0"(i), "O"(64)); // expected-no-error +} + diff --git a/test/Sema/inline-asm-validate.c b/test/Sema/inline-asm-validate.c index c32dedb65e8c..73335e76cd80 100644 --- a/test/Sema/inline-asm-validate.c +++ b/test/Sema/inline-asm-validate.c @@ -1,9 +1,8 @@ // RUN: %clang_cc1 -triple arm64-apple-macosx10.8.0 -fsyntax-only -verify %s -// expected-no-diagnostics unsigned t, r, *p; int foo (void) { - __asm__ __volatile__( "stxr %w[_t], %[_r], [%[_p]]" : [_t] "=&r" (t) : [_p] "p" (p), [_r] "r" (r) : "memory"); + __asm__ __volatile__( "stxr %w[_t], %[_r], [%[_p]]" : [_t] "=&r" (t) : [_p] "p" (p), [_r] "r" (r) : "memory"); // expected-warning{{value size does not match register size specified by the constraint and modifier}} expected-note {{use constraint modifier "w"}} return 1; } diff --git a/test/Sema/ms-inline-asm.c b/test/Sema/ms-inline-asm.c index 66504aa08417..4c6948f4d45d 100644 --- a/test/Sema/ms-inline-asm.c +++ b/test/Sema/ms-inline-asm.c @@ -1,5 +1,5 @@ // REQUIRES: x86-registered-target -// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -fasm-blocks -Wno-microsoft -verify -fsyntax-only +// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -fasm-blocks -Wno-microsoft -Wunused-label -verify -fsyntax-only void t1(void) { __asm __asm // expected-error {{__asm used with no assembly instructions}} @@ -29,7 +29,7 @@ void f() { } f(); __asm { - mov eax, TYPE bar // expected-error {{unable to lookup expression}} + mov eax, TYPE bar // expected-error {{unable to lookup expression}} expected-error {{use of undeclared label 'bar'}} } } @@ -60,13 +60,13 @@ int t2(int *arr, int i) { } // expected-error@+1 {{cannot use base register with variable reference}} - __asm mov eax, arr[ebp + 1 + (2 * 5) - 3 + 1<<1] + __asm { mov eax, arr[ebp + 1 + (2 * 5) - 3 + 1<<1] } // expected-error@+1 {{cannot use index register with variable reference}} - __asm mov eax, arr[esi * 4] + __asm { mov eax, arr[esi * 4] } // expected-error@+1 {{cannot use more than one symbol in memory operand}} - __asm mov eax, arr[i] + __asm { mov eax, arr[i] } // expected-error@+1 {{cannot use more than one symbol in memory operand}} - __asm mov eax, global[i] + __asm { mov eax, global[i] } // FIXME: Why don't we diagnose this? // expected-Xerror@+1 {{cannot reference multiple local variables in assembly operand}} @@ -80,22 +80,77 @@ typedef struct { } A; void t3() { - __asm mov eax, [eax] UndeclaredId // expected-error {{unknown token in expression}} + __asm { mov eax, [eax] UndeclaredId } // expected-error {{unknown token in expression}} expected-error {{use of undeclared label 'UndeclaredId'}} // FIXME: Only emit one diagnostic here. + // expected-error@+3 {{use of undeclared label 'A'}} // expected-error@+2 {{unexpected type name 'A': expected expression}} // expected-error@+1 {{unknown token in expression}} - __asm mov eax, [eax] A + __asm { mov eax, [eax] A } } void t4() { // The dot in the "intel dot operator" is optional in MSVC. MSVC also does // global field lookup, but we don't. - __asm mov eax, [0] A.a - __asm mov eax, [0].A.a - __asm mov eax, [0].a // expected-error {{Unable to lookup field reference!}} - __asm mov eax, fs:[0] A.a - __asm mov eax, fs:[0].A.a - __asm mov eax, fs:[0].a // expected-error {{Unable to lookup field reference!}} - __asm mov eax, fs:[0]. A.a // expected-error {{Unexpected token type!}} + __asm { mov eax, [0] A.a } + __asm { mov eax, [0].A.a } + __asm { mov eax, [0].a } // expected-error {{Unable to lookup field reference!}} + __asm { mov eax, fs:[0] A.a } + __asm { mov eax, fs:[0].A.a } + __asm { mov eax, fs:[0].a } // expected-error {{Unable to lookup field reference!}} + __asm { mov eax, fs:[0]. A.a } // expected-error {{Unexpected token type!}} +} + +void test_operand_size() { + __asm { call word t4 } // expected-error {{Expected 'PTR' or 'ptr' token!}} +} + +__declspec(naked) int t5(int x) { // expected-note {{attribute is here}} + asm { movl eax, x } // expected-error {{parameter references not allowed in naked functions}} expected-error {{use of undeclared label 'x'}} + asm { retl } +} + +int y; +__declspec(naked) int t6(int x) { + asm { mov eax, y } // No error. + asm { ret } +} + +void t7() { + __asm { + foo: // expected-note {{inline assembly label 'foo' declared here}} + mov eax, 0 + } + goto foo; // expected-error {{cannot jump from this goto statement to label 'foo' inside an inline assembly block}} +} + +void t8() { + __asm foo: // expected-note {{inline assembly label 'foo' declared here}} + __asm mov eax, 0 + goto foo; // expected-error {{cannot jump from this goto statement to label 'foo' inside an inline assembly block}} +} + +void t9() { + goto foo; // expected-error {{cannot jump from this goto statement to label 'foo' inside an inline assembly block}} + __asm { + foo: // expected-note {{inline assembly label 'foo' declared here}} + mov eax, 0 + } +} + +void t10() { + goto foo; // expected-error {{cannot jump from this goto statement to label 'foo' inside an inline assembly block}} + __asm foo: // expected-note {{inline assembly label 'foo' declared here}} + __asm mov eax, 0 +} + +void t11() { +foo: + __asm mov eax, foo // expected-error {{use of undeclared label 'foo'}} expected-warning {{unused label 'foo'}} +} + +void t12() { + __asm foo: + __asm bar: // expected-warning {{unused label 'bar'}} + __asm jmp foo } diff --git a/test/Sema/ms_bitfield_layout.c b/test/Sema/ms_bitfield_layout.c index 8444f469d59d..293df770cd7e 100644 --- a/test/Sema/ms_bitfield_layout.c +++ b/test/Sema/ms_bitfield_layout.c @@ -1,265 +1,265 @@ -// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts %s 2>/dev/null \
-// RUN: | FileCheck %s
-// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts %s 2>/dev/null \
-// RUN: | FileCheck %s
-
-typedef struct A {
- char x;
- int a : 22;
- int : 0;
- int c : 10;
- char b : 3;
- char d: 4;
- short y;
-} A;
-
-// CHECK: Type: struct A
-// CHECK: Size:128
-// CHECK: Alignment:32
-// CHECK: FieldOffsets: [0, 32, 64, 64, 96, 99, 112]>
-
-typedef struct B {
- char x;
- int : 0;
- short a : 4;
- char y;
-} B;
-
-// CHECK: Type: struct B
-// CHECK: Size:48
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 8, 16, 32]>
-
-typedef struct C {
- char x;
- short a : 4;
- int : 0;
- char y;
-} C;
-
-// CHECK: Type: struct C
-// CHECK: Size:64
-// CHECK: Alignment:32
-// CHECK: FieldOffsets: [0, 16, 32, 32]>
-
-typedef struct D {
- char x;
- short : 0;
- int : 0;
- char y;
-} D;
-
-// CHECK: Type: struct D
-// CHECK: Size:16
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 8, 8]>
-
-typedef union E {
- char x;
- long long a : 3;
- int b : 3;
- long long : 0;
- short y;
-} E;
-
-// CHECK: Type: union E
-// CHECK: Size:64
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 0, 0, 0, 0]>
-
-typedef struct F {
- char x;
- char a : 3;
- char b : 3;
- char c : 3;
- short d : 6;
- short e : 6;
- short f : 6;
- short g : 11;
- short h : 11;
- short i : 11;
- short y;
-} F;
-
-// CHECK: Type: struct F
-// CHECK: Size:128
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 8, 11, 16, 32, 38, 48, 64, 80, 96, 112]>
-
-typedef union G {
- char x;
- int a : 3;
- int : 0;
- long long : 0;
- short y;
-} G;
-
-// CHECK: Type: union G
-// CHECK: Size:32
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 0, 0, 0, 0]>
-
-typedef struct H {
- unsigned short a : 1;
- unsigned char : 0;
- unsigned long : 0;
- unsigned short c : 1;
-} H;
-
-// CHECK: Type: struct H
-// CHECK: Size:32
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 16, 16, 16]>
-
-typedef struct I {
- short : 8;
- __declspec(align(16)) short : 8;
-} I;
-
-// CHECK: Type: struct I
-// CHECK: Size:16
-// CHECK: Alignment:16
-// CHECK: FieldOffsets: [0, 8]
-
-#pragma pack(push, 1)
-
-typedef struct A1 {
- char x;
- int a : 22;
- int : 0;
- int c : 10;
- char b : 3;
- char d: 4;
- short y;
-} A1;
-
-// CHECK: Type: struct A1
-// CHECK: Size:96
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 40, 40, 72, 75, 80]>
-
-typedef struct B1 {
- char x;
- int : 0;
- short a : 4;
- char y;
-} B1;
-
-// CHECK: Type: struct B1
-// CHECK: Size:32
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 8, 24]>
-
-typedef struct C1 {
- char x;
- short a : 4;
- int : 0;
- char y;
-} C1;
-
-// CHECK: Type: struct C1
-// CHECK: Size:32
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 24, 24]>
-
-typedef struct D1 {
- char x;
- short : 0;
- int : 0;
- char y;
-} D1;
-
-// CHECK: Type: struct D1
-// CHECK: Size:16
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 8, 8]>
-
-typedef union E1 {
- char x;
- long long a : 3;
- int b : 3;
- long long : 0;
- short y;
-} E1;
-
-// CHECK: Type: union E1
-// CHECK: Size:64
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 0, 0, 0, 0]>
-
-typedef struct F1 {
- char x;
- char a : 3;
- char b : 3;
- char c : 3;
- short d : 6;
- short e : 6;
- short f : 6;
- short g : 11;
- short h : 11;
- short i : 11;
- short y;
-} F1;
-
-// CHECK: Type: struct F1
-// CHECK: Size:120
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8, 11, 16, 24, 30, 40, 56, 72, 88, 104]>
-
-typedef union G1 {
- char x;
- int a : 3;
- int : 0;
- long long : 0;
- short y;
-} G1;
-
-// CHECK: Type: union G1
-// CHECK: Size:32
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 0, 0, 0, 0]>
-
-typedef struct H1 {
- unsigned long a : 1;
- unsigned char : 0;
- unsigned long : 0;
- unsigned long c : 1;
-} H1;
-
-// CHECK: Type: struct H1
-// CHECK: Size:64
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 32, 32, 32]>
-
-typedef struct I1 {
- short : 8;
- __declspec(align(16)) short : 8;
-} I1;
-
-// CHECK: Type: struct I1
-// CHECK: Size:16
-// CHECK: Alignment:8
-// CHECK: FieldOffsets: [0, 8]
-
-#pragma pack(pop)
-
-int x[
-sizeof(A ) +
-sizeof(B ) +
-sizeof(C ) +
-sizeof(D ) +
-sizeof(E ) +
-sizeof(F ) +
-sizeof(G ) +
-sizeof(H ) +
-sizeof(I ) +
-sizeof(A1) +
-sizeof(B1) +
-sizeof(C1) +
-sizeof(D1) +
-sizeof(E1) +
-sizeof(F1) +
-sizeof(G1) +
-sizeof(H1) +
-sizeof(I1) +
-0];
+// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts %s 2>/dev/null \ +// RUN: | FileCheck %s +// RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts %s 2>/dev/null \ +// RUN: | FileCheck %s + +typedef struct A { + char x; + int a : 22; + int : 0; + int c : 10; + char b : 3; + char d: 4; + short y; +} A; + +// CHECK: Type: struct A +// CHECK: Size:128 +// CHECK: Alignment:32 +// CHECK: FieldOffsets: [0, 32, 64, 64, 96, 99, 112]> + +typedef struct B { + char x; + int : 0; + short a : 4; + char y; +} B; + +// CHECK: Type: struct B +// CHECK: Size:48 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 8, 16, 32]> + +typedef struct C { + char x; + short a : 4; + int : 0; + char y; +} C; + +// CHECK: Type: struct C +// CHECK: Size:64 +// CHECK: Alignment:32 +// CHECK: FieldOffsets: [0, 16, 32, 32]> + +typedef struct D { + char x; + short : 0; + int : 0; + char y; +} D; + +// CHECK: Type: struct D +// CHECK: Size:16 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 8, 8]> + +typedef union E { + char x; + long long a : 3; + int b : 3; + long long : 0; + short y; +} E; + +// CHECK: Type: union E +// CHECK: Size:64 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 0, 0, 0, 0]> + +typedef struct F { + char x; + char a : 3; + char b : 3; + char c : 3; + short d : 6; + short e : 6; + short f : 6; + short g : 11; + short h : 11; + short i : 11; + short y; +} F; + +// CHECK: Type: struct F +// CHECK: Size:128 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 8, 11, 16, 32, 38, 48, 64, 80, 96, 112]> + +typedef union G { + char x; + int a : 3; + int : 0; + long long : 0; + short y; +} G; + +// CHECK: Type: union G +// CHECK: Size:32 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 0, 0, 0, 0]> + +typedef struct H { + unsigned short a : 1; + unsigned char : 0; + unsigned long : 0; + unsigned short c : 1; +} H; + +// CHECK: Type: struct H +// CHECK: Size:32 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 16, 16, 16]> + +typedef struct I { + short : 8; + __declspec(align(16)) short : 8; +} I; + +// CHECK: Type: struct I +// CHECK: Size:16 +// CHECK: Alignment:16 +// CHECK: FieldOffsets: [0, 8] + +#pragma pack(push, 1) + +typedef struct A1 { + char x; + int a : 22; + int : 0; + int c : 10; + char b : 3; + char d: 4; + short y; +} A1; + +// CHECK: Type: struct A1 +// CHECK: Size:96 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 40, 40, 72, 75, 80]> + +typedef struct B1 { + char x; + int : 0; + short a : 4; + char y; +} B1; + +// CHECK: Type: struct B1 +// CHECK: Size:32 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 8, 24]> + +typedef struct C1 { + char x; + short a : 4; + int : 0; + char y; +} C1; + +// CHECK: Type: struct C1 +// CHECK: Size:32 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 24, 24]> + +typedef struct D1 { + char x; + short : 0; + int : 0; + char y; +} D1; + +// CHECK: Type: struct D1 +// CHECK: Size:16 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 8, 8]> + +typedef union E1 { + char x; + long long a : 3; + int b : 3; + long long : 0; + short y; +} E1; + +// CHECK: Type: union E1 +// CHECK: Size:64 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 0, 0, 0, 0]> + +typedef struct F1 { + char x; + char a : 3; + char b : 3; + char c : 3; + short d : 6; + short e : 6; + short f : 6; + short g : 11; + short h : 11; + short i : 11; + short y; +} F1; + +// CHECK: Type: struct F1 +// CHECK: Size:120 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8, 11, 16, 24, 30, 40, 56, 72, 88, 104]> + +typedef union G1 { + char x; + int a : 3; + int : 0; + long long : 0; + short y; +} G1; + +// CHECK: Type: union G1 +// CHECK: Size:32 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 0, 0, 0, 0]> + +typedef struct H1 { + unsigned long a : 1; + unsigned char : 0; + unsigned long : 0; + unsigned long c : 1; +} H1; + +// CHECK: Type: struct H1 +// CHECK: Size:64 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 32, 32, 32]> + +typedef struct I1 { + short : 8; + __declspec(align(16)) short : 8; +} I1; + +// CHECK: Type: struct I1 +// CHECK: Size:16 +// CHECK: Alignment:8 +// CHECK: FieldOffsets: [0, 8] + +#pragma pack(pop) + +int x[ +sizeof(A ) + +sizeof(B ) + +sizeof(C ) + +sizeof(D ) + +sizeof(E ) + +sizeof(F ) + +sizeof(G ) + +sizeof(H ) + +sizeof(I ) + +sizeof(A1) + +sizeof(B1) + +sizeof(C1) + +sizeof(D1) + +sizeof(E1) + +sizeof(F1) + +sizeof(G1) + +sizeof(H1) + +sizeof(I1) + +0]; diff --git a/test/Sema/nonnull.c b/test/Sema/nonnull.c index b1f69208241b..4b3df8518cfc 100644 --- a/test/Sema/nonnull.c +++ b/test/Sema/nonnull.c @@ -15,7 +15,7 @@ __attribute__((nonnull(1))) void Class_init(Instance this, char *str) { int main(void) { Class *obj; - Class_init(0, "Hello World"); // expected-warning {{null passed to a callee which requires a non-null argument}} + Class_init(0, "Hello World"); // expected-warning {{null passed to a callee that requires a non-null argument}} Class_init(obj, "Hello World"); } @@ -27,7 +27,7 @@ void baz2(__attribute__((nonnull(1))) const char *str); // expected-warning {{'n void baz3(__attribute__((nonnull)) int x); // expected-warning {{'nonnull' attribute only applies to pointer arguments}} void test_baz() { - baz(0); // expected-warning {{null passed to a callee which requires a non-null argument}} + baz(0); // expected-warning {{null passed to a callee that requires a non-null argument}} baz2(0); // no-warning baz3(0); // no-warning } @@ -47,10 +47,109 @@ void *test_bad_returns_null(void) { } void PR18795(int (*g)(const char *h, ...) __attribute__((nonnull(1))) __attribute__((nonnull))) { - g(0); // expected-warning{{null passed to a callee which requires a non-null argument}} + g(0); // expected-warning{{null passed to a callee that requires a non-null argument}} } void PR18795_helper() { - PR18795(0); // expected-warning{{null passed to a callee which requires a non-null argument}} + PR18795(0); // expected-warning{{null passed to a callee that requires a non-null argument}} } +void vararg1(int n, ...) __attribute__((nonnull(2))); +void vararg1_test() { + vararg1(0); + vararg1(1, (void*)0); // expected-warning{{null passed}} + vararg1(2, (void*)0, (void*)0); // expected-warning{{null passed}} + vararg1(2, (void*)&vararg1, (void*)0); +} + +void vararg2(int n, ...) __attribute__((nonnull, nonnull, nonnull)); +void vararg2_test() { + vararg2(0); + vararg2(1, (void*)0); // expected-warning{{null passed}} + vararg2(2, (void*)0, (void*)0); // expected-warning 2{{null passed}} +} + +void vararg3(int n, ...) __attribute__((nonnull, nonnull(2), nonnull(3))); +void vararg3_test() { + vararg3(0); + vararg3(1, (void*)0); // expected-warning{{null passed}} + vararg3(2, (void*)0, (void*)0); // expected-warning 2{{null passed}} +} + +void redecl(void *, void *); +void redecl(void *, void *) __attribute__((nonnull(1))); +void redecl(void *, void *) __attribute__((nonnull(2))); +void redecl(void *, void *); +void redecl_test(void *p) { + redecl(p, 0); // expected-warning{{null passed}} + redecl(0, p); // expected-warning{{null passed}} +} + +// rdar://18712242 +#define NULL (void*)0 +__attribute__((__nonnull__)) +int evil_nonnull_func(int* pointer, void * pv) +{ + if (pointer == NULL) { // expected-warning {{comparison of nonnull parameter 'pointer' equal to a null pointer is false on first encounter}} + return 0; + } else { + return *pointer; + } + + pointer = pv; + if (!pointer) + return 0; + else + return *pointer; + + if (pv == NULL) {} // expected-warning {{comparison of nonnull parameter 'pv' equal to a null pointer is false on first encounter}} +} +void set_param_to_null(int**); +int another_evil_nonnull_func(int* pointer, char ch, void * pv) __attribute__((nonnull(1, 3))); +int another_evil_nonnull_func(int* pointer, char ch, void * pv) { + if (pointer == NULL) { // expected-warning {{comparison of nonnull parameter 'pointer' equal to a null pointer is false on first encounter}} + return 0; + } else { + return *pointer; + } + + set_param_to_null(&pointer); + if (!pointer) + return 0; + else + return *pointer; + + if (pv == NULL) {} // expected-warning {{comparison of nonnull parameter 'pv' equal to a null pointer is false on first encounter}} +} + +extern void *returns_null(void**); +extern void FOO(); +extern void FEE(); + +extern void *pv; +__attribute__((__nonnull__)) +void yet_another_evil_nonnull_func(int* pointer) +{ + while (pv) { + // This comparison will not be optimized away. + if (pointer) { // expected-warning {{nonnull parameter 'pointer' will evaluate to 'true' on first encounter}} + FOO(); + } else { + FEE(); + } + pointer = returns_null(&pv); + } +} + +void pr21668_1(__attribute__((nonnull)) const char *p, const char *s) { + if (p) // expected-warning {{nonnull parameter 'p' will evaluate to 'true' on first encounter}} + ; + if (s) // No warning + ; +} + +void pr21668_2(__attribute__((nonnull)) const char *p) { + p = 0; + if (p) // No warning + ; +} diff --git a/test/Sema/parentheses.cpp b/test/Sema/parentheses.cpp index ac2694f72e10..324d9b5f1e41 100644 --- a/test/Sema/parentheses.cpp +++ b/test/Sema/parentheses.cpp @@ -47,7 +47,7 @@ void f(Stream& s, bool b) { // CHECK: fix-it:"{{.*}}":{[[@LINE-5]]:15-[[@LINE-5]]:15}:"(" // CHECK: fix-it:"{{.*}}":{[[@LINE-6]]:32-[[@LINE-6]]:32}:")" - (void)(s << 5 == 1); // expected-warning {{overloaded operator << has lower precedence than comparison operator}} \ + (void)(s << 5 == 1); // expected-warning {{overloaded operator << has higher precedence than comparison operator}} \ // expected-note {{place parentheses around the '<<' expression to silence this warning}} \ // expected-note {{place parentheses around comparison expression to evaluate it first}} // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:10}:"(" @@ -55,7 +55,7 @@ void f(Stream& s, bool b) { // CHECK: fix-it:"{{.*}}":{[[@LINE-5]]:15-[[@LINE-5]]:15}:"(" // CHECK: fix-it:"{{.*}}":{[[@LINE-6]]:21-[[@LINE-6]]:21}:")" - (void)(s >> 5 == 1); // expected-warning {{overloaded operator >> has lower precedence than comparison operator}} \ + (void)(s >> 5 == 1); // expected-warning {{overloaded operator >> has higher precedence than comparison operator}} \ // expected-note {{place parentheses around the '>>' expression to silence this warning}} \ // expected-note {{place parentheses around comparison expression to evaluate it first}} // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:10}:"(" @@ -113,3 +113,105 @@ namespace PR15628 { (void)(i-- ? true : false); // no-warning } } + +namespace PR20735 { + struct X { + static int state; + static int get(); + int get_num(); + int num; + }; + namespace ns { + int num = 0; + int get(); + } + void test(X x) { + if (5 & x.get_num() != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:29-[[@LINE-6]]:29}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:24-[[@LINE-9]]:24}:")" + + if (5 & x.num != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:23-[[@LINE-6]]:23}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:18-[[@LINE-9]]:18}:")" + + if (5 & x.state != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:25-[[@LINE-6]]:25}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:20-[[@LINE-9]]:20}:")" + + if (5 & x.get() != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:25-[[@LINE-6]]:25}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:20-[[@LINE-9]]:20}:")" + + if (5 & X::state != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:26-[[@LINE-6]]:26}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:21-[[@LINE-9]]:21}:")" + + if (5 & X::get() != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:26-[[@LINE-6]]:26}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:21-[[@LINE-9]]:21}:")" + + if (5 & ns::get() != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:27-[[@LINE-6]]:27}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:22-[[@LINE-9]]:22}:")" + + if (5 & ns::num != 0) {} + // expected-warning@-1 {{& has lower precedence than !=; != will be evaluated first}} + // expected-note@-2 {{place parentheses around the '!=' expression to silence this warning}} + // expected-note@-3 {{place parentheses around the & expression to evaluate it first}} + // CHECK: place parentheses around the '!=' expression to silence this warning + // fix-it:"{{.*}}":{[[@LINE-5]]:13-[[@LINE-5]]:13}:"(" + // fix-it:"{{.*}}":{[[@LINE-6]]:25-[[@LINE-6]]:25}:")" + // CHECK: place parentheses around the & expression to evaluate it first + // fix-it:"{{.*}}":{[[@LINE-8]]:9-[[@LINE-8]]:9}:"(" + // fix-it:"{{.*}}":{[[@LINE-9]]:20-[[@LINE-9]]:20}:")" + } +} diff --git a/test/Sema/scope-check.c b/test/Sema/scope-check.c index a9494d3e3fb4..fa37d10d070b 100644 --- a/test/Sema/scope-check.c +++ b/test/Sema/scope-check.c @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=gnu99 %s -Wno-unreachable-code int test1(int x) { - goto L; // expected-error{{goto into protected scope}} + goto L; // expected-error{{cannot jump from this goto statement to its label}} int a[x]; // expected-note {{jump bypasses initialization of variable length array}} int b[x]; // expected-note {{jump bypasses initialization of variable length array}} L: @@ -9,7 +9,7 @@ int test1(int x) { } int test2(int x) { - goto L; // expected-error{{goto into protected scope}} + goto L; // expected-error{{cannot jump from this goto statement to its label}} typedef int a[x]; // expected-note {{jump bypasses initialization of VLA typedef}} L: return sizeof(a); @@ -18,14 +18,14 @@ int test2(int x) { void test3clean(int*); int test3() { - goto L; // expected-error{{goto into protected scope}} + goto L; // expected-error{{cannot jump from this goto statement to its label}} int a __attribute((cleanup(test3clean))); // expected-note {{jump bypasses initialization of variable with __attribute__((cleanup))}} L: return a; } int test4(int x) { - goto L; // expected-error{{goto into protected scope}} + goto L; // expected-error{{cannot jump from this goto statement to its label}} int a[x]; // expected-note {{jump bypasses initialization of variable length array}} test4(x); L: @@ -50,7 +50,7 @@ void test7(int x) { switch (x) { case 1: ; int a[x]; // expected-note {{jump bypasses initialization of variable length array}} - case 2: // expected-error {{switch case is in protected scope}} + case 2: // expected-error {{cannot jump from switch statement to this case label}} a[1] = 2; break; } @@ -58,17 +58,17 @@ void test7(int x) { int test8(int x) { // For statement. - goto L2; // expected-error {{goto into protected scope}} + goto L2; // expected-error {{cannot jump from this goto statement to its label}} for (int arr[x]; // expected-note {{jump bypasses initialization of variable length array}} ; ++x) L2:; // Statement expressions. - goto L3; // expected-error {{goto into protected scope}} + goto L3; // expected-error {{cannot jump from this goto statement to its label}} int Y = ({ int a[x]; // expected-note {{jump bypasses initialization of variable length array}} L3: 4; }); - goto L4; // expected-error {{goto into protected scope}} + goto L4; // expected-error {{cannot jump from this goto statement to its label}} { int A[x], // expected-note {{jump bypasses initialization of variable length array}} B[x]; // expected-note {{jump bypasses initialization of variable length array}} @@ -91,7 +91,7 @@ int test8(int x) { int A[x], B = ({ if (x) goto L7; else - goto L8; // expected-error {{goto into protected scope}} + goto L8; // expected-error {{cannot jump from this goto statement to its label}} 4; }), C[x]; // expected-note {{jump bypasses initialization of variable length array}} L8:; // bad @@ -103,7 +103,7 @@ int test8(int x) { goto L9; else // FIXME: - goto L10; // fixme-error {{goto into protected scope}} + goto L10; // fixme-error {{cannot jump from this goto statement to its label}} 4; })]; L10:; // bad } @@ -123,7 +123,7 @@ int test8(int x) { } // Statement expressions 2. - goto L1; // expected-error {{goto into protected scope}} + goto L1; // expected-error {{cannot jump from this goto statement to its label}} return x == ({ int a[x]; // expected-note {{jump bypasses initialization of variable length array}} L1: @@ -133,7 +133,7 @@ int test8(int x) { void test9(int n, void *P) { int Y; int Z = 4; - goto *P; // expected-error {{indirect goto might cross protected scopes}} + goto *P; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}} L2: ; int a[n]; // expected-note {{jump bypasses initialization of variable length array}} @@ -151,14 +151,14 @@ L4: } void test10(int n, void *P) { - goto L0; // expected-error {{goto into protected scope}} + goto L0; // expected-error {{cannot jump from this goto statement to its label}} typedef int A[n]; // expected-note {{jump bypasses initialization of VLA typedef}} L0: - goto L1; // expected-error {{goto into protected scope}} + goto L1; // expected-error {{cannot jump from this goto statement to its label}} A b, c[10]; // expected-note 2 {{jump bypasses initialization of variable length array}} L1: - goto L2; // expected-error {{goto into protected scope}} + goto L2; // expected-error {{cannot jump from this goto statement to its label}} A d[n]; // expected-note {{jump bypasses initialization of variable length array}} L2: return; @@ -171,7 +171,7 @@ void test11(int n) { case 2: case 3:; int Arr[n]; // expected-note {{jump bypasses initialization of variable length array}} - case 4: // expected-error {{switch case is in protected scope}} + case 4: // expected-error {{cannot jump from switch statement to this case label}} return; } }; @@ -185,7 +185,7 @@ void test12(int n) { L1: goto L2; L2: - goto L3; // expected-error {{goto into protected scope}} + goto L3; // expected-error {{cannot jump from this goto statement to its label}} int Arr[n]; // expected-note {{jump bypasses initialization of variable length array}} L3: goto L4; @@ -220,7 +220,7 @@ int test14(int n) { void test15(int n, void *pc) { static const void *addrs[] = { &&L1, &&L2 }; - goto *pc; // expected-error {{indirect goto might cross protected scope}} + goto *pc; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}} L1: { diff --git a/test/Sema/sentinel-attribute.c b/test/Sema/sentinel-attribute.c index 46f135041c1f..1beae87a51de 100644 --- a/test/Sema/sentinel-attribute.c +++ b/test/Sema/sentinel-attribute.c @@ -1,7 +1,11 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: not %clang_cc1 -fsyntax-only %s -fdiagnostics-parseable-fixits 2>&1 | \ +// RUN: FileCheck %s --check-prefix=C +// RUN: not %clang_cc1 -fsyntax-only %s -fdiagnostics-parseable-fixits -x c++ -std=c++11 2>&1 | \ +// RUN: FileCheck %s --check-prefix=CXX11 int x __attribute__((sentinel)); //expected-warning{{'sentinel' attribute only applies to functions, methods and blocks}} -void f1(int a, ...) __attribute__ ((sentinel)); +void f1(int a, ...) __attribute__ ((sentinel)); // expected-note {{function has been explicitly marked sentinel here}} void f2(int a, ...) __attribute__ ((sentinel(1))); void f3(int a, ...) __attribute__ ((sentinel("hello"))); //expected-error{{'sentinel' attribute requires parameter 1 to be an integer constant}} @@ -13,3 +17,10 @@ void f5(int a) __attribute__ ((sentinel)); //expected-warning{{'sentinel' attrib void f6() __attribute__((__sentinel__)); // expected-warning {{'sentinel' attribute requires named arguments}} + +void g() { + // The integer literal zero is not a sentinel. + f1(1, 0); // expected-warning {{missing sentinel in function call}} +// C: fix-it:{{.*}}:{23:10-23:10}:", (void*) 0" +// CXX11: fix-it:{{.*}}:{23:10-23:10}:", nullptr" +} diff --git a/test/Sema/sizeof-struct-non-zero-as-member.cl b/test/Sema/sizeof-struct-non-zero-as-member.cl new file mode 100644 index 000000000000..0e13c61503aa --- /dev/null +++ b/test/Sema/sizeof-struct-non-zero-as-member.cl @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -triple amdgcn -target-cpu verde -S -emit-llvm -o - %s +// expected-no-diagnostics + +// Record lowering was crashing on SI and newer targets, because it +// was using the wrong size for test::ptr. Since global memory +// has 64-bit pointers, sizeof(test::ptr) should be 8. + +struct test_as0 {int *ptr;}; +constant int as0[sizeof(struct test_as0) == 4 ? 1 : -1] = { 0 }; + +struct test_as1 {global int *ptr;}; +constant int as1[sizeof(struct test_as1) == 8 ? 1 : -1] = { 0 }; + +struct test_as2 {constant int *ptr;}; +constant int as2[sizeof(struct test_as2) == 8 ? 1 : -1] = { 0 }; + +struct test_as3 {local int *ptr;}; +constant int as3[sizeof(struct test_as3) == 4 ? 1 : -1] = { 0 }; diff --git a/test/Sema/statements.c b/test/Sema/statements.c index 8cd30b0c93cd..9ab571521a3a 100644 --- a/test/Sema/statements.c +++ b/test/Sema/statements.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify +// RUN: %clang_cc1 %s -fsyntax-only -verify -triple x86_64-pc-linux-gnu typedef unsigned __uint32_t; diff --git a/test/Sema/static-array.c b/test/Sema/static-array.c index 5ca693b2bf54..304485d5af9f 100644 --- a/test/Sema/static-array.c +++ b/test/Sema/static-array.c @@ -11,13 +11,13 @@ void f(int *p) { cat0(0); - cat(0); // expected-warning {{null passed to a callee which requires a non-null argument}} + cat(0); // expected-warning {{null passed to a callee that requires a non-null argument}} cat(a); // expected-warning {{array argument is too small; contains 2 elements, callee requires at least 3}} cat(b); cat(c); cat(p); - vat(1, 0); // expected-warning {{null passed to a callee which requires a non-null argument}} + vat(1, 0); // expected-warning {{null passed to a callee that requires a non-null argument}} vat(3, b); } diff --git a/test/Sema/stdcall-fastcall.c b/test/Sema/stdcall-fastcall.c index dea1fc5e7af7..256f5588e6d2 100644 --- a/test/Sema/stdcall-fastcall.c +++ b/test/Sema/stdcall-fastcall.c @@ -6,7 +6,7 @@ int __attribute__((fastcall)) var2; // expected-warning{{'fastcall' only applies // Different CC qualifiers are not compatible void __attribute__((stdcall, fastcall)) foo3(void); // expected-error{{fastcall and stdcall attributes are not compatible}} -void __attribute__((stdcall)) foo4(); // expected-note{{previous declaration is here}} +void __attribute__((stdcall)) foo4(); // expected-note{{previous declaration is here}} expected-warning{{function with no prototype cannot use the stdcall calling convention}} void __attribute__((fastcall)) foo4(void); // expected-error{{function declared 'fastcall' here was previously declared 'stdcall'}} // rdar://8876096 diff --git a/test/Sema/string-plus-char.c b/test/Sema/string-plus-char.c index 322e8f5962be..66c1182eb046 100644 --- a/test/Sema/string-plus-char.c +++ b/test/Sema/string-plus-char.c @@ -1,5 +1,11 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +struct AB{const char *a; const char*b;}; + +const char *foo(const struct AB *ab) { + return ab->a + 'b'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} +} + void f(const char *s) { char *str = 0; char *str2 = str + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} @@ -8,6 +14,15 @@ void f(const char *s) { str = 'c' + str;// expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} + char strArr[] = "foo"; + str = strArr + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} + char *strArr2[] = {"ac","dc"}; + str = strArr2[0] + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} + + + struct AB ab; + constStr = foo(&ab) + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}} + // no-warning char c = 'c'; str = str + c; diff --git a/test/Sema/struct-packed-align.c b/test/Sema/struct-packed-align.c index 166d5eb1ff8d..291de6762cd1 100644 --- a/test/Sema/struct-packed-align.c +++ b/test/Sema/struct-packed-align.c @@ -127,9 +127,11 @@ struct nS { nt start_lba; }; +#if defined(_WIN32) && !defined(__declspec) // _MSC_VER is unavailable in cc1. +// Alignment doesn't affect packing in MS mode. +extern int n1[sizeof(struct nS) == 16 ? 1 : -1]; +extern int n2[__alignof(struct nS) == 8 ? 1 : -1]; +#else extern int n1[sizeof(struct nS) == 9 ? 1 : -1]; extern int n2[__alignof(struct nS) == 1 ? 1 : -1]; - - - - +#endif diff --git a/test/Sema/switch-1.c b/test/Sema/switch-1.c index ce1e7dc9433f..5191c92e714d 100644 --- a/test/Sema/switch-1.c +++ b/test/Sema/switch-1.c @@ -20,3 +20,8 @@ int f(int i) { return (i, 65537) * 65537; // expected-warning {{overflow in expression; result is 131073 with type 'int'}} \ // expected-warning {{expression result unused}} } + +// rdar://18405357 +unsigned long long l = 65536 * 65536; // expected-warning {{overflow in expression; result is 0 with type 'int'}} +unsigned long long l2 = 65536 * (unsigned)65536; +unsigned long long l3 = 65536 * 65536ULL; diff --git a/test/Sema/switch.c b/test/Sema/switch.c index 092378d48bc5..7aa695d7cb91 100644 --- a/test/Sema/switch.c +++ b/test/Sema/switch.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default -triple x86_64-linux-gnu %s void f (int z) { while (z) { default: z--; // expected-error {{statement not in switch}} @@ -375,3 +375,13 @@ void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) { } } +void PR11778(char c, int n, long long ll) { + // Do not reject this; we don't have duplicate case values because we + // check for duplicates in the promoted type. + switch (c) case 1: case 257: ; // expected-warning {{overflow}} + + switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}} + switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}} + switch ((long long)n) case 0x100000001LL: case 1: ; + switch (ll) case 0x100000001LL: case 1: ; +} diff --git a/test/Sema/types.c b/test/Sema/types.c index 0450de1c8e9b..5614d164a5f4 100644 --- a/test/Sema/types.c +++ b/test/Sema/types.c @@ -1,5 +1,7 @@ -// RUN: %clang_cc1 %s -pedantic -verify -triple=x86_64-apple-darwin9 -// RUN: %clang_cc1 %s -pedantic -verify -triple=mips64-linux-gnu +// RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-apple-darwin9 +// RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=mips64-linux-gnu +// RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-unknown-linux +// RUN: %clang_cc1 %s -fblocks -pedantic -verify -triple=x86_64-unknown-linux-gnux32 // rdar://6097662 typedef int (*T)[2]; @@ -28,12 +30,12 @@ int c() { int __int128; // expected-error {{cannot combine with previous}} expected-warning {{does not declare anything}} } // __int128_t is __int128; __uint128_t is unsigned __int128. -typedef __int128 check_int_128; // expected-note {{here}} -typedef __int128_t check_int_128; // expected-note {{here}} expected-warning {{redefinition}} +typedef __int128 check_int_128; +typedef __int128_t check_int_128; // expected-note {{here}} typedef int check_int_128; // expected-error {{different types ('int' vs '__int128_t' (aka '__int128'))}} -typedef unsigned __int128 check_uint_128; // expected-note {{here}} -typedef __uint128_t check_uint_128; // expected-note {{here}} expected-warning {{redefinition}} +typedef unsigned __int128 check_uint_128; +typedef __uint128_t check_uint_128; // expected-note {{here}} typedef int check_uint_128; // expected-error {{different types ('int' vs '__uint128_t' (aka 'unsigned __int128'))}} // Array type merging should convert array size to whatever matches the target @@ -82,3 +84,7 @@ void convert() { uchar32 r = 0; r.s[ 1234 ] = 1; // expected-error {{illegal vector component name 's'}} } + +int &*_Atomic null_type_0; // expected-error {{expected identifier or '('}} +int &*__restrict__ null_type_1; // expected-error {{expected identifier or '('}} +int ^_Atomic null_type_2; // expected-error {{block pointer to non-function type is invalid}} diff --git a/test/Sema/typo-correction.c b/test/Sema/typo-correction.c new file mode 100644 index 000000000000..df7da797f050 --- /dev/null +++ b/test/Sema/typo-correction.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// +// This file contains typo correction tests which hit different code paths in C +// than in C++ and may exhibit different behavior as a result. + +__typeof__(struct F*) var[invalid]; // expected-error-re {{use of undeclared identifier 'invalid'{{$}}}} + +void PR21656() { + float x; + x = (float)arst; // expected-error-re {{use of undeclared identifier 'arst'{{$}}}} +} + +a = b ? : 0; // expected-warning {{type specifier missing, defaults to 'int'}} \ + // expected-error {{use of undeclared identifier 'b'}} + +struct ContainerStuct { + enum { SOME_ENUM }; // expected-note {{'SOME_ENUM' declared here}} +}; + +void func(int arg) { + switch (arg) { + case SOME_ENUM_: // expected-error {{use of undeclared identifier 'SOME_ENUM_'; did you mean 'SOME_ENUM'}} + ; + } +} diff --git a/test/Sema/var-redecl.c b/test/Sema/var-redecl.c index 0e30aa271379..811e9f10bf20 100644 --- a/test/Sema/var-redecl.c +++ b/test/Sema/var-redecl.c @@ -4,7 +4,7 @@ int outer1; // expected-note{{previous definition is here}} extern int outer2; // expected-note{{previous definition is here}} int outer4; int outer4; // expected-note{{previous definition is here}} -int outer5; // expected-note{{previous definition is here}} +int outer5; int outer6(float); // expected-note{{previous definition is here}} int outer7(float); @@ -13,7 +13,7 @@ void outer_test() { extern float outer2; // expected-error{{redefinition of 'outer2' with a different type}} extern float outer3; // expected-note{{previous definition is here}} double outer4; - extern int outer5; + extern int outer5; // expected-note{{previous definition is here}} extern int outer6; // expected-error{{redefinition of 'outer6' as different kind of symbol}} int outer7; extern int outer8; // expected-note{{previous definition is here}} @@ -60,3 +60,11 @@ int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} \ static int a; extern int a; // expected-note {{previous declaration is here}} int a; // expected-error {{non-static declaration of 'a' follows static declaration}} + +void f(int x) { // expected-note {{previous definition is here}} + extern int x; // expected-error {{extern declaration of 'x' follows non-extern declaration}} +} + +extern int b[]; +void g20() { extern int b[3]; } // expected-note{{previous definition is here}} +void g21() { extern int b[4]; } // expected-error{{redefinition of 'b' with a different type: 'int [4]' vs 'int [3]'}} diff --git a/test/Sema/warn-cast-qual.c b/test/Sema/warn-cast-qual.c new file mode 100644 index 000000000000..dc11f5717ebe --- /dev/null +++ b/test/Sema/warn-cast-qual.c @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -Wcast-qual -verify %s + +#include <stdint.h> + +void foo() { + const char * const ptr = 0; + const char * const *ptrptr = 0; + char *y = (char *)ptr; // expected-warning {{cast from 'const char *' to 'char *' drops const qualifier}} + char **y1 = (char **)ptrptr; // expected-warning {{cast from 'const char *const' to 'char *' drops const qualifier}} + const char **y2 = (const char **)ptrptr; // expected-warning {{cast from 'const char *const *' to 'const char **' drops const qualifier}} + + char *z = (char *)(uintptr_t)(const void *)ptr; // no warning + char *z1 = (char *)(const void *)ptr; // expected-warning {{cast from 'const void *' to 'char *' drops const qualifier}} + + volatile char *vol = 0; + char *vol2 = (char *)vol; // expected-warning {{cast from 'volatile char *' to 'char *' drops volatile qualifier}} + const volatile char *volc = 0; + char *volc2 = (char *)volc; // expected-warning {{cast from 'const volatile char *' to 'char *' drops const and volatile qualifiers}} + + int **intptrptr; + const int **intptrptrc = (const int **)intptrptr; // expected-warning {{cast from 'int **' to 'const int **' must have all intermediate pointers const qualified}} + volatile int **intptrptrv = (volatile int **)intptrptr; // expected-warning {{cast from 'int **' to 'volatile int **' must have all intermediate pointers const qualified}} + + int *intptr; + const int *intptrc = (const int *)intptr; // no warning + + const char **charptrptrc; + char **charptrptr = (char **)charptrptrc; // expected-warning {{cast from 'const char *' to 'char *' drops const qualifier}} +} diff --git a/test/Sema/warn-string-conversion.c b/test/Sema/warn-string-conversion.c new file mode 100644 index 000000000000..708dd543e402 --- /dev/null +++ b/test/Sema/warn-string-conversion.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -Wstring-conversion %s + +#define assert(EXPR) (void)(EXPR); + +// Expection for common assert form. +void test1() { + assert(0 && "foo"); + assert("foo" && 0); + assert(0 || "foo"); // expected-warning {{string literal}} +} + +void test2() { + if ("hi") {} // expected-warning {{string literal}} + while ("hello") {} // expected-warning {{string literal}} + for (;"howdy";) {} // expected-warning {{string literal}} + do { } while ("hey"); // expected-warning {{string literal}} +} diff --git a/test/Sema/warn-tautological-compare.c b/test/Sema/warn-tautological-compare.c new file mode 100644 index 000000000000..55de6179a31a --- /dev/null +++ b/test/Sema/warn-tautological-compare.c @@ -0,0 +1,86 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -verify %s +// rdar://18716393 + +extern int a[] __attribute__((weak)); +int b[] = {8,13,21}; +struct { + int x[10]; +} c; +const char str[] = "text"; + +void ignore() { + if (!a) {} +} +void test() { + if (!b) {} // expected-warning {{address of array 'b' will always evaluate to 'true'}} + if (b == 0) {} // expected-warning {{comparison of array 'b' equal to a null pointer is always false}} + if (!c.x) {} // expected-warning {{address of array 'c.x' will always evaluate to 'true'}} + if (c.x == 0) {} // expected-warning {{comparison of array 'c.x' equal to a null pointer is always false}} + if (!str) {} // expected-warning {{address of array 'str' will always evaluate to 'true'}} + if (0 == str) {} // expected-warning {{comparison of array 'str' equal to a null pointer is always false}} +} + +int array[2]; +int test1() +{ + if (!array) { // expected-warning {{address of array 'array' will always evaluate to 'true'}} + return array[0]; + } else if (array != 0) { // expected-warning {{comparison of array 'array' not equal to a null pointer is always true}} + return array[1]; + } + if (array == 0) // expected-warning {{comparison of array 'array' equal to a null pointer is always false}} + return 1; + return 0; +} + +#define NULL (void*)0 + +int test2(int* pointer, char ch, void * pv) { + if (!&pointer) { // expected-warning {{address of 'pointer' will always evaluate to 'true'}} + return 0; + } + + if (&pointer) { // expected-warning {{address of 'pointer' will always evaluate to 'true'}} + return 0; + } + + if (&pointer == NULL) {} // expected-warning {{comparison of address of 'pointer' equal to a null pointer is always false}} + + if (&pointer != NULL) {} // expected-warning {{comparison of address of 'pointer' not equal to a null pointer is always true}} + + return 1; +} + +void test3() { + if (array) { } // expected-warning {{address of array 'array' will always evaluate to 'true'}} + if (array != 0) {} // expected-warning {{comparison of array 'array' not equal to a null pointer is always true}} + if (!array) { } // expected-warning {{address of array 'array' will always evaluate to 'true'}} + if (array == 0) {} // expected-warning {{comparison of array 'array' equal to a null pointer is always false}} + + if (array[0] && + array) {} // expected-warning {{address of array 'array' will always evaluate to 'true'}} + + if (array[0] || + array) {} // expected-warning {{address of array 'array' will always evaluate to 'true'}} + + if (array[0] && + !array) {} // expected-warning {{address of array 'array' will always evaluate to 'true'}} + if (array[0] || + !array) {} // expected-warning {{address of array 'array' will always evaluate to 'true'}} + + if (array && // expected-warning {{address of array 'array' will always evaluate to 'true'}} + array[0]) {} + if (!array || // expected-warning {{address of array 'array' will always evaluate to 'true'}} + array[0]) {} + + if (array || // expected-warning {{address of array 'array' will always evaluate to 'true'}} + (!array && array[0])) {} // expected-warning {{address of array 'array' will always evaluate to 'true'}} + } + +// rdar://19256338 +#define SAVE_READ(PTR) if( (PTR) && (&result) ) *result=*PTR; +void _HTTPClientErrorHandler(int me) +{ + int *result; + SAVE_READ(&me); +} diff --git a/test/Sema/warn-thread-safety-analysis.c b/test/Sema/warn-thread-safety-analysis.c index 6d41e40d303f..55e6e707f013 100644 --- a/test/Sema/warn-thread-safety-analysis.c +++ b/test/Sema/warn-thread-safety-analysis.c @@ -117,12 +117,12 @@ int main() { mutex_unlock(foo_.mu_); mutex_exclusive_lock(&mu1); - mutex_shared_unlock(&mu1); // expected-warning {{releasing mutex 'mu1' using shared access, expected exclusive access}} - mutex_exclusive_unlock(&mu1); + mutex_shared_unlock(&mu1); // expected-warning {{releasing mutex 'mu1' using shared access, expected exclusive access}} + mutex_exclusive_unlock(&mu1); // expected-warning {{releasing mutex 'mu1' that was not held}} mutex_shared_lock(&mu1); mutex_exclusive_unlock(&mu1); // expected-warning {{releasing mutex 'mu1' using exclusive access, expected shared access}} - mutex_shared_unlock(&mu1); + mutex_shared_unlock(&mu1); // expected-warning {{releasing mutex 'mu1' that was not held}} return 0; } diff --git a/test/Sema/warn-unsequenced.c b/test/Sema/warn-unsequenced.c index a14d3281662b..70163dc0de94 100644 --- a/test/Sema/warn-unsequenced.c +++ b/test/Sema/warn-unsequenced.c @@ -29,6 +29,11 @@ void test() { a = f(a++, 0); // ok a = f(++a, a++); // expected-warning {{multiple unsequenced modifications}} + ++a + f(++a, 0); // expected-warning {{multiple unsequenced modifications}} + f(++a, 0) + ++a; // expected-warning {{multiple unsequenced modifications}} + a++ + f(a++, 0); // expected-warning {{multiple unsequenced modifications}} + f(a++, 0) + a++; // expected-warning {{multiple unsequenced modifications}} + a = ++a; // expected-warning {{multiple unsequenced modifications}} a += ++a; // expected-warning {{unsequenced modification and access}} @@ -48,7 +53,7 @@ void test() { (1 ? a : ++a) + a; // ok (xs[5] ? ++a : ++a) + a; // FIXME: warn here - (++a, xs[6] ? ++a : 0) + a; // FIXME: warn here + (++a, xs[6] ? ++a : 0) + a; // expected-warning {{unsequenced modification and access}} // Here, the read of the fourth 'a' might happen before or after the write to // the second 'a'. @@ -84,5 +89,8 @@ void test() { (__builtin_classify_type(++a) ? 1 : 0) + ++a; // ok (__builtin_constant_p(++a) ? 1 : 0) + ++a; // ok - (__builtin_expect(++a, 0) ? 1 : 0) + ++a; // FIXME: warn here + (__builtin_expect(++a, 0) ? 1 : 0) + ++a; // expected-warning {{multiple unsequenced modifications}} + _Generic(++a, default: 0) + ++a; // ok + sizeof(++a) + ++a; // ok + _Alignof(++a) + ++a; // expected-warning {{extension}} } diff --git a/test/Sema/warn-unused-value.c b/test/Sema/warn-unused-value.c index 95cd8fb70400..edf791593a42 100644 --- a/test/Sema/warn-unused-value.c +++ b/test/Sema/warn-unused-value.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -Wunused-label %s -// RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s -// RUN: %clang_cc1 -fsyntax-only -verify -Wall %s +// RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wunused-value -Wunused-label %s +// RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wunused %s +// RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wall %s int i = 0; int j = 0; @@ -88,3 +88,22 @@ void f1(struct s0 *a) { // rdar://8139785 f0((int)(a->f0 + 1, 10)); // expected-warning {{expression result unused}} } + +void blah(int a); +#define GenTest(x) _Generic(x, default : blah)(x) + +void unevaluated_operands(void) { + int val = 0; + + (void)sizeof(++val); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + (void)_Generic(val++, default : 0); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + (void)_Alignof(val++); // expected-warning {{expression with side effects has no effect in an unevaluated context}} expected-warning {{'_Alignof' applied to an expression is a GNU extension}} + + // VLAs can have side effects so long as it's part of the type and not + // an expression. + (void)sizeof(int[++val]); // Ok + (void)_Alignof(int[++val]); // Ok + + // Side effects as part of macro expansion are ok. + GenTest(val++); +} diff --git a/test/Sema/wchar.c b/test/Sema/wchar.c index 74e482a2a0f8..a45a14daaef2 100644 --- a/test/Sema/wchar.c +++ b/test/Sema/wchar.c @@ -8,9 +8,9 @@ typedef __WCHAR_TYPE__ wchar_t; #define WCHAR_T_TYPE unsigned short #elif defined(__arm) || defined(__aarch64__) #define WCHAR_T_TYPE unsigned int -#elif defined(__sun) || defined(__AuroraUX__) +#elif defined(__sun) #define WCHAR_T_TYPE long -#else /* Solaris or AuroraUX. */ +#else /* Solaris. */ #define WCHAR_T_TYPE int #endif diff --git a/test/SemaCUDA/amdgpu-num-gpr-attr.cu b/test/SemaCUDA/amdgpu-num-gpr-attr.cu new file mode 100644 index 000000000000..83acbc5007ec --- /dev/null +++ b/test/SemaCUDA/amdgpu-num-gpr-attr.cu @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +__attribute__((amdgpu_num_vgpr(64))) +__global__ void test_num_vgpr() { } // expected-error {{'amdgpu_num_vgpr' attribute only applies to kernel functions}} + +__attribute__((amdgpu_num_sgpr(32))) +__global__ void test_num_sgpr() { } // expected-error {{'amdgpu_num_sgpr' attribute only applies to kernel functions}} + +// fixme-expected-error@+3 {{'amdgpu_num_sgpr' attribute only applies to kernel functions}} +// expected-error@+2 {{'amdgpu_num_vgpr' attribute only applies to kernel functions}} +__attribute__((amdgpu_num_sgpr(32), amdgpu_num_vgpr(64))) +__global__ void test_num_vgpr_num_sgpr() { } diff --git a/test/SemaCUDA/function-target.cu b/test/SemaCUDA/function-target.cu index 51bc8c9f559e..ca56030309de 100644 --- a/test/SemaCUDA/function-target.cu +++ b/test/SemaCUDA/function-target.cu @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -fcuda-is-device -verify %s #include "Inputs/cuda.h" @@ -31,14 +32,40 @@ __device__ void d1(void) { d1g<<<1, 1>>>(); // expected-error {{reference to __global__ function 'd1g' in __device__ function}} } -__host__ void hd1h(void); // expected-note {{candidate function not viable: call to __host__ function from __host__ __device__ function}} -__device__ void hd1d(void); // expected-note {{candidate function not viable: call to __device__ function from __host__ __device__ function}} +// Expected 0-1 as in one of host/device side compilation it is an error, while +// not in the other +__host__ void hd1h(void); // expected-note 0-1 {{candidate function not viable: call to __host__ function from __host__ __device__ function}} +__device__ void hd1d(void); // expected-note 0-1 {{candidate function not viable: call to __device__ function from __host__ __device__ function}} +__host__ void hd1hg(void); +__device__ void hd1dg(void); +#ifdef __CUDA_ARCH__ +__host__ void hd1hig(void); // expected-note {{candidate function not viable: call to __host__ function from __host__ __device__ function}} +#else +__device__ void hd1dig(void); // expected-note {{candidate function not viable: call to __device__ function from __host__ __device__ function}} +#endif __host__ __device__ void hd1hd(void); __global__ void hd1g(void); // expected-note {{'hd1g' declared here}} __host__ __device__ void hd1(void) { - hd1h(); // expected-error {{no matching function}} - hd1d(); // expected-error {{no matching function}} + // Expected 0-1 as in one of host/device side compilation it is an error, + // while not in the other + hd1d(); // expected-error 0-1 {{no matching function}} + hd1h(); // expected-error 0-1 {{no matching function}} + + // No errors as guarded +#ifdef __CUDA_ARCH__ + hd1d(); +#else + hd1h(); +#endif + + // Errors as incorrectly guarded +#ifndef __CUDA_ARCH__ + hd1dig(); // expected-error {{no matching function}} +#else + hd1hig(); // expected-error {{no matching function}} +#endif + hd1hd(); hd1g<<<1, 1>>>(); // expected-error {{reference to __global__ function 'hd1g' in __host__ __device__ function}} } diff --git a/test/SemaCUDA/implicit-copy.cu b/test/SemaCUDA/implicit-copy.cu new file mode 100644 index 000000000000..b1b4887f561b --- /dev/null +++ b/test/SemaCUDA/implicit-copy.cu @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 -std=gnu++11 -triple nvptx64-unknown-unknown -fsyntax-only -verify %s +// RUN: %clang_cc1 -std=gnu++11 -triple nvptx64-unknown-unknown -fcuda-is-device -fsyntax-only -verify %s + +struct CopyableH { + const CopyableH& operator=(const CopyableH& x) { return *this; } +}; +struct CopyableD { + __attribute__((device)) const CopyableD& operator=(const CopyableD x) { return *this; } +}; + +struct SimpleH { + CopyableH b; +}; +// expected-note@-3 2 {{candidate function (the implicit copy assignment operator) not viable: call to __host__ function from __device__ function}} +// expected-note@-4 2 {{candidate function (the implicit move assignment operator) not viable: call to __host__ function from __device__ function}} + +struct SimpleD { + CopyableD b; +}; +// expected-note@-3 2 {{candidate function (the implicit copy assignment operator) not viable: call to __device__ function from __host__ function}} +// expected-note@-4 2 {{candidate function (the implicit move assignment operator) not viable: call to __device__ function from __host__ function}} + +void foo1hh() { + SimpleH a, b; + a = b; +} +__attribute__((device)) void foo1hd() { + SimpleH a, b; + a = b; // expected-error {{no viable overloaded}} +} +void foo1dh() { + SimpleD a, b; + a = b; // expected-error {{no viable overloaded}} +} +__attribute__((device)) void foo1dd() { + SimpleD a, b; + a = b; +} + +void foo2hh(SimpleH &a, SimpleH &b) { + a = b; +} +__attribute__((device)) void foo2hd(SimpleH &a, SimpleH &b) { + a = b; // expected-error {{no viable overloaded}} +} +void foo2dh(SimpleD &a, SimpleD &b) { + a = b; // expected-error {{no viable overloaded}} +} +__attribute__((device)) void foo2dd(SimpleD &a, SimpleD &b) { + a = b; +} diff --git a/test/SemaCUDA/implicit-intrinsic.cu b/test/SemaCUDA/implicit-intrinsic.cu new file mode 100644 index 000000000000..3d24aa719e57 --- /dev/null +++ b/test/SemaCUDA/implicit-intrinsic.cu @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -std=gnu++11 -triple nvptx64-unknown-unknown -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +// expected-no-diagnostics +__device__ void __threadfence_system() { + // This shouldn't produce an error, since __nvvm_membar_sys is inferred to + // be __host__ __device__ and thus callable from device code. + __nvvm_membar_sys(); +} diff --git a/test/SemaCUDA/implicit-member-target-collision-cxx11.cu b/test/SemaCUDA/implicit-member-target-collision-cxx11.cu new file mode 100644 index 000000000000..f038c376ff3c --- /dev/null +++ b/test/SemaCUDA/implicit-member-target-collision-cxx11.cu @@ -0,0 +1,111 @@ +// RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +//------------------------------------------------------------------------------ +// Test 1: collision between two bases + +struct A1_with_host_ctor { + A1_with_host_ctor() {} +}; + +struct B1_with_device_ctor { + __device__ B1_with_device_ctor() {} +}; + +struct C1_with_collision : A1_with_host_ctor, B1_with_device_ctor { +}; + +// expected-note@-3 {{candidate constructor (the implicit default constructor) not viable}} +// expected-note@-4 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-5 {{candidate constructor (the implicit copy constructor) not viable}} +// expected-note@-6 {{candidate constructor (the implicit move constructor) not viable}} + +void hostfoo1() { + C1_with_collision c; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 2: collision between two fields + +struct C2_with_collision { + A1_with_host_ctor aa; + B1_with_device_ctor bb; +}; + +// expected-note@-5 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-6 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-7 {{candidate constructor (the implicit copy constructor}} not viable +// expected-note@-8 {{candidate constructor (the implicit move constructor}} not viable + +void hostfoo2() { + C2_with_collision c; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 3: collision between a field and a base + +struct C3_with_collision : A1_with_host_ctor { + B1_with_device_ctor bb; +}; + +// expected-note@-4 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-5 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-6 {{candidate constructor (the implicit copy constructor}} not viable +// expected-note@-7 {{candidate constructor (the implicit move constructor}} not viable + +void hostfoo3() { + C3_with_collision c; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 4: collision on resolving a copy ctor + +struct A4_with_host_copy_ctor { + A4_with_host_copy_ctor() {} + A4_with_host_copy_ctor(const A4_with_host_copy_ctor&) {} +}; + +struct B4_with_device_copy_ctor { + B4_with_device_copy_ctor() {} + __device__ B4_with_device_copy_ctor(const B4_with_device_copy_ctor&) {} +}; + +struct C4_with_collision : A4_with_host_copy_ctor, B4_with_device_copy_ctor { +}; + +// expected-note@-3 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-4 {{implicit copy constructor inferred target collision}} +// expected-note@-5 {{candidate constructor (the implicit copy constructor}} not viable + +void hostfoo4() { + C4_with_collision c; + C4_with_collision c2 = c; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 5: collision on resolving a move ctor + +struct A5_with_host_move_ctor { + A5_with_host_move_ctor() {} + A5_with_host_move_ctor(A5_with_host_move_ctor&&) {} +// expected-note@-1 {{copy constructor is implicitly deleted because 'A5_with_host_move_ctor' has a user-declared move constructor}} +}; + +struct B5_with_device_move_ctor { + B5_with_device_move_ctor() {} + __device__ B5_with_device_move_ctor(B5_with_device_move_ctor&&) {} +}; + +struct C5_with_collision : A5_with_host_move_ctor, B5_with_device_move_ctor { +}; +// expected-note@-2 {{deleted}} + +void hostfoo5() { + C5_with_collision c; + // What happens here: + // This tries to find the move ctor. Since the move ctor is deleted due to + // collision, it then looks for a copy ctor. But copy ctors are implicitly + // deleted when move ctors are declared explicitly. + C5_with_collision c2(static_cast<C5_with_collision&&>(c)); // expected-error {{call to implicitly-deleted}} +} diff --git a/test/SemaCUDA/implicit-member-target-collision.cu b/test/SemaCUDA/implicit-member-target-collision.cu new file mode 100644 index 000000000000..25cdccbfd35d --- /dev/null +++ b/test/SemaCUDA/implicit-member-target-collision.cu @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +//------------------------------------------------------------------------------ +// Test 1: collision between two bases + +struct A1_with_host_ctor { + A1_with_host_ctor() {} +}; + +struct B1_with_device_ctor { + __device__ B1_with_device_ctor() {} +}; + +struct C1_with_collision : A1_with_host_ctor, B1_with_device_ctor { +}; + +// expected-note@-3 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-4 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-5 {{candidate constructor (the implicit copy constructor}} not viable + +void hostfoo1() { + C1_with_collision c; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 2: collision between two fields + +struct C2_with_collision { + A1_with_host_ctor aa; + B1_with_device_ctor bb; +}; + +// expected-note@-5 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-6 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-7 {{candidate constructor (the implicit copy constructor}} not viable + +void hostfoo2() { + C2_with_collision c; // expected-error {{no matching constructor}} + +} + +//------------------------------------------------------------------------------ +// Test 3: collision between a field and a base + +struct C3_with_collision : A1_with_host_ctor { + B1_with_device_ctor bb; +}; + +// expected-note@-4 {{candidate constructor (the implicit default constructor}} not viable +// expected-note@-5 {{implicit default constructor inferred target collision: call to both __host__ and __device__ members}} +// expected-note@-6 {{candidate constructor (the implicit copy constructor}} not viable + +void hostfoo3() { + C3_with_collision c; // expected-error {{no matching constructor}} +} diff --git a/test/SemaCUDA/implicit-member-target.cu b/test/SemaCUDA/implicit-member-target.cu new file mode 100644 index 000000000000..6064560f2c6f --- /dev/null +++ b/test/SemaCUDA/implicit-member-target.cu @@ -0,0 +1,186 @@ +// RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +//------------------------------------------------------------------------------ +// Test 1: infer default ctor to be host. + +struct A1_with_host_ctor { + A1_with_host_ctor() {} +}; + +// The implicit default constructor is inferred to be host because it only needs +// to invoke a single host constructor (A1_with_host_ctor's). So we'll encounter +// an error when calling it from a __device__ function, but not from a __host__ +// function. +struct B1_with_implicit_default_ctor : A1_with_host_ctor { +}; + +// expected-note@-3 {{call to __host__ function from __device__}} +// expected-note@-4 {{candidate constructor (the implicit copy constructor) not viable}} +// expected-note@-5 {{candidate constructor (the implicit move constructor) not viable}} + +void hostfoo() { + B1_with_implicit_default_ctor b; +} + +__device__ void devicefoo() { + B1_with_implicit_default_ctor b; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 2: infer default ctor to be device. + +struct A2_with_device_ctor { + __device__ A2_with_device_ctor() {} +}; + +struct B2_with_implicit_default_ctor : A2_with_device_ctor { +}; + +// expected-note@-3 {{call to __device__ function from __host__}} +// expected-note@-4 {{candidate constructor (the implicit copy constructor) not viable}} +// expected-note@-5 {{candidate constructor (the implicit move constructor) not viable}} + +void hostfoo2() { + B2_with_implicit_default_ctor b; // expected-error {{no matching constructor}} +} + +__device__ void devicefoo2() { + B2_with_implicit_default_ctor b; +} + +//------------------------------------------------------------------------------ +// Test 3: infer copy ctor + +struct A3_with_device_ctors { + __host__ A3_with_device_ctors() {} + __device__ A3_with_device_ctors(const A3_with_device_ctors&) {} +}; + +struct B3_with_implicit_ctors : A3_with_device_ctors { +}; + +// expected-note@-3 {{copy constructor of 'B3_with_implicit_ctors' is implicitly deleted}} + +void hostfoo3() { + B3_with_implicit_ctors b; // this is OK because the inferred default ctor + // here is __host__ + B3_with_implicit_ctors b2 = b; // expected-error {{call to implicitly-deleted copy constructor}} + +} + +//------------------------------------------------------------------------------ +// Test 4: infer default ctor from a field, not a base + +struct A4_with_host_ctor { + A4_with_host_ctor() {} +}; + +struct B4_with_implicit_default_ctor { + A4_with_host_ctor field; +}; + +// expected-note@-4 {{call to __host__ function from __device__}} +// expected-note@-5 {{candidate constructor (the implicit copy constructor) not viable}} +// expected-note@-6 {{candidate constructor (the implicit move constructor) not viable}} + +void hostfoo4() { + B4_with_implicit_default_ctor b; +} + +__device__ void devicefoo4() { + B4_with_implicit_default_ctor b; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 5: copy ctor with non-const param + +struct A5_copy_ctor_constness { + __host__ A5_copy_ctor_constness() {} + __host__ A5_copy_ctor_constness(A5_copy_ctor_constness&) {} +}; + +struct B5_copy_ctor_constness : A5_copy_ctor_constness { +}; + +// expected-note@-3 {{candidate constructor (the implicit copy constructor) not viable: call to __host__ function from __device__ function}} +// expected-note@-4 {{candidate constructor (the implicit default constructor) not viable}} + +void hostfoo5(B5_copy_ctor_constness& b_arg) { + B5_copy_ctor_constness b = b_arg; +} + +__device__ void devicefoo5(B5_copy_ctor_constness& b_arg) { + B5_copy_ctor_constness b = b_arg; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 6: explicitly defaulted ctor: since they are spelled out, they have +// a host/device designation explicitly so no inference needs to be done. + +struct A6_with_device_ctor { + __device__ A6_with_device_ctor() {} +}; + +struct B6_with_defaulted_ctor : A6_with_device_ctor { + __host__ B6_with_defaulted_ctor() = default; +}; + +// expected-note@-3 {{candidate constructor not viable: call to __host__ function from __device__ function}} +// expected-note@-5 {{candidate constructor (the implicit copy constructor) not viable}} +// expected-note@-6 {{candidate constructor (the implicit move constructor) not viable}} + +__device__ void devicefoo6() { + B6_with_defaulted_ctor b; // expected-error {{no matching constructor}} +} + +//------------------------------------------------------------------------------ +// Test 7: copy assignment operator + +struct A7_with_copy_assign { + A7_with_copy_assign() {} + __device__ A7_with_copy_assign& operator=(const A7_with_copy_assign&) {} +}; + +struct B7_with_copy_assign : A7_with_copy_assign { +}; + +// expected-note@-3 {{candidate function (the implicit copy assignment operator) not viable: call to __device__ function from __host__ function}} +// expected-note@-4 {{candidate function (the implicit move assignment operator) not viable: call to __device__ function from __host__ function}} + +void hostfoo7() { + B7_with_copy_assign b1, b2; + b1 = b2; // expected-error {{no viable overloaded '='}} +} + +//------------------------------------------------------------------------------ +// Test 8: move assignment operator + +// definitions for std::move +namespace std { +inline namespace foo { +template <class T> struct remove_reference { typedef T type; }; +template <class T> struct remove_reference<T&> { typedef T type; }; +template <class T> struct remove_reference<T&&> { typedef T type; }; + +template <class T> typename remove_reference<T>::type&& move(T&& t); +} +} + +struct A8_with_move_assign { + A8_with_move_assign() {} + __device__ A8_with_move_assign& operator=(A8_with_move_assign&&) {} + __device__ A8_with_move_assign& operator=(const A8_with_move_assign&) {} +}; + +struct B8_with_move_assign : A8_with_move_assign { +}; + +// expected-note@-3 {{candidate function (the implicit copy assignment operator) not viable: call to __device__ function from __host__ function}} +// expected-note@-4 {{candidate function (the implicit move assignment operator) not viable: call to __device__ function from __host__ function}} + +void hostfoo8() { + B8_with_move_assign b1, b2; + b1 = std::move(b2); // expected-error {{no viable overloaded '='}} +} diff --git a/test/SemaCUDA/launch_bounds.cu b/test/SemaCUDA/launch_bounds.cu index bed7658aed59..8edc41b6ce91 100644 --- a/test/SemaCUDA/launch_bounds.cu +++ b/test/SemaCUDA/launch_bounds.cu @@ -6,9 +6,6 @@ __launch_bounds__(128, 7) void Test1(void); __launch_bounds__(128) void Test2(void); __launch_bounds__(1, 2, 3) void Test3(void); // expected-error {{'launch_bounds' attribute takes no more than 2 arguments}} - -// FIXME: the error should read that the attribute takes exactly one or two arguments, but there -// is no support for such a diagnostic currently. -__launch_bounds__() void Test4(void); // expected-error {{'launch_bounds' attribute takes no more than 2 arguments}} +__launch_bounds__() void Test4(void); // expected-error {{'launch_bounds' attribute takes at least 1 argument}} int Test5 __launch_bounds__(128, 7); // expected-warning {{'launch_bounds' attribute only applies to functions and methods}} diff --git a/test/SemaCUDA/method-target.cu b/test/SemaCUDA/method-target.cu new file mode 100644 index 000000000000..4fa290719cc1 --- /dev/null +++ b/test/SemaCUDA/method-target.cu @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include "Inputs/cuda.h" + +//------------------------------------------------------------------------------ +// Test 1: host method called from device function + +struct S1 { + void method() {} +}; + +__device__ void foo1(S1& s) { + s.method(); // expected-error {{reference to __host__ function 'method' in __device__ function}} +} + +//------------------------------------------------------------------------------ +// Test 2: host method called from device function, for overloaded method + +struct S2 { + void method(int) {} // expected-note {{candidate function not viable: call to __host__ function from __device__ function}} + void method(float) {} // expected-note {{candidate function not viable: call to __host__ function from __device__ function}} +}; + +__device__ void foo2(S2& s, int i, float f) { + s.method(f); // expected-error {{no matching member function}} +} + +//------------------------------------------------------------------------------ +// Test 3: device method called from host function + +struct S3 { + __device__ void method() {} +}; + +void foo3(S3& s) { + s.method(); // expected-error {{reference to __device__ function 'method' in __host__ function}} +} + +//------------------------------------------------------------------------------ +// Test 4: device method called from host&device function + +struct S4 { + __device__ void method() {} +}; + +__host__ __device__ void foo4(S4& s) { + s.method(); // expected-error {{reference to __device__ function 'method' in __host__ __device__ function}} +} + +//------------------------------------------------------------------------------ +// Test 5: overloaded operators + +struct S5 { + S5() {} + S5& operator=(const S5&) {return *this;} // expected-note {{candidate function not viable}} +}; + +__device__ void foo5(S5& s, S5& t) { + s = t; // expected-error {{no viable overloaded '='}} +} + +//------------------------------------------------------------------------------ +// Test 6: call method through pointer + +struct S6 { + void method() {} +}; + +__device__ void foo6(S6* s) { + s->method(); // expected-error {{reference to __host__ function 'method' in __device__ function}} +} diff --git a/test/SemaCXX/Inputs/header-with-pragma-optimize-off.h b/test/SemaCXX/Inputs/header-with-pragma-optimize-off.h new file mode 100644 index 000000000000..ac5020697eba --- /dev/null +++ b/test/SemaCXX/Inputs/header-with-pragma-optimize-off.h @@ -0,0 +1,5 @@ + +// Open an "off" region in this header. +#pragma clang optimize off + +// Let the "off" region fall through to anything including this header. diff --git a/test/SemaCXX/Inputs/override-system-header.h b/test/SemaCXX/Inputs/override-system-header.h new file mode 100644 index 000000000000..9831ab7952b1 --- /dev/null +++ b/test/SemaCXX/Inputs/override-system-header.h @@ -0,0 +1,6 @@ +// override-system-header.h to test out 'override' warning. +// rdar://18295240 +#define END_COM_MAP virtual unsigned AddRef(void) = 0; + +#define STDMETHOD(method) virtual void method +#define IFACEMETHOD(method) STDMETHOD(method) diff --git a/test/SemaCXX/MicrosoftCompatibility.cpp b/test/SemaCXX/MicrosoftCompatibility.cpp index fb7d9751d1a5..56486b8f049a 100644 --- a/test/SemaCXX/MicrosoftCompatibility.cpp +++ b/test/SemaCXX/MicrosoftCompatibility.cpp @@ -34,7 +34,7 @@ namespace ms_protected_scope { int jump_over_variable_init(bool b) { if (b) - goto foo; // expected-warning {{goto into protected scope}} + goto foo; // expected-warning {{jump from this goto statement to its label is a Microsoft extension}} C c; // expected-note {{jump bypasses variable initialization}} foo: return 1; @@ -45,7 +45,7 @@ struct Y { }; void jump_over_var_with_dtor() { - goto end; // expected-warning{{goto into protected scope}} + goto end; // expected-warning{{jump from this goto statement to its label is a Microsoft extension}} Y y; // expected-note {{jump bypasses variable with a non-trivial destructor}} end: ; @@ -55,14 +55,14 @@ void jump_over_var_with_dtor() { switch (c) { case 0: int x = 56; // expected-note {{jump bypasses variable initialization}} - case 1: // expected-error {{switch case is in protected scope}} + case 1: // expected-error {{cannot jump}} x = 10; } } void exception_jump() { - goto l2; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{cannot jump}} try { // expected-note {{jump bypasses initialization of try block}} l2: ; } catch(int) { @@ -71,7 +71,7 @@ void exception_jump() { int jump_over_indirect_goto() { static void *ps[] = { &&a0 }; - goto *&&a0; // expected-warning {{goto into protected scope}} + goto *&&a0; // expected-warning {{jump from this goto statement to its label is a Microsoft extension}} int a = 3; // expected-note {{jump bypasses variable initialization}} a0: return 0; diff --git a/test/SemaCXX/MicrosoftExtensions.cpp b/test/SemaCXX/MicrosoftExtensions.cpp index 6d221a409e7b..57d6f0d6bef2 100644 --- a/test/SemaCXX/MicrosoftExtensions.cpp +++ b/test/SemaCXX/MicrosoftExtensions.cpp @@ -79,6 +79,7 @@ struct M { // __unaligned handling typedef char __unaligned *aligned_type; +typedef struct UnalignedTag { int f; } __unaligned *aligned_type2; template<typename T> void h1(T (__stdcall M::* const )()) { } @@ -372,14 +373,15 @@ struct SomeBase { // expected-note@+2 {{overridden virtual function is here}} // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}} - virtual void SealedFunction() sealed; + virtual void SealedFunction() sealed; // expected-note {{overridden virtual function is here}} }; // expected-note@+2 {{'SealedType' declared here}} // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}} struct SealedType sealed : SomeBase { - // expected-error@+1 {{declaration of 'SealedFunction' overrides a 'sealed' function}} - virtual void SealedFunction(); + // expected-error@+2 {{declaration of 'SealedFunction' overrides a 'sealed' function}} + // FIXME. warning can be suppressed if we're also issuing error for overriding a 'final' function. + virtual void SealedFunction(); // expected-warning {{'SealedFunction' overrides a member function but is not marked 'override'}} // expected-warning@+1 {{'override' keyword is a C++11 extension}} virtual void OverrideMe() override; diff --git a/test/SemaCXX/MicrosoftSuper.cpp b/test/SemaCXX/MicrosoftSuper.cpp new file mode 100644 index 000000000000..cb21656ab762 --- /dev/null +++ b/test/SemaCXX/MicrosoftSuper.cpp @@ -0,0 +1,149 @@ +// RUN: %clang_cc1 %s -fsyntax-only -fms-extensions -std=c++11 -verify + +struct Errors { + using __super::foo; // expected-error {{'__super' cannot be used with a using declaration}} + __super::XXX x; // expected-error {{invalid use of '__super', Errors has no base classes}} expected-error {{expected}} + + void foo() { + // expected-note@+4 {{replace parentheses with an initializer to declare a variable}} + // expected-warning@+3 {{empty parentheses interpreted as a function declaration}} + // expected-error@+2 {{C++ requires a type specifier for all declarations}} + // expected-error@+1 {{use of '__super' inside a lambda is unsupported}} + auto lambda = []{ __super::foo(); }; + } +}; + +struct Base1 { + void foo(int) {} + + static void static_foo() {} + + typedef int XXX; +}; + +struct Derived : Base1 { + __super::XXX x; + typedef __super::XXX Type; + + enum E { + X = sizeof(__super::XXX) + }; + + void foo() { + __super::foo(1); + + if (true) { + __super::foo(1); + } + + return __super::foo(1); + } + + static void bar() { + __super::static_foo(); + } +}; + +struct Outer { + struct Inner : Base1 { + static const int x = sizeof(__super::XXX); + }; +}; + +struct Base2 { + void foo(char) {} +}; + +struct MemberFunctionInMultipleBases : Base1, Base2 { + void foo() { + __super::foo('x'); + } +}; + +struct Base3 { + void foo(int) {} + void foo(char) {} +}; + +struct OverloadedMemberFunction : Base3 { + void foo() { + __super::foo('x'); + } +}; + +struct PointerToMember : Base1 { + template <void (Base1::*MP)(int)> + struct Wrapper { + static void bar() {} + }; + + void baz(); +}; + +void PointerToMember::baz() { + Wrapper<&__super::foo>::bar(); +} + +template <typename T> +struct BaseTemplate { + typedef int XXX; + + int foo() { return 0; } +}; + +struct DerivedFromKnownSpecialization : BaseTemplate<int> { + __super::XXX a; + typedef __super::XXX b; + + void foo() { + __super::XXX c; + typedef __super::XXX d; + + __super::foo(); + } +}; + +template <typename T> +struct DerivedFromDependentBase : BaseTemplate<T> { + typename __super::XXX a; + typedef typename __super::XXX b; + + __super::XXX c; // expected-error {{missing 'typename'}} + typedef __super::XXX d; // expected-error {{missing 'typename'}} + + void foo() { + typename __super::XXX e; + typedef typename __super::XXX f; + + __super::XXX g; // expected-error {{missing 'typename'}} + typedef __super::XXX h; // expected-error {{missing 'typename'}} + + int x = __super::foo(); + } +}; + +template <typename T> +struct DerivedFromTemplateParameter : T { + typename __super::XXX a; + typedef typename __super::XXX b; + + __super::XXX c; // expected-error {{missing 'typename'}} + typedef __super::XXX d; // expected-error {{missing 'typename'}} + + void foo() { + typename __super::XXX e; + typedef typename __super::XXX f; + + __super::XXX g; // expected-error {{missing 'typename'}} + typedef __super::XXX h; // expected-error {{missing 'typename'}} + + __super::foo(1); + } +}; + +void instantiate() { + DerivedFromDependentBase<int> d; + d.foo(); + DerivedFromTemplateParameter<Base1> t; + t.foo(); +} diff --git a/test/SemaCXX/PR10177.cpp b/test/SemaCXX/PR10177.cpp index 8d745de0a6a1..e361ff37bc03 100644 --- a/test/SemaCXX/PR10177.cpp +++ b/test/SemaCXX/PR10177.cpp @@ -1,4 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++1y -verify %s -DCXX1Y + +#ifndef CXX1Y template<typename T, typename U, U> using alias_ref = T; template<typename T, typename U, U> void func_ref() {} @@ -9,22 +12,29 @@ struct U { static int a; }; -template<int N> struct S; // expected-note 2{{here}} +template<int N> struct S; // expected-note 6{{here}} template<int N> -int U<N>::a = S<N>::kError; // expected-error 2{{undefined}} +int U<N>::a = S<N>::kError; // expected-error 6{{undefined}} template<typename T> void f() { - // FIXME: The standard suggests that U<0>::a is odr-used by this expression, - // but it's not entirely clear that's the right behaviour. - (void)alias_ref<int, int&, U<0>::a>(); + (void)alias_ref<int, int&, U<0>::a>(); // expected-note {{here}} (void)func_ref<int, int&, U<1>::a>(); // expected-note {{here}} (void)class_ref<int, int&, U<2>::a>(); // expected-note {{here}} }; + +template<int N> +void fi() { + (void)alias_ref<int, int&, U<N>::a>(); // expected-note {{here}} + (void)func_ref<int, int&, U<N+1>::a>(); // expected-note {{here}} + (void)class_ref<int, int&, U<N+2>::a>(); // expected-note {{here}} +}; + int main() { - f<int>(); // expected-note 2{{here}} + f<int>(); // NOTE: Non-dependent name uses are type-checked at template definition time. + fi<10>(); // expected-note 3{{here}} } namespace N { @@ -38,3 +48,12 @@ namespace N { } int j = f<int>(); } + +#else +// expected-no-diagnostics + +namespace { template<typename> extern int n; } +template<typename T> int g() { return n<int>; } + +#endif + diff --git a/test/SemaCXX/PR20705.cpp b/test/SemaCXX/PR20705.cpp new file mode 100644 index 000000000000..be2676e56356 --- /dev/null +++ b/test/SemaCXX/PR20705.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +template <typename T> +struct X {}; +auto b = []() { + struct S { + static typename X<decltype(int)>::type Run(){}; + // expected-error@-1 4{{}} + }; + return 5; +}(); + +template <typename T1, typename T2> +class PC { +}; + +template <typename T> +class P { + static typename PC<T, Invalid>::Type Foo(); + // expected-error@-1 4{{}} +}; diff --git a/test/SemaCXX/align_value.cpp b/test/SemaCXX/align_value.cpp new file mode 100644 index 000000000000..519868201f99 --- /dev/null +++ b/test/SemaCXX/align_value.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef double * __attribute__((align_value(64))) aligned_double; + +void foo(aligned_double x, double * y __attribute__((align_value(32))), + double & z __attribute__((align_value(128)))) { }; + +template <typename T, int Q> +struct x { + typedef T* aligned_int __attribute__((align_value(32+8*Q))); + aligned_int V; + + void foo(aligned_int a, T &b __attribute__((align_value(sizeof(T)*4)))); +}; + +x<float, 4> y; + +template <typename T, int Q> +struct nope { + // expected-error@+1 {{requested alignment is not a power of 2}} + void foo(T &b __attribute__((align_value(sizeof(T)+1)))); +}; + +// expected-note@+1 {{in instantiation of template class 'nope<long double, 4>' requested here}} +nope<long double, 4> y2; + diff --git a/test/SemaCXX/anonymous-union.cpp b/test/SemaCXX/anonymous-union.cpp index fde27b049d88..46d426cf0c0f 100644 --- a/test/SemaCXX/anonymous-union.cpp +++ b/test/SemaCXX/anonymous-union.cpp @@ -80,10 +80,14 @@ union { // expected-error{{anonymous unions at namespace or global scope must be }; static union { - int int_val2; + int int_val2; // expected-note{{previous definition is here}} float float_val2; }; +void PR21858() { + void int_val2(); // expected-error{{redefinition of 'int_val2' as different kind of symbol}} +} + void f() { int_val2 = 0; float_val2 = 0.0; diff --git a/test/SemaCXX/arrow-operator.cpp b/test/SemaCXX/arrow-operator.cpp index 173ff729fc1b..3e32a6ba33eb 100644 --- a/test/SemaCXX/arrow-operator.cpp +++ b/test/SemaCXX/arrow-operator.cpp @@ -52,14 +52,15 @@ class wrapped_ptr { class Worker { public: - void DoSomething(); + void DoSomething(); // expected-note {{'DoSomething' declared here}} void Chuck(); }; void test() { wrapped_ptr<Worker> worker(new Worker); worker.DoSomething(); // expected-error {{no member named 'DoSomething' in 'arrow_suggest::wrapped_ptr<arrow_suggest::Worker>'; did you mean to use '->' instead of '.'?}} - worker.DoSamething(); // expected-error {{no member named 'DoSamething' in 'arrow_suggest::wrapped_ptr<arrow_suggest::Worker>'}} + worker.DoSamething(); // expected-error {{no member named 'DoSamething' in 'arrow_suggest::wrapped_ptr<arrow_suggest::Worker>'; did you mean to use '->' instead of '.'?}} \ + // expected-error {{no member named 'DoSamething' in 'arrow_suggest::Worker'; did you mean 'DoSomething'?}} worker.Chuck(); // expected-error {{no member named 'Chuck' in 'arrow_suggest::wrapped_ptr<arrow_suggest::Worker>'; did you mean 'Check'?}} } diff --git a/test/SemaCXX/ast-print.cpp b/test/SemaCXX/ast-print.cpp index 4851571283f4..baece3c2b320 100644 --- a/test/SemaCXX/ast-print.cpp +++ b/test/SemaCXX/ast-print.cpp @@ -208,3 +208,8 @@ void test(int i) { } } } + +namespace { +// CHECK: struct {{\[\[gnu::visibility\(\"hidden\"\)\]\]}} S; +struct [[gnu::visibility("hidden")]] S; +} diff --git a/test/SemaCXX/atomic-type.cpp b/test/SemaCXX/atomic-type.cpp index ae18eab5b4a9..779b0671cad6 100644 --- a/test/SemaCXX/atomic-type.cpp +++ b/test/SemaCXX/atomic-type.cpp @@ -83,3 +83,7 @@ namespace copy_init { // allows extraneous braces around initializers. Y y3 = { { X(0) }, { 4 } }; // expected-error 2{{illegal initializer type}} } + +bool PR21836(_Atomic(int) *x) { + return *x; +} diff --git a/test/SemaCXX/attr-cxx0x-fixit.cpp b/test/SemaCXX/attr-cxx0x-fixit.cpp new file mode 100644 index 000000000000..69eb22399607 --- /dev/null +++ b/test/SemaCXX/attr-cxx0x-fixit.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +// RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -std=c++11 %s 2>&1 | FileCheck %s + +[[noreturn()]] void f(); // expected-error {{attribute 'noreturn' cannot have an argument list}} \ +// CHECK: fix-it:"{{.*}}":{4:11-4:13}:"" diff --git a/test/SemaCXX/attr-flag-enum-reject.cpp b/test/SemaCXX/attr-flag-enum-reject.cpp new file mode 100644 index 000000000000..f28d60c0c295 --- /dev/null +++ b/test/SemaCXX/attr-flag-enum-reject.cpp @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -x c++ -Wassign-enum %s + +enum __attribute__((flag_enum)) flag { // expected-warning {{ignored}} +}; diff --git a/test/SemaCXX/attr-gnu.cpp b/test/SemaCXX/attr-gnu.cpp new file mode 100644 index 000000000000..b4e9f4609f67 --- /dev/null +++ b/test/SemaCXX/attr-gnu.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -fms-compatibility -verify %s + +void f() { + // GNU-style attributes are prohibited in this position. + auto P = new int * __attribute__((vector_size(8))); // expected-error {{an attribute list cannot appear here}} \ + // expected-error {{invalid vector element type 'int *'}} + + // Ensure that MS type attribute keywords are still supported in this + // position. + auto P2 = new int * __sptr; // Ok +} + +void g(int a[static [[]] 5]); // expected-error {{static array size is a C99 feature, not permitted in C++}} + +namespace { +class B { +public: + virtual void test() {} + virtual void test2() {} + virtual void test3() {} +}; + +class D : public B { +public: + void test() __attribute__((deprecated)) final {} // expected-warning {{GCC does not allow an attribute in this position on a function declaration}} + void test2() [[]] override {} // Ok + void test3() __attribute__((cf_unknown_transfer)) override {} // Ok, not known to GCC. +}; +} diff --git a/test/SemaCXX/attr-nodebug.cpp b/test/SemaCXX/attr-nodebug.cpp index b441da21f8e7..fd35722f62b1 100644 --- a/test/SemaCXX/attr-nodebug.cpp +++ b/test/SemaCXX/attr-nodebug.cpp @@ -1,7 +1,9 @@ -// RUN: %clang_cc1 %s -verify -fsyntax-only +// RUN: %clang_cc1 %s -std=c++11 -verify -fsyntax-only // Note: most of the 'nodebug' tests are in attr-nodebug.c. // expected-no-diagnostics class c { void t3() __attribute__((nodebug)); }; + +[[gnu::nodebug]] void f() {} diff --git a/test/SemaCXX/attr-nonnull.cpp b/test/SemaCXX/attr-nonnull.cpp index 8af49d9d29e6..8fce99759b6a 100644 --- a/test/SemaCXX/attr-nonnull.cpp +++ b/test/SemaCXX/attr-nonnull.cpp @@ -27,8 +27,8 @@ namespace rdar8769025 { __attribute__((nonnull(2))) void f2(int i, int * const &p); void test_f1() { - f1(0); // expected-warning{{null passed to a callee which requires a non-null argument}} - f2(0, 0); // expected-warning{{null passed to a callee which requires a non-null argument}} + f1(0); // expected-warning{{null passed to a callee that requires a non-null argument}} + f2(0, 0); // expected-warning{{null passed to a callee that requires a non-null argument}} } } diff --git a/test/SemaCXX/attr-optnone.cpp b/test/SemaCXX/attr-optnone.cpp index eaa50004047c..58776caf7ae6 100644 --- a/test/SemaCXX/attr-optnone.cpp +++ b/test/SemaCXX/attr-optnone.cpp @@ -3,11 +3,37 @@ int foo() __attribute__((optnone)); int bar() __attribute__((optnone)) __attribute__((noinline)); -int baz() __attribute__((always_inline)) __attribute__((optnone)); // expected-error{{'always_inline' and 'optnone' attributes are not compatible}} -int quz() __attribute__((optnone)) __attribute__((always_inline)); // expected-error{{'optnone' and 'always_inline' attributes are not compatible}} +int baz() __attribute__((always_inline)) __attribute__((optnone)); // expected-warning{{'always_inline' attribute ignored}} expected-note{{conflicting attribute is here}} +int quz() __attribute__((optnone)) __attribute__((always_inline)); // expected-warning{{'always_inline' attribute ignored}} expected-note{{conflicting attribute is here}} -__forceinline __attribute__((optnone)) int bax(); // expected-error{{'__forceinline' and 'optnone' attributes are not compatible}} -__attribute__((optnone)) __forceinline int qux(); // expected-error{{'optnone' and '__forceinline' attributes are not compatible}} +__attribute__((always_inline)) int baz1(); // expected-warning{{'always_inline' attribute ignored}} +__attribute__((optnone)) int baz1() { return 1; } // expected-note{{conflicting attribute is here}} + +__attribute__((optnone)) int quz1(); // expected-note{{conflicting attribute is here}} +__attribute__((always_inline)) int quz1() { return 1; } // expected-warning{{'always_inline' attribute ignored}} + +int bay() __attribute__((minsize)) __attribute__((optnone)); // expected-warning{{'minsize' attribute ignored}} expected-note{{conflicting}} +int quy() __attribute__((optnone)) __attribute__((minsize)); // expected-warning{{'minsize' attribute ignored}} expected-note{{conflicting}} + +__attribute__((minsize)) int bay1(); // expected-warning{{'minsize' attribute ignored}} +__attribute__((optnone)) int bay1() { return 1; } // expected-note{{conflicting attribute is here}} + +__attribute__((optnone)) int quy1(); // expected-note{{conflicting attribute is here}} +__attribute__((minsize)) int quy1() { return 1; } // expected-warning{{'minsize' attribute ignored}} + +__attribute__((always_inline)) // expected-warning{{'always_inline' attribute ignored}} + __attribute__((minsize)) // expected-warning{{'minsize' attribute ignored}} +void bay2(); +__attribute__((optnone)) // expected-note 2 {{conflicting}} +void bay2() {} + +__forceinline __attribute__((optnone)) int bax(); // expected-warning{{'__forceinline' attribute ignored}} expected-note{{conflicting}} +__attribute__((optnone)) __forceinline int qux(); // expected-warning{{'__forceinline' attribute ignored}} expected-note{{conflicting}} + +__forceinline int bax2(); // expected-warning{{'__forceinline' attribute ignored}} +__attribute__((optnone)) int bax2() { return 1; } // expected-note{{conflicting}} +__attribute__((optnone)) int qux2(); // expected-note{{conflicting}} +__forceinline int qux2() { return 1; } // expected-warning{{'__forceinline' attribute ignored}} int globalVar __attribute__((optnone)); // expected-warning{{'optnone' attribute only applies to functions}} @@ -29,8 +55,8 @@ int foo2(); [[clang::optnone]] int bar2() __attribute__((noinline)); -[[clang::optnone]] -int baz2() __attribute__((always_inline)); // expected-error{{'always_inline' and 'optnone' attributes are not compatible}} +[[clang::optnone]] // expected-note {{conflicting}} +int baz2() __attribute__((always_inline)); // expected-warning{{'always_inline' attribute ignored}} [[clang::optnone]] int globalVar2; //expected-warning{{'optnone' attribute only applies to functions}} diff --git a/test/SemaCXX/attr-print.cpp b/test/SemaCXX/attr-print.cpp index a07eeff5646e..337a6fb69ba3 100644 --- a/test/SemaCXX/attr-print.cpp +++ b/test/SemaCXX/attr-print.cpp @@ -22,3 +22,12 @@ typedef int Small1 __attribute__((mode(byte))); // CHECK: int small __attribute__((mode(byte))); int small __attribute__((mode(byte))); + +// CHECK: int v __attribute__((visibility("hidden"))); +int v __attribute__((visibility("hidden"))); + +// CHECK: class __attribute__((consumable("unknown"))) AttrTester1 +class __attribute__((consumable(unknown))) AttrTester1 { + // CHECK: void callableWhen() __attribute__((callable_when("unconsumed", "consumed"))); + void callableWhen() __attribute__((callable_when("unconsumed", "consumed"))); +}; diff --git a/test/SemaCXX/attributed-auto-deduction.cpp b/test/SemaCXX/attributed-auto-deduction.cpp new file mode 100644 index 000000000000..b0cae187e8e3 --- /dev/null +++ b/test/SemaCXX/attributed-auto-deduction.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -triple armv7 -std=c++14 -x c++ %s -fsyntax-only +// expected-no-diagnostics + +void deduce() { + auto single_int = [](int i) __attribute__ (( pcs("aapcs") )) { + return i; + }; + auto multiple_int = [](int i) __attribute__ (( pcs("aapcs") )) + __attribute__ (( pcs("aapcs") )) { + return i; + }; + + auto single_void = []() __attribute__ (( pcs("aapcs") )) { }; + auto multiple_void = []() __attribute__ (( pcs("aapcs") )) + __attribute__ (( pcs("aapcs") )) { }; +} + +auto ( __attribute__ (( pcs("aapcs") )) single_attribute() ) { } +auto ( ( __attribute__ (( pcs("aapcs") )) ( ( __attribute__ (( pcs("aapcs") )) multiple_attributes() ) ) ) ) { } + diff --git a/test/SemaCXX/bitfield.cpp b/test/SemaCXX/bitfield.cpp new file mode 100644 index 000000000000..083c28ffbb3d --- /dev/null +++ b/test/SemaCXX/bitfield.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 %s -verify + +// expected-no-diagnostics + +namespace PromotionVersusMutation { + typedef unsigned Unsigned; + typedef signed Signed; + + struct T { unsigned n : 2; } t; + + typedef __typeof__(t.n) Unsigned; // Bitfield is unsigned + typedef __typeof__(+t.n) Signed; // ... but promotes to signed. + + typedef __typeof__(t.n + 0) Signed; // Arithmetic promotes. + + typedef __typeof__(t.n = 0) Unsigned; // Assignment produces an lvalue... + typedef __typeof__(t.n += 0) Unsigned; + typedef __typeof__(t.n *= 0) Unsigned; + typedef __typeof__(+(t.n = 0)) Signed; // ... which is a bit-field. + typedef __typeof__(+(t.n += 0)) Signed; + typedef __typeof__(+(t.n *= 0)) Signed; + + typedef __typeof__(++t.n) Unsigned; // Increment is equivalent to compound-assignment. + typedef __typeof__(--t.n) Unsigned; + typedef __typeof__(+(++t.n)) Signed; + typedef __typeof__(+(--t.n)) Signed; + + typedef __typeof__(t.n++) Unsigned; // Post-increment's result has the type + typedef __typeof__(t.n--) Unsigned; // of the operand... + typedef __typeof__(+(t.n++)) Unsigned; // ... and is not a bit-field (because + typedef __typeof__(+(t.n--)) Unsigned; // it's not a glvalue). +} diff --git a/test/SemaCXX/blocks.cpp b/test/SemaCXX/blocks.cpp index a2672d13b72d..0521802172f9 100644 --- a/test/SemaCXX/blocks.cpp +++ b/test/SemaCXX/blocks.cpp @@ -100,3 +100,48 @@ namespace test5 { }); } } + + +// rdar://16356628 +// +// Ensure that we can end function bodies while parsing an +// expression that requires an explicitly-tracked cleanup object +// (i.e. a block literal). + +// The nested function body in this test case is a template +// instantiation. The template function has to be constexpr because +// we'll otherwise delay its instantiation to the end of the +// translation unit. +namespace test6a { + template <class T> constexpr int func() { return 0; } + void run(void (^)(), int); + + void test() { + int aCapturedVar = 0; + run(^{ (void) aCapturedVar; }, func<int>()); + } +} + +// The nested function body in this test case is a method of a local +// class. +namespace test6b { + void run(void (^)(), void (^)()); + void test() { + int aCapturedVar = 0; + run(^{ (void) aCapturedVar; }, + ^{ struct A { static void foo() {} }; + A::foo(); }); + } +} + +// The nested function body in this test case is a lambda invocation +// function. +namespace test6c { + void run(void (^)(), void (^)()); + void test() { + int aCapturedVar = 0; + run(^{ (void) aCapturedVar; }, + ^{ struct A { static void foo() {} }; + A::foo(); }); + } +} diff --git a/test/SemaCXX/builtin-assume-aligned-tmpl.cpp b/test/SemaCXX/builtin-assume-aligned-tmpl.cpp new file mode 100644 index 000000000000..0909070c5e11 --- /dev/null +++ b/test/SemaCXX/builtin-assume-aligned-tmpl.cpp @@ -0,0 +1,87 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<int z> +int test9(int *a) { + a = (int *) __builtin_assume_aligned(a, z + 1); // expected-error {{requested alignment is not a power of 2}} + return a[0]; +} + +void test9i(int *a) { + test9<42>(a); // expected-note {{in instantiation of function template specialization 'test9<42>' requested here}} +} + +template<typename T> +int test10(int *a, T z) { + a = (int *) __builtin_assume_aligned(a, z + 1); // expected-error {{must be a constant integer}} + return a[0]; +} + +int test10i(int *a) { + return test10(a, 42); // expected-note {{in instantiation of function template specialization 'test10<int>' requested here}} +} + +template <int q> +void *atest() __attribute__((assume_aligned(q))); // expected-error {{requested alignment is not a power of 2}} + +template <int q, int o> +void *atest2() __attribute__((assume_aligned(q, o))); // expected-error {{requested alignment is not a power of 2}} + +void test20() { + atest<31>(); // expected-note {{in instantiation of function template specialization 'atest<31>' requested here}} + atest<32>(); + + atest2<31, 5>(); // expected-note {{in instantiation of function template specialization 'atest2<31, 5>' requested here}} + atest2<32, 4>(); +} + +// expected-error@+1 {{invalid application of 'sizeof' to a function type}} +template<typename T> __attribute__((assume_aligned(sizeof(int(T()))))) T *f(); +void test21() { + void *p = f<void>(); // expected-note {{in instantiation of function template specialization 'f<void>' requested here}} +} + +// expected-error@+1 {{functional-style cast from 'void' to 'int' is not allowed}} +template<typename T> __attribute__((assume_aligned(sizeof((int(T())))))) T *g(); +void test23() { + void *p = g<void>(); // expected-note {{in instantiation of function template specialization 'g<void>' requested here}} +} + +template <typename T, int o> +T *atest3() __attribute__((assume_aligned(31, o))); // expected-error {{requested alignment is not a power of 2}} + +template <typename T, int o> +T *atest4() __attribute__((assume_aligned(32, o))); + +void test22() { + atest3<int, 5>(); + atest4<int, 5>(); +} + +// expected-warning@+1 {{'assume_aligned' attribute only applies to functions and methods}} +class __attribute__((assume_aligned(32))) x { + int y; +}; + +// expected-warning@+1 {{'assume_aligned' attribute only applies to return values that are pointers or references}} +x foo() __attribute__((assume_aligned(32))); + +struct s1 { + static const int x = 32; +}; + +struct s2 { + static const int x = 64; +}; + +struct s3 { + static const int x = 63; +}; + +template <typename X> +void *atest5() __attribute__((assume_aligned(X::x))); // expected-error {{requested alignment is not a power of 2}} +void test24() { + atest5<s1>(); + atest5<s2>(); + atest5<s3>(); // expected-note {{in instantiation of function template specialization 'atest5<s3>' requested here}} +} + diff --git a/test/SemaCXX/builtin-assume-aligned.cpp b/test/SemaCXX/builtin-assume-aligned.cpp new file mode 100644 index 000000000000..48bd8414fc50 --- /dev/null +++ b/test/SemaCXX/builtin-assume-aligned.cpp @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -triple x86_64-linux-gnu %s + +int n; +constexpr int *p = 0; +// expected-error@+1 {{must be initialized by a constant expression}} +constexpr int *k = (int *) __builtin_assume_aligned(p, 16, n = 5); + +constexpr void *l = __builtin_assume_aligned(p, 16); + +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{cast from 'void *' is not allowed in a constant expression}} +constexpr int *c = (int *) __builtin_assume_aligned(p, 16); + +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{alignment of the base pointee object (4 bytes) is less than the asserted 16 bytes}} +constexpr void *m = __builtin_assume_aligned(&n, 16); + +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{offset of the aligned pointer from the base pointee object (-2 bytes) is not a multiple of the asserted 4 bytes}} +constexpr void *q1 = __builtin_assume_aligned(&n, 4, 2); +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{offset of the aligned pointer from the base pointee object (2 bytes) is not a multiple of the asserted 4 bytes}} +constexpr void *q2 = __builtin_assume_aligned(&n, 4, -2); +constexpr void *q3 = __builtin_assume_aligned(&n, 4, 4); +constexpr void *q4 = __builtin_assume_aligned(&n, 4, -4); + +static char ar1[6]; +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{alignment of the base pointee object (1 byte) is less than the asserted 16 bytes}} +constexpr void *r1 = __builtin_assume_aligned(&ar1[2], 16); + +static char ar2[6] __attribute__((aligned(32))); +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{offset of the aligned pointer from the base pointee object (2 bytes) is not a multiple of the asserted 16 bytes}} +constexpr void *r2 = __builtin_assume_aligned(&ar2[2], 16); +constexpr void *r3 = __builtin_assume_aligned(&ar2[2], 16, 2); +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{offset of the aligned pointer from the base pointee object (1 byte) is not a multiple of the asserted 16 bytes}} +constexpr void *r4 = __builtin_assume_aligned(&ar2[2], 16, 1); + +constexpr int* x = __builtin_constant_p((int*)0xFF) ? (int*)0xFF : (int*)0xFF; +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{value of the aligned pointer (255) is not a multiple of the asserted 32 bytes}} +constexpr void *s1 = __builtin_assume_aligned(x, 32); +// expected-error@+2 {{must be initialized by a constant expression}} +// expected-note@+1 {{value of the aligned pointer (250) is not a multiple of the asserted 32 bytes}} +constexpr void *s2 = __builtin_assume_aligned(x, 32, 5); +constexpr void *s3 = __builtin_assume_aligned(x, 32, -1); + diff --git a/test/SemaCXX/call-with-static-chain.cpp b/test/SemaCXX/call-with-static-chain.cpp new file mode 100644 index 000000000000..45fe2ac29472 --- /dev/null +++ b/test/SemaCXX/call-with-static-chain.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int &f(); + +struct A { + void f(); +}; + +typedef int I; + +void g() { + __builtin_call_with_static_chain(f(), f) = 42; + __builtin_call_with_static_chain(A().f(), f); // expected-error {{first argument to __builtin_call_with_static_chain must be a non-member call expression}} + __builtin_call_with_static_chain((42).~I(), f); // expected-error {{first argument to __builtin_call_with_static_chain must not be a pseudo-destructor call}} +} diff --git a/test/SemaCXX/complex-folding.cpp b/test/SemaCXX/complex-folding.cpp new file mode 100644 index 000000000000..1c2f9c73eb31 --- /dev/null +++ b/test/SemaCXX/complex-folding.cpp @@ -0,0 +1,90 @@ +// RUN: %clang_cc1 %s -std=c++1z -fsyntax-only -verify +// +// Test the constant folding of builtin complex numbers. + +static_assert((0.0 + 0.0j) == (0.0 + 0.0j)); +static_assert((0.0 + 0.0j) != (0.0 + 0.0j)); // expected-error {{static_assert}} + +static_assert((0.0 + 0.0j) == 0.0); +static_assert(0.0 == (0.0 + 0.0j)); +static_assert(0.0 == 0.0j); +static_assert((0.0 + 1.0j) != 0.0); +static_assert(1.0 != (0.0 + 0.0j)); +static_assert(0.0 != 1.0j); + +// Walk around the complex plane stepping between angular differences and +// equality. +static_assert((1.0 + 0.0j) == (0.0 + 0.0j)); // expected-error {{static_assert}} +static_assert((1.0 + 0.0j) == (1.0 + 0.0j)); +static_assert((1.0 + 1.0j) == (1.0 + 0.0j)); // expected-error {{static_assert}} +static_assert((1.0 + 1.0j) == (1.0 + 1.0j)); +static_assert((0.0 + 1.0j) == (1.0 + 1.0j)); // expected-error {{static_assert}} +static_assert((0.0 + 1.0j) == (0.0 + 1.0j)); +static_assert((-1.0 + 1.0j) == (0.0 + 1.0j)); // expected-error {{static_assert}} +static_assert((-1.0 + 1.0j) == (-1.0 + 1.0j)); +static_assert((-1.0 + 0.0j) == (-1.0 + 1.0j)); // expected-error {{static_assert}} +static_assert((-1.0 + 0.0j) == (-1.0 + 0.0j)); +static_assert((-1.0 - 1.0j) == (-1.0 + 0.0j)); // expected-error {{static_assert}} +static_assert((-1.0 - 1.0j) == (-1.0 - 1.0j)); +static_assert((0.0 - 1.0j) == (-1.0 - 1.0j)); // expected-error {{static_assert}} +static_assert((0.0 - 1.0j) == (0.0 - 1.0j)); +static_assert((1.0 - 1.0j) == (0.0 - 1.0j)); // expected-error {{static_assert}} +static_assert((1.0 - 1.0j) == (1.0 - 1.0j)); + +// Test basic mathematical folding of both complex and real operands. +static_assert(((1.0 + 0.5j) + (0.25 - 0.75j)) == (1.25 - 0.25j)); +static_assert(((1.0 + 0.5j) + 0.25) == (1.25 + 0.5j)); +static_assert((1.0 + (0.25 - 0.75j)) == (1.25 - 0.75j)); + +static_assert(((1.0 + 0.5j) - (0.25 - 0.75j)) == (0.75 + 1.25j)); +static_assert(((1.0 + 0.5j) - 0.25) == (0.75 + 0.5j)); +static_assert((1.0 - (0.25 - 0.75j)) == (0.75 + 0.75j)); + +static_assert(((1.25 + 0.5j) * (0.25 - 0.75j)) == (0.6875 - 0.8125j)); +static_assert(((1.25 + 0.5j) * 0.25) == (0.3125 + 0.125j)); +static_assert((1.25 * (0.25 - 0.75j)) == (0.3125 - 0.9375j)); + +static_assert(((1.25 + 0.5j) / (0.25 - 0.75j)) == (-0.1 + 1.7j)); +static_assert(((1.25 + 0.5j) / 0.25) == (5.0 + 2.0j)); +static_assert((1.25 / (0.25 - 0.75j)) == (0.5 + 1.5j)); + +// Test that infinities are preserved, don't turn into NaNs, and do form zeros +// when the divisor. +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * 1.0)) == 1); +static_assert(__builtin_isinf_sign(__imag__((1.0 + __builtin_inf() * 1.0j) * 1.0)) == 1); +static_assert(__builtin_isinf_sign(__real__(1.0 * (__builtin_inf() + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__imag__(1.0 * (1.0 + __builtin_inf() * 1.0j))) == 1); + +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * (1.0 + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) * (__builtin_inf() + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) * (__builtin_inf() + 1.0j))) == 1); + +static_assert(__builtin_isinf_sign(__real__((1.0 + __builtin_inf() * 1.0j) * (1.0 + 1.0j))) == -1); +static_assert(__builtin_isinf_sign(__imag__((1.0 + __builtin_inf() * 1.0j) * (1.0 + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) * (1.0 + __builtin_inf() * 1.0j))) == -1); +static_assert(__builtin_isinf_sign(__imag__((1.0 + 1.0j) * (1.0 + __builtin_inf() * 1.0j))) == 1); + +static_assert(__builtin_isinf_sign(__real__((1.0 + __builtin_inf() * 1.0j) * (1.0 + __builtin_inf() * 1.0j))) == -1); +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + __builtin_inf() * 1.0j) * (__builtin_inf() + __builtin_inf() * 1.0j))) == -1); + +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) / (1.0 + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__imag__(1.0 + (__builtin_inf() * 1.0j) / (1.0 + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__imag__((__builtin_inf() + __builtin_inf() * 1.0j) / (1.0 + 1.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) / 1.0)) == 1); +static_assert(__builtin_isinf_sign(__imag__(1.0 + (__builtin_inf() * 1.0j) / 1.0)) == 1); +static_assert(__builtin_isinf_sign(__imag__((__builtin_inf() + __builtin_inf() * 1.0j) / 1.0)) == 1); + +static_assert(((1.0 + 1.0j) / (__builtin_inf() + 1.0j)) == (0.0 + 0.0j)); +static_assert(((1.0 + 1.0j) / (1.0 + __builtin_inf() * 1.0j)) == (0.0 + 0.0j)); +static_assert(((1.0 + 1.0j) / (__builtin_inf() + __builtin_inf() * 1.0j)) == (0.0 + 0.0j)); +static_assert(((1.0 + 1.0j) / __builtin_inf()) == (0.0 + 0.0j)); + +static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) / (0.0 + 0.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((1.0 + 1.0j) / 0.0)) == 1); + +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) / (0.0 + 0.0j))) == 1); +static_assert(__builtin_isinf_sign(__imag__((1.0 + __builtin_inf() * 1.0j) / (0.0 + 0.0j))) == 1); +static_assert(__builtin_isinf_sign(__imag__((__builtin_inf() + __builtin_inf() * 1.0j) / (0.0 + 0.0j))) == 1); +static_assert(__builtin_isinf_sign(__real__((__builtin_inf() + 1.0j) / 0.0)) == 1); +static_assert(__builtin_isinf_sign(__imag__((1.0 + __builtin_inf() * 1.0j) / 0.0)) == 1); +static_assert(__builtin_isinf_sign(__imag__((__builtin_inf() + __builtin_inf() * 1.0j) / 0.0)) == 1); diff --git a/test/SemaCXX/const-cast.cpp b/test/SemaCXX/const-cast.cpp index cb9937c50d50..330e18661b19 100644 --- a/test/SemaCXX/const-cast.cpp +++ b/test/SemaCXX/const-cast.cpp @@ -64,3 +64,6 @@ short *bad_const_cast_test(char const *volatile *const volatile *var) (void)const_cast<int&&>(0); // expected-error {{const_cast from rvalue to reference type 'int &&'}} expected-warning {{C++11}} return **var3; } + +template <typename T> +char *PR21845() { return const_cast<char *>((void)T::x); } // expected-error {{const_cast from 'void' to 'char *' is not allowed}} diff --git a/test/SemaCXX/constant-expression-cxx11.cpp b/test/SemaCXX/constant-expression-cxx11.cpp index 09d93fa73af1..14c0ae320d77 100644 --- a/test/SemaCXX/constant-expression-cxx11.cpp +++ b/test/SemaCXX/constant-expression-cxx11.cpp @@ -95,11 +95,13 @@ namespace TemplateArgumentConversion { } namespace CaseStatements { + int x; void f(int n) { switch (n) { case MemberZero().zero: // expected-error {{did you mean to call it with no arguments?}} expected-note {{previous}} case id(0): // expected-error {{duplicate case value '0'}} return; + case __builtin_constant_p(true) ? (__SIZE_TYPE__)&x : 0:; // expected-error {{constant}} } } } @@ -602,7 +604,7 @@ struct A { constexpr A(int a, int b) : k(a + b) {} int k; }; constexpr int fn(const A &a) { return a.k; } static_assert(fn(A(4,5)) == 9, ""); -struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}} +struct B { int n; int m; } constexpr b = { 0, b.n }; struct C { constexpr C(C *this_) : m(42), n(this_->m) {} // ok int m, n; @@ -1177,7 +1179,7 @@ namespace ExternConstexpr { void f() { extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}} constexpr int j = 0; - constexpr int k; // expected-error {{default initialization of an object of const type}} + constexpr int k; // expected-error {{default initialization of an object of const type}} expected-note{{add an explicit initializer to initialize 'k'}} } } @@ -1326,6 +1328,49 @@ namespace MutableMembers { struct C { B b; }; constexpr C c[3] = {}; constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}} + + struct D { int x; mutable int y; }; // expected-note {{here}} + constexpr D d1 = { 1, 2 }; + int l = ++d1.y; + constexpr D d2 = d1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}} + + struct E { + union { + int a; + mutable int b; // expected-note {{here}} + }; + }; + constexpr E e1 = {{1}}; + constexpr E e2 = e1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}} + + struct F { + union U { }; + mutable U u; + struct X { }; + mutable X x; + struct Y : X { X x; U u; }; + mutable Y y; + int n; + }; + // This is OK; we don't actually read any mutable state here. + constexpr F f1 = {}; + constexpr F f2 = f1; + + struct G { + struct X {}; + union U { X a; }; + mutable U u; // expected-note {{here}} + }; + constexpr G g1 = {}; + constexpr G g2 = g1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}} + constexpr G::U gu1 = {}; + constexpr G::U gu2 = gu1; + + union H { + mutable G::X gx; // expected-note {{here}} + }; + constexpr H h1 = {}; + constexpr H h2 = h1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}} } namespace Fold { @@ -1443,7 +1488,7 @@ namespace InvalidClasses { namespace NamespaceAlias { constexpr int f() { - namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++1y extension}} + namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++14 extension}} return &NS::f != nullptr; } } @@ -1568,7 +1613,8 @@ namespace TypeId { A &g(); constexpr auto &x = typeid(f()); constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \ - // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}} + // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}} \ + // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} } namespace PR14203 { @@ -1667,6 +1713,9 @@ namespace InitializerList { return sum(ints.begin(), ints.end()); } static_assert(sum({1, 2, 3, 4, 5}) == 15, ""); + + static_assert(*std::initializer_list<int>{1, 2, 3}.begin() == 1, ""); + static_assert(std::initializer_list<int>{1, 2, 3}.begin()[2] == 3, ""); } namespace StmtExpr { @@ -1700,7 +1749,7 @@ namespace VirtualFromBase { template <typename T> struct X : T { constexpr X() {} double d = 0.0; - constexpr int f() { return sizeof(T); } // expected-warning {{will not be implicitly 'const' in C++1y}} + constexpr int f() { return sizeof(T); } // expected-warning {{will not be implicitly 'const' in C++14}} }; // Virtual f(), not OK. @@ -1715,17 +1764,17 @@ namespace VirtualFromBase { } namespace ConstexprConstructorRecovery { - class X { - public: - enum E : short { - headers = 0x1, - middlefile = 0x2, - choices = 0x4 - }; - constexpr X() noexcept {}; - protected: + class X { + public: + enum E : short { + headers = 0x1, + middlefile = 0x2, + choices = 0x4 + }; + constexpr X() noexcept {}; + protected: E val{0}; // expected-error {{cannot initialize a member subobject of type 'ConstexprConstructorRecovery::X::E' with an rvalue of type 'int'}} - }; + }; constexpr X x{}; } @@ -1799,8 +1848,9 @@ namespace ZeroSizeTypes { namespace BadDefaultInit { template<int N> struct X { static const int n = N; }; - struct A { // expected-note {{subexpression}} - int k = X<A().k>::n; // expected-error {{defaulted default constructor of 'A' cannot be used}} expected-error {{not a constant expression}} expected-note {{in call to 'A()'}} + struct A { + int k = // expected-error {{cannot use defaulted default constructor of 'A' within the class outside of member functions because 'k' has an initializer}} + X<A().k>::n; // expected-error {{not a constant expression}} expected-note {{implicit default constructor for 'BadDefaultInit::A' first required here}} }; // FIXME: The "constexpr constructor must initialize all members" diagnostic @@ -1892,3 +1942,45 @@ namespace PR19010 { }; void test() { constexpr Test t; } } + +void PR21327(int a, int b) { + static_assert(&a + 1 != &b, ""); // expected-error {{constant expression}} +} + +namespace EmptyClass { + struct E1 {} e1; + union E2 {} e2; // expected-note {{here}} + struct E3 : E1 {} e3; + + // The defaulted copy constructor for an empty class does not read any + // members. The defaulted copy constructor for an empty union reads the + // object representation. + constexpr E1 e1b(e1); + constexpr E2 e2b(e2); // expected-error {{constant expression}} expected-note{{read of non-const}} expected-note {{in call}} + constexpr E3 e3b(e3); +} + +namespace PR21786 { + extern void (*start[])(); + extern void (*end[])(); + static_assert(&start != &end, ""); // expected-error {{constant expression}} + static_assert(&start != nullptr, ""); + + struct Foo; + struct Bar { + static const Foo x; + static const Foo y; + }; + static_assert(&Bar::x != nullptr, ""); + static_assert(&Bar::x != &Bar::y, ""); +} + +namespace PR21859 { + constexpr int Fun() { return; } // expected-error {{non-void constexpr function 'Fun' should return a value}} + constexpr int Var = Fun(); // expected-error {{constexpr variable 'Var' must be initialized by a constant expression}} +} + +struct InvalidRedef { + int f; // expected-note{{previous definition is here}} + constexpr int f(void); // expected-error{{redefinition of 'f'}} expected-warning{{will not be implicitly 'const'}} +}; diff --git a/test/SemaCXX/constant-expression-cxx1y.cpp b/test/SemaCXX/constant-expression-cxx1y.cpp index 521526ddba44..e8925f3f84aa 100644 --- a/test/SemaCXX/constant-expression-cxx1y.cpp +++ b/test/SemaCXX/constant-expression-cxx1y.cpp @@ -719,8 +719,7 @@ namespace deduced_return_type { namespace modify_temporary_during_construction { struct A { int &&temporary; int x; int y; }; constexpr int f(int &r) { r *= 9; return r - 12; } - // FIXME: The 'uninitialized' warning here is bogus. - constexpr A a = { 6, f(a.temporary), a.temporary }; // expected-warning {{uninitialized}} expected-note {{temporary created here}} + constexpr A a = { 6, f(a.temporary), a.temporary }; // expected-note {{temporary created here}} static_assert(a.x == 42, ""); static_assert(a.y == 54, ""); constexpr int k = a.temporary++; // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}} @@ -911,3 +910,31 @@ namespace PR17331 { constexpr int ARR[] = { 1, 2, 3, 4, 5 }; static_assert(sum(ARR) == 15, ""); } + +namespace EmptyClass { + struct E1 {} e1; + union E2 {} e2; // expected-note 4{{here}} + struct E3 : E1 {} e3; + + template<typename E> + constexpr int f(E &a, int kind) { + switch (kind) { + case 0: { E e(a); return 0; } // expected-note {{read}} expected-note {{in call}} + case 1: { E e(static_cast<E&&>(a)); return 0; } // expected-note {{read}} expected-note {{in call}} + case 2: { E e; e = a; return 0; } // expected-note {{read}} expected-note {{in call}} + case 3: { E e; e = static_cast<E&&>(a); return 0; } // expected-note {{read}} expected-note {{in call}} + } + } + constexpr int test1 = f(e1, 0); + constexpr int test2 = f(e2, 0); // expected-error {{constant expression}} expected-note {{in call}} + constexpr int test3 = f(e3, 0); + constexpr int test4 = f(e1, 1); + constexpr int test5 = f(e2, 1); // expected-error {{constant expression}} expected-note {{in call}} + constexpr int test6 = f(e3, 1); + constexpr int test7 = f(e1, 2); + constexpr int test8 = f(e2, 2); // expected-error {{constant expression}} expected-note {{in call}} + constexpr int test9 = f(e3, 2); + constexpr int testa = f(e1, 3); + constexpr int testb = f(e2, 3); // expected-error {{constant expression}} expected-note {{in call}} + constexpr int testc = f(e3, 3); +} diff --git a/test/SemaCXX/constexpr-value-init.cpp b/test/SemaCXX/constexpr-value-init.cpp index 9ad11290190f..3657c18ddbac 100644 --- a/test/SemaCXX/constexpr-value-init.cpp +++ b/test/SemaCXX/constexpr-value-init.cpp @@ -14,7 +14,7 @@ void f() { constexpr A a; // expected-error {{constant expression}} expected-note {{in call to 'A()'}} } -constexpr B b1; // expected-error {{requires a user-provided default constructor}} +constexpr B b1; // expected-error {{without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'b1'}} constexpr B b2 = B(); // ok static_assert(b2.a.a == 1, ""); static_assert(b2.a.b == 2, ""); @@ -23,9 +23,9 @@ struct C { int c; }; struct D : C { int d; }; -constexpr C c1; // expected-error {{requires a user-provided default constructor}} +constexpr C c1; // expected-error {{without a user-provided default constructor}} expected-note{{add an explicit initializer to initialize 'c1'}} constexpr C c2 = C(); // ok -constexpr D d1; // expected-error {{requires a user-provided default constructor}} +constexpr D d1; // expected-error {{without a user-provided default constructor}} expected-note{{add an explicit initializer to initialize 'd1'}} constexpr D d2 = D(); // ok with DR1452 static_assert(D().c == 0, ""); static_assert(D().d == 0, ""); diff --git a/test/SemaCXX/conversion-function.cpp b/test/SemaCXX/conversion-function.cpp index 40ac33b8eb0d..077e4d9f3cce 100644 --- a/test/SemaCXX/conversion-function.cpp +++ b/test/SemaCXX/conversion-function.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -Wbind-to-temporary-copy -verify %s class X { public: operator bool(); @@ -172,12 +172,10 @@ namespace source_locations { namespace crazy_declarators { struct A { - (&operator bool())(); // expected-error {{must use a typedef to declare a conversion to 'bool (&)()'}} - - // FIXME: This diagnostic is misleading (the correct spelling - // would be 'operator int*'), but it's a corner case of a - // rarely-used syntax extension. - *operator int(); // expected-error {{must use a typedef to declare a conversion to 'int *'}} + (&operator bool())(); // expected-error {{use a typedef to declare a conversion to 'bool (&)()'}} + *operator int(); // expected-error {{put the complete type after 'operator'}} + // No suggestion of using a typedef here; that's not possible. + template<typename T> (&operator T())(); // expected-error-re {{cannot specify any part of a return type in the declaration of a conversion function{{$}}}} }; } diff --git a/test/SemaCXX/conversion.cpp b/test/SemaCXX/conversion.cpp index 852bbba7efa1..b8f0e076a2bc 100644 --- a/test/SemaCXX/conversion.cpp +++ b/test/SemaCXX/conversion.cpp @@ -90,6 +90,18 @@ void test3() { ; do ; while(NULL_COND(true)); + +#define NULL_WRAPPER NULL_COND(false) + if (NULL_WRAPPER) + ; + while (NULL_WRAPPER) + ; + for (; NULL_WRAPPER;) + ; + do + ; + while (NULL_WRAPPER); + int *ip = NULL; int (*fp)() = NULL; struct foo { @@ -137,3 +149,11 @@ namespace test6 { return NULL; } } + +namespace test7 { + bool fun() { + bool x = nullptr; // expected-warning {{implicit conversion of nullptr constant to 'bool'}} + if (nullptr) {} // expected-warning {{implicit conversion of nullptr constant to 'bool'}} + return nullptr; // expected-warning {{implicit conversion of nullptr constant to 'bool'}} + } +} diff --git a/test/SemaCXX/crashes.cpp b/test/SemaCXX/crashes.cpp index 1570d12eeb2f..6ae476f7080c 100644 --- a/test/SemaCXX/crashes.cpp +++ b/test/SemaCXX/crashes.cpp @@ -231,3 +231,9 @@ namespace pr16989 { }; void C2::f() {} } + +namespace pr20660 { + appendList(int[]...); // expected-error {{C++ requires a type specifier for all declarations}} + appendList(int[]...) { } // expected-error {{C++ requires a type specifier for all declarations}} +} + diff --git a/test/SemaCXX/cxx-deprecated.cpp b/test/SemaCXX/cxx-deprecated.cpp new file mode 100644 index 000000000000..47accd4ae1d5 --- /dev/null +++ b/test/SemaCXX/cxx-deprecated.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s + +namespace [[deprecated]] {} // expected-warning {{'deprecated' attribute on anonymous namespace ignored}} + +namespace [[deprecated]] N { // expected-note 4{{'N' has been explicitly marked deprecated here}} + int X; + int Y = X; // Ok + int f(); +} + +int N::f() { // Ok + return Y; // Ok +} + +void f() { + int Y = N::f(); // expected-warning {{'N' is deprecated}} + using N::X; // expected-warning {{'N' is deprecated}} + int Z = X; //Ok +} + +void g() { + using namespace N; // expected-warning {{'N' is deprecated}} + int Z = Y; // Ok +} + +namespace M = N; // expected-warning {{'N' is deprecated}} diff --git a/test/SemaCXX/cxx0x-compat.cpp b/test/SemaCXX/cxx0x-compat.cpp index a58a7f875cdb..bcf0cf11dc18 100644 --- a/test/SemaCXX/cxx0x-compat.cpp +++ b/test/SemaCXX/cxx0x-compat.cpp @@ -41,9 +41,15 @@ void h(size_t foo, size_t bar) { #define _x + 1 char c = 'x'_x; // expected-warning {{will be treated as a user-defined literal suffix}} +template<int ...N> int f() { // expected-warning {{C++11 extension}} + return (N + ...); // expected-warning {{C++1z extension}} +} + #else -auto init_capture = [a(0)] {}; // expected-warning {{initialized lambda captures are incompatible with C++ standards before C++1y}} +auto init_capture = [a(0)] {}; // expected-warning {{initialized lambda captures are incompatible with C++ standards before C++14}} static_assert(true); // expected-warning {{incompatible with C++ standards before C++1z}} +template<int ...N> int f() { return (N + ...); } // expected-warning {{incompatible with C++ standards before C++1z}} + #endif diff --git a/test/SemaCXX/cxx0x-cursory-default-delete.cpp b/test/SemaCXX/cxx0x-cursory-default-delete.cpp index 07a784226640..375cf4a1ac5c 100644 --- a/test/SemaCXX/cxx0x-cursory-default-delete.cpp +++ b/test/SemaCXX/cxx0x-cursory-default-delete.cpp @@ -25,7 +25,7 @@ void fn1 () { non_const_copy ncc2 = ncc; ncc = ncc2; const non_const_copy cncc{}; - const non_const_copy cncc1; // expected-error {{default initialization of an object of const type 'const non_const_copy' requires a user-provided default constructor}} + const non_const_copy cncc1; // expected-error {{default initialization of an object of const type 'const non_const_copy' without a user-provided default constructor}} expected-note {{add an explicit initializer to initialize 'cncc1'}} non_const_copy ncc3 = cncc; // expected-error {{no matching}} ncc = cncc; // expected-error {{no viable overloaded}} }; diff --git a/test/SemaCXX/cxx0x-initializer-references.cpp b/test/SemaCXX/cxx0x-initializer-references.cpp index 9096c8a1c2d5..d1a9ed30076f 100644 --- a/test/SemaCXX/cxx0x-initializer-references.cpp +++ b/test/SemaCXX/cxx0x-initializer-references.cpp @@ -118,3 +118,9 @@ namespace inner_init { F f2 { { 0 } }; // expected-error {{chosen constructor is explicit}} F f3 { { { 0 } } }; // expected-error {{chosen constructor is explicit}} } + +namespace PR20844 { + struct A {}; + struct B { operator A&(); } b; + A &a{b}; // expected-error {{excess elements}} expected-note {{in initialization of temporary of type 'PR20844::A'}} +} diff --git a/test/SemaCXX/cxx11-ast-print.cpp b/test/SemaCXX/cxx11-ast-print.cpp index f7bfc1123a7f..5604374c5610 100644 --- a/test/SemaCXX/cxx11-ast-print.cpp +++ b/test/SemaCXX/cxx11-ast-print.cpp @@ -15,7 +15,7 @@ decltype(4.5_baz) operator"" _baz(char); // CHECK: const char *operator "" _quux(const char *); const char *operator"" _quux(const char *); -// CHECK: template <char...> const char *operator "" _fritz(); +// CHECK: template <char ...> const char *operator "" _fritz(); template<char...> const char *operator"" _fritz(); // CHECK: const char *p1 = "bar1"_foo; diff --git a/test/SemaCXX/cxx11-thread-unsupported.cpp b/test/SemaCXX/cxx11-thread-unsupported.cpp new file mode 100644 index 000000000000..d3fcf82ef415 --- /dev/null +++ b/test/SemaCXX/cxx11-thread-unsupported.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -std=c++11 -triple=x86_64-apple-macosx10.6 -verify %s + +void f() { + thread_local int x; // expected-error {{thread-local storage is not supported for the current target}} +} diff --git a/test/SemaCXX/cxx1y-constexpr-not-const.cpp b/test/SemaCXX/cxx1y-constexpr-not-const.cpp index 3f100b8b691e..071b39c7fb39 100644 --- a/test/SemaCXX/cxx1y-constexpr-not-const.cpp +++ b/test/SemaCXX/cxx1y-constexpr-not-const.cpp @@ -14,5 +14,5 @@ struct X { // expected-error@6 {{non-constexpr declaration of 'f' follows constexpr declaration}} // expected-note@5 {{previous}} #else -// expected-warning@5 {{'constexpr' non-static member function will not be implicitly 'const' in C++1y; add 'const' to avoid a change in behavior}} +// expected-warning@5 {{'constexpr' non-static member function will not be implicitly 'const' in C++14; add 'const' to avoid a change in behavior}} #endif diff --git a/test/SemaCXX/cxx1y-deduced-return-type.cpp b/test/SemaCXX/cxx1y-deduced-return-type.cpp index 60864165954a..50e0cf79c57b 100644 --- a/test/SemaCXX/cxx1y-deduced-return-type.cpp +++ b/test/SemaCXX/cxx1y-deduced-return-type.cpp @@ -483,3 +483,16 @@ namespace OverloadedOperators { int g = a - a; } } + +namespace TrailingReturnTypeForConversionOperator { + struct X { + operator auto() -> int { return 0; } // expected-error {{cannot specify any part of a return type in the declaration of a conversion function; put the complete type after 'operator'}} + } x; + int k = x.operator auto(); + + struct Y { + operator auto() -> int & { // expected-error {{cannot specify}} + return 0; // expected-error {{cannot bind to}} + } + }; +}; diff --git a/test/SemaCXX/cxx1y-generic-lambdas.cpp b/test/SemaCXX/cxx1y-generic-lambdas.cpp index dc8574825dd9..90ecf6904e54 100644 --- a/test/SemaCXX/cxx1y-generic-lambdas.cpp +++ b/test/SemaCXX/cxx1y-generic-lambdas.cpp @@ -859,11 +859,13 @@ namespace ns1 { struct X1 { struct X2 { enum { E = [](auto i) { return i; }(3) }; //expected-error{{inside of a constant expression}}\ - //expected-error{{not an integral constant}} + //expected-error{{not an integral constant}}\ + //expected-note{{non-literal type}} int L = ([] (int i) { return i; })(2); void foo(int i = ([] (int i) { return i; })(2)) { } int B : ([](int i) { return i; })(3); //expected-error{{inside of a constant expression}}\ - //expected-error{{not an integral constant}} + //expected-error{{not an integral constant}}\ + //expected-note{{non-literal type}} int arr[([](int i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\ //expected-error{{must have a constant size}} int (*fp)(int) = [](int i) { return i; }; @@ -871,9 +873,10 @@ struct X1 { int L2 = ([](auto i) { return i; })(2); void fooG(int i = ([] (auto i) { return i; })(2)) { } int BG : ([](auto i) { return i; })(3); //expected-error{{inside of a constant expression}} \ - //expected-error{{not an integral constant}} + //expected-error{{not an integral constant}}\ + //expected-note{{non-literal type}} int arrG[([](auto i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\ - //expected-error{{must have a constant size}} + //expected-error{{must have a constant size}} int (*fpG)(int) = [](auto i) { return i; }; void fooptrG(int (*fp)(char) = [](auto c) { return 0; }) { } }; @@ -887,14 +890,16 @@ struct X1 { int L = ([] (T i) { return i; })(2); void foo(int i = ([] (int i) { return i; })(2)) { } int B : ([](T i) { return i; })(3); //expected-error{{inside of a constant expression}}\ - //expected-error{{not an integral constant}} + //expected-error{{not an integral constant}}\ + //expected-note{{non-literal type}} int arr[([](T i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\ - //expected-error{{must have a constant size}} + //expected-error{{must have a constant size}} int (*fp)(T) = [](T i) { return i; }; void fooptr(T (*fp)(char) = [](char c) { return 0; }) { } int L2 = ([](auto i) { return i; })(2); void fooG(T i = ([] (auto i) { return i; })(2)) { } - int BG : ([](auto i) { return i; })(3); //expected-error{{not an integral constant}} + int BG : ([](auto i) { return i; })(3); //expected-error{{not an integral constant}}\ + //expected-note{{non-literal type}} int arrG[([](auto i) { return i; })(3)]; //expected-error{{must have a constant size}} int (*fpG)(T) = [](auto i) { return i; }; void fooptrG(T (*fp)(char) = [](auto c) { return 0; }) { } @@ -913,3 +918,16 @@ int run2 = x2.fooG3(); } //end ns inclass_lambdas_within_nested_classes + +namespace pr21684_disambiguate_auto_followed_by_ellipsis_no_id { +int a = [](auto ...) { return 0; }(); +} + +namespace PR22117 { + int x = [](auto) { + return [](auto... run_args) { + using T = int(decltype(run_args)...); + return 0; + }; + }(0)(0); +} diff --git a/test/SemaCXX/cxx1y-variable-templates_in_class.cpp b/test/SemaCXX/cxx1y-variable-templates_in_class.cpp index 1e5e834b6d2a..93a2095c9b8c 100644 --- a/test/SemaCXX/cxx1y-variable-templates_in_class.cpp +++ b/test/SemaCXX/cxx1y-variable-templates_in_class.cpp @@ -58,13 +58,13 @@ namespace out_of_line { template<typename T, typename T0> static CONST T b = T(100); template<typename T> static CONST T b<T,int>; }; - template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}} + template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}} expected-note {{add an explicit initializer to initialize 'a<int, char>'}} template<typename T> CONST T B4::a<T,int>; template CONST int B4::a<int,char>; // expected-note {{in instantiation of}} template CONST int B4::a<int,int>; template<typename T, typename T0> CONST T B4::b; - template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}} + template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}} expected-note {{add an explicit initializer to initialize 'b<int, int>'}} template CONST int B4::b<int,char>; template CONST int B4::b<int,int>; // expected-note {{in instantiation of}} } @@ -321,3 +321,9 @@ namespace in_nested_classes { // TODO: } +namespace bitfield { +struct S { + template <int I> + static int f : I; // expected-error {{static member 'f' cannot be a bit-field}} +}; +} diff --git a/test/SemaCXX/cxx98-compat-flags.cpp b/test/SemaCXX/cxx98-compat-flags.cpp index 6dc24be6bbfa..f90ad345e975 100644 --- a/test/SemaCXX/cxx98-compat-flags.cpp +++ b/test/SemaCXX/cxx98-compat-flags.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -verify %s -// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -Wno-bind-to-temporary-copy -Wno-unnamed-type-template-args -Wno-local-type-template-args -Werror %s +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat-pedantic -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat-pedantic -Wno-bind-to-temporary-copy -Wno-unnamed-type-template-args -Wno-local-type-template-args -Werror %s template<typename T> int TemplateFn(T) { return 0; } void LocalTemplateArg() { diff --git a/test/SemaCXX/cxx98-compat-pedantic.cpp b/test/SemaCXX/cxx98-compat-pedantic.cpp index b74dcb4238ae..38bc341e83ce 100644 --- a/test/SemaCXX/cxx98-compat-pedantic.cpp +++ b/test/SemaCXX/cxx98-compat-pedantic.cpp @@ -2,7 +2,7 @@ // RUN: %clang_cc1 -fsyntax-only -std=c++1y -DCXX1Y -Wc++98-compat -Werror %s -DCXX1Y2 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat-pedantic -verify %s // RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -Werror %s -// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror %s +// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror %s -DCXX98 // RUN: %clang_cc1 -fsyntax-only -std=c++1y -Wc++98-compat-pedantic -verify %s -Wno-c++98-c++11-compat-pedantic -DCXX1Y2 @@ -49,5 +49,32 @@ unsigned long long ull1 = // expected-warning {{'long long' is incompatible with int k = 0b1001; #ifdef CXX1Y -// expected-warning@-2 {{binary integer literals are incompatible with C++ standards before C++1y}} +// expected-warning@-2 {{binary integer literals are incompatible with C++ standards before C++14}} #endif + +namespace CopyCtorIssues { + struct Private { + Private(); + private: + Private(const Private&); // expected-note {{declared private here}} + }; + struct NoViable { + NoViable(); + NoViable(NoViable&); // expected-note {{not viable}} + }; + struct Ambiguous { + Ambiguous(); + Ambiguous(const Ambiguous &, int = 0); // expected-note {{candidate}} + Ambiguous(const Ambiguous &, double = 0); // expected-note {{candidate}} + }; + struct Deleted { + Private p; // expected-note {{implicitly deleted}} + }; + + const Private &a = Private(); // expected-warning {{copying variable of type 'CopyCtorIssues::Private' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}} + const NoViable &b = NoViable(); // expected-warning {{copying variable of type 'CopyCtorIssues::NoViable' when binding a reference to a temporary would find no viable constructor in C++98}} +#if !CXX98 + const Ambiguous &c = Ambiguous(); // expected-warning {{copying variable of type 'CopyCtorIssues::Ambiguous' when binding a reference to a temporary would find ambiguous constructors in C++98}} +#endif + const Deleted &d = Deleted(); // expected-warning {{copying variable of type 'CopyCtorIssues::Deleted' when binding a reference to a temporary would invoke a deleted constructor in C++98}} +} diff --git a/test/SemaCXX/cxx98-compat.cpp b/test/SemaCXX/cxx98-compat.cpp index 96af95425aec..029e90989628 100644 --- a/test/SemaCXX/cxx98-compat.cpp +++ b/test/SemaCXX/cxx98-compat.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -verify %s -// RUN: %clang_cc1 -fsyntax-only -std=c++1y -Wc++98-compat -verify %s -DCXX1YCOMPAT +// RUN: %clang_cc1 -fsyntax-only -std=c++14 -Wc++98-compat -verify %s -DCXX14COMPAT namespace std { struct type_info; @@ -225,31 +225,6 @@ template<typename T> typename T::ImPrivate SFINAEAccessControl(T t) { // expecte int SFINAEAccessControl(...) { return 0; } int CheckSFINAEAccessControl = SFINAEAccessControl(PrivateMember()); // expected-note {{while substituting deduced template arguments into function template 'SFINAEAccessControl' [with T = PrivateMember]}} -namespace CopyCtorIssues { - struct Private { - Private(); - private: - Private(const Private&); // expected-note {{declared private here}} - }; - struct NoViable { - NoViable(); - NoViable(NoViable&); // expected-note {{not viable}} - }; - struct Ambiguous { - Ambiguous(); - Ambiguous(const Ambiguous &, int = 0); // expected-note {{candidate}} - Ambiguous(const Ambiguous &, double = 0); // expected-note {{candidate}} - }; - struct Deleted { - Private p; // expected-note {{implicitly deleted}} - }; - - const Private &a = Private(); // expected-warning {{copying variable of type 'CopyCtorIssues::Private' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}} - const NoViable &b = NoViable(); // expected-warning {{copying variable of type 'CopyCtorIssues::NoViable' when binding a reference to a temporary would find no viable constructor in C++98}} - const Ambiguous &c = Ambiguous(); // expected-warning {{copying variable of type 'CopyCtorIssues::Ambiguous' when binding a reference to a temporary would find ambiguous constructors in C++98}} - const Deleted &d = Deleted(); // expected-warning {{copying variable of type 'CopyCtorIssues::Deleted' when binding a reference to a temporary would invoke a deleted constructor in C++98}} -} - namespace UnionOrAnonStructMembers { struct NonTrivCtor { NonTrivCtor(); // expected-note 2{{user-provided default constructor}} @@ -286,18 +261,18 @@ template<typename T> void EnumNNSFn() { template void EnumNNSFn<Enum>(); // expected-note {{in instantiation}} void JumpDiagnostics(int n) { - goto DirectJump; // expected-warning {{goto would jump into protected scope in C++98}} + goto DirectJump; // expected-warning {{jump from this goto statement to its label is incompatible with C++98}} TrivialButNonPOD tnp1; // expected-note {{jump bypasses initialization of non-POD variable}} DirectJump: void *Table[] = {&&DirectJump, &&Later}; - goto *Table[n]; // expected-warning {{indirect goto might cross protected scopes in C++98}} + goto *Table[n]; // expected-warning {{jump from this indirect goto statement to one of its possible targets is incompatible with C++98}} TrivialButNonPOD tnp2; // expected-note {{jump bypasses initialization of non-POD variable}} -Later: // expected-note {{possible target of indirect goto}} +Later: // expected-note {{possible target of indirect goto statement}} switch (n) { TrivialButNonPOD tnp3; // expected-note {{jump bypasses initialization of non-POD variable}} - default: // expected-warning {{switch case would be in a protected scope in C++98}} + default: // expected-warning {{jump from switch statement to this case label is incompatible with C++98}} return; } } @@ -373,10 +348,10 @@ namespace rdar11736429 { } template<typename T> T var = T(10); -#ifdef CXX1YCOMPAT -// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++1y}} +#ifdef CXX14COMPAT +// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++14}} #else -// expected-warning@-4 {{variable templates are a C++1y extension}} +// expected-warning@-4 {{variable templates are a C++14 extension}} #endif // No diagnostic for specializations of variable templates; we will have @@ -388,27 +363,27 @@ float fvar = var<float>; class A { template<typename T> static T var = T(10); -#ifdef CXX1YCOMPAT -// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++1y}} +#ifdef CXX14COMPAT +// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++14}} #else -// expected-warning@-4 {{variable templates are a C++1y extension}} +// expected-warning@-4 {{variable templates are a C++14 extension}} #endif - template<typename T> static T* var<T*> = new T(); + template<typename T> static T* var<T*> = new T(); }; struct B { template<typename T> static T v; }; -#ifdef CXX1YCOMPAT -// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++1y}} +#ifdef CXX14COMPAT +// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++14}} #else -// expected-warning@-4 {{variable templates are a C++1y extension}} +// expected-warning@-4 {{variable templates are a C++14 extension}} #endif template<typename T> T B::v = T(); -#ifdef CXX1YCOMPAT -// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++1y}} +#ifdef CXX14COMPAT +// expected-warning@-2 {{variable templates are incompatible with C++ standards before C++14}} #else -// expected-warning@-4 {{variable templates are a C++1y extension}} +// expected-warning@-4 {{variable templates are a C++14 extension}} #endif template<typename T> T* B::v<T*> = new T(); @@ -416,6 +391,6 @@ template<> int B::v<int> = 10; template int B::v<int>; float fsvar = B::v<float>; -#ifdef CXX1YCOMPAT -int digit_seps = 123'456; // expected-warning {{digit separators are incompatible with C++ standards before C++1y}} +#ifdef CXX14COMPAT +int digit_seps = 123'456; // expected-warning {{digit separators are incompatible with C++ standards before C++14}} #endif diff --git a/test/SemaCXX/decl-init-ref.cpp b/test/SemaCXX/decl-init-ref.cpp index 2d0c9cb4ffbe..42b9286852c7 100644 --- a/test/SemaCXX/decl-init-ref.cpp +++ b/test/SemaCXX/decl-init-ref.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -Wno-uninitialized struct A {}; diff --git a/test/SemaCXX/decl-microsoft-call-conv.cpp b/test/SemaCXX/decl-microsoft-call-conv.cpp index eb6c8507eddc..a4b68cdbc7d4 100644 --- a/test/SemaCXX/decl-microsoft-call-conv.cpp +++ b/test/SemaCXX/decl-microsoft-call-conv.cpp @@ -10,6 +10,7 @@ void free_func_default(); // expected-note 2 {{previous declaration i void __cdecl free_func_cdecl(); // expected-note 2 {{previous declaration is here}} void __stdcall free_func_stdcall(); // expected-note 2 {{previous declaration is here}} void __fastcall free_func_fastcall(); // expected-note 2 {{previous declaration is here}} +void __vectorcall free_func_vectorcall(); // expected-note 2 {{previous declaration is here}} void __cdecl free_func_default(); void __stdcall free_func_default(); // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} @@ -27,6 +28,10 @@ void __cdecl free_func_fastcall(); // expected-error {{function declared 'cde void __stdcall free_func_fastcall(); // expected-error {{function declared 'stdcall' here was previously declared 'fastcall'}} void free_func_fastcall(); +void __cdecl free_func_vectorcall(); // expected-error {{function declared 'cdecl' here was previously declared 'vectorcall'}} +void __stdcall free_func_vectorcall(); // expected-error {{function declared 'stdcall' here was previously declared 'vectorcall'}} +void free_func_vectorcall(); + // Overloaded functions may have different calling conventions void __fastcall free_func_default(int); void __cdecl free_func_default(int *); @@ -45,6 +50,8 @@ struct S { void __cdecl member_cdecl2(); // expected-note {{previous declaration is here}} void __thiscall member_thiscall1(); void __thiscall member_thiscall2(); // expected-note {{previous declaration is here}} + void __vectorcall member_vectorcall1(); + void __vectorcall member_vectorcall2(); // expected-note {{previous declaration is here}} // Typedefs carrying the __cdecl convention are adjusted to __thiscall. void_fun_t member_typedef_default; // expected-note {{previous declaration is here}} @@ -83,6 +90,9 @@ void __thiscall S::member_cdecl2() {} // expected-error {{function declared 'thi void S::member_thiscall1() {} void __cdecl S::member_thiscall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'thiscall'}} +void S::member_vectorcall1() {} +void __cdecl S::member_vectorcall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'vectorcall'}} + void S::static_member_default1() {} void __cdecl S::static_member_default2() {} void __stdcall S::static_member_default3() {} // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} @@ -143,9 +153,10 @@ void __attribute__((noreturn)) __stdcall __attribute__((regparm(1))) multi_attri void multi_attribute(int x) { __builtin_unreachable(); } +// expected-error@+3 {{vectorcall and cdecl attributes are not compatible}} // expected-error@+2 {{stdcall and cdecl attributes are not compatible}} // expected-error@+1 {{fastcall and cdecl attributes are not compatible}} -void __cdecl __cdecl __stdcall __cdecl __fastcall multi_cc(int x); +void __cdecl __cdecl __stdcall __cdecl __fastcall __vectorcall multi_cc(int x); template <typename T> void __stdcall StdcallTemplate(T) {} template <> void StdcallTemplate<int>(int) {} diff --git a/test/SemaCXX/default1.cpp b/test/SemaCXX/default1.cpp index 23466fac62aa..6001001b11eb 100644 --- a/test/SemaCXX/default1.cpp +++ b/test/SemaCXX/default1.cpp @@ -65,3 +65,9 @@ int i2() { int pr20055_f(int x = 0, int y = UNDEFINED); // expected-error{{use of undeclared identifier}} int pr20055_v = pr20055_f(0); + +void PR20769() { void PR20769(int = 1); } +void PR20769(int = 2); + +void PR20769_b(int = 1); +void PR20769_b() { void PR20769_b(int = 2); } diff --git a/test/SemaCXX/default2.cpp b/test/SemaCXX/default2.cpp index 16260449d4be..c4d40b4280e9 100644 --- a/test/SemaCXX/default2.cpp +++ b/test/SemaCXX/default2.cpp @@ -122,3 +122,9 @@ class XX { void A(int length = -1 ) { } void B() { A(); } }; + +template <int I = (1 * I)> struct S {}; // expected-error-re {{use of undeclared identifier 'I'{{$}}}} +S<1> s; + +template <int I1 = I2, int I2 = 1> struct T {}; // expected-error-re {{use of undeclared identifier 'I2'{{$}}}} +T<0, 1> t; diff --git a/test/SemaCXX/dependent-noexcept-unevaluated.cpp b/test/SemaCXX/dependent-noexcept-unevaluated.cpp index 0a3a8bb250bc..fad8d0918d53 100644 --- a/test/SemaCXX/dependent-noexcept-unevaluated.cpp +++ b/test/SemaCXX/dependent-noexcept-unevaluated.cpp @@ -23,7 +23,7 @@ struct array { T data[N]; - void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>()))); + void swap(array& a) noexcept(noexcept(::swap(declval<T&>(), declval<T&>()))); }; struct DefaultOnly @@ -38,3 +38,4 @@ int main() { array<DefaultOnly, 1> a, b; } + diff --git a/test/SemaCXX/deprecated.cpp b/test/SemaCXX/deprecated.cpp index 2fe6d59861ac..5fcf2130d36f 100644 --- a/test/SemaCXX/deprecated.cpp +++ b/test/SemaCXX/deprecated.cpp @@ -35,7 +35,7 @@ void stuff() { #endif } -struct S { int n; }; +struct S { int n; void operator+(int); }; struct T : private S { S::n; #if __cplusplus < 201103L @@ -43,6 +43,12 @@ struct T : private S { #else // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}} #endif + S::operator+; +#if __cplusplus < 201103L + // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}} +#else + // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}} +#endif }; #if __cplusplus >= 201103L diff --git a/test/SemaCXX/devirtualize-vtable-marking.cpp b/test/SemaCXX/devirtualize-vtable-marking.cpp new file mode 100644 index 000000000000..fc3e8ce7704c --- /dev/null +++ b/test/SemaCXX/devirtualize-vtable-marking.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -verify -std=c++11 %s + +template <typename T> struct OwnPtr { + T *p; + ~OwnPtr() { + // expected-error@+1 {{invalid application of 'sizeof'}} + static_assert(sizeof(T) > 0, "incomplete T"); + delete p; + } +}; + +namespace use_vtable_for_vcall { +struct Incomplete; // expected-note {{forward declaration}} +struct A { + virtual ~A() {} + virtual void m() {} +}; +struct B : A { // expected-note {{in instantiation}} + B(); + virtual void m() { } + virtual void m2() { static_cast<A *>(this)->m(); } + OwnPtr<Incomplete> m_sqlError; +}; + +B *f() { + return new B(); +} +} + +namespace dont_mark_qualified_vcall { +struct Incomplete; +struct A { + virtual ~A() {} + virtual void m() {} +}; +struct B : A { + B(); + // Previously we would mark B's vtable referenced to devirtualize this call to + // A::m, even though it's not a virtual call. + virtual void m() { A::m(); } + OwnPtr<Incomplete> m_sqlError; +}; + +B *f() { + return new B(); +} +} diff --git a/test/SemaCXX/dllexport.cpp b/test/SemaCXX/dllexport.cpp index 668553b5c500..5d002ac81e5c 100644 --- a/test/SemaCXX/dllexport.cpp +++ b/test/SemaCXX/dllexport.cpp @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c++11 -DMS %s -// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c++1y -DMS %s -// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c++1y %s -// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s +// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s +// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c++1y -Wunsupported-dll-base-class-template %s +// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c++11 -Wunsupported-dll-base-class-template %s // Helper structs to make templates more expressive. struct ImplicitInst_Exported {}; @@ -69,6 +69,9 @@ namespace ns { __declspec(dllexport) int ExternalGlobal; } __declspec(dllexport) auto InternalAutoTypeGlobal = Internal(); // expected-error{{'InternalAutoTypeGlobal' must have external linkage when declared 'dllexport'}} __declspec(dllexport) auto ExternalAutoTypeGlobal = External(); +// Thread local variables are invalid. +__declspec(dllexport) __thread int ThreadLocalGlobal; // expected-error{{'ThreadLocalGlobal' cannot be thread local when declared 'dllexport'}} + // Export in local scope. void functionScope() { __declspec(dllexport) int LocalVarDecl; // expected-error{{'LocalVarDecl' must have external linkage when declared 'dllexport'}} @@ -324,6 +327,10 @@ template<> __declspec(dllexport) inline void funcTmpl<ExplicitSpec_InlineDef_Exp // Classes //===----------------------------------------------------------------------===// +namespace { + struct __declspec(dllexport) AnonymousClass {}; // expected-error{{(anonymous namespace)::AnonymousClass' must have external linkage when declared 'dllexport'}} +} + class __declspec(dllexport) ClassDecl; class __declspec(dllexport) ClassDef {}; @@ -337,6 +344,49 @@ template <typename T> struct __declspec(dllexport) PartiallySpecializedClassTemp template <typename T> struct ExpliciallySpecializedClassTemplate {}; template <> struct __declspec(dllexport) ExpliciallySpecializedClassTemplate<int> { void f() {} }; +// Don't instantiate class members of implicitly instantiated templates, even if they are exported. +struct IncompleteType; +template <typename T> struct __declspec(dllexport) ImplicitlyInstantiatedExportedTemplate { + int f() { return sizeof(T); } // no-error +}; +ImplicitlyInstantiatedExportedTemplate<IncompleteType> implicitlyInstantiatedExportedTemplate; + +// Don't instantiate class members of templates with explicit instantiation declarations, even if they are exported. +struct IncompleteType2; +template <typename T> struct __declspec(dllexport) ExportedTemplateWithExplicitInstantiationDecl { + int f() { return sizeof(T); } // no-error +}; +extern template struct ExportedTemplateWithExplicitInstantiationDecl<IncompleteType2>; + +// Instantiate class members for explicitly instantiated exported templates. +struct IncompleteType3; // expected-note{{forward declaration of 'IncompleteType3'}} +template <typename T> struct __declspec(dllexport) ExplicitlyInstantiatedExportedTemplate { + int f() { return sizeof(T); } // expected-error{{invalid application of 'sizeof' to an incomplete type 'IncompleteType3'}} +}; +template struct ExplicitlyInstantiatedExportedTemplate<IncompleteType3>; // expected-note{{in instantiation of member function 'ExplicitlyInstantiatedExportedTemplate<IncompleteType3>::f' requested here}} + +// In MS mode, instantiate members of class templates that are base classes of exported classes. +#ifdef MS + // expected-note@+3{{forward declaration of 'IncompleteType4'}} + // expected-note@+3{{in instantiation of member function 'BaseClassTemplateOfExportedClass<IncompleteType4>::f' requested here}} +#endif +struct IncompleteType4; +template <typename T> struct BaseClassTemplateOfExportedClass { +#ifdef MS + // expected-error@+2{{invalid application of 'sizeof' to an incomplete type 'IncompleteType4'}} +#endif + int f() { return sizeof(T); }; +}; +struct __declspec(dllexport) ExportedBaseClass : public BaseClassTemplateOfExportedClass<IncompleteType4> {}; + +// Don't instantiate members of explicitly exported class templates that are base classes of exported classes. +struct IncompleteType5; +template <typename T> struct __declspec(dllexport) ExportedBaseClassTemplateOfExportedClass { + int f() { return sizeof(T); }; // no-error +}; +struct __declspec(dllexport) ExportedBaseClass2 : public ExportedBaseClassTemplateOfExportedClass<IncompleteType5> {}; + + //===----------------------------------------------------------------------===// // Classes with template base classes diff --git a/test/SemaCXX/dllimport.cpp b/test/SemaCXX/dllimport.cpp index 889b7b9a8068..eb6a554522ba 100644 --- a/test/SemaCXX/dllimport.cpp +++ b/test/SemaCXX/dllimport.cpp @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c++11 -DMS %s -// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c++1y -DMS %s -// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c++1y %s -// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s +// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s +// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -verify -std=c++1y -Wunsupported-dll-base-class-template -DGNU %s +// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify -std=c++11 -Wunsupported-dll-base-class-template -DGNU %s // Helper structs to make templates more expressive. struct ImplicitInst_Imported {}; @@ -91,6 +91,9 @@ namespace ns { __declspec(dllimport) int ExternalGlobal; } __declspec(dllimport) auto InternalAutoTypeGlobal = Internal(); // expected-error{{'InternalAutoTypeGlobal' must have external linkage when declared 'dllimport'}} // expected-error@-1{{definition of dllimport data}} +// Thread local variables are invalid. +__declspec(dllimport) __thread int ThreadLocalGlobal; // expected-error{{'ThreadLocalGlobal' cannot be thread local when declared 'dllimport'}} + // Import in local scope. __declspec(dllimport) float LocalRedecl1; // expected-note{{previous definition is here}} __declspec(dllimport) float LocalRedecl2; // expected-note{{previous definition is here}} @@ -188,7 +191,6 @@ template<> __declspec(dllimport) int VarTmpl<ExplicitSpec_Def_Imported> = 1; // #endif // __has_feature(cxx_variable_templates) - //===----------------------------------------------------------------------===// // Functions //===----------------------------------------------------------------------===// @@ -207,13 +209,23 @@ __declspec(dllimport) void def() {} // expected-error{{dllimport cannot be appli extern "C" __declspec(dllimport) void externC(); // Import inline function. +#ifdef GNU +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) inline void inlineFunc1() {} inline void __attribute__((dllimport)) inlineFunc2() {} +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) inline void inlineDecl(); void inlineDecl() {} __declspec(dllimport) void inlineDef(); +#ifdef GNU +// expected-warning@+2{{'inlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif inline void inlineDef() {} // Redeclarations @@ -236,8 +248,13 @@ extern "C" { __declspec(dllimport) void redecl5(); // expected-warning{{redeclaration of 'redecl5' should not add 'dllimport' attribute}} } +#ifdef MS void redecl6(); // expected-note{{previous declaration is here}} __declspec(dllimport) inline void redecl6() {} // expected-warning{{redeclaration of 'redecl6' should not add 'dllimport' attribute}} +#else + void redecl6(); +__declspec(dllimport) inline void redecl6() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif // Friend functions struct FuncFriend { @@ -245,13 +262,28 @@ struct FuncFriend { friend __declspec(dllimport) void friend2(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} friend __declspec(dllimport) void friend3(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} friend void friend4(); // expected-note{{previous declaration is here}} - friend void friend5(); // expected-note{{previous declaration is here}} +#ifdef MS +// expected-note@+2{{previous declaration is here}} +#endif + friend void friend5(); }; __declspec(dllimport) void friend1(); void friend2(); // expected-warning{{'friend2' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} void friend3() {} // expected-warning{{'friend3' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} __declspec(dllimport) void friend4(); // expected-warning{{redeclaration of 'friend4' should not add 'dllimport' attribute}} +#ifdef MS __declspec(dllimport) inline void friend5() {} // expected-warning{{redeclaration of 'friend5' should not add 'dllimport' attribute}} +#else +__declspec(dllimport) inline void friend5() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif + + +void __declspec(dllimport) friend6(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} +void __declspec(dllimport) friend7(); +struct FuncFriend2 { + friend void friend6(); // expected-warning{{'friend6' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} + friend void ::friend7(); +}; // Implicit declarations can be redeclared with dllimport. __declspec(dllimport) void* operator new(__SIZE_TYPE__ n); @@ -267,7 +299,11 @@ namespace ns { __declspec(dllimport) void externalFunc(); } // here which is irrelevant. But because the delete keyword is parsed later // there is currently no straight-forward way to avoid this diagnostic. __declspec(dllimport) void deletedFunc() = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} expected-error{{dllimport cannot be applied to non-inline function definition}} +#ifdef MS __declspec(dllimport) inline void deletedInlineFunc() = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} +#else +__declspec(dllimport) inline void deletedInlineFunc() = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif @@ -283,6 +319,12 @@ template<typename T> void __declspec(dllimport) funcTmplDecl2(); template<typename T> __declspec(dllimport) void funcTmplDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} // Import inline function template. +#ifdef GNU +// expected-warning@+5{{'dllimport' attribute ignored on inline function}} +// expected-warning@+5{{'dllimport' attribute ignored on inline function}} +// expected-warning@+6{{'dllimport' attribute ignored on inline function}} +// expected-warning@+9{{'inlineFuncTmplDef' redeclared inline; 'dllimport' attribute ignored}} +#endif template<typename T> __declspec(dllimport) inline void inlineFuncTmpl1() {} template<typename T> inline void __attribute__((dllimport)) inlineFuncTmpl2() {} @@ -305,8 +347,10 @@ template<typename T> void funcTmplRedecl3() {} // expected template<typename T> void funcTmplRedecl4(); // expected-note{{previous declaration is here}} template<typename T> __declspec(dllimport) void funcTmplRedecl4(); // expected-error{{redeclaration of 'funcTmplRedecl4' cannot add 'dllimport' attribute}} +#ifdef MS template<typename T> void funcTmplRedecl5(); // expected-note{{previous declaration is here}} template<typename T> __declspec(dllimport) inline void funcTmplRedecl5() {} // expected-error{{redeclaration of 'funcTmplRedecl5' cannot add 'dllimport' attribute}} +#endif // Function template friends struct FuncTmplFriend { @@ -314,6 +358,9 @@ struct FuncTmplFriend { template<typename T> friend __declspec(dllimport) void funcTmplFriend2(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} template<typename T> friend __declspec(dllimport) void funcTmplFriend3(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} template<typename T> friend void funcTmplFriend4(); // expected-note{{previous declaration is here}} +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> friend __declspec(dllimport) inline void funcTmplFriend5(); }; template<typename T> __declspec(dllimport) void funcTmplFriend1(); @@ -332,6 +379,9 @@ namespace ns { template<typename T> __declspec(dllimport) void externalFuncTmpl( template<typename T> void funcTmpl() {} template<typename T> inline void inlineFuncTmpl() {} template<typename T> __declspec(dllimport) void importedFuncTmplDecl(); +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> __declspec(dllimport) inline void importedFuncTmpl() {} // Import implicit instantiation of an imported function template. @@ -350,7 +400,9 @@ template void importedFuncTmpl<ExplicitInst_Imported>(); // declared inline. template<> __declspec(dllimport) void importedFuncTmpl<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void importedFuncTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} +#ifdef MS template<> __declspec(dllimport) inline void importedFuncTmpl<ExplicitSpec_InlineDef_Imported>() {} +#endif // Not importing specialization of an imported function template without // explicit dllimport. @@ -359,16 +411,25 @@ template<> void importedFuncTmpl<ExplicitSpec_NotImported>() {} // Import explicit instantiation declaration of a non-imported function template. extern template __declspec(dllimport) void funcTmpl<ExplicitDecl_Imported>(); +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif extern template __declspec(dllimport) void inlineFuncTmpl<ExplicitDecl_Imported>(); // Import explicit instantiation definition of a non-imported function template. template __declspec(dllimport) void funcTmpl<ExplicitInst_Imported>(); +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template __declspec(dllimport) void inlineFuncTmpl<ExplicitInst_Imported>(); // Import specialization of a non-imported function template. A definition must // be declared inline. template<> __declspec(dllimport) void funcTmpl<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void funcTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} +#ifdef GNU +// expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<> __declspec(dllimport) inline void funcTmpl<ExplicitSpec_InlineDef_Imported>() {} @@ -383,16 +444,28 @@ struct ImportMembers { __declspec(dllimport) void normalDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} }; +#ifdef GNU +// expected-warning@+5{{'dllimport' attribute ignored on inline function}} +// expected-warning@+6{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) void normalDecl(); __declspec(dllimport) void normalDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} __declspec(dllimport) void normalInclass() {} __declspec(dllimport) void normalInlineDef(); __declspec(dllimport) inline void normalInlineDecl(); +#ifdef GNU +// expected-warning@+5{{'dllimport' attribute ignored on inline function}} +// expected-warning@+6{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) virtual void virtualDecl(); __declspec(dllimport) virtual void virtualDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} __declspec(dllimport) virtual void virtualInclass() {} __declspec(dllimport) virtual void virtualInlineDef(); __declspec(dllimport) virtual inline void virtualInlineDecl(); +#ifdef GNU +// expected-warning@+5{{'dllimport' attribute ignored on inline function}} +// expected-warning@+6{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) static void staticDecl(); __declspec(dllimport) static void staticDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} __declspec(dllimport) static void staticInclass() {} @@ -418,12 +491,21 @@ public: void ImportMembers::Nested::normalDef() {} // expected-warning{{'ImportMembers::Nested::normalDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} void ImportMembers::normalDef() {} // expected-warning{{'ImportMembers::normalDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportMembers::normalInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif inline void ImportMembers::normalInlineDef() {} void ImportMembers::normalInlineDecl() {} void ImportMembers::virtualDef() {} // expected-warning{{'ImportMembers::virtualDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportMembers::virtualInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif inline void ImportMembers::virtualInlineDef() {} void ImportMembers::virtualInlineDecl() {} void ImportMembers::staticDef() {} // expected-warning{{'ImportMembers::staticDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportMembers::staticInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif inline void ImportMembers::staticInlineDef() {} void ImportMembers::staticInlineDecl() {} @@ -436,13 +518,15 @@ constexpr int ImportMembers::ConstexprFieldDef; // expected-error{{definition of struct ImportMemberDefs { __declspec(dllimport) void normalDef(); __declspec(dllimport) void normalInlineDef(); - __declspec(dllimport) inline void normalInlineDecl(); __declspec(dllimport) virtual void virtualDef(); __declspec(dllimport) virtual void virtualInlineDef(); - __declspec(dllimport) virtual inline void virtualInlineDecl(); __declspec(dllimport) static void staticDef(); __declspec(dllimport) static void staticInlineDef(); +#ifdef MS + __declspec(dllimport) inline void normalInlineDecl(); + __declspec(dllimport) virtual inline void virtualInlineDecl(); __declspec(dllimport) static inline void staticInlineDecl(); +#endif __declspec(dllimport) static int StaticField; __declspec(dllimport) static const int StaticConstField; @@ -450,14 +534,16 @@ struct ImportMemberDefs { }; __declspec(dllimport) void ImportMemberDefs::normalDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} +__declspec(dllimport) void ImportMemberDefs::virtualDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} +__declspec(dllimport) void ImportMemberDefs::staticDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} +#ifdef MS __declspec(dllimport) inline void ImportMemberDefs::normalInlineDef() {} __declspec(dllimport) void ImportMemberDefs::normalInlineDecl() {} -__declspec(dllimport) void ImportMemberDefs::virtualDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} __declspec(dllimport) inline void ImportMemberDefs::virtualInlineDef() {} __declspec(dllimport) void ImportMemberDefs::virtualInlineDecl() {} -__declspec(dllimport) void ImportMemberDefs::staticDef() {} // expected-error{{dllimport cannot be applied to non-inline function definition}} __declspec(dllimport) inline void ImportMemberDefs::staticInlineDef() {} __declspec(dllimport) void ImportMemberDefs::staticInlineDecl() {} +#endif __declspec(dllimport) int ImportMemberDefs::StaticField; // expected-error{{definition of dllimport static field not allowed}} expected-note{{attribute is here}} __declspec(dllimport) const int ImportMemberDefs::StaticConstField = 1; // expected-error{{definition of dllimport static field not allowed}} expected-note{{attribute is here}} @@ -477,6 +563,7 @@ struct ImportSpecials { // Import deleted member functions. struct ImportDeleted { +#ifdef MS __declspec(dllimport) ImportDeleted() = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} __declspec(dllimport) ~ImportDeleted() = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} __declspec(dllimport) ImportDeleted(const ImportDeleted&) = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} @@ -484,6 +571,15 @@ struct ImportDeleted { __declspec(dllimport) ImportDeleted(ImportDeleted&&) = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} __declspec(dllimport) ImportDeleted& operator=(ImportDeleted&&) = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} __declspec(dllimport) void deleted() = delete; // expected-error{{attribute 'dllimport' cannot be applied to a deleted function}} +#else + __declspec(dllimport) ImportDeleted() = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) ~ImportDeleted() = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) ImportDeleted(const ImportDeleted&) = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) ImportDeleted& operator=(const ImportDeleted&) = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) ImportDeleted(ImportDeleted&&) = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) ImportDeleted& operator=(ImportDeleted&&) = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} + __declspec(dllimport) void deleted() = delete; // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif }; @@ -498,6 +594,14 @@ struct ImportAlloc { // Import defaulted member functions. struct ImportDefaulted { +#ifdef GNU + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} + // expected-warning@+7{{'dllimport' attribute ignored on inline function}} +#endif __declspec(dllimport) ImportDefaulted() = default; __declspec(dllimport) ~ImportDefaulted() = default; __declspec(dllimport) ImportDefaulted(const ImportDefaulted&) = default; @@ -512,6 +616,10 @@ struct ImportDefaultedDefs { __declspec(dllimport) ImportDefaultedDefs(); __declspec(dllimport) ~ImportDefaultedDefs(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} +#ifdef GNU +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +// expected-note@+2{{previous declaration is here}} +#endif __declspec(dllimport) inline ImportDefaultedDefs(const ImportDefaultedDefs&); __declspec(dllimport) ImportDefaultedDefs& operator=(const ImportDefaultedDefs&); @@ -526,6 +634,10 @@ __declspec(dllimport) ImportDefaultedDefs::ImportDefaultedDefs() = default; // e ImportDefaultedDefs::~ImportDefaultedDefs() = default; // expected-warning{{'ImportDefaultedDefs::~ImportDefaultedDefs' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} // Import inline declaration and definition. +#ifdef GNU +// expected-error@+3{{redeclaration of 'ImportDefaultedDefs::ImportDefaultedDefs' cannot add 'dllimport' attribute}} +// expected-warning@+3{{'ImportDefaultedDefs::operator=' redeclared inline; 'dllimport' attribute ignored}} +#endif __declspec(dllimport) ImportDefaultedDefs::ImportDefaultedDefs(const ImportDefaultedDefs&) = default; inline ImportDefaultedDefs& ImportDefaultedDefs::operator=(const ImportDefaultedDefs&) = default; @@ -536,15 +648,21 @@ ImportDefaultedDefs& ImportDefaultedDefs::operator=(ImportDefaultedDefs&&) = def // Redeclarations cannot add dllimport. struct MemberRedecl { void normalDef(); // expected-note{{previous declaration is here}} - void normalInlineDef(); // expected-note{{previous declaration is here}} inline void normalInlineDecl(); // expected-note{{previous declaration is here}} virtual void virtualDef(); // expected-note{{previous declaration is here}} - virtual void virtualInlineDef(); // expected-note{{previous declaration is here}} virtual inline void virtualInlineDecl(); // expected-note{{previous declaration is here}} static void staticDef(); // expected-note{{previous declaration is here}} - static void staticInlineDef(); // expected-note{{previous declaration is here}} static inline void staticInlineDecl(); // expected-note{{previous declaration is here}} +#ifdef MS + // expected-note@+4{{previous declaration is here}} + // expected-note@+4{{previous declaration is here}} + // expected-note@+4{{previous declaration is here}} +#endif + void normalInlineDef(); + virtual void virtualInlineDef(); + static void staticInlineDef(); + static int StaticField; // expected-note{{previous declaration is here}} static const int StaticConstField; // expected-note{{previous declaration is here}} constexpr static int ConstexprField = 1; // expected-note{{previous declaration is here}} @@ -552,17 +670,26 @@ struct MemberRedecl { __declspec(dllimport) void MemberRedecl::normalDef() {} // expected-error{{redeclaration of 'MemberRedecl::normalDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -__declspec(dllimport) inline void MemberRedecl::normalInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::normalInlineDef' cannot add 'dllimport' attribute}} __declspec(dllimport) void MemberRedecl::normalInlineDecl() {} // expected-error{{redeclaration of 'MemberRedecl::normalInlineDecl' cannot add 'dllimport' attribute}} __declspec(dllimport) void MemberRedecl::virtualDef() {} // expected-error{{redeclaration of 'MemberRedecl::virtualDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -__declspec(dllimport) inline void MemberRedecl::virtualInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::virtualInlineDef' cannot add 'dllimport' attribute}} __declspec(dllimport) void MemberRedecl::virtualInlineDecl() {} // expected-error{{redeclaration of 'MemberRedecl::virtualInlineDecl' cannot add 'dllimport' attribute}} __declspec(dllimport) void MemberRedecl::staticDef() {} // expected-error{{redeclaration of 'MemberRedecl::staticDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -__declspec(dllimport) inline void MemberRedecl::staticInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::staticInlineDef' cannot add 'dllimport' attribute}} __declspec(dllimport) void MemberRedecl::staticInlineDecl() {} // expected-error{{redeclaration of 'MemberRedecl::staticInlineDecl' cannot add 'dllimport' attribute}} +#ifdef MS +__declspec(dllimport) inline void MemberRedecl::normalInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::normalInlineDef' cannot add 'dllimport' attribute}} +__declspec(dllimport) inline void MemberRedecl::virtualInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::virtualInlineDef' cannot add 'dllimport' attribute}} +__declspec(dllimport) inline void MemberRedecl::staticInlineDef() {} // expected-error{{redeclaration of 'MemberRedecl::staticInlineDef' cannot add 'dllimport' attribute}} +#else +__declspec(dllimport) inline void MemberRedecl::normalInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +__declspec(dllimport) inline void MemberRedecl::virtualInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +__declspec(dllimport) inline void MemberRedecl::staticInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif + + + __declspec(dllimport) int MemberRedecl::StaticField = 1; // expected-error{{redeclaration of 'MemberRedecl::StaticField' cannot add 'dllimport' attribute}} // expected-error@-1{{definition of dllimport static field not allowed}} // expected-note@-2{{attribute is here}} @@ -582,13 +709,20 @@ __declspec(dllimport) constexpr int MemberRedecl::ConstexprField; // expect struct ImportMemberTmpl { template<typename T> __declspec(dllimport) void normalDecl(); template<typename T> __declspec(dllimport) void normalDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - template<typename T> __declspec(dllimport) void normalInclass() {} template<typename T> __declspec(dllimport) void normalInlineDef(); - template<typename T> __declspec(dllimport) inline void normalInlineDecl(); template<typename T> __declspec(dllimport) static void staticDecl(); template<typename T> __declspec(dllimport) static void staticDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - template<typename T> __declspec(dllimport) static void staticInclass() {} template<typename T> __declspec(dllimport) static void staticInlineDef(); + +#ifdef GNU + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} +#endif + template<typename T> __declspec(dllimport) void normalInclass() {} + template<typename T> __declspec(dllimport) inline void normalInlineDecl(); + template<typename T> __declspec(dllimport) static void staticInclass() {} template<typename T> __declspec(dllimport) static inline void staticInlineDecl(); #if __has_feature(cxx_variable_templates) @@ -604,12 +738,17 @@ struct ImportMemberTmpl { }; template<typename T> void ImportMemberTmpl::normalDef() {} // expected-warning{{'ImportMemberTmpl::normalDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} -template<typename T> inline void ImportMemberTmpl::normalInlineDef() {} template<typename T> void ImportMemberTmpl::normalInlineDecl() {} template<typename T> void ImportMemberTmpl::staticDef() {} // expected-warning{{'ImportMemberTmpl::staticDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} -template<typename T> inline void ImportMemberTmpl::staticInlineDef() {} template<typename T> void ImportMemberTmpl::staticInlineDecl() {} +#ifdef GNU +// expected-warning@+3{{ImportMemberTmpl::normalInlineDef' redeclared inline; 'dllimport' attribute ignored}} +// expected-warning@+3{{ImportMemberTmpl::staticInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif +template<typename T> inline void ImportMemberTmpl::normalInlineDef() {} +template<typename T> inline void ImportMemberTmpl::staticInlineDef() {} + #if __has_feature(cxx_variable_templates) template<typename T> int ImportMemberTmpl::StaticFieldDef; // expected-error{{definition of dllimport static field not allowed}} template<typename T> const int ImportMemberTmpl::StaticConstFieldDef = 1; // expected-error{{definition of dllimport static field not allowed}} @@ -620,12 +759,17 @@ template<typename T> constexpr int ImportMemberTmpl::ConstexprFieldDef; // expec // Redeclarations cannot add dllimport. struct MemTmplRedecl { template<typename T> void normalDef(); // expected-note{{previous declaration is here}} - template<typename T> void normalInlineDef(); // expected-note{{previous declaration is here}} template<typename T> inline void normalInlineDecl(); // expected-note{{previous declaration is here}} template<typename T> static void staticDef(); // expected-note{{previous declaration is here}} - template<typename T> static void staticInlineDef(); // expected-note{{previous declaration is here}} template<typename T> static inline void staticInlineDecl(); // expected-note{{previous declaration is here}} +#ifdef MS +// expected-note@+3{{previous declaration is here}} +// expected-note@+3{{previous declaration is here}} +#endif + template<typename T> void normalInlineDef(); + template<typename T> static void staticInlineDef(); + #if __has_feature(cxx_variable_templates) template<typename T> static int StaticField; // expected-note{{previous declaration is here}} template<typename T> static const int StaticConstField; // expected-note{{previous declaration is here}} @@ -635,11 +779,19 @@ struct MemTmplRedecl { template<typename T> __declspec(dllimport) void MemTmplRedecl::normalDef() {} // expected-error{{redeclaration of 'MemTmplRedecl::normalDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} +#ifdef MS template<typename T> __declspec(dllimport) inline void MemTmplRedecl::normalInlineDef() {} // expected-error{{redeclaration of 'MemTmplRedecl::normalInlineDef' cannot add 'dllimport' attribute}} +#else +template<typename T> __declspec(dllimport) inline void MemTmplRedecl::normalInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> __declspec(dllimport) void MemTmplRedecl::normalInlineDecl() {} // expected-error{{redeclaration of 'MemTmplRedecl::normalInlineDecl' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void MemTmplRedecl::staticDef() {} // expected-error{{redeclaration of 'MemTmplRedecl::staticDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} +#ifdef MS template<typename T> __declspec(dllimport) inline void MemTmplRedecl::staticInlineDef() {} // expected-error{{redeclaration of 'MemTmplRedecl::staticInlineDef' cannot add 'dllimport' attribute}} +#else +template<typename T> __declspec(dllimport) inline void MemTmplRedecl::staticInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> __declspec(dllimport) void MemTmplRedecl::staticInlineDecl() {} // expected-error{{redeclaration of 'MemTmplRedecl::staticInlineDecl' cannot add 'dllimport' attribute}} #if __has_feature(cxx_variable_templates) @@ -658,8 +810,14 @@ template<typename T> __declspec(dllimport) constexpr int MemTmplRedecl::Constexp struct MemFunTmpl { template<typename T> void normalDef() {} +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> __declspec(dllimport) void importedNormal() {} template<typename T> static void staticDef() {} +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<typename T> __declspec(dllimport) static void importedStatic() {} }; @@ -683,16 +841,24 @@ template void MemFunTmpl::importedStatic<ExplicitInst_Imported>(); // Import specialization of an imported member function template. template<> __declspec(dllimport) void MemFunTmpl::importedNormal<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void MemFunTmpl::importedNormal<ExplicitSpec_Def_Imported>() {} // error on mingw +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<> __declspec(dllimport) inline void MemFunTmpl::importedNormal<ExplicitSpec_InlineDef_Imported>() {} -#ifndef MSABI -// expected-error@-3{{dllimport cannot be applied to non-inline function definition}} +#if 1 +// FIXME: This should not be an error when targeting MSVC. (PR21406) +// expected-error@-7{{dllimport cannot be applied to non-inline function definition}} #endif template<> __declspec(dllimport) void MemFunTmpl::importedStatic<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void MemFunTmpl::importedStatic<ExplicitSpec_Def_Imported>() {} // error on mingw +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<> __declspec(dllimport) inline void MemFunTmpl::importedStatic<ExplicitSpec_InlineDef_Imported>() {} -#ifndef MSABI -// expected-error@-3{{dllimport cannot be applied to non-inline function definition}} +#if 1 +// FIXME: This should not be an error when targeting MSVC. (PR21406) +// expected-error@-7{{dllimport cannot be applied to non-inline function definition}} #endif // Not importing specialization of an imported member function template without @@ -703,27 +869,43 @@ template<> void MemFunTmpl::importedStatic<ExplicitSpec_NotImported>() {} // Import explicit instantiation declaration of a non-imported member function // template. +#ifdef GNU +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +#endif extern template __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitDecl_Imported>(); extern template __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitDecl_Imported>(); // Import explicit instantiation definition of a non-imported member function // template. +#ifdef GNU +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +// expected-warning@+3{{'dllimport' attribute ignored on inline function}} +#endif template __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitInst_Imported>(); template __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitInst_Imported>(); // Import specialization of a non-imported member function template. template<> __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void MemFunTmpl::normalDef<ExplicitSpec_Def_Imported>() {} // error on mingw +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<> __declspec(dllimport) inline void MemFunTmpl::normalDef<ExplicitSpec_InlineDef_Imported>() {} -#ifndef MSABI -// expected-error@-3{{dllimport cannot be applied to non-inline function definition}} +#if 1 +// FIXME: This should not be an error when targeting MSVC. (PR21406) +// expected-error@-7{{dllimport cannot be applied to non-inline function definition}} #endif template<> __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitSpec_Imported>(); template<> __declspec(dllimport) void MemFunTmpl::staticDef<ExplicitSpec_Def_Imported>() {} // error on mingw +#ifdef GNU + // expected-warning@+2{{'dllimport' attribute ignored on inline function}} +#endif template<> __declspec(dllimport) inline void MemFunTmpl::staticDef<ExplicitSpec_InlineDef_Imported>() {} -#ifndef MSABI -// expected-error@-3{{dllimport cannot be applied to non-inline function definition}} +#if 1 +// FIXME: This should not be an error when targeting MSVC. (PR21406) +// expected-error@-7{{dllimport cannot be applied to non-inline function definition}} #endif @@ -783,18 +965,27 @@ template<typename T> struct ImportClassTmplMembers { __declspec(dllimport) void normalDecl(); __declspec(dllimport) void normalDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - __declspec(dllimport) void normalInclass() {} __declspec(dllimport) void normalInlineDef(); - __declspec(dllimport) inline void normalInlineDecl(); __declspec(dllimport) virtual void virtualDecl(); __declspec(dllimport) virtual void virtualDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - __declspec(dllimport) virtual void virtualInclass() {} __declspec(dllimport) virtual void virtualInlineDef(); - __declspec(dllimport) virtual inline void virtualInlineDecl(); __declspec(dllimport) static void staticDecl(); __declspec(dllimport) static void staticDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - __declspec(dllimport) static void staticInclass() {} __declspec(dllimport) static void staticInlineDef(); + +#ifdef GNU +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +// expected-warning@+7{{'dllimport' attribute ignored on inline function}} +#endif + __declspec(dllimport) void normalInclass() {} + __declspec(dllimport) inline void normalInlineDecl(); + __declspec(dllimport) virtual void virtualInclass() {} + __declspec(dllimport) virtual inline void virtualInlineDecl(); + __declspec(dllimport) static void staticInclass() {} __declspec(dllimport) static inline void staticInlineDecl(); protected: @@ -817,12 +1008,21 @@ public: // NB: MSVC is inconsistent here and disallows *InlineDef on class templates, // but allows it on classes. We allow both. template<typename T> void ImportClassTmplMembers<T>::normalDef() {} // expected-warning{{'ImportClassTmplMembers::normalDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportClassTmplMembers::normalInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif template<typename T> inline void ImportClassTmplMembers<T>::normalInlineDef() {} template<typename T> void ImportClassTmplMembers<T>::normalInlineDecl() {} template<typename T> void ImportClassTmplMembers<T>::virtualDef() {} // expected-warning{{'ImportClassTmplMembers::virtualDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportClassTmplMembers::virtualInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif template<typename T> inline void ImportClassTmplMembers<T>::virtualInlineDef() {} template<typename T> void ImportClassTmplMembers<T>::virtualInlineDecl() {} template<typename T> void ImportClassTmplMembers<T>::staticDef() {} // expected-warning{{'ImportClassTmplMembers::staticDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} +#ifdef GNU +// expected-warning@+2{{'ImportClassTmplMembers::staticInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif template<typename T> inline void ImportClassTmplMembers<T>::staticInlineDef() {} template<typename T> void ImportClassTmplMembers<T>::staticInlineDecl() {} @@ -835,15 +1035,21 @@ template<typename T> constexpr int ImportClassTmplMembers<T>::ConstexprFieldDef; template<typename T> struct CTMR /*ClassTmplMemberRedecl*/ { void normalDef(); // expected-note{{previous declaration is here}} - void normalInlineDef(); // expected-note{{previous declaration is here}} inline void normalInlineDecl(); // expected-note{{previous declaration is here}} virtual void virtualDef(); // expected-note{{previous declaration is here}} - virtual void virtualInlineDef(); // expected-note{{previous declaration is here}} virtual inline void virtualInlineDecl(); // expected-note{{previous declaration is here}} static void staticDef(); // expected-note{{previous declaration is here}} - static void staticInlineDef(); // expected-note{{previous declaration is here}} static inline void staticInlineDecl(); // expected-note{{previous declaration is here}} +#ifdef MS +// expected-note@+4{{previous declaration is here}} +// expected-note@+4{{previous declaration is here}} +// expected-note@+4{{previous declaration is here}} +#endif + void normalInlineDef(); + virtual void virtualInlineDef(); + static void staticInlineDef(); + static int StaticField; // expected-note{{previous declaration is here}} static const int StaticConstField; // expected-note{{previous declaration is here}} constexpr static int ConstexprField = 1; // expected-note{{previous declaration is here}} @@ -851,17 +1057,24 @@ struct CTMR /*ClassTmplMemberRedecl*/ { template<typename T> __declspec(dllimport) void CTMR<T>::normalDef() {} // expected-error{{redeclaration of 'CTMR::normalDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -template<typename T> __declspec(dllimport) inline void CTMR<T>::normalInlineDef() {} // expected-error{{redeclaration of 'CTMR::normalInlineDef' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void CTMR<T>::normalInlineDecl() {} // expected-error{{redeclaration of 'CTMR::normalInlineDecl' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void CTMR<T>::virtualDef() {} // expected-error{{redeclaration of 'CTMR::virtualDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -template<typename T> __declspec(dllimport) inline void CTMR<T>::virtualInlineDef() {} // expected-error{{redeclaration of 'CTMR::virtualInlineDef' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void CTMR<T>::virtualInlineDecl() {} // expected-error{{redeclaration of 'CTMR::virtualInlineDecl' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void CTMR<T>::staticDef() {} // expected-error{{redeclaration of 'CTMR::staticDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -template<typename T> __declspec(dllimport) inline void CTMR<T>::staticInlineDef() {} // expected-error{{redeclaration of 'CTMR::staticInlineDef' cannot add 'dllimport' attribute}} template<typename T> __declspec(dllimport) void CTMR<T>::staticInlineDecl() {} // expected-error{{redeclaration of 'CTMR::staticInlineDecl' cannot add 'dllimport' attribute}} +#ifdef MS +template<typename T> __declspec(dllimport) inline void CTMR<T>::normalInlineDef() {} // expected-error{{redeclaration of 'CTMR::normalInlineDef' cannot add 'dllimport' attribute}} +template<typename T> __declspec(dllimport) inline void CTMR<T>::virtualInlineDef() {} // expected-error{{redeclaration of 'CTMR::virtualInlineDef' cannot add 'dllimport' attribute}} +template<typename T> __declspec(dllimport) inline void CTMR<T>::staticInlineDef() {} // expected-error{{redeclaration of 'CTMR::staticInlineDef' cannot add 'dllimport' attribute}} +#else +template<typename T> __declspec(dllimport) inline void CTMR<T>::normalInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +template<typename T> __declspec(dllimport) inline void CTMR<T>::virtualInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +template<typename T> __declspec(dllimport) inline void CTMR<T>::staticInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif + template<typename T> __declspec(dllimport) int CTMR<T>::StaticField = 1; // expected-error{{redeclaration of 'CTMR::StaticField' cannot add 'dllimport' attribute}} // expected-warning@-1{{definition of dllimport static field}} // expected-note@-2{{attribute is here}} @@ -882,13 +1095,20 @@ template<typename T> struct ImportClsTmplMemTmpl { template<typename U> __declspec(dllimport) void normalDecl(); template<typename U> __declspec(dllimport) void normalDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - template<typename U> __declspec(dllimport) void normalInclass() {} template<typename U> __declspec(dllimport) void normalInlineDef(); - template<typename U> __declspec(dllimport) inline void normalInlineDecl(); template<typename U> __declspec(dllimport) static void staticDecl(); template<typename U> __declspec(dllimport) static void staticDef(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}} - template<typename U> __declspec(dllimport) static void staticInclass() {} template<typename U> __declspec(dllimport) static void staticInlineDef(); + +#ifdef GNU + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} + // expected-warning@+5{{'dllimport' attribute ignored on inline function}} +#endif + template<typename U> __declspec(dllimport) void normalInclass() {} + template<typename U> __declspec(dllimport) inline void normalInlineDecl(); + template<typename U> __declspec(dllimport) static void staticInclass() {} template<typename U> __declspec(dllimport) static inline void staticInlineDecl(); #if __has_feature(cxx_variable_templates) @@ -904,12 +1124,17 @@ struct ImportClsTmplMemTmpl { }; template<typename T> template<typename U> void ImportClsTmplMemTmpl<T>::normalDef() {} // expected-warning{{'ImportClsTmplMemTmpl::normalDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} -template<typename T> template<typename U> inline void ImportClsTmplMemTmpl<T>::normalInlineDef() {} template<typename T> template<typename U> void ImportClsTmplMemTmpl<T>::normalInlineDecl() {} template<typename T> template<typename U> void ImportClsTmplMemTmpl<T>::staticDef() {} // expected-warning{{'ImportClsTmplMemTmpl::staticDef' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}} -template<typename T> template<typename U> inline void ImportClsTmplMemTmpl<T>::staticInlineDef() {} template<typename T> template<typename U> void ImportClsTmplMemTmpl<T>::staticInlineDecl() {} +#ifdef GNU +// expected-warning@+3{{'ImportClsTmplMemTmpl::normalInlineDef' redeclared inline; 'dllimport' attribute ignored}} +// expected-warning@+3{{'ImportClsTmplMemTmpl::staticInlineDef' redeclared inline; 'dllimport' attribute ignored}} +#endif +template<typename T> template<typename U> inline void ImportClsTmplMemTmpl<T>::normalInlineDef() {} +template<typename T> template<typename U> inline void ImportClsTmplMemTmpl<T>::staticInlineDef() {} + #if __has_feature(cxx_variable_templates) template<typename T> template<typename U> int ImportClsTmplMemTmpl<T>::StaticFieldDef; // expected-warning{{definition of dllimport static field}} template<typename T> template<typename U> const int ImportClsTmplMemTmpl<T>::StaticConstFieldDef = 1; // expected-warning{{definition of dllimport static field}} @@ -921,12 +1146,17 @@ template<typename T> template<typename U> constexpr int ImportClsTmplMemTmpl<T>: template<typename T> struct CTMTR /*ClassTmplMemberTmplRedecl*/ { template<typename U> void normalDef(); // expected-note{{previous declaration is here}} - template<typename U> void normalInlineDef(); // expected-note{{previous declaration is here}} template<typename U> inline void normalInlineDecl(); // expected-note{{previous declaration is here}} template<typename U> static void staticDef(); // expected-note{{previous declaration is here}} - template<typename U> static void staticInlineDef(); // expected-note{{previous declaration is here}} template<typename U> static inline void staticInlineDecl(); // expected-note{{previous declaration is here}} +#ifdef MS + // expected-note@+3{{previous declaration is here}} + // expected-note@+3{{previous declaration is here}} +#endif + template<typename U> void normalInlineDef(); + template<typename U> static void staticInlineDef(); + #if __has_feature(cxx_variable_templates) template<typename U> static int StaticField; // expected-note{{previous declaration is here}} template<typename U> static const int StaticConstField; // expected-note{{previous declaration is here}} @@ -936,13 +1166,19 @@ struct CTMTR /*ClassTmplMemberTmplRedecl*/ { template<typename T> template<typename U> __declspec(dllimport) void CTMTR<T>::normalDef() {} // expected-error{{redeclaration of 'CTMTR::normalDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::normalInlineDef() {} // expected-error{{redeclaration of 'CTMTR::normalInlineDef' cannot add 'dllimport' attribute}} template<typename T> template<typename U> __declspec(dllimport) void CTMTR<T>::normalInlineDecl() {} // expected-error{{redeclaration of 'CTMTR::normalInlineDecl' cannot add 'dllimport' attribute}} template<typename T> template<typename U> __declspec(dllimport) void CTMTR<T>::staticDef() {} // expected-error{{redeclaration of 'CTMTR::staticDef' cannot add 'dllimport' attribute}} // expected-error@-1{{dllimport cannot be applied to non-inline function definition}} -template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::staticInlineDef() {} // expected-error{{redeclaration of 'CTMTR::staticInlineDef' cannot add 'dllimport' attribute}} template<typename T> template<typename U> __declspec(dllimport) void CTMTR<T>::staticInlineDecl() {} // expected-error{{redeclaration of 'CTMTR::staticInlineDecl' cannot add 'dllimport' attribute}} +#ifdef MS +template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::normalInlineDef() {} // expected-error{{redeclaration of 'CTMTR::normalInlineDef' cannot add 'dllimport' attribute}} +template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::staticInlineDef() {} // expected-error{{redeclaration of 'CTMTR::staticInlineDef' cannot add 'dllimport' attribute}} +#else +template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::normalInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +template<typename T> template<typename U> __declspec(dllimport) inline void CTMTR<T>::staticInlineDef() {} // expected-warning{{'dllimport' attribute ignored on inline function}} +#endif + #if __has_feature(cxx_variable_templates) template<typename T> template<typename U> __declspec(dllimport) int CTMTR<T>::StaticField = 1; // expected-error{{redeclaration of 'CTMTR::StaticField' cannot add 'dllimport' attribute}} // expected-warning@-1{{definition of dllimport static field}} @@ -961,6 +1197,10 @@ template<typename T> template<typename U> __declspec(dllimport) constexpr int CT // Classes //===----------------------------------------------------------------------===// +namespace { + struct __declspec(dllimport) AnonymousClass {}; // expected-error{{(anonymous namespace)::AnonymousClass' must have external linkage when declared 'dllimport'}} +} + class __declspec(dllimport) ClassDecl; class __declspec(dllimport) ClassDef { }; @@ -984,7 +1224,7 @@ class __declspec(dllimport) ImportClassWithDllMember { // expected-error@+4{{attribute 'dllimport' cannot be applied to member of 'dllexport' class}} // expected-error@+4{{attribute 'dllexport' cannot be applied to member of 'dllexport' class}} #endif -class __declspec(dllexport) ExportClassWithDllMember { +template <typename T> class __declspec(dllexport) ExportClassWithDllMember { void __declspec(dllimport) foo(); void __declspec(dllexport) bar(); }; diff --git a/test/SemaCXX/enable_if.cpp b/test/SemaCXX/enable_if.cpp index e9dc24254f20..99545e09820e 100644 --- a/test/SemaCXX/enable_if.cpp +++ b/test/SemaCXX/enable_if.cpp @@ -77,3 +77,44 @@ void test() { typedep(1); typedep(n); // expected-note{{in instantiation of function template specialization 'typedep<Nothing>' requested here}} } + +template <typename T> class C { + void f() __attribute__((enable_if(T::expr == 0, ""))) {} + void g() { f(); } +}; + +int fn3(bool b) __attribute__((enable_if(b, ""))); +template <class T> void test3() { + fn3(sizeof(T) == 1); +} + +// FIXME: issue an error (without instantiation) because ::h(T()) is not +// convertible to bool, because return types aren't overloadable. +void h(int); +template <typename T> void outer() { + void local_function() __attribute__((enable_if(::h(T()), ""))); + local_function(); +}; + +namespace PR20988 { + struct Integer { + Integer(int); + }; + + int fn1(const Integer &) __attribute__((enable_if(true, ""))); + template <class T> void test1() { + int &expr = T::expr(); + fn1(expr); + } + + int fn2(const Integer &) __attribute__((enable_if(false, ""))); // expected-note{{candidate disabled}} + template <class T> void test2() { + int &expr = T::expr(); + fn2(expr); // expected-error{{no matching function for call to 'fn2'}} + } + + int fn3(bool b) __attribute__((enable_if(b, ""))); + template <class T> void test3() { + fn3(sizeof(T) == 1); + } +} diff --git a/test/SemaCXX/enum-scoped.cpp b/test/SemaCXX/enum-scoped.cpp index 1eed2281e935..909802335e46 100644 --- a/test/SemaCXX/enum-scoped.cpp +++ b/test/SemaCXX/enum-scoped.cpp @@ -301,3 +301,11 @@ namespace PR18044 { using E::a; // ok! E b = a; } + +namespace test11 { + enum class E { a }; + typedef E E2; + E2 f1() { return E::a; } + + bool f() { return !f1(); } // expected-error {{invalid argument type 'E2' (aka 'test11::E') to unary expression}} +} diff --git a/test/SemaCXX/exceptions.cpp b/test/SemaCXX/exceptions.cpp index c2ca9f952b22..9646a9c3b31a 100644 --- a/test/SemaCXX/exceptions.cpp +++ b/test/SemaCXX/exceptions.cpp @@ -35,37 +35,37 @@ void throws() { void jumps() { l1: goto l5; - goto l4; // expected-error {{goto into protected scope}} - goto l3; // expected-error {{goto into protected scope}} - goto l2; // expected-error {{goto into protected scope}} + goto l4; // expected-error {{cannot jump}} + goto l3; // expected-error {{cannot jump}} + goto l2; // expected-error {{cannot jump}} goto l1; try { // expected-note 4 {{jump bypasses initialization of try block}} l2: goto l5; - goto l4; // expected-error {{goto into protected scope}} - goto l3; // expected-error {{goto into protected scope}} + goto l4; // expected-error {{cannot jump}} + goto l3; // expected-error {{cannot jump}} goto l2; goto l1; } catch(int) { // expected-note 4 {{jump bypasses initialization of catch block}} l3: goto l5; - goto l4; // expected-error {{goto into protected scope}} + goto l4; // expected-error {{cannot jump}} goto l3; - goto l2; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{cannot jump}} goto l1; } catch(...) { // expected-note 4 {{jump bypasses initialization of catch block}} l4: goto l5; goto l4; - goto l3; // expected-error {{goto into protected scope}} - goto l2; // expected-error {{goto into protected scope}} + goto l3; // expected-error {{cannot jump}} + goto l2; // expected-error {{cannot jump}} goto l1; } l5: goto l5; - goto l4; // expected-error {{goto into protected scope}} - goto l3; // expected-error {{goto into protected scope}} - goto l2; // expected-error {{goto into protected scope}} + goto l4; // expected-error {{cannot jump}} + goto l3; // expected-error {{cannot jump}} + goto l2; // expected-error {{cannot jump}} goto l1; } diff --git a/test/SemaCXX/explicit.cpp b/test/SemaCXX/explicit.cpp index aa28bd85af46..155141c058c4 100644 --- a/test/SemaCXX/explicit.cpp +++ b/test/SemaCXX/explicit.cpp @@ -86,7 +86,7 @@ namespace Conversion { // Y is an aggregate, so aggregate-initialization is performed and the // conversion function is not considered. const Y y10{z}; // expected-error {{excess elements}} - const Y& y11{z}; // expected-error {{no viable conversion from 'Z' to 'const Y'}} + const Y& y11{z}; // expected-error {{excess elements}} expected-note {{in initialization of temporary of type 'const Y'}} const int& y12{z}; // X is not an aggregate, so constructors are considered. diff --git a/test/SemaCXX/flexible-array-test.cpp b/test/SemaCXX/flexible-array-test.cpp index e58f19a62eca..2d74fa52452e 100644 --- a/test/SemaCXX/flexible-array-test.cpp +++ b/test/SemaCXX/flexible-array-test.cpp @@ -14,6 +14,12 @@ void QMap<Key, T>::insert(const Key &, const T &avalue) v = avalue; } +struct Rec { + union { // expected-warning-re {{variable sized type '{{.*}}' not at the end of a struct or class is a GNU extension}} + int u0[]; + }; + int x; +} rec; struct inotify_event { diff --git a/test/SemaCXX/for-range-examples.cpp b/test/SemaCXX/for-range-examples.cpp index 2f777fb46df0..d07331c51e29 100644 --- a/test/SemaCXX/for-range-examples.cpp +++ b/test/SemaCXX/for-range-examples.cpp @@ -214,17 +214,19 @@ namespace test6 { namespace test7 { void f() { int arr[5], b; - for (a : arr) {} // expected-warning {{extension}} - // FIXME: Give a -Wshadow for this by default? - for (b : arr) {} // expected-warning {{extension}} - for (arr : arr) {} // expected-warning {{extension}} - for (c alignas(8) : arr) { // expected-warning {{extension}} + for (a : arr) {} // expected-error {{requires type for loop variable}} + // FIXME: Give a different error in this case? + for (b : arr) {} // expected-error {{requires type for loop variable}} + for (arr : arr) {} // expected-error {{requires type for loop variable}} + for (c alignas(8) : arr) { // expected-error {{requires type for loop variable}} static_assert(alignof(c) == 8, ""); // expected-warning {{extension}} } - // FIXME: We should reject this, but don't, because we only check the - // attribute before we deduce the 'auto' type. - for (d alignas(1) : arr) {} // expected-warning {{extension}} - for (e [[deprecated]] : arr) { e = 0; } // expected-warning {{deprecated}} expected-note {{here}} expected-warning {{extension}} + // FIXME: The fix-it hint here is not sufficient to fix the error. + // We fail to diagnose that d is underaligned for its type, because + // we check the alignment attribute before we perform the auto + // deduction. + for (d alignas(1) : arr) {} // expected-error {{requires type for loop variable}} + for (e [[deprecated]] : arr) { e = 0; } // expected-warning {{deprecated}} expected-note {{here}} expected-error {{requires type for loop variable}} } } diff --git a/test/SemaCXX/friend.cpp b/test/SemaCXX/friend.cpp index 03589101e1b8..55aa069803bf 100644 --- a/test/SemaCXX/friend.cpp +++ b/test/SemaCXX/friend.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 friend class A; // expected-error {{'friend' used outside of class}} void f() { friend class A; } // expected-error {{'friend' used outside of class}} @@ -296,3 +296,56 @@ namespace test11 { friend class __attribute__((visibility("hidden"), noreturn)) B; // expected-warning {{'noreturn' attribute only applies to functions and methods}} }; } + +namespace pr21851 { +// PR21851 was a problem where we assumed that when the friend function redecl +// lookup found a C++ method, it would necessarily have a qualifier. Below we +// have some test cases where unqualified lookup finds C++ methods without using +// qualifiers. Unfortunately, we can't exercise the case of an access check +// failure because nested classes always have access to the members of outer +// classes. + +void friend_own_method() { + class A { + void m() {} + friend void m(); + }; +} + +void friend_enclosing_method() { + class A; + class C { + int p; + friend class A; + }; + class A { + void enclosing_friend() { + (void)b->p; + (void)c->p; + } + class B { + void b(A *a) { + (void)a->c->p; + } + int p; + friend void enclosing_friend(); + }; + B *b; + C *c; + }; +} + +static auto friend_file_func() { + extern void file_scope_friend(); + class A { + int p; + friend void file_scope_friend(); + }; + return A(); +} + +void file_scope_friend() { + auto a = friend_file_func(); + (void)a.p; +} +} diff --git a/test/SemaCXX/goto.cpp b/test/SemaCXX/goto.cpp index 042ec3cd8035..2d37ea9099a2 100644 --- a/test/SemaCXX/goto.cpp +++ b/test/SemaCXX/goto.cpp @@ -109,7 +109,7 @@ namespace PR10620 { ~S() {} }; void g(const S& s) { - goto done; // expected-error {{goto into protected scope}} + goto done; // expected-error {{cannot jump}} const S s2(s); // expected-note {{jump bypasses variable initialization}} done: ; @@ -119,7 +119,7 @@ namespace PR10620 { namespace test12 { struct A { A(); A(const A&); ~A(); }; void test(A a) { // expected-note {{jump enters lifetime of block}} FIXME: weird location - goto lbl; // expected-error {{goto into protected scope}} + goto lbl; // expected-error {{cannot jump}} (void) ^{ (void) a; }; lbl: return; diff --git a/test/SemaCXX/implicit-exception-spec.cpp b/test/SemaCXX/implicit-exception-spec.cpp index e26f985f0d0a..ff3d685d912e 100644 --- a/test/SemaCXX/implicit-exception-spec.cpp +++ b/test/SemaCXX/implicit-exception-spec.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s +// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall -Wno-unused-local-typedefs %s template<bool b> struct ExceptionIf { static int f(); }; template<> struct ExceptionIf<false> { typedef int f; }; @@ -17,42 +17,43 @@ namespace InClassInitializers { // is false. bool ThrowSomething() noexcept(false); struct ConstExpr { - bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{cannot be used by non-static data member initializer}} + bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{cannot use defaulted default constructor of 'ConstExpr' within the class outside of member functions}} + // expected-note@-1 {{implicit default constructor for 'InClassInitializers::ConstExpr' first required here}} }; - // We can use it now. - bool w = noexcept(ConstExpr()); // Much more obviously broken: we can't parse the initializer without already // knowing whether it produces a noexcept expression. struct TemplateArg { - int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{cannot be used by non-static data member initializer}} + int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{cannot use defaulted default constructor of 'TemplateArg' within the class outside of member functions}} + // expected-note@-1 {{implicit default constructor for 'InClassInitializers::TemplateArg' first required here}} }; - bool x = noexcept(TemplateArg()); // And within a nested class. - struct Nested { // expected-error {{cannot be used by non-static data member initializer}} + struct Nested { // expected-note {{implicit default constructor for 'InClassInitializers::Nested::Inner' first required here}} struct Inner { + // expected-error@+1 {{cannot use defaulted default constructor of 'Inner' within 'Nested' outside of member functions}} int n = ExceptionIf<noexcept(Nested())>::f(); // expected-note {{implicit default constructor for 'InClassInitializers::Nested' first required here}} } inner; }; - struct Nested2 { + struct Nested2 { // expected-error {{implicit default constructor for 'InClassInitializers::Nested2' must explicitly initialize the member 'inner' which does not have a default constructor}} struct Inner; - int n = Inner().n; // expected-error {{cannot be used by non-static data member initializer}} - struct Inner { + int n = Inner().n; // expected-note {{implicit default constructor for 'InClassInitializers::Nested2::Inner' first required here}} + struct Inner { // expected-note {{declared here}} + // expected-error@+1 {{cannot use defaulted default constructor of 'Inner' within 'Nested2' outside of member functions}} int n = ExceptionIf<noexcept(Nested2())>::f(); - } inner; + // expected-note@-1 {{implicit default constructor for 'InClassInitializers::Nested2' first required here}} + } inner; // expected-note {{member is declared here}} }; } namespace ExceptionSpecification { - // A type is permitted to be used in a dynamic exception specification when it - // is still being defined, but isn't complete within such an exception - // specification. - struct Nested { // expected-note {{not complete}} + // FIXME: This diagnostic is quite useless; we should indicate whose + // exception specification we were looking for and why. + struct Nested { struct T { - T() noexcept(!noexcept(Nested())); // expected-error{{incomplete type}} - } t; + T() noexcept(!noexcept(Nested())); + } t; // expected-error{{exception specification is not available until end of class definition}} }; } diff --git a/test/SemaCXX/issue547.cpp b/test/SemaCXX/issue547.cpp index bfec6e080ba5..2a9dd13adf4e 100644 --- a/test/SemaCXX/issue547.cpp +++ b/test/SemaCXX/issue547.cpp @@ -27,32 +27,32 @@ struct classify_function<R(Args...) const volatile> { }; template<typename R, typename ...Args> -struct classify_function<R(Args......)> { +struct classify_function<R(Args..., ...)> { static const unsigned value = 5; }; template<typename R, typename ...Args> -struct classify_function<R(Args......) const> { +struct classify_function<R(Args..., ...) const> { static const unsigned value = 6; }; template<typename R, typename ...Args> -struct classify_function<R(Args......) volatile> { +struct classify_function<R(Args..., ...) volatile> { static const unsigned value = 7; }; template<typename R, typename ...Args> -struct classify_function<R(Args......) const volatile> { +struct classify_function<R(Args..., ...) const volatile> { static const unsigned value = 8; }; template<typename R, typename ...Args> -struct classify_function<R(Args......) &&> { +struct classify_function<R(Args..., ...) &&> { static const unsigned value = 9; }; template<typename R, typename ...Args> -struct classify_function<R(Args......) const &> { +struct classify_function<R(Args..., ...) const &> { static const unsigned value = 10; }; diff --git a/test/SemaCXX/lambda-expressions.cpp b/test/SemaCXX/lambda-expressions.cpp index 9a53e4604f76..cad322ab52fe 100644 --- a/test/SemaCXX/lambda-expressions.cpp +++ b/test/SemaCXX/lambda-expressions.cpp @@ -258,9 +258,7 @@ namespace TypeDeduction { void f() { const S s {}; S &&t = [&] { return s; } (); -#if __cplusplus <= 201103L - // expected-error@-2 {{drops qualifiers}} -#else +#if __cplusplus > 201103L S &&u = [&] () -> auto { return s; } (); #endif } @@ -363,3 +361,79 @@ namespace PR18473 { void PR19249() { auto x = [&x]{}; // expected-error {{cannot appear in its own init}} } + +namespace PR20731 { +template <class L, int X = sizeof(L)> +void Job(L l); + +template <typename... Args> +void Logger(Args &&... args) { + auto len = Invalid_Function((args)...); + // expected-error@-1 {{use of undeclared identifier 'Invalid_Function'}} + Job([len]() {}); +} + +void GetMethod() { + Logger(); + // expected-note@-1 {{in instantiation of function template specialization 'PR20731::Logger<>' requested here}} +} + +template <typename T> +struct A { + T t; + // expected-error@-1 {{field has incomplete type 'void'}} +}; + +template <typename F> +void g(F f) { + auto a = A<decltype(f())>{}; + // expected-note@-1 {{in instantiation of template class 'PR20731::A<void>' requested here}} + auto xf = [a, f]() {}; + int x = sizeof(xf); +}; +void f() { + g([] {}); + // expected-note-re@-1 {{in instantiation of function template specialization 'PR20731::g<(lambda at {{.*}}>' requested here}} +} + +template <class _Rp> struct function { + template <class _Fp> + function(_Fp) { + static_assert(sizeof(_Fp) > 0, "Type must be complete."); + } +}; + +template <typename T> void p(T t) { + auto l = some_undefined_function(t); + // expected-error@-1 {{use of undeclared identifier 'some_undefined_function'}} + function<void()>(([l]() {})); +} +void q() { p(0); } +// expected-note@-1 {{in instantiation of function template specialization 'PR20731::p<int>' requested here}} +} + +namespace lambda_in_default_mem_init { + template<typename T> void f() { + struct S { int n = []{ return 0; }(); }; + } + template void f<int>(); + + template<typename T> void g() { + struct S { int n = [](int n){ return n; }(0); }; + } + template void g<int>(); +} + +namespace error_in_transform_prototype { + template<class T> + void f(T t) { + // expected-error@+2 {{type 'int' cannot be used prior to '::' because it has no members}} + // expected-error@+1 {{no member named 'ns' in 'error_in_transform_prototype::S'}} + auto x = [](typename T::ns::type &k) {}; + } + class S {}; + void foo() { + f(5); // expected-note {{requested here}} + f(S()); // expected-note {{requested here}} + } +} diff --git a/test/SemaCXX/cxx0x-initializer-stdinitializerlist-system-header.cpp b/test/SemaCXX/libstdcxx_explicit_init_list_hack.cpp index 774745777c17..774745777c17 100644 --- a/test/SemaCXX/cxx0x-initializer-stdinitializerlist-system-header.cpp +++ b/test/SemaCXX/libstdcxx_explicit_init_list_hack.cpp diff --git a/test/SemaCXX/libstdcxx_is_pod_hack.cpp b/test/SemaCXX/libstdcxx_is_pod_hack.cpp index 1ba3721c8c2e..8d187124f013 100644 --- a/test/SemaCXX/libstdcxx_is_pod_hack.cpp +++ b/test/SemaCXX/libstdcxx_is_pod_hack.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only %s +// RUN: %clang_cc1 -fsyntax-only -verify %s // This is a test for an egregious hack in Clang that works around // issues with GCC's evolution. libstdc++ 4.2.x uses __is_pod as an @@ -7,7 +7,7 @@ // a keyword *unless* it is introduced following the struct keyword. template<typename T> -struct __is_pod { +struct __is_pod { // expected-warning {{keyword '__is_pod' will be made available as an identifier}} __is_pod() {} }; @@ -15,7 +15,7 @@ __is_pod<int> ipi; // Ditto for __is_same. template<typename T> -struct __is_same { +struct __is_same { // expected-warning {{keyword '__is_same' will be made available as an identifier}} }; __is_same<int> isi; @@ -24,7 +24,7 @@ __is_same<int> isi; // trait in Embarcadero's compiler but is used as an identifier in // libstdc++. struct test_is_signed { - static const bool __is_signed = true; + static const bool __is_signed = true; // expected-warning {{keyword '__is_signed' will be made available as an identifier}} }; bool check_signed = test_is_signed::__is_signed; @@ -36,6 +36,13 @@ void foo() { bool b = __is_pod(int); must_be_true<__is_pod(int)> mbt; } + +// expected-warning@+1 {{declaration does not declare anything}} +struct // expected-error {{declaration of anonymous struct must be a definition}} +#pragma pack(pop) + S { +}; + #if !__has_feature(is_pod) # error __is_pod should still be available. #endif diff --git a/test/SemaCXX/libstdcxx_pair_swap_hack.cpp b/test/SemaCXX/libstdcxx_pair_swap_hack.cpp new file mode 100644 index 000000000000..02431e02e48d --- /dev/null +++ b/test/SemaCXX/libstdcxx_pair_swap_hack.cpp @@ -0,0 +1,74 @@ +// This is a test for an egregious hack in Clang that works around +// an issue with GCC's <utility> implementation. std::pair::swap +// has an exception specification that makes an unqualified call to +// swap. This is invalid, because it ends up calling itself with +// the wrong number of arguments. +// +// The same problem afflicts a bunch of other class templates. Those +// affected are array, pair, priority_queue, stack, and queue. + +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=pair +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=priority_queue +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=stack +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=queue + +// MSVC's standard library uses a very similar pattern that relies on delayed +// parsing of exception specifications. +// +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array -DMSVC + +#ifdef BE_THE_HEADER + +#pragma GCC system_header +namespace std { + template<typename T> void swap(T &, T &); + template<typename T> void do_swap(T &a, T &b) noexcept(noexcept(swap(a, b))) { + swap(a, b); + } + + template<typename A, typename B> struct CLASS { +#ifdef MSVC + void swap(CLASS &other) noexcept(noexcept(do_swap(member, other.member))); +#endif + A member; +#ifndef MSVC + void swap(CLASS &other) noexcept(noexcept(swap(member, other.member))); +#endif + }; + +// template<typename T> void do_swap(T &, T &); +// template<typename A> struct vector { +// void swap(vector &other) noexcept(noexcept(do_swap(member, other.member))); +// A member; +// }; +} + +#else + +#define BE_THE_HEADER +#include __FILE__ + +struct X {}; +using PX = std::CLASS<X, X>; +using PI = std::CLASS<int, int>; +void swap(X &, X &) noexcept; +PX px; +PI pi; + +static_assert(noexcept(px.swap(px)), ""); +static_assert(!noexcept(pi.swap(pi)), ""); + +namespace sad { + template<typename T> void swap(T &, T &); + + template<typename A, typename B> struct CLASS { + void swap(CLASS &other) noexcept(noexcept(swap(*this, other))); // expected-error {{too many arguments}} expected-note {{declared here}} + }; + + CLASS<int, int> pi; + + static_assert(!noexcept(pi.swap(pi)), ""); // expected-note {{in instantiation of}} +} + +#endif diff --git a/test/SemaCXX/member-init.cpp b/test/SemaCXX/member-init.cpp index d8a00b3b1e24..b3ee30b456ec 100644 --- a/test/SemaCXX/member-init.cpp +++ b/test/SemaCXX/member-init.cpp @@ -14,7 +14,10 @@ public: bool b(); int k; struct Recurse { - int &n = b() ? Recurse().n : k; // expected-error {{defaulted default constructor of 'Recurse' cannot be used by non-static data member initializer which appears before end of class definition}} + int &n = // expected-error {{cannot use defaulted default constructor of 'Recurse' within the class outside of member functions because 'n' has an initializer}} + b() ? + Recurse().n : // expected-note {{implicit default constructor for 'Recurse' first required here}} + k; }; struct UnknownBound { @@ -110,3 +113,82 @@ namespace PR18560 { struct Y { int b = f(); }; } + +namespace template_valid { +// Valid, we shouldn't build a CXXDefaultInitExpr until A's ctor definition. +struct A { + A(); + template <typename T> + struct B { int m1 = sizeof(A) + sizeof(T); }; + B<int> m2; +}; +A::A() {} +} + +namespace template_default_ctor { +struct A { + template <typename T> + struct B { + int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'B' within 'A' outside of member functions because 'm1' has an initializer}} + }; + // expected-note@+1 {{implicit default constructor for 'template_default_ctor::A::B<int>' first required here}} + enum { NOE = noexcept(B<int>()) }; +}; +} + +namespace default_ctor { +struct A { + struct B { + int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'B' within 'A' outside of member functions because 'm1' has an initializer}} + }; + // expected-note@+1 {{implicit default constructor for 'default_ctor::A::B' first required here}} + enum { NOE = noexcept(B()) }; +}; +} + +namespace member_template { +struct A { + template <typename T> + struct B { + struct C { + int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'C' within 'A' outside of member functions because 'm1' has an initializer}} + }; + template <typename U> + struct D { + int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'D' within 'A' outside of member functions because 'm1' has an initializer}} + }; + }; + enum { + // expected-note@+1 {{implicit default constructor for 'member_template::A::B<int>::C' first required here}} + NOE1 = noexcept(B<int>::C()), + // expected-note@+1 {{implicit default constructor for 'member_template::A::B<int>::D<int>' first required here}} + NOE2 = noexcept(B<int>::D<int>()) + }; +}; +} + +namespace explicit_instantiation { +template<typename T> struct X { + X(); // expected-note {{in instantiation of default member initializer 'explicit_instantiation::X<float>::n' requested here}} + int n = T::error; // expected-error {{type 'float' cannot be used prior to '::' because it has no members}} +}; +template struct X<int>; // ok +template<typename T> X<T>::X() {} +template struct X<float>; // expected-note {{in instantiation of member function 'explicit_instantiation::X<float>::X' requested here}} +} + +namespace local_class { +template<typename T> void f() { + struct X { // expected-note {{in instantiation of default member initializer 'local_class::f()::X::n' requested here}} + int n = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} + }; +} +void g() { f<int>(); } // expected-note {{in instantiation of function template specialization 'local_class::f<int>' requested here}} +} + +namespace PR22056 { +template <int N> +struct S { + int x[3] = {[N] = 3}; +}; +} diff --git a/test/SemaCXX/member-pointer-ms.cpp b/test/SemaCXX/member-pointer-ms.cpp index e7c4ae9409e0..39cf601dc956 100644 --- a/test/SemaCXX/member-pointer-ms.cpp +++ b/test/SemaCXX/member-pointer-ms.cpp @@ -249,6 +249,25 @@ struct __virtual_inheritance D; struct D : virtual B {}; } #ifdef VMB + +namespace PR20017 { +template <typename T> +struct A { + int T::*f(); +}; + +struct B; + +auto a = &A<B>::f; + +struct B {}; + +void q() { + A<B> b; + (b.*a)(); +} +} + #pragma pointers_to_members(full_generality, multiple_inheritance) struct TrulySingleInheritance; static_assert(sizeof(int TrulySingleInheritance::*) == kMultipleDataSize, ""); diff --git a/test/SemaCXX/namespace-alias.cpp b/test/SemaCXX/namespace-alias.cpp index e18b58b4d441..63615ecbd352 100644 --- a/test/SemaCXX/namespace-alias.cpp +++ b/test/SemaCXX/namespace-alias.cpp @@ -35,12 +35,12 @@ namespace H { namespace A2 { } // These all point to A1. - namespace B = A1; // expected-note {{previous definition is here}} + namespace B = A1; namespace B = A1; namespace C = B; - namespace B = C; + namespace B = C; // expected-note {{previously defined as an alias for 'A1'}} - namespace B = A2; // expected-error {{redefinition of 'B' as different kind of symbol}} + namespace B = A2; // expected-error {{redefinition of 'B' as an alias for a different namespace}} } namespace I { diff --git a/test/SemaCXX/nonnull.cpp b/test/SemaCXX/nonnull.cpp index 9ff6d115bd16..97b54553427d 100644 --- a/test/SemaCXX/nonnull.cpp +++ b/test/SemaCXX/nonnull.cpp @@ -13,3 +13,8 @@ struct TS { } }; +namespace Template { + template<typename T> __attribute__((nonnull)) void f(T t); + void g() { f((void*)0); } // expected-warning {{null passed to a callee that requires a non-null argument}} + void h() { f(0); } +} diff --git a/test/SemaCXX/nullptr.cpp b/test/SemaCXX/nullptr.cpp index 28798a4f8ce8..7d765b482c73 100644 --- a/test/SemaCXX/nullptr.cpp +++ b/test/SemaCXX/nullptr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding -Wno-null-conversion %s #include <stdint.h> typedef decltype(nullptr) nullptr_t; diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp index feb7c716ff00..369e9eb802a5 100644 --- a/test/SemaCXX/overloaded-operator.cpp +++ b/test/SemaCXX/overloaded-operator.cpp @@ -519,3 +519,15 @@ namespace ConversionVersusTemplateOrdering { int x = a; int y = b; } + +namespace NoADLForMemberOnlyOperators { + template<typename T> struct A { typename T::error e; }; // expected-error {{type 'char' cannot be used prior to '::'}} + template<typename T> struct B { int n; }; + + void f(B<A<void> > b1, B<A<int> > b2, B<A<char> > b3) { + b1 = b1; // ok, does not instantiate A<void>. + (void)b1->n; // expected-error {{is not a pointer}} + b2[3]; // expected-error {{does not provide a subscript}} + b3 / 0; // expected-note {{in instantiation of}} expected-error {{invalid operands to}} + } +} diff --git a/test/SemaCXX/override-in-system-header.cpp b/test/SemaCXX/override-in-system-header.cpp new file mode 100644 index 000000000000..689585e0cf12 --- /dev/null +++ b/test/SemaCXX/override-in-system-header.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -std=c++11 -isystem %S/Inputs %s -verify +// expected-no-diagnostics +// rdar://18295240 + +#include <override-system-header.h> + +struct A +{ + virtual void x(); + END_COM_MAP; + IFACEMETHOD(Initialize)(); +}; + +struct B : A +{ + virtual void x() override; + END_COM_MAP; + IFACEMETHOD(Initialize)(); +}; diff --git a/test/SemaCXX/pragma-optimize.cpp b/test/SemaCXX/pragma-optimize.cpp index 0f03b81f5fff..48a15460fc96 100644 --- a/test/SemaCXX/pragma-optimize.cpp +++ b/test/SemaCXX/pragma-optimize.cpp @@ -1,4 +1,6 @@ -// RUN: %clang_cc1 -x c++ -std=c++11 -triple x86_64-unknown-linux -emit-llvm -O2 < %s | FileCheck %s +// RUN: %clang_cc1 -I %S/Inputs -x c++ -std=c++11 -triple x86_64-unknown-linux -emit-llvm -O2 < %s | FileCheck %s +// RUN: %clang_cc1 -I %S/Inputs -x c++ -std=c++11 -triple x86_64-unknown-linux -emit-llvm -Os < %s | FileCheck %s +// RUN: %clang_cc1 -I %S/Inputs -x c++ -std=c++11 -triple x86_64-unknown-linux -emit-llvm -Oz < %s | FileCheck %s #pragma clang optimize off @@ -55,6 +57,13 @@ int __attribute__((always_inline)) baz(int z) { } // CHECK-DAG: @_Z3bazi{{.*}} [[ATTRBAZ:#[0-9]+]] +// This function definition will not be decorated with `optnone` because the +// attribute would conflict with `minsize`. +int __attribute__((minsize)) bax(int z) { + return foo(z, 2); +} +// CHECK-DAG: @_Z3baxi{{.*}} [[ATTRBAX:#[0-9]+]] + #pragma clang optimize on // The function "int wombat(int param)" created by the macro is not @@ -96,18 +105,60 @@ int container3 (int par) { // CHECK-DAG: @_Z6thriceIiET_S0_{{.*}} [[ATTRTHRICEINT:#[0-9]+]] +// Test that we can re-open and re-close an "off" region after the first one, +// and that this works as expected. + +#pragma clang optimize off + +int another_optnone(int x) { + return x << 1; +} +// CHECK-DAG: @_Z15another_optnonei{{.*}} [[ATTRANOTHEROPTNONE:#[0-9]+]] + +#pragma clang optimize on + +int another_normal(int x) { + return x << 2; +} +// CHECK-DAG: @_Z14another_normali{{.*}} [[ATTRANOTHERNORMAL:#[0-9]+]] + + +// Test that we can re-open an "off" region by including a header with the +// pragma and that this works as expected (i.e. the off region "falls through" +// the end of the header into this file). + +#include <header-with-pragma-optimize-off.h> + +int yet_another_optnone(int x) { + return x << 3; +} +// CHECK-DAG: @_Z19yet_another_optnonei{{.*}} [[ATTRYETANOTHEROPTNONE:#[0-9]+]] + +#pragma clang optimize on + +int yet_another_normal(int x) { + return x << 4; +} +// CHECK-DAG: @_Z18yet_another_normali{{.*}} [[ATTRYETANOTHERNORMAL:#[0-9]+]] + + // Check for both noinline and optnone on each function that should have them. // CHECK-DAG: attributes [[ATTRBAR]] = { {{.*}}noinline{{.*}}optnone{{.*}} } // CHECK-DAG: attributes [[ATTRCREATED]] = { {{.*}}noinline{{.*}}optnone{{.*}} } // CHECK-DAG: attributes [[ATTRMETHOD]] = { {{.*}}noinline{{.*}}optnone{{.*}} } // CHECK-DAG: attributes [[ATTRTHRICEFLOAT]] = { {{.*}}noinline{{.*}}optnone{{.*}} } +// CHECK-DAG: attributes [[ATTRANOTHEROPTNONE]] = { {{.*}}noinline{{.*}}optnone{{.*}} } +// CHECK-DAG: attributes [[ATTRYETANOTHEROPTNONE]] = { {{.*}}noinline{{.*}}optnone{{.*}} } // Check that the other functions do NOT have optnone. // CHECK-DAG-NOT: attributes [[ATTRFOO]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRBAZ]] = { {{.*}}optnone{{.*}} } +// CHECK-DAG-NOT: attributes [[ATTRBAX]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRWOMBAT]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRCONTAINER]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRTWICE]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRCONTAINER2]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRCONTAINER3]] = { {{.*}}optnone{{.*}} } // CHECK-DAG-NOT: attributes [[ATTRTHRICEINT]] = { {{.*}}optnone{{.*}} } +// CHECK-DAG-NOT: attributes [[ATTRANOTHERNORMAL]] = { {{.*}}optnone{{.*}} } +// CHECK-DAG-NOT: attributes [[ATTRYETANOTHERNORMAL]] = { {{.*}}optnone{{.*}} } diff --git a/test/SemaCXX/predefined-expr.cpp b/test/SemaCXX/predefined-expr.cpp index 257d44c60069..f4a155da6678 100644 --- a/test/SemaCXX/predefined-expr.cpp +++ b/test/SemaCXX/predefined-expr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++1y -fblocks -fsyntax-only -verify %s +// RUN: %clang_cc1 -x c++ -std=c++1y -fblocks -fsyntax-only -triple %itanium_abi_triple -verify %s // PR16946 // expected-no-diagnostics @@ -33,10 +33,9 @@ int baz() { (); ^{ - // FIXME: This is obviously wrong. - static_assert(sizeof(__func__) == 1, "__baz_block_invoke"); - static_assert(sizeof(__FUNCTION__) == 1, "__baz_block_invoke"); - static_assert(sizeof(__PRETTY_FUNCTION__) == 1, "__baz_block_invoke"); + static_assert(sizeof(__func__) == 27, "___Z3bazIiEiv_block_invoke"); + static_assert(sizeof(__FUNCTION__) == 27, "___Z3bazIiEiv_block_invoke"); + static_assert(sizeof(__PRETTY_FUNCTION__) == 27, "___Z3bazIiEiv_block_invoke"); } (); @@ -65,10 +64,9 @@ int main() { (); ^{ - // FIXME: This is obviously wrong. - static_assert(sizeof(__func__) == 1, "__main_block_invoke"); - static_assert(sizeof(__FUNCTION__) == 1, "__main_block_invoke"); - static_assert(sizeof(__PRETTY_FUNCTION__) == 1, "__main_block_invoke"); + static_assert(sizeof(__func__) == 20, "__main_block_invoke"); + static_assert(sizeof(__FUNCTION__) == 20, "__main_block_invoke"); + static_assert(sizeof(__PRETTY_FUNCTION__) == 20, "__main_block_invoke"); } (); diff --git a/test/SemaCXX/return-noreturn.cpp b/test/SemaCXX/return-noreturn.cpp index 531dc23995d2..cdd96e6a9ec4 100644 --- a/test/SemaCXX/return-noreturn.cpp +++ b/test/SemaCXX/return-noreturn.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default -// RUN: %clang_cc1 %s -fsyntax-only -std=c++11 -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default +// RUN: %clang_cc1 %s -fsyntax-only -fcxx-exceptions -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default +// RUN: %clang_cc1 %s -fsyntax-only -fcxx-exceptions -std=c++11 -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default // A destructor may be marked noreturn and should still influence the CFG. void pr6884_abort() __attribute__((noreturn)); @@ -143,7 +143,84 @@ template <PR9412_MatchType type> int PR9412_t() { } // expected-warning {{control reaches end of non-void function}} void PR9412_f() { - PR9412_t<PR9412_Exact>(); // expected-note {{in instantiation of function template specialization 'PR9412_t<0>' requested here}} + PR9412_t<PR9412_Exact>(); // expected-note {{in instantiation of function template specialization 'PR9412_t<PR9412_MatchType::PR9412_Exact>' requested here}} +} + +struct NoReturn { + ~NoReturn() __attribute__((noreturn)); + operator bool() const; +}; +struct Return { + ~Return(); + operator bool() const; +}; + +int testTernaryUnconditionalNoreturn() { + true ? NoReturn() : NoReturn(); +} + +int testTernaryStaticallyConditionalNoretrunOnTrue() { + true ? NoReturn() : Return(); +} + +int testTernaryStaticallyConditionalRetrunOnTrue() { + true ? Return() : NoReturn(); +} // expected-warning {{control reaches end of non-void function}} + +int testTernaryStaticallyConditionalNoretrunOnFalse() { + false ? Return() : NoReturn(); +} + +int testTernaryStaticallyConditionalRetrunOnFalse() { + false ? NoReturn() : Return(); +} // expected-warning {{control reaches end of non-void function}} + +int testTernaryConditionalNoreturnTrueBranch(bool value) { + value ? (NoReturn() || NoReturn()) : Return(); +} // expected-warning {{control may reach end of non-void function}} + +int testTernaryConditionalNoreturnFalseBranch(bool value) { + value ? Return() : (NoReturn() || NoReturn()); +} // expected-warning {{control may reach end of non-void function}} + +int testConditionallyExecutedComplexTernaryTrueBranch(bool value) { + value || (true ? NoReturn() : true); +} // expected-warning {{control may reach end of non-void function}} + +int testConditionallyExecutedComplexTernaryFalseBranch(bool value) { + value || (false ? true : NoReturn()); +} // expected-warning {{control may reach end of non-void function}} + +int testStaticallyExecutedLogicalOrBranch() { + false || NoReturn(); +} + +int testStaticallyExecutedLogicalAndBranch() { + true && NoReturn(); +} + +int testStaticallySkippedLogicalOrBranch() { + true || NoReturn(); +} // expected-warning {{control reaches end of non-void function}} + +int testStaticallySkppedLogicalAndBranch() { + false && NoReturn(); +} // expected-warning {{control reaches end of non-void function}} + +int testConditionallyExecutedComplexLogicalBranch(bool value) { + value || (true && NoReturn()); +} // expected-warning {{control may reach end of non-void function}} + +int testConditionallyExecutedComplexLogicalBranch2(bool value) { + (true && value) || (true && NoReturn()); +} // expected-warning {{control may reach end of non-void function}} + +int testConditionallyExecutedComplexLogicalBranch3(bool value) { + (false && (Return() || true)) || (true && NoReturn()); +} + +int testConditionallyExecutedComplexLogicalBranch4(bool value) { + false || ((Return() || true) && (true && NoReturn())); } #if __cplusplus >= 201103L @@ -168,3 +245,20 @@ namespace LambdaVsTemporaryDtor { } // ok, initialization of lambda does not return } #endif + +// Ensure that function-try-blocks also check for return values properly. +int functionTryBlock1(int s) try { + return 0; +} catch (...) { +} // expected-warning {{control may reach end of non-void function}} + +int functionTryBlock2(int s) try { +} catch (...) { + return 0; +} // expected-warning {{control may reach end of non-void function}} + +int functionTryBlock3(int s) try { + return 0; +} catch (...) { + return 0; +} // ok, both paths return. diff --git a/test/SemaCXX/return.cpp b/test/SemaCXX/return.cpp index 98dbd51f5806..8c1664516a71 100644 --- a/test/SemaCXX/return.cpp +++ b/test/SemaCXX/return.cpp @@ -112,3 +112,11 @@ namespace ctor_returns_void { ~S() { return f(); } // expected-error {{destructor '~S' must not return void expression}} }; } + +void cxx_unresolved_expr() { + // The use of an undeclared variable tricks clang into building a + // CXXUnresolvedConstructExpr, and the missing ')' gives it an invalid source + // location for its rparen. Check that emitting a diag on the range of the + // expr doesn't assert. + return int(undeclared, 4; // expected-error {{expected ')'}} expected-note{{to match this '('}} expected-error {{void function 'cxx_unresolved_expr' should not return a value}} expected-error {{use of undeclared identifier 'undeclared'}} +} diff --git a/test/SemaCXX/runtimediag-ppe.cpp b/test/SemaCXX/runtimediag-ppe.cpp index 0e8451b472e7..2788963b6c1b 100644 --- a/test/SemaCXX/runtimediag-ppe.cpp +++ b/test/SemaCXX/runtimediag-ppe.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-unused-value %s // Make sure diagnostics that we don't print based on runtime control // flow are delayed correctly in cases where we can't immediately tell whether diff --git a/test/SemaCXX/scope-check.cpp b/test/SemaCXX/scope-check.cpp index dc15dc8b3e60..ac700999c284 100644 --- a/test/SemaCXX/scope-check.cpp +++ b/test/SemaCXX/scope-check.cpp @@ -32,7 +32,7 @@ namespace test1 { int f(bool b) { if (b) - goto foo; // expected-error {{goto into protected scope}} + goto foo; // expected-error {{cannot jump}} C c; // expected-note {{jump bypasses variable initialization}} foo: return 1; @@ -79,7 +79,7 @@ namespace test4 { C c0; - goto *ip; // expected-error {{indirect goto might cross protected scopes}} + goto *ip; // expected-error {{cannot jump}} C c1; // expected-note {{jump bypasses variable initialization}} lbl1: // expected-note {{possible target of indirect goto}} return 0; @@ -103,7 +103,7 @@ namespace test5 { if (ip[1]) { D d; // expected-note {{jump exits scope of variable with non-trivial destructor}} ip += 2; - goto *ip; // expected-error {{indirect goto might cross protected scopes}} + goto *ip; // expected-error {{cannot jump}} } return 1; } @@ -153,13 +153,13 @@ namespace test8 { switch (c) { case 0: int x = 56; // expected-note {{jump bypasses variable initialization}} - case 1: // expected-error {{switch case is in protected scope}} + case 1: // expected-error {{cannot jump}} x = 10; } } void test2() { - goto l2; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{cannot jump}} l1: int x = 5; // expected-note {{jump bypasses variable initialization}} l2: x++; } @@ -208,7 +208,7 @@ namespace PR10462 { namespace test10 { int test() { static void *ps[] = { &&a0 }; - goto *&&a0; // expected-error {{goto into protected scope}} + goto *&&a0; // expected-error {{cannot jump}} int a = 3; // expected-note {{jump bypasses variable initialization}} a0: return 0; @@ -225,7 +225,7 @@ namespace test11 { static void *ips[] = { &&l0 }; l0: // expected-note {{possible target of indirect goto}} C c0 = 42; // expected-note {{jump exits scope of variable with non-trivial destructor}} - goto *ip; // expected-error {{indirect goto might cross protected scopes}} + goto *ip; // expected-error {{cannot jump}} } } @@ -240,7 +240,7 @@ namespace test12 { l0: // expected-note {{possible target of indirect goto}} const C &c1 = 42; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}} const C &c2 = c0; - goto *ip; // expected-error {{indirect goto might cross protected scopes}} + goto *ip; // expected-error {{cannot jump}} } } @@ -254,7 +254,7 @@ namespace test13 { static void *ips[] = { &&l0 }; l0: // expected-note {{possible target of indirect goto}} const int &c1 = C(1).i; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}} - goto *ip; // expected-error {{indirect goto might cross protected scopes}} + goto *ip; // expected-error {{cannot jump}} } } @@ -276,21 +276,21 @@ namespace test14 { // PR14225 namespace test15 { void f1() try { - goto x; // expected-error {{goto into protected scope}} + goto x; // expected-error {{cannot jump}} } catch(...) { // expected-note {{jump bypasses initialization of catch block}} x: ; } void f2() try { // expected-note {{jump bypasses initialization of try block}} x: ; } catch(...) { - goto x; // expected-error {{goto into protected scope}} + goto x; // expected-error {{cannot jump}} } } namespace test16 { struct S { int n; }; int f() { - goto x; // expected-error {{goto into protected scope}} + goto x; // expected-error {{cannot jump}} const S &s = S(); // expected-note {{jump bypasses variable initialization}} x: return s.n; } @@ -300,7 +300,7 @@ x: return s.n; namespace test17 { struct S { int get(); private: int n; }; int f() { - goto x; // expected-error {{goto into protected scope}} + goto x; // expected-error {{cannot jump}} S s = {}; // expected-note {{jump bypasses variable initialization}} x: return s.get(); } @@ -321,7 +321,7 @@ namespace test18 { void *p = &&x; x: // expected-note {{possible target of indirect goto}} B b = { 0, A() }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}} - goto *p; // expected-error {{indirect goto might cross protected scopes}} + goto *p; // expected-error {{cannot jump}} } } @@ -342,7 +342,7 @@ namespace test19 { A a; x: // expected-note {{possible target of indirect goto}} std::initializer_list<A> il = { a }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}} - goto *p; // expected-error {{indirect goto might cross protected scopes}} + goto *p; // expected-error {{cannot jump}} } } @@ -370,14 +370,14 @@ namespace test20 { a, { A() } // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}} }; - goto *p; // expected-error {{indirect goto might cross protected scopes}} + goto *p; // expected-error {{cannot jump}} } } #endif namespace test21 { template<typename T> void f() { - goto x; // expected-error {{protected scope}} + goto x; // expected-error {{cannot jump}} T t; // expected-note {{bypasses}} x: return; } @@ -428,7 +428,7 @@ namespace test_recovery { void test(nexist, int c) { // expected-error {{}} nexist_fn(); // expected-error {{}} goto nexist_label; // expected-error {{use of undeclared label}} - goto a0; // expected-error {{goto into protected scope}} + goto a0; // expected-error {{cannot jump}} int a = 0; // expected-note {{jump bypasses variable initialization}} a0:; @@ -436,7 +436,7 @@ namespace test_recovery { case $: // expected-error {{}} case 0: int x = 56; // expected-note {{jump bypasses variable initialization}} - case 1: // expected-error {{switch case is in protected scope}} + case 1: // expected-error {{cannot jump}} x = 10; } } diff --git a/test/SemaCXX/statements.cpp b/test/SemaCXX/statements.cpp index 6d04c84a6752..15b0b50ddc75 100644 --- a/test/SemaCXX/statements.cpp +++ b/test/SemaCXX/statements.cpp @@ -10,7 +10,7 @@ struct X { }; void test2() { - goto later; // expected-error {{goto into protected scope}} + goto later; // expected-error {{cannot jump}} X x; // expected-note {{jump bypasses variable initialization}} later: ; @@ -20,3 +20,20 @@ namespace PR6536 { struct A {}; void a() { goto out; A x; out: return; } } + +void test3() { + __asm__ ("":"+r" (test3)); // expected-error{{invalid lvalue in asm output}} +} + +void test4(); // expected-note{{possible target for call}} +void test4(int) { // expected-note{{possible target for call}} + // expected-error@+1{{overloaded function could not be resolved}} + __asm__ ("":"+r" (test4)); // expected-error{{invalid lvalue in asm output}} +} +void test5() { + char buf[1]; + __asm__ ("":"+r" (buf)); +} + +struct MMX_t {}; +void test6() { __asm__("" : "=m"(*(MMX_t *)0)); } diff --git a/test/SemaCXX/string-plus-int.cpp b/test/SemaCXX/string-plus-int.cpp index 5752f8f96631..fe9c71949698 100644 --- a/test/SemaCXX/string-plus-int.cpp +++ b/test/SemaCXX/string-plus-int.cpp @@ -64,3 +64,8 @@ void f(int index) { consume(A B + sizeof(A) - 1); } +template <typename T> +void PR21848() { + (void)(sizeof(T) + ""); // expected-warning {{to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} +} +template void PR21848<int>(); // expected-note {{in instantiation of function template specialization 'PR21848<int>' requested here}} diff --git a/test/SemaCXX/struct-class-redecl.cpp b/test/SemaCXX/struct-class-redecl.cpp index e1b95ba8d63c..706ec5688ba5 100644 --- a/test/SemaCXX/struct-class-redecl.cpp +++ b/test/SemaCXX/struct-class-redecl.cpp @@ -7,6 +7,12 @@ union X { int x; float y; }; // expected-error{{use of 'X' with tag type that do template<typename T> struct Y; // expected-note{{did you mean class here?}} template<class U> class Y { }; // expected-warning{{previously declared}} +template <typename> +struct Z { // expected-note{{previous definition is here}} + struct Z { // expected-error{{nested redefinition of 'Z'}} + }; +}; + class A; class A; // expected-note{{previous use is here}} struct A; // expected-warning{{struct 'A' was previously declared as a class}} diff --git a/test/SemaCXX/trailing-return-0x.cpp b/test/SemaCXX/trailing-return-0x.cpp index cf5e659660eb..c6b22c54be0c 100644 --- a/test/SemaCXX/trailing-return-0x.cpp +++ b/test/SemaCXX/trailing-return-0x.cpp @@ -17,8 +17,8 @@ auto f() -> int return 0; } -auto g(); // expected-error{{return without trailing return type; deduced return types are a C++1y extension}} -decltype(auto) g2(); // expected-warning{{extension}} expected-error-re{{{{^}}deduced return types are a C++1y extension}} +auto g(); // expected-error{{return without trailing return type; deduced return types are a C++14 extension}} +decltype(auto) g2(); // expected-warning{{extension}} expected-error-re{{{{^}}deduced return types are a C++14 extension}} auto badness = g2(); int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}} @@ -75,14 +75,14 @@ only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f); namespace PR12053 { template <typename T> auto f1(T t) -> decltype(f1(t)) {} // expected-note{{candidate template ignored}} - + void test_f1() { f1(0); // expected-error{{no matching function for call to 'f1'}} } - + template <typename T> auto f2(T t) -> decltype(f2(&t)) {} // expected-note{{candidate template ignored}} - + void test_f2() { f2(0); // expected-error{{no matching function for call to 'f2'}} } diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp index 3b94ef0951eb..4833c14b30be 100644 --- a/test/SemaCXX/type-traits.cpp +++ b/test/SemaCXX/type-traits.cpp @@ -146,6 +146,10 @@ struct ThreeArgCtor { ThreeArgCtor(int*, char*, int); }; +struct VariadicCtor { + template<typename...T> VariadicCtor(T...); +}; + void is_pod() { { int arr[T(__is_pod(int))]; } @@ -1968,6 +1972,10 @@ void constructible_checks() { // PR19178 { int arr[F(__is_constructible(Abstract))]; } { int arr[F(__is_nothrow_constructible(Abstract))]; } + + // PR20228 + { int arr[T(__is_constructible(VariadicCtor, + int, int, int, int, int, int, int, int, int))]; } } // Instantiation of __is_trivially_constructible diff --git a/test/SemaCXX/typeid.cpp b/test/SemaCXX/typeid.cpp index d3a2a28deb8b..48fcce0b4924 100644 --- a/test/SemaCXX/typeid.cpp +++ b/test/SemaCXX/typeid.cpp @@ -21,3 +21,9 @@ void g1(X &x) { (void)typeid(X&); // expected-error{{'typeid' of incomplete type 'X'}} (void)typeid(x); // expected-error{{'typeid' of incomplete type 'X'}} } + +void h(int i) { + char V[i]; + typeid(V); // expected-error{{'typeid' of variably modified type 'char [i]'}} + typeid(char [i]); // expected-error{{'typeid' of variably modified type 'char [i]'}} +} diff --git a/test/SemaCXX/typo-correction-delayed.cpp b/test/SemaCXX/typo-correction-delayed.cpp new file mode 100644 index 000000000000..e028faad2510 --- /dev/null +++ b/test/SemaCXX/typo-correction-delayed.cpp @@ -0,0 +1,159 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s + +struct A {}; +struct B {}; +struct D { + A fizbin; // expected-note 2 {{declared here}} + A foobar; // expected-note 2 {{declared here}} + B roxbin; // expected-note 2 {{declared here}} + B toobad; // expected-note 2 {{declared here}} + void BooHoo(); + void FoxBox(); +}; + +void something(A, B); +void test() { + D obj; + something(obj.fixbin, // expected-error {{did you mean 'fizbin'?}} + obj.toobat); // expected-error {{did you mean 'toobad'?}} + something(obj.toobat, // expected-error {{did you mean 'foobar'?}} + obj.fixbin); // expected-error {{did you mean 'roxbin'?}} + something(obj.fixbin, // expected-error {{did you mean 'fizbin'?}} + obj.fixbin); // expected-error {{did you mean 'roxbin'?}} + something(obj.toobat, // expected-error {{did you mean 'foobar'?}} + obj.toobat); // expected-error {{did you mean 'toobad'?}} + // Both members could be corrected to methods, but that isn't valid. + something(obj.boohoo, // expected-error-re {{no member named 'boohoo' in 'D'{{$}}}} + obj.foxbox); // expected-error-re {{no member named 'foxbox' in 'D'{{$}}}} + // The first argument has a usable correction but the second doesn't. + something(obj.boobar, // expected-error-re {{no member named 'boobar' in 'D'{{$}}}} + obj.foxbox); // expected-error-re {{no member named 'foxbox' in 'D'{{$}}}} +} + +// Ensure the delayed typo correction does the right thing when trying to +// recover using a seemingly-valid correction for which a valid expression to +// replace the TypoExpr cannot be created (but which does have a second +// correction candidate that would be a valid and usable correction). +class Foo { +public: + template <> void testIt(); // expected-error {{no function template matches}} + void textIt(); // expected-note {{'textIt' declared here}} +}; +void testMemberExpr(Foo *f) { + f->TestIt(); // expected-error {{no member named 'TestIt' in 'Foo'; did you mean 'textIt'?}} +} + +void callee(double, double); +void testNoCandidates() { + callee(xxxxxx, // expected-error-re {{use of undeclared identifier 'xxxxxx'{{$}}}} + zzzzzz); // expected-error-re {{use of undeclared identifier 'zzzzzz'{{$}}}} +} + +class string {}; +struct Item { + void Nest(); + string text(); + Item* next(); // expected-note {{'next' declared here}} +}; +void testExprFilter(Item *i) { + Item *j; + j = i->Next(); // expected-error {{no member named 'Next' in 'Item'; did you mean 'next'?}} +} + +// Test that initializer expressions are handled correctly and that the type +// being initialized is taken into account when choosing a correction. +namespace initializerCorrections { +struct Node { + string text() const; + // Node* Next() is not implemented yet +}; +void f(Node *node) { + // text is only an edit distance of 1 from Next, but would trigger type + // conversion errors if used in this initialization expression. + Node *next = node->Next(); // expected-error-re {{no member named 'Next' in 'initializerCorrections::Node'{{$}}}} +} + +struct LinkedNode { + LinkedNode* next(); // expected-note {{'next' declared here}} + string text() const; +}; +void f(LinkedNode *node) { + // text and next are equidistant from Next, but only one results in a valid + // initialization expression. + LinkedNode *next = node->Next(); // expected-error {{no member named 'Next' in 'initializerCorrections::LinkedNode'; did you mean 'next'?}} +} + +struct NestedNode { + NestedNode* Nest(); + NestedNode* next(); + string text() const; +}; +void f(NestedNode *node) { + // There are two equidistant, usable corrections for Next: next and Nest + NestedNode *next = node->Next(); // expected-error-re {{no member named 'Next' in 'initializerCorrections::NestedNode'{{$}}}} +} +} + +namespace PR21669 { +void f(int *i) { + // Check that arguments to a builtin with custom type checking are corrected + // properly, since calls to such builtins bypass much of the normal code path + // for building and checking the call. + __atomic_load(i, i, something_something); // expected-error-re {{use of undeclared identifier 'something_something'{{$}}}} +} +} + +const int DefaultArg = 9; // expected-note {{'DefaultArg' declared here}} +template <int I = defaultArg> struct S {}; // expected-error {{use of undeclared identifier 'defaultArg'; did you mean 'DefaultArg'?}} +S<1> s; + +namespace foo {} +void test_paren_suffix() { + foo::bar({5, 6}); // expected-error-re {{no member named 'bar' in namespace 'foo'{{$}}}} \ + // expected-error {{expected expression}} +} + +const int kNum = 10; // expected-note {{'kNum' declared here}} +class SomeClass { + int Kind; +public: + explicit SomeClass() : Kind(kSum) {} // expected-error {{use of undeclared identifier 'kSum'; did you mean 'kNum'?}} +}; + +// There used to be an issue with typo resolution inside overloads. +struct AssertionResult { ~AssertionResult(); }; +AssertionResult Overload(const char *a); +AssertionResult Overload(int a); +void UseOverload() { + // expected-note@+1 {{'result' declared here}} + const char *result; + // expected-error@+1 {{use of undeclared identifier 'resulta'; did you mean 'result'?}} + Overload(resulta); +} + +namespace PR21925 { +struct X { + int get() { return 7; } // expected-note {{'get' declared here}} +}; +void test() { + X variable; // expected-note {{'variable' declared here}} + + // expected-error@+2 {{use of undeclared identifier 'variableX'; did you mean 'variable'?}} + // expected-error@+1 {{no member named 'getX' in 'PR21925::X'; did you mean 'get'?}} + int x = variableX.getX(); +} +} + +namespace PR21905 { +int (*a) () = (void)Z; // expected-error-re {{use of undeclared identifier 'Z'{{$}}}} +} + +namespace PR21947 { +int blue; // expected-note {{'blue' declared here}} +__typeof blur y; // expected-error {{use of undeclared identifier 'blur'; did you mean 'blue'?}} +} + +namespace PR22092 { +a = b ? : 0; // expected-error {{C++ requires a type specifier for all declarations}} \ + // expected-error-re {{use of undeclared identifier 'b'{{$}}}} +} diff --git a/test/SemaCXX/typo-correction-pt2.cpp b/test/SemaCXX/typo-correction-pt2.cpp deleted file mode 100644 index 88a7073f9946..000000000000 --- a/test/SemaCXX/typo-correction-pt2.cpp +++ /dev/null @@ -1,302 +0,0 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s -// -// FIXME: This file is overflow from test/SemaCXX/typo-correction.cpp due to a -// hard-coded limit of 20 different typo corrections Sema::CorrectTypo will -// attempt within a single file (which is to avoid having very broken files take -// minutes to finally be rejected by the parser). - -namespace PR12951 { -// If there are two corrections that have the same identifier and edit distance -// and only differ by their namespaces, don't suggest either as a correction -// since both are equally likely corrections. -namespace foobar { struct Thing {}; } -namespace bazquux { struct Thing {}; } -void f() { Thing t; } // expected-error{{unknown type name 'Thing'}} -} - -namespace bogus_keyword_suggestion { -void test() { - status = "OK"; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} - return status; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} - } -} - -namespace PR13387 { -struct A { - void CreateFoo(float, float); - void CreateBar(float, float); -}; -struct B : A { - using A::CreateFoo; - void CreateFoo(int, int); -}; -void f(B &x) { - x.Createfoo(0,0); // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}} -} -} - -struct DataStruct {void foo();}; -struct T { - DataStruct data_struct; - void f(); -}; -// should be void T::f(); -void f() { - data_struct->foo(); // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}} -} - -namespace PR12287 { -class zif { - void nab(int); -}; -void nab(); // expected-note{{'::PR12287::nab' declared here}} -void zif::nab(int) { - nab(); // expected-error{{too few arguments to function call, expected 1, have 0; did you mean '::PR12287::nab'?}} -} -} - -namespace TemplateFunction { -template <class T> -void A(T) { } // expected-note {{'::TemplateFunction::A' declared here}} - -template <class T> -void B(T) { } // expected-note {{'::TemplateFunction::B' declared here}} - -class Foo { - public: - void A(int, int) {} - void B() {} -}; - -void test(Foo F, int num) { - F.A(num); // expected-error {{too few arguments to function call, expected 2, have 1; did you mean '::TemplateFunction::A'?}} - F.B(num); // expected-error {{too many arguments to function call, expected 0, have 1; did you mean '::TemplateFunction::B'?}} -} -} -namespace using_suggestion_val_dropped_specifier { -void FFF() {} // expected-note {{'::using_suggestion_val_dropped_specifier::FFF' declared here}} -namespace N { } -using N::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_specifier::N'; did you mean '::using_suggestion_val_dropped_specifier::FFF'?}} -} - -namespace class_member_typo_corrections { -class Outer { -public: - class Inner {}; // expected-note {{'Outer::Inner' declared here}} - Inner MyMethod(Inner arg); -}; - -Inner Outer::MyMethod(Inner arg) { // expected-error {{unknown type name 'Inner'; did you mean 'Outer::Inner'?}} - return Inner(); -} - -class Result { -public: - enum ResultType { - ENTITY, // expected-note {{'Result::ENTITY' declared here}} - PREDICATE, // expected-note {{'Result::PREDICATE' declared here}} - LITERAL // expected-note {{'Result::LITERAL' declared here}} - }; - - ResultType type(); -}; - -void test() { - Result result_cell; - switch (result_cell.type()) { - case ENTITY: // expected-error {{use of undeclared identifier 'ENTITY'; did you mean 'Result::ENTITY'?}} - case LITERAL: // expected-error {{use of undeclared identifier 'LITERAL'; did you mean 'Result::LITERAL'?}} - case PREDICAT: // expected-error {{use of undeclared identifier 'PREDICAT'; did you mean 'Result::PREDICATE'?}} - break; - } -} - -class Figure { - enum ResultType { - SQUARE, - TRIANGLE, - CIRCLE - }; - -public: - ResultType type(); -}; - -void testAccess() { - Figure obj; - switch (obj.type()) { // expected-warning {{enumeration values 'SQUARE', 'TRIANGLE', and 'CIRCLE' not handled in switch}} - case SQUARE: // expected-error-re {{use of undeclared identifier 'SQUARE'{{$}}}} - case TRIANGLE: // expected-error-re {{use of undeclared identifier 'TRIANGLE'{{$}}}} - case CIRCE: // expected-error-re {{use of undeclared identifier 'CIRCE'{{$}}}} - break; - } -} -} - -long readline(const char *, char *, unsigned long); -void assign_to_unknown_var() { - deadline_ = 1; // expected-error-re {{use of undeclared identifier 'deadline_'{{$}}}} -} - -namespace no_ns_before_dot { -namespace re2 {} -void test() { - req.set_check(false); // expected-error-re {{use of undeclared identifier 'req'{{$}}}} -} -} - -namespace PR17394 { - class A { - protected: - long zzzzzzzzzz; - }; - class B : private A {}; - B zzzzzzzzzy<>; // expected-error {{expected ';' after top level declarator}}{} -} - -namespace correct_fields_in_member_funcs { -struct S { - int my_member; // expected-note {{'my_member' declared here}} - void f() { my_menber = 1; } // expected-error {{use of undeclared identifier 'my_menber'; did you mean 'my_member'?}} -}; -} - -namespace PR17019 { - template<class F> - struct evil { - evil(F de) { // expected-note {{'de' declared here}} - de_; // expected-error {{use of undeclared identifier 'de_'; did you mean 'de'?}} \ - // expected-warning {{expression result unused}} - } - ~evil() { - de_->bar() // expected-error {{use of undeclared identifier 'de_'}} - } - }; - - void meow() { - evil<int> Q(0); // expected-note {{in instantiation of member function}} - } -} - -namespace fix_class_name_qualifier { -class MessageHeaders {}; -class MessageUtils { - public: - static void ParseMessageHeaders(int, int); // expected-note {{'MessageUtils::ParseMessageHeaders' declared here}} -}; - -void test() { - // No, we didn't mean to call MessageHeaders::MessageHeaders. - MessageHeaders::ParseMessageHeaders(5, 4); // expected-error {{no member named 'ParseMessageHeaders' in 'fix_class_name_qualifier::MessageHeaders'; did you mean 'MessageUtils::ParseMessageHeaders'?}} -} -} - -namespace PR18213 { // expected-note {{'PR18213' declared here}} -struct WrapperInfo { - int i; -}; - -template <typename T> struct Wrappable { - static WrapperInfo kWrapperInfo; -}; - -// Note the space before "::PR18213" is intended and needed, as it highlights -// the actual typo, which is the leading "::". -// TODO: Suggest removing the "::" from "::PR18213" (the right correction) -// instead of incorrectly suggesting dropping "PR18213::WrapperInfo::". -template <> -PR18213::WrapperInfo ::PR18213::Wrappable<int>::kWrapperInfo = { 0 }; // expected-error {{no member named 'PR18213' in 'PR18213::WrapperInfo'; did you mean simply 'PR18213'?}} \ - // expected-error {{C++ requires a type specifier for all declarations}} -} - -namespace PR18651 { -struct { - int x; -} a, b; - -int y = x; // expected-error-re {{use of undeclared identifier 'x'{{$}}}} -} - -namespace PR18685 { -template <class C, int I, int J> -class SetVector { - public: - SetVector() {} -}; - -template <class C, int I> -class SmallSetVector : public SetVector<C, I, 8> {}; - -class foo {}; -SmallSetVector<foo*, 2> fooSet; -} - -PR18685::BitVector Map; // expected-error-re {{no type named 'BitVector' in namespace 'PR18685'{{$}}}} - -namespace shadowed_template { -template <typename T> class Fizbin {}; // expected-note {{'::shadowed_template::Fizbin' declared here}} -class Baz { - int Fizbin(); - // TODO: Teach the parser to recover from the typo correction instead of - // continuing to treat the template name as an implicit-int declaration. - Fizbin<int> qux; // expected-error {{unknown type name 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}} \ - // expected-error {{expected member name or ';' after declaration specifiers}} -}; -} - -namespace PR18852 { -void func() { - struct foo { - void bar() {} - }; - bar(); // expected-error-re {{use of undeclared identifier 'bar'{{$}}}} -} - -class Thread { - public: - void Start(); - static void Stop(); // expected-note {{'Thread::Stop' declared here}} -}; - -class Manager { - public: - void Start(int); // expected-note {{'Start' declared here}} - void Stop(int); // expected-note {{'Stop' declared here}} -}; - -void test(Manager *m) { - // Don't suggest Thread::Start as a correction just because it has the same - // (unqualified) name and accepts the right number of args; this is a method - // call on an object in an unrelated class. - m->Start(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} - m->Stop(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} - Stop(); // expected-error {{use of undeclared identifier 'Stop'; did you mean 'Thread::Stop'?}} -} - -} - -namespace std { -class bernoulli_distribution { - public: - double p() const; -}; -} -void test() { - // Make sure that typo correction doesn't suggest changing 'p' to - // 'std::bernoulli_distribution::p' as that is most likely wrong. - if (p) // expected-error-re {{use of undeclared identifier 'p'{{$}}}} - return; -} - -namespace PR19681 { - struct TypoA {}; - struct TypoB { - void test(); - private: - template<typename T> void private_memfn(T); // expected-note{{declared here}} - }; - void TypoB::test() { - // FIXME: should suggest 'PR19681::TypoB::private_memfn' instead of '::PR19681::TypoB::private_memfn' - (void)static_cast<void(TypoB::*)(int)>(&TypoA::private_memfn); // expected-error{{no member named 'private_memfn' in 'PR19681::TypoA'; did you mean '::PR19681::TypoB::private_memfn'?}} - } -} diff --git a/test/SemaCXX/typo-correction.cpp b/test/SemaCXX/typo-correction.cpp index e8160b066de4..324900150c7f 100644 --- a/test/SemaCXX/typo-correction.cpp +++ b/test/SemaCXX/typo-correction.cpp @@ -1,8 +1,9 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s -// -// WARNING: Do not add more typo correction test cases to this file lest you run -// afoul the hard-coded limit (escape hatch) of 20 different typos whose -// correction was attempted by Sema::CorrectTypo +// RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions %s + +namespace PR21817{ +int a(-rsing[2]); // expected-error {{undeclared identifier 'rsing'; did you mean 'using'?}} + // expected-error@-1 {{expected expression}} +} struct errc { int v_; @@ -97,7 +98,7 @@ unknown_type_test::stream_out out; // expected-error{{no type named 'stream_out' // Demonstrate a case where using only the cached value returns the wrong thing // when the cached value was the result of a previous callback object that only // accepts a subset of the current callback object. -namespace { +namespace cache_invalidation_test { using namespace unknown_type_test; void bar(long i); void before_caching_classname() { @@ -209,11 +210,12 @@ namespace PR13051 { }; void foo(); // expected-note{{'foo' declared here}} - void g(void(*)()); - void g(bool(S<int>::*)() const); + void g(void(*)()); // expected-note{{candidate function not viable}} + void g(bool(S<int>::*)() const); // expected-note{{candidate function not viable}} void test() { - g(&S<int>::tempalte f<int>); // expected-error{{did you mean 'template'?}} + g(&S<int>::tempalte f<int>); // expected-error{{did you mean 'template'?}} \ + // expected-error{{no matching function for call to 'g'}} g(&S<int>::opeartor bool); // expected-error{{did you mean 'operator'?}} g(&S<int>::foo); // expected-error{{no member named 'foo' in 'PR13051::S<int>'; did you mean simply 'foo'?}} } @@ -247,7 +249,7 @@ namespace b6956809_test1 { struct S1 { void method(A*); // no note here - void method(B*); + void method(B*); // expected-note{{'method' declared here}} }; void test1() { @@ -258,15 +260,15 @@ namespace b6956809_test1 { struct S2 { S2(); - void method(A*) const; // expected-note{{candidate function not viable}} + void method(A*) const; private: - void method(B*); // expected-note{{candidate function not viable}} + void method(B*); }; void test2() { B b; const S2 s; - s.methodd(&b); // expected-error{{no member named 'methodd' in 'b6956809_test1::S2'; did you mean 'method'}} expected-error{{no matching member function for call to 'method'}} + s.methodd(&b); // expected-error-re{{no member named 'methodd' in 'b6956809_test1::S2'{{$}}}} } } @@ -274,7 +276,7 @@ namespace b6956809_test2 { template<typename T> struct Err { typename T::error n; }; // expected-error{{type 'void *' cannot be used prior to '::' because it has no members}} struct S { template<typename T> typename Err<T>::type method(T); // expected-note{{in instantiation of template class 'b6956809_test2::Err<void *>' requested here}} - template<typename T> int method(T *); + template<typename T> int method(T *); // expected-note{{'method' declared here}} }; void test() { @@ -283,13 +285,352 @@ namespace b6956809_test2 { } } -// This test should have one correction, followed by an error without a -// suggestion due to exceeding the maximum number of typos for which correction -// is attempted. -namespace CorrectTypo_has_reached_its_limit { -int flibberdy(); // expected-note{{'flibberdy' declared here}} -int no_correction() { - return hibberdy() + // expected-error{{use of undeclared identifier 'hibberdy'; did you mean 'flibberdy'?}} - gibberdy(); // expected-error-re{{use of undeclared identifier 'gibberdy'{{$}}}} +namespace PR12951 { +// If there are two corrections that have the same identifier and edit distance +// and only differ by their namespaces, don't suggest either as a correction +// since both are equally likely corrections. +namespace foobar { struct Thing {}; } +namespace bazquux { struct Thing {}; } +void f() { Thing t; } // expected-error{{unknown type name 'Thing'}} +} + +namespace bogus_keyword_suggestion { +void test() { + status = "OK"; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} + return status; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} + } +} + +namespace PR13387 { +struct A { + void CreateFoo(float, float); + void CreateBar(float, float); +}; +struct B : A { + using A::CreateFoo; + void CreateFoo(int, int); // expected-note {{'CreateFoo' declared here}} +}; +void f(B &x) { + x.Createfoo(0,0); // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}} +} +} + +struct DataStruct {void foo();}; +struct T { + DataStruct data_struct; + void f(); +}; +// should be void T::f(); +void f() { + data_struct->foo(); // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}} +} + +namespace PR12287 { +class zif { + void nab(int); +}; +void nab(); // expected-note{{'::PR12287::nab' declared here}} +void zif::nab(int) { + nab(); // expected-error{{too few arguments to function call, expected 1, have 0; did you mean '::PR12287::nab'?}} +} +} + +namespace TemplateFunction { +template <class T> +void A(T) { } // expected-note {{'::TemplateFunction::A' declared here}} + +template <class T> +void B(T) { } // expected-note {{'::TemplateFunction::B' declared here}} + +class Foo { + public: + void A(int, int) {} + void B() {} +}; + +void test(Foo F, int num) { + F.A(num); // expected-error {{too few arguments to function call, expected 2, have 1; did you mean '::TemplateFunction::A'?}} + F.B(num); // expected-error {{too many arguments to function call, expected 0, have 1; did you mean '::TemplateFunction::B'?}} +} +} +namespace using_suggestion_val_dropped_specifier { +void FFF() {} // expected-note {{'::using_suggestion_val_dropped_specifier::FFF' declared here}} +namespace N { } +using N::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_specifier::N'; did you mean '::using_suggestion_val_dropped_specifier::FFF'?}} +} + +namespace class_member_typo_corrections { +class Outer { +public: + class Inner {}; // expected-note {{'Outer::Inner' declared here}} + Inner MyMethod(Inner arg); +}; + +Inner Outer::MyMethod(Inner arg) { // expected-error {{unknown type name 'Inner'; did you mean 'Outer::Inner'?}} + return Inner(); +} + +class Result { +public: + enum ResultType { + ENTITY, // expected-note {{'Result::ENTITY' declared here}} + PREDICATE, // expected-note {{'Result::PREDICATE' declared here}} + LITERAL // expected-note {{'Result::LITERAL' declared here}} + }; + + ResultType type(); +}; + +void test() { + Result result_cell; + switch (result_cell.type()) { + case ENTITY: // expected-error {{use of undeclared identifier 'ENTITY'; did you mean 'Result::ENTITY'?}} + case LITERAL: // expected-error {{use of undeclared identifier 'LITERAL'; did you mean 'Result::LITERAL'?}} + case PREDICAT: // expected-error {{use of undeclared identifier 'PREDICAT'; did you mean 'Result::PREDICATE'?}} + break; + } +} + +class Figure { + enum ResultType { + SQUARE, + TRIANGLE, + CIRCLE + }; + +public: + ResultType type(); +}; + +void testAccess() { + Figure obj; + switch (obj.type()) { // expected-warning {{enumeration values 'SQUARE', 'TRIANGLE', and 'CIRCLE' not handled in switch}} + case SQUARE: // expected-error-re {{use of undeclared identifier 'SQUARE'{{$}}}} + case TRIANGLE: // expected-error-re {{use of undeclared identifier 'TRIANGLE'{{$}}}} + case CIRCE: // expected-error-re {{use of undeclared identifier 'CIRCE'{{$}}}} + break; + } +} +} + +long readline(const char *, char *, unsigned long); +void assign_to_unknown_var() { + deadline_ = 1; // expected-error-re {{use of undeclared identifier 'deadline_'{{$}}}} +} + +namespace no_ns_before_dot { +namespace re2 {} +void test() { + req.set_check(false); // expected-error-re {{use of undeclared identifier 'req'{{$}}}} +} +} + +namespace PR17394 { + class A { + protected: + long zzzzzzzzzz; + }; + class B : private A {}; + B zzzzzzzzzy<>; // expected-error {{expected ';' after top level declarator}}{} +} + +namespace correct_fields_in_member_funcs { +struct S { + int my_member; // expected-note {{'my_member' declared here}} + void f() { my_menber = 1; } // expected-error {{use of undeclared identifier 'my_menber'; did you mean 'my_member'?}} +}; +} + +namespace PR17019 { + template<class F> + struct evil { + evil(F de) { // expected-note {{'de' declared here}} + de_; // expected-error {{use of undeclared identifier 'de_'; did you mean 'de'?}} \ + // expected-warning {{expression result unused}} + } + ~evil() { + de_->bar() // expected-error {{use of undeclared identifier 'de_'}} + } + }; + + void meow() { + evil<int> Q(0); // expected-note {{in instantiation of member function}} + } +} + +namespace fix_class_name_qualifier { +class MessageHeaders {}; +class MessageUtils { + public: + static void ParseMessageHeaders(int, int); // expected-note {{'MessageUtils::ParseMessageHeaders' declared here}} +}; + +void test() { + // No, we didn't mean to call MessageHeaders::MessageHeaders. + MessageHeaders::ParseMessageHeaders(5, 4); // expected-error {{no member named 'ParseMessageHeaders' in 'fix_class_name_qualifier::MessageHeaders'; did you mean 'MessageUtils::ParseMessageHeaders'?}} +} +} + +namespace PR18213 { // expected-note {{'PR18213' declared here}} +struct WrapperInfo { + int i; +}; + +template <typename T> struct Wrappable { + static WrapperInfo kWrapperInfo; +}; + +// Note the space before "::PR18213" is intended and needed, as it highlights +// the actual typo, which is the leading "::". +// TODO: Suggest removing the "::" from "::PR18213" (the right correction) +// instead of incorrectly suggesting dropping "PR18213::WrapperInfo::". +template <> +PR18213::WrapperInfo ::PR18213::Wrappable<int>::kWrapperInfo = { 0 }; // expected-error {{no member named 'PR18213' in 'PR18213::WrapperInfo'; did you mean simply 'PR18213'?}} \ + // expected-error {{C++ requires a type specifier for all declarations}} +} + +namespace PR18651 { +struct { + int x; +} a, b; + +int y = x; // expected-error-re {{use of undeclared identifier 'x'{{$}}}} +} + +namespace PR18685 { +template <class C, int I, int J> +class SetVector { + public: + SetVector() {} +}; + +template <class C, int I> +class SmallSetVector : public SetVector<C, I, 8> {}; + +class foo {}; +SmallSetVector<foo*, 2> fooSet; +} + +PR18685::BitVector Map; // expected-error-re {{no type named 'BitVector' in namespace 'PR18685'{{$}}}} + +namespace shadowed_template { +template <typename T> class Fizbin {}; // expected-note {{'::shadowed_template::Fizbin' declared here}} +class Baz { + int Fizbin(); + // TODO: Teach the parser to recover from the typo correction instead of + // continuing to treat the template name as an implicit-int declaration. + Fizbin<int> qux; // expected-error {{unknown type name 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}} \ + // expected-error {{expected member name or ';' after declaration specifiers}} +}; +} + +namespace PR18852 { +void func() { + struct foo { + void bar() {} + }; + bar(); // expected-error-re {{use of undeclared identifier 'bar'{{$}}}} +} + +class Thread { + public: + void Start(); + static void Stop(); // expected-note {{'Thread::Stop' declared here}} +}; + +class Manager { + public: + void Start(int); // expected-note {{'Start' declared here}} + void Stop(int); // expected-note {{'Stop' declared here}} +}; + +void test(Manager *m) { + // Don't suggest Thread::Start as a correction just because it has the same + // (unqualified) name and accepts the right number of args; this is a method + // call on an object in an unrelated class. + m->Start(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} + m->Stop(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} + Stop(); // expected-error {{use of undeclared identifier 'Stop'; did you mean 'Thread::Stop'?}} +} + +} + +namespace std { +class bernoulli_distribution { + public: + double p() const; +}; +} +void test() { + // Make sure that typo correction doesn't suggest changing 'p' to + // 'std::bernoulli_distribution::p' as that is most likely wrong. + if (p) // expected-error-re {{use of undeclared identifier 'p'{{$}}}} + return; +} + +namespace PR19681 { + struct TypoA {}; + struct TypoB { + void test(); + private: + template<typename T> void private_memfn(T); // expected-note{{declared here}} + }; + void TypoB::test() { + // FIXME: should suggest 'PR19681::TypoB::private_memfn' instead of '::PR19681::TypoB::private_memfn' + (void)static_cast<void(TypoB::*)(int)>(&TypoA::private_memfn); // expected-error{{no member named 'private_memfn' in 'PR19681::TypoA'; did you mean '::PR19681::TypoB::private_memfn'?}} + } +} + +namespace testWantFunctionLikeCasts { + long test(bool a) { + if (a) + return struc(5.7); // expected-error-re {{use of undeclared identifier 'struc'{{$}}}} + else + return lon(8.0); // expected-error {{use of undeclared identifier 'lon'; did you mean 'long'?}} + } +} + +namespace testCXXDeclarationSpecifierParsing { +namespace test { + struct SomeSettings {}; // expected-note {{'test::SomeSettings' declared here}} +} +class Test {}; +int bar() { + Test::SomeSettings some_settings; // expected-error {{no type named 'SomeSettings' in 'testCXXDeclarationSpecifierParsing::Test'; did you mean 'test::SomeSettings'?}} +} +} + +namespace testNonStaticMemberHandling { +struct Foo { + bool usesMetadata; // expected-note {{'usesMetadata' declared here}} +}; +int test(Foo f) { + if (UsesMetadata) // expected-error-re {{use of undeclared identifier 'UsesMetadata'{{$}}}} + return 5; + if (f.UsesMetadata) // expected-error {{no member named 'UsesMetadata' in 'testNonStaticMemberHandling::Foo'; did you mean 'usesMetadata'?}} + return 11; + return 0; +} }; + +namespace testMemberExprDeclarationNameInfo { + // The AST should only have the corrected name with no mention of 'data_'. + void f(int); + struct S { + int data; // expected-note 2{{'data' declared here}} + void m_fn1() { + data_ // expected-error {{use of undeclared identifier 'data_'}} + [] = // expected-error {{expected expression}} + f(data_); // expected-error {{use of undeclared identifier 'data_'}} + } + }; +} + +namespace testArraySubscriptIndex { + struct S { + int data; // expected-note {{'data' declared here}} + void m_fn1() { + (+)[data_]; // expected-error{{expected expression}} expected-error {{use of undeclared identifier 'data_'; did you mean 'data'}} + } + }; } diff --git a/test/SemaCXX/undefined-internal.cpp b/test/SemaCXX/undefined-internal.cpp index f32036a025f4..0138967ef80c 100644 --- a/test/SemaCXX/undefined-internal.cpp +++ b/test/SemaCXX/undefined-internal.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wbind-to-temporary-copy %s // Make sure we don't produce invalid IR. // RUN: %clang_cc1 -emit-llvm-only %s @@ -163,7 +163,7 @@ namespace cxx11_odr_rules { // Check that the checks work with unevaluated contexts (void)sizeof(p(A::used1)); - (void)typeid(p(A::used1)); // xpected-note {{used here}} + (void)typeid(p(A::used1)); // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} xpected-note {{used here}} // Misc other testing a(A::unused, 1 ? A::used2 : A::used2); // xpected-note {{used here}} diff --git a/test/SemaCXX/uninitialized.cpp b/test/SemaCXX/uninitialized.cpp index 677a141f3ec3..018b1feba96b 100644 --- a/test/SemaCXX/uninitialized.cpp +++ b/test/SemaCXX/uninitialized.cpp @@ -1,9 +1,22 @@ // RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -Wno-unused-value -std=c++11 -verify %s +// definitions for std::move +namespace std { +inline namespace foo { +template <class T> struct remove_reference { typedef T type; }; +template <class T> struct remove_reference<T&> { typedef T type; }; +template <class T> struct remove_reference<T&&> { typedef T type; }; + +template <class T> typename remove_reference<T>::type&& move(T&& t); +} +} + int foo(int x); int bar(int* x); int boo(int& x); int far(const int& x); +int moved(int&& x); +int &ref(int x); // Test self-references within initializers which are guaranteed to be // uninitialized. @@ -24,6 +37,20 @@ int k = __alignof__(k); int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}} int m = 1 + (k ? m : m); // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}} int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} +int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}} +const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}} +int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}} +int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}} +int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}} +int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}} +int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}} +int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}} +int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}} +int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} +int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}} +int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}} +int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}} +int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}} void test_stuff () { int a = a; // no-warning: used to signal intended lack of initialization. @@ -44,6 +71,21 @@ void test_stuff () { int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}} int m = 1 + (k ? m : m); // expected-warning {{'m' is uninitialized when used within its own initialization}} int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} + int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}} + const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}} + int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}} + int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}} + int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}} + int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}} + int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}} + int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}} + int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}} + int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} + int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}} + int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}} + int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}} + int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}} + for (;;) { int a = a; // no-warning: used to signal intended lack of initialization. @@ -64,9 +106,64 @@ void test_stuff () { int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}} int m = 1 + (k ? m : m); // expected-warning {{'m' is uninitialized when used within its own initialization}} int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} + int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}} + const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}} + int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}} + int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}} + int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}} + int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}} + int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}} + int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}} + int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}} + int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} + int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}} + int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}} + int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}} + int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}} + } } +// Also test similar constructs in a field's initializer. +struct S { + int x; + int y; + const int z = 5; + void *ptr; + + S(bool (*)[1]) : x(x) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(bool (*)[3]) : x(x + x) {} // expected-warning 2{{field 'x' is uninitialized when used here}} + S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(bool (*)[5]) : x(foo(x)) {} // expected-warning {{field 'x' is uninitialized when used here}} + + // These don't actually require the value of x and so shouldn't warn. + S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363 + S(char (*)[2]) : ptr(&ptr) {} + S(char (*)[3]) : x(bar(&x)) {} + S(char (*)[4]) : x(boo(x)) {} + S(char (*)[5]) : x(far(x)) {} + S(char (*)[6]) : x(__alignof__(x)) {} + + S(int (*)[1]) : x(0), y(x ? y : y) {} // expected-warning 2{{field 'y' is uninitialized when used here}} + S(int (*)[2]) : x(0), y(1 + (x ? y : y)) {} // expected-warning 2{{field 'y' is uninitialized when used here}} + S(int (*)[3]) : x(-x) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[4]) : x(std::move(x)) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[5]) : z(std::move(z)) {} // expected-warning {{field 'z' is uninitialized when used here}} + S(int (*)[6]) : x(moved(std::move(x))) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[7]) : x(0), y(std::move((x ? x : (18, y)))) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[8]) : x(0), y(x ?: y) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[9]) : x(0), y(y ?: x) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[10]) : x(0), y((foo(y), x)) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[11]) : x(0), y(x += y) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[12]) : x(x += 10) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[13]) : x(x++) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[14]) : x(0), y(((x ? (y, x) : (77, y))++, sizeof(y))) {} // expected-warning {{field 'y' is uninitialized when used here}} + S(int (*)[15]) : x(++ref(x)) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[16]) : x((ref(x) += 10)) {} // expected-warning {{field 'x' is uninitialized when used here}} + S(int (*)[17]) : x(0), y(y ? x : x) {} // expected-warning {{field 'y' is uninitialized when used here}} +}; + // Test self-references with record types. class A { // Non-POD class. @@ -76,7 +173,7 @@ class A { static int count; int get() const { return num; } int get2() { return num; } - void set(int x) { num = x; } + int set(int x) { num = x; return num; } static int zero() { return 0; } A() {} @@ -84,13 +181,20 @@ class A { A(int x) {} A(int *x) {} A(A *a) {} + A(A &&a) {} ~A(); + bool operator!(); + bool operator!=(const A&); }; +bool operator!=(int, const A&); + A getA() { return A(); } A getA(int x) { return A(); } A getA(A* a) { return A(); } A getA(A a) { return A(); } +A moveA(A&& a) { return A(); } +A const_refA(const A& a) { return A(); } void setupA(bool x) { A a1; @@ -127,9 +231,36 @@ void setupA(bool x) { A *a26 = new A(a26->get()); // expected-warning {{variable 'a26' is uninitialized when used within its own initialization}} A *a27 = new A(a27->get2()); // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}} A *a28 = new A(a28->num); // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}} + + const A a29(a29); // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}} + const A a30 = a30; // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}} + + A a31 = std::move(a31); // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}} + A a32 = moveA(std::move(a32)); // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}} + A a33 = A(std::move(a33)); // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}} + A a34(std::move(a34)); // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}} + A a35 = std::move(x ? a34 : (37, a35)); // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}} + + A a36 = const_refA(a36); + A a37(const_refA(a37)); + + A a38({a38}); // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}} + A a39 = {a39}; // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}} + A a40 = A({a40}); // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}} + + A a41 = !a41; // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}} + A a42 = !(a42); // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}} + A a43 = a43 != a42; // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}} + A a44 = a43 != a44; // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}} + A a45 = a45 != a45; // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}} + A a46 = 0 != a46; // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}} + + A a47(a47.set(a47.num)); // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}} + A a48(a47.set(a48.num)); // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}} + A a49(a47.set(a48.num)); } -bool x; +bool cond; A a1; A a2(a1.get()); @@ -149,8 +280,8 @@ A a14 = A(a14); // expected-warning {{variable 'a14' is uninitialized when used A a15 = getA(a15.num); // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}} A a16(&a16.num); // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}} A a17(a17.get2()); // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}} -A a18 = x ? a18 : a17; // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}} -A a19 = getA(x ? a19 : a17); // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}} +A a18 = cond ? a18 : a17; // expected-warning {{variable 'a18' is uninitialized when used within its own initialization}} +A a19 = getA(cond ? a19 : a17); // expected-warning {{variable 'a19' is uninitialized when used within its own initialization}} A a20{a20}; // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}} A a21 = {a21}; // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}} @@ -163,6 +294,101 @@ A *a26 = new A(a26->get()); // expected-warning {{variable 'a26' is uninitial A *a27 = new A(a27->get2()); // expected-warning {{variable 'a27' is uninitialized when used within its own initialization}} A *a28 = new A(a28->num); // expected-warning {{variable 'a28' is uninitialized when used within its own initialization}} +const A a29(a29); // expected-warning {{variable 'a29' is uninitialized when used within its own initialization}} +const A a30 = a30; // expected-warning {{variable 'a30' is uninitialized when used within its own initialization}} + +A a31 = std::move(a31); // expected-warning {{variable 'a31' is uninitialized when used within its own initialization}} +A a32 = moveA(std::move(a32)); // expected-warning {{variable 'a32' is uninitialized when used within its own initialization}} +A a33 = A(std::move(a33)); // expected-warning {{variable 'a33' is uninitialized when used within its own initialization}} +A a34(std::move(a34)); // expected-warning {{variable 'a34' is uninitialized when used within its own initialization}} +A a35 = std::move(x ? a34 : (37, a35)); // expected-warning {{variable 'a35' is uninitialized when used within its own initialization}} + +A a36 = const_refA(a36); +A a37(const_refA(a37)); + +A a38({a38}); // expected-warning {{variable 'a38' is uninitialized when used within its own initialization}} +A a39 = {a39}; // expected-warning {{variable 'a39' is uninitialized when used within its own initialization}} +A a40 = A({a40}); // expected-warning {{variable 'a40' is uninitialized when used within its own initialization}} + +A a41 = !a41; // expected-warning {{variable 'a41' is uninitialized when used within its own initialization}} +A a42 = !(a42); // expected-warning {{variable 'a42' is uninitialized when used within its own initialization}} +A a43 = a43 != a42; // expected-warning {{variable 'a43' is uninitialized when used within its own initialization}} +A a44 = a43 != a44; // expected-warning {{variable 'a44' is uninitialized when used within its own initialization}} +A a45 = a45 != a45; // expected-warning 2{{variable 'a45' is uninitialized when used within its own initialization}} + +A a46 = 0 != a46; // expected-warning {{variable 'a46' is uninitialized when used within its own initialization}} + +A a47(a47.set(a47.num)); // expected-warning 2{{variable 'a47' is uninitialized when used within its own initialization}} +A a48(a47.set(a48.num)); // expected-warning {{variable 'a48' is uninitialized when used within its own initialization}} +A a49(a47.set(a48.num)); + +class T { + A a, a2; + const A c_a; + A* ptr_a; + + T() {} + T(bool (*)[1]) : a() {} + T(bool (*)[2]) : a2(a.get()) {} + T(bool (*)[3]) : a2(a) {} + T(bool (*)[4]) : a(&a) {} + T(bool (*)[5]) : a(a.zero()) {} + T(bool (*)[6]) : a(a.ONE) {} + T(bool (*)[7]) : a(getA()) {} + T(bool (*)[8]) : a2(getA(a.TWO)) {} + T(bool (*)[9]) : a(getA(&a)) {} + T(bool (*)[10]) : a(a.count) {} + + T(bool (*)[11]) : a(a) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[12]) : a(a.get()) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[13]) : a(a.num) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[14]) : a(A(a)) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[15]) : a(getA(a.num)) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[16]) : a(&a.num) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[17]) : a(a.get2()) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[18]) : a2(cond ? a2 : a) {} // expected-warning {{field 'a2' is uninitialized when used here}} + T(bool (*)[19]) : a2(cond ? a2 : a) {} // expected-warning {{field 'a2' is uninitialized when used here}} + T(bool (*)[20]) : a{a} {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[21]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}} + + T(bool (*)[22]) : ptr_a(new A(ptr_a->count)) {} + T(bool (*)[23]) : ptr_a(new A(ptr_a->ONE)) {} + T(bool (*)[24]) : ptr_a(new A(ptr_a->TWO)) {} + T(bool (*)[25]) : ptr_a(new A(ptr_a->zero())) {} + + T(bool (*)[26]) : ptr_a(new A(ptr_a->get())) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}} + T(bool (*)[27]) : ptr_a(new A(ptr_a->get2())) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}} + T(bool (*)[28]) : ptr_a(new A(ptr_a->num)) {} // expected-warning {{field 'ptr_a' is uninitialized when used here}} + + T(bool (*)[29]) : c_a(c_a) {} // expected-warning {{field 'c_a' is uninitialized when used here}} + T(bool (*)[30]) : c_a(A(c_a)) {} // expected-warning {{field 'c_a' is uninitialized when used here}} + + T(bool (*)[31]) : a(std::move(a)) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[32]) : a(moveA(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[33]) : a(A(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[34]) : a(A(std::move(a))) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[35]) : a2(std::move(x ? a : (37, a2))) {} // expected-warning {{field 'a2' is uninitialized when used here}} + + T(bool (*)[36]) : a(const_refA(a)) {} + T(bool (*)[37]) : a(A(const_refA(a))) {} + + T(bool (*)[38]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[39]) : a{a} {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[40]) : a({a}) {} // expected-warning {{field 'a' is uninitialized when used here}} + + T(bool (*)[41]) : a(!a) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[42]) : a(!(a)) {} // expected-warning {{field 'a' is uninitialized when used here}} + T(bool (*)[43]) : a(), a2(a2 != a) {} // expected-warning {{field 'a2' is uninitialized when used here}} + T(bool (*)[44]) : a(), a2(a != a2) {} // expected-warning {{field 'a2' is uninitialized when used here}} + T(bool (*)[45]) : a(a != a) {} // expected-warning 2{{field 'a' is uninitialized when used here}} + T(bool (*)[46]) : a(0 != a) {} // expected-warning {{field 'a' is uninitialized when used here}} + + T(bool (*)[47]) : a2(a2.set(a2.num)) {} // expected-warning 2{{field 'a2' is uninitialized when used here}} + T(bool (*)[48]) : a2(a.set(a2.num)) {} // expected-warning {{field 'a2' is uninitialized when used here}} + T(bool (*)[49]) : a2(a.set(a.num)) {} + +}; + struct B { // POD struct. int x; @@ -173,13 +399,14 @@ B getB() { return B(); }; B getB(int x) { return B(); }; B getB(int *x) { return B(); }; B getB(B *b) { return B(); }; +B moveB(B &&b) { return B(); }; B* getPtrB() { return 0; }; B* getPtrB(int x) { return 0; }; B* getPtrB(int *x) { return 0; }; B* getPtrB(B **b) { return 0; }; -void setupB() { +void setupB(bool x) { B b1; B b2(b1); B b3 = { 5, &b3.x }; @@ -209,6 +436,14 @@ void setupB() { B b17 = { b17.x = 5, b17.y = 0 }; B b18 = { b18.x + 1, b18.y }; // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}} + + const B b19 = b19; // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}} + const B b20(b20); // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}} + + B b21 = std::move(b21); // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}} + B b22 = moveB(std::move(b22)); // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}} + B b23 = B(std::move(b23)); // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}} + B b24 = std::move(x ? b23 : (18, b24)); // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}} } B b1; @@ -234,25 +469,50 @@ B* b16 = getPtrB(b16->y); // expected-warning {{variable 'b16' is uninitialized B b17 = { b17.x = 5, b17.y = 0 }; B b18 = { b18.x + 1, b18.y }; // expected-warning 2{{variable 'b18' is uninitialized when used within its own initialization}} - -// Also test similar constructs in a field's initializer. -struct S { - int x; - void *ptr; - - S(bool (*)[1]) : x(x) {} // expected-warning {{field 'x' is uninitialized when used here}} - S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field 'x' is uninitialized when used here}} - S(bool (*)[3]) : x(x + x) {} // expected-warning 2{{field 'x' is uninitialized when used here}} - S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field 'x' is uninitialized when used here}} - S(bool (*)[5]) : x(foo(x)) {} // expected-warning {{field 'x' is uninitialized when used here}} - - // These don't actually require the value of x and so shouldn't warn. - S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363 - S(char (*)[2]) : ptr(&ptr) {} - S(char (*)[3]) : x(__alignof__(x)) {} - S(char (*)[4]) : x(bar(&x)) {} - S(char (*)[5]) : x(boo(x)) {} - S(char (*)[6]) : x(far(x)) {} +const B b19 = b19; // expected-warning {{variable 'b19' is uninitialized when used within its own initialization}} +const B b20(b20); // expected-warning {{variable 'b20' is uninitialized when used within its own initialization}} + +B b21 = std::move(b21); // expected-warning {{variable 'b21' is uninitialized when used within its own initialization}} +B b22 = moveB(std::move(b22)); // expected-warning {{variable 'b22' is uninitialized when used within its own initialization}} +B b23 = B(std::move(b23)); // expected-warning {{variable 'b23' is uninitialized when used within its own initialization}} +B b24 = std::move(x ? b23 : (18, b24)); // expected-warning {{variable 'b24' is uninitialized when used within its own initialization}} + +class U { + B b1, b2; + B *ptr1, *ptr2; + const B constb = {}; + + U() {} + U(bool (*)[1]) : b1() {} + U(bool (*)[2]) : b2(b1) {} + U(bool (*)[3]) : b1{ 5, &b1.x } {} + U(bool (*)[4]) : b1(getB()) {} + U(bool (*)[5]) : b1(getB(&b1)) {} + U(bool (*)[6]) : b1(getB(&b1.x)) {} + + U(bool (*)[7]) : b1(b1) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[8]) : b1(getB(b1.x)) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[9]) : b1(getB(b1.y)) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[10]) : b1(getB(-b1.x)) {} // expected-warning {{field 'b1' is uninitialized when used here}} + + U(bool (*)[11]) : ptr1(0) {} + U(bool (*)[12]) : ptr1(0), ptr2(ptr1) {} + U(bool (*)[13]) : ptr1(getPtrB()) {} + U(bool (*)[14]) : ptr1(getPtrB(&ptr1)) {} + + U(bool (*)[15]) : ptr1(getPtrB(ptr1->x)) {} // expected-warning {{field 'ptr1' is uninitialized when used here}} + U(bool (*)[16]) : ptr2(getPtrB(ptr2->y)) {} // expected-warning {{field 'ptr2' is uninitialized when used here}} + + U(bool (*)[17]) : b1 { b1.x = 5, b1.y = 0 } {} + U(bool (*)[18]) : b1 { b1.x + 1, b1.y } {} // expected-warning 2{{field 'b1' is uninitialized when used here}} + + U(bool (*)[19]) : constb(constb) {} // expected-warning {{field 'constb' is uninitialized when used here}} + U(bool (*)[20]) : constb(B(constb)) {} // expected-warning {{field 'constb' is uninitialized when used here}} + + U(bool (*)[21]) : b1(std::move(b1)) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[22]) : b1(moveB(std::move(b1))) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[23]) : b1(B(std::move(b1))) {} // expected-warning {{field 'b1' is uninitialized when used here}} + U(bool (*)[24]) : b2(std::move(x ? b1 : (18, b2))) {} // expected-warning {{field 'b2' is uninitialized when used here}} }; struct C { char a[100], *e; } car = { .e = car.a }; @@ -360,6 +620,8 @@ namespace { E(char (*)[12]) : a((b + c, c, a)) {} // expected-warning {{field 'a' is uninitialized when used here}} E(char (*)[13]) : a((a, a, a, a)) {} // expected-warning {{field 'a' is uninitialized when used here}} E(char (*)[14]) : a((b, c, c)) {} + E(char (*)[15]) : a(b ?: a) {} // expected-warning {{field 'a' is uninitialized when used here}} + E(char (*)[16]) : a(a ?: b) {} // expected-warning {{field 'a' is uninitialized when used here}} }; struct F { @@ -385,6 +647,11 @@ namespace { G(char (*)[7]) : f3(f3->*f_ptr) {} // expected-warning {{field 'f3' is uninitialized when used here}} G(char (*)[8]) : f3(new F(f3->*ptr)) {} // expected-warning {{field 'f3' is uninitialized when used here}} }; + + struct H { + H() : a(a) {} // expected-warning {{field 'a' is uninitialized when used here}} + const A a; + }; } namespace statics { @@ -406,6 +673,21 @@ namespace statics { static int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}} static int m = 1 + (k ? m : m); // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}} static int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} + static int o = std::move(o); // expected-warning {{variable 'o' is uninitialized when used within its own initialization}} + static const int p = std::move(p); // expected-warning {{variable 'p' is uninitialized when used within its own initialization}} + static int q = moved(std::move(q)); // expected-warning {{variable 'q' is uninitialized when used within its own initialization}} + static int r = std::move((p ? q : (18, r))); // expected-warning {{variable 'r' is uninitialized when used within its own initialization}} + static int s = r ?: s; // expected-warning {{variable 's' is uninitialized when used within its own initialization}} + static int t = t ?: s; // expected-warning {{variable 't' is uninitialized when used within its own initialization}} + static int u = (foo(u), s); // expected-warning {{variable 'u' is uninitialized when used within its own initialization}} + static int v = (u += v); // expected-warning {{variable 'v' is uninitialized when used within its own initialization}} + static int w = (w += 10); // expected-warning {{variable 'w' is uninitialized when used within its own initialization}} + static int x = x++; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} + static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{variable 'y' is uninitialized when used within its own initialization}} + static int z = ++ref(z); // expected-warning {{variable 'z' is uninitialized when used within its own initialization}} + static int aa = (ref(aa) += 10); // expected-warning {{variable 'aa' is uninitialized when used within its own initialization}} + static int bb = bb ? x : y; // expected-warning {{variable 'bb' is uninitialized when used within its own initialization}} + void test() { static int a = a; // no-warning: used to signal intended lack of initialization. @@ -426,7 +708,22 @@ namespace statics { static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}} static int m = 1 + (k ? m : m); // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}} static int n = -n; // expected-warning {{static variable 'n' is suspiciously used within its own initialization}} - for (;;) { + static int o = std::move(o); // expected-warning {{static variable 'o' is suspiciously used within its own initialization}} + static const int p = std::move(p); // expected-warning {{static variable 'p' is suspiciously used within its own initialization}} + static int q = moved(std::move(q)); // expected-warning {{static variable 'q' is suspiciously used within its own initialization}} + static int r = std::move((p ? q : (18, r))); // expected-warning {{static variable 'r' is suspiciously used within its own initialization}} + static int s = r ?: s; // expected-warning {{static variable 's' is suspiciously used within its own initialization}} + static int t = t ?: s; // expected-warning {{static variable 't' is suspiciously used within its own initialization}} + static int u = (foo(u), s); // expected-warning {{static variable 'u' is suspiciously used within its own initialization}} + static int v = (u += v); // expected-warning {{static variable 'v' is suspiciously used within its own initialization}} + static int w = (w += 10); // expected-warning {{static variable 'w' is suspiciously used within its own initialization}} + static int x = x++; // expected-warning {{static variable 'x' is suspiciously used within its own initialization}} + static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{static variable 'y' is suspiciously used within its own initialization}} + static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}} + static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}} + static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}} + + for (;;) { static int a = a; // no-warning: used to signal intended lack of initialization. static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}} static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}} @@ -445,6 +742,20 @@ namespace statics { static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}} static int m = 1 + (k ? m : m); // expected-warning 2{{static variable 'm' is suspiciously used within its own initialization}} static int n = -n; // expected-warning {{static variable 'n' is suspiciously used within its own initialization}} + static int o = std::move(o); // expected-warning {{static variable 'o' is suspiciously used within its own initialization}} + static const int p = std::move(p); // expected-warning {{static variable 'p' is suspiciously used within its own initialization}} + static int q = moved(std::move(q)); // expected-warning {{static variable 'q' is suspiciously used within its own initialization}} + static int r = std::move((p ? q : (18, r))); // expected-warning {{static variable 'r' is suspiciously used within its own initialization}} + static int s = r ?: s; // expected-warning {{static variable 's' is suspiciously used within its own initialization}} + static int t = t ?: s; // expected-warning {{static variable 't' is suspiciously used within its own initialization}} + static int u = (foo(u), s); // expected-warning {{static variable 'u' is suspiciously used within its own initialization}} + static int v = (u += v); // expected-warning {{static variable 'v' is suspiciously used within its own initialization}} + static int w = (w += 10); // expected-warning {{static variable 'w' is suspiciously used within its own initialization}} + static int x = x++; // expected-warning {{static variable 'x' is suspiciously used within its own initialization}} + static int y = ((s ? (y, v) : (77, y))++, sizeof(y)); // expected-warning {{static variable 'y' is suspiciously used within its own initialization}} + static int z = ++ref(z); // expected-warning {{static variable 'z' is suspiciously used within its own initialization}} + static int aa = (ref(aa) += 10); // expected-warning {{static variable 'aa' is suspiciously used within its own initialization}} + static int bb = bb ? x : y; // expected-warning {{static variable 'bb' is suspiciously used within its own initialization}} } } } @@ -473,13 +784,21 @@ namespace references { int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}} int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}} int &d{d}; // expected-warning{{reference 'd' is not yet bound to a value when used within its own initialization}} + int &e = d ?: e; // expected-warning{{reference 'e' is not yet bound to a value when used within its own initialization}} + int &f = f ?: d; // expected-warning{{reference 'f' is not yet bound to a value when used within its own initialization}} + + int &return_ref1(int); + int &return_ref2(int&); + + int &g = return_ref1(g); // expected-warning{{reference 'g' is not yet bound to a value when used within its own initialization}} + int &h = return_ref2(h); // expected-warning{{reference 'h' is not yet bound to a value when used within its own initialization}} struct S { S() : a(a) {} // expected-warning{{reference 'a' is not yet bound to a value when used here}} int &a; }; - void f() { + void test() { int &a = a; // expected-warning{{reference 'a' is not yet bound to a value when used within its own initialization}} int &b(b); // expected-warning{{reference 'b' is not yet bound to a value when used within its own initialization}} int &c = a ? b : c; // expected-warning{{reference 'c' is not yet bound to a value when used within its own initialization}} @@ -529,6 +848,7 @@ namespace lambdas { } namespace record_fields { + bool x; struct A { A() {} A get(); @@ -541,6 +861,7 @@ namespace record_fields { A const_ref(const A&); A pointer(A*); A normal(A); + A rref(A&&); struct B { A a; @@ -553,9 +874,13 @@ namespace record_fields { B(char (*)[7]) : a(const_ref(a)) {} B(char (*)[8]) : a(pointer(&a)) {} B(char (*)[9]) : a(normal(a)) {} // expected-warning {{uninitialized}} + B(char (*)[10]) : a(std::move(a)) {} // expected-warning {{uninitialized}} + B(char (*)[11]) : a(A(std::move(a))) {} // expected-warning {{uninitialized}} + B(char (*)[12]) : a(rref(std::move(a))) {} // expected-warning {{uninitialized}} + B(char (*)[13]) : a(std::move(x ? a : (25, a))) {} // expected-warning 2{{uninitialized}} }; struct C { - C() {} // expected-note4{{in this constructor}} + C() {} // expected-note9{{in this constructor}} A a1 = a1; // expected-warning {{uninitialized}} A a2 = a2.get(); // expected-warning {{uninitialized}} A a3 = a3.num(); @@ -565,8 +890,13 @@ namespace record_fields { A a7 = const_ref(a7); A a8 = pointer(&a8); A a9 = normal(a9); // expected-warning {{uninitialized}} + const A a10 = a10; // expected-warning {{uninitialized}} + A a11 = std::move(a11); // expected-warning {{uninitialized}} + A a12 = A(std::move(a12)); // expected-warning {{uninitialized}} + A a13 = rref(std::move(a13)); // expected-warning {{uninitialized}} + A a14 = std::move(x ? a13 : (22, a14)); // expected-warning {{uninitialized}} }; - struct D { // expected-note4{{in the implicit default constructor}} + struct D { // expected-note9{{in the implicit default constructor}} A a1 = a1; // expected-warning {{uninitialized}} A a2 = a2.get(); // expected-warning {{uninitialized}} A a3 = a3.num(); @@ -576,6 +906,11 @@ namespace record_fields { A a7 = const_ref(a7); A a8 = pointer(&a8); A a9 = normal(a9); // expected-warning {{uninitialized}} + const A a10 = a10; // expected-warning {{uninitialized}} + A a11 = std::move(a11); // expected-warning {{uninitialized}} + A a12 = A(std::move(a12)); // expected-warning {{uninitialized}} + A a13 = rref(std::move(a13)); // expected-warning {{uninitialized}} + A a14 = std::move(x ? a13 : (22, a14)); // expected-warning {{uninitialized}} }; D d; struct E { @@ -588,6 +923,11 @@ namespace record_fields { A a7 = const_ref(a7); A a8 = pointer(&a8); A a9 = normal(a9); + const A a10 = a10; + A a11 = std::move(a11); + A a12 = A(std::move(a12)); + A a13 = rref(std::move(a13)); + A a14 = std::move(x ? a13 : (22, a14)); }; } @@ -710,6 +1050,20 @@ namespace cross_field_warnings { int d = a + b + c; R() : a(c = 5), b(c), c(a) {} }; + + // FIXME: Use the CFG-based analysis to give a sometimes uninitialized + // warning on y. + struct T { + int x; + int y; + T(bool b) + : x(b ? (y = 5) : (1 + y)), // expected-warning{{field 'y' is uninitialized when used here}} + y(y + 1) {} + T(int b) + : x(!b ? (1 + y) : (y = 5)), // expected-warning{{field 'y' is uninitialized when used here}} + y(y + 1) {} + }; + } namespace base_class { @@ -728,3 +1082,306 @@ namespace base_class { C() : A(y = 4), x(y) {} }; } + +namespace delegating_constructor { + struct A { + A(int); + A(int&, int); + + A(char (*)[1]) : A(x) {} + // expected-warning@-1 {{field 'x' is uninitialized when used here}} + A(char (*)[2]) : A(x, x) {} + // expected-warning@-1 {{field 'x' is uninitialized when used here}} + + A(char (*)[3]) : A(x, 0) {} + + int x; + }; +} + +namespace init_list { + int num = 5; + struct A { int i1, i2; }; + struct B { A a1, a2; }; + + A a1{1,2}; + A a2{a2.i1 + 2}; // expected-warning{{uninitialized}} + A a3 = {a3.i1 + 2}; // expected-warning{{uninitialized}} + A a4 = A{a4.i2 + 2}; // expected-warning{{uninitialized}} + + B b1 = { {}, {} }; + B b2 = { {}, b2.a1 }; + B b3 = { b3.a1 }; // expected-warning{{uninitialized}} + B b4 = { {}, b4.a2} ; // expected-warning{{uninitialized}} + B b5 = { b5.a2 }; // expected-warning{{uninitialized}} + + B b6 = { {b6.a1.i1} }; // expected-warning{{uninitialized}} + B b7 = { {0, b7.a1.i1} }; + B b8 = { {}, {b8.a1.i1} }; + B b9 = { {}, {0, b9.a1.i1} }; + + B b10 = { {b10.a1.i2} }; // expected-warning{{uninitialized}} + B b11 = { {0, b11.a1.i2} }; // expected-warning{{uninitialized}} + B b12 = { {}, {b12.a1.i2} }; + B b13 = { {}, {0, b13.a1.i2} }; + + B b14 = { {b14.a2.i1} }; // expected-warning{{uninitialized}} + B b15 = { {0, b15.a2.i1} }; // expected-warning{{uninitialized}} + B b16 = { {}, {b16.a2.i1} }; // expected-warning{{uninitialized}} + B b17 = { {}, {0, b17.a2.i1} }; + + B b18 = { {b18.a2.i2} }; // expected-warning{{uninitialized}} + B b19 = { {0, b19.a2.i2} }; // expected-warning{{uninitialized}} + B b20 = { {}, {b20.a2.i2} }; // expected-warning{{uninitialized}} + B b21 = { {}, {0, b21.a2.i2} }; // expected-warning{{uninitialized}} + + B b22 = { {b18.a2.i2 + 5} }; + + struct C {int a; int& b; int c; }; + C c1 = { 0, num, 0 }; + C c2 = { 1, num, c2.b }; + C c3 = { c3.b, num }; // expected-warning{{uninitialized}} + C c4 = { 0, c4.b, 0 }; // expected-warning{{uninitialized}} + C c5 = { 0, c5.c, 0 }; + C c6 = { c6.b, num, 0 }; // expected-warning{{uninitialized}} + C c7 = { 0, c7.a, 0 }; + + struct D {int &a; int &b; }; + D d1 = { num, num }; + D d2 = { num, d2.a }; + D d3 = { d3.b, num }; // expected-warning{{uninitialized}} + + // Same as above in member initializer form. + struct Awrapper { + A a1{1,2}; + A a2{a2.i1 + 2}; // expected-warning{{uninitialized}} + A a3 = {a3.i1 + 2}; // expected-warning{{uninitialized}} + A a4 = A{a4.i2 + 2}; // expected-warning{{uninitialized}} + Awrapper() {} // expected-note 3{{in this constructor}} + Awrapper(int) : + a1{1,2}, + a2{a2.i1 + 2}, // expected-warning{{uninitialized}} + a3{a3.i1 + 2}, // expected-warning{{uninitialized}} + a4{a4.i2 + 2} // expected-warning{{uninitialized}} + {} + }; + + struct Bwrapper { + B b1 = { {}, {} }; + B b2 = { {}, b2.a1 }; + B b3 = { b3.a1 }; // expected-warning{{uninitialized}} + B b4 = { {}, b4.a2} ; // expected-warning{{uninitialized}} + B b5 = { b5.a2 }; // expected-warning{{uninitialized}} + + B b6 = { {b6.a1.i1} }; // expected-warning{{uninitialized}} + B b7 = { {0, b7.a1.i1} }; + B b8 = { {}, {b8.a1.i1} }; + B b9 = { {}, {0, b9.a1.i1} }; + + B b10 = { {b10.a1.i2} }; // expected-warning{{uninitialized}} + B b11 = { {0, b11.a1.i2} }; // expected-warning{{uninitialized}} + B b12 = { {}, {b12.a1.i2} }; + B b13 = { {}, {0, b13.a1.i2} }; + + B b14 = { {b14.a2.i1} }; // expected-warning{{uninitialized}} + B b15 = { {0, b15.a2.i1} }; // expected-warning{{uninitialized}} + B b16 = { {}, {b16.a2.i1} }; // expected-warning{{uninitialized}} + B b17 = { {}, {0, b17.a2.i1} }; + + B b18 = { {b18.a2.i2} }; // expected-warning{{uninitialized}} + B b19 = { {0, b19.a2.i2} }; // expected-warning{{uninitialized}} + B b20 = { {}, {b20.a2.i2} }; // expected-warning{{uninitialized}} + B b21 = { {}, {0, b21.a2.i2} }; // expected-warning{{uninitialized}} + + B b22 = { {b18.a2.i2 + 5} }; + Bwrapper() {} // expected-note 13{{in this constructor}} + Bwrapper(int) : + b1{ {}, {} }, + b2{ {}, b2.a1 }, + b3{ b3.a1 }, // expected-warning{{uninitialized}} + b4{ {}, b4.a2}, // expected-warning{{uninitialized}} + b5{ b5.a2 }, // expected-warning{{uninitialized}} + + b6{ {b6.a1.i1} }, // expected-warning{{uninitialized}} + b7{ {0, b7.a1.i1} }, + b8{ {}, {b8.a1.i1} }, + b9{ {}, {0, b9.a1.i1} }, + + b10{ {b10.a1.i2} }, // expected-warning{{uninitialized}} + b11{ {0, b11.a1.i2} }, // expected-warning{{uninitialized}} + b12{ {}, {b12.a1.i2} }, + b13{ {}, {0, b13.a1.i2} }, + + b14{ {b14.a2.i1} }, // expected-warning{{uninitialized}} + b15{ {0, b15.a2.i1} }, // expected-warning{{uninitialized}} + b16{ {}, {b16.a2.i1} }, // expected-warning{{uninitialized}} + b17{ {}, {0, b17.a2.i1} }, + + b18{ {b18.a2.i2} }, // expected-warning{{uninitialized}} + b19{ {0, b19.a2.i2} }, // expected-warning{{uninitialized}} + b20{ {}, {b20.a2.i2} }, // expected-warning{{uninitialized}} + b21{ {}, {0, b21.a2.i2} }, // expected-warning{{uninitialized}} + + b22{ {b18.a2.i2 + 5} } + {} + }; + + struct Cwrapper { + C c1 = { 0, num, 0 }; + C c2 = { 1, num, c2.b }; + C c3 = { c3.b, num }; // expected-warning{{uninitialized}} + C c4 = { 0, c4.b, 0 }; // expected-warning{{uninitialized}} + C c5 = { 0, c5.c, 0 }; + C c6 = { c6.b, num, 0 }; // expected-warning{{uninitialized}} + C c7 = { 0, c7.a, 0 }; + + Cwrapper() {} // expected-note 3{{in this constructor}} + Cwrapper(int) : + c1{ 0, num, 0 }, + c2{ 1, num, c2.b }, + c3{ c3.b, num }, // expected-warning{{uninitialized}} + c4{ 0, c4.b, 0 }, // expected-warning{{uninitialized}} + c5{ 0, c5.c, 0 }, + c6{ c6.b, num, 0 }, // expected-warning{{uninitialized}} + c7{ 0, c7.a, 0 } + {} + }; + + struct Dwrapper { + D d1 = { num, num }; + D d2 = { num, d2.a }; + D d3 = { d3.b, num }; // expected-warning{{uninitialized}} + Dwrapper() {} // expected-note{{in this constructor}} + Dwrapper(int) : + d1{ num, num }, + d2{ num, d2.a }, + d3{ d3.b, num } // expected-warning{{uninitialized}} + {} + }; +} + +namespace template_class { +class Foo { + public: + int *Create() { return nullptr; } +}; + +template <typename T> +class A { +public: + // Don't warn on foo here. + A() : ptr(foo->Create()) {} + +private: + Foo *foo = new Foo; + int *ptr; +}; + +template <typename T> +class B { +public: + // foo is uninitialized here, but class B is never instantiated. + B() : ptr(foo->Create()) {} + +private: + Foo *foo; + int *ptr; +}; + +template <typename T> +class C { +public: + C() : ptr(foo->Create()) {} + // expected-warning@-1 {{field 'foo' is uninitialized when used here}} +private: + Foo *foo; + int *ptr; +}; + +C<int> c; +// expected-note@-1 {{in instantiation of member function 'template_class::C<int>::C' requested here}} + +} + +namespace base_class_access { +struct A { + A(); + A(int); + + int i; + int foo(); + + static int bar(); +}; + +struct B : public A { + B(int (*)[1]) : A() {} + B(int (*)[2]) : A(bar()) {} + + B(int (*)[3]) : A(i) {} + // expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}} + + B(int (*)[4]) : A(foo()) {} + // expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}} +}; + +struct C { + C(int) {} +}; + +struct D : public C, public A { + D(int (*)[1]) : C(0) {} + D(int (*)[2]) : C(bar()) {} + + D(int (*)[3]) : C(i) {} + // expected-warning@-1 {{base class 'base_class_access::A' is uninitialized when used here to access 'base_class_access::A::i'}} + + D(int (*)[4]) : C(foo()) {} + // expected-warning@-1 {{base_class_access::A' is uninitialized when used here to access 'base_class_access::A::foo'}} +}; + +} + +namespace value { +template <class T> T move(T t); +template <class T> T notmove(T t); +} +namespace lvalueref { +template <class T> T move(T& t); +template <class T> T notmove(T& t); +} +namespace rvalueref { +template <class T> T move(T&& t); +template <class T> T notmove(T&& t); +} + +namespace move_test { +int a1 = std::move(a1); // expected-warning {{uninitialized}} +int a2 = value::move(a2); // expected-warning {{uninitialized}} +int a3 = value::notmove(a3); // expected-warning {{uninitialized}} +int a4 = lvalueref::move(a4); +int a5 = lvalueref::notmove(a5); +int a6 = rvalueref::move(a6); +int a7 = rvalueref::notmove(a7); + +void test() { + int a1 = std::move(a1); // expected-warning {{uninitialized}} + int a2 = value::move(a2); // expected-warning {{uninitialized}} + int a3 = value::notmove(a3); // expected-warning {{uninitialized}} + int a4 = lvalueref::move(a4); + int a5 = lvalueref::notmove(a5); + int a6 = rvalueref::move(a6); + int a7 = rvalueref::notmove(a7); +} + +class A { + int a; + A(int (*) [1]) : a(std::move(a)) {} // expected-warning {{uninitialized}} + A(int (*) [2]) : a(value::move(a)) {} // expected-warning {{uninitialized}} + A(int (*) [3]) : a(value::notmove(a)) {} // expected-warning {{uninitialized}} + A(int (*) [4]) : a(lvalueref::move(a)) {} + A(int (*) [5]) : a(lvalueref::notmove(a)) {} + A(int (*) [6]) : a(rvalueref::move(a)) {} + A(int (*) [7]) : a(rvalueref::notmove(a)) {} +}; +} diff --git a/test/SemaCXX/unknown-type-name.cpp b/test/SemaCXX/unknown-type-name.cpp index f2c84df242ff..9d28c310ed97 100644 --- a/test/SemaCXX/unknown-type-name.cpp +++ b/test/SemaCXX/unknown-type-name.cpp @@ -27,7 +27,7 @@ int var(zepelin); // expected-error{{did you mean 'zeppelin'?}} template<typename T> struct A { typedef T type; - + type f(); type g(); @@ -93,14 +93,14 @@ template<typename T> int A<T>::h(T::type x, char) {} // expected-error{{missing template<typename T> int h(T::type, int); // expected-error{{missing 'typename'}} template<typename T> int h(T::type x, char); // expected-error{{missing 'typename'}} -template<typename T> int junk1(T::junk); // expected-warning{{variable templates are a C++1y extension}} +template<typename T> int junk1(T::junk); // expected-warning{{variable templates are a C++14 extension}} template<typename T> int junk2(T::junk) throw(); // expected-error{{missing 'typename'}} template<typename T> int junk3(T::junk) = delete; // expected-error{{missing 'typename'}} expected-warning{{C++11}} template<typename T> int junk4(T::junk j); // expected-error{{missing 'typename'}} // FIXME: We can tell this was intended to be a function because it does not // have a dependent nested name specifier. -template<typename T> int i(T::type, int()); // expected-warning{{variable templates are a C++1y extension}} +template<typename T> int i(T::type, int()); // expected-warning{{variable templates are a C++14 extension}} // FIXME: We know which type specifier should have been specified here. Provide // a fix-it to add 'typename A<T>::type' diff --git a/test/SemaCXX/using-decl-1.cpp b/test/SemaCXX/using-decl-1.cpp index 40f80a70ef37..e730c9d63a20 100644 --- a/test/SemaCXX/using-decl-1.cpp +++ b/test/SemaCXX/using-decl-1.cpp @@ -255,3 +255,11 @@ namespace TypoCorrectTemplateMember { using A::goobar; // expected-error {{no member named 'goobar' in 'TypoCorrectTemplateMember::A'; did you mean 'foobar'?}} }; } + +namespace use_instance_in_static { +struct A { int n; }; +struct B : A { + using A::n; + static int f() { return n; } // expected-error {{invalid use of member 'n' in static member function}} +}; +} diff --git a/test/SemaCXX/vararg-non-pod.cpp b/test/SemaCXX/vararg-non-pod.cpp index 56dafc41f132..39d4cccacd35 100644 --- a/test/SemaCXX/vararg-non-pod.cpp +++ b/test/SemaCXX/vararg-non-pod.cpp @@ -1,5 +1,8 @@ // RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-error=non-pod-varargs +// Check that the warning is still there under -fms-compatibility. +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-error=non-pod-varargs -fms-compatibility + extern char version[]; class C { @@ -100,7 +103,7 @@ Base &get_base(...); int eat_base(...); void test_typeid(Base &base) { - (void)typeid(get_base(base)); // expected-warning{{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}} + (void)typeid(get_base(base)); // expected-warning{{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}} expected-warning{{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} (void)typeid(eat_base(base)); // okay } diff --git a/test/SemaCXX/vtable-instantiation.cc b/test/SemaCXX/vtable-instantiation.cpp index 2a1b98900647..78f2b3ed1a2a 100644 --- a/test/SemaCXX/vtable-instantiation.cc +++ b/test/SemaCXX/vtable-instantiation.cpp @@ -41,7 +41,7 @@ namespace PR9325 { void f() { - Target<int*>* traits = &Provider<int*>::Instance; + Target<int*>* traits = &Provider<int*>::Instance; // expected-note{{requested here}} } } @@ -60,7 +60,7 @@ namespace PR10020 { }; template <typename Type> - GMG<Type> GMG<Type>::singleton; + GMG<Type> GMG<Type>::singleton; // expected-note{{requested here}} void test(void) { GMG<int>::Method(); // expected-note{{in instantiation of}} diff --git a/test/SemaCXX/warn-bool-conversion.cpp b/test/SemaCXX/warn-bool-conversion.cpp index b4628947f06e..b0c8d0d19d14 100644 --- a/test/SemaCXX/warn-bool-conversion.cpp +++ b/test/SemaCXX/warn-bool-conversion.cpp @@ -118,3 +118,30 @@ namespace Pointer { // expected-warning@-1{{address of 'S::a' will always evaluate to 'true'}} } } + +namespace macros { + #define assert(x) if (x) {} + #define zero_on_null(x) ((x) ? *(x) : 0) + + int array[5]; + void fun(); + int x; + + void test() { + assert(array); + assert(array && "expecting null pointer"); + // expected-warning@-1{{address of array 'array' will always evaluate to 'true'}} + + assert(fun); + assert(fun && "expecting null pointer"); + // expected-warning@-1{{address of function 'fun' will always evaluate to 'true'}} + // expected-note@-2 {{prefix with the address-of operator to silence this warning}} + + // TODO: warn on assert(&x) while not warning on zero_on_null(&x) + zero_on_null(&x); + assert(zero_on_null(&x)); + assert(&x); + assert(&x && "expecting null pointer"); + // expected-warning@-1{{address of 'x' will always evaluate to 'true'}} + } +} diff --git a/test/SemaCXX/warn-consumed-parsing.cpp b/test/SemaCXX/warn-consumed-parsing.cpp index 5c0a04fffe36..179604141b7b 100644 --- a/test/SemaCXX/warn-consumed-parsing.cpp +++ b/test/SemaCXX/warn-consumed-parsing.cpp @@ -37,6 +37,7 @@ class CONSUMABLE(unknown) AttrTester1 { void callableWhen0() CALLABLE_WHEN("unconsumed"); void callableWhen1() CALLABLE_WHEN(42); // expected-error {{'callable_when' attribute requires a string}} void callableWhen2() CALLABLE_WHEN("foo"); // expected-warning {{'callable_when' attribute argument not supported: foo}} + void callableWhen3() CALLABLE_WHEN(unconsumed); void consumes() SET_TYPESTATE(consumed); bool testUnconsumed() TEST_TYPESTATE(consumed); }; diff --git a/test/SemaCXX/warn-global-constructors.cpp b/test/SemaCXX/warn-global-constructors.cpp index 90d8558666c3..856826414a8b 100644 --- a/test/SemaCXX/warn-global-constructors.cpp +++ b/test/SemaCXX/warn-global-constructors.cpp @@ -120,3 +120,9 @@ namespace pr19253 { }; E e; } + +namespace pr20420 { +// No warning is expected. This used to crash. +void *array_storage[1]; +const int &global_reference = *(int *)array_storage; +} diff --git a/test/SemaCXX/warn-overloaded-virtual.cpp b/test/SemaCXX/warn-overloaded-virtual.cpp index 629d59dee537..6204826192d7 100644 --- a/test/SemaCXX/warn-overloaded-virtual.cpp +++ b/test/SemaCXX/warn-overloaded-virtual.cpp @@ -48,8 +48,8 @@ struct Base { void Base::foo(int) { } struct Derived : public Base { - virtual void foo(int); - void foo(int, int); + virtual void foo(int); + void foo(int, int); }; } @@ -138,3 +138,21 @@ namespace { // expected-warning@-1{{hides overloaded virtual functions}} }; } + +namespace { +struct base { + void f(char) {} +}; + +struct derived : base { + void f(int) {} +}; + +void foo(derived &d) { + d.f('1'); // FIXME: this should warn about calling (anonymous namespace)::derived::f(int) + // instead of (anonymous namespace)::base::f(char). + // Note: this should be under a new diagnostic flag and eventually moved to a + // new test case since it's not strictly related to virtual functions. + d.f(12); // This should not warn. +} +} diff --git a/test/SemaCXX/warn-self-move.cpp b/test/SemaCXX/warn-self-move.cpp new file mode 100644 index 000000000000..23778c187113 --- /dev/null +++ b/test/SemaCXX/warn-self-move.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -fsyntax-only -Wself-move -std=c++11 -verify %s + +// definitions for std::move +namespace std { +inline namespace foo { +template <class T> struct remove_reference { typedef T type; }; +template <class T> struct remove_reference<T&> { typedef T type; }; +template <class T> struct remove_reference<T&&> { typedef T type; }; + +template <class T> typename remove_reference<T>::type &&move(T &&t); +} +} + +void int_test() { + int x = 5; + x = std::move(x); // expected-warning{{explicitly moving}} + (x) = std::move(x); // expected-warning{{explicitly moving}} + + using std::move; + x = move(x); // expected-warning{{explicitly moving}} +} + +int global; +void global_int_test() { + global = std::move(global); // expected-warning{{explicitly moving}} + (global) = std::move(global); // expected-warning{{explicitly moving}} + + using std::move; + global = move(global); // expected-warning{{explicitly moving}} +} + +class field_test { + int x; + field_test(field_test&& other) { + x = std::move(x); // expected-warning{{explicitly moving}} + x = std::move(other.x); + other.x = std::move(x); + other.x = std::move(other.x); // expected-warning{{explicitly moving}} + } +}; + +struct A {}; +struct B { A a; }; +struct C { C() {}; ~C() {} }; +void struct_test() { + A a; + a = std::move(a); // expected-warning{{explicitly moving}} + + B b; + b = std::move(b); // expected-warning{{explicitly moving}} + b.a = std::move(b.a); // expected-warning{{explicitly moving}} + + C c; + c = std::move(c); // expected-warning{{explicitly moving}} +} diff --git a/test/SemaCXX/warn-tautological-compare.cpp b/test/SemaCXX/warn-tautological-compare.cpp index b44f3f9d8fa3..7d5b4b14e998 100644 --- a/test/SemaCXX/warn-tautological-compare.cpp +++ b/test/SemaCXX/warn-tautological-compare.cpp @@ -136,3 +136,43 @@ namespace PointerCompare { // expected-warning@-1{{comparison of address of 'S::a' equal to a null pointer is always false}} } } + +namespace macros { + #define assert(x) if (x) {} + int array[5]; + void fun(); + int x; + + void test() { + assert(array == 0); + // expected-warning@-1{{comparison of array 'array' equal to a null pointer is always false}} + assert(array != 0); + // expected-warning@-1{{comparison of array 'array' not equal to a null pointer is always true}} + assert(array == 0 && "expecting null pointer"); + // expected-warning@-1{{comparison of array 'array' equal to a null pointer is always false}} + assert(array != 0 && "expecting non-null pointer"); + // expected-warning@-1{{comparison of array 'array' not equal to a null pointer is always true}} + + assert(fun == 0); + // expected-warning@-1{{comparison of function 'fun' equal to a null pointer is always false}} + // expected-note@-2{{prefix with the address-of operator to silence this warning}} + assert(fun != 0); + // expected-warning@-1{{comparison of function 'fun' not equal to a null pointer is always true}} + // expected-note@-2{{prefix with the address-of operator to silence this warning}} + assert(fun == 0 && "expecting null pointer"); + // expected-warning@-1{{comparison of function 'fun' equal to a null pointer is always false}} + // expected-note@-2{{prefix with the address-of operator to silence this warning}} + assert(fun != 0 && "expecting non-null pointer"); + // expected-warning@-1{{comparison of function 'fun' not equal to a null pointer is always true}} + // expected-note@-2{{prefix with the address-of operator to silence this warning}} + + assert(&x == 0); + // expected-warning@-1{{comparison of address of 'x' equal to a null pointer is always false}} + assert(&x != 0); + // expected-warning@-1{{comparison of address of 'x' not equal to a null pointer is always true}} + assert(&x == 0 && "expecting null pointer"); + // expected-warning@-1{{comparison of address of 'x' equal to a null pointer is always false}} + assert(&x != 0 && "expecting non-null pointer"); + // expected-warning@-1{{comparison of address of 'x' not equal to a null pointer is always true}} + } +} diff --git a/test/SemaCXX/warn-tautological-undefined-compare.cpp b/test/SemaCXX/warn-tautological-undefined-compare.cpp index ce05bfc14d17..9321c0edbd3a 100644 --- a/test/SemaCXX/warn-tautological-undefined-compare.cpp +++ b/test/SemaCXX/warn-tautological-undefined-compare.cpp @@ -110,3 +110,31 @@ namespace function_return_reference { // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true}} } } + +namespace macros { + #define assert(x) if (x) {} + + void test(int &x) { + assert(&x != 0); + // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true}} + assert(&x == 0); + // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to false}} + assert(&x != 0 && "Expecting valid reference"); + // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true}} + assert(&x == 0 && "Expecting invalid reference"); + // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to false}} + } + + class S { + void test() { + assert(this != 0); + // expected-warning@-1{{'this' pointer cannot be null in well-defined C++ code; comparison may be assumed to always evaluate to true}} + assert(this == 0); + // expected-warning@-1{{'this' pointer cannot be null in well-defined C++ code; comparison may be assumed to always evaluate to false}} + assert(this != 0 && "Expecting valid reference"); + // expected-warning@-1{{'this' pointer cannot be null in well-defined C++ code; comparison may be assumed to always evaluate to true}} + assert(this == 0 && "Expecting invalid reference"); + // expected-warning@-1{{'this' pointer cannot be null in well-defined C++ code; comparison may be assumed to always evaluate to false}} + } + }; +} diff --git a/test/SemaCXX/warn-thread-safety-analysis.cpp b/test/SemaCXX/warn-thread-safety-analysis.cpp index 34a33aab42d2..091e47335b57 100644 --- a/test/SemaCXX/warn-thread-safety-analysis.cpp +++ b/test/SemaCXX/warn-thread-safety-analysis.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -fcxx-exceptions %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wno-thread-safety-negative -fcxx-exceptions %s // FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s // FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety %s @@ -36,6 +36,9 @@ class __attribute__((lockable)) Mutex { bool ReaderTryLock() __attribute__((shared_trylock_function(true))); void LockWhen(const int &cond) __attribute__((exclusive_lock_function)); + // for negative capabilities + const Mutex& operator!() const { return *this; } + void AssertHeld() ASSERT_EXCLUSIVE_LOCK(); void AssertReaderHeld() ASSERT_SHARED_LOCK(); }; @@ -60,6 +63,12 @@ class SCOPED_LOCKABLE ReleasableMutexLock { void Release() UNLOCK_FUNCTION(); }; +class __attribute__((scoped_lockable)) DoubleMutexLock { +public: + DoubleMutexLock(Mutex *mu1, Mutex *mu2) + __attribute__((exclusive_lock_function(mu1, mu2))); + ~DoubleMutexLock() __attribute__((unlock_function)); +}; // The universal lock, written "*", allows checking to be selectively turned // off for a particular piece of code. @@ -95,6 +104,37 @@ public: }; +// For testing operator overloading +template <class K, class T> +class MyMap { +public: + T& operator[](const K& k); +}; + + +// For testing handling of containers. +template <class T> +class MyContainer { +public: + MyContainer(); + + typedef T* iterator; + typedef const T* const_iterator; + + T* begin(); + T* end(); + + const T* cbegin(); + const T* cend(); + + T& operator[](int i); + const T& operator[](int i) const; + +private: + T* ptr_; +}; + + Mutex sls_mu; @@ -1628,6 +1668,12 @@ struct TestScopedLockable { a = b+1; b = a+1; } + + void foo5() { + DoubleMutexLock mulock(&mu1, &mu2); + a = b + 1; + b = a + 1; + } }; } // end namespace test_scoped_lockable @@ -2280,6 +2326,15 @@ void test() { (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock(); (a > 0 ? fooArray[1] : fooArray[b]).a = 0; (a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock(); +} + + +void test2() { + Foo *fooArray; + Bar bar; + int a; + int b; + int c; bar.getFoo().mu_.Lock(); bar.getFooey().a = 0; // \ @@ -2295,20 +2350,20 @@ void test() { bar.getFoo3(a, b).mu_.Lock(); bar.getFoo3(a, c).a = 0; // \ - // expected-warning {{writing variable 'a' requires holding mutex 'bar.getFoo3(a,c).mu_' exclusively}} \ - // expected-note {{'bar.getFoo3(a,b).mu_'}} + // expected-warning {{writing variable 'a' requires holding mutex 'bar.getFoo3(a, c).mu_' exclusively}} \ + // expected-note {{found near match 'bar.getFoo3(a, b).mu_'}} bar.getFoo3(a, b).mu_.Unlock(); getBarFoo(bar, a).mu_.Lock(); getBarFoo(bar, b).a = 0; // \ - // expected-warning {{writing variable 'a' requires holding mutex 'getBarFoo(bar,b).mu_' exclusively}} \ - // expected-note {{'getBarFoo(bar,a).mu_'}} + // expected-warning {{writing variable 'a' requires holding mutex 'getBarFoo(bar, b).mu_' exclusively}} \ + // expected-note {{found near match 'getBarFoo(bar, a).mu_'}} getBarFoo(bar, a).mu_.Unlock(); (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock(); (a > 0 ? fooArray[b] : fooArray[c]).a = 0; // \ - // expected-warning {{writing variable 'a' requires holding mutex '((a#_)#_#fooArray[b]).mu_' exclusively}} \ - // expected-note {{'((a#_)#_#fooArray[_]).mu_'}} + // expected-warning {{writing variable 'a' requires holding mutex '((0 < a) ? fooArray[b] : fooArray[c]).mu_' exclusively}} \ + // expected-note {{found near match '((0 < a) ? fooArray[1] : fooArray[b]).mu_'}} (a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock(); } @@ -4378,3 +4433,418 @@ class Foo { }; } // end namespace ThreadAttributesOnLambdas + + + +namespace AttributeExpressionCornerCases { + +class Foo { + int a GUARDED_BY(getMu()); + + Mutex* getMu() LOCK_RETURNED(""); + Mutex* getUniv() LOCK_RETURNED("*"); + + void test1() { + a = 0; + } + + void test2() EXCLUSIVE_LOCKS_REQUIRED(getUniv()) { + a = 0; + } + + void foo(Mutex* mu) EXCLUSIVE_LOCKS_REQUIRED(mu); + + void test3() { + foo(nullptr); + } +}; + + +class MapTest { + struct MuCell { Mutex* mu; }; + + MyMap<MyString, Mutex*> map; + MyMap<MyString, MuCell> mapCell; + + int a GUARDED_BY(map["foo"]); + int b GUARDED_BY(mapCell["foo"].mu); + + void test() { + map["foo"]->Lock(); + a = 0; + map["foo"]->Unlock(); + } + + void test2() { + mapCell["foo"].mu->Lock(); + b = 0; + mapCell["foo"].mu->Unlock(); + } +}; + + +class PreciseSmartPtr { + SmartPtr<Mutex> mu; + int val GUARDED_BY(mu); + + static bool compare(PreciseSmartPtr& a, PreciseSmartPtr &b) { + a.mu->Lock(); + bool result = (a.val == b.val); // expected-warning {{reading variable 'val' requires holding mutex 'b.mu'}} \ + // expected-note {{found near match 'a.mu'}} + a.mu->Unlock(); + return result; + } +}; + + +class SmartRedeclare { + SmartPtr<Mutex> mu; + int val GUARDED_BY(mu); + + void test() EXCLUSIVE_LOCKS_REQUIRED(mu); + void test2() EXCLUSIVE_LOCKS_REQUIRED(mu.get()); + void test3() EXCLUSIVE_LOCKS_REQUIRED(mu.get()); +}; + + +void SmartRedeclare::test() EXCLUSIVE_LOCKS_REQUIRED(mu.get()) { + val = 0; +} + +void SmartRedeclare::test2() EXCLUSIVE_LOCKS_REQUIRED(mu) { + val = 0; +} + +void SmartRedeclare::test3() { + val = 0; +} + + +namespace CustomMutex { + + +class LOCKABLE BaseMutex { }; +class DerivedMutex : public BaseMutex { }; + +void customLock(const BaseMutex *m) EXCLUSIVE_LOCK_FUNCTION(m); +void customUnlock(const BaseMutex *m) UNLOCK_FUNCTION(m); + +static struct DerivedMutex custMu; + +static void doSomethingRequiringLock() EXCLUSIVE_LOCKS_REQUIRED(custMu) { } + +void customTest() { + customLock(reinterpret_cast<BaseMutex*>(&custMu)); // ignore casts + doSomethingRequiringLock(); + customUnlock(reinterpret_cast<BaseMutex*>(&custMu)); +} + +} // end namespace CustomMutex + +} // end AttributeExpressionCornerCases + + +namespace ScopedLockReturnedInvalid { + +class Opaque; + +Mutex* getMutex(Opaque* o) LOCK_RETURNED(""); + +void test(Opaque* o) { + MutexLock lock(getMutex(o)); +} + +} // end namespace ScopedLockReturnedInvalid + + +namespace NegativeRequirements { + +class Bar { + Mutex mu; + int a GUARDED_BY(mu); + +public: + void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + mu.Lock(); + a = 0; + mu.Unlock(); + } +}; + + +class Foo { + Mutex mu; + int a GUARDED_BY(mu); + +public: + void foo() { + mu.Lock(); // warning? needs !mu? + baz(); // expected-warning {{cannot call function 'baz' while mutex 'mu' is held}} + bar(); + mu.Unlock(); + } + + void bar() { + bar2(); // expected-warning {{calling function 'bar2' requires holding '!mu'}} + } + + void bar2() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + baz(); + } + + void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + mu.Lock(); + a = 0; + mu.Unlock(); + } + + void test() { + Bar b; + b.baz(); // no warning -- in different class. + } +}; + +} // end namespace NegativeRequirements + + +namespace NegativeThreadRoles { + +typedef int __attribute__((capability("role"))) ThreadRole; + +void acquire(ThreadRole R) __attribute__((exclusive_lock_function(R))) __attribute__((no_thread_safety_analysis)) {} +void release(ThreadRole R) __attribute__((unlock_function(R))) __attribute__((no_thread_safety_analysis)) {} + +ThreadRole FlightControl, Logger; + +extern void enque_log_msg(const char *msg); +void log_msg(const char *msg) { + enque_log_msg(msg); +} + +void dispatch_log(const char *msg) __attribute__((requires_capability(!FlightControl))) {} +void dispatch_log2(const char *msg) __attribute__((requires_capability(Logger))) {} + +void flight_control_entry(void) __attribute__((requires_capability(FlightControl))) { + dispatch_log("wrong"); /* expected-warning {{cannot call function 'dispatch_log' while mutex 'FlightControl' is held}} */ + dispatch_log2("also wrong"); /* expected-warning {{calling function 'dispatch_log2' requires holding role 'Logger' exclusively}} */ +} + +void spawn_fake_flight_control_thread(void) { + acquire(FlightControl); + flight_control_entry(); + release(FlightControl); +} + +extern const char *deque_log_msg(void) __attribute__((requires_capability(Logger))); +void logger_entry(void) __attribute__((requires_capability(Logger))) { + const char *msg; + + while ((msg = deque_log_msg())) { + dispatch_log(msg); + } +} + +void spawn_fake_logger_thread(void) { + acquire(Logger); + logger_entry(); + release(Logger); +} + +int main(void) { + spawn_fake_flight_control_thread(); + spawn_fake_logger_thread(); + + for (;;) + ; /* Pretend to dispatch things. */ + + return 0; +} + +} // end namespace NegativeThreadRoles + + +namespace AssertSharedExclusive { + +void doSomething(); + +class Foo { + Mutex mu; + int a GUARDED_BY(mu); + + void test() SHARED_LOCKS_REQUIRED(mu) { + mu.AssertHeld(); + if (a > 0) + doSomething(); + } +}; + +} // end namespace AssertSharedExclusive + + +namespace RangeBasedForAndReferences { + +class Foo { + struct MyStruct { + int a; + }; + + Mutex mu; + int a GUARDED_BY(mu); + MyContainer<int> cntr GUARDED_BY(mu); + MyStruct s GUARDED_BY(mu); + int arr[10] GUARDED_BY(mu); + + void nonref_test() { + int b = a; // expected-warning {{reading variable 'a' requires holding mutex 'mu'}} + b = 0; // no warning + } + + void auto_test() { + auto b = a; // expected-warning {{reading variable 'a' requires holding mutex 'mu'}} + b = 0; // no warning + auto &c = a; // no warning + c = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + } + + void ref_test() { + int &b = a; + int &c = b; + int &d = c; + b = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + c = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + d = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + + MyStruct &rs = s; + rs.a = 0; // expected-warning {{writing variable 's' requires holding mutex 'mu' exclusively}} + + int (&rarr)[10] = arr; + rarr[2] = 0; // expected-warning {{writing variable 'arr' requires holding mutex 'mu' exclusively}} + } + + void ptr_test() { + int *b = &a; + *b = 0; // no expected warning yet + } + + void for_test() { + int total = 0; + for (int i : cntr) { // expected-warning2 {{reading variable 'cntr' requires holding mutex 'mu'}} + total += i; + } + } +}; + + +} // end namespace RangeBasedForAndReferences + + + +namespace PassByRefTest { + +class Foo { +public: + Foo() : a(0), b(0) { } + + int a; + int b; + + void operator+(const Foo& f); + + void operator[](const Foo& g); +}; + +template<class T> +T&& mymove(T& f); + + +// test top-level functions +void copy(Foo f); +void write1(Foo& f); +void write2(int a, Foo& f); +void read1(const Foo& f); +void read2(int a, const Foo& f); +void destroy(Foo&& f); + +void operator/(const Foo& f, const Foo& g); +void operator*(const Foo& f, const Foo& g); + + + + +class Bar { +public: + Mutex mu; + Foo foo GUARDED_BY(mu); + Foo foo2 GUARDED_BY(mu); + Foo* foop PT_GUARDED_BY(mu); + SmartPtr<Foo> foosp PT_GUARDED_BY(mu); + + // test methods. + void mwrite1(Foo& f); + void mwrite2(int a, Foo& f); + void mread1(const Foo& f); + void mread2(int a, const Foo& f); + + // static methods + static void smwrite1(Foo& f); + static void smwrite2(int a, Foo& f); + static void smread1(const Foo& f); + static void smread2(int a, const Foo& f); + + void operator<<(const Foo& f); + + void test1() { + copy(foo); // expected-warning {{reading variable 'foo' requires holding mutex 'mu'}} + write1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + write2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + read1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + read2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + destroy(mymove(foo)); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + + mwrite1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + mwrite2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + mread1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + mread2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + + smwrite1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + smwrite2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + smread1(foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + smread2(10, foo); // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + + foo + foo2; // expected-warning {{reading variable 'foo' requires holding mutex 'mu'}} \ + // expected-warning {{passing variable 'foo2' by reference requires holding mutex 'mu'}} + foo / foo2; // expected-warning {{reading variable 'foo' requires holding mutex 'mu'}} \ + // expected-warning {{passing variable 'foo2' by reference requires holding mutex 'mu'}} + foo * foo2; // expected-warning {{reading variable 'foo' requires holding mutex 'mu'}} \ + // expected-warning {{passing variable 'foo2' by reference requires holding mutex 'mu'}} + foo[foo2]; // expected-warning {{reading variable 'foo' requires holding mutex 'mu'}} \ + // expected-warning {{passing variable 'foo2' by reference requires holding mutex 'mu'}} + (*this) << foo; // expected-warning {{passing variable 'foo' by reference requires holding mutex 'mu'}} + + copy(*foop); // expected-warning {{reading the value pointed to by 'foop' requires holding mutex 'mu'}} + write1(*foop); // expected-warning {{passing the value that 'foop' points to by reference requires holding mutex 'mu'}} + write2(10, *foop); // expected-warning {{passing the value that 'foop' points to by reference requires holding mutex 'mu'}} + read1(*foop); // expected-warning {{passing the value that 'foop' points to by reference requires holding mutex 'mu'}} + read2(10, *foop); // expected-warning {{passing the value that 'foop' points to by reference requires holding mutex 'mu'}} + destroy(mymove(*foop)); // expected-warning {{passing the value that 'foop' points to by reference requires holding mutex 'mu'}} + + copy(*foosp); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + write1(*foosp); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + write2(10, *foosp); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + read1(*foosp); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + read2(10, *foosp); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + destroy(mymove(*foosp)); // expected-warning {{reading the value pointed to by 'foosp' requires holding mutex 'mu'}} + + // TODO -- these requires better smart pointer handling. + copy(*foosp.get()); + write1(*foosp.get()); + write2(10, *foosp.get()); + read1(*foosp.get()); + read2(10, *foosp.get()); + destroy(mymove(*foosp.get())); + } +}; + + +} // end namespace PassByRefTest + diff --git a/test/SemaCXX/warn-thread-safety-negative.cpp b/test/SemaCXX/warn-thread-safety-negative.cpp new file mode 100644 index 000000000000..f88233a60b27 --- /dev/null +++ b/test/SemaCXX/warn-thread-safety-negative.cpp @@ -0,0 +1,104 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions %s + +// FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s +// FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety %s + +#define LOCKABLE __attribute__ ((lockable)) +#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) +#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) +#define GUARDED_VAR __attribute__ ((guarded_var)) +#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x))) +#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var)) +#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) +#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) +#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__))) +#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__))) +#define ASSERT_EXCLUSIVE_LOCK(...) __attribute__ ((assert_exclusive_lock(__VA_ARGS__))) +#define ASSERT_SHARED_LOCK(...) __attribute__ ((assert_shared_lock(__VA_ARGS__))) +#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__))) +#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__))) +#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__))) +#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) +#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) +#define EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__ ((exclusive_locks_required(__VA_ARGS__))) +#define SHARED_LOCKS_REQUIRED(...) \ + __attribute__ ((shared_locks_required(__VA_ARGS__))) +#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) + + +class __attribute__((lockable)) Mutex { + public: + void Lock() __attribute__((exclusive_lock_function)); + void ReaderLock() __attribute__((shared_lock_function)); + void Unlock() __attribute__((unlock_function)); + bool TryLock() __attribute__((exclusive_trylock_function(true))); + bool ReaderTryLock() __attribute__((shared_trylock_function(true))); + void LockWhen(const int &cond) __attribute__((exclusive_lock_function)); + + // for negative capabilities + const Mutex& operator!() const { return *this; } + + void AssertHeld() ASSERT_EXCLUSIVE_LOCK(); + void AssertReaderHeld() ASSERT_SHARED_LOCK(); +}; + + +namespace SimpleTest { + +class Bar { + Mutex mu; + int a GUARDED_BY(mu); + +public: + void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + mu.Lock(); + a = 0; + mu.Unlock(); + } +}; + + +class Foo { + Mutex mu; + int a GUARDED_BY(mu); + +public: + void foo() { + mu.Lock(); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}} + baz(); // expected-warning {{cannot call function 'baz' while mutex 'mu' is held}} + bar(); + mu.Unlock(); + } + + void bar() { + baz(); // expected-warning {{calling function 'baz' requires holding '!mu'}} + } + + void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + mu.Lock(); + a = 0; + mu.Unlock(); + } + + void test() { + Bar b; + b.baz(); // no warning -- in different class. + } + + void test2() { + mu.Lock(); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}} + a = 0; + mu.Unlock(); + baz(); // no warning -- !mu in set. + } + + void test3() EXCLUSIVE_LOCKS_REQUIRED(!mu) { + mu.Lock(); + a = 0; + mu.Unlock(); + baz(); // no warning -- !mu in set. + } +}; + +} // end namespace SimpleTest diff --git a/test/SemaCXX/warn-thread-safety-verbose.cpp b/test/SemaCXX/warn-thread-safety-verbose.cpp new file mode 100644 index 000000000000..4e19f30bf2c3 --- /dev/null +++ b/test/SemaCXX/warn-thread-safety-verbose.cpp @@ -0,0 +1,86 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-verbose -Wno-thread-safety-negative -fcxx-exceptions %s + +#define LOCKABLE __attribute__ ((lockable)) +#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) +#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) +#define GUARDED_VAR __attribute__ ((guarded_var)) +#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x))) +#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var)) +#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) +#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) +#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__))) +#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__))) +#define ASSERT_EXCLUSIVE_LOCK(...) __attribute__ ((assert_exclusive_lock(__VA_ARGS__))) +#define ASSERT_SHARED_LOCK(...) __attribute__ ((assert_shared_lock(__VA_ARGS__))) +#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__))) +#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__))) +#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__))) +#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) +#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) +#define EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__ ((exclusive_locks_required(__VA_ARGS__))) +#define SHARED_LOCKS_REQUIRED(...) \ + __attribute__ ((shared_locks_required(__VA_ARGS__))) +#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) + + +class __attribute__((lockable)) Mutex { + public: + void Lock() __attribute__((exclusive_lock_function)); + void ReaderLock() __attribute__((shared_lock_function)); + void Unlock() __attribute__((unlock_function)); + bool TryLock() __attribute__((exclusive_trylock_function(true))); + bool ReaderTryLock() __attribute__((shared_trylock_function(true))); + void LockWhen(const int &cond) __attribute__((exclusive_lock_function)); + + // for negative capabilities + const Mutex& operator!() const { return *this; } + + void AssertHeld() ASSERT_EXCLUSIVE_LOCK(); + void AssertReaderHeld() ASSERT_SHARED_LOCK(); +}; + + +class Test { + Mutex mu; + int a GUARDED_BY(mu); // expected-note3 {{Guarded_by declared here.}} + + void foo1() EXCLUSIVE_LOCKS_REQUIRED(mu); + void foo2() SHARED_LOCKS_REQUIRED(mu); + void foo3() LOCKS_EXCLUDED(mu); + + void test1() { // expected-note {{Thread warning in function 'test1'}} + a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + } + + void test2() { // expected-note {{Thread warning in function 'test2'}} + int b = a; // expected-warning {{reading variable 'a' requires holding mutex 'mu'}} + } + + void test3() { // expected-note {{Thread warning in function 'test3'}} + foo1(); // expected-warning {{calling function 'foo1' requires holding mutex 'mu' exclusively}} + } + + void test4() { // expected-note {{Thread warning in function 'test4'}} + foo2(); // expected-warning {{calling function 'foo2' requires holding mutex 'mu'}} + } + + void test5() { // expected-note {{Thread warning in function 'test5'}} + mu.ReaderLock(); + foo1(); // expected-warning {{calling function 'foo1' requires holding mutex 'mu' exclusively}} + mu.Unlock(); + } + + void test6() { // expected-note {{Thread warning in function 'test6'}} + mu.ReaderLock(); + a = 0; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} + mu.Unlock(); + } + + void test7() { // expected-note {{Thread warning in function 'test7'}} + mu.Lock(); + foo3(); // expected-warning {{cannot call function 'foo3' while mutex 'mu' is held}} + mu.Unlock(); + } +}; + diff --git a/test/SemaCXX/warn-undefined-bool-conversion.cpp b/test/SemaCXX/warn-undefined-bool-conversion.cpp index 1f8baa0e8d8a..24099f79adc5 100644 --- a/test/SemaCXX/warn-undefined-bool-conversion.cpp +++ b/test/SemaCXX/warn-undefined-bool-conversion.cpp @@ -95,3 +95,27 @@ namespace function_return_reference { // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; pointer may be assumed to always convert to true}} } } + +namespace macros { + #define assert(x) if (x) {} + #define zero_on_null(x) ((x) ? *(x) : 0) + + void test(int &x) { + // TODO: warn on assert(&x) but not on zero_on_null(&x) + zero_on_null(&x); + assert(zero_on_null(&x)); + assert(&x); + + assert(&x && "Expecting valid reference"); + // expected-warning@-1{{reference cannot be bound to dereferenced null pointer in well-defined C++ code; pointer may be assumed to always convert to true}} + } + + class S { + void test() { + assert(this); + + assert(this && "Expecting invalid reference"); + // expected-warning@-1{{'this' pointer cannot be null in well-defined C++ code; pointer may be assumed to always convert to true}} + } + }; +} diff --git a/test/SemaCXX/warn-unused-comparison.cpp b/test/SemaCXX/warn-unused-comparison.cpp index 3afad585b668..a24b5a29a3df 100644 --- a/test/SemaCXX/warn-unused-comparison.cpp +++ b/test/SemaCXX/warn-unused-comparison.cpp @@ -83,6 +83,8 @@ void test() { #define EQ(x,y) (x) == (y) EQ(x, 5); #undef EQ + + (void)sizeof(1 < 2, true); // No warning; unevaluated context. } namespace PR10291 { diff --git a/test/SemaCXX/warn-unused-filescoped.cpp b/test/SemaCXX/warn-unused-filescoped.cpp index df4c47e71787..18defee7d04a 100644 --- a/test/SemaCXX/warn-unused-filescoped.cpp +++ b/test/SemaCXX/warn-unused-filescoped.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -Wno-c++11-extensions -std=c++98 %s -// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -std=c++11 %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -Wno-unused-local-typedefs -Wno-c++11-extensions -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function -Wno-unused-local-typedefs -std=c++11 %s #ifdef HEADER diff --git a/test/SemaCXX/warn-unused-local-typedef-serialize.cpp b/test/SemaCXX/warn-unused-local-typedef-serialize.cpp new file mode 100644 index 000000000000..aa2c48bb5719 --- /dev/null +++ b/test/SemaCXX/warn-unused-local-typedef-serialize.cpp @@ -0,0 +1,11 @@ +// RUN: %clang -x c++-header -c -Wunused-local-typedef %s -o %t.gch -Werror +// RUN: %clang -DBE_THE_SOURCE -c -Wunused-local-typedef -include %t %s -o /dev/null 2>&1 | FileCheck %s +// RUN: %clang -DBE_THE_SOURCE -c -Wunused-local-typedef -include %t %s -o /dev/null 2>&1 | FileCheck %s + +#ifndef BE_THE_SOURCE +inline void myfun() { +// The warning should fire every time the pch file is used, not when it's built. +// CHECK: warning: unused typedef + typedef int a; +} +#endif diff --git a/test/SemaCXX/warn-unused-local-typedef-x86asm.cpp b/test/SemaCXX/warn-unused-local-typedef-x86asm.cpp new file mode 100644 index 000000000000..d7792c0e11eb --- /dev/null +++ b/test/SemaCXX/warn-unused-local-typedef-x86asm.cpp @@ -0,0 +1,16 @@ +// REQUIRES: x86-registered-target +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -std=c++11 -Wunused-local-typedef -verify -fasm-blocks %s +// expected-no-diagnostics +void use_in_asm() { + typedef struct { + int a; + int b; + } A; + __asm mov eax, [eax].A.b + + using Alias = struct { + int a; + int b; + }; + __asm mov eax, [eax].Alias.b +} diff --git a/test/SemaCXX/warn-unused-local-typedef.cpp b/test/SemaCXX/warn-unused-local-typedef.cpp new file mode 100644 index 000000000000..a9406531d2d7 --- /dev/null +++ b/test/SemaCXX/warn-unused-local-typedef.cpp @@ -0,0 +1,242 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-local-typedef -verify -std=c++1y %s + +struct S { + typedef int Foo; // no diag +}; + +namespace N { + typedef int Foo; // no diag + typedef int Foo2; // no diag +} + +template <class T> class Vec {}; + +typedef int global_foo; // no diag + +void f() { + typedef int foo0; // expected-warning {{unused typedef 'foo0'}} + using foo0alias = int ; // expected-warning {{unused type alias 'foo0alias'}} + + typedef int foo1 __attribute__((unused)); // no diag + + typedef int foo2; + { + typedef int foo2; // expected-warning {{unused typedef 'foo2'}} + } + typedef foo2 foo3; // expected-warning {{unused typedef 'foo3'}} + + typedef int foo2_2; // expected-warning {{unused typedef 'foo2_2'}} + { + typedef int foo2_2; + typedef foo2_2 foo3_2; // expected-warning {{unused typedef 'foo3_2'}} + } + + typedef int foo4; + foo4 the_thing; + + typedef int* foo5; + typedef foo5* foo6; // no diag + foo6 *myptr; + + struct S2 { + typedef int Foo; // no diag + typedef int Foo2; // expected-warning {{unused typedef 'Foo2'}} + + struct Deeper { + typedef int DeepFoo; // expected-warning {{unused typedef 'DeepFoo'}} + }; + }; + + S2::Foo s2foo; + + typedef struct {} foostruct; // expected-warning {{unused typedef 'foostruct'}} + + typedef struct {} foostruct2; // no diag + foostruct2 fs2; + + typedef int vecint; // no diag + Vec<vecint> v; + + N::Foo nfoo; + + typedef int ConstExprInt; + static constexpr int a = (ConstExprInt)4; +} + +int printf(char const *, ...); + +void test() { + typedef signed long int superint; // no diag + printf("%f", (superint) 42); + + typedef signed long int superint2; // no diag + printf("%f", static_cast<superint2>(42)); + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-local-typedef" + typedef int trungl_bot_was_here; // no diag +#pragma clang diagnostic pop + + typedef int foo; // expected-warning {{unused typedef 'foo'}} +} + +template <class T> +void template_fun(T t) { + typedef int foo; // expected-warning {{unused typedef 'foo'}} + typedef int bar; // no-diag + bar asdf; + + struct S2 { + typedef int Foo; // no diag + + typedef int Foo2; // expected-warning {{unused typedef 'Foo2'}} + + typedef int Foo3; // no diag + }; + + typename S2::Foo s2foo; + typename T::Foo s3foo; + + typedef typename S2::Foo3 TTSF; // expected-warning {{unused typedef 'TTSF'}} +} +void template_fun_user() { + struct Local { + typedef int Foo; // no-diag + typedef int Bar; // expected-warning {{unused typedef 'Bar'}} + } p; + template_fun(p); +} + +void typedef_in_nested_name() { + typedef struct { + typedef int Foo; + } A; + A::Foo adsf; + + using A2 = struct { + typedef int Foo; + }; + A2::Foo adsf2; +} + +auto sneaky() { + struct S { + // Local typedefs can be used after the scope they were in has closed: + typedef int t; + + // Even if they aren't, this could be an inline function that could be used + // in another TU, so this shouldn't warn either: + typedef int s; + + private: + typedef int p; // expected-warning{{unused typedef 'p'}} + }; + return S(); +} +auto x = sneaky(); +decltype(x)::t y; + +static auto static_sneaky() { + struct S { + typedef int t; + // This function has internal linkage, so we can warn: + typedef int s; // expected-warning {{unused typedef 's'}} + }; + return S(); +} +auto sx = static_sneaky(); +decltype(sx)::t sy; + +auto sneaky_with_friends() { + struct S { + private: + friend class G; + // Can't warn if we have friends: + typedef int p; + }; + return S(); +} + +namespace { +auto nstatic_sneaky() { + struct S { + typedef int t; + // This function has internal linkage, so we can warn: + typedef int s; // expected-warning {{unused typedef 's'}} + }; + return S(); +} +auto nsx = nstatic_sneaky(); +decltype(nsx)::t nsy; +} + +// Like sneaky(), but returning pointer to local type +template<typename T> +struct remove_reference { typedef T type; }; +template<typename T> struct remove_reference<T&> { typedef T type; }; +auto pointer_sneaky() { + struct S { + typedef int t; + typedef int s; + }; + return (S*)nullptr; +} +remove_reference<decltype(*pointer_sneaky())>::type::t py; + +// Like sneaky(), but returning templated struct referencing local type. +template <class T> struct container { int a; T t; }; +auto template_sneaky() { + struct S { + typedef int t; + typedef int s; + }; + return container<S>(); +} +auto tx = template_sneaky(); +decltype(tx.t)::t ty; + +// Like sneaky(), but doing its sneakiness by returning a member function +// pointer. +auto sneaky_memfun() { + struct S { + typedef int type; + int n; + }; + return &S::n; +} + +template <class T> void sneaky_memfun_g(int T::*p) { + typename T::type X; +} + +void sneaky_memfun_h() { + sneaky_memfun_g(sneaky_memfun()); +} + +void typedefs_in_constructors() { + struct A {}; + struct B : public A { + // Neither of these two should warn: + typedef A INHERITED; + B() : INHERITED() {} + + typedef B SELF; + B(int) : SELF() {} + }; +} + +void *operator new(__SIZE_TYPE__, void *p) throw() { return p; } +void placement_new_and_delete() { + struct MyStruct { }; + char memory[sizeof(MyStruct)]; + void *p = memory; + + typedef MyStruct A_t1; + MyStruct *a = new (p) A_t1(); + + typedef MyStruct A_t2; + a->~A_t2(); +} + +// This should not disable any warnings: +#pragma clang diagnostic ignored "-Wunused-local-typedef" diff --git a/test/SemaCXX/warn-unused-private-field-delayed-template.cpp b/test/SemaCXX/warn-unused-private-field-delayed-template.cpp new file mode 100644 index 000000000000..7cafcca643f5 --- /dev/null +++ b/test/SemaCXX/warn-unused-private-field-delayed-template.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -fdelayed-template-parsing -Wunused-private-field -Wused-but-marked-unused -Wno-uninitialized -verify -std=c++11 %s +// expected-no-diagnostics + +class EverythingMayBeUsed { + int x; +public: + template <class T> + void f() { + x = 0; + } +}; diff --git a/test/SemaCXX/warn-unused-result.cpp b/test/SemaCXX/warn-unused-result.cpp index 581af09080db..7bdb4245a95a 100644 --- a/test/SemaCXX/warn-unused-result.cpp +++ b/test/SemaCXX/warn-unused-result.cpp @@ -94,3 +94,50 @@ void Bar() { }; } + +namespace PR18571 { +// Unevaluated contexts should not trigger unused result warnings. +template <typename T> +auto foo(T) -> decltype(f(), bool()) { // Should not warn. + return true; +} + +void g() { + foo(1); +} +} + +namespace std { +class type_info { }; +} + +namespace { +// The typeid expression operand is evaluated only when the expression type is +// a glvalue of polymorphic class type. + +struct B { + virtual void f() {} +}; + +struct D : B { + void f() override {} +}; + +struct C {}; + +void g() { + // The typeid expression operand is evaluated only when the expression type is + // a glvalue of polymorphic class type; otherwise the expression operand is not + // evaluated and should not trigger a diagnostic. + D d; + C c; + (void)typeid(f(), c); // Should not warn. + (void)typeid(f(), d); // expected-warning {{ignoring return value}} expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} + + // The sizeof expression operand is never evaluated. + (void)sizeof(f(), c); // Should not warn. + + // The noexcept expression operand is never evaluated. + (void)noexcept(f(), false); // Should not warn. +} +} diff --git a/test/SemaCXX/warn-unused-value-cxx11.cpp b/test/SemaCXX/warn-unused-value-cxx11.cpp new file mode 100644 index 000000000000..d929b4fd12fb --- /dev/null +++ b/test/SemaCXX/warn-unused-value-cxx11.cpp @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wunused-value %s + +void f() __attribute__((const)); + +namespace PR18571 { +// Unevaluated contexts should not trigger unused result warnings. +template <typename T> +auto foo(T) -> decltype(f(), bool()) { // Should not warn. + return true; +} + +void g() { + foo(1); +} + +void h() { + int i = 0; + (void)noexcept(++i); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + decltype(i++) j = 0; // expected-warning {{expression with side effects has no effect in an unevaluated context}} +} + +struct S { + S operator++(int); + S(int i); + S(); + + int& f(); + S g(); +}; + +void j() { + S s; + int i = 0; + (void)noexcept(s++); // Ok + (void)noexcept(i++); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + (void)noexcept(i = 5); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + (void)noexcept(s = 5); // Ok + + (void)sizeof(s.f()); // Ok + (void)sizeof(s.f() = 5); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + (void)noexcept(s.g() = 5); // Ok +} + +}
\ No newline at end of file diff --git a/test/SemaCXX/warn-unused-value.cpp b/test/SemaCXX/warn-unused-value.cpp index 4e1347cc307a..efabd5063068 100644 --- a/test/SemaCXX/warn-unused-value.cpp +++ b/test/SemaCXX/warn-unused-value.cpp @@ -39,13 +39,13 @@ namespace test2 { void method() const { X* x; &x[0]; // expected-warning {{expression result unused}} - } + } }; typedef basic_string<char> string; - void func(const std::string& str) { + void func(const std::string& str) { str.method(); // expected-note {{in instantiation of member function}} } - } + } } } @@ -69,3 +69,31 @@ void f() { Unused(1, 1); // expected-warning {{expression result unused}} } } + +namespace std { + struct type_info {}; +} + +namespace test4 { +struct Good { Good &f(); }; +struct Bad { virtual Bad& f(); }; + +void f() { + int i = 0; + (void)typeid(++i); // expected-warning {{expression with side effects has no effect in an unevaluated context}} + + Good g; + (void)typeid(g.f()); // Ok; not a polymorphic use of a glvalue. + + // This is a polymorphic use of a glvalue, which results in the typeid being + // evaluated instead of unevaluated. + Bad b; + (void)typeid(b.f()); // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} + + // A dereference of a volatile pointer is a side effecting operation, however + // since it is idiomatic code, and the alternatives induce higher maintenance + // costs, it is allowed. + int * volatile x; + (void)sizeof(*x); // Ok +} +} diff --git a/test/SemaObjC/access-property-getter.m b/test/SemaObjC/access-property-getter.m index afaf82e73106..41827bb3c8a4 100644 --- a/test/SemaObjC/access-property-getter.m +++ b/test/SemaObjC/access-property-getter.m @@ -34,3 +34,20 @@ return 0; } @end + +// rdar://19137815 +#pragma clang diagnostic ignored "-Wunused-getter-return-value" + +@interface NSObject @end + +@interface I : NSObject +@property (copy) id window; +@end + +@implementation I +- (void) Meth { + [self window]; + self.window; +} +@end + diff --git a/test/SemaObjC/arc-jump-block.m b/test/SemaObjC/arc-jump-block.m index 9b06c5a780cc..418d296452b4 100644 --- a/test/SemaObjC/arc-jump-block.m +++ b/test/SemaObjC/arc-jump-block.m @@ -21,15 +21,15 @@ extern __attribute__((visibility("default"))) struct dispatch_queue_s _dispatch_ case 0: dispatch_async((&_dispatch_main_q), ^{ [self pageLeft]; }); // expected-note 3 {{jump enters lifetime of block which strongly captures a variable}} break; - case 2: // expected-error {{switch case is in protected scope}} + case 2: // expected-error {{cannot jump}} dispatch_async((&_dispatch_main_q), ^{ [self pageRight]; }); // expected-note 2 {{jump enters lifetime of block which strongly captures a variable}} break; - case 3: // expected-error {{switch case is in protected scope}} + case 3: // expected-error {{cannot jump}} { dispatch_async((&_dispatch_main_q), ^{ [self pageRight]; }); break; } - case 4: // expected-error {{switch case is in protected scope}} + case 4: // expected-error {{cannot jump}} break; } @@ -90,7 +90,7 @@ int test2(id obj, int state) { // expected-note {{jump enters lifetime of block} (void) ^{ (void) obj; }; return 0; - default: // expected-error {{switch case is in protected scope}} + default: // expected-error {{cannot jump}} return 1; } } diff --git a/test/SemaObjC/arc-repeated-weak.mm b/test/SemaObjC/arc-repeated-weak.mm index 64df92a9afa9..264c598942ae 100644 --- a/test/SemaObjC/arc-repeated-weak.mm +++ b/test/SemaObjC/arc-repeated-weak.mm @@ -425,3 +425,17 @@ void doubleLevelAccessIvar(Test *a, Test *b) { } @end +// rdar://19053620 +@interface NSNull ++ (NSNull *)null; +@end + +@interface INTF @end + +@implementation INTF +- (void) Meth : (id) data +{ + data = data ?: NSNull.null; +} +@end + diff --git a/test/SemaObjC/arc.m b/test/SemaObjC/arc.m index ba7c09f4f9d7..54a7db7b11b1 100644 --- a/test/SemaObjC/arc.m +++ b/test/SemaObjC/arc.m @@ -129,7 +129,7 @@ void test6(unsigned cond) { ; id x; // expected-note {{jump bypasses initialization of retaining variable}} - case 1: // expected-error {{switch case is in protected scope}} + case 1: // expected-error {{cannot jump}} break; } } diff --git a/test/SemaObjC/attr-availability-1.m b/test/SemaObjC/attr-availability-1.m new file mode 100644 index 000000000000..063407adaeee --- /dev/null +++ b/test/SemaObjC/attr-availability-1.m @@ -0,0 +1,116 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin9.0.0 -fsyntax-only -verify %s +// RUN: %clang_cc1 -x objective-c++ -std=c++11 -triple x86_64-apple-darwin9.0.0 -fsyntax-only -verify %s +// RUN: %clang_cc1 -x objective-c++ -std=c++03 -triple x86_64-apple-darwin9.0.0 -fsyntax-only -verify %s +// rdar://18490958 + +@protocol P +- (void)proto_method __attribute__((availability(macosx,introduced=10_1,deprecated=10_2))); // expected-note 2 {{'proto_method' has been explicitly marked deprecated here}} +@end + +@interface A <P> +- (void)method __attribute__((availability(macosx,introduced=10_1,deprecated=10_2))); // expected-note {{'method' has been explicitly marked deprecated here}} + +- (void)overridden __attribute__((availability(macosx,introduced=10_3))); // expected-note{{overridden method is here}} +- (void)overridden2 __attribute__((availability(macosx,introduced=10_3))); +- (void)overridden3 __attribute__((availability(macosx,deprecated=10_3))); +- (void)overridden4 __attribute__((availability(macosx,deprecated=10_3))); // expected-note{{overridden method is here}} +- (void)overridden5 __attribute__((availability(macosx,unavailable))); +- (void)overridden6 __attribute__((availability(macosx,introduced=10_3))); // expected-note{{overridden method is here}} +@end + +// rdar://11475360 +@interface B : A +- (void)method; // NOTE: we expect 'method' to *not* inherit availability. +- (void)overridden __attribute__((availability(macosx,introduced=10_4))); // expected-warning{{overriding method introduced after overridden method on OS X (10_4 vs. 10_3)}} +- (void)overridden2 __attribute__((availability(macosx,introduced=10_2))); +- (void)overridden3 __attribute__((availability(macosx,deprecated=10_4))); +- (void)overridden4 __attribute__((availability(macosx,deprecated=10_2))); // expected-warning{{overriding method deprecated before overridden method on OS X (10_3 vs. 10_2)}} +- (void)overridden5 __attribute__((availability(macosx,introduced=10_3))); +- (void)overridden6 __attribute__((availability(macosx,unavailable))); // expected-warning{{overriding method cannot be unavailable on OS X when its overridden method is available}} +@end + +void f(A *a, B *b) { + [a method]; // expected-warning{{'method' is deprecated: first deprecated in OS X 10.2}} + [b method]; // no-warning + [a proto_method]; // expected-warning{{'proto_method' is deprecated: first deprecated in OS X 10.2}} + [b proto_method]; // expected-warning{{'proto_method' is deprecated: first deprecated in OS X 10.2}} +} + +// Test case for <rdar://problem/11627873>. Warn about +// using a deprecated method when that method is re-implemented in a +// subclass where the redeclared method is not deprecated. +@interface C +- (void) method __attribute__((availability(macosx,introduced=10_1,deprecated=10_2))); // expected-note {{'method' has been explicitly marked deprecated here}} +@end + +@interface D : C +- (void) method; +@end + +@interface E : D +- (void) method; +@end + +@implementation D +- (void) method { + [super method]; // expected-warning {{'method' is deprecated: first deprecated in OS X 10.2}} +} +@end + +@implementation E +- (void) method { + [super method]; // no-warning +} +@end + +// rdar://18059669 +@class NSMutableArray; + +@interface NSDictionary ++ (instancetype)dictionaryWithObjectsAndKeys:(id)firstObject, ... __attribute__((sentinel(0,1))); +@end + +@class NSString; + +extern NSString *NSNibTopLevelObjects __attribute__((availability(macosx,introduced=10_0 ,deprecated=10_8,message="" ))); +id NSNibOwner, topNibObjects; + +@interface AppDelegate (SIEImport) // expected-error {{cannot find interface declaration for 'AppDelegate'}} + +-(void)__attribute__((ibaction))importFromSIE:(id)sender; + +@end + +@implementation AppDelegate (SIEImport) // expected-error {{cannot find interface declaration for 'AppDelegate'}} + +-(void)__attribute__((ibaction))importFromSIE:(id)sender { + + NSMutableArray *topNibObjects; + NSDictionary *nibLoadDict = [NSDictionary dictionaryWithObjectsAndKeys:self, NSNibOwner, topNibObjects, NSNibTopLevelObjects, ((void *)0)]; +} + +@end + +@interface Mixed +- (void)Meth1 __attribute__((availability(macosx,introduced=10.3_0))); // expected-warning {{use same version number separators '_' or '.'}} +- (void)Meth2 __attribute__((availability(macosx,introduced=10_3.1))); // expected-warning {{use same version number separators '_' or '.'}} +@end + +// rdar://18804883 +@protocol P18804883 +- (void)proto_method __attribute__((availability(macosx,introduced=10_1,deprecated=NA))); // means nothing (not deprecated) +@end + +@interface A18804883 <P18804883> +- (void)interface_method __attribute__((availability(macosx,introduced=NA))); // expected-note {{'interface_method' has been explicitly marked unavailable here}} +- (void)strange_method __attribute__((availability(macosx,introduced=NA,deprecated=NA))); // expected-note {{'strange_method' has been explicitly marked unavailable here}} +- (void) always_available __attribute__((availability(macosx,deprecated=NA))); +@end + +void foo (A18804883* pa) { + [pa interface_method]; // expected-error {{'interface_method' is unavailable: not available on OS X}} + [pa proto_method]; + [pa strange_method]; // expected-error {{'strange_method' is unavailable: not available on OS X}} + [pa always_available]; +} + diff --git a/test/SemaObjC/attr-availability.m b/test/SemaObjC/attr-availability.m index 7990b1202e8f..c455bc7acce6 100644 --- a/test/SemaObjC/attr-availability.m +++ b/test/SemaObjC/attr-availability.m @@ -60,3 +60,30 @@ void f(A *a, B *b) { } @end +// rdar://18059669 +@class NSMutableArray; + +@interface NSDictionary ++ (instancetype)dictionaryWithObjectsAndKeys:(id)firstObject, ... __attribute__((sentinel(0,1))); +@end + +@class NSString; + +extern NSString *NSNibTopLevelObjects __attribute__((availability(macosx,introduced=10.0 ,deprecated=10.8,message="" ))); +id NSNibOwner, topNibObjects; + +@interface AppDelegate (SIEImport) // expected-error {{cannot find interface declaration for 'AppDelegate'}} + +-(void)__attribute__((ibaction))importFromSIE:(id)sender; + +@end + +@implementation AppDelegate (SIEImport) // expected-error {{cannot find interface declaration for 'AppDelegate'}} + +-(void)__attribute__((ibaction))importFromSIE:(id)sender { + + NSMutableArray *topNibObjects; + NSDictionary *nibLoadDict = [NSDictionary dictionaryWithObjectsAndKeys:self, NSNibOwner, topNibObjects, NSNibTopLevelObjects, ((void *)0)]; +} + +@end diff --git a/test/SemaObjC/attr-deprecated-pch.m b/test/SemaObjC/attr-deprecated-pch.m new file mode 100644 index 000000000000..2b48aea379a0 --- /dev/null +++ b/test/SemaObjC/attr-deprecated-pch.m @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -DBOTH -verify %s +// If the decls come from a pch, the behavior shouldn't change: +// RUN: %clang_cc1 -x objective-c-header %s -emit-pch -o %t +// RUN: %clang_cc1 -DUSES -include-pch %t -fsyntax-only -verify %s +// expected-no-diagnostics + +// The slightly strange ifdefs are so that the command that builds the gch file +// doesn't need any -D switches, for these would get embedded in the gch. + +#ifndef USES +@interface Interface1 +- (void)partiallyUnavailableMethod; +@end +@interface Interface2 +- (void)partiallyUnavailableMethod __attribute__((unavailable)); +@end +#endif + +#if defined(USES) || defined(BOTH) +void f(id a) { + [a partiallyUnavailableMethod]; // no warning, `a` could be an Interface1. +} +#endif diff --git a/test/SemaObjC/attr-deprecated.m b/test/SemaObjC/attr-deprecated.m index ca30d0a27d88..13ba68db58e6 100644 --- a/test/SemaObjC/attr-deprecated.m +++ b/test/SemaObjC/attr-deprecated.m @@ -1,11 +1,11 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s -// RUN: %clang_cc1 -x objective-c++ -fsyntax-only -verify -Wno-objc-root-class %s +// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-darwin10.4 -verify -Wno-objc-root-class %s +// RUN: %clang_cc1 -x objective-c++ -fsyntax-only -triple x86_64-apple-darwin10.4 -verify -Wno-objc-root-class %s @interface A { int X __attribute__((deprecated)); // expected-note 2 {{'X' has been explicitly marked deprecated here}} } + (void)F __attribute__((deprecated)); // expected-note 2 {{'F' has been explicitly marked deprecated here}} -- (void)f __attribute__((deprecated)); // expected-note 4 {{'f' has been explicitly marked deprecated here}} +- (void)f __attribute__((deprecated)); // expected-note 5 {{'f' has been explicitly marked deprecated here}} @end @implementation A @@ -54,7 +54,7 @@ void t1(A *a) void t2(id a) { - [a f]; + [a f]; // expected-warning {{'f' is deprecated}} } void t3(A<P>* a) @@ -197,18 +197,19 @@ __attribute__((deprecated)) @interface TestBase @property (nonatomic, strong) id object __attribute__((deprecated("deprecated"))); // expected-note {{'object' has been explicitly marked deprecated here}} \ expected-note {{property 'object' is declared deprecated here}} \ -expected-note {{'setObject:' has been explicitly marked deprecated here}} +expected-note {{'setObject:' has been explicitly marked deprecated here}} \ +expected-note {{property declared here}} @end @interface TestDerived : TestBase -@property (nonatomic, strong) id object; +@property (nonatomic, strong) id object; //expected-warning {{auto property synthesis will not synthesize property 'object'; it will be implemented by its superclass}} @end @interface TestUse @end @implementation TestBase @end -@implementation TestDerived @end +@implementation TestDerived @end // expected-note {{detected while default synthesizing properties in class implementation}} @implementation TestUse @@ -227,3 +228,59 @@ expected-note {{'setObject:' has been explicitly marked deprecated here}} @end +// rdar://18848183 +@interface NSString +- (const char *)cString __attribute__((availability(macosx,introduced=10.0 ,deprecated=10.4,message="" ))); // expected-note {{'cString' has been explicitly marked deprecated here}} +@end + +id PID = 0; +const char * func() { + return [PID cString]; // expected-warning {{'cString' is deprecated: first deprecated in OS X 10.4}} +} + +// rdar://18960378 +@interface NSObject ++ (instancetype)alloc; +- (instancetype)init; +@end + +@interface NSLocale +- (instancetype)init __attribute__((unavailable)); +@end + +@interface PLBatteryProperties : NSObject ++ (id)properties; +@end + +@implementation PLBatteryProperties ++ (id)properties { + return [[self alloc] init]; +} +@end + +@implementation UndeclaredImpl // expected-warning{{cannot find interface declaration}} +- (void)partiallyUnavailableMethod {} +@end + +@interface InterfaceWithSameMethodAsUndeclaredImpl +- (void)partiallyUnavailableMethod __attribute__((unavailable)); +@end + +void f(id a) { + [a partiallyUnavailableMethod]; // no warning, `a` could be an UndeclaredImpl. +} + +@interface InterfaceWithImplementation +- (void)anotherPartiallyUnavailableMethod; +@end +@implementation InterfaceWithImplementation +- (void)anotherPartiallyUnavailableMethod {} +@end + +@interface InterfaceWithSameMethodAsInterfaceWithImplementation +- (void)anotherPartiallyUnavailableMethod __attribute__((unavailable)); +@end + +void g(id a) { + [a anotherPartiallyUnavailableMethod]; // no warning, `a` could be an InterfaceWithImplementation. +} diff --git a/test/SemaObjC/autoreleasepool.m b/test/SemaObjC/autoreleasepool.m index 45c749e570c1..c88f1bacca63 100644 --- a/test/SemaObjC/autoreleasepool.m +++ b/test/SemaObjC/autoreleasepool.m @@ -7,7 +7,7 @@ void autoreleasepool_pop(void*); @implementation AUTORP - (void) unregisterTask:(id) task { - goto L; // expected-error {{goto into protected scope}} + goto L; // expected-error {{cannot jump}} @autoreleasepool { // expected-note {{jump bypasses auto release push of @autoreleasepool block}} void *tmp = objc_autoreleasepool_push(); diff --git a/test/SemaObjC/compare-qualified-class.m b/test/SemaObjC/compare-qualified-class.m index 60ef851e1f3f..a52561521444 100644 --- a/test/SemaObjC/compare-qualified-class.m +++ b/test/SemaObjC/compare-qualified-class.m @@ -28,3 +28,38 @@ int main () { classA == classD; // expected-warning {{comparison of distinct pointer types ('Class<SomeProtocol>' and 'Class<SomeProtocol1>')}} } +// rdar://18491222 +@protocol NSObject @end + +@interface NSObject @end +@protocol ProtocolX <NSObject> +@end + +@protocol ProtocolY <NSObject> +@end + +@interface ClassA : NSObject +@end + +@interface ClassB : ClassA <ProtocolY, ProtocolX> +@end + +@interface OtherClass : NSObject +@property (nonatomic, copy) ClassB<ProtocolX> *aProperty; +- (ClassA<ProtocolY> *)aMethod; +- (ClassA<ProtocolY> *)anotherMethod; +@end + +@implementation OtherClass +- (ClassA<ProtocolY> *)aMethod { + // This does not work, even though ClassB subclasses from A and conforms to Y + // because the property type explicity adds ProtocolX conformance + // even though ClassB already conforms to ProtocolX + return self.aProperty; +} +- (ClassA<ProtocolY> *)anotherMethod { + // This works, even though all it is doing is removing an explicit + // protocol conformance that ClassB already conforms to + return (ClassB *)self.aProperty; +} +@end diff --git a/test/SemaObjC/conditional-expr.m b/test/SemaObjC/conditional-expr.m index d8862c584a0d..71e108cce673 100644 --- a/test/SemaObjC/conditional-expr.m +++ b/test/SemaObjC/conditional-expr.m @@ -101,10 +101,10 @@ int f8(int a, A<P0> *x, A *y) { } void f9(int a, A<P0> *x, A<P1> *y) { - id l0 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}} - A<P0> *l1 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}} - A<P1> *l2 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}} - [ (a ? x : y ) intProp ]; // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}} + id l0 = (a ? x : y ); // Ok. y is of A<P1> object type and A is qualified by P0. + A<P0> *l1 = (a ? x : y ); // Ok. y is of A<P1> object type and A is qualified by P0. + A<P1> *l2 = (a ? x : y ); // expected-warning {{incompatible pointer types initializing 'A<P1> *' with an expression of type 'A<P0> *'}} + (void)[ (a ? x : y ) intProp ]; // Ok. Common type is A<P0> * and P0's property intProp is accessed. } void f10(int a, id<P0> x, id y) { @@ -116,5 +116,5 @@ void f11(int a, id<P0> x, id<P1> y) { } void f12(int a, A<P0> *x, A<P1> *y) { - A<P1>* l0 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}} + A<P1>* l0 = (a ? x : y ); // expected-warning {{incompatible pointer types initializing 'A<P1> *' with an expression of type 'A<P0> *'}} } diff --git a/test/SemaObjC/debugger-support.m b/test/SemaObjC/debugger-support.m index 21c096edad43..5dbc3eebfa2c 100644 --- a/test/SemaObjC/debugger-support.m +++ b/test/SemaObjC/debugger-support.m @@ -9,6 +9,6 @@ void test0(id x) { // CHECK-NEXT: [[RESULT:%.*]] = alloca [[A:%.*]], align 4 // CHECK-NEXT: store i8* {{%.*}}, i8** [[X]], // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]], - // CHECK-NEXT: [[T1:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" + // CHECK-NEXT: [[T1:%.*]] = load i8** @OBJC_SELECTOR_REFERENCES_ // CHECK-NEXT: [[T2:%.*]] = call { i64, i64 } bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to { i64, i64 } (i8*, i8*)*)(i8* [[T0]], i8* [[T1]]) } diff --git a/test/SemaObjC/default-synthesize-1.m b/test/SemaObjC/default-synthesize-1.m index f9f2e72eaf94..731aa863e103 100644 --- a/test/SemaObjC/default-synthesize-1.m +++ b/test/SemaObjC/default-synthesize-1.m @@ -124,3 +124,20 @@ // expected-note {{detected while default synthesizing properties in class implementation}} @synthesize x; // expected-error {{cannot synthesize property 'x' with incomplete type 'enum A'}} @end + +// rdar://17774815 +@interface ZXParsedResult +@property (nonatomic, copy, readonly) NSString *description; // expected-note {{property declared here}} +@end + +@interface ZXCalendarParsedResult : ZXParsedResult + +@property (nonatomic, copy, readonly) NSString *description; // expected-warning {{auto property synthesis will not synthesize property 'description'; it will be implemented by its superclass}} + +@end + +@implementation ZXCalendarParsedResult // expected-note {{detected while default synthesizing properties in class implementation}} +- (NSString *) Meth { + return _description; // expected-error {{use of undeclared identifier '_description'}} +} +@end diff --git a/test/SemaObjC/default-synthesize-3.m b/test/SemaObjC/default-synthesize-3.m index c91597462d91..dce9edabb90d 100644 --- a/test/SemaObjC/default-synthesize-3.m +++ b/test/SemaObjC/default-synthesize-3.m @@ -44,7 +44,7 @@ __attribute ((objc_requires_property_definitions)) // expected-error {{'objc_req @interface NSObject @end @protocol Foo @property (readonly) char isFoo; // expected-note {{property declared here}} -@property (readonly) char isNotFree; +@property (readonly) char isNotFree; // expected-note {{property declared here}} @end @interface Bar : NSObject <Foo> @@ -66,10 +66,10 @@ __attribute ((objc_requires_property_definitions)) // expected-error {{'objc_req @property (readwrite) char isFoo; // expected-warning {{auto property synthesis will not synthesize property 'isFoo' because it is 'readwrite' but it will be synthesized 'readonly' via another property}} @property char Property1; // expected-warning {{auto property synthesis will not synthesize property 'Property1' because it cannot share an ivar with another synthesized property}} @property char Property2; -@property (readwrite) char isNotFree; +@property (readwrite) char isNotFree; // expected-warning {{auto property synthesis will not synthesize property 'isNotFree'}} @end -@implementation Baz { +@implementation Baz { // expected-note {{detected while default synthesizing properties in class implementation}} char _isFoo; char _isNotFree; } @@ -90,9 +90,9 @@ __attribute ((objc_requires_property_definitions)) // expected-error {{'objc_req @end @interface B -@property (readonly) id prop; -@property (readonly) id prop1; -@property (readonly) id prop2; +@property (readonly) id prop; // expected-note {{property declared here}} +@property (readonly) id prop1; // expected-note {{property declared here}} +@property (readonly) id prop2; // expected-note {{property declared here}} @end @interface B() @@ -104,12 +104,12 @@ __attribute ((objc_requires_property_definitions)) // expected-error {{'objc_req @end @interface S : B<P1> -@property (assign,readwrite) id prop; -@property (assign,readwrite) id prop1; -@property (assign,readwrite) id prop2; +@property (assign,readwrite) id prop; // expected-warning {{auto property synthesis will not synthesize property 'prop'}} +@property (assign,readwrite) id prop1; // expected-warning {{auto property synthesis will not synthesize property 'prop1'}} +@property (assign,readwrite) id prop2; // expected-warning {{auto property synthesis will not synthesize property 'prop2'}} @end -@implementation S +@implementation S // expected-note 3 {{detected while default synthesizing properties in class implementation}} @end // rdar://14085456 diff --git a/test/SemaObjC/default-synthesize.m b/test/SemaObjC/default-synthesize.m index 9356b9f5b3a3..3f0ae0261daf 100644 --- a/test/SemaObjC/default-synthesize.m +++ b/test/SemaObjC/default-synthesize.m @@ -97,10 +97,10 @@ } @end -@interface SubClass : TopClass <TopProtocol> +@interface SubClass : TopClass <TopProtocol> @end -@implementation SubClass @end +@implementation SubClass @end // rdar://7920807 @interface C @end @@ -138,3 +138,39 @@ @implementation MyClass // expected-warning {{auto property synthesis will not synthesize property 'requiredString' declared in protocol 'MyProtocol'}} @end + +// rdar://18152478 +@protocol NSObject @end +@protocol TMSourceManagerDelegate<NSObject> +@end + +@protocol TMSourceManager <NSObject> +@property (nonatomic, assign) id <TMSourceManagerDelegate> delegate; +@end + +@interface TMSourceManager +@property (nonatomic, assign) id <TMSourceManagerDelegate> delegate; +@end + +@protocol TMTimeZoneManager <TMSourceManager> +@end + +@interface TimeZoneManager : TMSourceManager <TMTimeZoneManager> +@end + +@implementation TimeZoneManager +@end + +// rdar://18179833 +@protocol BaseProt +@property (assign) id prot; +@end + +@interface Base<BaseProt> +@end + +@interface I : Base<BaseProt> +@end + +@implementation I +@end diff --git a/test/SemaObjC/encode-typeof-test.m b/test/SemaObjC/encode-typeof-test.m index 2cda9739681b..fe8f29c3b972 100644 --- a/test/SemaObjC/encode-typeof-test.m +++ b/test/SemaObjC/encode-typeof-test.m @@ -24,3 +24,22 @@ int main() int i; typeof(@encode(typeof(i))) e = @encode(typeof(Intf)); // expected-warning {{initializer-string for char array is too long}} } + +// rdar://9255564 +typedef short short8 __attribute__((ext_vector_type(8))); + +struct foo { + char a; + int b; + long c; + short8 d; + int array[4]; + short int bitfield1:5; + unsigned short bitfield2:11; + char *string; +}; + +const char *RetEncode () { + return @encode(struct foo); // expected-warning {{encoding of 'struct foo' type is incomplete because 'short8' (vector of 8 'short' values) component has unknown encoding}} +} + diff --git a/test/SemaObjC/format-cstrings-warning.m b/test/SemaObjC/format-cstrings-warning.m new file mode 100644 index 000000000000..28fa7ce0dcd8 --- /dev/null +++ b/test/SemaObjC/format-cstrings-warning.m @@ -0,0 +1,79 @@ +// RUN: %clang_cc1 -Wcstring-format-directive -verify -fsyntax-only %s +// rdar://18182443 + +typedef __builtin_va_list __darwin_va_list; +typedef __builtin_va_list va_list; + +@interface NSString +@end + +va_list argList; + +@interface NSString (NSStringExtensionMethods) +- (NSString *)stringByAppendingFormat:(NSString *)format, ... __attribute__((format(__NSString__, 1, 2))); +- (instancetype)initWithFormat:(NSString *)format, ... __attribute__((format(__NSString__, 1, 2))); // expected-note 2 {{method 'initWithFormat:' declared here}} +- (instancetype)initWithFormat:(NSString *)format arguments:(va_list)argList __attribute__((format(__NSString__, 1, 0))); +- (instancetype)initWithFormat:(NSString *)format locale:(id)locale, ... __attribute__((format(__NSString__, 1, 3))); +- (instancetype)initWithFormat:(NSString *)format locale:(id)locale arguments:(va_list)argList __attribute__((format(__NSString__, 1, 0))); ++ (instancetype)stringWithFormat:(NSString *)format, ... __attribute__((format(__NSString__, 1, 2))); // expected-note {{method 'stringWithFormat:' declared here}} ++ (instancetype)localizedStringWithFormat:(NSString *)format, ... __attribute__((format(__NSString__, 1, 2))); // expected-note {{method 'localizedStringWithFormat:' declared here}} +- (void)MyRandomMethod:(NSString *)format locale:(id)locale arguments:(va_list)argList __attribute__((format(__NSString__, 1, 0))); // expected-note {{method 'MyRandomMethod:locale:arguments:' declared here}} +@end + +@interface NSMutableString : NSString +@end + +@interface NSMutableString (NSMutableStringExtensionMethods) + +- (void)appendFormat:(NSString *)format, ... __attribute__((format(__NSString__, 1, 2))); + +@end + +NSString *ns(NSString *pns) { + [pns initWithFormat: @"Number %d length %c name %s", 1, 'a', "something"]; // expected-warning {{using %s directive in NSString which is being passed as a formatting argument to the formatting method}} + [NSString localizedStringWithFormat : @"Hello%s", " There"]; // expected-warning {{using %s directive in NSString which is being passed as a formatting argument to the formatting method}} + [pns initWithFormat : @"Hello%s %d %d", "Hello", 1, 2]; // expected-warning {{using %s directive in NSString which is being passed as a formatting argument to the formatting method}} + [pns MyRandomMethod : @"Hello%s %d %d" locale:0 arguments: argList]; // expected-warning {{using %s directive in NSString which is being passed as a formatting argument to the formatting method}} + return [NSString stringWithFormat : @"Hello%s", " There"]; // expected-warning {{using %s directive in NSString which is being passed as a formatting argument to the formatting method}} +} + + +typedef const struct __CFString * CFStringRef; +typedef struct __CFString * CFMutableStringRef; +typedef const struct __CFAllocator * CFAllocatorRef; + + +typedef const struct __CFDictionary * CFDictionaryRef; + + +extern +CFStringRef CFStringCreateWithFormat(CFAllocatorRef alloc, CFDictionaryRef formatOptions, CFStringRef format, ...) __attribute__((format(CFString, 3, 4))); + +extern +CFStringRef CFStringCreateWithFormatAndArguments(CFAllocatorRef alloc, CFDictionaryRef formatOptions, CFStringRef format, va_list arguments) __attribute__((format(CFString, 3, 0))); // expected-note {{'CFStringCreateWithFormatAndArguments' declared here}} + +extern +void CFStringAppendFormat(CFMutableStringRef theString, CFDictionaryRef formatOptions, CFStringRef format, ...) __attribute__((format(CFString, 3, 4))); + +extern +void CFStringAppendFormatAndArguments(CFMutableStringRef theString, CFDictionaryRef formatOptions, CFStringRef format, va_list arguments) __attribute__((format(CFString, 3, 0))); // expected-note {{'CFStringAppendFormatAndArguments' declared here}} + +void Test1(va_list argList) { + CFAllocatorRef alloc; + CFStringCreateWithFormatAndArguments (alloc, 0, (CFStringRef)@"%s\n", argList); // expected-warning {{using %s directive in CFString which is being passed as a formatting argument to the formatting CFfunction}} + CFStringAppendFormatAndArguments ((CFMutableStringRef)@"AAAA", 0, (CFStringRef)"Hello %s there %d\n", argList); // expected-warning {{using %s directive in CFString which is being passed as a formatting argument to the formatting CFfunction}} + CFStringCreateWithFormatAndArguments (alloc, 0, (CFStringRef)@"%c\n", argList); + CFStringAppendFormatAndArguments ((CFMutableStringRef)@"AAAA", 0, (CFStringRef)"%d\n", argList); +} + +extern void MyNSLog(NSString *format, ...) __attribute__((format(__NSString__, 1, 2))); // expected-note {{'MyNSLog' declared here}} +extern void MyCFStringCreateWithFormat(CFStringRef format, ...) __attribute__((format(__CFString__, 1, 2))); // expected-note {{'MyCFStringCreateWithFormat' declared here}} +extern void XMyNSLog(int, NSString *format, ...) __attribute__((format(__NSString__, 2, 3))); // expected-note {{'XMyNSLog' declared here}} + +void Test2() { + MyNSLog(@"%s\n", "Hello"); // expected-warning {{using %s directive in CFString which is being passed as a formatting argument to the formatting CFfunction}} + + MyCFStringCreateWithFormat((CFStringRef)@"%s", "Hello"); // expected-warning {{using %s directive in CFString which is being passed as a formatting argument to the formatting CFfunction}} + XMyNSLog(4, @"%s\n", "Hello"); // expected-warning {{using %s directive in CFString which is being passed as a formatting argument to the formatting CFfunction}} +} + diff --git a/test/SemaObjC/format-strings-objc.m b/test/SemaObjC/format-strings-objc.m index 49567a710c3a..f4c528cc7ac0 100644 --- a/test/SemaObjC/format-strings-objc.m +++ b/test/SemaObjC/format-strings-objc.m @@ -243,7 +243,7 @@ void testByValueObjectInFormat(Foo *obj) { // <rdar://problem/13557053> void testTypeOf(NSInteger dW, NSInteger dH) { - NSLog(@"dW %d dH %d",({ __typeof__(dW) __a = (dW); __a < 0 ? -__a : __a; }),({ __typeof__(dH) __a = (dH); __a < 0 ? -__a : __a; })); // expected-warning 2 {{values of type 'NSInteger' should not be used as format arguments; add an explicit cast to 'long' instead}} + NSLog(@"dW %d dH %d",({ __typeof__(dW) __a = (dW); __a < 0 ? -__a : __a; }),({ __typeof__(dH) __a = (dH); __a < 0 ? -__a : __a; })); // expected-warning 2 {{format specifies type 'int' but the argument has type 'long'}} } void testUnicode() { diff --git a/test/SemaObjC/iboutlet.m b/test/SemaObjC/iboutlet.m index 63eac9af8a52..7d656a51684a 100644 --- a/test/SemaObjC/iboutlet.m +++ b/test/SemaObjC/iboutlet.m @@ -6,12 +6,10 @@ @class NSView; -#define IBOutlet __attribute__((iboutlet)) - -@interface I +IB_DESIGNABLE @interface I @property (getter = MyGetter, readonly, assign) IBOutlet NSView *myView; // expected-warning {{readonly IBOutlet property 'myView' when auto-synthesized may not work correctly with 'nib' loader}} expected-note {{property should be changed to be readwrite}} -@property (readonly) IBOutlet NSView *myView1; // expected-warning {{readonly IBOutlet property 'myView1' when auto-synthesized may not work correctly with 'nib' loader}} expected-note {{property should be changed to be readwrite}} +IBInspectable @property (readonly) IBOutlet NSView *myView1; // expected-warning {{readonly IBOutlet property 'myView1' when auto-synthesized may not work correctly with 'nib' loader}} expected-note {{property should be changed to be readwrite}} @property (getter = MyGetter, READONLY) IBOutlet NSView *myView2; // expected-warning {{readonly IBOutlet property 'myView2' when auto-synthesized may not work correctly with 'nib' loader}} diff --git a/test/SemaObjC/ivar-lookup.m b/test/SemaObjC/ivar-lookup.m index 938c8eb189a5..57f432c717a1 100644 --- a/test/SemaObjC/ivar-lookup.m +++ b/test/SemaObjC/ivar-lookup.m @@ -99,9 +99,9 @@ extern struct foo x; }; struct S { __typeof(myStatus) __in; // fails. - struct S1 { + struct S1 { // expected-warning {{declaration does not declare anything}} __typeof(myStatus) __in; // fails. - struct S { + struct S { // expected-warning {{declaration does not declare anything}} __typeof(myStatus) __in; // fails. }; }; diff --git a/test/SemaObjC/method-lookup-3.m b/test/SemaObjC/method-lookup-3.m index b3d9c46484c3..ff2c4898a411 100644 --- a/test/SemaObjC/method-lookup-3.m +++ b/test/SemaObjC/method-lookup-3.m @@ -71,3 +71,29 @@ struct test4b { float x, y; }; void test4(id x) { (void) [x test4]; //expected-warning {{multiple methods named 'test4' found}} } + +// rdar://19265296 +#pragma clang diagnostic ignored "-Wobjc-multiple-method-names" +@interface NSObject ++ (id)alloc; ++ (id)class; +- (id) init; +@end + +@class NSString; +@interface A : NSObject +- (instancetype)initWithType:(NSString *)whatever; +@end + +@interface Test : NSObject @end + +@implementation Test ++ (instancetype)foo +{ + return [[[self class] alloc] initWithType:3]; +} +- (instancetype)initWithType:(int)whatever +{ + return [super init]; +} +@end diff --git a/test/SemaObjC/nonnull.m b/test/SemaObjC/nonnull.m index a345eddbf1e4..cacca07240f6 100644 --- a/test/SemaObjC/nonnull.m +++ b/test/SemaObjC/nonnull.m @@ -31,16 +31,16 @@ foo (int i1, int i2, int i3, void (^cp1)(), void (^cp2)(), void (^cp3)()) { func1(cp1, cp2, i1); - func1(0, cp2, i1); // expected-warning {{null passed to a callee which requires a non-null argument}} - func1(cp1, 0, i1); // expected-warning {{null passed to a callee which requires a non-null argument}} + func1(0, cp2, i1); // expected-warning {{null passed to a callee that requires a non-null argument}} + func1(cp1, 0, i1); // expected-warning {{null passed to a callee that requires a non-null argument}} func1(cp1, cp2, 0); - func3(0, i2, cp3, i3); // expected-warning {{null passed to a callee which requires a non-null argument}} - func3(cp3, i2, 0, i3); // expected-warning {{null passed to a callee which requires a non-null argument}} + func3(0, i2, cp3, i3); // expected-warning {{null passed to a callee that requires a non-null argument}} + func3(cp3, i2, 0, i3); // expected-warning {{null passed to a callee that requires a non-null argument}} - func4(0, cp1); // expected-warning {{null passed to a callee which requires a non-null argument}} - func4(cp1, 0); // expected-warning {{null passed to a callee which requires a non-null argument}} + func4(0, cp1); // expected-warning {{null passed to a callee that requires a non-null argument}} + func4(cp1, 0); // expected-warning {{null passed to a callee that requires a non-null argument}} // Shouldn't these emit warnings? Clang doesn't, and neither does GCC. It // seems that the checking should handle Objective-C pointers. @@ -64,7 +64,7 @@ __attribute__((nonnull)) void _dispatch_queue_push_list(dispatch_object_t _head); // no warning void func6(dispatch_object_t _head) { - _dispatch_queue_push_list(0); // expected-warning {{null passed to a callee which requires a non-null argument}} + _dispatch_queue_push_list(0); // expected-warning {{null passed to a callee that requires a non-null argument}} _dispatch_queue_push_list(_head._do); // no warning } @@ -91,10 +91,10 @@ extern void DoSomethingNotNull(void *db) __attribute__((nonnull(1))); @implementation IMP - (void) Meth { NSObject *object; - [object doSomethingWithNonNullPointer:NULL:1:NULL]; // expected-warning 2 {{null passed to a callee which requires a non-null argument}} - [object doSomethingWithNonNullPointer:vp:1:NULL]; // expected-warning {{null passed to a callee which requires a non-null argument}} - [NSObject doSomethingClassyWithNonNullPointer:NULL]; // expected-warning {{null passed to a callee which requires a non-null argument}} - DoSomethingNotNull(NULL); // expected-warning {{null passed to a callee which requires a non-null argument}} + [object doSomethingWithNonNullPointer:NULL:1:NULL]; // expected-warning 2 {{null passed to a callee that requires a non-null argument}} + [object doSomethingWithNonNullPointer:vp:1:NULL]; // expected-warning {{null passed to a callee that requires a non-null argument}} + [NSObject doSomethingClassyWithNonNullPointer:NULL]; // expected-warning {{null passed to a callee that requires a non-null argument}} + DoSomethingNotNull(NULL); // expected-warning {{null passed to a callee that requires a non-null argument}} [object doSomethingWithNonNullPointer:vp:1:vp]; } - (void*) testRetNull { @@ -111,15 +111,15 @@ __attribute__((objc_root_class)) @end void test(TestNonNullParameters *f) { - [f doNotPassNullParameter:0]; // expected-warning {{null passed to a callee which requires a non-null argument}} + [f doNotPassNullParameter:0]; // expected-warning {{null passed to a callee that requires a non-null argument}} [f doNotPassNullParameterArgIndex:0]; // no-warning - [f doNotPassNullOnMethod:0]; // expected-warning {{null passed to a callee which requires a non-null argument}} + [f doNotPassNullOnMethod:0]; // expected-warning {{null passed to a callee that requires a non-null argument}} } void PR18795(int (^g)(const char *h, ...) __attribute__((nonnull(1))) __attribute__((nonnull))) { - g(0); // expected-warning{{null passed to a callee which requires a non-null argument}} + g(0); // expected-warning{{null passed to a callee that requires a non-null argument}} } void PR18795_helper() { - PR18795(0); // expected-warning{{null passed to a callee which requires a non-null argument}} + PR18795(0); // expected-warning{{null passed to a callee that requires a non-null argument}} } diff --git a/test/SemaObjC/objc-cf-audited-warning.m b/test/SemaObjC/objc-cf-audited-warning.m new file mode 100644 index 000000000000..db782299b8ab --- /dev/null +++ b/test/SemaObjC/objc-cf-audited-warning.m @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fobjc-arc -verify %s +// rdar://18222007 + +#if __has_feature(arc_cf_code_audited) +#define CF_IMPLICIT_BRIDGING_ENABLED _Pragma("clang arc_cf_code_audited begin") +#define CF_IMPLICIT_BRIDGING_DISABLED _Pragma("clang arc_cf_code_audited end") +#endif +#define CF_BRIDGED_TYPE(T) __attribute__((objc_bridge(T))) + +typedef const struct CF_BRIDGED_TYPE(NSURL) __CFURL * CFURLRef; +typedef signed long long CFIndex; +typedef unsigned char Boolean; +typedef unsigned char UInt8; +typedef const struct __CFAllocator * CFAllocatorRef; +const CFAllocatorRef kCFAllocatorDefault; + +CF_IMPLICIT_BRIDGING_ENABLED +CFURLRef CFURLCreateFromFileSystemRepresentation(CFAllocatorRef allocator, const UInt8 *buffer, CFIndex bufLen, Boolean isDirectory); // expected-note {{passing argument to parameter 'buffer' here}} +CF_IMPLICIT_BRIDGING_DISABLED + +void saveImageToJPG(const char *filename) +{ + CFURLRef url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, filename, 10, 0); // expected-warning {{passing 'const char *' to parameter of type 'const UInt8 *' (aka 'const unsigned char *') converts between pointers to integer types with different sign}} +} diff --git a/test/SemaObjC/objc-dictionary-literal.m b/test/SemaObjC/objc-dictionary-literal.m index 9d86d88bcbec..f9fd57f2dae2 100644 --- a/test/SemaObjC/objc-dictionary-literal.m +++ b/test/SemaObjC/objc-dictionary-literal.m @@ -3,6 +3,8 @@ // RUN: %clang_cc1 -fsyntax-only -triple i386-apple-macosx10.9.0 -fobjc-runtime=macosx-fragile-10.9.0 -fobjc-subscripting-legacy-runtime -verify %s // rdar://15363492 +#define nil ((void *)0) + @interface NSNumber + (NSNumber *)numberWithChar:(char)value; + (NSNumber *)numberWithInt:(int)value; @@ -15,6 +17,7 @@ typedef long NSInteger; @interface NSDictionary + (id)dictionaryWithObjects:(const id [])objects forKeys:(const id <NSCopying> [])keys count:(NSUInteger)cnt; - (void)setObject:(id)object forKeyedSubscript:(id)key; +- (id)objectForKeyedSubscript:(id)key; @end @interface NSString<NSCopying> @@ -25,12 +28,24 @@ typedef long NSInteger; - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index; @end +void *pvoid; int main() { NSDictionary *dict = @{ @"name":@666 }; dict[@"name"] = @666; dict["name"] = @666; // expected-error {{indexing expression is invalid because subscript type 'char *' is not an Objective-C pointer}} + // rdar://18254621 + [@{@"foo" : @"bar"} objectForKeyedSubscript:nil]; + (void)@{@"foo" : @"bar"}[nil]; + [@{@"foo" : @"bar"} objectForKeyedSubscript:pvoid]; + (void)@{@"foo" : @"bar"}[pvoid]; + + [@{@"foo" : @"bar"} setObject:nil forKeyedSubscript:@"gorf"]; + @{@"foo" : @"bar"}[nil] = @"gorf"; + [@{@"foo" : @"bar"} setObject:pvoid forKeyedSubscript:@"gorf"]; + @{@"foo" : @"bar"}[pvoid] = @"gorf"; + return 0; } diff --git a/test/SemaObjC/objcbridge-attribute-arc.m b/test/SemaObjC/objcbridge-attribute-arc.m index ee2bf07ed47e..ab8cab8d1919 100644 --- a/test/SemaObjC/objcbridge-attribute-arc.m +++ b/test/SemaObjC/objcbridge-attribute-arc.m @@ -221,3 +221,19 @@ void Test9(CFErrorRef2 cf, NSError *ns, NSString *str, Class c, CFUColor2Ref cf2 (void)(__bridge Class)cf; // expected-warning {{'CFErrorRef2' (aka 'struct __CFErrorRef *') bridges to NSError, not 'Class'}} (void)(__bridge CFErrorRef)c; // expected-warning {{'__unsafe_unretained Class' cannot bridge to 'CFErrorRef' (aka 'struct __CFErrorRef *')}} } + +// rdar://19157264 +#if __has_feature(objc_bridge_id) +typedef struct __attribute__((objc_bridge(id))) __CFFoo *CFFooRef; +#endif + +id convert(CFFooRef obj) { + (void)(NSError *)obj; // expected-error {{cast of C pointer type 'CFFooRef' (aka 'struct __CFFoo *') to Objective-C pointer type 'NSError *' requires a bridged cast}} \ + // expected-note {{use __bridge to convert directly (no change in ownership)}} \ + // expected-note {{use __bridge_transfer to transfer ownership of a +1 'CFFooRef' (aka 'struct __CFFoo *') into ARC}} + (void) (__bridge NSError *)obj; + (void) (id)obj; // expected-error {{cast of C pointer type 'CFFooRef' (aka 'struct __CFFoo *') to Objective-C pointer type 'id' requires a bridged cast}} \ + // expected-note {{use __bridge to convert directly (no change in ownership)}} \ + // expected-note {{use __bridge_transfer to transfer ownership of a +1 'CFFooRef' (aka 'struct __CFFoo *') into ARC}} + return (__bridge id)obj; +} diff --git a/test/SemaObjC/property-user-setter.m b/test/SemaObjC/property-user-setter.m index e84fad2394ab..7674c2b3a2cd 100644 --- a/test/SemaObjC/property-user-setter.m +++ b/test/SemaObjC/property-user-setter.m @@ -124,15 +124,16 @@ int main (void) { @synthesize t, T; @synthesize Pxyz, pxyz; - (id) Meth { - self.P = 0; - self.q = 0; + self.P = 0; // expected-warning {{property 'P' not found on object of type 'rdar11363363 *'; did you mean to access property p?}} + self.q = 0; // expected-warning {{property 'q' not found on object of type 'rdar11363363 *'; did you mean to access property Q?}} // rdar://11528439 self.t = 0; // expected-error {{synthesized properties 't' and 'T' both claim setter 'setT:'}} self.T = 0; // expected-error {{synthesized properties 'T' and 't' both claim setter 'setT:'}} self.Pxyz = 0; // expected-error {{synthesized properties 'Pxyz' and 'pxyz' both claim setter 'setPxyz:'}} self.pxyz = 0; // expected-error {{synthesized properties 'pxyz' and 'Pxyz' both claim setter 'setPxyz:'}} - self.R = 0; - return self.R; // expected-error {{no getter method for read from property}} + self.r = 0; + return self.R; // expected-error {{no getter method for read from property}} \ + // expected-warning {{property 'R' not found on object of type 'rdar11363363 *'; did you mean to access property r?}} } @end diff --git a/test/SemaObjC/protocol-expr-1.m b/test/SemaObjC/protocol-expr-1.m index 94a0d9e3e8b5..5ff3db474c75 100644 --- a/test/SemaObjC/protocol-expr-1.m +++ b/test/SemaObjC/protocol-expr-1.m @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s // expected-no-diagnostics -@protocol fproto; +@protocol fproto @end @protocol p1 @end diff --git a/test/SemaObjC/protocol-expr-neg-1.m b/test/SemaObjC/protocol-expr-neg-1.m index 58ac8c0ca322..aed56c016b08 100644 --- a/test/SemaObjC/protocol-expr-neg-1.m +++ b/test/SemaObjC/protocol-expr-neg-1.m @@ -2,7 +2,7 @@ @class Protocol; -@protocol fproto; +@protocol fproto; // expected-note {{'fproto' declared here}} @protocol p1 @end @@ -12,8 +12,23 @@ int main() { Protocol *proto = @protocol(p1); - Protocol *fproto = @protocol(fproto); + Protocol *fproto = @protocol(fproto); // expected-warning {{@protocol is using a forward protocol declaration of fproto}} Protocol *pp = @protocol(i); // expected-error {{cannot find protocol declaration for 'i'}} Protocol *p1p = @protocol(cl); // expected-error {{cannot find protocol declaration for 'cl'}} } +// rdar://17768630 +@protocol SuperProtocol; // expected-note {{'SuperProtocol' declared here}} +@protocol TestProtocol; // expected-note {{'TestProtocol' declared here}} + +@interface I +- (int) conformsToProtocol : (Protocol *)protocl; +@end + +int doesConform(id foo) { + return [foo conformsToProtocol:@protocol(TestProtocol)]; // expected-warning {{@protocol is using a forward protocol declaration of TestProtocol}} +} + +int doesConformSuper(id foo) { + return [foo conformsToProtocol:@protocol(SuperProtocol)]; // expected-warning {{@protocol is using a forward protocol declaration of SuperProtocol}} +} diff --git a/test/SemaObjC/protocols-suppress-conformance.m b/test/SemaObjC/protocols-suppress-conformance.m index 299e44e8074e..a6604b7ff958 100644 --- a/test/SemaObjC/protocols-suppress-conformance.m +++ b/test/SemaObjC/protocols-suppress-conformance.m @@ -5,7 +5,7 @@ __attribute__((objc_protocol_requires_explicit_implementation)) @protocol Protocol - (void) theBestOfTimes; // expected-note {{method 'theBestOfTimes' declared here}} -@property (readonly) id theWorstOfTimes; // expected-note {{property declared here}} +@property (readonly) id theWorstOfTimes; // expected-note {{property declared here}} @end // In this example, ClassA adopts the protocol. We won't @@ -13,14 +13,14 @@ __attribute__((objc_protocol_requires_explicit_implementation)) // be adopted later by a subclass. @interface ClassA <Protocol> - (void) theBestOfTimes; -@property (readonly) id theWorstOfTimes; +@property (readonly) id theWorstOfTimes; // expected-note {{property declared here}} @end // This class subclasses ClassA (which also adopts 'Protocol'). @interface ClassB : ClassA <Protocol> @end -@implementation ClassB // expected-warning {{property 'theWorstOfTimes' requires method 'theWorstOfTimes' to be defined - use @synthesize, @dynamic or provide a method implementation in this class implementation}} +@implementation ClassB // expected-warning {{property 'theWorstOfTimes' requires method 'theWorstOfTimes' to be defined - use @synthesize, @dynamic or provide a method implementation in this class implementation}} @end @interface ClassB_Good : ClassA <Protocol> @@ -32,7 +32,7 @@ __attribute__((objc_protocol_requires_explicit_implementation)) @end @interface ClassB_AlsoGood : ClassA <Protocol> -@property (readonly) id theWorstOfTimes; +@property (readonly) id theWorstOfTimes; // expected-warning {{auto property synthesis will not synthesize property 'theWorstOfTimes'; it will be implemented by its superclass}} @end // Default synthesis acts as if @dynamic @@ -40,7 +40,7 @@ __attribute__((objc_protocol_requires_explicit_implementation)) // it is declared in ClassA. This is okay, since // the author of ClassB_AlsoGood needs explicitly // write @property in the @interface. -@implementation ClassB_AlsoGood // no-warning +@implementation ClassB_AlsoGood // expected-note {{detected while default synthesizing properties in class implementation}} - (void) theBestOfTimes {} @end diff --git a/test/SemaObjC/resolve-method-in-global-pool.m b/test/SemaObjC/resolve-method-in-global-pool.m new file mode 100644 index 000000000000..523856d663f6 --- /dev/null +++ b/test/SemaObjC/resolve-method-in-global-pool.m @@ -0,0 +1,63 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -fblocks -Wno-objc-root-class %s +// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin10 -fsyntax-only -verify -fblocks -Wno-objc-root-class %s +// expected-no-diagnostics + +// rdar://16808765 + +@interface NSObject ++ (void)clsMethod:(int*)arg; +@end + +@class NSDictionary; +@class NSError; + +@interface Foo : NSObject +- (void)getDonuts:(void (^)(NSDictionary *, NSError *))replyBlock; +- (void)getCake:(int*)arg, ...; +@end + +@protocol Protocol +@required +- (void)getDonuts:(void (^)(NSDictionary *))replyBlock; +- (void)getCake:(float*)arg, ...; ++ (void)clsMethod:(float*)arg; +@end + +@implementation Foo +{ + float g; +} + +- (void)getDonuts:(void (^)(NSDictionary *, NSError *))replyBlock { + [(id) 0 getDonuts:^(NSDictionary *replyDict) { }]; +} + +- (void) getCake:(int*)arg, ... { + [(id)0 getCake: &g, 1,3.14]; +} +@end + +void func( Class c, float g ) { + [c clsMethod: &g]; +} + +// rdar://18095772 +@protocol NSKeyedArchiverDelegate @end + +@interface NSKeyedArchiver +@property (assign) id <NSKeyedArchiverDelegate> delegate; +@end + +@interface NSConnection +@property (assign) id delegate; +@end + +extern id NSApp; + +@interface AppDelegate +@end + +AppDelegate* GetDelegate() +{ + return [NSApp delegate]; +} diff --git a/test/SemaObjC/scope-check.m b/test/SemaObjC/scope-check.m index e19ba47ad272..b52e7a06ffc2 100644 --- a/test/SemaObjC/scope-check.m +++ b/test/SemaObjC/scope-check.m @@ -3,9 +3,9 @@ @class A, B, C; void test1() { - goto L; // expected-error{{goto into protected scope}} - goto L2; // expected-error{{goto into protected scope}} - goto L3; // expected-error{{goto into protected scope}} + goto L; // expected-error{{cannot jump}} + goto L2; // expected-error{{cannot jump}} + goto L3; // expected-error{{cannot jump}} @try { // expected-note {{jump bypasses initialization of @try block}} L: ; } @catch (A *x) { // expected-note {{jump bypasses initialization of @catch block}} @@ -17,11 +17,11 @@ L3: ; } @try { - goto L4; // expected-error{{goto into protected scope}} - goto L5; // expected-error{{goto into protected scope}} + goto L4; // expected-error{{cannot jump}} + goto L5; // expected-error{{cannot jump}} } @catch (C *c) { // expected-note {{jump bypasses initialization of @catch block}} L5: ; - goto L6; // expected-error{{goto into protected scope}} + goto L6; // expected-error{{cannot jump}} } @catch (B *c) { // expected-note {{jump bypasses initialization of @catch block}} L6: ; } @finally { // expected-note {{jump bypasses initialization of @finally block}} @@ -32,12 +32,12 @@ L3: ; @try { // expected-note 2 {{jump bypasses initialization of @try block}} L7: ; } @catch (C *c) { - goto L7; // expected-error{{goto into protected scope}} + goto L7; // expected-error{{cannot jump}} } @finally { - goto L7; // expected-error{{goto into protected scope}} + goto L7; // expected-error{{cannot jump}} } - goto L8; // expected-error{{goto into protected scope}} + goto L8; // expected-error{{cannot jump}} @try { } @catch (A *c) { } @catch (B *c) { @@ -47,7 +47,7 @@ L3: ; // rdar://6810106 id X; - goto L9; // expected-error{{goto into protected scope}} + goto L9; // expected-error{{cannot jump}} goto L10; // ok @synchronized // expected-note {{jump bypasses initialization of @synchronized block}} ( ({ L10: ; X; })) { @@ -79,7 +79,7 @@ void test3() { + (void) hello { @try { - goto blargh; // expected-error {{goto into protected scope}} + goto blargh; // expected-error {{cannot jump}} } @catch (...) { // expected-note {{jump bypasses initialization of @catch block}} blargh: ; } @@ -87,14 +87,14 @@ void test3() { + (void)meth2 { int n; void *P; - goto L0; // expected-error {{goto into protected scope}} + goto L0; // expected-error {{cannot jump}} typedef int A[n]; // expected-note {{jump bypasses initialization of VLA typedef}} L0: - goto L1; // expected-error {{goto into protected scope}} + goto L1; // expected-error {{cannot jump}} A b, c[10]; // expected-note 2 {{jump bypasses initialization of variable length array}} L1: - goto L2; // expected-error {{goto into protected scope}} + goto L2; // expected-error {{cannot jump}} A d[n]; // expected-note {{jump bypasses initialization of variable length array}} L2: return; diff --git a/test/SemaObjC/super-property-notation.m b/test/SemaObjC/super-property-notation.m index aa67f0af39dc..2b13a5c0f87c 100644 --- a/test/SemaObjC/super-property-notation.m +++ b/test/SemaObjC/super-property-notation.m @@ -30,7 +30,7 @@ void f0() { // rdar://13349296 __attribute__((objc_root_class)) @interface ClassBase -@property (nonatomic, retain) ClassBase * foo; +@property (nonatomic, retain) ClassBase * foo; // expected-note {{property declared here}} @end @implementation ClassBase @@ -41,10 +41,10 @@ __attribute__((objc_root_class)) @interface ClassBase @end @interface ClassDerived : ClassBase -@property (nonatomic, retain) ClassDerived * foo; +@property (nonatomic, retain) ClassDerived * foo; // expected-warning {{auto property synthesis will not synthesize property 'foo'; it will be implemented by its superclass}} @end -@implementation ClassDerived +@implementation ClassDerived // expected-note {{detected while default synthesizing properties in class implementation}} - (void) Meth:(ClassBase*)foo { super.foo = foo; // must work with no warning [super setFoo:foo]; // works with no warning diff --git a/test/SemaObjC/warn-category-method-deprecated.m b/test/SemaObjC/warn-category-method-deprecated.m new file mode 100644 index 000000000000..349a27a795c2 --- /dev/null +++ b/test/SemaObjC/warn-category-method-deprecated.m @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fsyntax-only -Wno-objc-root-class -verify %s +// rdar://18013929 + +@protocol P +- (void)meth; +@end + +@interface I <P> +@end + +@interface I(cat) +- (void)meth __attribute__((deprecated)); // expected-note {{'meth' has been explicitly marked deprecated here}} +@end + +void foo(I *i) { + [i meth]; // expected-warning {{'meth' is deprecated}} +} diff --git a/test/SemaObjC/warn-explicit-call-initialize.m b/test/SemaObjC/warn-explicit-call-initialize.m new file mode 100644 index 000000000000..99fdf530afd8 --- /dev/null +++ b/test/SemaObjC/warn-explicit-call-initialize.m @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-darwin10 -verify %s +// rdar://16628028 + +@interface NSObject ++ (void)initialize; // expected-note 2 {{method 'initialize' declared here}} +@end + +@interface I : NSObject ++ (void)initialize; // expected-note {{method 'initialize' declared here}} ++ (void)SomeRandomMethod; +@end + +@implementation I +- (void) Meth { + [I initialize]; // expected-warning {{explicit call to +initialize results in duplicate call to +initialize}} + [NSObject initialize]; // expected-warning {{explicit call to +initialize results in duplicate call to +initialize}} +} ++ (void)initialize { + [super initialize]; +} ++ (void)SomeRandomMethod { // expected-note {{method 'SomeRandomMethod' declared here}} + [super initialize]; // expected-warning {{explicit call to [super initialize] should only be in implementation of +initialize}} +} +@end + diff --git a/test/SemaObjC/warn-strict-selector-match.m b/test/SemaObjC/warn-strict-selector-match.m index 34f1712f8b58..9f22e73edc69 100644 --- a/test/SemaObjC/warn-strict-selector-match.m +++ b/test/SemaObjC/warn-strict-selector-match.m @@ -29,8 +29,7 @@ id foo(void) { } @protocol MyObject -- (id)initWithData:(Object *)data; // expected-note {{using}} \ - // expected-note {{passing argument to parameter 'data' here}} +- (id)initWithData:(Object *)data; // expected-note {{using}} @end @protocol SomeOther @@ -54,8 +53,7 @@ id foo(void) { } + (NTGridDataObject*)dataObject:(id<MyObject, MyCoding>)data { - NTGridDataObject *result = [(id)0 initWithData:data]; // expected-warning {{multiple methods named 'initWithData:' found}} \ - expected-warning {{sending 'id<MyObject,MyCoding>' to parameter of incompatible type 'Object *'}} + NTGridDataObject *result = [(id)0 initWithData:data]; // expected-warning {{multiple methods named 'initWithData:' found}} return result; } @end diff --git a/test/SemaObjCXX/arc-ppe.mm b/test/SemaObjCXX/arc-ppe.mm index c9ff81110ddb..193f27316703 100644 --- a/test/SemaObjCXX/arc-ppe.mm +++ b/test/SemaObjCXX/arc-ppe.mm @@ -13,4 +13,4 @@ void test1() { (void)typeid(NP((void*)(id*)0)); } class Poly { virtual ~Poly(); }; Poly& P(void*); -void test2() { (void)typeid(P((void*)(id*)0)); } // expected-error {{pointer to non-const type 'id'}} +void test2() { (void)typeid(P((void*)(id*)0)); } // expected-error {{pointer to non-const type 'id'}} expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} diff --git a/test/SemaObjCXX/synchronized.mm b/test/SemaObjCXX/synchronized.mm new file mode 100644 index 000000000000..37305c5cca8c --- /dev/null +++ b/test/SemaObjCXX/synchronized.mm @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s + +@interface PBXTrackableTaskManager @end +@implementation PBXTrackableTaskManager @end + +struct x { + operator PBXTrackableTaskManager *() const { return 0; } +} a; + +struct y { + operator int *() const { return 0; } +} b; + +void test1() { + @synchronized (a) { + } + + @synchronized (b) { // expected-error {{@synchronized requires an Objective-C object type ('struct y' invalid)}} + } +} diff --git a/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl b/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl new file mode 100644 index 000000000000..50363f23a900 --- /dev/null +++ b/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl @@ -0,0 +1,227 @@ +// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=CL2.0 +// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=CL2.0 +// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=CL2.0 + +/* OpenCLC v2.0 adds a set of restrictions for conversions between pointers to +* different address spaces, mainly described in Sections 6.5.5 and 6.5.6. +* +* It adds notion of overlapping address spaces. The main differention is that +* an unnamed address space is added, called '__generic'. Pointers to the +* generic address space can be interchangabley used with pointers to any +* other address space except for __constant address space (Section 6.5.5). +* +* Based on this there are 3 sets of tests: __generic, named (__global in this +* case), and __constant, that should cover all program paths for CL address +* space conversions used in initialisations, assignments, casts, comparisons +* and arithmetic operations. +*/ + +#ifdef GENERIC +#define AS generic +#endif + +#ifdef GLOBAL +#define AS global +#endif + +#ifdef CONSTANT +#define AS constant +#endif + +void f_glob(global int *arg_glob) {} +#ifndef GLOBAL +// expected-note@-2{{passing argument to parameter 'arg_glob' here}} +#endif + +void f_loc(local int *arg_loc) { +} // expected-note@-1{{passing argument to parameter 'arg_loc' here}} + +void f_const(constant int *arg_const) {} +#ifndef CONSTANT +// expected-note@-2{{passing argument to parameter 'arg_const' here}} +#endif + +void f_priv(private int *arg_priv) { +} // expected-note@-1{{passing argument to parameter 'arg_priv' here}} + +void f_gen(generic int *arg_gen) {} +#ifdef CONSTANT +// expected-note@-2{{passing argument to parameter 'arg_gen' here}} +#endif + +void test_conversion(global int *arg_glob, local int *arg_loc, + constant int *arg_const, private int *arg_priv, + generic int *arg_gen) { + + AS int *var_init1 = arg_glob; +#ifdef CONSTANT +// expected-error@-2{{initializing '__constant int *' with an expression of type '__global int *' changes address space of pointer}} +#endif + + AS int *var_init2 = arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{initializing '__{{global|constant}} int *' with an expression of type '__local int *' changes address space of pointer}} +#endif + + AS int *var_init3 = arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{initializing '__{{global|generic}} int *' with an expression of type '__constant int *' changes address space of pointer}} +#endif + + AS int *var_init4 = arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{initializing '__{{global|constant}} int *' with an expression of type 'int *' changes address space of pointer}} +#endif + + AS int *var_init5 = arg_gen; +#ifndef GENERIC +// expected-error-re@-2{{initializing '__{{global|constant}} int *' with an expression of type '__generic int *' changes address space of pointer}} +#endif + + AS int *var_cast1 = (AS int *)arg_glob; +#ifdef CONSTANT +// expected-error@-2{{casting '__global int *' to type '__constant int *' changes address space of pointer}} +#endif + + AS int *var_cast2 = (AS int *)arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{casting '__local int *' to type '__{{global|constant}} int *' changes address space of pointer}} +#endif + + AS int *var_cast3 = (AS int *)arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{casting '__constant int *' to type '__{{global|generic}} int *' changes address space of pointer}} +#endif + + AS int *var_cast4 = (AS int *)arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{casting 'int *' to type '__{{global|constant}} int *' changes address space of pointer}} +#endif + + AS int *var_cast5 = (AS int *)arg_gen; +#ifdef CONSTANT +// expected-error@-2{{casting '__generic int *' to type '__constant int *' changes address space of pointer}} +#endif + + AS int *var_impl; + var_impl = arg_glob; +#ifdef CONSTANT +// expected-error@-2{{assigning '__global int *' to '__constant int *' changes address space of pointer}} +#endif + + var_impl = arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{assigning '__local int *' to '__{{global|constant}} int *' changes address space of pointer}} +#endif + + var_impl = arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{assigning '__constant int *' to '__{{global|generic}} int *' changes address space of pointer}} +#endif + + var_impl = arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{assigning 'int *' to '__{{global|constant}} int *' changes address space of pointer}} +#endif + + var_impl = arg_gen; +#ifndef GENERIC +// expected-error-re@-2{{assigning '__generic int *' to '__{{global|constant}} int *' changes address space of pointer}} +#endif + + var_cast1 = (AS int *)arg_glob; +#ifdef CONSTANT +// expected-error@-2{{casting '__global int *' to type '__constant int *' changes address space of pointer}} +#endif + + var_cast2 = (AS int *)arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{casting '__local int *' to type '__{{global|constant}} int *' changes address space of pointer}} +#endif + + var_cast3 = (AS int *)arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{casting '__constant int *' to type '__{{global|generic}} int *' changes address space of pointer}} +#endif + + var_cast4 = (AS int *)arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{casting 'int *' to type '__{{global|constant}} int *' changes address space of pointer}} +#endif + + var_cast5 = (AS int *)arg_gen; +#ifdef CONSTANT +// expected-error@-2{{casting '__generic int *' to type '__constant int *' changes address space of pointer}} +#endif + + AS int *var_cmp; + int b = var_cmp != arg_glob; +#ifdef CONSTANT +// expected-error@-2{{comparison between ('__constant int *' and '__global int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_cmp != arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{comparison between ('__{{global|constant}} int *' and '__local int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_cmp == arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{comparison between ('__{{global|generic}} int *' and '__constant int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_cmp <= arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{comparison between ('__{{global|constant}} int *' and 'int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_cmp >= arg_gen; +#ifdef CONSTANT +// expected-error@-2{{comparison between ('__constant int *' and '__generic int *') which are pointers to non-overlapping address spaces}} +#endif + + AS int *var_sub; + b = var_sub - arg_glob; +#ifdef CONSTANT +// expected-error@-2{{arithmetic operation with operands of type ('__constant int *' and '__global int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_sub - arg_loc; +#ifndef GENERIC +// expected-error-re@-2{{arithmetic operation with operands of type ('__{{global|constant}} int *' and '__local int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_sub - arg_const; +#ifndef CONSTANT +// expected-error-re@-2{{arithmetic operation with operands of type ('__{{global|generic}} int *' and '__constant int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_sub - arg_priv; +#ifndef GENERIC +// expected-error-re@-2{{arithmetic operation with operands of type ('__{{global|constant}} int *' and 'int *') which are pointers to non-overlapping address spaces}} +#endif + + b = var_sub - arg_gen; +#ifdef CONSTANT +// expected-error@-2{{arithmetic operation with operands of type ('__constant int *' and '__generic int *') which are pointers to non-overlapping address spaces}} +#endif + + f_glob(var_sub); +#ifndef GLOBAL +// expected-error-re@-2{{passing '__{{constant|generic}} int *' to parameter of type '__global int *' changes address space of pointer}} +#endif + + f_loc(var_sub); // expected-error-re{{passing '__{{global|constant|generic}} int *' to parameter of type '__local int *' changes address space of pointer}} + + f_const(var_sub); +#ifndef CONSTANT +// expected-error-re@-2{{passing '__{{global|generic}} int *' to parameter of type '__constant int *' changes address space of pointer}} +#endif + + f_priv(var_sub); // expected-error-re{{passing '__{{global|constant|generic}} int *' to parameter of type 'int *' changes address space of pointer}} + + f_gen(var_sub); +#ifdef CONSTANT +// expected-error@-2{{passing '__constant int *' to parameter of type '__generic int *' changes address space of pointer}} +#endif +} diff --git a/test/SemaOpenCL/address-spaces.cl b/test/SemaOpenCL/address-spaces.cl index b188ea4576f1..7026d1bc086d 100644 --- a/test/SemaOpenCL/address-spaces.cl +++ b/test/SemaOpenCL/address-spaces.cl @@ -12,14 +12,16 @@ __kernel void foo(__global int *gip) { ip = &ci; // expected-error {{assigning '__constant int *' to 'int *' changes address space of pointer}} } -void explicit_cast(global int* g, local int* l, constant int* c, private int* p) +void explicit_cast(global int* g, local int* l, constant int* c, private int* p, const constant int *cc) { g = (global int*) l; // expected-error {{casting '__local int *' to type '__global int *' changes address space of pointer}} g = (global int*) c; // expected-error {{casting '__constant int *' to type '__global int *' changes address space of pointer}} + g = (global int*) cc; // expected-error {{casting 'const __constant int *' to type '__global int *' changes address space of pointer}} g = (global int*) p; // expected-error {{casting 'int *' to type '__global int *' changes address space of pointer}} l = (local int*) g; // expected-error {{casting '__global int *' to type '__local int *' changes address space of pointer}} l = (local int*) c; // expected-error {{casting '__constant int *' to type '__local int *' changes address space of pointer}} + l = (local int*) cc; // expected-error {{casting 'const __constant int *' to type '__local int *' changes address space of pointer}} l = (local int*) p; // expected-error {{casting 'int *' to type '__local int *' changes address space of pointer}} c = (constant int*) g; // expected-error {{casting '__global int *' to type '__constant int *' changes address space of pointer}} @@ -29,6 +31,7 @@ void explicit_cast(global int* g, local int* l, constant int* c, private int* p) p = (private int*) g; // expected-error {{casting '__global int *' to type 'int *' changes address space of pointer}} p = (private int*) l; // expected-error {{casting '__local int *' to type 'int *' changes address space of pointer}} p = (private int*) c; // expected-error {{casting '__constant int *' to type 'int *' changes address space of pointer}} + p = (private int*) cc; // expected-error {{casting 'const __constant int *' to type 'int *' changes address space of pointer}} } void ok_explicit_casts(global int *g, global int* g2, local int* l, local int* l2, private int* p, private int* p2) diff --git a/test/SemaOpenCL/amdgpu-num-register-attrs.cl b/test/SemaOpenCL/amdgpu-num-register-attrs.cl new file mode 100644 index 000000000000..ec8f8c072a23 --- /dev/null +++ b/test/SemaOpenCL/amdgpu-num-register-attrs.cl @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -triple r600-- -verify -fsyntax-only %s + +typedef __attribute__((amdgpu_num_vgpr(128))) struct FooStruct { // expected-error {{'amdgpu_num_vgpr' attribute only applies to kernel functions}} + int x; + float y; +} FooStruct; + + +__attribute__((amdgpu_num_vgpr("ABC"))) kernel void foo2() {} // expected-error {{'amdgpu_num_vgpr' attribute requires an integer constant}} +__attribute__((amdgpu_num_sgpr("ABC"))) kernel void foo3() {} // expected-error {{'amdgpu_num_sgpr' attribute requires an integer constant}} + + +__attribute__((amdgpu_num_vgpr(40))) void foo4() {} // expected-error {{'amdgpu_num_vgpr' attribute only applies to kernel functions}} +__attribute__((amdgpu_num_sgpr(64))) void foo5() {} // expected-error {{'amdgpu_num_sgpr' attribute only applies to kernel functions}} + +__attribute__((amdgpu_num_vgpr(40))) kernel void foo7() {} +__attribute__((amdgpu_num_sgpr(64))) kernel void foo8() {} +__attribute__((amdgpu_num_vgpr(40), amdgpu_num_sgpr(64))) kernel void foo9() {} + +// Check 0 VGPR is accepted. +__attribute__((amdgpu_num_vgpr(0))) kernel void foo10() {} + +// Check 0 SGPR is accepted. +__attribute__((amdgpu_num_sgpr(0))) kernel void foo11() {} + +// Check both 0 SGPR and VGPR is accepted. +__attribute__((amdgpu_num_vgpr(0), amdgpu_num_sgpr(0))) kernel void foo12() {} + +// Too large VGPR value. +__attribute__((amdgpu_num_vgpr(4294967296))) kernel void foo13() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} + +__attribute__((amdgpu_num_sgpr(4294967296))) kernel void foo14() {} // expected-error {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} + +__attribute__((amdgpu_num_sgpr(4294967296), amdgpu_num_vgpr(4294967296))) kernel void foo15() {} // expected-error 2 {{integer constant expression evaluates to value 4294967296 that cannot be represented in a 32-bit unsigned integer type}} + + +// Make sure it is accepted with kernel keyword before the attribute. +kernel __attribute__((amdgpu_num_vgpr(40))) void foo16() {} + +kernel __attribute__((amdgpu_num_sgpr(40))) void foo17() {} diff --git a/test/SemaOpenCL/extern.cl b/test/SemaOpenCL/extern.cl index ee5e07237f06..b2e4857e28da 100644 --- a/test/SemaOpenCL/extern.cl +++ b/test/SemaOpenCL/extern.cl @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -x cl -cl-std=CL1.2 -emit-llvm %s -o - -verify | FileCheck %s +// RUN: %clang_cc1 -x cl -cl-std=CL1.2 -emit-llvm -ffake-address-space-map %s -o - -verify | FileCheck %s // expected-no-diagnostics -// CHECK: @foo = external global float +// CHECK: @foo = external addrspace(3) constant float extern constant float foo; kernel void test(global float* buf) { diff --git a/test/SemaTemplate/canonical-expr-type.cpp b/test/SemaTemplate/canonical-expr-type.cpp index 4770c4fa3ed6..f8d7d7ec1a27 100644 --- a/test/SemaTemplate/canonical-expr-type.cpp +++ b/test/SemaTemplate/canonical-expr-type.cpp @@ -47,3 +47,11 @@ struct X2 { void f0(type2); void f0(type3); // expected-error{{redeclared}} }; + +// Test canonicalization doesn't conflate different literal suffixes. +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0)]) {} +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0L)]) {} +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0LL)]) {} +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0.f)]) {} +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0.)]) {} +template<typename T> void literal_suffix(int (&)[sizeof(T() + 0.l)]) {} diff --git a/test/SemaTemplate/class-template-decl.cpp b/test/SemaTemplate/class-template-decl.cpp index b721aab35464..c67361bfeafb 100644 --- a/test/SemaTemplate/class-template-decl.cpp +++ b/test/SemaTemplate/class-template-decl.cpp @@ -57,7 +57,7 @@ void f() { template<typename T> class X; // expected-error{{expression}} } -template<typename T> class X1 var; // expected-warning{{variable templates are a C++1y extension}} \ +template<typename T> class X1 var; // expected-warning{{variable templates are a C++14 extension}} \ // expected-error {{variable has incomplete type 'class X1'}} \ // expected-note {{forward declaration of 'X1'}} diff --git a/test/SemaTemplate/constructor-template.cpp b/test/SemaTemplate/constructor-template.cpp index cf3fdfb7c1ea..c5306a6e32f4 100644 --- a/test/SemaTemplate/constructor-template.cpp +++ b/test/SemaTemplate/constructor-template.cpp @@ -54,7 +54,7 @@ struct B { A<int> x; B(B& a) : x(a.x) {} }; struct X2 { X2(); // expected-note{{candidate constructor}} X2(X2&); // expected-note {{candidate constructor}} - template<typename T> X2(T); + template<typename T> X2(T); // expected-note {{candidate template ignored: instantiation would take its own class type by value}} }; X2 test(bool Cond, X2 x2) { @@ -126,3 +126,51 @@ namespace PR8182 { } } + +// Don't blow out the stack trying to call an illegal constructor +// instantiation. We intentionally allow implicit instantiations to +// exist, so make sure they're unusable. +// +// rdar://19199836 +namespace self_by_value { + template <class T, class U> struct A { + A() {} + A(const A<T,U> &o) {} + A(A<T,T> o) {} + }; + + void helper(A<int,float>); + + void test1(A<int,int> a) { + helper(a); + } + void test2() { + helper(A<int,int>()); + } +} + +namespace self_by_value_2 { + template <class T, class U> struct A { + A() {} // expected-note {{not viable: requires 0 arguments}} + A(A<T,U> &o) {} // expected-note {{not viable: expects an l-value}} + A(A<T,T> o) {} // expected-note {{ignored: instantiation takes its own class type by value}} + }; + + void helper_A(A<int,int>); // expected-note {{passing argument to parameter here}} + void test_A() { + helper_A(A<int,int>()); // expected-error {{no matching constructor}} + } +} + +namespace self_by_value_3 { + template <class T, class U> struct A { + A() {} + A(A<T,U> &o) {} + A(A<T,T> o) {} + }; + + void helper_A(A<int,int>); + void test_A(A<int,int> b) { + helper_A(b); + } +} diff --git a/test/SemaTemplate/crash.cpp b/test/SemaTemplate/crash.cpp new file mode 100644 index 000000000000..428e95ccf96e --- /dev/null +++ b/test/SemaTemplate/crash.cpp @@ -0,0 +1,11 @@ +// RUN: not %clang_cc1 -verify %s -std=c++11 + +// PR17730 +template <typename T> +void S<T>::mem1(); + +template <typename T> +void S<T>::mem2() { + const int I = sizeof(T); + (void)I; +} diff --git a/test/SemaTemplate/cxx1z-fold-expressions.cpp b/test/SemaTemplate/cxx1z-fold-expressions.cpp new file mode 100644 index 000000000000..8bb79113fa9d --- /dev/null +++ b/test/SemaTemplate/cxx1z-fold-expressions.cpp @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -std=c++1z -verify %s + +template<typename ...T> constexpr auto sum(T ...t) { return (... + t); } +template<typename ...T> constexpr auto product(T ...t) { return (t * ...); } +template<typename ...T> constexpr auto all(T ...t) { return (true && ... && t); } +template<typename ...T> constexpr auto dumb(T ...t) { return (false && ... && t); } + +static_assert(sum(1, 2, 3, 4, 5) == 15); +static_assert(product(1, 2, 3, 4, 5) == 120); +static_assert(!all(true, true, false, true, false)); +static_assert(all(true, true, true, true, true)); +static_assert(!dumb(true, true, true, true, true)); + +struct S { + int a, b, c, d, e; +}; +template<typename ...T> constexpr auto increment_all(T &...t) { + (++t, ...); +} +constexpr bool check() { + S s = { 1, 2, 3, 4, 5 }; + increment_all(s.a, s.b, s.c, s.d, s.e); + return s.a == 2 && s.b == 3 && s.c == 4 && s.d == 5 && s.e == 6; +} +static_assert(check()); + +template<int ...N> void empty() { + static_assert((N + ...) == 0); + static_assert((N * ...) == 1); + static_assert((N | ...) == 0); + static_assert((N & ...) == -1); + static_assert((N || ...) == false); + static_assert((N && ...) == true); + (N, ...); +} +template void empty<>(); + +// An empty fold-expression isn't a null pointer just because it's an integer +// with value 0. +template<int ...N> void null_ptr() { + void *p = (N + ...); // expected-error {{rvalue of type 'int'}} + void *q = (N | ...); // expected-error {{rvalue of type 'int'}} +} +template void null_ptr<>(); // expected-note {{in instantiation of}} + +template<int ...N> void bad_empty() { + (N - ...); // expected-error {{empty expansion for operator '-' with no fallback}} + (N / ...); // expected-error {{empty expansion for operator '/' with no fallback}} + (N % ...); // expected-error {{empty expansion for operator '%' with no fallback}} + (N = ...); // expected-error {{empty expansion for operator '=' with no fallback}} +} +template void bad_empty<>(); // expected-note {{in instantiation of}} + +template<int ...N> void empty_with_base() { + extern int k; + (k = ... = N); // expected-warning{{unused}} + + void (k = ... = N); // expected-error {{expected ')'}} expected-note {{to match}} + void ((k = ... = N)); + (void) (k = ... = N); +} +template void empty_with_base<>(); // expected-note {{in instantiation of}} +template void empty_with_base<1>(); + +struct A { + struct B { + struct C { + struct D { + int e; + } d; + } c; + } b; +} a; +template<typename T, typename ...Ts> constexpr decltype(auto) apply(T &t, Ts ...ts) { + return (t.*....*ts); +} +static_assert(&apply(a, &A::b, &A::B::c, &A::B::C::d, &A::B::C::D::e) == &a.b.c.d.e); diff --git a/test/SemaTemplate/deduction.cpp b/test/SemaTemplate/deduction.cpp index e9422898c07d..c59f10dbb12e 100644 --- a/test/SemaTemplate/deduction.cpp +++ b/test/SemaTemplate/deduction.cpp @@ -107,7 +107,7 @@ namespace PR7463 { } namespace test0 { - template <class T> void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'char'}} + template <class T> void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'char'}} char *char_maker(); void test() { make(char_maker); // expected-error {{no matching function for call to 'make'}} @@ -191,4 +191,14 @@ namespace PR19372 { using U = BindBack<Z, int, int>::apply<char>; using U = Z<char, int, int>; + + namespace BetterReduction { + template<typename ...> struct S; + template<typename ...A> using X = S<A...>; // expected-note {{parameter}} + template<typename ...A> using Y = X<A..., A...>; + template<typename ...A> using Z = X<A..., 1, 2, 3>; // expected-error {{must be a type}} + + using T = Y<int>; + using T = S<int, int>; + } } diff --git a/test/SemaTemplate/dependent-type-identity.cpp b/test/SemaTemplate/dependent-type-identity.cpp index a796834ce01a..5b9da5d89258 100644 --- a/test/SemaTemplate/dependent-type-identity.cpp +++ b/test/SemaTemplate/dependent-type-identity.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // This test concerns the identity of dependent types within the // canonical type system. This corresponds to C++ [temp.type], which @@ -122,3 +122,24 @@ namespace PR18275 { template struct A<int>; template struct A<int[1]>; } + +namespace PR21289 { + template<typename T> using X = int; + template<typename T, decltype(sizeof(0))> using Y = int; + template<typename ...Ts> struct S {}; + template<typename ...Ts> void f() { + // This is a dependent type. It is *not* S<int>, even though it canonically + // contains no template parameters. + using Type = S<X<Ts>...>; + Type s; + using Type = S<int, int, int>; + } + void g() { f<void, void, void>(); } + + template<typename ...Ts> void h(S<int>) {} + // Pending a core issue, it's not clear if these are redeclarations, but they + // are probably intended to be... even though substitution can succeed for one + // of them but fail for the other! + template<typename ...Ts> void h(S<X<Ts>...>) {} // expected-note {{previous}} + template<typename ...Ts> void h(S<Y<Ts, sizeof(Ts)>...>) {} // expected-error {{redefinition}} +} diff --git a/test/SemaTemplate/derived.cpp b/test/SemaTemplate/derived.cpp index ce20cea7dcc5..cbd004cf6195 100644 --- a/test/SemaTemplate/derived.cpp +++ b/test/SemaTemplate/derived.cpp @@ -4,8 +4,8 @@ template<typename T> class vector2 {}; template<typename T> class vector : vector2<T> {}; -template<typename T> void Foo2(vector2<const T*> V) {} // expected-note{{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'int'}} -template<typename T> void Foo(vector<const T*> V) {} // expected-note {{candidate template ignored: can't deduce a type for 'T' which would make 'const T' equal 'int'}} +template<typename T> void Foo2(vector2<const T*> V) {} // expected-note{{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'int'}} +template<typename T> void Foo(vector<const T*> V) {} // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'int'}} void test() { Foo2(vector2<int*>()); // expected-error{{no matching function for call to 'Foo2'}} diff --git a/test/SemaTemplate/enum-bool.cpp b/test/SemaTemplate/enum-bool.cpp new file mode 100644 index 000000000000..31a96e3488ed --- /dev/null +++ b/test/SemaTemplate/enum-bool.cpp @@ -0,0 +1,11 @@ +// %RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o %t + +enum E : bool { A }; +template <E> +struct S { + struct Inner { + Inner() {} + }; +}; + +template class S<A>; diff --git a/test/SemaTemplate/explicit-instantiation.cpp b/test/SemaTemplate/explicit-instantiation.cpp index c28c5d183150..040a932e9720 100644 --- a/test/SemaTemplate/explicit-instantiation.cpp +++ b/test/SemaTemplate/explicit-instantiation.cpp @@ -1,4 +1,5 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions %s +// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -std=c++11 %s template void *; // expected-error{{expected unqualified-id}} @@ -13,8 +14,8 @@ struct X0 { T f0(T x) { return x + 1; // expected-error{{invalid operands}} - } - T* f0(T*, T*) { return T(); } // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}} + } + T *f0(T *, T *) { return T(); } // expected-warning 0-1 {{expression which evaluates to zero treated as a null pointer constant of type 'int *'}} expected-error 0-1 {{cannot initialize return object of type 'int *' with an rvalue of type 'int'}} template <typename U> T f0(T, U) { return T(); } // expected-note-re {{candidate template ignored: could not match 'int (int, U){{( __attribute__\(\(thiscall\)\))?}}' against 'int (int){{( __attribute__\(\(thiscall\)\))?}} const'}} \ // expected-note {{candidate template ignored: could not match 'int' against 'int *'}} @@ -25,7 +26,7 @@ T X0<T>::value; // expected-error{{no matching constructor}} template int X0<int>::value; -struct NotDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor)}} +struct NotDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor)}} expected-note 0-1 {{candidate constructor (the implicit move constructor)}} NotDefaultConstructible(int); // expected-note{{candidate constructor}} }; @@ -149,3 +150,33 @@ namespace undefined_static_data_member { template int C<int>::b<int>; template int D::c<int>; } + +// expected-note@+1 3-4 {{explicit instantiation refers here}} +template <class T> void Foo(T i) throw(T) { throw i; } +// expected-error@+1 {{exception specification in explicit instantiation does not match instantiated one}} +template void Foo(int a) throw(char); +// expected-error@+1 {{exception specification in explicit instantiation does not match instantiated one}} +template void Foo(double a) throw(); +// expected-error@+1 1 {{exception specification in explicit instantiation does not match instantiated one}} +template void Foo(long a) throw(long, char); +template void Foo(float a); +#if __cplusplus >= 201103L +// expected-error@+1 0-1 {{exception specification in explicit instantiation does not match instantiated one}} +template void Foo(double a) noexcept; +#endif + +#if __cplusplus >= 201103L +namespace PR21942 { +template <int> +struct A { + virtual void foo() final; +}; + +template <> +void A<0>::foo() {} // expected-note{{overridden virtual function is here}} + +struct B : A<0> { + virtual void foo() override; // expected-error{{declaration of 'foo' overrides a 'final' function}} +}; +} +#endif diff --git a/test/SemaTemplate/function-template-specialization-noreturn.cpp b/test/SemaTemplate/function-template-specialization-noreturn.cpp index 3e1f61855a50..672da2725470 100644 --- a/test/SemaTemplate/function-template-specialization-noreturn.cpp +++ b/test/SemaTemplate/function-template-specialization-noreturn.cpp @@ -6,3 +6,15 @@ template <int N> void __attribute__((noreturn)) f3() { __builtin_unreachable(); } template <> void f3<1>() { } // expected-warning {{function declared 'noreturn' should not return}} + +#if __cplusplus >= 201103L +namespace PR21942 { +template <int> +struct A { + void foo[[noreturn]](); +}; + +template <> +void A<0>::foo() {} // expected-warning{{function declared 'noreturn' should not return}} +} +#endif diff --git a/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp b/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp index a376f0e5fd5b..f62ef61758a4 100644 --- a/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp +++ b/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp @@ -58,6 +58,13 @@ namespace dr1330_example { S().f<S>(); // ok S().f<int>(); // expected-note {{instantiation of exception spec}} } + + template<typename T> + struct U { + void f() noexcept(T::error); + void (g)() noexcept(T::error); + }; + U<int> uint; // ok } namespace core_19754_example { @@ -137,3 +144,37 @@ namespace PR12763 { }; void X::g() {} // expected-note {{in instantiation of}} } + +namespace Variadic { + template<bool B> void check() { static_assert(B, ""); } + template<bool B, bool B2, bool ...Bs> void check() { static_assert(B, ""); check<B2, Bs...>(); } + + template<typename ...T> void consume(T...); + + template<typename ...T> void f(void (*...p)() throw (T)) { + void (*q[])() = { p... }; + consume((p(),0)...); + } + template<bool ...B> void g(void (*...p)() noexcept (B)) { + consume((p(),0)...); + check<noexcept(p()) == B ...>(); + } + template<typename ...T> void i() { + consume([]() throw(T) {} ...); + consume([]() noexcept(sizeof(T) == 4) {} ...); + } + template<bool ...B> void j() { + consume([](void (*p)() noexcept(B)) { + void (*q)() noexcept = p; // expected-error {{not superset of source}} + } ...); + } + + void z() { + f<int, char, double>(nullptr, nullptr, nullptr); + g<true, false, true>(nullptr, nullptr, nullptr); + i<int, long, short>(); + j<true, true>(); + j<true, false>(); // expected-note {{in instantiation of}} + } + +} diff --git a/test/SemaTemplate/instantiate-exception-spec.cpp b/test/SemaTemplate/instantiate-exception-spec.cpp index 993ee8dfae1f..d3411722283c 100644 --- a/test/SemaTemplate/instantiate-exception-spec.cpp +++ b/test/SemaTemplate/instantiate-exception-spec.cpp @@ -1,5 +1,7 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -verify %s -DERRORS +// RUN: %clang_cc1 -fexceptions -fcxx-exceptions -emit-llvm-only %s +#ifdef ERRORS template<typename T> void f1(T*) throw(T); // expected-error{{incomplete type 'Incomplete' is not allowed in exception specification}} struct Incomplete; // expected-note{{forward}} @@ -7,3 +9,20 @@ void test_f1(Incomplete *incomplete_p, int *int_p) { f1(int_p); f1(incomplete_p); // expected-note{{instantiation of}} } +#endif + +template<typename T> void f(void (*p)() throw(T)) { +#ifdef ERRORS + void (*q)() throw(char) = p; // expected-error {{target exception spec}} + + extern void (*p2)() throw(T); + void (*q2)() throw(char) = p2; // expected-error {{target exception spec}} + + extern void (*p3)() throw(char); + void (*q3)() throw(T) = p3; // expected-error {{target exception spec}} + + void (*q4)() throw(T) = p2; // ok +#endif + p(); +} +void g() { f<int>(0); } // expected-note {{instantiation of}} diff --git a/test/SemaTemplate/instantiate-expr-1.cpp b/test/SemaTemplate/instantiate-expr-1.cpp index e7772435865d..820ee38e3eab 100644 --- a/test/SemaTemplate/instantiate-expr-1.cpp +++ b/test/SemaTemplate/instantiate-expr-1.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple x86_64-pc-linux-gnu template<int I, int J> struct Bitfields { int simple : I; // expected-error{{bit-field 'simple' has zero width}} diff --git a/test/SemaTemplate/instantiate-init.cpp b/test/SemaTemplate/instantiate-init.cpp index 22c70be3a8dc..e9be60d16c1f 100644 --- a/test/SemaTemplate/instantiate-init.cpp +++ b/test/SemaTemplate/instantiate-init.cpp @@ -115,6 +115,7 @@ namespace PR13064 { struct A { explicit A(int); }; // expected-note{{here}} template<typename T> struct B { T a { 0 }; }; B<A> b; + // expected-note@+1 {{in instantiation of default member initializer}} template<typename T> struct C { T a = { 0 }; }; // expected-error{{explicit}} C<A> c; // expected-note{{here}} } @@ -133,3 +134,12 @@ namespace PR16903 { fun(in); } } + +namespace ReturnStmtIsInitialization { + struct X { + X() {} + X(const X &) = delete; + }; + template<typename T> X f() { return {}; } + auto &&x = f<void>(); +} diff --git a/test/SemaTemplate/instantiate-method.cpp b/test/SemaTemplate/instantiate-method.cpp index 58cb89795558..961884417b54 100644 --- a/test/SemaTemplate/instantiate-method.cpp +++ b/test/SemaTemplate/instantiate-method.cpp @@ -182,3 +182,28 @@ namespace SameSignatureAfterInstantiation { }; S<const int> s; // expected-note {{instantiation}} } + +namespace PR22040 { + template <typename T> struct Foobar { + template <> void bazqux(typename T::type) {} // expected-error {{cannot specialize a function 'bazqux' within class scope}} expected-error 2{{cannot be used prior to '::' because it has no members}} + }; + + void test() { + // FIXME: we should suppress the "no member" errors + Foobar<void>::bazqux(); // expected-error{{no member named 'bazqux' in }} expected-note{{in instantiation of template class }} + Foobar<int>::bazqux(); // expected-error{{no member named 'bazqux' in }} expected-note{{in instantiation of template class }} + Foobar<int>::bazqux(3); // expected-error{{no member named 'bazqux' in }} + } +} + +template <typename> +struct SpecializationOfGlobalFnInClassScope { + template <> + void ::Fn(); // expected-error{{cannot have a qualified name}} +}; + +class AbstractClassWithGlobalFn { + template <typename> + void ::f(); // expected-error{{cannot have a qualified name}} + virtual void f1() = 0; +}; diff --git a/test/SemaTemplate/instantiate-non-dependent-types.cpp b/test/SemaTemplate/instantiate-non-dependent-types.cpp index a0005c56675a..432b9053bdca 100644 --- a/test/SemaTemplate/instantiate-non-dependent-types.cpp +++ b/test/SemaTemplate/instantiate-non-dependent-types.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s template<typename T> struct X1 { static void member() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}} @@ -11,4 +12,41 @@ struct X2 { typedef instantiate<&X1<int>::member> i; // expected-note{{in instantiation of}} }; -X2<int> x; +X2<int> x; + +template <class T, class A> class C { +public: + int i; + void f(T &t) { + T *q = new T(); + t.T::~T(); + q->~T(); + // expected-error@+2 {{'int' is not a class, namespace, or scoped enumeration}} + // expected-error@+1 {{no member named '~Colors' in 'Colors'}} + q->A::~A(); + // expected-error@+2 {{no member named '~int' in 'Q'}} + // expected-error@+1 {{no member named '~Colors' in 'Q'}} + q->~A(); + + delete q; + } +}; + +class Q { +public: + Q() {} + ~Q() {} +}; + +enum Colors {red, green, blue}; + +C<Q, int> dummy; +C<Q, Colors> dummyColors; +int main() { + Q qinst; + // expected-note@+1 {{in instantiation of member function 'C<Q, int>::f' requested here}} + dummy.f(qinst); + // expected-note@+1 {{in instantiation of member function 'C<Q, Colors>::f' requested here}} + dummyColors.f(qinst); +} + diff --git a/test/SemaTemplate/instantiate-scope.cpp b/test/SemaTemplate/instantiate-scope.cpp new file mode 100644 index 000000000000..733105674b7a --- /dev/null +++ b/test/SemaTemplate/instantiate-scope.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s + +template<typename ...T> struct X { + void f(int); + void f(...); + static int n; +}; + +template<typename T, typename U> using A = T; + +// These definitions are OK, X<A<T, decltype(...)>...> is equivalent to X<T...> +// so this defines the member of the primary template. +template<typename ...T> +void X<A<T, decltype(f(T()))>...>::f(int) {} // expected-error {{undeclared}} + +template<typename ...T> +int X<A<T, decltype(f(T()))>...>::n = 0; // expected-error {{undeclared}} + +struct Y {}; void f(Y); + +void g() { + // OK, substitution succeeds. + X<Y>().f(0); + X<Y>::n = 1; + + // Error, substitution fails; this should not be treated as a SFINAE-able + // condition, so we don't select X<void>::f(...). + X<void>().f(0); // expected-note {{instantiation of}} + X<void>::n = 1; // expected-note {{instantiation of}} +} diff --git a/test/SemaTemplate/instantiate-typeof.cpp b/test/SemaTemplate/instantiate-typeof.cpp index 92873cb4b0b6..f4d7847e4fa6 100644 --- a/test/SemaTemplate/instantiate-typeof.cpp +++ b/test/SemaTemplate/instantiate-typeof.cpp @@ -1,10 +1,11 @@ // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +// expected-no-diagnostics // Make sure we correctly treat __typeof as potentially-evaluated when appropriate template<typename T> void f(T n) { - int buffer[n]; // expected-note {{declared here}} - [] { __typeof(buffer) x; }(); // expected-error {{variable 'buffer' with variably modified type cannot be captured in a lambda expression}} + int buffer[n]; + [&buffer] { __typeof(buffer) x; }(); } int main() { - f<int>(1); // expected-note {{in instantiation}} + f<int>(1); } diff --git a/test/SemaTemplate/lookup-dependent-bases.cpp b/test/SemaTemplate/lookup-dependent-bases.cpp index 61fca4a2a45f..f7867d8339bb 100644 --- a/test/SemaTemplate/lookup-dependent-bases.cpp +++ b/test/SemaTemplate/lookup-dependent-bases.cpp @@ -1,20 +1,55 @@ // RUN: %clang_cc1 -fms-compatibility -fsyntax-only -verify %s -// expected-no-diagnostics -class C { -public: - static void foo2() { } +namespace basic { +struct C { + static void foo2() {} }; -template <class T> -class A { -public: - typedef C D; +template <typename T> +struct A { + typedef C D; }; -template <class T> -class B : public A<T> { -public: - void foo() { - D::foo2(); - } +template <typename T> +struct B : A<T> { + void foo() { + D::foo2(); // expected-warning {{use of undeclared identifier 'D'; unqualified lookup into dependent bases of class template 'B' is a Microsoft extension}} + } }; + +template struct B<int>; // Instantiation has no warnings. +} + +namespace nested_nodep_base { +// There are limits to our hacks, MSVC accepts this, but we don't. +struct A { + struct D { static void foo2(); }; +}; +template <typename T> +struct B : T { + struct C { + void foo() { + D::foo2(); // expected-error {{use of undeclared identifier 'D'}} + } + }; +}; + +template struct B<A>; // Instantiation has no warnings. +} + +namespace nested_dep_base { +// We actually accept this because the inner class has a dependent base even +// though it isn't a template. +struct A { + struct D { static void foo2(); }; +}; +template <typename T> +struct B { + struct C : T { + void foo() { + D::foo2(); // expected-warning {{use of undeclared identifier 'D'; unqualified lookup into dependent bases of class template 'C' is a Microsoft extension}} + } + }; +}; + +template struct B<A>; // Instantiation has no warnings. +} diff --git a/test/SemaTemplate/ms-lookup-template-base-classes.cpp b/test/SemaTemplate/ms-lookup-template-base-classes.cpp index 40f73c0d9e64..979782f1cba8 100644 --- a/test/SemaTemplate/ms-lookup-template-base-classes.cpp +++ b/test/SemaTemplate/ms-lookup-template-base-classes.cpp @@ -220,7 +220,8 @@ template <typename T> struct C : T { int *bar() { return &b; } // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}} expected-warning {{lookup into dependent bases}} int baz() { return T::b; } // expected-error {{no member named 'b' in 'PR16014::A'}} int T::*qux() { return &T::b; } // expected-error {{no member named 'b' in 'PR16014::A'}} - int T::*fuz() { return &U::a; } // expected-error {{use of undeclared identifier 'U'}} + int T::*fuz() { return &U::a; } // expected-error {{use of undeclared identifier 'U'}} \ + // expected-warning {{unqualified lookup into dependent bases of class template 'C'}} }; template struct B<A>; @@ -249,7 +250,8 @@ struct A : T { ::UndefClass::undef(); // expected-error {{no member named 'UndefClass' in the global namespace}} } void baz() { - B::qux(); // expected-error {{use of undeclared identifier 'B'}} + B::qux(); // expected-error {{use of undeclared identifier 'B'}} \ + // expected-warning {{unqualified lookup into dependent bases of class template 'A'}} } }; @@ -460,3 +462,31 @@ template <typename T> struct D : C<T> { int x = f<NameFromBase>(); }; } + +namespace function_template_undef_impl { +template<class T> +void f() { + Undef::staticMethod(); // expected-error {{use of undeclared identifier 'Undef'}} + UndefVar.method(); // expected-error {{use of undeclared identifier 'UndefVar'}} +} +} + +namespace PR20716 { +template <template <typename T> class A> +struct B : A<int> +{ + XXX x; // expected-error {{unknown type name}} +}; + +template <typename T> +struct C {}; + +template <typename T> +using D = C<T>; + +template <typename T> +struct E : D<T> +{ + XXX x; // expected-error {{unknown type name}} +}; +} diff --git a/test/SemaTemplate/pack-deduction.cpp b/test/SemaTemplate/pack-deduction.cpp index f3f969e9af00..84eefa63d215 100644 --- a/test/SemaTemplate/pack-deduction.cpp +++ b/test/SemaTemplate/pack-deduction.cpp @@ -37,3 +37,31 @@ namespace RetainExprPacks { template<typename ...Ts> int g(X<Ts...>, decltype(f(Ts()...))); int n = g<int, int>(X<int, int, int>(), 0); } + +namespace PR14615 { + namespace comment0 { + template <class A, class...> struct X {}; + template <class... B> struct X<int, B...> { + typedef int type; + struct valid {}; + }; + template <typename A, typename... B, typename T = X<A, B...>, + typename = typename T::valid> + typename T::type check(int); + int i = check<int, char>(1); + } + + namespace comment2 { + template <class...> struct X; + template <typename... B, typename X<B...>::type I = 0> + char check(B...); // expected-note {{undefined template 'PR14615::comment2::X<char, int>'}} + void f() { check<char>(1, 2); } // expected-error {{no matching function}} + } + + namespace comment3 { + template <class...> struct X; + template <typename... B, typename X<B...>::type I = (typename X<B...>::type)0> + char check(B...); // expected-note {{undefined template 'PR14615::comment3::X<char, int>'}} + void f() { check<char>(1, 2); } // expected-error {{no matching function}} + } +} diff --git a/test/SemaTemplate/temp_arg_enum_printing.cpp b/test/SemaTemplate/temp_arg_enum_printing.cpp new file mode 100644 index 000000000000..a788975b20dd --- /dev/null +++ b/test/SemaTemplate/temp_arg_enum_printing.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -ast-print %s | FileCheck %s + +namespace NamedEnumNS +{ + +enum NamedEnum +{ + Val0, + Val1 +}; + +template <NamedEnum E> +void foo(); + +void test() { + // CHECK: template <NamedEnumNS::NamedEnum E = NamedEnumNS::NamedEnum::Val0> + NamedEnumNS::foo<Val0>(); + // CHECK: template <NamedEnumNS::NamedEnum E = NamedEnumNS::NamedEnum::Val1> + NamedEnumNS::foo<(NamedEnum)1>(); + // CHECK: template <NamedEnumNS::NamedEnum E = 2> + NamedEnumNS::foo<(NamedEnum)2>(); +} + +} // NamedEnumNS diff --git a/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp b/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp new file mode 100644 index 000000000000..5000927d8941 --- /dev/null +++ b/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp @@ -0,0 +1,150 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s + +template<typename T, T val> struct A {}; + +template<typename T, typename U> constexpr bool is_same = false; // expected-note +{{here}} +template<typename T> constexpr bool is_same<T, T> = true; + +namespace String { + A<const char*, "test"> a; // expected-error {{does not refer to any declaration}} + A<const char (&)[5], "test"> b; // expected-error {{does not refer to any declaration}} +} + +namespace Array { + char arr[3]; + char x; + A<const char*, arr> a; + A<const char(&)[3], arr> b; + A<const char*, &arr[0]> c; + A<const char*, &arr[1]> d; // expected-error {{refers to subobject '&arr[1]'}} + A<const char*, (&arr)[0]> e; + A<const char*, &x> f; + A<const char*, &(&x)[0]> g; + A<const char*, &(&x)[1]> h; // expected-error {{refers to subobject '&x + 1'}} + A<const char*, 0> i; // expected-error {{not allowed in a converted constant}} + A<const char*, nullptr> j; +} + +namespace Function { + void f(); + void g() noexcept; + void h(); + void h(int); + template<typename...T> void i(T...); + typedef A<void (*)(), f> a; + typedef A<void (*)(), &f> a; + typedef A<void (*)(), g> b; + typedef A<void (*)(), &g> b; + typedef A<void (*)(), h> c; + typedef A<void (*)(), &h> c; + typedef A<void (*)(), i> d; + typedef A<void (*)(), &i> d; + typedef A<void (*)(), i<>> d; + typedef A<void (*)(), i<int>> e; // expected-error {{is not implicitly convertible}} + + typedef A<void (*)(), 0> x; // expected-error {{not allowed in a converted constant}} + typedef A<void (*)(), nullptr> y; +} + +void Func() { + A<const char*, __func__> a; // expected-error {{does not refer to any declaration}} +} + +namespace LabelAddrDiff { + void f() { + a: b: A<int, __builtin_constant_p(true) ? (__INTPTR_TYPE__)&&b - (__INTPTR_TYPE__)&&a : 0> s; // expected-error {{label address difference}} + }; +} + +namespace Temp { + struct S { int n; }; + constexpr S &addr(S &&s) { return s; } + A<S &, addr({})> a; // expected-error {{constant}} expected-note 2{{temporary}} + A<S *, &addr({})> b; // expected-error {{constant}} expected-note 2{{temporary}} + A<int &, addr({}).n> c; // expected-error {{constant}} expected-note 2{{temporary}} + A<int *, &addr({}).n> d; // expected-error {{constant}} expected-note 2{{temporary}} +} + +namespace std { struct type_info; } + +namespace RTTI { + A<const std::type_info&, typeid(int)> a; // expected-error {{does not refer to any declaration}} + A<const std::type_info*, &typeid(int)> b; // expected-error {{does not refer to any declaration}} +} + +namespace PtrMem { + struct B { int b; }; + struct C : B {}; + struct D : B {}; + struct E : C, D { int e; }; + + constexpr int B::*b = &B::b; + constexpr int C::*cb = b; + constexpr int D::*db = b; + constexpr int E::*ecb = cb; // expected-note +{{here}} + constexpr int E::*edb = db; // expected-note +{{here}} + + constexpr int E::*e = &E::e; + constexpr int D::*de = (int D::*)e; + constexpr int C::*ce = (int C::*)e; + constexpr int B::*bde = (int B::*)de; // expected-note +{{here}} + constexpr int B::*bce = (int B::*)ce; // expected-note +{{here}} + + // FIXME: This should all be accepted, but we don't yet have a representation + // nor mangling for this form of template argument. + using Ab = A<int B::*, b>; + using Ab = A<int B::*, &B::b>; + using Abce = A<int B::*, bce>; // expected-error {{not supported}} + using Abde = A<int B::*, bde>; // expected-error {{not supported}} + static_assert(!is_same<Ab, Abce>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} + static_assert(!is_same<Ab, Abde>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} + static_assert(!is_same<Abce, Abde>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}} + static_assert(is_same<Abce, A<int B::*, (int B::*)(int C::*)&E::e>, ""); // expected-error {{undeclared}} expected-error {{not supported}} + + using Ae = A<int E::*, e>; + using Ae = A<int E::*, &E::e>; + using Aecb = A<int E::*, ecb>; // expected-error {{not supported}} + using Aedb = A<int E::*, edb>; // expected-error {{not supported}} + static_assert(!is_same<Ae, Aecb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} + static_assert(!is_same<Ae, Aedb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} + static_assert(!is_same<Aecb, Aedb>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}} + static_assert(is_same<Aecb, A<int E::*, (int E::*)(int C::*)&B::b>, ""); // expected-error {{undeclared}} expected-error {{not supported}} + + using An = A<int E::*, nullptr>; + using A0 = A<int E::*, (int E::*)0>; + static_assert(is_same<An, A0>); +} + +namespace DeduceDifferentType { + template<int N> struct A {}; + template<long N> int a(A<N>); // expected-note {{does not have the same type}} + int a_imp = a(A<3>()); // expected-error {{no matching function}} + int a_exp = a<3>(A<3>()); + + template<decltype(nullptr)> struct B {}; + template<int *P> int b(B<P>); // expected-note {{could not match}} expected-note {{not implicitly convertible}} + int b_imp = b(B<nullptr>()); // expected-error {{no matching function}} + int b_exp = b<nullptr>(B<nullptr>()); // expected-error {{no matching function}} + + struct X { constexpr operator int() { return 0; } } x; + template<X &> struct C {}; + template<int N> int c(C<N>); // expected-note {{does not have the same type}} expected-note {{not implicitly convertible}} + int c_imp = c(C<x>()); // expected-error {{no matching function}} + int c_exp = c<x>(C<x>()); // expected-error {{no matching function}} + + struct Z; + struct Y { constexpr operator Z&(); } y; + struct Z { constexpr operator Y&() { return y; } } z; + constexpr Y::operator Z&() { return z; } + template<Y &> struct D {}; + template<Z &z> int d(D<z>); // expected-note {{does not have the same type}} + int d_imp = d(D<y>()); // expected-error {{no matching function}} + int d_exp = d<y>(D<y>()); +} + +namespace DeclMatch { + template<typename T, T> int f(); + template<typename T> class X { friend int f<T, 0>(); static int n; }; + template<typename T, T> int f() { return X<T>::n; } + int k = f<int, 0>(); // ok, friend +} diff --git a/test/SemaTemplate/virtual-member-functions.cpp b/test/SemaTemplate/virtual-member-functions.cpp index a23bf4e3ee5e..c2fc2634edd6 100644 --- a/test/SemaTemplate/virtual-member-functions.cpp +++ b/test/SemaTemplate/virtual-member-functions.cpp @@ -3,19 +3,17 @@ namespace PR5557 { template <class T> struct A { - A(); - virtual void anchor(); + A(); // expected-note{{instantiation}} virtual int a(T x); }; template<class T> A<T>::A() {} -template<class T> void A<T>::anchor() { } template<class T> int A<T>::a(T x) { return *x; // expected-error{{requires pointer operand}} } -void f(A<int> x) { - x.anchor(); // expected-note{{instantiation}} +void f() { + A<int> x; // expected-note{{instantiation}} } template<typename T> @@ -27,6 +25,24 @@ template<> void X<int>::f() { } } +// Like PR5557, but with a defined destructor instead of a defined constructor. +namespace PR5557_dtor { +template <class T> struct A { + A(); // Don't have an implicit constructor. + ~A(); // expected-note{{instantiation}} + virtual int a(T x); +}; +template<class T> A<T>::~A() {} + +template<class T> int A<T>::a(T x) { + return *x; // expected-error{{requires pointer operand}} +} + +void f() { + A<int> x; // expected-note{{instantiation}} +} +} + template<typename T> struct Base { virtual ~Base() { diff --git a/test/Tooling/auto-detect-from-source-parent-of-cwd.cpp b/test/Tooling/auto-detect-from-source-parent-of-cwd.cpp index d7ec3f60ac7c..6a97f310ff32 100644 --- a/test/Tooling/auto-detect-from-source-parent-of-cwd.cpp +++ b/test/Tooling/auto-detect-from-source-parent-of-cwd.cpp @@ -11,6 +11,3 @@ invalid; // REQUIRES: shell -// PR15590 -// XFAIL: win64 -// XFAIL: mingw diff --git a/test/Tooling/auto-detect-from-source-parent.cpp b/test/Tooling/auto-detect-from-source-parent.cpp index 5f27d5ab8051..830d09d6a0e0 100644 --- a/test/Tooling/auto-detect-from-source-parent.cpp +++ b/test/Tooling/auto-detect-from-source-parent.cpp @@ -1,12 +1,8 @@ // RUN: rm -rf %t // RUN: mkdir -p %t/abc/def/ijk/qwe -// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %t/abc/def/ijk/qwe/test.cpp\",\"file\":\"%t/abc/def/ijk/qwe/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json +// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/abc/def/ijk/qwe/test.cpp\",\"file\":\"%/t/abc/def/ijk/qwe/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json // RUN: cp "%s" "%t/abc/def/ijk/qwe/test.cpp" // RUN: not clang-check "%t/abc/def/ijk/qwe/test.cpp" 2>&1 | FileCheck %s // CHECK: C++ requires invalid; - -// REQUIRES: shell -// PR15590 -// XFAIL: win64 diff --git a/test/Tooling/auto-detect-from-source.cpp b/test/Tooling/auto-detect-from-source.cpp index 6ff39acdc8c2..12a660d585a9 100644 --- a/test/Tooling/auto-detect-from-source.cpp +++ b/test/Tooling/auto-detect-from-source.cpp @@ -1,12 +1,8 @@ // RUN: rm -rf %t // RUN: mkdir %t -// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %t/test.cpp\",\"file\":\"%t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json +// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/test.cpp\",\"file\":\"%/t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json // RUN: cp "%s" "%t/test.cpp" // RUN: not clang-check "%t/test.cpp" 2>&1 | FileCheck %s // CHECK: C++ requires invalid; - -// REQUIRES: shell -// PR15590 -// XFAIL: win64 diff --git a/test/Tooling/clang-check-autodetect-dir.cpp b/test/Tooling/clang-check-autodetect-dir.cpp index 8ef3f3d01734..b84f3fede888 100644 --- a/test/Tooling/clang-check-autodetect-dir.cpp +++ b/test/Tooling/clang-check-autodetect-dir.cpp @@ -1,13 +1,9 @@ // RUN: rm -rf %t // RUN: mkdir -p %t/abc/def -// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %t/test.cpp\",\"file\":\"%t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json +// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/test.cpp\",\"file\":\"%/t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json // RUN: cp "%s" "%t/test.cpp" // RUN: not clang-check -p "%t/abc/def" "%t/test.cpp" 2>&1|FileCheck %s // FIXME: Make the above easier. // CHECK: C++ requires invalid; - -// REQUIRES: shell -// PR15590 -// XFAIL: win64 diff --git a/test/Tooling/clang-check-pwd.cpp b/test/Tooling/clang-check-pwd.cpp index d85b9b1ae472..3ce196be3eec 100644 --- a/test/Tooling/clang-check-pwd.cpp +++ b/test/Tooling/clang-check-pwd.cpp @@ -12,6 +12,3 @@ invalid; // REQUIRES: shell -// PR15590 -// XFAIL: win64 -// XFAIL: mingw diff --git a/test/Tooling/pch.cpp b/test/Tooling/pch.cpp index 40bc1e9731c1..5da49eaea9c1 100644 --- a/test/Tooling/pch.cpp +++ b/test/Tooling/pch.cpp @@ -9,7 +9,6 @@ // the test file with an unrelated include as second translation unit. // Test for an non-empty file after clang-check is executed. // RUN: clang-check -ast-dump "%S/Inputs/pch.cpp" "%s" -- -include-pch %t1 -I "%S" -c >%t2 2>&1 -// REQUIRES: shell // RUN: test -s %t2 #include "Inputs/pch-fail.h" diff --git a/test/VFS/external-names.c b/test/VFS/external-names.c index aa0bd6745309..81ec4ec50b3e 100644 --- a/test/VFS/external-names.c +++ b/test/VFS/external-names.c @@ -28,8 +28,8 @@ // Debug info // RUN: %clang_cc1 -I %t -ivfsoverlay %t.external.yaml -triple %itanium_abi_triple -g -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG-EXTERNAL %s -// CHECK-DEBUG-EXTERNAL: ![[Num:[0-9]*]] = metadata !{metadata !"{{.*}}Inputs{{.}}external-names.h -// CHECK-DEBUG-EXTERNAL: metadata !{i32 {{[0-9]*}}, metadata ![[Num]]{{.*}}DW_TAG_file_type +// CHECK-DEBUG-EXTERNAL: ![[Num:[0-9]*]] = !{!"{{.*}}Inputs{{.}}external-names.h +// CHECK-DEBUG-EXTERNAL: !{!"0x29", ![[Num]]{{.*}}DW_TAG_file_type // RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -triple %itanium_abi_triple -g -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG %s // CHECK-DEBUG-NOT: Inputs diff --git a/test/VFS/umbrella-mismatch.m b/test/VFS/umbrella-mismatch.m index c73129448c55..f3a4ab34e065 100644 --- a/test/VFS/umbrella-mismatch.m +++ b/test/VFS/umbrella-mismatch.m @@ -1,6 +1,5 @@ // RUN: rm -rf %t -// RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%S/Inputs:g" %S/Inputs/vfsoverlay.yaml > %t.yaml -// REQUIRES: shell +// RUN: sed -e "s;INPUT_DIR;%/S/Inputs;g" -e "s;OUT_DIR;%/S/Inputs;g" %S/Inputs/vfsoverlay.yaml > %t.yaml // RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -ivfsoverlay %t.yaml -F %S/Inputs -fsyntax-only %s -verify // RUN: %clang_cc1 -Werror -fmodules -fmodules-cache-path=%t -F %S/Inputs -fsyntax-only %s -verify diff --git a/test/lit.cfg b/test/lit.cfg index ccefb70f7300..846a6e92ca51 100644 --- a/test/lit.cfg +++ b/test/lit.cfg @@ -73,7 +73,6 @@ config.llvm_obj_root = getattr(config, 'llvm_obj_root', None) # safe_env_vars = ('TMPDIR', 'TEMP', 'TMP', 'USERPROFILE', 'PWD', # 'MACOSX_DEPLOYMENT_TARGET', 'IPHONEOS_DEPLOYMENT_TARGET', -# 'IOS_SIMULATOR_DEPLOYMENT_TARGET', # 'VCINSTALLDIR', 'VC100COMNTOOLS', 'VC90COMNTOOLS', # 'VC80COMNTOOLS') possibly_dangerous_env_vars = ['COMPILER_PATH', 'RC_DEBUG_OPTIONS', @@ -115,11 +114,6 @@ for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']: if symbolizer in os.environ: config.environment[symbolizer] = os.environ[symbolizer] -# Propagate options for sanitizers. -for options in ['ASAN_OPTIONS']: - if options in os.environ: - config.environment[options] = os.environ[options] - ### # Check that the object root is known. @@ -223,7 +217,8 @@ def getClangBuiltinIncludeDir(clang): # FIXME: Rather than just getting the version, we should have clang print # out its resource dir here in an easy to scrape form. cmd = subprocess.Popen([clang, '-print-file-name=include'], - stdout=subprocess.PIPE) + stdout=subprocess.PIPE, + env=config.environment) if not cmd.stdout: lit_config.fatal("Couldn't find the include dir for Clang ('%s')" % clang) dir = cmd.stdout.read().strip() @@ -258,7 +253,8 @@ def makeMSABITriple(triple): # -win32 is not supported for non-x86 targets; use a default. return 'i686-pc-win32' -config.substitutions.append( ('%clang_cc1', '%s -cc1 -internal-isystem %s' +config.substitutions.append( ('%clang_cc1', + '%s -cc1 -internal-isystem %s -nostdsysteminc' % (config.clang, getClangBuiltinIncludeDir(config.clang))) ) config.substitutions.append( ('%clang_cpp', ' ' + config.clang + @@ -310,14 +306,14 @@ tool_dirs = os.path.pathsep.join((clang_tools_dir, llvm_tools_dir)) # For example, don't match 'clang-check-' or '.clang-format'. NoPreHyphenDot = r"(?<!(-|\.))" NoPostHyphenDot = r"(?!(-|\.))" +NoPostBar = r"(?!(/|\\))" for pattern in [r"\bFileCheck\b", r"\bc-index-test\b", NoPreHyphenDot + r"\bclang-check\b" + NoPostHyphenDot, NoPreHyphenDot + r"\bclang-format\b" + NoPostHyphenDot, NoPreHyphenDot + r"\bclang-interpreter\b" + NoPostHyphenDot, - # FIXME: Some clang test uses opt? - NoPreHyphenDot + r"\bopt\b" + NoPostHyphenDot, + NoPreHyphenDot + r"\bopt\b" + NoPostBar + NoPostHyphenDot, # Handle these specially as they are strings searched # for during testing. r"\| \bcount\b", @@ -408,11 +404,11 @@ if not re.match(r'.*-win32$', config.target_triple): config.available_features.add('non-ms-sdk') # [PR8833] LLP64-incompatible tests -if not re.match(r'^x86_64.*-(win32|mingw32)$', config.target_triple): +if not re.match(r'^x86_64.*-(win32|mingw32|windows-gnu)$', config.target_triple): config.available_features.add('LP64') # [PR12920] "clang-driver" -- set if gcc driver is not used. -if not re.match(r'.*-(cygwin|mingw32)$', config.target_triple): +if not re.match(r'.*-(cygwin|mingw32|windows-gnu)$', config.target_triple): config.available_features.add('clang-driver') # [PR18856] Depends to remove opened file. On win32, a file could be removed @@ -430,7 +426,8 @@ def get_llvm_config_props(): '--assertion-mode', '--targets-built', ], - stdout=subprocess.PIPE + stdout=subprocess.PIPE, + env=config.environment ) # 1st line corresponds to --assertion-mode, "ON" or "OFF". line = cmd.stdout.readline().strip().decode('ascii') @@ -457,6 +454,10 @@ else: if (config.llvm_use_sanitizer == "Memory" or config.llvm_use_sanitizer == "MemoryWithOrigins"): config.available_features.add("msan") +if config.llvm_use_sanitizer == "Undefined": + config.available_features.add("ubsan") +else: + config.available_features.add("not_ubsan") # Check if we should run long running tests. if lit_config.params.get("run_long_tests", None) == "true": |