+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -verify -fobjc-gc -analyzer-constraints=basic %s -Wno-implicit-function-declaration

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -verify -fobjc-gc -analyzer-constraints=range %s -Wno-implicit-function-declaration

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -verify -fobjc-gc -disable-free %s -Wno-implicit-function-declaration

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -fobjc-gc %s -Wno-implicit-function-declaration

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fobjc-gc %s -Wno-implicit-function-declaration

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -verify %s -analyzer-constraints=basic -analyzer-store=basic

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -verify %s -analyzer-constraints=range -analyzer-store=basic

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -verify %s -analyzer-constraints=basic -analyzer-store=region

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -verify %s -analyzer-constraints=range -analyzer-store=region

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=cocoa.experimental.Dealloc '-DIBOutlet=__attribute__((iboutlet))' %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -DTEST_64 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -DTEST_64 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// NOTWORK: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s &&

+// NOTWORK: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s &&

+// NOTWORK: %clang_cc1 -DTEST_64 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s &&

+// NOTWORK: %clang_cc1 -DTEST_64 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=cocoa.NilArg -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-checker=core.DeadStores -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-checker=core.DeadStores -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-checker=core.DeadStores -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-checker=core.DeadStores -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-checker=cocoa.MethodSigs -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-constraints=basic -analyzer-store=basic -analyzer-check-objc-mem -fobjc-gc -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-constraints=range -analyzer-store=basic -analyzer-check-objc-mem -fobjc-gc -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-constraints=basic -analyzer-store=basic -analyzer-check-objc-mem -fobjc-gc -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-constraints=range -analyzer-store=region -analyzer-check-objc-mem -fobjc-gc -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-checker=cocoa.experimental.Dealloc %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify -triple x86_64-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -triple x86_64-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -triple x86_64-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -triple x86_64-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks -analyzer-stats %s

+// RUN: %clang_cc1 -analyze -analyzer-experimental-checks -analyzer-checker=core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-experimental-checks -analyzer-checker=core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify -Wno-unreachable-code -ffreestanding %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -Wno-unreachable-code -ffreestanding %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -Wno-unreachable-code -ffreestanding %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -Wno-unreachable-code -ffreestanding %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.DeadStores -warn-uninit-values -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-experimental-checks -verify %s

+// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core.DeadStores,core.experimental.IdempotentOps -analyzer-check-objc-mem -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core.DeadStores,core.experimental.IdempotentOps -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core.DeadStores,core.experimental.IdempotentOps -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core.DeadStores,core.experimental.IdempotentOps -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core.DeadStores,core.experimental.IdempotentOps -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -fexceptions -analyze -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code %s

+// RUN: %clang_cc1 -fexceptions -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code %s

+// RUN: %clang_cc1 -fexceptions -analyze -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code %s

+// RUN: %clang_cc1 -fexceptions -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code %s

+// RUN: %clang_cc1 -fexceptions -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -analyzer-checker=core.DeadStores -verify -Wno-unreachable-code %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-checker=core.DeadStores -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem %s -analyzer-store=basic -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem %s -analyzer-store=region -verify

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-store=region -analyzer-experimental-checks -fblocks -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental.UnreachableCode,core.experimental.CastSize -analyzer-check-objc-mem -analyzer-experimental-checks -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=basic -verify -fblocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -fblocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -fblocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fblocks %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify -fblocks %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fblocks %s -analyzer-eagerly-assume

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -fblocks %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fblocks %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental.IdempotentOps,core.experimental.CastToStruct,core.experimental.ReturnPtrRange,core.experimental.ReturnPtrRange,core.experimental.ArrayBound -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -DTEST_64 -analyze -analyzer-checker=core.experimental.IdempotentOps,core.experimental.CastToStruct,core.experimental.ReturnPtrRange,core.experimental.ArrayBound -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify -fblocks -analyzer-opt-analyze-nested-blocks %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=basic -fobjc-gc -analyzer-constraints=basic -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=basic -fobjc-gc -analyzer-constraints=basic -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=basic -analyzer-constraints=range -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=basic -verify -fblocks -Wno-unreachable-code %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=core.experimental,cocoa.AtSync -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify -fblocks -Wno-unreachable-code %s

+

+// PR 9269 - don't assert when building the following CFG. The for statement

+// contains a condition with multiple basic blocks, and the value of the

+// statement expression is then indexed as part of a bigger condition expression.

+// This example exposed a bug in child traversal in the CFGBuilder.

+void pr9269() {

+ struct s { char *bar[10]; } baz[2] = { 0 };

+ unsigned i = 0;

+ for (i = 0;

+ (* ({ while(0); ({ &baz[0]; }); })).bar[0] != 0;

+ ++i) {}

+}

+

+// Test evaluation of GNU-style ?:.

+int pr9287(int type) { return type ? : 0; } // no-warning

+

+void pr9287_b(int type, int *p) {

+ int x = type ? : 0;

+ if (x) {

+ p = 0;

+ }

+ if (type) {

+ *p = 0xDEADBEEF; // expected-warning {{null pointer}}

+ }

+}

+

+void pr9287_c(int type, int *p) {

+ int x = type ? : 0;

+ if (x) {

+ p = 0;

+ }

+ if (!type) {

+ *p = 0xDEADBEEF; // no-warning

+ }

+}

+

+// RUN: %clang_cc1 -triple i386-apple-darwin8 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=range -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin8 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=basic %s 2>&1 | FileCheck -check-prefix=darwin8 %s

+// RUN: %clang_cc1 -triple i386-apple-darwin8 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=region %s 2>&1 | FileCheck -check-prefix=darwin8 %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=basic %s 2>&1 | FileCheck -check-prefix=darwin9 %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=region %s 2>&1 | FileCheck -check-prefix=darwin9 %s

+// RUN: %clang_cc1 -triple thumbv6-apple-darwin4.0.0-iphoneos -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=basic %s 2>&1 | FileCheck -check-prefix=darwin9 %s

+// RUN: %clang_cc1 -triple thumbv6-apple-darwin4.0.0-iphoneos -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=region %s 2>&1 | FileCheck -check-prefix=darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyzer-check-objc-mem -analyze -analyzer-checker=core.experimental -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyzer-check-objc-mem -analyze -analyzer-checker=core.experimental -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -std=gnu99 -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental -std=gnu99 -analyzer-check-objc-mem -verify %s -analyzer-constraints=basic -analyzer-store=basic -Wreturn-type

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental -std=gnu99 -analyzer-check-objc-mem -verify %s -analyzer-constraints=range -analyzer-store=basic -Wreturn-type

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental -std=gnu99 -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -analyzer-no-purge-dead -verify %s -Wreturn-type

+// RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-checker=core.experimental -std=gnu99 -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s -Wreturn-type

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-experimental-checks -verify %s

+// RUN: %clang_cc1 -Wno-array-bounds -analyze -analyzer-checker=core.experimental -analyzer-experimental-checks -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -Werror %s -analyzer-store=basic -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -Werror %s -analyzer-store=region -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -fblocks -analyzer-output=plist -o - %s | FileCheck %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -fblocks -analyzer-output=plist -o - %s | FileCheck %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -pedantic -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -pedantic -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental.FixedAddr,core.experimental.PointerArithm,core.experimental.PointerSub -analyzer-check-objc-mem -analyzer-store=region -verify -triple x86_64-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental.FixedAddr,core.experimental.PointerArithm,core.experimental.PointerSub -analyzer-check-objc-mem -analyzer-store=region -verify -triple i686-apple-darwin9 %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem %s -analyzer-store=basic -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem %s -analyzer-store=region -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-checker=core.DeadStores -verify %s

+// RUN: %clang_cc1 -verify -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region %s

+// RUN: %clang_cc1 -verify -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=basic %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-constraints=basic -analyzer-store=region %s -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -triple i386-apple-darwin10 -analyzer-store=region %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -triple i386-apple-darwin10 -analyzer-store=basic %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -analyzer-constraints=range -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=basic -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-store=region -verify %s

+kDAReturnSuccess = 0, kDAReturnError = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x01, kDAReturnBusy = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x02, kDAReturnBadArgument = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x03, kDAReturnExclusiveAccess = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x04, kDAReturnNoResources = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x05, kDAReturnNotFound = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x06, kDAReturnNotMounted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x07, kDAReturnNotPermitted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x08, kDAReturnNotPrivileged = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x09, kDAReturnNotReady = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0A, kDAReturnNotWritable = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0B, kDAReturnUnsupported = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0C };

