2015-04-29 06:58:25 +08:00
|
|
|
// RUN: %clang_cc1 -triple x86_64-windows -fborland-extensions -DBORLAND -fsyntax-only -verify -fblocks %s
|
|
|
|
// RUN: %clang_cc1 -triple x86_64-windows -fms-extensions -fsyntax-only -verify -fblocks %s
|
2011-04-28 09:08:34 +08:00
|
|
|
|
|
|
|
#define JOIN2(x,y) x ## y
|
|
|
|
#define JOIN(x,y) JOIN2(x,y)
|
|
|
|
#define TEST2(name) JOIN(name,__LINE__)
|
|
|
|
#define TEST TEST2(test)
|
|
|
|
typedef int DWORD;
|
|
|
|
|
|
|
|
#pragma sysheader begin
|
|
|
|
|
|
|
|
struct EXCEPTION_INFO{};
|
|
|
|
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
unsigned long __exception_code();
|
|
|
|
#ifdef BORLAND
|
2011-04-28 09:08:34 +08:00
|
|
|
struct EXCEPTION_INFO* __exception_info();
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
#endif
|
2015-02-05 06:37:07 +08:00
|
|
|
int __abnormal_termination();
|
2011-04-28 09:08:34 +08:00
|
|
|
|
|
|
|
#define GetExceptionCode __exception_code
|
|
|
|
#define GetExceptionInformation __exception_info
|
|
|
|
#define AbnormalTermination __abnormal_termination
|
|
|
|
|
|
|
|
#pragma sysheader end
|
|
|
|
|
2011-10-21 11:57:52 +08:00
|
|
|
DWORD FilterExpression(int); // expected-note{{declared here}}
|
2011-04-28 09:08:34 +08:00
|
|
|
DWORD FilterExceptionInformation(struct EXCEPTION_INFO*);
|
|
|
|
|
|
|
|
const char * NotFilterExpression();
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
__try {
|
|
|
|
__try {
|
|
|
|
}
|
|
|
|
__finally{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__finally{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__finally{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
} // expected-error{{expected '__except' or '__finally' block}}
|
|
|
|
|
|
|
|
void TEST() {
|
2011-10-21 11:57:52 +08:00
|
|
|
__except ( FilterExpression() ) { // expected-warning{{implicit declaration of function '__except' is invalid in C99}} \
|
|
|
|
// expected-error{{too few arguments to function call, expected 1, have 0}}
|
2011-04-28 09:08:34 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__finally { } // expected-error{{}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try{
|
|
|
|
int try_scope = 0;
|
|
|
|
} // TODO: expected expression is an extra error
|
|
|
|
__except( try_scope ? 1 : -1 ) // expected-error{{undeclared identifier 'try_scope'}} expected-error{{expected expression}}
|
|
|
|
{}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
// TODO: Why are there two errors?
|
|
|
|
__except( ) { // expected-error{{expected expression}} expected-error{{expected expression}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
__except ( FilterExpression(GetExceptionCode()) ) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
__except( FilterExpression(__exception_code()) ) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
__except( FilterExceptionInformation(__exception_info()) ) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
__except(FilterExceptionInformation( GetExceptionInformation() ) ) {
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
2019-11-08 06:13:26 +08:00
|
|
|
__except ( NotFilterExpression() ) { // expected-error{{filter expression has non-integral type 'const char *'}}
|
2011-04-28 09:08:34 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
int function_scope = 0;
|
|
|
|
__try {
|
|
|
|
int try_scope = 0;
|
|
|
|
}
|
|
|
|
__except ( FilterExpression(GetExceptionCode()) ) {
|
|
|
|
(void)function_scope;
|
|
|
|
(void)try_scope; // expected-error{{undeclared identifier}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
int function_scope = 0;
|
|
|
|
__try {
|
|
|
|
int try_scope = 0;
|
|
|
|
}
|
|
|
|
__finally {
|
|
|
|
(void)function_scope;
|
|
|
|
(void)try_scope; // expected-error{{undeclared identifier}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
int function_scope = 0;
|
|
|
|
__try {
|
|
|
|
|
|
|
|
}
|
|
|
|
__except( function_scope ? 1 : -1 ) {}
|
|
|
|
}
|
|
|
|
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
#ifdef BORLAND
|
2011-04-28 09:08:34 +08:00
|
|
|
void TEST() {
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
(void)__abnormal_termination(); // expected-error{{only allowed in __finally block}}
|
|
|
|
(void)AbnormalTermination(); // expected-error{{only allowed in __finally block}}
|
|
|
|
|
2011-04-28 09:08:34 +08:00
|
|
|
__try {
|
|
|
|
(void)AbnormalTermination; // expected-error{{only allowed in __finally block}}
|
|
|
|
(void)__abnormal_termination; // expected-error{{only allowed in __finally block}}
|
|
|
|
}
|
|
|
|
__except( 1 ) {
|
|
|
|
(void)AbnormalTermination; // expected-error{{only allowed in __finally block}}
|
|
|
|
(void)__abnormal_termination; // expected-error{{only allowed in __finally block}}
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
}
|
|
|
|
__finally {
|
|
|
|
AbnormalTermination();
|
|
|
|
__abnormal_termination();
|
|
|
|
}
|
|
|
|
}
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
#endif
|
2011-04-28 09:08:34 +08:00
|
|
|
|
|
|
|
void TEST() {
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
(void)__exception_info(); // expected-error{{only allowed in __except filter expression}}
|
2011-04-28 09:08:34 +08:00
|
|
|
(void)GetExceptionInformation(); // expected-error{{only allowed in __except filter expression}}
|
Initial support for Win64 SEH IR emission
The lowering looks a lot like normal EH lowering, with the exception
that the exceptions are caught by executing filter expression code
instead of matching typeinfo globals. The filter expressions are
outlined into functions which are used in landingpad clauses where
typeinfo would normally go.
Major aspects that still need work:
- Non-call exceptions in __try bodies won't work yet. The plan is to
outline the __try block in the frontend to keep things simple.
- Filter expressions cannot use local variables until capturing is
implemented.
- __finally blocks will not run after exceptions. Fixing this requires
work in the LLVM SEH preparation pass.
The IR lowering looks like this:
// C code:
bool safe_div(int n, int d, int *r) {
__try {
*r = normal_div(n, d);
} __except(_exception_code() == EXCEPTION_INT_DIVIDE_BY_ZERO) {
return false;
}
return true;
}
; LLVM IR:
define i32 @filter(i8* %e, i8* %fp) {
%ehptrs = bitcast i8* %e to i32**
%ehrec = load i32** %ehptrs
%code = load i32* %ehrec
%matches = icmp eq i32 %code, i32 u0xC0000094
%matches.i32 = zext i1 %matches to i32
ret i32 %matches.i32
}
define i1 zeroext @safe_div(i32 %n, i32 %d, i32* %r) {
%rr = invoke i32 @normal_div(i32 %n, i32 %d)
to label %normal unwind to label %lpad
normal:
store i32 %rr, i32* %r
ret i1 1
lpad:
%ehvals = landingpad {i8*, i32} personality i32 (...)* @__C_specific_handler
catch i8* bitcast (i32 (i8*, i8*)* @filter to i8*)
%ehptr = extractvalue {i8*, i32} %ehvals, i32 0
%sel = extractvalue {i8*, i32} %ehvals, i32 1
%filter_sel = call i32 @llvm.eh.seh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filter to i8*))
%matches = icmp eq i32 %sel, %filter_sel
br i1 %matches, label %eh.except, label %eh.resume
eh.except:
ret i1 false
eh.resume:
resume
}
Reviewers: rjmccall, rsmith, majnemer
Differential Revision: http://reviews.llvm.org/D5607
llvm-svn: 226760
2015-01-22 09:36:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
#ifndef BORLAND
|
|
|
|
(void)__exception_code; // expected-error{{builtin functions must be directly called}}
|
|
|
|
#endif
|
|
|
|
(void)__exception_code(); // expected-error{{only allowed in __except block or filter expression}}
|
|
|
|
(void)GetExceptionCode(); // expected-error{{only allowed in __except block or filter expression}}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TEST() {
|
|
|
|
__try {
|
|
|
|
} __except(1) {
|
|
|
|
GetExceptionCode(); // valid
|
|
|
|
GetExceptionInformation(); // expected-error{{only allowed in __except filter expression}}
|
|
|
|
}
|
2011-04-28 09:08:34 +08:00
|
|
|
}
|
2014-07-07 06:32:59 +08:00
|
|
|
|
2014-07-07 08:12:30 +08:00
|
|
|
void test_seh_leave_stmt() {
|
2014-07-07 06:53:19 +08:00
|
|
|
__leave; // expected-error{{'__leave' statement not in __try block}}
|
|
|
|
|
2014-07-07 06:32:59 +08:00
|
|
|
__try {
|
2014-07-07 08:12:30 +08:00
|
|
|
__leave;
|
|
|
|
__leave 4; // expected-error{{expected ';' after __leave statement}}
|
2014-07-07 06:32:59 +08:00
|
|
|
} __except(1) {
|
2014-07-07 06:53:19 +08:00
|
|
|
__leave; // expected-error{{'__leave' statement not in __try block}}
|
2014-07-07 06:32:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
2014-07-07 08:12:30 +08:00
|
|
|
__leave;
|
2014-07-07 06:32:59 +08:00
|
|
|
} __finally {
|
2014-07-07 06:53:19 +08:00
|
|
|
__leave; // expected-error{{'__leave' statement not in __try block}}
|
2014-07-07 06:32:59 +08:00
|
|
|
}
|
2014-07-07 06:53:19 +08:00
|
|
|
__leave; // expected-error{{'__leave' statement not in __try block}}
|
2014-07-07 06:32:59 +08:00
|
|
|
}
|
Warn when jumping out of a __finally block via continue, break, return, __leave.
Since continue, break, return are much more common than __finally, this tries
to keep the work for continue, break, return O(1). Sema keeps a stack of active
__finally scopes (to do this, ActOnSEHFinally() is split into
ActOnStartSEHFinally() and ActOnFinishSEHFinally()), and the various jump
statements then check if the current __finally scope (if present) is deeper
than then destination scope of the jump.
The same warning for goto statements is still missing.
This is the moral equivalent of MSVC's C4532.
llvm-svn: 231623
2015-03-09 10:47:59 +08:00
|
|
|
|
|
|
|
void test_jump_out_of___finally() {
|
|
|
|
while(1) {
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
continue; // expected-warning{{jump out of __finally block has undefined behavior}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
while (1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check that a deep __finally containing a block with a shallow continue
|
|
|
|
// doesn't trigger the warning.
|
|
|
|
while(1) {{{{
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
^{
|
|
|
|
while(1)
|
|
|
|
continue;
|
|
|
|
}();
|
|
|
|
}
|
|
|
|
}}}}
|
|
|
|
|
|
|
|
while(1) {
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
break; // expected-warning{{jump out of __finally block has undefined behavior}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
switch(1) {
|
|
|
|
case 1:
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
break; // expected-warning{{jump out of __finally block has undefined behavior}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
while (1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
__leave; // expected-warning{{jump out of __finally block has undefined behavior}}
|
|
|
|
}
|
|
|
|
} __finally {
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
__try {
|
|
|
|
__leave;
|
|
|
|
} __finally {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
return; // expected-warning{{jump out of __finally block has undefined behavior}}
|
|
|
|
}
|
|
|
|
|
|
|
|
__try {
|
|
|
|
} __finally {
|
|
|
|
^{
|
|
|
|
return;
|
|
|
|
}();
|
|
|
|
}
|
|
|
|
}
|
2015-04-03 06:09:32 +08:00
|
|
|
|
|
|
|
void test_typo_in_except() {
|
|
|
|
__try {
|
|
|
|
} __except(undeclared_identifier) { // expected-error {{use of undeclared identifier 'undeclared_identifier'}} expected-error {{expected expression}}
|
|
|
|
}
|
|
|
|
}
|