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 'fbe1c92c17'
${ noResults }
infer_clone/infer/tests/codetoanalyze/objc/shared/block/block-it.m.dot

156 lines
14 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 {
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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_1" [label="1: Start objc_blockMyBlock::array_1\nFormals: object:objc_object* idx:unsigned long stop:_Bool*\nLocals: ShouldStop:int \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_1" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_5" ;
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_1" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_6" ;
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_2" [label="2: Exit objc_blockMyBlock::array_1 \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_3" [label="3: + \n " ]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_3" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_4" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_4" [label="4: between_join_and_exit \n " shape="box"]
Fix control-flow graph shape when conditional is last instruction. Summary:public When a conditional is the last instruction, there will be a join node leading directly to the exit node. Some instructions, such as nullification of dead variables, and abstraction, are added to the control flow graph automatically. But, join nodes cannot contain instructions. So when a procedure ends with a conditional, there might be no place to store these instructions. This diff adds one extra node between the join and the exit node in that situation. Reviewed By: jvillard Differential Revision: D3179056 fb-gh-sync-id: 2b9cd7e fbshipit-source-id: 2b9cd7e
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_4" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_2" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_5" [label="5: Prune (true branch, if) \n n$1=*&ShouldStop:int [line 24, column 9]\n PRUNE(n$1, true); [line 24, column 9]\n " shape="invhouse"]
Fix control-flow graph shape when conditional is last instruction. Summary:public When a conditional is the last instruction, there will be a join node leading directly to the exit node. Some instructions, such as nullification of dead variables, and abstraction, are added to the control flow graph automatically. But, join nodes cannot contain instructions. So when a procedure ends with a conditional, there might be no place to store these instructions. This diff adds one extra node between the join and the exit node in that situation. Reviewed By: jvillard Differential Revision: D3179056 fb-gh-sync-id: 2b9cd7e fbshipit-source-id: 2b9cd7e
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_5" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_7" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_6" [label="6: Prune (false branch, if) \n n$1=*&ShouldStop:int [line 24, column 9]\n PRUNE(!n$1, false); [line 24, column 9]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_6" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_3" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_7" [label="7: BinaryOperatorStmt: Assign \n n$2=*&stop:_Bool* [line 25, column 8]\n *n$2:_Bool=1 [line 25, column 7]\n " shape="box"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_7" -> "objc_blockMyBlock::array_1(struct objc_object).df8ecbd6344ac89a5113acabcc96a39a_3" ;
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_1" [label="1: Start objc_blockMyBlock::array_trans_2\nFormals: object:objc_object* idx:unsigned long stop:_Bool*\nLocals: ShouldStop:int \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_1" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_5" ;
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_1" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_6" ;
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_2" [label="2: Exit objc_blockMyBlock::array_trans_2 \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_3" [label="3: + \n " ]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_3" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_4" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_4" [label="4: between_join_and_exit \n " shape="box"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_4" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_2" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_5" [label="5: Prune (true branch, if) \n n$32=*&ShouldStop:int [line 41, column 13]\n PRUNE(n$32, true); [line 41, column 13]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_5" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_7" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_6" [label="6: Prune (false branch, if) \n n$32=*&ShouldStop:int [line 41, column 13]\n PRUNE(!n$32, false); [line 41, column 13]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_6" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_3" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_7" [label="7: BinaryOperatorStmt: Assign \n n$33=*&stop:_Bool* [line 42, column 12]\n *n$33:_Bool=1 [line 42, column 11]\n " shape="box"]
Treating blocks iterators for NSArray
9 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
"objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_7" -> "objc_blockMyBlock::array_trans_2(struct objc_object).682ea63855d347615885efa9ad25d5ed_3" ;
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_1" [label="1: Start MyBlock::array\nFormals: self:MyBlock*\nLocals: a:NSArray* \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 years ago
[clang] Remove the translation of enumerateWithBlocks that causes FPs dead store. Reviewed By: ddino Differential Revision: D6135127 fbshipit-source-id: 0ae52e2
7 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_1" -> "array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_4" ;
[SIL] change `variable_initialization()` builtin to a new auxiliary instruction Summary: Instead of emitting an ad-hoc builtin on variable declaration emit a new metadata instruction. This allows us to remove the code matching on that ad-hoc builtin that had to be inserted in several checkers. Inferbo & pulse used that information meaningfully and had to undergo some minor changes to cope with the new metada instruction. Reviewed By: ezgicicek Differential Revision: D14833100 fbshipit-source-id: 9b3009d22
6 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_2" [label="2: Exit MyBlock::array \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 years ago
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_3" [label="3: Message Call: enumerateObjectsUsingBlock: \n n$5=*&a:NSArray* [line 19, column 4]\n n$6=_fun_NSArray::enumerateObjectsUsingBlock:(n$5:NSArray*,(_fun_objc_blockMyBlock::array_1):_fn_(*)) block_params virtual [line 19, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_3" -> "array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_2" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_4" [label="4: DeclStmt \n VARIABLE_DECLARED(a:NSArray*); [line 18, column 3]\n n$7=_fun___objc_alloc_no_fail(sizeof(t=NSArray):unsigned long) [line 18, column 17]\n n$8=_fun_NSArray::init(n$7:NSArray*) virtual [line 18, column 16]\n *&a:NSArray*=n$8 [line 18, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Remove the translation of enumerateWithBlocks that causes FPs dead store. Reviewed By: ddino Differential Revision: D6135127 fbshipit-source-id: 0ae52e2
7 years ago
"array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_4" -> "array#MyBlock#instance.8be6e5b5e968d186440e1931c9eb40de_3" ;
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
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_1" [label="1: Start MyBlock::array_trans\nFormals: self:MyBlock*\nLocals: idx:unsigned long object:objc_object* stop:_Bool* enumerateObjectsUsingBlock:_fn_(*) objects:NSArray* a:NSArray* \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_1" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_20" ;
[SIL] change `variable_initialization()` builtin to a new auxiliary instruction Summary: Instead of emitting an ad-hoc builtin on variable declaration emit a new metadata instruction. This allows us to remove the code matching on that ad-hoc builtin that had to be inserted in several checkers. Inferbo & pulse used that information meaningfully and had to undergo some minor changes to cope with the new metada instruction. Reviewed By: ezgicicek Differential Revision: D14833100 fbshipit-source-id: 9b3009d22
6 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_2" [label="2: Exit MyBlock::array_trans \n " color=yellow style=filled]
Treating blocks iterators for NSArray
9 years ago
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_3" [label="3: Call _fun_free \n n$9=*&stop:_Bool* [line 55, column 8]\n n$10=_fun_free(n$9:void*) [line 55, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_3" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_2" ;
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_4" [label="4: + \n " ]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_4" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_7" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_5" [label="5: DeclStmt \n VARIABLE_DECLARED(idx:unsigned long); [line 48, column 8]\n *&idx:unsigned long=(unsigned long)0 [line 48, column 8]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_5" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_4" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_6" [label="6: UnaryOperator \n n$11=*&idx:unsigned long [line 48, column 49]\n *&idx:unsigned long=(n$11 + 1) [line 48, column 49]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_6" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_4" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_7" [label="7: BinaryOperatorStmt: LT \n n$12=*&idx:unsigned long [line 48, column 28]\n n$13=*&objects:NSArray* [line 48, column 34]\n n$14=_fun_NSArray::count(n$13:NSArray*) [line 48, column 42]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_7" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_8" ;
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_7" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_9" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_8" [label="8: Prune (true branch, for loop) \n PRUNE((n$12 < n$14), true); [line 48, column 28]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_8" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_15" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_9" [label="9: Prune (false branch, for loop) \n PRUNE(!(n$12 < n$14), false); [line 48, column 28]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_9" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_3" ;
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_10" [label="10: + \n " ]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_10" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_6" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_11" [label="11: BinaryOperatorStmt: EQ \n n$15=*&stop:_Bool* [line 52, column 10]\n n$16=*n$15:_Bool [line 52, column 9]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_11" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_12" ;
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_11" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_13" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_12" [label="12: Prune (true branch, if) \n PRUNE((n$16 == 1), true); [line 52, column 9]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_12" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_3" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_13" [label="13: Prune (false branch, if) \n PRUNE(!(n$16 == 1), false); [line 52, column 9]\n " shape="invhouse"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_13" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_10" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_14" [label="14: Call n$20 \n n$20=*&enumerateObjectsUsingBlock:_fn_(*) [line 51, column 5]\n n$21=*&object:objc_object* [line 51, column 32]\n n$22=*&idx:unsigned long [line 51, column 40]\n n$23=*&stop:_Bool* [line 51, column 45]\n n$24=n$20(n$21:objc_object*,n$22:unsigned long,n$23:_Bool*) objc_block [line 51, column 5]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_14" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_11" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_15" [label="15: DeclStmt \n VARIABLE_DECLARED(object:objc_object*); [line 50, column 5]\n n$26=*&objects:NSArray* [line 50, column 17]\n n$25=*&idx:unsigned long [line 50, column 25]\n n$27=_fun_NSArray::objectAtIndexedSubscript:(n$26:NSArray*,n$25:unsigned long) virtual [line 50, column 17]\n *&object:objc_object*=n$27 [line 50, column 5]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_15" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_14" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_16" [label="16: BinaryOperatorStmt: Assign \n n$29=*&stop:_Bool* [line 46, column 4]\n *n$29:_Bool=0 [line 46, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_16" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_5" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_17" [label="17: DeclStmt \n VARIABLE_DECLARED(stop:_Bool*); [line 45, column 3]\n n$30=_fun_malloc_no_fail(sizeof(t=_Bool;nbytes=1):_Bool) [line 45, column 16]\n *&stop:_Bool*=(_Bool*)n$30 [line 45, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_17" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_16" ;
[SIL] change `variable_initialization()` builtin to a new auxiliary instruction Summary: Instead of emitting an ad-hoc builtin on variable declaration emit a new metadata instruction. This allows us to remove the code matching on that ad-hoc builtin that had to be inserted in several checkers. Inferbo & pulse used that information meaningfully and had to undergo some minor changes to cope with the new metada instruction. Reviewed By: ezgicicek Differential Revision: D14833100 fbshipit-source-id: 9b3009d22
6 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_18" [label="18: DeclStmt \n VARIABLE_DECLARED(enumerateObjectsUsingBlock:_fn_(*)); [line 37, column 3]\n *&enumerateObjectsUsingBlock:_fn_(*)=(_fun_objc_blockMyBlock::array_trans_2) [line 37, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_18" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_17" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_19" [label="19: DeclStmt \n VARIABLE_DECLARED(objects:NSArray*); [line 34, column 3]\n n$36=*&a:NSArray* [line 34, column 22]\n *&objects:NSArray*=n$36 [line 34, column 3]\n " shape="box"]
Treating blocks iterators for NSArray
9 years ago
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_19" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_18" ;
[cfg] run pre-analysis lazily in ondemand Summary: This also prints the CFGs *after* pre-analysis for individual procedures in infer-out/captured/<filename>/<proc>.dot. One can also look up the CFGs before pre-analysis in infer-out/captured/proc_cfgs_frontend.dot. Context: I want to add a pre-analysis that needs to look at proc attributes inter-procedurally. For this to make sense it has to happen *after* all of capture, and before analysis. Thus, this diff brings back the lazy running of the pre-analysis like in D15803492, except that we still make sure to run the pre-analyses systematically regardless of the checkers being run by running the pre-analysis from ondemand.ml. Also we don't need to re-introduce the "did_preanalysis" proc attribute for the same reason that the pre-analysis is now run once and for all by ondemand.ml (instead of each individual checker back in the days). This has the benefit of running the pre-analysis only when needed, and the drawback that several concurrent processes analysing the same proc descs will duplicate work. Since pre-analyses are supposed to be very fast I assume that neither is a big deal. If they become more expensive then the benefit gets bigger and the drawback is just the same as with regular analyses. Reviewed By: skcho Differential Revision: D18573920 fbshipit-source-id: de350eaef
5 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_20" [label="20: DeclStmt \n VARIABLE_DECLARED(a:NSArray*); [line 32, column 3]\n n$37=_fun___objc_alloc_no_fail(sizeof(t=NSArray):unsigned long) [line 32, column 17]\n n$38=_fun_NSArray::init(n$37:NSArray*) virtual [line 32, column 16]\n *&a:NSArray*=n$38 [line 32, 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
[clang] Change procname file naming scheme Summary: Procnames files are now reversed qualifier lists with `#` as separator (instead of `::` which needs to be escaped in bash). Because of the mechanism that is used to obtain qualifiers, it also affects naming for ObjC classes. Examples: ``` std::unique_ptr<int>::get -> get#unique_ptr<int>#std#__MANGLED,...__ // C++ method folly::split -> split#folly#__MANGLED,..._ // function within namespace NSNumber numberWithBool: -> numberWithBool:#NSNumber#class // ObjC method ``` Reviewed By: jvillard Differential Revision: D4689701 fbshipit-source-id: c3acfc6
8 years ago
"array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_20" -> "array_trans#MyBlock#instance.13289a590560d0628a3ae5174e716a32_19" ;
Treating blocks iterators for NSArray
9 years ago
}