+kDAReturnSuccess = 0, kDAReturnError = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x01, kDAReturnBusy = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x02, kDAReturnBadArgument = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x03, kDAReturnExclusiveAccess = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x04, kDAReturnNoResources = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x05, kDAReturnNotFound = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x06, kDAReturnNotMounted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x07, kDAReturnNotPermitted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x08, kDAReturnNotPrivileged = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x09, kDAReturnNotReady = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0A, kDAReturnNotWritable = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0B, kDAReturnUnsupported = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0C };

+kDAReturnSuccess = 0, kDAReturnError = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x01, kDAReturnBusy = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x02, kDAReturnBadArgument = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x03, kDAReturnExclusiveAccess = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x04, kDAReturnNoResources = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x05, kDAReturnNotFound = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x06, kDAReturnNotMounted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x07, kDAReturnNotPermitted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x08, kDAReturnNotPrivileged = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x09, kDAReturnNotReady = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0A, kDAReturnNotWritable = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0B, kDAReturnUnsupported = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0C };

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=macosx.CFRetainRelease,cocoa.ClassRelease -analyzer-check-objc-mem -analyzer-store=basic -fblocks -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=macosx.CFRetainRelease,cocoa.ClassRelease -analyzer-check-objc-mem -analyzer-store=region -fblocks -verify %s

