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 '2151be9c25'
${ noResults }
infer_clone/infer/tests/codetoanalyze/cpp/shared/exceptions/Exceptions.cpp.dot

201 lines
24 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
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_1" [label="1: Start FN_deref_null_after_catch_bad\nFormals: i:int*\nLocals: 0$?%__sil_tmp__temp_construct_n$4:std::runtime_error 0$?%__sil_tmpSIL_materialize_temp__n$5:std::runtime_error const \n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_1" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_5" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_2" [label="2: Exit FN_deref_null_after_catch_bad \n NULLIFY(&0$?%__sil_tmp__temp_construct_n$4); [line 53, column 1]\n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$5); [line 53, column 1]\n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_3" [label="3: Return Stmt \n n$0=*&i:int* [line 52, column 11]\n n$1=*n$0:int [line 52, column 10]\n *&return:int=n$1 [line 52, column 3]\n NULLIFY(&i); [line 52, column 3]\n EXIT_SCOPE(n$0,n$1,i); [line 52, column 3]\n APPLY_ABSTRACTION; [line 52, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_3" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_2" ;
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_4" [label="4: ObjCCPPThrow \n n$7=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$5:std::runtime_error const ) assign_last [line 48, column 11]\n n$6=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmpSIL_materialize_temp__n$5:std::runtime_error const *,\"error\":char const *) [line 48, column 11]\n n$8=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmp__temp_construct_n$4:std::runtime_error*,&0$?%__sil_tmpSIL_materialize_temp__n$5:std::runtime_error const &) [line 48, column 11]\n n$9=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$4:std::runtime_error) [line 48, column 5]\n EXIT_SCOPE(n$6,n$7,n$8,n$9,0$?%__sil_tmpSIL_materialize_temp__n$5); [line 48, column 5]\n APPLY_ABSTRACTION; [line 48, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_4" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_3" ;
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_4" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_6" [color="red" ];
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_5" [label="5: BinaryOperatorStmt: Assign \n n$10=*&i:int* [line 47, column 6]\n *n$10:int=2 [line 47, column 5]\n EXIT_SCOPE(n$10); [line 47, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_5" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_4" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_6" [label="6: BinaryOperatorStmt: Assign \n *&i:int*=null [line 50, column 5]\n APPLY_ABSTRACTION; [line 50, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_6" -> "FN_deref_null_after_catch_bad#4627123003703707696.43441e3badf1bb571cbe770f9d51a51c_3" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_1" [label="1: Start FN_deref_null_in_catch_bad\nFormals: \nLocals: 0$?%__sil_tmp__temp_construct_n$2:std::runtime_error 0$?%__sil_tmpSIL_materialize_temp__n$3:std::runtime_error const i:int* \n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_1" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_6" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_2" [label="2: Exit FN_deref_null_in_catch_bad \n NULLIFY(&0$?%__sil_tmp__temp_construct_n$2); [line 43, column 1]\n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$3); [line 43, column 1]\n NULLIFY(&i); [line 43, column 1]\n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_3" [label="3: Return Stmt \n *&return:int=0 [line 42, column 3]\n EXIT_SCOPE(i); [line 42, column 3]\n APPLY_ABSTRACTION; [line 42, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_3" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_2" ;
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_4" [label="4: ObjCCPPThrow \n n$5=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$3:std::runtime_error const ) assign_last [line 38, column 11]\n n$4=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmpSIL_materialize_temp__n$3:std::runtime_error const *,\"error\":char const *) [line 38, column 11]\n n$6=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmp__temp_construct_n$2:std::runtime_error*,&0$?%__sil_tmpSIL_materialize_temp__n$3:std::runtime_error const &) [line 38, column 11]\n n$7=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$2:std::runtime_error) [line 38, column 5]\n EXIT_SCOPE(n$4,n$5,n$6,n$7,0$?%__sil_tmpSIL_materialize_temp__n$3); [line 38, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_4" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_3" ;
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_4" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_5" [color="red" ];
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_5" [label="5: Return Stmt \n n$9=*&i:int* [line 40, column 13]\n n$10=*n$9:int [line 40, column 12]\n *&return:int=n$10 [line 40, column 5]\n EXIT_SCOPE(n$9,n$10,i); [line 40, column 5]\n APPLY_ABSTRACTION; [line 40, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_5" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_2" ;
[SIL][preanalysis] add call flag for functions treating first formal as return Summary: This helps some checkers and the liveness preanalysis. Reviewed By: da319 Differential Revision: D13102954 fbshipit-source-id: b8d3c5fe2
6 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_6" [label="6: DeclStmt \n n$12=_fun___variable_initialization(&i:int*) assign_last [line 36, column 3]\n *&i:int*=null [line 36, column 3]\n EXIT_SCOPE(n$12); [line 36, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_6" -> "FN_deref_null_in_catch_bad#9297890526029657977.c83eec7c9ab8ce2e38ddbc08f8c3dfeb_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
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_1" [label="1: Start FN_multiple_catches_bad\nFormals: b:_Bool\nLocals: 0$?%__sil_tmp__temp_construct_n$4:std::length_error 0$?%__sil_tmpSIL_materialize_temp__n$5:std::length_error const 0$?%__sil_tmp__temp_construct_n$11:std::range_error 0$?%__sil_tmpSIL_materialize_temp__n$12:std::range_error const j:int* i:int* \n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_1" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_12" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_2" [label="2: Exit FN_multiple_catches_bad \n NULLIFY(&j); [line 70, column 1]\n NULLIFY(&0$?%__sil_tmp__temp_construct_n$11); [line 70, column 1]\n NULLIFY(&0$?%__sil_tmp__temp_construct_n$4); [line 70, column 1]\n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$12); [line 70, column 1]\n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$5); [line 70, column 1]\n NULLIFY(&i); [line 70, column 1]\n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_3" [label="3: Return Stmt \n *&return:int=0 [line 69, column 3]\n EXIT_SCOPE(i,j); [line 69, column 3]\n APPLY_ABSTRACTION; [line 69, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_3" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_2" ;
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" [label="4: + \n " ]
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_3" ;
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_10" [color="red" ];
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_9" [color="red" ];
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_5" [label="5: Prune (true branch, if) \n n$2=*&b:_Bool [line 59, column 9]\n PRUNE(n$2, true); [line 59, column 9]\n NULLIFY(&b); [line 59, column 9]\n EXIT_SCOPE(n$2,b); [line 59, column 9]\n " shape="invhouse"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_5" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_7" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_6" [label="6: Prune (false branch, if) \n n$2=*&b:_Bool [line 59, column 9]\n PRUNE(!n$2, false); [line 59, column 9]\n NULLIFY(&b); [line 59, column 9]\n EXIT_SCOPE(n$2,b); [line 59, column 9]\n " shape="invhouse"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_6" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_8" ;
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_7" [label="7: ObjCCPPThrow \n n$7=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$5:std::length_error const ) assign_last [line 60, column 13]\n n$6=_fun_std::length_error::length_error(&0$?%__sil_tmpSIL_materialize_temp__n$5:std::length_error const *,\"error\":char const *) [line 60, column 13]\n n$8=_fun_std::length_error::length_error(&0$?%__sil_tmp__temp_construct_n$4:std::length_error*,&0$?%__sil_tmpSIL_materialize_temp__n$5:std::length_error const &) [line 60, column 13]\n n$9=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$4:std::length_error) [line 60, column 7]\n EXIT_SCOPE(n$6,n$7,n$8,n$9,0$?%__sil_tmpSIL_materialize_temp__n$5); [line 60, column 7]\n APPLY_ABSTRACTION; [line 60, column 7]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_7" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" ;
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_8" [label="8: ObjCCPPThrow \n n$14=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$12:std::range_error const ) assign_last [line 62, column 13]\n n$13=_fun_std::range_error::range_error(&0$?%__sil_tmpSIL_materialize_temp__n$12:std::range_error const *,\"error\":char const *) [line 62, column 13]\n n$15=_fun_std::range_error::range_error(&0$?%__sil_tmp__temp_construct_n$11:std::range_error*,&0$?%__sil_tmpSIL_materialize_temp__n$12:std::range_error const &) [line 62, column 13]\n n$16=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$11:std::range_error) [line 62, column 7]\n EXIT_SCOPE(n$13,n$14,n$15,n$16,0$?%__sil_tmpSIL_materialize_temp__n$12); [line 62, column 7]\n APPLY_ABSTRACTION; [line 62, column 7]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_8" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_4" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_9" [label="9: Return Stmt \n n$19=*&i:int* [line 65, column 13]\n n$20=*n$19:int [line 65, column 12]\n *&return:int=n$20 [line 65, column 5]\n EXIT_SCOPE(n$19,n$20,i,j); [line 65, column 5]\n APPLY_ABSTRACTION; [line 65, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_9" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_2" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_10" [label="10: Return Stmt \n n$23=*&j:int* [line 67, column 13]\n n$24=*n$23:int [line 67, column 12]\n *&return:int=n$24 [line 67, column 5]\n EXIT_SCOPE(n$23,n$24,i,j); [line 67, column 5]\n APPLY_ABSTRACTION; [line 67, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_10" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_2" ;
[SIL][preanalysis] add call flag for functions treating first formal as return Summary: This helps some checkers and the liveness preanalysis. Reviewed By: da319 Differential Revision: D13102954 fbshipit-source-id: b8d3c5fe2
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_11" [label="11: DeclStmt \n n$26=_fun___variable_initialization(&j:int*) assign_last [line 57, column 3]\n *&j:int*=null [line 57, column 3]\n EXIT_SCOPE(n$26); [line 57, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_11" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_5" ;
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_11" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_6" ;
[SIL][preanalysis] add call flag for functions treating first formal as return Summary: This helps some checkers and the liveness preanalysis. Reviewed By: da319 Differential Revision: D13102954 fbshipit-source-id: b8d3c5fe2
6 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_12" [label="12: DeclStmt \n n$27=_fun___variable_initialization(&i:int*) assign_last [line 56, column 3]\n *&i:int*=null [line 56, column 3]\n EXIT_SCOPE(n$27); [line 56, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_12" -> "FN_multiple_catches_bad#4595182522053295670.680a793e449c2d7439ff6441ca69fa98_11" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_1" [label="1: Start basic_throw_ok\nFormals: \nLocals: 0$?%__sil_tmp__temp_construct_n$1:std::runtime_error 0$?%__sil_tmpSIL_materialize_temp__n$2:std::runtime_error const \n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_1" -> "basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_3" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_2" [label="2: Exit basic_throw_ok \n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$2); [line 27, column 64]\n NULLIFY(&0$?%__sil_tmp__temp_construct_n$1); [line 27, column 64]\n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_3" [label="3: ObjCCPPThrow \n n$4=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$2:std::runtime_error const ) assign_last [line 27, column 31]\n n$3=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmpSIL_materialize_temp__n$2:std::runtime_error const *,\"throwing!\":char const *) [line 27, column 31]\n n$5=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmp__temp_construct_n$1:std::runtime_error*,&0$?%__sil_tmpSIL_materialize_temp__n$2:std::runtime_error const &) [line 27, column 31]\n n$6=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$1:std::runtime_error) [line 27, column 25]\n EXIT_SCOPE(n$3,n$4,n$5,n$6,0$?%__sil_tmpSIL_materialize_temp__n$2); [line 27, column 25]\n APPLY_ABSTRACTION; [line 27, column 25]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_3" -> "basic_throw_ok#10529188890980782893.c9e1b8dd080b2621cfca65612331859d_2" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_1" [label="1: Start call_deref_with_null\nFormals: \nLocals: \n " color=yellow style=filled]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_1" -> "call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_3" ;
"call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_2" [label="2: Exit call_deref_with_null \n " color=yellow style=filled]
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
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_3" [label="3: Call _fun_deref_null \n n$1=_fun_deref_null(null:int*) [line 25, column 30]\n EXIT_SCOPE(n$1); [line 25, column 30]\n APPLY_ABSTRACTION; [line 25, column 30]\n " shape="box"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_3" -> "call_deref_with_null#4611966425999531792.6346543307e9a799421a89e451b917c2_2" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_1" [label="1: Start dead_deref_null_after_throw_ok\nFormals: \nLocals: 0$?%__sil_tmp__temp_construct_n$3:std::runtime_error 0$?%__sil_tmpSIL_materialize_temp__n$4:std::runtime_error const i:int* \n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_1" -> "dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_5" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_2" [label="2: Exit dead_deref_null_after_throw_ok \n NULLIFY(&0$?%__sil_tmp__temp_construct_n$3); [line 33, column 1]\n NULLIFY(&i); [line 33, column 1]\n NULLIFY(&0$?%__sil_tmpSIL_materialize_temp__n$4); [line 33, column 1]\n " color=yellow style=filled]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_3" [label="3: Return Stmt \n n$0=*&i:int* [line 32, column 11]\n n$1=*n$0:int [line 32, column 10]\n *&return:int=n$1 [line 32, column 3]\n EXIT_SCOPE(n$0,n$1,i); [line 32, column 3]\n APPLY_ABSTRACTION; [line 32, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_3" -> "dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_2" ;
RFC: stop using _ to separate ObjC/C++ class name from method in Typ.Procname.to_string Reviewed By: jvillard Differential Revision: D14736442 fbshipit-source-id: 500df354b
6 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_4" [label="4: ObjCCPPThrow \n n$6=_fun___variable_initialization(&0$?%__sil_tmpSIL_materialize_temp__n$4:std::runtime_error const ) assign_last [line 31, column 9]\n n$5=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmpSIL_materialize_temp__n$4:std::runtime_error const *,\"throwing!\":char const *) [line 31, column 9]\n n$7=_fun_std::runtime_error::runtime_error(&0$?%__sil_tmp__temp_construct_n$3:std::runtime_error*,&0$?%__sil_tmpSIL_materialize_temp__n$4:std::runtime_error const &) [line 31, column 9]\n n$8=_fun___infer_objc_cpp_throw(&0$?%__sil_tmp__temp_construct_n$3:std::runtime_error) [line 31, column 3]\n EXIT_SCOPE(n$5,n$6,n$7,n$8,0$?%__sil_tmpSIL_materialize_temp__n$4); [line 31, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_4" -> "dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_3" ;
[SIL][preanalysis] add call flag for functions treating first formal as return Summary: This helps some checkers and the liveness preanalysis. Reviewed By: da319 Differential Revision: D13102954 fbshipit-source-id: b8d3c5fe2
6 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_5" [label="5: DeclStmt \n n$9=_fun___variable_initialization(&i:int*) assign_last [line 30, column 3]\n *&i:int*=null [line 30, column 3]\n EXIT_SCOPE(n$9); [line 30, column 3]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_5" -> "dead_deref_null_after_throw_ok#12025371096822526715.42d41c040f3a321bb94f60bf7b55d001_4" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_1" [label="1: Start deref\nFormals: p:int*\nLocals: \n " color=yellow style=filled]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_1" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_5" ;
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_2" [label="2: Exit deref \n " color=yellow style=filled]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
9 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_3" [label="3: Return Stmt \n n$0=*&p:int* [line 15, column 11]\n n$1=*n$0:int [line 15, column 10]\n *&return:int=n$1 [line 15, column 3]\n NULLIFY(&p); [line 15, column 3]\n EXIT_SCOPE(n$0,n$1,p); [line 15, column 3]\n APPLY_ABSTRACTION; [line 15, column 3]\n " shape="box"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_3" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_2" ;
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_4" [label="4: + \n " ]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_4" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_3" ;
Change license to MIT Summary: Change the license of the source code from BSD + PATENTS to MIT. Change `checkCopyright` to reflect the new license and learn some new file types. Generated with: ``` git grep BSD | xargs -n 1 ./scripts/checkCopyright -i ``` Reviewed By: jeremydubreil, mbouaziz, jberdine Differential Revision: D8071249 fbshipit-source-id: 97ca23a
7 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_5" [label="5: BinaryOperatorStmt: EQ \n n$3=*&p:int* [line 12, column 7]\n " shape="box"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_5" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_6" ;
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_5" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_7" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_6" [label="6: Prune (true branch, if) \n PRUNE((n$3 == null), true); [line 12, column 7]\n EXIT_SCOPE(n$3); [line 12, column 7]\n " shape="invhouse"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_6" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_8" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_7" [label="7: Prune (false branch, if) \n PRUNE(!(n$3 == null), false); [line 12, column 7]\n EXIT_SCOPE(n$3); [line 12, column 7]\n APPLY_ABSTRACTION; [line 12, column 7]\n " shape="invhouse"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_7" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_4" ;
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_8" [label="8: ObjCCPPThrow \n n$5=_fun___infer_objc_cpp_throw(\"Null pointer!\":char const *) [line 13, column 5]\n EXIT_SCOPE(n$5); [line 13, column 5]\n APPLY_ABSTRACTION; [line 13, column 5]\n " shape="box"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_8" -> "deref#13506892413034678690.824465c4193ad2288eb512b1083edab3_4" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_1" [label="1: Start deref_null\nFormals: p:int*\nLocals: \n " color=yellow style=filled]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_1" -> "deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_3" ;
"deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_2" [label="2: Exit deref_null \n " color=yellow style=filled]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
9 years ago
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_3" [label="3: Return Stmt \n n$1=*&p:int* [line 20, column 13]\n n$2=*n$1:int [line 20, column 12]\n *&return:int=n$2 [line 20, column 5]\n NULLIFY(&p); [line 20, column 5]\n EXIT_SCOPE(n$1,n$2,p); [line 20, column 5]\n APPLY_ABSTRACTION; [line 20, column 5]\n " shape="box"]
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
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
"deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_3" -> "deref_null#11536394632240553702.ea4eed042da22ab7ceb619ec1b7f73bb_2" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"main.fad58de7366495db4650cfefac2fcd61_1" [label="1: Start main\nFormals: \nLocals: \n " color=yellow style=filled]
[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
"main.fad58de7366495db4650cfefac2fcd61_1" -> "main.fad58de7366495db4650cfefac2fcd61_3" ;
"main.fad58de7366495db4650cfefac2fcd61_2" [label="2: Exit main \n " color=yellow style=filled]
[preanalysis] do not delay killing variables taken by reference Summary: Before, the liveness pre-analysis would place extra instructions in the CFG for either: 1. marking an `Ident.t` as dead, or 2. marking a `Pvar.t` as `= 0` But we have no way of marking pvars dead without setting them to 0. This is bad because setting pvars to 0 is not possible everywhere they are dead. Indeed, we only do it when we haven't seen their address being taken anyway. This prevents the following situation, recorded in our tests: ``` int address_taken() { int** x; int* y; int i = 7; y = &i; x = &y; // if we don't reason about taken addresses while adding nullify instructions, // we'll add // `nullify(y)` here and report a false NPE on the next line return **x; } ``` So we want to mark pvars as dead without nullifying them. This diff extends the `Remove_temps` SIL instruction to accept pvars as well, and so renames it to `ExitScope`. Reviewed By: da319 Differential Revision: D13102953 fbshipit-source-id: aa7f03a52
6 years ago
"main.fad58de7366495db4650cfefac2fcd61_3" [label="3: Return Stmt \n n$1=_fun_deref(null:int*) [line 74, column 12]\n *&return:int=n$1 [line 74, column 5]\n EXIT_SCOPE(n$1); [line 74, column 5]\n APPLY_ABSTRACTION; [line 74, column 5]\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
"main.fad58de7366495db4650cfefac2fcd61_3" -> "main.fad58de7366495db4650cfefac2fcd61_2" ;
[cfg] print dotty *after* pre-analysis Summary: Useful to understand the changes in the pre-analysis, or to inspect the CFG that checkers actually get. This means that the pre-analysis always runs when we output the dotty, but I don't really see a reason why not. In fact, we could probably *always* store the CFGs as pre-analysed. Reviewed By: mbouaziz Differential Revision: D13102952 fbshipit-source-id: 89f3102ec
6 years ago
"main.fad58de7366495db4650cfefac2fcd61_4" [label="4: Return Stmt \n *&return:int=-1 [line 76, column 5]\n APPLY_ABSTRACTION; [line 76, column 5]\n " shape="box"]
[clang] basic support for exceptional control-flow Summary: This diff: - translates C++ `catch` blocks - adds an exceptional control-flow edge from the end of a `try` block to the beginning of a `catch` block This obviously doesn't reflect the way exceptions actually work, but I think it is better than what we have now. For one thing, we'll see/translate code inside `catch` blocks, which were opaque before. If Clang analyses don't want this behavior, they can simply use `ProcCfg.Normal` (which, up until this diff, behaved identically to `ProcCfg.Exceptional`. In the future, we can extend `trans_state` to track blocks that might throw an exception, and have each of these blocks transition to `catch` instead. Reviewed By: jvillard Differential Revision: D7814521 fbshipit-source-id: 67b86a6
7 years ago
"main.fad58de7366495db4650cfefac2fcd61_4" -> "main.fad58de7366495db4650cfefac2fcd61_2" ;
Translate C++ exceptions Reviewed By: akotulski Differential Revision: D3005619 fb-gh-sync-id: a64790b shipit-source-id: a64790b
9 years ago
}