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 'b0a0fbcc35'
${ noResults }
infer_clone/infer/tests/codetoanalyze/cpp/shared/reference/nested_assignment.cpp.dot

65 lines
5.7 KiB
Raw Normal View History Unescape

Add @generated comment to icfg.dot files Reviewed By: jvillard Differential Revision: D3358243 fbshipit-source-id: a47cc01
9 years ago
/* @generated */
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 {
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_5" [label="5: DeclStmt \n *&a:int=3 [line 17]\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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_5" -> "nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_4" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_4" [label="4: 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_4" -> "nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_3" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_3" [label="3: 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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_3" -> "nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_2" ;
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_2" [label="2: Exit nested \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
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_1" [label="1: 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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_1" -> "nested{d41d8cd98f00b204e9800998ecf8427e_Z6nestedv}.59d18215121661ae2707e8993c9e1433_5" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_5" [label="5: DeclStmt \n *&a:int=3 [line 11]\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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_5" -> "normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_4" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_4" -> "normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_3" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_3" [label="3: DeclStmt \n n$0=*&ref_from_val:int& [line 13]\n *&ref_from_ref:int&=n$0 [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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_3" -> "normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_2" ;
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_2" [label="2: Exit normal \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
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_1" -> "normal{d41d8cd98f00b204e9800998ecf8427e_Z6normalv}.27770b5cdb0944c31e210c781f6d966a_5" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_6" [label="6: 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_6" -> "crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_5" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_5" [label="5: DeclStmt \n n$3=*&a:int [line 24]\n *&b:int=n$3 [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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_5" -> "crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_4" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_4" [label="4: 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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_4" -> "crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_3" ;
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_3" [label="3: 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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_3" -> "crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_2" ;
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_2" [label="2: Exit crazy_nested \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
[backend] eliminate phantom spaces in printing of types Summary: These are dangerous if you are trying to compare a type to a string, and they're also unsightly. Reviewed By: jvillard Differential Revision: D4189956 fbshipit-source-id: 14ce127
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_1" [label="1: 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 " 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
[debug][dotty] Fix issue in dotty output where overloaded functions were conflated Reviewed By: jvillard Differential Revision: D4117078 fbshipit-source-id: fdd8e93
8 years ago
"crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_1" -> "crazy_nested{d41d8cd98f00b204e9800998ecf8427e_Z12crazy_nestedv}.34e5d17f31c7b7458122d9487519fa7a_6" ;
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
}