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

65 lines
5.4 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 */
[cfg] rename iCFG to cfg in dotty files Summary: Not sure what an "iCFG" is but the dotty is only about CFGs anyway. Diff obtained by mass-`sed`. Reviewed By: sblackshear Differential Revision: D6324280 fbshipit-source-id: b7603bb
7 years ago
digraph cfg {
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_1" [label="1: Start crazy_nested\nFormals: \nLocals: ref_from_ref:int& ref_from_val:int& b:int a:int \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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_1" -> "crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_6" ;
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_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
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_3" [label="3: DeclStmt \n n$3=_fun___variable_initialization(&ref_from_ref:int&) [line 27, column 3]\n n$1=*&ref_from_val:int& [line 27, column 23]\n *&b:int=5 [line 27, column 38]\n n$2=*&b:int [line 27, column 38]\n *n$1:int=n$2 [line 27, column 23]\n *&ref_from_ref:int&=n$1 [line 27, column 3]\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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_3" -> "crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_2" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_4" [label="4: DeclStmt \n n$5=_fun___variable_initialization(&ref_from_val:int&) [line 26, column 3]\n *&b:int=4 [line 26, column 27]\n n$4=*&b:int [line 26, column 27]\n *&a:int=n$4 [line 26, column 23]\n *&ref_from_val:int&=&a [line 26, column 3]\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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_4" -> "crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_3" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_5" [label="5: DeclStmt \n n$7=_fun___variable_initialization(&b:int) [line 22, column 3]\n n$6=*&a:int [line 22, column 11]\n *&b:int=n$6 [line 22, column 3]\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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_5" -> "crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_4" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_6" [label="6: DeclStmt \n n$8=_fun___variable_initialization(&a:int) [line 21, column 3]\n *&a:int=3 [line 21, column 3]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_6" -> "crazy_nested#10001276026471322284.a3162fff8adcb89d9e3fa84dea455e7f_5" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_1" [label="1: Start nested\nFormals: \nLocals: ref_from_ref:int& ref_from_val:int& a:int \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
[clang] update clang plugin to hash mangled names Summary: With this change and the previous facebook-clang-plugins change, infer no longer exhausts the biniou buffer when reading the serialized C++ AST. update-submodule: facebook-clang-plugins Reviewed By: mbouaziz Differential Revision: D5891081 fbshipit-source-id: cf48eac
7 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_1" -> "nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_5" ;
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_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
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_3" [label="3: DeclStmt \n n$2=_fun___variable_initialization(&ref_from_ref:int&) [line 17, column 3]\n n$1=*&ref_from_val:int& [line 17, column 23]\n *n$1:int=6 [line 17, column 23]\n *&ref_from_ref:int&=n$1 [line 17, column 3]\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
[clang] update clang plugin to hash mangled names Summary: With this change and the previous facebook-clang-plugins change, infer no longer exhausts the biniou buffer when reading the serialized C++ AST. update-submodule: facebook-clang-plugins Reviewed By: mbouaziz Differential Revision: D5891081 fbshipit-source-id: cf48eac
7 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_3" -> "nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_2" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_4" [label="4: DeclStmt \n n$3=_fun___variable_initialization(&ref_from_val:int&) [line 16, column 3]\n *&a:int=4 [line 16, column 23]\n *&ref_from_val:int&=&a [line 16, column 3]\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
[clang] update clang plugin to hash mangled names Summary: With this change and the previous facebook-clang-plugins change, infer no longer exhausts the biniou buffer when reading the serialized C++ AST. update-submodule: facebook-clang-plugins Reviewed By: mbouaziz Differential Revision: D5891081 fbshipit-source-id: cf48eac
7 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_4" -> "nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_3" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_5" [label="5: DeclStmt \n n$4=_fun___variable_initialization(&a:int) [line 15, column 3]\n *&a:int=3 [line 15, column 3]\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
[clang] update clang plugin to hash mangled names Summary: With this change and the previous facebook-clang-plugins change, infer no longer exhausts the biniou buffer when reading the serialized C++ AST. update-submodule: facebook-clang-plugins Reviewed By: mbouaziz Differential Revision: D5891081 fbshipit-source-id: cf48eac
7 years ago
"nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_5" -> "nested#4768179933025409429.17c34afcb279e8ad08f7f8afaad41585_4" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_1" [label="1: Start normal\nFormals: \nLocals: ref_from_ref:int& ref_from_val:int& a:int \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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_1" -> "normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_5" ;
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_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
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_3" [label="3: DeclStmt \n n$2=_fun___variable_initialization(&ref_from_ref:int&) [line 11, column 3]\n n$1=*&ref_from_val:int& [line 11, column 23]\n *&ref_from_ref:int&=n$1 [line 11, column 3]\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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_3" -> "normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_2" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_4" [label="4: DeclStmt \n n$3=_fun___variable_initialization(&ref_from_val:int&) [line 10, column 3]\n *&ref_from_val:int&=&a [line 10, column 3]\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] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_4" -> "normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_3" ;
[clang] leave markers of variable initialization for pulse Summary: When initialising a variable via semi-exotic means, the frontend loses the information that the variable was initialised. For instance, it translates: ``` struct Foo { int i; }; ... Foo s = {42}; ``` as: ``` s.i := 42 ``` This can be confusing for backends that need to know that `s` actually got initialised, eg pulse. The solution implemented here is to insert of dummy call to `__variable_initiazition`: ``` __variable_initialization(&s); s.i := 42; ``` Then checkers can recognise that this builtin function does what its name says. Reviewed By: mbouaziz Differential Revision: D12887122 fbshipit-source-id: 6e7214438
6 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_5" [label="5: DeclStmt \n n$4=_fun___variable_initialization(&a:int) [line 9, column 3]\n *&a:int=3 [line 9, column 3]\n " shape="box"]
Sort nodes when printing cfg to dot file Summary: Currently cfg nodes are written into dot files in whatever order they appear in a hash table. This seems unnecessarily sensitive, so this diff sorts the nodes. Reviewed By: dulmarod Differential Revision: D4232377 fbshipit-source-id: a907cc6
8 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_5" -> "normal#16009437256715545217.c7cd9ebbb6d7cc9f4987cf90ce12a044_4" ;
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
}