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

457 lines
46 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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_1" [label="1: Start reference_field::ptr_F_div0\nFormals: \nLocals: r:reference_field::Ptr x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_1" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_2" [label="2: Exit reference_field::ptr_F_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_3" [label="3: Return Stmt \n n$0=*&r.x:reference_field::X* [line 84, column 14]\n n$1=*n$0.f:int [line 84, column 14]\n *&return:int=(1 / n$1) [line 84, column 3]\n _=*&x:reference_field::X [line 84, column 19]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 84, column 19]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_3" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_2" ;
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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 83, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_4" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ptr); [line 82, column 3]\n n$5=_fun_reference_field::Ptr::Ptr(&r:reference_field::Ptr*,&x:reference_field::X&) [line 82, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_5" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_4" ;
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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 81, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_6" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_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
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 80, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 80, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_7" -> "ptr_F_div0#reference_field#14005768761742554773.fa7bac24d70ab0b747e7fb5360157c5f_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_1" [label="1: Start reference_field::ptr_I_div0\nFormals: \nLocals: r:reference_field::Ptr x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_1" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_2" [label="2: Exit reference_field::ptr_I_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_3" [label="3: Return Stmt \n n$0=*&r.i:int* [line 92, column 15]\n n$1=*n$0:int [line 92, column 14]\n *&return:int=(1 / n$1) [line 92, column 3]\n _=*&x:reference_field::X [line 92, column 17]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 92, column 17]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_3" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_2" ;
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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 91, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_4" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ptr); [line 90, column 3]\n n$5=_fun_reference_field::Ptr::Ptr(&r:reference_field::Ptr*,&x:reference_field::X&) [line 90, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_5" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_4" ;
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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 89, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_6" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_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
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 88, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 88, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_7" -> "ptr_I_div0#reference_field#18255668366877010738.5b1f39b2d5e2810cbdbf96621d88c2d0_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_1" [label="1: Start reference_field::ptr_getF_div0\nFormals: \nLocals: r:reference_field::Ptr x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_1" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_2" [label="2: Exit reference_field::ptr_getF_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_3" [label="3: Return Stmt \n _=*&r:reference_field::Ptr [line 100, column 14]\n n$1=_fun_reference_field::Ptr::getF(&r:reference_field::Ptr&) [line 100, column 14]\n *&return:int=(1 / n$1) [line 100, column 3]\n _=*&x:reference_field::X [line 100, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 100, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_3" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_2" ;
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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 99, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_4" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ptr); [line 98, column 3]\n n$5=_fun_reference_field::Ptr::Ptr(&r:reference_field::Ptr*,&x:reference_field::X&) [line 98, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_5" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_4" ;
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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 97, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_6" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_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
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 96, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 96, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_7" -> "ptr_getF_div0#reference_field#3337646019334387234.41e241b3e1d6a6f7c629a1c6ca69cf07_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_1" [label="1: Start reference_field::ptr_getI_div0\nFormals: \nLocals: r:reference_field::Ptr x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_1" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_2" [label="2: Exit reference_field::ptr_getI_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_3" [label="3: Return Stmt \n _=*&r:reference_field::Ptr [line 108, column 14]\n n$1=_fun_reference_field::Ptr::getI(&r:reference_field::Ptr&) [line 108, column 14]\n *&return:int=(1 / n$1) [line 108, column 3]\n _=*&x:reference_field::X [line 108, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 108, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_3" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_2" ;
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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 107, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_4" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ptr); [line 106, column 3]\n n$5=_fun_reference_field::Ptr::Ptr(&r:reference_field::Ptr*,&x:reference_field::X&) [line 106, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_5" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_4" ;
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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 105, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_6" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_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
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 104, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 104, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_7" -> "ptr_getI_div0#reference_field#2818660867908728453.99667cea541002986498839338031f13_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_1" [label="1: Start reference_field::ref_F_div0\nFormals: \nLocals: r:reference_field::Ref x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_1" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_2" [label="2: Exit reference_field::ref_F_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_3" [label="3: Return Stmt \n n$0=*&r.x:reference_field::X& [line 51, column 14]\n n$1=*n$0.f:int [line 51, column 14]\n *&return:int=(1 / n$1) [line 51, column 3]\n _=*&x:reference_field::X [line 51, column 18]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 51, column 18]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_3" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_2" ;
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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 50, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_4" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ref); [line 49, column 3]\n n$5=_fun_reference_field::Ref::Ref(&r:reference_field::Ref*,&x:reference_field::X&) [line 49, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_5" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_4" ;
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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 48, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_6" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_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
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 47, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 47, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_7" -> "ref_F_div0#reference_field#11041134718140208132.6e58f8c7050613499e915a7d12b0f081_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_1" [label="1: Start reference_field::ref_I_div0\nFormals: \nLocals: r:reference_field::Ref x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_1" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_2" [label="2: Exit reference_field::ref_I_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_3" [label="3: Return Stmt \n n$0=*&r.i:int& [line 59, column 14]\n n$1=*n$0:int [line 59, column 14]\n *&return:int=(1 / n$1) [line 59, column 3]\n _=*&x:reference_field::X [line 59, column 16]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 59, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_3" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_2" ;
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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 58, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_4" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ref); [line 57, column 3]\n n$5=_fun_reference_field::Ref::Ref(&r:reference_field::Ref*,&x:reference_field::X&) [line 57, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_5" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_4" ;
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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 56, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_6" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_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
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 55, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 55, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_7" -> "ref_I_div0#reference_field#12578013844532400739.b911fdef1ca9c73b658bff3d5d964b9b_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_1" [label="1: Start reference_field::ref_getF_div0\nFormals: \nLocals: r:reference_field::Ref x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_1" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_2" [label="2: Exit reference_field::ref_getF_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_3" [label="3: Return Stmt \n _=*&r:reference_field::Ref [line 67, column 14]\n n$1=_fun_reference_field::Ref::getF(&r:reference_field::Ref&) [line 67, column 14]\n *&return:int=(1 / n$1) [line 67, column 3]\n _=*&x:reference_field::X [line 67, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 67, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_3" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_2" ;
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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 66, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_4" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ref); [line 65, column 3]\n n$5=_fun_reference_field::Ref::Ref(&r:reference_field::Ref*,&x:reference_field::X&) [line 65, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_5" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_4" ;
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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 64, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_6" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_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
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 63, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 63, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_7" -> "ref_getF_div0#reference_field#2481930918988851369.2dc7181f26bf9bad7c2f06846f4d7ec4_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_1" [label="1: Start reference_field::ref_getI_div0\nFormals: \nLocals: r:reference_field::Ref x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_1" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_2" [label="2: Exit reference_field::ref_getI_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_3" [label="3: Return Stmt \n _=*&r:reference_field::Ref [line 75, column 14]\n n$1=_fun_reference_field::Ref::getI(&r:reference_field::Ref&) [line 75, column 14]\n *&return:int=(1 / n$1) [line 75, column 3]\n _=*&x:reference_field::X [line 75, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 75, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_3" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_2" ;
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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 74, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_4" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Ref); [line 73, column 3]\n n$5=_fun_reference_field::Ref::Ref(&r:reference_field::Ref*,&x:reference_field::X&) [line 73, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_5" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_4" ;
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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 72, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_6" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_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
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 71, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 71, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_7" -> "ref_getI_div0#reference_field#17267881158640772750.8919328183561d84930ec2a40da70667_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_1" [label="1: Start reference_field::val_F_div0\nFormals: \nLocals: r:reference_field::Val x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_1" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_2" [label="2: Exit reference_field::val_F_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_3" [label="3: Return Stmt \n n$0=*&r.x.f:int [line 117, column 14]\n *&return:int=(1 / n$0) [line 117, column 3]\n _=*&x:reference_field::X [line 117, column 18]\n n$2=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 117, column 18]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_3" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_2" ;
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 116, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_4" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Val); [line 115, column 3]\n n$4=_fun_reference_field::Val::Val(&r:reference_field::Val*,&x:reference_field::X&) [line 115, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_5" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_4" ;
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 114, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_6" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 113, column 3]\n n$5=_fun_reference_field::X::X(&x:reference_field::X*) [line 113, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_7" -> "val_F_div0#reference_field#8428286850923379914.8fdee85eabf77b0016437fa0006d373c_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_1" [label="1: Start reference_field::val_I_div0\nFormals: \nLocals: r:reference_field::Val x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_1" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_2" [label="2: Exit reference_field::val_I_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_3" [label="3: Return Stmt \n n$0=*&r.i:int [line 125, column 14]\n *&return:int=(1 / n$0) [line 125, column 3]\n _=*&x:reference_field::X [line 125, column 16]\n n$2=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 125, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_3" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_2" ;
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 124, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_4" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Val); [line 123, column 3]\n n$4=_fun_reference_field::Val::Val(&r:reference_field::Val*,&x:reference_field::X&) [line 123, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_5" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_4" ;
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 122, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_6" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 121, column 3]\n n$5=_fun_reference_field::X::X(&x:reference_field::X*) [line 121, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_7" -> "val_I_div0#reference_field#17788064844610257149.11b45a3e82e229e7a7714480217c1af3_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_1" [label="1: Start reference_field::val_getF_div0\nFormals: \nLocals: r:reference_field::Val x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_1" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_2" [label="2: Exit reference_field::val_getF_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_3" [label="3: Return Stmt \n _=*&r:reference_field::Val [line 133, column 14]\n n$1=_fun_reference_field::Val::getF(&r:reference_field::Val&) [line 133, column 14]\n *&return:int=(1 / n$1) [line 133, column 3]\n _=*&x:reference_field::X [line 133, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 133, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_3" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_2" ;
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 132, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_4" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Val); [line 131, column 3]\n n$5=_fun_reference_field::Val::Val(&r:reference_field::Val*,&x:reference_field::X&) [line 131, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_5" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_4" ;
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 130, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_6" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 129, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 129, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_7" -> "val_getF_div0#reference_field#16910887455441500799.24fc3c9591435f1b92c06c5c7da4bd2e_6" ;
Get rid of Declare_locals Reviewed By: jeremydubreil Differential Revision: D9234331 fbshipit-source-id: 70443eabe
6 years ago
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_1" [label="1: Start reference_field::val_getI_div0\nFormals: \nLocals: r:reference_field::Val x:reference_field::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_1" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_2" [label="2: Exit reference_field::val_getI_div0 \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_3" [label="3: Return Stmt \n _=*&r:reference_field::Val [line 141, column 14]\n n$1=_fun_reference_field::Val::getI(&r:reference_field::Val&) [line 141, column 14]\n *&return:int=(1 / n$1) [line 141, column 3]\n _=*&x:reference_field::X [line 141, column 21]\n n$3=_fun_reference_field::X::~X(&x:reference_field::X*) injected [line 141, column 21]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_3" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_2" ;
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_4" [label="4: BinaryOperatorStmt: Assign \n *&x.f:int=1 [line 140, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_4" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_5" [label="5: DeclStmt \n VARIABLE_DECLARED(r:reference_field::Val); [line 139, column 3]\n n$5=_fun_reference_field::Val::Val(&r:reference_field::Val*,&x:reference_field::X&) [line 139, column 7]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_5" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_4" ;
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_6" [label="6: BinaryOperatorStmt: Assign \n *&x.f:int=0 [line 138, column 3]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_6" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_7" [label="7: DeclStmt \n VARIABLE_DECLARED(x:reference_field::X); [line 137, column 3]\n n$6=_fun_reference_field::X::X(&x:reference_field::X*) [line 137, column 5]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_7" -> "val_getI_div0#reference_field#1916539470996695608.683d462cf87abbc81874a14e4872564a_6" ;
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
"getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_1" [label="1: Start reference_field::Ptr::getF\nFormals: this:reference_field::Ptr*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_1" -> "getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_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
"getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_2" [label="2: Exit reference_field::Ptr::getF \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Ptr* [line 33, column 23]\n n$1=*n$0.x:reference_field::X* [line 33, column 23]\n n$2=*n$1.f:int [line 33, column 23]\n *&return:int=n$2 [line 33, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_3" -> "getF#Ptr#reference_field#(6867936719957773992).53c4cdb31ea7c9aac827b2830f575dd5_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
"getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_1" [label="1: Start reference_field::Ptr::getI\nFormals: this:reference_field::Ptr*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_1" -> "getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_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
"getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_2" [label="2: Exit reference_field::Ptr::getI \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Ptr* [line 34, column 24]\n n$1=*n$0.i:int* [line 34, column 24]\n n$2=*n$1:int [line 34, column 23]\n *&return:int=n$2 [line 34, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_3" -> "getI#Ptr#reference_field#(9990830118718700597).db587e508ad6680b9c85197fd72992d4_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
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_1" [label="1: Start reference_field::Ptr::Ptr\nFormals: this:reference_field::Ptr* r_:reference_field::X&\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_1" -> "Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_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
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_2" [label="2: Exit reference_field::Ptr::Ptr \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_3" [label="3: Constructor Init \n n$1=*&this:reference_field::Ptr* [line 32, column 24]\n n$2=*&this:reference_field::Ptr* [line 32, column 27]\n n$3=*n$2.x:reference_field::X* [line 32, column 27]\n *n$1.i:int*=n$3.f [line 32, column 24]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_3" -> "Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_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
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_4" [label="4: Constructor Init \n n$4=*&this:reference_field::Ptr* [line 32, column 16]\n n$5=*&r_:reference_field::X& [line 32, column 19]\n *n$4.x:reference_field::X*=n$5 [line 32, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_4" -> "Ptr#Ptr#reference_field#{6088279996118893652}.360bbf008525cb3c23d8ada20f2a72af_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
"getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_1" [label="1: Start reference_field::Ref::getI\nFormals: this:reference_field::Ref*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_1" -> "getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_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
"getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_2" [label="2: Exit reference_field::Ref::getI \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Ref* [line 26, column 23]\n n$1=*n$0.i:int& [line 26, column 23]\n n$2=*n$1:int [line 26, column 23]\n *&return:int=n$2 [line 26, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_3" -> "getI#Ref#reference_field#(11319674367674692208).ab98b8b3de535d47d4b70092fc16ce37_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
"getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_1" [label="1: Start reference_field::Ref::getF\nFormals: this:reference_field::Ref*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_1" -> "getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_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
"getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_2" [label="2: Exit reference_field::Ref::getF \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Ref* [line 25, column 23]\n n$1=*n$0.x:reference_field::X& [line 25, column 23]\n n$2=*n$1.f:int [line 25, column 23]\n *&return:int=n$2 [line 25, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_3" -> "getF#Ref#reference_field#(4333270831228787341).d47ae80c78316dac2e24a22fc076cf41_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
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_1" [label="1: Start reference_field::Ref::Ref\nFormals: this:reference_field::Ref* r_:reference_field::X&\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_1" -> "Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_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
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_2" [label="2: Exit reference_field::Ref::Ref \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_3" [label="3: Constructor Init \n n$1=*&this:reference_field::Ref* [line 24, column 23]\n n$2=*&this:reference_field::Ref* [line 24, column 25]\n n$3=*n$2.x:reference_field::X& [line 24, column 25]\n *n$1.i:int&=n$3.f [line 24, column 23]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_3" -> "Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_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
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_4" [label="4: Constructor Init \n n$4=*&this:reference_field::Ref* [line 24, column 16]\n n$5=*&r_:reference_field::X& [line 24, column 18]\n *n$4.x:reference_field::X&=n$5 [line 24, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_4" -> "Ref#Ref#reference_field#{1778104277749367423}.02a281ecc4e6bde89182d1ef952810a2_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
"getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_1" [label="1: Start reference_field::Val::getI\nFormals: this:reference_field::Val*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_1" -> "getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_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
"getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_2" [label="2: Exit reference_field::Val::getI \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Val* [line 42, column 23]\n n$1=*n$0.i:int [line 42, column 23]\n *&return:int=n$1 [line 42, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_3" -> "getI#Val#reference_field#(5092177944978041506).c3db07b6697824cd689cc81f71b31e2a_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
"getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_1" [label="1: Start reference_field::Val::getF\nFormals: this:reference_field::Val*\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_1" -> "getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_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
"getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_2" [label="2: Exit reference_field::Val::getF \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_3" [label="3: Return Stmt \n n$0=*&this:reference_field::Val* [line 41, column 23]\n n$1=*n$0.x.f:int [line 41, column 23]\n *&return:int=n$1 [line 41, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_3" -> "getF#Val#reference_field#(5603383781744538435).f0720826d9b8abc0c6259038f1412318_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
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_1" [label="1: Start reference_field::Val::Val\nFormals: this:reference_field::Val* r_:reference_field::X&\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_1" -> "Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_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
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_2" [label="2: Exit reference_field::Val::Val \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_3" [label="3: Constructor Init \n n$1=*&this:reference_field::Val* [line 40, column 23]\n n$2=*&this:reference_field::Val* [line 40, column 25]\n n$3=*n$2.x.f:int [line 40, column 25]\n *n$1.i:int=n$3 [line 40, column 23]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_3" -> "Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_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
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_4" [label="4: Constructor Init \n n$4=*&this:reference_field::Val* [line 40, column 16]\n n$5=*&r_:reference_field::X& [line 40, column 18]\n n$6=_fun_reference_field::X::X(n$4.x:reference_field::X*,n$5:reference_field::X&) [line 40, column 16]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_4" -> "Val#Val#reference_field#{10086609758499948489}.3f0d77ba0039a38103c912b5065ccdaa_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
"X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_1" [label="1: Start reference_field::X::X\nFormals: this:reference_field::X* __param_0:reference_field::X const &\nLocals: \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_1" -> "X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_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
"X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_2" [label="2: Exit reference_field::X::X \n " color=yellow style=filled]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
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
"X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_3" [label="3: Constructor Init \n n$1=*&this:reference_field::X* [line 10, column 8]\n n$2=*&__param_0:reference_field::X const & [line 10, column 8]\n n$3=*n$2.f:int [line 10, column 8]\n *n$1.f:int=n$3 [line 10, column 8]\n " shape="box"]
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_3" -> "X#X#reference_field#{16892162000533972663|constexpr}.d3ad2332bde2031935fecc6685296b44_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
"X#X#reference_field#{2751762285772383996}.b7c8700d1b15a5db2c677bfc2eb37a5f_1" [label="1: Start reference_field::X::X\nFormals: this:reference_field::X*\nLocals: \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
[clang] Adding parameters as part of the procname for C++/ObjC methods and ObjC blocks Reviewed By: mbouaziz Differential Revision: D8237112 fbshipit-source-id: c0ec4b4
7 years ago
"X#X#reference_field#{2751762285772383996}.b7c8700d1b15a5db2c677bfc2eb37a5f_1" -> "X#X#reference_field#{2751762285772383996}.b7c8700d1b15a5db2c677bfc2eb37a5f_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
"X#X#reference_field#{2751762285772383996}.b7c8700d1b15a5db2c677bfc2eb37a5f_2" [label="2: Exit reference_field::X::X \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
Fix translation when accessing reference type fields Summary:public Add extra dereference when accessing fields that have T& type. It is similar to what is done when accessing variables of T& type. The only difference is that we need to handle constructor initializer list separately (this is the only place where the field can be initialized) Reviewed By: ddino Differential Revision: D2965887 fb-gh-sync-id: 1b8708b shipit-source-id: 1b8708b
9 years ago
}