+kDAReturnSuccess = 0, kDAReturnError = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x01, kDAReturnBusy = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x02, kDAReturnBadArgument = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x03, kDAReturnExclusiveAccess = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x04, kDAReturnNoResources = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x05, kDAReturnNotFound = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x06, kDAReturnNotMounted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x07, kDAReturnNotPermitted = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x08, kDAReturnNotPrivileged = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x09, kDAReturnNotReady = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0A, kDAReturnNotWritable = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0B, kDAReturnUnsupported = (((0x3eU)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0C };

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-checker=core.StackAddrEscape -analyzer-store=basic -fblocks -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-checker=core.StackAddrEscape -analyzer-store=region -fblocks -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-check-objc-mem -analyzer-checker=core.StackAddrEscape -analyzer-store region -verify %s

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental.CString,core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -DUSE_BUILTINS -analyzer-checker=core.experimental.CString,core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -DVARIANT -analyzer-checker=core.experimental.CString,core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -analyze -DUSE_BUILTINS -DVARIANT -analyzer-checker=core.experimental.CString,core.experimental.UnreachableCode -analyzer-check-objc-mem -analyzer-store=region -verify %s

+// strnlen()

+//===----------------------------------------------------------------------===

+

+#define strnlen BUILTIN(strnlen)

+size_t strnlen(const char *s, size_t maxlen);

+

+void strnlen_constant0() {

+ if (strnlen("123", 10) != 3)

+ (void)*(char*)0; // no-warning

+}

+

+void strnlen_constant1() {

+ const char *a = "123";

+ if (strnlen(a, 10) != 3)

+ (void)*(char*)0; // no-warning

+}

+

+void strnlen_constant2(char x) {

+ char a[] = "123";

+ if (strnlen(a, 10) != 3)

+ (void)*(char*)0; // no-warning

+ a[0] = x;

+ if (strnlen(a, 10) != 3)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+void strnlen_constant4() {

+ if (strnlen("123456", 3) != 3)

+ (void)*(char*)0; // no-warning

+}

+

+void strnlen_constant5() {

+ const char *a = "123456";

+ if (strnlen(a, 3) != 3)

+ (void)*(char*)0; // no-warning

+}

+

+void strnlen_constant6(char x) {

+ char a[] = "123456";

+ if (strnlen(a, 3) != 3)

+ (void)*(char*)0; // no-warning

+ a[0] = x;

+ if (strnlen(a, 3) != 3)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+size_t strnlen_null() {

+ return strnlen(0, 3); // expected-warning{{Null pointer argument in call to byte string function}}

+}

+

+size_t strnlen_fn() {

+ return strnlen((char*)&strlen_fn, 3); // expected-warning{{Argument to byte string function is the address of the function 'strlen_fn', which is not a null-terminated string}}

+}

+

+size_t strnlen_nonloc() {

+label:

+ return strnlen((char*)&&label, 3); // expected-warning{{Argument to byte string function is the address of the label 'label', which is not a null-terminated string}}

+}

+

+void strnlen_subregion() {

+ struct two_stringsn { char a[2], b[2] };

+ extern void use_two_stringsn(struct two_stringsn *);

+

+ struct two_stringsn z;

+ use_two_stringsn(&z);

+

+ size_t a = strnlen(z.a, 10);

+ z.b[0] = 5;

+ size_t b = strnlen(z.a, 10);

+ if (a == 0 && b != 0)

+ (void)*(char*)0; // expected-warning{{never executed}}

+

+ use_two_stringsn(&z);

+

+ size_t c = strnlen(z.a, 10);

+ if (a == 0 && c != 0)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+extern void use_stringn(char *);

+void strnlen_argument(char *x) {

+ size_t a = strnlen(x, 10);

+ size_t b = strnlen(x, 10);

+ if (a == 0 && b != 0)

+ (void)*(char*)0; // expected-warning{{never executed}}

+

+ use_stringn(x);

+

+ size_t c = strnlen(x, 10);

+ if (a == 0 && c != 0)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+extern char global_strn[];

+void strnlen_global() {

+ size_t a = strnlen(global_strn, 10);

+ size_t b = strnlen(global_strn, 10);

+ if (a == 0 && b != 0)

+ (void)*(char*)0; // expected-warning{{never executed}}

+

+ // Call a function with unknown effects, which should invalidate globals.

+ use_stringn(0);

+

+ size_t c = strnlen(global_str, 10);

+ if (a == 0 && c != 0)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+void strnlen_indirect(char *x) {

+ size_t a = strnlen(x, 10);

+ char *p = x;

+ char **p2 = &p;

+ size_t b = strnlen(x, 10);

+ if (a == 0 && b != 0)

+ (void)*(char*)0; // expected-warning{{never executed}}

+

+ extern void use_stringn_ptr(char*const*);

+ use_stringn_ptr(p2);

+

+ size_t c = strnlen(x, 10);

+ if (a == 0 && c != 0)

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+void strnlen_liveness(const char *x) {

+ if (strnlen(x, 10) < 5)

+ return;

+ if (strnlen(x, 10) < 5)

+ (void)*(char*)0; // no-warning

+}

+

+//===----------------------------------------------------------------------===

+// strncpy()

+//===----------------------------------------------------------------------===

+

+#ifdef VARIANT

+

+#define __strncpy_chk BUILTIN(__strncpy_chk)

+char *__strncpy_chk(char *restrict s1, const char *restrict s2, size_t n, size_t destlen);

+

+#define strncpy(a,b,c) __strncpy_chk(a,b,c, (size_t)-1)

+

+#else /* VARIANT */

+

+#define strncpy BUILTIN(strncpy)

+char *strncpy(char *restrict s1, const char *restrict s2, size_t n);

+

+#endif /* VARIANT */

+

+

+void strncpy_null_dst(char *x) {

+ strncpy(NULL, x, 1); // expected-warning{{Null pointer argument in call to byte string function}}

+}

+

+void strncpy_null_src(char *x) {

+ strncpy(x, NULL, 1); // expected-warning{{Null pointer argument in call to byte string function}}

+}

+

+void strncpy_fn(char *x) {

+ strncpy(x, (char*)&strncpy_fn, 1); // expected-warning{{Argument to byte string function is the address of the function 'strncpy_fn', which is not a null-terminated string}}

+}

+

+void strncpy_effects(char *x, char *y) {

+ char a = x[0];

+

+ if (strncpy(x, y, strlen(y)) != x)

+ (void)*(char*)0; // no-warning

+

+ if (strlen(x) != strlen(y))

+ (void)*(char*)0; // no-warning

+

+ if (a != x[0])

+ (void)*(char*)0; // expected-warning{{null}}

+}

+

+void strncpy_overflow(char *y) {

+ char x[4];

+ if (strlen(y) == 4)

+ strncpy(x, y, strlen(y)); // expected-warning{{Byte string function overflows destination buffer}}

+}

+

+void strncpy_len_overflow(char *y) {

+ char x[4];

+ if (strlen(y) == 3)

+ strncpy(x, y, sizeof(x)); // no-warning

+}

+

+void strncpy_no_overflow(char *y) {

+ char x[4];

+ if (strlen(y) == 3)

+ strncpy(x, y, strlen(y)); // no-warning

+}

+

+void strncpy_no_len_overflow(char *y) {

+ char x[4];

+ if (strlen(y) == 4)

+ strncpy(x, y, sizeof(x)-1); // no-warning

+}

+

+//===----------------------------------------------------------------------===

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.experimental -analyzer-check-objc-mem -analyzer-experimental-checks -analyzer-store=region -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-check-objc-mem -analyzer-checker=unix.API,macosx.API %s -analyzer-store=region -fblocks -verify

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-check-objc-mem -analyzer-checker=unix.API,macosx.API %s -analyzer-store=basic -fblocks -verify

+// RUN: %clang_cc1 -analyze -analyzer-checker=core.DeadStores,core.experimental.UnreachableCode -analyzer-check-objc-mem -verify -analyzer-opt-analyze-nested-blocks -Wno-unused-value %s

+ # Installed LLVM does not contain ${CMAKE_CFG_INTDIR} in paths.

+ if( NOT EXISTS ${LIT} )

+ set(LIT "${PATH_TO_LLVM_BUILD}/bin/llvm-lit")

+ endif()

+ set_target_properties(clang-test.deps PROPERTIES FOLDER "Clang tests")

+ set_target_properties(clang-test-${testdir} PROPERTIES FOLDER "Clang tests")

+ set_target_properties(clang-test PROPERTIES FOLDER "Clang tests")

+ set_target_properties(clang-c++tests PROPERTIES FOLDER "Clang tests")

+ add_dependencies(check-all clang-test.deps)

+ if ( LLVM_INCLUDE_TESTS )

+ add_dependencies(check-all check.deps ClangUnitTests)

+ endif ( LLVM_INCLUDE_TESTS )

+ llvm-dis opt

+ set_target_properties(check-all PROPERTIES FOLDER "Clang tests")

+// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify %s -std=c++0x

+

+struct S {

+ virtual ~S();

+

+ void g() throw (auto(*)()->int);

+

+ // Note, this is not permitted: conversion-declarator cannot have a trailing return type.

+ // FIXME: don't issue the second diagnostic for this.

+ operator auto(*)()->int(); // expected-error{{'auto' not allowed here}} expected-error {{C++ requires a type specifier}}

+};

+

+typedef auto Fun(int a) -> decltype(a + a);

+typedef auto (*PFun)(int a) -> decltype(a + a);

+

+void g(auto (*f)() -> int) {

+ try { }

+ catch (auto (&f)() -> int) { }

+ catch (auto (*const f[10])() -> int) { }

+}

+

+namespace std {

+ class type_info;

+}

+

+template<typename T> struct U {};

+

+void j() {

+ (void)typeid(auto(*)()->void);

+ (void)sizeof(auto(*)()->void);

+ (void)__alignof(auto(*)()->void);

+

+ U<auto(*)()->void> v;

+

+ int n;

+ (void)static_cast<auto(*)()->void>(&j);

+ auto p = reinterpret_cast<auto(*)()->int>(&j);

+ (void)const_cast<auto(**)()->int>(&p);

+ (void)(auto(*)()->void)(&j);

+}

+

+template <auto (*f)() -> void = &j> class C { };

+struct F : auto(*)()->int {}; // expected-error{{expected class name}}

+template<typename T = auto(*)()->int> struct G { };

+

+int g();

+auto (*h)() -> auto = &g; // expected-error{{'auto' not allowed here}}

+auto (*i)() = &g; // ok; auto deduced as int.

+auto (*k)() -> int = i; // ok; no deduction.

+ if (auto d = d) {} // expected-error {{variable 'd' declared with 'auto' type cannot appear in its own initializer}}

+ auto e = ({ auto f = e; 0; }); // expected-error {{variable 'e' declared with 'auto' type cannot appear in its own initializer}}

+

+ if (auto b) {} // expected-error {{expected '='}}

+ for (;auto b;) {} // expected-error {{expected '='}}

+ while (auto b) {} // expected-error {{expected '='}}

+ if (auto b = true) { (void)b; }

+ for (auto c = 0; c < b; ++c) {

+ auto int r; // expected-warning {{'auto' storage class specifier is redundant and will be removed in future releases}}

+// PR 9278: auto is not allowed in typedefs, except with a trailing return type.

+typedef auto *AutoPtr; // expected-error{{'auto' not allowed in typedef}}

+typedef auto (*PFun)(int a); // expected-error{{'auto' not allowed in typedef}}

+typedef auto Fun(int a) -> decltype(a + a);

+

+// FIXME: don't issue the second diagnostic for this error.

+auto k() -> auto; // expected-error{{'auto' not allowed here}} unexpected-error{{without trailing return type}}

+auto (d() -> int); // expected-error {{trailing return type may not be nested within parentheses}}

+auto e() -> auto (*)() -> auto (*)() -> void; // ok: same as void (*(*e())())();

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s

+

+auto f() -> int[32]; // expected-error{{function cannot return array}}

+auto g() -> int(int); // expected-error{{function cannot return function}}

+auto h() -> auto() -> int; // expected-error{{function cannot return function}}

+auto i() -> auto(*)() -> int;

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s

+

+auto j() -> enum { e3 }; // expected-error{{can not be defined in a type specifier}}

+

+// PR8959 - This should implicitly truncate the immediate to a byte.

+int test4(volatile int *addr) {

+ unsigned char oldval;

+ __asm__ ("frob %0" : "=r"(oldval) : "0"(0xff));

+ return (int)oldval;

+// CHECK: call i8 asm "frob $0", "=r,0{{.*}}"(i8 -1)

+}

+

+// RUN: %clang -S %s -o /dev/null

+struct rtxc_snapshot {

+ int a, b, c, d;

+};

+__attribute__ ((section("__DATA, __common"))) struct rtxc_snapshot rtxc_log_A[4];

+// CHECK: @test1.x = private constant [12 x i32] [i32 1

+// CHECK: store i32 0, i32* %{{.*}}, !tbaa !1

+// CHECK: store i32 1, i32* %{{.*}}, !tbaa !3

+// PR9307

+struct Test1 { int x; };

+struct Test1MA { int x; } __attribute__((may_alias));

+void test1(struct Test1MA *p1, struct Test1 *p2) {

+ // CHECK: store i32 2, i32* {{%.*}}, !tbaa !1

+ p1->x = 2;

+ // CHECK: store i32 3, i32* {{%.*}}, !tbaa !3

+ p2->x = 3;

+}

+ // CHECK-NEXT: [[STRUCT:%.*]] = bitcast {{.*}}* [[UNION]] to

+ // CHECK-NEXT: [[STRUCT:%.*]] = bitcast {{.*}}* [[UNION]] to

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s

+// rdar: // 8353567

+// pr7726

+

+extern "C" int printf(...);

+

+void test0() {

+// CHECK: call i32 (...)* @printf({{.*}}, i8* inttoptr (i64 3735928559 to i8*))

+ printf("%p\n", (void *)0xdeadbeef ? : (void *)0xaaaaaa);

+}

+

+// rdar://8446940

+namespace radar8446940 {

+extern "C" void abort();

+

+int main () {

+ char x[1];

+ char *y = x ? : 0;

+

+ if (x != y)

+ abort();

+}

+}

+

+namespace radar8453812 {

+extern "C" void abort();

+_Complex int getComplex(_Complex int val) {

+ static int count;

+ if (count++)

+ abort();

+ return val;

+}

+

+_Complex int cmplx() {

+ _Complex int cond;

+ _Complex int rhs;

+

+ return getComplex(1+2i) ? : rhs;

+}

+

+// lvalue test

+void foo (int& lv) {

+ ++lv;

+}

+

+int global = 1;

+

+int &cond() {

+ static int count;

+ if (count++)

+ abort();

+ return global;

+}

+

+

+int main() {

+ cmplx();

+ int rhs = 10;

+ foo (cond()? : rhs);

+ return global-2;

+}

+}

+

+namespace test3 {

+ struct A {

+ A();

+ A(const A&);

+ ~A();

+ };

+

+ struct B {

+ B();

+ B(const B&);

+ ~B();

+ operator bool();

+ operator A();

+ };

+

+ B test0(B &x) {

+ // CHECK: define void @_ZN5test35test0ERNS_1BE(

+ // CHECK: [[X:%.*]] = alloca [[B:%.*]]*,

+ // CHECK-NEXT: store [[B]]* {{%.*}}, [[B]]** [[X]]

+ // CHECK-NEXT: [[T0:%.*]] = load [[B]]** [[X]]

+ // CHECK-NEXT: [[BOOL:%.*]] = call zeroext i1 @_ZN5test31BcvbEv([[B]]* [[T0]])

+ // CHECK-NEXT: br i1 [[BOOL]]

+ // CHECK: call void @_ZN5test31BC1ERKS0_([[B]]* [[RESULT:%.*]], [[B]]* [[T0]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31BC1Ev([[B]]* [[RESULT]])

+ // CHECK-NEXT: br label

+ // CHECK: ret void

+ return x ?: B();

+ }

+

+ B test1() {

+ // CHECK: define void @_ZN5test35test1Ev(

+ // CHECK: [[TEMP:%.*]] = alloca [[B]],

+ // CHECK-NEXT: call void @_ZN5test312test1_helperEv([[B]]* sret [[TEMP]])

+ // CHECK-NEXT: [[BOOL:%.*]] = call zeroext i1 @_ZN5test31BcvbEv([[B]]* [[TEMP]])

+ // CHECK-NEXT: br i1 [[BOOL]]

+ // CHECK: call void @_ZN5test31BC1ERKS0_([[B]]* [[RESULT:%.*]], [[B]]* [[TEMP]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31BC1Ev([[B]]* [[RESULT]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31BD1Ev([[B]]* [[TEMP]])

+ // CHECK-NEXT: ret void

+ extern B test1_helper();

+ return test1_helper() ?: B();

+ }

+

+

+ A test2(B &x) {

+ // CHECK: define void @_ZN5test35test2ERNS_1BE(

+ // CHECK: [[X:%.*]] = alloca [[B]]*,

+ // CHECK-NEXT: store [[B]]* {{%.*}}, [[B]]** [[X]]

+ // CHECK-NEXT: [[T0:%.*]] = load [[B]]** [[X]]

+ // CHECK-NEXT: [[BOOL:%.*]] = call zeroext i1 @_ZN5test31BcvbEv([[B]]* [[T0]])

+ // CHECK-NEXT: br i1 [[BOOL]]

+ // CHECK: call void @_ZN5test31BcvNS_1AEEv([[A:%.*]]* sret [[RESULT:%.*]], [[B]]* [[T0]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31AC1Ev([[A]]* [[RESULT]])

+ // CHECK-NEXT: br label

+ // CHECK: ret void

+ return x ?: A();

+ }

+

+ A test3() {

+ // CHECK: define void @_ZN5test35test3Ev(

+ // CHECK: [[TEMP:%.*]] = alloca [[B]],

+ // CHECK-NEXT: call void @_ZN5test312test3_helperEv([[B]]* sret [[TEMP]])

+ // CHECK-NEXT: [[BOOL:%.*]] = call zeroext i1 @_ZN5test31BcvbEv([[B]]* [[TEMP]])

+ // CHECK-NEXT: br i1 [[BOOL]]

+ // CHECK: call void @_ZN5test31BcvNS_1AEEv([[A]]* sret [[RESULT:%.*]], [[B]]* [[TEMP]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31AC1Ev([[A]]* [[RESULT]])

+ // CHECK-NEXT: br label

+ // CHECK: call void @_ZN5test31BD1Ev([[B]]* [[TEMP]])

+ // CHECK-NEXT: ret void

+ extern B test3_helper();

+ return test3_helper() ?: A();

+ }

+

+}

+// RUN: %clang -emit-llvm -g -S %s -o - | FileCheck %s

+

+// TAG_member is used to encode debug info for class constructor.

+// CHECK: TAG_member

+class A {

+public:

+ int z;

+};

+

+A *foo () {

+ A *a = new A();

+ return a;

+}

+

+

+// PR9303: invalid assert on this

+namespace test6 {

+ bool cond();

+ void test() {

+ try {

+ lbl:

+ if (cond()) goto lbl;

+ } catch (...) {

+ }

+ }

+}

+// RUN: %clang_cc1 -std=c++0x -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s

+ template< typename T >

+ void auto_(decltype(new auto(T()))) {

+ }

+

+

+ // CHECK: define weak_odr void @_ZN5Casts5auto_IiEEvDTnw_DapicvT__EEE(

+ template void auto_<int>(int*);

+

+// 1x for the declaration

+// 1x for the object-pointer byref copy helper

+// 1x for the block-pointer byref copy helper

+// 8x for the block copy helper

+

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -emit-llvm -fobjc-exceptions -fblocks -o %t %s

+ // CHECK-NEXT: [[CAPTURE:%.*]] = load [[TEST2]]** [[X]]

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-nonfragile-abi -fexceptions -fobjc-exceptions -O2 -o - %s | FileCheck %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fexceptions -fobjc-exceptions -O2 -o - %s | FileCheck %s

+

+// rdar://problem/9027663

+void t2(NSArray *array) {

+ for (NSArray *array in array) { // expected-warning {{collection expression type 'NSArray *' may not respond}}

+ }

+}

+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -fexceptions -fobjc-exceptions -fgnu-runtime -o - %s | FileCheck %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-nonfragile-abi -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK-NF

+

+// Most of this test is apparently just verifying that we don't crash.

+

+// rdar://problem/7854674

+// CHECK: define void @test0([[A:%.*]]*

+// CHECK-NF: define void @test0([[A:%.*]]*

+void test0(A *a) {

+ // CHECK: alloca [[A]]*

+ // CHECK-NEXT: [[POINT:%.*]] = alloca [[POINT_T:%.*]],

+ // CHECK-NF: alloca [[A]]*

+ // CHECK-NF-NEXT: [[POINT:%.*]] = alloca [[POINT_T:%.*]],

+

+ // CHECK: [[T0:%.*]] = bitcast [[POINT_T]]* [[POINT]] to i8*

+ // CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[T0]], i8 0, i64 48, i32 4, i1 false)

+ // CHECK-NEXT: call {{.*}} @objc_msgSend_stret to

+ // CHECK-NF: [[T0:%.*]] = bitcast [[POINT_T]]* [[POINT]] to i8*

+ // CHECK-NF-NEXT: call void @llvm.memset.p0i8.i64(i8* [[T0]], i8 0, i64 48, i32 4, i1 false)

+ // CHECK-NF-NEXT: call {{.*}} @objc_msgSend_stret to

+ MyPoint point = [a returnAPoint];

+}

+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK-MAC

+// RUN: %clang_cc1 -emit-llvm -fobjc-nonfragile-abi -o - %s | FileCheck %s -check-prefix=CHECK-MAC-NF

+// RUN: %clang_cc1 -fgnu-runtime -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK-GNU

+// RUN: %clang_cc1 -fgnu-runtime -fobjc-nonfragile-abi -emit-llvm -o - %s | FileCheck %s -check-prefix CHECK-GNU-NF

+ // CHECK-MAC: call {{.*}} @objc_msgSend(

+ // CHECK-MAC-NF: call {{.*}} @objc_msgSend(

+ // CHECK-GNU: call {{.*}} @objc_msg_lookup(

+ // CHECK-GNU-NF: call {{.*}} @objc_msg_lookup_sender(

+

+ // CHECK-MAC: call {{.*}} @objc_msgSend to

+ // CHECK-MAC-NF: call {{.*}} @objc_msgSend to

+ // CHECK-GNU: call {{.*}} @objc_msg_lookup to

+ // CHECK-GNU-NF: call {{.*}} @objc_msg_lookup_sender to

+

+ // CHECK-MAC: call {{.*}} @objc_msgSend to

+ // CHECK-MAC-NF: call {{.*}} @objc_msgSend to

+ // CHECK-GNU: call {{.*}} @objc_msg_lookup to

+ // CHECK-GNU-NF: call {{.*}} @objc_msg_lookup_sender to

+

+ // CHECK-MAC: call {{.*}} @objc_msgSend to

+ // CHECK-MAC-NF: call {{.*}} @objc_msgSend to

+ // CHECK-GNU: call {{.*}} @objc_msg_lookup to

+ // CHECK-GNU-NF: call {{.*}} @objc_msg_lookup_sender to

+ // CHECK-MAC: call {{.*}} @objc_msgSend to

+ // CHECK-MAC-NF: call {{.*}} @objc_msgSend to

+ // CHECK-GNU: call {{.*}} @objc_msg_lookup to

+ // CHECK-GNU-NF: call {{.*}} @objc_msg_lookup_sender to

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-nonfragile-abi -emit-llvm -fexceptions -fobjc-exceptions -o %t %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-nonfragile-abi -fobjc-exceptions -fvisibility hidden -emit-llvm -o %t %s

+// RUN: %clang_cc1 -triple armv6-apple-darwin10 -target-abi apcs-gnu -fobjc-nonfragile-abi -fobjc-exceptions -emit-llvm -o %t %s

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -emit-llvm -fobjc-exceptions %s -o - | FileCheck %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -emit-llvm -fobjc-exceptions %s -o -

+// RUN: %clang_cc1 %s -fobjc-exceptions -S -o - -triple=i686-apple-darwin9

+// RUN: %clang_cc1 %s -fobjc-exceptions -S -o - -triple=x86_64-apple-darwin9

+// RUN: %clang_cc1 -fobjc-nonfragile-abi -emit-llvm -fexceptions -fobjc-exceptions -o - %s | FileCheck --check-prefix=DEFAULT_EH %s

+// RUN: %clang_cc1 -fsjlj-exceptions -fobjc-nonfragile-abi -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck --check-prefix=SJLJ_EH %s

+// RUN: %clang_cc1 -fsyntax-only -fobjc-exceptions %s

+// RUN: %clang_cc1 -ast-print -fobjc-exceptions %s

+// RUN: %clang_cc1 -ast-dump -fobjc-exceptions %s

+// RUN: %clang_cc1 -triple i386-unknown-unknown -fobjc-exceptions -fgnu-runtime -emit-llvm -o %t %s

+// RUN: %clang_cc1 -emit-llvm -fobjc-exceptions -o %t %s

+// RUN: %clang_cc1 -g -emit-llvm -fobjc-exceptions -o %t %s

+// CHECK-LINK: ld{{.*}} "-arch" "i386"{{.*}} "-some-linker-arg"

+// TEST0: "-fmessage-length" "0" "-fobjc-exceptions" "-fdiagnostics-show-option"

+/* RUN: cp %s %t

+ RUN: %clang_cc1 -x objective-c -fixit %t

+ RUN: %clang_cc1 -x objective-c -Werror %t

+ */

+

+// rdar://9036633

+

+int main() {

+ auto int i = 0;

+ return i;

+}

+

+// PR8974

+// XFAIL: win32

+// RUN: rm -rf %t.dir

+// RUN: mkdir -p %t.dir/a/b

+// RUN: echo > %t.dir/a/b/x.h

+// RUN: cd %t.dir

+// RUN: %clang -include a/b/x.h -MD -MF %t.d -S -x c -o %t.o %s

+// RUN: grep ' a/b/x\.h' %t.d

+

+namespace outer {

+ namespace inner {

+ template<typename T>

+ struct vector {

+ typedef T* iterator;

+ };

+ }

+}

+

+namespace outer_alias = outer;

+

+struct X { };

+

+using outer_alias::inner::vector;

+

+struct X_vector : outer_alias::inner::vector<X> {

+ using outer_alias::inner::vector<X>::iterator;

+};

+

+namespace outer {

+ namespace inner {

+ template<typename T, unsigned N>

+ struct array {

+ void foo();

+ static int max_size;

+ };

+ }

+}

+

+template<typename T, unsigned N>

+void outer::inner::array<T, N>::foo() {

+}

+

+template<typename T, unsigned N>

+int outer::inner::array<T, N>::max_size = 17;

+

+template<typename T>

+struct X2 : outer::inner::vector<T> {

+ typedef T type;

+ using typename outer::inner::vector<type>::iterator;

+ using outer::inner::vector<type>::push_back;

+};

+

+namespace outer {

+ namespace inner {

+ namespace secret {

+ }

+ }

+}

+

+using namespace outer_alias::inner::secret;

+namespace super_secret = outer_alias::inner::secret;

+

+template<typename T>

+struct X3 {

+ void f(T *t) {

+ t->::outer_alias::inner::template vector<T>::~vector<T>();

+ }

+};

+

+// RUN: c-index-test -test-annotate-tokens=%s:13:1:60:1 %s | FileCheck %s

+

+// CHECK: Keyword: "using" [14:1 - 14:6] UsingDeclaration=vector[4:12]

+// CHECK: Identifier: "outer_alias" [14:7 - 14:18] NamespaceRef=outer_alias:10:11

+// CHECK: Punctuation: "::" [14:18 - 14:20] UsingDeclaration=vector[4:12]

+// CHECK: Identifier: "inner" [14:20 - 14:25] NamespaceRef=inner:2:13

+// CHECK: Punctuation: "::" [14:25 - 14:27] UsingDeclaration=vector[4:12]

+// CHECK: Identifier: "vector" [14:27 - 14:33] OverloadedDeclRef=vector[4:12]

+// CHECK: Punctuation: ";" [14:33 - 14:34]

+// FIXME: Base specifiers, too

+// CHECK: Keyword: "using" [17:3 - 17:8] UsingDeclaration=iterator[5:18]

+// CHECK: Identifier: "outer_alias" [17:9 - 17:20] NamespaceRef=outer_alias:10:11

+// CHECK: Punctuation: "::" [17:20 - 17:22] UsingDeclaration=iterator[5:18]

+// CHECK: Identifier: "inner" [17:22 - 17:27] NamespaceRef=inner:2:13

+// CHECK: Punctuation: "::" [17:27 - 17:29] UsingDeclaration=iterator[5:18]

+// CHECK: Identifier: "vector" [17:29 - 17:35] TemplateRef=vector:4:12

+// CHECK: Punctuation: "<" [17:35 - 17:36] UsingDeclaration=iterator[5:18]

+// CHECK: Identifier: "X" [17:36 - 17:37] TypeRef=struct X:12:8

+// CHECK: Punctuation: ">" [17:37 - 17:38] UsingDeclaration=iterator[5:18]

+// CHECK: Punctuation: "::" [17:38 - 17:40] UsingDeclaration=iterator[5:18]

+// CHECK: Identifier: "iterator" [17:40 - 17:48] OverloadedDeclRef=iterator[5:18]

+

+// FIXME: Check nested-name-specifiers on VarDecl, CXXMethodDecl.

+

+// CHECK: Keyword: "using" [40:3 - 40:8] UsingDeclaration=iterator:40:46

+// CHECK: Keyword: "typename" [40:9 - 40:17] UsingDeclaration=iterator:40:46

+// CHECK: Identifier: "outer" [40:18 - 40:23] NamespaceRef=outer:20:11

+// CHECK: Punctuation: "::" [40:23 - 40:25] UsingDeclaration=iterator:40:46

+// CHECK: Identifier: "inner" [40:25 - 40:30] NamespaceRef=inner:21:13

+// CHECK: Punctuation: "::" [40:30 - 40:32] UsingDeclaration=iterator:40:46

+// CHECK: Identifier: "vector" [40:32 - 40:38] TemplateRef=vector:4:12

+// CHECK: Punctuation: "<" [40:38 - 40:39] UsingDeclaration=iterator:40:46

+// CHECK: Identifier: "type" [40:39 - 40:43] TypeRef=type:39:13

+// CHECK: Punctuation: ">" [40:43 - 40:44] UsingDeclaration=iterator:40:46

+// CHECK: Punctuation: "::" [40:44 - 40:46] UsingDeclaration=iterator:40:46

+// CHECK: Identifier: "iterator" [40:46 - 40:54] UsingDeclaration=iterator:40:46

+// CHECK: Punctuation: ";" [40:54 - 40:55] ClassTemplate=X2:38:8 (Definition)

+// CHECK: Keyword: "using" [41:3 - 41:8] UsingDeclaration=push_back:41:37

+// CHECK: Identifier: "outer" [41:9 - 41:14] NamespaceRef=outer:20:11

+// CHECK: Punctuation: "::" [41:14 - 41:16] UsingDeclaration=push_back:41:37

+// CHECK: Identifier: "inner" [41:16 - 41:21] NamespaceRef=inner:21:13

+// CHECK: Punctuation: "::" [41:21 - 41:23] UsingDeclaration=push_back:41:37

+// CHECK: Identifier: "vector" [41:23 - 41:29] TemplateRef=vector:4:12

+// CHECK: Punctuation: "<" [41:29 - 41:30] UsingDeclaration=push_back:41:37

+// CHECK: Identifier: "type" [41:30 - 41:34] TypeRef=type:39:13

+// CHECK: Punctuation: ">" [41:34 - 41:35] UsingDeclaration=push_back:41:37

+// CHECK: Punctuation: "::" [41:35 - 41:37] UsingDeclaration=push_back:41:37

+// CHECK: Identifier: "push_back" [41:37 - 41:46] UsingDeclaration=push_back:41:37

+

+// Using directive

+// CHECK: Keyword: "using" [51:1 - 51:6] UsingDirective=:51:37

+// CHECK: Keyword: "namespace" [51:7 - 51:16] UsingDirective=:51:37

+// CHECK: Identifier: "outer_alias" [51:17 - 51:28] NamespaceRef=outer_alias:10:11

+// CHECK: Punctuation: "::" [51:28 - 51:30] UsingDirective=:51:37

+// CHECK: Identifier: "inner" [51:30 - 51:35] NamespaceRef=inner:45:13

+// CHECK: Punctuation: "::" [51:35 - 51:37] UsingDirective=:51:37

+// CHECK: Identifier: "secret" [51:37 - 51:43] NamespaceRef=secret:46:15

+

+// Namespace alias

+// CHECK: Keyword: "namespace" [52:1 - 52:10] NamespaceAlias=super_secret:52:11

+// CHECK: Identifier: "super_secret" [52:11 - 52:23] NamespaceAlias=super_secret:52:11

+// CHECK: Punctuation: "=" [52:24 - 52:25] NamespaceAlias=super_secret:52:11

+// CHECK: Identifier: "outer_alias" [52:26 - 52:37] NamespaceRef=outer_alias:10:11

+// CHECK: Punctuation: "::" [52:37 - 52:39] NamespaceAlias=super_secret:52:11

+// CHECK: Identifier: "inner" [52:39 - 52:44] NamespaceRef=inner:45:13

+// CHECK: Punctuation: "::" [52:44 - 52:46] NamespaceAlias=super_secret:52:11

+// CHECK: Identifier: "secret" [52:46 - 52:52] NamespaceRef=secret:46:15

+// CHECK: Punctuation: ";" [52:52 - 52:53]

+

+// Pseudo-destructor

+// CHECK: Identifier: "t" [57:5 - 57:6] DeclRefExpr=t:56:13

+// CHECK: Punctuation: "->" [57:6 - 57:8] UnexposedExpr=

+// CHECK: Punctuation: "::" [57:8 - 57:10] UnexposedExpr=

+// CHECK: Identifier: "outer_alias" [57:10 - 57:21] NamespaceRef=outer_alias:10:11

+// CHECK: Punctuation: "::" [57:21 - 57:23] UnexposedExpr=

+// CHECK: Identifier: "inner" [57:23 - 57:28] NamespaceRef=inner:45:13

+// CHECK: Punctuation: "::" [57:28 - 57:30] UnexposedExpr=

+// CHECK: Keyword: "template" [57:30 - 57:38] UnexposedExpr=

+// CHECK: Identifier: "vector" [57:39 - 57:45] TemplateRef=vector:4:12

+// CHECK: Punctuation: "<" [57:45 - 57:46] UnexposedExpr=

+// CHECK: Identifier: "T" [57:46 - 57:47] UnexposedExpr=

+// CHECK: Punctuation: ">" [57:47 - 57:48] UnexposedExpr=

+// CHECK: Punctuation: "::" [57:48 - 57:50] UnexposedExpr=

+// CHECK: Punctuation: "~" [57:50 - 57:51] UnexposedExpr=

+// CHECK: Identifier: "vector" [57:51 - 57:57] TemplateRef=vector:4:12

+// CHECK: Punctuation: "<" [57:57 - 57:58] UnexposedExpr=

+// CHECK: Identifier: "T" [57:58 - 57:59] UnexposedExpr=

+// CHECK: Punctuation: ">" [57:59 - 57:60] UnexposedExpr=

+// CHECK: Punctuation: "(" [57:60 - 57:61] CallExpr=

+// CHECK: Punctuation: ")" [57:61 - 57:62] CallExpr=

+// RUN: %clang_cc1 -include %S/objc_stmts.h -emit-llvm -fobjc-exceptions -o - %s

+// RUN: %clang_cc1 -include %S/objc_stmts.h -ast-dump -fobjc-exceptions -o - %s 2>&1 | FileCheck %s

+// RUN: %clang_cc1 -x objective-c -emit-pch -fobjc-exceptions -o %t %S/objc_stmts.h

+// RUN: %clang_cc1 -include-pch %t -emit-llvm -fobjc-exceptions -o - %s

+// RUN: %clang_cc1 -include-pch %t -ast-dump -fobjc-exceptions -o - %s 2>&1 | FileCheck %s

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+// rdar://7029784

+

+@interface A

+-(id) f0 { // expected-error {{expected ';' after method prototype}}

+ assert(0);

+}

+@end

+

+@interface B

+-(id) f0 { // expected-error {{expected ';' after method prototype}}

+ assert(0);

+@end

+

+@interface C

+- (id) f0 { // expected-error {{expected ';' after method prototype}}

+ assert(0);

+};

+@end

+

+@interface D

+- (id) f0 { // expected-error {{expected ';' after method prototype}}

+ assert(0);

+@property int P;

+@end

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions -x objective-c++ %s

+// RUN: %clang_cc1 -rewrite-objc -fobjc-exceptions -verify %s -o -

+// RUN: %clang_cc1 -x objective-c++ -Wno-return-type -fblocks -fms-extensions -rewrite-objc %s -o %t-rw.cpp

+// RUN: %clang_cc1 -fsyntax-only -fblocks -Wno-address-of-temporary -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp

+

+// rdar://9055596

+void *sel_registerName(const char *);

+

+typedef void (^FooBlock) (int foo, int bar, int baz);

+

+@interface Foo { }

+@property (readwrite, copy, nonatomic) FooBlock fooBlock;

+@end

+

+static void Bar (Foo * foo) {

+ foo.fooBlock (1,2,3);

+}

+// RUN: %clang_cc1 -rewrite-objc -fobjc-exceptions -o - %s

+// RUN: %clang_cc1 -x objective-c++ -Wno-return-type -fblocks -fms-extensions -rewrite-objc %s -o %t-rw.cpp

+// RUN: %clang_cc1 -fsyntax-only -fblocks -Wno-address-of-temporary -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp

+

+void *sel_registerName(const char *);

+void objc_enumerationMutation(id);

+// RUN: %clang_cc1 -x objective-c++ -Wno-return-type -fblocks -fms-extensions -rewrite-objc %s -o %t-rw.cpp

+// RUN: %clang_cc1 -fsyntax-only -fblocks -Wno-address-of-temporary -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp

+void *sel_registerName(const char *);

+void objc_enumerationMutation(id);

+

+// RUN: %clang_cc1 -x objective-c++ -Wno-return-type -fblocks -fms-extensions -rewrite-objc %s -o %t-rw.cpp

+// RUN: %clang_cc1 -fsyntax-only -fblocks -Wno-address-of-temporary -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp

+// rdar:// 9039342

+

+void *sel_registerName(const char *);

+void objc_enumerationMutation(id);

+

+@protocol CoreDAVLeafDataPayload @end

+

+@class NSString;

+

+@interface CoreDAVAction

+- (id) context;

+@end

+

+@interface I

+{

+ id uuidsToAddActions;

+}

+@end

+

+@implementation I

+- (void) Meth {

+ for (id<CoreDAVLeafDataPayload> uuid in uuidsToAddActions) {

+ CoreDAVAction *action = 0;

+ id <CoreDAVLeafDataPayload> payload = [action context];

+ }

+}

+@end

+// RUN: %clang_cc1 -x objective-c++ -Wno-return-type -fblocks -fms-extensions -rewrite-objc %s -o %t-rw.cpp

+// RUN: %clang_cc1 -fsyntax-only -fblocks -Wno-address-of-temporary -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp

+

+// rdar://9056351

+void *sel_registerName(const char *);

+

+@interface NSObject @end

+@class NSString;

+

+@protocol P

+ -(void)ParliamentFunkadelic;

+@end

+

+@interface Foo {

+ NSObject <P> *_dataSource;

+}

+@end

+

+@interface Bar { }

++(void)WhateverBar:(NSString*)format, ...;

+@end

+

+@implementation Foo

+-(void)WhateverFoo {

+ [Bar WhateverBar:@"ISyncSessionDriverDataSource %@ responded poorly", _dataSource];

+}

+@end

+// Enumeration types with a fixed underlying type.

+const int seventeen = 17;

+typedef int Int;

+

+struct X0 {

+ enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}

+ enum E1 : seventeen;

+};

+

+enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}

+ SomeValue = 0x100000000

+};

+

+// Test the GNU extension for initializing an array from an array

+// compound literal. PR9261.

+typedef int int5[5];

+int a1[5] = (int[]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}}

+int a2[5] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}}

+int a3[] = ((int[]){1, 2, 3, 4, 5}); // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}}

+int a4[] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}}

+int a5[] = (int5){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int5' (aka 'int [5]') is a GNU extension}}

+

+int a6[5] = (int[]){1, 2, 3}; // expected-error{{cannot initialize array of type 'int [5]' with array of type 'int [3]'}}

+

+int nonconst_value();

+int a7[5] = (int[5]){ 1, 2, 3, 4, nonconst_value() }; // expected-error{{initializer element is not a compile-time constant}}

+

+// <rdar://problem/8559831>

+enum E8559831a { E8559831a_val };

+enum E8559831b { E8559831b_val };

+typedef enum { E8559831c_val } E8559831c;

+enum { E8559831d_val } value_d;

+

+void test_8559831_a(enum E8559831a value);

+void test_8559831(enum E8559831b value_a, E8559831c value_c) {

+ test_8559831_a(value_a); // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}

+ enum E8559831a a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}

+ a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}}

+

+ test_8559831_a(value_c); // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}

+ enum E8559831a a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}

