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 '057efb2893'
${ noResults }
infer_clone/infer/tests/codetoanalyze/c/frontend/switchstmt/switch.c.dot

765 lines
51 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 {
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"getValue.faa0c7b1433b0c97fcdc15fa47c8180f_1" [label="1: Start getValue\nFormals: \nLocals: \n DECLARE_LOCALS(&return); [line 136, column 1]\n " color=yellow style=filled]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"getValue.faa0c7b1433b0c97fcdc15fa47c8180f_1" -> "getValue.faa0c7b1433b0c97fcdc15fa47c8180f_3" ;
"getValue.faa0c7b1433b0c97fcdc15fa47c8180f_2" [label="2: Exit getValue \n " color=yellow style=filled]
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"getValue.faa0c7b1433b0c97fcdc15fa47c8180f_3" [label="3: Return Stmt \n *&return:int=1 [line 136, column 18]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
"getValue.faa0c7b1433b0c97fcdc15fa47c8180f_3" -> "getValue.faa0c7b1433b0c97fcdc15fa47c8180f_2" ;
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_1" [label="1: Start test_switch1\nFormals: \nLocals: x:int value:int \n DECLARE_LOCALS(&return,&x,&value); [line 12, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_1" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_22" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_2" [label="2: Exit test_switch1 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_3" [label="3: Return Stmt \n *&return:int=0 [line 35, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_3" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_2" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" [label="4: + \n " ]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_5" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_5" [label="5: BinaryOperatorStmt: LT \n n$0=*&value:int [line 15, column 10]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_5" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_6" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_5" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_7" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_6" [label="6: Prune (true branch, while) \n PRUNE((n$0 < 10), true); [line 15, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_6" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_9" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_7" [label="7: Prune (false branch, while) \n PRUNE(!(n$0 < 10), false); [line 15, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_7" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_3" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_8" [label="8: Call _fun_printf \n n$1=_fun_printf(\"(after_switch)HELLO WORLD!\":char const *) [line 33, column 5]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_8" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_9" [label="9: SwitchStmt \n n$2=*&value:int [line 16, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_9" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_20" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_9" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_21" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_10" [label="10: Call _fun_printf \n n$4=_fun_printf(\"(2/def)HELLO WORLD!\":char const *) [line 30, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_10" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_11" [label="11: Call _fun_printf \n n$6=_fun_printf(\"(1)HELLO WORLD!\":char const *) [line 26, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_11" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_12" [label="12: Call _fun_printf \n n$8=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 23, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_12" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_8" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_13" [label="13: BinaryOperatorStmt: Assign \n n$9=*&value:int [line 21, column 11]\n *&x:int=(n$9 + 1) [line 21, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_13" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_12" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_14" [label="14: Call _fun_printf \n n$10=_fun_printf(\"(out)HELLO WORLD!\":char const *) [line 20, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_14" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_13" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_15" [label="15: DeclStmt \n *&x:int=1 [line 19, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_15" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_14" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_16" [label="16: Prune (true branch, switch) \n PRUNE((n$2 == 2), true); [line 28, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_16" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_10" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_17" [label="17: Prune (false branch, switch) \n PRUNE(!(n$2 == 2), false); [line 28, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_17" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_10" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_18" [label="18: Prune (true branch, switch) \n PRUNE((n$2 == 1), true); [line 25, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_18" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_11" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_19" [label="19: Prune (false branch, switch) \n PRUNE(!(n$2 == 1), false); [line 25, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_19" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_16" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_19" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_17" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_20" [label="20: Prune (true branch, switch) \n PRUNE((n$2 == 0), true); [line 22, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_20" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_12" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_21" [label="21: Prune (false branch, switch) \n PRUNE(!(n$2 == 0), false); [line 22, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_21" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_18" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_21" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_19" ;
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_22" [label="22: DeclStmt \n *&value:int=0 [line 13, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_22" -> "test_switch1.7c92c7e14d1a0ee28a9ab29b22df5d3f_4" ;
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_1" [label="1: Start test_switch10\nFormals: \nLocals: value:int \n DECLARE_LOCALS(&return,&value); [line 184, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_1" -> "test_switch10.8a4170d3888102a2491712a5ad55ad8d_5" ;
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_2" [label="2: Exit test_switch10 \n " color=yellow style=filled]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_3" [label="3: Return Stmt \n *&return:int=0 [line 187, column 3]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_3" -> "test_switch10.8a4170d3888102a2491712a5ad55ad8d_2" ;
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_4" [label="4: SwitchStmt \n *&value:int=7 [line 186, column 11]\n n$0=*&value:int [line 186, column 11]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_4" -> "test_switch10.8a4170d3888102a2491712a5ad55ad8d_3" ;
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_5" [label="5: DeclStmt \n *&value:int=0 [line 185, column 3]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch10.8a4170d3888102a2491712a5ad55ad8d_5" -> "test_switch10.8a4170d3888102a2491712a5ad55ad8d_4" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_1" [label="1: Start test_switch11\nFormals: \nLocals: 0$?%__sil_tmpSIL_temp_conditional___n$0:int value:int \n DECLARE_LOCALS(&return,&0$?%__sil_tmpSIL_temp_conditional___n$0,&value); [line 190, column 1]\n " color=yellow style=filled]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_1" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_14" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_2" [label="2: Exit test_switch11 \n " color=yellow style=filled]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_3" [label="3: Return Stmt \n *&return:int=0 [line 196, column 3]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_3" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_2" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_4" [label="4: + \n " ]
[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
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_4" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_10" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_5" [label="5: BinaryOperatorStmt: EQ \n n$1=*&value:int [line 192, column 20]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_5" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_6" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_5" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_7" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_6" [label="6: Prune (true branch, boolean exp) \n PRUNE((n$1 == 0), true); [line 192, column 20]\n " shape="invhouse"]
[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
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_6" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_8" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_7" [label="7: Prune (false branch, boolean exp) \n PRUNE(!(n$1 == 0), false); [line 192, column 20]\n " shape="invhouse"]
[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
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_7" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_9" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_8" [label="8: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$0:int=7 [line 192, column 20]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_8" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_4" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_9" [label="9: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$0:int=9 [line 192, column 20]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_9" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_4" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_10" [label="10: SwitchStmt \n n$2=*&0$?%__sil_tmpSIL_temp_conditional___n$0:int [line 192, column 20]\n *&value:int=n$2 [line 192, column 11]\n n$3=*&value:int [line 192, column 11]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_10" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_12" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_10" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_13" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_11" [label="11: Call _fun_printf \n n$4=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 194, column 7]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_11" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_3" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_12" [label="12: Prune (true branch, switch) \n PRUNE((n$3 == 0), true); [line 193, column 5]\n " shape="invhouse"]
[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
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_12" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_11" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_13" [label="13: Prune (false branch, switch) \n PRUNE(!(n$3 == 0), false); [line 193, column 5]\n " shape="invhouse"]
[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
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_13" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_3" ;
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_14" [label="14: DeclStmt \n *&value:int=0 [line 191, column 3]\n " shape="box"]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_14" -> "test_switch11.a1a6d859e414d268a57ed2a2bb6f8a8e_5" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_1" [label="1: Start test_switch2\nFormals: \nLocals: something:int z:int x:int value:int \n DECLARE_LOCALS(&return,&something,&z,&x,&value); [line 38, column 1]\n " color=yellow style=filled]
[debug] print procedures in alphabetical order in cfgs Summary: When looking at large CFGs, at least in `xdot`, it's often difficult to find the procedure you're looking for. Sorting the proc names puts them in alphabetical order, which makes searching one procedure easier. Reviewed By: mbouaziz Differential Revision: D7758521 fbshipit-source-id: 8e9997f
7 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_1" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_18" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_2" [label="2: Exit test_switch2 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_3" [label="3: Return Stmt \n *&return:int=0 [line 58, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_3" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_2" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_4" [label="4: SwitchStmt \n n$0=*&value:int [line 40, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_4" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_16" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_4" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_17" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_5" [label="5: BinaryOperatorStmt: Assign \n *&z:int=42 [line 52, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_5" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_3" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_6" [label="6: UnaryOperator \n n$3=*&something:int [line 50, column 7]\n *&something:int=(n$3 + 1) [line 50, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_6" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_5" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_7" [label="7: DeclStmt \n *&something:int=1 [line 49, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_7" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_6" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_8" [label="8: DeclStmt \n *&z:int=9 [line 45, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_8" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_7" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_9" [label="9: Call _fun_printf \n n$5=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 43, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_9" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_3" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_10" [label="10: Prune (true branch, switch) \n PRUNE((n$0 == 3), true); [line 55, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_10" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_3" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_11" [label="11: Prune (false branch, switch) \n PRUNE(!(n$0 == 3), false); [line 55, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_11" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_3" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_12" [label="12: Prune (true branch, switch) \n PRUNE((n$0 == 2), true); [line 54, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_12" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_3" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_13" [label="13: Prune (false branch, switch) \n PRUNE(!(n$0 == 2), false); [line 54, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_13" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_10" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_13" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_11" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_14" [label="14: Prune (true branch, switch) \n PRUNE((n$0 == 1), true); [line 48, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_14" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_7" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_15" [label="15: Prune (false branch, switch) \n PRUNE(!(n$0 == 1), false); [line 48, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_15" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_12" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_15" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_13" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_16" [label="16: Prune (true branch, switch) \n PRUNE((n$0 == 0), true); [line 42, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_16" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_9" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_17" [label="17: Prune (false branch, switch) \n PRUNE(!(n$0 == 0), false); [line 42, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_17" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_7" ;
"test_switch2.0717c55583f10f472ddb2d73d867e556_18" [label="18: DeclStmt \n *&value:int=0 [line 39, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch2.0717c55583f10f472ddb2d73d867e556_18" -> "test_switch2.0717c55583f10f472ddb2d73d867e556_4" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_1" [label="1: Start test_switch3\nFormals: \nLocals: z:int something:int value:int \n DECLARE_LOCALS(&return,&z,&something,&value); [line 61, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_1" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_17" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_2" [label="2: Exit test_switch3 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" [label="3: Return Stmt \n *&return:int=0 [line 76, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_2" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_4" [label="4: SwitchStmt \n n$0=*&value:int [line 63, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_4" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_15" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_4" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_16" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_5" [label="5: DeclStmt \n *&z:int=9 [line 71, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_5" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_6" [label="6: UnaryOperator \n n$3=*&something:int [line 69, column 7]\n *&something:int=(n$3 + 1) [line 69, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_6" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_7" [label="7: DeclStmt \n *&something:int=1 [line 68, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_7" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_6" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_8" [label="8: Call _fun_printf \n n$5=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 65, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_8" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_9" [label="9: Prune (true branch, switch) \n PRUNE((n$0 == 3), true); [line 73, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_9" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_10" [label="10: Prune (false branch, switch) \n PRUNE(!(n$0 == 3), false); [line 73, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_10" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_11" [label="11: Prune (true branch, switch) \n PRUNE((n$0 == 2), true); [line 72, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_11" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_3" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_12" [label="12: Prune (false branch, switch) \n PRUNE(!(n$0 == 2), false); [line 72, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_12" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_9" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_12" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_10" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_13" [label="13: Prune (true branch, switch) \n PRUNE((n$0 == 1), true); [line 67, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_13" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_7" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_14" [label="14: Prune (false branch, switch) \n PRUNE(!(n$0 == 1), false); [line 67, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_14" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_11" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_14" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_12" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_15" [label="15: Prune (true branch, switch) \n PRUNE((n$0 == 0), true); [line 64, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_15" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_8" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_16" [label="16: Prune (false branch, switch) \n PRUNE(!(n$0 == 0), false); [line 64, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_16" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_13" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_16" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_14" ;
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_17" [label="17: DeclStmt \n *&value:int=0 [line 62, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch3.d602e3f7cc0068667fd33a3e54ff193c_17" -> "test_switch3.d602e3f7cc0068667fd33a3e54ff193c_4" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_1" [label="1: Start test_switch4\nFormals: \nLocals: something:int z:int x:int value:int \n DECLARE_LOCALS(&return,&something,&z,&x,&value); [line 79, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_1" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_18" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_2" [label="2: Exit test_switch4 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" [label="3: Return Stmt \n *&return:int=0 [line 99, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_2" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_4" [label="4: SwitchStmt \n n$0=*&value:int [line 81, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_4" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_16" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_4" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_17" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_5" [label="5: BinaryOperatorStmt: Assign \n *&z:int=42 [line 93, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_5" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_6" [label="6: UnaryOperator \n n$3=*&something:int [line 91, column 7]\n *&something:int=(n$3 + 1) [line 91, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_6" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_5" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_7" [label="7: DeclStmt \n *&something:int=1 [line 90, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_7" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_6" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_8" [label="8: DeclStmt \n *&z:int=9 [line 86, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_8" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_7" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_9" [label="9: Call _fun_printf \n n$5=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 84, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_9" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_10" [label="10: Prune (true branch, switch) \n PRUNE((n$0 == 3), true); [line 96, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_10" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_11" [label="11: Prune (false branch, switch) \n PRUNE(!(n$0 == 3), false); [line 96, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_11" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_12" [label="12: Prune (true branch, switch) \n PRUNE((n$0 == 2), true); [line 95, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_12" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_3" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_13" [label="13: Prune (false branch, switch) \n PRUNE(!(n$0 == 2), false); [line 95, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_13" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_10" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_13" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_11" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_14" [label="14: Prune (true branch, switch) \n PRUNE((n$0 == 1), true); [line 89, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_14" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_7" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_15" [label="15: Prune (false branch, switch) \n PRUNE(!(n$0 == 1), false); [line 89, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_15" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_12" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_15" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_13" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_16" [label="16: Prune (true branch, switch) \n PRUNE((n$0 == 0), true); [line 83, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_16" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_9" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_17" [label="17: Prune (false branch, switch) \n PRUNE(!(n$0 == 0), false); [line 83, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_17" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_7" ;
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_18" [label="18: DeclStmt \n *&value:int=0 [line 80, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_18" -> "test_switch4.70d4e6e8539e8d1ee3505d4562bc236d_4" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_1" [label="1: Start test_switch5\nFormals: \nLocals: x:int value:int \n DECLARE_LOCALS(&return,&x,&value); [line 102, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_1" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_14" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_2" [label="2: Exit test_switch5 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_3" [label="3: Return Stmt \n *&return:int=0 [line 115, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_3" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_2" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" [label="4: + \n " ]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_5" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_5" [label="5: BinaryOperatorStmt: LT \n n$0=*&value:int [line 104, column 10]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_5" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_6" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_5" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_7" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_6" [label="6: Prune (true branch, while) \n PRUNE((n$0 < 10), true); [line 104, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_6" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_8" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_7" [label="7: Prune (false branch, while) \n PRUNE(!(n$0 < 10), false); [line 104, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_7" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_3" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_8" [label="8: SwitchStmt \n n$1=*&value:int [line 105, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_8" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_12" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_8" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_13" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_9" [label="9: Call _fun_printf \n n$3=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 111, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_9" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_10" [label="10: BinaryOperatorStmt: Assign \n n$5=*&value:int [line 108, column 11]\n *&x:int=(n$5 + 1) [line 108, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_10" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_11" [label="11: Call _fun_printf \n n$6=_fun_printf(\"(out)HELLO WORLD!\":char const *) [line 107, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_11" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_10" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_12" [label="12: Prune (true branch, switch) \n PRUNE((n$1 == 0), true); [line 110, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_12" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_9" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_13" [label="13: Prune (false branch, switch) \n PRUNE(!(n$1 == 0), false); [line 110, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_13" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" ;
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_14" [label="14: DeclStmt \n *&value:int=0 [line 103, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch5.1d93fcc376cd01517eabe22cb325bcfd_14" -> "test_switch5.1d93fcc376cd01517eabe22cb325bcfd_4" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_1" [label="1: Start test_switch6\nFormals: \nLocals: 0$?%__sil_tmpSIL_temp_conditional___n$0:int z:int something:int value:int \n DECLARE_LOCALS(&return,&0$?%__sil_tmpSIL_temp_conditional___n$0,&z,&something,&value); [line 118, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_1" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_23" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_2" [label="2: Exit test_switch6 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_3" [label="3: Return Stmt \n *&return:int=0 [line 133, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_3" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_2" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_4" [label="4: + \n " ]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_4" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_10" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_5" [label="5: BinaryOperatorStmt: GT \n n$1=*&value:int [line 120, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_5" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_6" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_5" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_7" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_6" [label="6: Prune (true branch, boolean exp) \n PRUNE((n$1 > 0), true); [line 120, column 11]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_6" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_8" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_7" [label="7: Prune (false branch, boolean exp) \n PRUNE(!(n$1 > 0), false); [line 120, column 11]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_7" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_9" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_8" [label="8: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$0:int=1 [line 120, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_8" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_4" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_9" [label="9: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$0:int=0 [line 120, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_9" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_4" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_10" [label="10: SwitchStmt \n n$2=*&0$?%__sil_tmpSIL_temp_conditional___n$0:int [line 120, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_10" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_21" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_10" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_22" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_11" [label="11: DeclStmt \n *&z:int=9 [line 128, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_11" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_12" [label="12: UnaryOperator \n n$5=*&something:int [line 126, column 7]\n *&something:int=(n$5 + 1) [line 126, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_12" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_13" [label="13: DeclStmt \n *&something:int=1 [line 125, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_13" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_12" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_14" [label="14: Call _fun_printf \n n$7=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 122, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_14" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_15" [label="15: Prune (true branch, switch) \n PRUNE((n$2 == 3), true); [line 130, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_15" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_16" [label="16: Prune (false branch, switch) \n PRUNE(!(n$2 == 3), false); [line 130, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_16" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_17" [label="17: Prune (true branch, switch) \n PRUNE((n$2 == 2), true); [line 129, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_17" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_3" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_18" [label="18: Prune (false branch, switch) \n PRUNE(!(n$2 == 2), false); [line 129, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_18" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_15" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_18" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_16" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_19" [label="19: Prune (true branch, switch) \n PRUNE((n$2 == 1), true); [line 124, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_19" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_13" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_20" [label="20: Prune (false branch, switch) \n PRUNE(!(n$2 == 1), false); [line 124, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_20" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_17" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_20" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_18" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_21" [label="21: Prune (true branch, switch) \n PRUNE((n$2 == 0), true); [line 121, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_21" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_14" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_22" [label="22: Prune (false branch, switch) \n PRUNE(!(n$2 == 0), false); [line 121, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_22" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_19" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_22" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_20" ;
"test_switch6.a23e54b3840073f4ece330ef3c560915_23" [label="23: DeclStmt \n *&value:int=0 [line 119, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch6.a23e54b3840073f4ece330ef3c560915_23" -> "test_switch6.a23e54b3840073f4ece330ef3c560915_5" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_1" [label="1: Start test_switch7\nFormals: \nLocals: z:int something:int value:int \n DECLARE_LOCALS(&return,&z,&something,&value); [line 138, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_1" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_17" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_2" [label="2: Exit test_switch7 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" [label="3: Return Stmt \n *&return:int=0 [line 153, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_2" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_4" [label="4: SwitchStmt \n n$0=_fun_getValue() [line 140, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_4" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_15" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_4" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_16" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_5" [label="5: DeclStmt \n *&z:int=9 [line 148, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_5" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_6" [label="6: UnaryOperator \n n$3=*&something:int [line 146, column 7]\n *&something:int=(n$3 + 1) [line 146, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_6" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_7" [label="7: DeclStmt \n *&something:int=1 [line 145, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_7" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_6" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_8" [label="8: Call _fun_printf \n n$5=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 142, column 7]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_8" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_9" [label="9: Prune (true branch, switch) \n PRUNE((n$0 == 3), true); [line 150, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_9" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_10" [label="10: Prune (false branch, switch) \n PRUNE(!(n$0 == 3), false); [line 150, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_10" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_11" [label="11: Prune (true branch, switch) \n PRUNE((n$0 == 2), true); [line 149, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_11" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_3" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_12" [label="12: Prune (false branch, switch) \n PRUNE(!(n$0 == 2), false); [line 149, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_12" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_9" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_12" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_10" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_13" [label="13: Prune (true branch, switch) \n PRUNE((n$0 == 1), true); [line 144, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_13" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_7" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_14" [label="14: Prune (false branch, switch) \n PRUNE(!(n$0 == 1), false); [line 144, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_14" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_11" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_14" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_12" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_15" [label="15: Prune (true branch, switch) \n PRUNE((n$0 == 0), true); [line 141, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_15" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_8" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_16" [label="16: Prune (false branch, switch) \n PRUNE(!(n$0 == 0), false); [line 141, column 5]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_16" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_13" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_16" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_14" ;
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_17" [label="17: DeclStmt \n *&value:int=0 [line 139, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch7.8298274f5578f21bdddf71ffa79afcb8_17" -> "test_switch7.8298274f5578f21bdddf71ffa79afcb8_4" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_1" [label="1: Start test_switch8\nFormals: \nLocals: a:int 0$?%__sil_tmpSIL_temp_conditional___n$1:int z:int something:int value:int \n DECLARE_LOCALS(&return,&a,&0$?%__sil_tmpSIL_temp_conditional___n$1,&z,&something,&value); [line 156, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_1" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_29" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_2" [label="2: Exit test_switch8 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_3" [label="3: Return Stmt \n *&return:int=0 [line 175, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_3" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_2" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_4" [label="4: + \n " ]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_4" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_5" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_5" [label="5: BinaryOperatorStmt: LT \n n$0=*&value:int [line 158, column 10]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_5" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_6" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_5" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_7" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_6" [label="6: Prune (true branch, while) \n PRUNE((n$0 < 10), true); [line 158, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_6" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_10" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_7" [label="7: Prune (false branch, while) \n PRUNE(!(n$0 < 10), false); [line 158, column 10]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_7" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_3" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" [label="8: DeclStmt \n *&a:int=0 [line 173, column 5]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_4" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_9" [label="9: + \n " ]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_9" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_15" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_10" [label="10: BinaryOperatorStmt: EQ \n n$2=_fun_getValue() [line 159, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_10" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_11" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_10" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_12" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_11" [label="11: Prune (true branch, boolean exp) \n PRUNE((n$2 == 0), true); [line 159, column 13]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_11" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_13" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_12" [label="12: Prune (false branch, boolean exp) \n PRUNE(!(n$2 == 0), false); [line 159, column 13]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_12" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_14" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_13" [label="13: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$1:int=1 [line 159, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_13" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_9" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_14" [label="14: ConditionalStmt Branch \n *&0$?%__sil_tmpSIL_temp_conditional___n$1:int=2 [line 159, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_14" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_9" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_15" [label="15: SwitchStmt \n n$3=*&0$?%__sil_tmpSIL_temp_conditional___n$1:int [line 159, column 13]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_15" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_27" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_15" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_28" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_16" [label="16: DeclStmt \n *&z:int=9 [line 168, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_16" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_17" [label="17: UnaryOperator \n n$7=*&something:int [line 165, column 9]\n *&something:int=(n$7 + 1) [line 165, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_17" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_4" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_18" [label="18: DeclStmt \n *&something:int=1 [line 164, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_18" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_17" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_19" [label="19: Return Stmt \n *&return:int=0 [line 162, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_19" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_2" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_20" [label="20: Call _fun_printf \n n$8=_fun_printf(\"(0)HELLO WORLD!\":char const *) [line 161, column 9]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_20" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_19" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_21" [label="21: Prune (true branch, switch) \n PRUNE((n$3 == 3), true); [line 170, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_21" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_22" [label="22: Prune (false branch, switch) \n PRUNE(!(n$3 == 3), false); [line 170, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_22" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_23" [label="23: Prune (true branch, switch) \n PRUNE((n$3 == 2), true); [line 169, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_23" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_8" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_24" [label="24: Prune (false branch, switch) \n PRUNE(!(n$3 == 2), false); [line 169, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_24" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_21" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_24" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_22" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_25" [label="25: Prune (true branch, switch) \n PRUNE((n$3 == 1), true); [line 163, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_25" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_18" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_26" [label="26: Prune (false branch, switch) \n PRUNE(!(n$3 == 1), false); [line 163, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_26" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_23" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_26" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_24" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_27" [label="27: Prune (true branch, switch) \n PRUNE((n$3 == 0), true); [line 160, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_27" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_20" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_28" [label="28: Prune (false branch, switch) \n PRUNE(!(n$3 == 0), false); [line 160, column 7]\n " shape="invhouse"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_28" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_25" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_28" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_26" ;
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_29" [label="29: DeclStmt \n *&value:int=0 [line 157, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_29" -> "test_switch8.6a6653773b94c1bb3f3c90dc1790d1ed_4" ;
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_1" [label="1: Start test_switch9\nFormals: \nLocals: value:int \n DECLARE_LOCALS(&return,&value); [line 178, column 1]\n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_1" -> "test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_5" ;
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_2" [label="2: Exit test_switch9 \n " color=yellow style=filled]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_3" [label="3: Return Stmt \n *&return:int=0 [line 181, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_3" -> "test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_2" ;
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_4" [label="4: SwitchStmt \n n$0=*&value:int [line 180, column 11]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_4" -> "test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_3" ;
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_5" [label="5: DeclStmt \n *&value:int=0 [line 179, column 3]\n " shape="box"]
initial synchronization
10 years ago
[clang] make switch statement translation more robust Summary: Labels inside switch statements were causing havoc (see test), and the translation of switch statements in general could be improved to handle more cases. It turns out that `case` (and `default`) statements are more or less fancy labels into the code. In other words, if you erase all the `case XXX:` and `default:` strings in the `switch` statement you get the real structure of the program, and `switch` just jumps straight to the first `case` directives (and to the second if the first one is not satisfied, etc. until all `case`/`default` have been considered). This suggests an alternative implementation: translate the body of the `switch` and simply record the list of switch cases inside that body, along with where they point to. Then post-process this list to construct the control flow of the `switch`, which points into the control-flow of the `body`. In order not to modify every function in `CTrans` to propagate the current list of cases, I created an ugly `ref` inside `SwitchCase` instead (but it cannot be directly accessed and it's guaranteed to be well-parenthesised wrt nested switches by the `SwitchCase` API so it's not too bad). [unrelated] Also make translation failures output more information about what exactly in the source code is causing the crash, and the ancestors in the AST that lead to the crash site. Reviewed By: martinoluca Differential Revision: D8011046 fbshipit-source-id: 8455090
7 years ago
"test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_5" -> "test_switch9.f4a96f02ca05cf92a483f69cdfe717b1_4" ;
initial synchronization
10 years ago
}