pghs975uc
/
infer_clone
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ebcfae388a'
${ noResults }
infer_clone/infer/tests/codetoanalyze/cpp/frontend/reference/nested_assignment.cpp.dot

64 lines
3.0 KiB
Raw Normal View History Unescape

Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
digraph iCFG {
[clang-format] Reformat all c/cpp/objc sources with clang-format Reviewed By: jul Differential Revision: https://phabricator.fb.com/D2953843
9 years ago
16 [label="16: DeclStmt \n *&a:int =3 [line 23]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
16 -> 15 ;
[clang-format] Reformat all c/cpp/objc sources with clang-format Reviewed By: jul Differential Revision: https://phabricator.fb.com/D2953843
9 years ago
15 [label="15: DeclStmt \n n$3=*&a:int [line 24]\n *&b:int =n$3 [line 24]\n REMOVE_TEMPS(n$3); [line 24]\n NULLIFY(&b,false); [line 24]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
15 -> 14 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
14 [label="14: DeclStmt \n *&b:int =4 [line 28]\n n$2=*&b:int [line 28]\n *&a:int =n$2 [line 28]\n *&ref_from_val:int &=&a [line 28]\n REMOVE_TEMPS(n$2); [line 28]\n NULLIFY(&b,false); [line 28]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
14 -> 13 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
13 [label="13: DeclStmt \n n$0=*&ref_from_val:int & [line 29]\n *&b:int =5 [line 29]\n n$1=*&b:int [line 29]\n *n$0:int =n$1 [line 29]\n *&ref_from_ref:int &=n$0 [line 29]\n REMOVE_TEMPS(n$0,n$1); [line 29]\n NULLIFY(&b,false); [line 29]\n NULLIFY(&ref_from_ref,false); [line 29]\n NULLIFY(&ref_from_val,false); [line 29]\n NULLIFY(&a,false); [line 29]\n APPLY_ABSTRACTION; [line 29]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
13 -> 12 ;
12 [label="12: Exit crazy_nested \n " color=yellow style=filled]
[clang-format] Reformat all c/cpp/objc sources with clang-format Reviewed By: jul Differential Revision: https://phabricator.fb.com/D2953843
9 years ago
11 [label="11: Start crazy_nested\nFormals: \nLocals: ref_from_ref:int & ref_from_val:int & b:int a:int \n DECLARE_LOCALS(&return,&ref_from_ref,&ref_from_val,&b,&a); [line 22]\n NULLIFY(&b,false); [line 22]\n NULLIFY(&ref_from_ref,false); [line 22]\n NULLIFY(&ref_from_val,false); [line 22]\n " color=yellow style=filled]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
11 -> 16 ;
10 [label="10: DeclStmt \n *&a:int =3 [line 17]\n " shape="box"]
10 -> 9 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
9 [label="9: DeclStmt \n *&a:int =4 [line 18]\n *&ref_from_val:int &=&a [line 18]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
9 -> 8 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
8 [label="8: DeclStmt \n n$0=*&ref_from_val:int & [line 19]\n *n$0:int =6 [line 19]\n *&ref_from_ref:int &=n$0 [line 19]\n REMOVE_TEMPS(n$0); [line 19]\n NULLIFY(&ref_from_ref,false); [line 19]\n NULLIFY(&ref_from_val,false); [line 19]\n NULLIFY(&a,false); [line 19]\n APPLY_ABSTRACTION; [line 19]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
8 -> 7 ;
7 [label="7: Exit nested \n " color=yellow style=filled]
6 [label="6: Start nested\nFormals: \nLocals: ref_from_ref:int & ref_from_val:int & a:int \n DECLARE_LOCALS(&return,&ref_from_ref,&ref_from_val,&a); [line 16]\n NULLIFY(&ref_from_ref,false); [line 16]\n NULLIFY(&ref_from_val,false); [line 16]\n " color=yellow style=filled]
6 -> 10 ;
5 [label="5: DeclStmt \n *&a:int =3 [line 11]\n " shape="box"]
5 -> 4 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
4 [label="4: DeclStmt \n *&ref_from_val:int &=&a [line 12]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
4 -> 3 ;
Fix failing C++ frontend test Reviewed By: jvillard Differential Revision: D2555190 fb-gh-sync-id: af7bab2
9 years ago
3 [label="3: DeclStmt \n n$0=*&ref_from_val:int & [line 13]\n *&ref_from_ref:int &=n$0 [line 13]\n REMOVE_TEMPS(n$0); [line 13]\n NULLIFY(&ref_from_ref,false); [line 13]\n NULLIFY(&ref_from_val,false); [line 13]\n NULLIFY(&a,false); [line 13]\n APPLY_ABSTRACTION; [line 13]\n " shape="box"]
Handle assignment operations correctly Summary: public C++ assignment operation result is lvalue, while in C it was rvalue. This leads to different AST produced by clang for then same code! Use language information from clang (`-x` flag) to distinguish these cases. More specifically, let's look at following code: int r; int f = (r = 3); // type of (r = 3) expression: // C/objC -> int rvalue // C++/objC++ -> int lvalue Existing code did extra dereference because it was rvalue in C and there was no cast afterwards in C++ there will be extra LValueToRvalue cast when neccesary so we don't have to do extra dereference manually Reference: http://en.cppreference.com/w/c/language/value_category (search for 'assignment and compound assignment operators') NOTE: AST output doesn't change when something is hidden behind `extern "C"`, so we should use global language information Reviewed By: ddino Differential Revision: D2549866 fb-gh-sync-id: b193b11
9 years ago
3 -> 2 ;
2 [label="2: Exit normal \n " color=yellow style=filled]
1 [label="1: Start normal\nFormals: \nLocals: ref_from_ref:int & ref_from_val:int & a:int \n DECLARE_LOCALS(&return,&ref_from_ref,&ref_from_val,&a); [line 10]\n NULLIFY(&ref_from_ref,false); [line 10]\n NULLIFY(&ref_from_val,false); [line 10]\n " color=yellow style=filled]
1 -> 5 ;
}