+ a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}}

+

+ test_8559831_a(value_d);

+ enum E8559831a a3 = value_d;

+ a3 = value_d;

+}

+// PR 8876 - don't warn about trivially unreachable null derefs. Note that

+// we put this here because the reachability analysis only kicks in for

+// suppressing false positives when code has no errors.

+#define PR8876(err_ptr) do {\

+ if (err_ptr) *(int*)(err_ptr) = 1;\

+ } while (0)

+

+#define PR8876_pos(err_ptr) do {\

+ if (!err_ptr) *(int*)(err_ptr) = 1;\

+ } while (0)

+

+

+int test_pr8876() {

+ PR8876(0); // no-warning

+ PR8876_pos(0); // expected-warning{{indirection of non-volatile null pointer will be deleted, not trap}} expected-note{{consider using __builtin_trap() or qualifying pointer with 'volatile'}}

+ return 0;

+}

+

+// PR 8183 - Handle null pointer constants on the left-side of the '&&', and reason about

+// this when determining the reachability of the null pointer dereference on the right side.

+void pr8183(unsigned long long test)

+{

+ (void)((((void*)0)) && (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000))))); // no-warning

+ (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000)))); // expected-warning {{indirection of non-volatile null pointer will be deleted, not trap}} expected-note {{consider using __builtin_trap() or qualifying pointer with 'volatile'}}

+}

+

+

+// PR8486

+//

+// Test what happens when -Wformat is on, but -Wformat-security is off.

+#pragma GCC diagnostic warning "-Wformat"

+#pragma GCC diagnostic ignored "-Wformat-security"

+

+void pr8486() {

+ printf("%s", 1); // expected-warning{{conversion specifies type 'char *' but the argument has type 'int'}}

+}

+

+// PR9314

+// Don't warn about string literals that are PreDefinedExprs, e.g. __func__.

+void pr9314() {

+ printf(__PRETTY_FUNCTION__); // no-warning

+ printf(__func__); // no-warning

+}

+

+int illegaldiv1a[1 || 1/0]; // expected-warning {{division by zero is undefined}}

+int illegaldiv1b[1 && 1/0]; // expected-warning {{division by zero is undefined}} expected-error{{variable length array declaration not allowed at file scope}}

+

+// PR9262

+int illegaldiv4[0 / (1 / 0)]; // expected-warning {{division by zero is undefined}} expected-error {{variable length array declaration not allowed at file scope}}

+

+// RUN: %clang_cc1 -fsyntax-only -Wparentheses -Werror -fdiagnostics-show-option %s 2>&1 | FileCheck %s

+// CHECK: error: using the result of an assignment as a condition without parentheses [-Werror,-Wparentheses]

+

+char* const volatile restrict ignored_cvr_quals(); // expected-warning{{'const volatile restrict' type qualifiers on return type have no effect}}

+// RUN: %clang -Wall -Wshift-sign-overflow -ffreestanding -fsyntax-only -Xclang -verify %s

+#define WORD_BIT (sizeof(int) * CHAR_BIT)

+

+

+ int i;

+ i = 1 << (WORD_BIT - 2);

+ i = 2 << (WORD_BIT - 1); // expected-warning {{bits to represent, but 'int' only has}}

+ i = 1 << (WORD_BIT - 1); // expected-warning {{overrides the sign bit of the shift expression}}

+ i = -1 << (WORD_BIT - 1);

+ i = 0 << (WORD_BIT - 1);

+ i = (char)1 << (WORD_BIT - 2);

+

+ unsigned u;

+ u = 1U << (WORD_BIT - 1);

+ u = 5U << (WORD_BIT - 1);

+

+ long long int lli;

+ lli = INT_MIN << 2; // expected-warning {{bits to represent, but 'int' only has}}

+ lli = 1LL << (sizeof(long long) * CHAR_BIT - 2);

+void h1(int x) {}

+int h2(int x) { return 1; }

+

+

+ h1<<<1, 1>>>(42); // expected-error {{kernel call to non-global function h1}}

+

+ int (*fp)(int) = h2;

+ fp<<<1, 1>>>(42); // expected-error {{must have void return type}}

+

+// Enumeration types with a fixed underlying type.

+const int seventeen = 17;

+typedef int Int;

+

+struct X0 {

+ enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}

+ enum E1 : seventeen;

+};

+

+enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}

+ SomeValue = 0x100000000

+};

+ MACRO(a.b->f()); // expected-error{{base of member reference is a function}}

+

+// PR9247: Crash on invalid in clang::Sema::ActOnFinishCXXMemberSpecification

+namespace pr9247 {

+ struct A {

+ virtual void g(const A& input) = 0;

+ struct B {

+ C* f(int foo);

+ };

+ };

+}

+ char arr[I]; // expected-note 2 {{declared here}}

+ s.arr[4] = 0; // expected-warning {{array index of '4' indexes past the end of an array (that contains 3 elements)}}

+ int arr[SIZE]; // expected-note {{array 'arr' declared here}}

+ return ARR_IN_MACRO(0, arr, SIZE) + // no-warning

+// PR 9284 - a template parameter can cause an array bounds access to be

+// infeasible.

+template <bool extendArray>

+void pr9284() {

+ int arr[3 + (extendArray ? 1 : 0)];

+

+ if (extendArray)

+ arr[3] = 42; // no-warning

+}

+

+template <bool extendArray>

+void pr9284b() {

+ int arr[3 + (extendArray ? 1 : 0)]; // expected-note {{array 'arr' declared here}}

+

+ if (!extendArray)

+ arr[3] = 42; // expected-warning{{array index of '3' indexes past the end of an array (that contains 3 elements)}}

+}

+

+void test_pr9284() {

+ pr9284<true>();

+ pr9284<false>();

+ pr9284b<true>();

+ pr9284b<false>(); // expected-note{{in instantiation of function template specialization 'pr9284b<false>' requested here}}

+}

+

+int test_pr9296() {

+ int array[2];

+ return array[true]; // no-warning

+}

+

+

+namespace radar9046492 {

+// rdar://9046492

+#define FOO __attribute__((unavailable("not available - replaced")))

+

+void foo() FOO; // expected-note {{candidate function has been explicitly made unavailable}}

+void bar() {

+ foo(); // expected-error {{call to unavailable function 'foo' not available - replaced}}

+}

+}

+ auto int a; // expected-warning {{'auto' storage class specifier is redundant and will be removed in future releases}}

+

+// PR 9276 - Make sure we check auto types deduce the same

+// in the case of a dependent initializer

+namespace PR9276 {

+ template<typename T>

+ void f() {

+ auto i = T(), j = 0; // expected-error {{deduced as 'long' in declaration of 'i' and deduced as 'int' in declaration of 'j'}}

+ }

+

+ void g() {

+ f<long>(); // expected-note {{here}}

+ f<int>();

+ }

+}

+

+namespace NoRepeatedDiagnostic {

+ template<typename T>

+ void f() {

+ auto a = 0, b = 0.0, c = T(); // expected-error {{deduced as 'int' in declaration of 'a' and deduced as 'double' in declaration of 'b'}}

+ }

+ // We've already diagnosed an issue. No extra diagnostics is needed for these.

+ template void f<int>();

+ template void f<double>();

+ template void f<char>();

+}

+

+enum : long {

+ long_enum_val = 10000

+};

+

+enum : long x; // expected-error{{unnamed enumeration must be a definition}} \

+// expected-warning{{declaration does not declare anything}}

+// RUN: %clang_cc1 -Werror -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s

+namespace {

+ // CHECK: define void @test4(

+ extern "C" void test4(void) {}

+}

+

+// PR9316: Ensure that even non-namespace-scope function declarations in

+// a C declaration context respect that over the anonymous namespace.

+extern "C" {

+ namespace {

+ struct X {

+ int f() {

+ extern int g();

+ extern int a;

+

+ // Test both for mangling in the code generation and warnings from use

+ // of internal, undefined names via -Werror.

+ // CHECK: call i32 @g(

+ // CHECK: load i32* @a,

+ return g() + a;

+ }

+ };

+ }

+ // Force the above function to be emitted by codegen.

+ int test(X& x) {

+ return x.f();

+ }

+}

+

+ return b->f0->f0; // expected-error{{perhaps you meant to call it with no arguments}}

+ return fun.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}}

+

+ S fun3(int i=0);

+ int fun3(int i, int j);

+ int g3() {

+ return fun3.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}}

+ }

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+// Note: the formatting in this test case is intentionally funny, with

+// nested-name-specifiers stretched out vertically so that we can

+// match up diagnostics per-line and still verify that we're getting

+// good source-location information.

+

+namespace outer {

+ namespace inner {

+ template<typename T>

+ struct X0 {

+ };

+ }

+}

+

+template<typename T>

+struct add_reference {

+ typedef T& type;

+};

+

+namespace outer_alias = outer;

+

+template<typename T>

+struct UnresolvedUsingValueDeclTester {

+ using outer::inner::X0<

+ typename add_reference<T>::type

+ * // expected-error{{declared as a pointer to a reference of type}}

+ >::value;

+};

+

+UnresolvedUsingValueDeclTester<int> UnresolvedUsingValueDeclCheck; // expected-note{{in instantiation of template class}}

+

+template<typename T>

+struct UnresolvedUsingTypenameDeclTester {

+ using outer::inner::X0<

+ typename add_reference<T>::type

+ * // expected-error{{declared as a pointer to a reference of type}}

+ >::value;

+};

+

+UnresolvedUsingTypenameDeclTester<int> UnresolvedUsingTypenameDeclCheck; // expected-note{{in instantiation of template class}}

+

+

+template<typename T, typename U>

+struct PseudoDestructorExprTester {

+ void f(T *t) {

+ t->T::template Inner<typename add_reference<U>::type

+ * // expected-error{{as a pointer to a reference of type}}

+ >::Blarg::~Blarg();

+ }

+};

+

+struct HasInnerTemplate {

+ template<typename T>

+ struct Inner;

+

+ typedef HasInnerTemplate T;

+};

+

+void PseudoDestructorExprCheck(

+ PseudoDestructorExprTester<HasInnerTemplate, float> tester) {

+ tester.f(0); // expected-note{{in instantiation of member function}}

+}

+

+template<typename T>

+struct DependentScopedDeclRefExpr {

+ void f() {

+ outer_alias::inner::X0<T>::value = 17;

+ }

+};

+

+namespace alias = A;

+double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}

+int const scalar_c2(); // expected-warning{{'const' type qualifier on return type has no effect}}

+

+const

+char*

+const // expected-warning{{'const' type qualifier on return type has no effect}}

+f();

+

+char

+const*

+const // expected-warning{{'const' type qualifier on return type has no effect}}

+g();

+

+char* const h(); // expected-warning{{'const' type qualifier on return type has no effect}}

+char* volatile i(); // expected-warning{{'volatile' type qualifier on return type has no effect}}

+

+// RUN: %clang_cc1 -Wall -Wshift-sign-overflow -ffreestanding -fsyntax-only -verify %s

+

+#include <limits.h>

+

+#define WORD_BIT (sizeof(int) * CHAR_BIT)

+

+template <int N> void f() {

+ (void)(N << 30); // expected-warning {{bits to represent, but 'int' only has}}

+ (void)(30 << N); // expected-warning {{bits to represent, but 'int' only has}}

+}

+

+void test() {

+ f<30>(); // expected-note {{instantiation}}

+}

+

+// PR9304 and rdar://9045501

+void click_check_header_sizes() {

+ switch (0 == 8) { // expected-warning {{switch condition has boolean value}}

+ case 0: ;

+ }

+}

+

+namespace test6 {

+ template <class T> struct A {

+ static const int zero = 0;

+ static const int one = 1;

+ static const int two = 2;

+

+ int value;

+

+ A() : value(zero) {

+ value = one;

+ }

+ };

+

+ namespace { struct Internal; }

+

+ void test() {

+ A<Internal> a;

+ a.value = A<Internal>::two;

+ }

+}

+

+// We support (as an extension) private, undefined copy constructors when

+// a temporary is bound to a reference even in C++98. Similarly, we shouldn't

+// warn about this copy constructor being used without a definition.

+namespace PR9323 {

+ namespace {

+ struct Uncopyable {

+ Uncopyable() {}

+ private:

+ Uncopyable(const Uncopyable&); // expected-note {{declared private here}}

+ };

+ }

+ void f(const Uncopyable&) {}

+ void test() {

+ f(Uncopyable()); // expected-warning {{C++98 requires an accessible copy constructor}}

+ };

+}

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+int f() __attribute__((warn_unused_result));

+

+struct S {

+ void t() const;

+};

+S g1() __attribute__((warn_unused_result));

+S *g2() __attribute__((warn_unused_result));

+S &g3() __attribute__((warn_unused_result));

+

+void test() {

+ f(); // expected-warning {{ignoring return value}}

+ g1(); // expected-warning {{ignoring return value}}

+ g2(); // expected-warning {{ignoring return value}}

+ g3(); // expected-warning {{ignoring return value}}

+

+ (void)f();

+ (void)g1();

+ (void)g2();

+ (void)g3();

+

+ if (f() == 0) return;

+

+ g1().t();

+ g2()->t();

+ g3().t();

+

+ int i = f();

+ S s1 = g1();

+ S *s2 = g2();

+ S &s3 = g3();

+ const S &s4 = g1();

+}

+

+struct X {

+ int foo() __attribute__((warn_unused_result));

+};

+

+void bah() {

+ X x, *x2;

+ x.foo(); // expected-warning {{ignoring return value}}

+ x2->foo(); // expected-warning {{ignoring return value}}

+}

+// RUN: %clang_cc1 -x objective-c -fblocks -fsyntax-only -verify %s

+

+@interface I

+{

+ id pi;

+}

+- (id) Meth;

+@end

+

+// Objective-C does not support trailing return types, so check we don't get

+// the C++ diagnostic suggesting we forgot one.

+auto noTrailingReturnType(); // expected-error {{'auto' not allowed in function return type}}

+

+typedef int (^P) (int x);

+

+@implementation I

+- (id) Meth {

+ auto p = [pi Meth];

+ return p;

+}

+

+- (P) bfunc {

+ auto my_block = ^int (int x) {return x; };

+ my_block(1);

+ return my_block;

+}

+@end

+

+

+// rdar://9036633

+int main() {

+ auto int auto_i = 7; // expected-warning {{'auto' storage class specifier is redundant and will be removed in future releases}}

+}

+// RUN: %clang_cc1 -verify -fobjc-exceptions %s

+int glob;

+@property int glob;

+// rdar://9027673

+// Warning on future name lookup rule is removed.

+- (int) Meth { return glob; } // no warning

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+// rdar://7076235

+

+@protocol P

+- (bycopy id)serverPID; // expected-note {{previous declaration is here}}

+- (void)doStuff:(bycopy id)clientId; // expected-note {{previous declaration is here}}

+- (bycopy id)Ok;

++ (oneway id) stillMore : (byref id)Arg : (bycopy oneway id)Arg1; // expected-note 3 {{previous declaration is here}}

+@end

+

+@interface I <P>

+- (id)Ok;

+@end

+

+@implementation I

+- (id)serverPID { return 0; } // expected-warning {{conflicting distributed object modifiers on return type in implementation of 'serverPID'}}

+- (void)doStuff:(id)clientId { } // expected-warning {{conflicting distributed object modifiers on parameter type in implementation of 'doStuff:'}}

+- (bycopy id)Ok { return 0; }

++ (id) stillMore : (id)Arg : (bycopy id)Arg1 { return Arg; } // expected-warning {{conflicting distributed object modifiers on return type in implementation of 'stillMore::'}} \

+ // expected-warning 2{{conflicting distributed object modifiers on parameter type in implementation of 'stillMore::'}}

+@end

+// RUN: %clang_cc1 %s -fsyntax-only -verify -fobjc-exceptions

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s

+// RUN: %clang_cc1 -fsyntax-only %s -verify -fobjc-exceptions

+// RUN: %clang_cc1 %s -fsyntax-only -verify -Wmissing-noreturn -fobjc-exceptions

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s

+// RUN: %clang_cc1 %s -verify -fsyntax-only -fobjc-exceptions

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions -Wunused-exception-parameter %s

+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s