diff --git a/change-notes/1.23/analysis-cpp.md b/change-notes/1.23/analysis-cpp.md index 4c7b1d0a26c..4c2cac9f3c3 100644 --- a/change-notes/1.23/analysis-cpp.md +++ b/change-notes/1.23/analysis-cpp.md @@ -2,66 +2,65 @@ The following changes in version 1.23 affect C/C++ analysis in all applications. -## General improvements - ## New queries | **Query** | **Tags** | **Purpose** | |-----------------------------|-----------|--------------------------------------------------------------------| -| Hard-coded Japanese era start date (`cpp/japanese-era/exact-era-date`) | reliability, japanese-era | This query is a combination of two old queries that were identical in purpose but separate as an implementation detail. This new query replaces Hard-coded Japanese era start date in call (`cpp/japanese-era/constructor-or-method-with-exact-era-date`) and Hard-coded Japanese era start date in struct (`cpp/japanese-era/struct-with-exact-era-date`). | -| Signed overflow check (`cpp/signed-overflow-check`) | correctness, security | Finds overflow checks that rely on signed integer addition to overflow, which has undefined behavior. Example: `a + b < a`. | -| Pointer overflow check (`cpp/pointer-overflow-check`) | correctness, security | Finds overflow checks that rely on pointer addition to overflow, which has undefined behavior. Example: `ptr + a < ptr`. | +| Hard-coded Japanese era start date (`cpp/japanese-era/exact-era-date`) | reliability, japanese-era | This query is a combination of two old queries that were identical in purpose but separate as an implementation detail. This new query replaces Hard-coded Japanese era start date in call (`cpp/japanese-era/constructor-or-method-with-exact-era-date`) and Hard-coded Japanese era start date in struct (`cpp/japanese-era/struct-with-exact-era-date`). Results are not shown on LGTM by default. | +| Pointer overflow check (`cpp/pointer-overflow-check`) | correctness, security | Finds overflow checks that rely on pointer addition to overflow, which has undefined behavior. Example: `ptr + a < ptr`. Results are shown on LGTM by default. | +| Signed overflow check (`cpp/signed-overflow-check`) | correctness, security | Finds overflow checks that rely on signed integer addition to overflow, which has undefined behavior. Example: `a + b < a`. Results are shown on LGTM by default. | + ## Changes to existing queries | **Query** | **Expected impact** | **Change** | |----------------------------|------------------------|------------------------------------------------------------------| -| Query name (`query id`) | Expected impact | Message. | +| Comparison of narrow type with wide type in loop condition (`cpp/comparison-with-wider-type`) | Higher precision | The precision of this query has been increased to "high" as the alerts from this query have proved to be valuable on real-world projects. With this precision, results are now displayed by default in LGTM. | | Hard-coded Japanese era start date in call (`cpp/japanese-era/constructor-or-method-with-exact-era-date`) | Deprecated | This query has been deprecated. Use the new combined query Hard-coded Japanese era start date (`cpp/japanese-era/exact-era-date`) instead. | | Hard-coded Japanese era start date in struct (`cpp/japanese-era/struct-with-exact-era-date`) | Deprecated | This query has been deprecated. Use the new combined query Hard-coded Japanese era start date (`cpp/japanese-era/exact-era-date`) instead. | | Hard-coded Japanese era start date (`cpp/japanese-era/exact-era-date`) | More correct results | This query now checks for the beginning date of the Reiwa era (1st May 2019). | +| Non-constant format string (`cpp/non-constant-format`) | Fewer false positive results | Fixed false positive results triggrered by mismatching declarations of a formatting function. | | Sign check of bitwise operation (`cpp/bitwise-sign-check`) | Fewer false positive results | Results involving `>=` or `<=` are no longer reported. | -| Too few arguments to formatting function (`cpp/wrong-number-format-arguments`) | Fewer false positive results | Fixed false positives resulting from mistmatching declarations of a formatting function. | -| Too many arguments to formatting function (`cpp/too-many-format-arguments`) | Fewer false positive results | Fixed false positives resulting from mistmatching declarations of a formatting function. | -| Unclear comparison precedence (`cpp/comparison-precedence`) | Fewer false positive results | False positives involving template classes and functions have been fixed. | -| Comparison of narrow type with wide type in loop condition (`cpp/comparison-with-wider-type`) | Higher precision | The precision of this query has been increased to "high" as the alerts from this query have proved to be valuable on real-world projects. With this precision, results are now displayed by default in LGTM. | -| Non-constant format string (`cpp/non-constant-format`) | Fewer false positive results | Fixed false positives resulting from mistmatching declarations of a formatting function. | -| Wrong type of arguments to formatting function (`cpp/wrong-type-format-argument`) | More correct results and fewer false positive results | This query now understands explicitly specified argument numbers in format strings, such as the `1$` in `%1$s`. | +| Too few arguments to formatting function (`cpp/wrong-number-format-arguments`) | Fewer false positive results | Fixed false positive results triggered by mismatching declarations of a formatting function. | +| Too many arguments to formatting function (`cpp/too-many-format-arguments`) | Fewer false positive results | Fixed false positive results triggered by mismatching declarations of a formatting function. | +| Unclear comparison precedence (`cpp/comparison-precedence`) | Fewer false positive results | False positive results involving template classes and functions have been fixed. | +| Wrong type of arguments to formatting function (`cpp/wrong-type-format-argument`) | More correct results and fewer false positive results | This query now understands explicitly-specified argument numbers in format strings, such as the `1$` in `%1$s`. | ## Changes to libraries -* The data-flow library has been extended with a new feature to aid debugging. - Instead of specifying `isSink(Node n) { any() }` on a configuration to - explore the possible flow from a source, it is recommended to use the new - `Configuration::hasPartialFlow` predicate, as this gives a more complete - picture of the partial flow paths from a given source. The feature is - disabled by default and can be enabled for individual configurations by - overriding `int explorationLimit()`. -* The data-flow library now supports flow out of C++ reference parameters. -* The data-flow library now allows flow through the address-of operator (`&`). -* The `DataFlow::DefinitionByReferenceNode` class now considers `f(x)` to be a - definition of `x` when `x` is a variable of pointer type. It no longer - considers deep paths such as `f(&x.myField)` to be definitions of `x`. These - changes are in line with the user expectations we've observed. -* The data-flow library now makes it easier to specify barriers/sanitizers - arising from guards by overriding the predicate - `isBarrierGuard`/`isSanitizerGuard` on data-flow and taint-tracking - configurations respectively. -* There is now a `DataFlow::localExprFlow` predicate and a - `TaintTracking::localExprTaint` predicate to make it easy to use the most - common case of local data flow and taint: from one `Expr` to another. +* The data-flow library in `semmle.code.cpp.dataflow.DataFlow` and + `semmle.code.cpp.dataflow.TaintTracking` have had extensive changes: + * Data flow through fields is now more complete and reliable. + * The data-flow library has been extended with a new feature to aid debugging. + Previously, to explore the possible flow from all sources you could specify `isSink(Node n) { any() }` on a configuration. + Now you can use the new `Configuration::hasPartialFlow` predicate, + which gives a more complete picture of the partial flow paths from a given source, including flow that doesn't reach any sink. + The feature is disabled by default and can be enabled for individual configurations by overriding `int explorationLimit()`. + * There is now flow out of C++ reference parameters. + * There is now flow through the address-of operator (`&`). + * The `DataFlow::DefinitionByReferenceNode` class now considers `f(x)` to be a + definition of `x` when `x` is a variable of pointer type. It no longer + considers deep paths such as `f(&x.myField)` to be definitions of `x`. These + changes are in line with the user expectations we've observed. + * It's now easier to specify barriers/sanitizers + arising from guards by overriding the predicate + `isBarrierGuard`/`isSanitizerGuard` on data-flow and taint-tracking + configurations respectively. + * There is now a `DataFlow::localExprFlow` predicate and a + `TaintTracking::localExprTaint` predicate to make it easy to use the most + common case of local data flow and taint: from one `Expr` to another. * The member predicates of the `FunctionInput` and `FunctionOutput` classes have been renamed for - clarity (e.g. `isOutReturnPointer()` to `isReturnValueDeref()`). The existing member predicates + clarity (for example, `isOutReturnPointer()` to `isReturnValueDeref()`). The existing member predicates have been deprecated, and will be removed in a future release. Code that uses the old member predicates should be updated to use the corresponding new member predicate. -* The predicates `Declaration.hasStdName()` and `Declaration.hasGlobalOrStdName` - have been added, simplifying handling of C++ standard library functions. +* The predicate `Declaration.hasGlobalOrStdName` has been added, making it + easier to recognize C library functions called from C++. * The control-flow graph is now computed in QL, not in the extractor. This can - lead to regressions (or improvements) in how queries are optimized because + lead to changes in how queries are optimized because optimization in QL relies on static size estimates, and the control-flow edge relations will now have different size estimates than before. * Support has been added for non-type template arguments. This means that the return type of `Declaration::getTemplateArgument()` and - `Declaration::getATemplateArgument` have changed to `Locatable`. See the - documentation for `Declaration::getTemplateArgument()` and - `Declaration::getTemplateArgumentKind()` for details. + `Declaration::getATemplateArgument` have changed to `Locatable`. For details, see the + CodeQL library documentation for `Declaration::getTemplateArgument()` and + `Declaration::getTemplateArgumentKind()`. diff --git a/change-notes/1.23/analysis-java.md b/change-notes/1.23/analysis-java.md index 8c38f57e9d2..ad1f2248912 100644 --- a/change-notes/1.23/analysis-java.md +++ b/change-notes/1.23/analysis-java.md @@ -6,25 +6,23 @@ The following changes in version 1.23 affect Java analysis in all applications. | **Query** | **Tags** | **Purpose** | |-----------------------------|-----------|--------------------------------------------------------------------| -| Continue statement that does not continue (`java/continue-in-false-loop`) | correctness | Finds `continue` statements in `do { ... } while (false)` loops. | +| Continue statement that does not continue (`java/continue-in-false-loop`) | correctness | Finds `continue` statements in `do { ... } while (false)` loops. Results are shown on LGTM by default. | ## Changes to existing queries | **Query** | **Expected impact** | **Change** | |------------------------------|------------------------|-----------------------------------| -| Dereferenced variable may be null (`java/dereferenced-value-may-be-null`) | Fewer false positives | Certain indirect null guards involving two auxiliary variables known to be equal can now be detected. | -| Non-synchronized override of synchronized method (`java/non-sync-override`) | Fewer false positives | Results are now only reported if the immediately overridden method is synchronized. | -| Query built from user-controlled sources (`java/sql-injection`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as SQL expressions sinks. | -| Query built from local-user-controlled sources (`java/sql-injection-local`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as SQL expressions sinks. | -| Query built without neutralizing special characters (`java/concatenated-sql-query`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as SQL expressions sinks. | -| Useless comparison test (`java/constant-comparison`) | Fewer false positives | Additional overflow check patterns are now recognized and no longer reported. | +| Dereferenced variable may be null (`java/dereferenced-value-may-be-null`) | Fewer false positive results | Additional indirect null guards are detected, where two auxiliary variables are known to be equal. | +| Non-synchronized override of synchronized method (`java/non-sync-override`) | Fewer false positive results | Results are now only reported if the immediately overridden method is synchronized. | +| Query built from local-user-controlled sources (`java/sql-injection-local`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as sinks for SQL expressions. | +| Query built from user-controlled sources (`java/sql-injection`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as sinks for SQL expressions. | +| Query built without neutralizing special characters (`java/concatenated-sql-query`) | More results | The query now identifies arguments to `Statement.executeLargeUpdate` and `Connection.prepareCall` as sinks for SQL expressions. | +| Useless comparison test (`java/constant-comparison`) | Fewer false positive results | Additional overflow check patterns are now recognized and no longer reported. Also, a few bug fixes in the range analysis for floating-point variables gives a further reduction in false positive results. | ## Changes to libraries -* The data-flow library has been extended with a new feature to aid debugging. - Instead of specifying `isSink(Node n) { any() }` on a configuration to - explore the possible flow from a source, it is recommended to use the new - `Configuration::hasPartialFlow` predicate, as this gives a more complete - picture of the partial flow paths from a given source. The feature is - disabled by default and can be enabled for individual configurations by - overriding `int explorationLimit()`. +The data-flow library has been extended with a new feature to aid debugging. +Previously, to explore the possible flow from all sources you could specify `isSink(Node n) { any() }` on a configuration. +Now you can use the new `Configuration::hasPartialFlow` predicate, +which gives a more complete picture of the partial flow paths from a given source, including flow that doesn't reach any sink. +The feature is disabled by default and can be enabled for individual configurations by overriding `int explorationLimit()`. diff --git a/change-notes/1.23/analysis-javascript.md b/change-notes/1.23/analysis-javascript.md index e815f5e8ba0..4d449fb017b 100644 --- a/change-notes/1.23/analysis-javascript.md +++ b/change-notes/1.23/analysis-javascript.md @@ -27,7 +27,7 @@ |---------------------------------------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Ignoring result from pure array method (`js/ignore-array-result`) | maintainability, correctness | Highlights calls to array methods without side effects where the return value is ignored. Results are shown on LGTM by default. | | Incomplete URL scheme check (`js/incomplete-url-scheme-check`) | security, correctness, external/cwe/cwe-020 | Highlights checks for `javascript:` URLs that do not take `data:` or `vbscript:` URLs into account. Results are shown on LGTM by default. | -| Loop bound injection (`js/loop-bound-injection`) | security, external/cwe/cwe-834 | Highlights loops where a user-controlled object with an arbitrary .length value can trick the server to loop indefinitely. Results are shown on LGTM by default. | +| Loop bound injection (`js/loop-bound-injection`) | security, external/cwe/cwe-834 | Highlights loops where a user-controlled object with an arbitrary `.length` value can trick the server into looping indefinitely. Results are shown on LGTM by default. | | Shell command built from environment values (`js/shell-command-injection-from-environment`) | correctness, security, external/cwe/cwe-078, external/cwe/cwe-088 | Highlights shell commands that may change behavior inadvertently depending on the execution environment, indicating a possible violation of [CWE-78](https://cwe.mitre.org/data/definitions/78.html). Results are shown on LGTM by default.| | Suspicious method name (`js/suspicious-method-name-declaration`) | correctness, typescript, methods | Highlights suspiciously named methods where the developer likely meant to write a constructor or function. Results are shown on LGTM by default. | | Unreachable method overloads (`js/unreachable-method-overloads`) | correctness, typescript | Highlights method overloads that are impossible to use from client code. Results are shown on LGTM by default. | @@ -39,19 +39,19 @@ | **Query** | **Expected impact** | **Change** | |--------------------------------|------------------------------|---------------------------------------------------------------------------| -| Incomplete string escaping or encoding (`js/incomplete-sanitization`) | Fewer false-positive results | This rule now recognizes additional ways delimiters can be stripped away. | -| Client-side cross-site scripting (`js/xss`) | More results, fewer false-positive results | More potential vulnerabilities involving functions that manipulate DOM attributes are now recognized, and more sanitizers are detected. | +| Client-side cross-site scripting (`js/xss`) | More results, fewer false positive results | More potential vulnerabilities involving functions that manipulate DOM attributes are now recognized, and more sanitizers are detected. | | Code injection (`js/code-injection`) | More results | More potential vulnerabilities involving functions that manipulate DOM event handler attributes are now recognized. | -| Hard-coded credentials (`js/hardcoded-credentials`) | Fewer false-positive results | This rule now flags fewer password examples. | -| Illegal invocation (`js/illegal-invocation`) | Fewer false-positive results | This rule now correctly handles methods named `call` and `apply`. | -| Incorrect suffix check (`js/incorrect-suffix-check`) | Fewer false-positive results | The query recognizes valid checks in more cases. | -| Network data written to file (`js/http-to-file-access`) | Fewer false-positive results | This query has been renamed to better match its intended purpose, and now only considers network data untrusted. | -| Password in configuration file (`js/password-in-configuration-file`) | Fewer false-positive results | This rule now flags fewer password examples. | +| Hard-coded credentials (`js/hardcoded-credentials`) | Fewer false positive results | This rule now flags fewer password examples. | +| Illegal invocation (`js/illegal-invocation`) | Fewer false positive results | This rule now correctly handles methods named `call` and `apply`. | +| Incomplete string escaping or encoding (`js/incomplete-sanitization`) | Fewer false positive results | This rule now recognizes additional ways delimiters can be stripped away. | +| Incorrect suffix check (`js/incorrect-suffix-check`) | Fewer false positive results | The query recognizes valid checks in more cases. | +| Network data written to file (`js/http-to-file-access`) | Fewer false positive results | This query has been renamed to better match its intended purpose, and now only considers network data untrusted. | +| Password in configuration file (`js/password-in-configuration-file`) | Fewer false positive results | This rule now flags fewer password examples. | | Prototype pollution (`js/prototype-pollution`) | More results | The query now highlights vulnerable uses of jQuery and Angular, and the results are shown on LGTM by default. | -| Reflected cross-site scripting (`js/reflected-xss`) | Fewer false-positive results | The query now recognizes more sanitizers. | -| Stored cross-site scripting (`js/stored-xss`) | Fewer false-positive results | The query now recognizes more sanitizers. | +| Reflected cross-site scripting (`js/reflected-xss`) | Fewer false positive results | The query now recognizes more sanitizers. | +| Stored cross-site scripting (`js/stored-xss`) | Fewer false positive results | The query now recognizes more sanitizers. | | Uncontrolled command line (`js/command-line-injection`) | More results | This query now treats responses from servers as untrusted. | -| Uncontrolled data used in path expression (`js/path-injection`) | Fewer false-positive results | This query now recognizes calls to Express `sendFile` as safe in some cases. | +| Uncontrolled data used in path expression (`js/path-injection`) | Fewer false positive results | This query now recognizes calls to Express `sendFile` as safe in some cases. | | Unknown directive (`js/unknown-directive`) | Fewer false positive results | This query no longer flags uses of ":", which is sometimes used like a directive. | ## Changes to libraries @@ -67,16 +67,16 @@ The following queries (deprecated since 1.17) are no longer available in the distribution: -* Builtin redefined (js/builtin-redefinition) -* Inefficient method definition (js/method-definition-in-constructor) * Bad parity check (js/incomplete-parity-check) -* Potentially misspelled property or variable name (js/wrong-capitalization) -* Unknown JSDoc tag (js/jsdoc/unknown-tag-type) +* Builtin redefined (js/builtin-redefinition) +* Call to parseInt without radix (js/parseint-without-radix) +* Inefficient method definition (js/method-definition-in-constructor) * Invalid JSLint directive (js/jslint/invalid-directive) * Malformed JSLint directive (js/jslint/malformed-directive) -* Use of HTML comments (js/html-comment) * Multi-line string literal (js/multi-line-string) * Octal literal (js/octal-literal) +* Potentially misspelled property or variable name (js/wrong-capitalization) * Reserved word used as variable name (js/use-of-reserved-word) * Trailing comma in array or object expressions (js/trailing-comma-in-array-or-object) -* Call to parseInt without radix (js/parseint-without-radix) +* Unknown JSDoc tag (js/jsdoc/unknown-tag-type) +* Use of HTML comments (js/html-comment) diff --git a/change-notes/1.23/analysis-python.md b/change-notes/1.23/analysis-python.md index 6cea1745284..5320567af85 100644 --- a/change-notes/1.23/analysis-python.md +++ b/change-notes/1.23/analysis-python.md @@ -3,7 +3,19 @@ ## General improvements +### Python 3.8 support +Python 3.8 syntax is now supported. In particular, the following constructs are parsed correctly: + +- Assignment expressions using the "walrus" operator, such as `while chunk := file.read(1024): ...`. +- The positional argument separator `/`, such as in `def foo(a, /, b, *, c): ...`. +- Self-documenting expressions in f-strings, such as `f"{var=}"`. + +### General query improvements + +Following the replacement of the `Object` API (for example, `ClassObject`) in favor of the +`Value` API (for example, `ClassValue`) in the 1.21 release, many of the standard queries have been updated +to use the `Value` API. This should result in more precise results. ## New queries @@ -18,10 +30,23 @@ | **Query** | **Expected impact** | **Change** | |----------------------------|------------------------|------------| -| Unreachable code | Fewer false positives | Analysis now accounts for uses of `contextlib.suppress` to suppress exceptions. | -| `__iter__` method returns a non-iterator | Better alert message | Alert now highlights which class is expected to be an iterator. | - +| Explicit export is undefined (`py/undefined-export`) | Fewer false positive results | Instances where an exported value may be defined in a module that lacks points-to information are no longer flagged. | +| Module-level cyclic import (`py/unsafe-cyclic-import`) | Fewer false positive results | Instances where one of the links in an import cycle is never actually executed are no longer flagged. | +| Non-iterable used in for loop (`py/non-iterable-in-for-loop`) | Fewer false positive results | `__aiter__` is now recognized as an iterator method. | +| Unreachable code (`py/unreachable-statement`) | Fewer false positive results | Analysis now accounts for uses of `contextlib.suppress` to suppress exceptions. | +| Unreachable code (`py/unreachable-statement`) | Fewer false positive results | Unreachable `else` branches that do nothing but `assert` their non-reachability are no longer flagged. | +| Unused import (`py/unused-import`) | Fewer false positive results | Instances where a module is used in a forward-referenced type annotation, or only during type checking are no longer flagged. | +| `__iter__` method returns a non-iterator (`py/iter-returns-non-iterator`) | Better alert message | Alert now highlights which class is expected to be an iterator. | +| `__init__` method returns a value (`py/explicit-return-in-init`) | Fewer false positive results | Instances where the `__init__` method returns the value of a call to a procedure are no longer flagged. | ## Changes to QL libraries * Django library now recognizes positional arguments from a `django.conf.urls.url` regex (Django version 1.x) +* Instances of the `Value` class now support the `isAbsent` method, indicating + whether that `Value` lacks points-to information, but inference + suggests that it exists. For instance, if a file contains `import + django`, but `django` was not extracted properly, there will be a + `ModuleValue` corresponding to this "unknown" module, and the `isAbsent` + method will hold for this `ModuleValue`. +* The `Expr` class now has a nullary method `pointsTo` that returns the possible + instances of `Value` that this expression may have. diff --git a/change-notes/1.23/extractor-javascript.md b/change-notes/1.23/extractor-javascript.md index 8b7a35f5b4f..f8eed613b6d 100644 --- a/change-notes/1.23/extractor-javascript.md +++ b/change-notes/1.23/extractor-javascript.md @@ -7,17 +7,17 @@ * Asynchronous generator methods are now parsed correctly and no longer cause a spurious syntax error. * Files in `node_modules` and `bower_components` folders are no longer extracted by default. If you still want to extract files from these folders, you can add the following filters to your `lgtm.yml` file (or add them to existing filters): -```yaml -extraction: - javascript: - index: - filters: - - include: "**/node_modules" - - include: "**/bower_components" -``` + ```yaml + extraction: + javascript: + index: + filters: + - include: "**/node_modules" + - include: "**/bower_components" + ``` +* Additional [Flow](https://flow.org/) syntax is now supported. * Recognition of CommonJS modules has improved. As a result, some files that were previously extracted as global scripts are now extracted as modules. * Top-level `await` is now supported. -* A bug was fixed in how the TypeScript extractor handles default-exported anonymous classes. -* A bug was fixed in how the TypeScript extractor handles computed instance field names. +* Bugs were fixed in how the TypeScript extractor handles default-exported anonymous classes and computed-instance field names. diff --git a/change-notes/1.24/analysis-cpp.md b/change-notes/1.24/analysis-cpp.md index 2e7fdd422af..68795215b13 100644 --- a/change-notes/1.24/analysis-cpp.md +++ b/change-notes/1.24/analysis-cpp.md @@ -17,4 +17,11 @@ The following changes in version 1.24 affect C/C++ analysis in all applications. ## Changes to libraries -* +* The new class `StackVariable` should be used in place of `LocalScopeVariable` + in most cases. The difference is that `StackVariable` does not include + variables declared with `static` or `thread_local`. + * As a rule of thumb, custom queries about the _values_ of variables should + be changed from `LocalScopeVariable` to `StackVariable`, while queries + about the _name or scope_ of variables should remain unchanged. + * The `LocalScopeVariableReachability` library is deprecated in favor of + `StackVariableReachability`. The functionality is the same. diff --git a/change-notes/1.24/analysis-csharp.md b/change-notes/1.24/analysis-csharp.md new file mode 100644 index 00000000000..bd0c81115ab --- /dev/null +++ b/change-notes/1.24/analysis-csharp.md @@ -0,0 +1,25 @@ +# Improvements to C# analysis + +The following changes in version 1.24 affect C# analysis in all applications. + +## New queries + +| **Query** | **Tags** | **Purpose** | +|-----------------------------|-----------|--------------------------------------------------------------------| +| Insecure configuration for ASP.NET requestValidationMode (`cs/insecure-request-validation-mode`) | security, external/cwe/cwe-016 | Finds where this attribute has been set to a value less than 4.5, which turns off some validation features and makes the application less secure. | + +## Changes to existing queries + +| **Query** | **Expected impact** | **Change** | +|------------------------------|------------------------|-----------------------------------| + +## Removal of old queries + +## Changes to code extraction + +## Changes to libraries + +* The taint tracking library now tracks flow through (implicit or explicit) conversion operator calls. + +## Changes to autobuilder + diff --git a/change-notes/1.24/analysis-javascript.md b/change-notes/1.24/analysis-javascript.md index fbe7fd00899..c6c544e2f3d 100644 --- a/change-notes/1.24/analysis-javascript.md +++ b/change-notes/1.24/analysis-javascript.md @@ -4,13 +4,17 @@ * Support for the following frameworks and libraries has been improved: - [react](https://www.npmjs.com/package/react) + - [typeahead.js](https://www.npmjs.com/package/typeahead.js) - [Handlebars](https://www.npmjs.com/package/handlebars) +- Imports with the `.js` extension can now be resolved to a TypeScript file, + when the import refers to a file generated by TypeScript. + ## New queries -| **Query** | **Tags** | **Purpose** | -|---------------------------------------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| - +| **Query** | **Tags** | **Purpose** | +|---------------------------------------------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| Cross-site scripting through exception (`js/xss-through-exception`) | security, external/cwe/cwe-079, external/cwe/cwe-116 | Highlights potential XSS vulnerabilities where an exception is written to the DOM. Results are not shown on LGTM by default. | ## Changes to existing queries @@ -22,3 +26,5 @@ ## Changes to libraries +* The predicates `RegExpTerm.getSuccessor` and `RegExpTerm.getPredecessor` have been changed to reflect textual, not operational, matching order. This only makes a difference in lookbehind assertions, which are operationally matched backwards. Previously, `getSuccessor` would mimick this, so in an assertion `(?<=ab)` the term `b` would be considered the predecessor, not the successor, of `a`. Textually, however, `a` is still matched before `b`, and this is the order we now follow. + diff --git a/cpp/ql/src/Critical/DeadCodeCondition.ql b/cpp/ql/src/Critical/DeadCodeCondition.ql index 45b4418f155..a769d3d4025 100644 --- a/cpp/ql/src/Critical/DeadCodeCondition.ql +++ b/cpp/ql/src/Critical/DeadCodeCondition.ql @@ -22,7 +22,7 @@ predicate testAndBranch(Expr e, Stmt branch) { ) } -predicate choice(LocalScopeVariable v, Stmt branch, string value) { +predicate choice(StackVariable v, Stmt branch, string value) { exists(AnalysedExpr e | testAndBranch(e, branch) and ( @@ -33,7 +33,7 @@ predicate choice(LocalScopeVariable v, Stmt branch, string value) { ) } -predicate guarded(LocalScopeVariable v, Stmt loopstart, AnalysedExpr child) { +predicate guarded(StackVariable v, Stmt loopstart, AnalysedExpr child) { choice(v, loopstart, _) and loopstart.getChildStmt*() = child.getEnclosingStmt() and (definition(v, child) or exists(child.getNullSuccessor(v))) @@ -47,9 +47,7 @@ predicate addressLeak(Variable v, Stmt leak) { ) } -from - LocalScopeVariable v, Stmt branch, AnalysedExpr cond, string context, string test, - string testresult +from StackVariable v, Stmt branch, AnalysedExpr cond, string context, string test, string testresult where choice(v, branch, context) and forall(ControlFlowNode def | definition(v, def) and definitionReaches(def, cond) | diff --git a/cpp/ql/src/Critical/DescriptorMayNotBeClosed.ql b/cpp/ql/src/Critical/DescriptorMayNotBeClosed.ql index 47401c6eea5..135b9a644d1 100644 --- a/cpp/ql/src/Critical/DescriptorMayNotBeClosed.ql +++ b/cpp/ql/src/Critical/DescriptorMayNotBeClosed.ql @@ -23,14 +23,14 @@ predicate closeCall(FunctionCall fc, Variable v) { ) } -predicate openDefinition(LocalScopeVariable v, ControlFlowNode def) { +predicate openDefinition(StackVariable v, ControlFlowNode def) { exists(Expr expr | exprDefinition(v, def, expr) and allocateDescriptorCall(expr)) } predicate openReaches(ControlFlowNode def, ControlFlowNode node) { - exists(LocalScopeVariable v | openDefinition(v, def) and node = def.getASuccessor()) + exists(StackVariable v | openDefinition(v, def) and node = def.getASuccessor()) or - exists(LocalScopeVariable v, ControlFlowNode mid | + exists(StackVariable v, ControlFlowNode mid | openDefinition(v, def) and openReaches(def, mid) and not errorSuccessor(v, mid) and @@ -40,7 +40,7 @@ predicate openReaches(ControlFlowNode def, ControlFlowNode node) { ) } -predicate assignedToFieldOrGlobal(LocalScopeVariable v, Assignment assign) { +predicate assignedToFieldOrGlobal(StackVariable v, Assignment assign) { exists(Variable external | assign.getRValue() = v.getAnAccess() and assign.getLValue().(VariableAccess).getTarget() = external and @@ -48,7 +48,7 @@ predicate assignedToFieldOrGlobal(LocalScopeVariable v, Assignment assign) { ) } -from LocalScopeVariable v, ControlFlowNode def, ReturnStmt ret +from StackVariable v, ControlFlowNode def, ReturnStmt ret where openDefinition(v, def) and openReaches(def, ret) and diff --git a/cpp/ql/src/Critical/FileMayNotBeClosed.ql b/cpp/ql/src/Critical/FileMayNotBeClosed.ql index fefe43aa845..c97e7cacca3 100644 --- a/cpp/ql/src/Critical/FileMayNotBeClosed.ql +++ b/cpp/ql/src/Critical/FileMayNotBeClosed.ql @@ -10,7 +10,7 @@ */ import FileClosed -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability /** * Extend the NullValue class used by Nullness.qll to include simple -1 as a 'null' value @@ -68,18 +68,18 @@ predicate fcloseCallOrIndirect(FunctionCall fc, Variable v) { ) } -predicate fopenDefinition(LocalScopeVariable v, ControlFlowNode def) { +predicate fopenDefinition(StackVariable v, ControlFlowNode def) { exists(Expr expr | exprDefinition(v, def, expr) and fopenCallOrIndirect(expr)) } -class FOpenVariableReachability extends LocalScopeVariableReachabilityWithReassignment { +class FOpenVariableReachability extends StackVariableReachabilityWithReassignment { FOpenVariableReachability() { this = "FOpenVariableReachability" } - override predicate isSourceActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSourceActual(ControlFlowNode node, StackVariable v) { fopenDefinition(v, node) } - override predicate isSinkActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSinkActual(ControlFlowNode node, StackVariable v) { // node may be used in fopenReaches exists(node.(AnalysedExpr).getNullSuccessor(v)) or fcloseCallOrIndirect(node, v) or @@ -88,15 +88,13 @@ class FOpenVariableReachability extends LocalScopeVariableReachabilityWithReassi v.getFunction() = node.(ReturnStmt).getEnclosingFunction() } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { - definitionBarrier(v, node) - } + override predicate isBarrier(ControlFlowNode node, StackVariable v) { definitionBarrier(v, node) } } /** * The value from fopen at `def` is still held in Variable `v` upon entering `node`. */ -predicate fopenVariableReaches(LocalScopeVariable v, ControlFlowNode def, ControlFlowNode node) { +predicate fopenVariableReaches(StackVariable v, ControlFlowNode def, ControlFlowNode node) { exists(FOpenVariableReachability r | // reachability r.reachesTo(def, _, node, v) @@ -107,25 +105,23 @@ predicate fopenVariableReaches(LocalScopeVariable v, ControlFlowNode def, Contro ) } -class FOpenReachability extends LocalScopeVariableReachabilityExt { +class FOpenReachability extends StackVariableReachabilityExt { FOpenReachability() { this = "FOpenReachability" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { - fopenDefinition(v, node) - } + override predicate isSource(ControlFlowNode node, StackVariable v) { fopenDefinition(v, node) } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSink(ControlFlowNode node, StackVariable v) { v.getFunction() = node.(ReturnStmt).getEnclosingFunction() } override predicate isBarrier( - ControlFlowNode source, ControlFlowNode node, ControlFlowNode next, LocalScopeVariable v + ControlFlowNode source, ControlFlowNode node, ControlFlowNode next, StackVariable v ) { isSource(source, v) and next = node.getASuccessor() and // the file (stored in any variable `v0`) opened at `source` is closed or // assigned to a global at node, or NULL checked on the edge node -> next. - exists(LocalScopeVariable v0 | fopenVariableReaches(v0, source, node) | + exists(StackVariable v0 | fopenVariableReaches(v0, source, node) | node.(AnalysedExpr).getNullSuccessor(v0) = next or fcloseCallOrIndirect(node, v0) or assignedToFieldOrGlobal(v0, node) @@ -142,11 +138,11 @@ predicate fopenReaches(ControlFlowNode def, ControlFlowNode node) { exists(FOpenReachability r | r.reaches(def, _, node)) } -predicate assignedToFieldOrGlobal(LocalScopeVariable v, Expr e) { - // assigned to anything except a LocalScopeVariable +predicate assignedToFieldOrGlobal(StackVariable v, Expr e) { + // assigned to anything except a StackVariable // (typically a field or global, but for example also *ptr = v) e.(Assignment).getRValue() = v.getAnAccess() and - not e.(Assignment).getLValue().(VariableAccess).getTarget() instanceof LocalScopeVariable + not e.(Assignment).getLValue().(VariableAccess).getTarget() instanceof StackVariable or exists(Expr midExpr, Function mid, int arg | // indirect assignment @@ -163,7 +159,7 @@ predicate assignedToFieldOrGlobal(LocalScopeVariable v, Expr e) { from ControlFlowNode def, ReturnStmt ret where fopenReaches(def, ret) and - not exists(LocalScopeVariable v | + not exists(StackVariable v | fopenVariableReaches(v, def, ret) and ret.getAChild*() = v.getAnAccess() ) diff --git a/cpp/ql/src/Critical/InconsistentNullnessTesting.ql b/cpp/ql/src/Critical/InconsistentNullnessTesting.ql index 52d551f6bfd..86e2cb4fb29 100644 --- a/cpp/ql/src/Critical/InconsistentNullnessTesting.ql +++ b/cpp/ql/src/Critical/InconsistentNullnessTesting.ql @@ -11,7 +11,7 @@ import cpp -from LocalScopeVariable v, ControlFlowNode def, VariableAccess checked, VariableAccess unchecked +from StackVariable v, ControlFlowNode def, VariableAccess checked, VariableAccess unchecked where checked = v.getAnAccess() and dereferenced(checked) and diff --git a/cpp/ql/src/Critical/LateNegativeTest.ql b/cpp/ql/src/Critical/LateNegativeTest.ql index f7693d5c28e..098a224c818 100644 --- a/cpp/ql/src/Critical/LateNegativeTest.ql +++ b/cpp/ql/src/Critical/LateNegativeTest.ql @@ -13,7 +13,7 @@ import cpp -predicate negativeCheck(LocalScopeVariable v, ComparisonOperation op) { +predicate negativeCheck(StackVariable v, ComparisonOperation op) { exists(int varindex, string constant, Literal lit | op.getChild(varindex) = v.getAnAccess() and op.getChild(1 - varindex) = lit and @@ -38,7 +38,7 @@ predicate negativeCheck(LocalScopeVariable v, ComparisonOperation op) { ) } -from LocalScopeVariable v, ArrayExpr dangerous, Expr check +from StackVariable v, ArrayExpr dangerous, Expr check where useUsePair(v, dangerous.getArrayOffset(), check.getAChild()) and negativeCheck(v, check) and diff --git a/cpp/ql/src/Critical/MemoryMayNotBeFreed.ql b/cpp/ql/src/Critical/MemoryMayNotBeFreed.ql index 2bede681912..b60fa917e9a 100644 --- a/cpp/ql/src/Critical/MemoryMayNotBeFreed.ql +++ b/cpp/ql/src/Critical/MemoryMayNotBeFreed.ql @@ -10,7 +10,7 @@ */ import MemoryFreed -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability /** * 'call' is either a direct call to f, or a possible call to f @@ -97,18 +97,18 @@ predicate freeCallOrIndirect(ControlFlowNode n, Variable v) { ) } -predicate allocationDefinition(LocalScopeVariable v, ControlFlowNode def) { +predicate allocationDefinition(StackVariable v, ControlFlowNode def) { exists(Expr expr | exprDefinition(v, def, expr) and allocCallOrIndirect(expr)) } -class AllocVariableReachability extends LocalScopeVariableReachabilityWithReassignment { +class AllocVariableReachability extends StackVariableReachabilityWithReassignment { AllocVariableReachability() { this = "AllocVariableReachability" } - override predicate isSourceActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSourceActual(ControlFlowNode node, StackVariable v) { allocationDefinition(v, node) } - override predicate isSinkActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSinkActual(ControlFlowNode node, StackVariable v) { // node may be used in allocationReaches exists(node.(AnalysedExpr).getNullSuccessor(v)) or freeCallOrIndirect(node, v) or @@ -117,15 +117,13 @@ class AllocVariableReachability extends LocalScopeVariableReachabilityWithReassi v.getFunction() = node.(ReturnStmt).getEnclosingFunction() } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { - definitionBarrier(v, node) - } + override predicate isBarrier(ControlFlowNode node, StackVariable v) { definitionBarrier(v, node) } } /** * The value from allocation `def` is still held in Variable `v` upon entering `node`. */ -predicate allocatedVariableReaches(LocalScopeVariable v, ControlFlowNode def, ControlFlowNode node) { +predicate allocatedVariableReaches(StackVariable v, ControlFlowNode def, ControlFlowNode node) { exists(AllocVariableReachability r | // reachability r.reachesTo(def, _, node, v) @@ -136,25 +134,25 @@ predicate allocatedVariableReaches(LocalScopeVariable v, ControlFlowNode def, Co ) } -class AllocReachability extends LocalScopeVariableReachabilityExt { +class AllocReachability extends StackVariableReachabilityExt { AllocReachability() { this = "AllocReachability" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSource(ControlFlowNode node, StackVariable v) { allocationDefinition(v, node) } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSink(ControlFlowNode node, StackVariable v) { v.getFunction() = node.(ReturnStmt).getEnclosingFunction() } override predicate isBarrier( - ControlFlowNode source, ControlFlowNode node, ControlFlowNode next, LocalScopeVariable v + ControlFlowNode source, ControlFlowNode node, ControlFlowNode next, StackVariable v ) { isSource(source, v) and next = node.getASuccessor() and // the memory (stored in any variable `v0`) allocated at `source` is freed or // assigned to a global at node, or NULL checked on the edge node -> next. - exists(LocalScopeVariable v0 | allocatedVariableReaches(v0, source, node) | + exists(StackVariable v0 | allocatedVariableReaches(v0, source, node) | node.(AnalysedExpr).getNullSuccessor(v0) = next or freeCallOrIndirect(node, v0) or assignedToFieldOrGlobal(v0, node) @@ -171,11 +169,11 @@ predicate allocationReaches(ControlFlowNode def, ControlFlowNode node) { exists(AllocReachability r | r.reaches(def, _, node)) } -predicate assignedToFieldOrGlobal(LocalScopeVariable v, Expr e) { - // assigned to anything except a LocalScopeVariable +predicate assignedToFieldOrGlobal(StackVariable v, Expr e) { + // assigned to anything except a StackVariable // (typically a field or global, but for example also *ptr = v) e.(Assignment).getRValue() = v.getAnAccess() and - not e.(Assignment).getLValue().(VariableAccess).getTarget() instanceof LocalScopeVariable + not e.(Assignment).getLValue().(VariableAccess).getTarget() instanceof StackVariable or exists(Expr midExpr, Function mid, int arg | // indirect assignment @@ -192,7 +190,7 @@ predicate assignedToFieldOrGlobal(LocalScopeVariable v, Expr e) { from ControlFlowNode def, ReturnStmt ret where allocationReaches(def, ret) and - not exists(LocalScopeVariable v | + not exists(StackVariable v | allocatedVariableReaches(v, def, ret) and ret.getAChild*() = v.getAnAccess() ) diff --git a/cpp/ql/src/Critical/MissingNegativityTest.ql b/cpp/ql/src/Critical/MissingNegativityTest.ql index e351cba163e..565217578e0 100644 --- a/cpp/ql/src/Critical/MissingNegativityTest.ql +++ b/cpp/ql/src/Critical/MissingNegativityTest.ql @@ -43,7 +43,7 @@ class FunctionWithNegativeReturn extends Function { predicate dangerousUse(IntegralReturnValue val, Expr use) { exists(ArrayExpr ae | ae.getArrayOffset() = val and use = val) or - exists(LocalScopeVariable v, ControlFlowNode def, ArrayExpr ae | + exists(StackVariable v, ControlFlowNode def, ArrayExpr ae | exprDefinition(v, def, val) and use = ae.getArrayOffset() and not boundsChecked(v, use) and @@ -54,7 +54,7 @@ predicate dangerousUse(IntegralReturnValue val, Expr use) { val = use and use.getType().getUnderlyingType() instanceof PointerType or - exists(LocalScopeVariable v, ControlFlowNode def, AddExpr add | + exists(StackVariable v, ControlFlowNode def, AddExpr add | exprDefinition(v, def, val) and definitionUsePair(v, def, use) and add.getAnOperand() = use and diff --git a/cpp/ql/src/Critical/NewDelete.qll b/cpp/ql/src/Critical/NewDelete.qll index 39b265556b0..691c9a1031d 100644 --- a/cpp/ql/src/Critical/NewDelete.qll +++ b/cpp/ql/src/Critical/NewDelete.qll @@ -60,7 +60,7 @@ predicate allocExprOrIndirect(Expr alloc, string kind) { pragma[nomagic] private predicate allocReachesVariable(Variable v, Expr alloc, string kind) { exists(Expr mid | - not v instanceof LocalScopeVariable and + not v instanceof StackVariable and v.getAnAssignedValue() = mid and allocReaches0(mid, alloc, kind) ) @@ -76,7 +76,7 @@ private predicate allocReaches0(Expr e, Expr alloc, string kind) { allocExprOrIndirect(alloc, kind) and e = alloc or - exists(SsaDefinition def, LocalScopeVariable v | + exists(SsaDefinition def, StackVariable v | // alloc via SSA allocReaches0(def.getAnUltimateDefiningValue(v), alloc, kind) and e = def.getAUse(v) diff --git a/cpp/ql/src/Critical/OverflowCalculated.ql b/cpp/ql/src/Critical/OverflowCalculated.ql index fbca4a20a8f..c60ed7a610d 100644 --- a/cpp/ql/src/Critical/OverflowCalculated.ql +++ b/cpp/ql/src/Critical/OverflowCalculated.ql @@ -18,7 +18,7 @@ class MallocCall extends FunctionCall { Expr getAllocatedSize() { if this.getArgument(0) instanceof VariableAccess then - exists(LocalScopeVariable v, ControlFlowNode def | + exists(StackVariable v, ControlFlowNode def | definitionUsePair(v, def, this.getArgument(0)) and exprDefinition(v, def, result) ) diff --git a/cpp/ql/src/Critical/ReturnStackAllocatedObject.ql b/cpp/ql/src/Critical/ReturnStackAllocatedObject.ql index 6d5cf2a58cc..353e51daa71 100644 --- a/cpp/ql/src/Critical/ReturnStackAllocatedObject.ql +++ b/cpp/ql/src/Critical/ReturnStackAllocatedObject.ql @@ -20,11 +20,10 @@ class ReturnPointsToExpr extends PointsToExpr { ReturnStmt getReturnStmt() { result.getExpr().getFullyConverted() = this } } -from ReturnPointsToExpr ret, LocalVariable local, float confidence +from ReturnPointsToExpr ret, StackVariable local, float confidence where ret.pointsTo() = local and ret.getReturnStmt().getEnclosingFunction() = local.getFunction() and - not local.isStatic() and confidence = ret.confidence() and confidence > 0.01 select ret, diff --git a/cpp/ql/src/Critical/Unused.ql b/cpp/ql/src/Critical/Unused.ql index 8046d47c746..89ebde29171 100644 --- a/cpp/ql/src/Critical/Unused.ql +++ b/cpp/ql/src/Critical/Unused.ql @@ -20,11 +20,10 @@ class ScopeUtilityClass extends Class { Call getAUse() { result = this.getAConstructor().getACallToThisFunction() } } -from LocalScopeVariable v, ControlFlowNode def +from StackVariable v, ControlFlowNode def where definition(v, def) and not definitionUsePair(v, def, _) and - not v.isStatic() and not v.getAnAccess().isAddressOfAccess() and // parameter initializers are not in the call-graph at the moment not v.(Parameter).getInitializer().getExpr() = def and diff --git a/cpp/ql/src/Critical/UseAfterFree.ql b/cpp/ql/src/Critical/UseAfterFree.ql index 9efbb6c3b44..8fd228ca7e4 100644 --- a/cpp/ql/src/Critical/UseAfterFree.ql +++ b/cpp/ql/src/Critical/UseAfterFree.ql @@ -10,10 +10,10 @@ */ import cpp -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability /** `e` is an expression that frees the memory pointed to by `v`. */ -predicate isFreeExpr(Expr e, LocalScopeVariable v) { +predicate isFreeExpr(Expr e, StackVariable v) { exists(VariableAccess va | va.getTarget() = v | exists(FunctionCall fc | fc = e | fc.getTarget().hasGlobalOrStdName("free") and @@ -27,7 +27,7 @@ predicate isFreeExpr(Expr e, LocalScopeVariable v) { } /** `e` is an expression that (may) dereference `v`. */ -predicate isDerefExpr(Expr e, LocalScopeVariable v) { +predicate isDerefExpr(Expr e, StackVariable v) { v.getAnAccess() = e and dereferenced(e) or isDerefByCallExpr(_, _, e, v) @@ -39,27 +39,27 @@ predicate isDerefExpr(Expr e, LocalScopeVariable v) { * or a source code function that dereferences the relevant * parameter. */ -predicate isDerefByCallExpr(Call c, int i, VariableAccess va, LocalScopeVariable v) { +predicate isDerefByCallExpr(Call c, int i, VariableAccess va, StackVariable v) { v.getAnAccess() = va and va = c.getAnArgumentSubExpr(i) and not c.passesByReference(i, va) and (c.getTarget().hasEntryPoint() implies isDerefExpr(_, c.getTarget().getParameter(i))) } -class UseAfterFreeReachability extends LocalScopeVariableReachability { +class UseAfterFreeReachability extends StackVariableReachability { UseAfterFreeReachability() { this = "UseAfterFree" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { isFreeExpr(node, v) } + override predicate isSource(ControlFlowNode node, StackVariable v) { isFreeExpr(node, v) } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { isDerefExpr(node, v) } + override predicate isSink(ControlFlowNode node, StackVariable v) { isDerefExpr(node, v) } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { + override predicate isBarrier(ControlFlowNode node, StackVariable v) { definitionBarrier(v, node) or isFreeExpr(node, v) } } -from UseAfterFreeReachability r, LocalScopeVariable v, Expr free, Expr e +from UseAfterFreeReachability r, StackVariable v, Expr free, Expr e where r.reaches(free, v, e) select e, "Memory pointed to by '" + v.getName().toString() + "' may have been previously freed $@", free, "here" diff --git a/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.qhelp b/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.qhelp index 621ae3273fd..7907df47957 100644 --- a/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.qhelp +++ b/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.qhelp @@ -18,49 +18,39 @@ optimizing compiler.

Solutions to this problem can be thought of as falling into one of two -categories: (1) rewrite the signed expression so that overflow cannot occur -but the signedness remains, or (2) rewrite (or cast) the signed expression -into unsigned form. +categories:

-

-Below we list examples of expressions where signed overflow may -occur, along with proposed solutions. The list should not be -considered exhaustive. -

+
    +
  1. Rewrite the signed expression so that overflow cannot occur +but the signedness remains.
    2. +
  2. Change the variables and all their uses to be unsigned.
    3. +

-Given unsigned short i, delta and i + delta < i, -it is possible to rewrite it as (unsigned short)(i + delta) < i. -Note that i + deltadoes not actually overflow, due to int promotion +The following cases all fall into the first category.

-

-Given unsigned short i, delta and i + delta < i, -it is also possible to rewrite it as USHORT_MAX - delta. It must be true -that delta > 0 and the limits.h or climits +

    +
  1. +Given unsigned short n1, delta and n1 + delta < n1, +it is possible to rewrite it as (unsigned short)(n1 + delta) < n1. +Note that n1 + delta does not actually overflow, due to int promotion. +
    2. + +
  2. +Given unsigned short n1, delta and n1 + delta < n1, +it is also possible to rewrite it as n1 > USHORT_MAX - delta. The +limits.h or climits header must then be included. +
    3. + +
  3. +Given int n1, delta and n1 + delta < n1, +it is possible to rewrite it as n1 > INT_MAX - delta. It must be true +that delta >= 0 and the limits.h or climits header has been included. -

    - -

    -Given int i, delta and i + delta < i, -it is possible to rewrite it as INT_MAX - delta. It must be true -that delta > 0 and the limits.h or climits -header has been included. -

    - -

    -Given int i, delta and i + delta < i, -it is also possible to rewrite it as (unsigned)i + delta < i. -Note that program semantics are affected by this change. -

    - -

    -Given int i, delta and i + delta < i, -it is also possible to rewrite it as unsigned int i, delta and -i + delta < i. Note that program semantics are -affected by this change. -

    +
    4. +
 @@ -68,7 +58,7 @@ affected by this change. In the following example, even though delta has been declared unsigned short, C/C++ type promotion rules require that its type is promoted to the larger type used in the addition and comparison, -namely a signed int. Addition is performed on +namely a signed int. Addition is performed on signed integers, and may have undefined behavior if an overflow occurs. As a result, the entire (comparison) expression may also have an undefined result. @@ -87,10 +77,10 @@ are avoided.

In the following example, even though both n and delta -have been declared unsigned short, both are promoted to +have been declared unsigned short, both are promoted to signed int prior to addition. Because we started out with the narrower short type, the addition is guaranteed not to overflow -and is therefore defined. But the fact that n1 + delta never +and is therefore defined. But the fact that n1 + delta never overflows means that the condition n1 + delta < n1 will never hold true, which likely is not what the programmer intended. (see also the cpp/bad-addition-overflow-check query). @@ -98,7 +88,7 @@ hold true, which likely is not what the programmer intended. (see also the

The next example provides a solution to the previous one. Even though -i + delta does not overflow, casting it to an +n1 + delta does not overflow, casting it to an unsigned short truncates the addition modulo 2^16, so that unsigned short "wrap around" may now be observed. Furthermore, since the left-hand side is now of type unsigned short, diff --git a/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.ql b/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.ql index ce1a8149c40..1cc7b74375d 100644 --- a/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.ql +++ b/cpp/ql/src/Likely Bugs/Arithmetic/SignedOverflowCheck.ql @@ -14,6 +14,7 @@ import cpp private import semmle.code.cpp.valuenumbering.GlobalValueNumbering private import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis +private import semmle.code.cpp.commons.Exclusions from RelationalOperation ro, AddExpr add, Expr expr1, Expr expr2 where @@ -22,7 +23,7 @@ where ro.getAnOperand() = expr2 and globalValueNumber(expr1) = globalValueNumber(expr2) and add.getUnspecifiedType().(IntegralType).isSigned() and - not exists(MacroInvocation mi | mi.getAnAffectedElement() = add) and + not isFromMacroDefinition(ro) and exprMightOverflowPositively(add) and exists(Compilation c | c.getAFileCompiled() = ro.getFile() | not c.getAnArgument() = "-fwrapv" and diff --git a/cpp/ql/src/Likely Bugs/Format/SnprintfOverflow.ql b/cpp/ql/src/Likely Bugs/Format/SnprintfOverflow.ql index 6a0098df131..029f11dd8c6 100644 --- a/cpp/ql/src/Likely Bugs/Format/SnprintfOverflow.ql +++ b/cpp/ql/src/Likely Bugs/Format/SnprintfOverflow.ql @@ -37,7 +37,7 @@ predicate flowsToExprImpl(Expr source, Expr sink, boolean pathMightOverflow) { pathMightOverflow = false and source.(FunctionCall).getTarget().(Snprintf).returnsFullFormatLength() or - exists(RangeSsaDefinition def, LocalScopeVariable v | + exists(RangeSsaDefinition def, StackVariable v | flowsToDef(source, def, v, pathMightOverflow) and sink = def.getAUse(v) ) @@ -63,9 +63,7 @@ predicate flowsToExprImpl(Expr source, Expr sink, boolean pathMightOverflow) { * `pathMightOverflow` is true if there is an arithmetic operation * on the path that might overflow. */ -predicate flowsToDef( - Expr source, RangeSsaDefinition def, LocalScopeVariable v, boolean pathMightOverflow -) { +predicate flowsToDef(Expr source, RangeSsaDefinition def, StackVariable v, boolean pathMightOverflow) { // Might the current definition overflow? exists(boolean otherMightOverflow | flowsToDefImpl(source, def, v, otherMightOverflow) | if defMightOverflow(def, v) @@ -86,7 +84,7 @@ predicate flowsToDef( * the path. But it is a good way to reduce the number of false positives. */ predicate flowsToDefImpl( - Expr source, RangeSsaDefinition def, LocalScopeVariable v, boolean pathMightOverflow + Expr source, RangeSsaDefinition def, StackVariable v, boolean pathMightOverflow ) { // Assignment or initialization: `e = v;` exists(Expr e | diff --git a/cpp/ql/src/Likely Bugs/Likely Typos/AssignWhereCompareMeant.ql b/cpp/ql/src/Likely Bugs/Likely Typos/AssignWhereCompareMeant.ql index 368171a1359..c25febfc6b7 100644 --- a/cpp/ql/src/Likely Bugs/Likely Typos/AssignWhereCompareMeant.ql +++ b/cpp/ql/src/Likely Bugs/Likely Typos/AssignWhereCompareMeant.ql @@ -12,24 +12,24 @@ */ import cpp -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability -class UndefReachability extends LocalScopeVariableReachability { +class UndefReachability extends StackVariableReachability { UndefReachability() { this = "UndefReachability" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSource(ControlFlowNode node, StackVariable v) { candidateVariable(v) and node = v.getParentScope() and not v instanceof Parameter and not v.hasInitializer() } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSink(ControlFlowNode node, StackVariable v) { candidateVariable(v) and node = v.getAnAccess() } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { + override predicate isBarrier(ControlFlowNode node, StackVariable v) { node.(AssignExpr).getLValue() = v.getAnAccess() } } diff --git a/cpp/ql/src/Likely Bugs/Memory Management/ImproperNullTermination.ql b/cpp/ql/src/Likely Bugs/Memory Management/ImproperNullTermination.ql index 54392d105a6..2a4b2d16507 100644 --- a/cpp/ql/src/Likely Bugs/Memory Management/ImproperNullTermination.ql +++ b/cpp/ql/src/Likely Bugs/Memory Management/ImproperNullTermination.ql @@ -11,7 +11,7 @@ */ import cpp -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability import semmle.code.cpp.commons.NullTermination /** @@ -22,10 +22,10 @@ DeclStmt declWithNoInit(LocalVariable v) { not exists(v.getInitializer()) } -class ImproperNullTerminationReachability extends LocalScopeVariableReachabilityWithReassignment { +class ImproperNullTerminationReachability extends StackVariableReachabilityWithReassignment { ImproperNullTerminationReachability() { this = "ImproperNullTerminationReachability" } - override predicate isSourceActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSourceActual(ControlFlowNode node, StackVariable v) { node = declWithNoInit(v) or exists(Call c, VariableAccess va | @@ -36,12 +36,12 @@ class ImproperNullTerminationReachability extends LocalScopeVariableReachability ) } - override predicate isSinkActual(ControlFlowNode node, LocalScopeVariable v) { + override predicate isSinkActual(ControlFlowNode node, StackVariable v) { node.(VariableAccess).getTarget() = v and variableMustBeNullTerminated(node) } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { + override predicate isBarrier(ControlFlowNode node, StackVariable v) { exprDefinition(v, node, _) or mayAddNullTerminator(node, v.getAnAccess()) or isSinkActual(node, v) // only report first use diff --git a/cpp/ql/src/Likely Bugs/Memory Management/ReturnStackAllocatedMemory.ql b/cpp/ql/src/Likely Bugs/Memory Management/ReturnStackAllocatedMemory.ql index d10addadca9..fc06ed0a500 100644 --- a/cpp/ql/src/Likely Bugs/Memory Management/ReturnStackAllocatedMemory.ql +++ b/cpp/ql/src/Likely Bugs/Memory Management/ReturnStackAllocatedMemory.ql @@ -42,10 +42,8 @@ predicate hasNontrivialConversion(Expr e) { hasNontrivialConversion(e.getConversion()) } -from LocalScopeVariable var, VariableAccess va, ReturnStmt r +from StackVariable var, VariableAccess va, ReturnStmt r where - not var.isStatic() and - not var.isThreadLocal() and not var.getUnspecifiedType() instanceof ReferenceType and not r.isFromUninstantiatedTemplate(_) and va = var.getAnAccess() and diff --git a/cpp/ql/src/Likely Bugs/Memory Management/UninitializedLocal.ql b/cpp/ql/src/Likely Bugs/Memory Management/UninitializedLocal.ql index e213e9e461d..57dac90c850 100644 --- a/cpp/ql/src/Likely Bugs/Memory Management/UninitializedLocal.ql +++ b/cpp/ql/src/Likely Bugs/Memory Management/UninitializedLocal.ql @@ -12,7 +12,7 @@ */ import cpp -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability /** * Auxiliary predicate: Types that don't require initialization @@ -40,23 +40,17 @@ DeclStmt declWithNoInit(LocalVariable v) { result.getADeclaration() = v and not exists(v.getInitializer()) and /* The type of the variable is not stack-allocated. */ - not allocatedType(v.getType()) and - /* The variable is not static (otherwise it is zeroed). */ - not v.isStatic() and - /* The variable is not extern (otherwise it is zeroed). */ - not v.hasSpecifier("extern") + not allocatedType(v.getType()) } -class UninitialisedLocalReachability extends LocalScopeVariableReachability { +class UninitialisedLocalReachability extends StackVariableReachability { UninitialisedLocalReachability() { this = "UninitialisedLocal" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { - node = declWithNoInit(v) - } + override predicate isSource(ControlFlowNode node, StackVariable v) { node = declWithNoInit(v) } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { useOfVarActual(v, node) } + override predicate isSink(ControlFlowNode node, StackVariable v) { useOfVarActual(v, node) } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { + override predicate isBarrier(ControlFlowNode node, StackVariable v) { // only report the _first_ possibly uninitialized use useOfVarActual(v, node) or definitionBarrier(v, node) diff --git a/cpp/ql/src/Likely Bugs/Underspecified Functions/MistypedFunctionArguments.ql b/cpp/ql/src/Likely Bugs/Underspecified Functions/MistypedFunctionArguments.ql index 1142cc1a45b..e137e90c716 100644 --- a/cpp/ql/src/Likely Bugs/Underspecified Functions/MistypedFunctionArguments.ql +++ b/cpp/ql/src/Likely Bugs/Underspecified Functions/MistypedFunctionArguments.ql @@ -84,10 +84,10 @@ predicate hasZeroParamDecl(Function f) { } // True if this file (or header) was compiled as a C file -predicate isCompiledAsC(Function f) { - exists(File file | file.compiledAsC() | - file = f.getFile() or file.getAnIncludedFile+() = f.getFile() - ) +predicate isCompiledAsC(File f) { + f.compiledAsC() + or + exists(File src | isCompiledAsC(src) | src.getAnIncludedFile() = f) } from FunctionCall fc, Function f, Parameter p @@ -95,7 +95,7 @@ where f = fc.getTarget() and p = f.getAParameter() and hasZeroParamDecl(f) and - isCompiledAsC(f) and + isCompiledAsC(f.getFile()) and not f.isVarargs() and not f instanceof BuiltInFunction and p.getIndex() < fc.getNumberOfArguments() and diff --git a/cpp/ql/src/Likely Bugs/Underspecified Functions/TooFewArguments.ql b/cpp/ql/src/Likely Bugs/Underspecified Functions/TooFewArguments.ql index a3e78fe61c4..705c1ec4dc8 100644 --- a/cpp/ql/src/Likely Bugs/Underspecified Functions/TooFewArguments.ql +++ b/cpp/ql/src/Likely Bugs/Underspecified Functions/TooFewArguments.ql @@ -24,10 +24,10 @@ predicate hasZeroParamDecl(Function f) { } // True if this file (or header) was compiled as a C file -predicate isCompiledAsC(Function f) { - exists(File file | file.compiledAsC() | - file = f.getFile() or file.getAnIncludedFile+() = f.getFile() - ) +predicate isCompiledAsC(File f) { + f.compiledAsC() + or + exists(File src | isCompiledAsC(src) | src.getAnIncludedFile() = f) } from FunctionCall fc, Function f @@ -36,7 +36,7 @@ where not f.isVarargs() and not f instanceof BuiltInFunction and hasZeroParamDecl(f) and - isCompiledAsC(f) and + isCompiledAsC(f.getFile()) and // There is an explicit declaration of the function whose parameter count is larger // than the number of call arguments exists(FunctionDeclarationEntry fde | fde = f.getADeclarationEntry() | diff --git a/cpp/ql/src/Likely Bugs/Underspecified Functions/TooManyArguments.ql b/cpp/ql/src/Likely Bugs/Underspecified Functions/TooManyArguments.ql index b0bd7746c15..59368236bbd 100644 --- a/cpp/ql/src/Likely Bugs/Underspecified Functions/TooManyArguments.ql +++ b/cpp/ql/src/Likely Bugs/Underspecified Functions/TooManyArguments.ql @@ -25,10 +25,10 @@ predicate hasZeroParamDecl(Function f) { } // True if this file (or header) was compiled as a C file -predicate isCompiledAsC(Function f) { - exists(File file | file.compiledAsC() | - file = f.getFile() or file.getAnIncludedFile+() = f.getFile() - ) +predicate isCompiledAsC(File f) { + f.compiledAsC() + or + exists(File src | isCompiledAsC(src) | src.getAnIncludedFile() = f) } from FunctionCall fc, Function f @@ -36,7 +36,7 @@ where f = fc.getTarget() and not f.isVarargs() and hasZeroParamDecl(f) and - isCompiledAsC(f) and + isCompiledAsC(f.getFile()) and exists(f.getBlock()) and // There must not exist a declaration with the number of parameters // at least as large as the number of call arguments diff --git a/cpp/ql/src/Security/CWE/CWE-129/ImproperArrayIndexValidation.ql b/cpp/ql/src/Security/CWE/CWE-129/ImproperArrayIndexValidation.ql index 3d7379be507..c073cf37af8 100644 --- a/cpp/ql/src/Security/CWE/CWE-129/ImproperArrayIndexValidation.ql +++ b/cpp/ql/src/Security/CWE/CWE-129/ImproperArrayIndexValidation.ql @@ -16,7 +16,7 @@ private import semmle.code.cpp.rangeanalysis.RangeAnalysisUtils import semmle.code.cpp.security.TaintTracking predicate hasUpperBound(VariableAccess offsetExpr) { - exists(BasicBlock controlled, LocalScopeVariable offsetVar, SsaDefinition def | + exists(BasicBlock controlled, StackVariable offsetVar, SsaDefinition def | controlled.contains(offsetExpr) and linearBoundControls(controlled, def, offsetVar) and offsetExpr = def.getAUse(offsetVar) @@ -24,7 +24,7 @@ predicate hasUpperBound(VariableAccess offsetExpr) { } pragma[noinline] -predicate linearBoundControls(BasicBlock controlled, SsaDefinition def, LocalScopeVariable offsetVar) { +predicate linearBoundControls(BasicBlock controlled, SsaDefinition def, StackVariable offsetVar) { exists(GuardCondition guard, boolean branch | guard.controls(controlled, branch) and cmpWithLinearBound(guard, def.getAUse(offsetVar), Lesser(), branch) diff --git a/cpp/ql/src/Security/CWE/CWE-190/ComparisonWithWiderType.ql b/cpp/ql/src/Security/CWE/CWE-190/ComparisonWithWiderType.ql index 92f679a0f1f..aebaca36ad0 100644 --- a/cpp/ql/src/Security/CWE/CWE-190/ComparisonWithWiderType.ql +++ b/cpp/ql/src/Security/CWE/CWE-190/ComparisonWithWiderType.ql @@ -44,7 +44,7 @@ Element friendlyLoc(Expr e) { not e instanceof Access and not e instanceof Call and result = e } -from Loop l, RelationalOperation rel, Expr small, Expr large +from Loop l, RelationalOperation rel, VariableAccess small, Expr large where small = rel.getLesserOperand() and large = rel.getGreaterOperand() and @@ -60,7 +60,7 @@ where not getComparisonSize(large.(SubExpr).getLeftOperand().getExplicitlyConverted()) <= getComparisonSize(small) and not getComparisonSize(large.(RShiftExpr).getLeftOperand().getExplicitlyConverted()) <= getComparisonSize(small) and // ignore loop-invariant smaller variables - loopVariant(small.getAChild*(), l) + loopVariant(small, l) select rel, "Comparison between $@ of type " + small.getType().getName() + " and $@ of wider type " + large.getType().getName() + ".", friendlyLoc(small), small.toString(), friendlyLoc(large), diff --git a/cpp/ql/src/Security/CWE/CWE-367/TOCTOUFilesystemRace.ql b/cpp/ql/src/Security/CWE/CWE-367/TOCTOUFilesystemRace.ql index 67b2f5c7eef..052cce56198 100644 --- a/cpp/ql/src/Security/CWE/CWE-367/TOCTOUFilesystemRace.ql +++ b/cpp/ql/src/Security/CWE/CWE-367/TOCTOUFilesystemRace.ql @@ -82,7 +82,7 @@ FunctionCall stat(Expr path, Expr buf) { predicate referenceTo(Expr source, Expr use) { source = use or - exists(SsaDefinition def, LocalScopeVariable v | + exists(SsaDefinition def, StackVariable v | def.getAnUltimateDefiningValue(v) = source and def.getAUse(v) = use ) } @@ -109,9 +109,7 @@ where ) ) and // checkUse and opUse refer to the same SSA variable - exists(SsaDefinition def, LocalScopeVariable v | - def.getAUse(v) = checkUse and def.getAUse(v) = opUse - ) and + exists(SsaDefinition def, StackVariable v | def.getAUse(v) = checkUse and def.getAUse(v) = opUse) and // opUse looks like an operation on a filename fc = filenameOperation(opUse) and // the return value of check is used (possibly with one step of diff --git a/cpp/ql/src/Security/CWE/CWE-468/IncorrectPointerScalingCommon.qll b/cpp/ql/src/Security/CWE/CWE-468/IncorrectPointerScalingCommon.qll index e2756de18fd..4854c1dc38e 100644 --- a/cpp/ql/src/Security/CWE/CWE-468/IncorrectPointerScalingCommon.qll +++ b/cpp/ql/src/Security/CWE/CWE-468/IncorrectPointerScalingCommon.qll @@ -100,9 +100,9 @@ Type baseType(Type t) { */ predicate exprSourceType(Expr use, Type sourceType, Location sourceLoc) { // Reaching definitions. - if exists(SsaDefinition def, LocalScopeVariable v | use = def.getAUse(v)) + if exists(SsaDefinition def, StackVariable v | use = def.getAUse(v)) then - exists(SsaDefinition def, LocalScopeVariable v | use = def.getAUse(v) | + exists(SsaDefinition def, StackVariable v | use = def.getAUse(v) | defSourceType(def, v, sourceType, sourceLoc) ) else @@ -137,7 +137,7 @@ predicate exprSourceType(Expr use, Type sourceType, Location sourceLoc) { * Holds if there is a pointer expression with type `sourceType` at * location `sourceLoc` which might define the value of `v` at `def`. */ -predicate defSourceType(SsaDefinition def, LocalScopeVariable v, Type sourceType, Location sourceLoc) { +predicate defSourceType(SsaDefinition def, StackVariable v, Type sourceType, Location sourceLoc) { exprSourceType(def.getDefiningValue(v), sourceType, sourceLoc) or defSourceType(def.getAPhiInput(v), v, sourceType, sourceLoc) diff --git a/cpp/ql/src/jsf/4.13 Functions/AV Rule 111.ql b/cpp/ql/src/jsf/4.13 Functions/AV Rule 111.ql index 8c62c5763aa..8cdeb486c1f 100644 --- a/cpp/ql/src/jsf/4.13 Functions/AV Rule 111.ql +++ b/cpp/ql/src/jsf/4.13 Functions/AV Rule 111.ql @@ -20,10 +20,9 @@ class ReturnPointsToExpr extends PointsToExpr { ReturnStmt getReturnStmt() { result.getExpr() = this } } -from ReturnPointsToExpr ret, LocalVariable dest +from ReturnPointsToExpr ret, StackVariable dest where ret.pointsTo() = dest and - ret.getReturnStmt().getParentStmt().getEnclosingFunction() = dest.getFunction() and - not dest.isStatic() + ret.getReturnStmt().getParentStmt().getEnclosingFunction() = dest.getFunction() select ret.getReturnStmt(), "AV Rule 111: A function shall not return a pointer or reference to a non-static local object." diff --git a/cpp/ql/src/semmle/code/cpp/Enclosing.qll b/cpp/ql/src/semmle/code/cpp/Enclosing.qll index b56f7219d07..07d39b10e83 100644 --- a/cpp/ql/src/semmle/code/cpp/Enclosing.qll +++ b/cpp/ql/src/semmle/code/cpp/Enclosing.qll @@ -13,6 +13,11 @@ Element stmtEnclosingElement(Stmt s) { /** * Gets the enclosing element of expression `e`. */ +// The `pragma[nomagic]` is a workaround to prevent this cached stage (and all +// subsequent stages) from being evaluated twice. See QL-888. It has the effect +// of making the `Conversion` class predicate get the same optimization in all +// queries. +pragma[nomagic] cached Element exprEnclosingElement(Expr e) { result = exprEnclosingElement(e.getParent()) diff --git a/cpp/ql/src/semmle/code/cpp/Variable.qll b/cpp/ql/src/semmle/code/cpp/Variable.qll index 194cc5333c7..221a77f1a40 100644 --- a/cpp/ql/src/semmle/code/cpp/Variable.qll +++ b/cpp/ql/src/semmle/code/cpp/Variable.qll @@ -307,8 +307,8 @@ class ParameterDeclarationEntry extends VariableDeclarationEntry { * } * ``` * - * Local variables can be static; use the `isStatic` member predicate to - * detect those. + * See also `StackVariable`, which is the class of local-scope variables + * without statics and thread-locals. */ class LocalScopeVariable extends Variable, @localscopevariable { /** Gets the function to which this variable belongs. */ @@ -316,12 +316,21 @@ class LocalScopeVariable extends Variable, @localscopevariable { } /** - * DEPRECATED: use `LocalScopeVariable` instead. + * A C/C++ variable with _automatic storage duration_. In other words, a + * function parameter or a local variable that is not static or thread-local. + * For example, the variables `a` and `b` in the following code. + * ``` + * void myFunction(int a) { + * int b; + * static int c; + * } + * ``` */ -deprecated class StackVariable extends Variable { - StackVariable() { this instanceof LocalScopeVariable } - - Function getFunction() { result = this.(LocalScopeVariable).getFunction() } +class StackVariable extends LocalScopeVariable { + StackVariable() { + not this.isStatic() and + not this.isThreadLocal() + } } /** @@ -496,7 +505,7 @@ class TemplateVariable extends Variable { * `myTemplateFunction`: * ``` * void myFunction() { - * T a; + * float a; * } * * template @@ -509,9 +518,6 @@ class TemplateVariable extends Variable { * myTemplateFunction(); * ``` */ -class SemanticStackVariable extends LocalScopeVariable { - SemanticStackVariable() { - not this.isStatic() and - not this.isFromUninstantiatedTemplate(_) - } +class SemanticStackVariable extends StackVariable { + SemanticStackVariable() { not this.isFromUninstantiatedTemplate(_) } } diff --git a/cpp/ql/src/semmle/code/cpp/commons/Exclusions.qll b/cpp/ql/src/semmle/code/cpp/commons/Exclusions.qll index cae647982d2..a0dfea20046 100644 --- a/cpp/ql/src/semmle/code/cpp/commons/Exclusions.qll +++ b/cpp/ql/src/semmle/code/cpp/commons/Exclusions.qll @@ -94,11 +94,18 @@ predicate functionContainsPreprocCode(Function f) { * ``` */ predicate isFromMacroDefinition(Element e) { - exists(MacroInvocation mi | - // e is in mi + exists(MacroInvocation mi, Location eLocation, Location miLocation | mi.getAnExpandedElement() = e and - // and e was apparently not passed in as a macro parameter - e.getLocation().getStartLine() = mi.getLocation().getStartLine() and - e.getLocation().getStartColumn() = mi.getLocation().getStartColumn() + eLocation = e.getLocation() and + miLocation = mi.getLocation() and + // If the location of `e` coincides with the macro invocation, then `e` did + // not come from a macro argument. The inequalities here could also be + // equalities, but that confuses the join orderer into joining on the source + // locations too early. + // There are cases where the start location of a non-argument element comes + // right after the invocation's open parenthesis, so it appears to be more + // robust to match on the end location instead. + eLocation.getEndLine() >= miLocation.getEndLine() and + eLocation.getEndColumn() >= miLocation.getEndColumn() ) } diff --git a/cpp/ql/src/semmle/code/cpp/commons/NullTermination.qll b/cpp/ql/src/semmle/code/cpp/commons/NullTermination.qll index 650e2bc9954..38add4ab5ef 100644 --- a/cpp/ql/src/semmle/code/cpp/commons/NullTermination.qll +++ b/cpp/ql/src/semmle/code/cpp/commons/NullTermination.qll @@ -3,7 +3,7 @@ private import semmle.code.cpp.models.interfaces.ArrayFunction private import semmle.code.cpp.models.implementations.Strcat private predicate mayAddNullTerminatorHelper(Expr e, VariableAccess va, Expr e0) { - exists(LocalScopeVariable v0, Expr val | + exists(StackVariable v0, Expr val | exprDefinition(v0, e, val) and val.getAChild*() = va and mayAddNullTerminator(e0, v0.getAnAccess()) @@ -41,7 +41,7 @@ predicate mayAddNullTerminator(Expr e, VariableAccess va) { or // Assignment to non-stack variable exists(AssignExpr ae | e = ae | - not ae.getLValue().(VariableAccess).getTarget() instanceof LocalScopeVariable and + not ae.getLValue().(VariableAccess).getTarget() instanceof StackVariable and ae.getRValue().getAChild*() = va ) or diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/DefinitionsAndUses.qll b/cpp/ql/src/semmle/code/cpp/controlflow/DefinitionsAndUses.qll index 0bac436d16e..1ab33c9a25c 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/DefinitionsAndUses.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/DefinitionsAndUses.qll @@ -1,5 +1,5 @@ import cpp -private import semmle.code.cpp.controlflow.LocalScopeVariableReachability +private import semmle.code.cpp.controlflow.StackVariableReachability private import semmle.code.cpp.dataflow.EscapesTree /** @@ -108,7 +108,7 @@ library class DefOrUse extends ControlFlowNodeBase { /* * Implementation detail: this predicate and its private auxiliary * predicates are instances of the more general predicates in - * LocalScopeVariableReachability.qll, and should be kept in sync. + * StackVariableReachability.qll, and should be kept in sync. * * Unfortunately, caching of abstract predicates does not work well, so the * predicates are duplicated for now. diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/Guards.qll b/cpp/ql/src/semmle/code/cpp/controlflow/Guards.qll index c64f724975d..007c1f2ecfc 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/Guards.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/Guards.qll @@ -371,7 +371,7 @@ private int int_value(Expr e) { /** An `SsaDefinition` with an additional predicate `isLt`. */ class GuardedSsa extends SsaDefinition { /** Holds if this `SsaDefinition` is guarded such that `this(var) < gt + k` is `testIsTrue` in `block`. */ - predicate isLt(LocalScopeVariable var, Expr gt, int k, BasicBlock block, boolean testIsTrue) { + predicate isLt(StackVariable var, Expr gt, int k, BasicBlock block, boolean testIsTrue) { exists(Expr luse, GuardCondition test | this.getAUse(var) = luse | test.ensuresLt(luse, gt, k, block, testIsTrue) ) diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll b/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll index 117854d39e6..32857146029 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll @@ -1,6 +1,12 @@ +/** + * DEPRECATED: Use `StackVariableReachability` instead. + */ + import cpp /** + * DEPRECATED: Use `StackVariableReachability` instead. + * * A reachability analysis for control-flow nodes involving stack variables. * This defines sources, sinks, and any other configurable aspect of the * analysis. Multiple analyses can coexist. To create an analysis, extend this @@ -18,7 +24,7 @@ import cpp * Then, to query whether there is flow between some source and sink, call the * `reaches` predicate on an instance of `MyAnalysisConfiguration`. */ -abstract class LocalScopeVariableReachability extends string { +abstract deprecated class LocalScopeVariableReachability extends string { bindingset[this] LocalScopeVariableReachability() { length() >= 0 } @@ -207,6 +213,8 @@ predicate bbSuccessorEntryReachesLoopInvariant( } /** + * DEPRECATED: Use `StackVariableReachabilityWithReassignment` instead. + * * Reachability analysis for control-flow nodes involving stack variables. * Unlike `LocalScopeVariableReachability`, this analysis takes variable * reassignments into account. @@ -216,7 +224,7 @@ predicate bbSuccessorEntryReachesLoopInvariant( * `isSource` and `isSink`, and that there is a `reachesTo` predicate in * addition to `reaches`. */ -abstract class LocalScopeVariableReachabilityWithReassignment extends LocalScopeVariableReachability { +abstract deprecated class LocalScopeVariableReachabilityWithReassignment extends LocalScopeVariableReachability { bindingset[this] LocalScopeVariableReachabilityWithReassignment() { length() >= 0 } @@ -314,12 +322,14 @@ abstract class LocalScopeVariableReachabilityWithReassignment extends LocalScope } /** + * DEPRECATED: Use `StackVariableReachabilityExt` instead. + * * Same as `LocalScopeVariableReachability`, but `isBarrier` works on control-flow * edges rather than nodes and is therefore parameterized by the original * source node as well. Otherwise, this class is used like * `LocalScopeVariableReachability`. */ -abstract class LocalScopeVariableReachabilityExt extends string { +abstract deprecated class LocalScopeVariableReachabilityExt extends string { bindingset[this] LocalScopeVariableReachabilityExt() { length() >= 0 } diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/SSA.qll b/cpp/ql/src/semmle/code/cpp/controlflow/SSA.qll index 8384a5b3c66..4e2e018eda3 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/SSA.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/SSA.qll @@ -9,11 +9,11 @@ library class StandardSSA extends SSAHelper { /** * A definition of one or more SSA variables, including phi node definitions. * An _SSA variable_, as defined in the literature, is effectively the pair of - * an `SsaDefinition d` and a `LocalScopeVariable v`, written `(d, v)` in this + * an `SsaDefinition d` and a `StackVariable v`, written `(d, v)` in this * documentation. Note that definitions and uses can be coincident due to the * presence of parameter definitions and phi nodes. * - * Not all `LocalScopeVariable`s of a function have SSA definitions. If the variable + * Not all `StackVariable`s of a function have SSA definitions. If the variable * has its address taken, either explicitly or implicitly, then it is excluded * from analysis. `SsaDefinition`s are not generated in locations that are * statically seen to be unreachable. @@ -22,21 +22,19 @@ class SsaDefinition extends ControlFlowNodeBase { SsaDefinition() { exists(StandardSSA x | x.ssa_defn(_, this, _, _)) } /** - * Gets a variable corresponding to an SSA LocalScopeVariable defined by + * Gets a variable corresponding to an SSA StackVariable defined by * this definition. */ - LocalScopeVariable getAVariable() { exists(StandardSSA x | x.ssa_defn(result, this, _, _)) } + StackVariable getAVariable() { exists(StandardSSA x | x.ssa_defn(result, this, _, _)) } /** * Gets a string representation of the SSA variable represented by the pair * `(this, v)`. */ - string toString(LocalScopeVariable v) { exists(StandardSSA x | result = x.toString(this, v)) } + string toString(StackVariable v) { exists(StandardSSA x | result = x.toString(this, v)) } /** Gets a use of the SSA variable represented by the pair `(this, v)`. */ - VariableAccess getAUse(LocalScopeVariable v) { - exists(StandardSSA x | result = x.getAUse(this, v)) - } + VariableAccess getAUse(StackVariable v) { exists(StandardSSA x | result = x.getAUse(this, v)) } /** * Gets the control-flow node for this definition. This will usually be the @@ -55,9 +53,7 @@ class SsaDefinition extends ControlFlowNodeBase { BasicBlock getBasicBlock() { result.contains(getDefinition()) } /** Holds if this definition is a phi node for variable `v`. */ - predicate isPhiNode(LocalScopeVariable v) { - exists(StandardSSA x | x.phi_node(v, this.(BasicBlock))) - } + predicate isPhiNode(StackVariable v) { exists(StandardSSA x | x.phi_node(v, this.(BasicBlock))) } Location getLocation() { result = this.(ControlFlowNode).getLocation() } @@ -68,7 +64,7 @@ class SsaDefinition extends ControlFlowNodeBase { * Holds if the SSA variable `(result, v)` is an input to the phi definition * `(this, v)`. */ - SsaDefinition getAPhiInput(LocalScopeVariable v) { + SsaDefinition getAPhiInput(StackVariable v) { this.isPhiNode(v) and result.reachesEndOfBB(v, this.(BasicBlock).getAPredecessor()) } @@ -92,7 +88,7 @@ class SsaDefinition extends ControlFlowNodeBase { * instead covered via `definedByParameter` and `getDefinition`, * respectively. */ - Expr getDefiningValue(LocalScopeVariable v) { + Expr getDefiningValue(StackVariable v) { exists(ControlFlowNode def | def = this.getDefinition() | def = v.getInitializer().getExpr() and def = result or @@ -117,7 +113,7 @@ class SsaDefinition extends ControlFlowNodeBase { } /** Holds if `(this, v)` reaches the end of basic block `b`. */ - predicate reachesEndOfBB(LocalScopeVariable v, BasicBlock b) { + predicate reachesEndOfBB(StackVariable v, BasicBlock b) { exists(StandardSSA x | x.ssaDefinitionReachesEndOfBB(v, this, b)) } @@ -125,7 +121,7 @@ class SsaDefinition extends ControlFlowNodeBase { * Gets a definition that ultimately defines this variable and is not * itself a phi node. */ - SsaDefinition getAnUltimateSsaDefinition(LocalScopeVariable v) { + SsaDefinition getAnUltimateSsaDefinition(StackVariable v) { result = this.getAPhiInput(v).getAnUltimateSsaDefinition(v) or v = this.getAVariable() and @@ -138,7 +134,7 @@ class SsaDefinition extends ControlFlowNodeBase { * recursing backwards through phi definitions. Not all definitions have a * defining expression---see the documentation for `getDefiningValue`. */ - Expr getAnUltimateDefiningValue(LocalScopeVariable v) { + Expr getAnUltimateDefiningValue(StackVariable v) { result = this.getAnUltimateSsaDefinition(v).getDefiningValue(v) } @@ -149,7 +145,7 @@ class SsaDefinition extends ControlFlowNodeBase { * `getAnUltimateSsaDefinition` to refer to a predicate named * `getAnUltimateSsaDefinition` in this class. */ - deprecated Expr getAnUltimateDefinition(LocalScopeVariable v) { + deprecated Expr getAnUltimateDefinition(StackVariable v) { result = this.getAnUltimateDefiningValue(v) } } diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/SSAUtils.qll b/cpp/ql/src/semmle/code/cpp/controlflow/SSAUtils.qll index 5501fb0a394..b9b34a1d68c 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/SSAUtils.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/SSAUtils.qll @@ -21,11 +21,9 @@ private predicate dominanceFrontier(BasicBlock x, BasicBlock w) { } /** - * Extended version of `definition` that also includes parameters but excludes - * static variables. + * Extended version of `definition` that also includes parameters. */ -predicate var_definition(LocalScopeVariable v, ControlFlowNode node) { - not v.isStatic() and +predicate var_definition(StackVariable v, ControlFlowNode node) { not addressTakenVariable(v) and not unreachable(node) and ( @@ -51,7 +49,7 @@ predicate var_definition(LocalScopeVariable v, ControlFlowNode node) { * analysis because the pointer could be used to change the value at * any moment. */ -private predicate addressTakenVariable(LocalScopeVariable var) { +private predicate addressTakenVariable(StackVariable var) { // If the type of the variable is a reference type, then it is safe (as // far as SSA is concerned) to take its address, because this does not // enable the variable to be modified indirectly. Obviously the @@ -71,7 +69,7 @@ private predicate addressTakenVariable(LocalScopeVariable var) { ) } -private predicate isReferenceVar(LocalScopeVariable v) { +private predicate isReferenceVar(StackVariable v) { v.getUnspecifiedType() instanceof ReferenceType } @@ -79,22 +77,22 @@ private predicate isReferenceVar(LocalScopeVariable v) { * This predicate is the same as `var_definition`, but annotated with * the basic block and index of the control flow node. */ -private predicate variableUpdate(LocalScopeVariable v, ControlFlowNode n, BasicBlock b, int i) { +private predicate variableUpdate(StackVariable v, ControlFlowNode n, BasicBlock b, int i) { var_definition(v, n) and n = b.getNode(i) } -private predicate ssa_use(LocalScopeVariable v, VariableAccess node, BasicBlock b, int index) { +private predicate ssa_use(StackVariable v, VariableAccess node, BasicBlock b, int index) { useOfVar(v, node) and b.getNode(index) = node } -private predicate live_at_start_of_bb(LocalScopeVariable v, BasicBlock b) { +private predicate live_at_start_of_bb(StackVariable v, BasicBlock b) { exists(int i | ssa_use(v, _, b, i) | not exists(int j | variableUpdate(v, _, b, j) | j < i)) or live_at_exit_of_bb(v, b) and not variableUpdate(v, _, b, _) } pragma[noinline] -private predicate live_at_exit_of_bb(LocalScopeVariable v, BasicBlock b) { +private predicate live_at_exit_of_bb(StackVariable v, BasicBlock b) { live_at_start_of_bb(v, b.getASuccessor()) } @@ -110,12 +108,12 @@ library class SSAHelper extends int { * basic block `b`. */ cached - predicate custom_phi_node(LocalScopeVariable v, BasicBlock b) { none() } + predicate custom_phi_node(StackVariable v, BasicBlock b) { none() } /** * Remove any custom phi nodes that are invalid. */ - private predicate sanitized_custom_phi_node(LocalScopeVariable v, BasicBlock b) { + private predicate sanitized_custom_phi_node(StackVariable v, BasicBlock b) { custom_phi_node(v, b) and not addressTakenVariable(v) and not isReferenceVar(v) and @@ -127,7 +125,7 @@ library class SSAHelper extends int { * `b`. */ cached - predicate phi_node(LocalScopeVariable v, BasicBlock b) { + predicate phi_node(StackVariable v, BasicBlock b) { frontier_phi_node(v, b) or sanitized_custom_phi_node(v, b) } @@ -138,13 +136,13 @@ library class SSAHelper extends int { * definitions). This is known as the iterated dominance frontier. See * Modern Compiler Implementation by Andrew Appel. */ - private predicate frontier_phi_node(LocalScopeVariable v, BasicBlock b) { + private predicate frontier_phi_node(StackVariable v, BasicBlock b) { exists(BasicBlock x | dominanceFrontier(x, b) and ssa_defn_rec(v, x)) and /* We can also eliminate those nodes where the variable is not live on any incoming edge */ live_at_start_of_bb(v, b) } - private predicate ssa_defn_rec(LocalScopeVariable v, BasicBlock b) { + private predicate ssa_defn_rec(StackVariable v, BasicBlock b) { phi_node(v, b) or variableUpdate(v, _, b, _) @@ -155,7 +153,7 @@ library class SSAHelper extends int { * position `index` in block `b`. This includes definitions from phi nodes. */ cached - predicate ssa_defn(LocalScopeVariable v, ControlFlowNode node, BasicBlock b, int index) { + predicate ssa_defn(StackVariable v, ControlFlowNode node, BasicBlock b, int index) { phi_node(v, b) and b.getStart() = node and index = -1 or variableUpdate(v, node, b, index) @@ -179,7 +177,7 @@ library class SSAHelper extends int { * irrelevant indices at which there is no definition or use when traversing * basic blocks. */ - private predicate defUseRank(LocalScopeVariable v, BasicBlock b, int rankix, int i) { + private predicate defUseRank(StackVariable v, BasicBlock b, int rankix, int i) { i = rank[rankix](int j | ssa_defn(v, _, b, j) or ssa_use(v, _, b, j)) } @@ -189,7 +187,7 @@ library class SSAHelper extends int { * the extra rank at the end represents a position past the last node in * the block. */ - private int lastRank(LocalScopeVariable v, BasicBlock b) { + private int lastRank(StackVariable v, BasicBlock b) { result = max(int rankix | defUseRank(v, b, rankix, _)) + 1 } @@ -197,7 +195,7 @@ library class SSAHelper extends int { * Holds if SSA variable `(v, def)` is defined at rank index `rankix` in * basic block `b`. */ - private predicate ssaDefRank(LocalScopeVariable v, ControlFlowNode def, BasicBlock b, int rankix) { + private predicate ssaDefRank(StackVariable v, ControlFlowNode def, BasicBlock b, int rankix) { exists(int i | ssa_defn(v, def, b, i) and defUseRank(v, b, rankix, i) @@ -210,9 +208,7 @@ library class SSAHelper extends int { * `v` that comes _at or after_ the reached node. Reaching a node means * that the definition is visible to any _use_ at that node. */ - private predicate ssaDefReachesRank( - LocalScopeVariable v, ControlFlowNode def, BasicBlock b, int rankix - ) { + private predicate ssaDefReachesRank(StackVariable v, ControlFlowNode def, BasicBlock b, int rankix) { // A definition should not reach its own node unless a loop allows it. // When nodes are both definitions and uses for the same variable, the // use is understood to happen _before_ the definition. Phi nodes are @@ -227,7 +223,7 @@ library class SSAHelper extends int { /** Holds if SSA variable `(v, def)` reaches the end of block `b`. */ cached - predicate ssaDefinitionReachesEndOfBB(LocalScopeVariable v, ControlFlowNode def, BasicBlock b) { + predicate ssaDefinitionReachesEndOfBB(StackVariable v, ControlFlowNode def, BasicBlock b) { live_at_exit_of_bb(v, b) and ssaDefReachesRank(v, def, b, lastRank(v, b)) or exists(BasicBlock idom | @@ -243,7 +239,7 @@ library class SSAHelper extends int { * reaches the end of `b`. */ pragma[noinline] - private predicate noDefinitionsSinceIDominator(LocalScopeVariable v, BasicBlock idom, BasicBlock b) { + private predicate noDefinitionsSinceIDominator(StackVariable v, BasicBlock idom, BasicBlock b) { bbIDominates(idom, b) and // It is sufficient to traverse the dominator graph, cf. discussion above. live_at_exit_of_bb(v, b) and not ssa_defn(v, _, b, _) @@ -253,9 +249,7 @@ library class SSAHelper extends int { * Holds if SSA variable `(v, def)` reaches `use` within the same basic * block, where `use` is a `VariableAccess` of `v`. */ - private predicate ssaDefinitionReachesUseWithinBB( - LocalScopeVariable v, ControlFlowNode def, Expr use - ) { + private predicate ssaDefinitionReachesUseWithinBB(StackVariable v, ControlFlowNode def, Expr use) { exists(BasicBlock b, int rankix, int i | ssaDefReachesRank(v, def, b, rankix) and defUseRank(v, b, rankix, i) and @@ -266,7 +260,7 @@ library class SSAHelper extends int { /** * Holds if SSA variable `(v, def)` reaches the control-flow node `use`. */ - private predicate ssaDefinitionReaches(LocalScopeVariable v, ControlFlowNode def, Expr use) { + private predicate ssaDefinitionReaches(StackVariable v, ControlFlowNode def, Expr use) { ssaDefinitionReachesUseWithinBB(v, def, use) or exists(BasicBlock b | @@ -281,7 +275,7 @@ library class SSAHelper extends int { * `(node, v)`. */ cached - string toString(ControlFlowNode node, LocalScopeVariable v) { + string toString(ControlFlowNode node, StackVariable v) { if phi_node(v, node.(BasicBlock)) then result = "SSA phi(" + v.getName() + ")" else ( @@ -294,7 +288,7 @@ library class SSAHelper extends int { * access of `v`. */ cached - VariableAccess getAUse(ControlFlowNode def, LocalScopeVariable v) { + VariableAccess getAUse(ControlFlowNode def, StackVariable v) { ssaDefinitionReaches(v, def, result) and ssa_use(v, result, _, _) } diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/StackVariableReachability.qll b/cpp/ql/src/semmle/code/cpp/controlflow/StackVariableReachability.qll index b8ffa3344f6..696184620e3 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/StackVariableReachability.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/StackVariableReachability.qll @@ -1,11 +1,24 @@ import cpp /** - * DEPRECATED: use `LocalScopeVariableReachability` instead. - * * A reachability analysis for control-flow nodes involving stack variables. + * This defines sources, sinks, and any other configurable aspect of the + * analysis. Multiple analyses can coexist. To create an analysis, extend this + * class with a subclass whose characteristic predicate is a unique singleton + * string. For example, write + * + * ``` + * class MyAnalysisConfiguration extends StackVariableReachability { + * MyAnalysisConfiguration() { this = "MyAnalysisConfiguration" } + * // Override `isSource` and `isSink`. + * // Override `isBarrier`. + * } + * ``` + * + * Then, to query whether there is flow between some source and sink, call the + * `reaches` predicate on an instance of `MyAnalysisConfiguration`. */ -abstract deprecated class StackVariableReachability extends string { +abstract class StackVariableReachability extends string { bindingset[this] StackVariableReachability() { length() >= 0 } @@ -24,13 +37,13 @@ abstract deprecated class StackVariableReachability extends string { * uses basic blocks internally for better performance: * * ``` - * predicate reaches(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + * predicate reaches(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { * reachesImpl(source, v, sink) * and * isSink(sink, v) * } * - * predicate reachesImpl(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + * predicate reachesImpl(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { * sink = source.getASuccessor() and isSource(source, v) * or * exists(ControlFlowNode mid | reachesImpl(source, v, mid) | @@ -44,7 +57,7 @@ abstract deprecated class StackVariableReachability extends string { * In addition to using a better performing implementation, this analysis * accounts for loops where the condition is provably true upon entry. */ - predicate reaches(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + predicate reaches(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { /* * Implementation detail: the predicates in this class are a generalization of * those in DefinitionsAndUses.qll, and should be kept in sync. @@ -71,7 +84,8 @@ abstract deprecated class StackVariableReachability extends string { } private predicate bbSuccessorEntryReaches( - BasicBlock bb, StackVariable v, ControlFlowNode node, boolean skipsFirstLoopAlwaysTrueUponEntry + BasicBlock bb, SemanticStackVariable v, ControlFlowNode node, + boolean skipsFirstLoopAlwaysTrueUponEntry ) { exists(BasicBlock succ, boolean succSkipsFirstLoopAlwaysTrueUponEntry | bbSuccessorEntryReachesLoopInvariant(bb, succ, skipsFirstLoopAlwaysTrueUponEntry, @@ -85,11 +99,22 @@ abstract deprecated class StackVariableReachability extends string { ) } - private predicate bbEntryReachesLocally(BasicBlock bb, StackVariable v, ControlFlowNode node) { - exists(int n | node = bb.getNode(n) and isSink(node, v) | - not exists(int m | m < n | isBarrier(bb.getNode(m), v)) + private predicate bbEntryReachesLocally( + BasicBlock bb, SemanticStackVariable v, ControlFlowNode node + ) { + exists(int n | + node = bb.getNode(n) and + isSink(node, v) + | + not exists(this.firstBarrierIndexIn(bb, v)) + or + n <= this.firstBarrierIndexIn(bb, v) ) } + + private int firstBarrierIndexIn(BasicBlock bb, SemanticStackVariable v) { + result = min(int m | isBarrier(bb.getNode(m), v)) + } } /** @@ -113,26 +138,32 @@ private predicate bbLoopEntryConditionAlwaysTrueAt(BasicBlock bb, int i, Control } /** - * Basic block `pred` ends with a condition belonging to a loop, and that - * condition is provably true upon entry. Basic block `succ` is a successor - * of `pred`, and `skipsLoop` indicates whether `succ` is the false-successor - * of `pred`. + * Basic block `pred` contains all or part of the condition belonging to a loop, + * and there is an edge from `pred` to `succ` that concludes the condition. + * If the edge corrseponds with the loop condition being found to be `true`, then + * `skipsLoop` is `false`. Otherwise the edge corresponds with the loop condition + * being found to be `false` and `skipsLoop` is `true`. Non-concluding edges + * within a complex loop condition are not matched by this predicate. */ private predicate bbLoopConditionAlwaysTrueUponEntrySuccessor( BasicBlock pred, BasicBlock succ, boolean skipsLoop ) { - succ = pred.getASuccessor() and - exists(ControlFlowNode last | - last = pred.getEnd() and - loopConditionAlwaysTrueUponEntry(_, last) and - if succ = pred.getAFalseSuccessor() then skipsLoop = true else skipsLoop = false + exists(Expr cond | + loopConditionAlwaysTrueUponEntry(_, cond) and + cond.getAChild*() = pred.getEnd() and + succ = pred.getASuccessor() and + not cond.getAChild*() = succ.getStart() and + ( + succ = pred.getAFalseSuccessor() and + skipsLoop = true + or + succ = pred.getATrueSuccessor() and + skipsLoop = false + ) ) } /** - * DEPRECATED: use the corresponding predicate in - * `LocalScopeVariableReachability` instead. - * * Loop invariant for `bbSuccessorEntryReaches`: * * - `succ` is a successor of `pred`. @@ -146,7 +177,7 @@ private predicate bbLoopConditionAlwaysTrueUponEntrySuccessor( * is provably true upon entry, then `succ` is not allowed to skip * that loop (`succSkipsFirstLoopAlwaysTrueUponEntry = false`). */ -deprecated predicate bbSuccessorEntryReachesLoopInvariant( +predicate bbSuccessorEntryReachesLoopInvariant( BasicBlock pred, BasicBlock succ, boolean predSkipsFirstLoopAlwaysTrueUponEntry, boolean succSkipsFirstLoopAlwaysTrueUponEntry ) { @@ -162,7 +193,7 @@ deprecated predicate bbSuccessorEntryReachesLoopInvariant( // The edge from `pred` to `succ` is _not_ from a loop condition provably // true upon entry, so the values of `predSkipsFirstLoopAlwaysTrueUponEntry` // and `succSkipsFirstLoopAlwaysTrueUponEntry` must be the same. - not bbLoopConditionAlwaysTrueUponEntrySuccessor(pred, _, _) and + not bbLoopConditionAlwaysTrueUponEntrySuccessor(pred, succ, _) and succSkipsFirstLoopAlwaysTrueUponEntry = predSkipsFirstLoopAlwaysTrueUponEntry and // Moreover, if `pred` contains the entry point of a loop where the // condition is provably true upon entry, then `succ` is not allowed @@ -176,13 +207,16 @@ deprecated predicate bbSuccessorEntryReachesLoopInvariant( } /** - * DEPRECATED: use `LocalScopeVariableReachabilityWithReassignment` instead. - * * Reachability analysis for control-flow nodes involving stack variables. * Unlike `StackVariableReachability`, this analysis takes variable * reassignments into account. + * + * This class is used like `StackVariableReachability`, except that + * subclasses should override `isSourceActual` and `isSinkActual` instead of + * `isSource` and `isSink`, and that there is a `reachesTo` predicate in + * addition to `reaches`. */ -abstract deprecated class StackVariableReachabilityWithReassignment extends StackVariableReachability { +abstract class StackVariableReachabilityWithReassignment extends StackVariableReachability { bindingset[this] StackVariableReachabilityWithReassignment() { length() >= 0 } @@ -199,19 +233,19 @@ abstract deprecated class StackVariableReachabilityWithReassignment extends Stac * performance: * * ``` - * predicate reaches(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + * predicate reaches(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { * reachesImpl(source, v, sink) * and * isSinkActual(sink, v) * } * - * predicate reachesImpl(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + * predicate reachesImpl(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { * isSourceActual(source, v) * and * ( * sink = source.getASuccessor() * or - * exists(ControlFlowNode mid, StackVariable v0 | reachesImpl(source, v0, mid) | + * exists(ControlFlowNode mid, SemanticStackVariable v0 | reachesImpl(source, v0, mid) | * // ordinary successor * not isBarrier(mid, v) and * sink = mid.getASuccessor() and @@ -228,7 +262,7 @@ abstract deprecated class StackVariableReachabilityWithReassignment extends Stac * In addition to using a better performing implementation, this analysis * accounts for loops where the condition is provably true upon entry. */ - override predicate reaches(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + override predicate reaches(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { reachesTo(source, v, sink, _) } @@ -236,7 +270,7 @@ abstract deprecated class StackVariableReachabilityWithReassignment extends Stac * As `reaches`, but also specifies the last variable it was reassigned to (`v0`). */ predicate reachesTo( - ControlFlowNode source, StackVariable v, ControlFlowNode sink, StackVariable v0 + ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink, SemanticStackVariable v0 ) { exists(ControlFlowNode def | actualSourceReaches(source, v, def, v0) and @@ -246,17 +280,19 @@ abstract deprecated class StackVariableReachabilityWithReassignment extends Stac } private predicate actualSourceReaches( - ControlFlowNode source, StackVariable v, ControlFlowNode def, StackVariable v0 + ControlFlowNode source, SemanticStackVariable v, ControlFlowNode def, SemanticStackVariable v0 ) { isSourceActual(source, v) and def = source and v0 = v or - exists(ControlFlowNode source1, StackVariable v1 | actualSourceReaches(source, v, source1, v1) | + exists(ControlFlowNode source1, SemanticStackVariable v1 | + actualSourceReaches(source, v, source1, v1) + | reassignment(source1, v1, def, v0) ) } private predicate reassignment( - ControlFlowNode source, StackVariable v, ControlFlowNode def, StackVariable v0 + ControlFlowNode source, SemanticStackVariable v, ControlFlowNode def, SemanticStackVariable v0 ) { StackVariableReachability.super.reaches(source, v, def) and exprDefinition(v0, def, v.getAnAccess()) @@ -278,13 +314,12 @@ abstract deprecated class StackVariableReachabilityWithReassignment extends Stac } /** - * DEPRECATED: use `LocalScopeVariableReachabilityExt` instead. - * * Same as `StackVariableReachability`, but `isBarrier` works on control-flow * edges rather than nodes and is therefore parameterized by the original - * source node as well. + * source node as well. Otherwise, this class is used like + * `StackVariableReachability`. */ -abstract deprecated class StackVariableReachabilityExt extends string { +abstract class StackVariableReachabilityExt extends string { bindingset[this] StackVariableReachabilityExt() { length() >= 0 } @@ -300,7 +335,7 @@ abstract deprecated class StackVariableReachabilityExt extends string { ); /** See `StackVariableReachability.reaches`. */ - predicate reaches(ControlFlowNode source, StackVariable v, ControlFlowNode sink) { + predicate reaches(ControlFlowNode source, SemanticStackVariable v, ControlFlowNode sink) { exists(BasicBlock bb, int i | isSource(source, v) and bb.getNode(i) = source and @@ -321,7 +356,7 @@ abstract deprecated class StackVariableReachabilityExt extends string { } private predicate bbSuccessorEntryReaches( - ControlFlowNode source, BasicBlock bb, StackVariable v, ControlFlowNode node, + ControlFlowNode source, BasicBlock bb, SemanticStackVariable v, ControlFlowNode node, boolean skipsFirstLoopAlwaysTrueUponEntry ) { exists(BasicBlock succ, boolean succSkipsFirstLoopAlwaysTrueUponEntry | @@ -338,7 +373,7 @@ abstract deprecated class StackVariableReachabilityExt extends string { } private predicate bbEntryReachesLocally( - ControlFlowNode source, BasicBlock bb, StackVariable v, ControlFlowNode node + ControlFlowNode source, BasicBlock bb, SemanticStackVariable v, ControlFlowNode node ) { isSource(source, v) and exists(int n | node = bb.getNode(n) and isSink(node, v) | diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/internal/ConstantExprs.qll b/cpp/ql/src/semmle/code/cpp/controlflow/internal/ConstantExprs.qll index 43b1a76c837..263fb141312 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/internal/ConstantExprs.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/internal/ConstantExprs.qll @@ -924,7 +924,7 @@ library class LoopEntryConditionEvaluator extends ExprEvaluator { /* * Use primitive basic blocks in reachability analysis for better performance. * This is similar to the pattern used in e.g. `DefinitionsAndUses` and - * `LocalScopeVariableReachability`. + * `StackVariableReachability`. */ exists(PrimitiveBasicBlock bb1, int pos1 | bb1.getNode(pos1) = valueOrDef | diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/StackAddress.qll b/cpp/ql/src/semmle/code/cpp/dataflow/StackAddress.qll index d0694a12932..f375bbae199 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/StackAddress.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/StackAddress.qll @@ -61,7 +61,7 @@ predicate stackPointerFlowsToUse(Expr use, Type useType, Expr source, boolean is stackPointerFlowsToUse(use.(PointerAddExpr).getAnOperand(), useType, source, isLocal) or // Indirect use of a stack address. - exists(SsaDefinition def, LocalScopeVariable var | + exists(SsaDefinition def, StackVariable var | stackPointerFlowsToDef(def, var, useType, source, isLocal) and use = def.getAUse(var) ) @@ -97,8 +97,7 @@ private PointerType getExprPtrType(Expr use) { result = use.getUnspecifiedType() predicate stackReferenceFlowsToUse(Expr use, Type useType, Expr source, boolean isLocal) { // Stack variables - exists(LocalScopeVariable var | - not var.isStatic() and + exists(StackVariable var | use = source and source = var.getAnAccess() and isLocal = true and @@ -140,7 +139,7 @@ predicate stackReferenceFlowsToUse(Expr use, Type useType, Expr source, boolean stackPointerFlowsToUse(use.(PointerDereferenceExpr).getOperand(), useType, source, isLocal) or // Indirect use of a stack reference, via a reference variable. - exists(SsaDefinition def, LocalScopeVariable var | + exists(SsaDefinition def, StackVariable var | stackReferenceFlowsToDef(def, var, useType, source, isLocal) and use = def.getAUse(var) ) @@ -162,7 +161,7 @@ predicate stackReferenceFlowsToUse(Expr use, Type useType, Expr source, boolean * addresses through SSA definitions. */ predicate stackPointerFlowsToDef( - SsaDefinition def, LocalScopeVariable var, Type useType, Expr source, boolean isLocal + SsaDefinition def, StackVariable var, Type useType, Expr source, boolean isLocal ) { stackPointerFlowsToUse(def.getDefiningValue(var), useType, source, isLocal) or @@ -184,7 +183,7 @@ predicate stackPointerFlowsToDef( * int&, rather than pointers. */ predicate stackReferenceFlowsToDef( - SsaDefinition def, LocalScopeVariable var, Type useType, Expr source, boolean isLocal + SsaDefinition def, StackVariable var, Type useType, Expr source, boolean isLocal ) { // Check that the type of the variable is a reference type and delegate // the rest of the work to stackReferenceFlowsToDef_Impl. @@ -197,7 +196,7 @@ predicate stackReferenceFlowsToDef( * predicate. */ predicate stackReferenceFlowsToDef_Impl( - SsaDefinition def, LocalScopeVariable var, Type useType, Expr source, boolean isLocal + SsaDefinition def, StackVariable var, Type useType, Expr source, boolean isLocal ) { stackReferenceFlowsToUse(def.getDefiningValue(var), useType, source, isLocal) or @@ -213,7 +212,7 @@ predicate stackReferenceFlowsToDef_Impl( } /** The type of the variable is a reference type, such as int&. */ -predicate isReferenceVariable(LocalScopeVariable var) { +predicate isReferenceVariable(StackVariable var) { var.getUnspecifiedType() instanceof ReferenceType } @@ -284,7 +283,7 @@ predicate memberFcnMightRunOnStack(MemberFunction fcn, Type useType) { predicate constructorMightRunOnStack(Constructor constructor) { exists(ConstructorCall call | call.getTarget() = constructor | // Call to a constructor from a stack variable's initializer. - exists(LocalScopeVariable var | var.getInitializer().getExpr() = call) + exists(StackVariable var | var.getInitializer().getExpr() = call) or // Call to a constructor from another constructor which might // also run on the stack. diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl2.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl2.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl2.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl2.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl3.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl3.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl3.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl3.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl4.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl4.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl4.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImpl4.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplCommon.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplCommon.qll index 91f5aeacc9d..87b33a79b8b 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplCommon.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplCommon.qll @@ -360,7 +360,7 @@ private module ImplCommon { */ cached predicate read(Node node1, Content f, Node node2) { - readStep(node1, f, node2) and storeStep(_, f, _) + readStep(node1, f, node2) or exists(DataFlowCall call, ReturnKind kind | read0(call, kind, node1, f) and diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplLocal.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplLocal.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplLocal.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/DataFlowImplLocal.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll b/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll index abd56c6283c..5085e74a97f 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll @@ -88,7 +88,7 @@ class FlowVar extends TFlowVar { * `FlowVar` instance for the uninitialized value of that variable. */ cached - abstract predicate definedByInitialValue(LocalScopeVariable v); + abstract predicate definedByInitialValue(StackVariable v); /** Gets a textual representation of this element. */ cached @@ -268,7 +268,7 @@ module FlowVar_internal { * Holds if `sbb` is the `SubBasicBlock` where `v` receives its initial value. * See the documentation for `FlowVar.definedByInitialValue`. */ - predicate blockVarDefinedByVariable(SubBasicBlock sbb, LocalScopeVariable v) { + predicate blockVarDefinedByVariable(SubBasicBlock sbb, StackVariable v) { sbb = v.(Parameter).getFunction().getEntryPoint() or exists(DeclStmt declStmt | @@ -279,7 +279,7 @@ module FlowVar_internal { } newtype TFlowVar = - TSsaVar(SsaDefinition def, LocalScopeVariable v) { + TSsaVar(SsaDefinition def, StackVariable v) { fullySupportedSsaVariable(v) and v = def.getAVariable() } or @@ -303,7 +303,7 @@ module FlowVar_internal { */ class SsaVar extends TSsaVar, FlowVar { SsaDefinition def; - LocalScopeVariable v; + StackVariable v; SsaVar() { this = TSsaVar(def, v) } @@ -343,7 +343,7 @@ module FlowVar_internal { override predicate definedPartiallyAt(Expr e) { none() } - override predicate definedByInitialValue(LocalScopeVariable param) { + override predicate definedByInitialValue(StackVariable param) { def.definedByParameter(param) and param = v } @@ -407,7 +407,7 @@ module FlowVar_internal { getAReachedBlockVarSBB(this).getANode() = p.getFunction() } - override predicate definedByInitialValue(LocalScopeVariable lsv) { + override predicate definedByInitialValue(StackVariable lsv) { blockVarDefinedByVariable(sbb, lsv) and lsv = v } @@ -647,11 +647,8 @@ module FlowVar_internal { /** * A local variable that is uninitialized immediately after its declaration. */ - class UninitializedLocalVariable extends LocalVariable { - UninitializedLocalVariable() { - not this.hasInitializer() and - not this.isStatic() - } + class UninitializedLocalVariable extends LocalVariable, StackVariable { + UninitializedLocalVariable() { not this.hasInitializer() } } /** Holds if `va` may be an uninitialized access to `v`. */ diff --git a/cpp/ql/src/semmle/code/cpp/exprs/ArithmeticOperation.qll b/cpp/ql/src/semmle/code/cpp/exprs/ArithmeticOperation.qll index 741d63fbc44..46e672f1d98 100644 --- a/cpp/ql/src/semmle/code/cpp/exprs/ArithmeticOperation.qll +++ b/cpp/ql/src/semmle/code/cpp/exprs/ArithmeticOperation.qll @@ -62,11 +62,10 @@ abstract class CrementOperation extends UnaryArithmeticOperation { override predicate mayBeImpure() { any() } override predicate mayBeGloballyImpure() { - not exists(VariableAccess va, LocalScopeVariable v | + not exists(VariableAccess va, StackVariable v | va = this.getOperand() and v = va.getTarget() and - not va.getConversion+() instanceof ReferenceDereferenceExpr and - not v.isStatic() + not va.getConversion+() instanceof ReferenceDereferenceExpr ) } } diff --git a/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll b/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll index aeabe10f168..1d787f03167 100644 --- a/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll +++ b/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll @@ -21,11 +21,10 @@ abstract class Assignment extends Operation { override predicate mayBeGloballyImpure() { this.getRValue().mayBeGloballyImpure() or - not exists(VariableAccess va, LocalScopeVariable v | + not exists(VariableAccess va, StackVariable v | va = this.getLValue() and v = va.getTarget() and - not va.getConversion+() instanceof ReferenceDereferenceExpr and - not v.isStatic() + not va.getConversion+() instanceof ReferenceDereferenceExpr ) } } diff --git a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl.qll b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl2.qll b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl2.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl2.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl2.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl3.qll b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl3.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl3.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl3.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl4.qll b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl4.qll index 9519a74265f..1f322a02201 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl4.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl4.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImplCommon.qll b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImplCommon.qll index 91f5aeacc9d..87b33a79b8b 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImplCommon.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/dataflow/internal/DataFlowImplCommon.qll @@ -360,7 +360,7 @@ private module ImplCommon { */ cached predicate read(Node node1, Content f, Node node2) { - readStep(node1, f, node2) and storeStep(_, f, _) + readStep(node1, f, node2) or exists(DataFlowCall call, ReturnKind kind | read0(call, kind, node1, f) and diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Instruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Instruction.qll index b325aeb1bf1..241de4406e8 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Instruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Instruction.qll @@ -359,24 +359,25 @@ class Instruction extends Construction::TInstruction { */ int getDisplayIndexInBlock() { exists(IRBlock block | - block = getBlock() and - ( - exists(int index, int phiCount | - phiCount = count(block.getAPhiInstruction()) and - this = block.getInstruction(index) and - result = index + phiCount + this = block.getInstruction(result) + or + this = rank[-result - 1](PhiInstruction phiInstr | + phiInstr = block.getAPhiInstruction() + | + phiInstr order by phiInstr.getUniqueId() ) - or - this instanceof PhiInstruction and - this = rank[result + 1](PhiInstruction phiInstr | - phiInstr = block.getAPhiInstruction() - | - phiInstr order by phiInstr.getUniqueId() - ) - ) ) } + private int getLineRank() { + this = rank[result](Instruction instr | + instr.getAST().getFile() = getAST().getFile() and + instr.getAST().getLocation().getStartLine() = getAST().getLocation().getStartLine() + | + instr order by instr.getBlock().getDisplayIndex(), instr.getDisplayIndexInBlock() + ) + } + /** * Gets a human-readable string that uniquely identifies this instruction * within the function. This string is used to refer to this instruction when @@ -385,8 +386,7 @@ class Instruction extends Construction::TInstruction { * Example: `r1_1` */ string getResultId() { - result = getResultPrefix() + getBlock().getDisplayIndex().toString() + "_" + - getDisplayIndexInBlock().toString() + result = getResultPrefix() + getAST().getLocation().getStartLine() + "_" + getLineRank() } /** diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Instruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Instruction.qll index b325aeb1bf1..241de4406e8 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Instruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Instruction.qll @@ -359,24 +359,25 @@ class Instruction extends Construction::TInstruction { */ int getDisplayIndexInBlock() { exists(IRBlock block | - block = getBlock() and - ( - exists(int index, int phiCount | - phiCount = count(block.getAPhiInstruction()) and - this = block.getInstruction(index) and - result = index + phiCount + this = block.getInstruction(result) + or + this = rank[-result - 1](PhiInstruction phiInstr | + phiInstr = block.getAPhiInstruction() + | + phiInstr order by phiInstr.getUniqueId() ) - or - this instanceof PhiInstruction and - this = rank[result + 1](PhiInstruction phiInstr | - phiInstr = block.getAPhiInstruction() - | - phiInstr order by phiInstr.getUniqueId() - ) - ) ) } + private int getLineRank() { + this = rank[result](Instruction instr | + instr.getAST().getFile() = getAST().getFile() and + instr.getAST().getLocation().getStartLine() = getAST().getLocation().getStartLine() + | + instr order by instr.getBlock().getDisplayIndex(), instr.getDisplayIndexInBlock() + ) + } + /** * Gets a human-readable string that uniquely identifies this instruction * within the function. This string is used to refer to this instruction when @@ -385,8 +386,7 @@ class Instruction extends Construction::TInstruction { * Example: `r1_1` */ string getResultId() { - result = getResultPrefix() + getBlock().getDisplayIndex().toString() + "_" + - getDisplayIndexInBlock().toString() + result = getResultPrefix() + getAST().getLocation().getStartLine() + "_" + getLineRank() } /** diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Instruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Instruction.qll index b325aeb1bf1..241de4406e8 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Instruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Instruction.qll @@ -359,24 +359,25 @@ class Instruction extends Construction::TInstruction { */ int getDisplayIndexInBlock() { exists(IRBlock block | - block = getBlock() and - ( - exists(int index, int phiCount | - phiCount = count(block.getAPhiInstruction()) and - this = block.getInstruction(index) and - result = index + phiCount + this = block.getInstruction(result) + or + this = rank[-result - 1](PhiInstruction phiInstr | + phiInstr = block.getAPhiInstruction() + | + phiInstr order by phiInstr.getUniqueId() ) - or - this instanceof PhiInstruction and - this = rank[result + 1](PhiInstruction phiInstr | - phiInstr = block.getAPhiInstruction() - | - phiInstr order by phiInstr.getUniqueId() - ) - ) ) } + private int getLineRank() { + this = rank[result](Instruction instr | + instr.getAST().getFile() = getAST().getFile() and + instr.getAST().getLocation().getStartLine() = getAST().getLocation().getStartLine() + | + instr order by instr.getBlock().getDisplayIndex(), instr.getDisplayIndexInBlock() + ) + } + /** * Gets a human-readable string that uniquely identifies this instruction * within the function. This string is used to refer to this instruction when @@ -385,8 +386,7 @@ class Instruction extends Construction::TInstruction { * Example: `r1_1` */ string getResultId() { - result = getResultPrefix() + getBlock().getDisplayIndex().toString() + "_" + - getDisplayIndexInBlock().toString() + result = getResultPrefix() + getAST().getLocation().getStartLine() + "_" + getLineRank() } /** diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll index c6a6bc3fec9..3b44e6f555a 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll @@ -1,5 +1,6 @@ import AliasAnalysis private import SimpleSSAImports +import SimpleSSAPublicImports private class IntValue = Ints::IntValue; diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll index 8f160f5a456..33d2bbbadec 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll @@ -2,4 +2,3 @@ import semmle.code.cpp.ir.implementation.raw.IR import semmle.code.cpp.ir.internal.IntegerConstant as Ints import semmle.code.cpp.ir.implementation.internal.OperandTag import semmle.code.cpp.ir.internal.IRCppLanguage as Language -import semmle.code.cpp.ir.internal.Overlap diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll new file mode 100644 index 00000000000..94e6fbf2a22 --- /dev/null +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll @@ -0,0 +1 @@ +import semmle.code.cpp.ir.internal.Overlap diff --git a/cpp/ql/src/semmle/code/cpp/ir/internal/IRCppLanguage.qll b/cpp/ql/src/semmle/code/cpp/ir/internal/IRCppLanguage.qll index 613958a0d4c..cc41429489f 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/internal/IRCppLanguage.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/internal/IRCppLanguage.qll @@ -32,7 +32,7 @@ class StringLiteral = Cpp::StringLiteral; class Variable = Cpp::Variable; -class AutomaticVariable = Cpp::LocalScopeVariable; +class AutomaticVariable = Cpp::StackVariable; class StaticVariable = Cpp::Variable; @@ -66,10 +66,7 @@ int getTypeSize(Type type) { result = type.getSize() } int getPointerSize() { exists(Cpp::NullPointerType nullptr | result = nullptr.getSize()) } -predicate isVariableAutomatic(Variable var) { - var instanceof Cpp::LocalScopeVariable and - not var.(Cpp::LocalScopeVariable).isStatic() -} +predicate isVariableAutomatic(Cpp::StackVariable var) { any() } string getStringLiteralText(StringLiteral s) { result = s.getValueText().replaceAll("\n", " ").replaceAll("\r", "").replaceAll("\t", " ") diff --git a/cpp/ql/src/semmle/code/cpp/rangeanalysis/NanAnalysis.qll b/cpp/ql/src/semmle/code/cpp/rangeanalysis/NanAnalysis.qll index 10a91deaa3a..ea12434ac5b 100644 --- a/cpp/ql/src/semmle/code/cpp/rangeanalysis/NanAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/rangeanalysis/NanAnalysis.qll @@ -24,7 +24,7 @@ predicate nanExcludingComparison(ComparisonOperation guard, boolean polarity) { * by virtue of the guard in `def`. */ private predicate excludesNan(RangeSsaDefinition def, VariableAccess v) { - exists(VariableAccess inCond, ComparisonOperation guard, boolean branch, LocalScopeVariable lsv | + exists(VariableAccess inCond, ComparisonOperation guard, boolean branch, StackVariable lsv | def.isGuardPhi(inCond, guard, branch) and inCond.getTarget() = lsv and v = def.getAUse(lsv) and diff --git a/cpp/ql/src/semmle/code/cpp/rangeanalysis/RangeSSA.qll b/cpp/ql/src/semmle/code/cpp/rangeanalysis/RangeSSA.qll index 61068801978..99e6539658d 100644 --- a/cpp/ql/src/semmle/code/cpp/rangeanalysis/RangeSSA.qll +++ b/cpp/ql/src/semmle/code/cpp/rangeanalysis/RangeSSA.qll @@ -31,7 +31,7 @@ library class RangeSSA extends SSAHelper { /** * Add a phi node on the out-edge of a guard. */ - override predicate custom_phi_node(LocalScopeVariable v, BasicBlock b) { + override predicate custom_phi_node(StackVariable v, BasicBlock b) { guard_defn(v.getAnAccess(), _, b, _) } } @@ -67,19 +67,19 @@ class RangeSsaDefinition extends ControlFlowNodeBase { RangeSsaDefinition() { exists(RangeSSA x | x.ssa_defn(_, this, _, _)) } /** - * Gets a variable corresponding to a SSA LocalScopeVariable defined by + * Gets a variable corresponding to a SSA StackVariable defined by * this definition. */ - LocalScopeVariable getAVariable() { exists(RangeSSA x | x.ssa_defn(result, this, _, _)) } + StackVariable getAVariable() { exists(RangeSSA x | x.ssa_defn(result, this, _, _)) } /** * A string representation of the SSA variable represented by the pair * `(this, v)`. */ - string toString(LocalScopeVariable v) { exists(RangeSSA x | result = x.toString(this, v)) } + string toString(StackVariable v) { exists(RangeSSA x | result = x.toString(this, v)) } /** Gets a use of the SSA variable represented by the pair `(this, v)`. */ - VariableAccess getAUse(LocalScopeVariable v) { exists(RangeSSA x | result = x.getAUse(this, v)) } + VariableAccess getAUse(StackVariable v) { exists(RangeSSA x | result = x.getAUse(this, v)) } /** Gets the control flow node for this definition. */ ControlFlowNode getDefinition() { result = this } @@ -87,9 +87,7 @@ class RangeSsaDefinition extends ControlFlowNodeBase { BasicBlock getBasicBlock() { result.contains(getDefinition()) } /** Whether this definition is a phi node for variable `v`. */ - predicate isPhiNode(LocalScopeVariable v) { - exists(RangeSSA x | x.phi_node(v, this.(BasicBlock))) - } + predicate isPhiNode(StackVariable v) { exists(RangeSSA x | x.phi_node(v, this.(BasicBlock))) } /** * If this definition is a phi node corresponding to a guard, @@ -104,7 +102,7 @@ class RangeSsaDefinition extends ControlFlowNodeBase { /** Whether this definition is from a parameter */ predicate definedByParameter(Parameter p) { this = p.getFunction().getEntryPoint() } - RangeSsaDefinition getAPhiInput(LocalScopeVariable v) { + RangeSsaDefinition getAPhiInput(StackVariable v) { this.isPhiNode(v) and exists(BasicBlock pred | pred = this.(BasicBlock).getAPredecessor() and @@ -137,7 +135,7 @@ class RangeSsaDefinition extends ControlFlowNodeBase { } /** Gets the expression assigned to this SsaDefinition. */ - Expr getDefiningValue(LocalScopeVariable v) { + Expr getDefiningValue(StackVariable v) { exists(ControlFlowNode def | def = this.getDefinition() | def = v.getInitializer().getExpr() and def = result or @@ -155,7 +153,7 @@ class RangeSsaDefinition extends ControlFlowNodeBase { ) } - predicate reachesEndOfBB(LocalScopeVariable v, BasicBlock b) { + predicate reachesEndOfBB(StackVariable v, BasicBlock b) { exists(RangeSSA x | x.ssaDefinitionReachesEndOfBB(v, this, b)) } } diff --git a/cpp/ql/src/semmle/code/cpp/rangeanalysis/SimpleRangeAnalysis.qll b/cpp/ql/src/semmle/code/cpp/rangeanalysis/SimpleRangeAnalysis.qll index b7b646d5c8a..72dba0ab609 100644 --- a/cpp/ql/src/semmle/code/cpp/rangeanalysis/SimpleRangeAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/rangeanalysis/SimpleRangeAnalysis.qll @@ -120,7 +120,7 @@ private predicate analyzableExpr(Expr e) { exists(exprMinVal(e.(Conversion).getExpr())) or // Also allow variable accesses, provided that they have SSA // information. - exists(RangeSsaDefinition def, LocalScopeVariable v | e = def.getAUse(v)) + exists(RangeSsaDefinition def, StackVariable v | e = def.getAUse(v)) ) } @@ -136,7 +136,7 @@ private predicate analyzableExpr(Expr e) { * here. */ private predicate defDependsOnDef( - RangeSsaDefinition def, LocalScopeVariable v, RangeSsaDefinition srcDef, LocalScopeVariable srcVar + RangeSsaDefinition def, StackVariable v, RangeSsaDefinition srcDef, StackVariable srcVar ) { // Definitions with a defining value. exists(Expr expr | assignmentDef(def, v, expr) | exprDependsOnDef(expr, srcDef, srcVar)) @@ -171,7 +171,7 @@ private predicate defDependsOnDef( * Helper predicate for `defDependsOnDef`. This predicate matches * the structure of `getLowerBoundsImpl` and `getUpperBoundsImpl`. */ -private predicate exprDependsOnDef(Expr e, RangeSsaDefinition srcDef, LocalScopeVariable srcVar) { +private predicate exprDependsOnDef(Expr e, RangeSsaDefinition srcDef, StackVariable srcVar) { exists(UnaryMinusExpr negateExpr | e = negateExpr | exprDependsOnDef(negateExpr.getOperand(), srcDef, srcVar) ) @@ -226,7 +226,7 @@ private predicate exprDependsOnDef(Expr e, RangeSsaDefinition srcDef, LocalScope * the structure of `getPhiLowerBounds` and `getPhiUpperBounds`. */ private predicate phiDependsOnDef( - RangeSsaDefinition phi, LocalScopeVariable v, RangeSsaDefinition srcDef, LocalScopeVariable srcVar + RangeSsaDefinition phi, StackVariable v, RangeSsaDefinition srcDef, StackVariable srcVar ) { exists(VariableAccess access, ComparisonOperation guard | access = v.getAnAccess() and @@ -241,19 +241,17 @@ private predicate phiDependsOnDef( /** The transitive closure of `defDependsOnDef`. */ private predicate defDependsOnDefTransitively( - RangeSsaDefinition def, LocalScopeVariable v, RangeSsaDefinition srcDef, LocalScopeVariable srcVar + RangeSsaDefinition def, StackVariable v, RangeSsaDefinition srcDef, StackVariable srcVar ) { defDependsOnDef(def, v, srcDef, srcVar) or - exists(RangeSsaDefinition midDef, LocalScopeVariable midVar | - defDependsOnDef(def, v, midDef, midVar) - | + exists(RangeSsaDefinition midDef, StackVariable midVar | defDependsOnDef(def, v, midDef, midVar) | defDependsOnDefTransitively(midDef, midVar, srcDef, srcVar) ) } /** The set of definitions that depend recursively on themselves. */ -private predicate isRecursiveDef(RangeSsaDefinition def, LocalScopeVariable v) { +private predicate isRecursiveDef(RangeSsaDefinition def, StackVariable v) { defDependsOnDefTransitively(def, v, def, v) } @@ -271,7 +269,7 @@ private predicate isRecursiveDef(RangeSsaDefinition def, LocalScopeVariable v) { * * This predicate finds all the definitions in the first set. */ -private predicate assignmentDef(RangeSsaDefinition def, LocalScopeVariable v, Expr expr) { +private predicate assignmentDef(RangeSsaDefinition def, StackVariable v, Expr expr) { v.getUnspecifiedType() instanceof ArithmeticType and ( def = v.getInitializer().getExpr() and def = expr @@ -285,7 +283,7 @@ private predicate assignmentDef(RangeSsaDefinition def, LocalScopeVariable v, Ex } /** See comment above sourceDef. */ -private predicate analyzableDef(RangeSsaDefinition def, LocalScopeVariable v) { +private predicate analyzableDef(RangeSsaDefinition def, StackVariable v) { assignmentDef(def, v, _) or defDependsOnDef(def, v, _, _) } @@ -613,7 +611,7 @@ private float getLowerBoundsImpl(Expr expr) { ) or // Use SSA to get the lower bounds for a variable use. - exists(RangeSsaDefinition def, LocalScopeVariable v | expr = def.getAUse(v) | + exists(RangeSsaDefinition def, StackVariable v | expr = def.getAUse(v) | result = getDefLowerBounds(def, v) ) } @@ -766,7 +764,7 @@ private float getUpperBoundsImpl(Expr expr) { ) or // Use SSA to get the upper bounds for a variable use. - exists(RangeSsaDefinition def, LocalScopeVariable v | expr = def.getAUse(v) | + exists(RangeSsaDefinition def, StackVariable v | expr = def.getAUse(v) | result = getDefUpperBounds(def, v) ) } @@ -860,7 +858,7 @@ private float boolConversionUpperBound(Expr expr) { * In this example, the lower bound of x is 0, but we can * use the guard to deduce that the lower bound is 2 inside the block. */ -private float getPhiLowerBounds(LocalScopeVariable v, RangeSsaDefinition phi) { +private float getPhiLowerBounds(StackVariable v, RangeSsaDefinition phi) { exists( VariableAccess access, ComparisonOperation guard, boolean branch, float defLB, float guardLB | @@ -877,7 +875,7 @@ private float getPhiLowerBounds(LocalScopeVariable v, RangeSsaDefinition phi) { } /** See comment for `getPhiLowerBounds`, above. */ -private float getPhiUpperBounds(LocalScopeVariable v, RangeSsaDefinition phi) { +private float getPhiUpperBounds(StackVariable v, RangeSsaDefinition phi) { exists( VariableAccess access, ComparisonOperation guard, boolean branch, float defUB, float guardUB | @@ -894,7 +892,7 @@ private float getPhiUpperBounds(LocalScopeVariable v, RangeSsaDefinition phi) { } /** Only to be called by `getDefLowerBounds`. */ -private float getDefLowerBoundsImpl(RangeSsaDefinition def, LocalScopeVariable v) { +private float getDefLowerBoundsImpl(RangeSsaDefinition def, StackVariable v) { // Definitions with a defining value. exists(Expr expr | assignmentDef(def, v, expr) | result = getFullyConvertedLowerBounds(expr)) or @@ -936,7 +934,7 @@ private float getDefLowerBoundsImpl(RangeSsaDefinition def, LocalScopeVariable v } /** Only to be called by `getDefUpperBounds`. */ -private float getDefUpperBoundsImpl(RangeSsaDefinition def, LocalScopeVariable v) { +private float getDefUpperBoundsImpl(RangeSsaDefinition def, StackVariable v) { // Definitions with a defining value. exists(Expr expr | assignmentDef(def, v, expr) | result = getFullyConvertedUpperBounds(expr)) or @@ -982,7 +980,7 @@ private float getDefUpperBoundsImpl(RangeSsaDefinition def, LocalScopeVariable v * done by `getDefLowerBoundsImpl`, but this is where widening is applied * to prevent the analysis from exploding due to a recursive definition. */ -private float getDefLowerBounds(RangeSsaDefinition def, LocalScopeVariable v) { +private float getDefLowerBounds(RangeSsaDefinition def, StackVariable v) { exists(float newLB, float truncatedLB | newLB = getDefLowerBoundsImpl(def, v) and if varMinVal(v) <= newLB and newLB <= varMaxVal(v) @@ -1011,7 +1009,7 @@ private float getDefLowerBounds(RangeSsaDefinition def, LocalScopeVariable v) { } /** See comment for `getDefLowerBounds`, above. */ -private float getDefUpperBounds(RangeSsaDefinition def, LocalScopeVariable v) { +private float getDefUpperBounds(RangeSsaDefinition def, StackVariable v) { exists(float newUB, float truncatedUB | newUB = getDefUpperBoundsImpl(def, v) and if varMinVal(v) <= newUB and newUB <= varMaxVal(v) @@ -1044,9 +1042,7 @@ private float getDefUpperBounds(RangeSsaDefinition def, LocalScopeVariable v) { * unanalyzable definitions (such as function parameters) and make their * bounds unknown. */ -private predicate unanalyzableDefBounds( - RangeSsaDefinition def, LocalScopeVariable v, float lb, float ub -) { +private predicate unanalyzableDefBounds(RangeSsaDefinition def, StackVariable v, float lb, float ub) { v = def.getAVariable() and not analyzableDef(def, v) and lb = varMinVal(v) and @@ -1268,13 +1264,13 @@ private module SimpleRangeAnalysisCached { /** Holds if the definition might overflow negatively. */ cached - predicate defMightOverflowNegatively(RangeSsaDefinition def, LocalScopeVariable v) { + predicate defMightOverflowNegatively(RangeSsaDefinition def, StackVariable v) { getDefLowerBoundsImpl(def, v) < varMinVal(v) } /** Holds if the definition might overflow positively. */ cached - predicate defMightOverflowPositively(RangeSsaDefinition def, LocalScopeVariable v) { + predicate defMightOverflowPositively(RangeSsaDefinition def, StackVariable v) { getDefUpperBoundsImpl(def, v) > varMaxVal(v) } @@ -1283,7 +1279,7 @@ private module SimpleRangeAnalysisCached { * negatively). */ cached - predicate defMightOverflow(RangeSsaDefinition def, LocalScopeVariable v) { + predicate defMightOverflow(RangeSsaDefinition def, StackVariable v) { defMightOverflowNegatively(def, v) or defMightOverflowPositively(def, v) } diff --git a/cpp/ql/src/semmle/code/cpp/valuenumbering/GlobalValueNumbering.qll b/cpp/ql/src/semmle/code/cpp/valuenumbering/GlobalValueNumbering.qll index 5c8196c15e0..f9231e24725 100644 --- a/cpp/ql/src/semmle/code/cpp/valuenumbering/GlobalValueNumbering.qll +++ b/cpp/ql/src/semmle/code/cpp/valuenumbering/GlobalValueNumbering.qll @@ -170,8 +170,8 @@ private newtype GVNBase = GVN_FloatConst(float val, Type t) { mk_FloatConst(val, t, _) } or // If the local variable does not have a defining value, then // we use the SsaDefinition as its global value number. - GVN_UndefinedLocalScopeVariable(LocalScopeVariable x, SsaDefinition def) { - mk_UndefinedLocalScopeVariable(x, def, _) + GVN_UndefinedStackVariable(StackVariable x, SsaDefinition def) { + mk_UndefinedStackVariable(x, def, _) } or // Variables with no SSA information. As a crude (but safe) // approximation, we use `mostRecentSideEffect` to compute a definition @@ -235,8 +235,8 @@ class GVN extends GVNBase { if this instanceof GVN_FloatConst then result = "FloatConst" else - if this instanceof GVN_UndefinedLocalScopeVariable - then result = "UndefinedLocalScopeVariable" + if this instanceof GVN_UndefinedStackVariable + then result = "UndefinedStackVariable" else if this instanceof GVN_OtherVariable then result = "OtherVariable" @@ -307,7 +307,7 @@ private predicate mk_FloatConst(float val, Type t, Expr e) { t = e.getUnspecifiedType() } -private predicate analyzableLocalScopeVariable(VariableAccess access) { +private predicate analyzableStackVariable(VariableAccess access) { strictcount(SsaDefinition def | def.getAUse(_) = access | def) = 1 and strictcount(SsaDefinition def, Variable v | def.getAUse(v) = access | v) = 1 and count(SsaDefinition def, Variable v | @@ -322,10 +322,10 @@ private predicate analyzableLocalScopeVariable(VariableAccess access) { // defining value. If there is a defining value, then there is no // need to generate a fresh `GVN` for the access because `globalValueNumber` // will follow the chain and use the GVN of the defining value. -private predicate mk_UndefinedLocalScopeVariable( - LocalScopeVariable x, SsaDefinition def, VariableAccess access +private predicate mk_UndefinedStackVariable( + StackVariable x, SsaDefinition def, VariableAccess access ) { - analyzableLocalScopeVariable(access) and + analyzableStackVariable(access) and access = def.getAUse(x) and not exists(def.getDefiningValue(x)) } @@ -515,16 +515,16 @@ GVN globalValueNumber(Expr e) { ) or // Local variable with a defining value. - exists(LocalScopeVariable x, SsaDefinition def | - analyzableLocalScopeVariable(e) and + exists(StackVariable x, SsaDefinition def | + analyzableStackVariable(e) and e = def.getAUse(x) and result = globalValueNumber(def.getDefiningValue(x).getFullyConverted()) ) or // Local variable without a defining value. - exists(LocalScopeVariable x, SsaDefinition def | - mk_UndefinedLocalScopeVariable(x, def, e) and - result = GVN_UndefinedLocalScopeVariable(x, def) + exists(StackVariable x, SsaDefinition def | + mk_UndefinedStackVariable(x, def, e) and + result = GVN_UndefinedStackVariable(x, def) ) or // Variable with no SSA information. @@ -594,7 +594,7 @@ private predicate analyzableConst(Expr e) { */ private predicate analyzableExpr(Expr e) { analyzableConst(e) or - analyzableLocalScopeVariable(e) or + analyzableStackVariable(e) or analyzableDotFieldAccess(e) or analyzablePointerFieldAccess(e) or analyzableImplicitThisFieldAccess(e) or diff --git a/cpp/ql/src/semmle/uml/MagicDraw.qll b/cpp/ql/src/semmle/uml/MagicDraw.qll index 6192af3e021..3cd4701a05d 100644 --- a/cpp/ql/src/semmle/uml/MagicDraw.qll +++ b/cpp/ql/src/semmle/uml/MagicDraw.qll @@ -112,7 +112,7 @@ class UMLType extends UMLElement { else result = this.getUMLName() } - string toString() { result = this.getUMLName() } + override string toString() { result = this.getUMLName() } } /** @@ -163,7 +163,7 @@ class UMLProperty extends UMLElement { result.getDeclaringType() = this.getUMLType().getCType() } - string toString() { + override string toString() { if this.isEnumConstant() then result = "- <> " + this.getUMLName() else result = "- " + this.getUMLName() @@ -196,7 +196,7 @@ class UMLOperation extends UMLElement { result.getDeclaringType() = this.getUMLType().getCType() } - string toString() { result = "+ " + this.getUMLName() } + override string toString() { result = "+ " + this.getUMLName() } } /** @@ -221,7 +221,7 @@ class UMLAssociation extends UMLProperty { /** * Gets the C field corresponding to this property, if any. */ - Field getCField() { + override Field getCField() { result.hasName(this.getLabel()) and result.getDeclaringType() = this.getSource().getCType() } @@ -271,7 +271,7 @@ class UMLInheritance extends UMLElement { ) } - string toString() { + override string toString() { result = this.getUMLClient().getUMLName() + " implements " + this.getUMLSupplier().getUMLName() } } @@ -303,5 +303,5 @@ class UMLPackage extends UMLElement { else result = this.getUMLName() } - string toString() { result = this.getUMLQualifiedName() } + override string toString() { result = this.getUMLQualifiedName() } } diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaCompleteness.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaCompleteness.ql index 7af147f73d6..5d11509470c 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaCompleteness.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaCompleteness.ql @@ -9,12 +9,12 @@ import cpp import semmle.code.cpp.controlflow.SSA /* - * Count of number of uses of a LocalScopeVariable where no corresponding SSA definition exists, + * Count of number of uses of a StackVariable where no corresponding SSA definition exists, * but at least one SSA definition for that variable can reach that use. * Should always be zero *regardless* of the input */ -select count(LocalScopeVariable v, Expr use | +select count(StackVariable v, Expr use | exists(SsaDefinition def, BasicBlock db, BasicBlock ub | def.getAUse(v) = use and db.contains(def.getDefinition()) and ub.contains(use) | diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaDefUsePairs.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaDefUsePairs.ql index 2328645e098..9bcb32918aa 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaDefUsePairs.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaDefUsePairs.ql @@ -7,6 +7,6 @@ import cpp import semmle.code.cpp.controlflow.SSA -from SsaDefinition def, LocalScopeVariable var, Expr use +from SsaDefinition def, StackVariable var, Expr use where def.getAUse(var) = use select def, def.toString(var), use diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaDominance.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaDominance.ql index 2bbf7c7707d..087b8a809fb 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaDominance.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaDominance.ql @@ -12,7 +12,7 @@ import semmle.code.cpp.controlflow.SSA * Should always be zero *regardless* of the input */ -select count(SsaDefinition d, LocalScopeVariable v, Expr u | +select count(SsaDefinition d, StackVariable v, Expr u | d.getAUse(v) = u and not exists(BasicBlock bd, BasicBlock bu | bd.contains(mkElement(d).(ControlFlowNode)) and bu.contains(u) diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaLt.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaLt.ql index ef422265b61..37aaaba5013 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaLt.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaLt.ql @@ -8,7 +8,7 @@ import cpp import semmle.code.cpp.controlflow.SSA import semmle.code.cpp.controlflow.Guards -from GuardedSsa def, LocalScopeVariable var, Expr other, int k, int start, int end, string op +from GuardedSsa def, StackVariable var, Expr other, int k, int start, int end, string op where exists(BasicBlock block | def.isLt(var, other, k, block, true) and op = "<" diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaPhiInputs.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaPhiInputs.ql index 353b6cd279c..c0ab984f671 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaPhiInputs.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaPhiInputs.ql @@ -8,8 +8,7 @@ import cpp import semmle.code.cpp.controlflow.SSA from - File file, SsaDefinition phi, LocalScopeVariable var, SsaDefinition input, int philine, - int inputline + File file, SsaDefinition phi, StackVariable var, SsaDefinition input, int philine, int inputline where phi.getAPhiInput(var) = input and file = phi.getLocation().getFile() and diff --git a/cpp/ql/test/library-tests/controlflow/controlflow/SsaUniqueness.ql b/cpp/ql/test/library-tests/controlflow/controlflow/SsaUniqueness.ql index bff4301287f..b42b2edf61f 100644 --- a/cpp/ql/test/library-tests/controlflow/controlflow/SsaUniqueness.ql +++ b/cpp/ql/test/library-tests/controlflow/controlflow/SsaUniqueness.ql @@ -12,7 +12,7 @@ import semmle.code.cpp.controlflow.SSA * Should always be zero *regardless* of the input */ -select count(SsaDefinition d1, SsaDefinition d2, Expr u, LocalScopeVariable v | +select count(SsaDefinition d1, SsaDefinition d2, Expr u, StackVariable v | d1.getAUse(v) = u and d2.getAUse(v) = u and not d1 = d2 diff --git a/cpp/ql/test/library-tests/controlflow_stresstest/SsaDefUsePairs.ql b/cpp/ql/test/library-tests/controlflow_stresstest/SsaDefUsePairs.ql index 2328645e098..9bcb32918aa 100644 --- a/cpp/ql/test/library-tests/controlflow_stresstest/SsaDefUsePairs.ql +++ b/cpp/ql/test/library-tests/controlflow_stresstest/SsaDefUsePairs.ql @@ -7,6 +7,6 @@ import cpp import semmle.code.cpp.controlflow.SSA -from SsaDefinition def, LocalScopeVariable var, Expr use +from SsaDefinition def, StackVariable var, Expr use where def.getAUse(var) = use select def, def.toString(var), use diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/uninitialized.ql b/cpp/ql/test/library-tests/dataflow/dataflow-tests/uninitialized.ql index 8be3004152e..71de17cbcf1 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/uninitialized.ql +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/uninitialized.ql @@ -1,5 +1,5 @@ import semmle.code.cpp.dataflow.internal.FlowVar -from LocalScopeVariable var, VariableAccess va +from Variable var, VariableAccess va where FlowVar_internal::mayBeUsedUninitialized(var, va) select var, va diff --git a/cpp/ql/test/library-tests/dataflow/variable/noInit.ql b/cpp/ql/test/library-tests/dataflow/variable/noInit.ql index 8be3004152e..71de17cbcf1 100644 --- a/cpp/ql/test/library-tests/dataflow/variable/noInit.ql +++ b/cpp/ql/test/library-tests/dataflow/variable/noInit.ql @@ -1,5 +1,5 @@ import semmle.code.cpp.dataflow.internal.FlowVar -from LocalScopeVariable var, VariableAccess va +from Variable var, VariableAccess va where FlowVar_internal::mayBeUsedUninitialized(var, va) select var, va diff --git a/cpp/ql/test/library-tests/defuse/definition.ql b/cpp/ql/test/library-tests/defuse/definition.ql index adcf9e68ffa..3bb62428895 100644 --- a/cpp/ql/test/library-tests/defuse/definition.ql +++ b/cpp/ql/test/library-tests/defuse/definition.ql @@ -1,5 +1,5 @@ import cpp -from LocalScopeVariable v, ControlFlowNode d +from StackVariable v, ControlFlowNode d where definition(v, d) select v, d diff --git a/cpp/ql/test/library-tests/defuse/definitionUsePairEquivalence.ql b/cpp/ql/test/library-tests/defuse/definitionUsePairEquivalence.ql index a84e397a97e..2d4474b3302 100644 --- a/cpp/ql/test/library-tests/defuse/definitionUsePairEquivalence.ql +++ b/cpp/ql/test/library-tests/defuse/definitionUsePairEquivalence.ql @@ -1,24 +1,22 @@ import cpp -import semmle.code.cpp.controlflow.LocalScopeVariableReachability +import semmle.code.cpp.controlflow.StackVariableReachability -// Test that def/use algorithm is an instance of LocalScopeVariableReachability -class MyDefOrUse extends LocalScopeVariableReachability { +// Test that def/use algorithm is an instance of StackVariableReachability +class MyDefOrUse extends StackVariableReachability { MyDefOrUse() { this = "MyDefUse" } - override predicate isSource(ControlFlowNode node, LocalScopeVariable v) { definition(v, node) } + override predicate isSource(ControlFlowNode node, StackVariable v) { definition(v, node) } - override predicate isSink(ControlFlowNode node, LocalScopeVariable v) { useOfVar(v, node) } + override predicate isSink(ControlFlowNode node, StackVariable v) { useOfVar(v, node) } - override predicate isBarrier(ControlFlowNode node, LocalScopeVariable v) { - definitionBarrier(v, node) - } + override predicate isBarrier(ControlFlowNode node, StackVariable v) { definitionBarrier(v, node) } } predicate equivalence() { - forall(LocalScopeVariable v, Expr first, Expr second | definitionUsePair(v, first, second) | + forall(StackVariable v, Expr first, Expr second | definitionUsePair(v, first, second) | exists(MyDefOrUse x | x.reaches(first, v, second)) ) and - forall(LocalScopeVariable v, Expr first, Expr second | + forall(StackVariable v, Expr first, Expr second | exists(MyDefOrUse x | x.reaches(first, v, second)) | definitionUsePair(v, first, second) diff --git a/cpp/ql/test/library-tests/defuse/exprDefinition.ql b/cpp/ql/test/library-tests/defuse/exprDefinition.ql index 4bf86e1ae17..531cb0f7436 100644 --- a/cpp/ql/test/library-tests/defuse/exprDefinition.ql +++ b/cpp/ql/test/library-tests/defuse/exprDefinition.ql @@ -1,5 +1,5 @@ import cpp -from LocalScopeVariable v, ControlFlowNode def, Expr e +from StackVariable v, ControlFlowNode def, Expr e where exprDefinition(v, def, e) select v, def, e diff --git a/cpp/ql/test/library-tests/defuse/useOfVar.ql b/cpp/ql/test/library-tests/defuse/useOfVar.ql index c68a1d6d19a..17ea92df3cd 100644 --- a/cpp/ql/test/library-tests/defuse/useOfVar.ql +++ b/cpp/ql/test/library-tests/defuse/useOfVar.ql @@ -1,5 +1,5 @@ import cpp -from LocalScopeVariable v, VariableAccess use +from StackVariable v, VariableAccess use where useOfVar(v, use) select v, use diff --git a/cpp/ql/test/library-tests/defuse/useOfVarActual.ql b/cpp/ql/test/library-tests/defuse/useOfVarActual.ql index d3ce210f780..45794ca661d 100644 --- a/cpp/ql/test/library-tests/defuse/useOfVarActual.ql +++ b/cpp/ql/test/library-tests/defuse/useOfVarActual.ql @@ -1,9 +1,9 @@ import cpp -from LocalScopeVariable v, VariableAccess use +from StackVariable v, VariableAccess use where useOfVarActual(v, use) and // Also check that `useOfVarActual` is a subset of `useOfVar`; if not // the query will not return any results - forall(LocalScopeVariable v0, VariableAccess use0 | useOfVarActual(v0, use0) | useOfVar(v0, use0)) + forall(StackVariable v0, VariableAccess use0 | useOfVarActual(v0, use0) | useOfVar(v0, use0)) select v, use diff --git a/cpp/ql/test/library-tests/ir/ir/raw_ir.expected b/cpp/ql/test/library-tests/ir/ir/raw_ir.expected index 5a70e632d49..28021c12e2d 100644 --- a/cpp/ql/test/library-tests/ir/ir/raw_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/raw_ir.expected @@ -1,1818 +1,1818 @@ bad_asts.cpp: # 9| int Bad::S::MemberFunction(int) # 9| Block 0 -# 9| v0_0(void) = EnterFunction : -# 9| mu0_1(unknown) = AliasedDefinition : -# 9| mu0_2(unknown) = UnmodeledDefinition : -# 9| r0_3(glval) = InitializeThis : -# 9| r0_4(glval) = VariableAddress[y] : -# 9| mu0_5(int) = InitializeParameter[y] : &:r0_4 -# 10| r0_6(glval) = VariableAddress[#return] : -# 10| r0_7(int) = Constant[6] : -#-----| r0_8(S *) = CopyValue : r0_3 -# 10| r0_9(glval) = FieldAddress[x] : r0_8 -# 10| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 10| r0_11(int) = Add : r0_7, r0_10 -# 10| r0_12(glval) = VariableAddress[y] : -# 10| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 10| r0_14(int) = Add : r0_11, r0_13 -# 10| mu0_15(int) = Store : &:r0_6, r0_14 -# 9| r0_16(glval) = VariableAddress[#return] : -# 9| v0_17(void) = ReturnValue : &:r0_16, ~mu0_2 -# 9| v0_18(void) = UnmodeledUse : mu* -# 9| v0_19(void) = AliasedUse : ~mu0_2 -# 9| v0_20(void) = ExitFunction : +# 9| v9_1(void) = EnterFunction : +# 9| mu9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 9| r9_4(glval) = InitializeThis : +# 9| r9_5(glval) = VariableAddress[y] : +# 9| mu9_6(int) = InitializeParameter[y] : &:r9_5 +# 10| r10_1(glval) = VariableAddress[#return] : +# 10| r10_2(int) = Constant[6] : +#-----| r0_27(S *) = CopyValue : r9_4 +# 10| r10_3(glval) = FieldAddress[x] : r0_27 +# 10| r10_4(int) = Load : &:r10_3, ~mu9_3 +# 10| r10_5(int) = Add : r10_2, r10_4 +# 10| r10_6(glval) = VariableAddress[y] : +# 10| r10_7(int) = Load : &:r10_6, ~mu9_3 +# 10| r10_8(int) = Add : r10_5, r10_7 +# 10| mu10_9(int) = Store : &:r10_1, r10_8 +# 9| r9_7(glval) = VariableAddress[#return] : +# 9| v9_8(void) = ReturnValue : &:r9_7, ~mu9_3 +# 9| v9_9(void) = UnmodeledUse : mu* +# 9| v9_10(void) = AliasedUse : ~mu9_3 +# 9| v9_11(void) = ExitFunction : # 14| void Bad::CallBadMemberFunction() # 14| Block 0 -# 14| v0_0(void) = EnterFunction : -# 14| mu0_1(unknown) = AliasedDefinition : -# 14| mu0_2(unknown) = UnmodeledDefinition : -# 15| r0_3(glval) = VariableAddress[s] : -# 15| mu0_4(S) = Uninitialized[s] : &:r0_3 -# 15| r0_5(glval) = FieldAddress[x] : r0_3 -# 15| r0_6(int) = Constant[0] : -# 15| mu0_7(int) = Store : &:r0_5, r0_6 -# 16| r0_8(glval) = VariableAddress[s] : -# 16| r0_9(glval) = FunctionAddress[MemberFunction] : -# 16| r0_10(int) = Constant[1] : -# 16| r0_11(int) = Call : func:r0_9, this:r0_8, 0:r0_10 -# 16| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 16| v0_13(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu0_2 -# 16| mu0_14(S) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 17| v0_15(void) = NoOp : -# 14| v0_16(void) = ReturnVoid : -# 14| v0_17(void) = UnmodeledUse : mu* -# 14| v0_18(void) = AliasedUse : ~mu0_2 -# 14| v0_19(void) = ExitFunction : +# 14| v14_1(void) = EnterFunction : +# 14| mu14_2(unknown) = AliasedDefinition : +# 14| mu14_3(unknown) = UnmodeledDefinition : +# 15| r15_1(glval) = VariableAddress[s] : +# 15| mu15_2(S) = Uninitialized[s] : &:r15_1 +# 15| r15_3(glval) = FieldAddress[x] : r15_1 +# 15| r15_4(int) = Constant[0] : +# 15| mu15_5(int) = Store : &:r15_3, r15_4 +# 16| r16_1(glval) = VariableAddress[s] : +# 16| r16_2(glval) = FunctionAddress[MemberFunction] : +# 16| r16_3(int) = Constant[1] : +# 16| r16_4(int) = Call : func:r16_2, this:r16_1, 0:r16_3 +# 16| mu16_5(unknown) = ^CallSideEffect : ~mu14_3 +# 16| v16_6(void) = ^BufferReadSideEffect[-1] : &:r16_1, ~mu14_3 +# 16| mu16_7(S) = ^IndirectMayWriteSideEffect[-1] : &:r16_1 +# 17| v17_1(void) = NoOp : +# 14| v14_4(void) = ReturnVoid : +# 14| v14_5(void) = UnmodeledUse : mu* +# 14| v14_6(void) = AliasedUse : ~mu14_3 +# 14| v14_7(void) = ExitFunction : # 22| void Bad::Point::Point() # 22| Block 0 -# 22| v0_0(void) = EnterFunction : -# 22| mu0_1(unknown) = AliasedDefinition : -# 22| mu0_2(unknown) = UnmodeledDefinition : -# 22| r0_3(glval) = InitializeThis : -# 23| v0_4(void) = NoOp : -# 22| v0_5(void) = ReturnVoid : -# 22| v0_6(void) = UnmodeledUse : mu* -# 22| v0_7(void) = AliasedUse : ~mu0_2 -# 22| v0_8(void) = ExitFunction : +# 22| v22_1(void) = EnterFunction : +# 22| mu22_2(unknown) = AliasedDefinition : +# 22| mu22_3(unknown) = UnmodeledDefinition : +# 22| r22_4(glval) = InitializeThis : +# 23| v23_1(void) = NoOp : +# 22| v22_5(void) = ReturnVoid : +# 22| v22_6(void) = UnmodeledUse : mu* +# 22| v22_7(void) = AliasedUse : ~mu22_3 +# 22| v22_8(void) = ExitFunction : # 26| void Bad::CallCopyConstructor(Bad::Point const&) # 26| Block 0 -# 26| v0_0(void) = EnterFunction : -# 26| mu0_1(unknown) = AliasedDefinition : -# 26| mu0_2(unknown) = UnmodeledDefinition : -# 26| r0_3(glval) = VariableAddress[a] : -# 26| mu0_4(Point &) = InitializeParameter[a] : &:r0_3 -# 27| r0_5(glval) = VariableAddress[b] : -# 27| r0_6(glval) = VariableAddress[a] : -# 27| r0_7(Point &) = Load : &:r0_6, ~mu0_2 -# 27| r0_8(glval) = CopyValue : r0_7 -# 27| r0_9(glval) = Convert : r0_8 -# 27| r0_10(Point) = Load : &:r0_9, ~mu0_2 -# 27| mu0_11(Point) = Store : &:r0_5, r0_10 -# 28| v0_12(void) = NoOp : -# 26| v0_13(void) = ReturnVoid : -# 26| v0_14(void) = UnmodeledUse : mu* -# 26| v0_15(void) = AliasedUse : ~mu0_2 -# 26| v0_16(void) = ExitFunction : +# 26| v26_1(void) = EnterFunction : +# 26| mu26_2(unknown) = AliasedDefinition : +# 26| mu26_3(unknown) = UnmodeledDefinition : +# 26| r26_4(glval) = VariableAddress[a] : +# 26| mu26_5(Point &) = InitializeParameter[a] : &:r26_4 +# 27| r27_1(glval) = VariableAddress[b] : +# 27| r27_2(glval) = VariableAddress[a] : +# 27| r27_3(Point &) = Load : &:r27_2, ~mu26_3 +# 27| r27_4(glval) = CopyValue : r27_3 +# 27| r27_5(glval) = Convert : r27_4 +# 27| r27_6(Point) = Load : &:r27_5, ~mu26_3 +# 27| mu27_7(Point) = Store : &:r27_1, r27_6 +# 28| v28_1(void) = NoOp : +# 26| v26_6(void) = ReturnVoid : +# 26| v26_7(void) = UnmodeledUse : mu* +# 26| v26_8(void) = AliasedUse : ~mu26_3 +# 26| v26_9(void) = ExitFunction : # 30| void Bad::errorExpr() # 30| Block 0 -# 30| v0_0(void) = EnterFunction : -# 30| mu0_1(unknown) = AliasedDefinition : -# 30| mu0_2(unknown) = UnmodeledDefinition : -# 31| r0_3(glval) = VariableAddress[intref] : -# 31| r0_4(error) = Error : -# 31| mu0_5(int &) = Store : &:r0_3, r0_4 -# 32| r0_6(glval) = VariableAddress[x] : -# 32| r0_7(error) = Error : -# 32| mu0_8(int) = Store : &:r0_6, r0_7 -#-----| r0_9(glval) = Error : -#-----| r0_10(error) = Load : &:r0_9, ~mu0_2 -# 33| r0_11(glval) = VariableAddress[x] : -# 33| mu0_12(int) = Store : &:r0_11, r0_10 -# 34| v0_13(void) = NoOp : -# 30| v0_14(void) = ReturnVoid : -# 30| v0_15(void) = UnmodeledUse : mu* -# 30| v0_16(void) = AliasedUse : ~mu0_2 -# 30| v0_17(void) = ExitFunction : +# 30| v30_1(void) = EnterFunction : +# 30| mu30_2(unknown) = AliasedDefinition : +# 30| mu30_3(unknown) = UnmodeledDefinition : +# 31| r31_1(glval) = VariableAddress[intref] : +# 31| r31_2(error) = Error : +# 31| mu31_3(int &) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[x] : +# 32| r32_2(error) = Error : +# 32| mu32_3(int) = Store : &:r32_1, r32_2 +#-----| r0_36(glval) = Error : +#-----| r0_43(error) = Load : &:r0_36, ~mu30_3 +# 33| r33_1(glval) = VariableAddress[x] : +# 33| mu33_2(int) = Store : &:r33_1, r0_43 +# 34| v34_1(void) = NoOp : +# 30| v30_4(void) = ReturnVoid : +# 30| v30_5(void) = UnmodeledUse : mu* +# 30| v30_6(void) = AliasedUse : ~mu30_3 +# 30| v30_7(void) = ExitFunction : clang.cpp: # 5| int* globalIntAddress() # 5| Block 0 -# 5| v0_0(void) = EnterFunction : -# 5| mu0_1(unknown) = AliasedDefinition : -# 5| mu0_2(unknown) = UnmodeledDefinition : -# 6| r0_3(glval) = VariableAddress[#return] : -# 6| r0_4(glval) = VariableAddress[globalInt] : -# 6| r0_5(int *) = CopyValue : r0_4 -# 6| mu0_6(int *) = Store : &:r0_3, r0_5 -# 5| r0_7(glval) = VariableAddress[#return] : -# 5| v0_8(void) = ReturnValue : &:r0_7, ~mu0_2 -# 5| v0_9(void) = UnmodeledUse : mu* -# 5| v0_10(void) = AliasedUse : ~mu0_2 -# 5| v0_11(void) = ExitFunction : +# 5| v5_1(void) = EnterFunction : +# 5| mu5_2(unknown) = AliasedDefinition : +# 5| mu5_3(unknown) = UnmodeledDefinition : +# 6| r6_1(glval) = VariableAddress[#return] : +# 6| r6_2(glval) = VariableAddress[globalInt] : +# 6| r6_3(int *) = CopyValue : r6_2 +# 6| mu6_4(int *) = Store : &:r6_1, r6_3 +# 5| r5_4(glval) = VariableAddress[#return] : +# 5| v5_5(void) = ReturnValue : &:r5_4, ~mu5_3 +# 5| v5_6(void) = UnmodeledUse : mu* +# 5| v5_7(void) = AliasedUse : ~mu5_3 +# 5| v5_8(void) = ExitFunction : ir.cpp: # 1| void Constants() # 1| Block 0 -# 1| v0_0(void) = EnterFunction : -# 1| mu0_1(unknown) = AliasedDefinition : -# 1| mu0_2(unknown) = UnmodeledDefinition : -# 2| r0_3(glval) = VariableAddress[c_i] : -# 2| r0_4(char) = Constant[1] : -# 2| mu0_5(char) = Store : &:r0_3, r0_4 -# 3| r0_6(glval) = VariableAddress[c_c] : -# 3| r0_7(char) = Constant[65] : -# 3| mu0_8(char) = Store : &:r0_6, r0_7 -# 5| r0_9(glval) = VariableAddress[sc_i] : -# 5| r0_10(signed char) = Constant[-1] : -# 5| mu0_11(signed char) = Store : &:r0_9, r0_10 -# 6| r0_12(glval) = VariableAddress[sc_c] : -# 6| r0_13(signed char) = Constant[65] : -# 6| mu0_14(signed char) = Store : &:r0_12, r0_13 -# 8| r0_15(glval) = VariableAddress[uc_i] : -# 8| r0_16(unsigned char) = Constant[5] : -# 8| mu0_17(unsigned char) = Store : &:r0_15, r0_16 -# 9| r0_18(glval) = VariableAddress[uc_c] : -# 9| r0_19(unsigned char) = Constant[65] : -# 9| mu0_20(unsigned char) = Store : &:r0_18, r0_19 -# 11| r0_21(glval) = VariableAddress[s] : -# 11| r0_22(short) = Constant[5] : -# 11| mu0_23(short) = Store : &:r0_21, r0_22 -# 12| r0_24(glval) = VariableAddress[us] : -# 12| r0_25(unsigned short) = Constant[5] : -# 12| mu0_26(unsigned short) = Store : &:r0_24, r0_25 -# 14| r0_27(glval) = VariableAddress[i] : -# 14| r0_28(int) = Constant[5] : -# 14| mu0_29(int) = Store : &:r0_27, r0_28 -# 15| r0_30(glval) = VariableAddress[ui] : -# 15| r0_31(unsigned int) = Constant[5] : -# 15| mu0_32(unsigned int) = Store : &:r0_30, r0_31 -# 17| r0_33(glval) = VariableAddress[l] : -# 17| r0_34(long) = Constant[5] : -# 17| mu0_35(long) = Store : &:r0_33, r0_34 -# 18| r0_36(glval) = VariableAddress[ul] : -# 18| r0_37(unsigned long) = Constant[5] : -# 18| mu0_38(unsigned long) = Store : &:r0_36, r0_37 -# 20| r0_39(glval) = VariableAddress[ll_i] : -# 20| r0_40(long long) = Constant[5] : -# 20| mu0_41(long long) = Store : &:r0_39, r0_40 -# 21| r0_42(glval) = VariableAddress[ll_ll] : -# 21| r0_43(long long) = Constant[5] : -# 21| mu0_44(long long) = Store : &:r0_42, r0_43 -# 22| r0_45(glval) = VariableAddress[ull_i] : -# 22| r0_46(unsigned long long) = Constant[5] : -# 22| mu0_47(unsigned long long) = Store : &:r0_45, r0_46 -# 23| r0_48(glval) = VariableAddress[ull_ull] : -# 23| r0_49(unsigned long long) = Constant[5] : -# 23| mu0_50(unsigned long long) = Store : &:r0_48, r0_49 -# 25| r0_51(glval) = VariableAddress[b_t] : -# 25| r0_52(bool) = Constant[1] : -# 25| mu0_53(bool) = Store : &:r0_51, r0_52 -# 26| r0_54(glval) = VariableAddress[b_f] : -# 26| r0_55(bool) = Constant[0] : -# 26| mu0_56(bool) = Store : &:r0_54, r0_55 -# 28| r0_57(glval) = VariableAddress[wc_i] : -# 28| r0_58(wchar_t) = Constant[5] : -# 28| mu0_59(wchar_t) = Store : &:r0_57, r0_58 -# 29| r0_60(glval) = VariableAddress[wc_c] : -# 29| r0_61(wchar_t) = Constant[65] : -# 29| mu0_62(wchar_t) = Store : &:r0_60, r0_61 -# 31| r0_63(glval) = VariableAddress[c16] : -# 31| r0_64(char16_t) = Constant[65] : -# 31| mu0_65(char16_t) = Store : &:r0_63, r0_64 -# 32| r0_66(glval) = VariableAddress[c32] : -# 32| r0_67(char32_t) = Constant[65] : -# 32| mu0_68(char32_t) = Store : &:r0_66, r0_67 -# 34| r0_69(glval) = VariableAddress[f_i] : -# 34| r0_70(float) = Constant[1.0] : -# 34| mu0_71(float) = Store : &:r0_69, r0_70 -# 35| r0_72(glval) = VariableAddress[f_f] : -# 35| r0_73(float) = Constant[1.0] : -# 35| mu0_74(float) = Store : &:r0_72, r0_73 -# 36| r0_75(glval) = VariableAddress[f_d] : -# 36| r0_76(float) = Constant[1.0] : -# 36| mu0_77(float) = Store : &:r0_75, r0_76 -# 38| r0_78(glval) = VariableAddress[d_i] : -# 38| r0_79(double) = Constant[1.0] : -# 38| mu0_80(double) = Store : &:r0_78, r0_79 -# 39| r0_81(glval) = VariableAddress[d_f] : -# 39| r0_82(double) = Constant[1.0] : -# 39| mu0_83(double) = Store : &:r0_81, r0_82 -# 40| r0_84(glval) = VariableAddress[d_d] : -# 40| r0_85(double) = Constant[1.0] : -# 40| mu0_86(double) = Store : &:r0_84, r0_85 -# 41| v0_87(void) = NoOp : -# 1| v0_88(void) = ReturnVoid : -# 1| v0_89(void) = UnmodeledUse : mu* -# 1| v0_90(void) = AliasedUse : ~mu0_2 -# 1| v0_91(void) = ExitFunction : +# 1| v1_1(void) = EnterFunction : +# 1| mu1_2(unknown) = AliasedDefinition : +# 1| mu1_3(unknown) = UnmodeledDefinition : +# 2| r2_1(glval) = VariableAddress[c_i] : +# 2| r2_2(char) = Constant[1] : +# 2| mu2_3(char) = Store : &:r2_1, r2_2 +# 3| r3_1(glval) = VariableAddress[c_c] : +# 3| r3_2(char) = Constant[65] : +# 3| mu3_3(char) = Store : &:r3_1, r3_2 +# 5| r5_1(glval) = VariableAddress[sc_i] : +# 5| r5_2(signed char) = Constant[-1] : +# 5| mu5_3(signed char) = Store : &:r5_1, r5_2 +# 6| r6_1(glval) = VariableAddress[sc_c] : +# 6| r6_2(signed char) = Constant[65] : +# 6| mu6_3(signed char) = Store : &:r6_1, r6_2 +# 8| r8_1(glval) = VariableAddress[uc_i] : +# 8| r8_2(unsigned char) = Constant[5] : +# 8| mu8_3(unsigned char) = Store : &:r8_1, r8_2 +# 9| r9_1(glval) = VariableAddress[uc_c] : +# 9| r9_2(unsigned char) = Constant[65] : +# 9| mu9_3(unsigned char) = Store : &:r9_1, r9_2 +# 11| r11_1(glval) = VariableAddress[s] : +# 11| r11_2(short) = Constant[5] : +# 11| mu11_3(short) = Store : &:r11_1, r11_2 +# 12| r12_1(glval) = VariableAddress[us] : +# 12| r12_2(unsigned short) = Constant[5] : +# 12| mu12_3(unsigned short) = Store : &:r12_1, r12_2 +# 14| r14_1(glval) = VariableAddress[i] : +# 14| r14_2(int) = Constant[5] : +# 14| mu14_3(int) = Store : &:r14_1, r14_2 +# 15| r15_1(glval) = VariableAddress[ui] : +# 15| r15_2(unsigned int) = Constant[5] : +# 15| mu15_3(unsigned int) = Store : &:r15_1, r15_2 +# 17| r17_1(glval) = VariableAddress[l] : +# 17| r17_2(long) = Constant[5] : +# 17| mu17_3(long) = Store : &:r17_1, r17_2 +# 18| r18_1(glval) = VariableAddress[ul] : +# 18| r18_2(unsigned long) = Constant[5] : +# 18| mu18_3(unsigned long) = Store : &:r18_1, r18_2 +# 20| r20_1(glval) = VariableAddress[ll_i] : +# 20| r20_2(long long) = Constant[5] : +# 20| mu20_3(long long) = Store : &:r20_1, r20_2 +# 21| r21_1(glval) = VariableAddress[ll_ll] : +# 21| r21_2(long long) = Constant[5] : +# 21| mu21_3(long long) = Store : &:r21_1, r21_2 +# 22| r22_1(glval) = VariableAddress[ull_i] : +# 22| r22_2(unsigned long long) = Constant[5] : +# 22| mu22_3(unsigned long long) = Store : &:r22_1, r22_2 +# 23| r23_1(glval) = VariableAddress[ull_ull] : +# 23| r23_2(unsigned long long) = Constant[5] : +# 23| mu23_3(unsigned long long) = Store : &:r23_1, r23_2 +# 25| r25_1(glval) = VariableAddress[b_t] : +# 25| r25_2(bool) = Constant[1] : +# 25| mu25_3(bool) = Store : &:r25_1, r25_2 +# 26| r26_1(glval) = VariableAddress[b_f] : +# 26| r26_2(bool) = Constant[0] : +# 26| mu26_3(bool) = Store : &:r26_1, r26_2 +# 28| r28_1(glval) = VariableAddress[wc_i] : +# 28| r28_2(wchar_t) = Constant[5] : +# 28| mu28_3(wchar_t) = Store : &:r28_1, r28_2 +# 29| r29_1(glval) = VariableAddress[wc_c] : +# 29| r29_2(wchar_t) = Constant[65] : +# 29| mu29_3(wchar_t) = Store : &:r29_1, r29_2 +# 31| r31_1(glval) = VariableAddress[c16] : +# 31| r31_2(char16_t) = Constant[65] : +# 31| mu31_3(char16_t) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[c32] : +# 32| r32_2(char32_t) = Constant[65] : +# 32| mu32_3(char32_t) = Store : &:r32_1, r32_2 +# 34| r34_1(glval) = VariableAddress[f_i] : +# 34| r34_2(float) = Constant[1.0] : +# 34| mu34_3(float) = Store : &:r34_1, r34_2 +# 35| r35_1(glval) = VariableAddress[f_f] : +# 35| r35_2(float) = Constant[1.0] : +# 35| mu35_3(float) = Store : &:r35_1, r35_2 +# 36| r36_1(glval) = VariableAddress[f_d] : +# 36| r36_2(float) = Constant[1.0] : +# 36| mu36_3(float) = Store : &:r36_1, r36_2 +# 38| r38_1(glval) = VariableAddress[d_i] : +# 38| r38_2(double) = Constant[1.0] : +# 38| mu38_3(double) = Store : &:r38_1, r38_2 +# 39| r39_1(glval) = VariableAddress[d_f] : +# 39| r39_2(double) = Constant[1.0] : +# 39| mu39_3(double) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[d_d] : +# 40| r40_2(double) = Constant[1.0] : +# 40| mu40_3(double) = Store : &:r40_1, r40_2 +# 41| v41_1(void) = NoOp : +# 1| v1_4(void) = ReturnVoid : +# 1| v1_5(void) = UnmodeledUse : mu* +# 1| v1_6(void) = AliasedUse : ~mu1_3 +# 1| v1_7(void) = ExitFunction : # 43| void Foo() # 43| Block 0 -# 43| v0_0(void) = EnterFunction : -# 43| mu0_1(unknown) = AliasedDefinition : -# 43| mu0_2(unknown) = UnmodeledDefinition : -# 44| r0_3(glval) = VariableAddress[x] : -# 44| r0_4(int) = Constant[17] : -# 44| mu0_5(int) = Store : &:r0_3, r0_4 -# 45| r0_6(glval) = VariableAddress[y] : -# 45| r0_7(short) = Constant[7] : -# 45| mu0_8(short) = Store : &:r0_6, r0_7 -# 46| r0_9(glval) = VariableAddress[x] : -# 46| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 46| r0_11(glval) = VariableAddress[y] : -# 46| r0_12(short) = Load : &:r0_11, ~mu0_2 -# 46| r0_13(int) = Convert : r0_12 -# 46| r0_14(int) = Add : r0_10, r0_13 -# 46| r0_15(short) = Convert : r0_14 -# 46| r0_16(glval) = VariableAddress[y] : -# 46| mu0_17(short) = Store : &:r0_16, r0_15 -# 47| r0_18(glval) = VariableAddress[x] : -# 47| r0_19(int) = Load : &:r0_18, ~mu0_2 -# 47| r0_20(glval) = VariableAddress[y] : -# 47| r0_21(short) = Load : &:r0_20, ~mu0_2 -# 47| r0_22(int) = Convert : r0_21 -# 47| r0_23(int) = Mul : r0_19, r0_22 -# 47| r0_24(glval) = VariableAddress[x] : -# 47| mu0_25(int) = Store : &:r0_24, r0_23 -# 48| v0_26(void) = NoOp : -# 43| v0_27(void) = ReturnVoid : -# 43| v0_28(void) = UnmodeledUse : mu* -# 43| v0_29(void) = AliasedUse : ~mu0_2 -# 43| v0_30(void) = ExitFunction : +# 43| v43_1(void) = EnterFunction : +# 43| mu43_2(unknown) = AliasedDefinition : +# 43| mu43_3(unknown) = UnmodeledDefinition : +# 44| r44_1(glval) = VariableAddress[x] : +# 44| r44_2(int) = Constant[17] : +# 44| mu44_3(int) = Store : &:r44_1, r44_2 +# 45| r45_1(glval) = VariableAddress[y] : +# 45| r45_2(short) = Constant[7] : +# 45| mu45_3(short) = Store : &:r45_1, r45_2 +# 46| r46_1(glval) = VariableAddress[x] : +# 46| r46_2(int) = Load : &:r46_1, ~mu43_3 +# 46| r46_3(glval) = VariableAddress[y] : +# 46| r46_4(short) = Load : &:r46_3, ~mu43_3 +# 46| r46_5(int) = Convert : r46_4 +# 46| r46_6(int) = Add : r46_2, r46_5 +# 46| r46_7(short) = Convert : r46_6 +# 46| r46_8(glval) = VariableAddress[y] : +# 46| mu46_9(short) = Store : &:r46_8, r46_7 +# 47| r47_1(glval) = VariableAddress[x] : +# 47| r47_2(int) = Load : &:r47_1, ~mu43_3 +# 47| r47_3(glval) = VariableAddress[y] : +# 47| r47_4(short) = Load : &:r47_3, ~mu43_3 +# 47| r47_5(int) = Convert : r47_4 +# 47| r47_6(int) = Mul : r47_2, r47_5 +# 47| r47_7(glval) = VariableAddress[x] : +# 47| mu47_8(int) = Store : &:r47_7, r47_6 +# 48| v48_1(void) = NoOp : +# 43| v43_4(void) = ReturnVoid : +# 43| v43_5(void) = UnmodeledUse : mu* +# 43| v43_6(void) = AliasedUse : ~mu43_3 +# 43| v43_7(void) = ExitFunction : # 50| void IntegerOps(int, int) # 50| Block 0 -# 50| v0_0(void) = EnterFunction : -# 50| mu0_1(unknown) = AliasedDefinition : -# 50| mu0_2(unknown) = UnmodeledDefinition : -# 50| r0_3(glval) = VariableAddress[x] : -# 50| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 50| r0_5(glval) = VariableAddress[y] : -# 50| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 51| r0_7(glval) = VariableAddress[z] : -# 51| mu0_8(int) = Uninitialized[z] : &:r0_7 -# 53| r0_9(glval) = VariableAddress[x] : -# 53| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 53| r0_11(glval) = VariableAddress[y] : -# 53| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 53| r0_13(int) = Add : r0_10, r0_12 -# 53| r0_14(glval) = VariableAddress[z] : -# 53| mu0_15(int) = Store : &:r0_14, r0_13 -# 54| r0_16(glval) = VariableAddress[x] : -# 54| r0_17(int) = Load : &:r0_16, ~mu0_2 -# 54| r0_18(glval) = VariableAddress[y] : -# 54| r0_19(int) = Load : &:r0_18, ~mu0_2 -# 54| r0_20(int) = Sub : r0_17, r0_19 -# 54| r0_21(glval) = VariableAddress[z] : -# 54| mu0_22(int) = Store : &:r0_21, r0_20 -# 55| r0_23(glval) = VariableAddress[x] : -# 55| r0_24(int) = Load : &:r0_23, ~mu0_2 -# 55| r0_25(glval) = VariableAddress[y] : -# 55| r0_26(int) = Load : &:r0_25, ~mu0_2 -# 55| r0_27(int) = Mul : r0_24, r0_26 -# 55| r0_28(glval) = VariableAddress[z] : -# 55| mu0_29(int) = Store : &:r0_28, r0_27 -# 56| r0_30(glval) = VariableAddress[x] : -# 56| r0_31(int) = Load : &:r0_30, ~mu0_2 -# 56| r0_32(glval) = VariableAddress[y] : -# 56| r0_33(int) = Load : &:r0_32, ~mu0_2 -# 56| r0_34(int) = Div : r0_31, r0_33 -# 56| r0_35(glval) = VariableAddress[z] : -# 56| mu0_36(int) = Store : &:r0_35, r0_34 -# 57| r0_37(glval) = VariableAddress[x] : -# 57| r0_38(int) = Load : &:r0_37, ~mu0_2 -# 57| r0_39(glval) = VariableAddress[y] : -# 57| r0_40(int) = Load : &:r0_39, ~mu0_2 -# 57| r0_41(int) = Rem : r0_38, r0_40 -# 57| r0_42(glval) = VariableAddress[z] : -# 57| mu0_43(int) = Store : &:r0_42, r0_41 -# 59| r0_44(glval) = VariableAddress[x] : -# 59| r0_45(int) = Load : &:r0_44, ~mu0_2 -# 59| r0_46(glval) = VariableAddress[y] : -# 59| r0_47(int) = Load : &:r0_46, ~mu0_2 -# 59| r0_48(int) = BitAnd : r0_45, r0_47 -# 59| r0_49(glval) = VariableAddress[z] : -# 59| mu0_50(int) = Store : &:r0_49, r0_48 -# 60| r0_51(glval) = VariableAddress[x] : -# 60| r0_52(int) = Load : &:r0_51, ~mu0_2 -# 60| r0_53(glval) = VariableAddress[y] : -# 60| r0_54(int) = Load : &:r0_53, ~mu0_2 -# 60| r0_55(int) = BitOr : r0_52, r0_54 -# 60| r0_56(glval) = VariableAddress[z] : -# 60| mu0_57(int) = Store : &:r0_56, r0_55 -# 61| r0_58(glval) = VariableAddress[x] : -# 61| r0_59(int) = Load : &:r0_58, ~mu0_2 -# 61| r0_60(glval) = VariableAddress[y] : -# 61| r0_61(int) = Load : &:r0_60, ~mu0_2 -# 61| r0_62(int) = BitXor : r0_59, r0_61 -# 61| r0_63(glval) = VariableAddress[z] : -# 61| mu0_64(int) = Store : &:r0_63, r0_62 -# 63| r0_65(glval) = VariableAddress[x] : -# 63| r0_66(int) = Load : &:r0_65, ~mu0_2 -# 63| r0_67(glval) = VariableAddress[y] : -# 63| r0_68(int) = Load : &:r0_67, ~mu0_2 -# 63| r0_69(int) = ShiftLeft : r0_66, r0_68 -# 63| r0_70(glval) = VariableAddress[z] : -# 63| mu0_71(int) = Store : &:r0_70, r0_69 -# 64| r0_72(glval) = VariableAddress[x] : -# 64| r0_73(int) = Load : &:r0_72, ~mu0_2 -# 64| r0_74(glval) = VariableAddress[y] : -# 64| r0_75(int) = Load : &:r0_74, ~mu0_2 -# 64| r0_76(int) = ShiftRight : r0_73, r0_75 -# 64| r0_77(glval) = VariableAddress[z] : -# 64| mu0_78(int) = Store : &:r0_77, r0_76 -# 66| r0_79(glval) = VariableAddress[x] : -# 66| r0_80(int) = Load : &:r0_79, ~mu0_2 -# 66| r0_81(glval) = VariableAddress[z] : -# 66| mu0_82(int) = Store : &:r0_81, r0_80 -# 68| r0_83(glval) = VariableAddress[x] : -# 68| r0_84(int) = Load : &:r0_83, ~mu0_2 -# 68| r0_85(glval) = VariableAddress[z] : -# 68| r0_86(int) = Load : &:r0_85, ~mu0_2 -# 68| r0_87(int) = Add : r0_86, r0_84 -# 68| mu0_88(int) = Store : &:r0_85, r0_87 -# 69| r0_89(glval) = VariableAddress[x] : -# 69| r0_90(int) = Load : &:r0_89, ~mu0_2 -# 69| r0_91(glval) = VariableAddress[z] : -# 69| r0_92(int) = Load : &:r0_91, ~mu0_2 -# 69| r0_93(int) = Sub : r0_92, r0_90 -# 69| mu0_94(int) = Store : &:r0_91, r0_93 -# 70| r0_95(glval) = VariableAddress[x] : -# 70| r0_96(int) = Load : &:r0_95, ~mu0_2 -# 70| r0_97(glval) = VariableAddress[z] : -# 70| r0_98(int) = Load : &:r0_97, ~mu0_2 -# 70| r0_99(int) = Mul : r0_98, r0_96 -# 70| mu0_100(int) = Store : &:r0_97, r0_99 -# 71| r0_101(glval) = VariableAddress[x] : -# 71| r0_102(int) = Load : &:r0_101, ~mu0_2 -# 71| r0_103(glval) = VariableAddress[z] : -# 71| r0_104(int) = Load : &:r0_103, ~mu0_2 -# 71| r0_105(int) = Div : r0_104, r0_102 -# 71| mu0_106(int) = Store : &:r0_103, r0_105 -# 72| r0_107(glval) = VariableAddress[x] : -# 72| r0_108(int) = Load : &:r0_107, ~mu0_2 -# 72| r0_109(glval) = VariableAddress[z] : -# 72| r0_110(int) = Load : &:r0_109, ~mu0_2 -# 72| r0_111(int) = Rem : r0_110, r0_108 -# 72| mu0_112(int) = Store : &:r0_109, r0_111 -# 74| r0_113(glval) = VariableAddress[x] : -# 74| r0_114(int) = Load : &:r0_113, ~mu0_2 -# 74| r0_115(glval) = VariableAddress[z] : -# 74| r0_116(int) = Load : &:r0_115, ~mu0_2 -# 74| r0_117(int) = BitAnd : r0_116, r0_114 -# 74| mu0_118(int) = Store : &:r0_115, r0_117 -# 75| r0_119(glval) = VariableAddress[x] : -# 75| r0_120(int) = Load : &:r0_119, ~mu0_2 -# 75| r0_121(glval) = VariableAddress[z] : -# 75| r0_122(int) = Load : &:r0_121, ~mu0_2 -# 75| r0_123(int) = BitOr : r0_122, r0_120 -# 75| mu0_124(int) = Store : &:r0_121, r0_123 -# 76| r0_125(glval) = VariableAddress[x] : -# 76| r0_126(int) = Load : &:r0_125, ~mu0_2 -# 76| r0_127(glval) = VariableAddress[z] : -# 76| r0_128(int) = Load : &:r0_127, ~mu0_2 -# 76| r0_129(int) = BitXor : r0_128, r0_126 -# 76| mu0_130(int) = Store : &:r0_127, r0_129 -# 78| r0_131(glval) = VariableAddress[x] : -# 78| r0_132(int) = Load : &:r0_131, ~mu0_2 -# 78| r0_133(glval) = VariableAddress[z] : -# 78| r0_134(int) = Load : &:r0_133, ~mu0_2 -# 78| r0_135(int) = ShiftLeft : r0_134, r0_132 -# 78| mu0_136(int) = Store : &:r0_133, r0_135 -# 79| r0_137(glval) = VariableAddress[x] : -# 79| r0_138(int) = Load : &:r0_137, ~mu0_2 -# 79| r0_139(glval) = VariableAddress[z] : -# 79| r0_140(int) = Load : &:r0_139, ~mu0_2 -# 79| r0_141(int) = ShiftRight : r0_140, r0_138 -# 79| mu0_142(int) = Store : &:r0_139, r0_141 -# 81| r0_143(glval) = VariableAddress[x] : -# 81| r0_144(int) = Load : &:r0_143, ~mu0_2 -# 81| r0_145(int) = CopyValue : r0_144 -# 81| r0_146(glval) = VariableAddress[z] : -# 81| mu0_147(int) = Store : &:r0_146, r0_145 -# 82| r0_148(glval) = VariableAddress[x] : -# 82| r0_149(int) = Load : &:r0_148, ~mu0_2 -# 82| r0_150(int) = Negate : r0_149 -# 82| r0_151(glval) = VariableAddress[z] : -# 82| mu0_152(int) = Store : &:r0_151, r0_150 -# 83| r0_153(glval) = VariableAddress[x] : -# 83| r0_154(int) = Load : &:r0_153, ~mu0_2 -# 83| r0_155(int) = BitComplement : r0_154 -# 83| r0_156(glval) = VariableAddress[z] : -# 83| mu0_157(int) = Store : &:r0_156, r0_155 -# 84| r0_158(glval) = VariableAddress[x] : -# 84| r0_159(int) = Load : &:r0_158, ~mu0_2 -# 84| r0_160(int) = Constant[0] : -# 84| r0_161(bool) = CompareNE : r0_159, r0_160 -# 84| r0_162(bool) = LogicalNot : r0_161 -# 84| r0_163(int) = Convert : r0_162 -# 84| r0_164(glval) = VariableAddress[z] : -# 84| mu0_165(int) = Store : &:r0_164, r0_163 -# 85| v0_166(void) = NoOp : -# 50| v0_167(void) = ReturnVoid : -# 50| v0_168(void) = UnmodeledUse : mu* -# 50| v0_169(void) = AliasedUse : ~mu0_2 -# 50| v0_170(void) = ExitFunction : +# 50| v50_1(void) = EnterFunction : +# 50| mu50_2(unknown) = AliasedDefinition : +# 50| mu50_3(unknown) = UnmodeledDefinition : +# 50| r50_4(glval) = VariableAddress[x] : +# 50| mu50_5(int) = InitializeParameter[x] : &:r50_4 +# 50| r50_6(glval) = VariableAddress[y] : +# 50| mu50_7(int) = InitializeParameter[y] : &:r50_6 +# 51| r51_1(glval) = VariableAddress[z] : +# 51| mu51_2(int) = Uninitialized[z] : &:r51_1 +# 53| r53_1(glval) = VariableAddress[x] : +# 53| r53_2(int) = Load : &:r53_1, ~mu50_3 +# 53| r53_3(glval) = VariableAddress[y] : +# 53| r53_4(int) = Load : &:r53_3, ~mu50_3 +# 53| r53_5(int) = Add : r53_2, r53_4 +# 53| r53_6(glval) = VariableAddress[z] : +# 53| mu53_7(int) = Store : &:r53_6, r53_5 +# 54| r54_1(glval) = VariableAddress[x] : +# 54| r54_2(int) = Load : &:r54_1, ~mu50_3 +# 54| r54_3(glval) = VariableAddress[y] : +# 54| r54_4(int) = Load : &:r54_3, ~mu50_3 +# 54| r54_5(int) = Sub : r54_2, r54_4 +# 54| r54_6(glval) = VariableAddress[z] : +# 54| mu54_7(int) = Store : &:r54_6, r54_5 +# 55| r55_1(glval) = VariableAddress[x] : +# 55| r55_2(int) = Load : &:r55_1, ~mu50_3 +# 55| r55_3(glval) = VariableAddress[y] : +# 55| r55_4(int) = Load : &:r55_3, ~mu50_3 +# 55| r55_5(int) = Mul : r55_2, r55_4 +# 55| r55_6(glval) = VariableAddress[z] : +# 55| mu55_7(int) = Store : &:r55_6, r55_5 +# 56| r56_1(glval) = VariableAddress[x] : +# 56| r56_2(int) = Load : &:r56_1, ~mu50_3 +# 56| r56_3(glval) = VariableAddress[y] : +# 56| r56_4(int) = Load : &:r56_3, ~mu50_3 +# 56| r56_5(int) = Div : r56_2, r56_4 +# 56| r56_6(glval) = VariableAddress[z] : +# 56| mu56_7(int) = Store : &:r56_6, r56_5 +# 57| r57_1(glval) = VariableAddress[x] : +# 57| r57_2(int) = Load : &:r57_1, ~mu50_3 +# 57| r57_3(glval) = VariableAddress[y] : +# 57| r57_4(int) = Load : &:r57_3, ~mu50_3 +# 57| r57_5(int) = Rem : r57_2, r57_4 +# 57| r57_6(glval) = VariableAddress[z] : +# 57| mu57_7(int) = Store : &:r57_6, r57_5 +# 59| r59_1(glval) = VariableAddress[x] : +# 59| r59_2(int) = Load : &:r59_1, ~mu50_3 +# 59| r59_3(glval) = VariableAddress[y] : +# 59| r59_4(int) = Load : &:r59_3, ~mu50_3 +# 59| r59_5(int) = BitAnd : r59_2, r59_4 +# 59| r59_6(glval) = VariableAddress[z] : +# 59| mu59_7(int) = Store : &:r59_6, r59_5 +# 60| r60_1(glval) = VariableAddress[x] : +# 60| r60_2(int) = Load : &:r60_1, ~mu50_3 +# 60| r60_3(glval) = VariableAddress[y] : +# 60| r60_4(int) = Load : &:r60_3, ~mu50_3 +# 60| r60_5(int) = BitOr : r60_2, r60_4 +# 60| r60_6(glval) = VariableAddress[z] : +# 60| mu60_7(int) = Store : &:r60_6, r60_5 +# 61| r61_1(glval) = VariableAddress[x] : +# 61| r61_2(int) = Load : &:r61_1, ~mu50_3 +# 61| r61_3(glval) = VariableAddress[y] : +# 61| r61_4(int) = Load : &:r61_3, ~mu50_3 +# 61| r61_5(int) = BitXor : r61_2, r61_4 +# 61| r61_6(glval) = VariableAddress[z] : +# 61| mu61_7(int) = Store : &:r61_6, r61_5 +# 63| r63_1(glval) = VariableAddress[x] : +# 63| r63_2(int) = Load : &:r63_1, ~mu50_3 +# 63| r63_3(glval) = VariableAddress[y] : +# 63| r63_4(int) = Load : &:r63_3, ~mu50_3 +# 63| r63_5(int) = ShiftLeft : r63_2, r63_4 +# 63| r63_6(glval) = VariableAddress[z] : +# 63| mu63_7(int) = Store : &:r63_6, r63_5 +# 64| r64_1(glval) = VariableAddress[x] : +# 64| r64_2(int) = Load : &:r64_1, ~mu50_3 +# 64| r64_3(glval) = VariableAddress[y] : +# 64| r64_4(int) = Load : &:r64_3, ~mu50_3 +# 64| r64_5(int) = ShiftRight : r64_2, r64_4 +# 64| r64_6(glval) = VariableAddress[z] : +# 64| mu64_7(int) = Store : &:r64_6, r64_5 +# 66| r66_1(glval) = VariableAddress[x] : +# 66| r66_2(int) = Load : &:r66_1, ~mu50_3 +# 66| r66_3(glval) = VariableAddress[z] : +# 66| mu66_4(int) = Store : &:r66_3, r66_2 +# 68| r68_1(glval) = VariableAddress[x] : +# 68| r68_2(int) = Load : &:r68_1, ~mu50_3 +# 68| r68_3(glval) = VariableAddress[z] : +# 68| r68_4(int) = Load : &:r68_3, ~mu50_3 +# 68| r68_5(int) = Add : r68_4, r68_2 +# 68| mu68_6(int) = Store : &:r68_3, r68_5 +# 69| r69_1(glval) = VariableAddress[x] : +# 69| r69_2(int) = Load : &:r69_1, ~mu50_3 +# 69| r69_3(glval) = VariableAddress[z] : +# 69| r69_4(int) = Load : &:r69_3, ~mu50_3 +# 69| r69_5(int) = Sub : r69_4, r69_2 +# 69| mu69_6(int) = Store : &:r69_3, r69_5 +# 70| r70_1(glval) = VariableAddress[x] : +# 70| r70_2(int) = Load : &:r70_1, ~mu50_3 +# 70| r70_3(glval) = VariableAddress[z] : +# 70| r70_4(int) = Load : &:r70_3, ~mu50_3 +# 70| r70_5(int) = Mul : r70_4, r70_2 +# 70| mu70_6(int) = Store : &:r70_3, r70_5 +# 71| r71_1(glval) = VariableAddress[x] : +# 71| r71_2(int) = Load : &:r71_1, ~mu50_3 +# 71| r71_3(glval) = VariableAddress[z] : +# 71| r71_4(int) = Load : &:r71_3, ~mu50_3 +# 71| r71_5(int) = Div : r71_4, r71_2 +# 71| mu71_6(int) = Store : &:r71_3, r71_5 +# 72| r72_1(glval) = VariableAddress[x] : +# 72| r72_2(int) = Load : &:r72_1, ~mu50_3 +# 72| r72_3(glval) = VariableAddress[z] : +# 72| r72_4(int) = Load : &:r72_3, ~mu50_3 +# 72| r72_5(int) = Rem : r72_4, r72_2 +# 72| mu72_6(int) = Store : &:r72_3, r72_5 +# 74| r74_1(glval) = VariableAddress[x] : +# 74| r74_2(int) = Load : &:r74_1, ~mu50_3 +# 74| r74_3(glval) = VariableAddress[z] : +# 74| r74_4(int) = Load : &:r74_3, ~mu50_3 +# 74| r74_5(int) = BitAnd : r74_4, r74_2 +# 74| mu74_6(int) = Store : &:r74_3, r74_5 +# 75| r75_1(glval) = VariableAddress[x] : +# 75| r75_2(int) = Load : &:r75_1, ~mu50_3 +# 75| r75_3(glval) = VariableAddress[z] : +# 75| r75_4(int) = Load : &:r75_3, ~mu50_3 +# 75| r75_5(int) = BitOr : r75_4, r75_2 +# 75| mu75_6(int) = Store : &:r75_3, r75_5 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Load : &:r76_1, ~mu50_3 +# 76| r76_3(glval) = VariableAddress[z] : +# 76| r76_4(int) = Load : &:r76_3, ~mu50_3 +# 76| r76_5(int) = BitXor : r76_4, r76_2 +# 76| mu76_6(int) = Store : &:r76_3, r76_5 +# 78| r78_1(glval) = VariableAddress[x] : +# 78| r78_2(int) = Load : &:r78_1, ~mu50_3 +# 78| r78_3(glval) = VariableAddress[z] : +# 78| r78_4(int) = Load : &:r78_3, ~mu50_3 +# 78| r78_5(int) = ShiftLeft : r78_4, r78_2 +# 78| mu78_6(int) = Store : &:r78_3, r78_5 +# 79| r79_1(glval) = VariableAddress[x] : +# 79| r79_2(int) = Load : &:r79_1, ~mu50_3 +# 79| r79_3(glval) = VariableAddress[z] : +# 79| r79_4(int) = Load : &:r79_3, ~mu50_3 +# 79| r79_5(int) = ShiftRight : r79_4, r79_2 +# 79| mu79_6(int) = Store : &:r79_3, r79_5 +# 81| r81_1(glval) = VariableAddress[x] : +# 81| r81_2(int) = Load : &:r81_1, ~mu50_3 +# 81| r81_3(int) = CopyValue : r81_2 +# 81| r81_4(glval) = VariableAddress[z] : +# 81| mu81_5(int) = Store : &:r81_4, r81_3 +# 82| r82_1(glval) = VariableAddress[x] : +# 82| r82_2(int) = Load : &:r82_1, ~mu50_3 +# 82| r82_3(int) = Negate : r82_2 +# 82| r82_4(glval) = VariableAddress[z] : +# 82| mu82_5(int) = Store : &:r82_4, r82_3 +# 83| r83_1(glval) = VariableAddress[x] : +# 83| r83_2(int) = Load : &:r83_1, ~mu50_3 +# 83| r83_3(int) = BitComplement : r83_2 +# 83| r83_4(glval) = VariableAddress[z] : +# 83| mu83_5(int) = Store : &:r83_4, r83_3 +# 84| r84_1(glval) = VariableAddress[x] : +# 84| r84_2(int) = Load : &:r84_1, ~mu50_3 +# 84| r84_3(int) = Constant[0] : +# 84| r84_4(bool) = CompareNE : r84_2, r84_3 +# 84| r84_5(bool) = LogicalNot : r84_4 +# 84| r84_6(int) = Convert : r84_5 +# 84| r84_7(glval) = VariableAddress[z] : +# 84| mu84_8(int) = Store : &:r84_7, r84_6 +# 85| v85_1(void) = NoOp : +# 50| v50_8(void) = ReturnVoid : +# 50| v50_9(void) = UnmodeledUse : mu* +# 50| v50_10(void) = AliasedUse : ~mu50_3 +# 50| v50_11(void) = ExitFunction : # 87| void IntegerCompare(int, int) # 87| Block 0 -# 87| v0_0(void) = EnterFunction : -# 87| mu0_1(unknown) = AliasedDefinition : -# 87| mu0_2(unknown) = UnmodeledDefinition : -# 87| r0_3(glval) = VariableAddress[x] : -# 87| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 87| r0_5(glval) = VariableAddress[y] : -# 87| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 88| r0_7(glval) = VariableAddress[b] : -# 88| mu0_8(bool) = Uninitialized[b] : &:r0_7 -# 90| r0_9(glval) = VariableAddress[x] : -# 90| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 90| r0_11(glval) = VariableAddress[y] : -# 90| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 90| r0_13(bool) = CompareEQ : r0_10, r0_12 -# 90| r0_14(glval) = VariableAddress[b] : -# 90| mu0_15(bool) = Store : &:r0_14, r0_13 -# 91| r0_16(glval) = VariableAddress[x] : -# 91| r0_17(int) = Load : &:r0_16, ~mu0_2 -# 91| r0_18(glval) = VariableAddress[y] : -# 91| r0_19(int) = Load : &:r0_18, ~mu0_2 -# 91| r0_20(bool) = CompareNE : r0_17, r0_19 -# 91| r0_21(glval) = VariableAddress[b] : -# 91| mu0_22(bool) = Store : &:r0_21, r0_20 -# 92| r0_23(glval) = VariableAddress[x] : -# 92| r0_24(int) = Load : &:r0_23, ~mu0_2 -# 92| r0_25(glval) = VariableAddress[y] : -# 92| r0_26(int) = Load : &:r0_25, ~mu0_2 -# 92| r0_27(bool) = CompareLT : r0_24, r0_26 -# 92| r0_28(glval) = VariableAddress[b] : -# 92| mu0_29(bool) = Store : &:r0_28, r0_27 -# 93| r0_30(glval) = VariableAddress[x] : -# 93| r0_31(int) = Load : &:r0_30, ~mu0_2 -# 93| r0_32(glval) = VariableAddress[y] : -# 93| r0_33(int) = Load : &:r0_32, ~mu0_2 -# 93| r0_34(bool) = CompareGT : r0_31, r0_33 -# 93| r0_35(glval) = VariableAddress[b] : -# 93| mu0_36(bool) = Store : &:r0_35, r0_34 -# 94| r0_37(glval) = VariableAddress[x] : -# 94| r0_38(int) = Load : &:r0_37, ~mu0_2 -# 94| r0_39(glval) = VariableAddress[y] : -# 94| r0_40(int) = Load : &:r0_39, ~mu0_2 -# 94| r0_41(bool) = CompareLE : r0_38, r0_40 -# 94| r0_42(glval) = VariableAddress[b] : -# 94| mu0_43(bool) = Store : &:r0_42, r0_41 -# 95| r0_44(glval) = VariableAddress[x] : -# 95| r0_45(int) = Load : &:r0_44, ~mu0_2 -# 95| r0_46(glval) = VariableAddress[y] : -# 95| r0_47(int) = Load : &:r0_46, ~mu0_2 -# 95| r0_48(bool) = CompareGE : r0_45, r0_47 -# 95| r0_49(glval) = VariableAddress[b] : -# 95| mu0_50(bool) = Store : &:r0_49, r0_48 -# 96| v0_51(void) = NoOp : -# 87| v0_52(void) = ReturnVoid : -# 87| v0_53(void) = UnmodeledUse : mu* -# 87| v0_54(void) = AliasedUse : ~mu0_2 -# 87| v0_55(void) = ExitFunction : +# 87| v87_1(void) = EnterFunction : +# 87| mu87_2(unknown) = AliasedDefinition : +# 87| mu87_3(unknown) = UnmodeledDefinition : +# 87| r87_4(glval) = VariableAddress[x] : +# 87| mu87_5(int) = InitializeParameter[x] : &:r87_4 +# 87| r87_6(glval) = VariableAddress[y] : +# 87| mu87_7(int) = InitializeParameter[y] : &:r87_6 +# 88| r88_1(glval) = VariableAddress[b] : +# 88| mu88_2(bool) = Uninitialized[b] : &:r88_1 +# 90| r90_1(glval) = VariableAddress[x] : +# 90| r90_2(int) = Load : &:r90_1, ~mu87_3 +# 90| r90_3(glval) = VariableAddress[y] : +# 90| r90_4(int) = Load : &:r90_3, ~mu87_3 +# 90| r90_5(bool) = CompareEQ : r90_2, r90_4 +# 90| r90_6(glval) = VariableAddress[b] : +# 90| mu90_7(bool) = Store : &:r90_6, r90_5 +# 91| r91_1(glval) = VariableAddress[x] : +# 91| r91_2(int) = Load : &:r91_1, ~mu87_3 +# 91| r91_3(glval) = VariableAddress[y] : +# 91| r91_4(int) = Load : &:r91_3, ~mu87_3 +# 91| r91_5(bool) = CompareNE : r91_2, r91_4 +# 91| r91_6(glval) = VariableAddress[b] : +# 91| mu91_7(bool) = Store : &:r91_6, r91_5 +# 92| r92_1(glval) = VariableAddress[x] : +# 92| r92_2(int) = Load : &:r92_1, ~mu87_3 +# 92| r92_3(glval) = VariableAddress[y] : +# 92| r92_4(int) = Load : &:r92_3, ~mu87_3 +# 92| r92_5(bool) = CompareLT : r92_2, r92_4 +# 92| r92_6(glval) = VariableAddress[b] : +# 92| mu92_7(bool) = Store : &:r92_6, r92_5 +# 93| r93_1(glval) = VariableAddress[x] : +# 93| r93_2(int) = Load : &:r93_1, ~mu87_3 +# 93| r93_3(glval) = VariableAddress[y] : +# 93| r93_4(int) = Load : &:r93_3, ~mu87_3 +# 93| r93_5(bool) = CompareGT : r93_2, r93_4 +# 93| r93_6(glval) = VariableAddress[b] : +# 93| mu93_7(bool) = Store : &:r93_6, r93_5 +# 94| r94_1(glval) = VariableAddress[x] : +# 94| r94_2(int) = Load : &:r94_1, ~mu87_3 +# 94| r94_3(glval) = VariableAddress[y] : +# 94| r94_4(int) = Load : &:r94_3, ~mu87_3 +# 94| r94_5(bool) = CompareLE : r94_2, r94_4 +# 94| r94_6(glval) = VariableAddress[b] : +# 94| mu94_7(bool) = Store : &:r94_6, r94_5 +# 95| r95_1(glval) = VariableAddress[x] : +# 95| r95_2(int) = Load : &:r95_1, ~mu87_3 +# 95| r95_3(glval) = VariableAddress[y] : +# 95| r95_4(int) = Load : &:r95_3, ~mu87_3 +# 95| r95_5(bool) = CompareGE : r95_2, r95_4 +# 95| r95_6(glval) = VariableAddress[b] : +# 95| mu95_7(bool) = Store : &:r95_6, r95_5 +# 96| v96_1(void) = NoOp : +# 87| v87_8(void) = ReturnVoid : +# 87| v87_9(void) = UnmodeledUse : mu* +# 87| v87_10(void) = AliasedUse : ~mu87_3 +# 87| v87_11(void) = ExitFunction : # 98| void IntegerCrement(int) # 98| Block 0 -# 98| v0_0(void) = EnterFunction : -# 98| mu0_1(unknown) = AliasedDefinition : -# 98| mu0_2(unknown) = UnmodeledDefinition : -# 98| r0_3(glval) = VariableAddress[x] : -# 98| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 99| r0_5(glval) = VariableAddress[y] : -# 99| mu0_6(int) = Uninitialized[y] : &:r0_5 -# 101| r0_7(glval) = VariableAddress[x] : -# 101| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 101| r0_9(int) = Constant[1] : -# 101| r0_10(int) = Add : r0_8, r0_9 -# 101| mu0_11(int) = Store : &:r0_7, r0_10 -# 101| r0_12(glval) = VariableAddress[y] : -# 101| mu0_13(int) = Store : &:r0_12, r0_10 -# 102| r0_14(glval) = VariableAddress[x] : -# 102| r0_15(int) = Load : &:r0_14, ~mu0_2 -# 102| r0_16(int) = Constant[1] : -# 102| r0_17(int) = Sub : r0_15, r0_16 -# 102| mu0_18(int) = Store : &:r0_14, r0_17 -# 102| r0_19(glval) = VariableAddress[y] : -# 102| mu0_20(int) = Store : &:r0_19, r0_17 -# 103| r0_21(glval) = VariableAddress[x] : -# 103| r0_22(int) = Load : &:r0_21, ~mu0_2 -# 103| r0_23(int) = Constant[1] : -# 103| r0_24(int) = Add : r0_22, r0_23 -# 103| mu0_25(int) = Store : &:r0_21, r0_24 -# 103| r0_26(glval) = VariableAddress[y] : -# 103| mu0_27(int) = Store : &:r0_26, r0_22 -# 104| r0_28(glval) = VariableAddress[x] : -# 104| r0_29(int) = Load : &:r0_28, ~mu0_2 -# 104| r0_30(int) = Constant[1] : -# 104| r0_31(int) = Sub : r0_29, r0_30 -# 104| mu0_32(int) = Store : &:r0_28, r0_31 -# 104| r0_33(glval) = VariableAddress[y] : -# 104| mu0_34(int) = Store : &:r0_33, r0_29 -# 105| v0_35(void) = NoOp : -# 98| v0_36(void) = ReturnVoid : -# 98| v0_37(void) = UnmodeledUse : mu* -# 98| v0_38(void) = AliasedUse : ~mu0_2 -# 98| v0_39(void) = ExitFunction : +# 98| v98_1(void) = EnterFunction : +# 98| mu98_2(unknown) = AliasedDefinition : +# 98| mu98_3(unknown) = UnmodeledDefinition : +# 98| r98_4(glval) = VariableAddress[x] : +# 98| mu98_5(int) = InitializeParameter[x] : &:r98_4 +# 99| r99_1(glval) = VariableAddress[y] : +# 99| mu99_2(int) = Uninitialized[y] : &:r99_1 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(int) = Load : &:r101_1, ~mu98_3 +# 101| r101_3(int) = Constant[1] : +# 101| r101_4(int) = Add : r101_2, r101_3 +# 101| mu101_5(int) = Store : &:r101_1, r101_4 +# 101| r101_6(glval) = VariableAddress[y] : +# 101| mu101_7(int) = Store : &:r101_6, r101_4 +# 102| r102_1(glval) = VariableAddress[x] : +# 102| r102_2(int) = Load : &:r102_1, ~mu98_3 +# 102| r102_3(int) = Constant[1] : +# 102| r102_4(int) = Sub : r102_2, r102_3 +# 102| mu102_5(int) = Store : &:r102_1, r102_4 +# 102| r102_6(glval) = VariableAddress[y] : +# 102| mu102_7(int) = Store : &:r102_6, r102_4 +# 103| r103_1(glval) = VariableAddress[x] : +# 103| r103_2(int) = Load : &:r103_1, ~mu98_3 +# 103| r103_3(int) = Constant[1] : +# 103| r103_4(int) = Add : r103_2, r103_3 +# 103| mu103_5(int) = Store : &:r103_1, r103_4 +# 103| r103_6(glval) = VariableAddress[y] : +# 103| mu103_7(int) = Store : &:r103_6, r103_2 +# 104| r104_1(glval) = VariableAddress[x] : +# 104| r104_2(int) = Load : &:r104_1, ~mu98_3 +# 104| r104_3(int) = Constant[1] : +# 104| r104_4(int) = Sub : r104_2, r104_3 +# 104| mu104_5(int) = Store : &:r104_1, r104_4 +# 104| r104_6(glval) = VariableAddress[y] : +# 104| mu104_7(int) = Store : &:r104_6, r104_2 +# 105| v105_1(void) = NoOp : +# 98| v98_6(void) = ReturnVoid : +# 98| v98_7(void) = UnmodeledUse : mu* +# 98| v98_8(void) = AliasedUse : ~mu98_3 +# 98| v98_9(void) = ExitFunction : # 107| void IntegerCrement_LValue(int) # 107| Block 0 -# 107| v0_0(void) = EnterFunction : -# 107| mu0_1(unknown) = AliasedDefinition : -# 107| mu0_2(unknown) = UnmodeledDefinition : -# 107| r0_3(glval) = VariableAddress[x] : -# 107| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 108| r0_5(glval) = VariableAddress[p] : -# 108| mu0_6(int *) = Uninitialized[p] : &:r0_5 -# 110| r0_7(glval) = VariableAddress[x] : -# 110| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 110| r0_9(int) = Constant[1] : -# 110| r0_10(int) = Add : r0_8, r0_9 -# 110| mu0_11(int) = Store : &:r0_7, r0_10 -# 110| r0_12(glval) = CopyValue : r0_7 -# 110| r0_13(int *) = CopyValue : r0_12 -# 110| r0_14(glval) = VariableAddress[p] : -# 110| mu0_15(int *) = Store : &:r0_14, r0_13 -# 111| r0_16(glval) = VariableAddress[x] : -# 111| r0_17(int) = Load : &:r0_16, ~mu0_2 -# 111| r0_18(int) = Constant[1] : -# 111| r0_19(int) = Sub : r0_17, r0_18 -# 111| mu0_20(int) = Store : &:r0_16, r0_19 -# 111| r0_21(glval) = CopyValue : r0_16 -# 111| r0_22(int *) = CopyValue : r0_21 -# 111| r0_23(glval) = VariableAddress[p] : -# 111| mu0_24(int *) = Store : &:r0_23, r0_22 -# 112| v0_25(void) = NoOp : -# 107| v0_26(void) = ReturnVoid : -# 107| v0_27(void) = UnmodeledUse : mu* -# 107| v0_28(void) = AliasedUse : ~mu0_2 -# 107| v0_29(void) = ExitFunction : +# 107| v107_1(void) = EnterFunction : +# 107| mu107_2(unknown) = AliasedDefinition : +# 107| mu107_3(unknown) = UnmodeledDefinition : +# 107| r107_4(glval) = VariableAddress[x] : +# 107| mu107_5(int) = InitializeParameter[x] : &:r107_4 +# 108| r108_1(glval) = VariableAddress[p] : +# 108| mu108_2(int *) = Uninitialized[p] : &:r108_1 +# 110| r110_1(glval) = VariableAddress[x] : +# 110| r110_2(int) = Load : &:r110_1, ~mu107_3 +# 110| r110_3(int) = Constant[1] : +# 110| r110_4(int) = Add : r110_2, r110_3 +# 110| mu110_5(int) = Store : &:r110_1, r110_4 +# 110| r110_6(glval) = CopyValue : r110_1 +# 110| r110_7(int *) = CopyValue : r110_6 +# 110| r110_8(glval) = VariableAddress[p] : +# 110| mu110_9(int *) = Store : &:r110_8, r110_7 +# 111| r111_1(glval) = VariableAddress[x] : +# 111| r111_2(int) = Load : &:r111_1, ~mu107_3 +# 111| r111_3(int) = Constant[1] : +# 111| r111_4(int) = Sub : r111_2, r111_3 +# 111| mu111_5(int) = Store : &:r111_1, r111_4 +# 111| r111_6(glval) = CopyValue : r111_1 +# 111| r111_7(int *) = CopyValue : r111_6 +# 111| r111_8(glval) = VariableAddress[p] : +# 111| mu111_9(int *) = Store : &:r111_8, r111_7 +# 112| v112_1(void) = NoOp : +# 107| v107_6(void) = ReturnVoid : +# 107| v107_7(void) = UnmodeledUse : mu* +# 107| v107_8(void) = AliasedUse : ~mu107_3 +# 107| v107_9(void) = ExitFunction : # 114| void FloatOps(double, double) # 114| Block 0 -# 114| v0_0(void) = EnterFunction : -# 114| mu0_1(unknown) = AliasedDefinition : -# 114| mu0_2(unknown) = UnmodeledDefinition : -# 114| r0_3(glval) = VariableAddress[x] : -# 114| mu0_4(double) = InitializeParameter[x] : &:r0_3 -# 114| r0_5(glval) = VariableAddress[y] : -# 114| mu0_6(double) = InitializeParameter[y] : &:r0_5 -# 115| r0_7(glval) = VariableAddress[z] : -# 115| mu0_8(double) = Uninitialized[z] : &:r0_7 -# 117| r0_9(glval) = VariableAddress[x] : -# 117| r0_10(double) = Load : &:r0_9, ~mu0_2 -# 117| r0_11(glval) = VariableAddress[y] : -# 117| r0_12(double) = Load : &:r0_11, ~mu0_2 -# 117| r0_13(double) = Add : r0_10, r0_12 -# 117| r0_14(glval) = VariableAddress[z] : -# 117| mu0_15(double) = Store : &:r0_14, r0_13 -# 118| r0_16(glval) = VariableAddress[x] : -# 118| r0_17(double) = Load : &:r0_16, ~mu0_2 -# 118| r0_18(glval) = VariableAddress[y] : -# 118| r0_19(double) = Load : &:r0_18, ~mu0_2 -# 118| r0_20(double) = Sub : r0_17, r0_19 -# 118| r0_21(glval) = VariableAddress[z] : -# 118| mu0_22(double) = Store : &:r0_21, r0_20 -# 119| r0_23(glval) = VariableAddress[x] : -# 119| r0_24(double) = Load : &:r0_23, ~mu0_2 -# 119| r0_25(glval) = VariableAddress[y] : -# 119| r0_26(double) = Load : &:r0_25, ~mu0_2 -# 119| r0_27(double) = Mul : r0_24, r0_26 -# 119| r0_28(glval) = VariableAddress[z] : -# 119| mu0_29(double) = Store : &:r0_28, r0_27 -# 120| r0_30(glval) = VariableAddress[x] : -# 120| r0_31(double) = Load : &:r0_30, ~mu0_2 -# 120| r0_32(glval) = VariableAddress[y] : -# 120| r0_33(double) = Load : &:r0_32, ~mu0_2 -# 120| r0_34(double) = Div : r0_31, r0_33 -# 120| r0_35(glval) = VariableAddress[z] : -# 120| mu0_36(double) = Store : &:r0_35, r0_34 -# 122| r0_37(glval) = VariableAddress[x] : -# 122| r0_38(double) = Load : &:r0_37, ~mu0_2 -# 122| r0_39(glval) = VariableAddress[z] : -# 122| mu0_40(double) = Store : &:r0_39, r0_38 -# 124| r0_41(glval) = VariableAddress[x] : -# 124| r0_42(double) = Load : &:r0_41, ~mu0_2 -# 124| r0_43(glval) = VariableAddress[z] : -# 124| r0_44(double) = Load : &:r0_43, ~mu0_2 -# 124| r0_45(double) = Add : r0_44, r0_42 -# 124| mu0_46(double) = Store : &:r0_43, r0_45 -# 125| r0_47(glval) = VariableAddress[x] : -# 125| r0_48(double) = Load : &:r0_47, ~mu0_2 -# 125| r0_49(glval) = VariableAddress[z] : -# 125| r0_50(double) = Load : &:r0_49, ~mu0_2 -# 125| r0_51(double) = Sub : r0_50, r0_48 -# 125| mu0_52(double) = Store : &:r0_49, r0_51 -# 126| r0_53(glval) = VariableAddress[x] : -# 126| r0_54(double) = Load : &:r0_53, ~mu0_2 -# 126| r0_55(glval) = VariableAddress[z] : -# 126| r0_56(double) = Load : &:r0_55, ~mu0_2 -# 126| r0_57(double) = Mul : r0_56, r0_54 -# 126| mu0_58(double) = Store : &:r0_55, r0_57 -# 127| r0_59(glval) = VariableAddress[x] : -# 127| r0_60(double) = Load : &:r0_59, ~mu0_2 -# 127| r0_61(glval) = VariableAddress[z] : -# 127| r0_62(double) = Load : &:r0_61, ~mu0_2 -# 127| r0_63(double) = Div : r0_62, r0_60 -# 127| mu0_64(double) = Store : &:r0_61, r0_63 -# 129| r0_65(glval) = VariableAddress[x] : -# 129| r0_66(double) = Load : &:r0_65, ~mu0_2 -# 129| r0_67(double) = CopyValue : r0_66 -# 129| r0_68(glval) = VariableAddress[z] : -# 129| mu0_69(double) = Store : &:r0_68, r0_67 -# 130| r0_70(glval) = VariableAddress[x] : -# 130| r0_71(double) = Load : &:r0_70, ~mu0_2 -# 130| r0_72(double) = Negate : r0_71 -# 130| r0_73(glval) = VariableAddress[z] : -# 130| mu0_74(double) = Store : &:r0_73, r0_72 -# 131| v0_75(void) = NoOp : -# 114| v0_76(void) = ReturnVoid : -# 114| v0_77(void) = UnmodeledUse : mu* -# 114| v0_78(void) = AliasedUse : ~mu0_2 -# 114| v0_79(void) = ExitFunction : +# 114| v114_1(void) = EnterFunction : +# 114| mu114_2(unknown) = AliasedDefinition : +# 114| mu114_3(unknown) = UnmodeledDefinition : +# 114| r114_4(glval) = VariableAddress[x] : +# 114| mu114_5(double) = InitializeParameter[x] : &:r114_4 +# 114| r114_6(glval) = VariableAddress[y] : +# 114| mu114_7(double) = InitializeParameter[y] : &:r114_6 +# 115| r115_1(glval) = VariableAddress[z] : +# 115| mu115_2(double) = Uninitialized[z] : &:r115_1 +# 117| r117_1(glval) = VariableAddress[x] : +# 117| r117_2(double) = Load : &:r117_1, ~mu114_3 +# 117| r117_3(glval) = VariableAddress[y] : +# 117| r117_4(double) = Load : &:r117_3, ~mu114_3 +# 117| r117_5(double) = Add : r117_2, r117_4 +# 117| r117_6(glval) = VariableAddress[z] : +# 117| mu117_7(double) = Store : &:r117_6, r117_5 +# 118| r118_1(glval) = VariableAddress[x] : +# 118| r118_2(double) = Load : &:r118_1, ~mu114_3 +# 118| r118_3(glval) = VariableAddress[y] : +# 118| r118_4(double) = Load : &:r118_3, ~mu114_3 +# 118| r118_5(double) = Sub : r118_2, r118_4 +# 118| r118_6(glval) = VariableAddress[z] : +# 118| mu118_7(double) = Store : &:r118_6, r118_5 +# 119| r119_1(glval) = VariableAddress[x] : +# 119| r119_2(double) = Load : &:r119_1, ~mu114_3 +# 119| r119_3(glval) = VariableAddress[y] : +# 119| r119_4(double) = Load : &:r119_3, ~mu114_3 +# 119| r119_5(double) = Mul : r119_2, r119_4 +# 119| r119_6(glval) = VariableAddress[z] : +# 119| mu119_7(double) = Store : &:r119_6, r119_5 +# 120| r120_1(glval) = VariableAddress[x] : +# 120| r120_2(double) = Load : &:r120_1, ~mu114_3 +# 120| r120_3(glval) = VariableAddress[y] : +# 120| r120_4(double) = Load : &:r120_3, ~mu114_3 +# 120| r120_5(double) = Div : r120_2, r120_4 +# 120| r120_6(glval) = VariableAddress[z] : +# 120| mu120_7(double) = Store : &:r120_6, r120_5 +# 122| r122_1(glval) = VariableAddress[x] : +# 122| r122_2(double) = Load : &:r122_1, ~mu114_3 +# 122| r122_3(glval) = VariableAddress[z] : +# 122| mu122_4(double) = Store : &:r122_3, r122_2 +# 124| r124_1(glval) = VariableAddress[x] : +# 124| r124_2(double) = Load : &:r124_1, ~mu114_3 +# 124| r124_3(glval) = VariableAddress[z] : +# 124| r124_4(double) = Load : &:r124_3, ~mu114_3 +# 124| r124_5(double) = Add : r124_4, r124_2 +# 124| mu124_6(double) = Store : &:r124_3, r124_5 +# 125| r125_1(glval) = VariableAddress[x] : +# 125| r125_2(double) = Load : &:r125_1, ~mu114_3 +# 125| r125_3(glval) = VariableAddress[z] : +# 125| r125_4(double) = Load : &:r125_3, ~mu114_3 +# 125| r125_5(double) = Sub : r125_4, r125_2 +# 125| mu125_6(double) = Store : &:r125_3, r125_5 +# 126| r126_1(glval) = VariableAddress[x] : +# 126| r126_2(double) = Load : &:r126_1, ~mu114_3 +# 126| r126_3(glval) = VariableAddress[z] : +# 126| r126_4(double) = Load : &:r126_3, ~mu114_3 +# 126| r126_5(double) = Mul : r126_4, r126_2 +# 126| mu126_6(double) = Store : &:r126_3, r126_5 +# 127| r127_1(glval) = VariableAddress[x] : +# 127| r127_2(double) = Load : &:r127_1, ~mu114_3 +# 127| r127_3(glval) = VariableAddress[z] : +# 127| r127_4(double) = Load : &:r127_3, ~mu114_3 +# 127| r127_5(double) = Div : r127_4, r127_2 +# 127| mu127_6(double) = Store : &:r127_3, r127_5 +# 129| r129_1(glval) = VariableAddress[x] : +# 129| r129_2(double) = Load : &:r129_1, ~mu114_3 +# 129| r129_3(double) = CopyValue : r129_2 +# 129| r129_4(glval) = VariableAddress[z] : +# 129| mu129_5(double) = Store : &:r129_4, r129_3 +# 130| r130_1(glval) = VariableAddress[x] : +# 130| r130_2(double) = Load : &:r130_1, ~mu114_3 +# 130| r130_3(double) = Negate : r130_2 +# 130| r130_4(glval) = VariableAddress[z] : +# 130| mu130_5(double) = Store : &:r130_4, r130_3 +# 131| v131_1(void) = NoOp : +# 114| v114_8(void) = ReturnVoid : +# 114| v114_9(void) = UnmodeledUse : mu* +# 114| v114_10(void) = AliasedUse : ~mu114_3 +# 114| v114_11(void) = ExitFunction : # 133| void FloatCompare(double, double) # 133| Block 0 -# 133| v0_0(void) = EnterFunction : -# 133| mu0_1(unknown) = AliasedDefinition : -# 133| mu0_2(unknown) = UnmodeledDefinition : -# 133| r0_3(glval) = VariableAddress[x] : -# 133| mu0_4(double) = InitializeParameter[x] : &:r0_3 -# 133| r0_5(glval) = VariableAddress[y] : -# 133| mu0_6(double) = InitializeParameter[y] : &:r0_5 -# 134| r0_7(glval) = VariableAddress[b] : -# 134| mu0_8(bool) = Uninitialized[b] : &:r0_7 -# 136| r0_9(glval) = VariableAddress[x] : -# 136| r0_10(double) = Load : &:r0_9, ~mu0_2 -# 136| r0_11(glval) = VariableAddress[y] : -# 136| r0_12(double) = Load : &:r0_11, ~mu0_2 -# 136| r0_13(bool) = CompareEQ : r0_10, r0_12 -# 136| r0_14(glval) = VariableAddress[b] : -# 136| mu0_15(bool) = Store : &:r0_14, r0_13 -# 137| r0_16(glval) = VariableAddress[x] : -# 137| r0_17(double) = Load : &:r0_16, ~mu0_2 -# 137| r0_18(glval) = VariableAddress[y] : -# 137| r0_19(double) = Load : &:r0_18, ~mu0_2 -# 137| r0_20(bool) = CompareNE : r0_17, r0_19 -# 137| r0_21(glval) = VariableAddress[b] : -# 137| mu0_22(bool) = Store : &:r0_21, r0_20 -# 138| r0_23(glval) = VariableAddress[x] : -# 138| r0_24(double) = Load : &:r0_23, ~mu0_2 -# 138| r0_25(glval) = VariableAddress[y] : -# 138| r0_26(double) = Load : &:r0_25, ~mu0_2 -# 138| r0_27(bool) = CompareLT : r0_24, r0_26 -# 138| r0_28(glval) = VariableAddress[b] : -# 138| mu0_29(bool) = Store : &:r0_28, r0_27 -# 139| r0_30(glval) = VariableAddress[x] : -# 139| r0_31(double) = Load : &:r0_30, ~mu0_2 -# 139| r0_32(glval) = VariableAddress[y] : -# 139| r0_33(double) = Load : &:r0_32, ~mu0_2 -# 139| r0_34(bool) = CompareGT : r0_31, r0_33 -# 139| r0_35(glval) = VariableAddress[b] : -# 139| mu0_36(bool) = Store : &:r0_35, r0_34 -# 140| r0_37(glval) = VariableAddress[x] : -# 140| r0_38(double) = Load : &:r0_37, ~mu0_2 -# 140| r0_39(glval) = VariableAddress[y] : -# 140| r0_40(double) = Load : &:r0_39, ~mu0_2 -# 140| r0_41(bool) = CompareLE : r0_38, r0_40 -# 140| r0_42(glval) = VariableAddress[b] : -# 140| mu0_43(bool) = Store : &:r0_42, r0_41 -# 141| r0_44(glval) = VariableAddress[x] : -# 141| r0_45(double) = Load : &:r0_44, ~mu0_2 -# 141| r0_46(glval) = VariableAddress[y] : -# 141| r0_47(double) = Load : &:r0_46, ~mu0_2 -# 141| r0_48(bool) = CompareGE : r0_45, r0_47 -# 141| r0_49(glval) = VariableAddress[b] : -# 141| mu0_50(bool) = Store : &:r0_49, r0_48 -# 142| v0_51(void) = NoOp : -# 133| v0_52(void) = ReturnVoid : -# 133| v0_53(void) = UnmodeledUse : mu* -# 133| v0_54(void) = AliasedUse : ~mu0_2 -# 133| v0_55(void) = ExitFunction : +# 133| v133_1(void) = EnterFunction : +# 133| mu133_2(unknown) = AliasedDefinition : +# 133| mu133_3(unknown) = UnmodeledDefinition : +# 133| r133_4(glval) = VariableAddress[x] : +# 133| mu133_5(double) = InitializeParameter[x] : &:r133_4 +# 133| r133_6(glval) = VariableAddress[y] : +# 133| mu133_7(double) = InitializeParameter[y] : &:r133_6 +# 134| r134_1(glval) = VariableAddress[b] : +# 134| mu134_2(bool) = Uninitialized[b] : &:r134_1 +# 136| r136_1(glval) = VariableAddress[x] : +# 136| r136_2(double) = Load : &:r136_1, ~mu133_3 +# 136| r136_3(glval) = VariableAddress[y] : +# 136| r136_4(double) = Load : &:r136_3, ~mu133_3 +# 136| r136_5(bool) = CompareEQ : r136_2, r136_4 +# 136| r136_6(glval) = VariableAddress[b] : +# 136| mu136_7(bool) = Store : &:r136_6, r136_5 +# 137| r137_1(glval) = VariableAddress[x] : +# 137| r137_2(double) = Load : &:r137_1, ~mu133_3 +# 137| r137_3(glval) = VariableAddress[y] : +# 137| r137_4(double) = Load : &:r137_3, ~mu133_3 +# 137| r137_5(bool) = CompareNE : r137_2, r137_4 +# 137| r137_6(glval) = VariableAddress[b] : +# 137| mu137_7(bool) = Store : &:r137_6, r137_5 +# 138| r138_1(glval) = VariableAddress[x] : +# 138| r138_2(double) = Load : &:r138_1, ~mu133_3 +# 138| r138_3(glval) = VariableAddress[y] : +# 138| r138_4(double) = Load : &:r138_3, ~mu133_3 +# 138| r138_5(bool) = CompareLT : r138_2, r138_4 +# 138| r138_6(glval) = VariableAddress[b] : +# 138| mu138_7(bool) = Store : &:r138_6, r138_5 +# 139| r139_1(glval) = VariableAddress[x] : +# 139| r139_2(double) = Load : &:r139_1, ~mu133_3 +# 139| r139_3(glval) = VariableAddress[y] : +# 139| r139_4(double) = Load : &:r139_3, ~mu133_3 +# 139| r139_5(bool) = CompareGT : r139_2, r139_4 +# 139| r139_6(glval) = VariableAddress[b] : +# 139| mu139_7(bool) = Store : &:r139_6, r139_5 +# 140| r140_1(glval) = VariableAddress[x] : +# 140| r140_2(double) = Load : &:r140_1, ~mu133_3 +# 140| r140_3(glval) = VariableAddress[y] : +# 140| r140_4(double) = Load : &:r140_3, ~mu133_3 +# 140| r140_5(bool) = CompareLE : r140_2, r140_4 +# 140| r140_6(glval) = VariableAddress[b] : +# 140| mu140_7(bool) = Store : &:r140_6, r140_5 +# 141| r141_1(glval) = VariableAddress[x] : +# 141| r141_2(double) = Load : &:r141_1, ~mu133_3 +# 141| r141_3(glval) = VariableAddress[y] : +# 141| r141_4(double) = Load : &:r141_3, ~mu133_3 +# 141| r141_5(bool) = CompareGE : r141_2, r141_4 +# 141| r141_6(glval) = VariableAddress[b] : +# 141| mu141_7(bool) = Store : &:r141_6, r141_5 +# 142| v142_1(void) = NoOp : +# 133| v133_8(void) = ReturnVoid : +# 133| v133_9(void) = UnmodeledUse : mu* +# 133| v133_10(void) = AliasedUse : ~mu133_3 +# 133| v133_11(void) = ExitFunction : # 144| void FloatCrement(float) # 144| Block 0 -# 144| v0_0(void) = EnterFunction : -# 144| mu0_1(unknown) = AliasedDefinition : -# 144| mu0_2(unknown) = UnmodeledDefinition : -# 144| r0_3(glval) = VariableAddress[x] : -# 144| mu0_4(float) = InitializeParameter[x] : &:r0_3 -# 145| r0_5(glval) = VariableAddress[y] : -# 145| mu0_6(float) = Uninitialized[y] : &:r0_5 -# 147| r0_7(glval) = VariableAddress[x] : -# 147| r0_8(float) = Load : &:r0_7, ~mu0_2 -# 147| r0_9(float) = Constant[1.0] : -# 147| r0_10(float) = Add : r0_8, r0_9 -# 147| mu0_11(float) = Store : &:r0_7, r0_10 -# 147| r0_12(glval) = VariableAddress[y] : -# 147| mu0_13(float) = Store : &:r0_12, r0_10 -# 148| r0_14(glval) = VariableAddress[x] : -# 148| r0_15(float) = Load : &:r0_14, ~mu0_2 -# 148| r0_16(float) = Constant[1.0] : -# 148| r0_17(float) = Sub : r0_15, r0_16 -# 148| mu0_18(float) = Store : &:r0_14, r0_17 -# 148| r0_19(glval) = VariableAddress[y] : -# 148| mu0_20(float) = Store : &:r0_19, r0_17 -# 149| r0_21(glval) = VariableAddress[x] : -# 149| r0_22(float) = Load : &:r0_21, ~mu0_2 -# 149| r0_23(float) = Constant[1.0] : -# 149| r0_24(float) = Add : r0_22, r0_23 -# 149| mu0_25(float) = Store : &:r0_21, r0_24 -# 149| r0_26(glval) = VariableAddress[y] : -# 149| mu0_27(float) = Store : &:r0_26, r0_22 -# 150| r0_28(glval) = VariableAddress[x] : -# 150| r0_29(float) = Load : &:r0_28, ~mu0_2 -# 150| r0_30(float) = Constant[1.0] : -# 150| r0_31(float) = Sub : r0_29, r0_30 -# 150| mu0_32(float) = Store : &:r0_28, r0_31 -# 150| r0_33(glval) = VariableAddress[y] : -# 150| mu0_34(float) = Store : &:r0_33, r0_29 -# 151| v0_35(void) = NoOp : -# 144| v0_36(void) = ReturnVoid : -# 144| v0_37(void) = UnmodeledUse : mu* -# 144| v0_38(void) = AliasedUse : ~mu0_2 -# 144| v0_39(void) = ExitFunction : +# 144| v144_1(void) = EnterFunction : +# 144| mu144_2(unknown) = AliasedDefinition : +# 144| mu144_3(unknown) = UnmodeledDefinition : +# 144| r144_4(glval) = VariableAddress[x] : +# 144| mu144_5(float) = InitializeParameter[x] : &:r144_4 +# 145| r145_1(glval) = VariableAddress[y] : +# 145| mu145_2(float) = Uninitialized[y] : &:r145_1 +# 147| r147_1(glval) = VariableAddress[x] : +# 147| r147_2(float) = Load : &:r147_1, ~mu144_3 +# 147| r147_3(float) = Constant[1.0] : +# 147| r147_4(float) = Add : r147_2, r147_3 +# 147| mu147_5(float) = Store : &:r147_1, r147_4 +# 147| r147_6(glval) = VariableAddress[y] : +# 147| mu147_7(float) = Store : &:r147_6, r147_4 +# 148| r148_1(glval) = VariableAddress[x] : +# 148| r148_2(float) = Load : &:r148_1, ~mu144_3 +# 148| r148_3(float) = Constant[1.0] : +# 148| r148_4(float) = Sub : r148_2, r148_3 +# 148| mu148_5(float) = Store : &:r148_1, r148_4 +# 148| r148_6(glval) = VariableAddress[y] : +# 148| mu148_7(float) = Store : &:r148_6, r148_4 +# 149| r149_1(glval) = VariableAddress[x] : +# 149| r149_2(float) = Load : &:r149_1, ~mu144_3 +# 149| r149_3(float) = Constant[1.0] : +# 149| r149_4(float) = Add : r149_2, r149_3 +# 149| mu149_5(float) = Store : &:r149_1, r149_4 +# 149| r149_6(glval) = VariableAddress[y] : +# 149| mu149_7(float) = Store : &:r149_6, r149_2 +# 150| r150_1(glval) = VariableAddress[x] : +# 150| r150_2(float) = Load : &:r150_1, ~mu144_3 +# 150| r150_3(float) = Constant[1.0] : +# 150| r150_4(float) = Sub : r150_2, r150_3 +# 150| mu150_5(float) = Store : &:r150_1, r150_4 +# 150| r150_6(glval) = VariableAddress[y] : +# 150| mu150_7(float) = Store : &:r150_6, r150_2 +# 151| v151_1(void) = NoOp : +# 144| v144_6(void) = ReturnVoid : +# 144| v144_7(void) = UnmodeledUse : mu* +# 144| v144_8(void) = AliasedUse : ~mu144_3 +# 144| v144_9(void) = ExitFunction : # 153| void PointerOps(int*, int) # 153| Block 0 -# 153| v0_0(void) = EnterFunction : -# 153| mu0_1(unknown) = AliasedDefinition : -# 153| mu0_2(unknown) = UnmodeledDefinition : -# 153| r0_3(glval) = VariableAddress[p] : -# 153| mu0_4(int *) = InitializeParameter[p] : &:r0_3 -# 153| r0_5(glval) = VariableAddress[i] : -# 153| mu0_6(int) = InitializeParameter[i] : &:r0_5 -# 154| r0_7(glval) = VariableAddress[q] : -# 154| mu0_8(int *) = Uninitialized[q] : &:r0_7 -# 155| r0_9(glval) = VariableAddress[b] : -# 155| mu0_10(bool) = Uninitialized[b] : &:r0_9 -# 157| r0_11(glval) = VariableAddress[p] : -# 157| r0_12(int *) = Load : &:r0_11, ~mu0_2 -# 157| r0_13(glval) = VariableAddress[i] : -# 157| r0_14(int) = Load : &:r0_13, ~mu0_2 -# 157| r0_15(int *) = PointerAdd[4] : r0_12, r0_14 -# 157| r0_16(glval) = VariableAddress[q] : -# 157| mu0_17(int *) = Store : &:r0_16, r0_15 -# 158| r0_18(glval) = VariableAddress[i] : -# 158| r0_19(int) = Load : &:r0_18, ~mu0_2 -# 158| r0_20(glval) = VariableAddress[p] : -# 158| r0_21(int *) = Load : &:r0_20, ~mu0_2 -# 158| r0_22(int *) = PointerAdd[4] : r0_21, r0_19 -# 158| r0_23(glval) = VariableAddress[q] : -# 158| mu0_24(int *) = Store : &:r0_23, r0_22 -# 159| r0_25(glval) = VariableAddress[p] : -# 159| r0_26(int *) = Load : &:r0_25, ~mu0_2 -# 159| r0_27(glval) = VariableAddress[i] : -# 159| r0_28(int) = Load : &:r0_27, ~mu0_2 -# 159| r0_29(int *) = PointerSub[4] : r0_26, r0_28 -# 159| r0_30(glval) = VariableAddress[q] : -# 159| mu0_31(int *) = Store : &:r0_30, r0_29 -# 160| r0_32(glval) = VariableAddress[p] : -# 160| r0_33(int *) = Load : &:r0_32, ~mu0_2 -# 160| r0_34(glval) = VariableAddress[q] : -# 160| r0_35(int *) = Load : &:r0_34, ~mu0_2 -# 160| r0_36(long) = PointerDiff[4] : r0_33, r0_35 -# 160| r0_37(int) = Convert : r0_36 -# 160| r0_38(glval) = VariableAddress[i] : -# 160| mu0_39(int) = Store : &:r0_38, r0_37 -# 162| r0_40(glval) = VariableAddress[p] : -# 162| r0_41(int *) = Load : &:r0_40, ~mu0_2 -# 162| r0_42(glval) = VariableAddress[q] : -# 162| mu0_43(int *) = Store : &:r0_42, r0_41 -# 164| r0_44(glval) = VariableAddress[i] : -# 164| r0_45(int) = Load : &:r0_44, ~mu0_2 -# 164| r0_46(glval) = VariableAddress[q] : -# 164| r0_47(int *) = Load : &:r0_46, ~mu0_2 -# 164| r0_48(int *) = PointerAdd[4] : r0_47, r0_45 -# 164| mu0_49(int *) = Store : &:r0_46, r0_48 -# 165| r0_50(glval) = VariableAddress[i] : -# 165| r0_51(int) = Load : &:r0_50, ~mu0_2 -# 165| r0_52(glval) = VariableAddress[q] : -# 165| r0_53(int *) = Load : &:r0_52, ~mu0_2 -# 165| r0_54(int *) = PointerSub[4] : r0_53, r0_51 -# 165| mu0_55(int *) = Store : &:r0_52, r0_54 -# 167| r0_56(glval) = VariableAddress[p] : -# 167| r0_57(int *) = Load : &:r0_56, ~mu0_2 -# 167| r0_58(int *) = Constant[0] : -# 167| r0_59(bool) = CompareNE : r0_57, r0_58 -# 167| r0_60(glval) = VariableAddress[b] : -# 167| mu0_61(bool) = Store : &:r0_60, r0_59 -# 168| r0_62(glval) = VariableAddress[p] : -# 168| r0_63(int *) = Load : &:r0_62, ~mu0_2 -# 168| r0_64(int *) = Constant[0] : -# 168| r0_65(bool) = CompareNE : r0_63, r0_64 -# 168| r0_66(bool) = LogicalNot : r0_65 -# 168| r0_67(glval) = VariableAddress[b] : -# 168| mu0_68(bool) = Store : &:r0_67, r0_66 -# 169| v0_69(void) = NoOp : -# 153| v0_70(void) = ReturnVoid : -# 153| v0_71(void) = UnmodeledUse : mu* -# 153| v0_72(void) = AliasedUse : ~mu0_2 -# 153| v0_73(void) = ExitFunction : +# 153| v153_1(void) = EnterFunction : +# 153| mu153_2(unknown) = AliasedDefinition : +# 153| mu153_3(unknown) = UnmodeledDefinition : +# 153| r153_4(glval) = VariableAddress[p] : +# 153| mu153_5(int *) = InitializeParameter[p] : &:r153_4 +# 153| r153_6(glval) = VariableAddress[i] : +# 153| mu153_7(int) = InitializeParameter[i] : &:r153_6 +# 154| r154_1(glval) = VariableAddress[q] : +# 154| mu154_2(int *) = Uninitialized[q] : &:r154_1 +# 155| r155_1(glval) = VariableAddress[b] : +# 155| mu155_2(bool) = Uninitialized[b] : &:r155_1 +# 157| r157_1(glval) = VariableAddress[p] : +# 157| r157_2(int *) = Load : &:r157_1, ~mu153_3 +# 157| r157_3(glval) = VariableAddress[i] : +# 157| r157_4(int) = Load : &:r157_3, ~mu153_3 +# 157| r157_5(int *) = PointerAdd[4] : r157_2, r157_4 +# 157| r157_6(glval) = VariableAddress[q] : +# 157| mu157_7(int *) = Store : &:r157_6, r157_5 +# 158| r158_1(glval) = VariableAddress[i] : +# 158| r158_2(int) = Load : &:r158_1, ~mu153_3 +# 158| r158_3(glval) = VariableAddress[p] : +# 158| r158_4(int *) = Load : &:r158_3, ~mu153_3 +# 158| r158_5(int *) = PointerAdd[4] : r158_4, r158_2 +# 158| r158_6(glval) = VariableAddress[q] : +# 158| mu158_7(int *) = Store : &:r158_6, r158_5 +# 159| r159_1(glval) = VariableAddress[p] : +# 159| r159_2(int *) = Load : &:r159_1, ~mu153_3 +# 159| r159_3(glval) = VariableAddress[i] : +# 159| r159_4(int) = Load : &:r159_3, ~mu153_3 +# 159| r159_5(int *) = PointerSub[4] : r159_2, r159_4 +# 159| r159_6(glval) = VariableAddress[q] : +# 159| mu159_7(int *) = Store : &:r159_6, r159_5 +# 160| r160_1(glval) = VariableAddress[p] : +# 160| r160_2(int *) = Load : &:r160_1, ~mu153_3 +# 160| r160_3(glval) = VariableAddress[q] : +# 160| r160_4(int *) = Load : &:r160_3, ~mu153_3 +# 160| r160_5(long) = PointerDiff[4] : r160_2, r160_4 +# 160| r160_6(int) = Convert : r160_5 +# 160| r160_7(glval) = VariableAddress[i] : +# 160| mu160_8(int) = Store : &:r160_7, r160_6 +# 162| r162_1(glval) = VariableAddress[p] : +# 162| r162_2(int *) = Load : &:r162_1, ~mu153_3 +# 162| r162_3(glval) = VariableAddress[q] : +# 162| mu162_4(int *) = Store : &:r162_3, r162_2 +# 164| r164_1(glval) = VariableAddress[i] : +# 164| r164_2(int) = Load : &:r164_1, ~mu153_3 +# 164| r164_3(glval) = VariableAddress[q] : +# 164| r164_4(int *) = Load : &:r164_3, ~mu153_3 +# 164| r164_5(int *) = PointerAdd[4] : r164_4, r164_2 +# 164| mu164_6(int *) = Store : &:r164_3, r164_5 +# 165| r165_1(glval) = VariableAddress[i] : +# 165| r165_2(int) = Load : &:r165_1, ~mu153_3 +# 165| r165_3(glval) = VariableAddress[q] : +# 165| r165_4(int *) = Load : &:r165_3, ~mu153_3 +# 165| r165_5(int *) = PointerSub[4] : r165_4, r165_2 +# 165| mu165_6(int *) = Store : &:r165_3, r165_5 +# 167| r167_1(glval) = VariableAddress[p] : +# 167| r167_2(int *) = Load : &:r167_1, ~mu153_3 +# 167| r167_3(int *) = Constant[0] : +# 167| r167_4(bool) = CompareNE : r167_2, r167_3 +# 167| r167_5(glval) = VariableAddress[b] : +# 167| mu167_6(bool) = Store : &:r167_5, r167_4 +# 168| r168_1(glval) = VariableAddress[p] : +# 168| r168_2(int *) = Load : &:r168_1, ~mu153_3 +# 168| r168_3(int *) = Constant[0] : +# 168| r168_4(bool) = CompareNE : r168_2, r168_3 +# 168| r168_5(bool) = LogicalNot : r168_4 +# 168| r168_6(glval) = VariableAddress[b] : +# 168| mu168_7(bool) = Store : &:r168_6, r168_5 +# 169| v169_1(void) = NoOp : +# 153| v153_8(void) = ReturnVoid : +# 153| v153_9(void) = UnmodeledUse : mu* +# 153| v153_10(void) = AliasedUse : ~mu153_3 +# 153| v153_11(void) = ExitFunction : # 171| void ArrayAccess(int*, int) # 171| Block 0 -# 171| v0_0(void) = EnterFunction : -# 171| mu0_1(unknown) = AliasedDefinition : -# 171| mu0_2(unknown) = UnmodeledDefinition : -# 171| r0_3(glval) = VariableAddress[p] : -# 171| mu0_4(int *) = InitializeParameter[p] : &:r0_3 -# 171| r0_5(glval) = VariableAddress[i] : -# 171| mu0_6(int) = InitializeParameter[i] : &:r0_5 -# 172| r0_7(glval) = VariableAddress[x] : -# 172| mu0_8(int) = Uninitialized[x] : &:r0_7 -# 174| r0_9(glval) = VariableAddress[p] : -# 174| r0_10(int *) = Load : &:r0_9, ~mu0_2 -# 174| r0_11(glval) = VariableAddress[i] : -# 174| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 174| r0_13(glval) = PointerAdd[4] : r0_10, r0_12 -# 174| r0_14(int) = Load : &:r0_13, ~mu0_2 -# 174| r0_15(glval) = VariableAddress[x] : -# 174| mu0_16(int) = Store : &:r0_15, r0_14 -# 175| r0_17(glval) = VariableAddress[p] : -# 175| r0_18(int *) = Load : &:r0_17, ~mu0_2 -# 175| r0_19(glval) = VariableAddress[i] : -# 175| r0_20(int) = Load : &:r0_19, ~mu0_2 -# 175| r0_21(glval) = PointerAdd[4] : r0_18, r0_20 -# 175| r0_22(int) = Load : &:r0_21, ~mu0_2 -# 175| r0_23(glval) = VariableAddress[x] : -# 175| mu0_24(int) = Store : &:r0_23, r0_22 -# 177| r0_25(glval) = VariableAddress[x] : -# 177| r0_26(int) = Load : &:r0_25, ~mu0_2 -# 177| r0_27(glval) = VariableAddress[p] : -# 177| r0_28(int *) = Load : &:r0_27, ~mu0_2 -# 177| r0_29(glval) = VariableAddress[i] : -# 177| r0_30(int) = Load : &:r0_29, ~mu0_2 -# 177| r0_31(glval) = PointerAdd[4] : r0_28, r0_30 -# 177| mu0_32(int) = Store : &:r0_31, r0_26 -# 178| r0_33(glval) = VariableAddress[x] : -# 178| r0_34(int) = Load : &:r0_33, ~mu0_2 -# 178| r0_35(glval) = VariableAddress[p] : -# 178| r0_36(int *) = Load : &:r0_35, ~mu0_2 -# 178| r0_37(glval) = VariableAddress[i] : -# 178| r0_38(int) = Load : &:r0_37, ~mu0_2 -# 178| r0_39(glval) = PointerAdd[4] : r0_36, r0_38 -# 178| mu0_40(int) = Store : &:r0_39, r0_34 -# 180| r0_41(glval) = VariableAddress[a] : -# 180| mu0_42(int[10]) = Uninitialized[a] : &:r0_41 -# 181| r0_43(glval) = VariableAddress[a] : -# 181| r0_44(int *) = Convert : r0_43 -# 181| r0_45(glval) = VariableAddress[i] : -# 181| r0_46(int) = Load : &:r0_45, ~mu0_2 -# 181| r0_47(glval) = PointerAdd[4] : r0_44, r0_46 -# 181| r0_48(int) = Load : &:r0_47, ~mu0_2 -# 181| r0_49(glval) = VariableAddress[x] : -# 181| mu0_50(int) = Store : &:r0_49, r0_48 -# 182| r0_51(glval) = VariableAddress[a] : -# 182| r0_52(int *) = Convert : r0_51 -# 182| r0_53(glval) = VariableAddress[i] : -# 182| r0_54(int) = Load : &:r0_53, ~mu0_2 -# 182| r0_55(glval) = PointerAdd[4] : r0_52, r0_54 -# 182| r0_56(int) = Load : &:r0_55, ~mu0_2 -# 182| r0_57(glval) = VariableAddress[x] : -# 182| mu0_58(int) = Store : &:r0_57, r0_56 -# 183| r0_59(glval) = VariableAddress[x] : -# 183| r0_60(int) = Load : &:r0_59, ~mu0_2 -# 183| r0_61(glval) = VariableAddress[a] : -# 183| r0_62(int *) = Convert : r0_61 -# 183| r0_63(glval) = VariableAddress[i] : -# 183| r0_64(int) = Load : &:r0_63, ~mu0_2 -# 183| r0_65(glval) = PointerAdd[4] : r0_62, r0_64 -# 183| mu0_66(int) = Store : &:r0_65, r0_60 -# 184| r0_67(glval) = VariableAddress[x] : -# 184| r0_68(int) = Load : &:r0_67, ~mu0_2 -# 184| r0_69(glval) = VariableAddress[a] : -# 184| r0_70(int *) = Convert : r0_69 -# 184| r0_71(glval) = VariableAddress[i] : -# 184| r0_72(int) = Load : &:r0_71, ~mu0_2 -# 184| r0_73(glval) = PointerAdd[4] : r0_70, r0_72 -# 184| mu0_74(int) = Store : &:r0_73, r0_68 -# 185| v0_75(void) = NoOp : -# 171| v0_76(void) = ReturnVoid : -# 171| v0_77(void) = UnmodeledUse : mu* -# 171| v0_78(void) = AliasedUse : ~mu0_2 -# 171| v0_79(void) = ExitFunction : +# 171| v171_1(void) = EnterFunction : +# 171| mu171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[p] : +# 171| mu171_5(int *) = InitializeParameter[p] : &:r171_4 +# 171| r171_6(glval) = VariableAddress[i] : +# 171| mu171_7(int) = InitializeParameter[i] : &:r171_6 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| mu172_2(int) = Uninitialized[x] : &:r172_1 +# 174| r174_1(glval) = VariableAddress[p] : +# 174| r174_2(int *) = Load : &:r174_1, ~mu171_3 +# 174| r174_3(glval) = VariableAddress[i] : +# 174| r174_4(int) = Load : &:r174_3, ~mu171_3 +# 174| r174_5(glval) = PointerAdd[4] : r174_2, r174_4 +# 174| r174_6(int) = Load : &:r174_5, ~mu171_3 +# 174| r174_7(glval) = VariableAddress[x] : +# 174| mu174_8(int) = Store : &:r174_7, r174_6 +# 175| r175_1(glval) = VariableAddress[p] : +# 175| r175_2(int *) = Load : &:r175_1, ~mu171_3 +# 175| r175_3(glval) = VariableAddress[i] : +# 175| r175_4(int) = Load : &:r175_3, ~mu171_3 +# 175| r175_5(glval) = PointerAdd[4] : r175_2, r175_4 +# 175| r175_6(int) = Load : &:r175_5, ~mu171_3 +# 175| r175_7(glval) = VariableAddress[x] : +# 175| mu175_8(int) = Store : &:r175_7, r175_6 +# 177| r177_1(glval) = VariableAddress[x] : +# 177| r177_2(int) = Load : &:r177_1, ~mu171_3 +# 177| r177_3(glval) = VariableAddress[p] : +# 177| r177_4(int *) = Load : &:r177_3, ~mu171_3 +# 177| r177_5(glval) = VariableAddress[i] : +# 177| r177_6(int) = Load : &:r177_5, ~mu171_3 +# 177| r177_7(glval) = PointerAdd[4] : r177_4, r177_6 +# 177| mu177_8(int) = Store : &:r177_7, r177_2 +# 178| r178_1(glval) = VariableAddress[x] : +# 178| r178_2(int) = Load : &:r178_1, ~mu171_3 +# 178| r178_3(glval) = VariableAddress[p] : +# 178| r178_4(int *) = Load : &:r178_3, ~mu171_3 +# 178| r178_5(glval) = VariableAddress[i] : +# 178| r178_6(int) = Load : &:r178_5, ~mu171_3 +# 178| r178_7(glval) = PointerAdd[4] : r178_4, r178_6 +# 178| mu178_8(int) = Store : &:r178_7, r178_2 +# 180| r180_1(glval) = VariableAddress[a] : +# 180| mu180_2(int[10]) = Uninitialized[a] : &:r180_1 +# 181| r181_1(glval) = VariableAddress[a] : +# 181| r181_2(int *) = Convert : r181_1 +# 181| r181_3(glval) = VariableAddress[i] : +# 181| r181_4(int) = Load : &:r181_3, ~mu171_3 +# 181| r181_5(glval) = PointerAdd[4] : r181_2, r181_4 +# 181| r181_6(int) = Load : &:r181_5, ~mu171_3 +# 181| r181_7(glval) = VariableAddress[x] : +# 181| mu181_8(int) = Store : &:r181_7, r181_6 +# 182| r182_1(glval) = VariableAddress[a] : +# 182| r182_2(int *) = Convert : r182_1 +# 182| r182_3(glval) = VariableAddress[i] : +# 182| r182_4(int) = Load : &:r182_3, ~mu171_3 +# 182| r182_5(glval) = PointerAdd[4] : r182_2, r182_4 +# 182| r182_6(int) = Load : &:r182_5, ~mu171_3 +# 182| r182_7(glval) = VariableAddress[x] : +# 182| mu182_8(int) = Store : &:r182_7, r182_6 +# 183| r183_1(glval) = VariableAddress[x] : +# 183| r183_2(int) = Load : &:r183_1, ~mu171_3 +# 183| r183_3(glval) = VariableAddress[a] : +# 183| r183_4(int *) = Convert : r183_3 +# 183| r183_5(glval) = VariableAddress[i] : +# 183| r183_6(int) = Load : &:r183_5, ~mu171_3 +# 183| r183_7(glval) = PointerAdd[4] : r183_4, r183_6 +# 183| mu183_8(int) = Store : &:r183_7, r183_2 +# 184| r184_1(glval) = VariableAddress[x] : +# 184| r184_2(int) = Load : &:r184_1, ~mu171_3 +# 184| r184_3(glval) = VariableAddress[a] : +# 184| r184_4(int *) = Convert : r184_3 +# 184| r184_5(glval) = VariableAddress[i] : +# 184| r184_6(int) = Load : &:r184_5, ~mu171_3 +# 184| r184_7(glval) = PointerAdd[4] : r184_4, r184_6 +# 184| mu184_8(int) = Store : &:r184_7, r184_2 +# 185| v185_1(void) = NoOp : +# 171| v171_8(void) = ReturnVoid : +# 171| v171_9(void) = UnmodeledUse : mu* +# 171| v171_10(void) = AliasedUse : ~mu171_3 +# 171| v171_11(void) = ExitFunction : # 187| void StringLiteral(int) # 187| Block 0 -# 187| v0_0(void) = EnterFunction : -# 187| mu0_1(unknown) = AliasedDefinition : -# 187| mu0_2(unknown) = UnmodeledDefinition : -# 187| r0_3(glval) = VariableAddress[i] : -# 187| mu0_4(int) = InitializeParameter[i] : &:r0_3 -# 188| r0_5(glval) = VariableAddress[c] : -# 188| r0_6(glval) = StringConstant["Foo"] : -# 188| r0_7(char *) = Convert : r0_6 -# 188| r0_8(glval) = VariableAddress[i] : -# 188| r0_9(int) = Load : &:r0_8, ~mu0_2 -# 188| r0_10(glval) = PointerAdd[1] : r0_7, r0_9 -# 188| r0_11(char) = Load : &:r0_10, ~mu0_2 -# 188| mu0_12(char) = Store : &:r0_5, r0_11 -# 189| r0_13(glval) = VariableAddress[pwc] : -# 189| r0_14(glval) = StringConstant[L"Bar"] : -# 189| r0_15(wchar_t *) = Convert : r0_14 -# 189| r0_16(wchar_t *) = Convert : r0_15 -# 189| mu0_17(wchar_t *) = Store : &:r0_13, r0_16 -# 190| r0_18(glval) = VariableAddress[wc] : -# 190| r0_19(glval) = VariableAddress[pwc] : -# 190| r0_20(wchar_t *) = Load : &:r0_19, ~mu0_2 -# 190| r0_21(glval) = VariableAddress[i] : -# 190| r0_22(int) = Load : &:r0_21, ~mu0_2 -# 190| r0_23(glval) = PointerAdd[4] : r0_20, r0_22 -# 190| r0_24(wchar_t) = Load : &:r0_23, ~mu0_2 -# 190| mu0_25(wchar_t) = Store : &:r0_18, r0_24 -# 191| v0_26(void) = NoOp : -# 187| v0_27(void) = ReturnVoid : -# 187| v0_28(void) = UnmodeledUse : mu* -# 187| v0_29(void) = AliasedUse : ~mu0_2 -# 187| v0_30(void) = ExitFunction : +# 187| v187_1(void) = EnterFunction : +# 187| mu187_2(unknown) = AliasedDefinition : +# 187| mu187_3(unknown) = UnmodeledDefinition : +# 187| r187_4(glval) = VariableAddress[i] : +# 187| mu187_5(int) = InitializeParameter[i] : &:r187_4 +# 188| r188_1(glval) = VariableAddress[c] : +# 188| r188_2(glval) = StringConstant["Foo"] : +# 188| r188_3(char *) = Convert : r188_2 +# 188| r188_4(glval) = VariableAddress[i] : +# 188| r188_5(int) = Load : &:r188_4, ~mu187_3 +# 188| r188_6(glval) = PointerAdd[1] : r188_3, r188_5 +# 188| r188_7(char) = Load : &:r188_6, ~mu187_3 +# 188| mu188_8(char) = Store : &:r188_1, r188_7 +# 189| r189_1(glval) = VariableAddress[pwc] : +# 189| r189_2(glval) = StringConstant[L"Bar"] : +# 189| r189_3(wchar_t *) = Convert : r189_2 +# 189| r189_4(wchar_t *) = Convert : r189_3 +# 189| mu189_5(wchar_t *) = Store : &:r189_1, r189_4 +# 190| r190_1(glval) = VariableAddress[wc] : +# 190| r190_2(glval) = VariableAddress[pwc] : +# 190| r190_3(wchar_t *) = Load : &:r190_2, ~mu187_3 +# 190| r190_4(glval) = VariableAddress[i] : +# 190| r190_5(int) = Load : &:r190_4, ~mu187_3 +# 190| r190_6(glval) = PointerAdd[4] : r190_3, r190_5 +# 190| r190_7(wchar_t) = Load : &:r190_6, ~mu187_3 +# 190| mu190_8(wchar_t) = Store : &:r190_1, r190_7 +# 191| v191_1(void) = NoOp : +# 187| v187_6(void) = ReturnVoid : +# 187| v187_7(void) = UnmodeledUse : mu* +# 187| v187_8(void) = AliasedUse : ~mu187_3 +# 187| v187_9(void) = ExitFunction : # 193| void PointerCompare(int*, int*) # 193| Block 0 -# 193| v0_0(void) = EnterFunction : -# 193| mu0_1(unknown) = AliasedDefinition : -# 193| mu0_2(unknown) = UnmodeledDefinition : -# 193| r0_3(glval) = VariableAddress[p] : -# 193| mu0_4(int *) = InitializeParameter[p] : &:r0_3 -# 193| r0_5(glval) = VariableAddress[q] : -# 193| mu0_6(int *) = InitializeParameter[q] : &:r0_5 -# 194| r0_7(glval) = VariableAddress[b] : -# 194| mu0_8(bool) = Uninitialized[b] : &:r0_7 -# 196| r0_9(glval) = VariableAddress[p] : -# 196| r0_10(int *) = Load : &:r0_9, ~mu0_2 -# 196| r0_11(glval) = VariableAddress[q] : -# 196| r0_12(int *) = Load : &:r0_11, ~mu0_2 -# 196| r0_13(bool) = CompareEQ : r0_10, r0_12 -# 196| r0_14(glval) = VariableAddress[b] : -# 196| mu0_15(bool) = Store : &:r0_14, r0_13 -# 197| r0_16(glval) = VariableAddress[p] : -# 197| r0_17(int *) = Load : &:r0_16, ~mu0_2 -# 197| r0_18(glval) = VariableAddress[q] : -# 197| r0_19(int *) = Load : &:r0_18, ~mu0_2 -# 197| r0_20(bool) = CompareNE : r0_17, r0_19 -# 197| r0_21(glval) = VariableAddress[b] : -# 197| mu0_22(bool) = Store : &:r0_21, r0_20 -# 198| r0_23(glval) = VariableAddress[p] : -# 198| r0_24(int *) = Load : &:r0_23, ~mu0_2 -# 198| r0_25(glval) = VariableAddress[q] : -# 198| r0_26(int *) = Load : &:r0_25, ~mu0_2 -# 198| r0_27(bool) = CompareLT : r0_24, r0_26 -# 198| r0_28(glval) = VariableAddress[b] : -# 198| mu0_29(bool) = Store : &:r0_28, r0_27 -# 199| r0_30(glval) = VariableAddress[p] : -# 199| r0_31(int *) = Load : &:r0_30, ~mu0_2 -# 199| r0_32(glval) = VariableAddress[q] : -# 199| r0_33(int *) = Load : &:r0_32, ~mu0_2 -# 199| r0_34(bool) = CompareGT : r0_31, r0_33 -# 199| r0_35(glval) = VariableAddress[b] : -# 199| mu0_36(bool) = Store : &:r0_35, r0_34 -# 200| r0_37(glval) = VariableAddress[p] : -# 200| r0_38(int *) = Load : &:r0_37, ~mu0_2 -# 200| r0_39(glval) = VariableAddress[q] : -# 200| r0_40(int *) = Load : &:r0_39, ~mu0_2 -# 200| r0_41(bool) = CompareLE : r0_38, r0_40 -# 200| r0_42(glval) = VariableAddress[b] : -# 200| mu0_43(bool) = Store : &:r0_42, r0_41 -# 201| r0_44(glval) = VariableAddress[p] : -# 201| r0_45(int *) = Load : &:r0_44, ~mu0_2 -# 201| r0_46(glval) = VariableAddress[q] : -# 201| r0_47(int *) = Load : &:r0_46, ~mu0_2 -# 201| r0_48(bool) = CompareGE : r0_45, r0_47 -# 201| r0_49(glval) = VariableAddress[b] : -# 201| mu0_50(bool) = Store : &:r0_49, r0_48 -# 202| v0_51(void) = NoOp : -# 193| v0_52(void) = ReturnVoid : -# 193| v0_53(void) = UnmodeledUse : mu* -# 193| v0_54(void) = AliasedUse : ~mu0_2 -# 193| v0_55(void) = ExitFunction : +# 193| v193_1(void) = EnterFunction : +# 193| mu193_2(unknown) = AliasedDefinition : +# 193| mu193_3(unknown) = UnmodeledDefinition : +# 193| r193_4(glval) = VariableAddress[p] : +# 193| mu193_5(int *) = InitializeParameter[p] : &:r193_4 +# 193| r193_6(glval) = VariableAddress[q] : +# 193| mu193_7(int *) = InitializeParameter[q] : &:r193_6 +# 194| r194_1(glval) = VariableAddress[b] : +# 194| mu194_2(bool) = Uninitialized[b] : &:r194_1 +# 196| r196_1(glval) = VariableAddress[p] : +# 196| r196_2(int *) = Load : &:r196_1, ~mu193_3 +# 196| r196_3(glval) = VariableAddress[q] : +# 196| r196_4(int *) = Load : &:r196_3, ~mu193_3 +# 196| r196_5(bool) = CompareEQ : r196_2, r196_4 +# 196| r196_6(glval) = VariableAddress[b] : +# 196| mu196_7(bool) = Store : &:r196_6, r196_5 +# 197| r197_1(glval) = VariableAddress[p] : +# 197| r197_2(int *) = Load : &:r197_1, ~mu193_3 +# 197| r197_3(glval) = VariableAddress[q] : +# 197| r197_4(int *) = Load : &:r197_3, ~mu193_3 +# 197| r197_5(bool) = CompareNE : r197_2, r197_4 +# 197| r197_6(glval) = VariableAddress[b] : +# 197| mu197_7(bool) = Store : &:r197_6, r197_5 +# 198| r198_1(glval) = VariableAddress[p] : +# 198| r198_2(int *) = Load : &:r198_1, ~mu193_3 +# 198| r198_3(glval) = VariableAddress[q] : +# 198| r198_4(int *) = Load : &:r198_3, ~mu193_3 +# 198| r198_5(bool) = CompareLT : r198_2, r198_4 +# 198| r198_6(glval) = VariableAddress[b] : +# 198| mu198_7(bool) = Store : &:r198_6, r198_5 +# 199| r199_1(glval) = VariableAddress[p] : +# 199| r199_2(int *) = Load : &:r199_1, ~mu193_3 +# 199| r199_3(glval) = VariableAddress[q] : +# 199| r199_4(int *) = Load : &:r199_3, ~mu193_3 +# 199| r199_5(bool) = CompareGT : r199_2, r199_4 +# 199| r199_6(glval) = VariableAddress[b] : +# 199| mu199_7(bool) = Store : &:r199_6, r199_5 +# 200| r200_1(glval) = VariableAddress[p] : +# 200| r200_2(int *) = Load : &:r200_1, ~mu193_3 +# 200| r200_3(glval) = VariableAddress[q] : +# 200| r200_4(int *) = Load : &:r200_3, ~mu193_3 +# 200| r200_5(bool) = CompareLE : r200_2, r200_4 +# 200| r200_6(glval) = VariableAddress[b] : +# 200| mu200_7(bool) = Store : &:r200_6, r200_5 +# 201| r201_1(glval) = VariableAddress[p] : +# 201| r201_2(int *) = Load : &:r201_1, ~mu193_3 +# 201| r201_3(glval) = VariableAddress[q] : +# 201| r201_4(int *) = Load : &:r201_3, ~mu193_3 +# 201| r201_5(bool) = CompareGE : r201_2, r201_4 +# 201| r201_6(glval) = VariableAddress[b] : +# 201| mu201_7(bool) = Store : &:r201_6, r201_5 +# 202| v202_1(void) = NoOp : +# 193| v193_8(void) = ReturnVoid : +# 193| v193_9(void) = UnmodeledUse : mu* +# 193| v193_10(void) = AliasedUse : ~mu193_3 +# 193| v193_11(void) = ExitFunction : # 204| void PointerCrement(int*) # 204| Block 0 -# 204| v0_0(void) = EnterFunction : -# 204| mu0_1(unknown) = AliasedDefinition : -# 204| mu0_2(unknown) = UnmodeledDefinition : -# 204| r0_3(glval) = VariableAddress[p] : -# 204| mu0_4(int *) = InitializeParameter[p] : &:r0_3 -# 205| r0_5(glval) = VariableAddress[q] : -# 205| mu0_6(int *) = Uninitialized[q] : &:r0_5 -# 207| r0_7(glval) = VariableAddress[p] : -# 207| r0_8(int *) = Load : &:r0_7, ~mu0_2 -# 207| r0_9(int) = Constant[1] : -# 207| r0_10(int *) = PointerAdd[4] : r0_8, r0_9 -# 207| mu0_11(int *) = Store : &:r0_7, r0_10 -# 207| r0_12(glval) = VariableAddress[q] : -# 207| mu0_13(int *) = Store : &:r0_12, r0_10 -# 208| r0_14(glval) = VariableAddress[p] : -# 208| r0_15(int *) = Load : &:r0_14, ~mu0_2 -# 208| r0_16(int) = Constant[1] : -# 208| r0_17(int *) = PointerSub[4] : r0_15, r0_16 -# 208| mu0_18(int *) = Store : &:r0_14, r0_17 -# 208| r0_19(glval) = VariableAddress[q] : -# 208| mu0_20(int *) = Store : &:r0_19, r0_17 -# 209| r0_21(glval) = VariableAddress[p] : -# 209| r0_22(int *) = Load : &:r0_21, ~mu0_2 -# 209| r0_23(int) = Constant[1] : -# 209| r0_24(int *) = PointerAdd[4] : r0_22, r0_23 -# 209| mu0_25(int *) = Store : &:r0_21, r0_24 -# 209| r0_26(glval) = VariableAddress[q] : -# 209| mu0_27(int *) = Store : &:r0_26, r0_22 -# 210| r0_28(glval) = VariableAddress[p] : -# 210| r0_29(int *) = Load : &:r0_28, ~mu0_2 -# 210| r0_30(int) = Constant[1] : -# 210| r0_31(int *) = PointerSub[4] : r0_29, r0_30 -# 210| mu0_32(int *) = Store : &:r0_28, r0_31 -# 210| r0_33(glval) = VariableAddress[q] : -# 210| mu0_34(int *) = Store : &:r0_33, r0_29 -# 211| v0_35(void) = NoOp : -# 204| v0_36(void) = ReturnVoid : -# 204| v0_37(void) = UnmodeledUse : mu* -# 204| v0_38(void) = AliasedUse : ~mu0_2 -# 204| v0_39(void) = ExitFunction : +# 204| v204_1(void) = EnterFunction : +# 204| mu204_2(unknown) = AliasedDefinition : +# 204| mu204_3(unknown) = UnmodeledDefinition : +# 204| r204_4(glval) = VariableAddress[p] : +# 204| mu204_5(int *) = InitializeParameter[p] : &:r204_4 +# 205| r205_1(glval) = VariableAddress[q] : +# 205| mu205_2(int *) = Uninitialized[q] : &:r205_1 +# 207| r207_1(glval) = VariableAddress[p] : +# 207| r207_2(int *) = Load : &:r207_1, ~mu204_3 +# 207| r207_3(int) = Constant[1] : +# 207| r207_4(int *) = PointerAdd[4] : r207_2, r207_3 +# 207| mu207_5(int *) = Store : &:r207_1, r207_4 +# 207| r207_6(glval) = VariableAddress[q] : +# 207| mu207_7(int *) = Store : &:r207_6, r207_4 +# 208| r208_1(glval) = VariableAddress[p] : +# 208| r208_2(int *) = Load : &:r208_1, ~mu204_3 +# 208| r208_3(int) = Constant[1] : +# 208| r208_4(int *) = PointerSub[4] : r208_2, r208_3 +# 208| mu208_5(int *) = Store : &:r208_1, r208_4 +# 208| r208_6(glval) = VariableAddress[q] : +# 208| mu208_7(int *) = Store : &:r208_6, r208_4 +# 209| r209_1(glval) = VariableAddress[p] : +# 209| r209_2(int *) = Load : &:r209_1, ~mu204_3 +# 209| r209_3(int) = Constant[1] : +# 209| r209_4(int *) = PointerAdd[4] : r209_2, r209_3 +# 209| mu209_5(int *) = Store : &:r209_1, r209_4 +# 209| r209_6(glval) = VariableAddress[q] : +# 209| mu209_7(int *) = Store : &:r209_6, r209_2 +# 210| r210_1(glval) = VariableAddress[p] : +# 210| r210_2(int *) = Load : &:r210_1, ~mu204_3 +# 210| r210_3(int) = Constant[1] : +# 210| r210_4(int *) = PointerSub[4] : r210_2, r210_3 +# 210| mu210_5(int *) = Store : &:r210_1, r210_4 +# 210| r210_6(glval) = VariableAddress[q] : +# 210| mu210_7(int *) = Store : &:r210_6, r210_2 +# 211| v211_1(void) = NoOp : +# 204| v204_6(void) = ReturnVoid : +# 204| v204_7(void) = UnmodeledUse : mu* +# 204| v204_8(void) = AliasedUse : ~mu204_3 +# 204| v204_9(void) = ExitFunction : # 213| void CompoundAssignment() # 213| Block 0 -# 213| v0_0(void) = EnterFunction : -# 213| mu0_1(unknown) = AliasedDefinition : -# 213| mu0_2(unknown) = UnmodeledDefinition : -# 215| r0_3(glval) = VariableAddress[x] : -# 215| r0_4(int) = Constant[5] : -# 215| mu0_5(int) = Store : &:r0_3, r0_4 -# 216| r0_6(int) = Constant[7] : -# 216| r0_7(glval) = VariableAddress[x] : -# 216| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 216| r0_9(int) = Add : r0_8, r0_6 -# 216| mu0_10(int) = Store : &:r0_7, r0_9 -# 219| r0_11(glval) = VariableAddress[y] : -# 219| r0_12(short) = Constant[5] : -# 219| mu0_13(short) = Store : &:r0_11, r0_12 -# 220| r0_14(glval) = VariableAddress[x] : -# 220| r0_15(int) = Load : &:r0_14, ~mu0_2 -# 220| r0_16(glval) = VariableAddress[y] : -# 220| r0_17(short) = Load : &:r0_16, ~mu0_2 -# 220| r0_18(int) = Convert : r0_17 -# 220| r0_19(int) = Add : r0_18, r0_15 -# 220| r0_20(short) = Convert : r0_19 -# 220| mu0_21(short) = Store : &:r0_16, r0_20 -# 223| r0_22(int) = Constant[1] : -# 223| r0_23(glval) = VariableAddress[y] : -# 223| r0_24(short) = Load : &:r0_23, ~mu0_2 -# 223| r0_25(short) = ShiftLeft : r0_24, r0_22 -# 223| mu0_26(short) = Store : &:r0_23, r0_25 -# 226| r0_27(glval) = VariableAddress[z] : -# 226| r0_28(long) = Constant[7] : -# 226| mu0_29(long) = Store : &:r0_27, r0_28 -# 227| r0_30(float) = Constant[2.0] : -# 227| r0_31(glval) = VariableAddress[z] : -# 227| r0_32(long) = Load : &:r0_31, ~mu0_2 -# 227| r0_33(float) = Convert : r0_32 -# 227| r0_34(float) = Add : r0_33, r0_30 -# 227| r0_35(long) = Convert : r0_34 -# 227| mu0_36(long) = Store : &:r0_31, r0_35 -# 228| v0_37(void) = NoOp : -# 213| v0_38(void) = ReturnVoid : -# 213| v0_39(void) = UnmodeledUse : mu* -# 213| v0_40(void) = AliasedUse : ~mu0_2 -# 213| v0_41(void) = ExitFunction : +# 213| v213_1(void) = EnterFunction : +# 213| mu213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 215| r215_1(glval) = VariableAddress[x] : +# 215| r215_2(int) = Constant[5] : +# 215| mu215_3(int) = Store : &:r215_1, r215_2 +# 216| r216_1(int) = Constant[7] : +# 216| r216_2(glval) = VariableAddress[x] : +# 216| r216_3(int) = Load : &:r216_2, ~mu213_3 +# 216| r216_4(int) = Add : r216_3, r216_1 +# 216| mu216_5(int) = Store : &:r216_2, r216_4 +# 219| r219_1(glval) = VariableAddress[y] : +# 219| r219_2(short) = Constant[5] : +# 219| mu219_3(short) = Store : &:r219_1, r219_2 +# 220| r220_1(glval) = VariableAddress[x] : +# 220| r220_2(int) = Load : &:r220_1, ~mu213_3 +# 220| r220_3(glval) = VariableAddress[y] : +# 220| r220_4(short) = Load : &:r220_3, ~mu213_3 +# 220| r220_5(int) = Convert : r220_4 +# 220| r220_6(int) = Add : r220_5, r220_2 +# 220| r220_7(short) = Convert : r220_6 +# 220| mu220_8(short) = Store : &:r220_3, r220_7 +# 223| r223_1(int) = Constant[1] : +# 223| r223_2(glval) = VariableAddress[y] : +# 223| r223_3(short) = Load : &:r223_2, ~mu213_3 +# 223| r223_4(short) = ShiftLeft : r223_3, r223_1 +# 223| mu223_5(short) = Store : &:r223_2, r223_4 +# 226| r226_1(glval) = VariableAddress[z] : +# 226| r226_2(long) = Constant[7] : +# 226| mu226_3(long) = Store : &:r226_1, r226_2 +# 227| r227_1(float) = Constant[2.0] : +# 227| r227_2(glval) = VariableAddress[z] : +# 227| r227_3(long) = Load : &:r227_2, ~mu213_3 +# 227| r227_4(float) = Convert : r227_3 +# 227| r227_5(float) = Add : r227_4, r227_1 +# 227| r227_6(long) = Convert : r227_5 +# 227| mu227_7(long) = Store : &:r227_2, r227_6 +# 228| v228_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~mu213_3 +# 213| v213_7(void) = ExitFunction : # 230| void UninitializedVariables() # 230| Block 0 -# 230| v0_0(void) = EnterFunction : -# 230| mu0_1(unknown) = AliasedDefinition : -# 230| mu0_2(unknown) = UnmodeledDefinition : -# 231| r0_3(glval) = VariableAddress[x] : -# 231| mu0_4(int) = Uninitialized[x] : &:r0_3 -# 232| r0_5(glval) = VariableAddress[y] : -# 232| r0_6(glval) = VariableAddress[x] : -# 232| r0_7(int) = Load : &:r0_6, ~mu0_2 -# 232| mu0_8(int) = Store : &:r0_5, r0_7 -# 233| v0_9(void) = NoOp : -# 230| v0_10(void) = ReturnVoid : -# 230| v0_11(void) = UnmodeledUse : mu* -# 230| v0_12(void) = AliasedUse : ~mu0_2 -# 230| v0_13(void) = ExitFunction : +# 230| v230_1(void) = EnterFunction : +# 230| mu230_2(unknown) = AliasedDefinition : +# 230| mu230_3(unknown) = UnmodeledDefinition : +# 231| r231_1(glval) = VariableAddress[x] : +# 231| mu231_2(int) = Uninitialized[x] : &:r231_1 +# 232| r232_1(glval) = VariableAddress[y] : +# 232| r232_2(glval) = VariableAddress[x] : +# 232| r232_3(int) = Load : &:r232_2, ~mu230_3 +# 232| mu232_4(int) = Store : &:r232_1, r232_3 +# 233| v233_1(void) = NoOp : +# 230| v230_4(void) = ReturnVoid : +# 230| v230_5(void) = UnmodeledUse : mu* +# 230| v230_6(void) = AliasedUse : ~mu230_3 +# 230| v230_7(void) = ExitFunction : # 235| int Parameters(int, int) # 235| Block 0 -# 235| v0_0(void) = EnterFunction : -# 235| mu0_1(unknown) = AliasedDefinition : -# 235| mu0_2(unknown) = UnmodeledDefinition : -# 235| r0_3(glval) = VariableAddress[x] : -# 235| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 235| r0_5(glval) = VariableAddress[y] : -# 235| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 236| r0_7(glval) = VariableAddress[#return] : -# 236| r0_8(glval) = VariableAddress[x] : -# 236| r0_9(int) = Load : &:r0_8, ~mu0_2 -# 236| r0_10(glval) = VariableAddress[y] : -# 236| r0_11(int) = Load : &:r0_10, ~mu0_2 -# 236| r0_12(int) = Rem : r0_9, r0_11 -# 236| mu0_13(int) = Store : &:r0_7, r0_12 -# 235| r0_14(glval) = VariableAddress[#return] : -# 235| v0_15(void) = ReturnValue : &:r0_14, ~mu0_2 -# 235| v0_16(void) = UnmodeledUse : mu* -# 235| v0_17(void) = AliasedUse : ~mu0_2 -# 235| v0_18(void) = ExitFunction : +# 235| v235_1(void) = EnterFunction : +# 235| mu235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = VariableAddress[x] : +# 235| mu235_5(int) = InitializeParameter[x] : &:r235_4 +# 235| r235_6(glval) = VariableAddress[y] : +# 235| mu235_7(int) = InitializeParameter[y] : &:r235_6 +# 236| r236_1(glval) = VariableAddress[#return] : +# 236| r236_2(glval) = VariableAddress[x] : +# 236| r236_3(int) = Load : &:r236_2, ~mu235_3 +# 236| r236_4(glval) = VariableAddress[y] : +# 236| r236_5(int) = Load : &:r236_4, ~mu235_3 +# 236| r236_6(int) = Rem : r236_3, r236_5 +# 236| mu236_7(int) = Store : &:r236_1, r236_6 +# 235| r235_8(glval) = VariableAddress[#return] : +# 235| v235_9(void) = ReturnValue : &:r235_8, ~mu235_3 +# 235| v235_10(void) = UnmodeledUse : mu* +# 235| v235_11(void) = AliasedUse : ~mu235_3 +# 235| v235_12(void) = ExitFunction : # 239| void IfStatements(bool, int, int) # 239| Block 0 -# 239| v0_0(void) = EnterFunction : -# 239| mu0_1(unknown) = AliasedDefinition : -# 239| mu0_2(unknown) = UnmodeledDefinition : -# 239| r0_3(glval) = VariableAddress[b] : -# 239| mu0_4(bool) = InitializeParameter[b] : &:r0_3 -# 239| r0_5(glval) = VariableAddress[x] : -# 239| mu0_6(int) = InitializeParameter[x] : &:r0_5 -# 239| r0_7(glval) = VariableAddress[y] : -# 239| mu0_8(int) = InitializeParameter[y] : &:r0_7 -# 240| r0_9(glval) = VariableAddress[b] : -# 240| r0_10(bool) = Load : &:r0_9, ~mu0_2 -# 240| v0_11(void) = ConditionalBranch : r0_10 +# 239| v239_1(void) = EnterFunction : +# 239| mu239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 239| r239_4(glval) = VariableAddress[b] : +# 239| mu239_5(bool) = InitializeParameter[b] : &:r239_4 +# 239| r239_6(glval) = VariableAddress[x] : +# 239| mu239_7(int) = InitializeParameter[x] : &:r239_6 +# 239| r239_8(glval) = VariableAddress[y] : +# 239| mu239_9(int) = InitializeParameter[y] : &:r239_8 +# 240| r240_1(glval) = VariableAddress[b] : +# 240| r240_2(bool) = Load : &:r240_1, ~mu239_3 +# 240| v240_3(void) = ConditionalBranch : r240_2 #-----| False -> Block 1 #-----| True -> Block 7 # 243| Block 1 -# 243| r1_0(glval) = VariableAddress[b] : -# 243| r1_1(bool) = Load : &:r1_0, ~mu0_2 -# 243| v1_2(void) = ConditionalBranch : r1_1 +# 243| r243_1(glval) = VariableAddress[b] : +# 243| r243_2(bool) = Load : &:r243_1, ~mu239_3 +# 243| v243_3(void) = ConditionalBranch : r243_2 #-----| False -> Block 3 #-----| True -> Block 2 # 244| Block 2 -# 244| r2_0(glval) = VariableAddress[y] : -# 244| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 244| r2_2(glval) = VariableAddress[x] : -# 244| mu2_3(int) = Store : &:r2_2, r2_1 +# 244| r244_1(glval) = VariableAddress[y] : +# 244| r244_2(int) = Load : &:r244_1, ~mu239_3 +# 244| r244_3(glval) = VariableAddress[x] : +# 244| mu244_4(int) = Store : &:r244_3, r244_2 #-----| Goto -> Block 3 # 247| Block 3 -# 247| r3_0(glval) = VariableAddress[x] : -# 247| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 247| r3_2(int) = Constant[7] : -# 247| r3_3(bool) = CompareLT : r3_1, r3_2 -# 247| v3_4(void) = ConditionalBranch : r3_3 +# 247| r247_1(glval) = VariableAddress[x] : +# 247| r247_2(int) = Load : &:r247_1, ~mu239_3 +# 247| r247_3(int) = Constant[7] : +# 247| r247_4(bool) = CompareLT : r247_2, r247_3 +# 247| v247_5(void) = ConditionalBranch : r247_4 #-----| False -> Block 5 #-----| True -> Block 4 # 248| Block 4 -# 248| r4_0(int) = Constant[2] : -# 248| r4_1(glval) = VariableAddress[x] : -# 248| mu4_2(int) = Store : &:r4_1, r4_0 +# 248| r248_1(int) = Constant[2] : +# 248| r248_2(glval) = VariableAddress[x] : +# 248| mu248_3(int) = Store : &:r248_2, r248_1 #-----| Goto -> Block 6 # 250| Block 5 -# 250| r5_0(int) = Constant[7] : -# 250| r5_1(glval) = VariableAddress[x] : -# 250| mu5_2(int) = Store : &:r5_1, r5_0 +# 250| r250_1(int) = Constant[7] : +# 250| r250_2(glval) = VariableAddress[x] : +# 250| mu250_3(int) = Store : &:r250_2, r250_1 #-----| Goto -> Block 6 # 251| Block 6 -# 251| v6_0(void) = NoOp : -# 239| v6_1(void) = ReturnVoid : -# 239| v6_2(void) = UnmodeledUse : mu* -# 239| v6_3(void) = AliasedUse : ~mu0_2 -# 239| v6_4(void) = ExitFunction : +# 251| v251_1(void) = NoOp : +# 239| v239_10(void) = ReturnVoid : +# 239| v239_11(void) = UnmodeledUse : mu* +# 239| v239_12(void) = AliasedUse : ~mu239_3 +# 239| v239_13(void) = ExitFunction : # 240| Block 7 -# 240| v7_0(void) = NoOp : +# 240| v240_4(void) = NoOp : #-----| Goto -> Block 1 # 253| void WhileStatements(int) # 253| Block 0 -# 253| v0_0(void) = EnterFunction : -# 253| mu0_1(unknown) = AliasedDefinition : -# 253| mu0_2(unknown) = UnmodeledDefinition : -# 253| r0_3(glval) = VariableAddress[n] : -# 253| mu0_4(int) = InitializeParameter[n] : &:r0_3 +# 253| v253_1(void) = EnterFunction : +# 253| mu253_2(unknown) = AliasedDefinition : +# 253| mu253_3(unknown) = UnmodeledDefinition : +# 253| r253_4(glval) = VariableAddress[n] : +# 253| mu253_5(int) = InitializeParameter[n] : &:r253_4 #-----| Goto -> Block 3 # 255| Block 1 -# 255| r1_0(int) = Constant[1] : -# 255| r1_1(glval) = VariableAddress[n] : -# 255| r1_2(int) = Load : &:r1_1, ~mu0_2 -# 255| r1_3(int) = Sub : r1_2, r1_0 -# 255| mu1_4(int) = Store : &:r1_1, r1_3 +# 255| r255_1(int) = Constant[1] : +# 255| r255_2(glval) = VariableAddress[n] : +# 255| r255_3(int) = Load : &:r255_2, ~mu253_3 +# 255| r255_4(int) = Sub : r255_3, r255_1 +# 255| mu255_5(int) = Store : &:r255_2, r255_4 #-----| Goto (back edge) -> Block 3 # 257| Block 2 -# 257| v2_0(void) = NoOp : -# 253| v2_1(void) = ReturnVoid : -# 253| v2_2(void) = UnmodeledUse : mu* -# 253| v2_3(void) = AliasedUse : ~mu0_2 -# 253| v2_4(void) = ExitFunction : +# 257| v257_1(void) = NoOp : +# 253| v253_6(void) = ReturnVoid : +# 253| v253_7(void) = UnmodeledUse : mu* +# 253| v253_8(void) = AliasedUse : ~mu253_3 +# 253| v253_9(void) = ExitFunction : # 254| Block 3 -# 254| r3_0(glval) = VariableAddress[n] : -# 254| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 254| r3_2(int) = Constant[0] : -# 254| r3_3(bool) = CompareGT : r3_1, r3_2 -# 254| v3_4(void) = ConditionalBranch : r3_3 +# 254| r254_1(glval) = VariableAddress[n] : +# 254| r254_2(int) = Load : &:r254_1, ~mu253_3 +# 254| r254_3(int) = Constant[0] : +# 254| r254_4(bool) = CompareGT : r254_2, r254_3 +# 254| v254_5(void) = ConditionalBranch : r254_4 #-----| False -> Block 2 #-----| True -> Block 1 # 259| void DoStatements(int) # 259| Block 0 -# 259| v0_0(void) = EnterFunction : -# 259| mu0_1(unknown) = AliasedDefinition : -# 259| mu0_2(unknown) = UnmodeledDefinition : -# 259| r0_3(glval) = VariableAddress[n] : -# 259| mu0_4(int) = InitializeParameter[n] : &:r0_3 +# 259| v259_1(void) = EnterFunction : +# 259| mu259_2(unknown) = AliasedDefinition : +# 259| mu259_3(unknown) = UnmodeledDefinition : +# 259| r259_4(glval) = VariableAddress[n] : +# 259| mu259_5(int) = InitializeParameter[n] : &:r259_4 #-----| Goto -> Block 1 # 261| Block 1 -# 261| r1_0(int) = Constant[1] : -# 261| r1_1(glval) = VariableAddress[n] : -# 261| r1_2(int) = Load : &:r1_1, ~mu0_2 -# 261| r1_3(int) = Sub : r1_2, r1_0 -# 261| mu1_4(int) = Store : &:r1_1, r1_3 -# 262| r1_5(glval) = VariableAddress[n] : -# 262| r1_6(int) = Load : &:r1_5, ~mu0_2 -# 262| r1_7(int) = Constant[0] : -# 262| r1_8(bool) = CompareGT : r1_6, r1_7 -# 262| v1_9(void) = ConditionalBranch : r1_8 +# 261| r261_1(int) = Constant[1] : +# 261| r261_2(glval) = VariableAddress[n] : +# 261| r261_3(int) = Load : &:r261_2, ~mu259_3 +# 261| r261_4(int) = Sub : r261_3, r261_1 +# 261| mu261_5(int) = Store : &:r261_2, r261_4 +# 262| r262_1(glval) = VariableAddress[n] : +# 262| r262_2(int) = Load : &:r262_1, ~mu259_3 +# 262| r262_3(int) = Constant[0] : +# 262| r262_4(bool) = CompareGT : r262_2, r262_3 +# 262| v262_5(void) = ConditionalBranch : r262_4 #-----| False -> Block 2 #-----| True (back edge) -> Block 1 # 263| Block 2 -# 263| v2_0(void) = NoOp : -# 259| v2_1(void) = ReturnVoid : -# 259| v2_2(void) = UnmodeledUse : mu* -# 259| v2_3(void) = AliasedUse : ~mu0_2 -# 259| v2_4(void) = ExitFunction : +# 263| v263_1(void) = NoOp : +# 259| v259_6(void) = ReturnVoid : +# 259| v259_7(void) = UnmodeledUse : mu* +# 259| v259_8(void) = AliasedUse : ~mu259_3 +# 259| v259_9(void) = ExitFunction : # 265| void For_Empty() # 265| Block 0 -# 265| v0_0(void) = EnterFunction : -# 265| mu0_1(unknown) = AliasedDefinition : -# 265| mu0_2(unknown) = UnmodeledDefinition : -# 266| r0_3(glval) = VariableAddress[j] : -# 266| mu0_4(int) = Uninitialized[j] : &:r0_3 +# 265| v265_1(void) = EnterFunction : +# 265| mu265_2(unknown) = AliasedDefinition : +# 265| mu265_3(unknown) = UnmodeledDefinition : +# 266| r266_1(glval) = VariableAddress[j] : +# 266| mu266_2(int) = Uninitialized[j] : &:r266_1 #-----| Goto -> Block 2 # 265| Block 1 -# 265| v1_0(void) = ReturnVoid : -# 265| v1_1(void) = UnmodeledUse : mu* -# 265| v1_2(void) = AliasedUse : ~mu0_2 -# 265| v1_3(void) = ExitFunction : +# 265| v265_4(void) = ReturnVoid : +# 265| v265_5(void) = UnmodeledUse : mu* +# 265| v265_6(void) = AliasedUse : ~mu265_3 +# 265| v265_7(void) = ExitFunction : # 268| Block 2 -# 268| v2_0(void) = NoOp : +# 268| v268_1(void) = NoOp : #-----| Goto (back edge) -> Block 2 # 272| void For_Init() # 272| Block 0 -# 272| v0_0(void) = EnterFunction : -# 272| mu0_1(unknown) = AliasedDefinition : -# 272| mu0_2(unknown) = UnmodeledDefinition : -# 273| r0_3(glval) = VariableAddress[i] : -# 273| r0_4(int) = Constant[0] : -# 273| mu0_5(int) = Store : &:r0_3, r0_4 +# 272| v272_1(void) = EnterFunction : +# 272| mu272_2(unknown) = AliasedDefinition : +# 272| mu272_3(unknown) = UnmodeledDefinition : +# 273| r273_1(glval) = VariableAddress[i] : +# 273| r273_2(int) = Constant[0] : +# 273| mu273_3(int) = Store : &:r273_1, r273_2 #-----| Goto -> Block 2 # 272| Block 1 -# 272| v1_0(void) = ReturnVoid : -# 272| v1_1(void) = UnmodeledUse : mu* -# 272| v1_2(void) = AliasedUse : ~mu0_2 -# 272| v1_3(void) = ExitFunction : +# 272| v272_4(void) = ReturnVoid : +# 272| v272_5(void) = UnmodeledUse : mu* +# 272| v272_6(void) = AliasedUse : ~mu272_3 +# 272| v272_7(void) = ExitFunction : # 274| Block 2 -# 274| v2_0(void) = NoOp : +# 274| v274_1(void) = NoOp : #-----| Goto (back edge) -> Block 2 # 278| void For_Condition() # 278| Block 0 -# 278| v0_0(void) = EnterFunction : -# 278| mu0_1(unknown) = AliasedDefinition : -# 278| mu0_2(unknown) = UnmodeledDefinition : -# 279| r0_3(glval) = VariableAddress[i] : -# 279| r0_4(int) = Constant[0] : -# 279| mu0_5(int) = Store : &:r0_3, r0_4 +# 278| v278_1(void) = EnterFunction : +# 278| mu278_2(unknown) = AliasedDefinition : +# 278| mu278_3(unknown) = UnmodeledDefinition : +# 279| r279_1(glval) = VariableAddress[i] : +# 279| r279_2(int) = Constant[0] : +# 279| mu279_3(int) = Store : &:r279_1, r279_2 #-----| Goto -> Block 1 # 280| Block 1 -# 280| r1_0(glval) = VariableAddress[i] : -# 280| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 280| r1_2(int) = Constant[10] : -# 280| r1_3(bool) = CompareLT : r1_1, r1_2 -# 280| v1_4(void) = ConditionalBranch : r1_3 +# 280| r280_1(glval) = VariableAddress[i] : +# 280| r280_2(int) = Load : &:r280_1, ~mu278_3 +# 280| r280_3(int) = Constant[10] : +# 280| r280_4(bool) = CompareLT : r280_2, r280_3 +# 280| v280_5(void) = ConditionalBranch : r280_4 #-----| False -> Block 3 #-----| True -> Block 2 # 281| Block 2 -# 281| v2_0(void) = NoOp : +# 281| v281_1(void) = NoOp : #-----| Goto (back edge) -> Block 1 # 283| Block 3 -# 283| v3_0(void) = NoOp : -# 278| v3_1(void) = ReturnVoid : -# 278| v3_2(void) = UnmodeledUse : mu* -# 278| v3_3(void) = AliasedUse : ~mu0_2 -# 278| v3_4(void) = ExitFunction : +# 283| v283_1(void) = NoOp : +# 278| v278_4(void) = ReturnVoid : +# 278| v278_5(void) = UnmodeledUse : mu* +# 278| v278_6(void) = AliasedUse : ~mu278_3 +# 278| v278_7(void) = ExitFunction : # 285| void For_Update() # 285| Block 0 -# 285| v0_0(void) = EnterFunction : -# 285| mu0_1(unknown) = AliasedDefinition : -# 285| mu0_2(unknown) = UnmodeledDefinition : -# 286| r0_3(glval) = VariableAddress[i] : -# 286| r0_4(int) = Constant[0] : -# 286| mu0_5(int) = Store : &:r0_3, r0_4 +# 285| v285_1(void) = EnterFunction : +# 285| mu285_2(unknown) = AliasedDefinition : +# 285| mu285_3(unknown) = UnmodeledDefinition : +# 286| r286_1(glval) = VariableAddress[i] : +# 286| r286_2(int) = Constant[0] : +# 286| mu286_3(int) = Store : &:r286_1, r286_2 #-----| Goto -> Block 2 # 285| Block 1 -# 285| v1_0(void) = ReturnVoid : -# 285| v1_1(void) = UnmodeledUse : mu* -# 285| v1_2(void) = AliasedUse : ~mu0_2 -# 285| v1_3(void) = ExitFunction : +# 285| v285_4(void) = ReturnVoid : +# 285| v285_5(void) = UnmodeledUse : mu* +# 285| v285_6(void) = AliasedUse : ~mu285_3 +# 285| v285_7(void) = ExitFunction : # 288| Block 2 -# 288| v2_0(void) = NoOp : -# 287| r2_1(int) = Constant[1] : -# 287| r2_2(glval) = VariableAddress[i] : -# 287| r2_3(int) = Load : &:r2_2, ~mu0_2 -# 287| r2_4(int) = Add : r2_3, r2_1 -# 287| mu2_5(int) = Store : &:r2_2, r2_4 +# 288| v288_1(void) = NoOp : +# 287| r287_1(int) = Constant[1] : +# 287| r287_2(glval) = VariableAddress[i] : +# 287| r287_3(int) = Load : &:r287_2, ~mu285_3 +# 287| r287_4(int) = Add : r287_3, r287_1 +# 287| mu287_5(int) = Store : &:r287_2, r287_4 #-----| Goto (back edge) -> Block 2 # 292| void For_InitCondition() # 292| Block 0 -# 292| v0_0(void) = EnterFunction : -# 292| mu0_1(unknown) = AliasedDefinition : -# 292| mu0_2(unknown) = UnmodeledDefinition : -# 293| r0_3(glval) = VariableAddress[i] : -# 293| r0_4(int) = Constant[0] : -# 293| mu0_5(int) = Store : &:r0_3, r0_4 +# 292| v292_1(void) = EnterFunction : +# 292| mu292_2(unknown) = AliasedDefinition : +# 292| mu292_3(unknown) = UnmodeledDefinition : +# 293| r293_1(glval) = VariableAddress[i] : +# 293| r293_2(int) = Constant[0] : +# 293| mu293_3(int) = Store : &:r293_1, r293_2 #-----| Goto -> Block 1 # 293| Block 1 -# 293| r1_0(glval) = VariableAddress[i] : -# 293| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 293| r1_2(int) = Constant[10] : -# 293| r1_3(bool) = CompareLT : r1_1, r1_2 -# 293| v1_4(void) = ConditionalBranch : r1_3 +# 293| r293_4(glval) = VariableAddress[i] : +# 293| r293_5(int) = Load : &:r293_4, ~mu292_3 +# 293| r293_6(int) = Constant[10] : +# 293| r293_7(bool) = CompareLT : r293_5, r293_6 +# 293| v293_8(void) = ConditionalBranch : r293_7 #-----| False -> Block 3 #-----| True -> Block 2 # 294| Block 2 -# 294| v2_0(void) = NoOp : +# 294| v294_1(void) = NoOp : #-----| Goto (back edge) -> Block 1 # 296| Block 3 -# 296| v3_0(void) = NoOp : -# 292| v3_1(void) = ReturnVoid : -# 292| v3_2(void) = UnmodeledUse : mu* -# 292| v3_3(void) = AliasedUse : ~mu0_2 -# 292| v3_4(void) = ExitFunction : +# 296| v296_1(void) = NoOp : +# 292| v292_4(void) = ReturnVoid : +# 292| v292_5(void) = UnmodeledUse : mu* +# 292| v292_6(void) = AliasedUse : ~mu292_3 +# 292| v292_7(void) = ExitFunction : # 298| void For_InitUpdate() # 298| Block 0 -# 298| v0_0(void) = EnterFunction : -# 298| mu0_1(unknown) = AliasedDefinition : -# 298| mu0_2(unknown) = UnmodeledDefinition : -# 299| r0_3(glval) = VariableAddress[i] : -# 299| r0_4(int) = Constant[0] : -# 299| mu0_5(int) = Store : &:r0_3, r0_4 +# 298| v298_1(void) = EnterFunction : +# 298| mu298_2(unknown) = AliasedDefinition : +# 298| mu298_3(unknown) = UnmodeledDefinition : +# 299| r299_1(glval) = VariableAddress[i] : +# 299| r299_2(int) = Constant[0] : +# 299| mu299_3(int) = Store : &:r299_1, r299_2 #-----| Goto -> Block 2 # 298| Block 1 -# 298| v1_0(void) = ReturnVoid : -# 298| v1_1(void) = UnmodeledUse : mu* -# 298| v1_2(void) = AliasedUse : ~mu0_2 -# 298| v1_3(void) = ExitFunction : +# 298| v298_4(void) = ReturnVoid : +# 298| v298_5(void) = UnmodeledUse : mu* +# 298| v298_6(void) = AliasedUse : ~mu298_3 +# 298| v298_7(void) = ExitFunction : # 300| Block 2 -# 300| v2_0(void) = NoOp : -# 299| r2_1(int) = Constant[1] : -# 299| r2_2(glval) = VariableAddress[i] : -# 299| r2_3(int) = Load : &:r2_2, ~mu0_2 -# 299| r2_4(int) = Add : r2_3, r2_1 -# 299| mu2_5(int) = Store : &:r2_2, r2_4 +# 300| v300_1(void) = NoOp : +# 299| r299_4(int) = Constant[1] : +# 299| r299_5(glval) = VariableAddress[i] : +# 299| r299_6(int) = Load : &:r299_5, ~mu298_3 +# 299| r299_7(int) = Add : r299_6, r299_4 +# 299| mu299_8(int) = Store : &:r299_5, r299_7 #-----| Goto (back edge) -> Block 2 # 304| void For_ConditionUpdate() # 304| Block 0 -# 304| v0_0(void) = EnterFunction : -# 304| mu0_1(unknown) = AliasedDefinition : -# 304| mu0_2(unknown) = UnmodeledDefinition : -# 305| r0_3(glval) = VariableAddress[i] : -# 305| r0_4(int) = Constant[0] : -# 305| mu0_5(int) = Store : &:r0_3, r0_4 +# 304| v304_1(void) = EnterFunction : +# 304| mu304_2(unknown) = AliasedDefinition : +# 304| mu304_3(unknown) = UnmodeledDefinition : +# 305| r305_1(glval) = VariableAddress[i] : +# 305| r305_2(int) = Constant[0] : +# 305| mu305_3(int) = Store : &:r305_1, r305_2 #-----| Goto -> Block 1 # 306| Block 1 -# 306| r1_0(glval) = VariableAddress[i] : -# 306| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 306| r1_2(int) = Constant[10] : -# 306| r1_3(bool) = CompareLT : r1_1, r1_2 -# 306| v1_4(void) = ConditionalBranch : r1_3 +# 306| r306_1(glval) = VariableAddress[i] : +# 306| r306_2(int) = Load : &:r306_1, ~mu304_3 +# 306| r306_3(int) = Constant[10] : +# 306| r306_4(bool) = CompareLT : r306_2, r306_3 +# 306| v306_5(void) = ConditionalBranch : r306_4 #-----| False -> Block 3 #-----| True -> Block 2 # 307| Block 2 -# 307| v2_0(void) = NoOp : -# 306| r2_1(int) = Constant[1] : -# 306| r2_2(glval) = VariableAddress[i] : -# 306| r2_3(int) = Load : &:r2_2, ~mu0_2 -# 306| r2_4(int) = Add : r2_3, r2_1 -# 306| mu2_5(int) = Store : &:r2_2, r2_4 +# 307| v307_1(void) = NoOp : +# 306| r306_6(int) = Constant[1] : +# 306| r306_7(glval) = VariableAddress[i] : +# 306| r306_8(int) = Load : &:r306_7, ~mu304_3 +# 306| r306_9(int) = Add : r306_8, r306_6 +# 306| mu306_10(int) = Store : &:r306_7, r306_9 #-----| Goto (back edge) -> Block 1 # 309| Block 3 -# 309| v3_0(void) = NoOp : -# 304| v3_1(void) = ReturnVoid : -# 304| v3_2(void) = UnmodeledUse : mu* -# 304| v3_3(void) = AliasedUse : ~mu0_2 -# 304| v3_4(void) = ExitFunction : +# 309| v309_1(void) = NoOp : +# 304| v304_4(void) = ReturnVoid : +# 304| v304_5(void) = UnmodeledUse : mu* +# 304| v304_6(void) = AliasedUse : ~mu304_3 +# 304| v304_7(void) = ExitFunction : # 311| void For_InitConditionUpdate() # 311| Block 0 -# 311| v0_0(void) = EnterFunction : -# 311| mu0_1(unknown) = AliasedDefinition : -# 311| mu0_2(unknown) = UnmodeledDefinition : -# 312| r0_3(glval) = VariableAddress[i] : -# 312| r0_4(int) = Constant[0] : -# 312| mu0_5(int) = Store : &:r0_3, r0_4 +# 311| v311_1(void) = EnterFunction : +# 311| mu311_2(unknown) = AliasedDefinition : +# 311| mu311_3(unknown) = UnmodeledDefinition : +# 312| r312_1(glval) = VariableAddress[i] : +# 312| r312_2(int) = Constant[0] : +# 312| mu312_3(int) = Store : &:r312_1, r312_2 #-----| Goto -> Block 1 # 312| Block 1 -# 312| r1_0(glval) = VariableAddress[i] : -# 312| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 312| r1_2(int) = Constant[10] : -# 312| r1_3(bool) = CompareLT : r1_1, r1_2 -# 312| v1_4(void) = ConditionalBranch : r1_3 +# 312| r312_4(glval) = VariableAddress[i] : +# 312| r312_5(int) = Load : &:r312_4, ~mu311_3 +# 312| r312_6(int) = Constant[10] : +# 312| r312_7(bool) = CompareLT : r312_5, r312_6 +# 312| v312_8(void) = ConditionalBranch : r312_7 #-----| False -> Block 3 #-----| True -> Block 2 # 313| Block 2 -# 313| v2_0(void) = NoOp : -# 312| r2_1(int) = Constant[1] : -# 312| r2_2(glval) = VariableAddress[i] : -# 312| r2_3(int) = Load : &:r2_2, ~mu0_2 -# 312| r2_4(int) = Add : r2_3, r2_1 -# 312| mu2_5(int) = Store : &:r2_2, r2_4 +# 313| v313_1(void) = NoOp : +# 312| r312_9(int) = Constant[1] : +# 312| r312_10(glval) = VariableAddress[i] : +# 312| r312_11(int) = Load : &:r312_10, ~mu311_3 +# 312| r312_12(int) = Add : r312_11, r312_9 +# 312| mu312_13(int) = Store : &:r312_10, r312_12 #-----| Goto (back edge) -> Block 1 # 315| Block 3 -# 315| v3_0(void) = NoOp : -# 311| v3_1(void) = ReturnVoid : -# 311| v3_2(void) = UnmodeledUse : mu* -# 311| v3_3(void) = AliasedUse : ~mu0_2 -# 311| v3_4(void) = ExitFunction : +# 315| v315_1(void) = NoOp : +# 311| v311_4(void) = ReturnVoid : +# 311| v311_5(void) = UnmodeledUse : mu* +# 311| v311_6(void) = AliasedUse : ~mu311_3 +# 311| v311_7(void) = ExitFunction : # 317| void For_Break() # 317| Block 0 -# 317| v0_0(void) = EnterFunction : -# 317| mu0_1(unknown) = AliasedDefinition : -# 317| mu0_2(unknown) = UnmodeledDefinition : -# 318| r0_3(glval) = VariableAddress[i] : -# 318| r0_4(int) = Constant[0] : -# 318| mu0_5(int) = Store : &:r0_3, r0_4 +# 317| v317_1(void) = EnterFunction : +# 317| mu317_2(unknown) = AliasedDefinition : +# 317| mu317_3(unknown) = UnmodeledDefinition : +# 318| r318_1(glval) = VariableAddress[i] : +# 318| r318_2(int) = Constant[0] : +# 318| mu318_3(int) = Store : &:r318_1, r318_2 #-----| Goto -> Block 1 # 318| Block 1 -# 318| r1_0(glval) = VariableAddress[i] : -# 318| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 318| r1_2(int) = Constant[10] : -# 318| r1_3(bool) = CompareLT : r1_1, r1_2 -# 318| v1_4(void) = ConditionalBranch : r1_3 +# 318| r318_4(glval) = VariableAddress[i] : +# 318| r318_5(int) = Load : &:r318_4, ~mu317_3 +# 318| r318_6(int) = Constant[10] : +# 318| r318_7(bool) = CompareLT : r318_5, r318_6 +# 318| v318_8(void) = ConditionalBranch : r318_7 #-----| False -> Block 5 #-----| True -> Block 3 # 318| Block 2 -# 318| r2_0(int) = Constant[1] : -# 318| r2_1(glval) = VariableAddress[i] : -# 318| r2_2(int) = Load : &:r2_1, ~mu0_2 -# 318| r2_3(int) = Add : r2_2, r2_0 -# 318| mu2_4(int) = Store : &:r2_1, r2_3 +# 318| r318_9(int) = Constant[1] : +# 318| r318_10(glval) = VariableAddress[i] : +# 318| r318_11(int) = Load : &:r318_10, ~mu317_3 +# 318| r318_12(int) = Add : r318_11, r318_9 +# 318| mu318_13(int) = Store : &:r318_10, r318_12 #-----| Goto (back edge) -> Block 1 # 319| Block 3 -# 319| r3_0(glval) = VariableAddress[i] : -# 319| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 319| r3_2(int) = Constant[5] : -# 319| r3_3(bool) = CompareEQ : r3_1, r3_2 -# 319| v3_4(void) = ConditionalBranch : r3_3 +# 319| r319_1(glval) = VariableAddress[i] : +# 319| r319_2(int) = Load : &:r319_1, ~mu317_3 +# 319| r319_3(int) = Constant[5] : +# 319| r319_4(bool) = CompareEQ : r319_2, r319_3 +# 319| v319_5(void) = ConditionalBranch : r319_4 #-----| False -> Block 2 #-----| True -> Block 4 # 320| Block 4 -# 320| v4_0(void) = NoOp : +# 320| v320_1(void) = NoOp : #-----| Goto -> Block 5 # 322| Block 5 -# 322| v5_0(void) = NoOp : -# 323| v5_1(void) = NoOp : -# 317| v5_2(void) = ReturnVoid : -# 317| v5_3(void) = UnmodeledUse : mu* -# 317| v5_4(void) = AliasedUse : ~mu0_2 -# 317| v5_5(void) = ExitFunction : +# 322| v322_1(void) = NoOp : +# 323| v323_1(void) = NoOp : +# 317| v317_4(void) = ReturnVoid : +# 317| v317_5(void) = UnmodeledUse : mu* +# 317| v317_6(void) = AliasedUse : ~mu317_3 +# 317| v317_7(void) = ExitFunction : # 325| void For_Continue_Update() # 325| Block 0 -# 325| v0_0(void) = EnterFunction : -# 325| mu0_1(unknown) = AliasedDefinition : -# 325| mu0_2(unknown) = UnmodeledDefinition : -# 326| r0_3(glval) = VariableAddress[i] : -# 326| r0_4(int) = Constant[0] : -# 326| mu0_5(int) = Store : &:r0_3, r0_4 +# 325| v325_1(void) = EnterFunction : +# 325| mu325_2(unknown) = AliasedDefinition : +# 325| mu325_3(unknown) = UnmodeledDefinition : +# 326| r326_1(glval) = VariableAddress[i] : +# 326| r326_2(int) = Constant[0] : +# 326| mu326_3(int) = Store : &:r326_1, r326_2 #-----| Goto -> Block 1 # 326| Block 1 -# 326| r1_0(glval) = VariableAddress[i] : -# 326| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 326| r1_2(int) = Constant[10] : -# 326| r1_3(bool) = CompareLT : r1_1, r1_2 -# 326| v1_4(void) = ConditionalBranch : r1_3 +# 326| r326_4(glval) = VariableAddress[i] : +# 326| r326_5(int) = Load : &:r326_4, ~mu325_3 +# 326| r326_6(int) = Constant[10] : +# 326| r326_7(bool) = CompareLT : r326_5, r326_6 +# 326| v326_8(void) = ConditionalBranch : r326_7 #-----| False -> Block 5 #-----| True -> Block 2 # 327| Block 2 -# 327| r2_0(glval) = VariableAddress[i] : -# 327| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 327| r2_2(int) = Constant[5] : -# 327| r2_3(bool) = CompareEQ : r2_1, r2_2 -# 327| v2_4(void) = ConditionalBranch : r2_3 +# 327| r327_1(glval) = VariableAddress[i] : +# 327| r327_2(int) = Load : &:r327_1, ~mu325_3 +# 327| r327_3(int) = Constant[5] : +# 327| r327_4(bool) = CompareEQ : r327_2, r327_3 +# 327| v327_5(void) = ConditionalBranch : r327_4 #-----| False -> Block 4 #-----| True -> Block 3 # 328| Block 3 -# 328| v3_0(void) = NoOp : +# 328| v328_1(void) = NoOp : #-----| Goto -> Block 4 # 326| Block 4 -# 326| v4_0(void) = NoOp : -# 326| r4_1(int) = Constant[1] : -# 326| r4_2(glval) = VariableAddress[i] : -# 326| r4_3(int) = Load : &:r4_2, ~mu0_2 -# 326| r4_4(int) = Add : r4_3, r4_1 -# 326| mu4_5(int) = Store : &:r4_2, r4_4 +# 326| v326_9(void) = NoOp : +# 326| r326_10(int) = Constant[1] : +# 326| r326_11(glval) = VariableAddress[i] : +# 326| r326_12(int) = Load : &:r326_11, ~mu325_3 +# 326| r326_13(int) = Add : r326_12, r326_10 +# 326| mu326_14(int) = Store : &:r326_11, r326_13 #-----| Goto (back edge) -> Block 1 # 331| Block 5 -# 331| v5_0(void) = NoOp : -# 325| v5_1(void) = ReturnVoid : -# 325| v5_2(void) = UnmodeledUse : mu* -# 325| v5_3(void) = AliasedUse : ~mu0_2 -# 325| v5_4(void) = ExitFunction : +# 331| v331_1(void) = NoOp : +# 325| v325_4(void) = ReturnVoid : +# 325| v325_5(void) = UnmodeledUse : mu* +# 325| v325_6(void) = AliasedUse : ~mu325_3 +# 325| v325_7(void) = ExitFunction : # 333| void For_Continue_NoUpdate() # 333| Block 0 -# 333| v0_0(void) = EnterFunction : -# 333| mu0_1(unknown) = AliasedDefinition : -# 333| mu0_2(unknown) = UnmodeledDefinition : -# 334| r0_3(glval) = VariableAddress[i] : -# 334| r0_4(int) = Constant[0] : -# 334| mu0_5(int) = Store : &:r0_3, r0_4 +# 333| v333_1(void) = EnterFunction : +# 333| mu333_2(unknown) = AliasedDefinition : +# 333| mu333_3(unknown) = UnmodeledDefinition : +# 334| r334_1(glval) = VariableAddress[i] : +# 334| r334_2(int) = Constant[0] : +# 334| mu334_3(int) = Store : &:r334_1, r334_2 #-----| Goto -> Block 1 # 334| Block 1 -# 334| r1_0(glval) = VariableAddress[i] : -# 334| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 334| r1_2(int) = Constant[10] : -# 334| r1_3(bool) = CompareLT : r1_1, r1_2 -# 334| v1_4(void) = ConditionalBranch : r1_3 +# 334| r334_4(glval) = VariableAddress[i] : +# 334| r334_5(int) = Load : &:r334_4, ~mu333_3 +# 334| r334_6(int) = Constant[10] : +# 334| r334_7(bool) = CompareLT : r334_5, r334_6 +# 334| v334_8(void) = ConditionalBranch : r334_7 #-----| False -> Block 5 #-----| True -> Block 2 # 335| Block 2 -# 335| r2_0(glval) = VariableAddress[i] : -# 335| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 335| r2_2(int) = Constant[5] : -# 335| r2_3(bool) = CompareEQ : r2_1, r2_2 -# 335| v2_4(void) = ConditionalBranch : r2_3 +# 335| r335_1(glval) = VariableAddress[i] : +# 335| r335_2(int) = Load : &:r335_1, ~mu333_3 +# 335| r335_3(int) = Constant[5] : +# 335| r335_4(bool) = CompareEQ : r335_2, r335_3 +# 335| v335_5(void) = ConditionalBranch : r335_4 #-----| False -> Block 4 #-----| True -> Block 3 # 336| Block 3 -# 336| v3_0(void) = NoOp : +# 336| v336_1(void) = NoOp : #-----| Goto -> Block 4 # 334| Block 4 -# 334| v4_0(void) = NoOp : +# 334| v334_9(void) = NoOp : #-----| Goto (back edge) -> Block 1 # 339| Block 5 -# 339| v5_0(void) = NoOp : -# 333| v5_1(void) = ReturnVoid : -# 333| v5_2(void) = UnmodeledUse : mu* -# 333| v5_3(void) = AliasedUse : ~mu0_2 -# 333| v5_4(void) = ExitFunction : +# 339| v339_1(void) = NoOp : +# 333| v333_4(void) = ReturnVoid : +# 333| v333_5(void) = UnmodeledUse : mu* +# 333| v333_6(void) = AliasedUse : ~mu333_3 +# 333| v333_7(void) = ExitFunction : # 341| int Dereference(int*) # 341| Block 0 -# 341| v0_0(void) = EnterFunction : -# 341| mu0_1(unknown) = AliasedDefinition : -# 341| mu0_2(unknown) = UnmodeledDefinition : -# 341| r0_3(glval) = VariableAddress[p] : -# 341| mu0_4(int *) = InitializeParameter[p] : &:r0_3 -# 342| r0_5(int) = Constant[1] : -# 342| r0_6(glval) = VariableAddress[p] : -# 342| r0_7(int *) = Load : &:r0_6, ~mu0_2 -# 342| r0_8(glval) = CopyValue : r0_7 -# 342| mu0_9(int) = Store : &:r0_8, r0_5 -# 343| r0_10(glval) = VariableAddress[#return] : -# 343| r0_11(glval) = VariableAddress[p] : -# 343| r0_12(int *) = Load : &:r0_11, ~mu0_2 -# 343| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 343| mu0_14(int) = Store : &:r0_10, r0_13 -# 341| r0_15(glval) = VariableAddress[#return] : -# 341| v0_16(void) = ReturnValue : &:r0_15, ~mu0_2 -# 341| v0_17(void) = UnmodeledUse : mu* -# 341| v0_18(void) = AliasedUse : ~mu0_2 -# 341| v0_19(void) = ExitFunction : +# 341| v341_1(void) = EnterFunction : +# 341| mu341_2(unknown) = AliasedDefinition : +# 341| mu341_3(unknown) = UnmodeledDefinition : +# 341| r341_4(glval) = VariableAddress[p] : +# 341| mu341_5(int *) = InitializeParameter[p] : &:r341_4 +# 342| r342_1(int) = Constant[1] : +# 342| r342_2(glval) = VariableAddress[p] : +# 342| r342_3(int *) = Load : &:r342_2, ~mu341_3 +# 342| r342_4(glval) = CopyValue : r342_3 +# 342| mu342_5(int) = Store : &:r342_4, r342_1 +# 343| r343_1(glval) = VariableAddress[#return] : +# 343| r343_2(glval) = VariableAddress[p] : +# 343| r343_3(int *) = Load : &:r343_2, ~mu341_3 +# 343| r343_4(int) = Load : &:r343_3, ~mu341_3 +# 343| mu343_5(int) = Store : &:r343_1, r343_4 +# 341| r341_6(glval) = VariableAddress[#return] : +# 341| v341_7(void) = ReturnValue : &:r341_6, ~mu341_3 +# 341| v341_8(void) = UnmodeledUse : mu* +# 341| v341_9(void) = AliasedUse : ~mu341_3 +# 341| v341_10(void) = ExitFunction : # 348| int* AddressOf() # 348| Block 0 -# 348| v0_0(void) = EnterFunction : -# 348| mu0_1(unknown) = AliasedDefinition : -# 348| mu0_2(unknown) = UnmodeledDefinition : -# 349| r0_3(glval) = VariableAddress[#return] : -# 349| r0_4(glval) = VariableAddress[g] : -# 349| r0_5(int *) = CopyValue : r0_4 -# 349| mu0_6(int *) = Store : &:r0_3, r0_5 -# 348| r0_7(glval) = VariableAddress[#return] : -# 348| v0_8(void) = ReturnValue : &:r0_7, ~mu0_2 -# 348| v0_9(void) = UnmodeledUse : mu* -# 348| v0_10(void) = AliasedUse : ~mu0_2 -# 348| v0_11(void) = ExitFunction : +# 348| v348_1(void) = EnterFunction : +# 348| mu348_2(unknown) = AliasedDefinition : +# 348| mu348_3(unknown) = UnmodeledDefinition : +# 349| r349_1(glval) = VariableAddress[#return] : +# 349| r349_2(glval) = VariableAddress[g] : +# 349| r349_3(int *) = CopyValue : r349_2 +# 349| mu349_4(int *) = Store : &:r349_1, r349_3 +# 348| r348_4(glval) = VariableAddress[#return] : +# 348| v348_5(void) = ReturnValue : &:r348_4, ~mu348_3 +# 348| v348_6(void) = UnmodeledUse : mu* +# 348| v348_7(void) = AliasedUse : ~mu348_3 +# 348| v348_8(void) = ExitFunction : # 352| void Break(int) # 352| Block 0 -# 352| v0_0(void) = EnterFunction : -# 352| mu0_1(unknown) = AliasedDefinition : -# 352| mu0_2(unknown) = UnmodeledDefinition : -# 352| r0_3(glval) = VariableAddress[n] : -# 352| mu0_4(int) = InitializeParameter[n] : &:r0_3 +# 352| v352_1(void) = EnterFunction : +# 352| mu352_2(unknown) = AliasedDefinition : +# 352| mu352_3(unknown) = UnmodeledDefinition : +# 352| r352_4(glval) = VariableAddress[n] : +# 352| mu352_5(int) = InitializeParameter[n] : &:r352_4 #-----| Goto -> Block 5 # 354| Block 1 -# 354| r1_0(glval) = VariableAddress[n] : -# 354| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 354| r1_2(int) = Constant[1] : -# 354| r1_3(bool) = CompareEQ : r1_1, r1_2 -# 354| v1_4(void) = ConditionalBranch : r1_3 +# 354| r354_1(glval) = VariableAddress[n] : +# 354| r354_2(int) = Load : &:r354_1, ~mu352_3 +# 354| r354_3(int) = Constant[1] : +# 354| r354_4(bool) = CompareEQ : r354_2, r354_3 +# 354| v354_5(void) = ConditionalBranch : r354_4 #-----| False -> Block 3 #-----| True -> Block 2 # 355| Block 2 -# 355| v2_0(void) = NoOp : +# 355| v355_1(void) = NoOp : #-----| Goto -> Block 4 # 356| Block 3 -# 356| r3_0(int) = Constant[1] : -# 356| r3_1(glval) = VariableAddress[n] : -# 356| r3_2(int) = Load : &:r3_1, ~mu0_2 -# 356| r3_3(int) = Sub : r3_2, r3_0 -# 356| mu3_4(int) = Store : &:r3_1, r3_3 +# 356| r356_1(int) = Constant[1] : +# 356| r356_2(glval) = VariableAddress[n] : +# 356| r356_3(int) = Load : &:r356_2, ~mu352_3 +# 356| r356_4(int) = Sub : r356_3, r356_1 +# 356| mu356_5(int) = Store : &:r356_2, r356_4 #-----| Goto (back edge) -> Block 5 # 357| Block 4 -# 357| v4_0(void) = NoOp : -# 358| v4_1(void) = NoOp : -# 352| v4_2(void) = ReturnVoid : -# 352| v4_3(void) = UnmodeledUse : mu* -# 352| v4_4(void) = AliasedUse : ~mu0_2 -# 352| v4_5(void) = ExitFunction : +# 357| v357_1(void) = NoOp : +# 358| v358_1(void) = NoOp : +# 352| v352_6(void) = ReturnVoid : +# 352| v352_7(void) = UnmodeledUse : mu* +# 352| v352_8(void) = AliasedUse : ~mu352_3 +# 352| v352_9(void) = ExitFunction : # 353| Block 5 -# 353| r5_0(glval) = VariableAddress[n] : -# 353| r5_1(int) = Load : &:r5_0, ~mu0_2 -# 353| r5_2(int) = Constant[0] : -# 353| r5_3(bool) = CompareGT : r5_1, r5_2 -# 353| v5_4(void) = ConditionalBranch : r5_3 +# 353| r353_1(glval) = VariableAddress[n] : +# 353| r353_2(int) = Load : &:r353_1, ~mu352_3 +# 353| r353_3(int) = Constant[0] : +# 353| r353_4(bool) = CompareGT : r353_2, r353_3 +# 353| v353_5(void) = ConditionalBranch : r353_4 #-----| False -> Block 4 #-----| True -> Block 1 # 360| void Continue(int) # 360| Block 0 -# 360| v0_0(void) = EnterFunction : -# 360| mu0_1(unknown) = AliasedDefinition : -# 360| mu0_2(unknown) = UnmodeledDefinition : -# 360| r0_3(glval) = VariableAddress[n] : -# 360| mu0_4(int) = InitializeParameter[n] : &:r0_3 +# 360| v360_1(void) = EnterFunction : +# 360| mu360_2(unknown) = AliasedDefinition : +# 360| mu360_3(unknown) = UnmodeledDefinition : +# 360| r360_4(glval) = VariableAddress[n] : +# 360| mu360_5(int) = InitializeParameter[n] : &:r360_4 #-----| Goto -> Block 1 # 362| Block 1 -# 362| r1_0(glval) = VariableAddress[n] : -# 362| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 362| r1_2(int) = Constant[1] : -# 362| r1_3(bool) = CompareEQ : r1_1, r1_2 -# 362| v1_4(void) = ConditionalBranch : r1_3 +# 362| r362_1(glval) = VariableAddress[n] : +# 362| r362_2(int) = Load : &:r362_1, ~mu360_3 +# 362| r362_3(int) = Constant[1] : +# 362| r362_4(bool) = CompareEQ : r362_2, r362_3 +# 362| v362_5(void) = ConditionalBranch : r362_4 #-----| False -> Block 3 #-----| True -> Block 2 # 363| Block 2 -# 363| v2_0(void) = NoOp : +# 363| v363_1(void) = NoOp : #-----| Goto -> Block 4 # 365| Block 3 -# 365| r3_0(int) = Constant[1] : -# 365| r3_1(glval) = VariableAddress[n] : -# 365| r3_2(int) = Load : &:r3_1, ~mu0_2 -# 365| r3_3(int) = Sub : r3_2, r3_0 -# 365| mu3_4(int) = Store : &:r3_1, r3_3 +# 365| r365_1(int) = Constant[1] : +# 365| r365_2(glval) = VariableAddress[n] : +# 365| r365_3(int) = Load : &:r365_2, ~mu360_3 +# 365| r365_4(int) = Sub : r365_3, r365_1 +# 365| mu365_5(int) = Store : &:r365_2, r365_4 #-----| Goto -> Block 4 # 361| Block 4 -# 361| v4_0(void) = NoOp : -# 366| r4_1(glval) = VariableAddress[n] : -# 366| r4_2(int) = Load : &:r4_1, ~mu0_2 -# 366| r4_3(int) = Constant[0] : -# 366| r4_4(bool) = CompareGT : r4_2, r4_3 -# 366| v4_5(void) = ConditionalBranch : r4_4 +# 361| v361_1(void) = NoOp : +# 366| r366_1(glval) = VariableAddress[n] : +# 366| r366_2(int) = Load : &:r366_1, ~mu360_3 +# 366| r366_3(int) = Constant[0] : +# 366| r366_4(bool) = CompareGT : r366_2, r366_3 +# 366| v366_5(void) = ConditionalBranch : r366_4 #-----| False -> Block 5 #-----| True (back edge) -> Block 1 # 367| Block 5 -# 367| v5_0(void) = NoOp : -# 360| v5_1(void) = ReturnVoid : -# 360| v5_2(void) = UnmodeledUse : mu* -# 360| v5_3(void) = AliasedUse : ~mu0_2 -# 360| v5_4(void) = ExitFunction : +# 367| v367_1(void) = NoOp : +# 360| v360_6(void) = ReturnVoid : +# 360| v360_7(void) = UnmodeledUse : mu* +# 360| v360_8(void) = AliasedUse : ~mu360_3 +# 360| v360_9(void) = ExitFunction : # 372| void Call() # 372| Block 0 -# 372| v0_0(void) = EnterFunction : -# 372| mu0_1(unknown) = AliasedDefinition : -# 372| mu0_2(unknown) = UnmodeledDefinition : -# 373| r0_3(glval) = FunctionAddress[VoidFunc] : -# 373| v0_4(void) = Call : func:r0_3 -# 373| mu0_5(unknown) = ^CallSideEffect : ~mu0_2 -# 374| v0_6(void) = NoOp : -# 372| v0_7(void) = ReturnVoid : -# 372| v0_8(void) = UnmodeledUse : mu* -# 372| v0_9(void) = AliasedUse : ~mu0_2 -# 372| v0_10(void) = ExitFunction : +# 372| v372_1(void) = EnterFunction : +# 372| mu372_2(unknown) = AliasedDefinition : +# 372| mu372_3(unknown) = UnmodeledDefinition : +# 373| r373_1(glval) = FunctionAddress[VoidFunc] : +# 373| v373_2(void) = Call : func:r373_1 +# 373| mu373_3(unknown) = ^CallSideEffect : ~mu372_3 +# 374| v374_1(void) = NoOp : +# 372| v372_4(void) = ReturnVoid : +# 372| v372_5(void) = UnmodeledUse : mu* +# 372| v372_6(void) = AliasedUse : ~mu372_3 +# 372| v372_7(void) = ExitFunction : # 376| int CallAdd(int, int) # 376| Block 0 -# 376| v0_0(void) = EnterFunction : -# 376| mu0_1(unknown) = AliasedDefinition : -# 376| mu0_2(unknown) = UnmodeledDefinition : -# 376| r0_3(glval) = VariableAddress[x] : -# 376| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 376| r0_5(glval) = VariableAddress[y] : -# 376| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 377| r0_7(glval) = VariableAddress[#return] : -# 377| r0_8(glval) = FunctionAddress[Add] : -# 377| r0_9(glval) = VariableAddress[x] : -# 377| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 377| r0_11(glval) = VariableAddress[y] : -# 377| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 377| r0_13(int) = Call : func:r0_8, 0:r0_10, 1:r0_12 -# 377| mu0_14(unknown) = ^CallSideEffect : ~mu0_2 -# 377| mu0_15(int) = Store : &:r0_7, r0_13 -# 376| r0_16(glval) = VariableAddress[#return] : -# 376| v0_17(void) = ReturnValue : &:r0_16, ~mu0_2 -# 376| v0_18(void) = UnmodeledUse : mu* -# 376| v0_19(void) = AliasedUse : ~mu0_2 -# 376| v0_20(void) = ExitFunction : +# 376| v376_1(void) = EnterFunction : +# 376| mu376_2(unknown) = AliasedDefinition : +# 376| mu376_3(unknown) = UnmodeledDefinition : +# 376| r376_4(glval) = VariableAddress[x] : +# 376| mu376_5(int) = InitializeParameter[x] : &:r376_4 +# 376| r376_6(glval) = VariableAddress[y] : +# 376| mu376_7(int) = InitializeParameter[y] : &:r376_6 +# 377| r377_1(glval) = VariableAddress[#return] : +# 377| r377_2(glval) = FunctionAddress[Add] : +# 377| r377_3(glval) = VariableAddress[x] : +# 377| r377_4(int) = Load : &:r377_3, ~mu376_3 +# 377| r377_5(glval) = VariableAddress[y] : +# 377| r377_6(int) = Load : &:r377_5, ~mu376_3 +# 377| r377_7(int) = Call : func:r377_2, 0:r377_4, 1:r377_6 +# 377| mu377_8(unknown) = ^CallSideEffect : ~mu376_3 +# 377| mu377_9(int) = Store : &:r377_1, r377_7 +# 376| r376_8(glval) = VariableAddress[#return] : +# 376| v376_9(void) = ReturnValue : &:r376_8, ~mu376_3 +# 376| v376_10(void) = UnmodeledUse : mu* +# 376| v376_11(void) = AliasedUse : ~mu376_3 +# 376| v376_12(void) = ExitFunction : # 380| int Comma(int, int) # 380| Block 0 -# 380| v0_0(void) = EnterFunction : -# 380| mu0_1(unknown) = AliasedDefinition : -# 380| mu0_2(unknown) = UnmodeledDefinition : -# 380| r0_3(glval) = VariableAddress[x] : -# 380| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 380| r0_5(glval) = VariableAddress[y] : -# 380| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 381| r0_7(glval) = VariableAddress[#return] : -# 381| r0_8(glval) = FunctionAddress[VoidFunc] : -# 381| v0_9(void) = Call : func:r0_8 -# 381| mu0_10(unknown) = ^CallSideEffect : ~mu0_2 -# 381| r0_11(glval) = FunctionAddress[CallAdd] : -# 381| r0_12(glval) = VariableAddress[x] : -# 381| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 381| r0_14(glval) = VariableAddress[y] : -# 381| r0_15(int) = Load : &:r0_14, ~mu0_2 -# 381| r0_16(int) = Call : func:r0_11, 0:r0_13, 1:r0_15 -# 381| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 381| r0_18(int) = CopyValue : r0_16 -# 381| mu0_19(int) = Store : &:r0_7, r0_18 -# 380| r0_20(glval) = VariableAddress[#return] : -# 380| v0_21(void) = ReturnValue : &:r0_20, ~mu0_2 -# 380| v0_22(void) = UnmodeledUse : mu* -# 380| v0_23(void) = AliasedUse : ~mu0_2 -# 380| v0_24(void) = ExitFunction : +# 380| v380_1(void) = EnterFunction : +# 380| mu380_2(unknown) = AliasedDefinition : +# 380| mu380_3(unknown) = UnmodeledDefinition : +# 380| r380_4(glval) = VariableAddress[x] : +# 380| mu380_5(int) = InitializeParameter[x] : &:r380_4 +# 380| r380_6(glval) = VariableAddress[y] : +# 380| mu380_7(int) = InitializeParameter[y] : &:r380_6 +# 381| r381_1(glval) = VariableAddress[#return] : +# 381| r381_2(glval) = FunctionAddress[VoidFunc] : +# 381| v381_3(void) = Call : func:r381_2 +# 381| mu381_4(unknown) = ^CallSideEffect : ~mu380_3 +# 381| r381_5(glval) = FunctionAddress[CallAdd] : +# 381| r381_6(glval) = VariableAddress[x] : +# 381| r381_7(int) = Load : &:r381_6, ~mu380_3 +# 381| r381_8(glval) = VariableAddress[y] : +# 381| r381_9(int) = Load : &:r381_8, ~mu380_3 +# 381| r381_10(int) = Call : func:r381_5, 0:r381_7, 1:r381_9 +# 381| mu381_11(unknown) = ^CallSideEffect : ~mu380_3 +# 381| r381_12(int) = CopyValue : r381_10 +# 381| mu381_13(int) = Store : &:r381_1, r381_12 +# 380| r380_8(glval) = VariableAddress[#return] : +# 380| v380_9(void) = ReturnValue : &:r380_8, ~mu380_3 +# 380| v380_10(void) = UnmodeledUse : mu* +# 380| v380_11(void) = AliasedUse : ~mu380_3 +# 380| v380_12(void) = ExitFunction : # 384| void Switch(int) # 384| Block 0 -# 384| v0_0(void) = EnterFunction : -# 384| mu0_1(unknown) = AliasedDefinition : -# 384| mu0_2(unknown) = UnmodeledDefinition : -# 384| r0_3(glval) = VariableAddress[x] : -# 384| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 385| r0_5(glval) = VariableAddress[y] : -# 385| mu0_6(int) = Uninitialized[y] : &:r0_5 -# 386| r0_7(glval) = VariableAddress[x] : -# 386| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 386| v0_9(void) = Switch : r0_8 +# 384| v384_1(void) = EnterFunction : +# 384| mu384_2(unknown) = AliasedDefinition : +# 384| mu384_3(unknown) = UnmodeledDefinition : +# 384| r384_4(glval) = VariableAddress[x] : +# 384| mu384_5(int) = InitializeParameter[x] : &:r384_4 +# 385| r385_1(glval) = VariableAddress[y] : +# 385| mu385_2(int) = Uninitialized[y] : &:r385_1 +# 386| r386_1(glval) = VariableAddress[x] : +# 386| r386_2(int) = Load : &:r386_1, ~mu384_3 +# 386| v386_3(void) = Switch : r386_2 #-----| Case[-1] -> Block 2 #-----| Case[1] -> Block 3 #-----| Case[2] -> Block 4 @@ -1821,4031 +1821,4031 @@ ir.cpp: #-----| Default -> Block 7 # 387| Block 1 -# 387| r1_0(int) = Constant[1234] : -# 387| r1_1(glval) = VariableAddress[y] : -# 387| mu1_2(int) = Store : &:r1_1, r1_0 +# 387| r387_1(int) = Constant[1234] : +# 387| r387_2(glval) = VariableAddress[y] : +# 387| mu387_3(int) = Store : &:r387_2, r387_1 #-----| Goto -> Block 2 # 389| Block 2 -# 389| v2_0(void) = NoOp : -# 390| r2_1(int) = Constant[-1] : -# 390| r2_2(glval) = VariableAddress[y] : -# 390| mu2_3(int) = Store : &:r2_2, r2_1 -# 391| v2_4(void) = NoOp : +# 389| v389_1(void) = NoOp : +# 390| r390_1(int) = Constant[-1] : +# 390| r390_2(glval) = VariableAddress[y] : +# 390| mu390_3(int) = Store : &:r390_2, r390_1 +# 391| v391_1(void) = NoOp : #-----| Goto -> Block 9 # 393| Block 3 -# 393| v3_0(void) = NoOp : +# 393| v393_1(void) = NoOp : #-----| Goto -> Block 4 # 394| Block 4 -# 394| v4_0(void) = NoOp : -# 395| r4_1(int) = Constant[1] : -# 395| r4_2(glval) = VariableAddress[y] : -# 395| mu4_3(int) = Store : &:r4_2, r4_1 -# 396| v4_4(void) = NoOp : +# 394| v394_1(void) = NoOp : +# 395| r395_1(int) = Constant[1] : +# 395| r395_2(glval) = VariableAddress[y] : +# 395| mu395_3(int) = Store : &:r395_2, r395_1 +# 396| v396_1(void) = NoOp : #-----| Goto -> Block 9 # 398| Block 5 -# 398| v5_0(void) = NoOp : -# 399| r5_1(int) = Constant[3] : -# 399| r5_2(glval) = VariableAddress[y] : -# 399| mu5_3(int) = Store : &:r5_2, r5_1 +# 398| v398_1(void) = NoOp : +# 399| r399_1(int) = Constant[3] : +# 399| r399_2(glval) = VariableAddress[y] : +# 399| mu399_3(int) = Store : &:r399_2, r399_1 #-----| Goto -> Block 6 # 400| Block 6 -# 400| v6_0(void) = NoOp : -# 401| r6_1(int) = Constant[4] : -# 401| r6_2(glval) = VariableAddress[y] : -# 401| mu6_3(int) = Store : &:r6_2, r6_1 -# 402| v6_4(void) = NoOp : +# 400| v400_1(void) = NoOp : +# 401| r401_1(int) = Constant[4] : +# 401| r401_2(glval) = VariableAddress[y] : +# 401| mu401_3(int) = Store : &:r401_2, r401_1 +# 402| v402_1(void) = NoOp : #-----| Goto -> Block 9 # 404| Block 7 -# 404| v7_0(void) = NoOp : -# 405| r7_1(int) = Constant[0] : -# 405| r7_2(glval) = VariableAddress[y] : -# 405| mu7_3(int) = Store : &:r7_2, r7_1 -# 406| v7_4(void) = NoOp : +# 404| v404_1(void) = NoOp : +# 405| r405_1(int) = Constant[0] : +# 405| r405_2(glval) = VariableAddress[y] : +# 405| mu405_3(int) = Store : &:r405_2, r405_1 +# 406| v406_1(void) = NoOp : #-----| Goto -> Block 9 # 408| Block 8 -# 408| r8_0(int) = Constant[5678] : -# 408| r8_1(glval) = VariableAddress[y] : -# 408| mu8_2(int) = Store : &:r8_1, r8_0 +# 408| r408_1(int) = Constant[5678] : +# 408| r408_2(glval) = VariableAddress[y] : +# 408| mu408_3(int) = Store : &:r408_2, r408_1 #-----| Goto -> Block 9 # 409| Block 9 -# 409| v9_0(void) = NoOp : -# 410| v9_1(void) = NoOp : -# 384| v9_2(void) = ReturnVoid : -# 384| v9_3(void) = UnmodeledUse : mu* -# 384| v9_4(void) = AliasedUse : ~mu0_2 -# 384| v9_5(void) = ExitFunction : +# 409| v409_1(void) = NoOp : +# 410| v410_1(void) = NoOp : +# 384| v384_6(void) = ReturnVoid : +# 384| v384_7(void) = UnmodeledUse : mu* +# 384| v384_8(void) = AliasedUse : ~mu384_3 +# 384| v384_9(void) = ExitFunction : # 422| Point ReturnStruct(Point) # 422| Block 0 -# 422| v0_0(void) = EnterFunction : -# 422| mu0_1(unknown) = AliasedDefinition : -# 422| mu0_2(unknown) = UnmodeledDefinition : -# 422| r0_3(glval) = VariableAddress[pt] : -# 422| mu0_4(Point) = InitializeParameter[pt] : &:r0_3 -# 423| r0_5(glval) = VariableAddress[#return] : -# 423| r0_6(glval) = VariableAddress[pt] : -# 423| r0_7(Point) = Load : &:r0_6, ~mu0_2 -# 423| mu0_8(Point) = Store : &:r0_5, r0_7 -# 422| r0_9(glval) = VariableAddress[#return] : -# 422| v0_10(void) = ReturnValue : &:r0_9, ~mu0_2 -# 422| v0_11(void) = UnmodeledUse : mu* -# 422| v0_12(void) = AliasedUse : ~mu0_2 -# 422| v0_13(void) = ExitFunction : +# 422| v422_1(void) = EnterFunction : +# 422| mu422_2(unknown) = AliasedDefinition : +# 422| mu422_3(unknown) = UnmodeledDefinition : +# 422| r422_4(glval) = VariableAddress[pt] : +# 422| mu422_5(Point) = InitializeParameter[pt] : &:r422_4 +# 423| r423_1(glval) = VariableAddress[#return] : +# 423| r423_2(glval) = VariableAddress[pt] : +# 423| r423_3(Point) = Load : &:r423_2, ~mu422_3 +# 423| mu423_4(Point) = Store : &:r423_1, r423_3 +# 422| r422_6(glval) = VariableAddress[#return] : +# 422| v422_7(void) = ReturnValue : &:r422_6, ~mu422_3 +# 422| v422_8(void) = UnmodeledUse : mu* +# 422| v422_9(void) = AliasedUse : ~mu422_3 +# 422| v422_10(void) = ExitFunction : # 426| void FieldAccess() # 426| Block 0 -# 426| v0_0(void) = EnterFunction : -# 426| mu0_1(unknown) = AliasedDefinition : -# 426| mu0_2(unknown) = UnmodeledDefinition : -# 427| r0_3(glval) = VariableAddress[pt] : -# 427| mu0_4(Point) = Uninitialized[pt] : &:r0_3 -# 428| r0_5(int) = Constant[5] : -# 428| r0_6(glval) = VariableAddress[pt] : -# 428| r0_7(glval) = FieldAddress[x] : r0_6 -# 428| mu0_8(int) = Store : &:r0_7, r0_5 -# 429| r0_9(glval) = VariableAddress[pt] : -# 429| r0_10(glval) = FieldAddress[x] : r0_9 -# 429| r0_11(int) = Load : &:r0_10, ~mu0_2 -# 429| r0_12(glval) = VariableAddress[pt] : -# 429| r0_13(glval) = FieldAddress[y] : r0_12 -# 429| mu0_14(int) = Store : &:r0_13, r0_11 -# 430| r0_15(glval) = VariableAddress[p] : -# 430| r0_16(glval) = VariableAddress[pt] : -# 430| r0_17(glval) = FieldAddress[y] : r0_16 -# 430| r0_18(int *) = CopyValue : r0_17 -# 430| mu0_19(int *) = Store : &:r0_15, r0_18 -# 431| v0_20(void) = NoOp : -# 426| v0_21(void) = ReturnVoid : -# 426| v0_22(void) = UnmodeledUse : mu* -# 426| v0_23(void) = AliasedUse : ~mu0_2 -# 426| v0_24(void) = ExitFunction : +# 426| v426_1(void) = EnterFunction : +# 426| mu426_2(unknown) = AliasedDefinition : +# 426| mu426_3(unknown) = UnmodeledDefinition : +# 427| r427_1(glval) = VariableAddress[pt] : +# 427| mu427_2(Point) = Uninitialized[pt] : &:r427_1 +# 428| r428_1(int) = Constant[5] : +# 428| r428_2(glval) = VariableAddress[pt] : +# 428| r428_3(glval) = FieldAddress[x] : r428_2 +# 428| mu428_4(int) = Store : &:r428_3, r428_1 +# 429| r429_1(glval) = VariableAddress[pt] : +# 429| r429_2(glval) = FieldAddress[x] : r429_1 +# 429| r429_3(int) = Load : &:r429_2, ~mu426_3 +# 429| r429_4(glval) = VariableAddress[pt] : +# 429| r429_5(glval) = FieldAddress[y] : r429_4 +# 429| mu429_6(int) = Store : &:r429_5, r429_3 +# 430| r430_1(glval) = VariableAddress[p] : +# 430| r430_2(glval) = VariableAddress[pt] : +# 430| r430_3(glval) = FieldAddress[y] : r430_2 +# 430| r430_4(int *) = CopyValue : r430_3 +# 430| mu430_5(int *) = Store : &:r430_1, r430_4 +# 431| v431_1(void) = NoOp : +# 426| v426_4(void) = ReturnVoid : +# 426| v426_5(void) = UnmodeledUse : mu* +# 426| v426_6(void) = AliasedUse : ~mu426_3 +# 426| v426_7(void) = ExitFunction : # 433| void LogicalOr(bool, bool) # 433| Block 0 -# 433| v0_0(void) = EnterFunction : -# 433| mu0_1(unknown) = AliasedDefinition : -# 433| mu0_2(unknown) = UnmodeledDefinition : -# 433| r0_3(glval) = VariableAddress[a] : -# 433| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 433| r0_5(glval) = VariableAddress[b] : -# 433| mu0_6(bool) = InitializeParameter[b] : &:r0_5 -# 434| r0_7(glval) = VariableAddress[x] : -# 434| mu0_8(int) = Uninitialized[x] : &:r0_7 -# 435| r0_9(glval) = VariableAddress[a] : -# 435| r0_10(bool) = Load : &:r0_9, ~mu0_2 -# 435| v0_11(void) = ConditionalBranch : r0_10 +# 433| v433_1(void) = EnterFunction : +# 433| mu433_2(unknown) = AliasedDefinition : +# 433| mu433_3(unknown) = UnmodeledDefinition : +# 433| r433_4(glval) = VariableAddress[a] : +# 433| mu433_5(bool) = InitializeParameter[a] : &:r433_4 +# 433| r433_6(glval) = VariableAddress[b] : +# 433| mu433_7(bool) = InitializeParameter[b] : &:r433_6 +# 434| r434_1(glval) = VariableAddress[x] : +# 434| mu434_2(int) = Uninitialized[x] : &:r434_1 +# 435| r435_1(glval) = VariableAddress[a] : +# 435| r435_2(bool) = Load : &:r435_1, ~mu433_3 +# 435| v435_3(void) = ConditionalBranch : r435_2 #-----| False -> Block 1 #-----| True -> Block 2 # 435| Block 1 -# 435| r1_0(glval) = VariableAddress[b] : -# 435| r1_1(bool) = Load : &:r1_0, ~mu0_2 -# 435| v1_2(void) = ConditionalBranch : r1_1 +# 435| r435_4(glval) = VariableAddress[b] : +# 435| r435_5(bool) = Load : &:r435_4, ~mu433_3 +# 435| v435_6(void) = ConditionalBranch : r435_5 #-----| False -> Block 3 #-----| True -> Block 2 # 436| Block 2 -# 436| r2_0(int) = Constant[7] : -# 436| r2_1(glval) = VariableAddress[x] : -# 436| mu2_2(int) = Store : &:r2_1, r2_0 +# 436| r436_1(int) = Constant[7] : +# 436| r436_2(glval) = VariableAddress[x] : +# 436| mu436_3(int) = Store : &:r436_2, r436_1 #-----| Goto -> Block 3 # 439| Block 3 -# 439| r3_0(glval) = VariableAddress[a] : -# 439| r3_1(bool) = Load : &:r3_0, ~mu0_2 -# 439| v3_2(void) = ConditionalBranch : r3_1 +# 439| r439_1(glval) = VariableAddress[a] : +# 439| r439_2(bool) = Load : &:r439_1, ~mu433_3 +# 439| v439_3(void) = ConditionalBranch : r439_2 #-----| False -> Block 4 #-----| True -> Block 5 # 439| Block 4 -# 439| r4_0(glval) = VariableAddress[b] : -# 439| r4_1(bool) = Load : &:r4_0, ~mu0_2 -# 439| v4_2(void) = ConditionalBranch : r4_1 +# 439| r439_4(glval) = VariableAddress[b] : +# 439| r439_5(bool) = Load : &:r439_4, ~mu433_3 +# 439| v439_6(void) = ConditionalBranch : r439_5 #-----| False -> Block 6 #-----| True -> Block 5 # 440| Block 5 -# 440| r5_0(int) = Constant[1] : -# 440| r5_1(glval) = VariableAddress[x] : -# 440| mu5_2(int) = Store : &:r5_1, r5_0 +# 440| r440_1(int) = Constant[1] : +# 440| r440_2(glval) = VariableAddress[x] : +# 440| mu440_3(int) = Store : &:r440_2, r440_1 #-----| Goto -> Block 7 # 443| Block 6 -# 443| r6_0(int) = Constant[5] : -# 443| r6_1(glval) = VariableAddress[x] : -# 443| mu6_2(int) = Store : &:r6_1, r6_0 +# 443| r443_1(int) = Constant[5] : +# 443| r443_2(glval) = VariableAddress[x] : +# 443| mu443_3(int) = Store : &:r443_2, r443_1 #-----| Goto -> Block 7 # 445| Block 7 -# 445| v7_0(void) = NoOp : -# 433| v7_1(void) = ReturnVoid : -# 433| v7_2(void) = UnmodeledUse : mu* -# 433| v7_3(void) = AliasedUse : ~mu0_2 -# 433| v7_4(void) = ExitFunction : +# 445| v445_1(void) = NoOp : +# 433| v433_8(void) = ReturnVoid : +# 433| v433_9(void) = UnmodeledUse : mu* +# 433| v433_10(void) = AliasedUse : ~mu433_3 +# 433| v433_11(void) = ExitFunction : # 447| void LogicalAnd(bool, bool) # 447| Block 0 -# 447| v0_0(void) = EnterFunction : -# 447| mu0_1(unknown) = AliasedDefinition : -# 447| mu0_2(unknown) = UnmodeledDefinition : -# 447| r0_3(glval) = VariableAddress[a] : -# 447| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 447| r0_5(glval) = VariableAddress[b] : -# 447| mu0_6(bool) = InitializeParameter[b] : &:r0_5 -# 448| r0_7(glval) = VariableAddress[x] : -# 448| mu0_8(int) = Uninitialized[x] : &:r0_7 -# 449| r0_9(glval) = VariableAddress[a] : -# 449| r0_10(bool) = Load : &:r0_9, ~mu0_2 -# 449| v0_11(void) = ConditionalBranch : r0_10 +# 447| v447_1(void) = EnterFunction : +# 447| mu447_2(unknown) = AliasedDefinition : +# 447| mu447_3(unknown) = UnmodeledDefinition : +# 447| r447_4(glval) = VariableAddress[a] : +# 447| mu447_5(bool) = InitializeParameter[a] : &:r447_4 +# 447| r447_6(glval) = VariableAddress[b] : +# 447| mu447_7(bool) = InitializeParameter[b] : &:r447_6 +# 448| r448_1(glval) = VariableAddress[x] : +# 448| mu448_2(int) = Uninitialized[x] : &:r448_1 +# 449| r449_1(glval) = VariableAddress[a] : +# 449| r449_2(bool) = Load : &:r449_1, ~mu447_3 +# 449| v449_3(void) = ConditionalBranch : r449_2 #-----| False -> Block 3 #-----| True -> Block 1 # 449| Block 1 -# 449| r1_0(glval) = VariableAddress[b] : -# 449| r1_1(bool) = Load : &:r1_0, ~mu0_2 -# 449| v1_2(void) = ConditionalBranch : r1_1 +# 449| r449_4(glval) = VariableAddress[b] : +# 449| r449_5(bool) = Load : &:r449_4, ~mu447_3 +# 449| v449_6(void) = ConditionalBranch : r449_5 #-----| False -> Block 3 #-----| True -> Block 2 # 450| Block 2 -# 450| r2_0(int) = Constant[7] : -# 450| r2_1(glval) = VariableAddress[x] : -# 450| mu2_2(int) = Store : &:r2_1, r2_0 +# 450| r450_1(int) = Constant[7] : +# 450| r450_2(glval) = VariableAddress[x] : +# 450| mu450_3(int) = Store : &:r450_2, r450_1 #-----| Goto -> Block 3 # 453| Block 3 -# 453| r3_0(glval) = VariableAddress[a] : -# 453| r3_1(bool) = Load : &:r3_0, ~mu0_2 -# 453| v3_2(void) = ConditionalBranch : r3_1 +# 453| r453_1(glval) = VariableAddress[a] : +# 453| r453_2(bool) = Load : &:r453_1, ~mu447_3 +# 453| v453_3(void) = ConditionalBranch : r453_2 #-----| False -> Block 6 #-----| True -> Block 4 # 453| Block 4 -# 453| r4_0(glval) = VariableAddress[b] : -# 453| r4_1(bool) = Load : &:r4_0, ~mu0_2 -# 453| v4_2(void) = ConditionalBranch : r4_1 +# 453| r453_4(glval) = VariableAddress[b] : +# 453| r453_5(bool) = Load : &:r453_4, ~mu447_3 +# 453| v453_6(void) = ConditionalBranch : r453_5 #-----| False -> Block 6 #-----| True -> Block 5 # 454| Block 5 -# 454| r5_0(int) = Constant[1] : -# 454| r5_1(glval) = VariableAddress[x] : -# 454| mu5_2(int) = Store : &:r5_1, r5_0 +# 454| r454_1(int) = Constant[1] : +# 454| r454_2(glval) = VariableAddress[x] : +# 454| mu454_3(int) = Store : &:r454_2, r454_1 #-----| Goto -> Block 7 # 457| Block 6 -# 457| r6_0(int) = Constant[5] : -# 457| r6_1(glval) = VariableAddress[x] : -# 457| mu6_2(int) = Store : &:r6_1, r6_0 +# 457| r457_1(int) = Constant[5] : +# 457| r457_2(glval) = VariableAddress[x] : +# 457| mu457_3(int) = Store : &:r457_2, r457_1 #-----| Goto -> Block 7 # 459| Block 7 -# 459| v7_0(void) = NoOp : -# 447| v7_1(void) = ReturnVoid : -# 447| v7_2(void) = UnmodeledUse : mu* -# 447| v7_3(void) = AliasedUse : ~mu0_2 -# 447| v7_4(void) = ExitFunction : +# 459| v459_1(void) = NoOp : +# 447| v447_8(void) = ReturnVoid : +# 447| v447_9(void) = UnmodeledUse : mu* +# 447| v447_10(void) = AliasedUse : ~mu447_3 +# 447| v447_11(void) = ExitFunction : # 461| void LogicalNot(bool, bool) # 461| Block 0 -# 461| v0_0(void) = EnterFunction : -# 461| mu0_1(unknown) = AliasedDefinition : -# 461| mu0_2(unknown) = UnmodeledDefinition : -# 461| r0_3(glval) = VariableAddress[a] : -# 461| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 461| r0_5(glval) = VariableAddress[b] : -# 461| mu0_6(bool) = InitializeParameter[b] : &:r0_5 -# 462| r0_7(glval) = VariableAddress[x] : -# 462| mu0_8(int) = Uninitialized[x] : &:r0_7 -# 463| r0_9(glval) = VariableAddress[a] : -# 463| r0_10(bool) = Load : &:r0_9, ~mu0_2 -# 463| v0_11(void) = ConditionalBranch : r0_10 +# 461| v461_1(void) = EnterFunction : +# 461| mu461_2(unknown) = AliasedDefinition : +# 461| mu461_3(unknown) = UnmodeledDefinition : +# 461| r461_4(glval) = VariableAddress[a] : +# 461| mu461_5(bool) = InitializeParameter[a] : &:r461_4 +# 461| r461_6(glval) = VariableAddress[b] : +# 461| mu461_7(bool) = InitializeParameter[b] : &:r461_6 +# 462| r462_1(glval) = VariableAddress[x] : +# 462| mu462_2(int) = Uninitialized[x] : &:r462_1 +# 463| r463_1(glval) = VariableAddress[a] : +# 463| r463_2(bool) = Load : &:r463_1, ~mu461_3 +# 463| v463_3(void) = ConditionalBranch : r463_2 #-----| False -> Block 1 #-----| True -> Block 2 # 464| Block 1 -# 464| r1_0(int) = Constant[1] : -# 464| r1_1(glval) = VariableAddress[x] : -# 464| mu1_2(int) = Store : &:r1_1, r1_0 +# 464| r464_1(int) = Constant[1] : +# 464| r464_2(glval) = VariableAddress[x] : +# 464| mu464_3(int) = Store : &:r464_2, r464_1 #-----| Goto -> Block 2 # 467| Block 2 -# 467| r2_0(glval) = VariableAddress[a] : -# 467| r2_1(bool) = Load : &:r2_0, ~mu0_2 -# 467| v2_2(void) = ConditionalBranch : r2_1 +# 467| r467_1(glval) = VariableAddress[a] : +# 467| r467_2(bool) = Load : &:r467_1, ~mu461_3 +# 467| v467_3(void) = ConditionalBranch : r467_2 #-----| False -> Block 4 #-----| True -> Block 3 # 467| Block 3 -# 467| r3_0(glval) = VariableAddress[b] : -# 467| r3_1(bool) = Load : &:r3_0, ~mu0_2 -# 467| v3_2(void) = ConditionalBranch : r3_1 +# 467| r467_4(glval) = VariableAddress[b] : +# 467| r467_5(bool) = Load : &:r467_4, ~mu461_3 +# 467| v467_6(void) = ConditionalBranch : r467_5 #-----| False -> Block 4 #-----| True -> Block 5 # 468| Block 4 -# 468| r4_0(int) = Constant[2] : -# 468| r4_1(glval) = VariableAddress[x] : -# 468| mu4_2(int) = Store : &:r4_1, r4_0 +# 468| r468_1(int) = Constant[2] : +# 468| r468_2(glval) = VariableAddress[x] : +# 468| mu468_3(int) = Store : &:r468_2, r468_1 #-----| Goto -> Block 6 # 471| Block 5 -# 471| r5_0(int) = Constant[3] : -# 471| r5_1(glval) = VariableAddress[x] : -# 471| mu5_2(int) = Store : &:r5_1, r5_0 +# 471| r471_1(int) = Constant[3] : +# 471| r471_2(glval) = VariableAddress[x] : +# 471| mu471_3(int) = Store : &:r471_2, r471_1 #-----| Goto -> Block 6 # 473| Block 6 -# 473| v6_0(void) = NoOp : -# 461| v6_1(void) = ReturnVoid : -# 461| v6_2(void) = UnmodeledUse : mu* -# 461| v6_3(void) = AliasedUse : ~mu0_2 -# 461| v6_4(void) = ExitFunction : +# 473| v473_1(void) = NoOp : +# 461| v461_8(void) = ReturnVoid : +# 461| v461_9(void) = UnmodeledUse : mu* +# 461| v461_10(void) = AliasedUse : ~mu461_3 +# 461| v461_11(void) = ExitFunction : # 475| void ConditionValues(bool, bool) # 475| Block 0 -# 475| v0_0(void) = EnterFunction : -# 475| mu0_1(unknown) = AliasedDefinition : -# 475| mu0_2(unknown) = UnmodeledDefinition : -# 475| r0_3(glval) = VariableAddress[a] : -# 475| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 475| r0_5(glval) = VariableAddress[b] : -# 475| mu0_6(bool) = InitializeParameter[b] : &:r0_5 -# 476| r0_7(glval) = VariableAddress[x] : -# 476| mu0_8(bool) = Uninitialized[x] : &:r0_7 -# 477| r0_9(glval) = VariableAddress[a] : -# 477| r0_10(bool) = Load : &:r0_9, ~mu0_2 -# 477| v0_11(void) = ConditionalBranch : r0_10 +# 475| v475_1(void) = EnterFunction : +# 475| mu475_2(unknown) = AliasedDefinition : +# 475| mu475_3(unknown) = UnmodeledDefinition : +# 475| r475_4(glval) = VariableAddress[a] : +# 475| mu475_5(bool) = InitializeParameter[a] : &:r475_4 +# 475| r475_6(glval) = VariableAddress[b] : +# 475| mu475_7(bool) = InitializeParameter[b] : &:r475_6 +# 476| r476_1(glval) = VariableAddress[x] : +# 476| mu476_2(bool) = Uninitialized[x] : &:r476_1 +# 477| r477_1(glval) = VariableAddress[a] : +# 477| r477_2(bool) = Load : &:r477_1, ~mu475_3 +# 477| v477_3(void) = ConditionalBranch : r477_2 #-----| False -> Block 10 #-----| True -> Block 1 # 477| Block 1 -# 477| r1_0(glval) = VariableAddress[b] : -# 477| r1_1(bool) = Load : &:r1_0, ~mu0_2 -# 477| v1_2(void) = ConditionalBranch : r1_1 +# 477| r477_4(glval) = VariableAddress[b] : +# 477| r477_5(bool) = Load : &:r477_4, ~mu475_3 +# 477| v477_6(void) = ConditionalBranch : r477_5 #-----| False -> Block 10 #-----| True -> Block 12 # 478| Block 2 -# 478| r2_0(glval) = VariableAddress[#temp478:9] : -# 478| r2_1(bool) = Constant[0] : -# 478| mu2_2(bool) = Store : &:r2_0, r2_1 +# 478| r478_1(glval) = VariableAddress[#temp478:9] : +# 478| r478_2(bool) = Constant[0] : +# 478| mu478_3(bool) = Store : &:r478_1, r478_2 #-----| Goto -> Block 3 # 478| Block 3 -# 478| r3_0(glval) = VariableAddress[#temp478:9] : -# 478| r3_1(bool) = Load : &:r3_0, ~mu0_2 -# 478| r3_2(glval) = VariableAddress[x] : -# 478| mu3_3(bool) = Store : &:r3_2, r3_1 -# 479| r3_4(glval) = VariableAddress[a] : -# 479| r3_5(bool) = Load : &:r3_4, ~mu0_2 -# 479| v3_6(void) = ConditionalBranch : r3_5 +# 478| r478_4(glval) = VariableAddress[#temp478:9] : +# 478| r478_5(bool) = Load : &:r478_4, ~mu475_3 +# 478| r478_6(glval) = VariableAddress[x] : +# 478| mu478_7(bool) = Store : &:r478_6, r478_5 +# 479| r479_1(glval) = VariableAddress[a] : +# 479| r479_2(bool) = Load : &:r479_1, ~mu475_3 +# 479| v479_3(void) = ConditionalBranch : r479_2 #-----| False -> Block 9 #-----| True -> Block 8 # 478| Block 4 -# 478| r4_0(glval) = VariableAddress[#temp478:9] : -# 478| r4_1(bool) = Constant[1] : -# 478| mu4_2(bool) = Store : &:r4_0, r4_1 +# 478| r478_8(glval) = VariableAddress[#temp478:9] : +# 478| r478_9(bool) = Constant[1] : +# 478| mu478_10(bool) = Store : &:r478_8, r478_9 #-----| Goto -> Block 3 # 478| Block 5 -# 478| r5_0(glval) = VariableAddress[b] : -# 478| r5_1(bool) = Load : &:r5_0, ~mu0_2 -# 478| v5_2(void) = ConditionalBranch : r5_1 +# 478| r478_11(glval) = VariableAddress[b] : +# 478| r478_12(bool) = Load : &:r478_11, ~mu475_3 +# 478| v478_13(void) = ConditionalBranch : r478_12 #-----| False -> Block 2 #-----| True -> Block 4 # 479| Block 6 -# 479| r6_0(glval) = VariableAddress[#temp479:11] : -# 479| r6_1(bool) = Constant[0] : -# 479| mu6_2(bool) = Store : &:r6_0, r6_1 +# 479| r479_4(glval) = VariableAddress[#temp479:11] : +# 479| r479_5(bool) = Constant[0] : +# 479| mu479_6(bool) = Store : &:r479_4, r479_5 #-----| Goto -> Block 7 # 479| Block 7 -# 479| r7_0(glval) = VariableAddress[#temp479:11] : -# 479| r7_1(bool) = Load : &:r7_0, ~mu0_2 -# 479| r7_2(bool) = LogicalNot : r7_1 -# 479| r7_3(glval) = VariableAddress[x] : -# 479| mu7_4(bool) = Store : &:r7_3, r7_2 -# 480| v7_5(void) = NoOp : -# 475| v7_6(void) = ReturnVoid : -# 475| v7_7(void) = UnmodeledUse : mu* -# 475| v7_8(void) = AliasedUse : ~mu0_2 -# 475| v7_9(void) = ExitFunction : +# 479| r479_7(glval) = VariableAddress[#temp479:11] : +# 479| r479_8(bool) = Load : &:r479_7, ~mu475_3 +# 479| r479_9(bool) = LogicalNot : r479_8 +# 479| r479_10(glval) = VariableAddress[x] : +# 479| mu479_11(bool) = Store : &:r479_10, r479_9 +# 480| v480_1(void) = NoOp : +# 475| v475_8(void) = ReturnVoid : +# 475| v475_9(void) = UnmodeledUse : mu* +# 475| v475_10(void) = AliasedUse : ~mu475_3 +# 475| v475_11(void) = ExitFunction : # 479| Block 8 -# 479| r8_0(glval) = VariableAddress[#temp479:11] : -# 479| r8_1(bool) = Constant[1] : -# 479| mu8_2(bool) = Store : &:r8_0, r8_1 +# 479| r479_12(glval) = VariableAddress[#temp479:11] : +# 479| r479_13(bool) = Constant[1] : +# 479| mu479_14(bool) = Store : &:r479_12, r479_13 #-----| Goto -> Block 7 # 479| Block 9 -# 479| r9_0(glval) = VariableAddress[b] : -# 479| r9_1(bool) = Load : &:r9_0, ~mu0_2 -# 479| v9_2(void) = ConditionalBranch : r9_1 +# 479| r479_15(glval) = VariableAddress[b] : +# 479| r479_16(bool) = Load : &:r479_15, ~mu475_3 +# 479| v479_17(void) = ConditionalBranch : r479_16 #-----| False -> Block 6 #-----| True -> Block 8 # 477| Block 10 -# 477| r10_0(glval) = VariableAddress[#temp477:9] : -# 477| r10_1(bool) = Constant[0] : -# 477| mu10_2(bool) = Store : &:r10_0, r10_1 +# 477| r477_7(glval) = VariableAddress[#temp477:9] : +# 477| r477_8(bool) = Constant[0] : +# 477| mu477_9(bool) = Store : &:r477_7, r477_8 #-----| Goto -> Block 11 # 477| Block 11 -# 477| r11_0(glval) = VariableAddress[#temp477:9] : -# 477| r11_1(bool) = Load : &:r11_0, ~mu0_2 -# 477| r11_2(glval) = VariableAddress[x] : -# 477| mu11_3(bool) = Store : &:r11_2, r11_1 -# 478| r11_4(glval) = VariableAddress[a] : -# 478| r11_5(bool) = Load : &:r11_4, ~mu0_2 -# 478| v11_6(void) = ConditionalBranch : r11_5 +# 477| r477_10(glval) = VariableAddress[#temp477:9] : +# 477| r477_11(bool) = Load : &:r477_10, ~mu475_3 +# 477| r477_12(glval) = VariableAddress[x] : +# 477| mu477_13(bool) = Store : &:r477_12, r477_11 +# 478| r478_14(glval) = VariableAddress[a] : +# 478| r478_15(bool) = Load : &:r478_14, ~mu475_3 +# 478| v478_16(void) = ConditionalBranch : r478_15 #-----| False -> Block 5 #-----| True -> Block 4 # 477| Block 12 -# 477| r12_0(glval) = VariableAddress[#temp477:9] : -# 477| r12_1(bool) = Constant[1] : -# 477| mu12_2(bool) = Store : &:r12_0, r12_1 +# 477| r477_14(glval) = VariableAddress[#temp477:9] : +# 477| r477_15(bool) = Constant[1] : +# 477| mu477_16(bool) = Store : &:r477_14, r477_15 #-----| Goto -> Block 11 # 482| void Conditional(bool, int, int) # 482| Block 0 -# 482| v0_0(void) = EnterFunction : -# 482| mu0_1(unknown) = AliasedDefinition : -# 482| mu0_2(unknown) = UnmodeledDefinition : -# 482| r0_3(glval) = VariableAddress[a] : -# 482| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 482| r0_5(glval) = VariableAddress[x] : -# 482| mu0_6(int) = InitializeParameter[x] : &:r0_5 -# 482| r0_7(glval) = VariableAddress[y] : -# 482| mu0_8(int) = InitializeParameter[y] : &:r0_7 -# 483| r0_9(glval) = VariableAddress[z] : -# 483| r0_10(glval) = VariableAddress[a] : -# 483| r0_11(bool) = Load : &:r0_10, ~mu0_2 -# 483| v0_12(void) = ConditionalBranch : r0_11 +# 482| v482_1(void) = EnterFunction : +# 482| mu482_2(unknown) = AliasedDefinition : +# 482| mu482_3(unknown) = UnmodeledDefinition : +# 482| r482_4(glval) = VariableAddress[a] : +# 482| mu482_5(bool) = InitializeParameter[a] : &:r482_4 +# 482| r482_6(glval) = VariableAddress[x] : +# 482| mu482_7(int) = InitializeParameter[x] : &:r482_6 +# 482| r482_8(glval) = VariableAddress[y] : +# 482| mu482_9(int) = InitializeParameter[y] : &:r482_8 +# 483| r483_1(glval) = VariableAddress[z] : +# 483| r483_2(glval) = VariableAddress[a] : +# 483| r483_3(bool) = Load : &:r483_2, ~mu482_3 +# 483| v483_4(void) = ConditionalBranch : r483_3 #-----| False -> Block 2 #-----| True -> Block 1 # 483| Block 1 -# 483| r1_0(glval) = VariableAddress[x] : -# 483| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 483| r1_2(glval) = VariableAddress[#temp483:13] : -# 483| mu1_3(int) = Store : &:r1_2, r1_1 +# 483| r483_5(glval) = VariableAddress[x] : +# 483| r483_6(int) = Load : &:r483_5, ~mu482_3 +# 483| r483_7(glval) = VariableAddress[#temp483:13] : +# 483| mu483_8(int) = Store : &:r483_7, r483_6 #-----| Goto -> Block 3 # 483| Block 2 -# 483| r2_0(glval) = VariableAddress[y] : -# 483| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 483| r2_2(glval) = VariableAddress[#temp483:13] : -# 483| mu2_3(int) = Store : &:r2_2, r2_1 +# 483| r483_9(glval) = VariableAddress[y] : +# 483| r483_10(int) = Load : &:r483_9, ~mu482_3 +# 483| r483_11(glval) = VariableAddress[#temp483:13] : +# 483| mu483_12(int) = Store : &:r483_11, r483_10 #-----| Goto -> Block 3 # 483| Block 3 -# 483| r3_0(glval) = VariableAddress[#temp483:13] : -# 483| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 483| mu3_2(int) = Store : &:r0_9, r3_1 -# 484| v3_3(void) = NoOp : -# 482| v3_4(void) = ReturnVoid : -# 482| v3_5(void) = UnmodeledUse : mu* -# 482| v3_6(void) = AliasedUse : ~mu0_2 -# 482| v3_7(void) = ExitFunction : +# 483| r483_13(glval) = VariableAddress[#temp483:13] : +# 483| r483_14(int) = Load : &:r483_13, ~mu482_3 +# 483| mu483_15(int) = Store : &:r483_1, r483_14 +# 484| v484_1(void) = NoOp : +# 482| v482_10(void) = ReturnVoid : +# 482| v482_11(void) = UnmodeledUse : mu* +# 482| v482_12(void) = AliasedUse : ~mu482_3 +# 482| v482_13(void) = ExitFunction : # 486| void Conditional_LValue(bool) # 486| Block 0 -# 486| v0_0(void) = EnterFunction : -# 486| mu0_1(unknown) = AliasedDefinition : -# 486| mu0_2(unknown) = UnmodeledDefinition : -# 486| r0_3(glval) = VariableAddress[a] : -# 486| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 487| r0_5(glval) = VariableAddress[x] : -# 487| mu0_6(int) = Uninitialized[x] : &:r0_5 -# 488| r0_7(glval) = VariableAddress[y] : -# 488| mu0_8(int) = Uninitialized[y] : &:r0_7 -# 489| r0_9(int) = Constant[5] : -# 489| r0_10(glval) = VariableAddress[a] : -# 489| r0_11(bool) = Load : &:r0_10, ~mu0_2 -# 489| v0_12(void) = ConditionalBranch : r0_11 +# 486| v486_1(void) = EnterFunction : +# 486| mu486_2(unknown) = AliasedDefinition : +# 486| mu486_3(unknown) = UnmodeledDefinition : +# 486| r486_4(glval) = VariableAddress[a] : +# 486| mu486_5(bool) = InitializeParameter[a] : &:r486_4 +# 487| r487_1(glval) = VariableAddress[x] : +# 487| mu487_2(int) = Uninitialized[x] : &:r487_1 +# 488| r488_1(glval) = VariableAddress[y] : +# 488| mu488_2(int) = Uninitialized[y] : &:r488_1 +# 489| r489_1(int) = Constant[5] : +# 489| r489_2(glval) = VariableAddress[a] : +# 489| r489_3(bool) = Load : &:r489_2, ~mu486_3 +# 489| v489_4(void) = ConditionalBranch : r489_3 #-----| False -> Block 3 #-----| True -> Block 2 # 489| Block 1 -# 489| r1_0(glval) = VariableAddress[#temp489:6] : -# 489| r1_1(glval) = Load : &:r1_0, ~mu0_2 -# 489| mu1_2(int) = Store : &:r1_1, r0_9 -# 490| v1_3(void) = NoOp : -# 486| v1_4(void) = ReturnVoid : -# 486| v1_5(void) = UnmodeledUse : mu* -# 486| v1_6(void) = AliasedUse : ~mu0_2 -# 486| v1_7(void) = ExitFunction : +# 489| r489_5(glval) = VariableAddress[#temp489:6] : +# 489| r489_6(glval) = Load : &:r489_5, ~mu486_3 +# 489| mu489_7(int) = Store : &:r489_6, r489_1 +# 490| v490_1(void) = NoOp : +# 486| v486_6(void) = ReturnVoid : +# 486| v486_7(void) = UnmodeledUse : mu* +# 486| v486_8(void) = AliasedUse : ~mu486_3 +# 486| v486_9(void) = ExitFunction : # 489| Block 2 -# 489| r2_0(glval) = VariableAddress[x] : -# 489| r2_1(glval) = VariableAddress[#temp489:6] : -# 489| mu2_2(glval) = Store : &:r2_1, r2_0 +# 489| r489_8(glval) = VariableAddress[x] : +# 489| r489_9(glval) = VariableAddress[#temp489:6] : +# 489| mu489_10(glval) = Store : &:r489_9, r489_8 #-----| Goto -> Block 1 # 489| Block 3 -# 489| r3_0(glval) = VariableAddress[y] : -# 489| r3_1(glval) = VariableAddress[#temp489:6] : -# 489| mu3_2(glval) = Store : &:r3_1, r3_0 +# 489| r489_11(glval) = VariableAddress[y] : +# 489| r489_12(glval) = VariableAddress[#temp489:6] : +# 489| mu489_13(glval) = Store : &:r489_12, r489_11 #-----| Goto -> Block 1 # 492| void Conditional_Void(bool) # 492| Block 0 -# 492| v0_0(void) = EnterFunction : -# 492| mu0_1(unknown) = AliasedDefinition : -# 492| mu0_2(unknown) = UnmodeledDefinition : -# 492| r0_3(glval) = VariableAddress[a] : -# 492| mu0_4(bool) = InitializeParameter[a] : &:r0_3 -# 493| r0_5(glval) = VariableAddress[a] : -# 493| r0_6(bool) = Load : &:r0_5, ~mu0_2 -# 493| v0_7(void) = ConditionalBranch : r0_6 +# 492| v492_1(void) = EnterFunction : +# 492| mu492_2(unknown) = AliasedDefinition : +# 492| mu492_3(unknown) = UnmodeledDefinition : +# 492| r492_4(glval) = VariableAddress[a] : +# 492| mu492_5(bool) = InitializeParameter[a] : &:r492_4 +# 493| r493_1(glval) = VariableAddress[a] : +# 493| r493_2(bool) = Load : &:r493_1, ~mu492_3 +# 493| v493_3(void) = ConditionalBranch : r493_2 #-----| False -> Block 3 #-----| True -> Block 2 # 494| Block 1 -# 494| v1_0(void) = NoOp : -# 492| v1_1(void) = ReturnVoid : -# 492| v1_2(void) = UnmodeledUse : mu* -# 492| v1_3(void) = AliasedUse : ~mu0_2 -# 492| v1_4(void) = ExitFunction : +# 494| v494_1(void) = NoOp : +# 492| v492_6(void) = ReturnVoid : +# 492| v492_7(void) = UnmodeledUse : mu* +# 492| v492_8(void) = AliasedUse : ~mu492_3 +# 492| v492_9(void) = ExitFunction : # 493| Block 2 -# 493| r2_0(glval) = FunctionAddress[VoidFunc] : -# 493| v2_1(void) = Call : func:r2_0 -# 493| mu2_2(unknown) = ^CallSideEffect : ~mu0_2 +# 493| r493_4(glval) = FunctionAddress[VoidFunc] : +# 493| v493_5(void) = Call : func:r493_4 +# 493| mu493_6(unknown) = ^CallSideEffect : ~mu492_3 #-----| Goto -> Block 1 # 493| Block 3 -# 493| r3_0(glval) = FunctionAddress[VoidFunc] : -# 493| v3_1(void) = Call : func:r3_0 -# 493| mu3_2(unknown) = ^CallSideEffect : ~mu0_2 +# 493| r493_7(glval) = FunctionAddress[VoidFunc] : +# 493| v493_8(void) = Call : func:r493_7 +# 493| mu493_9(unknown) = ^CallSideEffect : ~mu492_3 #-----| Goto -> Block 1 # 496| void Nullptr() # 496| Block 0 -# 496| v0_0(void) = EnterFunction : -# 496| mu0_1(unknown) = AliasedDefinition : -# 496| mu0_2(unknown) = UnmodeledDefinition : -# 497| r0_3(glval) = VariableAddress[p] : -# 497| r0_4(int *) = Constant[0] : -# 497| mu0_5(int *) = Store : &:r0_3, r0_4 -# 498| r0_6(glval) = VariableAddress[q] : -# 498| r0_7(int *) = Constant[0] : -# 498| mu0_8(int *) = Store : &:r0_6, r0_7 -# 499| r0_9(int *) = Constant[0] : -# 499| r0_10(glval) = VariableAddress[p] : -# 499| mu0_11(int *) = Store : &:r0_10, r0_9 -# 500| r0_12(int *) = Constant[0] : -# 500| r0_13(glval) = VariableAddress[q] : -# 500| mu0_14(int *) = Store : &:r0_13, r0_12 -# 501| v0_15(void) = NoOp : -# 496| v0_16(void) = ReturnVoid : -# 496| v0_17(void) = UnmodeledUse : mu* -# 496| v0_18(void) = AliasedUse : ~mu0_2 -# 496| v0_19(void) = ExitFunction : +# 496| v496_1(void) = EnterFunction : +# 496| mu496_2(unknown) = AliasedDefinition : +# 496| mu496_3(unknown) = UnmodeledDefinition : +# 497| r497_1(glval) = VariableAddress[p] : +# 497| r497_2(int *) = Constant[0] : +# 497| mu497_3(int *) = Store : &:r497_1, r497_2 +# 498| r498_1(glval) = VariableAddress[q] : +# 498| r498_2(int *) = Constant[0] : +# 498| mu498_3(int *) = Store : &:r498_1, r498_2 +# 499| r499_1(int *) = Constant[0] : +# 499| r499_2(glval) = VariableAddress[p] : +# 499| mu499_3(int *) = Store : &:r499_2, r499_1 +# 500| r500_1(int *) = Constant[0] : +# 500| r500_2(glval) = VariableAddress[q] : +# 500| mu500_3(int *) = Store : &:r500_2, r500_1 +# 501| v501_1(void) = NoOp : +# 496| v496_4(void) = ReturnVoid : +# 496| v496_5(void) = UnmodeledUse : mu* +# 496| v496_6(void) = AliasedUse : ~mu496_3 +# 496| v496_7(void) = ExitFunction : # 503| void InitList(int, float) # 503| Block 0 -# 503| v0_0(void) = EnterFunction : -# 503| mu0_1(unknown) = AliasedDefinition : -# 503| mu0_2(unknown) = UnmodeledDefinition : -# 503| r0_3(glval) = VariableAddress[x] : -# 503| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 503| r0_5(glval) = VariableAddress[f] : -# 503| mu0_6(float) = InitializeParameter[f] : &:r0_5 -# 504| r0_7(glval) = VariableAddress[pt1] : -# 504| mu0_8(Point) = Uninitialized[pt1] : &:r0_7 -# 504| r0_9(glval) = FieldAddress[x] : r0_7 -# 504| r0_10(glval) = VariableAddress[x] : -# 504| r0_11(int) = Load : &:r0_10, ~mu0_2 -# 504| mu0_12(int) = Store : &:r0_9, r0_11 -# 504| r0_13(glval) = FieldAddress[y] : r0_7 -# 504| r0_14(glval) = VariableAddress[f] : -# 504| r0_15(float) = Load : &:r0_14, ~mu0_2 -# 504| r0_16(int) = Convert : r0_15 -# 504| mu0_17(int) = Store : &:r0_13, r0_16 -# 505| r0_18(glval) = VariableAddress[pt2] : -# 505| mu0_19(Point) = Uninitialized[pt2] : &:r0_18 -# 505| r0_20(glval) = FieldAddress[x] : r0_18 -# 505| r0_21(glval) = VariableAddress[x] : -# 505| r0_22(int) = Load : &:r0_21, ~mu0_2 -# 505| mu0_23(int) = Store : &:r0_20, r0_22 -# 505| r0_24(glval) = FieldAddress[y] : r0_18 -# 505| r0_25(int) = Constant[0] : -# 505| mu0_26(int) = Store : &:r0_24, r0_25 -# 506| r0_27(glval) = VariableAddress[pt3] : -# 506| mu0_28(Point) = Uninitialized[pt3] : &:r0_27 -# 506| r0_29(glval) = FieldAddress[x] : r0_27 -# 506| r0_30(int) = Constant[0] : -# 506| mu0_31(int) = Store : &:r0_29, r0_30 -# 506| r0_32(glval) = FieldAddress[y] : r0_27 -# 506| r0_33(int) = Constant[0] : -# 506| mu0_34(int) = Store : &:r0_32, r0_33 -# 508| r0_35(glval) = VariableAddress[x1] : -# 508| r0_36(int) = Constant[1] : -# 508| mu0_37(int) = Store : &:r0_35, r0_36 -# 509| r0_38(glval) = VariableAddress[x2] : -# 509| r0_39(int) = Constant[0] : -# 509| mu0_40(int) = Store : &:r0_38, r0_39 -# 510| v0_41(void) = NoOp : -# 503| v0_42(void) = ReturnVoid : -# 503| v0_43(void) = UnmodeledUse : mu* -# 503| v0_44(void) = AliasedUse : ~mu0_2 -# 503| v0_45(void) = ExitFunction : +# 503| v503_1(void) = EnterFunction : +# 503| mu503_2(unknown) = AliasedDefinition : +# 503| mu503_3(unknown) = UnmodeledDefinition : +# 503| r503_4(glval) = VariableAddress[x] : +# 503| mu503_5(int) = InitializeParameter[x] : &:r503_4 +# 503| r503_6(glval) = VariableAddress[f] : +# 503| mu503_7(float) = InitializeParameter[f] : &:r503_6 +# 504| r504_1(glval) = VariableAddress[pt1] : +# 504| mu504_2(Point) = Uninitialized[pt1] : &:r504_1 +# 504| r504_3(glval) = FieldAddress[x] : r504_1 +# 504| r504_4(glval) = VariableAddress[x] : +# 504| r504_5(int) = Load : &:r504_4, ~mu503_3 +# 504| mu504_6(int) = Store : &:r504_3, r504_5 +# 504| r504_7(glval) = FieldAddress[y] : r504_1 +# 504| r504_8(glval) = VariableAddress[f] : +# 504| r504_9(float) = Load : &:r504_8, ~mu503_3 +# 504| r504_10(int) = Convert : r504_9 +# 504| mu504_11(int) = Store : &:r504_7, r504_10 +# 505| r505_1(glval) = VariableAddress[pt2] : +# 505| mu505_2(Point) = Uninitialized[pt2] : &:r505_1 +# 505| r505_3(glval) = FieldAddress[x] : r505_1 +# 505| r505_4(glval) = VariableAddress[x] : +# 505| r505_5(int) = Load : &:r505_4, ~mu503_3 +# 505| mu505_6(int) = Store : &:r505_3, r505_5 +# 505| r505_7(glval) = FieldAddress[y] : r505_1 +# 505| r505_8(int) = Constant[0] : +# 505| mu505_9(int) = Store : &:r505_7, r505_8 +# 506| r506_1(glval) = VariableAddress[pt3] : +# 506| mu506_2(Point) = Uninitialized[pt3] : &:r506_1 +# 506| r506_3(glval) = FieldAddress[x] : r506_1 +# 506| r506_4(int) = Constant[0] : +# 506| mu506_5(int) = Store : &:r506_3, r506_4 +# 506| r506_6(glval) = FieldAddress[y] : r506_1 +# 506| r506_7(int) = Constant[0] : +# 506| mu506_8(int) = Store : &:r506_6, r506_7 +# 508| r508_1(glval) = VariableAddress[x1] : +# 508| r508_2(int) = Constant[1] : +# 508| mu508_3(int) = Store : &:r508_1, r508_2 +# 509| r509_1(glval) = VariableAddress[x2] : +# 509| r509_2(int) = Constant[0] : +# 509| mu509_3(int) = Store : &:r509_1, r509_2 +# 510| v510_1(void) = NoOp : +# 503| v503_8(void) = ReturnVoid : +# 503| v503_9(void) = UnmodeledUse : mu* +# 503| v503_10(void) = AliasedUse : ~mu503_3 +# 503| v503_11(void) = ExitFunction : # 512| void NestedInitList(int, float) # 512| Block 0 -# 512| v0_0(void) = EnterFunction : -# 512| mu0_1(unknown) = AliasedDefinition : -# 512| mu0_2(unknown) = UnmodeledDefinition : -# 512| r0_3(glval) = VariableAddress[x] : -# 512| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 512| r0_5(glval) = VariableAddress[f] : -# 512| mu0_6(float) = InitializeParameter[f] : &:r0_5 -# 513| r0_7(glval) = VariableAddress[r1] : -# 513| mu0_8(Rect) = Uninitialized[r1] : &:r0_7 -# 513| r0_9(glval) = FieldAddress[topLeft] : r0_7 -# 513| r0_10(Point) = Constant[0] : -# 513| mu0_11(Point) = Store : &:r0_9, r0_10 -# 513| r0_12(glval) = FieldAddress[bottomRight] : r0_7 -# 513| r0_13(Point) = Constant[0] : -# 513| mu0_14(Point) = Store : &:r0_12, r0_13 -# 514| r0_15(glval) = VariableAddress[r2] : -# 514| mu0_16(Rect) = Uninitialized[r2] : &:r0_15 -# 514| r0_17(glval) = FieldAddress[topLeft] : r0_15 -# 514| r0_18(glval) = FieldAddress[x] : r0_17 -# 514| r0_19(glval) = VariableAddress[x] : -# 514| r0_20(int) = Load : &:r0_19, ~mu0_2 -# 514| mu0_21(int) = Store : &:r0_18, r0_20 -# 514| r0_22(glval) = FieldAddress[y] : r0_17 -# 514| r0_23(glval) = VariableAddress[f] : -# 514| r0_24(float) = Load : &:r0_23, ~mu0_2 -# 514| r0_25(int) = Convert : r0_24 -# 514| mu0_26(int) = Store : &:r0_22, r0_25 -# 514| r0_27(glval) = FieldAddress[bottomRight] : r0_15 -# 514| r0_28(Point) = Constant[0] : -# 514| mu0_29(Point) = Store : &:r0_27, r0_28 -# 515| r0_30(glval) = VariableAddress[r3] : -# 515| mu0_31(Rect) = Uninitialized[r3] : &:r0_30 -# 515| r0_32(glval) = FieldAddress[topLeft] : r0_30 -# 515| r0_33(glval) = FieldAddress[x] : r0_32 -# 515| r0_34(glval) = VariableAddress[x] : -# 515| r0_35(int) = Load : &:r0_34, ~mu0_2 -# 515| mu0_36(int) = Store : &:r0_33, r0_35 -# 515| r0_37(glval) = FieldAddress[y] : r0_32 -# 515| r0_38(glval) = VariableAddress[f] : -# 515| r0_39(float) = Load : &:r0_38, ~mu0_2 -# 515| r0_40(int) = Convert : r0_39 -# 515| mu0_41(int) = Store : &:r0_37, r0_40 -# 515| r0_42(glval) = FieldAddress[bottomRight] : r0_30 -# 515| r0_43(glval) = FieldAddress[x] : r0_42 -# 515| r0_44(glval) = VariableAddress[x] : -# 515| r0_45(int) = Load : &:r0_44, ~mu0_2 -# 515| mu0_46(int) = Store : &:r0_43, r0_45 -# 515| r0_47(glval) = FieldAddress[y] : r0_42 -# 515| r0_48(glval) = VariableAddress[f] : -# 515| r0_49(float) = Load : &:r0_48, ~mu0_2 -# 515| r0_50(int) = Convert : r0_49 -# 515| mu0_51(int) = Store : &:r0_47, r0_50 -# 516| r0_52(glval) = VariableAddress[r4] : -# 516| mu0_53(Rect) = Uninitialized[r4] : &:r0_52 -# 516| r0_54(glval) = FieldAddress[topLeft] : r0_52 -# 516| r0_55(glval) = FieldAddress[x] : r0_54 -# 516| r0_56(glval) = VariableAddress[x] : -# 516| r0_57(int) = Load : &:r0_56, ~mu0_2 -# 516| mu0_58(int) = Store : &:r0_55, r0_57 -# 516| r0_59(glval) = FieldAddress[y] : r0_54 -# 516| r0_60(int) = Constant[0] : -# 516| mu0_61(int) = Store : &:r0_59, r0_60 -# 516| r0_62(glval) = FieldAddress[bottomRight] : r0_52 -# 516| r0_63(glval) = FieldAddress[x] : r0_62 -# 516| r0_64(glval) = VariableAddress[x] : -# 516| r0_65(int) = Load : &:r0_64, ~mu0_2 -# 516| mu0_66(int) = Store : &:r0_63, r0_65 -# 516| r0_67(glval) = FieldAddress[y] : r0_62 -# 516| r0_68(int) = Constant[0] : -# 516| mu0_69(int) = Store : &:r0_67, r0_68 -# 517| v0_70(void) = NoOp : -# 512| v0_71(void) = ReturnVoid : -# 512| v0_72(void) = UnmodeledUse : mu* -# 512| v0_73(void) = AliasedUse : ~mu0_2 -# 512| v0_74(void) = ExitFunction : +# 512| v512_1(void) = EnterFunction : +# 512| mu512_2(unknown) = AliasedDefinition : +# 512| mu512_3(unknown) = UnmodeledDefinition : +# 512| r512_4(glval) = VariableAddress[x] : +# 512| mu512_5(int) = InitializeParameter[x] : &:r512_4 +# 512| r512_6(glval) = VariableAddress[f] : +# 512| mu512_7(float) = InitializeParameter[f] : &:r512_6 +# 513| r513_1(glval) = VariableAddress[r1] : +# 513| mu513_2(Rect) = Uninitialized[r1] : &:r513_1 +# 513| r513_3(glval) = FieldAddress[topLeft] : r513_1 +# 513| r513_4(Point) = Constant[0] : +# 513| mu513_5(Point) = Store : &:r513_3, r513_4 +# 513| r513_6(glval) = FieldAddress[bottomRight] : r513_1 +# 513| r513_7(Point) = Constant[0] : +# 513| mu513_8(Point) = Store : &:r513_6, r513_7 +# 514| r514_1(glval) = VariableAddress[r2] : +# 514| mu514_2(Rect) = Uninitialized[r2] : &:r514_1 +# 514| r514_3(glval) = FieldAddress[topLeft] : r514_1 +# 514| r514_4(glval) = FieldAddress[x] : r514_3 +# 514| r514_5(glval) = VariableAddress[x] : +# 514| r514_6(int) = Load : &:r514_5, ~mu512_3 +# 514| mu514_7(int) = Store : &:r514_4, r514_6 +# 514| r514_8(glval) = FieldAddress[y] : r514_3 +# 514| r514_9(glval) = VariableAddress[f] : +# 514| r514_10(float) = Load : &:r514_9, ~mu512_3 +# 514| r514_11(int) = Convert : r514_10 +# 514| mu514_12(int) = Store : &:r514_8, r514_11 +# 514| r514_13(glval) = FieldAddress[bottomRight] : r514_1 +# 514| r514_14(Point) = Constant[0] : +# 514| mu514_15(Point) = Store : &:r514_13, r514_14 +# 515| r515_1(glval) = VariableAddress[r3] : +# 515| mu515_2(Rect) = Uninitialized[r3] : &:r515_1 +# 515| r515_3(glval) = FieldAddress[topLeft] : r515_1 +# 515| r515_4(glval) = FieldAddress[x] : r515_3 +# 515| r515_5(glval) = VariableAddress[x] : +# 515| r515_6(int) = Load : &:r515_5, ~mu512_3 +# 515| mu515_7(int) = Store : &:r515_4, r515_6 +# 515| r515_8(glval) = FieldAddress[y] : r515_3 +# 515| r515_9(glval) = VariableAddress[f] : +# 515| r515_10(float) = Load : &:r515_9, ~mu512_3 +# 515| r515_11(int) = Convert : r515_10 +# 515| mu515_12(int) = Store : &:r515_8, r515_11 +# 515| r515_13(glval) = FieldAddress[bottomRight] : r515_1 +# 515| r515_14(glval) = FieldAddress[x] : r515_13 +# 515| r515_15(glval) = VariableAddress[x] : +# 515| r515_16(int) = Load : &:r515_15, ~mu512_3 +# 515| mu515_17(int) = Store : &:r515_14, r515_16 +# 515| r515_18(glval) = FieldAddress[y] : r515_13 +# 515| r515_19(glval) = VariableAddress[f] : +# 515| r515_20(float) = Load : &:r515_19, ~mu512_3 +# 515| r515_21(int) = Convert : r515_20 +# 515| mu515_22(int) = Store : &:r515_18, r515_21 +# 516| r516_1(glval) = VariableAddress[r4] : +# 516| mu516_2(Rect) = Uninitialized[r4] : &:r516_1 +# 516| r516_3(glval) = FieldAddress[topLeft] : r516_1 +# 516| r516_4(glval) = FieldAddress[x] : r516_3 +# 516| r516_5(glval) = VariableAddress[x] : +# 516| r516_6(int) = Load : &:r516_5, ~mu512_3 +# 516| mu516_7(int) = Store : &:r516_4, r516_6 +# 516| r516_8(glval) = FieldAddress[y] : r516_3 +# 516| r516_9(int) = Constant[0] : +# 516| mu516_10(int) = Store : &:r516_8, r516_9 +# 516| r516_11(glval) = FieldAddress[bottomRight] : r516_1 +# 516| r516_12(glval) = FieldAddress[x] : r516_11 +# 516| r516_13(glval) = VariableAddress[x] : +# 516| r516_14(int) = Load : &:r516_13, ~mu512_3 +# 516| mu516_15(int) = Store : &:r516_12, r516_14 +# 516| r516_16(glval) = FieldAddress[y] : r516_11 +# 516| r516_17(int) = Constant[0] : +# 516| mu516_18(int) = Store : &:r516_16, r516_17 +# 517| v517_1(void) = NoOp : +# 512| v512_8(void) = ReturnVoid : +# 512| v512_9(void) = UnmodeledUse : mu* +# 512| v512_10(void) = AliasedUse : ~mu512_3 +# 512| v512_11(void) = ExitFunction : # 519| void ArrayInit(int, float) # 519| Block 0 -# 519| v0_0(void) = EnterFunction : -# 519| mu0_1(unknown) = AliasedDefinition : -# 519| mu0_2(unknown) = UnmodeledDefinition : -# 519| r0_3(glval) = VariableAddress[x] : -# 519| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 519| r0_5(glval) = VariableAddress[f] : -# 519| mu0_6(float) = InitializeParameter[f] : &:r0_5 -# 520| r0_7(glval) = VariableAddress[a1] : -# 520| mu0_8(int[3]) = Uninitialized[a1] : &:r0_7 -# 520| r0_9(int) = Constant[0] : -# 520| r0_10(glval) = PointerAdd[4] : r0_7, r0_9 -# 520| r0_11(unknown[12]) = Constant[0] : -# 520| mu0_12(unknown[12]) = Store : &:r0_10, r0_11 -# 521| r0_13(glval) = VariableAddress[a2] : -# 521| mu0_14(int[3]) = Uninitialized[a2] : &:r0_13 -# 521| r0_15(int) = Constant[0] : -# 521| r0_16(glval) = PointerAdd[4] : r0_13, r0_15 -# 521| r0_17(glval) = VariableAddress[x] : -# 521| r0_18(int) = Load : &:r0_17, ~mu0_2 -# 521| mu0_19(int) = Store : &:r0_16, r0_18 -# 521| r0_20(int) = Constant[1] : -# 521| r0_21(glval) = PointerAdd[4] : r0_13, r0_20 -# 521| r0_22(glval) = VariableAddress[f] : -# 521| r0_23(float) = Load : &:r0_22, ~mu0_2 -# 521| r0_24(int) = Convert : r0_23 -# 521| mu0_25(int) = Store : &:r0_21, r0_24 -# 521| r0_26(int) = Constant[2] : -# 521| r0_27(glval) = PointerAdd[4] : r0_13, r0_26 -# 521| r0_28(int) = Constant[0] : -# 521| mu0_29(int) = Store : &:r0_27, r0_28 -# 522| r0_30(glval) = VariableAddress[a3] : -# 522| mu0_31(int[3]) = Uninitialized[a3] : &:r0_30 -# 522| r0_32(int) = Constant[0] : -# 522| r0_33(glval) = PointerAdd[4] : r0_30, r0_32 -# 522| r0_34(glval) = VariableAddress[x] : -# 522| r0_35(int) = Load : &:r0_34, ~mu0_2 -# 522| mu0_36(int) = Store : &:r0_33, r0_35 -# 522| r0_37(int) = Constant[1] : -# 522| r0_38(glval) = PointerAdd[4] : r0_30, r0_37 -# 522| r0_39(unknown[8]) = Constant[0] : -# 522| mu0_40(unknown[8]) = Store : &:r0_38, r0_39 -# 523| v0_41(void) = NoOp : -# 519| v0_42(void) = ReturnVoid : -# 519| v0_43(void) = UnmodeledUse : mu* -# 519| v0_44(void) = AliasedUse : ~mu0_2 -# 519| v0_45(void) = ExitFunction : +# 519| v519_1(void) = EnterFunction : +# 519| mu519_2(unknown) = AliasedDefinition : +# 519| mu519_3(unknown) = UnmodeledDefinition : +# 519| r519_4(glval) = VariableAddress[x] : +# 519| mu519_5(int) = InitializeParameter[x] : &:r519_4 +# 519| r519_6(glval) = VariableAddress[f] : +# 519| mu519_7(float) = InitializeParameter[f] : &:r519_6 +# 520| r520_1(glval) = VariableAddress[a1] : +# 520| mu520_2(int[3]) = Uninitialized[a1] : &:r520_1 +# 520| r520_3(int) = Constant[0] : +# 520| r520_4(glval) = PointerAdd[4] : r520_1, r520_3 +# 520| r520_5(unknown[12]) = Constant[0] : +# 520| mu520_6(unknown[12]) = Store : &:r520_4, r520_5 +# 521| r521_1(glval) = VariableAddress[a2] : +# 521| mu521_2(int[3]) = Uninitialized[a2] : &:r521_1 +# 521| r521_3(int) = Constant[0] : +# 521| r521_4(glval) = PointerAdd[4] : r521_1, r521_3 +# 521| r521_5(glval) = VariableAddress[x] : +# 521| r521_6(int) = Load : &:r521_5, ~mu519_3 +# 521| mu521_7(int) = Store : &:r521_4, r521_6 +# 521| r521_8(int) = Constant[1] : +# 521| r521_9(glval) = PointerAdd[4] : r521_1, r521_8 +# 521| r521_10(glval) = VariableAddress[f] : +# 521| r521_11(float) = Load : &:r521_10, ~mu519_3 +# 521| r521_12(int) = Convert : r521_11 +# 521| mu521_13(int) = Store : &:r521_9, r521_12 +# 521| r521_14(int) = Constant[2] : +# 521| r521_15(glval) = PointerAdd[4] : r521_1, r521_14 +# 521| r521_16(int) = Constant[0] : +# 521| mu521_17(int) = Store : &:r521_15, r521_16 +# 522| r522_1(glval) = VariableAddress[a3] : +# 522| mu522_2(int[3]) = Uninitialized[a3] : &:r522_1 +# 522| r522_3(int) = Constant[0] : +# 522| r522_4(glval) = PointerAdd[4] : r522_1, r522_3 +# 522| r522_5(glval) = VariableAddress[x] : +# 522| r522_6(int) = Load : &:r522_5, ~mu519_3 +# 522| mu522_7(int) = Store : &:r522_4, r522_6 +# 522| r522_8(int) = Constant[1] : +# 522| r522_9(glval) = PointerAdd[4] : r522_1, r522_8 +# 522| r522_10(unknown[8]) = Constant[0] : +# 522| mu522_11(unknown[8]) = Store : &:r522_9, r522_10 +# 523| v523_1(void) = NoOp : +# 519| v519_8(void) = ReturnVoid : +# 519| v519_9(void) = UnmodeledUse : mu* +# 519| v519_10(void) = AliasedUse : ~mu519_3 +# 519| v519_11(void) = ExitFunction : # 530| void UnionInit(int, float) # 530| Block 0 -# 530| v0_0(void) = EnterFunction : -# 530| mu0_1(unknown) = AliasedDefinition : -# 530| mu0_2(unknown) = UnmodeledDefinition : -# 530| r0_3(glval) = VariableAddress[x] : -# 530| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 530| r0_5(glval) = VariableAddress[f] : -# 530| mu0_6(float) = InitializeParameter[f] : &:r0_5 -# 531| r0_7(glval) = VariableAddress[u1] : -# 531| mu0_8(U) = Uninitialized[u1] : &:r0_7 -# 531| r0_9(glval) = FieldAddress[d] : r0_7 -# 531| r0_10(glval) = VariableAddress[f] : -# 531| r0_11(float) = Load : &:r0_10, ~mu0_2 -# 531| r0_12(double) = Convert : r0_11 -# 531| mu0_13(double) = Store : &:r0_9, r0_12 -# 533| v0_14(void) = NoOp : -# 530| v0_15(void) = ReturnVoid : -# 530| v0_16(void) = UnmodeledUse : mu* -# 530| v0_17(void) = AliasedUse : ~mu0_2 -# 530| v0_18(void) = ExitFunction : +# 530| v530_1(void) = EnterFunction : +# 530| mu530_2(unknown) = AliasedDefinition : +# 530| mu530_3(unknown) = UnmodeledDefinition : +# 530| r530_4(glval) = VariableAddress[x] : +# 530| mu530_5(int) = InitializeParameter[x] : &:r530_4 +# 530| r530_6(glval) = VariableAddress[f] : +# 530| mu530_7(float) = InitializeParameter[f] : &:r530_6 +# 531| r531_1(glval) = VariableAddress[u1] : +# 531| mu531_2(U) = Uninitialized[u1] : &:r531_1 +# 531| r531_3(glval) = FieldAddress[d] : r531_1 +# 531| r531_4(glval) = VariableAddress[f] : +# 531| r531_5(float) = Load : &:r531_4, ~mu530_3 +# 531| r531_6(double) = Convert : r531_5 +# 531| mu531_7(double) = Store : &:r531_3, r531_6 +# 533| v533_1(void) = NoOp : +# 530| v530_8(void) = ReturnVoid : +# 530| v530_9(void) = UnmodeledUse : mu* +# 530| v530_10(void) = AliasedUse : ~mu530_3 +# 530| v530_11(void) = ExitFunction : # 535| void EarlyReturn(int, int) # 535| Block 0 -# 535| v0_0(void) = EnterFunction : -# 535| mu0_1(unknown) = AliasedDefinition : -# 535| mu0_2(unknown) = UnmodeledDefinition : -# 535| r0_3(glval) = VariableAddress[x] : -# 535| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 535| r0_5(glval) = VariableAddress[y] : -# 535| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 536| r0_7(glval) = VariableAddress[x] : -# 536| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 536| r0_9(glval) = VariableAddress[y] : -# 536| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 536| r0_11(bool) = CompareLT : r0_8, r0_10 -# 536| v0_12(void) = ConditionalBranch : r0_11 +# 535| v535_1(void) = EnterFunction : +# 535| mu535_2(unknown) = AliasedDefinition : +# 535| mu535_3(unknown) = UnmodeledDefinition : +# 535| r535_4(glval) = VariableAddress[x] : +# 535| mu535_5(int) = InitializeParameter[x] : &:r535_4 +# 535| r535_6(glval) = VariableAddress[y] : +# 535| mu535_7(int) = InitializeParameter[y] : &:r535_6 +# 536| r536_1(glval) = VariableAddress[x] : +# 536| r536_2(int) = Load : &:r536_1, ~mu535_3 +# 536| r536_3(glval) = VariableAddress[y] : +# 536| r536_4(int) = Load : &:r536_3, ~mu535_3 +# 536| r536_5(bool) = CompareLT : r536_2, r536_4 +# 536| v536_6(void) = ConditionalBranch : r536_5 #-----| False -> Block 3 #-----| True -> Block 2 # 535| Block 1 -# 535| v1_0(void) = ReturnVoid : -# 535| v1_1(void) = UnmodeledUse : mu* -# 535| v1_2(void) = AliasedUse : ~mu0_2 -# 535| v1_3(void) = ExitFunction : +# 535| v535_8(void) = ReturnVoid : +# 535| v535_9(void) = UnmodeledUse : mu* +# 535| v535_10(void) = AliasedUse : ~mu535_3 +# 535| v535_11(void) = ExitFunction : # 537| Block 2 -# 537| v2_0(void) = NoOp : +# 537| v537_1(void) = NoOp : #-----| Goto -> Block 1 # 540| Block 3 -# 540| r3_0(glval) = VariableAddress[x] : -# 540| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 540| r3_2(glval) = VariableAddress[y] : -# 540| mu3_3(int) = Store : &:r3_2, r3_1 -# 541| v3_4(void) = NoOp : +# 540| r540_1(glval) = VariableAddress[x] : +# 540| r540_2(int) = Load : &:r540_1, ~mu535_3 +# 540| r540_3(glval) = VariableAddress[y] : +# 540| mu540_4(int) = Store : &:r540_3, r540_2 +# 541| v541_1(void) = NoOp : #-----| Goto -> Block 1 # 543| int EarlyReturnValue(int, int) # 543| Block 0 -# 543| v0_0(void) = EnterFunction : -# 543| mu0_1(unknown) = AliasedDefinition : -# 543| mu0_2(unknown) = UnmodeledDefinition : -# 543| r0_3(glval) = VariableAddress[x] : -# 543| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 543| r0_5(glval) = VariableAddress[y] : -# 543| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 544| r0_7(glval) = VariableAddress[x] : -# 544| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 544| r0_9(glval) = VariableAddress[y] : -# 544| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 544| r0_11(bool) = CompareLT : r0_8, r0_10 -# 544| v0_12(void) = ConditionalBranch : r0_11 +# 543| v543_1(void) = EnterFunction : +# 543| mu543_2(unknown) = AliasedDefinition : +# 543| mu543_3(unknown) = UnmodeledDefinition : +# 543| r543_4(glval) = VariableAddress[x] : +# 543| mu543_5(int) = InitializeParameter[x] : &:r543_4 +# 543| r543_6(glval) = VariableAddress[y] : +# 543| mu543_7(int) = InitializeParameter[y] : &:r543_6 +# 544| r544_1(glval) = VariableAddress[x] : +# 544| r544_2(int) = Load : &:r544_1, ~mu543_3 +# 544| r544_3(glval) = VariableAddress[y] : +# 544| r544_4(int) = Load : &:r544_3, ~mu543_3 +# 544| r544_5(bool) = CompareLT : r544_2, r544_4 +# 544| v544_6(void) = ConditionalBranch : r544_5 #-----| False -> Block 3 #-----| True -> Block 2 # 543| Block 1 -# 543| r1_0(glval) = VariableAddress[#return] : -# 543| v1_1(void) = ReturnValue : &:r1_0, ~mu0_2 -# 543| v1_2(void) = UnmodeledUse : mu* -# 543| v1_3(void) = AliasedUse : ~mu0_2 -# 543| v1_4(void) = ExitFunction : +# 543| r543_8(glval) = VariableAddress[#return] : +# 543| v543_9(void) = ReturnValue : &:r543_8, ~mu543_3 +# 543| v543_10(void) = UnmodeledUse : mu* +# 543| v543_11(void) = AliasedUse : ~mu543_3 +# 543| v543_12(void) = ExitFunction : # 545| Block 2 -# 545| r2_0(glval) = VariableAddress[#return] : -# 545| r2_1(glval) = VariableAddress[x] : -# 545| r2_2(int) = Load : &:r2_1, ~mu0_2 -# 545| mu2_3(int) = Store : &:r2_0, r2_2 +# 545| r545_1(glval) = VariableAddress[#return] : +# 545| r545_2(glval) = VariableAddress[x] : +# 545| r545_3(int) = Load : &:r545_2, ~mu543_3 +# 545| mu545_4(int) = Store : &:r545_1, r545_3 #-----| Goto -> Block 1 # 548| Block 3 -# 548| r3_0(glval) = VariableAddress[#return] : -# 548| r3_1(glval) = VariableAddress[x] : -# 548| r3_2(int) = Load : &:r3_1, ~mu0_2 -# 548| r3_3(glval) = VariableAddress[y] : -# 548| r3_4(int) = Load : &:r3_3, ~mu0_2 -# 548| r3_5(int) = Add : r3_2, r3_4 -# 548| mu3_6(int) = Store : &:r3_0, r3_5 +# 548| r548_1(glval) = VariableAddress[#return] : +# 548| r548_2(glval) = VariableAddress[x] : +# 548| r548_3(int) = Load : &:r548_2, ~mu543_3 +# 548| r548_4(glval) = VariableAddress[y] : +# 548| r548_5(int) = Load : &:r548_4, ~mu543_3 +# 548| r548_6(int) = Add : r548_3, r548_5 +# 548| mu548_7(int) = Store : &:r548_1, r548_6 #-----| Goto -> Block 1 # 551| int CallViaFuncPtr(int(*)(int)) # 551| Block 0 -# 551| v0_0(void) = EnterFunction : -# 551| mu0_1(unknown) = AliasedDefinition : -# 551| mu0_2(unknown) = UnmodeledDefinition : -# 551| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| mu0_4(..(*)(..)) = InitializeParameter[pfn] : &:r0_3 -# 552| r0_5(glval) = VariableAddress[#return] : -# 552| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r0_7(..(*)(..)) = Load : &:r0_6, ~mu0_2 -# 552| r0_8(int) = Constant[5] : -# 552| r0_9(int) = Call : func:r0_7, 0:r0_8 -# 552| mu0_10(unknown) = ^CallSideEffect : ~mu0_2 -# 552| mu0_11(int) = Store : &:r0_5, r0_9 -# 551| r0_12(glval) = VariableAddress[#return] : -# 551| v0_13(void) = ReturnValue : &:r0_12, ~mu0_2 -# 551| v0_14(void) = UnmodeledUse : mu* -# 551| v0_15(void) = AliasedUse : ~mu0_2 -# 551| v0_16(void) = ExitFunction : +# 551| v551_1(void) = EnterFunction : +# 551| mu551_2(unknown) = AliasedDefinition : +# 551| mu551_3(unknown) = UnmodeledDefinition : +# 551| r551_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 551| mu551_5(..(*)(..)) = InitializeParameter[pfn] : &:r551_4 +# 552| r552_1(glval) = VariableAddress[#return] : +# 552| r552_2(glval<..(*)(..)>) = VariableAddress[pfn] : +# 552| r552_3(..(*)(..)) = Load : &:r552_2, ~mu551_3 +# 552| r552_4(int) = Constant[5] : +# 552| r552_5(int) = Call : func:r552_3, 0:r552_4 +# 552| mu552_6(unknown) = ^CallSideEffect : ~mu551_3 +# 552| mu552_7(int) = Store : &:r552_1, r552_5 +# 551| r551_6(glval) = VariableAddress[#return] : +# 551| v551_7(void) = ReturnValue : &:r551_6, ~mu551_3 +# 551| v551_8(void) = UnmodeledUse : mu* +# 551| v551_9(void) = AliasedUse : ~mu551_3 +# 551| v551_10(void) = ExitFunction : # 560| int EnumSwitch(E) # 560| Block 0 -# 560| v0_0(void) = EnterFunction : -# 560| mu0_1(unknown) = AliasedDefinition : -# 560| mu0_2(unknown) = UnmodeledDefinition : -# 560| r0_3(glval) = VariableAddress[e] : -# 560| mu0_4(E) = InitializeParameter[e] : &:r0_3 -# 561| r0_5(glval) = VariableAddress[e] : -# 561| r0_6(E) = Load : &:r0_5, ~mu0_2 -# 561| r0_7(int) = Convert : r0_6 -# 561| v0_8(void) = Switch : r0_7 +# 560| v560_1(void) = EnterFunction : +# 560| mu560_2(unknown) = AliasedDefinition : +# 560| mu560_3(unknown) = UnmodeledDefinition : +# 560| r560_4(glval) = VariableAddress[e] : +# 560| mu560_5(E) = InitializeParameter[e] : &:r560_4 +# 561| r561_1(glval) = VariableAddress[e] : +# 561| r561_2(E) = Load : &:r561_1, ~mu560_3 +# 561| r561_3(int) = Convert : r561_2 +# 561| v561_4(void) = Switch : r561_3 #-----| Case[0] -> Block 4 #-----| Case[1] -> Block 2 #-----| Default -> Block 3 # 560| Block 1 -# 560| r1_0(glval) = VariableAddress[#return] : -# 560| v1_1(void) = ReturnValue : &:r1_0, ~mu0_2 -# 560| v1_2(void) = UnmodeledUse : mu* -# 560| v1_3(void) = AliasedUse : ~mu0_2 -# 560| v1_4(void) = ExitFunction : +# 560| r560_6(glval) = VariableAddress[#return] : +# 560| v560_7(void) = ReturnValue : &:r560_6, ~mu560_3 +# 560| v560_8(void) = UnmodeledUse : mu* +# 560| v560_9(void) = AliasedUse : ~mu560_3 +# 560| v560_10(void) = ExitFunction : # 564| Block 2 -# 564| v2_0(void) = NoOp : -# 565| r2_1(glval) = VariableAddress[#return] : -# 565| r2_2(int) = Constant[1] : -# 565| mu2_3(int) = Store : &:r2_1, r2_2 +# 564| v564_1(void) = NoOp : +# 565| r565_1(glval) = VariableAddress[#return] : +# 565| r565_2(int) = Constant[1] : +# 565| mu565_3(int) = Store : &:r565_1, r565_2 #-----| Goto -> Block 1 # 566| Block 3 -# 566| v3_0(void) = NoOp : -# 567| r3_1(glval) = VariableAddress[#return] : -# 567| r3_2(int) = Constant[-1] : -# 567| mu3_3(int) = Store : &:r3_1, r3_2 +# 566| v566_1(void) = NoOp : +# 567| r567_1(glval) = VariableAddress[#return] : +# 567| r567_2(int) = Constant[-1] : +# 567| mu567_3(int) = Store : &:r567_1, r567_2 #-----| Goto -> Block 1 # 562| Block 4 -# 562| v4_0(void) = NoOp : -# 563| r4_1(glval) = VariableAddress[#return] : -# 563| r4_2(int) = Constant[0] : -# 563| mu4_3(int) = Store : &:r4_1, r4_2 +# 562| v562_1(void) = NoOp : +# 563| r563_1(glval) = VariableAddress[#return] : +# 563| r563_2(int) = Constant[0] : +# 563| mu563_3(int) = Store : &:r563_1, r563_2 #-----| Goto -> Block 1 # 571| void InitArray() # 571| Block 0 -# 571| v0_0(void) = EnterFunction : -# 571| mu0_1(unknown) = AliasedDefinition : -# 571| mu0_2(unknown) = UnmodeledDefinition : -# 572| r0_3(glval) = VariableAddress[a_pad] : -# 572| r0_4(glval) = StringConstant[""] : -# 572| r0_5(char[32]) = Load : &:r0_4, ~mu0_2 -# 572| mu0_6(char[32]) = Store : &:r0_3, r0_5 -# 573| r0_7(glval) = VariableAddress[a_nopad] : -# 573| r0_8(glval) = StringConstant["foo"] : -# 573| r0_9(char[4]) = Load : &:r0_8, ~mu0_2 -# 573| mu0_10(char[4]) = Store : &:r0_7, r0_9 -# 574| r0_11(glval) = VariableAddress[a_infer] : -# 574| r0_12(glval) = StringConstant["blah"] : -# 574| r0_13(char[5]) = Load : &:r0_12, ~mu0_2 -# 574| mu0_14(char[5]) = Store : &:r0_11, r0_13 -# 575| r0_15(glval) = VariableAddress[b] : -# 575| mu0_16(char[2]) = Uninitialized[b] : &:r0_15 -# 576| r0_17(glval) = VariableAddress[c] : -# 576| mu0_18(char[2]) = Uninitialized[c] : &:r0_17 -# 576| r0_19(int) = Constant[0] : -# 576| r0_20(glval) = PointerAdd[1] : r0_17, r0_19 -# 576| r0_21(unknown[2]) = Constant[0] : -# 576| mu0_22(unknown[2]) = Store : &:r0_20, r0_21 -# 577| r0_23(glval) = VariableAddress[d] : -# 577| mu0_24(char[2]) = Uninitialized[d] : &:r0_23 -# 577| r0_25(int) = Constant[0] : -# 577| r0_26(glval) = PointerAdd[1] : r0_23, r0_25 -# 577| r0_27(char) = Constant[0] : -# 577| mu0_28(char) = Store : &:r0_26, r0_27 -# 577| r0_29(int) = Constant[1] : -# 577| r0_30(glval) = PointerAdd[1] : r0_23, r0_29 -# 577| r0_31(char) = Constant[0] : -# 577| mu0_32(char) = Store : &:r0_30, r0_31 -# 578| r0_33(glval) = VariableAddress[e] : -# 578| mu0_34(char[2]) = Uninitialized[e] : &:r0_33 -# 578| r0_35(int) = Constant[0] : -# 578| r0_36(glval) = PointerAdd[1] : r0_33, r0_35 -# 578| r0_37(char) = Constant[0] : -# 578| mu0_38(char) = Store : &:r0_36, r0_37 -# 578| r0_39(int) = Constant[1] : -# 578| r0_40(glval) = PointerAdd[1] : r0_33, r0_39 -# 578| r0_41(char) = Constant[1] : -# 578| mu0_42(char) = Store : &:r0_40, r0_41 -# 579| r0_43(glval) = VariableAddress[f] : -# 579| mu0_44(char[3]) = Uninitialized[f] : &:r0_43 -# 579| r0_45(int) = Constant[0] : -# 579| r0_46(glval) = PointerAdd[1] : r0_43, r0_45 -# 579| r0_47(char) = Constant[0] : -# 579| mu0_48(char) = Store : &:r0_46, r0_47 -# 579| r0_49(int) = Constant[1] : -# 579| r0_50(glval) = PointerAdd[1] : r0_43, r0_49 -# 579| r0_51(unknown[2]) = Constant[0] : -# 579| mu0_52(unknown[2]) = Store : &:r0_50, r0_51 -# 580| v0_53(void) = NoOp : -# 571| v0_54(void) = ReturnVoid : -# 571| v0_55(void) = UnmodeledUse : mu* -# 571| v0_56(void) = AliasedUse : ~mu0_2 -# 571| v0_57(void) = ExitFunction : +# 571| v571_1(void) = EnterFunction : +# 571| mu571_2(unknown) = AliasedDefinition : +# 571| mu571_3(unknown) = UnmodeledDefinition : +# 572| r572_1(glval) = VariableAddress[a_pad] : +# 572| r572_2(glval) = StringConstant[""] : +# 572| r572_3(char[32]) = Load : &:r572_2, ~mu571_3 +# 572| mu572_4(char[32]) = Store : &:r572_1, r572_3 +# 573| r573_1(glval) = VariableAddress[a_nopad] : +# 573| r573_2(glval) = StringConstant["foo"] : +# 573| r573_3(char[4]) = Load : &:r573_2, ~mu571_3 +# 573| mu573_4(char[4]) = Store : &:r573_1, r573_3 +# 574| r574_1(glval) = VariableAddress[a_infer] : +# 574| r574_2(glval) = StringConstant["blah"] : +# 574| r574_3(char[5]) = Load : &:r574_2, ~mu571_3 +# 574| mu574_4(char[5]) = Store : &:r574_1, r574_3 +# 575| r575_1(glval) = VariableAddress[b] : +# 575| mu575_2(char[2]) = Uninitialized[b] : &:r575_1 +# 576| r576_1(glval) = VariableAddress[c] : +# 576| mu576_2(char[2]) = Uninitialized[c] : &:r576_1 +# 576| r576_3(int) = Constant[0] : +# 576| r576_4(glval) = PointerAdd[1] : r576_1, r576_3 +# 576| r576_5(unknown[2]) = Constant[0] : +# 576| mu576_6(unknown[2]) = Store : &:r576_4, r576_5 +# 577| r577_1(glval) = VariableAddress[d] : +# 577| mu577_2(char[2]) = Uninitialized[d] : &:r577_1 +# 577| r577_3(int) = Constant[0] : +# 577| r577_4(glval) = PointerAdd[1] : r577_1, r577_3 +# 577| r577_5(char) = Constant[0] : +# 577| mu577_6(char) = Store : &:r577_4, r577_5 +# 577| r577_7(int) = Constant[1] : +# 577| r577_8(glval) = PointerAdd[1] : r577_1, r577_7 +# 577| r577_9(char) = Constant[0] : +# 577| mu577_10(char) = Store : &:r577_8, r577_9 +# 578| r578_1(glval) = VariableAddress[e] : +# 578| mu578_2(char[2]) = Uninitialized[e] : &:r578_1 +# 578| r578_3(int) = Constant[0] : +# 578| r578_4(glval) = PointerAdd[1] : r578_1, r578_3 +# 578| r578_5(char) = Constant[0] : +# 578| mu578_6(char) = Store : &:r578_4, r578_5 +# 578| r578_7(int) = Constant[1] : +# 578| r578_8(glval) = PointerAdd[1] : r578_1, r578_7 +# 578| r578_9(char) = Constant[1] : +# 578| mu578_10(char) = Store : &:r578_8, r578_9 +# 579| r579_1(glval) = VariableAddress[f] : +# 579| mu579_2(char[3]) = Uninitialized[f] : &:r579_1 +# 579| r579_3(int) = Constant[0] : +# 579| r579_4(glval) = PointerAdd[1] : r579_1, r579_3 +# 579| r579_5(char) = Constant[0] : +# 579| mu579_6(char) = Store : &:r579_4, r579_5 +# 579| r579_7(int) = Constant[1] : +# 579| r579_8(glval) = PointerAdd[1] : r579_1, r579_7 +# 579| r579_9(unknown[2]) = Constant[0] : +# 579| mu579_10(unknown[2]) = Store : &:r579_8, r579_9 +# 580| v580_1(void) = NoOp : +# 571| v571_4(void) = ReturnVoid : +# 571| v571_5(void) = UnmodeledUse : mu* +# 571| v571_6(void) = AliasedUse : ~mu571_3 +# 571| v571_7(void) = ExitFunction : # 584| void VarArgs() # 584| Block 0 -# 584| v0_0(void) = EnterFunction : -# 584| mu0_1(unknown) = AliasedDefinition : -# 584| mu0_2(unknown) = UnmodeledDefinition : -# 585| r0_3(glval) = FunctionAddress[VarArgFunction] : -# 585| r0_4(glval) = StringConstant["%d %s"] : -# 585| r0_5(char *) = Convert : r0_4 -# 585| r0_6(int) = Constant[1] : -# 585| r0_7(glval) = StringConstant["string"] : -# 585| r0_8(char *) = Convert : r0_7 -# 585| v0_9(void) = Call : func:r0_3, 0:r0_5, 1:r0_6, 2:r0_8 -# 585| mu0_10(unknown) = ^CallSideEffect : ~mu0_2 -# 585| v0_11(void) = ^BufferReadSideEffect[0] : &:r0_5, ~mu0_2 -# 585| v0_12(void) = ^BufferReadSideEffect[2] : &:r0_8, ~mu0_2 -# 585| mu0_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_5 -# 585| mu0_14(unknown) = ^BufferMayWriteSideEffect[2] : &:r0_8 -# 586| v0_15(void) = NoOp : -# 584| v0_16(void) = ReturnVoid : -# 584| v0_17(void) = UnmodeledUse : mu* -# 584| v0_18(void) = AliasedUse : ~mu0_2 -# 584| v0_19(void) = ExitFunction : +# 584| v584_1(void) = EnterFunction : +# 584| mu584_2(unknown) = AliasedDefinition : +# 584| mu584_3(unknown) = UnmodeledDefinition : +# 585| r585_1(glval) = FunctionAddress[VarArgFunction] : +# 585| r585_2(glval) = StringConstant["%d %s"] : +# 585| r585_3(char *) = Convert : r585_2 +# 585| r585_4(int) = Constant[1] : +# 585| r585_5(glval) = StringConstant["string"] : +# 585| r585_6(char *) = Convert : r585_5 +# 585| v585_7(void) = Call : func:r585_1, 0:r585_3, 1:r585_4, 2:r585_6 +# 585| mu585_8(unknown) = ^CallSideEffect : ~mu584_3 +# 585| v585_9(void) = ^BufferReadSideEffect[0] : &:r585_3, ~mu584_3 +# 585| v585_10(void) = ^BufferReadSideEffect[2] : &:r585_6, ~mu584_3 +# 585| mu585_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r585_3 +# 585| mu585_12(unknown) = ^BufferMayWriteSideEffect[2] : &:r585_6 +# 586| v586_1(void) = NoOp : +# 584| v584_4(void) = ReturnVoid : +# 584| v584_5(void) = UnmodeledUse : mu* +# 584| v584_6(void) = AliasedUse : ~mu584_3 +# 584| v584_7(void) = ExitFunction : # 590| void SetFuncPtr() # 590| Block 0 -# 590| v0_0(void) = EnterFunction : -# 590| mu0_1(unknown) = AliasedDefinition : -# 590| mu0_2(unknown) = UnmodeledDefinition : -# 591| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r0_4(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 591| mu0_5(..(*)(..)) = Store : &:r0_3, r0_4 -# 592| r0_6(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r0_7(..(*)(..)) = CopyValue : r0_6 -# 592| r0_8(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| mu0_9(..(*)(..)) = Store : &:r0_8, r0_7 -# 593| r0_10(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 593| r0_11(..(*)(..)) = CopyValue : r0_10 -# 593| r0_12(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| mu0_13(..(*)(..)) = Store : &:r0_12, r0_11 -# 594| r0_14(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r0_15(..(*)(..)) = CopyValue : r0_14 -# 594| r0_16(..(*)(..)) = CopyValue : r0_15 -# 594| r0_17(..(*)(..)) = CopyValue : r0_16 -# 594| r0_18(..(*)(..)) = CopyValue : r0_17 -# 594| r0_19(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| mu0_20(..(*)(..)) = Store : &:r0_19, r0_18 -# 595| v0_21(void) = NoOp : -# 590| v0_22(void) = ReturnVoid : -# 590| v0_23(void) = UnmodeledUse : mu* -# 590| v0_24(void) = AliasedUse : ~mu0_2 -# 590| v0_25(void) = ExitFunction : +# 590| v590_1(void) = EnterFunction : +# 590| mu590_2(unknown) = AliasedDefinition : +# 590| mu590_3(unknown) = UnmodeledDefinition : +# 591| r591_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r591_2(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 591| mu591_3(..(*)(..)) = Store : &:r591_1, r591_2 +# 592| r592_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r592_2(..(*)(..)) = CopyValue : r592_1 +# 592| r592_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| mu592_4(..(*)(..)) = Store : &:r592_3, r592_2 +# 593| r593_1(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 593| r593_2(..(*)(..)) = CopyValue : r593_1 +# 593| r593_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| mu593_4(..(*)(..)) = Store : &:r593_3, r593_2 +# 594| r594_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r594_2(..(*)(..)) = CopyValue : r594_1 +# 594| r594_3(..(*)(..)) = CopyValue : r594_2 +# 594| r594_4(..(*)(..)) = CopyValue : r594_3 +# 594| r594_5(..(*)(..)) = CopyValue : r594_4 +# 594| r594_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| mu594_7(..(*)(..)) = Store : &:r594_6, r594_5 +# 595| v595_1(void) = NoOp : +# 590| v590_4(void) = ReturnVoid : +# 590| v590_5(void) = UnmodeledUse : mu* +# 590| v590_6(void) = AliasedUse : ~mu590_3 +# 590| v590_7(void) = ExitFunction : # 615| void DeclareObject() # 615| Block 0 -# 615| v0_0(void) = EnterFunction : -# 615| mu0_1(unknown) = AliasedDefinition : -# 615| mu0_2(unknown) = UnmodeledDefinition : -# 616| r0_3(glval) = VariableAddress[s1] : -# 616| mu0_4(String) = Uninitialized[s1] : &:r0_3 -# 616| r0_5(glval) = FunctionAddress[String] : -# 616| v0_6(void) = Call : func:r0_5, this:r0_3 -# 616| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 616| mu0_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 617| r0_9(glval) = VariableAddress[s2] : -# 617| mu0_10(String) = Uninitialized[s2] : &:r0_9 -# 617| r0_11(glval) = FunctionAddress[String] : -# 617| r0_12(glval) = StringConstant["hello"] : -# 617| r0_13(char *) = Convert : r0_12 -# 617| v0_14(void) = Call : func:r0_11, this:r0_9, 0:r0_13 -# 617| mu0_15(unknown) = ^CallSideEffect : ~mu0_2 -# 617| mu0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 617| v0_17(void) = ^BufferReadSideEffect[0] : &:r0_13, ~mu0_2 -# 617| mu0_18(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 -# 618| r0_19(glval) = VariableAddress[s3] : -# 618| r0_20(glval) = FunctionAddress[ReturnObject] : -# 618| r0_21(String) = Call : func:r0_20 -# 618| mu0_22(unknown) = ^CallSideEffect : ~mu0_2 -# 618| mu0_23(String) = Store : &:r0_19, r0_21 -# 619| r0_24(glval) = VariableAddress[s4] : -# 619| mu0_25(String) = Uninitialized[s4] : &:r0_24 -# 619| r0_26(glval) = FunctionAddress[String] : -# 619| r0_27(glval) = StringConstant["test"] : -# 619| r0_28(char *) = Convert : r0_27 -# 619| v0_29(void) = Call : func:r0_26, this:r0_24, 0:r0_28 -# 619| mu0_30(unknown) = ^CallSideEffect : ~mu0_2 -# 619| mu0_31(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 -# 619| v0_32(void) = ^BufferReadSideEffect[0] : &:r0_28, ~mu0_2 -# 619| mu0_33(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_28 -# 620| v0_34(void) = NoOp : -# 615| v0_35(void) = ReturnVoid : -# 615| v0_36(void) = UnmodeledUse : mu* -# 615| v0_37(void) = AliasedUse : ~mu0_2 -# 615| v0_38(void) = ExitFunction : +# 615| v615_1(void) = EnterFunction : +# 615| mu615_2(unknown) = AliasedDefinition : +# 615| mu615_3(unknown) = UnmodeledDefinition : +# 616| r616_1(glval) = VariableAddress[s1] : +# 616| mu616_2(String) = Uninitialized[s1] : &:r616_1 +# 616| r616_3(glval) = FunctionAddress[String] : +# 616| v616_4(void) = Call : func:r616_3, this:r616_1 +# 616| mu616_5(unknown) = ^CallSideEffect : ~mu615_3 +# 616| mu616_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r616_1 +# 617| r617_1(glval) = VariableAddress[s2] : +# 617| mu617_2(String) = Uninitialized[s2] : &:r617_1 +# 617| r617_3(glval) = FunctionAddress[String] : +# 617| r617_4(glval) = StringConstant["hello"] : +# 617| r617_5(char *) = Convert : r617_4 +# 617| v617_6(void) = Call : func:r617_3, this:r617_1, 0:r617_5 +# 617| mu617_7(unknown) = ^CallSideEffect : ~mu615_3 +# 617| mu617_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r617_1 +# 617| v617_9(void) = ^BufferReadSideEffect[0] : &:r617_5, ~mu615_3 +# 617| mu617_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r617_5 +# 618| r618_1(glval) = VariableAddress[s3] : +# 618| r618_2(glval) = FunctionAddress[ReturnObject] : +# 618| r618_3(String) = Call : func:r618_2 +# 618| mu618_4(unknown) = ^CallSideEffect : ~mu615_3 +# 618| mu618_5(String) = Store : &:r618_1, r618_3 +# 619| r619_1(glval) = VariableAddress[s4] : +# 619| mu619_2(String) = Uninitialized[s4] : &:r619_1 +# 619| r619_3(glval) = FunctionAddress[String] : +# 619| r619_4(glval) = StringConstant["test"] : +# 619| r619_5(char *) = Convert : r619_4 +# 619| v619_6(void) = Call : func:r619_3, this:r619_1, 0:r619_5 +# 619| mu619_7(unknown) = ^CallSideEffect : ~mu615_3 +# 619| mu619_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r619_1 +# 619| v619_9(void) = ^BufferReadSideEffect[0] : &:r619_5, ~mu615_3 +# 619| mu619_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r619_5 +# 620| v620_1(void) = NoOp : +# 615| v615_4(void) = ReturnVoid : +# 615| v615_5(void) = UnmodeledUse : mu* +# 615| v615_6(void) = AliasedUse : ~mu615_3 +# 615| v615_7(void) = ExitFunction : # 622| void CallMethods(String&, String*, String) # 622| Block 0 -# 622| v0_0(void) = EnterFunction : -# 622| mu0_1(unknown) = AliasedDefinition : -# 622| mu0_2(unknown) = UnmodeledDefinition : -# 622| r0_3(glval) = VariableAddress[r] : -# 622| mu0_4(String &) = InitializeParameter[r] : &:r0_3 -# 622| r0_5(glval) = VariableAddress[p] : -# 622| mu0_6(String *) = InitializeParameter[p] : &:r0_5 -# 622| r0_7(glval) = VariableAddress[s] : -# 622| mu0_8(String) = InitializeParameter[s] : &:r0_7 -# 623| r0_9(glval) = VariableAddress[r] : -# 623| r0_10(String &) = Load : &:r0_9, ~mu0_2 -# 623| r0_11(glval) = CopyValue : r0_10 -# 623| r0_12(glval) = Convert : r0_11 -# 623| r0_13(glval) = FunctionAddress[c_str] : -# 623| r0_14(char *) = Call : func:r0_13, this:r0_12 -# 623| mu0_15(unknown) = ^CallSideEffect : ~mu0_2 -# 623| v0_16(void) = ^BufferReadSideEffect[-1] : &:r0_12, ~mu0_2 -# 623| mu0_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_12 -# 624| r0_18(glval) = VariableAddress[p] : -# 624| r0_19(String *) = Load : &:r0_18, ~mu0_2 -# 624| r0_20(String *) = Convert : r0_19 -# 624| r0_21(glval) = FunctionAddress[c_str] : -# 624| r0_22(char *) = Call : func:r0_21, this:r0_20 -# 624| mu0_23(unknown) = ^CallSideEffect : ~mu0_2 -# 624| v0_24(void) = ^BufferReadSideEffect[-1] : &:r0_20, ~mu0_2 -# 624| mu0_25(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_20 -# 625| r0_26(glval) = VariableAddress[s] : -# 625| r0_27(glval) = Convert : r0_26 -# 625| r0_28(glval) = FunctionAddress[c_str] : -# 625| r0_29(char *) = Call : func:r0_28, this:r0_27 -# 625| mu0_30(unknown) = ^CallSideEffect : ~mu0_2 -# 625| v0_31(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~mu0_2 -# 625| mu0_32(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 -# 626| v0_33(void) = NoOp : -# 622| v0_34(void) = ReturnVoid : -# 622| v0_35(void) = UnmodeledUse : mu* -# 622| v0_36(void) = AliasedUse : ~mu0_2 -# 622| v0_37(void) = ExitFunction : +# 622| v622_1(void) = EnterFunction : +# 622| mu622_2(unknown) = AliasedDefinition : +# 622| mu622_3(unknown) = UnmodeledDefinition : +# 622| r622_4(glval) = VariableAddress[r] : +# 622| mu622_5(String &) = InitializeParameter[r] : &:r622_4 +# 622| r622_6(glval) = VariableAddress[p] : +# 622| mu622_7(String *) = InitializeParameter[p] : &:r622_6 +# 622| r622_8(glval) = VariableAddress[s] : +# 622| mu622_9(String) = InitializeParameter[s] : &:r622_8 +# 623| r623_1(glval) = VariableAddress[r] : +# 623| r623_2(String &) = Load : &:r623_1, ~mu622_3 +# 623| r623_3(glval) = CopyValue : r623_2 +# 623| r623_4(glval) = Convert : r623_3 +# 623| r623_5(glval) = FunctionAddress[c_str] : +# 623| r623_6(char *) = Call : func:r623_5, this:r623_4 +# 623| mu623_7(unknown) = ^CallSideEffect : ~mu622_3 +# 623| v623_8(void) = ^BufferReadSideEffect[-1] : &:r623_4, ~mu622_3 +# 623| mu623_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r623_4 +# 624| r624_1(glval) = VariableAddress[p] : +# 624| r624_2(String *) = Load : &:r624_1, ~mu622_3 +# 624| r624_3(String *) = Convert : r624_2 +# 624| r624_4(glval) = FunctionAddress[c_str] : +# 624| r624_5(char *) = Call : func:r624_4, this:r624_3 +# 624| mu624_6(unknown) = ^CallSideEffect : ~mu622_3 +# 624| v624_7(void) = ^BufferReadSideEffect[-1] : &:r624_3, ~mu622_3 +# 624| mu624_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r624_3 +# 625| r625_1(glval) = VariableAddress[s] : +# 625| r625_2(glval) = Convert : r625_1 +# 625| r625_3(glval) = FunctionAddress[c_str] : +# 625| r625_4(char *) = Call : func:r625_3, this:r625_2 +# 625| mu625_5(unknown) = ^CallSideEffect : ~mu622_3 +# 625| v625_6(void) = ^BufferReadSideEffect[-1] : &:r625_2, ~mu622_3 +# 625| mu625_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r625_2 +# 626| v626_1(void) = NoOp : +# 622| v622_10(void) = ReturnVoid : +# 622| v622_11(void) = UnmodeledUse : mu* +# 622| v622_12(void) = AliasedUse : ~mu622_3 +# 622| v622_13(void) = ExitFunction : # 630| int C::StaticMemberFunction(int) # 630| Block 0 -# 630| v0_0(void) = EnterFunction : -# 630| mu0_1(unknown) = AliasedDefinition : -# 630| mu0_2(unknown) = UnmodeledDefinition : -# 630| r0_3(glval) = VariableAddress[x] : -# 630| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 631| r0_5(glval) = VariableAddress[#return] : -# 631| r0_6(glval) = VariableAddress[x] : -# 631| r0_7(int) = Load : &:r0_6, ~mu0_2 -# 631| mu0_8(int) = Store : &:r0_5, r0_7 -# 630| r0_9(glval) = VariableAddress[#return] : -# 630| v0_10(void) = ReturnValue : &:r0_9, ~mu0_2 -# 630| v0_11(void) = UnmodeledUse : mu* -# 630| v0_12(void) = AliasedUse : ~mu0_2 -# 630| v0_13(void) = ExitFunction : +# 630| v630_1(void) = EnterFunction : +# 630| mu630_2(unknown) = AliasedDefinition : +# 630| mu630_3(unknown) = UnmodeledDefinition : +# 630| r630_4(glval) = VariableAddress[x] : +# 630| mu630_5(int) = InitializeParameter[x] : &:r630_4 +# 631| r631_1(glval) = VariableAddress[#return] : +# 631| r631_2(glval) = VariableAddress[x] : +# 631| r631_3(int) = Load : &:r631_2, ~mu630_3 +# 631| mu631_4(int) = Store : &:r631_1, r631_3 +# 630| r630_6(glval) = VariableAddress[#return] : +# 630| v630_7(void) = ReturnValue : &:r630_6, ~mu630_3 +# 630| v630_8(void) = UnmodeledUse : mu* +# 630| v630_9(void) = AliasedUse : ~mu630_3 +# 630| v630_10(void) = ExitFunction : # 634| int C::InstanceMemberFunction(int) # 634| Block 0 -# 634| v0_0(void) = EnterFunction : -# 634| mu0_1(unknown) = AliasedDefinition : -# 634| mu0_2(unknown) = UnmodeledDefinition : -# 634| r0_3(glval) = InitializeThis : -# 634| r0_4(glval) = VariableAddress[x] : -# 634| mu0_5(int) = InitializeParameter[x] : &:r0_4 -# 635| r0_6(glval) = VariableAddress[#return] : -# 635| r0_7(glval) = VariableAddress[x] : -# 635| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 635| mu0_9(int) = Store : &:r0_6, r0_8 -# 634| r0_10(glval) = VariableAddress[#return] : -# 634| v0_11(void) = ReturnValue : &:r0_10, ~mu0_2 -# 634| v0_12(void) = UnmodeledUse : mu* -# 634| v0_13(void) = AliasedUse : ~mu0_2 -# 634| v0_14(void) = ExitFunction : +# 634| v634_1(void) = EnterFunction : +# 634| mu634_2(unknown) = AliasedDefinition : +# 634| mu634_3(unknown) = UnmodeledDefinition : +# 634| r634_4(glval) = InitializeThis : +# 634| r634_5(glval) = VariableAddress[x] : +# 634| mu634_6(int) = InitializeParameter[x] : &:r634_5 +# 635| r635_1(glval) = VariableAddress[#return] : +# 635| r635_2(glval) = VariableAddress[x] : +# 635| r635_3(int) = Load : &:r635_2, ~mu634_3 +# 635| mu635_4(int) = Store : &:r635_1, r635_3 +# 634| r634_7(glval) = VariableAddress[#return] : +# 634| v634_8(void) = ReturnValue : &:r634_7, ~mu634_3 +# 634| v634_9(void) = UnmodeledUse : mu* +# 634| v634_10(void) = AliasedUse : ~mu634_3 +# 634| v634_11(void) = ExitFunction : # 638| int C::VirtualMemberFunction(int) # 638| Block 0 -# 638| v0_0(void) = EnterFunction : -# 638| mu0_1(unknown) = AliasedDefinition : -# 638| mu0_2(unknown) = UnmodeledDefinition : -# 638| r0_3(glval) = InitializeThis : -# 638| r0_4(glval) = VariableAddress[x] : -# 638| mu0_5(int) = InitializeParameter[x] : &:r0_4 -# 639| r0_6(glval) = VariableAddress[#return] : -# 639| r0_7(glval) = VariableAddress[x] : -# 639| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 639| mu0_9(int) = Store : &:r0_6, r0_8 -# 638| r0_10(glval) = VariableAddress[#return] : -# 638| v0_11(void) = ReturnValue : &:r0_10, ~mu0_2 -# 638| v0_12(void) = UnmodeledUse : mu* -# 638| v0_13(void) = AliasedUse : ~mu0_2 -# 638| v0_14(void) = ExitFunction : +# 638| v638_1(void) = EnterFunction : +# 638| mu638_2(unknown) = AliasedDefinition : +# 638| mu638_3(unknown) = UnmodeledDefinition : +# 638| r638_4(glval) = InitializeThis : +# 638| r638_5(glval) = VariableAddress[x] : +# 638| mu638_6(int) = InitializeParameter[x] : &:r638_5 +# 639| r639_1(glval) = VariableAddress[#return] : +# 639| r639_2(glval) = VariableAddress[x] : +# 639| r639_3(int) = Load : &:r639_2, ~mu638_3 +# 639| mu639_4(int) = Store : &:r639_1, r639_3 +# 638| r638_7(glval) = VariableAddress[#return] : +# 638| v638_8(void) = ReturnValue : &:r638_7, ~mu638_3 +# 638| v638_9(void) = UnmodeledUse : mu* +# 638| v638_10(void) = AliasedUse : ~mu638_3 +# 638| v638_11(void) = ExitFunction : # 642| void C::FieldAccess() # 642| Block 0 -# 642| v0_0(void) = EnterFunction : -# 642| mu0_1(unknown) = AliasedDefinition : -# 642| mu0_2(unknown) = UnmodeledDefinition : -# 642| r0_3(glval) = InitializeThis : -# 643| r0_4(int) = Constant[0] : -# 643| r0_5(C *) = CopyValue : r0_3 -# 643| r0_6(glval) = FieldAddress[m_a] : r0_5 -# 643| mu0_7(int) = Store : &:r0_6, r0_4 -# 644| r0_8(int) = Constant[1] : -# 644| r0_9(C *) = CopyValue : r0_3 -# 644| r0_10(glval) = CopyValue : r0_9 -# 644| r0_11(glval) = FieldAddress[m_a] : r0_10 -# 644| mu0_12(int) = Store : &:r0_11, r0_8 -# 645| r0_13(int) = Constant[2] : -#-----| r0_14(C *) = CopyValue : r0_3 -# 645| r0_15(glval) = FieldAddress[m_a] : r0_14 -# 645| mu0_16(int) = Store : &:r0_15, r0_13 -# 646| r0_17(glval) = VariableAddress[x] : -# 646| mu0_18(int) = Uninitialized[x] : &:r0_17 -# 647| r0_19(C *) = CopyValue : r0_3 -# 647| r0_20(glval) = FieldAddress[m_a] : r0_19 -# 647| r0_21(int) = Load : &:r0_20, ~mu0_2 -# 647| r0_22(glval) = VariableAddress[x] : -# 647| mu0_23(int) = Store : &:r0_22, r0_21 -# 648| r0_24(C *) = CopyValue : r0_3 -# 648| r0_25(glval) = CopyValue : r0_24 -# 648| r0_26(glval) = FieldAddress[m_a] : r0_25 -# 648| r0_27(int) = Load : &:r0_26, ~mu0_2 -# 648| r0_28(glval) = VariableAddress[x] : -# 648| mu0_29(int) = Store : &:r0_28, r0_27 -#-----| r0_30(C *) = CopyValue : r0_3 -# 649| r0_31(glval) = FieldAddress[m_a] : r0_30 -# 649| r0_32(int) = Load : &:r0_31, ~mu0_2 -# 649| r0_33(glval) = VariableAddress[x] : -# 649| mu0_34(int) = Store : &:r0_33, r0_32 -# 650| v0_35(void) = NoOp : -# 642| v0_36(void) = ReturnVoid : -# 642| v0_37(void) = UnmodeledUse : mu* -# 642| v0_38(void) = AliasedUse : ~mu0_2 -# 642| v0_39(void) = ExitFunction : +# 642| v642_1(void) = EnterFunction : +# 642| mu642_2(unknown) = AliasedDefinition : +# 642| mu642_3(unknown) = UnmodeledDefinition : +# 642| r642_4(glval) = InitializeThis : +# 643| r643_1(int) = Constant[0] : +# 643| r643_2(C *) = CopyValue : r642_4 +# 643| r643_3(glval) = FieldAddress[m_a] : r643_2 +# 643| mu643_4(int) = Store : &:r643_3, r643_1 +# 644| r644_1(int) = Constant[1] : +# 644| r644_2(C *) = CopyValue : r642_4 +# 644| r644_3(glval) = CopyValue : r644_2 +# 644| r644_4(glval) = FieldAddress[m_a] : r644_3 +# 644| mu644_5(int) = Store : &:r644_4, r644_1 +# 645| r645_1(int) = Constant[2] : +#-----| r0_62(C *) = CopyValue : r642_4 +# 645| r645_2(glval) = FieldAddress[m_a] : r0_62 +# 645| mu645_3(int) = Store : &:r645_2, r645_1 +# 646| r646_1(glval) = VariableAddress[x] : +# 646| mu646_2(int) = Uninitialized[x] : &:r646_1 +# 647| r647_1(C *) = CopyValue : r642_4 +# 647| r647_2(glval) = FieldAddress[m_a] : r647_1 +# 647| r647_3(int) = Load : &:r647_2, ~mu642_3 +# 647| r647_4(glval) = VariableAddress[x] : +# 647| mu647_5(int) = Store : &:r647_4, r647_3 +# 648| r648_1(C *) = CopyValue : r642_4 +# 648| r648_2(glval) = CopyValue : r648_1 +# 648| r648_3(glval) = FieldAddress[m_a] : r648_2 +# 648| r648_4(int) = Load : &:r648_3, ~mu642_3 +# 648| r648_5(glval) = VariableAddress[x] : +# 648| mu648_6(int) = Store : &:r648_5, r648_4 +#-----| r0_130(C *) = CopyValue : r642_4 +# 649| r649_1(glval) = FieldAddress[m_a] : r0_130 +# 649| r649_2(int) = Load : &:r649_1, ~mu642_3 +# 649| r649_3(glval) = VariableAddress[x] : +# 649| mu649_4(int) = Store : &:r649_3, r649_2 +# 650| v650_1(void) = NoOp : +# 642| v642_5(void) = ReturnVoid : +# 642| v642_6(void) = UnmodeledUse : mu* +# 642| v642_7(void) = AliasedUse : ~mu642_3 +# 642| v642_8(void) = ExitFunction : # 652| void C::MethodCalls() # 652| Block 0 -# 652| v0_0(void) = EnterFunction : -# 652| mu0_1(unknown) = AliasedDefinition : -# 652| mu0_2(unknown) = UnmodeledDefinition : -# 652| r0_3(glval) = InitializeThis : -# 653| r0_4(C *) = CopyValue : r0_3 -# 653| r0_5(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r0_6(int) = Constant[0] : -# 653| r0_7(int) = Call : func:r0_5, this:r0_4, 0:r0_6 -# 653| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 653| v0_9(void) = ^BufferReadSideEffect[-1] : &:r0_4, ~mu0_2 -# 653| mu0_10(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 654| r0_11(C *) = CopyValue : r0_3 -# 654| r0_12(glval) = CopyValue : r0_11 -# 654| r0_13(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r0_14(int) = Constant[1] : -# 654| r0_15(int) = Call : func:r0_13, this:r0_12, 0:r0_14 -# 654| mu0_16(unknown) = ^CallSideEffect : ~mu0_2 -# 654| v0_17(void) = ^BufferReadSideEffect[-1] : &:r0_12, ~mu0_2 -# 654| mu0_18(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_12 -#-----| r0_19(C *) = CopyValue : r0_3 -# 655| r0_20(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r0_21(int) = Constant[2] : -# 655| r0_22(int) = Call : func:r0_20, this:r0_19, 0:r0_21 -# 655| mu0_23(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_24(void) = ^BufferReadSideEffect[-1] : &:r0_19, ~mu0_2 -#-----| mu0_25(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_19 -# 656| v0_26(void) = NoOp : -# 652| v0_27(void) = ReturnVoid : -# 652| v0_28(void) = UnmodeledUse : mu* -# 652| v0_29(void) = AliasedUse : ~mu0_2 -# 652| v0_30(void) = ExitFunction : +# 652| v652_1(void) = EnterFunction : +# 652| mu652_2(unknown) = AliasedDefinition : +# 652| mu652_3(unknown) = UnmodeledDefinition : +# 652| r652_4(glval) = InitializeThis : +# 653| r653_1(C *) = CopyValue : r652_4 +# 653| r653_2(glval) = FunctionAddress[InstanceMemberFunction] : +# 653| r653_3(int) = Constant[0] : +# 653| r653_4(int) = Call : func:r653_2, this:r653_1, 0:r653_3 +# 653| mu653_5(unknown) = ^CallSideEffect : ~mu652_3 +# 653| v653_6(void) = ^BufferReadSideEffect[-1] : &:r653_1, ~mu652_3 +# 653| mu653_7(C) = ^IndirectMayWriteSideEffect[-1] : &:r653_1 +# 654| r654_1(C *) = CopyValue : r652_4 +# 654| r654_2(glval) = CopyValue : r654_1 +# 654| r654_3(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r654_4(int) = Constant[1] : +# 654| r654_5(int) = Call : func:r654_3, this:r654_2, 0:r654_4 +# 654| mu654_6(unknown) = ^CallSideEffect : ~mu652_3 +# 654| v654_7(void) = ^BufferReadSideEffect[-1] : &:r654_2, ~mu652_3 +# 654| mu654_8(C) = ^IndirectMayWriteSideEffect[-1] : &:r654_2 +#-----| r0_88(C *) = CopyValue : r652_4 +# 655| r655_1(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r655_2(int) = Constant[2] : +# 655| r655_3(int) = Call : func:r655_1, this:r0_88, 0:r655_2 +# 655| mu655_4(unknown) = ^CallSideEffect : ~mu652_3 +#-----| v0_110(void) = ^BufferReadSideEffect[-1] : &:r0_88, ~mu652_3 +#-----| mu0_116(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_88 +# 656| v656_1(void) = NoOp : +# 652| v652_5(void) = ReturnVoid : +# 652| v652_6(void) = UnmodeledUse : mu* +# 652| v652_7(void) = AliasedUse : ~mu652_3 +# 652| v652_8(void) = ExitFunction : # 658| void C::C() # 658| Block 0 -# 658| v0_0(void) = EnterFunction : -# 658| mu0_1(unknown) = AliasedDefinition : -# 658| mu0_2(unknown) = UnmodeledDefinition : -# 658| r0_3(glval) = InitializeThis : -# 659| r0_4(glval) = FieldAddress[m_a] : r0_3 -# 659| r0_5(int) = Constant[1] : -# 659| mu0_6(int) = Store : &:r0_4, r0_5 -# 663| r0_7(glval) = FieldAddress[m_b] : r0_3 -# 663| r0_8(glval) = FunctionAddress[String] : -# 663| v0_9(void) = Call : func:r0_8, this:r0_7 -# 663| mu0_10(unknown) = ^CallSideEffect : ~mu0_2 -# 663| mu0_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -# 660| r0_12(glval) = FieldAddress[m_c] : r0_3 -# 660| r0_13(char) = Constant[3] : -# 660| mu0_14(char) = Store : &:r0_12, r0_13 -# 661| r0_15(glval) = FieldAddress[m_e] : r0_3 -# 661| r0_16(void *) = Constant[0] : -# 661| mu0_17(void *) = Store : &:r0_15, r0_16 -# 662| r0_18(glval) = FieldAddress[m_f] : r0_3 -# 662| r0_19(glval) = FunctionAddress[String] : -# 662| r0_20(glval) = StringConstant["test"] : -# 662| r0_21(char *) = Convert : r0_20 -# 662| v0_22(void) = Call : func:r0_19, this:r0_18, 0:r0_21 -# 662| mu0_23(unknown) = ^CallSideEffect : ~mu0_2 -# 662| mu0_24(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_18 -# 662| v0_25(void) = ^BufferReadSideEffect[0] : &:r0_21, ~mu0_2 -# 662| mu0_26(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_21 -# 664| v0_27(void) = NoOp : -# 658| v0_28(void) = ReturnVoid : -# 658| v0_29(void) = UnmodeledUse : mu* -# 658| v0_30(void) = AliasedUse : ~mu0_2 -# 658| v0_31(void) = ExitFunction : +# 658| v658_1(void) = EnterFunction : +# 658| mu658_2(unknown) = AliasedDefinition : +# 658| mu658_3(unknown) = UnmodeledDefinition : +# 658| r658_4(glval) = InitializeThis : +# 659| r659_1(glval) = FieldAddress[m_a] : r658_4 +# 659| r659_2(int) = Constant[1] : +# 659| mu659_3(int) = Store : &:r659_1, r659_2 +# 663| r663_1(glval) = FieldAddress[m_b] : r658_4 +# 663| r663_2(glval) = FunctionAddress[String] : +# 663| v663_3(void) = Call : func:r663_2, this:r663_1 +# 663| mu663_4(unknown) = ^CallSideEffect : ~mu658_3 +# 663| mu663_5(String) = ^IndirectMayWriteSideEffect[-1] : &:r663_1 +# 660| r660_1(glval) = FieldAddress[m_c] : r658_4 +# 660| r660_2(char) = Constant[3] : +# 660| mu660_3(char) = Store : &:r660_1, r660_2 +# 661| r661_1(glval) = FieldAddress[m_e] : r658_4 +# 661| r661_2(void *) = Constant[0] : +# 661| mu661_3(void *) = Store : &:r661_1, r661_2 +# 662| r662_1(glval) = FieldAddress[m_f] : r658_4 +# 662| r662_2(glval) = FunctionAddress[String] : +# 662| r662_3(glval) = StringConstant["test"] : +# 662| r662_4(char *) = Convert : r662_3 +# 662| v662_5(void) = Call : func:r662_2, this:r662_1, 0:r662_4 +# 662| mu662_6(unknown) = ^CallSideEffect : ~mu658_3 +# 662| mu662_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r662_1 +# 662| v662_8(void) = ^BufferReadSideEffect[0] : &:r662_4, ~mu658_3 +# 662| mu662_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r662_4 +# 664| v664_1(void) = NoOp : +# 658| v658_5(void) = ReturnVoid : +# 658| v658_6(void) = UnmodeledUse : mu* +# 658| v658_7(void) = AliasedUse : ~mu658_3 +# 658| v658_8(void) = ExitFunction : # 675| int DerefReference(int&) # 675| Block 0 -# 675| v0_0(void) = EnterFunction : -# 675| mu0_1(unknown) = AliasedDefinition : -# 675| mu0_2(unknown) = UnmodeledDefinition : -# 675| r0_3(glval) = VariableAddress[r] : -# 675| mu0_4(int &) = InitializeParameter[r] : &:r0_3 -# 676| r0_5(glval) = VariableAddress[#return] : -# 676| r0_6(glval) = VariableAddress[r] : -# 676| r0_7(int &) = Load : &:r0_6, ~mu0_2 -# 676| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 676| mu0_9(int) = Store : &:r0_5, r0_8 -# 675| r0_10(glval) = VariableAddress[#return] : -# 675| v0_11(void) = ReturnValue : &:r0_10, ~mu0_2 -# 675| v0_12(void) = UnmodeledUse : mu* -# 675| v0_13(void) = AliasedUse : ~mu0_2 -# 675| v0_14(void) = ExitFunction : +# 675| v675_1(void) = EnterFunction : +# 675| mu675_2(unknown) = AliasedDefinition : +# 675| mu675_3(unknown) = UnmodeledDefinition : +# 675| r675_4(glval) = VariableAddress[r] : +# 675| mu675_5(int &) = InitializeParameter[r] : &:r675_4 +# 676| r676_1(glval) = VariableAddress[#return] : +# 676| r676_2(glval) = VariableAddress[r] : +# 676| r676_3(int &) = Load : &:r676_2, ~mu675_3 +# 676| r676_4(int) = Load : &:r676_3, ~mu675_3 +# 676| mu676_5(int) = Store : &:r676_1, r676_4 +# 675| r675_6(glval) = VariableAddress[#return] : +# 675| v675_7(void) = ReturnValue : &:r675_6, ~mu675_3 +# 675| v675_8(void) = UnmodeledUse : mu* +# 675| v675_9(void) = AliasedUse : ~mu675_3 +# 675| v675_10(void) = ExitFunction : # 679| int& TakeReference() # 679| Block 0 -# 679| v0_0(void) = EnterFunction : -# 679| mu0_1(unknown) = AliasedDefinition : -# 679| mu0_2(unknown) = UnmodeledDefinition : -# 680| r0_3(glval) = VariableAddress[#return] : -# 680| r0_4(glval) = VariableAddress[g] : -# 680| r0_5(int &) = CopyValue : r0_4 -# 680| mu0_6(int &) = Store : &:r0_3, r0_5 -# 679| r0_7(glval) = VariableAddress[#return] : -# 679| v0_8(void) = ReturnValue : &:r0_7, ~mu0_2 -# 679| v0_9(void) = UnmodeledUse : mu* -# 679| v0_10(void) = AliasedUse : ~mu0_2 -# 679| v0_11(void) = ExitFunction : +# 679| v679_1(void) = EnterFunction : +# 679| mu679_2(unknown) = AliasedDefinition : +# 679| mu679_3(unknown) = UnmodeledDefinition : +# 680| r680_1(glval) = VariableAddress[#return] : +# 680| r680_2(glval) = VariableAddress[g] : +# 680| r680_3(int &) = CopyValue : r680_2 +# 680| mu680_4(int &) = Store : &:r680_1, r680_3 +# 679| r679_4(glval) = VariableAddress[#return] : +# 679| v679_5(void) = ReturnValue : &:r679_4, ~mu679_3 +# 679| v679_6(void) = UnmodeledUse : mu* +# 679| v679_7(void) = AliasedUse : ~mu679_3 +# 679| v679_8(void) = ExitFunction : # 685| void InitReference(int) # 685| Block 0 -# 685| v0_0(void) = EnterFunction : -# 685| mu0_1(unknown) = AliasedDefinition : -# 685| mu0_2(unknown) = UnmodeledDefinition : -# 685| r0_3(glval) = VariableAddress[x] : -# 685| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 686| r0_5(glval) = VariableAddress[r] : -# 686| r0_6(glval) = VariableAddress[x] : -# 686| r0_7(int &) = CopyValue : r0_6 -# 686| mu0_8(int &) = Store : &:r0_5, r0_7 -# 687| r0_9(glval) = VariableAddress[r2] : -# 687| r0_10(glval) = VariableAddress[r] : -# 687| r0_11(int &) = Load : &:r0_10, ~mu0_2 -# 687| r0_12(glval) = CopyValue : r0_11 -# 687| r0_13(int &) = CopyValue : r0_12 -# 687| mu0_14(int &) = Store : &:r0_9, r0_13 -# 688| r0_15(glval) = VariableAddress[r3] : -# 688| r0_16(glval) = FunctionAddress[ReturnReference] : -# 688| r0_17(String &) = Call : func:r0_16 -# 688| mu0_18(unknown) = ^CallSideEffect : ~mu0_2 -# 688| r0_19(glval) = CopyValue : r0_17 -# 688| r0_20(glval) = Convert : r0_19 -# 688| r0_21(String &) = CopyValue : r0_20 -# 688| mu0_22(String &) = Store : &:r0_15, r0_21 -# 689| v0_23(void) = NoOp : -# 685| v0_24(void) = ReturnVoid : -# 685| v0_25(void) = UnmodeledUse : mu* -# 685| v0_26(void) = AliasedUse : ~mu0_2 -# 685| v0_27(void) = ExitFunction : +# 685| v685_1(void) = EnterFunction : +# 685| mu685_2(unknown) = AliasedDefinition : +# 685| mu685_3(unknown) = UnmodeledDefinition : +# 685| r685_4(glval) = VariableAddress[x] : +# 685| mu685_5(int) = InitializeParameter[x] : &:r685_4 +# 686| r686_1(glval) = VariableAddress[r] : +# 686| r686_2(glval) = VariableAddress[x] : +# 686| r686_3(int &) = CopyValue : r686_2 +# 686| mu686_4(int &) = Store : &:r686_1, r686_3 +# 687| r687_1(glval) = VariableAddress[r2] : +# 687| r687_2(glval) = VariableAddress[r] : +# 687| r687_3(int &) = Load : &:r687_2, ~mu685_3 +# 687| r687_4(glval) = CopyValue : r687_3 +# 687| r687_5(int &) = CopyValue : r687_4 +# 687| mu687_6(int &) = Store : &:r687_1, r687_5 +# 688| r688_1(glval) = VariableAddress[r3] : +# 688| r688_2(glval) = FunctionAddress[ReturnReference] : +# 688| r688_3(String &) = Call : func:r688_2 +# 688| mu688_4(unknown) = ^CallSideEffect : ~mu685_3 +# 688| r688_5(glval) = CopyValue : r688_3 +# 688| r688_6(glval) = Convert : r688_5 +# 688| r688_7(String &) = CopyValue : r688_6 +# 688| mu688_8(String &) = Store : &:r688_1, r688_7 +# 689| v689_1(void) = NoOp : +# 685| v685_6(void) = ReturnVoid : +# 685| v685_7(void) = UnmodeledUse : mu* +# 685| v685_8(void) = AliasedUse : ~mu685_3 +# 685| v685_9(void) = ExitFunction : # 691| void ArrayReferences() # 691| Block 0 -# 691| v0_0(void) = EnterFunction : -# 691| mu0_1(unknown) = AliasedDefinition : -# 691| mu0_2(unknown) = UnmodeledDefinition : -# 692| r0_3(glval) = VariableAddress[a] : -# 692| mu0_4(int[10]) = Uninitialized[a] : &:r0_3 -# 693| r0_5(glval) = VariableAddress[ra] : -# 693| r0_6(glval) = VariableAddress[a] : -# 693| r0_7(int(&)[10]) = CopyValue : r0_6 -# 693| mu0_8(int(&)[10]) = Store : &:r0_5, r0_7 -# 694| r0_9(glval) = VariableAddress[x] : -# 694| r0_10(glval) = VariableAddress[ra] : -# 694| r0_11(int(&)[10]) = Load : &:r0_10, ~mu0_2 -# 694| r0_12(glval) = CopyValue : r0_11 -# 694| r0_13(int *) = Convert : r0_12 -# 694| r0_14(int) = Constant[5] : -# 694| r0_15(glval) = PointerAdd[4] : r0_13, r0_14 -# 694| r0_16(int) = Load : &:r0_15, ~mu0_2 -# 694| mu0_17(int) = Store : &:r0_9, r0_16 -# 695| v0_18(void) = NoOp : -# 691| v0_19(void) = ReturnVoid : -# 691| v0_20(void) = UnmodeledUse : mu* -# 691| v0_21(void) = AliasedUse : ~mu0_2 -# 691| v0_22(void) = ExitFunction : +# 691| v691_1(void) = EnterFunction : +# 691| mu691_2(unknown) = AliasedDefinition : +# 691| mu691_3(unknown) = UnmodeledDefinition : +# 692| r692_1(glval) = VariableAddress[a] : +# 692| mu692_2(int[10]) = Uninitialized[a] : &:r692_1 +# 693| r693_1(glval) = VariableAddress[ra] : +# 693| r693_2(glval) = VariableAddress[a] : +# 693| r693_3(int(&)[10]) = CopyValue : r693_2 +# 693| mu693_4(int(&)[10]) = Store : &:r693_1, r693_3 +# 694| r694_1(glval) = VariableAddress[x] : +# 694| r694_2(glval) = VariableAddress[ra] : +# 694| r694_3(int(&)[10]) = Load : &:r694_2, ~mu691_3 +# 694| r694_4(glval) = CopyValue : r694_3 +# 694| r694_5(int *) = Convert : r694_4 +# 694| r694_6(int) = Constant[5] : +# 694| r694_7(glval) = PointerAdd[4] : r694_5, r694_6 +# 694| r694_8(int) = Load : &:r694_7, ~mu691_3 +# 694| mu694_9(int) = Store : &:r694_1, r694_8 +# 695| v695_1(void) = NoOp : +# 691| v691_4(void) = ReturnVoid : +# 691| v691_5(void) = UnmodeledUse : mu* +# 691| v691_6(void) = AliasedUse : ~mu691_3 +# 691| v691_7(void) = ExitFunction : # 697| void FunctionReferences() # 697| Block 0 -# 697| v0_0(void) = EnterFunction : -# 697| mu0_1(unknown) = AliasedDefinition : -# 697| mu0_2(unknown) = UnmodeledDefinition : -# 698| r0_3(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r0_4(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| r0_5(..(&)(..)) = CopyValue : r0_4 -# 698| mu0_6(..(&)(..)) = Store : &:r0_3, r0_5 -# 699| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r0_8(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r0_9(..(&)(..)) = Load : &:r0_8, ~mu0_2 -# 699| r0_10(..(*)(..)) = CopyValue : r0_9 -# 699| mu0_11(..(*)(..)) = Store : &:r0_7, r0_10 -# 700| r0_12(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r0_13(..(&)(..)) = Load : &:r0_12, ~mu0_2 -# 700| r0_14(..(*)(..)) = CopyValue : r0_13 -# 700| r0_15(int) = Constant[5] : -# 700| r0_16(int) = Call : func:r0_14, 0:r0_15 -# 700| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 701| v0_18(void) = NoOp : -# 697| v0_19(void) = ReturnVoid : -# 697| v0_20(void) = UnmodeledUse : mu* -# 697| v0_21(void) = AliasedUse : ~mu0_2 -# 697| v0_22(void) = ExitFunction : +# 697| v697_1(void) = EnterFunction : +# 697| mu697_2(unknown) = AliasedDefinition : +# 697| mu697_3(unknown) = UnmodeledDefinition : +# 698| r698_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 698| r698_2(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 698| r698_3(..(&)(..)) = CopyValue : r698_2 +# 698| mu698_4(..(&)(..)) = Store : &:r698_1, r698_3 +# 699| r699_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r699_2(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r699_3(..(&)(..)) = Load : &:r699_2, ~mu697_3 +# 699| r699_4(..(*)(..)) = CopyValue : r699_3 +# 699| mu699_5(..(*)(..)) = Store : &:r699_1, r699_4 +# 700| r700_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r700_2(..(&)(..)) = Load : &:r700_1, ~mu697_3 +# 700| r700_3(..(*)(..)) = CopyValue : r700_2 +# 700| r700_4(int) = Constant[5] : +# 700| r700_5(int) = Call : func:r700_3, 0:r700_4 +# 700| mu700_6(unknown) = ^CallSideEffect : ~mu697_3 +# 701| v701_1(void) = NoOp : +# 697| v697_4(void) = ReturnVoid : +# 697| v697_5(void) = UnmodeledUse : mu* +# 697| v697_6(void) = AliasedUse : ~mu697_3 +# 697| v697_7(void) = ExitFunction : # 704| int min(int, int) # 704| Block 0 -# 704| v0_0(void) = EnterFunction : -# 704| mu0_1(unknown) = AliasedDefinition : -# 704| mu0_2(unknown) = UnmodeledDefinition : -# 704| r0_3(glval) = VariableAddress[x] : -# 704| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 704| r0_5(glval) = VariableAddress[y] : -# 704| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 705| r0_7(glval) = VariableAddress[#return] : -# 705| r0_8(glval) = VariableAddress[x] : -# 705| r0_9(int) = Load : &:r0_8, ~mu0_2 -# 705| r0_10(glval) = VariableAddress[y] : -# 705| r0_11(int) = Load : &:r0_10, ~mu0_2 -# 705| r0_12(bool) = CompareLT : r0_9, r0_11 -# 705| v0_13(void) = ConditionalBranch : r0_12 +# 704| v704_1(void) = EnterFunction : +# 704| mu704_2(unknown) = AliasedDefinition : +# 704| mu704_3(unknown) = UnmodeledDefinition : +# 704| r704_4(glval) = VariableAddress[x] : +# 704| mu704_5(int) = InitializeParameter[x] : &:r704_4 +# 704| r704_6(glval) = VariableAddress[y] : +# 704| mu704_7(int) = InitializeParameter[y] : &:r704_6 +# 705| r705_1(glval) = VariableAddress[#return] : +# 705| r705_2(glval) = VariableAddress[x] : +# 705| r705_3(int) = Load : &:r705_2, ~mu704_3 +# 705| r705_4(glval) = VariableAddress[y] : +# 705| r705_5(int) = Load : &:r705_4, ~mu704_3 +# 705| r705_6(bool) = CompareLT : r705_3, r705_5 +# 705| v705_7(void) = ConditionalBranch : r705_6 #-----| False -> Block 2 #-----| True -> Block 1 # 705| Block 1 -# 705| r1_0(glval) = VariableAddress[x] : -# 705| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 705| r1_2(glval) = VariableAddress[#temp705:10] : -# 705| mu1_3(int) = Store : &:r1_2, r1_1 +# 705| r705_8(glval) = VariableAddress[x] : +# 705| r705_9(int) = Load : &:r705_8, ~mu704_3 +# 705| r705_10(glval) = VariableAddress[#temp705:10] : +# 705| mu705_11(int) = Store : &:r705_10, r705_9 #-----| Goto -> Block 3 # 705| Block 2 -# 705| r2_0(glval) = VariableAddress[y] : -# 705| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 705| r2_2(glval) = VariableAddress[#temp705:10] : -# 705| mu2_3(int) = Store : &:r2_2, r2_1 +# 705| r705_12(glval) = VariableAddress[y] : +# 705| r705_13(int) = Load : &:r705_12, ~mu704_3 +# 705| r705_14(glval) = VariableAddress[#temp705:10] : +# 705| mu705_15(int) = Store : &:r705_14, r705_13 #-----| Goto -> Block 3 # 705| Block 3 -# 705| r3_0(glval) = VariableAddress[#temp705:10] : -# 705| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 705| mu3_2(int) = Store : &:r0_7, r3_1 -# 704| r3_3(glval) = VariableAddress[#return] : -# 704| v3_4(void) = ReturnValue : &:r3_3, ~mu0_2 -# 704| v3_5(void) = UnmodeledUse : mu* -# 704| v3_6(void) = AliasedUse : ~mu0_2 -# 704| v3_7(void) = ExitFunction : +# 705| r705_16(glval) = VariableAddress[#temp705:10] : +# 705| r705_17(int) = Load : &:r705_16, ~mu704_3 +# 705| mu705_18(int) = Store : &:r705_1, r705_17 +# 704| r704_8(glval) = VariableAddress[#return] : +# 704| v704_9(void) = ReturnValue : &:r704_8, ~mu704_3 +# 704| v704_10(void) = UnmodeledUse : mu* +# 704| v704_11(void) = AliasedUse : ~mu704_3 +# 704| v704_12(void) = ExitFunction : # 708| int CallMin(int, int) # 708| Block 0 -# 708| v0_0(void) = EnterFunction : -# 708| mu0_1(unknown) = AliasedDefinition : -# 708| mu0_2(unknown) = UnmodeledDefinition : -# 708| r0_3(glval) = VariableAddress[x] : -# 708| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 708| r0_5(glval) = VariableAddress[y] : -# 708| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 709| r0_7(glval) = VariableAddress[#return] : -# 709| r0_8(glval) = FunctionAddress[min] : -# 709| r0_9(glval) = VariableAddress[x] : -# 709| r0_10(int) = Load : &:r0_9, ~mu0_2 -# 709| r0_11(glval) = VariableAddress[y] : -# 709| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 709| r0_13(int) = Call : func:r0_8, 0:r0_10, 1:r0_12 -# 709| mu0_14(unknown) = ^CallSideEffect : ~mu0_2 -# 709| mu0_15(int) = Store : &:r0_7, r0_13 -# 708| r0_16(glval) = VariableAddress[#return] : -# 708| v0_17(void) = ReturnValue : &:r0_16, ~mu0_2 -# 708| v0_18(void) = UnmodeledUse : mu* -# 708| v0_19(void) = AliasedUse : ~mu0_2 -# 708| v0_20(void) = ExitFunction : +# 708| v708_1(void) = EnterFunction : +# 708| mu708_2(unknown) = AliasedDefinition : +# 708| mu708_3(unknown) = UnmodeledDefinition : +# 708| r708_4(glval) = VariableAddress[x] : +# 708| mu708_5(int) = InitializeParameter[x] : &:r708_4 +# 708| r708_6(glval) = VariableAddress[y] : +# 708| mu708_7(int) = InitializeParameter[y] : &:r708_6 +# 709| r709_1(glval) = VariableAddress[#return] : +# 709| r709_2(glval) = FunctionAddress[min] : +# 709| r709_3(glval) = VariableAddress[x] : +# 709| r709_4(int) = Load : &:r709_3, ~mu708_3 +# 709| r709_5(glval) = VariableAddress[y] : +# 709| r709_6(int) = Load : &:r709_5, ~mu708_3 +# 709| r709_7(int) = Call : func:r709_2, 0:r709_4, 1:r709_6 +# 709| mu709_8(unknown) = ^CallSideEffect : ~mu708_3 +# 709| mu709_9(int) = Store : &:r709_1, r709_7 +# 708| r708_8(glval) = VariableAddress[#return] : +# 708| v708_9(void) = ReturnValue : &:r708_8, ~mu708_3 +# 708| v708_10(void) = UnmodeledUse : mu* +# 708| v708_11(void) = AliasedUse : ~mu708_3 +# 708| v708_12(void) = ExitFunction : # 715| long Outer::Func(void*, char) # 715| Block 0 -# 715| v0_0(void) = EnterFunction : -# 715| mu0_1(unknown) = AliasedDefinition : -# 715| mu0_2(unknown) = UnmodeledDefinition : -# 715| r0_3(glval) = VariableAddress[x] : -# 715| mu0_4(void *) = InitializeParameter[x] : &:r0_3 -# 715| r0_5(glval) = VariableAddress[y] : -# 715| mu0_6(char) = InitializeParameter[y] : &:r0_5 -# 716| r0_7(glval) = VariableAddress[#return] : -# 716| r0_8(long) = Constant[0] : -# 716| mu0_9(long) = Store : &:r0_7, r0_8 -# 715| r0_10(glval) = VariableAddress[#return] : -# 715| v0_11(void) = ReturnValue : &:r0_10, ~mu0_2 -# 715| v0_12(void) = UnmodeledUse : mu* -# 715| v0_13(void) = AliasedUse : ~mu0_2 -# 715| v0_14(void) = ExitFunction : +# 715| v715_1(void) = EnterFunction : +# 715| mu715_2(unknown) = AliasedDefinition : +# 715| mu715_3(unknown) = UnmodeledDefinition : +# 715| r715_4(glval) = VariableAddress[x] : +# 715| mu715_5(void *) = InitializeParameter[x] : &:r715_4 +# 715| r715_6(glval) = VariableAddress[y] : +# 715| mu715_7(char) = InitializeParameter[y] : &:r715_6 +# 716| r716_1(glval) = VariableAddress[#return] : +# 716| r716_2(long) = Constant[0] : +# 716| mu716_3(long) = Store : &:r716_1, r716_2 +# 715| r715_8(glval) = VariableAddress[#return] : +# 715| v715_9(void) = ReturnValue : &:r715_8, ~mu715_3 +# 715| v715_10(void) = UnmodeledUse : mu* +# 715| v715_11(void) = AliasedUse : ~mu715_3 +# 715| v715_12(void) = ExitFunction : # 720| double CallNestedTemplateFunc() # 720| Block 0 -# 720| v0_0(void) = EnterFunction : -# 720| mu0_1(unknown) = AliasedDefinition : -# 720| mu0_2(unknown) = UnmodeledDefinition : -# 721| r0_3(glval) = VariableAddress[#return] : -# 721| r0_4(glval) = FunctionAddress[Func] : -# 721| r0_5(void *) = Constant[0] : -# 721| r0_6(char) = Constant[111] : -# 721| r0_7(long) = Call : func:r0_4, 0:r0_5, 1:r0_6 -# 721| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 721| v0_9(void) = ^BufferReadSideEffect[0] : &:r0_5, ~mu0_2 -# 721| mu0_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_5 -# 721| r0_11(double) = Convert : r0_7 -# 721| mu0_12(double) = Store : &:r0_3, r0_11 -# 720| r0_13(glval) = VariableAddress[#return] : -# 720| v0_14(void) = ReturnValue : &:r0_13, ~mu0_2 -# 720| v0_15(void) = UnmodeledUse : mu* -# 720| v0_16(void) = AliasedUse : ~mu0_2 -# 720| v0_17(void) = ExitFunction : +# 720| v720_1(void) = EnterFunction : +# 720| mu720_2(unknown) = AliasedDefinition : +# 720| mu720_3(unknown) = UnmodeledDefinition : +# 721| r721_1(glval) = VariableAddress[#return] : +# 721| r721_2(glval) = FunctionAddress[Func] : +# 721| r721_3(void *) = Constant[0] : +# 721| r721_4(char) = Constant[111] : +# 721| r721_5(long) = Call : func:r721_2, 0:r721_3, 1:r721_4 +# 721| mu721_6(unknown) = ^CallSideEffect : ~mu720_3 +# 721| v721_7(void) = ^BufferReadSideEffect[0] : &:r721_3, ~mu720_3 +# 721| mu721_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r721_3 +# 721| r721_9(double) = Convert : r721_5 +# 721| mu721_10(double) = Store : &:r721_1, r721_9 +# 720| r720_4(glval) = VariableAddress[#return] : +# 720| v720_5(void) = ReturnValue : &:r720_4, ~mu720_3 +# 720| v720_6(void) = UnmodeledUse : mu* +# 720| v720_7(void) = AliasedUse : ~mu720_3 +# 720| v720_8(void) = ExitFunction : # 724| void TryCatch(bool) # 724| Block 0 -# 724| v0_0(void) = EnterFunction : -# 724| mu0_1(unknown) = AliasedDefinition : -# 724| mu0_2(unknown) = UnmodeledDefinition : -# 724| r0_3(glval) = VariableAddress[b] : -# 724| mu0_4(bool) = InitializeParameter[b] : &:r0_3 -# 726| r0_5(glval) = VariableAddress[x] : -# 726| r0_6(int) = Constant[5] : -# 726| mu0_7(int) = Store : &:r0_5, r0_6 -# 727| r0_8(glval) = VariableAddress[b] : -# 727| r0_9(bool) = Load : &:r0_8, ~mu0_2 -# 727| v0_10(void) = ConditionalBranch : r0_9 +# 724| v724_1(void) = EnterFunction : +# 724| mu724_2(unknown) = AliasedDefinition : +# 724| mu724_3(unknown) = UnmodeledDefinition : +# 724| r724_4(glval) = VariableAddress[b] : +# 724| mu724_5(bool) = InitializeParameter[b] : &:r724_4 +# 726| r726_1(glval) = VariableAddress[x] : +# 726| r726_2(int) = Constant[5] : +# 726| mu726_3(int) = Store : &:r726_1, r726_2 +# 727| r727_1(glval) = VariableAddress[b] : +# 727| r727_2(bool) = Load : &:r727_1, ~mu724_3 +# 727| v727_3(void) = ConditionalBranch : r727_2 #-----| False -> Block 4 #-----| True -> Block 3 # 724| Block 1 -# 724| v1_0(void) = UnmodeledUse : mu* -# 724| v1_1(void) = AliasedUse : ~mu0_2 -# 724| v1_2(void) = ExitFunction : +# 724| v724_6(void) = UnmodeledUse : mu* +# 724| v724_7(void) = AliasedUse : ~mu724_3 +# 724| v724_8(void) = ExitFunction : # 724| Block 2 -# 724| v2_0(void) = Unwind : +# 724| v724_9(void) = Unwind : #-----| Goto -> Block 1 # 728| Block 3 -# 728| r3_0(glval) = VariableAddress[#throw728:7] : -# 728| r3_1(glval) = StringConstant["string literal"] : -# 728| r3_2(char *) = Convert : r3_1 -# 728| mu3_3(char *) = Store : &:r3_0, r3_2 -# 728| v3_4(void) = ThrowValue : &:r3_0, ~mu0_2 +# 728| r728_1(glval) = VariableAddress[#throw728:7] : +# 728| r728_2(glval) = StringConstant["string literal"] : +# 728| r728_3(char *) = Convert : r728_2 +# 728| mu728_4(char *) = Store : &:r728_1, r728_3 +# 728| v728_5(void) = ThrowValue : &:r728_1, ~mu724_3 #-----| Exception -> Block 9 # 730| Block 4 -# 730| r4_0(glval) = VariableAddress[x] : -# 730| r4_1(int) = Load : &:r4_0, ~mu0_2 -# 730| r4_2(int) = Constant[2] : -# 730| r4_3(bool) = CompareLT : r4_1, r4_2 -# 730| v4_4(void) = ConditionalBranch : r4_3 +# 730| r730_1(glval) = VariableAddress[x] : +# 730| r730_2(int) = Load : &:r730_1, ~mu724_3 +# 730| r730_3(int) = Constant[2] : +# 730| r730_4(bool) = CompareLT : r730_2, r730_3 +# 730| v730_5(void) = ConditionalBranch : r730_4 #-----| False -> Block 8 #-----| True -> Block 5 # 731| Block 5 -# 731| r5_0(glval) = VariableAddress[b] : -# 731| r5_1(bool) = Load : &:r5_0, ~mu0_2 -# 731| v5_2(void) = ConditionalBranch : r5_1 +# 731| r731_1(glval) = VariableAddress[b] : +# 731| r731_2(bool) = Load : &:r731_1, ~mu724_3 +# 731| v731_3(void) = ConditionalBranch : r731_2 #-----| False -> Block 7 #-----| True -> Block 6 # 731| Block 6 -# 731| r6_0(int) = Constant[7] : -# 731| r6_1(glval) = VariableAddress[#temp731:11] : -# 731| mu6_2(int) = Store : &:r6_1, r6_0 -# 731| r6_3(glval) = VariableAddress[#temp731:11] : -# 731| r6_4(int) = Load : &:r6_3, ~mu0_2 -# 731| r6_5(glval) = VariableAddress[x] : -# 731| mu6_6(int) = Store : &:r6_5, r6_4 +# 731| r731_4(int) = Constant[7] : +# 731| r731_5(glval) = VariableAddress[#temp731:11] : +# 731| mu731_6(int) = Store : &:r731_5, r731_4 +# 731| r731_7(glval) = VariableAddress[#temp731:11] : +# 731| r731_8(int) = Load : &:r731_7, ~mu724_3 +# 731| r731_9(glval) = VariableAddress[x] : +# 731| mu731_10(int) = Store : &:r731_9, r731_8 #-----| Goto -> Block 8 # 731| Block 7 -# 731| r7_0(glval) = VariableAddress[#throw731:19] : -# 731| r7_1(glval) = FunctionAddress[String] : -# 731| r7_2(glval) = StringConstant["String object"] : -# 731| r7_3(char *) = Convert : r7_2 -# 731| v7_4(void) = Call : func:r7_1, this:r7_0, 0:r7_3 -# 731| mu7_5(unknown) = ^CallSideEffect : ~mu0_2 -# 731| mu7_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r7_0 -# 731| v7_7(void) = ^BufferReadSideEffect[0] : &:r7_3, ~mu0_2 -# 731| mu7_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r7_3 -# 731| v7_9(void) = ThrowValue : &:r7_0, ~mu0_2 +# 731| r731_11(glval) = VariableAddress[#throw731:19] : +# 731| r731_12(glval) = FunctionAddress[String] : +# 731| r731_13(glval) = StringConstant["String object"] : +# 731| r731_14(char *) = Convert : r731_13 +# 731| v731_15(void) = Call : func:r731_12, this:r731_11, 0:r731_14 +# 731| mu731_16(unknown) = ^CallSideEffect : ~mu724_3 +# 731| mu731_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r731_11 +# 731| v731_18(void) = ^BufferReadSideEffect[0] : &:r731_14, ~mu724_3 +# 731| mu731_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r731_14 +# 731| v731_20(void) = ThrowValue : &:r731_11, ~mu724_3 #-----| Exception -> Block 9 # 733| Block 8 -# 733| r8_0(int) = Constant[7] : -# 733| r8_1(glval) = VariableAddress[x] : -# 733| mu8_2(int) = Store : &:r8_1, r8_0 +# 733| r733_1(int) = Constant[7] : +# 733| r733_2(glval) = VariableAddress[x] : +# 733| mu733_3(int) = Store : &:r733_2, r733_1 #-----| Goto -> Block 14 # 735| Block 9 -# 735| v9_0(void) = CatchByType[const char *] : +# 735| v735_1(void) = CatchByType[const char *] : #-----| Exception -> Block 11 #-----| Goto -> Block 10 # 735| Block 10 -# 735| r10_0(glval) = VariableAddress[s] : -# 735| mu10_1(char *) = InitializeParameter[s] : &:r10_0 -# 736| r10_2(glval) = VariableAddress[#throw736:5] : -# 736| r10_3(glval) = FunctionAddress[String] : -# 736| r10_4(glval) = VariableAddress[s] : -# 736| r10_5(char *) = Load : &:r10_4, ~mu0_2 -# 736| v10_6(void) = Call : func:r10_3, this:r10_2, 0:r10_5 -# 736| mu10_7(unknown) = ^CallSideEffect : ~mu0_2 -# 736| mu10_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r10_2 -# 736| v10_9(void) = ^BufferReadSideEffect[0] : &:r10_5, ~mu0_2 -# 736| mu10_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r10_5 -# 736| v10_11(void) = ThrowValue : &:r10_2, ~mu0_2 +# 735| r735_2(glval) = VariableAddress[s] : +# 735| mu735_3(char *) = InitializeParameter[s] : &:r735_2 +# 736| r736_1(glval) = VariableAddress[#throw736:5] : +# 736| r736_2(glval) = FunctionAddress[String] : +# 736| r736_3(glval) = VariableAddress[s] : +# 736| r736_4(char *) = Load : &:r736_3, ~mu724_3 +# 736| v736_5(void) = Call : func:r736_2, this:r736_1, 0:r736_4 +# 736| mu736_6(unknown) = ^CallSideEffect : ~mu724_3 +# 736| mu736_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 +# 736| v736_8(void) = ^BufferReadSideEffect[0] : &:r736_4, ~mu724_3 +# 736| mu736_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_4 +# 736| v736_10(void) = ThrowValue : &:r736_1, ~mu724_3 #-----| Exception -> Block 2 # 738| Block 11 -# 738| v11_0(void) = CatchByType[const String &] : +# 738| v738_1(void) = CatchByType[const String &] : #-----| Exception -> Block 13 #-----| Goto -> Block 12 # 738| Block 12 -# 738| r12_0(glval) = VariableAddress[e] : -# 738| mu12_1(String &) = InitializeParameter[e] : &:r12_0 -# 738| v12_2(void) = NoOp : +# 738| r738_2(glval) = VariableAddress[e] : +# 738| mu738_3(String &) = InitializeParameter[e] : &:r738_2 +# 738| v738_4(void) = NoOp : #-----| Goto -> Block 14 # 740| Block 13 -# 740| v13_0(void) = CatchAny : -# 741| v13_1(void) = ReThrow : +# 740| v740_1(void) = CatchAny : +# 741| v741_1(void) = ReThrow : #-----| Exception -> Block 2 # 743| Block 14 -# 743| v14_0(void) = NoOp : -# 724| v14_1(void) = ReturnVoid : +# 743| v743_1(void) = NoOp : +# 724| v724_10(void) = ReturnVoid : #-----| Goto -> Block 1 # 745| Base& Base::operator=(Base const&) # 745| Block 0 -# 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = AliasedDefinition : -# 745| mu0_2(unknown) = UnmodeledDefinition : -# 745| r0_3(glval) = InitializeThis : -#-----| r0_4(glval) = VariableAddress[p#0] : -#-----| mu0_5(Base &) = InitializeParameter[p#0] : &:r0_4 -#-----| r0_6(Base *) = CopyValue : r0_3 -#-----| r0_7(glval) = FieldAddress[base_s] : r0_6 -#-----| r0_8(String *) = CopyValue : r0_7 -# 745| r0_9(glval) = FunctionAddress[operator=] : -#-----| r0_10(glval) = VariableAddress[p#0] : -#-----| r0_11(Base &) = Load : &:r0_10, ~mu0_2 -#-----| r0_12(glval) = CopyValue : r0_11 -#-----| r0_13(glval) = FieldAddress[base_s] : r0_12 -#-----| r0_14(String &) = CopyValue : r0_13 -# 745| r0_15(String &) = Call : func:r0_9, this:r0_8, 0:r0_14 -# 745| mu0_16(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_17(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu0_2 -#-----| v0_18(void) = ^BufferReadSideEffect[0] : &:r0_14, ~mu0_2 -#-----| mu0_19(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -#-----| mu0_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_14 -#-----| r0_21(glval) = CopyValue : r0_15 -#-----| r0_22(glval) = VariableAddress[#return] : -#-----| r0_23(Base *) = CopyValue : r0_3 -#-----| r0_24(glval) = CopyValue : r0_23 -#-----| r0_25(Base &) = CopyValue : r0_24 -#-----| mu0_26(Base &) = Store : &:r0_22, r0_25 -# 745| r0_27(glval) = VariableAddress[#return] : -# 745| v0_28(void) = ReturnValue : &:r0_27, ~mu0_2 -# 745| v0_29(void) = UnmodeledUse : mu* -# 745| v0_30(void) = AliasedUse : ~mu0_2 -# 745| v0_31(void) = ExitFunction : +# 745| v745_1(void) = EnterFunction : +# 745| mu745_3(unknown) = AliasedDefinition : +# 745| mu745_5(unknown) = UnmodeledDefinition : +# 745| r745_7(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| mu0_8(Base &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_13(Base *) = CopyValue : r745_7 +#-----| r0_17(glval) = FieldAddress[base_s] : r0_13 +#-----| r0_27(String *) = CopyValue : r0_17 +# 745| r745_12(glval) = FunctionAddress[operator=] : +#-----| r0_43(glval) = VariableAddress[p#0] : +#-----| r0_47(Base &) = Load : &:r0_43, ~mu745_5 +#-----| r0_50(glval) = CopyValue : r0_47 +#-----| r0_56(glval) = FieldAddress[base_s] : r0_50 +#-----| r0_62(String &) = CopyValue : r0_56 +# 745| r745_19(String &) = Call : func:r745_12, this:r0_27, 0:r0_62 +# 745| mu745_21(unknown) = ^CallSideEffect : ~mu745_5 +#-----| v0_75(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~mu745_5 +#-----| v0_80(void) = ^BufferReadSideEffect[0] : &:r0_62, ~mu745_5 +#-----| mu0_88(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 +#-----| mu0_94(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_62 +#-----| r0_97(glval) = CopyValue : r745_19 +#-----| r0_100(glval) = VariableAddress[#return] : +#-----| r0_104(Base *) = CopyValue : r745_7 +#-----| r0_110(glval) = CopyValue : r0_104 +#-----| r0_116(Base &) = CopyValue : r0_110 +#-----| mu0_121(Base &) = Store : &:r0_100, r0_116 +# 745| r745_22(glval) = VariableAddress[#return] : +# 745| v745_23(void) = ReturnValue : &:r745_22, ~mu745_5 +# 745| v745_24(void) = UnmodeledUse : mu* +# 745| v745_25(void) = AliasedUse : ~mu745_5 +# 745| v745_26(void) = ExitFunction : # 745| void Base::Base(Base const&) # 745| Block 0 -# 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = AliasedDefinition : -# 745| mu0_2(unknown) = UnmodeledDefinition : -# 745| r0_3(glval) = InitializeThis : -#-----| r0_4(glval) = VariableAddress[p#0] : -#-----| mu0_5(Base &) = InitializeParameter[p#0] : &:r0_4 -# 745| r0_6(glval) = FieldAddress[base_s] : r0_3 -# 745| r0_7(glval) = FunctionAddress[String] : -# 745| v0_8(void) = Call : func:r0_7, this:r0_6 -# 745| mu0_9(unknown) = ^CallSideEffect : ~mu0_2 -# 745| mu0_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_6 -# 745| v0_11(void) = NoOp : -# 745| v0_12(void) = ReturnVoid : -# 745| v0_13(void) = UnmodeledUse : mu* -# 745| v0_14(void) = AliasedUse : ~mu0_2 -# 745| v0_15(void) = ExitFunction : +# 745| v745_1(void) = EnterFunction : +# 745| mu745_3(unknown) = AliasedDefinition : +# 745| mu745_5(unknown) = UnmodeledDefinition : +# 745| r745_7(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| mu0_8(Base &) = InitializeParameter[p#0] : &:r0_1 +# 745| r745_9(glval) = FieldAddress[base_s] : r745_7 +# 745| r745_10(glval) = FunctionAddress[String] : +# 745| v745_11(void) = Call : func:r745_10, this:r745_9 +# 745| mu745_12(unknown) = ^CallSideEffect : ~mu745_5 +# 745| mu745_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r745_9 +# 745| v745_15(void) = NoOp : +# 745| v745_16(void) = ReturnVoid : +# 745| v745_17(void) = UnmodeledUse : mu* +# 745| v745_18(void) = AliasedUse : ~mu745_5 +# 745| v745_19(void) = ExitFunction : # 748| void Base::Base() # 748| Block 0 -# 748| v0_0(void) = EnterFunction : -# 748| mu0_1(unknown) = AliasedDefinition : -# 748| mu0_2(unknown) = UnmodeledDefinition : -# 748| r0_3(glval) = InitializeThis : -# 748| r0_4(glval) = FieldAddress[base_s] : r0_3 -# 748| r0_5(glval) = FunctionAddress[String] : -# 748| v0_6(void) = Call : func:r0_5, this:r0_4 -# 748| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 748| mu0_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 749| v0_9(void) = NoOp : -# 748| v0_10(void) = ReturnVoid : -# 748| v0_11(void) = UnmodeledUse : mu* -# 748| v0_12(void) = AliasedUse : ~mu0_2 -# 748| v0_13(void) = ExitFunction : +# 748| v748_1(void) = EnterFunction : +# 748| mu748_2(unknown) = AliasedDefinition : +# 748| mu748_3(unknown) = UnmodeledDefinition : +# 748| r748_4(glval) = InitializeThis : +# 748| r748_5(glval) = FieldAddress[base_s] : r748_4 +# 748| r748_6(glval) = FunctionAddress[String] : +# 748| v748_7(void) = Call : func:r748_6, this:r748_5 +# 748| mu748_8(unknown) = ^CallSideEffect : ~mu748_3 +# 748| mu748_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r748_5 +# 749| v749_1(void) = NoOp : +# 748| v748_10(void) = ReturnVoid : +# 748| v748_11(void) = UnmodeledUse : mu* +# 748| v748_12(void) = AliasedUse : ~mu748_3 +# 748| v748_13(void) = ExitFunction : # 750| void Base::~Base() # 750| Block 0 -# 750| v0_0(void) = EnterFunction : -# 750| mu0_1(unknown) = AliasedDefinition : -# 750| mu0_2(unknown) = UnmodeledDefinition : -# 750| r0_3(glval) = InitializeThis : -# 751| v0_4(void) = NoOp : -# 751| r0_5(glval) = FieldAddress[base_s] : r0_3 -# 751| r0_6(glval) = FunctionAddress[~String] : -# 751| v0_7(void) = Call : func:r0_6, this:r0_5 -# 751| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 750| v0_9(void) = ReturnVoid : -# 750| v0_10(void) = UnmodeledUse : mu* -# 750| v0_11(void) = AliasedUse : ~mu0_2 -# 750| v0_12(void) = ExitFunction : +# 750| v750_1(void) = EnterFunction : +# 750| mu750_2(unknown) = AliasedDefinition : +# 750| mu750_3(unknown) = UnmodeledDefinition : +# 750| r750_4(glval) = InitializeThis : +# 751| v751_1(void) = NoOp : +# 751| r751_2(glval) = FieldAddress[base_s] : r750_4 +# 751| r751_3(glval) = FunctionAddress[~String] : +# 751| v751_4(void) = Call : func:r751_3, this:r751_2 +# 751| mu751_5(unknown) = ^CallSideEffect : ~mu750_3 +# 750| v750_5(void) = ReturnVoid : +# 750| v750_6(void) = UnmodeledUse : mu* +# 750| v750_7(void) = AliasedUse : ~mu750_3 +# 750| v750_8(void) = ExitFunction : # 754| Middle& Middle::operator=(Middle const&) # 754| Block 0 -# 754| v0_0(void) = EnterFunction : -# 754| mu0_1(unknown) = AliasedDefinition : -# 754| mu0_2(unknown) = UnmodeledDefinition : -# 754| r0_3(glval) = InitializeThis : -#-----| r0_4(glval) = VariableAddress[p#0] : -#-----| mu0_5(Middle &) = InitializeParameter[p#0] : &:r0_4 -#-----| r0_6(Middle *) = CopyValue : r0_3 -#-----| r0_7(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_6 -# 754| r0_8(glval) = FunctionAddress[operator=] : -#-----| r0_9(glval) = VariableAddress[p#0] : -#-----| r0_10(Middle &) = Load : &:r0_9, ~mu0_2 -#-----| r0_11(glval) = CopyValue : r0_10 -#-----| r0_12(Middle *) = CopyValue : r0_11 -#-----| r0_13(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_12 -#-----| r0_14(glval) = CopyValue : r0_13 -#-----| r0_15(Base &) = CopyValue : r0_14 -# 754| r0_16(Base &) = Call : func:r0_8, this:r0_7, 0:r0_15 -# 754| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_18(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~mu0_2 -#-----| v0_19(void) = ^BufferReadSideEffect[0] : &:r0_15, ~mu0_2 -#-----| mu0_20(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -#-----| mu0_21(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_15 -#-----| r0_22(glval) = CopyValue : r0_16 -#-----| r0_23(Middle *) = CopyValue : r0_3 -#-----| r0_24(glval) = FieldAddress[middle_s] : r0_23 -#-----| r0_25(String *) = CopyValue : r0_24 -# 754| r0_26(glval) = FunctionAddress[operator=] : -#-----| r0_27(glval) = VariableAddress[p#0] : -#-----| r0_28(Middle &) = Load : &:r0_27, ~mu0_2 -#-----| r0_29(glval) = CopyValue : r0_28 -#-----| r0_30(glval) = FieldAddress[middle_s] : r0_29 -#-----| r0_31(String &) = CopyValue : r0_30 -# 754| r0_32(String &) = Call : func:r0_26, this:r0_25, 0:r0_31 -# 754| mu0_33(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_34(void) = ^BufferReadSideEffect[-1] : &:r0_25, ~mu0_2 -#-----| v0_35(void) = ^BufferReadSideEffect[0] : &:r0_31, ~mu0_2 -#-----| mu0_36(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 -#-----| mu0_37(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_31 -#-----| r0_38(glval) = CopyValue : r0_32 -#-----| r0_39(glval) = VariableAddress[#return] : -#-----| r0_40(Middle *) = CopyValue : r0_3 -#-----| r0_41(glval) = CopyValue : r0_40 -#-----| r0_42(Middle &) = CopyValue : r0_41 -#-----| mu0_43(Middle &) = Store : &:r0_39, r0_42 -# 754| r0_44(glval) = VariableAddress[#return] : -# 754| v0_45(void) = ReturnValue : &:r0_44, ~mu0_2 -# 754| v0_46(void) = UnmodeledUse : mu* -# 754| v0_47(void) = AliasedUse : ~mu0_2 -# 754| v0_48(void) = ExitFunction : +# 754| v754_1(void) = EnterFunction : +# 754| mu754_2(unknown) = AliasedDefinition : +# 754| mu754_3(unknown) = UnmodeledDefinition : +# 754| r754_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| mu0_8(Middle &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_13(Middle *) = CopyValue : r754_4 +#-----| r0_17(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_13 +# 754| r754_5(glval) = FunctionAddress[operator=] : +#-----| r0_36(glval) = VariableAddress[p#0] : +#-----| r0_43(Middle &) = Load : &:r0_36, ~mu754_3 +#-----| r0_47(glval) = CopyValue : r0_43 +#-----| r0_50(Middle *) = CopyValue : r0_47 +#-----| r0_56(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_50 +#-----| r0_62(glval) = CopyValue : r0_56 +#-----| r0_68(Base &) = CopyValue : r0_62 +# 754| r754_6(Base &) = Call : func:r754_5, this:r0_17, 0:r0_68 +# 754| mu754_7(unknown) = ^CallSideEffect : ~mu754_3 +#-----| v0_80(void) = ^BufferReadSideEffect[-1] : &:r0_17, ~mu754_3 +#-----| v0_88(void) = ^BufferReadSideEffect[0] : &:r0_68, ~mu754_3 +#-----| mu0_94(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_17 +#-----| mu0_97(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_68 +#-----| r0_100(glval) = CopyValue : r754_6 +#-----| r0_104(Middle *) = CopyValue : r754_4 +#-----| r0_110(glval) = FieldAddress[middle_s] : r0_104 +#-----| r0_116(String *) = CopyValue : r0_110 +# 754| r754_8(glval) = FunctionAddress[operator=] : +#-----| r0_122(glval) = VariableAddress[p#0] : +#-----| r0_124(Middle &) = Load : &:r0_122, ~mu754_3 +#-----| r0_127(glval) = CopyValue : r0_124 +#-----| r0_130(glval) = FieldAddress[middle_s] : r0_127 +#-----| r0_133(String &) = CopyValue : r0_130 +# 754| r754_9(String &) = Call : func:r754_8, this:r0_116, 0:r0_133 +# 754| mu754_10(unknown) = ^CallSideEffect : ~mu754_3 +#-----| v0_135(void) = ^BufferReadSideEffect[-1] : &:r0_116, ~mu754_3 +#-----| v0_137(void) = ^BufferReadSideEffect[0] : &:r0_133, ~mu754_3 +#-----| mu0_139(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_116 +#-----| mu0_141(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_133 +#-----| r0_143(glval) = CopyValue : r754_9 +#-----| r0_145(glval) = VariableAddress[#return] : +#-----| r0_147(Middle *) = CopyValue : r754_4 +#-----| r0_150(glval) = CopyValue : r0_147 +#-----| r0_153(Middle &) = CopyValue : r0_150 +#-----| mu0_157(Middle &) = Store : &:r0_145, r0_153 +# 754| r754_11(glval) = VariableAddress[#return] : +# 754| v754_12(void) = ReturnValue : &:r754_11, ~mu754_3 +# 754| v754_13(void) = UnmodeledUse : mu* +# 754| v754_14(void) = AliasedUse : ~mu754_3 +# 754| v754_15(void) = ExitFunction : # 757| void Middle::Middle() # 757| Block 0 -# 757| v0_0(void) = EnterFunction : -# 757| mu0_1(unknown) = AliasedDefinition : -# 757| mu0_2(unknown) = UnmodeledDefinition : -# 757| r0_3(glval) = InitializeThis : -# 757| r0_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_3 -# 757| r0_5(glval) = FunctionAddress[Base] : -# 757| v0_6(void) = Call : func:r0_5, this:r0_4 -# 757| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 757| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 757| r0_9(glval) = FieldAddress[middle_s] : r0_3 -# 757| r0_10(glval) = FunctionAddress[String] : -# 757| v0_11(void) = Call : func:r0_10, this:r0_9 -# 757| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 757| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 758| v0_14(void) = NoOp : -# 757| v0_15(void) = ReturnVoid : -# 757| v0_16(void) = UnmodeledUse : mu* -# 757| v0_17(void) = AliasedUse : ~mu0_2 -# 757| v0_18(void) = ExitFunction : +# 757| v757_1(void) = EnterFunction : +# 757| mu757_2(unknown) = AliasedDefinition : +# 757| mu757_3(unknown) = UnmodeledDefinition : +# 757| r757_4(glval) = InitializeThis : +# 757| r757_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r757_4 +# 757| r757_6(glval) = FunctionAddress[Base] : +# 757| v757_7(void) = Call : func:r757_6, this:r757_5 +# 757| mu757_8(unknown) = ^CallSideEffect : ~mu757_3 +# 757| mu757_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r757_5 +# 757| r757_10(glval) = FieldAddress[middle_s] : r757_4 +# 757| r757_11(glval) = FunctionAddress[String] : +# 757| v757_12(void) = Call : func:r757_11, this:r757_10 +# 757| mu757_13(unknown) = ^CallSideEffect : ~mu757_3 +# 757| mu757_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r757_10 +# 758| v758_1(void) = NoOp : +# 757| v757_15(void) = ReturnVoid : +# 757| v757_16(void) = UnmodeledUse : mu* +# 757| v757_17(void) = AliasedUse : ~mu757_3 +# 757| v757_18(void) = ExitFunction : # 759| void Middle::~Middle() # 759| Block 0 -# 759| v0_0(void) = EnterFunction : -# 759| mu0_1(unknown) = AliasedDefinition : -# 759| mu0_2(unknown) = UnmodeledDefinition : -# 759| r0_3(glval) = InitializeThis : -# 760| v0_4(void) = NoOp : -# 760| r0_5(glval) = FieldAddress[middle_s] : r0_3 -# 760| r0_6(glval) = FunctionAddress[~String] : -# 760| v0_7(void) = Call : func:r0_6, this:r0_5 -# 760| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 760| r0_9(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_3 -# 760| r0_10(glval) = FunctionAddress[~Base] : -# 760| v0_11(void) = Call : func:r0_10, this:r0_9 -# 760| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 759| v0_13(void) = ReturnVoid : -# 759| v0_14(void) = UnmodeledUse : mu* -# 759| v0_15(void) = AliasedUse : ~mu0_2 -# 759| v0_16(void) = ExitFunction : +# 759| v759_1(void) = EnterFunction : +# 759| mu759_2(unknown) = AliasedDefinition : +# 759| mu759_3(unknown) = UnmodeledDefinition : +# 759| r759_4(glval) = InitializeThis : +# 760| v760_1(void) = NoOp : +# 760| r760_2(glval) = FieldAddress[middle_s] : r759_4 +# 760| r760_3(glval) = FunctionAddress[~String] : +# 760| v760_4(void) = Call : func:r760_3, this:r760_2 +# 760| mu760_5(unknown) = ^CallSideEffect : ~mu759_3 +# 760| r760_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r759_4 +# 760| r760_7(glval) = FunctionAddress[~Base] : +# 760| v760_8(void) = Call : func:r760_7, this:r760_6 +# 760| mu760_9(unknown) = ^CallSideEffect : ~mu759_3 +# 759| v759_5(void) = ReturnVoid : +# 759| v759_6(void) = UnmodeledUse : mu* +# 759| v759_7(void) = AliasedUse : ~mu759_3 +# 759| v759_8(void) = ExitFunction : # 763| Derived& Derived::operator=(Derived const&) # 763| Block 0 -# 763| v0_0(void) = EnterFunction : -# 763| mu0_1(unknown) = AliasedDefinition : -# 763| mu0_2(unknown) = UnmodeledDefinition : -# 763| r0_3(glval) = InitializeThis : -#-----| r0_4(glval) = VariableAddress[p#0] : -#-----| mu0_5(Derived &) = InitializeParameter[p#0] : &:r0_4 -#-----| r0_6(Derived *) = CopyValue : r0_3 -#-----| r0_7(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_6 -# 763| r0_8(glval) = FunctionAddress[operator=] : -#-----| r0_9(glval) = VariableAddress[p#0] : -#-----| r0_10(Derived &) = Load : &:r0_9, ~mu0_2 -#-----| r0_11(glval) = CopyValue : r0_10 -#-----| r0_12(Derived *) = CopyValue : r0_11 -#-----| r0_13(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_12 -#-----| r0_14(glval) = CopyValue : r0_13 -#-----| r0_15(Middle &) = CopyValue : r0_14 -# 763| r0_16(Middle &) = Call : func:r0_8, this:r0_7, 0:r0_15 -# 763| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_18(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~mu0_2 -#-----| v0_19(void) = ^BufferReadSideEffect[0] : &:r0_15, ~mu0_2 -#-----| mu0_20(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -#-----| mu0_21(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_15 -#-----| r0_22(glval) = CopyValue : r0_16 -#-----| r0_23(Derived *) = CopyValue : r0_3 -#-----| r0_24(glval) = FieldAddress[derived_s] : r0_23 -#-----| r0_25(String *) = CopyValue : r0_24 -# 763| r0_26(glval) = FunctionAddress[operator=] : -#-----| r0_27(glval) = VariableAddress[p#0] : -#-----| r0_28(Derived &) = Load : &:r0_27, ~mu0_2 -#-----| r0_29(glval) = CopyValue : r0_28 -#-----| r0_30(glval) = FieldAddress[derived_s] : r0_29 -#-----| r0_31(String &) = CopyValue : r0_30 -# 763| r0_32(String &) = Call : func:r0_26, this:r0_25, 0:r0_31 -# 763| mu0_33(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_34(void) = ^BufferReadSideEffect[-1] : &:r0_25, ~mu0_2 -#-----| v0_35(void) = ^BufferReadSideEffect[0] : &:r0_31, ~mu0_2 -#-----| mu0_36(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 -#-----| mu0_37(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_31 -#-----| r0_38(glval) = CopyValue : r0_32 -#-----| r0_39(glval) = VariableAddress[#return] : -#-----| r0_40(Derived *) = CopyValue : r0_3 -#-----| r0_41(glval) = CopyValue : r0_40 -#-----| r0_42(Derived &) = CopyValue : r0_41 -#-----| mu0_43(Derived &) = Store : &:r0_39, r0_42 -# 763| r0_44(glval) = VariableAddress[#return] : -# 763| v0_45(void) = ReturnValue : &:r0_44, ~mu0_2 -# 763| v0_46(void) = UnmodeledUse : mu* -# 763| v0_47(void) = AliasedUse : ~mu0_2 -# 763| v0_48(void) = ExitFunction : +# 763| v763_1(void) = EnterFunction : +# 763| mu763_2(unknown) = AliasedDefinition : +# 763| mu763_3(unknown) = UnmodeledDefinition : +# 763| r763_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| mu0_8(Derived &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_13(Derived *) = CopyValue : r763_4 +#-----| r0_17(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_13 +# 763| r763_5(glval) = FunctionAddress[operator=] : +#-----| r0_36(glval) = VariableAddress[p#0] : +#-----| r0_43(Derived &) = Load : &:r0_36, ~mu763_3 +#-----| r0_47(glval) = CopyValue : r0_43 +#-----| r0_50(Derived *) = CopyValue : r0_47 +#-----| r0_56(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_50 +#-----| r0_62(glval) = CopyValue : r0_56 +#-----| r0_68(Middle &) = CopyValue : r0_62 +# 763| r763_6(Middle &) = Call : func:r763_5, this:r0_17, 0:r0_68 +# 763| mu763_7(unknown) = ^CallSideEffect : ~mu763_3 +#-----| v0_80(void) = ^BufferReadSideEffect[-1] : &:r0_17, ~mu763_3 +#-----| v0_88(void) = ^BufferReadSideEffect[0] : &:r0_68, ~mu763_3 +#-----| mu0_94(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_17 +#-----| mu0_97(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_68 +#-----| r0_100(glval) = CopyValue : r763_6 +#-----| r0_104(Derived *) = CopyValue : r763_4 +#-----| r0_110(glval) = FieldAddress[derived_s] : r0_104 +#-----| r0_116(String *) = CopyValue : r0_110 +# 763| r763_8(glval) = FunctionAddress[operator=] : +#-----| r0_122(glval) = VariableAddress[p#0] : +#-----| r0_124(Derived &) = Load : &:r0_122, ~mu763_3 +#-----| r0_127(glval) = CopyValue : r0_124 +#-----| r0_130(glval) = FieldAddress[derived_s] : r0_127 +#-----| r0_133(String &) = CopyValue : r0_130 +# 763| r763_9(String &) = Call : func:r763_8, this:r0_116, 0:r0_133 +# 763| mu763_10(unknown) = ^CallSideEffect : ~mu763_3 +#-----| v0_135(void) = ^BufferReadSideEffect[-1] : &:r0_116, ~mu763_3 +#-----| v0_137(void) = ^BufferReadSideEffect[0] : &:r0_133, ~mu763_3 +#-----| mu0_139(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_116 +#-----| mu0_141(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_133 +#-----| r0_143(glval) = CopyValue : r763_9 +#-----| r0_145(glval) = VariableAddress[#return] : +#-----| r0_147(Derived *) = CopyValue : r763_4 +#-----| r0_150(glval) = CopyValue : r0_147 +#-----| r0_153(Derived &) = CopyValue : r0_150 +#-----| mu0_157(Derived &) = Store : &:r0_145, r0_153 +# 763| r763_11(glval) = VariableAddress[#return] : +# 763| v763_12(void) = ReturnValue : &:r763_11, ~mu763_3 +# 763| v763_13(void) = UnmodeledUse : mu* +# 763| v763_14(void) = AliasedUse : ~mu763_3 +# 763| v763_15(void) = ExitFunction : # 766| void Derived::Derived() # 766| Block 0 -# 766| v0_0(void) = EnterFunction : -# 766| mu0_1(unknown) = AliasedDefinition : -# 766| mu0_2(unknown) = UnmodeledDefinition : -# 766| r0_3(glval) = InitializeThis : -# 766| r0_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r0_3 -# 766| r0_5(glval) = FunctionAddress[Middle] : -# 766| v0_6(void) = Call : func:r0_5, this:r0_4 -# 766| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 766| mu0_8(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 766| r0_9(glval) = FieldAddress[derived_s] : r0_3 -# 766| r0_10(glval) = FunctionAddress[String] : -# 766| v0_11(void) = Call : func:r0_10, this:r0_9 -# 766| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 766| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 767| v0_14(void) = NoOp : -# 766| v0_15(void) = ReturnVoid : -# 766| v0_16(void) = UnmodeledUse : mu* -# 766| v0_17(void) = AliasedUse : ~mu0_2 -# 766| v0_18(void) = ExitFunction : +# 766| v766_1(void) = EnterFunction : +# 766| mu766_2(unknown) = AliasedDefinition : +# 766| mu766_3(unknown) = UnmodeledDefinition : +# 766| r766_4(glval) = InitializeThis : +# 766| r766_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r766_4 +# 766| r766_6(glval) = FunctionAddress[Middle] : +# 766| v766_7(void) = Call : func:r766_6, this:r766_5 +# 766| mu766_8(unknown) = ^CallSideEffect : ~mu766_3 +# 766| mu766_9(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r766_5 +# 766| r766_10(glval) = FieldAddress[derived_s] : r766_4 +# 766| r766_11(glval) = FunctionAddress[String] : +# 766| v766_12(void) = Call : func:r766_11, this:r766_10 +# 766| mu766_13(unknown) = ^CallSideEffect : ~mu766_3 +# 766| mu766_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r766_10 +# 767| v767_1(void) = NoOp : +# 766| v766_15(void) = ReturnVoid : +# 766| v766_16(void) = UnmodeledUse : mu* +# 766| v766_17(void) = AliasedUse : ~mu766_3 +# 766| v766_18(void) = ExitFunction : # 768| void Derived::~Derived() # 768| Block 0 -# 768| v0_0(void) = EnterFunction : -# 768| mu0_1(unknown) = AliasedDefinition : -# 768| mu0_2(unknown) = UnmodeledDefinition : -# 768| r0_3(glval) = InitializeThis : -# 769| v0_4(void) = NoOp : -# 769| r0_5(glval) = FieldAddress[derived_s] : r0_3 -# 769| r0_6(glval) = FunctionAddress[~String] : -# 769| v0_7(void) = Call : func:r0_6, this:r0_5 -# 769| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 769| r0_9(glval) = ConvertToNonVirtualBase[Derived : Middle] : r0_3 -# 769| r0_10(glval) = FunctionAddress[~Middle] : -# 769| v0_11(void) = Call : func:r0_10, this:r0_9 -# 769| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 768| v0_13(void) = ReturnVoid : -# 768| v0_14(void) = UnmodeledUse : mu* -# 768| v0_15(void) = AliasedUse : ~mu0_2 -# 768| v0_16(void) = ExitFunction : +# 768| v768_1(void) = EnterFunction : +# 768| mu768_2(unknown) = AliasedDefinition : +# 768| mu768_3(unknown) = UnmodeledDefinition : +# 768| r768_4(glval) = InitializeThis : +# 769| v769_1(void) = NoOp : +# 769| r769_2(glval) = FieldAddress[derived_s] : r768_4 +# 769| r769_3(glval) = FunctionAddress[~String] : +# 769| v769_4(void) = Call : func:r769_3, this:r769_2 +# 769| mu769_5(unknown) = ^CallSideEffect : ~mu768_3 +# 769| r769_6(glval) = ConvertToNonVirtualBase[Derived : Middle] : r768_4 +# 769| r769_7(glval) = FunctionAddress[~Middle] : +# 769| v769_8(void) = Call : func:r769_7, this:r769_6 +# 769| mu769_9(unknown) = ^CallSideEffect : ~mu768_3 +# 768| v768_5(void) = ReturnVoid : +# 768| v768_6(void) = UnmodeledUse : mu* +# 768| v768_7(void) = AliasedUse : ~mu768_3 +# 768| v768_8(void) = ExitFunction : # 775| void MiddleVB1::MiddleVB1() # 775| Block 0 -# 775| v0_0(void) = EnterFunction : -# 775| mu0_1(unknown) = AliasedDefinition : -# 775| mu0_2(unknown) = UnmodeledDefinition : -# 775| r0_3(glval) = InitializeThis : -# 775| r0_4(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r0_3 -# 775| r0_5(glval) = FunctionAddress[Base] : -# 775| v0_6(void) = Call : func:r0_5, this:r0_4 -# 775| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 775| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 775| r0_9(glval) = FieldAddress[middlevb1_s] : r0_3 -# 775| r0_10(glval) = FunctionAddress[String] : -# 775| v0_11(void) = Call : func:r0_10, this:r0_9 -# 775| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 775| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 776| v0_14(void) = NoOp : -# 775| v0_15(void) = ReturnVoid : -# 775| v0_16(void) = UnmodeledUse : mu* -# 775| v0_17(void) = AliasedUse : ~mu0_2 -# 775| v0_18(void) = ExitFunction : +# 775| v775_1(void) = EnterFunction : +# 775| mu775_2(unknown) = AliasedDefinition : +# 775| mu775_3(unknown) = UnmodeledDefinition : +# 775| r775_4(glval) = InitializeThis : +# 775| r775_5(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r775_4 +# 775| r775_6(glval) = FunctionAddress[Base] : +# 775| v775_7(void) = Call : func:r775_6, this:r775_5 +# 775| mu775_8(unknown) = ^CallSideEffect : ~mu775_3 +# 775| mu775_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r775_5 +# 775| r775_10(glval) = FieldAddress[middlevb1_s] : r775_4 +# 775| r775_11(glval) = FunctionAddress[String] : +# 775| v775_12(void) = Call : func:r775_11, this:r775_10 +# 775| mu775_13(unknown) = ^CallSideEffect : ~mu775_3 +# 775| mu775_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r775_10 +# 776| v776_1(void) = NoOp : +# 775| v775_15(void) = ReturnVoid : +# 775| v775_16(void) = UnmodeledUse : mu* +# 775| v775_17(void) = AliasedUse : ~mu775_3 +# 775| v775_18(void) = ExitFunction : # 777| void MiddleVB1::~MiddleVB1() # 777| Block 0 -# 777| v0_0(void) = EnterFunction : -# 777| mu0_1(unknown) = AliasedDefinition : -# 777| mu0_2(unknown) = UnmodeledDefinition : -# 777| r0_3(glval) = InitializeThis : -# 778| v0_4(void) = NoOp : -# 778| r0_5(glval) = FieldAddress[middlevb1_s] : r0_3 -# 778| r0_6(glval) = FunctionAddress[~String] : -# 778| v0_7(void) = Call : func:r0_6, this:r0_5 -# 778| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 778| r0_9(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r0_3 -# 778| r0_10(glval) = FunctionAddress[~Base] : -# 778| v0_11(void) = Call : func:r0_10, this:r0_9 -# 778| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 777| v0_13(void) = ReturnVoid : -# 777| v0_14(void) = UnmodeledUse : mu* -# 777| v0_15(void) = AliasedUse : ~mu0_2 -# 777| v0_16(void) = ExitFunction : +# 777| v777_1(void) = EnterFunction : +# 777| mu777_2(unknown) = AliasedDefinition : +# 777| mu777_3(unknown) = UnmodeledDefinition : +# 777| r777_4(glval) = InitializeThis : +# 778| v778_1(void) = NoOp : +# 778| r778_2(glval) = FieldAddress[middlevb1_s] : r777_4 +# 778| r778_3(glval) = FunctionAddress[~String] : +# 778| v778_4(void) = Call : func:r778_3, this:r778_2 +# 778| mu778_5(unknown) = ^CallSideEffect : ~mu777_3 +# 778| r778_6(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r777_4 +# 778| r778_7(glval) = FunctionAddress[~Base] : +# 778| v778_8(void) = Call : func:r778_7, this:r778_6 +# 778| mu778_9(unknown) = ^CallSideEffect : ~mu777_3 +# 777| v777_5(void) = ReturnVoid : +# 777| v777_6(void) = UnmodeledUse : mu* +# 777| v777_7(void) = AliasedUse : ~mu777_3 +# 777| v777_8(void) = ExitFunction : # 784| void MiddleVB2::MiddleVB2() # 784| Block 0 -# 784| v0_0(void) = EnterFunction : -# 784| mu0_1(unknown) = AliasedDefinition : -# 784| mu0_2(unknown) = UnmodeledDefinition : -# 784| r0_3(glval) = InitializeThis : -# 784| r0_4(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r0_3 -# 784| r0_5(glval) = FunctionAddress[Base] : -# 784| v0_6(void) = Call : func:r0_5, this:r0_4 -# 784| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 784| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 784| r0_9(glval) = FieldAddress[middlevb2_s] : r0_3 -# 784| r0_10(glval) = FunctionAddress[String] : -# 784| v0_11(void) = Call : func:r0_10, this:r0_9 -# 784| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 784| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 785| v0_14(void) = NoOp : -# 784| v0_15(void) = ReturnVoid : -# 784| v0_16(void) = UnmodeledUse : mu* -# 784| v0_17(void) = AliasedUse : ~mu0_2 -# 784| v0_18(void) = ExitFunction : +# 784| v784_1(void) = EnterFunction : +# 784| mu784_2(unknown) = AliasedDefinition : +# 784| mu784_3(unknown) = UnmodeledDefinition : +# 784| r784_4(glval) = InitializeThis : +# 784| r784_5(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r784_4 +# 784| r784_6(glval) = FunctionAddress[Base] : +# 784| v784_7(void) = Call : func:r784_6, this:r784_5 +# 784| mu784_8(unknown) = ^CallSideEffect : ~mu784_3 +# 784| mu784_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r784_5 +# 784| r784_10(glval) = FieldAddress[middlevb2_s] : r784_4 +# 784| r784_11(glval) = FunctionAddress[String] : +# 784| v784_12(void) = Call : func:r784_11, this:r784_10 +# 784| mu784_13(unknown) = ^CallSideEffect : ~mu784_3 +# 784| mu784_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r784_10 +# 785| v785_1(void) = NoOp : +# 784| v784_15(void) = ReturnVoid : +# 784| v784_16(void) = UnmodeledUse : mu* +# 784| v784_17(void) = AliasedUse : ~mu784_3 +# 784| v784_18(void) = ExitFunction : # 786| void MiddleVB2::~MiddleVB2() # 786| Block 0 -# 786| v0_0(void) = EnterFunction : -# 786| mu0_1(unknown) = AliasedDefinition : -# 786| mu0_2(unknown) = UnmodeledDefinition : -# 786| r0_3(glval) = InitializeThis : -# 787| v0_4(void) = NoOp : -# 787| r0_5(glval) = FieldAddress[middlevb2_s] : r0_3 -# 787| r0_6(glval) = FunctionAddress[~String] : -# 787| v0_7(void) = Call : func:r0_6, this:r0_5 -# 787| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 787| r0_9(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r0_3 -# 787| r0_10(glval) = FunctionAddress[~Base] : -# 787| v0_11(void) = Call : func:r0_10, this:r0_9 -# 787| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 786| v0_13(void) = ReturnVoid : -# 786| v0_14(void) = UnmodeledUse : mu* -# 786| v0_15(void) = AliasedUse : ~mu0_2 -# 786| v0_16(void) = ExitFunction : +# 786| v786_1(void) = EnterFunction : +# 786| mu786_2(unknown) = AliasedDefinition : +# 786| mu786_3(unknown) = UnmodeledDefinition : +# 786| r786_4(glval) = InitializeThis : +# 787| v787_1(void) = NoOp : +# 787| r787_2(glval) = FieldAddress[middlevb2_s] : r786_4 +# 787| r787_3(glval) = FunctionAddress[~String] : +# 787| v787_4(void) = Call : func:r787_3, this:r787_2 +# 787| mu787_5(unknown) = ^CallSideEffect : ~mu786_3 +# 787| r787_6(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r786_4 +# 787| r787_7(glval) = FunctionAddress[~Base] : +# 787| v787_8(void) = Call : func:r787_7, this:r787_6 +# 787| mu787_9(unknown) = ^CallSideEffect : ~mu786_3 +# 786| v786_5(void) = ReturnVoid : +# 786| v786_6(void) = UnmodeledUse : mu* +# 786| v786_7(void) = AliasedUse : ~mu786_3 +# 786| v786_8(void) = ExitFunction : # 793| void DerivedVB::DerivedVB() # 793| Block 0 -# 793| v0_0(void) = EnterFunction : -# 793| mu0_1(unknown) = AliasedDefinition : -# 793| mu0_2(unknown) = UnmodeledDefinition : -# 793| r0_3(glval) = InitializeThis : -# 793| r0_4(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r0_3 -# 793| r0_5(glval) = FunctionAddress[Base] : -# 793| v0_6(void) = Call : func:r0_5, this:r0_4 -# 793| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 793| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 793| r0_9(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r0_3 -# 793| r0_10(glval) = FunctionAddress[MiddleVB1] : -# 793| v0_11(void) = Call : func:r0_10, this:r0_9 -# 793| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 793| mu0_13(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 793| r0_14(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r0_3 -# 793| r0_15(glval) = FunctionAddress[MiddleVB2] : -# 793| v0_16(void) = Call : func:r0_15, this:r0_14 -# 793| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 793| mu0_18(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r0_14 -# 793| r0_19(glval) = FieldAddress[derivedvb_s] : r0_3 -# 793| r0_20(glval) = FunctionAddress[String] : -# 793| v0_21(void) = Call : func:r0_20, this:r0_19 -# 793| mu0_22(unknown) = ^CallSideEffect : ~mu0_2 -# 793| mu0_23(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_19 -# 794| v0_24(void) = NoOp : -# 793| v0_25(void) = ReturnVoid : -# 793| v0_26(void) = UnmodeledUse : mu* -# 793| v0_27(void) = AliasedUse : ~mu0_2 -# 793| v0_28(void) = ExitFunction : +# 793| v793_1(void) = EnterFunction : +# 793| mu793_2(unknown) = AliasedDefinition : +# 793| mu793_3(unknown) = UnmodeledDefinition : +# 793| r793_4(glval) = InitializeThis : +# 793| r793_5(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r793_4 +# 793| r793_6(glval) = FunctionAddress[Base] : +# 793| v793_7(void) = Call : func:r793_6, this:r793_5 +# 793| mu793_8(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r793_5 +# 793| r793_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r793_4 +# 793| r793_11(glval) = FunctionAddress[MiddleVB1] : +# 793| v793_12(void) = Call : func:r793_11, this:r793_10 +# 793| mu793_13(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_14(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r793_10 +# 793| r793_15(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r793_4 +# 793| r793_16(glval) = FunctionAddress[MiddleVB2] : +# 793| v793_17(void) = Call : func:r793_16, this:r793_15 +# 793| mu793_18(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_19(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r793_15 +# 793| r793_20(glval) = FieldAddress[derivedvb_s] : r793_4 +# 793| r793_21(glval) = FunctionAddress[String] : +# 793| v793_22(void) = Call : func:r793_21, this:r793_20 +# 793| mu793_23(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_24(String) = ^IndirectMayWriteSideEffect[-1] : &:r793_20 +# 794| v794_1(void) = NoOp : +# 793| v793_25(void) = ReturnVoid : +# 793| v793_26(void) = UnmodeledUse : mu* +# 793| v793_27(void) = AliasedUse : ~mu793_3 +# 793| v793_28(void) = ExitFunction : # 795| void DerivedVB::~DerivedVB() # 795| Block 0 -# 795| v0_0(void) = EnterFunction : -# 795| mu0_1(unknown) = AliasedDefinition : -# 795| mu0_2(unknown) = UnmodeledDefinition : -# 795| r0_3(glval) = InitializeThis : -# 796| v0_4(void) = NoOp : -# 796| r0_5(glval) = FieldAddress[derivedvb_s] : r0_3 -# 796| r0_6(glval) = FunctionAddress[~String] : -# 796| v0_7(void) = Call : func:r0_6, this:r0_5 -# 796| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 796| r0_9(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r0_3 -# 796| r0_10(glval) = FunctionAddress[~MiddleVB2] : -# 796| v0_11(void) = Call : func:r0_10, this:r0_9 -# 796| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 796| r0_13(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r0_3 -# 796| r0_14(glval) = FunctionAddress[~MiddleVB1] : -# 796| v0_15(void) = Call : func:r0_14, this:r0_13 -# 796| mu0_16(unknown) = ^CallSideEffect : ~mu0_2 -# 796| r0_17(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r0_3 -# 796| r0_18(glval) = FunctionAddress[~Base] : -# 796| v0_19(void) = Call : func:r0_18, this:r0_17 -# 796| mu0_20(unknown) = ^CallSideEffect : ~mu0_2 -# 795| v0_21(void) = ReturnVoid : -# 795| v0_22(void) = UnmodeledUse : mu* -# 795| v0_23(void) = AliasedUse : ~mu0_2 -# 795| v0_24(void) = ExitFunction : +# 795| v795_1(void) = EnterFunction : +# 795| mu795_2(unknown) = AliasedDefinition : +# 795| mu795_3(unknown) = UnmodeledDefinition : +# 795| r795_4(glval) = InitializeThis : +# 796| v796_1(void) = NoOp : +# 796| r796_2(glval) = FieldAddress[derivedvb_s] : r795_4 +# 796| r796_3(glval) = FunctionAddress[~String] : +# 796| v796_4(void) = Call : func:r796_3, this:r796_2 +# 796| mu796_5(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_6(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r795_4 +# 796| r796_7(glval) = FunctionAddress[~MiddleVB2] : +# 796| v796_8(void) = Call : func:r796_7, this:r796_6 +# 796| mu796_9(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r795_4 +# 796| r796_11(glval) = FunctionAddress[~MiddleVB1] : +# 796| v796_12(void) = Call : func:r796_11, this:r796_10 +# 796| mu796_13(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_14(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r795_4 +# 796| r796_15(glval) = FunctionAddress[~Base] : +# 796| v796_16(void) = Call : func:r796_15, this:r796_14 +# 796| mu796_17(unknown) = ^CallSideEffect : ~mu795_3 +# 795| v795_5(void) = ReturnVoid : +# 795| v795_6(void) = UnmodeledUse : mu* +# 795| v795_7(void) = AliasedUse : ~mu795_3 +# 795| v795_8(void) = ExitFunction : # 799| void HierarchyConversions() # 799| Block 0 -# 799| v0_0(void) = EnterFunction : -# 799| mu0_1(unknown) = AliasedDefinition : -# 799| mu0_2(unknown) = UnmodeledDefinition : -# 800| r0_3(glval) = VariableAddress[b] : -# 800| mu0_4(Base) = Uninitialized[b] : &:r0_3 -# 800| r0_5(glval) = FunctionAddress[Base] : -# 800| v0_6(void) = Call : func:r0_5, this:r0_3 -# 800| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 800| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 801| r0_9(glval) = VariableAddress[m] : -# 801| mu0_10(Middle) = Uninitialized[m] : &:r0_9 -# 801| r0_11(glval) = FunctionAddress[Middle] : -# 801| v0_12(void) = Call : func:r0_11, this:r0_9 -# 801| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 801| mu0_14(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 802| r0_15(glval) = VariableAddress[d] : -# 802| mu0_16(Derived) = Uninitialized[d] : &:r0_15 -# 802| r0_17(glval) = FunctionAddress[Derived] : -# 802| v0_18(void) = Call : func:r0_17, this:r0_15 -# 802| mu0_19(unknown) = ^CallSideEffect : ~mu0_2 -# 802| mu0_20(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_15 -# 804| r0_21(glval) = VariableAddress[pb] : -# 804| r0_22(glval) = VariableAddress[b] : -# 804| r0_23(Base *) = CopyValue : r0_22 -# 804| mu0_24(Base *) = Store : &:r0_21, r0_23 -# 805| r0_25(glval) = VariableAddress[pm] : -# 805| r0_26(glval) = VariableAddress[m] : -# 805| r0_27(Middle *) = CopyValue : r0_26 -# 805| mu0_28(Middle *) = Store : &:r0_25, r0_27 -# 806| r0_29(glval) = VariableAddress[pd] : -# 806| r0_30(glval) = VariableAddress[d] : -# 806| r0_31(Derived *) = CopyValue : r0_30 -# 806| mu0_32(Derived *) = Store : &:r0_29, r0_31 -# 808| r0_33(glval) = VariableAddress[b] : -# 808| r0_34(glval) = FunctionAddress[operator=] : -# 808| r0_35(glval) = VariableAddress[m] : -# 808| r0_36(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_35 -# 808| r0_37(Base &) = CopyValue : r0_36 -# 808| r0_38(Base &) = Call : func:r0_34, this:r0_33, 0:r0_37 -# 808| mu0_39(unknown) = ^CallSideEffect : ~mu0_2 -# 808| v0_40(void) = ^BufferReadSideEffect[-1] : &:r0_33, ~mu0_2 -# 808| v0_41(void) = ^BufferReadSideEffect[0] : &:r0_37, ~mu0_2 -# 808| mu0_42(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_33 -# 808| mu0_43(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_37 -# 808| r0_44(glval) = CopyValue : r0_38 -# 809| r0_45(glval) = VariableAddress[b] : -# 809| r0_46(glval) = FunctionAddress[operator=] : -# 809| r0_47(glval) = FunctionAddress[Base] : -# 809| r0_48(glval) = VariableAddress[m] : -# 809| r0_49(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_48 -# 809| r0_50(Base &) = CopyValue : r0_49 -# 809| v0_51(void) = Call : func:r0_47, 0:r0_50 -# 809| mu0_52(unknown) = ^CallSideEffect : ~mu0_2 -# 809| mu0_53(Base) = ^IndirectMayWriteSideEffect[-1] : -# 809| v0_54(void) = ^BufferReadSideEffect[0] : &:r0_50, ~mu0_2 -# 809| mu0_55(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_50 -# 809| r0_56(glval) = Convert : v0_51 -# 809| r0_57(Base &) = CopyValue : r0_56 -# 809| r0_58(Base &) = Call : func:r0_46, this:r0_45, 0:r0_57 -# 809| mu0_59(unknown) = ^CallSideEffect : ~mu0_2 -# 809| v0_60(void) = ^BufferReadSideEffect[-1] : &:r0_45, ~mu0_2 -# 809| v0_61(void) = ^BufferReadSideEffect[0] : &:r0_57, ~mu0_2 -# 809| mu0_62(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_45 -# 809| mu0_63(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_57 -# 809| r0_64(glval) = CopyValue : r0_58 -# 810| r0_65(glval) = VariableAddress[b] : -# 810| r0_66(glval) = FunctionAddress[operator=] : -# 810| r0_67(glval) = FunctionAddress[Base] : -# 810| r0_68(glval) = VariableAddress[m] : -# 810| r0_69(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_68 -# 810| r0_70(Base &) = CopyValue : r0_69 -# 810| v0_71(void) = Call : func:r0_67, 0:r0_70 -# 810| mu0_72(unknown) = ^CallSideEffect : ~mu0_2 -# 810| mu0_73(Base) = ^IndirectMayWriteSideEffect[-1] : -# 810| v0_74(void) = ^BufferReadSideEffect[0] : &:r0_70, ~mu0_2 -# 810| mu0_75(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_70 -# 810| r0_76(glval) = Convert : v0_71 -# 810| r0_77(Base &) = CopyValue : r0_76 -# 810| r0_78(Base &) = Call : func:r0_66, this:r0_65, 0:r0_77 -# 810| mu0_79(unknown) = ^CallSideEffect : ~mu0_2 -# 810| v0_80(void) = ^BufferReadSideEffect[-1] : &:r0_65, ~mu0_2 -# 810| v0_81(void) = ^BufferReadSideEffect[0] : &:r0_77, ~mu0_2 -# 810| mu0_82(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_65 -# 810| mu0_83(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_77 -# 810| r0_84(glval) = CopyValue : r0_78 -# 811| r0_85(glval) = VariableAddress[pm] : -# 811| r0_86(Middle *) = Load : &:r0_85, ~mu0_2 -# 811| r0_87(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_86 -# 811| r0_88(glval) = VariableAddress[pb] : -# 811| mu0_89(Base *) = Store : &:r0_88, r0_87 -# 812| r0_90(glval) = VariableAddress[pm] : -# 812| r0_91(Middle *) = Load : &:r0_90, ~mu0_2 -# 812| r0_92(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_91 -# 812| r0_93(glval) = VariableAddress[pb] : -# 812| mu0_94(Base *) = Store : &:r0_93, r0_92 -# 813| r0_95(glval) = VariableAddress[pm] : -# 813| r0_96(Middle *) = Load : &:r0_95, ~mu0_2 -# 813| r0_97(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_96 -# 813| r0_98(glval) = VariableAddress[pb] : -# 813| mu0_99(Base *) = Store : &:r0_98, r0_97 -# 814| r0_100(glval) = VariableAddress[pm] : -# 814| r0_101(Middle *) = Load : &:r0_100, ~mu0_2 -# 814| r0_102(Base *) = Convert : r0_101 -# 814| r0_103(glval) = VariableAddress[pb] : -# 814| mu0_104(Base *) = Store : &:r0_103, r0_102 -# 816| r0_105(glval) = VariableAddress[m] : -# 816| r0_106(glval) = FunctionAddress[operator=] : -# 816| r0_107(glval) = VariableAddress[b] : -# 816| r0_108(glval) = ConvertToDerived[Middle : Base] : r0_107 -# 816| r0_109(glval) = Convert : r0_108 -# 816| r0_110(Middle &) = CopyValue : r0_109 -# 816| r0_111(Middle &) = Call : func:r0_106, this:r0_105, 0:r0_110 -# 816| mu0_112(unknown) = ^CallSideEffect : ~mu0_2 -# 816| v0_113(void) = ^BufferReadSideEffect[-1] : &:r0_105, ~mu0_2 -# 816| v0_114(void) = ^BufferReadSideEffect[0] : &:r0_110, ~mu0_2 -# 816| mu0_115(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_105 -# 816| mu0_116(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_110 -# 816| r0_117(glval) = CopyValue : r0_111 -# 817| r0_118(glval) = VariableAddress[m] : -# 817| r0_119(glval) = FunctionAddress[operator=] : -# 817| r0_120(glval) = VariableAddress[b] : -# 817| r0_121(glval) = ConvertToDerived[Middle : Base] : r0_120 -# 817| r0_122(glval) = Convert : r0_121 -# 817| r0_123(Middle &) = CopyValue : r0_122 -# 817| r0_124(Middle &) = Call : func:r0_119, this:r0_118, 0:r0_123 -# 817| mu0_125(unknown) = ^CallSideEffect : ~mu0_2 -# 817| v0_126(void) = ^BufferReadSideEffect[-1] : &:r0_118, ~mu0_2 -# 817| v0_127(void) = ^BufferReadSideEffect[0] : &:r0_123, ~mu0_2 -# 817| mu0_128(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_118 -# 817| mu0_129(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_123 -# 817| r0_130(glval) = CopyValue : r0_124 -# 818| r0_131(glval) = VariableAddress[pb] : -# 818| r0_132(Base *) = Load : &:r0_131, ~mu0_2 -# 818| r0_133(Middle *) = ConvertToDerived[Middle : Base] : r0_132 -# 818| r0_134(glval) = VariableAddress[pm] : -# 818| mu0_135(Middle *) = Store : &:r0_134, r0_133 -# 819| r0_136(glval) = VariableAddress[pb] : -# 819| r0_137(Base *) = Load : &:r0_136, ~mu0_2 -# 819| r0_138(Middle *) = ConvertToDerived[Middle : Base] : r0_137 -# 819| r0_139(glval) = VariableAddress[pm] : -# 819| mu0_140(Middle *) = Store : &:r0_139, r0_138 -# 820| r0_141(glval) = VariableAddress[pb] : -# 820| r0_142(Base *) = Load : &:r0_141, ~mu0_2 -# 820| r0_143(Middle *) = Convert : r0_142 -# 820| r0_144(glval) = VariableAddress[pm] : -# 820| mu0_145(Middle *) = Store : &:r0_144, r0_143 -# 822| r0_146(glval) = VariableAddress[b] : -# 822| r0_147(glval) = FunctionAddress[operator=] : -# 822| r0_148(glval) = VariableAddress[d] : -# 822| r0_149(glval) = ConvertToNonVirtualBase[Derived : Middle] : r0_148 -# 822| r0_150(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_149 -# 822| r0_151(Base &) = CopyValue : r0_150 -# 822| r0_152(Base &) = Call : func:r0_147, this:r0_146, 0:r0_151 -# 822| mu0_153(unknown) = ^CallSideEffect : ~mu0_2 -# 822| v0_154(void) = ^BufferReadSideEffect[-1] : &:r0_146, ~mu0_2 -# 822| v0_155(void) = ^BufferReadSideEffect[0] : &:r0_151, ~mu0_2 -# 822| mu0_156(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_146 -# 822| mu0_157(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_151 -# 822| r0_158(glval) = CopyValue : r0_152 -# 823| r0_159(glval) = VariableAddress[b] : -# 823| r0_160(glval) = FunctionAddress[operator=] : -# 823| r0_161(glval) = FunctionAddress[Base] : -# 823| r0_162(glval) = VariableAddress[d] : -# 823| r0_163(glval) = ConvertToNonVirtualBase[Derived : Middle] : r0_162 -# 823| r0_164(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_163 -# 823| r0_165(Base &) = CopyValue : r0_164 -# 823| v0_166(void) = Call : func:r0_161, 0:r0_165 -# 823| mu0_167(unknown) = ^CallSideEffect : ~mu0_2 -# 823| mu0_168(Base) = ^IndirectMayWriteSideEffect[-1] : -# 823| v0_169(void) = ^BufferReadSideEffect[0] : &:r0_165, ~mu0_2 -# 823| mu0_170(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_165 -# 823| r0_171(glval) = Convert : v0_166 -# 823| r0_172(Base &) = CopyValue : r0_171 -# 823| r0_173(Base &) = Call : func:r0_160, this:r0_159, 0:r0_172 -# 823| mu0_174(unknown) = ^CallSideEffect : ~mu0_2 -# 823| v0_175(void) = ^BufferReadSideEffect[-1] : &:r0_159, ~mu0_2 -# 823| v0_176(void) = ^BufferReadSideEffect[0] : &:r0_172, ~mu0_2 -# 823| mu0_177(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_159 -# 823| mu0_178(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_172 -# 823| r0_179(glval) = CopyValue : r0_173 -# 824| r0_180(glval) = VariableAddress[b] : -# 824| r0_181(glval) = FunctionAddress[operator=] : -# 824| r0_182(glval) = FunctionAddress[Base] : -# 824| r0_183(glval) = VariableAddress[d] : -# 824| r0_184(glval) = ConvertToNonVirtualBase[Derived : Middle] : r0_183 -# 824| r0_185(glval) = ConvertToNonVirtualBase[Middle : Base] : r0_184 -# 824| r0_186(Base &) = CopyValue : r0_185 -# 824| v0_187(void) = Call : func:r0_182, 0:r0_186 -# 824| mu0_188(unknown) = ^CallSideEffect : ~mu0_2 -# 824| mu0_189(Base) = ^IndirectMayWriteSideEffect[-1] : -# 824| v0_190(void) = ^BufferReadSideEffect[0] : &:r0_186, ~mu0_2 -# 824| mu0_191(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_186 -# 824| r0_192(glval) = Convert : v0_187 -# 824| r0_193(Base &) = CopyValue : r0_192 -# 824| r0_194(Base &) = Call : func:r0_181, this:r0_180, 0:r0_193 -# 824| mu0_195(unknown) = ^CallSideEffect : ~mu0_2 -# 824| v0_196(void) = ^BufferReadSideEffect[-1] : &:r0_180, ~mu0_2 -# 824| v0_197(void) = ^BufferReadSideEffect[0] : &:r0_193, ~mu0_2 -# 824| mu0_198(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_180 -# 824| mu0_199(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_193 -# 824| r0_200(glval) = CopyValue : r0_194 -# 825| r0_201(glval) = VariableAddress[pd] : -# 825| r0_202(Derived *) = Load : &:r0_201, ~mu0_2 -# 825| r0_203(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_202 -# 825| r0_204(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_203 -# 825| r0_205(glval) = VariableAddress[pb] : -# 825| mu0_206(Base *) = Store : &:r0_205, r0_204 -# 826| r0_207(glval) = VariableAddress[pd] : -# 826| r0_208(Derived *) = Load : &:r0_207, ~mu0_2 -# 826| r0_209(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_208 -# 826| r0_210(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_209 -# 826| r0_211(glval) = VariableAddress[pb] : -# 826| mu0_212(Base *) = Store : &:r0_211, r0_210 -# 827| r0_213(glval) = VariableAddress[pd] : -# 827| r0_214(Derived *) = Load : &:r0_213, ~mu0_2 -# 827| r0_215(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_214 -# 827| r0_216(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_215 -# 827| r0_217(glval) = VariableAddress[pb] : -# 827| mu0_218(Base *) = Store : &:r0_217, r0_216 -# 828| r0_219(glval) = VariableAddress[pd] : -# 828| r0_220(Derived *) = Load : &:r0_219, ~mu0_2 -# 828| r0_221(Base *) = Convert : r0_220 -# 828| r0_222(glval) = VariableAddress[pb] : -# 828| mu0_223(Base *) = Store : &:r0_222, r0_221 -# 830| r0_224(glval) = VariableAddress[d] : -# 830| r0_225(glval) = FunctionAddress[operator=] : -# 830| r0_226(glval) = VariableAddress[b] : -# 830| r0_227(glval) = ConvertToDerived[Middle : Base] : r0_226 -# 830| r0_228(glval) = ConvertToDerived[Derived : Middle] : r0_227 -# 830| r0_229(glval) = Convert : r0_228 -# 830| r0_230(Derived &) = CopyValue : r0_229 -# 830| r0_231(Derived &) = Call : func:r0_225, this:r0_224, 0:r0_230 -# 830| mu0_232(unknown) = ^CallSideEffect : ~mu0_2 -# 830| v0_233(void) = ^BufferReadSideEffect[-1] : &:r0_224, ~mu0_2 -# 830| v0_234(void) = ^BufferReadSideEffect[0] : &:r0_230, ~mu0_2 -# 830| mu0_235(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_224 -# 830| mu0_236(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_230 -# 830| r0_237(glval) = CopyValue : r0_231 -# 831| r0_238(glval) = VariableAddress[d] : -# 831| r0_239(glval) = FunctionAddress[operator=] : -# 831| r0_240(glval) = VariableAddress[b] : -# 831| r0_241(glval) = ConvertToDerived[Middle : Base] : r0_240 -# 831| r0_242(glval) = ConvertToDerived[Derived : Middle] : r0_241 -# 831| r0_243(glval) = Convert : r0_242 -# 831| r0_244(Derived &) = CopyValue : r0_243 -# 831| r0_245(Derived &) = Call : func:r0_239, this:r0_238, 0:r0_244 -# 831| mu0_246(unknown) = ^CallSideEffect : ~mu0_2 -# 831| v0_247(void) = ^BufferReadSideEffect[-1] : &:r0_238, ~mu0_2 -# 831| v0_248(void) = ^BufferReadSideEffect[0] : &:r0_244, ~mu0_2 -# 831| mu0_249(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_238 -# 831| mu0_250(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_244 -# 831| r0_251(glval) = CopyValue : r0_245 -# 832| r0_252(glval) = VariableAddress[pb] : -# 832| r0_253(Base *) = Load : &:r0_252, ~mu0_2 -# 832| r0_254(Middle *) = ConvertToDerived[Middle : Base] : r0_253 -# 832| r0_255(Derived *) = ConvertToDerived[Derived : Middle] : r0_254 -# 832| r0_256(glval) = VariableAddress[pd] : -# 832| mu0_257(Derived *) = Store : &:r0_256, r0_255 -# 833| r0_258(glval) = VariableAddress[pb] : -# 833| r0_259(Base *) = Load : &:r0_258, ~mu0_2 -# 833| r0_260(Middle *) = ConvertToDerived[Middle : Base] : r0_259 -# 833| r0_261(Derived *) = ConvertToDerived[Derived : Middle] : r0_260 -# 833| r0_262(glval) = VariableAddress[pd] : -# 833| mu0_263(Derived *) = Store : &:r0_262, r0_261 -# 834| r0_264(glval) = VariableAddress[pb] : -# 834| r0_265(Base *) = Load : &:r0_264, ~mu0_2 -# 834| r0_266(Derived *) = Convert : r0_265 -# 834| r0_267(glval) = VariableAddress[pd] : -# 834| mu0_268(Derived *) = Store : &:r0_267, r0_266 -# 836| r0_269(glval) = VariableAddress[pmv] : -# 836| r0_270(MiddleVB1 *) = Constant[0] : -# 836| mu0_271(MiddleVB1 *) = Store : &:r0_269, r0_270 -# 837| r0_272(glval) = VariableAddress[pdv] : -# 837| r0_273(DerivedVB *) = Constant[0] : -# 837| mu0_274(DerivedVB *) = Store : &:r0_272, r0_273 -# 838| r0_275(glval) = VariableAddress[pmv] : -# 838| r0_276(MiddleVB1 *) = Load : &:r0_275, ~mu0_2 -# 838| r0_277(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_276 -# 838| r0_278(glval) = VariableAddress[pb] : -# 838| mu0_279(Base *) = Store : &:r0_278, r0_277 -# 839| r0_280(glval) = VariableAddress[pdv] : -# 839| r0_281(DerivedVB *) = Load : &:r0_280, ~mu0_2 -# 839| r0_282(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_281 -# 839| r0_283(glval) = VariableAddress[pb] : -# 839| mu0_284(Base *) = Store : &:r0_283, r0_282 -# 840| v0_285(void) = NoOp : -# 799| v0_286(void) = ReturnVoid : -# 799| v0_287(void) = UnmodeledUse : mu* -# 799| v0_288(void) = AliasedUse : ~mu0_2 -# 799| v0_289(void) = ExitFunction : +# 799| v799_1(void) = EnterFunction : +# 799| mu799_2(unknown) = AliasedDefinition : +# 799| mu799_3(unknown) = UnmodeledDefinition : +# 800| r800_1(glval) = VariableAddress[b] : +# 800| mu800_2(Base) = Uninitialized[b] : &:r800_1 +# 800| r800_3(glval) = FunctionAddress[Base] : +# 800| v800_4(void) = Call : func:r800_3, this:r800_1 +# 800| mu800_5(unknown) = ^CallSideEffect : ~mu799_3 +# 800| mu800_6(Base) = ^IndirectMayWriteSideEffect[-1] : &:r800_1 +# 801| r801_1(glval) = VariableAddress[m] : +# 801| mu801_2(Middle) = Uninitialized[m] : &:r801_1 +# 801| r801_3(glval) = FunctionAddress[Middle] : +# 801| v801_4(void) = Call : func:r801_3, this:r801_1 +# 801| mu801_5(unknown) = ^CallSideEffect : ~mu799_3 +# 801| mu801_6(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r801_1 +# 802| r802_1(glval) = VariableAddress[d] : +# 802| mu802_2(Derived) = Uninitialized[d] : &:r802_1 +# 802| r802_3(glval) = FunctionAddress[Derived] : +# 802| v802_4(void) = Call : func:r802_3, this:r802_1 +# 802| mu802_5(unknown) = ^CallSideEffect : ~mu799_3 +# 802| mu802_6(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r802_1 +# 804| r804_1(glval) = VariableAddress[pb] : +# 804| r804_2(glval) = VariableAddress[b] : +# 804| r804_3(Base *) = CopyValue : r804_2 +# 804| mu804_4(Base *) = Store : &:r804_1, r804_3 +# 805| r805_1(glval) = VariableAddress[pm] : +# 805| r805_2(glval) = VariableAddress[m] : +# 805| r805_3(Middle *) = CopyValue : r805_2 +# 805| mu805_4(Middle *) = Store : &:r805_1, r805_3 +# 806| r806_1(glval) = VariableAddress[pd] : +# 806| r806_2(glval) = VariableAddress[d] : +# 806| r806_3(Derived *) = CopyValue : r806_2 +# 806| mu806_4(Derived *) = Store : &:r806_1, r806_3 +# 808| r808_1(glval) = VariableAddress[b] : +# 808| r808_2(glval) = FunctionAddress[operator=] : +# 808| r808_3(glval) = VariableAddress[m] : +# 808| r808_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r808_3 +# 808| r808_5(Base &) = CopyValue : r808_4 +# 808| r808_6(Base &) = Call : func:r808_2, this:r808_1, 0:r808_5 +# 808| mu808_7(unknown) = ^CallSideEffect : ~mu799_3 +# 808| v808_8(void) = ^BufferReadSideEffect[-1] : &:r808_1, ~mu799_3 +# 808| v808_9(void) = ^BufferReadSideEffect[0] : &:r808_5, ~mu799_3 +# 808| mu808_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r808_1 +# 808| mu808_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r808_5 +# 808| r808_12(glval) = CopyValue : r808_6 +# 809| r809_1(glval) = VariableAddress[b] : +# 809| r809_2(glval) = FunctionAddress[operator=] : +# 809| r809_3(glval) = FunctionAddress[Base] : +# 809| r809_4(glval) = VariableAddress[m] : +# 809| r809_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r809_4 +# 809| r809_6(Base &) = CopyValue : r809_5 +# 809| v809_7(void) = Call : func:r809_3, 0:r809_6 +# 809| mu809_8(unknown) = ^CallSideEffect : ~mu799_3 +# 809| mu809_9(Base) = ^IndirectMayWriteSideEffect[-1] : +# 809| v809_10(void) = ^BufferReadSideEffect[0] : &:r809_6, ~mu799_3 +# 809| mu809_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_6 +# 809| r809_12(glval) = Convert : v809_7 +# 809| r809_13(Base &) = CopyValue : r809_12 +# 809| r809_14(Base &) = Call : func:r809_2, this:r809_1, 0:r809_13 +# 809| mu809_15(unknown) = ^CallSideEffect : ~mu799_3 +# 809| v809_16(void) = ^BufferReadSideEffect[-1] : &:r809_1, ~mu799_3 +# 809| v809_17(void) = ^BufferReadSideEffect[0] : &:r809_13, ~mu799_3 +# 809| mu809_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r809_1 +# 809| mu809_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_13 +# 809| r809_20(glval) = CopyValue : r809_14 +# 810| r810_1(glval) = VariableAddress[b] : +# 810| r810_2(glval) = FunctionAddress[operator=] : +# 810| r810_3(glval) = FunctionAddress[Base] : +# 810| r810_4(glval) = VariableAddress[m] : +# 810| r810_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r810_4 +# 810| r810_6(Base &) = CopyValue : r810_5 +# 810| v810_7(void) = Call : func:r810_3, 0:r810_6 +# 810| mu810_8(unknown) = ^CallSideEffect : ~mu799_3 +# 810| mu810_9(Base) = ^IndirectMayWriteSideEffect[-1] : +# 810| v810_10(void) = ^BufferReadSideEffect[0] : &:r810_6, ~mu799_3 +# 810| mu810_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_6 +# 810| r810_12(glval) = Convert : v810_7 +# 810| r810_13(Base &) = CopyValue : r810_12 +# 810| r810_14(Base &) = Call : func:r810_2, this:r810_1, 0:r810_13 +# 810| mu810_15(unknown) = ^CallSideEffect : ~mu799_3 +# 810| v810_16(void) = ^BufferReadSideEffect[-1] : &:r810_1, ~mu799_3 +# 810| v810_17(void) = ^BufferReadSideEffect[0] : &:r810_13, ~mu799_3 +# 810| mu810_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r810_1 +# 810| mu810_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_13 +# 810| r810_20(glval) = CopyValue : r810_14 +# 811| r811_1(glval) = VariableAddress[pm] : +# 811| r811_2(Middle *) = Load : &:r811_1, ~mu799_3 +# 811| r811_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r811_2 +# 811| r811_4(glval) = VariableAddress[pb] : +# 811| mu811_5(Base *) = Store : &:r811_4, r811_3 +# 812| r812_1(glval) = VariableAddress[pm] : +# 812| r812_2(Middle *) = Load : &:r812_1, ~mu799_3 +# 812| r812_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r812_2 +# 812| r812_4(glval) = VariableAddress[pb] : +# 812| mu812_5(Base *) = Store : &:r812_4, r812_3 +# 813| r813_1(glval) = VariableAddress[pm] : +# 813| r813_2(Middle *) = Load : &:r813_1, ~mu799_3 +# 813| r813_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r813_2 +# 813| r813_4(glval) = VariableAddress[pb] : +# 813| mu813_5(Base *) = Store : &:r813_4, r813_3 +# 814| r814_1(glval) = VariableAddress[pm] : +# 814| r814_2(Middle *) = Load : &:r814_1, ~mu799_3 +# 814| r814_3(Base *) = Convert : r814_2 +# 814| r814_4(glval) = VariableAddress[pb] : +# 814| mu814_5(Base *) = Store : &:r814_4, r814_3 +# 816| r816_1(glval) = VariableAddress[m] : +# 816| r816_2(glval) = FunctionAddress[operator=] : +# 816| r816_3(glval) = VariableAddress[b] : +# 816| r816_4(glval) = ConvertToDerived[Middle : Base] : r816_3 +# 816| r816_5(glval) = Convert : r816_4 +# 816| r816_6(Middle &) = CopyValue : r816_5 +# 816| r816_7(Middle &) = Call : func:r816_2, this:r816_1, 0:r816_6 +# 816| mu816_8(unknown) = ^CallSideEffect : ~mu799_3 +# 816| v816_9(void) = ^BufferReadSideEffect[-1] : &:r816_1, ~mu799_3 +# 816| v816_10(void) = ^BufferReadSideEffect[0] : &:r816_6, ~mu799_3 +# 816| mu816_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r816_1 +# 816| mu816_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r816_6 +# 816| r816_13(glval) = CopyValue : r816_7 +# 817| r817_1(glval) = VariableAddress[m] : +# 817| r817_2(glval) = FunctionAddress[operator=] : +# 817| r817_3(glval) = VariableAddress[b] : +# 817| r817_4(glval) = ConvertToDerived[Middle : Base] : r817_3 +# 817| r817_5(glval) = Convert : r817_4 +# 817| r817_6(Middle &) = CopyValue : r817_5 +# 817| r817_7(Middle &) = Call : func:r817_2, this:r817_1, 0:r817_6 +# 817| mu817_8(unknown) = ^CallSideEffect : ~mu799_3 +# 817| v817_9(void) = ^BufferReadSideEffect[-1] : &:r817_1, ~mu799_3 +# 817| v817_10(void) = ^BufferReadSideEffect[0] : &:r817_6, ~mu799_3 +# 817| mu817_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r817_1 +# 817| mu817_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r817_6 +# 817| r817_13(glval) = CopyValue : r817_7 +# 818| r818_1(glval) = VariableAddress[pb] : +# 818| r818_2(Base *) = Load : &:r818_1, ~mu799_3 +# 818| r818_3(Middle *) = ConvertToDerived[Middle : Base] : r818_2 +# 818| r818_4(glval) = VariableAddress[pm] : +# 818| mu818_5(Middle *) = Store : &:r818_4, r818_3 +# 819| r819_1(glval) = VariableAddress[pb] : +# 819| r819_2(Base *) = Load : &:r819_1, ~mu799_3 +# 819| r819_3(Middle *) = ConvertToDerived[Middle : Base] : r819_2 +# 819| r819_4(glval) = VariableAddress[pm] : +# 819| mu819_5(Middle *) = Store : &:r819_4, r819_3 +# 820| r820_1(glval) = VariableAddress[pb] : +# 820| r820_2(Base *) = Load : &:r820_1, ~mu799_3 +# 820| r820_3(Middle *) = Convert : r820_2 +# 820| r820_4(glval) = VariableAddress[pm] : +# 820| mu820_5(Middle *) = Store : &:r820_4, r820_3 +# 822| r822_1(glval) = VariableAddress[b] : +# 822| r822_2(glval) = FunctionAddress[operator=] : +# 822| r822_3(glval) = VariableAddress[d] : +# 822| r822_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r822_3 +# 822| r822_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r822_4 +# 822| r822_6(Base &) = CopyValue : r822_5 +# 822| r822_7(Base &) = Call : func:r822_2, this:r822_1, 0:r822_6 +# 822| mu822_8(unknown) = ^CallSideEffect : ~mu799_3 +# 822| v822_9(void) = ^BufferReadSideEffect[-1] : &:r822_1, ~mu799_3 +# 822| v822_10(void) = ^BufferReadSideEffect[0] : &:r822_6, ~mu799_3 +# 822| mu822_11(Base) = ^IndirectMayWriteSideEffect[-1] : &:r822_1 +# 822| mu822_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r822_6 +# 822| r822_13(glval) = CopyValue : r822_7 +# 823| r823_1(glval) = VariableAddress[b] : +# 823| r823_2(glval) = FunctionAddress[operator=] : +# 823| r823_3(glval) = FunctionAddress[Base] : +# 823| r823_4(glval) = VariableAddress[d] : +# 823| r823_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r823_4 +# 823| r823_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r823_5 +# 823| r823_7(Base &) = CopyValue : r823_6 +# 823| v823_8(void) = Call : func:r823_3, 0:r823_7 +# 823| mu823_9(unknown) = ^CallSideEffect : ~mu799_3 +# 823| mu823_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 823| v823_11(void) = ^BufferReadSideEffect[0] : &:r823_7, ~mu799_3 +# 823| mu823_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_7 +# 823| r823_13(glval) = Convert : v823_8 +# 823| r823_14(Base &) = CopyValue : r823_13 +# 823| r823_15(Base &) = Call : func:r823_2, this:r823_1, 0:r823_14 +# 823| mu823_16(unknown) = ^CallSideEffect : ~mu799_3 +# 823| v823_17(void) = ^BufferReadSideEffect[-1] : &:r823_1, ~mu799_3 +# 823| v823_18(void) = ^BufferReadSideEffect[0] : &:r823_14, ~mu799_3 +# 823| mu823_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r823_1 +# 823| mu823_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_14 +# 823| r823_21(glval) = CopyValue : r823_15 +# 824| r824_1(glval) = VariableAddress[b] : +# 824| r824_2(glval) = FunctionAddress[operator=] : +# 824| r824_3(glval) = FunctionAddress[Base] : +# 824| r824_4(glval) = VariableAddress[d] : +# 824| r824_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r824_4 +# 824| r824_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r824_5 +# 824| r824_7(Base &) = CopyValue : r824_6 +# 824| v824_8(void) = Call : func:r824_3, 0:r824_7 +# 824| mu824_9(unknown) = ^CallSideEffect : ~mu799_3 +# 824| mu824_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 824| v824_11(void) = ^BufferReadSideEffect[0] : &:r824_7, ~mu799_3 +# 824| mu824_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_7 +# 824| r824_13(glval) = Convert : v824_8 +# 824| r824_14(Base &) = CopyValue : r824_13 +# 824| r824_15(Base &) = Call : func:r824_2, this:r824_1, 0:r824_14 +# 824| mu824_16(unknown) = ^CallSideEffect : ~mu799_3 +# 824| v824_17(void) = ^BufferReadSideEffect[-1] : &:r824_1, ~mu799_3 +# 824| v824_18(void) = ^BufferReadSideEffect[0] : &:r824_14, ~mu799_3 +# 824| mu824_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r824_1 +# 824| mu824_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_14 +# 824| r824_21(glval) = CopyValue : r824_15 +# 825| r825_1(glval) = VariableAddress[pd] : +# 825| r825_2(Derived *) = Load : &:r825_1, ~mu799_3 +# 825| r825_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r825_2 +# 825| r825_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r825_3 +# 825| r825_5(glval) = VariableAddress[pb] : +# 825| mu825_6(Base *) = Store : &:r825_5, r825_4 +# 826| r826_1(glval) = VariableAddress[pd] : +# 826| r826_2(Derived *) = Load : &:r826_1, ~mu799_3 +# 826| r826_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r826_2 +# 826| r826_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r826_3 +# 826| r826_5(glval) = VariableAddress[pb] : +# 826| mu826_6(Base *) = Store : &:r826_5, r826_4 +# 827| r827_1(glval) = VariableAddress[pd] : +# 827| r827_2(Derived *) = Load : &:r827_1, ~mu799_3 +# 827| r827_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r827_2 +# 827| r827_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r827_3 +# 827| r827_5(glval) = VariableAddress[pb] : +# 827| mu827_6(Base *) = Store : &:r827_5, r827_4 +# 828| r828_1(glval) = VariableAddress[pd] : +# 828| r828_2(Derived *) = Load : &:r828_1, ~mu799_3 +# 828| r828_3(Base *) = Convert : r828_2 +# 828| r828_4(glval) = VariableAddress[pb] : +# 828| mu828_5(Base *) = Store : &:r828_4, r828_3 +# 830| r830_1(glval) = VariableAddress[d] : +# 830| r830_2(glval) = FunctionAddress[operator=] : +# 830| r830_3(glval) = VariableAddress[b] : +# 830| r830_4(glval) = ConvertToDerived[Middle : Base] : r830_3 +# 830| r830_5(glval) = ConvertToDerived[Derived : Middle] : r830_4 +# 830| r830_6(glval) = Convert : r830_5 +# 830| r830_7(Derived &) = CopyValue : r830_6 +# 830| r830_8(Derived &) = Call : func:r830_2, this:r830_1, 0:r830_7 +# 830| mu830_9(unknown) = ^CallSideEffect : ~mu799_3 +# 830| v830_10(void) = ^BufferReadSideEffect[-1] : &:r830_1, ~mu799_3 +# 830| v830_11(void) = ^BufferReadSideEffect[0] : &:r830_7, ~mu799_3 +# 830| mu830_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r830_1 +# 830| mu830_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r830_7 +# 830| r830_14(glval) = CopyValue : r830_8 +# 831| r831_1(glval) = VariableAddress[d] : +# 831| r831_2(glval) = FunctionAddress[operator=] : +# 831| r831_3(glval) = VariableAddress[b] : +# 831| r831_4(glval) = ConvertToDerived[Middle : Base] : r831_3 +# 831| r831_5(glval) = ConvertToDerived[Derived : Middle] : r831_4 +# 831| r831_6(glval) = Convert : r831_5 +# 831| r831_7(Derived &) = CopyValue : r831_6 +# 831| r831_8(Derived &) = Call : func:r831_2, this:r831_1, 0:r831_7 +# 831| mu831_9(unknown) = ^CallSideEffect : ~mu799_3 +# 831| v831_10(void) = ^BufferReadSideEffect[-1] : &:r831_1, ~mu799_3 +# 831| v831_11(void) = ^BufferReadSideEffect[0] : &:r831_7, ~mu799_3 +# 831| mu831_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r831_1 +# 831| mu831_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r831_7 +# 831| r831_14(glval) = CopyValue : r831_8 +# 832| r832_1(glval) = VariableAddress[pb] : +# 832| r832_2(Base *) = Load : &:r832_1, ~mu799_3 +# 832| r832_3(Middle *) = ConvertToDerived[Middle : Base] : r832_2 +# 832| r832_4(Derived *) = ConvertToDerived[Derived : Middle] : r832_3 +# 832| r832_5(glval) = VariableAddress[pd] : +# 832| mu832_6(Derived *) = Store : &:r832_5, r832_4 +# 833| r833_1(glval) = VariableAddress[pb] : +# 833| r833_2(Base *) = Load : &:r833_1, ~mu799_3 +# 833| r833_3(Middle *) = ConvertToDerived[Middle : Base] : r833_2 +# 833| r833_4(Derived *) = ConvertToDerived[Derived : Middle] : r833_3 +# 833| r833_5(glval) = VariableAddress[pd] : +# 833| mu833_6(Derived *) = Store : &:r833_5, r833_4 +# 834| r834_1(glval) = VariableAddress[pb] : +# 834| r834_2(Base *) = Load : &:r834_1, ~mu799_3 +# 834| r834_3(Derived *) = Convert : r834_2 +# 834| r834_4(glval) = VariableAddress[pd] : +# 834| mu834_5(Derived *) = Store : &:r834_4, r834_3 +# 836| r836_1(glval) = VariableAddress[pmv] : +# 836| r836_2(MiddleVB1 *) = Constant[0] : +# 836| mu836_3(MiddleVB1 *) = Store : &:r836_1, r836_2 +# 837| r837_1(glval) = VariableAddress[pdv] : +# 837| r837_2(DerivedVB *) = Constant[0] : +# 837| mu837_3(DerivedVB *) = Store : &:r837_1, r837_2 +# 838| r838_1(glval) = VariableAddress[pmv] : +# 838| r838_2(MiddleVB1 *) = Load : &:r838_1, ~mu799_3 +# 838| r838_3(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r838_2 +# 838| r838_4(glval) = VariableAddress[pb] : +# 838| mu838_5(Base *) = Store : &:r838_4, r838_3 +# 839| r839_1(glval) = VariableAddress[pdv] : +# 839| r839_2(DerivedVB *) = Load : &:r839_1, ~mu799_3 +# 839| r839_3(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r839_2 +# 839| r839_4(glval) = VariableAddress[pb] : +# 839| mu839_5(Base *) = Store : &:r839_4, r839_3 +# 840| v840_1(void) = NoOp : +# 799| v799_4(void) = ReturnVoid : +# 799| v799_5(void) = UnmodeledUse : mu* +# 799| v799_6(void) = AliasedUse : ~mu799_3 +# 799| v799_7(void) = ExitFunction : # 842| void PolymorphicBase::PolymorphicBase() # 842| Block 0 -# 842| v0_0(void) = EnterFunction : -# 842| mu0_1(unknown) = AliasedDefinition : -# 842| mu0_2(unknown) = UnmodeledDefinition : -# 842| r0_3(glval) = InitializeThis : -# 842| v0_4(void) = NoOp : -# 842| v0_5(void) = ReturnVoid : -# 842| v0_6(void) = UnmodeledUse : mu* -# 842| v0_7(void) = AliasedUse : ~mu0_2 -# 842| v0_8(void) = ExitFunction : +# 842| v842_1(void) = EnterFunction : +# 842| mu842_2(unknown) = AliasedDefinition : +# 842| mu842_3(unknown) = UnmodeledDefinition : +# 842| r842_4(glval) = InitializeThis : +# 842| v842_5(void) = NoOp : +# 842| v842_6(void) = ReturnVoid : +# 842| v842_7(void) = UnmodeledUse : mu* +# 842| v842_8(void) = AliasedUse : ~mu842_3 +# 842| v842_9(void) = ExitFunction : # 846| void PolymorphicDerived::PolymorphicDerived() # 846| Block 0 -# 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = AliasedDefinition : -# 846| mu0_2(unknown) = UnmodeledDefinition : -# 846| r0_3(glval) = InitializeThis : -# 846| r0_4(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r0_3 -# 846| r0_5(glval) = FunctionAddress[PolymorphicBase] : -# 846| v0_6(void) = Call : func:r0_5, this:r0_4 -# 846| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 846| mu0_8(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r0_4 -# 846| v0_9(void) = NoOp : -# 846| v0_10(void) = ReturnVoid : -# 846| v0_11(void) = UnmodeledUse : mu* -# 846| v0_12(void) = AliasedUse : ~mu0_2 -# 846| v0_13(void) = ExitFunction : +# 846| v846_1(void) = EnterFunction : +# 846| mu846_3(unknown) = AliasedDefinition : +# 846| mu846_5(unknown) = UnmodeledDefinition : +# 846| r846_7(glval) = InitializeThis : +# 846| r846_9(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_7 +# 846| r846_10(glval) = FunctionAddress[PolymorphicBase] : +# 846| v846_12(void) = Call : func:r846_10, this:r846_9 +# 846| mu846_14(unknown) = ^CallSideEffect : ~mu846_5 +# 846| mu846_16(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r846_9 +# 846| v846_18(void) = NoOp : +# 846| v846_20(void) = ReturnVoid : +# 846| v846_22(void) = UnmodeledUse : mu* +# 846| v846_24(void) = AliasedUse : ~mu846_5 +# 846| v846_26(void) = ExitFunction : # 846| void PolymorphicDerived::~PolymorphicDerived() # 846| Block 0 -# 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = AliasedDefinition : -# 846| mu0_2(unknown) = UnmodeledDefinition : -# 846| r0_3(glval) = InitializeThis : -#-----| v0_4(void) = NoOp : -# 846| r0_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r0_3 -# 846| r0_6(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v0_7(void) = Call : func:r0_6, this:r0_5 -# 846| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 846| v0_9(void) = ReturnVoid : -# 846| v0_10(void) = UnmodeledUse : mu* -# 846| v0_11(void) = AliasedUse : ~mu0_2 -# 846| v0_12(void) = ExitFunction : +# 846| v846_1(void) = EnterFunction : +# 846| mu846_3(unknown) = AliasedDefinition : +# 846| mu846_5(unknown) = UnmodeledDefinition : +# 846| r846_7(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 846| r846_10(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_7 +# 846| r846_12(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v846_14(void) = Call : func:r846_12, this:r846_10 +# 846| mu846_16(unknown) = ^CallSideEffect : ~mu846_5 +# 846| v846_18(void) = ReturnVoid : +# 846| v846_20(void) = UnmodeledUse : mu* +# 846| v846_22(void) = AliasedUse : ~mu846_5 +# 846| v846_24(void) = ExitFunction : # 849| void DynamicCast() # 849| Block 0 -# 849| v0_0(void) = EnterFunction : -# 849| mu0_1(unknown) = AliasedDefinition : -# 849| mu0_2(unknown) = UnmodeledDefinition : -# 850| r0_3(glval) = VariableAddress[b] : -# 850| mu0_4(PolymorphicBase) = Uninitialized[b] : &:r0_3 -#-----| r0_5(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_6(void) = Call : func:r0_5, this:r0_3 -#-----| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -#-----| mu0_8(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 851| r0_9(glval) = VariableAddress[d] : -# 851| mu0_10(PolymorphicDerived) = Uninitialized[d] : &:r0_9 -# 851| r0_11(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v0_12(void) = Call : func:r0_11, this:r0_9 -# 851| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 851| mu0_14(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -# 853| r0_15(glval) = VariableAddress[pb] : -# 853| r0_16(glval) = VariableAddress[b] : -# 853| r0_17(PolymorphicBase *) = CopyValue : r0_16 -# 853| mu0_18(PolymorphicBase *) = Store : &:r0_15, r0_17 -# 854| r0_19(glval) = VariableAddress[pd] : -# 854| r0_20(glval) = VariableAddress[d] : -# 854| r0_21(PolymorphicDerived *) = CopyValue : r0_20 -# 854| mu0_22(PolymorphicDerived *) = Store : &:r0_19, r0_21 -# 857| r0_23(glval) = VariableAddress[pd] : -# 857| r0_24(PolymorphicDerived *) = Load : &:r0_23, ~mu0_2 -# 857| r0_25(PolymorphicBase *) = CheckedConvertOrNull : r0_24 -# 857| r0_26(glval) = VariableAddress[pb] : -# 857| mu0_27(PolymorphicBase *) = Store : &:r0_26, r0_25 -# 858| r0_28(glval) = VariableAddress[rb] : -# 858| r0_29(glval) = VariableAddress[d] : -# 858| r0_30(glval) = CheckedConvertOrThrow : r0_29 -# 858| r0_31(PolymorphicBase &) = CopyValue : r0_30 -# 858| mu0_32(PolymorphicBase &) = Store : &:r0_28, r0_31 -# 860| r0_33(glval) = VariableAddress[pb] : -# 860| r0_34(PolymorphicBase *) = Load : &:r0_33, ~mu0_2 -# 860| r0_35(PolymorphicDerived *) = CheckedConvertOrNull : r0_34 -# 860| r0_36(glval) = VariableAddress[pd] : -# 860| mu0_37(PolymorphicDerived *) = Store : &:r0_36, r0_35 -# 861| r0_38(glval) = VariableAddress[rd] : -# 861| r0_39(glval) = VariableAddress[b] : -# 861| r0_40(glval) = CheckedConvertOrThrow : r0_39 -# 861| r0_41(PolymorphicDerived &) = CopyValue : r0_40 -# 861| mu0_42(PolymorphicDerived &) = Store : &:r0_38, r0_41 -# 863| r0_43(glval) = VariableAddress[pv] : -# 863| r0_44(glval) = VariableAddress[pb] : -# 863| r0_45(PolymorphicBase *) = Load : &:r0_44, ~mu0_2 -# 863| r0_46(void *) = DynamicCastToVoid : r0_45 -# 863| mu0_47(void *) = Store : &:r0_43, r0_46 -# 864| r0_48(glval) = VariableAddress[pcv] : -# 864| r0_49(glval) = VariableAddress[pd] : -# 864| r0_50(PolymorphicDerived *) = Load : &:r0_49, ~mu0_2 -# 864| r0_51(void *) = DynamicCastToVoid : r0_50 -# 864| mu0_52(void *) = Store : &:r0_48, r0_51 -# 865| v0_53(void) = NoOp : -# 849| v0_54(void) = ReturnVoid : -# 849| v0_55(void) = UnmodeledUse : mu* -# 849| v0_56(void) = AliasedUse : ~mu0_2 -# 849| v0_57(void) = ExitFunction : +# 849| v849_1(void) = EnterFunction : +# 849| mu849_2(unknown) = AliasedDefinition : +# 849| mu849_3(unknown) = UnmodeledDefinition : +# 850| r850_1(glval) = VariableAddress[b] : +# 850| mu850_2(PolymorphicBase) = Uninitialized[b] : &:r850_1 +#-----| r0_8(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_13(void) = Call : func:r0_8, this:r850_1 +#-----| mu0_17(unknown) = ^CallSideEffect : ~mu849_3 +#-----| mu0_27(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r850_1 +# 851| r851_1(glval) = VariableAddress[d] : +# 851| mu851_2(PolymorphicDerived) = Uninitialized[d] : &:r851_1 +# 851| r851_3(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v851_4(void) = Call : func:r851_3, this:r851_1 +# 851| mu851_5(unknown) = ^CallSideEffect : ~mu849_3 +# 851| mu851_6(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r851_1 +# 853| r853_1(glval) = VariableAddress[pb] : +# 853| r853_2(glval) = VariableAddress[b] : +# 853| r853_3(PolymorphicBase *) = CopyValue : r853_2 +# 853| mu853_4(PolymorphicBase *) = Store : &:r853_1, r853_3 +# 854| r854_1(glval) = VariableAddress[pd] : +# 854| r854_2(glval) = VariableAddress[d] : +# 854| r854_3(PolymorphicDerived *) = CopyValue : r854_2 +# 854| mu854_4(PolymorphicDerived *) = Store : &:r854_1, r854_3 +# 857| r857_1(glval) = VariableAddress[pd] : +# 857| r857_2(PolymorphicDerived *) = Load : &:r857_1, ~mu849_3 +# 857| r857_3(PolymorphicBase *) = CheckedConvertOrNull : r857_2 +# 857| r857_4(glval) = VariableAddress[pb] : +# 857| mu857_5(PolymorphicBase *) = Store : &:r857_4, r857_3 +# 858| r858_1(glval) = VariableAddress[rb] : +# 858| r858_2(glval) = VariableAddress[d] : +# 858| r858_3(glval) = CheckedConvertOrThrow : r858_2 +# 858| r858_4(PolymorphicBase &) = CopyValue : r858_3 +# 858| mu858_5(PolymorphicBase &) = Store : &:r858_1, r858_4 +# 860| r860_1(glval) = VariableAddress[pb] : +# 860| r860_2(PolymorphicBase *) = Load : &:r860_1, ~mu849_3 +# 860| r860_3(PolymorphicDerived *) = CheckedConvertOrNull : r860_2 +# 860| r860_4(glval) = VariableAddress[pd] : +# 860| mu860_5(PolymorphicDerived *) = Store : &:r860_4, r860_3 +# 861| r861_1(glval) = VariableAddress[rd] : +# 861| r861_2(glval) = VariableAddress[b] : +# 861| r861_3(glval) = CheckedConvertOrThrow : r861_2 +# 861| r861_4(PolymorphicDerived &) = CopyValue : r861_3 +# 861| mu861_5(PolymorphicDerived &) = Store : &:r861_1, r861_4 +# 863| r863_1(glval) = VariableAddress[pv] : +# 863| r863_2(glval) = VariableAddress[pb] : +# 863| r863_3(PolymorphicBase *) = Load : &:r863_2, ~mu849_3 +# 863| r863_4(void *) = DynamicCastToVoid : r863_3 +# 863| mu863_5(void *) = Store : &:r863_1, r863_4 +# 864| r864_1(glval) = VariableAddress[pcv] : +# 864| r864_2(glval) = VariableAddress[pd] : +# 864| r864_3(PolymorphicDerived *) = Load : &:r864_2, ~mu849_3 +# 864| r864_4(void *) = DynamicCastToVoid : r864_3 +# 864| mu864_5(void *) = Store : &:r864_1, r864_4 +# 865| v865_1(void) = NoOp : +# 849| v849_4(void) = ReturnVoid : +# 849| v849_5(void) = UnmodeledUse : mu* +# 849| v849_6(void) = AliasedUse : ~mu849_3 +# 849| v849_7(void) = ExitFunction : # 867| void String::String() # 867| Block 0 -# 867| v0_0(void) = EnterFunction : -# 867| mu0_1(unknown) = AliasedDefinition : -# 867| mu0_2(unknown) = UnmodeledDefinition : -# 867| r0_3(glval) = InitializeThis : -# 868| r0_4(glval) = FunctionAddress[String] : -# 868| r0_5(glval) = StringConstant[""] : -# 868| r0_6(char *) = Convert : r0_5 -# 868| v0_7(void) = Call : func:r0_4, this:r0_3, 0:r0_6 -# 868| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 868| mu0_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 868| v0_10(void) = ^BufferReadSideEffect[0] : &:r0_6, ~mu0_2 -# 868| mu0_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_6 -# 869| v0_12(void) = NoOp : -# 867| v0_13(void) = ReturnVoid : -# 867| v0_14(void) = UnmodeledUse : mu* -# 867| v0_15(void) = AliasedUse : ~mu0_2 -# 867| v0_16(void) = ExitFunction : +# 867| v867_1(void) = EnterFunction : +# 867| mu867_2(unknown) = AliasedDefinition : +# 867| mu867_3(unknown) = UnmodeledDefinition : +# 867| r867_4(glval) = InitializeThis : +# 868| r868_1(glval) = FunctionAddress[String] : +# 868| r868_2(glval) = StringConstant[""] : +# 868| r868_3(char *) = Convert : r868_2 +# 868| v868_4(void) = Call : func:r868_1, this:r867_4, 0:r868_3 +# 868| mu868_5(unknown) = ^CallSideEffect : ~mu867_3 +# 868| mu868_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r867_4 +# 868| v868_7(void) = ^BufferReadSideEffect[0] : &:r868_3, ~mu867_3 +# 868| mu868_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r868_3 +# 869| v869_1(void) = NoOp : +# 867| v867_5(void) = ReturnVoid : +# 867| v867_6(void) = UnmodeledUse : mu* +# 867| v867_7(void) = AliasedUse : ~mu867_3 +# 867| v867_8(void) = ExitFunction : # 871| void ArrayConversions() # 871| Block 0 -# 871| v0_0(void) = EnterFunction : -# 871| mu0_1(unknown) = AliasedDefinition : -# 871| mu0_2(unknown) = UnmodeledDefinition : -# 872| r0_3(glval) = VariableAddress[a] : -# 872| mu0_4(char[5]) = Uninitialized[a] : &:r0_3 -# 873| r0_5(glval) = VariableAddress[p] : -# 873| r0_6(glval) = VariableAddress[a] : -# 873| r0_7(char *) = Convert : r0_6 -# 873| r0_8(char *) = Convert : r0_7 -# 873| mu0_9(char *) = Store : &:r0_5, r0_8 -# 874| r0_10(glval) = StringConstant["test"] : -# 874| r0_11(char *) = Convert : r0_10 -# 874| r0_12(glval) = VariableAddress[p] : -# 874| mu0_13(char *) = Store : &:r0_12, r0_11 -# 875| r0_14(glval) = VariableAddress[a] : -# 875| r0_15(char *) = Convert : r0_14 -# 875| r0_16(int) = Constant[0] : -# 875| r0_17(glval) = PointerAdd[1] : r0_15, r0_16 -# 875| r0_18(char *) = CopyValue : r0_17 -# 875| r0_19(char *) = Convert : r0_18 -# 875| r0_20(glval) = VariableAddress[p] : -# 875| mu0_21(char *) = Store : &:r0_20, r0_19 -# 876| r0_22(glval) = StringConstant["test"] : -# 876| r0_23(char *) = Convert : r0_22 -# 876| r0_24(int) = Constant[0] : -# 876| r0_25(glval) = PointerAdd[1] : r0_23, r0_24 -# 876| r0_26(char *) = CopyValue : r0_25 -# 876| r0_27(glval) = VariableAddress[p] : -# 876| mu0_28(char *) = Store : &:r0_27, r0_26 -# 877| r0_29(glval) = VariableAddress[ra] : -# 877| r0_30(glval) = VariableAddress[a] : -# 877| r0_31(char(&)[5]) = CopyValue : r0_30 -# 877| mu0_32(char(&)[5]) = Store : &:r0_29, r0_31 -# 878| r0_33(glval) = VariableAddress[rs] : -# 878| r0_34(glval) = StringConstant["test"] : -# 878| r0_35(char(&)[5]) = CopyValue : r0_34 -# 878| mu0_36(char(&)[5]) = Store : &:r0_33, r0_35 -# 879| r0_37(glval) = VariableAddress[pa] : -# 879| r0_38(glval) = VariableAddress[a] : -# 879| r0_39(char(*)[5]) = CopyValue : r0_38 -# 879| r0_40(char(*)[5]) = Convert : r0_39 -# 879| mu0_41(char(*)[5]) = Store : &:r0_37, r0_40 -# 880| r0_42(glval) = StringConstant["test"] : -# 880| r0_43(char(*)[5]) = CopyValue : r0_42 -# 880| r0_44(glval) = VariableAddress[pa] : -# 880| mu0_45(char(*)[5]) = Store : &:r0_44, r0_43 -# 881| v0_46(void) = NoOp : -# 871| v0_47(void) = ReturnVoid : -# 871| v0_48(void) = UnmodeledUse : mu* -# 871| v0_49(void) = AliasedUse : ~mu0_2 -# 871| v0_50(void) = ExitFunction : +# 871| v871_1(void) = EnterFunction : +# 871| mu871_2(unknown) = AliasedDefinition : +# 871| mu871_3(unknown) = UnmodeledDefinition : +# 872| r872_1(glval) = VariableAddress[a] : +# 872| mu872_2(char[5]) = Uninitialized[a] : &:r872_1 +# 873| r873_1(glval) = VariableAddress[p] : +# 873| r873_2(glval) = VariableAddress[a] : +# 873| r873_3(char *) = Convert : r873_2 +# 873| r873_4(char *) = Convert : r873_3 +# 873| mu873_5(char *) = Store : &:r873_1, r873_4 +# 874| r874_1(glval) = StringConstant["test"] : +# 874| r874_2(char *) = Convert : r874_1 +# 874| r874_3(glval) = VariableAddress[p] : +# 874| mu874_4(char *) = Store : &:r874_3, r874_2 +# 875| r875_1(glval) = VariableAddress[a] : +# 875| r875_2(char *) = Convert : r875_1 +# 875| r875_3(int) = Constant[0] : +# 875| r875_4(glval) = PointerAdd[1] : r875_2, r875_3 +# 875| r875_5(char *) = CopyValue : r875_4 +# 875| r875_6(char *) = Convert : r875_5 +# 875| r875_7(glval) = VariableAddress[p] : +# 875| mu875_8(char *) = Store : &:r875_7, r875_6 +# 876| r876_1(glval) = StringConstant["test"] : +# 876| r876_2(char *) = Convert : r876_1 +# 876| r876_3(int) = Constant[0] : +# 876| r876_4(glval) = PointerAdd[1] : r876_2, r876_3 +# 876| r876_5(char *) = CopyValue : r876_4 +# 876| r876_6(glval) = VariableAddress[p] : +# 876| mu876_7(char *) = Store : &:r876_6, r876_5 +# 877| r877_1(glval) = VariableAddress[ra] : +# 877| r877_2(glval) = VariableAddress[a] : +# 877| r877_3(char(&)[5]) = CopyValue : r877_2 +# 877| mu877_4(char(&)[5]) = Store : &:r877_1, r877_3 +# 878| r878_1(glval) = VariableAddress[rs] : +# 878| r878_2(glval) = StringConstant["test"] : +# 878| r878_3(char(&)[5]) = CopyValue : r878_2 +# 878| mu878_4(char(&)[5]) = Store : &:r878_1, r878_3 +# 879| r879_1(glval) = VariableAddress[pa] : +# 879| r879_2(glval) = VariableAddress[a] : +# 879| r879_3(char(*)[5]) = CopyValue : r879_2 +# 879| r879_4(char(*)[5]) = Convert : r879_3 +# 879| mu879_5(char(*)[5]) = Store : &:r879_1, r879_4 +# 880| r880_1(glval) = StringConstant["test"] : +# 880| r880_2(char(*)[5]) = CopyValue : r880_1 +# 880| r880_3(glval) = VariableAddress[pa] : +# 880| mu880_4(char(*)[5]) = Store : &:r880_3, r880_2 +# 881| v881_1(void) = NoOp : +# 871| v871_4(void) = ReturnVoid : +# 871| v871_5(void) = UnmodeledUse : mu* +# 871| v871_6(void) = AliasedUse : ~mu871_3 +# 871| v871_7(void) = ExitFunction : # 883| void FuncPtrConversions(int(*)(int), void*) # 883| Block 0 -# 883| v0_0(void) = EnterFunction : -# 883| mu0_1(unknown) = AliasedDefinition : -# 883| mu0_2(unknown) = UnmodeledDefinition : -# 883| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| mu0_4(..(*)(..)) = InitializeParameter[pfn] : &:r0_3 -# 883| r0_5(glval) = VariableAddress[p] : -# 883| mu0_6(void *) = InitializeParameter[p] : &:r0_5 -# 884| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r0_8(..(*)(..)) = Load : &:r0_7, ~mu0_2 -# 884| r0_9(void *) = Convert : r0_8 -# 884| r0_10(glval) = VariableAddress[p] : -# 884| mu0_11(void *) = Store : &:r0_10, r0_9 -# 885| r0_12(glval) = VariableAddress[p] : -# 885| r0_13(void *) = Load : &:r0_12, ~mu0_2 -# 885| r0_14(..(*)(..)) = Convert : r0_13 -# 885| r0_15(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| mu0_16(..(*)(..)) = Store : &:r0_15, r0_14 -# 886| v0_17(void) = NoOp : -# 883| v0_18(void) = ReturnVoid : -# 883| v0_19(void) = UnmodeledUse : mu* -# 883| v0_20(void) = AliasedUse : ~mu0_2 -# 883| v0_21(void) = ExitFunction : +# 883| v883_1(void) = EnterFunction : +# 883| mu883_2(unknown) = AliasedDefinition : +# 883| mu883_3(unknown) = UnmodeledDefinition : +# 883| r883_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 883| mu883_5(..(*)(..)) = InitializeParameter[pfn] : &:r883_4 +# 883| r883_6(glval) = VariableAddress[p] : +# 883| mu883_7(void *) = InitializeParameter[p] : &:r883_6 +# 884| r884_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 884| r884_2(..(*)(..)) = Load : &:r884_1, ~mu883_3 +# 884| r884_3(void *) = Convert : r884_2 +# 884| r884_4(glval) = VariableAddress[p] : +# 884| mu884_5(void *) = Store : &:r884_4, r884_3 +# 885| r885_1(glval) = VariableAddress[p] : +# 885| r885_2(void *) = Load : &:r885_1, ~mu883_3 +# 885| r885_3(..(*)(..)) = Convert : r885_2 +# 885| r885_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 885| mu885_5(..(*)(..)) = Store : &:r885_4, r885_3 +# 886| v886_1(void) = NoOp : +# 883| v883_8(void) = ReturnVoid : +# 883| v883_9(void) = UnmodeledUse : mu* +# 883| v883_10(void) = AliasedUse : ~mu883_3 +# 883| v883_11(void) = ExitFunction : # 888| void VarArgUsage(int) # 888| Block 0 -# 888| v0_0(void) = EnterFunction : -# 888| mu0_1(unknown) = AliasedDefinition : -# 888| mu0_2(unknown) = UnmodeledDefinition : -# 888| r0_3(glval) = VariableAddress[x] : -# 888| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 889| r0_5(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| mu0_6(__va_list_tag[1]) = Uninitialized[args] : &:r0_5 -# 891| r0_7(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r0_8(__va_list_tag *) = Convert : r0_7 -# 891| r0_9(glval) = VariableAddress[x] : -# 891| v0_10(void) = VarArgsStart : 0:r0_8, 1:r0_9 -# 892| r0_11(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| mu0_12(__va_list_tag[1]) = Uninitialized[args2] : &:r0_11 -# 893| r0_13(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r0_14(__va_list_tag *) = Convert : r0_13 -# 893| r0_15(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r0_16(__va_list_tag *) = Convert : r0_15 -# 893| v0_17(void) = VarArgsStart : 0:r0_14, 1:r0_16 -# 894| r0_18(glval) = VariableAddress[d] : -# 894| r0_19(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r0_20(__va_list_tag *) = Convert : r0_19 -# 894| r0_21(glval) = VarArg : 0:r0_20 -# 894| r0_22(double) = Load : &:r0_21, ~mu0_2 -# 894| mu0_23(double) = Store : &:r0_18, r0_22 -# 895| r0_24(glval) = VariableAddress[f] : -# 895| r0_25(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r0_26(__va_list_tag *) = Convert : r0_25 -# 895| r0_27(glval) = VarArg : 0:r0_26 -# 895| r0_28(double) = Load : &:r0_27, ~mu0_2 -# 895| r0_29(float) = Convert : r0_28 -# 895| mu0_30(float) = Store : &:r0_24, r0_29 -# 896| r0_31(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r0_32(__va_list_tag *) = Convert : r0_31 -# 896| v0_33(void) = VarArgsEnd : 0:r0_32 -# 897| r0_34(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r0_35(__va_list_tag *) = Convert : r0_34 -# 897| v0_36(void) = VarArgsEnd : 0:r0_35 -# 898| v0_37(void) = NoOp : -# 888| v0_38(void) = ReturnVoid : -# 888| v0_39(void) = UnmodeledUse : mu* -# 888| v0_40(void) = AliasedUse : ~mu0_2 -# 888| v0_41(void) = ExitFunction : +# 888| v888_1(void) = EnterFunction : +# 888| mu888_2(unknown) = AliasedDefinition : +# 888| mu888_3(unknown) = UnmodeledDefinition : +# 888| r888_4(glval) = VariableAddress[x] : +# 888| mu888_5(int) = InitializeParameter[x] : &:r888_4 +# 889| r889_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 889| mu889_2(__va_list_tag[1]) = Uninitialized[args] : &:r889_1 +# 891| r891_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 891| r891_2(__va_list_tag *) = Convert : r891_1 +# 891| r891_3(glval) = VariableAddress[x] : +# 891| v891_4(void) = VarArgsStart : 0:r891_2, 1:r891_3 +# 892| r892_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| mu892_2(__va_list_tag[1]) = Uninitialized[args2] : &:r892_1 +# 893| r893_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 893| r893_2(__va_list_tag *) = Convert : r893_1 +# 893| r893_3(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 893| r893_4(__va_list_tag *) = Convert : r893_3 +# 893| v893_5(void) = VarArgsStart : 0:r893_2, 1:r893_4 +# 894| r894_1(glval) = VariableAddress[d] : +# 894| r894_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 894| r894_3(__va_list_tag *) = Convert : r894_2 +# 894| r894_4(glval) = VarArg : 0:r894_3 +# 894| r894_5(double) = Load : &:r894_4, ~mu888_3 +# 894| mu894_6(double) = Store : &:r894_1, r894_5 +# 895| r895_1(glval) = VariableAddress[f] : +# 895| r895_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 895| r895_3(__va_list_tag *) = Convert : r895_2 +# 895| r895_4(glval) = VarArg : 0:r895_3 +# 895| r895_5(double) = Load : &:r895_4, ~mu888_3 +# 895| r895_6(float) = Convert : r895_5 +# 895| mu895_7(float) = Store : &:r895_1, r895_6 +# 896| r896_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 896| r896_2(__va_list_tag *) = Convert : r896_1 +# 896| v896_3(void) = VarArgsEnd : 0:r896_2 +# 897| r897_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 897| r897_2(__va_list_tag *) = Convert : r897_1 +# 897| v897_3(void) = VarArgsEnd : 0:r897_2 +# 898| v898_1(void) = NoOp : +# 888| v888_6(void) = ReturnVoid : +# 888| v888_7(void) = UnmodeledUse : mu* +# 888| v888_8(void) = AliasedUse : ~mu888_3 +# 888| v888_9(void) = ExitFunction : # 900| void CastToVoid(int) # 900| Block 0 -# 900| v0_0(void) = EnterFunction : -# 900| mu0_1(unknown) = AliasedDefinition : -# 900| mu0_2(unknown) = UnmodeledDefinition : -# 900| r0_3(glval) = VariableAddress[x] : -# 900| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 901| r0_5(glval) = VariableAddress[x] : -# 901| v0_6(void) = Convert : r0_5 -# 902| v0_7(void) = NoOp : -# 900| v0_8(void) = ReturnVoid : -# 900| v0_9(void) = UnmodeledUse : mu* -# 900| v0_10(void) = AliasedUse : ~mu0_2 -# 900| v0_11(void) = ExitFunction : +# 900| v900_1(void) = EnterFunction : +# 900| mu900_2(unknown) = AliasedDefinition : +# 900| mu900_3(unknown) = UnmodeledDefinition : +# 900| r900_4(glval) = VariableAddress[x] : +# 900| mu900_5(int) = InitializeParameter[x] : &:r900_4 +# 901| r901_1(glval) = VariableAddress[x] : +# 901| v901_2(void) = Convert : r901_1 +# 902| v902_1(void) = NoOp : +# 900| v900_6(void) = ReturnVoid : +# 900| v900_7(void) = UnmodeledUse : mu* +# 900| v900_8(void) = AliasedUse : ~mu900_3 +# 900| v900_9(void) = ExitFunction : # 904| void ConstantConditions(int) # 904| Block 0 -# 904| v0_0(void) = EnterFunction : -# 904| mu0_1(unknown) = AliasedDefinition : -# 904| mu0_2(unknown) = UnmodeledDefinition : -# 904| r0_3(glval) = VariableAddress[x] : -# 904| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 905| r0_5(glval) = VariableAddress[a] : -# 905| r0_6(bool) = Constant[1] : -# 905| mu0_7(bool) = Store : &:r0_5, r0_6 -# 906| r0_8(glval) = VariableAddress[b] : -# 906| r0_9(bool) = Constant[1] : -# 906| v0_10(void) = ConditionalBranch : r0_9 +# 904| v904_1(void) = EnterFunction : +# 904| mu904_2(unknown) = AliasedDefinition : +# 904| mu904_3(unknown) = UnmodeledDefinition : +# 904| r904_4(glval) = VariableAddress[x] : +# 904| mu904_5(int) = InitializeParameter[x] : &:r904_4 +# 905| r905_1(glval) = VariableAddress[a] : +# 905| r905_2(bool) = Constant[1] : +# 905| mu905_3(bool) = Store : &:r905_1, r905_2 +# 906| r906_1(glval) = VariableAddress[b] : +# 906| r906_2(bool) = Constant[1] : +# 906| v906_3(void) = ConditionalBranch : r906_2 #-----| False -> Block 3 #-----| True -> Block 2 # 906| Block 1 -# 906| r1_0(glval) = VariableAddress[#temp906:11] : -# 906| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 906| mu1_2(int) = Store : &:r0_8, r1_1 -# 907| v1_3(void) = NoOp : -# 904| v1_4(void) = ReturnVoid : -# 904| v1_5(void) = UnmodeledUse : mu* -# 904| v1_6(void) = AliasedUse : ~mu0_2 -# 904| v1_7(void) = ExitFunction : +# 906| r906_4(glval) = VariableAddress[#temp906:11] : +# 906| r906_5(int) = Load : &:r906_4, ~mu904_3 +# 906| mu906_6(int) = Store : &:r906_1, r906_5 +# 907| v907_1(void) = NoOp : +# 904| v904_6(void) = ReturnVoid : +# 904| v904_7(void) = UnmodeledUse : mu* +# 904| v904_8(void) = AliasedUse : ~mu904_3 +# 904| v904_9(void) = ExitFunction : # 906| Block 2 -# 906| r2_0(glval) = VariableAddress[x] : -# 906| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 906| r2_2(glval) = VariableAddress[#temp906:11] : -# 906| mu2_3(int) = Store : &:r2_2, r2_1 +# 906| r906_7(glval) = VariableAddress[x] : +# 906| r906_8(int) = Load : &:r906_7, ~mu904_3 +# 906| r906_9(glval) = VariableAddress[#temp906:11] : +# 906| mu906_10(int) = Store : &:r906_9, r906_8 #-----| Goto -> Block 1 # 906| Block 3 -# 906| r3_0(glval) = VariableAddress[x] : -# 906| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 906| r3_2(glval) = VariableAddress[#temp906:11] : -# 906| mu3_3(int) = Store : &:r3_2, r3_1 +# 906| r906_11(glval) = VariableAddress[x] : +# 906| r906_12(int) = Load : &:r906_11, ~mu904_3 +# 906| r906_13(glval) = VariableAddress[#temp906:11] : +# 906| mu906_14(int) = Store : &:r906_13, r906_12 #-----| Goto -> Block 1 # 940| void OperatorNew() # 940| Block 0 -# 940| v0_0(void) = EnterFunction : -# 940| mu0_1(unknown) = AliasedDefinition : -# 940| mu0_2(unknown) = UnmodeledDefinition : -# 941| r0_3(glval) = FunctionAddress[operator new] : -# 941| r0_4(unsigned long) = Constant[4] : -# 941| r0_5(void *) = Call : func:r0_3, 0:r0_4 -# 941| mu0_6(unknown) = ^CallSideEffect : ~mu0_2 -# 941| r0_7(int *) = Convert : r0_5 -# 942| r0_8(glval) = FunctionAddress[operator new] : -# 942| r0_9(unsigned long) = Constant[4] : -# 942| r0_10(float) = Constant[1.0] : -# 942| r0_11(void *) = Call : func:r0_8, 0:r0_9, 1:r0_10 -# 942| mu0_12(unknown) = ^CallSideEffect : ~mu0_2 -# 942| r0_13(int *) = Convert : r0_11 -# 943| r0_14(glval) = FunctionAddress[operator new] : -# 943| r0_15(unsigned long) = Constant[4] : -# 943| r0_16(void *) = Call : func:r0_14, 0:r0_15 -# 943| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 943| r0_18(int *) = Convert : r0_16 -# 943| r0_19(int) = Constant[0] : -# 943| mu0_20(int) = Store : &:r0_18, r0_19 -# 944| r0_21(glval) = FunctionAddress[operator new] : -# 944| r0_22(unsigned long) = Constant[8] : -# 944| r0_23(void *) = Call : func:r0_21, 0:r0_22 -# 944| mu0_24(unknown) = ^CallSideEffect : ~mu0_2 -# 944| r0_25(String *) = Convert : r0_23 -# 944| r0_26(glval) = FunctionAddress[String] : -# 944| v0_27(void) = Call : func:r0_26, this:r0_25 -# 944| mu0_28(unknown) = ^CallSideEffect : ~mu0_2 -# 944| mu0_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 -# 945| r0_30(glval) = FunctionAddress[operator new] : -# 945| r0_31(unsigned long) = Constant[8] : -# 945| r0_32(float) = Constant[1.0] : -# 945| r0_33(void *) = Call : func:r0_30, 0:r0_31, 1:r0_32 -# 945| mu0_34(unknown) = ^CallSideEffect : ~mu0_2 -# 945| r0_35(String *) = Convert : r0_33 -# 945| r0_36(glval) = FunctionAddress[String] : -# 945| r0_37(glval) = StringConstant["hello"] : -# 945| r0_38(char *) = Convert : r0_37 -# 945| v0_39(void) = Call : func:r0_36, this:r0_35, 0:r0_38 -# 945| mu0_40(unknown) = ^CallSideEffect : ~mu0_2 -# 945| mu0_41(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_35 -# 945| v0_42(void) = ^BufferReadSideEffect[0] : &:r0_38, ~mu0_2 -# 945| mu0_43(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_38 -# 946| r0_44(glval) = FunctionAddress[operator new] : -# 946| r0_45(unsigned long) = Constant[256] : -# 946| r0_46(align_val_t) = Constant[128] : -# 946| r0_47(void *) = Call : func:r0_44, 0:r0_45, 1:r0_46 -# 946| mu0_48(unknown) = ^CallSideEffect : ~mu0_2 -# 946| r0_49(Overaligned *) = Convert : r0_47 -# 947| r0_50(glval) = FunctionAddress[operator new] : -# 947| r0_51(unsigned long) = Constant[256] : -# 947| r0_52(align_val_t) = Constant[128] : -# 947| r0_53(float) = Constant[1.0] : -# 947| r0_54(void *) = Call : func:r0_50, 0:r0_51, 1:r0_52, 2:r0_53 -# 947| mu0_55(unknown) = ^CallSideEffect : ~mu0_2 -# 947| r0_56(Overaligned *) = Convert : r0_54 -# 947| r0_57(Overaligned) = Constant[0] : -# 947| mu0_58(Overaligned) = Store : &:r0_56, r0_57 -# 948| v0_59(void) = NoOp : -# 940| v0_60(void) = ReturnVoid : -# 940| v0_61(void) = UnmodeledUse : mu* -# 940| v0_62(void) = AliasedUse : ~mu0_2 -# 940| v0_63(void) = ExitFunction : +# 940| v940_1(void) = EnterFunction : +# 940| mu940_2(unknown) = AliasedDefinition : +# 940| mu940_3(unknown) = UnmodeledDefinition : +# 941| r941_1(glval) = FunctionAddress[operator new] : +# 941| r941_2(unsigned long) = Constant[4] : +# 941| r941_3(void *) = Call : func:r941_1, 0:r941_2 +# 941| mu941_4(unknown) = ^CallSideEffect : ~mu940_3 +# 941| r941_5(int *) = Convert : r941_3 +# 942| r942_1(glval) = FunctionAddress[operator new] : +# 942| r942_2(unsigned long) = Constant[4] : +# 942| r942_3(float) = Constant[1.0] : +# 942| r942_4(void *) = Call : func:r942_1, 0:r942_2, 1:r942_3 +# 942| mu942_5(unknown) = ^CallSideEffect : ~mu940_3 +# 942| r942_6(int *) = Convert : r942_4 +# 943| r943_1(glval) = FunctionAddress[operator new] : +# 943| r943_2(unsigned long) = Constant[4] : +# 943| r943_3(void *) = Call : func:r943_1, 0:r943_2 +# 943| mu943_4(unknown) = ^CallSideEffect : ~mu940_3 +# 943| r943_5(int *) = Convert : r943_3 +# 943| r943_6(int) = Constant[0] : +# 943| mu943_7(int) = Store : &:r943_5, r943_6 +# 944| r944_1(glval) = FunctionAddress[operator new] : +# 944| r944_2(unsigned long) = Constant[8] : +# 944| r944_3(void *) = Call : func:r944_1, 0:r944_2 +# 944| mu944_4(unknown) = ^CallSideEffect : ~mu940_3 +# 944| r944_5(String *) = Convert : r944_3 +# 944| r944_6(glval) = FunctionAddress[String] : +# 944| v944_7(void) = Call : func:r944_6, this:r944_5 +# 944| mu944_8(unknown) = ^CallSideEffect : ~mu940_3 +# 944| mu944_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r944_5 +# 945| r945_1(glval) = FunctionAddress[operator new] : +# 945| r945_2(unsigned long) = Constant[8] : +# 945| r945_3(float) = Constant[1.0] : +# 945| r945_4(void *) = Call : func:r945_1, 0:r945_2, 1:r945_3 +# 945| mu945_5(unknown) = ^CallSideEffect : ~mu940_3 +# 945| r945_6(String *) = Convert : r945_4 +# 945| r945_7(glval) = FunctionAddress[String] : +# 945| r945_8(glval) = StringConstant["hello"] : +# 945| r945_9(char *) = Convert : r945_8 +# 945| v945_10(void) = Call : func:r945_7, this:r945_6, 0:r945_9 +# 945| mu945_11(unknown) = ^CallSideEffect : ~mu940_3 +# 945| mu945_12(String) = ^IndirectMayWriteSideEffect[-1] : &:r945_6 +# 945| v945_13(void) = ^BufferReadSideEffect[0] : &:r945_9, ~mu940_3 +# 945| mu945_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r945_9 +# 946| r946_1(glval) = FunctionAddress[operator new] : +# 946| r946_2(unsigned long) = Constant[256] : +# 946| r946_3(align_val_t) = Constant[128] : +# 946| r946_4(void *) = Call : func:r946_1, 0:r946_2, 1:r946_3 +# 946| mu946_5(unknown) = ^CallSideEffect : ~mu940_3 +# 946| r946_6(Overaligned *) = Convert : r946_4 +# 947| r947_1(glval) = FunctionAddress[operator new] : +# 947| r947_2(unsigned long) = Constant[256] : +# 947| r947_3(align_val_t) = Constant[128] : +# 947| r947_4(float) = Constant[1.0] : +# 947| r947_5(void *) = Call : func:r947_1, 0:r947_2, 1:r947_3, 2:r947_4 +# 947| mu947_6(unknown) = ^CallSideEffect : ~mu940_3 +# 947| r947_7(Overaligned *) = Convert : r947_5 +# 947| r947_8(Overaligned) = Constant[0] : +# 947| mu947_9(Overaligned) = Store : &:r947_7, r947_8 +# 948| v948_1(void) = NoOp : +# 940| v940_4(void) = ReturnVoid : +# 940| v940_5(void) = UnmodeledUse : mu* +# 940| v940_6(void) = AliasedUse : ~mu940_3 +# 940| v940_7(void) = ExitFunction : # 950| void OperatorNewArray(int) # 950| Block 0 -# 950| v0_0(void) = EnterFunction : -# 950| mu0_1(unknown) = AliasedDefinition : -# 950| mu0_2(unknown) = UnmodeledDefinition : -# 950| r0_3(glval) = VariableAddress[n] : -# 950| mu0_4(int) = InitializeParameter[n] : &:r0_3 -# 951| r0_5(glval) = FunctionAddress[operator new[]] : -# 951| r0_6(unsigned long) = Constant[40] : -# 951| r0_7(void *) = Call : func:r0_5, 0:r0_6 -# 951| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 951| r0_9(int *) = Convert : r0_7 -# 952| r0_10(glval) = FunctionAddress[operator new[]] : -# 952| r0_11(glval) = VariableAddress[n] : -# 952| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 952| r0_13(unsigned long) = Convert : r0_12 -# 952| r0_14(unsigned long) = Constant[4] : -# 952| r0_15(unsigned long) = Mul : r0_13, r0_14 -# 952| r0_16(void *) = Call : func:r0_10, 0:r0_15 -# 952| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 952| r0_18(int *) = Convert : r0_16 -# 953| r0_19(glval) = FunctionAddress[operator new[]] : -# 953| r0_20(glval) = VariableAddress[n] : -# 953| r0_21(int) = Load : &:r0_20, ~mu0_2 -# 953| r0_22(unsigned long) = Convert : r0_21 -# 953| r0_23(unsigned long) = Constant[4] : -# 953| r0_24(unsigned long) = Mul : r0_22, r0_23 -# 953| r0_25(float) = Constant[1.0] : -# 953| r0_26(void *) = Call : func:r0_19, 0:r0_24, 1:r0_25 -# 953| mu0_27(unknown) = ^CallSideEffect : ~mu0_2 -# 953| r0_28(int *) = Convert : r0_26 -# 954| r0_29(glval) = FunctionAddress[operator new[]] : -# 954| r0_30(glval) = VariableAddress[n] : -# 954| r0_31(int) = Load : &:r0_30, ~mu0_2 -# 954| r0_32(unsigned long) = Convert : r0_31 -# 954| r0_33(unsigned long) = Constant[8] : -# 954| r0_34(unsigned long) = Mul : r0_32, r0_33 -# 954| r0_35(void *) = Call : func:r0_29, 0:r0_34 -# 954| mu0_36(unknown) = ^CallSideEffect : ~mu0_2 -# 954| r0_37(String *) = Convert : r0_35 -# 955| r0_38(glval) = FunctionAddress[operator new[]] : -# 955| r0_39(glval) = VariableAddress[n] : -# 955| r0_40(int) = Load : &:r0_39, ~mu0_2 -# 955| r0_41(unsigned long) = Convert : r0_40 -# 955| r0_42(unsigned long) = Constant[256] : -# 955| r0_43(unsigned long) = Mul : r0_41, r0_42 -# 955| r0_44(align_val_t) = Constant[128] : -# 955| r0_45(void *) = Call : func:r0_38, 0:r0_43, 1:r0_44 -# 955| mu0_46(unknown) = ^CallSideEffect : ~mu0_2 -# 955| r0_47(Overaligned *) = Convert : r0_45 -# 956| r0_48(glval) = FunctionAddress[operator new[]] : -# 956| r0_49(unsigned long) = Constant[2560] : -# 956| r0_50(align_val_t) = Constant[128] : -# 956| r0_51(float) = Constant[1.0] : -# 956| r0_52(void *) = Call : func:r0_48, 0:r0_49, 1:r0_50, 2:r0_51 -# 956| mu0_53(unknown) = ^CallSideEffect : ~mu0_2 -# 956| r0_54(Overaligned *) = Convert : r0_52 -# 957| r0_55(glval) = FunctionAddress[operator new[]] : -# 957| r0_56(glval) = VariableAddress[n] : -# 957| r0_57(int) = Load : &:r0_56, ~mu0_2 -# 957| r0_58(unsigned long) = Convert : r0_57 -# 957| r0_59(unsigned long) = Constant[1] : -# 957| r0_60(unsigned long) = Mul : r0_58, r0_59 -# 957| r0_61(void *) = Call : func:r0_55, 0:r0_60 -# 957| mu0_62(unknown) = ^CallSideEffect : ~mu0_2 -# 957| r0_63(DefaultCtorWithDefaultParam *) = Convert : r0_61 -# 958| r0_64(glval) = FunctionAddress[operator new[]] : -# 958| r0_65(glval) = VariableAddress[n] : -# 958| r0_66(int) = Load : &:r0_65, ~mu0_2 -# 958| r0_67(unsigned long) = Convert : r0_66 -# 958| r0_68(unsigned long) = Constant[4] : -# 958| r0_69(unsigned long) = Mul : r0_67, r0_68 -# 958| r0_70(void *) = Call : func:r0_64, 0:r0_69 -# 958| mu0_71(unknown) = ^CallSideEffect : ~mu0_2 -# 958| r0_72(int *) = Convert : r0_70 -# 959| v0_73(void) = NoOp : -# 950| v0_74(void) = ReturnVoid : -# 950| v0_75(void) = UnmodeledUse : mu* -# 950| v0_76(void) = AliasedUse : ~mu0_2 -# 950| v0_77(void) = ExitFunction : +# 950| v950_1(void) = EnterFunction : +# 950| mu950_2(unknown) = AliasedDefinition : +# 950| mu950_3(unknown) = UnmodeledDefinition : +# 950| r950_4(glval) = VariableAddress[n] : +# 950| mu950_5(int) = InitializeParameter[n] : &:r950_4 +# 951| r951_1(glval) = FunctionAddress[operator new[]] : +# 951| r951_2(unsigned long) = Constant[40] : +# 951| r951_3(void *) = Call : func:r951_1, 0:r951_2 +# 951| mu951_4(unknown) = ^CallSideEffect : ~mu950_3 +# 951| r951_5(int *) = Convert : r951_3 +# 952| r952_1(glval) = FunctionAddress[operator new[]] : +# 952| r952_2(glval) = VariableAddress[n] : +# 952| r952_3(int) = Load : &:r952_2, ~mu950_3 +# 952| r952_4(unsigned long) = Convert : r952_3 +# 952| r952_5(unsigned long) = Constant[4] : +# 952| r952_6(unsigned long) = Mul : r952_4, r952_5 +# 952| r952_7(void *) = Call : func:r952_1, 0:r952_6 +# 952| mu952_8(unknown) = ^CallSideEffect : ~mu950_3 +# 952| r952_9(int *) = Convert : r952_7 +# 953| r953_1(glval) = FunctionAddress[operator new[]] : +# 953| r953_2(glval) = VariableAddress[n] : +# 953| r953_3(int) = Load : &:r953_2, ~mu950_3 +# 953| r953_4(unsigned long) = Convert : r953_3 +# 953| r953_5(unsigned long) = Constant[4] : +# 953| r953_6(unsigned long) = Mul : r953_4, r953_5 +# 953| r953_7(float) = Constant[1.0] : +# 953| r953_8(void *) = Call : func:r953_1, 0:r953_6, 1:r953_7 +# 953| mu953_9(unknown) = ^CallSideEffect : ~mu950_3 +# 953| r953_10(int *) = Convert : r953_8 +# 954| r954_1(glval) = FunctionAddress[operator new[]] : +# 954| r954_2(glval) = VariableAddress[n] : +# 954| r954_3(int) = Load : &:r954_2, ~mu950_3 +# 954| r954_4(unsigned long) = Convert : r954_3 +# 954| r954_5(unsigned long) = Constant[8] : +# 954| r954_6(unsigned long) = Mul : r954_4, r954_5 +# 954| r954_7(void *) = Call : func:r954_1, 0:r954_6 +# 954| mu954_8(unknown) = ^CallSideEffect : ~mu950_3 +# 954| r954_9(String *) = Convert : r954_7 +# 955| r955_1(glval) = FunctionAddress[operator new[]] : +# 955| r955_2(glval) = VariableAddress[n] : +# 955| r955_3(int) = Load : &:r955_2, ~mu950_3 +# 955| r955_4(unsigned long) = Convert : r955_3 +# 955| r955_5(unsigned long) = Constant[256] : +# 955| r955_6(unsigned long) = Mul : r955_4, r955_5 +# 955| r955_7(align_val_t) = Constant[128] : +# 955| r955_8(void *) = Call : func:r955_1, 0:r955_6, 1:r955_7 +# 955| mu955_9(unknown) = ^CallSideEffect : ~mu950_3 +# 955| r955_10(Overaligned *) = Convert : r955_8 +# 956| r956_1(glval) = FunctionAddress[operator new[]] : +# 956| r956_2(unsigned long) = Constant[2560] : +# 956| r956_3(align_val_t) = Constant[128] : +# 956| r956_4(float) = Constant[1.0] : +# 956| r956_5(void *) = Call : func:r956_1, 0:r956_2, 1:r956_3, 2:r956_4 +# 956| mu956_6(unknown) = ^CallSideEffect : ~mu950_3 +# 956| r956_7(Overaligned *) = Convert : r956_5 +# 957| r957_1(glval) = FunctionAddress[operator new[]] : +# 957| r957_2(glval) = VariableAddress[n] : +# 957| r957_3(int) = Load : &:r957_2, ~mu950_3 +# 957| r957_4(unsigned long) = Convert : r957_3 +# 957| r957_5(unsigned long) = Constant[1] : +# 957| r957_6(unsigned long) = Mul : r957_4, r957_5 +# 957| r957_7(void *) = Call : func:r957_1, 0:r957_6 +# 957| mu957_8(unknown) = ^CallSideEffect : ~mu950_3 +# 957| r957_9(DefaultCtorWithDefaultParam *) = Convert : r957_7 +# 958| r958_1(glval) = FunctionAddress[operator new[]] : +# 958| r958_2(glval) = VariableAddress[n] : +# 958| r958_3(int) = Load : &:r958_2, ~mu950_3 +# 958| r958_4(unsigned long) = Convert : r958_3 +# 958| r958_5(unsigned long) = Constant[4] : +# 958| r958_6(unsigned long) = Mul : r958_4, r958_5 +# 958| r958_7(void *) = Call : func:r958_1, 0:r958_6 +# 958| mu958_8(unknown) = ^CallSideEffect : ~mu950_3 +# 958| r958_9(int *) = Convert : r958_7 +# 959| v959_1(void) = NoOp : +# 950| v950_6(void) = ReturnVoid : +# 950| v950_7(void) = UnmodeledUse : mu* +# 950| v950_8(void) = AliasedUse : ~mu950_3 +# 950| v950_9(void) = ExitFunction : # 961| int designatedInit() # 961| Block 0 -# 961| v0_0(void) = EnterFunction : -# 961| mu0_1(unknown) = AliasedDefinition : -# 961| mu0_2(unknown) = UnmodeledDefinition : -# 962| r0_3(glval) = VariableAddress[a1] : -# 962| mu0_4(int[1000]) = Uninitialized[a1] : &:r0_3 -# 962| r0_5(int) = Constant[0] : -# 962| r0_6(glval) = PointerAdd[4] : r0_3, r0_5 -# 962| r0_7(unknown[8]) = Constant[0] : -# 962| mu0_8(unknown[8]) = Store : &:r0_6, r0_7 -# 962| r0_9(int) = Constant[2] : -# 962| r0_10(glval) = PointerAdd[4] : r0_3, r0_9 -# 962| r0_11(int) = Constant[10002] : -# 962| mu0_12(int) = Store : &:r0_10, r0_11 -# 962| r0_13(int) = Constant[3] : -# 962| r0_14(glval) = PointerAdd[4] : r0_3, r0_13 -# 962| r0_15(unknown[3588]) = Constant[0] : -# 962| mu0_16(unknown[3588]) = Store : &:r0_14, r0_15 -# 962| r0_17(int) = Constant[900] : -# 962| r0_18(glval) = PointerAdd[4] : r0_3, r0_17 -# 962| r0_19(int) = Constant[10900] : -# 962| mu0_20(int) = Store : &:r0_18, r0_19 -# 962| r0_21(int) = Constant[901] : -# 962| r0_22(glval) = PointerAdd[4] : r0_3, r0_21 -# 962| r0_23(unknown[396]) = Constant[0] : -# 962| mu0_24(unknown[396]) = Store : &:r0_22, r0_23 -# 963| r0_25(glval) = VariableAddress[#return] : -# 963| r0_26(glval) = VariableAddress[a1] : -# 963| r0_27(int *) = Convert : r0_26 -# 963| r0_28(int) = Constant[900] : -# 963| r0_29(glval) = PointerAdd[4] : r0_27, r0_28 -# 963| r0_30(int) = Load : &:r0_29, ~mu0_2 -# 963| mu0_31(int) = Store : &:r0_25, r0_30 -# 961| r0_32(glval) = VariableAddress[#return] : -# 961| v0_33(void) = ReturnValue : &:r0_32, ~mu0_2 -# 961| v0_34(void) = UnmodeledUse : mu* -# 961| v0_35(void) = AliasedUse : ~mu0_2 -# 961| v0_36(void) = ExitFunction : +# 961| v961_1(void) = EnterFunction : +# 961| mu961_2(unknown) = AliasedDefinition : +# 961| mu961_3(unknown) = UnmodeledDefinition : +# 962| r962_1(glval) = VariableAddress[a1] : +# 962| mu962_2(int[1000]) = Uninitialized[a1] : &:r962_1 +# 962| r962_3(int) = Constant[0] : +# 962| r962_4(glval) = PointerAdd[4] : r962_1, r962_3 +# 962| r962_5(unknown[8]) = Constant[0] : +# 962| mu962_6(unknown[8]) = Store : &:r962_4, r962_5 +# 962| r962_7(int) = Constant[2] : +# 962| r962_8(glval) = PointerAdd[4] : r962_1, r962_7 +# 962| r962_9(int) = Constant[10002] : +# 962| mu962_10(int) = Store : &:r962_8, r962_9 +# 962| r962_11(int) = Constant[3] : +# 962| r962_12(glval) = PointerAdd[4] : r962_1, r962_11 +# 962| r962_13(unknown[3588]) = Constant[0] : +# 962| mu962_14(unknown[3588]) = Store : &:r962_12, r962_13 +# 962| r962_15(int) = Constant[900] : +# 962| r962_16(glval) = PointerAdd[4] : r962_1, r962_15 +# 962| r962_17(int) = Constant[10900] : +# 962| mu962_18(int) = Store : &:r962_16, r962_17 +# 962| r962_19(int) = Constant[901] : +# 962| r962_20(glval) = PointerAdd[4] : r962_1, r962_19 +# 962| r962_21(unknown[396]) = Constant[0] : +# 962| mu962_22(unknown[396]) = Store : &:r962_20, r962_21 +# 963| r963_1(glval) = VariableAddress[#return] : +# 963| r963_2(glval) = VariableAddress[a1] : +# 963| r963_3(int *) = Convert : r963_2 +# 963| r963_4(int) = Constant[900] : +# 963| r963_5(glval) = PointerAdd[4] : r963_3, r963_4 +# 963| r963_6(int) = Load : &:r963_5, ~mu961_3 +# 963| mu963_7(int) = Store : &:r963_1, r963_6 +# 961| r961_4(glval) = VariableAddress[#return] : +# 961| v961_5(void) = ReturnValue : &:r961_4, ~mu961_3 +# 961| v961_6(void) = UnmodeledUse : mu* +# 961| v961_7(void) = AliasedUse : ~mu961_3 +# 961| v961_8(void) = ExitFunction : # 966| void IfStmtWithDeclaration(int, int) # 966| Block 0 -# 966| v0_0(void) = EnterFunction : -# 966| mu0_1(unknown) = AliasedDefinition : -# 966| mu0_2(unknown) = UnmodeledDefinition : -# 966| r0_3(glval) = VariableAddress[x] : -# 966| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 966| r0_5(glval) = VariableAddress[y] : -# 966| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 967| r0_7(glval) = VariableAddress[b] : -# 967| r0_8(glval) = VariableAddress[x] : -# 967| r0_9(int) = Load : &:r0_8, ~mu0_2 -# 967| r0_10(glval) = VariableAddress[y] : -# 967| r0_11(int) = Load : &:r0_10, ~mu0_2 -# 967| r0_12(bool) = CompareLT : r0_9, r0_11 -# 967| mu0_13(bool) = Store : &:r0_7, r0_12 -# 967| r0_14(glval) = VariableAddress[b] : -# 967| r0_15(bool) = Load : &:r0_14, ~mu0_2 -# 967| r0_16(bool) = CopyValue : r0_15 -# 967| v0_17(void) = ConditionalBranch : r0_16 +# 966| v966_1(void) = EnterFunction : +# 966| mu966_2(unknown) = AliasedDefinition : +# 966| mu966_3(unknown) = UnmodeledDefinition : +# 966| r966_4(glval) = VariableAddress[x] : +# 966| mu966_5(int) = InitializeParameter[x] : &:r966_4 +# 966| r966_6(glval) = VariableAddress[y] : +# 966| mu966_7(int) = InitializeParameter[y] : &:r966_6 +# 967| r967_1(glval) = VariableAddress[b] : +# 967| r967_2(glval) = VariableAddress[x] : +# 967| r967_3(int) = Load : &:r967_2, ~mu966_3 +# 967| r967_4(glval) = VariableAddress[y] : +# 967| r967_5(int) = Load : &:r967_4, ~mu966_3 +# 967| r967_6(bool) = CompareLT : r967_3, r967_5 +# 967| mu967_7(bool) = Store : &:r967_1, r967_6 +# 967| r967_8(glval) = VariableAddress[b] : +# 967| r967_9(bool) = Load : &:r967_8, ~mu966_3 +# 967| r967_10(bool) = CopyValue : r967_9 +# 967| v967_11(void) = ConditionalBranch : r967_10 #-----| False -> Block 2 #-----| True -> Block 1 # 968| Block 1 -# 968| r1_0(int) = Constant[5] : -# 968| r1_1(glval) = VariableAddress[x] : -# 968| mu1_2(int) = Store : &:r1_1, r1_0 +# 968| r968_1(int) = Constant[5] : +# 968| r968_2(glval) = VariableAddress[x] : +# 968| mu968_3(int) = Store : &:r968_2, r968_1 #-----| Goto -> Block 6 # 970| Block 2 -# 970| r2_0(glval) = VariableAddress[z] : -# 970| r2_1(glval) = VariableAddress[x] : -# 970| r2_2(int) = Load : &:r2_1, ~mu0_2 -# 970| r2_3(glval) = VariableAddress[y] : -# 970| r2_4(int) = Load : &:r2_3, ~mu0_2 -# 970| r2_5(int) = Add : r2_2, r2_4 -# 970| mu2_6(int) = Store : &:r2_0, r2_5 -# 970| r2_7(glval) = VariableAddress[z] : -# 970| r2_8(int) = Load : &:r2_7, ~mu0_2 -# 970| r2_9(int) = Constant[0] : -# 970| r2_10(bool) = CompareNE : r2_8, r2_9 -# 970| r2_11(bool) = CopyValue : r2_10 -# 970| v2_12(void) = ConditionalBranch : r2_11 +# 970| r970_1(glval) = VariableAddress[z] : +# 970| r970_2(glval) = VariableAddress[x] : +# 970| r970_3(int) = Load : &:r970_2, ~mu966_3 +# 970| r970_4(glval) = VariableAddress[y] : +# 970| r970_5(int) = Load : &:r970_4, ~mu966_3 +# 970| r970_6(int) = Add : r970_3, r970_5 +# 970| mu970_7(int) = Store : &:r970_1, r970_6 +# 970| r970_8(glval) = VariableAddress[z] : +# 970| r970_9(int) = Load : &:r970_8, ~mu966_3 +# 970| r970_10(int) = Constant[0] : +# 970| r970_11(bool) = CompareNE : r970_9, r970_10 +# 970| r970_12(bool) = CopyValue : r970_11 +# 970| v970_13(void) = ConditionalBranch : r970_12 #-----| False -> Block 4 #-----| True -> Block 3 # 971| Block 3 -# 971| r3_0(int) = Constant[7] : -# 971| r3_1(glval) = VariableAddress[y] : -# 971| mu3_2(int) = Store : &:r3_1, r3_0 +# 971| r971_1(int) = Constant[7] : +# 971| r971_2(glval) = VariableAddress[y] : +# 971| mu971_3(int) = Store : &:r971_2, r971_1 #-----| Goto -> Block 6 # 973| Block 4 -# 973| r4_0(glval) = VariableAddress[p] : -# 973| r4_1(glval) = VariableAddress[x] : -# 973| r4_2(int *) = CopyValue : r4_1 -# 973| mu4_3(int *) = Store : &:r4_0, r4_2 -# 973| r4_4(glval) = VariableAddress[p] : -# 973| r4_5(int *) = Load : &:r4_4, ~mu0_2 -# 973| r4_6(int *) = Constant[0] : -# 973| r4_7(bool) = CompareNE : r4_5, r4_6 -# 973| r4_8(bool) = CopyValue : r4_7 -# 973| v4_9(void) = ConditionalBranch : r4_8 +# 973| r973_1(glval) = VariableAddress[p] : +# 973| r973_2(glval) = VariableAddress[x] : +# 973| r973_3(int *) = CopyValue : r973_2 +# 973| mu973_4(int *) = Store : &:r973_1, r973_3 +# 973| r973_5(glval) = VariableAddress[p] : +# 973| r973_6(int *) = Load : &:r973_5, ~mu966_3 +# 973| r973_7(int *) = Constant[0] : +# 973| r973_8(bool) = CompareNE : r973_6, r973_7 +# 973| r973_9(bool) = CopyValue : r973_8 +# 973| v973_10(void) = ConditionalBranch : r973_9 #-----| False -> Block 6 #-----| True -> Block 5 # 974| Block 5 -# 974| r5_0(int) = Constant[2] : -# 974| r5_1(glval) = VariableAddress[p] : -# 974| r5_2(int *) = Load : &:r5_1, ~mu0_2 -# 974| r5_3(glval) = CopyValue : r5_2 -# 974| mu5_4(int) = Store : &:r5_3, r5_0 +# 974| r974_1(int) = Constant[2] : +# 974| r974_2(glval) = VariableAddress[p] : +# 974| r974_3(int *) = Load : &:r974_2, ~mu966_3 +# 974| r974_4(glval) = CopyValue : r974_3 +# 974| mu974_5(int) = Store : &:r974_4, r974_1 #-----| Goto -> Block 6 # 976| Block 6 -# 976| v6_0(void) = NoOp : -# 966| v6_1(void) = ReturnVoid : -# 966| v6_2(void) = UnmodeledUse : mu* -# 966| v6_3(void) = AliasedUse : ~mu0_2 -# 966| v6_4(void) = ExitFunction : +# 976| v976_1(void) = NoOp : +# 966| v966_8(void) = ReturnVoid : +# 966| v966_9(void) = UnmodeledUse : mu* +# 966| v966_10(void) = AliasedUse : ~mu966_3 +# 966| v966_11(void) = ExitFunction : # 978| void WhileStmtWithDeclaration(int, int) # 978| Block 0 -# 978| v0_0(void) = EnterFunction : -# 978| mu0_1(unknown) = AliasedDefinition : -# 978| mu0_2(unknown) = UnmodeledDefinition : -# 978| r0_3(glval) = VariableAddress[x] : -# 978| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 978| r0_5(glval) = VariableAddress[y] : -# 978| mu0_6(int) = InitializeParameter[y] : &:r0_5 +# 978| v978_1(void) = EnterFunction : +# 978| mu978_2(unknown) = AliasedDefinition : +# 978| mu978_3(unknown) = UnmodeledDefinition : +# 978| r978_4(glval) = VariableAddress[x] : +# 978| mu978_5(int) = InitializeParameter[x] : &:r978_4 +# 978| r978_6(glval) = VariableAddress[y] : +# 978| mu978_7(int) = InitializeParameter[y] : &:r978_6 #-----| Goto -> Block 7 # 979| Block 1 -# 979| v1_0(void) = NoOp : +# 979| v979_1(void) = NoOp : #-----| Goto (back edge) -> Block 7 # 981| Block 2 -# 981| r2_0(glval) = VariableAddress[z] : -# 981| r2_1(glval) = VariableAddress[x] : -# 981| r2_2(int) = Load : &:r2_1, ~mu0_2 -# 981| r2_3(glval) = VariableAddress[y] : -# 981| r2_4(int) = Load : &:r2_3, ~mu0_2 -# 981| r2_5(int) = Add : r2_2, r2_4 -# 981| mu2_6(int) = Store : &:r2_0, r2_5 -# 981| r2_7(glval) = VariableAddress[z] : -# 981| r2_8(int) = Load : &:r2_7, ~mu0_2 -# 981| r2_9(int) = Constant[0] : -# 981| r2_10(bool) = CompareNE : r2_8, r2_9 -# 981| r2_11(bool) = CopyValue : r2_10 -# 981| v2_12(void) = ConditionalBranch : r2_11 +# 981| r981_1(glval) = VariableAddress[z] : +# 981| r981_2(glval) = VariableAddress[x] : +# 981| r981_3(int) = Load : &:r981_2, ~mu978_3 +# 981| r981_4(glval) = VariableAddress[y] : +# 981| r981_5(int) = Load : &:r981_4, ~mu978_3 +# 981| r981_6(int) = Add : r981_3, r981_5 +# 981| mu981_7(int) = Store : &:r981_1, r981_6 +# 981| r981_8(glval) = VariableAddress[z] : +# 981| r981_9(int) = Load : &:r981_8, ~mu978_3 +# 981| r981_10(int) = Constant[0] : +# 981| r981_11(bool) = CompareNE : r981_9, r981_10 +# 981| r981_12(bool) = CopyValue : r981_11 +# 981| v981_13(void) = ConditionalBranch : r981_12 #-----| False -> Block 4 #-----| True -> Block 3 # 981| Block 3 -# 981| v3_0(void) = NoOp : +# 981| v981_14(void) = NoOp : #-----| Goto (back edge) -> Block 2 # 983| Block 4 -# 983| r4_0(glval) = VariableAddress[p] : -# 983| r4_1(glval) = VariableAddress[x] : -# 983| r4_2(int *) = CopyValue : r4_1 -# 983| mu4_3(int *) = Store : &:r4_0, r4_2 -# 983| r4_4(glval) = VariableAddress[p] : -# 983| r4_5(int *) = Load : &:r4_4, ~mu0_2 -# 983| r4_6(int *) = Constant[0] : -# 983| r4_7(bool) = CompareNE : r4_5, r4_6 -# 983| r4_8(bool) = CopyValue : r4_7 -# 983| v4_9(void) = ConditionalBranch : r4_8 +# 983| r983_1(glval) = VariableAddress[p] : +# 983| r983_2(glval) = VariableAddress[x] : +# 983| r983_3(int *) = CopyValue : r983_2 +# 983| mu983_4(int *) = Store : &:r983_1, r983_3 +# 983| r983_5(glval) = VariableAddress[p] : +# 983| r983_6(int *) = Load : &:r983_5, ~mu978_3 +# 983| r983_7(int *) = Constant[0] : +# 983| r983_8(bool) = CompareNE : r983_6, r983_7 +# 983| r983_9(bool) = CopyValue : r983_8 +# 983| v983_10(void) = ConditionalBranch : r983_9 #-----| False -> Block 6 #-----| True -> Block 5 # 983| Block 5 -# 983| v5_0(void) = NoOp : +# 983| v983_11(void) = NoOp : #-----| Goto (back edge) -> Block 4 # 985| Block 6 -# 985| v6_0(void) = NoOp : -# 978| v6_1(void) = ReturnVoid : -# 978| v6_2(void) = UnmodeledUse : mu* -# 978| v6_3(void) = AliasedUse : ~mu0_2 -# 978| v6_4(void) = ExitFunction : +# 985| v985_1(void) = NoOp : +# 978| v978_8(void) = ReturnVoid : +# 978| v978_9(void) = UnmodeledUse : mu* +# 978| v978_10(void) = AliasedUse : ~mu978_3 +# 978| v978_11(void) = ExitFunction : # 979| Block 7 -# 979| r7_0(glval) = VariableAddress[b] : -# 979| r7_1(glval) = VariableAddress[x] : -# 979| r7_2(int) = Load : &:r7_1, ~mu0_2 -# 979| r7_3(glval) = VariableAddress[y] : -# 979| r7_4(int) = Load : &:r7_3, ~mu0_2 -# 979| r7_5(bool) = CompareLT : r7_2, r7_4 -# 979| mu7_6(bool) = Store : &:r7_0, r7_5 -# 979| r7_7(glval) = VariableAddress[b] : -# 979| r7_8(bool) = Load : &:r7_7, ~mu0_2 -# 979| r7_9(bool) = CopyValue : r7_8 -# 979| v7_10(void) = ConditionalBranch : r7_9 +# 979| r979_2(glval) = VariableAddress[b] : +# 979| r979_3(glval) = VariableAddress[x] : +# 979| r979_4(int) = Load : &:r979_3, ~mu978_3 +# 979| r979_5(glval) = VariableAddress[y] : +# 979| r979_6(int) = Load : &:r979_5, ~mu978_3 +# 979| r979_7(bool) = CompareLT : r979_4, r979_6 +# 979| mu979_8(bool) = Store : &:r979_2, r979_7 +# 979| r979_9(glval) = VariableAddress[b] : +# 979| r979_10(bool) = Load : &:r979_9, ~mu978_3 +# 979| r979_11(bool) = CopyValue : r979_10 +# 979| v979_12(void) = ConditionalBranch : r979_11 #-----| False -> Block 2 #-----| True -> Block 1 # 987| int PointerDecay(int[], int(float)) # 987| Block 0 -# 987| v0_0(void) = EnterFunction : -# 987| mu0_1(unknown) = AliasedDefinition : -# 987| mu0_2(unknown) = UnmodeledDefinition : -# 987| r0_3(glval) = VariableAddress[a] : -# 987| mu0_4(int *) = InitializeParameter[a] : &:r0_3 -# 987| r0_5(glval<..(*)(..)>) = VariableAddress[fn] : -# 987| mu0_6(..(*)(..)) = InitializeParameter[fn] : &:r0_5 -# 988| r0_7(glval) = VariableAddress[#return] : -# 988| r0_8(glval) = VariableAddress[a] : -# 988| r0_9(int *) = Load : &:r0_8, ~mu0_2 -# 988| r0_10(int) = Constant[0] : -# 988| r0_11(glval) = PointerAdd[4] : r0_9, r0_10 -# 988| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 988| r0_13(glval<..(*)(..)>) = VariableAddress[fn] : -# 988| r0_14(..(*)(..)) = Load : &:r0_13, ~mu0_2 -# 988| r0_15(float) = Constant[1.0] : -# 988| r0_16(int) = Call : func:r0_14, 0:r0_15 -# 988| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -# 988| r0_18(int) = Add : r0_12, r0_16 -# 988| mu0_19(int) = Store : &:r0_7, r0_18 -# 987| r0_20(glval) = VariableAddress[#return] : -# 987| v0_21(void) = ReturnValue : &:r0_20, ~mu0_2 -# 987| v0_22(void) = UnmodeledUse : mu* -# 987| v0_23(void) = AliasedUse : ~mu0_2 -# 987| v0_24(void) = ExitFunction : +# 987| v987_1(void) = EnterFunction : +# 987| mu987_2(unknown) = AliasedDefinition : +# 987| mu987_3(unknown) = UnmodeledDefinition : +# 987| r987_4(glval) = VariableAddress[a] : +# 987| mu987_5(int *) = InitializeParameter[a] : &:r987_4 +# 987| r987_6(glval<..(*)(..)>) = VariableAddress[fn] : +# 987| mu987_7(..(*)(..)) = InitializeParameter[fn] : &:r987_6 +# 988| r988_1(glval) = VariableAddress[#return] : +# 988| r988_2(glval) = VariableAddress[a] : +# 988| r988_3(int *) = Load : &:r988_2, ~mu987_3 +# 988| r988_4(int) = Constant[0] : +# 988| r988_5(glval) = PointerAdd[4] : r988_3, r988_4 +# 988| r988_6(int) = Load : &:r988_5, ~mu987_3 +# 988| r988_7(glval<..(*)(..)>) = VariableAddress[fn] : +# 988| r988_8(..(*)(..)) = Load : &:r988_7, ~mu987_3 +# 988| r988_9(float) = Constant[1.0] : +# 988| r988_10(int) = Call : func:r988_8, 0:r988_9 +# 988| mu988_11(unknown) = ^CallSideEffect : ~mu987_3 +# 988| r988_12(int) = Add : r988_6, r988_10 +# 988| mu988_13(int) = Store : &:r988_1, r988_12 +# 987| r987_8(glval) = VariableAddress[#return] : +# 987| v987_9(void) = ReturnValue : &:r987_8, ~mu987_3 +# 987| v987_10(void) = UnmodeledUse : mu* +# 987| v987_11(void) = AliasedUse : ~mu987_3 +# 987| v987_12(void) = ExitFunction : # 991| int ExprStmt(int, int, int) # 991| Block 0 -# 991| v0_0(void) = EnterFunction : -# 991| mu0_1(unknown) = AliasedDefinition : -# 991| mu0_2(unknown) = UnmodeledDefinition : -# 991| r0_3(glval) = VariableAddress[b] : -# 991| mu0_4(int) = InitializeParameter[b] : &:r0_3 -# 991| r0_5(glval) = VariableAddress[y] : -# 991| mu0_6(int) = InitializeParameter[y] : &:r0_5 -# 991| r0_7(glval) = VariableAddress[z] : -# 991| mu0_8(int) = InitializeParameter[z] : &:r0_7 -# 992| r0_9(glval) = VariableAddress[x] : -# 993| r0_10(glval) = VariableAddress[w] : -# 993| mu0_11(int) = Uninitialized[w] : &:r0_10 -# 994| r0_12(glval) = VariableAddress[b] : -# 994| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 994| r0_14(int) = Constant[0] : -# 994| r0_15(bool) = CompareNE : r0_13, r0_14 -# 994| v0_16(void) = ConditionalBranch : r0_15 +# 991| v991_1(void) = EnterFunction : +# 991| mu991_2(unknown) = AliasedDefinition : +# 991| mu991_3(unknown) = UnmodeledDefinition : +# 991| r991_4(glval) = VariableAddress[b] : +# 991| mu991_5(int) = InitializeParameter[b] : &:r991_4 +# 991| r991_6(glval) = VariableAddress[y] : +# 991| mu991_7(int) = InitializeParameter[y] : &:r991_6 +# 991| r991_8(glval) = VariableAddress[z] : +# 991| mu991_9(int) = InitializeParameter[z] : &:r991_8 +# 992| r992_1(glval) = VariableAddress[x] : +# 993| r993_1(glval) = VariableAddress[w] : +# 993| mu993_2(int) = Uninitialized[w] : &:r993_1 +# 994| r994_1(glval) = VariableAddress[b] : +# 994| r994_2(int) = Load : &:r994_1, ~mu991_3 +# 994| r994_3(int) = Constant[0] : +# 994| r994_4(bool) = CompareNE : r994_2, r994_3 +# 994| v994_5(void) = ConditionalBranch : r994_4 #-----| False -> Block 2 #-----| True -> Block 1 # 995| Block 1 -# 995| r1_0(glval) = VariableAddress[y] : -# 995| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 995| r1_2(glval) = VariableAddress[w] : -# 995| mu1_3(int) = Store : &:r1_2, r1_1 +# 995| r995_1(glval) = VariableAddress[y] : +# 995| r995_2(int) = Load : &:r995_1, ~mu991_3 +# 995| r995_3(glval) = VariableAddress[w] : +# 995| mu995_4(int) = Store : &:r995_3, r995_2 #-----| Goto -> Block 3 # 997| Block 2 -# 997| r2_0(glval) = VariableAddress[z] : -# 997| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 997| r2_2(glval) = VariableAddress[w] : -# 997| mu2_3(int) = Store : &:r2_2, r2_1 +# 997| r997_1(glval) = VariableAddress[z] : +# 997| r997_2(int) = Load : &:r997_1, ~mu991_3 +# 997| r997_3(glval) = VariableAddress[w] : +# 997| mu997_4(int) = Store : &:r997_3, r997_2 #-----| Goto -> Block 3 # 999| Block 3 -# 999| r3_0(glval) = VariableAddress[w] : -# 999| r3_1(int) = Load : &:r3_0, ~mu0_2 -# 992| r3_2(int) = CopyValue : r3_1 -# 992| mu3_3(int) = Store : &:r0_9, r3_2 -# 1002| r3_4(glval) = VariableAddress[#return] : -# 1002| r3_5(glval) = VariableAddress[x] : -# 1002| r3_6(int) = Load : &:r3_5, ~mu0_2 -# 1002| r3_7(int) = CopyValue : r3_6 -# 1002| mu3_8(int) = Store : &:r3_4, r3_7 -# 991| r3_9(glval) = VariableAddress[#return] : -# 991| v3_10(void) = ReturnValue : &:r3_9, ~mu0_2 -# 991| v3_11(void) = UnmodeledUse : mu* -# 991| v3_12(void) = AliasedUse : ~mu0_2 -# 991| v3_13(void) = ExitFunction : +# 999| r999_1(glval) = VariableAddress[w] : +# 999| r999_2(int) = Load : &:r999_1, ~mu991_3 +# 992| r992_2(int) = CopyValue : r999_2 +# 992| mu992_3(int) = Store : &:r992_1, r992_2 +# 1002| r1002_1(glval) = VariableAddress[#return] : +# 1002| r1002_2(glval) = VariableAddress[x] : +# 1002| r1002_3(int) = Load : &:r1002_2, ~mu991_3 +# 1002| r1002_4(int) = CopyValue : r1002_3 +# 1002| mu1002_5(int) = Store : &:r1002_1, r1002_4 +# 991| r991_10(glval) = VariableAddress[#return] : +# 991| v991_11(void) = ReturnValue : &:r991_10, ~mu991_3 +# 991| v991_12(void) = UnmodeledUse : mu* +# 991| v991_13(void) = AliasedUse : ~mu991_3 +# 991| v991_14(void) = ExitFunction : # 1006| void OperatorDelete() # 1006| Block 0 -# 1006| v0_0(void) = EnterFunction : -# 1006| mu0_1(unknown) = AliasedDefinition : -# 1006| mu0_2(unknown) = UnmodeledDefinition : -# 1007| r0_3(int *) = Constant[0] : -# 1007| v0_4(void) = NoOp : -# 1008| r0_5(String *) = Constant[0] : -# 1008| v0_6(void) = NoOp : -# 1009| r0_7(SizedDealloc *) = Constant[0] : -# 1009| v0_8(void) = NoOp : -# 1010| r0_9(Overaligned *) = Constant[0] : -# 1010| v0_10(void) = NoOp : -# 1011| r0_11(PolymorphicBase *) = Constant[0] : -# 1011| v0_12(void) = NoOp : -# 1012| v0_13(void) = NoOp : -# 1006| v0_14(void) = ReturnVoid : -# 1006| v0_15(void) = UnmodeledUse : mu* -# 1006| v0_16(void) = AliasedUse : ~mu0_2 -# 1006| v0_17(void) = ExitFunction : +# 1006| v1006_1(void) = EnterFunction : +# 1006| mu1006_2(unknown) = AliasedDefinition : +# 1006| mu1006_3(unknown) = UnmodeledDefinition : +# 1007| r1007_1(int *) = Constant[0] : +# 1007| v1007_2(void) = NoOp : +# 1008| r1008_1(String *) = Constant[0] : +# 1008| v1008_2(void) = NoOp : +# 1009| r1009_1(SizedDealloc *) = Constant[0] : +# 1009| v1009_2(void) = NoOp : +# 1010| r1010_1(Overaligned *) = Constant[0] : +# 1010| v1010_2(void) = NoOp : +# 1011| r1011_1(PolymorphicBase *) = Constant[0] : +# 1011| v1011_2(void) = NoOp : +# 1012| v1012_1(void) = NoOp : +# 1006| v1006_4(void) = ReturnVoid : +# 1006| v1006_5(void) = UnmodeledUse : mu* +# 1006| v1006_6(void) = AliasedUse : ~mu1006_3 +# 1006| v1006_7(void) = ExitFunction : # 1015| void OperatorDeleteArray() # 1015| Block 0 -# 1015| v0_0(void) = EnterFunction : -# 1015| mu0_1(unknown) = AliasedDefinition : -# 1015| mu0_2(unknown) = UnmodeledDefinition : -# 1016| r0_3(int *) = Constant[0] : -# 1016| v0_4(void) = NoOp : -# 1017| r0_5(String *) = Constant[0] : -# 1017| v0_6(void) = NoOp : -# 1018| r0_7(SizedDealloc *) = Constant[0] : -# 1018| v0_8(void) = NoOp : -# 1019| r0_9(Overaligned *) = Constant[0] : -# 1019| v0_10(void) = NoOp : -# 1020| r0_11(PolymorphicBase *) = Constant[0] : -# 1020| v0_12(void) = NoOp : -# 1021| v0_13(void) = NoOp : -# 1015| v0_14(void) = ReturnVoid : -# 1015| v0_15(void) = UnmodeledUse : mu* -# 1015| v0_16(void) = AliasedUse : ~mu0_2 -# 1015| v0_17(void) = ExitFunction : +# 1015| v1015_1(void) = EnterFunction : +# 1015| mu1015_2(unknown) = AliasedDefinition : +# 1015| mu1015_3(unknown) = UnmodeledDefinition : +# 1016| r1016_1(int *) = Constant[0] : +# 1016| v1016_2(void) = NoOp : +# 1017| r1017_1(String *) = Constant[0] : +# 1017| v1017_2(void) = NoOp : +# 1018| r1018_1(SizedDealloc *) = Constant[0] : +# 1018| v1018_2(void) = NoOp : +# 1019| r1019_1(Overaligned *) = Constant[0] : +# 1019| v1019_2(void) = NoOp : +# 1020| r1020_1(PolymorphicBase *) = Constant[0] : +# 1020| v1020_2(void) = NoOp : +# 1021| v1021_1(void) = NoOp : +# 1015| v1015_4(void) = ReturnVoid : +# 1015| v1015_5(void) = UnmodeledUse : mu* +# 1015| v1015_6(void) = AliasedUse : ~mu1015_3 +# 1015| v1015_7(void) = ExitFunction : # 1025| void EmptyStructInit() # 1025| Block 0 -# 1025| v0_0(void) = EnterFunction : -# 1025| mu0_1(unknown) = AliasedDefinition : -# 1025| mu0_2(unknown) = UnmodeledDefinition : -# 1026| r0_3(glval) = VariableAddress[s] : -# 1026| mu0_4(EmptyStruct) = Uninitialized[s] : &:r0_3 -# 1027| v0_5(void) = NoOp : -# 1025| v0_6(void) = ReturnVoid : -# 1025| v0_7(void) = UnmodeledUse : mu* -# 1025| v0_8(void) = AliasedUse : ~mu0_2 -# 1025| v0_9(void) = ExitFunction : +# 1025| v1025_1(void) = EnterFunction : +# 1025| mu1025_2(unknown) = AliasedDefinition : +# 1025| mu1025_3(unknown) = UnmodeledDefinition : +# 1026| r1026_1(glval) = VariableAddress[s] : +# 1026| mu1026_2(EmptyStruct) = Uninitialized[s] : &:r1026_1 +# 1027| v1027_1(void) = NoOp : +# 1025| v1025_4(void) = ReturnVoid : +# 1025| v1025_5(void) = UnmodeledUse : mu* +# 1025| v1025_6(void) = AliasedUse : ~mu1025_3 +# 1025| v1025_7(void) = ExitFunction : # 1029| void (lambda [] type at line 1029, col. 12)::operator()() const # 1029| Block 0 -# 1029| v0_0(void) = EnterFunction : -# 1029| mu0_1(unknown) = AliasedDefinition : -# 1029| mu0_2(unknown) = UnmodeledDefinition : -# 1029| r0_3(glval) = InitializeThis : -# 1029| v0_4(void) = NoOp : -# 1029| v0_5(void) = ReturnVoid : -# 1029| v0_6(void) = UnmodeledUse : mu* -# 1029| v0_7(void) = AliasedUse : ~mu0_2 -# 1029| v0_8(void) = ExitFunction : +# 1029| v1029_1(void) = EnterFunction : +# 1029| mu1029_3(unknown) = AliasedDefinition : +# 1029| mu1029_5(unknown) = UnmodeledDefinition : +# 1029| r1029_7(glval) = InitializeThis : +# 1029| v1029_9(void) = NoOp : +# 1029| v1029_11(void) = ReturnVoid : +# 1029| v1029_13(void) = UnmodeledUse : mu* +# 1029| v1029_15(void) = AliasedUse : ~mu1029_5 +# 1029| v1029_17(void) = ExitFunction : # 1029| void(* (lambda [] type at line 1029, col. 12)::operator void (*)()() const)() # 1029| Block 0 -# 1029| v0_0(void) = EnterFunction : -# 1029| mu0_1(unknown) = AliasedDefinition : -# 1029| mu0_2(unknown) = UnmodeledDefinition : -# 1029| r0_3(glval) = InitializeThis : -# 1029| r0_4(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| r0_5(..(*)(..)) = FunctionAddress[_FUN] : -# 1029| mu0_6(..(*)(..)) = Store : &:r0_4, r0_5 -# 1029| r0_7(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| v0_8(void) = ReturnValue : &:r0_7, ~mu0_2 -# 1029| v0_9(void) = UnmodeledUse : mu* -# 1029| v0_10(void) = AliasedUse : ~mu0_2 -# 1029| v0_11(void) = ExitFunction : +# 1029| v1029_1(void) = EnterFunction : +# 1029| mu1029_3(unknown) = AliasedDefinition : +# 1029| mu1029_5(unknown) = UnmodeledDefinition : +# 1029| r1029_7(glval) = InitializeThis : +# 1029| r1029_9(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| r1029_11(..(*)(..)) = FunctionAddress[_FUN] : +# 1029| mu1029_13(..(*)(..)) = Store : &:r1029_9, r1029_11 +# 1029| r1029_15(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| v1029_17(void) = ReturnValue : &:r1029_15, ~mu1029_5 +# 1029| v1029_19(void) = UnmodeledUse : mu* +# 1029| v1029_20(void) = AliasedUse : ~mu1029_5 +# 1029| v1029_21(void) = ExitFunction : # 1031| void Lambda(int, String const&) # 1031| Block 0 -# 1031| v0_0(void) = EnterFunction : -# 1031| mu0_1(unknown) = AliasedDefinition : -# 1031| mu0_2(unknown) = UnmodeledDefinition : -# 1031| r0_3(glval) = VariableAddress[x] : -# 1031| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 1031| r0_5(glval) = VariableAddress[s] : -# 1031| mu0_6(String &) = InitializeParameter[s] : &:r0_5 -# 1032| r0_7(glval) = VariableAddress[lambda_empty] : -# 1032| r0_8(glval) = VariableAddress[#temp1032:23] : -# 1032| mu0_9(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r0_8 -# 1032| r0_10(decltype([...](...){...})) = Load : &:r0_8, ~mu0_2 -# 1032| mu0_11(decltype([...](...){...})) = Store : &:r0_7, r0_10 -# 1033| r0_12(char) = Constant[65] : -# 1034| r0_13(glval) = VariableAddress[lambda_ref] : -# 1034| r0_14(glval) = VariableAddress[#temp1034:20] : -# 1034| mu0_15(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r0_14 -# 1034| r0_16(glval) = FieldAddress[s] : r0_14 -#-----| r0_17(glval) = VariableAddress[s] : -#-----| r0_18(String &) = Load : &:r0_17, ~mu0_2 -# 1034| r0_19(glval) = CopyValue : r0_18 -# 1034| r0_20(String &) = CopyValue : r0_19 -# 1034| mu0_21(String &) = Store : &:r0_16, r0_20 -# 1034| r0_22(glval) = FieldAddress[x] : r0_14 -#-----| r0_23(glval) = VariableAddress[x] : -#-----| r0_24(int &) = CopyValue : r0_23 -#-----| mu0_25(int &) = Store : &:r0_22, r0_24 -# 1034| r0_26(decltype([...](...){...})) = Load : &:r0_14, ~mu0_2 -# 1034| mu0_27(decltype([...](...){...})) = Store : &:r0_13, r0_26 -# 1035| r0_28(glval) = VariableAddress[lambda_ref] : -# 1035| r0_29(glval) = Convert : r0_28 -# 1035| r0_30(glval) = FunctionAddress[operator()] : -# 1035| r0_31(float) = Constant[1.0] : -# 1035| r0_32(char) = Call : func:r0_30, this:r0_29, 0:r0_31 -# 1035| mu0_33(unknown) = ^CallSideEffect : ~mu0_2 -# 1035| v0_34(void) = ^BufferReadSideEffect[-1] : &:r0_29, ~mu0_2 -# 1035| mu0_35(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_29 -# 1036| r0_36(glval) = VariableAddress[lambda_val] : -# 1036| r0_37(glval) = VariableAddress[#temp1036:20] : -# 1036| mu0_38(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r0_37 -# 1036| r0_39(glval) = FieldAddress[s] : r0_37 -#-----| r0_40(glval) = FunctionAddress[String] : -#-----| v0_41(void) = Call : func:r0_40, this:r0_39 -#-----| mu0_42(unknown) = ^CallSideEffect : ~mu0_2 -#-----| mu0_43(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_39 -# 1036| r0_44(glval) = FieldAddress[x] : r0_37 -#-----| r0_45(glval) = VariableAddress[x] : -#-----| r0_46(int) = Load : &:r0_45, ~mu0_2 -#-----| mu0_47(int) = Store : &:r0_44, r0_46 -# 1036| r0_48(decltype([...](...){...})) = Load : &:r0_37, ~mu0_2 -# 1036| mu0_49(decltype([...](...){...})) = Store : &:r0_36, r0_48 -# 1037| r0_50(glval) = VariableAddress[lambda_val] : -# 1037| r0_51(glval) = Convert : r0_50 -# 1037| r0_52(glval) = FunctionAddress[operator()] : -# 1037| r0_53(float) = Constant[2.0] : -# 1037| r0_54(char) = Call : func:r0_52, this:r0_51, 0:r0_53 -# 1037| mu0_55(unknown) = ^CallSideEffect : ~mu0_2 -# 1037| v0_56(void) = ^BufferReadSideEffect[-1] : &:r0_51, ~mu0_2 -# 1037| mu0_57(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_51 -# 1038| r0_58(glval) = VariableAddress[lambda_ref_explicit] : -# 1038| r0_59(glval) = VariableAddress[#temp1038:29] : -# 1038| mu0_60(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r0_59 -# 1038| r0_61(glval) = FieldAddress[s] : r0_59 -# 1038| r0_62(glval) = VariableAddress[s] : -# 1038| r0_63(String &) = Load : &:r0_62, ~mu0_2 -# 1038| r0_64(glval) = CopyValue : r0_63 -# 1038| r0_65(String &) = CopyValue : r0_64 -# 1038| mu0_66(String &) = Store : &:r0_61, r0_65 -# 1038| r0_67(decltype([...](...){...})) = Load : &:r0_59, ~mu0_2 -# 1038| mu0_68(decltype([...](...){...})) = Store : &:r0_58, r0_67 -# 1039| r0_69(glval) = VariableAddress[lambda_ref_explicit] : -# 1039| r0_70(glval) = Convert : r0_69 -# 1039| r0_71(glval) = FunctionAddress[operator()] : -# 1039| r0_72(float) = Constant[3.0] : -# 1039| r0_73(char) = Call : func:r0_71, this:r0_70, 0:r0_72 -# 1039| mu0_74(unknown) = ^CallSideEffect : ~mu0_2 -# 1039| v0_75(void) = ^BufferReadSideEffect[-1] : &:r0_70, ~mu0_2 -# 1039| mu0_76(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_70 -# 1040| r0_77(glval) = VariableAddress[lambda_val_explicit] : -# 1040| r0_78(glval) = VariableAddress[#temp1040:29] : -# 1040| mu0_79(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r0_78 -# 1040| r0_80(glval) = FieldAddress[s] : r0_78 -#-----| r0_81(glval) = FunctionAddress[String] : -#-----| v0_82(void) = Call : func:r0_81, this:r0_80 -#-----| mu0_83(unknown) = ^CallSideEffect : ~mu0_2 -#-----| mu0_84(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_80 -# 1040| r0_85(decltype([...](...){...})) = Load : &:r0_78, ~mu0_2 -# 1040| mu0_86(decltype([...](...){...})) = Store : &:r0_77, r0_85 -# 1041| r0_87(glval) = VariableAddress[lambda_val_explicit] : -# 1041| r0_88(glval) = Convert : r0_87 -# 1041| r0_89(glval) = FunctionAddress[operator()] : -# 1041| r0_90(float) = Constant[4.0] : -# 1041| r0_91(char) = Call : func:r0_89, this:r0_88, 0:r0_90 -# 1041| mu0_92(unknown) = ^CallSideEffect : ~mu0_2 -# 1041| v0_93(void) = ^BufferReadSideEffect[-1] : &:r0_88, ~mu0_2 -# 1041| mu0_94(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_88 -# 1042| r0_95(glval) = VariableAddress[lambda_mixed_explicit] : -# 1042| r0_96(glval) = VariableAddress[#temp1042:31] : -# 1042| mu0_97(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r0_96 -# 1042| r0_98(glval) = FieldAddress[s] : r0_96 -# 1042| r0_99(glval) = VariableAddress[s] : -# 1042| r0_100(String &) = Load : &:r0_99, ~mu0_2 -# 1042| r0_101(glval) = CopyValue : r0_100 -# 1042| r0_102(String &) = CopyValue : r0_101 -# 1042| mu0_103(String &) = Store : &:r0_98, r0_102 -# 1042| r0_104(glval) = FieldAddress[x] : r0_96 -# 1042| r0_105(glval) = VariableAddress[x] : -# 1042| r0_106(int) = Load : &:r0_105, ~mu0_2 -# 1042| mu0_107(int) = Store : &:r0_104, r0_106 -# 1042| r0_108(decltype([...](...){...})) = Load : &:r0_96, ~mu0_2 -# 1042| mu0_109(decltype([...](...){...})) = Store : &:r0_95, r0_108 -# 1043| r0_110(glval) = VariableAddress[lambda_mixed_explicit] : -# 1043| r0_111(glval) = Convert : r0_110 -# 1043| r0_112(glval) = FunctionAddress[operator()] : -# 1043| r0_113(float) = Constant[5.0] : -# 1043| r0_114(char) = Call : func:r0_112, this:r0_111, 0:r0_113 -# 1043| mu0_115(unknown) = ^CallSideEffect : ~mu0_2 -# 1043| v0_116(void) = ^BufferReadSideEffect[-1] : &:r0_111, ~mu0_2 -# 1043| mu0_117(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_111 -# 1044| r0_118(glval) = VariableAddress[r] : -# 1044| r0_119(glval) = VariableAddress[x] : -# 1044| r0_120(int) = Load : &:r0_119, ~mu0_2 -# 1044| r0_121(int) = Constant[1] : -# 1044| r0_122(int) = Sub : r0_120, r0_121 -# 1044| mu0_123(int) = Store : &:r0_118, r0_122 -# 1045| r0_124(glval) = VariableAddress[lambda_inits] : -# 1045| r0_125(glval) = VariableAddress[#temp1045:22] : -# 1045| mu0_126(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r0_125 -# 1045| r0_127(glval) = FieldAddress[s] : r0_125 -# 1045| r0_128(glval) = VariableAddress[s] : -# 1045| r0_129(String &) = Load : &:r0_128, ~mu0_2 -# 1045| r0_130(glval) = CopyValue : r0_129 -# 1045| r0_131(String &) = CopyValue : r0_130 -# 1045| mu0_132(String &) = Store : &:r0_127, r0_131 -# 1045| r0_133(glval) = FieldAddress[x] : r0_125 -# 1045| r0_134(glval) = VariableAddress[x] : -# 1045| r0_135(int) = Load : &:r0_134, ~mu0_2 -# 1045| mu0_136(int) = Store : &:r0_133, r0_135 -# 1045| r0_137(glval) = FieldAddress[i] : r0_125 -# 1045| r0_138(glval) = VariableAddress[x] : -# 1045| r0_139(int) = Load : &:r0_138, ~mu0_2 -# 1045| r0_140(int) = Constant[1] : -# 1045| r0_141(int) = Add : r0_139, r0_140 -# 1045| mu0_142(int) = Store : &:r0_137, r0_141 -# 1045| r0_143(glval) = FieldAddress[j] : r0_125 -# 1045| r0_144(glval) = VariableAddress[r] : -# 1045| r0_145(int &) = CopyValue : r0_144 -# 1045| mu0_146(int &) = Store : &:r0_143, r0_145 -# 1045| r0_147(decltype([...](...){...})) = Load : &:r0_125, ~mu0_2 -# 1045| mu0_148(decltype([...](...){...})) = Store : &:r0_124, r0_147 -# 1046| r0_149(glval) = VariableAddress[lambda_inits] : -# 1046| r0_150(glval) = Convert : r0_149 -# 1046| r0_151(glval) = FunctionAddress[operator()] : -# 1046| r0_152(float) = Constant[6.0] : -# 1046| r0_153(char) = Call : func:r0_151, this:r0_150, 0:r0_152 -# 1046| mu0_154(unknown) = ^CallSideEffect : ~mu0_2 -# 1046| v0_155(void) = ^BufferReadSideEffect[-1] : &:r0_150, ~mu0_2 -# 1046| mu0_156(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_150 -# 1047| v0_157(void) = NoOp : -# 1031| v0_158(void) = ReturnVoid : -# 1031| v0_159(void) = UnmodeledUse : mu* -# 1031| v0_160(void) = AliasedUse : ~mu0_2 -# 1031| v0_161(void) = ExitFunction : +# 1031| v1031_1(void) = EnterFunction : +# 1031| mu1031_2(unknown) = AliasedDefinition : +# 1031| mu1031_3(unknown) = UnmodeledDefinition : +# 1031| r1031_4(glval) = VariableAddress[x] : +# 1031| mu1031_5(int) = InitializeParameter[x] : &:r1031_4 +# 1031| r1031_6(glval) = VariableAddress[s] : +# 1031| mu1031_7(String &) = InitializeParameter[s] : &:r1031_6 +# 1032| r1032_15(glval) = VariableAddress[lambda_empty] : +# 1032| r1032_18(glval) = VariableAddress[#temp1032:23] : +# 1032| mu1032_21(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r1032_18 +# 1032| r1032_24(decltype([...](...){...})) = Load : &:r1032_18, ~mu1031_3 +# 1032| mu1032_27(decltype([...](...){...})) = Store : &:r1032_15, r1032_24 +# 1033| r1033_1(char) = Constant[65] : +# 1034| r1034_11(glval) = VariableAddress[lambda_ref] : +# 1034| r1034_13(glval) = VariableAddress[#temp1034:20] : +# 1034| mu1034_15(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r1034_13 +# 1034| r1034_17(glval) = FieldAddress[s] : r1034_13 +#-----| r0_75(glval) = VariableAddress[s] : +#-----| r0_80(String &) = Load : &:r0_75, ~mu1031_3 +# 1034| r1034_18(glval) = CopyValue : r0_80 +# 1034| r1034_20(String &) = CopyValue : r1034_18 +# 1034| mu1034_22(String &) = Store : &:r1034_17, r1034_20 +# 1034| r1034_24(glval) = FieldAddress[x] : r1034_13 +#-----| r0_104(glval) = VariableAddress[x] : +#-----| r0_110(int &) = CopyValue : r0_104 +#-----| mu0_116(int &) = Store : &:r1034_24, r0_110 +# 1034| r1034_29(decltype([...](...){...})) = Load : &:r1034_13, ~mu1031_3 +# 1034| mu1034_31(decltype([...](...){...})) = Store : &:r1034_11, r1034_29 +# 1035| r1035_1(glval) = VariableAddress[lambda_ref] : +# 1035| r1035_2(glval) = Convert : r1035_1 +# 1035| r1035_3(glval) = FunctionAddress[operator()] : +# 1035| r1035_4(float) = Constant[1.0] : +# 1035| r1035_5(char) = Call : func:r1035_3, this:r1035_2, 0:r1035_4 +# 1035| mu1035_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1035| v1035_7(void) = ^BufferReadSideEffect[-1] : &:r1035_2, ~mu1031_3 +# 1035| mu1035_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1035_2 +# 1036| r1036_31(glval) = VariableAddress[lambda_val] : +# 1036| r1036_32(glval) = VariableAddress[#temp1036:20] : +# 1036| mu1036_33(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r1036_32 +# 1036| r1036_34(glval) = FieldAddress[s] : r1036_32 +#-----| r0_147(glval) = FunctionAddress[String] : +#-----| v0_150(void) = Call : func:r0_147, this:r1036_34 +#-----| mu0_153(unknown) = ^CallSideEffect : ~mu1031_3 +#-----| mu0_157(String) = ^IndirectMayWriteSideEffect[-1] : &:r1036_34 +# 1036| r1036_35(glval) = FieldAddress[x] : r1036_32 +#-----| r0_160(glval) = VariableAddress[x] : +#-----| r0_161(int) = Load : &:r0_160, ~mu1031_3 +#-----| mu0_162(int) = Store : &:r1036_35, r0_161 +# 1036| r1036_36(decltype([...](...){...})) = Load : &:r1036_32, ~mu1031_3 +# 1036| mu1036_37(decltype([...](...){...})) = Store : &:r1036_31, r1036_36 +# 1037| r1037_1(glval) = VariableAddress[lambda_val] : +# 1037| r1037_2(glval) = Convert : r1037_1 +# 1037| r1037_3(glval) = FunctionAddress[operator()] : +# 1037| r1037_4(float) = Constant[2.0] : +# 1037| r1037_5(char) = Call : func:r1037_3, this:r1037_2, 0:r1037_4 +# 1037| mu1037_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1037| v1037_7(void) = ^BufferReadSideEffect[-1] : &:r1037_2, ~mu1031_3 +# 1037| mu1037_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1037_2 +# 1038| r1038_23(glval) = VariableAddress[lambda_ref_explicit] : +# 1038| r1038_24(glval) = VariableAddress[#temp1038:29] : +# 1038| mu1038_25(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r1038_24 +# 1038| r1038_26(glval) = FieldAddress[s] : r1038_24 +# 1038| r1038_27(glval) = VariableAddress[s] : +# 1038| r1038_28(String &) = Load : &:r1038_27, ~mu1031_3 +# 1038| r1038_29(glval) = CopyValue : r1038_28 +# 1038| r1038_30(String &) = CopyValue : r1038_29 +# 1038| mu1038_31(String &) = Store : &:r1038_26, r1038_30 +# 1038| r1038_32(decltype([...](...){...})) = Load : &:r1038_24, ~mu1031_3 +# 1038| mu1038_33(decltype([...](...){...})) = Store : &:r1038_23, r1038_32 +# 1039| r1039_1(glval) = VariableAddress[lambda_ref_explicit] : +# 1039| r1039_2(glval) = Convert : r1039_1 +# 1039| r1039_3(glval) = FunctionAddress[operator()] : +# 1039| r1039_4(float) = Constant[3.0] : +# 1039| r1039_5(char) = Call : func:r1039_3, this:r1039_2, 0:r1039_4 +# 1039| mu1039_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1039| v1039_7(void) = ^BufferReadSideEffect[-1] : &:r1039_2, ~mu1031_3 +# 1039| mu1039_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1039_2 +# 1040| r1040_32(glval) = VariableAddress[lambda_val_explicit] : +# 1040| r1040_33(glval) = VariableAddress[#temp1040:29] : +# 1040| mu1040_34(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r1040_33 +# 1040| r1040_35(glval) = FieldAddress[s] : r1040_33 +#-----| r0_163(glval) = FunctionAddress[String] : +#-----| v0_164(void) = Call : func:r0_163, this:r1040_35 +#-----| mu0_165(unknown) = ^CallSideEffect : ~mu1031_3 +#-----| mu0_166(String) = ^IndirectMayWriteSideEffect[-1] : &:r1040_35 +# 1040| r1040_36(decltype([...](...){...})) = Load : &:r1040_33, ~mu1031_3 +# 1040| mu1040_37(decltype([...](...){...})) = Store : &:r1040_32, r1040_36 +# 1041| r1041_1(glval) = VariableAddress[lambda_val_explicit] : +# 1041| r1041_2(glval) = Convert : r1041_1 +# 1041| r1041_3(glval) = FunctionAddress[operator()] : +# 1041| r1041_4(float) = Constant[4.0] : +# 1041| r1041_5(char) = Call : func:r1041_3, this:r1041_2, 0:r1041_4 +# 1041| mu1041_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1041| v1041_7(void) = ^BufferReadSideEffect[-1] : &:r1041_2, ~mu1031_3 +# 1041| mu1041_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1041_2 +# 1042| r1042_22(glval) = VariableAddress[lambda_mixed_explicit] : +# 1042| r1042_23(glval) = VariableAddress[#temp1042:31] : +# 1042| mu1042_24(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r1042_23 +# 1042| r1042_25(glval) = FieldAddress[s] : r1042_23 +# 1042| r1042_26(glval) = VariableAddress[s] : +# 1042| r1042_27(String &) = Load : &:r1042_26, ~mu1031_3 +# 1042| r1042_28(glval) = CopyValue : r1042_27 +# 1042| r1042_29(String &) = CopyValue : r1042_28 +# 1042| mu1042_30(String &) = Store : &:r1042_25, r1042_29 +# 1042| r1042_31(glval) = FieldAddress[x] : r1042_23 +# 1042| r1042_32(glval) = VariableAddress[x] : +# 1042| r1042_33(int) = Load : &:r1042_32, ~mu1031_3 +# 1042| mu1042_34(int) = Store : &:r1042_31, r1042_33 +# 1042| r1042_35(decltype([...](...){...})) = Load : &:r1042_23, ~mu1031_3 +# 1042| mu1042_36(decltype([...](...){...})) = Store : &:r1042_22, r1042_35 +# 1043| r1043_1(glval) = VariableAddress[lambda_mixed_explicit] : +# 1043| r1043_2(glval) = Convert : r1043_1 +# 1043| r1043_3(glval) = FunctionAddress[operator()] : +# 1043| r1043_4(float) = Constant[5.0] : +# 1043| r1043_5(char) = Call : func:r1043_3, this:r1043_2, 0:r1043_4 +# 1043| mu1043_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1043| v1043_7(void) = ^BufferReadSideEffect[-1] : &:r1043_2, ~mu1031_3 +# 1043| mu1043_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1043_2 +# 1044| r1044_1(glval) = VariableAddress[r] : +# 1044| r1044_2(glval) = VariableAddress[x] : +# 1044| r1044_3(int) = Load : &:r1044_2, ~mu1031_3 +# 1044| r1044_4(int) = Constant[1] : +# 1044| r1044_5(int) = Sub : r1044_3, r1044_4 +# 1044| mu1044_6(int) = Store : &:r1044_1, r1044_5 +# 1045| r1045_29(glval) = VariableAddress[lambda_inits] : +# 1045| r1045_30(glval) = VariableAddress[#temp1045:22] : +# 1045| mu1045_31(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r1045_30 +# 1045| r1045_32(glval) = FieldAddress[s] : r1045_30 +# 1045| r1045_33(glval) = VariableAddress[s] : +# 1045| r1045_34(String &) = Load : &:r1045_33, ~mu1031_3 +# 1045| r1045_35(glval) = CopyValue : r1045_34 +# 1045| r1045_36(String &) = CopyValue : r1045_35 +# 1045| mu1045_37(String &) = Store : &:r1045_32, r1045_36 +# 1045| r1045_38(glval) = FieldAddress[x] : r1045_30 +# 1045| r1045_39(glval) = VariableAddress[x] : +# 1045| r1045_40(int) = Load : &:r1045_39, ~mu1031_3 +# 1045| mu1045_41(int) = Store : &:r1045_38, r1045_40 +# 1045| r1045_42(glval) = FieldAddress[i] : r1045_30 +# 1045| r1045_43(glval) = VariableAddress[x] : +# 1045| r1045_44(int) = Load : &:r1045_43, ~mu1031_3 +# 1045| r1045_45(int) = Constant[1] : +# 1045| r1045_46(int) = Add : r1045_44, r1045_45 +# 1045| mu1045_47(int) = Store : &:r1045_42, r1045_46 +# 1045| r1045_48(glval) = FieldAddress[j] : r1045_30 +# 1045| r1045_49(glval) = VariableAddress[r] : +# 1045| r1045_50(int &) = CopyValue : r1045_49 +# 1045| mu1045_51(int &) = Store : &:r1045_48, r1045_50 +# 1045| r1045_52(decltype([...](...){...})) = Load : &:r1045_30, ~mu1031_3 +# 1045| mu1045_53(decltype([...](...){...})) = Store : &:r1045_29, r1045_52 +# 1046| r1046_1(glval) = VariableAddress[lambda_inits] : +# 1046| r1046_2(glval) = Convert : r1046_1 +# 1046| r1046_3(glval) = FunctionAddress[operator()] : +# 1046| r1046_4(float) = Constant[6.0] : +# 1046| r1046_5(char) = Call : func:r1046_3, this:r1046_2, 0:r1046_4 +# 1046| mu1046_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1046| v1046_7(void) = ^BufferReadSideEffect[-1] : &:r1046_2, ~mu1031_3 +# 1046| mu1046_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1046_2 +# 1047| v1047_1(void) = NoOp : +# 1031| v1031_8(void) = ReturnVoid : +# 1031| v1031_9(void) = UnmodeledUse : mu* +# 1031| v1031_10(void) = AliasedUse : ~mu1031_3 +# 1031| v1031_11(void) = ExitFunction : # 1032| char (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator()(float) const # 1032| Block 0 -# 1032| v0_0(void) = EnterFunction : -# 1032| mu0_1(unknown) = AliasedDefinition : -# 1032| mu0_2(unknown) = UnmodeledDefinition : -# 1032| r0_3(glval) = InitializeThis : -# 1032| r0_4(glval) = VariableAddress[f] : -# 1032| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1032| r0_6(glval) = VariableAddress[#return] : -# 1032| r0_7(char) = Constant[65] : -# 1032| mu0_8(char) = Store : &:r0_6, r0_7 -# 1032| r0_9(glval) = VariableAddress[#return] : -# 1032| v0_10(void) = ReturnValue : &:r0_9, ~mu0_2 -# 1032| v0_11(void) = UnmodeledUse : mu* -# 1032| v0_12(void) = AliasedUse : ~mu0_2 -# 1032| v0_13(void) = ExitFunction : +# 1032| v1032_1(void) = EnterFunction : +# 1032| mu1032_3(unknown) = AliasedDefinition : +# 1032| mu1032_5(unknown) = UnmodeledDefinition : +# 1032| r1032_7(glval) = InitializeThis : +# 1032| r1032_9(glval) = VariableAddress[f] : +# 1032| mu1032_11(float) = InitializeParameter[f] : &:r1032_9 +# 1032| r1032_13(glval) = VariableAddress[#return] : +# 1032| r1032_15(char) = Constant[65] : +# 1032| mu1032_18(char) = Store : &:r1032_13, r1032_15 +# 1032| r1032_21(glval) = VariableAddress[#return] : +# 1032| v1032_24(void) = ReturnValue : &:r1032_21, ~mu1032_5 +# 1032| v1032_27(void) = UnmodeledUse : mu* +# 1032| v1032_30(void) = AliasedUse : ~mu1032_5 +# 1032| v1032_31(void) = ExitFunction : # 1032| char(* (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator char (*)(float)() const)(float) # 1032| Block 0 -# 1032| v0_0(void) = EnterFunction : -# 1032| mu0_1(unknown) = AliasedDefinition : -# 1032| mu0_2(unknown) = UnmodeledDefinition : -# 1032| r0_3(glval) = InitializeThis : -# 1032| r0_4(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| r0_5(..(*)(..)) = FunctionAddress[_FUN] : -# 1032| mu0_6(..(*)(..)) = Store : &:r0_4, r0_5 -# 1032| r0_7(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| v0_8(void) = ReturnValue : &:r0_7, ~mu0_2 -# 1032| v0_9(void) = UnmodeledUse : mu* -# 1032| v0_10(void) = AliasedUse : ~mu0_2 -# 1032| v0_11(void) = ExitFunction : +# 1032| v1032_1(void) = EnterFunction : +# 1032| mu1032_3(unknown) = AliasedDefinition : +# 1032| mu1032_5(unknown) = UnmodeledDefinition : +# 1032| r1032_7(glval) = InitializeThis : +# 1032| r1032_9(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| r1032_11(..(*)(..)) = FunctionAddress[_FUN] : +# 1032| mu1032_13(..(*)(..)) = Store : &:r1032_9, r1032_11 +# 1032| r1032_15(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| v1032_18(void) = ReturnValue : &:r1032_15, ~mu1032_5 +# 1032| v1032_21(void) = UnmodeledUse : mu* +# 1032| v1032_24(void) = AliasedUse : ~mu1032_5 +# 1032| v1032_27(void) = ExitFunction : # 1034| char (void Lambda(int, String const&))::(lambda [] type at line 1034, col. 21)::operator()(float) const # 1034| Block 0 -# 1034| v0_0(void) = EnterFunction : -# 1034| mu0_1(unknown) = AliasedDefinition : -# 1034| mu0_2(unknown) = UnmodeledDefinition : -# 1034| r0_3(glval) = InitializeThis : -# 1034| r0_4(glval) = VariableAddress[f] : -# 1034| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1034| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1034, col. 21 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -#-----| r0_9(String &) = Load : &:r0_8, ~mu0_2 -# 1034| r0_10(glval) = CopyValue : r0_9 -# 1034| r0_11(glval) = FunctionAddress[c_str] : -# 1034| r0_12(char *) = Call : func:r0_11, this:r0_10 -# 1034| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 1034| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_10, ~mu0_2 -# 1034| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_10 -#-----| r0_16(lambda [] type at line 1034, col. 21 *) = CopyValue : r0_3 -#-----| r0_17(glval) = FieldAddress[x] : r0_16 -#-----| r0_18(int &) = Load : &:r0_17, ~mu0_2 -# 1034| r0_19(int) = Load : &:r0_18, ~mu0_2 -# 1034| r0_20(glval) = PointerAdd[1] : r0_12, r0_19 -# 1034| r0_21(char) = Load : &:r0_20, ~mu0_2 -# 1034| mu0_22(char) = Store : &:r0_6, r0_21 -# 1034| r0_23(glval) = VariableAddress[#return] : -# 1034| v0_24(void) = ReturnValue : &:r0_23, ~mu0_2 -# 1034| v0_25(void) = UnmodeledUse : mu* -# 1034| v0_26(void) = AliasedUse : ~mu0_2 -# 1034| v0_27(void) = ExitFunction : +# 1034| v1034_1(void) = EnterFunction : +# 1034| mu1034_2(unknown) = AliasedDefinition : +# 1034| mu1034_3(unknown) = UnmodeledDefinition : +# 1034| r1034_4(glval) = InitializeThis : +# 1034| r1034_5(glval) = VariableAddress[f] : +# 1034| mu1034_6(float) = InitializeParameter[f] : &:r1034_5 +# 1034| r1034_7(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +#-----| r0_36(String &) = Load : &:r0_27, ~mu1034_3 +# 1034| r1034_8(glval) = CopyValue : r0_36 +# 1034| r1034_9(glval) = FunctionAddress[c_str] : +# 1034| r1034_10(char *) = Call : func:r1034_9, this:r1034_8 +# 1034| mu1034_11(unknown) = ^CallSideEffect : ~mu1034_3 +# 1034| v1034_13(void) = ^BufferReadSideEffect[-1] : &:r1034_8, ~mu1034_3 +# 1034| mu1034_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r1034_8 +#-----| r0_71(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_75(glval) = FieldAddress[x] : r0_71 +#-----| r0_80(int &) = Load : &:r0_75, ~mu1034_3 +# 1034| r1034_18(int) = Load : &:r0_80, ~mu1034_3 +# 1034| r1034_20(glval) = PointerAdd[1] : r1034_10, r1034_18 +# 1034| r1034_22(char) = Load : &:r1034_20, ~mu1034_3 +# 1034| mu1034_24(char) = Store : &:r1034_7, r1034_22 +# 1034| r1034_26(glval) = VariableAddress[#return] : +# 1034| v1034_27(void) = ReturnValue : &:r1034_26, ~mu1034_3 +# 1034| v1034_28(void) = UnmodeledUse : mu* +# 1034| v1034_29(void) = AliasedUse : ~mu1034_3 +# 1034| v1034_31(void) = ExitFunction : # 1036| void (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::~() # 1036| Block 0 -# 1036| v0_0(void) = EnterFunction : -# 1036| mu0_1(unknown) = AliasedDefinition : -# 1036| mu0_2(unknown) = UnmodeledDefinition : -# 1036| r0_3(glval) = InitializeThis : -#-----| v0_4(void) = NoOp : -# 1036| r0_5(glval) = FieldAddress[s] : r0_3 -# 1036| r0_6(glval) = FunctionAddress[~String] : -# 1036| v0_7(void) = Call : func:r0_6, this:r0_5 -# 1036| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 1036| v0_9(void) = ReturnVoid : -# 1036| v0_10(void) = UnmodeledUse : mu* -# 1036| v0_11(void) = AliasedUse : ~mu0_2 -# 1036| v0_12(void) = ExitFunction : +# 1036| v1036_1(void) = EnterFunction : +# 1036| mu1036_3(unknown) = AliasedDefinition : +# 1036| mu1036_5(unknown) = UnmodeledDefinition : +# 1036| r1036_7(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1036| r1036_10(glval) = FieldAddress[s] : r1036_7 +# 1036| r1036_12(glval) = FunctionAddress[~String] : +# 1036| v1036_14(void) = Call : func:r1036_12, this:r1036_10 +# 1036| mu1036_15(unknown) = ^CallSideEffect : ~mu1036_5 +# 1036| v1036_16(void) = ReturnVoid : +# 1036| v1036_18(void) = UnmodeledUse : mu* +# 1036| v1036_20(void) = AliasedUse : ~mu1036_5 +# 1036| v1036_22(void) = ExitFunction : # 1036| char (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::operator()(float) const # 1036| Block 0 -# 1036| v0_0(void) = EnterFunction : -# 1036| mu0_1(unknown) = AliasedDefinition : -# 1036| mu0_2(unknown) = UnmodeledDefinition : -# 1036| r0_3(glval) = InitializeThis : -# 1036| r0_4(glval) = VariableAddress[f] : -# 1036| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1036| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1036, col. 21 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -# 1036| r0_9(glval) = FunctionAddress[c_str] : -# 1036| r0_10(char *) = Call : func:r0_9, this:r0_8 -# 1036| mu0_11(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_12(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu0_2 -#-----| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -#-----| r0_14(lambda [] type at line 1036, col. 21 *) = CopyValue : r0_3 -#-----| r0_15(glval) = FieldAddress[x] : r0_14 -#-----| r0_16(int) = Load : &:r0_15, ~mu0_2 -# 1036| r0_17(glval) = PointerAdd[1] : r0_10, r0_16 -# 1036| r0_18(char) = Load : &:r0_17, ~mu0_2 -# 1036| mu0_19(char) = Store : &:r0_6, r0_18 -# 1036| r0_20(glval) = VariableAddress[#return] : -# 1036| v0_21(void) = ReturnValue : &:r0_20, ~mu0_2 -# 1036| v0_22(void) = UnmodeledUse : mu* -# 1036| v0_23(void) = AliasedUse : ~mu0_2 -# 1036| v0_24(void) = ExitFunction : +# 1036| v1036_1(void) = EnterFunction : +# 1036| mu1036_3(unknown) = AliasedDefinition : +# 1036| mu1036_5(unknown) = UnmodeledDefinition : +# 1036| r1036_7(glval) = InitializeThis : +# 1036| r1036_9(glval) = VariableAddress[f] : +# 1036| mu1036_10(float) = InitializeParameter[f] : &:r1036_9 +# 1036| r1036_12(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_7 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +# 1036| r1036_16(glval) = FunctionAddress[c_str] : +# 1036| r1036_18(char *) = Call : func:r1036_16, this:r0_27 +# 1036| mu1036_20(unknown) = ^CallSideEffect : ~mu1036_5 +#-----| v0_50(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~mu1036_5 +#-----| mu0_56(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 +#-----| r0_62(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_7 +#-----| r0_68(glval) = FieldAddress[x] : r0_62 +#-----| r0_71(int) = Load : &:r0_68, ~mu1036_5 +# 1036| r1036_23(glval) = PointerAdd[1] : r1036_18, r0_71 +# 1036| r1036_24(char) = Load : &:r1036_23, ~mu1036_5 +# 1036| mu1036_25(char) = Store : &:r1036_12, r1036_24 +# 1036| r1036_26(glval) = VariableAddress[#return] : +# 1036| v1036_27(void) = ReturnValue : &:r1036_26, ~mu1036_5 +# 1036| v1036_28(void) = UnmodeledUse : mu* +# 1036| v1036_29(void) = AliasedUse : ~mu1036_5 +# 1036| v1036_30(void) = ExitFunction : # 1038| char (void Lambda(int, String const&))::(lambda [] type at line 1038, col. 30)::operator()(float) const # 1038| Block 0 -# 1038| v0_0(void) = EnterFunction : -# 1038| mu0_1(unknown) = AliasedDefinition : -# 1038| mu0_2(unknown) = UnmodeledDefinition : -# 1038| r0_3(glval) = InitializeThis : -# 1038| r0_4(glval) = VariableAddress[f] : -# 1038| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1038| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1038, col. 30 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -#-----| r0_9(String &) = Load : &:r0_8, ~mu0_2 -# 1038| r0_10(glval) = CopyValue : r0_9 -# 1038| r0_11(glval) = FunctionAddress[c_str] : -# 1038| r0_12(char *) = Call : func:r0_11, this:r0_10 -# 1038| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 1038| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_10, ~mu0_2 -# 1038| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_10 -# 1038| r0_16(int) = Constant[0] : -# 1038| r0_17(glval) = PointerAdd[1] : r0_12, r0_16 -# 1038| r0_18(char) = Load : &:r0_17, ~mu0_2 -# 1038| mu0_19(char) = Store : &:r0_6, r0_18 -# 1038| r0_20(glval) = VariableAddress[#return] : -# 1038| v0_21(void) = ReturnValue : &:r0_20, ~mu0_2 -# 1038| v0_22(void) = UnmodeledUse : mu* -# 1038| v0_23(void) = AliasedUse : ~mu0_2 -# 1038| v0_24(void) = ExitFunction : +# 1038| v1038_1(void) = EnterFunction : +# 1038| mu1038_2(unknown) = AliasedDefinition : +# 1038| mu1038_3(unknown) = UnmodeledDefinition : +# 1038| r1038_4(glval) = InitializeThis : +# 1038| r1038_5(glval) = VariableAddress[f] : +# 1038| mu1038_6(float) = InitializeParameter[f] : &:r1038_5 +# 1038| r1038_7(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1038, col. 30 *) = CopyValue : r1038_4 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +#-----| r0_36(String &) = Load : &:r0_27, ~mu1038_3 +# 1038| r1038_8(glval) = CopyValue : r0_36 +# 1038| r1038_9(glval) = FunctionAddress[c_str] : +# 1038| r1038_10(char *) = Call : func:r1038_9, this:r1038_8 +# 1038| mu1038_11(unknown) = ^CallSideEffect : ~mu1038_3 +# 1038| v1038_12(void) = ^BufferReadSideEffect[-1] : &:r1038_8, ~mu1038_3 +# 1038| mu1038_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1038_8 +# 1038| r1038_14(int) = Constant[0] : +# 1038| r1038_15(glval) = PointerAdd[1] : r1038_10, r1038_14 +# 1038| r1038_16(char) = Load : &:r1038_15, ~mu1038_3 +# 1038| mu1038_17(char) = Store : &:r1038_7, r1038_16 +# 1038| r1038_18(glval) = VariableAddress[#return] : +# 1038| v1038_19(void) = ReturnValue : &:r1038_18, ~mu1038_3 +# 1038| v1038_20(void) = UnmodeledUse : mu* +# 1038| v1038_21(void) = AliasedUse : ~mu1038_3 +# 1038| v1038_22(void) = ExitFunction : # 1040| void (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::~() # 1040| Block 0 -# 1040| v0_0(void) = EnterFunction : -# 1040| mu0_1(unknown) = AliasedDefinition : -# 1040| mu0_2(unknown) = UnmodeledDefinition : -# 1040| r0_3(glval) = InitializeThis : -#-----| v0_4(void) = NoOp : -# 1040| r0_5(glval) = FieldAddress[s] : r0_3 -# 1040| r0_6(glval) = FunctionAddress[~String] : -# 1040| v0_7(void) = Call : func:r0_6, this:r0_5 -# 1040| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 1040| v0_9(void) = ReturnVoid : -# 1040| v0_10(void) = UnmodeledUse : mu* -# 1040| v0_11(void) = AliasedUse : ~mu0_2 -# 1040| v0_12(void) = ExitFunction : +# 1040| v1040_1(void) = EnterFunction : +# 1040| mu1040_3(unknown) = AliasedDefinition : +# 1040| mu1040_5(unknown) = UnmodeledDefinition : +# 1040| r1040_7(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1040| r1040_10(glval) = FieldAddress[s] : r1040_7 +# 1040| r1040_12(glval) = FunctionAddress[~String] : +# 1040| v1040_14(void) = Call : func:r1040_12, this:r1040_10 +# 1040| mu1040_15(unknown) = ^CallSideEffect : ~mu1040_5 +# 1040| v1040_16(void) = ReturnVoid : +# 1040| v1040_18(void) = UnmodeledUse : mu* +# 1040| v1040_20(void) = AliasedUse : ~mu1040_5 +# 1040| v1040_22(void) = ExitFunction : # 1040| char (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::operator()(float) const # 1040| Block 0 -# 1040| v0_0(void) = EnterFunction : -# 1040| mu0_1(unknown) = AliasedDefinition : -# 1040| mu0_2(unknown) = UnmodeledDefinition : -# 1040| r0_3(glval) = InitializeThis : -# 1040| r0_4(glval) = VariableAddress[f] : -# 1040| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1040| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1040, col. 30 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -# 1040| r0_9(glval) = FunctionAddress[c_str] : -# 1040| r0_10(char *) = Call : func:r0_9, this:r0_8 -# 1040| mu0_11(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_12(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu0_2 -#-----| mu0_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 1040| r0_14(int) = Constant[0] : -# 1040| r0_15(glval) = PointerAdd[1] : r0_10, r0_14 -# 1040| r0_16(char) = Load : &:r0_15, ~mu0_2 -# 1040| mu0_17(char) = Store : &:r0_6, r0_16 -# 1040| r0_18(glval) = VariableAddress[#return] : -# 1040| v0_19(void) = ReturnValue : &:r0_18, ~mu0_2 -# 1040| v0_20(void) = UnmodeledUse : mu* -# 1040| v0_21(void) = AliasedUse : ~mu0_2 -# 1040| v0_22(void) = ExitFunction : +# 1040| v1040_1(void) = EnterFunction : +# 1040| mu1040_3(unknown) = AliasedDefinition : +# 1040| mu1040_5(unknown) = UnmodeledDefinition : +# 1040| r1040_7(glval) = InitializeThis : +# 1040| r1040_9(glval) = VariableAddress[f] : +# 1040| mu1040_10(float) = InitializeParameter[f] : &:r1040_9 +# 1040| r1040_12(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1040, col. 30 *) = CopyValue : r1040_7 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +# 1040| r1040_16(glval) = FunctionAddress[c_str] : +# 1040| r1040_18(char *) = Call : func:r1040_16, this:r0_27 +# 1040| mu1040_20(unknown) = ^CallSideEffect : ~mu1040_5 +#-----| v0_50(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~mu1040_5 +#-----| mu0_56(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 +# 1040| r1040_23(int) = Constant[0] : +# 1040| r1040_24(glval) = PointerAdd[1] : r1040_18, r1040_23 +# 1040| r1040_25(char) = Load : &:r1040_24, ~mu1040_5 +# 1040| mu1040_26(char) = Store : &:r1040_12, r1040_25 +# 1040| r1040_27(glval) = VariableAddress[#return] : +# 1040| v1040_28(void) = ReturnValue : &:r1040_27, ~mu1040_5 +# 1040| v1040_29(void) = UnmodeledUse : mu* +# 1040| v1040_30(void) = AliasedUse : ~mu1040_5 +# 1040| v1040_31(void) = ExitFunction : # 1042| char (void Lambda(int, String const&))::(lambda [] type at line 1042, col. 32)::operator()(float) const # 1042| Block 0 -# 1042| v0_0(void) = EnterFunction : -# 1042| mu0_1(unknown) = AliasedDefinition : -# 1042| mu0_2(unknown) = UnmodeledDefinition : -# 1042| r0_3(glval) = InitializeThis : -# 1042| r0_4(glval) = VariableAddress[f] : -# 1042| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1042| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1042, col. 32 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -#-----| r0_9(String &) = Load : &:r0_8, ~mu0_2 -# 1042| r0_10(glval) = CopyValue : r0_9 -# 1042| r0_11(glval) = FunctionAddress[c_str] : -# 1042| r0_12(char *) = Call : func:r0_11, this:r0_10 -# 1042| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 1042| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_10, ~mu0_2 -# 1042| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_10 -#-----| r0_16(lambda [] type at line 1042, col. 32 *) = CopyValue : r0_3 -#-----| r0_17(glval) = FieldAddress[x] : r0_16 -#-----| r0_18(int) = Load : &:r0_17, ~mu0_2 -# 1042| r0_19(glval) = PointerAdd[1] : r0_12, r0_18 -# 1042| r0_20(char) = Load : &:r0_19, ~mu0_2 -# 1042| mu0_21(char) = Store : &:r0_6, r0_20 -# 1042| r0_22(glval) = VariableAddress[#return] : -# 1042| v0_23(void) = ReturnValue : &:r0_22, ~mu0_2 -# 1042| v0_24(void) = UnmodeledUse : mu* -# 1042| v0_25(void) = AliasedUse : ~mu0_2 -# 1042| v0_26(void) = ExitFunction : +# 1042| v1042_1(void) = EnterFunction : +# 1042| mu1042_2(unknown) = AliasedDefinition : +# 1042| mu1042_3(unknown) = UnmodeledDefinition : +# 1042| r1042_4(glval) = InitializeThis : +# 1042| r1042_5(glval) = VariableAddress[f] : +# 1042| mu1042_6(float) = InitializeParameter[f] : &:r1042_5 +# 1042| r1042_7(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +#-----| r0_36(String &) = Load : &:r0_27, ~mu1042_3 +# 1042| r1042_8(glval) = CopyValue : r0_36 +# 1042| r1042_9(glval) = FunctionAddress[c_str] : +# 1042| r1042_10(char *) = Call : func:r1042_9, this:r1042_8 +# 1042| mu1042_11(unknown) = ^CallSideEffect : ~mu1042_3 +# 1042| v1042_12(void) = ^BufferReadSideEffect[-1] : &:r1042_8, ~mu1042_3 +# 1042| mu1042_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1042_8 +#-----| r0_71(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_75(glval) = FieldAddress[x] : r0_71 +#-----| r0_80(int) = Load : &:r0_75, ~mu1042_3 +# 1042| r1042_14(glval) = PointerAdd[1] : r1042_10, r0_80 +# 1042| r1042_15(char) = Load : &:r1042_14, ~mu1042_3 +# 1042| mu1042_16(char) = Store : &:r1042_7, r1042_15 +# 1042| r1042_17(glval) = VariableAddress[#return] : +# 1042| v1042_18(void) = ReturnValue : &:r1042_17, ~mu1042_3 +# 1042| v1042_19(void) = UnmodeledUse : mu* +# 1042| v1042_20(void) = AliasedUse : ~mu1042_3 +# 1042| v1042_21(void) = ExitFunction : # 1045| char (void Lambda(int, String const&))::(lambda [] type at line 1045, col. 23)::operator()(float) const # 1045| Block 0 -# 1045| v0_0(void) = EnterFunction : -# 1045| mu0_1(unknown) = AliasedDefinition : -# 1045| mu0_2(unknown) = UnmodeledDefinition : -# 1045| r0_3(glval) = InitializeThis : -# 1045| r0_4(glval) = VariableAddress[f] : -# 1045| mu0_5(float) = InitializeParameter[f] : &:r0_4 -# 1045| r0_6(glval) = VariableAddress[#return] : -#-----| r0_7(lambda [] type at line 1045, col. 23 *) = CopyValue : r0_3 -#-----| r0_8(glval) = FieldAddress[s] : r0_7 -#-----| r0_9(String &) = Load : &:r0_8, ~mu0_2 -# 1045| r0_10(glval) = CopyValue : r0_9 -# 1045| r0_11(glval) = FunctionAddress[c_str] : -# 1045| r0_12(char *) = Call : func:r0_11, this:r0_10 -# 1045| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 1045| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_10, ~mu0_2 -# 1045| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_10 -#-----| r0_16(lambda [] type at line 1045, col. 23 *) = CopyValue : r0_3 -#-----| r0_17(glval) = FieldAddress[x] : r0_16 -#-----| r0_18(int) = Load : &:r0_17, ~mu0_2 -#-----| r0_19(lambda [] type at line 1045, col. 23 *) = CopyValue : r0_3 -# 1045| r0_20(glval) = FieldAddress[i] : r0_19 -# 1045| r0_21(int) = Load : &:r0_20, ~mu0_2 -# 1045| r0_22(int) = Add : r0_18, r0_21 -#-----| r0_23(lambda [] type at line 1045, col. 23 *) = CopyValue : r0_3 -# 1045| r0_24(glval) = FieldAddress[j] : r0_23 -# 1045| r0_25(int &) = Load : &:r0_24, ~mu0_2 -# 1045| r0_26(int) = Load : &:r0_25, ~mu0_2 -# 1045| r0_27(int) = Sub : r0_22, r0_26 -# 1045| r0_28(glval) = PointerAdd[1] : r0_12, r0_27 -# 1045| r0_29(char) = Load : &:r0_28, ~mu0_2 -# 1045| mu0_30(char) = Store : &:r0_6, r0_29 -# 1045| r0_31(glval) = VariableAddress[#return] : -# 1045| v0_32(void) = ReturnValue : &:r0_31, ~mu0_2 -# 1045| v0_33(void) = UnmodeledUse : mu* -# 1045| v0_34(void) = AliasedUse : ~mu0_2 -# 1045| v0_35(void) = ExitFunction : +# 1045| v1045_1(void) = EnterFunction : +# 1045| mu1045_2(unknown) = AliasedDefinition : +# 1045| mu1045_3(unknown) = UnmodeledDefinition : +# 1045| r1045_4(glval) = InitializeThis : +# 1045| r1045_5(glval) = VariableAddress[f] : +# 1045| mu1045_6(float) = InitializeParameter[f] : &:r1045_5 +# 1045| r1045_7(glval) = VariableAddress[#return] : +#-----| r0_17(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_27(glval) = FieldAddress[s] : r0_17 +#-----| r0_36(String &) = Load : &:r0_27, ~mu1045_3 +# 1045| r1045_8(glval) = CopyValue : r0_36 +# 1045| r1045_9(glval) = FunctionAddress[c_str] : +# 1045| r1045_10(char *) = Call : func:r1045_9, this:r1045_8 +# 1045| mu1045_11(unknown) = ^CallSideEffect : ~mu1045_3 +# 1045| v1045_12(void) = ^BufferReadSideEffect[-1] : &:r1045_8, ~mu1045_3 +# 1045| mu1045_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1045_8 +#-----| r0_71(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_75(glval) = FieldAddress[x] : r0_71 +#-----| r0_80(int) = Load : &:r0_75, ~mu1045_3 +#-----| r0_88(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_14(glval) = FieldAddress[i] : r0_88 +# 1045| r1045_15(int) = Load : &:r1045_14, ~mu1045_3 +# 1045| r1045_16(int) = Add : r0_80, r1045_15 +#-----| r0_104(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_17(glval) = FieldAddress[j] : r0_104 +# 1045| r1045_18(int &) = Load : &:r1045_17, ~mu1045_3 +# 1045| r1045_19(int) = Load : &:r1045_18, ~mu1045_3 +# 1045| r1045_20(int) = Sub : r1045_16, r1045_19 +# 1045| r1045_21(glval) = PointerAdd[1] : r1045_10, r1045_20 +# 1045| r1045_22(char) = Load : &:r1045_21, ~mu1045_3 +# 1045| mu1045_23(char) = Store : &:r1045_7, r1045_22 +# 1045| r1045_24(glval) = VariableAddress[#return] : +# 1045| v1045_25(void) = ReturnValue : &:r1045_24, ~mu1045_3 +# 1045| v1045_26(void) = UnmodeledUse : mu* +# 1045| v1045_27(void) = AliasedUse : ~mu1045_3 +# 1045| v1045_28(void) = ExitFunction : # 1068| void RangeBasedFor(vector const&) # 1068| Block 0 -# 1068| v0_0(void) = EnterFunction : -# 1068| mu0_1(unknown) = AliasedDefinition : -# 1068| mu0_2(unknown) = UnmodeledDefinition : -# 1068| r0_3(glval &>) = VariableAddress[v] : -# 1068| mu0_4(vector &) = InitializeParameter[v] : &:r0_3 -# 1069| r0_5(glval &>) = VariableAddress[(__range)] : -# 1069| r0_6(glval &>) = VariableAddress[v] : -# 1069| r0_7(vector &) = Load : &:r0_6, ~mu0_2 -# 1069| r0_8(glval>) = CopyValue : r0_7 -# 1069| r0_9(vector &) = CopyValue : r0_8 -# 1069| mu0_10(vector &) = Store : &:r0_5, r0_9 -# 1069| r0_11(glval) = VariableAddress[(__begin)] : -#-----| r0_12(glval &>) = VariableAddress[(__range)] : -#-----| r0_13(vector &) = Load : &:r0_12, ~mu0_2 -#-----| r0_14(glval>) = CopyValue : r0_13 -# 1069| r0_15(glval) = FunctionAddress[begin] : -# 1069| r0_16(iterator) = Call : func:r0_15, this:r0_14 -# 1069| mu0_17(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_18(void) = ^BufferReadSideEffect[-1] : &:r0_14, ~mu0_2 -#-----| mu0_19(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_14 -# 1069| mu0_20(iterator) = Store : &:r0_11, r0_16 -# 1069| r0_21(glval) = VariableAddress[(__end)] : -#-----| r0_22(glval &>) = VariableAddress[(__range)] : -#-----| r0_23(vector &) = Load : &:r0_22, ~mu0_2 -#-----| r0_24(glval>) = CopyValue : r0_23 -# 1069| r0_25(glval) = FunctionAddress[end] : -# 1069| r0_26(iterator) = Call : func:r0_25, this:r0_24 -# 1069| mu0_27(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v0_28(void) = ^BufferReadSideEffect[-1] : &:r0_24, ~mu0_2 -#-----| mu0_29(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 -# 1069| mu0_30(iterator) = Store : &:r0_21, r0_26 +# 1068| v1068_1(void) = EnterFunction : +# 1068| mu1068_2(unknown) = AliasedDefinition : +# 1068| mu1068_3(unknown) = UnmodeledDefinition : +# 1068| r1068_4(glval &>) = VariableAddress[v] : +# 1068| mu1068_5(vector &) = InitializeParameter[v] : &:r1068_4 +# 1069| r1069_1(glval &>) = VariableAddress[(__range)] : +# 1069| r1069_2(glval &>) = VariableAddress[v] : +# 1069| r1069_3(vector &) = Load : &:r1069_2, ~mu1068_3 +# 1069| r1069_4(glval>) = CopyValue : r1069_3 +# 1069| r1069_5(vector &) = CopyValue : r1069_4 +# 1069| mu1069_6(vector &) = Store : &:r1069_1, r1069_5 +# 1069| r1069_7(glval) = VariableAddress[(__begin)] : +#-----| r0_50(glval &>) = VariableAddress[(__range)] : +#-----| r0_56(vector &) = Load : &:r0_50, ~mu1068_3 +#-----| r0_62(glval>) = CopyValue : r0_56 +# 1069| r1069_8(glval) = FunctionAddress[begin] : +# 1069| r1069_9(iterator) = Call : func:r1069_8, this:r0_62 +# 1069| mu1069_10(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_80(void) = ^BufferReadSideEffect[-1] : &:r0_62, ~mu1068_3 +#-----| mu0_88(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_62 +# 1069| mu1069_11(iterator) = Store : &:r1069_7, r1069_9 +# 1069| r1069_12(glval) = VariableAddress[(__end)] : +#-----| r0_100(glval &>) = VariableAddress[(__range)] : +#-----| r0_104(vector &) = Load : &:r0_100, ~mu1068_3 +#-----| r0_110(glval>) = CopyValue : r0_104 +# 1069| r1069_13(glval) = FunctionAddress[end] : +# 1069| r1069_14(iterator) = Call : func:r1069_13, this:r0_110 +# 1069| mu1069_15(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_124(void) = ^BufferReadSideEffect[-1] : &:r0_110, ~mu1068_3 +#-----| mu0_127(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_110 +# 1069| mu1069_16(iterator) = Store : &:r1069_12, r1069_14 #-----| Goto -> Block 6 #-----| Block 1 -#-----| r1_0(glval) = VariableAddress[(__begin)] : -#-----| r1_1(glval) = Convert : r1_0 -# 1075| r1_2(glval) = FunctionAddress[operator!=] : -#-----| r1_3(glval) = VariableAddress[(__end)] : -#-----| r1_4(iterator) = Load : &:r1_3, ~mu0_2 -# 1075| r1_5(bool) = Call : func:r1_2, this:r1_1, 0:r1_4 -# 1075| mu1_6(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v1_7(void) = ^BufferReadSideEffect[-1] : &:r1_1, ~mu0_2 -#-----| mu1_8(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r1_1 -# 1075| v1_9(void) = ConditionalBranch : r1_5 +#-----| r0_167(glval) = VariableAddress[(__begin)] : +#-----| r0_168(glval) = Convert : r0_167 +# 1075| r1075_1(glval) = FunctionAddress[operator!=] : +#-----| r0_169(glval) = VariableAddress[(__end)] : +#-----| r0_170(iterator) = Load : &:r0_169, ~mu1068_3 +# 1075| r1075_2(bool) = Call : func:r1075_1, this:r0_168, 0:r0_170 +# 1075| mu1075_3(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_171(void) = ^BufferReadSideEffect[-1] : &:r0_168, ~mu1068_3 +#-----| mu0_172(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_168 +# 1075| v1075_4(void) = ConditionalBranch : r1075_2 #-----| False -> Block 5 #-----| True -> Block 3 #-----| Block 2 -#-----| r2_0(glval) = VariableAddress[(__begin)] : -# 1075| r2_1(glval) = FunctionAddress[operator++] : -# 1075| r2_2(iterator &) = Call : func:r2_1, this:r2_0 -# 1075| mu2_3(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v2_4(void) = ^BufferReadSideEffect[-1] : &:r2_0, ~mu0_2 -#-----| mu2_5(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2_0 -# 1075| r2_6(glval) = CopyValue : r2_2 +#-----| r0_173(glval) = VariableAddress[(__begin)] : +# 1075| r1075_5(glval) = FunctionAddress[operator++] : +# 1075| r1075_6(iterator &) = Call : func:r1075_5, this:r0_173 +# 1075| mu1075_7(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_174(void) = ^BufferReadSideEffect[-1] : &:r0_173, ~mu1068_3 +#-----| mu0_175(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_173 +# 1075| r1075_8(glval) = CopyValue : r1075_6 #-----| Goto (back edge) -> Block 1 # 1075| Block 3 -# 1075| r3_0(glval) = VariableAddress[e] : -#-----| r3_1(glval) = VariableAddress[(__begin)] : -#-----| r3_2(glval) = Convert : r3_1 -# 1075| r3_3(glval) = FunctionAddress[operator*] : -# 1075| r3_4(int &) = Call : func:r3_3, this:r3_2 -# 1075| mu3_5(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v3_6(void) = ^BufferReadSideEffect[-1] : &:r3_2, ~mu0_2 -#-----| mu3_7(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r3_2 -# 1075| r3_8(glval) = CopyValue : r3_4 -# 1075| r3_9(glval) = Convert : r3_8 -# 1075| r3_10(int &) = CopyValue : r3_9 -# 1075| mu3_11(int &) = Store : &:r3_0, r3_10 -# 1076| r3_12(glval) = VariableAddress[e] : -# 1076| r3_13(int &) = Load : &:r3_12, ~mu0_2 -# 1076| r3_14(int) = Load : &:r3_13, ~mu0_2 -# 1076| r3_15(int) = Constant[5] : -# 1076| r3_16(bool) = CompareLT : r3_14, r3_15 -# 1076| v3_17(void) = ConditionalBranch : r3_16 +# 1075| r1075_9(glval) = VariableAddress[e] : +#-----| r0_176(glval) = VariableAddress[(__begin)] : +#-----| r0_177(glval) = Convert : r0_176 +# 1075| r1075_10(glval) = FunctionAddress[operator*] : +# 1075| r1075_11(int &) = Call : func:r1075_10, this:r0_177 +# 1075| mu1075_12(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_178(void) = ^BufferReadSideEffect[-1] : &:r0_177, ~mu1068_3 +#-----| mu0_179(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_177 +# 1075| r1075_13(glval) = CopyValue : r1075_11 +# 1075| r1075_14(glval) = Convert : r1075_13 +# 1075| r1075_15(int &) = CopyValue : r1075_14 +# 1075| mu1075_16(int &) = Store : &:r1075_9, r1075_15 +# 1076| r1076_1(glval) = VariableAddress[e] : +# 1076| r1076_2(int &) = Load : &:r1076_1, ~mu1068_3 +# 1076| r1076_3(int) = Load : &:r1076_2, ~mu1068_3 +# 1076| r1076_4(int) = Constant[5] : +# 1076| r1076_5(bool) = CompareLT : r1076_3, r1076_4 +# 1076| v1076_6(void) = ConditionalBranch : r1076_5 #-----| False -> Block 2 #-----| True -> Block 4 # 1077| Block 4 -# 1077| v4_0(void) = NoOp : +# 1077| v1077_1(void) = NoOp : #-----| Goto -> Block 5 # 1079| Block 5 -# 1079| v5_0(void) = NoOp : -# 1080| v5_1(void) = NoOp : -# 1068| v5_2(void) = ReturnVoid : -# 1068| v5_3(void) = UnmodeledUse : mu* -# 1068| v5_4(void) = AliasedUse : ~mu0_2 -# 1068| v5_5(void) = ExitFunction : +# 1079| v1079_1(void) = NoOp : +# 1080| v1080_1(void) = NoOp : +# 1068| v1068_6(void) = ReturnVoid : +# 1068| v1068_7(void) = UnmodeledUse : mu* +# 1068| v1068_8(void) = AliasedUse : ~mu1068_3 +# 1068| v1068_9(void) = ExitFunction : #-----| Block 6 -#-----| r6_0(glval) = VariableAddress[(__begin)] : -#-----| r6_1(glval) = Convert : r6_0 -# 1069| r6_2(glval) = FunctionAddress[operator!=] : -#-----| r6_3(glval) = VariableAddress[(__end)] : -#-----| r6_4(iterator) = Load : &:r6_3, ~mu0_2 -# 1069| r6_5(bool) = Call : func:r6_2, this:r6_1, 0:r6_4 -# 1069| mu6_6(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v6_7(void) = ^BufferReadSideEffect[-1] : &:r6_1, ~mu0_2 -#-----| mu6_8(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r6_1 -# 1069| v6_9(void) = ConditionalBranch : r6_5 +#-----| r0_180(glval) = VariableAddress[(__begin)] : +#-----| r0_181(glval) = Convert : r0_180 +# 1069| r1069_17(glval) = FunctionAddress[operator!=] : +#-----| r0_182(glval) = VariableAddress[(__end)] : +#-----| r0_183(iterator) = Load : &:r0_182, ~mu1068_3 +# 1069| r1069_18(bool) = Call : func:r1069_17, this:r0_181, 0:r0_183 +# 1069| mu1069_19(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_184(void) = ^BufferReadSideEffect[-1] : &:r0_181, ~mu1068_3 +#-----| mu0_185(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_181 +# 1069| v1069_20(void) = ConditionalBranch : r1069_18 #-----| False -> Block 10 #-----| True -> Block 7 # 1069| Block 7 -# 1069| r7_0(glval) = VariableAddress[e] : -#-----| r7_1(glval) = VariableAddress[(__begin)] : -#-----| r7_2(glval) = Convert : r7_1 -# 1069| r7_3(glval) = FunctionAddress[operator*] : -# 1069| r7_4(int &) = Call : func:r7_3, this:r7_2 -# 1069| mu7_5(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v7_6(void) = ^BufferReadSideEffect[-1] : &:r7_2, ~mu0_2 -#-----| mu7_7(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r7_2 -# 1069| r7_8(int) = Load : &:r7_4, ~mu0_2 -# 1069| mu7_9(int) = Store : &:r7_0, r7_8 -# 1070| r7_10(glval) = VariableAddress[e] : -# 1070| r7_11(int) = Load : &:r7_10, ~mu0_2 -# 1070| r7_12(int) = Constant[0] : -# 1070| r7_13(bool) = CompareGT : r7_11, r7_12 -# 1070| v7_14(void) = ConditionalBranch : r7_13 +# 1069| r1069_21(glval) = VariableAddress[e] : +#-----| r0_186(glval) = VariableAddress[(__begin)] : +#-----| r0_187(glval) = Convert : r0_186 +# 1069| r1069_22(glval) = FunctionAddress[operator*] : +# 1069| r1069_23(int &) = Call : func:r1069_22, this:r0_187 +# 1069| mu1069_24(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_188(void) = ^BufferReadSideEffect[-1] : &:r0_187, ~mu1068_3 +#-----| mu0_189(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_187 +# 1069| r1069_25(int) = Load : &:r1069_23, ~mu1068_3 +# 1069| mu1069_26(int) = Store : &:r1069_21, r1069_25 +# 1070| r1070_1(glval) = VariableAddress[e] : +# 1070| r1070_2(int) = Load : &:r1070_1, ~mu1068_3 +# 1070| r1070_3(int) = Constant[0] : +# 1070| r1070_4(bool) = CompareGT : r1070_2, r1070_3 +# 1070| v1070_5(void) = ConditionalBranch : r1070_4 #-----| False -> Block 9 #-----| True -> Block 8 # 1071| Block 8 -# 1071| v8_0(void) = NoOp : +# 1071| v1071_1(void) = NoOp : #-----| Goto -> Block 9 # 1069| Block 9 -# 1069| v9_0(void) = NoOp : -#-----| r9_1(glval) = VariableAddress[(__begin)] : -# 1069| r9_2(glval) = FunctionAddress[operator++] : -# 1069| r9_3(iterator &) = Call : func:r9_2, this:r9_1 -# 1069| mu9_4(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v9_5(void) = ^BufferReadSideEffect[-1] : &:r9_1, ~mu0_2 -#-----| mu9_6(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r9_1 -# 1069| r9_7(glval) = CopyValue : r9_3 +# 1069| v1069_27(void) = NoOp : +#-----| r0_190(glval) = VariableAddress[(__begin)] : +# 1069| r1069_28(glval) = FunctionAddress[operator++] : +# 1069| r1069_29(iterator &) = Call : func:r1069_28, this:r0_190 +# 1069| mu1069_30(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_191(void) = ^BufferReadSideEffect[-1] : &:r0_190, ~mu1068_3 +#-----| mu0_192(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_190 +# 1069| r1069_31(glval) = CopyValue : r1069_29 #-----| Goto (back edge) -> Block 6 # 1075| Block 10 -# 1075| r10_0(glval &>) = VariableAddress[(__range)] : -# 1075| r10_1(glval &>) = VariableAddress[v] : -# 1075| r10_2(vector &) = Load : &:r10_1, ~mu0_2 -# 1075| r10_3(glval>) = CopyValue : r10_2 -# 1075| r10_4(vector &) = CopyValue : r10_3 -# 1075| mu10_5(vector &) = Store : &:r10_0, r10_4 -# 1075| r10_6(glval) = VariableAddress[(__begin)] : -#-----| r10_7(glval &>) = VariableAddress[(__range)] : -#-----| r10_8(vector &) = Load : &:r10_7, ~mu0_2 -#-----| r10_9(glval>) = CopyValue : r10_8 -# 1075| r10_10(glval) = FunctionAddress[begin] : -# 1075| r10_11(iterator) = Call : func:r10_10, this:r10_9 -# 1075| mu10_12(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v10_13(void) = ^BufferReadSideEffect[-1] : &:r10_9, ~mu0_2 -#-----| mu10_14(vector) = ^IndirectMayWriteSideEffect[-1] : &:r10_9 -# 1075| mu10_15(iterator) = Store : &:r10_6, r10_11 -# 1075| r10_16(glval) = VariableAddress[(__end)] : -#-----| r10_17(glval &>) = VariableAddress[(__range)] : -#-----| r10_18(vector &) = Load : &:r10_17, ~mu0_2 -#-----| r10_19(glval>) = CopyValue : r10_18 -# 1075| r10_20(glval) = FunctionAddress[end] : -# 1075| r10_21(iterator) = Call : func:r10_20, this:r10_19 -# 1075| mu10_22(unknown) = ^CallSideEffect : ~mu0_2 -#-----| v10_23(void) = ^BufferReadSideEffect[-1] : &:r10_19, ~mu0_2 -#-----| mu10_24(vector) = ^IndirectMayWriteSideEffect[-1] : &:r10_19 -# 1075| mu10_25(iterator) = Store : &:r10_16, r10_21 +# 1075| r1075_17(glval &>) = VariableAddress[(__range)] : +# 1075| r1075_18(glval &>) = VariableAddress[v] : +# 1075| r1075_19(vector &) = Load : &:r1075_18, ~mu1068_3 +# 1075| r1075_20(glval>) = CopyValue : r1075_19 +# 1075| r1075_21(vector &) = CopyValue : r1075_20 +# 1075| mu1075_22(vector &) = Store : &:r1075_17, r1075_21 +# 1075| r1075_23(glval) = VariableAddress[(__begin)] : +#-----| r0_193(glval &>) = VariableAddress[(__range)] : +#-----| r0_194(vector &) = Load : &:r0_193, ~mu1068_3 +#-----| r0_195(glval>) = CopyValue : r0_194 +# 1075| r1075_24(glval) = FunctionAddress[begin] : +# 1075| r1075_25(iterator) = Call : func:r1075_24, this:r0_195 +# 1075| mu1075_26(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_196(void) = ^BufferReadSideEffect[-1] : &:r0_195, ~mu1068_3 +#-----| mu0_197(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_195 +# 1075| mu1075_27(iterator) = Store : &:r1075_23, r1075_25 +# 1075| r1075_28(glval) = VariableAddress[(__end)] : +#-----| r0_198(glval &>) = VariableAddress[(__range)] : +#-----| r0_199(vector &) = Load : &:r0_198, ~mu1068_3 +#-----| r0_200(glval>) = CopyValue : r0_199 +# 1075| r1075_29(glval) = FunctionAddress[end] : +# 1075| r1075_30(iterator) = Call : func:r1075_29, this:r0_200 +# 1075| mu1075_31(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_201(void) = ^BufferReadSideEffect[-1] : &:r0_200, ~mu1068_3 +#-----| mu0_202(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_200 +# 1075| mu1075_32(iterator) = Store : &:r1075_28, r1075_30 #-----| Goto -> Block 1 # 1099| int AsmStmt(int) # 1099| Block 0 -# 1099| v0_0(void) = EnterFunction : -# 1099| mu0_1(unknown) = AliasedDefinition : -# 1099| mu0_2(unknown) = UnmodeledDefinition : -# 1099| r0_3(glval) = VariableAddress[x] : -# 1099| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 1100| mu0_5(unknown) = InlineAsm : ~mu0_2 -# 1101| r0_6(glval) = VariableAddress[#return] : -# 1101| r0_7(glval) = VariableAddress[x] : -# 1101| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 1101| mu0_9(int) = Store : &:r0_6, r0_8 -# 1099| r0_10(glval) = VariableAddress[#return] : -# 1099| v0_11(void) = ReturnValue : &:r0_10, ~mu0_2 -# 1099| v0_12(void) = UnmodeledUse : mu* -# 1099| v0_13(void) = AliasedUse : ~mu0_2 -# 1099| v0_14(void) = ExitFunction : +# 1099| v1099_1(void) = EnterFunction : +# 1099| mu1099_2(unknown) = AliasedDefinition : +# 1099| mu1099_3(unknown) = UnmodeledDefinition : +# 1099| r1099_4(glval) = VariableAddress[x] : +# 1099| mu1099_5(int) = InitializeParameter[x] : &:r1099_4 +# 1100| mu1100_1(unknown) = InlineAsm : ~mu1099_3 +# 1101| r1101_1(glval) = VariableAddress[#return] : +# 1101| r1101_2(glval) = VariableAddress[x] : +# 1101| r1101_3(int) = Load : &:r1101_2, ~mu1099_3 +# 1101| mu1101_4(int) = Store : &:r1101_1, r1101_3 +# 1099| r1099_6(glval) = VariableAddress[#return] : +# 1099| v1099_7(void) = ReturnValue : &:r1099_6, ~mu1099_3 +# 1099| v1099_8(void) = UnmodeledUse : mu* +# 1099| v1099_9(void) = AliasedUse : ~mu1099_3 +# 1099| v1099_10(void) = ExitFunction : # 1104| void AsmStmtWithOutputs(unsigned int&, unsigned int, unsigned int&, unsigned int) # 1104| Block 0 -# 1104| v0_0(void) = EnterFunction : -# 1104| mu0_1(unknown) = AliasedDefinition : -# 1104| mu0_2(unknown) = UnmodeledDefinition : -# 1104| r0_3(glval) = VariableAddress[a] : -# 1104| mu0_4(unsigned int &) = InitializeParameter[a] : &:r0_3 -# 1104| r0_5(glval) = VariableAddress[b] : -# 1104| mu0_6(unsigned int) = InitializeParameter[b] : &:r0_5 -# 1104| r0_7(glval) = VariableAddress[c] : -# 1104| mu0_8(unsigned int &) = InitializeParameter[c] : &:r0_7 -# 1104| r0_9(glval) = VariableAddress[d] : -# 1104| mu0_10(unsigned int) = InitializeParameter[d] : &:r0_9 -# 1109| r0_11(glval) = VariableAddress[a] : -# 1109| r0_12(unsigned int &) = Load : &:r0_11, ~mu0_2 -# 1109| r0_13(glval) = CopyValue : r0_12 -# 1109| r0_14(glval) = VariableAddress[b] : -# 1109| r0_15(glval) = VariableAddress[c] : -# 1109| r0_16(unsigned int &) = Load : &:r0_15, ~mu0_2 -# 1109| r0_17(unsigned int) = Load : &:r0_16, ~mu0_2 -# 1109| r0_18(glval) = VariableAddress[d] : -# 1109| r0_19(unsigned int) = Load : &:r0_18, ~mu0_2 -# 1106| mu0_20(unknown) = InlineAsm : ~mu0_2, 0:r0_13, 1:r0_14, 2:r0_17, 3:r0_19 -# 1111| v0_21(void) = NoOp : -# 1104| v0_22(void) = ReturnVoid : -# 1104| v0_23(void) = UnmodeledUse : mu* -# 1104| v0_24(void) = AliasedUse : ~mu0_2 -# 1104| v0_25(void) = ExitFunction : +# 1104| v1104_1(void) = EnterFunction : +# 1104| mu1104_2(unknown) = AliasedDefinition : +# 1104| mu1104_3(unknown) = UnmodeledDefinition : +# 1104| r1104_4(glval) = VariableAddress[a] : +# 1104| mu1104_5(unsigned int &) = InitializeParameter[a] : &:r1104_4 +# 1104| r1104_6(glval) = VariableAddress[b] : +# 1104| mu1104_7(unsigned int) = InitializeParameter[b] : &:r1104_6 +# 1104| r1104_8(glval) = VariableAddress[c] : +# 1104| mu1104_9(unsigned int &) = InitializeParameter[c] : &:r1104_8 +# 1104| r1104_10(glval) = VariableAddress[d] : +# 1104| mu1104_11(unsigned int) = InitializeParameter[d] : &:r1104_10 +# 1109| r1109_1(glval) = VariableAddress[a] : +# 1109| r1109_2(unsigned int &) = Load : &:r1109_1, ~mu1104_3 +# 1109| r1109_3(glval) = CopyValue : r1109_2 +# 1109| r1109_4(glval) = VariableAddress[b] : +# 1109| r1109_5(glval) = VariableAddress[c] : +# 1109| r1109_6(unsigned int &) = Load : &:r1109_5, ~mu1104_3 +# 1109| r1109_7(unsigned int) = Load : &:r1109_6, ~mu1104_3 +# 1109| r1109_8(glval) = VariableAddress[d] : +# 1109| r1109_9(unsigned int) = Load : &:r1109_8, ~mu1104_3 +# 1106| mu1106_1(unknown) = InlineAsm : ~mu1104_3, 0:r1109_3, 1:r1109_4, 2:r1109_7, 3:r1109_9 +# 1111| v1111_1(void) = NoOp : +# 1104| v1104_12(void) = ReturnVoid : +# 1104| v1104_13(void) = UnmodeledUse : mu* +# 1104| v1104_14(void) = AliasedUse : ~mu1104_3 +# 1104| v1104_15(void) = ExitFunction : # 1113| void ExternDeclarations() # 1113| Block 0 -# 1113| v0_0(void) = EnterFunction : -# 1113| mu0_1(unknown) = AliasedDefinition : -# 1113| mu0_2(unknown) = UnmodeledDefinition : -# 1116| r0_3(glval) = VariableAddress[x] : -# 1116| mu0_4(int) = Uninitialized[x] : &:r0_3 -# 1117| r0_5(glval) = VariableAddress[y] : -# 1117| mu0_6(int) = Uninitialized[y] : &:r0_5 -# 1118| r0_7(glval) = VariableAddress[h] : -# 1118| mu0_8(int) = Uninitialized[h] : &:r0_7 -# 1120| v0_9(void) = NoOp : -# 1113| v0_10(void) = ReturnVoid : -# 1113| v0_11(void) = UnmodeledUse : mu* -# 1113| v0_12(void) = AliasedUse : ~mu0_2 -# 1113| v0_13(void) = ExitFunction : +# 1113| v1113_1(void) = EnterFunction : +# 1113| mu1113_2(unknown) = AliasedDefinition : +# 1113| mu1113_3(unknown) = UnmodeledDefinition : +# 1116| r1116_1(glval) = VariableAddress[x] : +# 1116| mu1116_2(int) = Uninitialized[x] : &:r1116_1 +# 1117| r1117_1(glval) = VariableAddress[y] : +# 1117| mu1117_2(int) = Uninitialized[y] : &:r1117_1 +# 1118| r1118_1(glval) = VariableAddress[h] : +# 1118| mu1118_2(int) = Uninitialized[h] : &:r1118_1 +# 1120| v1120_1(void) = NoOp : +# 1113| v1113_4(void) = ReturnVoid : +# 1113| v1113_5(void) = UnmodeledUse : mu* +# 1113| v1113_6(void) = AliasedUse : ~mu1113_3 +# 1113| v1113_7(void) = ExitFunction : # 1128| void ExternDeclarationsInMacro() # 1128| Block 0 -# 1128| v0_0(void) = EnterFunction : -# 1128| mu0_1(unknown) = AliasedDefinition : -# 1128| mu0_2(unknown) = UnmodeledDefinition : -# 1130| r0_3(glval) = VariableAddress[i] : -# 1130| r0_4(int) = Constant[0] : -# 1130| mu0_5(int) = Store : &:r0_3, r0_4 +# 1128| v1128_1(void) = EnterFunction : +# 1128| mu1128_2(unknown) = AliasedDefinition : +# 1128| mu1128_3(unknown) = UnmodeledDefinition : +# 1130| r1130_1(glval) = VariableAddress[i] : +# 1130| r1130_2(int) = Constant[0] : +# 1130| mu1130_3(int) = Store : &:r1130_1, r1130_2 #-----| Goto -> Block 1 # 1130| Block 1 -# 1130| r1_0(glval) = VariableAddress[i] : -# 1130| r1_1(int) = Load : &:r1_0, ~mu0_2 -# 1130| r1_2(int) = Constant[10] : -# 1130| r1_3(bool) = CompareLT : r1_1, r1_2 -# 1130| v1_4(void) = ConditionalBranch : r1_3 +# 1130| r1130_4(glval) = VariableAddress[i] : +# 1130| r1130_5(int) = Load : &:r1130_4, ~mu1128_3 +# 1130| r1130_6(int) = Constant[10] : +# 1130| r1130_7(bool) = CompareLT : r1130_5, r1130_6 +# 1130| v1130_8(void) = ConditionalBranch : r1130_7 #-----| False -> Block 3 #-----| True -> Block 2 # 1130| Block 2 -# 1130| r2_0(glval) = VariableAddress[i] : -# 1130| r2_1(int) = Load : &:r2_0, ~mu0_2 -# 1130| r2_2(int) = Constant[1] : -# 1130| r2_3(int) = Add : r2_1, r2_2 -# 1130| mu2_4(int) = Store : &:r2_0, r2_3 +# 1130| r1130_9(glval) = VariableAddress[i] : +# 1130| r1130_10(int) = Load : &:r1130_9, ~mu1128_3 +# 1130| r1130_11(int) = Constant[1] : +# 1130| r1130_12(int) = Add : r1130_10, r1130_11 +# 1130| mu1130_13(int) = Store : &:r1130_9, r1130_12 #-----| Goto (back edge) -> Block 1 # 1130| Block 3 -# 1130| v3_0(void) = NoOp : -# 1131| v3_1(void) = NoOp : -# 1128| v3_2(void) = ReturnVoid : -# 1128| v3_3(void) = UnmodeledUse : mu* -# 1128| v3_4(void) = AliasedUse : ~mu0_2 -# 1128| v3_5(void) = ExitFunction : +# 1130| v1130_14(void) = NoOp : +# 1131| v1131_1(void) = NoOp : +# 1128| v1128_4(void) = ReturnVoid : +# 1128| v1128_5(void) = UnmodeledUse : mu* +# 1128| v1128_6(void) = AliasedUse : ~mu1128_3 +# 1128| v1128_7(void) = ExitFunction : # 1133| void TryCatchNoCatchAny(bool) # 1133| Block 0 -# 1133| v0_0(void) = EnterFunction : -# 1133| mu0_1(unknown) = AliasedDefinition : -# 1133| mu0_2(unknown) = UnmodeledDefinition : -# 1133| r0_3(glval) = VariableAddress[b] : -# 1133| mu0_4(bool) = InitializeParameter[b] : &:r0_3 -# 1135| r0_5(glval) = VariableAddress[x] : -# 1135| r0_6(int) = Constant[5] : -# 1135| mu0_7(int) = Store : &:r0_5, r0_6 -# 1136| r0_8(glval) = VariableAddress[b] : -# 1136| r0_9(bool) = Load : &:r0_8, ~mu0_2 -# 1136| v0_10(void) = ConditionalBranch : r0_9 +# 1133| v1133_1(void) = EnterFunction : +# 1133| mu1133_2(unknown) = AliasedDefinition : +# 1133| mu1133_3(unknown) = UnmodeledDefinition : +# 1133| r1133_4(glval) = VariableAddress[b] : +# 1133| mu1133_5(bool) = InitializeParameter[b] : &:r1133_4 +# 1135| r1135_1(glval) = VariableAddress[x] : +# 1135| r1135_2(int) = Constant[5] : +# 1135| mu1135_3(int) = Store : &:r1135_1, r1135_2 +# 1136| r1136_1(glval) = VariableAddress[b] : +# 1136| r1136_2(bool) = Load : &:r1136_1, ~mu1133_3 +# 1136| v1136_3(void) = ConditionalBranch : r1136_2 #-----| False -> Block 4 #-----| True -> Block 3 # 1133| Block 1 -# 1133| v1_0(void) = UnmodeledUse : mu* -# 1133| v1_1(void) = AliasedUse : ~mu0_2 -# 1133| v1_2(void) = ExitFunction : +# 1133| v1133_6(void) = UnmodeledUse : mu* +# 1133| v1133_7(void) = AliasedUse : ~mu1133_3 +# 1133| v1133_8(void) = ExitFunction : # 1133| Block 2 -# 1133| v2_0(void) = Unwind : +# 1133| v1133_9(void) = Unwind : #-----| Goto -> Block 1 # 1137| Block 3 -# 1137| r3_0(glval) = VariableAddress[#throw1137:7] : -# 1137| r3_1(glval) = StringConstant["string literal"] : -# 1137| r3_2(char *) = Convert : r3_1 -# 1137| mu3_3(char *) = Store : &:r3_0, r3_2 -# 1137| v3_4(void) = ThrowValue : &:r3_0, ~mu0_2 +# 1137| r1137_1(glval) = VariableAddress[#throw1137:7] : +# 1137| r1137_2(glval) = StringConstant["string literal"] : +# 1137| r1137_3(char *) = Convert : r1137_2 +# 1137| mu1137_4(char *) = Store : &:r1137_1, r1137_3 +# 1137| v1137_5(void) = ThrowValue : &:r1137_1, ~mu1133_3 #-----| Exception -> Block 9 # 1139| Block 4 -# 1139| r4_0(glval) = VariableAddress[x] : -# 1139| r4_1(int) = Load : &:r4_0, ~mu0_2 -# 1139| r4_2(int) = Constant[2] : -# 1139| r4_3(bool) = CompareLT : r4_1, r4_2 -# 1139| v4_4(void) = ConditionalBranch : r4_3 +# 1139| r1139_1(glval) = VariableAddress[x] : +# 1139| r1139_2(int) = Load : &:r1139_1, ~mu1133_3 +# 1139| r1139_3(int) = Constant[2] : +# 1139| r1139_4(bool) = CompareLT : r1139_2, r1139_3 +# 1139| v1139_5(void) = ConditionalBranch : r1139_4 #-----| False -> Block 8 #-----| True -> Block 5 # 1140| Block 5 -# 1140| r5_0(glval) = VariableAddress[b] : -# 1140| r5_1(bool) = Load : &:r5_0, ~mu0_2 -# 1140| v5_2(void) = ConditionalBranch : r5_1 +# 1140| r1140_1(glval) = VariableAddress[b] : +# 1140| r1140_2(bool) = Load : &:r1140_1, ~mu1133_3 +# 1140| v1140_3(void) = ConditionalBranch : r1140_2 #-----| False -> Block 7 #-----| True -> Block 6 # 1140| Block 6 -# 1140| r6_0(int) = Constant[7] : -# 1140| r6_1(glval) = VariableAddress[#temp1140:11] : -# 1140| mu6_2(int) = Store : &:r6_1, r6_0 -# 1140| r6_3(glval) = VariableAddress[#temp1140:11] : -# 1140| r6_4(int) = Load : &:r6_3, ~mu0_2 -# 1140| r6_5(glval) = VariableAddress[x] : -# 1140| mu6_6(int) = Store : &:r6_5, r6_4 +# 1140| r1140_4(int) = Constant[7] : +# 1140| r1140_5(glval) = VariableAddress[#temp1140:11] : +# 1140| mu1140_6(int) = Store : &:r1140_5, r1140_4 +# 1140| r1140_7(glval) = VariableAddress[#temp1140:11] : +# 1140| r1140_8(int) = Load : &:r1140_7, ~mu1133_3 +# 1140| r1140_9(glval) = VariableAddress[x] : +# 1140| mu1140_10(int) = Store : &:r1140_9, r1140_8 #-----| Goto -> Block 8 # 1140| Block 7 -# 1140| r7_0(glval) = VariableAddress[#throw1140:19] : -# 1140| r7_1(glval) = FunctionAddress[String] : -# 1140| r7_2(glval) = StringConstant["String object"] : -# 1140| r7_3(char *) = Convert : r7_2 -# 1140| v7_4(void) = Call : func:r7_1, this:r7_0, 0:r7_3 -# 1140| mu7_5(unknown) = ^CallSideEffect : ~mu0_2 -# 1140| mu7_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r7_0 -# 1140| v7_7(void) = ^BufferReadSideEffect[0] : &:r7_3, ~mu0_2 -# 1140| mu7_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r7_3 -# 1140| v7_9(void) = ThrowValue : &:r7_0, ~mu0_2 +# 1140| r1140_11(glval) = VariableAddress[#throw1140:19] : +# 1140| r1140_12(glval) = FunctionAddress[String] : +# 1140| r1140_13(glval) = StringConstant["String object"] : +# 1140| r1140_14(char *) = Convert : r1140_13 +# 1140| v1140_15(void) = Call : func:r1140_12, this:r1140_11, 0:r1140_14 +# 1140| mu1140_16(unknown) = ^CallSideEffect : ~mu1133_3 +# 1140| mu1140_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r1140_11 +# 1140| v1140_18(void) = ^BufferReadSideEffect[0] : &:r1140_14, ~mu1133_3 +# 1140| mu1140_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r1140_14 +# 1140| v1140_20(void) = ThrowValue : &:r1140_11, ~mu1133_3 #-----| Exception -> Block 9 # 1142| Block 8 -# 1142| r8_0(int) = Constant[7] : -# 1142| r8_1(glval) = VariableAddress[x] : -# 1142| mu8_2(int) = Store : &:r8_1, r8_0 +# 1142| r1142_1(int) = Constant[7] : +# 1142| r1142_2(glval) = VariableAddress[x] : +# 1142| mu1142_3(int) = Store : &:r1142_2, r1142_1 #-----| Goto -> Block 13 # 1144| Block 9 -# 1144| v9_0(void) = CatchByType[const char *] : +# 1144| v1144_1(void) = CatchByType[const char *] : #-----| Exception -> Block 11 #-----| Goto -> Block 10 # 1144| Block 10 -# 1144| r10_0(glval) = VariableAddress[s] : -# 1144| mu10_1(char *) = InitializeParameter[s] : &:r10_0 -# 1145| r10_2(glval) = VariableAddress[#throw1145:5] : -# 1145| r10_3(glval) = FunctionAddress[String] : -# 1145| r10_4(glval) = VariableAddress[s] : -# 1145| r10_5(char *) = Load : &:r10_4, ~mu0_2 -# 1145| v10_6(void) = Call : func:r10_3, this:r10_2, 0:r10_5 -# 1145| mu10_7(unknown) = ^CallSideEffect : ~mu0_2 -# 1145| mu10_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r10_2 -# 1145| v10_9(void) = ^BufferReadSideEffect[0] : &:r10_5, ~mu0_2 -# 1145| mu10_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r10_5 -# 1145| v10_11(void) = ThrowValue : &:r10_2, ~mu0_2 +# 1144| r1144_2(glval) = VariableAddress[s] : +# 1144| mu1144_3(char *) = InitializeParameter[s] : &:r1144_2 +# 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : +# 1145| r1145_2(glval) = FunctionAddress[String] : +# 1145| r1145_3(glval) = VariableAddress[s] : +# 1145| r1145_4(char *) = Load : &:r1145_3, ~mu1133_3 +# 1145| v1145_5(void) = Call : func:r1145_2, this:r1145_1, 0:r1145_4 +# 1145| mu1145_6(unknown) = ^CallSideEffect : ~mu1133_3 +# 1145| mu1145_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 +# 1145| v1145_8(void) = ^BufferReadSideEffect[0] : &:r1145_4, ~mu1133_3 +# 1145| mu1145_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_4 +# 1145| v1145_10(void) = ThrowValue : &:r1145_1, ~mu1133_3 #-----| Exception -> Block 2 # 1147| Block 11 -# 1147| v11_0(void) = CatchByType[const String &] : +# 1147| v1147_1(void) = CatchByType[const String &] : #-----| Exception -> Block 2 #-----| Goto -> Block 12 # 1147| Block 12 -# 1147| r12_0(glval) = VariableAddress[e] : -# 1147| mu12_1(String &) = InitializeParameter[e] : &:r12_0 -# 1147| v12_2(void) = NoOp : +# 1147| r1147_2(glval) = VariableAddress[e] : +# 1147| mu1147_3(String &) = InitializeParameter[e] : &:r1147_2 +# 1147| v1147_4(void) = NoOp : #-----| Goto -> Block 13 # 1149| Block 13 -# 1149| v13_0(void) = NoOp : -# 1133| v13_1(void) = ReturnVoid : +# 1149| v1149_1(void) = NoOp : +# 1133| v1133_10(void) = ReturnVoid : #-----| Goto -> Block 1 # 1153| void VectorTypes(int) # 1153| Block 0 -# 1153| v0_0(void) = EnterFunction : -# 1153| mu0_1(unknown) = AliasedDefinition : -# 1153| mu0_2(unknown) = UnmodeledDefinition : -# 1153| r0_3(glval) = VariableAddress[i] : -# 1153| mu0_4(int) = InitializeParameter[i] : &:r0_3 -# 1154| r0_5(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1154| mu0_6(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r0_5 -# 1154| r0_7(int) = Constant[0] : -# 1154| r0_8(glval) = PointerAdd[4] : r0_5, r0_7 -# 1154| r0_9(int) = Constant[0] : -# 1154| mu0_10(int) = Store : &:r0_8, r0_9 -# 1154| r0_11(int) = Constant[1] : -# 1154| r0_12(glval) = PointerAdd[4] : r0_5, r0_11 -# 1154| r0_13(int) = Constant[1] : -# 1154| mu0_14(int) = Store : &:r0_12, r0_13 -# 1154| r0_15(int) = Constant[2] : -# 1154| r0_16(glval) = PointerAdd[4] : r0_5, r0_15 -# 1154| r0_17(int) = Constant[2] : -# 1154| mu0_18(int) = Store : &:r0_16, r0_17 -# 1154| r0_19(int) = Constant[3] : -# 1154| r0_20(glval) = PointerAdd[4] : r0_5, r0_19 -# 1154| r0_21(int) = Constant[3] : -# 1154| mu0_22(int) = Store : &:r0_20, r0_21 -# 1155| r0_23(glval) = VariableAddress[x] : -# 1155| r0_24(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1155| r0_25(glval) = VariableAddress[i] : -# 1155| r0_26(int) = Load : &:r0_25, ~mu0_2 -# 1155| r0_27(glval) = PointerAdd[4] : r0_24, r0_26 -# 1155| r0_28(int) = Load : &:r0_27, ~mu0_2 -# 1155| mu0_29(int) = Store : &:r0_23, r0_28 -# 1156| r0_30(glval) = VariableAddress[x] : -# 1156| r0_31(int) = Load : &:r0_30, ~mu0_2 -# 1156| r0_32(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1156| r0_33(glval) = VariableAddress[i] : -# 1156| r0_34(int) = Load : &:r0_33, ~mu0_2 -# 1156| r0_35(glval) = PointerAdd[4] : r0_32, r0_34 -# 1156| mu0_36(int) = Store : &:r0_35, r0_31 -# 1157| r0_37(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1157| r0_38(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r0_39(__attribute((vector_size(16UL))) int) = Load : &:r0_38, ~mu0_2 -# 1157| r0_40(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r0_41(__attribute((vector_size(16UL))) int) = Load : &:r0_40, ~mu0_2 -#-----| r0_42(int) = Constant[3] : -# 1157| r0_43(int) = Constant[2] : -# 1157| r0_44(int) = Constant[1] : -# 1157| r0_45(int) = Constant[0] : -# 1157| r0_46(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r0_39, 1:r0_41, 2:r0_42, 3:r0_43, 4:r0_44, 5:r0_45 -# 1157| mu0_47(__attribute((vector_size(16UL))) int) = Store : &:r0_37, r0_46 -# 1158| r0_48(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| r0_49(__attribute((vector_size(16UL))) int) = Load : &:r0_48, ~mu0_2 -# 1158| r0_50(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1158| r0_51(__attribute((vector_size(16UL))) int) = Load : &:r0_50, ~mu0_2 -# 1158| r0_52(__attribute((vector_size(16UL))) int) = Add : r0_49, r0_51 -# 1158| r0_53(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| mu0_54(__attribute((vector_size(16UL))) int) = Store : &:r0_53, r0_52 -# 1159| v0_55(void) = NoOp : -# 1153| v0_56(void) = ReturnVoid : -# 1153| v0_57(void) = UnmodeledUse : mu* -# 1153| v0_58(void) = AliasedUse : ~mu0_2 -# 1153| v0_59(void) = ExitFunction : +# 1153| v1153_1(void) = EnterFunction : +# 1153| mu1153_2(unknown) = AliasedDefinition : +# 1153| mu1153_3(unknown) = UnmodeledDefinition : +# 1153| r1153_4(glval) = VariableAddress[i] : +# 1153| mu1153_5(int) = InitializeParameter[i] : &:r1153_4 +# 1154| r1154_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1154| mu1154_2(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r1154_1 +# 1154| r1154_3(int) = Constant[0] : +# 1154| r1154_4(glval) = PointerAdd[4] : r1154_1, r1154_3 +# 1154| r1154_5(int) = Constant[0] : +# 1154| mu1154_6(int) = Store : &:r1154_4, r1154_5 +# 1154| r1154_7(int) = Constant[1] : +# 1154| r1154_8(glval) = PointerAdd[4] : r1154_1, r1154_7 +# 1154| r1154_9(int) = Constant[1] : +# 1154| mu1154_10(int) = Store : &:r1154_8, r1154_9 +# 1154| r1154_11(int) = Constant[2] : +# 1154| r1154_12(glval) = PointerAdd[4] : r1154_1, r1154_11 +# 1154| r1154_13(int) = Constant[2] : +# 1154| mu1154_14(int) = Store : &:r1154_12, r1154_13 +# 1154| r1154_15(int) = Constant[3] : +# 1154| r1154_16(glval) = PointerAdd[4] : r1154_1, r1154_15 +# 1154| r1154_17(int) = Constant[3] : +# 1154| mu1154_18(int) = Store : &:r1154_16, r1154_17 +# 1155| r1155_1(glval) = VariableAddress[x] : +# 1155| r1155_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1155| r1155_3(glval) = VariableAddress[i] : +# 1155| r1155_4(int) = Load : &:r1155_3, ~mu1153_3 +# 1155| r1155_5(glval) = PointerAdd[4] : r1155_2, r1155_4 +# 1155| r1155_6(int) = Load : &:r1155_5, ~mu1153_3 +# 1155| mu1155_7(int) = Store : &:r1155_1, r1155_6 +# 1156| r1156_1(glval) = VariableAddress[x] : +# 1156| r1156_2(int) = Load : &:r1156_1, ~mu1153_3 +# 1156| r1156_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1156| r1156_4(glval) = VariableAddress[i] : +# 1156| r1156_5(int) = Load : &:r1156_4, ~mu1153_3 +# 1156| r1156_6(glval) = PointerAdd[4] : r1156_3, r1156_5 +# 1156| mu1156_7(int) = Store : &:r1156_6, r1156_2 +# 1157| r1157_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1157| r1157_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_3(__attribute((vector_size(16UL))) int) = Load : &:r1157_2, ~mu1153_3 +# 1157| r1157_4(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_5(__attribute((vector_size(16UL))) int) = Load : &:r1157_4, ~mu1153_3 +#-----| r0_153(int) = Constant[3] : +# 1157| r1157_6(int) = Constant[2] : +# 1157| r1157_7(int) = Constant[1] : +# 1157| r1157_8(int) = Constant[0] : +# 1157| r1157_9(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r1157_3, 1:r1157_5, 2:r0_153, 3:r1157_6, 4:r1157_7, 5:r1157_8 +# 1157| mu1157_10(__attribute((vector_size(16UL))) int) = Store : &:r1157_1, r1157_9 +# 1158| r1158_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| r1158_2(__attribute((vector_size(16UL))) int) = Load : &:r1158_1, ~mu1153_3 +# 1158| r1158_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1158| r1158_4(__attribute((vector_size(16UL))) int) = Load : &:r1158_3, ~mu1153_3 +# 1158| r1158_5(__attribute((vector_size(16UL))) int) = Add : r1158_2, r1158_4 +# 1158| r1158_6(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| mu1158_7(__attribute((vector_size(16UL))) int) = Store : &:r1158_6, r1158_5 +# 1159| v1159_1(void) = NoOp : +# 1153| v1153_6(void) = ReturnVoid : +# 1153| v1153_7(void) = UnmodeledUse : mu* +# 1153| v1153_8(void) = AliasedUse : ~mu1153_3 +# 1153| v1153_9(void) = ExitFunction : # 1163| int ModeledCallTarget(int) # 1163| Block 0 -# 1163| v0_0(void) = EnterFunction : -# 1163| mu0_1(unknown) = AliasedDefinition : -# 1163| mu0_2(unknown) = UnmodeledDefinition : -# 1163| r0_3(glval) = VariableAddress[x] : -# 1163| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 1164| r0_5(glval) = VariableAddress[y] : -# 1164| mu0_6(int) = Uninitialized[y] : &:r0_5 -# 1165| r0_7(glval) = FunctionAddress[memcpy] : -# 1165| r0_8(glval) = VariableAddress[y] : -# 1165| r0_9(int *) = CopyValue : r0_8 -# 1165| r0_10(void *) = Convert : r0_9 -# 1165| r0_11(glval) = VariableAddress[x] : -# 1165| r0_12(int *) = CopyValue : r0_11 -# 1165| r0_13(void *) = Convert : r0_12 -# 1165| r0_14(int) = Constant[4] : -# 1165| r0_15(void *) = Call : func:r0_7, 0:r0_10, 1:r0_13, 2:r0_14 -# 1165| v0_16(void) = ^SizedBufferReadSideEffect[1] : &:r0_13, r0_14, ~mu0_2 -# 1165| mu0_17(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r0_10, r0_14 -# 1166| r0_18(glval) = VariableAddress[#return] : -# 1166| r0_19(glval) = VariableAddress[y] : -# 1166| r0_20(int) = Load : &:r0_19, ~mu0_2 -# 1166| mu0_21(int) = Store : &:r0_18, r0_20 -# 1163| r0_22(glval) = VariableAddress[#return] : -# 1163| v0_23(void) = ReturnValue : &:r0_22, ~mu0_2 -# 1163| v0_24(void) = UnmodeledUse : mu* -# 1163| v0_25(void) = AliasedUse : ~mu0_2 -# 1163| v0_26(void) = ExitFunction : +# 1163| v1163_1(void) = EnterFunction : +# 1163| mu1163_2(unknown) = AliasedDefinition : +# 1163| mu1163_3(unknown) = UnmodeledDefinition : +# 1163| r1163_4(glval) = VariableAddress[x] : +# 1163| mu1163_5(int) = InitializeParameter[x] : &:r1163_4 +# 1164| r1164_1(glval) = VariableAddress[y] : +# 1164| mu1164_2(int) = Uninitialized[y] : &:r1164_1 +# 1165| r1165_1(glval) = FunctionAddress[memcpy] : +# 1165| r1165_2(glval) = VariableAddress[y] : +# 1165| r1165_3(int *) = CopyValue : r1165_2 +# 1165| r1165_4(void *) = Convert : r1165_3 +# 1165| r1165_5(glval) = VariableAddress[x] : +# 1165| r1165_6(int *) = CopyValue : r1165_5 +# 1165| r1165_7(void *) = Convert : r1165_6 +# 1165| r1165_8(int) = Constant[4] : +# 1165| r1165_9(void *) = Call : func:r1165_1, 0:r1165_4, 1:r1165_7, 2:r1165_8 +# 1165| v1165_10(void) = ^SizedBufferReadSideEffect[1] : &:r1165_7, r1165_8, ~mu1163_3 +# 1165| mu1165_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r1165_4, r1165_8 +# 1166| r1166_1(glval) = VariableAddress[#return] : +# 1166| r1166_2(glval) = VariableAddress[y] : +# 1166| r1166_3(int) = Load : &:r1166_2, ~mu1163_3 +# 1166| mu1166_4(int) = Store : &:r1166_1, r1166_3 +# 1163| r1163_6(glval) = VariableAddress[#return] : +# 1163| v1163_7(void) = ReturnValue : &:r1163_6, ~mu1163_3 +# 1163| v1163_8(void) = UnmodeledUse : mu* +# 1163| v1163_9(void) = AliasedUse : ~mu1163_3 +# 1163| v1163_10(void) = ExitFunction : perf-regression.cpp: # 6| void Big::Big() # 6| Block 0 -# 6| v0_0(void) = EnterFunction : -# 6| mu0_1(unknown) = AliasedDefinition : -# 6| mu0_2(unknown) = UnmodeledDefinition : -# 6| r0_3(glval) = InitializeThis : -# 6| r0_4(glval) = FieldAddress[buffer] : r0_3 -# 6| r0_5(int) = Constant[0] : -# 6| r0_6(glval) = PointerAdd[1] : r0_4, r0_5 -# 6| r0_7(unknown[1073741824]) = Constant[0] : -# 6| mu0_8(unknown[1073741824]) = Store : &:r0_6, r0_7 -# 6| v0_9(void) = NoOp : -# 6| v0_10(void) = ReturnVoid : -# 6| v0_11(void) = UnmodeledUse : mu* -# 6| v0_12(void) = AliasedUse : ~mu0_2 -# 6| v0_13(void) = ExitFunction : +# 6| v6_1(void) = EnterFunction : +# 6| mu6_2(unknown) = AliasedDefinition : +# 6| mu6_3(unknown) = UnmodeledDefinition : +# 6| r6_4(glval) = InitializeThis : +# 6| r6_5(glval) = FieldAddress[buffer] : r6_4 +# 6| r6_6(int) = Constant[0] : +# 6| r6_7(glval) = PointerAdd[1] : r6_5, r6_6 +# 6| r6_8(unknown[1073741824]) = Constant[0] : +# 6| mu6_9(unknown[1073741824]) = Store : &:r6_7, r6_8 +# 6| v6_10(void) = NoOp : +# 6| v6_11(void) = ReturnVoid : +# 6| v6_12(void) = UnmodeledUse : mu* +# 6| v6_13(void) = AliasedUse : ~mu6_3 +# 6| v6_14(void) = ExitFunction : # 9| int main() # 9| Block 0 -# 9| v0_0(void) = EnterFunction : -# 9| mu0_1(unknown) = AliasedDefinition : -# 9| mu0_2(unknown) = UnmodeledDefinition : -# 10| r0_3(glval) = VariableAddress[big] : -# 10| r0_4(glval) = FunctionAddress[operator new] : -# 10| r0_5(unsigned long) = Constant[1073741824] : -# 10| r0_6(void *) = Call : func:r0_4, 0:r0_5 -# 10| mu0_7(unknown) = ^CallSideEffect : ~mu0_2 -# 10| r0_8(Big *) = Convert : r0_6 -# 10| r0_9(glval) = FunctionAddress[Big] : -# 10| v0_10(void) = Call : func:r0_9, this:r0_8 -# 10| mu0_11(unknown) = ^CallSideEffect : ~mu0_2 -# 10| mu0_12(Big) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 10| mu0_13(Big *) = Store : &:r0_3, r0_8 -# 12| r0_14(glval) = VariableAddress[#return] : -# 12| r0_15(int) = Constant[0] : -# 12| mu0_16(int) = Store : &:r0_14, r0_15 -# 9| r0_17(glval) = VariableAddress[#return] : -# 9| v0_18(void) = ReturnValue : &:r0_17, ~mu0_2 -# 9| v0_19(void) = UnmodeledUse : mu* -# 9| v0_20(void) = AliasedUse : ~mu0_2 -# 9| v0_21(void) = ExitFunction : +# 9| v9_1(void) = EnterFunction : +# 9| mu9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 10| r10_1(glval) = VariableAddress[big] : +# 10| r10_2(glval) = FunctionAddress[operator new] : +# 10| r10_3(unsigned long) = Constant[1073741824] : +# 10| r10_4(void *) = Call : func:r10_2, 0:r10_3 +# 10| mu10_5(unknown) = ^CallSideEffect : ~mu9_3 +# 10| r10_6(Big *) = Convert : r10_4 +# 10| r10_7(glval) = FunctionAddress[Big] : +# 10| v10_8(void) = Call : func:r10_7, this:r10_6 +# 10| mu10_9(unknown) = ^CallSideEffect : ~mu9_3 +# 10| mu10_10(Big) = ^IndirectMayWriteSideEffect[-1] : &:r10_6 +# 10| mu10_11(Big *) = Store : &:r10_1, r10_6 +# 12| r12_1(glval) = VariableAddress[#return] : +# 12| r12_2(int) = Constant[0] : +# 12| mu12_3(int) = Store : &:r12_1, r12_2 +# 9| r9_4(glval) = VariableAddress[#return] : +# 9| v9_5(void) = ReturnValue : &:r9_4, ~mu9_3 +# 9| v9_6(void) = UnmodeledUse : mu* +# 9| v9_7(void) = AliasedUse : ~mu9_3 +# 9| v9_8(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.expected b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.expected index 1e79d13fd3d..f832060de6e 100644 --- a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.expected +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.expected @@ -1,1051 +1,1051 @@ ssa.cpp: # 13| int ChiPhiNode(Point*, bool, bool) # 13| Block 0 -# 13| v0_0(void) = EnterFunction : -# 13| m0_1(unknown) = AliasedDefinition : -# 13| mu0_2(unknown) = UnmodeledDefinition : -# 13| r0_3(glval) = VariableAddress[p] : -# 13| m0_4(Point *) = InitializeParameter[p] : &:r0_3 -# 13| r0_5(glval) = VariableAddress[which1] : -# 13| m0_6(bool) = InitializeParameter[which1] : &:r0_5 -# 13| r0_7(glval) = VariableAddress[which2] : -# 13| m0_8(bool) = InitializeParameter[which2] : &:r0_7 -# 14| r0_9(glval) = VariableAddress[which1] : -# 14| r0_10(bool) = Load : &:r0_9, m0_6 -# 14| v0_11(void) = ConditionalBranch : r0_10 +# 13| v13_1(void) = EnterFunction : +# 13| m13_2(unknown) = AliasedDefinition : +# 13| mu13_3(unknown) = UnmodeledDefinition : +# 13| r13_4(glval) = VariableAddress[p] : +# 13| m13_5(Point *) = InitializeParameter[p] : &:r13_4 +# 13| r13_6(glval) = VariableAddress[which1] : +# 13| m13_7(bool) = InitializeParameter[which1] : &:r13_6 +# 13| r13_8(glval) = VariableAddress[which2] : +# 13| m13_9(bool) = InitializeParameter[which2] : &:r13_8 +# 14| r14_1(glval) = VariableAddress[which1] : +# 14| r14_2(bool) = Load : &:r14_1, m13_7 +# 14| v14_3(void) = ConditionalBranch : r14_2 #-----| False -> Block 2 #-----| True -> Block 1 # 15| Block 1 -# 15| r1_0(glval) = VariableAddress[p] : -# 15| r1_1(Point *) = Load : &:r1_0, m0_4 -# 15| r1_2(glval) = FieldAddress[x] : r1_1 -# 15| r1_3(int) = Load : &:r1_2, ~m0_1 -# 15| r1_4(int) = Constant[1] : -# 15| r1_5(int) = Add : r1_3, r1_4 -# 15| m1_6(int) = Store : &:r1_2, r1_5 -# 15| m1_7(unknown) = Chi : total:m0_1, partial:m1_6 +# 15| r15_1(glval) = VariableAddress[p] : +# 15| r15_2(Point *) = Load : &:r15_1, m13_5 +# 15| r15_3(glval) = FieldAddress[x] : r15_2 +# 15| r15_4(int) = Load : &:r15_3, ~m13_2 +# 15| r15_5(int) = Constant[1] : +# 15| r15_6(int) = Add : r15_4, r15_5 +# 15| m15_7(int) = Store : &:r15_3, r15_6 +# 15| m15_8(unknown) = Chi : total:m13_2, partial:m15_7 #-----| Goto -> Block 3 # 18| Block 2 -# 18| r2_0(glval) = VariableAddress[p] : -# 18| r2_1(Point *) = Load : &:r2_0, m0_4 -# 18| r2_2(glval) = FieldAddress[y] : r2_1 -# 18| r2_3(int) = Load : &:r2_2, ~m0_1 -# 18| r2_4(int) = Constant[1] : -# 18| r2_5(int) = Add : r2_3, r2_4 -# 18| m2_6(int) = Store : &:r2_2, r2_5 -# 18| m2_7(unknown) = Chi : total:m0_1, partial:m2_6 +# 18| r18_1(glval) = VariableAddress[p] : +# 18| r18_2(Point *) = Load : &:r18_1, m13_5 +# 18| r18_3(glval) = FieldAddress[y] : r18_2 +# 18| r18_4(int) = Load : &:r18_3, ~m13_2 +# 18| r18_5(int) = Constant[1] : +# 18| r18_6(int) = Add : r18_4, r18_5 +# 18| m18_7(int) = Store : &:r18_3, r18_6 +# 18| m18_8(unknown) = Chi : total:m13_2, partial:m18_7 #-----| Goto -> Block 3 # 21| Block 3 -# 21| m3_0(unknown) = Phi : from 1:~m1_7, from 2:~m2_7 -# 21| r3_1(glval) = VariableAddress[which2] : -# 21| r3_2(bool) = Load : &:r3_1, m0_8 -# 21| v3_3(void) = ConditionalBranch : r3_2 +# 21| m21_1(unknown) = Phi : from 1:~m15_8, from 2:~m18_8 +# 21| r21_2(glval) = VariableAddress[which2] : +# 21| r21_3(bool) = Load : &:r21_2, m13_9 +# 21| v21_4(void) = ConditionalBranch : r21_3 #-----| False -> Block 5 #-----| True -> Block 4 # 22| Block 4 -# 22| r4_0(glval) = VariableAddress[p] : -# 22| r4_1(Point *) = Load : &:r4_0, m0_4 -# 22| r4_2(glval) = FieldAddress[x] : r4_1 -# 22| r4_3(int) = Load : &:r4_2, ~m3_0 -# 22| r4_4(int) = Constant[1] : -# 22| r4_5(int) = Add : r4_3, r4_4 -# 22| m4_6(int) = Store : &:r4_2, r4_5 -# 22| m4_7(unknown) = Chi : total:m3_0, partial:m4_6 +# 22| r22_1(glval) = VariableAddress[p] : +# 22| r22_2(Point *) = Load : &:r22_1, m13_5 +# 22| r22_3(glval) = FieldAddress[x] : r22_2 +# 22| r22_4(int) = Load : &:r22_3, ~m21_1 +# 22| r22_5(int) = Constant[1] : +# 22| r22_6(int) = Add : r22_4, r22_5 +# 22| m22_7(int) = Store : &:r22_3, r22_6 +# 22| m22_8(unknown) = Chi : total:m21_1, partial:m22_7 #-----| Goto -> Block 6 # 25| Block 5 -# 25| r5_0(glval) = VariableAddress[p] : -# 25| r5_1(Point *) = Load : &:r5_0, m0_4 -# 25| r5_2(glval) = FieldAddress[y] : r5_1 -# 25| r5_3(int) = Load : &:r5_2, ~m3_0 -# 25| r5_4(int) = Constant[1] : -# 25| r5_5(int) = Add : r5_3, r5_4 -# 25| m5_6(int) = Store : &:r5_2, r5_5 -# 25| m5_7(unknown) = Chi : total:m3_0, partial:m5_6 +# 25| r25_1(glval) = VariableAddress[p] : +# 25| r25_2(Point *) = Load : &:r25_1, m13_5 +# 25| r25_3(glval) = FieldAddress[y] : r25_2 +# 25| r25_4(int) = Load : &:r25_3, ~m21_1 +# 25| r25_5(int) = Constant[1] : +# 25| r25_6(int) = Add : r25_4, r25_5 +# 25| m25_7(int) = Store : &:r25_3, r25_6 +# 25| m25_8(unknown) = Chi : total:m21_1, partial:m25_7 #-----| Goto -> Block 6 # 28| Block 6 -# 28| m6_0(unknown) = Phi : from 4:~m4_7, from 5:~m5_7 -# 28| r6_1(glval) = VariableAddress[#return] : -# 28| r6_2(glval) = VariableAddress[p] : -# 28| r6_3(Point *) = Load : &:r6_2, m0_4 -# 28| r6_4(glval) = FieldAddress[x] : r6_3 -# 28| r6_5(int) = Load : &:r6_4, ~m6_0 -# 28| r6_6(glval) = VariableAddress[p] : -# 28| r6_7(Point *) = Load : &:r6_6, m0_4 -# 28| r6_8(glval) = FieldAddress[y] : r6_7 -# 28| r6_9(int) = Load : &:r6_8, ~m6_0 -# 28| r6_10(int) = Add : r6_5, r6_9 -# 28| m6_11(int) = Store : &:r6_1, r6_10 -# 13| r6_12(glval) = VariableAddress[#return] : -# 13| v6_13(void) = ReturnValue : &:r6_12, m6_11 -# 13| v6_14(void) = UnmodeledUse : mu* -# 13| v6_15(void) = AliasedUse : ~m6_0 -# 13| v6_16(void) = ExitFunction : +# 28| m28_1(unknown) = Phi : from 4:~m22_8, from 5:~m25_8 +# 28| r28_2(glval) = VariableAddress[#return] : +# 28| r28_3(glval) = VariableAddress[p] : +# 28| r28_4(Point *) = Load : &:r28_3, m13_5 +# 28| r28_5(glval) = FieldAddress[x] : r28_4 +# 28| r28_6(int) = Load : &:r28_5, ~m28_1 +# 28| r28_7(glval) = VariableAddress[p] : +# 28| r28_8(Point *) = Load : &:r28_7, m13_5 +# 28| r28_9(glval) = FieldAddress[y] : r28_8 +# 28| r28_10(int) = Load : &:r28_9, ~m28_1 +# 28| r28_11(int) = Add : r28_6, r28_10 +# 28| m28_12(int) = Store : &:r28_2, r28_11 +# 13| r13_10(glval) = VariableAddress[#return] : +# 13| v13_11(void) = ReturnValue : &:r13_10, m28_12 +# 13| v13_12(void) = UnmodeledUse : mu* +# 13| v13_13(void) = AliasedUse : ~m28_1 +# 13| v13_14(void) = ExitFunction : # 31| int UnreachableViaGoto() # 31| Block 0 -# 31| v0_0(void) = EnterFunction : -# 31| m0_1(unknown) = AliasedDefinition : -# 31| mu0_2(unknown) = UnmodeledDefinition : -# 32| v0_3(void) = NoOp : -# 34| v0_4(void) = NoOp : -# 35| r0_5(glval) = VariableAddress[#return] : -# 35| r0_6(int) = Constant[0] : -# 35| m0_7(int) = Store : &:r0_5, r0_6 -# 31| r0_8(glval) = VariableAddress[#return] : -# 31| v0_9(void) = ReturnValue : &:r0_8, m0_7 -# 31| v0_10(void) = UnmodeledUse : mu* -# 31| v0_11(void) = AliasedUse : ~m0_1 -# 31| v0_12(void) = ExitFunction : +# 31| v31_1(void) = EnterFunction : +# 31| m31_2(unknown) = AliasedDefinition : +# 31| mu31_3(unknown) = UnmodeledDefinition : +# 32| v32_1(void) = NoOp : +# 34| v34_1(void) = NoOp : +# 35| r35_1(glval) = VariableAddress[#return] : +# 35| r35_2(int) = Constant[0] : +# 35| m35_3(int) = Store : &:r35_1, r35_2 +# 31| r31_4(glval) = VariableAddress[#return] : +# 31| v31_5(void) = ReturnValue : &:r31_4, m35_3 +# 31| v31_6(void) = UnmodeledUse : mu* +# 31| v31_7(void) = AliasedUse : ~m31_2 +# 31| v31_8(void) = ExitFunction : # 38| int UnreachableIf(bool) # 38| Block 0 -# 38| v0_0(void) = EnterFunction : -# 38| m0_1(unknown) = AliasedDefinition : -# 38| mu0_2(unknown) = UnmodeledDefinition : -# 38| r0_3(glval) = VariableAddress[b] : -# 38| m0_4(bool) = InitializeParameter[b] : &:r0_3 -# 39| r0_5(glval) = VariableAddress[x] : -# 39| r0_6(int) = Constant[5] : -# 39| m0_7(int) = Store : &:r0_5, r0_6 -# 40| r0_8(glval) = VariableAddress[y] : -# 40| r0_9(int) = Constant[10] : -# 40| m0_10(int) = Store : &:r0_8, r0_9 -# 41| r0_11(glval) = VariableAddress[b] : -# 41| r0_12(bool) = Load : &:r0_11, m0_4 -# 41| v0_13(void) = ConditionalBranch : r0_12 +# 38| v38_1(void) = EnterFunction : +# 38| m38_2(unknown) = AliasedDefinition : +# 38| mu38_3(unknown) = UnmodeledDefinition : +# 38| r38_4(glval) = VariableAddress[b] : +# 38| m38_5(bool) = InitializeParameter[b] : &:r38_4 +# 39| r39_1(glval) = VariableAddress[x] : +# 39| r39_2(int) = Constant[5] : +# 39| m39_3(int) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[y] : +# 40| r40_2(int) = Constant[10] : +# 40| m40_3(int) = Store : &:r40_1, r40_2 +# 41| r41_1(glval) = VariableAddress[b] : +# 41| r41_2(bool) = Load : &:r41_1, m38_5 +# 41| v41_3(void) = ConditionalBranch : r41_2 #-----| False -> Block 4 #-----| True -> Block 2 # 38| Block 1 -# 38| m1_0(int) = Phi : from 3:m3_2, from 5:m5_2 -# 38| r1_1(glval) = VariableAddress[#return] : -# 38| v1_2(void) = ReturnValue : &:r1_1, m1_0 -# 38| v1_3(void) = UnmodeledUse : mu* -# 38| v1_4(void) = AliasedUse : ~m0_1 -# 38| v1_5(void) = ExitFunction : +# 38| m38_6(int) = Phi : from 3:m46_3, from 5:m51_3 +# 38| r38_7(glval) = VariableAddress[#return] : +# 38| v38_8(void) = ReturnValue : &:r38_7, m38_6 +# 38| v38_9(void) = UnmodeledUse : mu* +# 38| v38_10(void) = AliasedUse : ~m38_2 +# 38| v38_11(void) = ExitFunction : # 42| Block 2 -# 42| r2_0(glval) = VariableAddress[x] : -# 42| r2_1(int) = Load : &:r2_0, m0_7 -# 42| r2_2(glval) = VariableAddress[y] : -# 42| r2_3(int) = Load : &:r2_2, m0_10 -# 42| r2_4(bool) = CompareEQ : r2_1, r2_3 -# 42| v2_5(void) = ConditionalBranch : r2_4 +# 42| r42_1(glval) = VariableAddress[x] : +# 42| r42_2(int) = Load : &:r42_1, m39_3 +# 42| r42_3(glval) = VariableAddress[y] : +# 42| r42_4(int) = Load : &:r42_3, m40_3 +# 42| r42_5(bool) = CompareEQ : r42_2, r42_4 +# 42| v42_6(void) = ConditionalBranch : r42_5 #-----| False -> Block 3 #-----| True -> Block 6 # 46| Block 3 -# 46| r3_0(glval) = VariableAddress[#return] : -# 46| r3_1(int) = Constant[0] : -# 46| m3_2(int) = Store : &:r3_0, r3_1 +# 46| r46_1(glval) = VariableAddress[#return] : +# 46| r46_2(int) = Constant[0] : +# 46| m46_3(int) = Store : &:r46_1, r46_2 #-----| Goto -> Block 1 # 50| Block 4 -# 50| r4_0(glval) = VariableAddress[x] : -# 50| r4_1(int) = Load : &:r4_0, m0_7 -# 50| r4_2(glval) = VariableAddress[y] : -# 50| r4_3(int) = Load : &:r4_2, m0_10 -# 50| r4_4(bool) = CompareLT : r4_1, r4_3 -# 50| v4_5(void) = ConditionalBranch : r4_4 +# 50| r50_1(glval) = VariableAddress[x] : +# 50| r50_2(int) = Load : &:r50_1, m39_3 +# 50| r50_3(glval) = VariableAddress[y] : +# 50| r50_4(int) = Load : &:r50_3, m40_3 +# 50| r50_5(bool) = CompareLT : r50_2, r50_4 +# 50| v50_6(void) = ConditionalBranch : r50_5 #-----| False -> Block 6 #-----| True -> Block 5 # 51| Block 5 -# 51| r5_0(glval) = VariableAddress[#return] : -# 51| r5_1(int) = Constant[0] : -# 51| m5_2(int) = Store : &:r5_0, r5_1 +# 51| r51_1(glval) = VariableAddress[#return] : +# 51| r51_2(int) = Constant[0] : +# 51| m51_3(int) = Store : &:r51_1, r51_2 #-----| Goto -> Block 1 # 38| Block 6 -# 38| v6_0(void) = Unreached : +# 38| v38_12(void) = Unreached : # 59| int DoWhileFalse() # 59| Block 0 -# 59| v0_0(void) = EnterFunction : -# 59| m0_1(unknown) = AliasedDefinition : -# 59| mu0_2(unknown) = UnmodeledDefinition : -# 60| r0_3(glval) = VariableAddress[i] : -# 60| r0_4(int) = Constant[0] : -# 60| m0_5(int) = Store : &:r0_3, r0_4 -# 62| r0_6(glval) = VariableAddress[i] : -# 62| r0_7(int) = Load : &:r0_6, m0_5 -# 62| r0_8(int) = Constant[1] : -# 62| r0_9(int) = Add : r0_7, r0_8 -# 62| m0_10(int) = Store : &:r0_6, r0_9 -# 63| r0_11(bool) = Constant[0] : -# 63| v0_12(void) = ConditionalBranch : r0_11 +# 59| v59_1(void) = EnterFunction : +# 59| m59_2(unknown) = AliasedDefinition : +# 59| mu59_3(unknown) = UnmodeledDefinition : +# 60| r60_1(glval) = VariableAddress[i] : +# 60| r60_2(int) = Constant[0] : +# 60| m60_3(int) = Store : &:r60_1, r60_2 +# 62| r62_1(glval) = VariableAddress[i] : +# 62| r62_2(int) = Load : &:r62_1, m60_3 +# 62| r62_3(int) = Constant[1] : +# 62| r62_4(int) = Add : r62_2, r62_3 +# 62| m62_5(int) = Store : &:r62_1, r62_4 +# 63| r63_1(bool) = Constant[0] : +# 63| v63_2(void) = ConditionalBranch : r63_1 #-----| False -> Block 1 #-----| True -> Block 2 # 65| Block 1 -# 65| r1_0(glval) = VariableAddress[#return] : -# 65| r1_1(glval) = VariableAddress[i] : -# 65| r1_2(int) = Load : &:r1_1, m0_10 -# 65| m1_3(int) = Store : &:r1_0, r1_2 -# 59| r1_4(glval) = VariableAddress[#return] : -# 59| v1_5(void) = ReturnValue : &:r1_4, m1_3 -# 59| v1_6(void) = UnmodeledUse : mu* -# 59| v1_7(void) = AliasedUse : ~m0_1 -# 59| v1_8(void) = ExitFunction : +# 65| r65_1(glval) = VariableAddress[#return] : +# 65| r65_2(glval) = VariableAddress[i] : +# 65| r65_3(int) = Load : &:r65_2, m62_5 +# 65| m65_4(int) = Store : &:r65_1, r65_3 +# 59| r59_4(glval) = VariableAddress[#return] : +# 59| v59_5(void) = ReturnValue : &:r59_4, m65_4 +# 59| v59_6(void) = UnmodeledUse : mu* +# 59| v59_7(void) = AliasedUse : ~m59_2 +# 59| v59_8(void) = ExitFunction : # 59| Block 2 -# 59| v2_0(void) = Unreached : +# 59| v59_9(void) = Unreached : # 68| void chiNodeAtEndOfLoop(int, char*) # 68| Block 0 -# 68| v0_0(void) = EnterFunction : -# 68| m0_1(unknown) = AliasedDefinition : -# 68| mu0_2(unknown) = UnmodeledDefinition : -# 68| r0_3(glval) = VariableAddress[n] : -# 68| m0_4(int) = InitializeParameter[n] : &:r0_3 -# 68| r0_5(glval) = VariableAddress[p] : -# 68| m0_6(char *) = InitializeParameter[p] : &:r0_5 +# 68| v68_1(void) = EnterFunction : +# 68| m68_2(unknown) = AliasedDefinition : +# 68| mu68_3(unknown) = UnmodeledDefinition : +# 68| r68_4(glval) = VariableAddress[n] : +# 68| m68_5(int) = InitializeParameter[n] : &:r68_4 +# 68| r68_6(glval) = VariableAddress[p] : +# 68| m68_7(char *) = InitializeParameter[p] : &:r68_6 #-----| Goto -> Block 3 # 70| Block 1 -# 70| r1_0(char) = Constant[0] : -# 70| r1_1(glval) = VariableAddress[p] : -# 70| r1_2(char *) = Load : &:r1_1, m3_2 -# 70| r1_3(int) = Constant[1] : -# 70| r1_4(char *) = PointerAdd[1] : r1_2, r1_3 -# 70| m1_5(char *) = Store : &:r1_1, r1_4 -# 70| r1_6(glval) = CopyValue : r1_2 -# 70| m1_7(char) = Store : &:r1_6, r1_0 -# 70| m1_8(unknown) = Chi : total:m3_0, partial:m1_7 +# 70| r70_1(char) = Constant[0] : +# 70| r70_2(glval) = VariableAddress[p] : +# 70| r70_3(char *) = Load : &:r70_2, m69_1 +# 70| r70_4(int) = Constant[1] : +# 70| r70_5(char *) = PointerAdd[1] : r70_3, r70_4 +# 70| m70_6(char *) = Store : &:r70_2, r70_5 +# 70| r70_7(glval) = CopyValue : r70_3 +# 70| m70_8(char) = Store : &:r70_7, r70_1 +# 70| m70_9(unknown) = Chi : total:m69_3, partial:m70_8 #-----| Goto (back edge) -> Block 3 # 71| Block 2 -# 71| v2_0(void) = NoOp : -# 68| v2_1(void) = ReturnVoid : -# 68| v2_2(void) = UnmodeledUse : mu* -# 68| v2_3(void) = AliasedUse : ~m3_0 -# 68| v2_4(void) = ExitFunction : +# 71| v71_1(void) = NoOp : +# 68| v68_8(void) = ReturnVoid : +# 68| v68_9(void) = UnmodeledUse : mu* +# 68| v68_10(void) = AliasedUse : ~m69_3 +# 68| v68_11(void) = ExitFunction : # 69| Block 3 -# 69| m3_0(unknown) = Phi : from 0:~m0_1, from 1:~m1_8 -# 69| m3_1(int) = Phi : from 0:m0_4, from 1:m3_7 -# 69| m3_2(char *) = Phi : from 0:m0_6, from 1:m1_5 -# 69| r3_3(glval) = VariableAddress[n] : -# 69| r3_4(int) = Load : &:r3_3, m3_1 -# 69| r3_5(int) = Constant[1] : -# 69| r3_6(int) = Sub : r3_4, r3_5 -# 69| m3_7(int) = Store : &:r3_3, r3_6 -# 69| r3_8(int) = Constant[0] : -# 69| r3_9(bool) = CompareGT : r3_4, r3_8 -# 69| v3_10(void) = ConditionalBranch : r3_9 +# 69| m69_1(char *) = Phi : from 0:m68_7, from 1:m70_6 +# 69| m69_2(int) = Phi : from 0:m68_5, from 1:m69_8 +# 69| m69_3(unknown) = Phi : from 0:~m68_2, from 1:~m70_9 +# 69| r69_4(glval) = VariableAddress[n] : +# 69| r69_5(int) = Load : &:r69_4, m69_2 +# 69| r69_6(int) = Constant[1] : +# 69| r69_7(int) = Sub : r69_5, r69_6 +# 69| m69_8(int) = Store : &:r69_4, r69_7 +# 69| r69_9(int) = Constant[0] : +# 69| r69_10(bool) = CompareGT : r69_5, r69_9 +# 69| v69_11(void) = ConditionalBranch : r69_10 #-----| False -> Block 2 #-----| True -> Block 1 # 75| void ScalarPhi(bool) # 75| Block 0 -# 75| v0_0(void) = EnterFunction : -# 75| m0_1(unknown) = AliasedDefinition : -# 75| mu0_2(unknown) = UnmodeledDefinition : -# 75| r0_3(glval) = VariableAddress[b] : -# 75| m0_4(bool) = InitializeParameter[b] : &:r0_3 -# 76| r0_5(glval) = VariableAddress[x] : -# 76| r0_6(int) = Constant[0] : -# 76| m0_7(int) = Store : &:r0_5, r0_6 -# 77| r0_8(glval) = VariableAddress[y] : -# 77| r0_9(int) = Constant[1] : -# 77| m0_10(int) = Store : &:r0_8, r0_9 -# 78| r0_11(glval) = VariableAddress[z] : -# 78| r0_12(int) = Constant[2] : -# 78| m0_13(int) = Store : &:r0_11, r0_12 -# 79| r0_14(glval) = VariableAddress[b] : -# 79| r0_15(bool) = Load : &:r0_14, m0_4 -# 79| v0_16(void) = ConditionalBranch : r0_15 +# 75| v75_1(void) = EnterFunction : +# 75| m75_2(unknown) = AliasedDefinition : +# 75| mu75_3(unknown) = UnmodeledDefinition : +# 75| r75_4(glval) = VariableAddress[b] : +# 75| m75_5(bool) = InitializeParameter[b] : &:r75_4 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Constant[0] : +# 76| m76_3(int) = Store : &:r76_1, r76_2 +# 77| r77_1(glval) = VariableAddress[y] : +# 77| r77_2(int) = Constant[1] : +# 77| m77_3(int) = Store : &:r77_1, r77_2 +# 78| r78_1(glval) = VariableAddress[z] : +# 78| r78_2(int) = Constant[2] : +# 78| m78_3(int) = Store : &:r78_1, r78_2 +# 79| r79_1(glval) = VariableAddress[b] : +# 79| r79_2(bool) = Load : &:r79_1, m75_5 +# 79| v79_3(void) = ConditionalBranch : r79_2 #-----| False -> Block 2 #-----| True -> Block 1 # 80| Block 1 -# 80| r1_0(int) = Constant[3] : -# 80| r1_1(glval) = VariableAddress[x] : -# 80| m1_2(int) = Store : &:r1_1, r1_0 -# 81| r1_3(int) = Constant[4] : -# 81| r1_4(glval) = VariableAddress[y] : -# 81| m1_5(int) = Store : &:r1_4, r1_3 +# 80| r80_1(int) = Constant[3] : +# 80| r80_2(glval) = VariableAddress[x] : +# 80| m80_3(int) = Store : &:r80_2, r80_1 +# 81| r81_1(int) = Constant[4] : +# 81| r81_2(glval) = VariableAddress[y] : +# 81| m81_3(int) = Store : &:r81_2, r81_1 #-----| Goto -> Block 3 # 84| Block 2 -# 84| r2_0(int) = Constant[5] : -# 84| r2_1(glval) = VariableAddress[x] : -# 84| m2_2(int) = Store : &:r2_1, r2_0 +# 84| r84_1(int) = Constant[5] : +# 84| r84_2(glval) = VariableAddress[x] : +# 84| m84_3(int) = Store : &:r84_2, r84_1 #-----| Goto -> Block 3 # 86| Block 3 -# 86| m3_0(int) = Phi : from 1:m1_2, from 2:m2_2 -# 86| m3_1(int) = Phi : from 1:m1_5, from 2:m0_10 -# 86| r3_2(glval) = VariableAddress[x_merge] : -# 86| r3_3(glval) = VariableAddress[x] : -# 86| r3_4(int) = Load : &:r3_3, m3_0 -# 86| m3_5(int) = Store : &:r3_2, r3_4 -# 87| r3_6(glval) = VariableAddress[y_merge] : -# 87| r3_7(glval) = VariableAddress[y] : -# 87| r3_8(int) = Load : &:r3_7, m3_1 -# 87| m3_9(int) = Store : &:r3_6, r3_8 -# 88| r3_10(glval) = VariableAddress[z_merge] : -# 88| r3_11(glval) = VariableAddress[z] : -# 88| r3_12(int) = Load : &:r3_11, m0_13 -# 88| m3_13(int) = Store : &:r3_10, r3_12 -# 89| v3_14(void) = NoOp : -# 75| v3_15(void) = ReturnVoid : -# 75| v3_16(void) = UnmodeledUse : mu* -# 75| v3_17(void) = AliasedUse : ~m0_1 -# 75| v3_18(void) = ExitFunction : +# 86| m86_1(int) = Phi : from 1:m81_3, from 2:m77_3 +# 86| m86_2(int) = Phi : from 1:m80_3, from 2:m84_3 +# 86| r86_3(glval) = VariableAddress[x_merge] : +# 86| r86_4(glval) = VariableAddress[x] : +# 86| r86_5(int) = Load : &:r86_4, m86_2 +# 86| m86_6(int) = Store : &:r86_3, r86_5 +# 87| r87_1(glval) = VariableAddress[y_merge] : +# 87| r87_2(glval) = VariableAddress[y] : +# 87| r87_3(int) = Load : &:r87_2, m86_1 +# 87| m87_4(int) = Store : &:r87_1, r87_3 +# 88| r88_1(glval) = VariableAddress[z_merge] : +# 88| r88_2(glval) = VariableAddress[z] : +# 88| r88_3(int) = Load : &:r88_2, m78_3 +# 88| m88_4(int) = Store : &:r88_1, r88_3 +# 89| v89_1(void) = NoOp : +# 75| v75_6(void) = ReturnVoid : +# 75| v75_7(void) = UnmodeledUse : mu* +# 75| v75_8(void) = AliasedUse : ~m75_2 +# 75| v75_9(void) = ExitFunction : # 91| void MustExactlyOverlap(Point) # 91| Block 0 -# 91| v0_0(void) = EnterFunction : -# 91| m0_1(unknown) = AliasedDefinition : -# 91| mu0_2(unknown) = UnmodeledDefinition : -# 91| r0_3(glval) = VariableAddress[a] : -# 91| m0_4(Point) = InitializeParameter[a] : &:r0_3 -# 92| r0_5(glval) = VariableAddress[b] : -# 92| r0_6(glval) = VariableAddress[a] : -# 92| r0_7(Point) = Load : &:r0_6, m0_4 -# 92| m0_8(Point) = Store : &:r0_5, r0_7 -# 93| v0_9(void) = NoOp : -# 91| v0_10(void) = ReturnVoid : -# 91| v0_11(void) = UnmodeledUse : mu* -# 91| v0_12(void) = AliasedUse : ~m0_1 -# 91| v0_13(void) = ExitFunction : +# 91| v91_1(void) = EnterFunction : +# 91| m91_2(unknown) = AliasedDefinition : +# 91| mu91_3(unknown) = UnmodeledDefinition : +# 91| r91_4(glval) = VariableAddress[a] : +# 91| m91_5(Point) = InitializeParameter[a] : &:r91_4 +# 92| r92_1(glval) = VariableAddress[b] : +# 92| r92_2(glval) = VariableAddress[a] : +# 92| r92_3(Point) = Load : &:r92_2, m91_5 +# 92| m92_4(Point) = Store : &:r92_1, r92_3 +# 93| v93_1(void) = NoOp : +# 91| v91_6(void) = ReturnVoid : +# 91| v91_7(void) = UnmodeledUse : mu* +# 91| v91_8(void) = AliasedUse : ~m91_2 +# 91| v91_9(void) = ExitFunction : # 95| void MustExactlyOverlapEscaped(Point) # 95| Block 0 -# 95| v0_0(void) = EnterFunction : -# 95| m0_1(unknown) = AliasedDefinition : -# 95| mu0_2(unknown) = UnmodeledDefinition : -# 95| r0_3(glval) = VariableAddress[a] : -# 95| m0_4(Point) = InitializeParameter[a] : &:r0_3 -# 95| m0_5(unknown) = Chi : total:m0_1, partial:m0_4 -# 96| r0_6(glval) = VariableAddress[b] : -# 96| r0_7(glval) = VariableAddress[a] : -# 96| r0_8(Point) = Load : &:r0_7, m0_4 -# 96| m0_9(Point) = Store : &:r0_6, r0_8 -# 97| r0_10(glval) = FunctionAddress[Escape] : -# 97| r0_11(glval) = VariableAddress[a] : -# 97| r0_12(Point *) = CopyValue : r0_11 -# 97| r0_13(void *) = Convert : r0_12 -# 97| v0_14(void) = Call : func:r0_10, 0:r0_13 -# 97| m0_15(unknown) = ^CallSideEffect : ~m0_5 -# 97| m0_16(unknown) = Chi : total:m0_5, partial:m0_15 -# 97| v0_17(void) = ^BufferReadSideEffect[0] : &:r0_13, ~m0_16 -# 97| m0_18(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 -# 97| m0_19(unknown) = Chi : total:m0_16, partial:m0_18 -# 98| v0_20(void) = NoOp : -# 95| v0_21(void) = ReturnVoid : -# 95| v0_22(void) = UnmodeledUse : mu* -# 95| v0_23(void) = AliasedUse : ~m0_16 -# 95| v0_24(void) = ExitFunction : +# 95| v95_1(void) = EnterFunction : +# 95| m95_2(unknown) = AliasedDefinition : +# 95| mu95_3(unknown) = UnmodeledDefinition : +# 95| r95_4(glval) = VariableAddress[a] : +# 95| m95_5(Point) = InitializeParameter[a] : &:r95_4 +# 95| m95_6(unknown) = Chi : total:m95_2, partial:m95_5 +# 96| r96_1(glval) = VariableAddress[b] : +# 96| r96_2(glval) = VariableAddress[a] : +# 96| r96_3(Point) = Load : &:r96_2, m95_5 +# 96| m96_4(Point) = Store : &:r96_1, r96_3 +# 97| r97_1(glval) = FunctionAddress[Escape] : +# 97| r97_2(glval) = VariableAddress[a] : +# 97| r97_3(Point *) = CopyValue : r97_2 +# 97| r97_4(void *) = Convert : r97_3 +# 97| v97_5(void) = Call : func:r97_1, 0:r97_4 +# 97| m97_6(unknown) = ^CallSideEffect : ~m95_6 +# 97| m97_7(unknown) = Chi : total:m95_6, partial:m97_6 +# 97| v97_8(void) = ^BufferReadSideEffect[0] : &:r97_4, ~m97_7 +# 97| m97_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r97_4 +# 97| m97_10(unknown) = Chi : total:m97_7, partial:m97_9 +# 98| v98_1(void) = NoOp : +# 95| v95_7(void) = ReturnVoid : +# 95| v95_8(void) = UnmodeledUse : mu* +# 95| v95_9(void) = AliasedUse : ~m97_7 +# 95| v95_10(void) = ExitFunction : # 100| void MustTotallyOverlap(Point) # 100| Block 0 -# 100| v0_0(void) = EnterFunction : -# 100| m0_1(unknown) = AliasedDefinition : -# 100| mu0_2(unknown) = UnmodeledDefinition : -# 100| r0_3(glval) = VariableAddress[a] : -# 100| m0_4(Point) = InitializeParameter[a] : &:r0_3 -# 101| r0_5(glval) = VariableAddress[x] : -# 101| r0_6(glval) = VariableAddress[a] : -# 101| r0_7(glval) = FieldAddress[x] : r0_6 -# 101| r0_8(int) = Load : &:r0_7, ~m0_4 -# 101| m0_9(int) = Store : &:r0_5, r0_8 -# 102| r0_10(glval) = VariableAddress[y] : -# 102| r0_11(glval) = VariableAddress[a] : -# 102| r0_12(glval) = FieldAddress[y] : r0_11 -# 102| r0_13(int) = Load : &:r0_12, ~m0_4 -# 102| m0_14(int) = Store : &:r0_10, r0_13 -# 103| v0_15(void) = NoOp : -# 100| v0_16(void) = ReturnVoid : -# 100| v0_17(void) = UnmodeledUse : mu* -# 100| v0_18(void) = AliasedUse : ~m0_1 -# 100| v0_19(void) = ExitFunction : +# 100| v100_1(void) = EnterFunction : +# 100| m100_2(unknown) = AliasedDefinition : +# 100| mu100_3(unknown) = UnmodeledDefinition : +# 100| r100_4(glval) = VariableAddress[a] : +# 100| m100_5(Point) = InitializeParameter[a] : &:r100_4 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(glval) = VariableAddress[a] : +# 101| r101_3(glval) = FieldAddress[x] : r101_2 +# 101| r101_4(int) = Load : &:r101_3, ~m100_5 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 102| r102_1(glval) = VariableAddress[y] : +# 102| r102_2(glval) = VariableAddress[a] : +# 102| r102_3(glval) = FieldAddress[y] : r102_2 +# 102| r102_4(int) = Load : &:r102_3, ~m100_5 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 103| v103_1(void) = NoOp : +# 100| v100_6(void) = ReturnVoid : +# 100| v100_7(void) = UnmodeledUse : mu* +# 100| v100_8(void) = AliasedUse : ~m100_2 +# 100| v100_9(void) = ExitFunction : # 105| void MustTotallyOverlapEscaped(Point) # 105| Block 0 -# 105| v0_0(void) = EnterFunction : -# 105| m0_1(unknown) = AliasedDefinition : -# 105| mu0_2(unknown) = UnmodeledDefinition : -# 105| r0_3(glval) = VariableAddress[a] : -# 105| m0_4(Point) = InitializeParameter[a] : &:r0_3 -# 105| m0_5(unknown) = Chi : total:m0_1, partial:m0_4 -# 106| r0_6(glval) = VariableAddress[x] : -# 106| r0_7(glval) = VariableAddress[a] : -# 106| r0_8(glval) = FieldAddress[x] : r0_7 -# 106| r0_9(int) = Load : &:r0_8, ~m0_4 -# 106| m0_10(int) = Store : &:r0_6, r0_9 -# 107| r0_11(glval) = VariableAddress[y] : -# 107| r0_12(glval) = VariableAddress[a] : -# 107| r0_13(glval) = FieldAddress[y] : r0_12 -# 107| r0_14(int) = Load : &:r0_13, ~m0_4 -# 107| m0_15(int) = Store : &:r0_11, r0_14 -# 108| r0_16(glval) = FunctionAddress[Escape] : -# 108| r0_17(glval) = VariableAddress[a] : -# 108| r0_18(Point *) = CopyValue : r0_17 -# 108| r0_19(void *) = Convert : r0_18 -# 108| v0_20(void) = Call : func:r0_16, 0:r0_19 -# 108| m0_21(unknown) = ^CallSideEffect : ~m0_5 -# 108| m0_22(unknown) = Chi : total:m0_5, partial:m0_21 -# 108| v0_23(void) = ^BufferReadSideEffect[0] : &:r0_19, ~m0_22 -# 108| m0_24(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_19 -# 108| m0_25(unknown) = Chi : total:m0_22, partial:m0_24 -# 109| v0_26(void) = NoOp : -# 105| v0_27(void) = ReturnVoid : -# 105| v0_28(void) = UnmodeledUse : mu* -# 105| v0_29(void) = AliasedUse : ~m0_22 -# 105| v0_30(void) = ExitFunction : +# 105| v105_1(void) = EnterFunction : +# 105| m105_2(unknown) = AliasedDefinition : +# 105| mu105_3(unknown) = UnmodeledDefinition : +# 105| r105_4(glval) = VariableAddress[a] : +# 105| m105_5(Point) = InitializeParameter[a] : &:r105_4 +# 105| m105_6(unknown) = Chi : total:m105_2, partial:m105_5 +# 106| r106_1(glval) = VariableAddress[x] : +# 106| r106_2(glval) = VariableAddress[a] : +# 106| r106_3(glval) = FieldAddress[x] : r106_2 +# 106| r106_4(int) = Load : &:r106_3, ~m105_5 +# 106| m106_5(int) = Store : &:r106_1, r106_4 +# 107| r107_1(glval) = VariableAddress[y] : +# 107| r107_2(glval) = VariableAddress[a] : +# 107| r107_3(glval) = FieldAddress[y] : r107_2 +# 107| r107_4(int) = Load : &:r107_3, ~m105_5 +# 107| m107_5(int) = Store : &:r107_1, r107_4 +# 108| r108_1(glval) = FunctionAddress[Escape] : +# 108| r108_2(glval) = VariableAddress[a] : +# 108| r108_3(Point *) = CopyValue : r108_2 +# 108| r108_4(void *) = Convert : r108_3 +# 108| v108_5(void) = Call : func:r108_1, 0:r108_4 +# 108| m108_6(unknown) = ^CallSideEffect : ~m105_6 +# 108| m108_7(unknown) = Chi : total:m105_6, partial:m108_6 +# 108| v108_8(void) = ^BufferReadSideEffect[0] : &:r108_4, ~m108_7 +# 108| m108_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r108_4 +# 108| m108_10(unknown) = Chi : total:m108_7, partial:m108_9 +# 109| v109_1(void) = NoOp : +# 105| v105_7(void) = ReturnVoid : +# 105| v105_8(void) = UnmodeledUse : mu* +# 105| v105_9(void) = AliasedUse : ~m108_7 +# 105| v105_10(void) = ExitFunction : # 111| void MayPartiallyOverlap(int, int) # 111| Block 0 -# 111| v0_0(void) = EnterFunction : -# 111| m0_1(unknown) = AliasedDefinition : -# 111| mu0_2(unknown) = UnmodeledDefinition : -# 111| r0_3(glval) = VariableAddress[x] : -# 111| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 111| r0_5(glval) = VariableAddress[y] : -# 111| m0_6(int) = InitializeParameter[y] : &:r0_5 -# 112| r0_7(glval) = VariableAddress[a] : -# 112| m0_8(Point) = Uninitialized[a] : &:r0_7 -# 112| r0_9(glval) = FieldAddress[x] : r0_7 -# 112| r0_10(glval) = VariableAddress[x] : -# 112| r0_11(int) = Load : &:r0_10, m0_4 -# 112| m0_12(int) = Store : &:r0_9, r0_11 -# 112| m0_13(Point) = Chi : total:m0_8, partial:m0_12 -# 112| r0_14(glval) = FieldAddress[y] : r0_7 -# 112| r0_15(glval) = VariableAddress[y] : -# 112| r0_16(int) = Load : &:r0_15, m0_6 -# 112| m0_17(int) = Store : &:r0_14, r0_16 -# 112| m0_18(Point) = Chi : total:m0_13, partial:m0_17 -# 113| r0_19(glval) = VariableAddress[b] : -# 113| r0_20(glval) = VariableAddress[a] : -# 113| r0_21(Point) = Load : &:r0_20, ~m0_18 -# 113| m0_22(Point) = Store : &:r0_19, r0_21 -# 114| v0_23(void) = NoOp : -# 111| v0_24(void) = ReturnVoid : -# 111| v0_25(void) = UnmodeledUse : mu* -# 111| v0_26(void) = AliasedUse : ~m0_1 -# 111| v0_27(void) = ExitFunction : +# 111| v111_1(void) = EnterFunction : +# 111| m111_2(unknown) = AliasedDefinition : +# 111| mu111_3(unknown) = UnmodeledDefinition : +# 111| r111_4(glval) = VariableAddress[x] : +# 111| m111_5(int) = InitializeParameter[x] : &:r111_4 +# 111| r111_6(glval) = VariableAddress[y] : +# 111| m111_7(int) = InitializeParameter[y] : &:r111_6 +# 112| r112_1(glval) = VariableAddress[a] : +# 112| m112_2(Point) = Uninitialized[a] : &:r112_1 +# 112| r112_3(glval) = FieldAddress[x] : r112_1 +# 112| r112_4(glval) = VariableAddress[x] : +# 112| r112_5(int) = Load : &:r112_4, m111_5 +# 112| m112_6(int) = Store : &:r112_3, r112_5 +# 112| m112_7(Point) = Chi : total:m112_2, partial:m112_6 +# 112| r112_8(glval) = FieldAddress[y] : r112_1 +# 112| r112_9(glval) = VariableAddress[y] : +# 112| r112_10(int) = Load : &:r112_9, m111_7 +# 112| m112_11(int) = Store : &:r112_8, r112_10 +# 112| m112_12(Point) = Chi : total:m112_7, partial:m112_11 +# 113| r113_1(glval) = VariableAddress[b] : +# 113| r113_2(glval) = VariableAddress[a] : +# 113| r113_3(Point) = Load : &:r113_2, ~m112_12 +# 113| m113_4(Point) = Store : &:r113_1, r113_3 +# 114| v114_1(void) = NoOp : +# 111| v111_8(void) = ReturnVoid : +# 111| v111_9(void) = UnmodeledUse : mu* +# 111| v111_10(void) = AliasedUse : ~m111_2 +# 111| v111_11(void) = ExitFunction : # 116| void MayPartiallyOverlapEscaped(int, int) # 116| Block 0 -# 116| v0_0(void) = EnterFunction : -# 116| m0_1(unknown) = AliasedDefinition : -# 116| mu0_2(unknown) = UnmodeledDefinition : -# 116| r0_3(glval) = VariableAddress[x] : -# 116| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 116| r0_5(glval) = VariableAddress[y] : -# 116| m0_6(int) = InitializeParameter[y] : &:r0_5 -# 117| r0_7(glval) = VariableAddress[a] : -# 117| m0_8(Point) = Uninitialized[a] : &:r0_7 -# 117| m0_9(unknown) = Chi : total:m0_1, partial:m0_8 -# 117| r0_10(glval) = FieldAddress[x] : r0_7 -# 117| r0_11(glval) = VariableAddress[x] : -# 117| r0_12(int) = Load : &:r0_11, m0_4 -# 117| m0_13(int) = Store : &:r0_10, r0_12 -# 117| m0_14(unknown) = Chi : total:m0_9, partial:m0_13 -# 117| r0_15(glval) = FieldAddress[y] : r0_7 -# 117| r0_16(glval) = VariableAddress[y] : -# 117| r0_17(int) = Load : &:r0_16, m0_6 -# 117| m0_18(int) = Store : &:r0_15, r0_17 -# 117| m0_19(unknown) = Chi : total:m0_14, partial:m0_18 -# 118| r0_20(glval) = VariableAddress[b] : -# 118| r0_21(glval) = VariableAddress[a] : -# 118| r0_22(Point) = Load : &:r0_21, ~m0_19 -# 118| m0_23(Point) = Store : &:r0_20, r0_22 -# 119| r0_24(glval) = FunctionAddress[Escape] : -# 119| r0_25(glval) = VariableAddress[a] : -# 119| r0_26(Point *) = CopyValue : r0_25 -# 119| r0_27(void *) = Convert : r0_26 -# 119| v0_28(void) = Call : func:r0_24, 0:r0_27 -# 119| m0_29(unknown) = ^CallSideEffect : ~m0_19 -# 119| m0_30(unknown) = Chi : total:m0_19, partial:m0_29 -# 119| v0_31(void) = ^BufferReadSideEffect[0] : &:r0_27, ~m0_30 -# 119| m0_32(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_27 -# 119| m0_33(unknown) = Chi : total:m0_30, partial:m0_32 -# 120| v0_34(void) = NoOp : -# 116| v0_35(void) = ReturnVoid : -# 116| v0_36(void) = UnmodeledUse : mu* -# 116| v0_37(void) = AliasedUse : ~m0_30 -# 116| v0_38(void) = ExitFunction : +# 116| v116_1(void) = EnterFunction : +# 116| m116_2(unknown) = AliasedDefinition : +# 116| mu116_3(unknown) = UnmodeledDefinition : +# 116| r116_4(glval) = VariableAddress[x] : +# 116| m116_5(int) = InitializeParameter[x] : &:r116_4 +# 116| r116_6(glval) = VariableAddress[y] : +# 116| m116_7(int) = InitializeParameter[y] : &:r116_6 +# 117| r117_1(glval) = VariableAddress[a] : +# 117| m117_2(Point) = Uninitialized[a] : &:r117_1 +# 117| m117_3(unknown) = Chi : total:m116_2, partial:m117_2 +# 117| r117_4(glval) = FieldAddress[x] : r117_1 +# 117| r117_5(glval) = VariableAddress[x] : +# 117| r117_6(int) = Load : &:r117_5, m116_5 +# 117| m117_7(int) = Store : &:r117_4, r117_6 +# 117| m117_8(unknown) = Chi : total:m117_3, partial:m117_7 +# 117| r117_9(glval) = FieldAddress[y] : r117_1 +# 117| r117_10(glval) = VariableAddress[y] : +# 117| r117_11(int) = Load : &:r117_10, m116_7 +# 117| m117_12(int) = Store : &:r117_9, r117_11 +# 117| m117_13(unknown) = Chi : total:m117_8, partial:m117_12 +# 118| r118_1(glval) = VariableAddress[b] : +# 118| r118_2(glval) = VariableAddress[a] : +# 118| r118_3(Point) = Load : &:r118_2, ~m117_13 +# 118| m118_4(Point) = Store : &:r118_1, r118_3 +# 119| r119_1(glval) = FunctionAddress[Escape] : +# 119| r119_2(glval) = VariableAddress[a] : +# 119| r119_3(Point *) = CopyValue : r119_2 +# 119| r119_4(void *) = Convert : r119_3 +# 119| v119_5(void) = Call : func:r119_1, 0:r119_4 +# 119| m119_6(unknown) = ^CallSideEffect : ~m117_13 +# 119| m119_7(unknown) = Chi : total:m117_13, partial:m119_6 +# 119| v119_8(void) = ^BufferReadSideEffect[0] : &:r119_4, ~m119_7 +# 119| m119_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r119_4 +# 119| m119_10(unknown) = Chi : total:m119_7, partial:m119_9 +# 120| v120_1(void) = NoOp : +# 116| v116_8(void) = ReturnVoid : +# 116| v116_9(void) = UnmodeledUse : mu* +# 116| v116_10(void) = AliasedUse : ~m119_7 +# 116| v116_11(void) = ExitFunction : # 122| void MergeMustExactlyOverlap(bool, int, int) # 122| Block 0 -# 122| v0_0(void) = EnterFunction : -# 122| m0_1(unknown) = AliasedDefinition : -# 122| mu0_2(unknown) = UnmodeledDefinition : -# 122| r0_3(glval) = VariableAddress[c] : -# 122| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 122| r0_5(glval) = VariableAddress[x1] : -# 122| m0_6(int) = InitializeParameter[x1] : &:r0_5 -# 122| r0_7(glval) = VariableAddress[x2] : -# 122| m0_8(int) = InitializeParameter[x2] : &:r0_7 -# 123| r0_9(glval) = VariableAddress[a] : -# 123| m0_10(Point) = Uninitialized[a] : &:r0_9 -# 123| r0_11(glval) = FieldAddress[x] : r0_9 -# 123| r0_12(int) = Constant[0] : -# 123| m0_13(int) = Store : &:r0_11, r0_12 -# 123| m0_14(Point) = Chi : total:m0_10, partial:m0_13 -# 123| r0_15(glval) = FieldAddress[y] : r0_9 -# 123| r0_16(int) = Constant[0] : -# 123| m0_17(int) = Store : &:r0_15, r0_16 -# 123| m0_18(Point) = Chi : total:m0_14, partial:m0_17 -# 124| r0_19(glval) = VariableAddress[c] : -# 124| r0_20(bool) = Load : &:r0_19, m0_4 -# 124| v0_21(void) = ConditionalBranch : r0_20 +# 122| v122_1(void) = EnterFunction : +# 122| m122_2(unknown) = AliasedDefinition : +# 122| mu122_3(unknown) = UnmodeledDefinition : +# 122| r122_4(glval) = VariableAddress[c] : +# 122| m122_5(bool) = InitializeParameter[c] : &:r122_4 +# 122| r122_6(glval) = VariableAddress[x1] : +# 122| m122_7(int) = InitializeParameter[x1] : &:r122_6 +# 122| r122_8(glval) = VariableAddress[x2] : +# 122| m122_9(int) = InitializeParameter[x2] : &:r122_8 +# 123| r123_1(glval) = VariableAddress[a] : +# 123| m123_2(Point) = Uninitialized[a] : &:r123_1 +# 123| r123_3(glval) = FieldAddress[x] : r123_1 +# 123| r123_4(int) = Constant[0] : +# 123| m123_5(int) = Store : &:r123_3, r123_4 +# 123| m123_6(Point) = Chi : total:m123_2, partial:m123_5 +# 123| r123_7(glval) = FieldAddress[y] : r123_1 +# 123| r123_8(int) = Constant[0] : +# 123| m123_9(int) = Store : &:r123_7, r123_8 +# 123| m123_10(Point) = Chi : total:m123_6, partial:m123_9 +# 124| r124_1(glval) = VariableAddress[c] : +# 124| r124_2(bool) = Load : &:r124_1, m122_5 +# 124| v124_3(void) = ConditionalBranch : r124_2 #-----| False -> Block 2 #-----| True -> Block 1 # 125| Block 1 -# 125| r1_0(glval) = VariableAddress[x1] : -# 125| r1_1(int) = Load : &:r1_0, m0_6 -# 125| r1_2(glval) = VariableAddress[a] : -# 125| r1_3(glval) = FieldAddress[x] : r1_2 -# 125| m1_4(int) = Store : &:r1_3, r1_1 -# 125| m1_5(Point) = Chi : total:m0_18, partial:m1_4 +# 125| r125_1(glval) = VariableAddress[x1] : +# 125| r125_2(int) = Load : &:r125_1, m122_7 +# 125| r125_3(glval) = VariableAddress[a] : +# 125| r125_4(glval) = FieldAddress[x] : r125_3 +# 125| m125_5(int) = Store : &:r125_4, r125_2 +# 125| m125_6(Point) = Chi : total:m123_10, partial:m125_5 #-----| Goto -> Block 3 # 128| Block 2 -# 128| r2_0(glval) = VariableAddress[x2] : -# 128| r2_1(int) = Load : &:r2_0, m0_8 -# 128| r2_2(glval) = VariableAddress[a] : -# 128| r2_3(glval) = FieldAddress[x] : r2_2 -# 128| m2_4(int) = Store : &:r2_3, r2_1 -# 128| m2_5(Point) = Chi : total:m0_18, partial:m2_4 +# 128| r128_1(glval) = VariableAddress[x2] : +# 128| r128_2(int) = Load : &:r128_1, m122_9 +# 128| r128_3(glval) = VariableAddress[a] : +# 128| r128_4(glval) = FieldAddress[x] : r128_3 +# 128| m128_5(int) = Store : &:r128_4, r128_2 +# 128| m128_6(Point) = Chi : total:m123_10, partial:m128_5 #-----| Goto -> Block 3 # 130| Block 3 -# 130| m3_0(Point) = Phi : from 1:m1_5, from 2:m2_5 -# 130| m3_1(int) = Phi : from 1:m1_4, from 2:m2_4 -# 130| r3_2(glval) = VariableAddress[x] : -# 130| r3_3(glval) = VariableAddress[a] : -# 130| r3_4(glval) = FieldAddress[x] : r3_3 -# 130| r3_5(int) = Load : &:r3_4, m3_1 -# 130| m3_6(int) = Store : &:r3_2, r3_5 -# 131| r3_7(glval) = VariableAddress[b] : -# 131| r3_8(glval) = VariableAddress[a] : -# 131| r3_9(Point) = Load : &:r3_8, m3_0 -# 131| m3_10(Point) = Store : &:r3_7, r3_9 -# 132| v3_11(void) = NoOp : -# 122| v3_12(void) = ReturnVoid : -# 122| v3_13(void) = UnmodeledUse : mu* -# 122| v3_14(void) = AliasedUse : ~m0_1 -# 122| v3_15(void) = ExitFunction : +# 130| m130_1(int) = Phi : from 1:m125_5, from 2:m128_5 +# 130| m130_2(Point) = Phi : from 1:m125_6, from 2:m128_6 +# 130| r130_3(glval) = VariableAddress[x] : +# 130| r130_4(glval) = VariableAddress[a] : +# 130| r130_5(glval) = FieldAddress[x] : r130_4 +# 130| r130_6(int) = Load : &:r130_5, m130_1 +# 130| m130_7(int) = Store : &:r130_3, r130_6 +# 131| r131_1(glval) = VariableAddress[b] : +# 131| r131_2(glval) = VariableAddress[a] : +# 131| r131_3(Point) = Load : &:r131_2, m130_2 +# 131| m131_4(Point) = Store : &:r131_1, r131_3 +# 132| v132_1(void) = NoOp : +# 122| v122_10(void) = ReturnVoid : +# 122| v122_11(void) = UnmodeledUse : mu* +# 122| v122_12(void) = AliasedUse : ~m122_2 +# 122| v122_13(void) = ExitFunction : # 134| void MergeMustExactlyWithMustTotallyOverlap(bool, Point, int) # 134| Block 0 -# 134| v0_0(void) = EnterFunction : -# 134| m0_1(unknown) = AliasedDefinition : -# 134| mu0_2(unknown) = UnmodeledDefinition : -# 134| r0_3(glval) = VariableAddress[c] : -# 134| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 134| r0_5(glval) = VariableAddress[p] : -# 134| m0_6(Point) = InitializeParameter[p] : &:r0_5 -# 134| r0_7(glval) = VariableAddress[x1] : -# 134| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 135| r0_9(glval) = VariableAddress[a] : -# 135| m0_10(Point) = Uninitialized[a] : &:r0_9 -# 135| r0_11(glval) = FieldAddress[x] : r0_9 -# 135| r0_12(int) = Constant[0] : -# 135| m0_13(int) = Store : &:r0_11, r0_12 -# 135| m0_14(Point) = Chi : total:m0_10, partial:m0_13 -# 135| r0_15(glval) = FieldAddress[y] : r0_9 -# 135| r0_16(int) = Constant[0] : -# 135| m0_17(int) = Store : &:r0_15, r0_16 -# 135| m0_18(Point) = Chi : total:m0_14, partial:m0_17 -# 136| r0_19(glval) = VariableAddress[c] : -# 136| r0_20(bool) = Load : &:r0_19, m0_4 -# 136| v0_21(void) = ConditionalBranch : r0_20 +# 134| v134_1(void) = EnterFunction : +# 134| m134_2(unknown) = AliasedDefinition : +# 134| mu134_3(unknown) = UnmodeledDefinition : +# 134| r134_4(glval) = VariableAddress[c] : +# 134| m134_5(bool) = InitializeParameter[c] : &:r134_4 +# 134| r134_6(glval) = VariableAddress[p] : +# 134| m134_7(Point) = InitializeParameter[p] : &:r134_6 +# 134| r134_8(glval) = VariableAddress[x1] : +# 134| m134_9(int) = InitializeParameter[x1] : &:r134_8 +# 135| r135_1(glval) = VariableAddress[a] : +# 135| m135_2(Point) = Uninitialized[a] : &:r135_1 +# 135| r135_3(glval) = FieldAddress[x] : r135_1 +# 135| r135_4(int) = Constant[0] : +# 135| m135_5(int) = Store : &:r135_3, r135_4 +# 135| m135_6(Point) = Chi : total:m135_2, partial:m135_5 +# 135| r135_7(glval) = FieldAddress[y] : r135_1 +# 135| r135_8(int) = Constant[0] : +# 135| m135_9(int) = Store : &:r135_7, r135_8 +# 135| m135_10(Point) = Chi : total:m135_6, partial:m135_9 +# 136| r136_1(glval) = VariableAddress[c] : +# 136| r136_2(bool) = Load : &:r136_1, m134_5 +# 136| v136_3(void) = ConditionalBranch : r136_2 #-----| False -> Block 2 #-----| True -> Block 1 # 137| Block 1 -# 137| r1_0(glval) = VariableAddress[x1] : -# 137| r1_1(int) = Load : &:r1_0, m0_8 -# 137| r1_2(glval) = VariableAddress[a] : -# 137| r1_3(glval) = FieldAddress[x] : r1_2 -# 137| m1_4(int) = Store : &:r1_3, r1_1 -# 137| m1_5(Point) = Chi : total:m0_18, partial:m1_4 +# 137| r137_1(glval) = VariableAddress[x1] : +# 137| r137_2(int) = Load : &:r137_1, m134_9 +# 137| r137_3(glval) = VariableAddress[a] : +# 137| r137_4(glval) = FieldAddress[x] : r137_3 +# 137| m137_5(int) = Store : &:r137_4, r137_2 +# 137| m137_6(Point) = Chi : total:m135_10, partial:m137_5 #-----| Goto -> Block 3 # 140| Block 2 -# 140| r2_0(glval) = VariableAddress[p] : -# 140| r2_1(Point) = Load : &:r2_0, m0_6 -# 140| r2_2(glval) = VariableAddress[a] : -# 140| m2_3(Point) = Store : &:r2_2, r2_1 +# 140| r140_1(glval) = VariableAddress[p] : +# 140| r140_2(Point) = Load : &:r140_1, m134_7 +# 140| r140_3(glval) = VariableAddress[a] : +# 140| m140_4(Point) = Store : &:r140_3, r140_2 #-----| Goto -> Block 3 # 142| Block 3 -# 142| m3_0(Point) = Phi : from 1:m1_5, from 2:m2_3 -# 142| m3_1(int) = Phi : from 1:m1_4, from 2:~m2_3 -# 142| r3_2(glval) = VariableAddress[x] : -# 142| r3_3(glval) = VariableAddress[a] : -# 142| r3_4(glval) = FieldAddress[x] : r3_3 -# 142| r3_5(int) = Load : &:r3_4, m3_1 -# 142| m3_6(int) = Store : &:r3_2, r3_5 -# 143| v3_7(void) = NoOp : -# 134| v3_8(void) = ReturnVoid : -# 134| v3_9(void) = UnmodeledUse : mu* -# 134| v3_10(void) = AliasedUse : ~m0_1 -# 134| v3_11(void) = ExitFunction : +# 142| m142_1(int) = Phi : from 1:m137_5, from 2:~m140_4 +# 142| m142_2(Point) = Phi : from 1:m137_6, from 2:m140_4 +# 142| r142_3(glval) = VariableAddress[x] : +# 142| r142_4(glval) = VariableAddress[a] : +# 142| r142_5(glval) = FieldAddress[x] : r142_4 +# 142| r142_6(int) = Load : &:r142_5, m142_1 +# 142| m142_7(int) = Store : &:r142_3, r142_6 +# 143| v143_1(void) = NoOp : +# 134| v134_10(void) = ReturnVoid : +# 134| v134_11(void) = UnmodeledUse : mu* +# 134| v134_12(void) = AliasedUse : ~m134_2 +# 134| v134_13(void) = ExitFunction : # 145| void MergeMustExactlyWithMayPartiallyOverlap(bool, Point, int) # 145| Block 0 -# 145| v0_0(void) = EnterFunction : -# 145| m0_1(unknown) = AliasedDefinition : -# 145| mu0_2(unknown) = UnmodeledDefinition : -# 145| r0_3(glval) = VariableAddress[c] : -# 145| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 145| r0_5(glval) = VariableAddress[p] : -# 145| m0_6(Point) = InitializeParameter[p] : &:r0_5 -# 145| r0_7(glval) = VariableAddress[x1] : -# 145| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 146| r0_9(glval) = VariableAddress[a] : -# 146| m0_10(Point) = Uninitialized[a] : &:r0_9 -# 146| r0_11(glval) = FieldAddress[x] : r0_9 -# 146| r0_12(int) = Constant[0] : -# 146| m0_13(int) = Store : &:r0_11, r0_12 -# 146| m0_14(Point) = Chi : total:m0_10, partial:m0_13 -# 146| r0_15(glval) = FieldAddress[y] : r0_9 -# 146| r0_16(int) = Constant[0] : -# 146| m0_17(int) = Store : &:r0_15, r0_16 -# 146| m0_18(Point) = Chi : total:m0_14, partial:m0_17 -# 147| r0_19(glval) = VariableAddress[c] : -# 147| r0_20(bool) = Load : &:r0_19, m0_4 -# 147| v0_21(void) = ConditionalBranch : r0_20 +# 145| v145_1(void) = EnterFunction : +# 145| m145_2(unknown) = AliasedDefinition : +# 145| mu145_3(unknown) = UnmodeledDefinition : +# 145| r145_4(glval) = VariableAddress[c] : +# 145| m145_5(bool) = InitializeParameter[c] : &:r145_4 +# 145| r145_6(glval) = VariableAddress[p] : +# 145| m145_7(Point) = InitializeParameter[p] : &:r145_6 +# 145| r145_8(glval) = VariableAddress[x1] : +# 145| m145_9(int) = InitializeParameter[x1] : &:r145_8 +# 146| r146_1(glval) = VariableAddress[a] : +# 146| m146_2(Point) = Uninitialized[a] : &:r146_1 +# 146| r146_3(glval) = FieldAddress[x] : r146_1 +# 146| r146_4(int) = Constant[0] : +# 146| m146_5(int) = Store : &:r146_3, r146_4 +# 146| m146_6(Point) = Chi : total:m146_2, partial:m146_5 +# 146| r146_7(glval) = FieldAddress[y] : r146_1 +# 146| r146_8(int) = Constant[0] : +# 146| m146_9(int) = Store : &:r146_7, r146_8 +# 146| m146_10(Point) = Chi : total:m146_6, partial:m146_9 +# 147| r147_1(glval) = VariableAddress[c] : +# 147| r147_2(bool) = Load : &:r147_1, m145_5 +# 147| v147_3(void) = ConditionalBranch : r147_2 #-----| False -> Block 2 #-----| True -> Block 1 # 148| Block 1 -# 148| r1_0(glval) = VariableAddress[x1] : -# 148| r1_1(int) = Load : &:r1_0, m0_8 -# 148| r1_2(glval) = VariableAddress[a] : -# 148| r1_3(glval) = FieldAddress[x] : r1_2 -# 148| m1_4(int) = Store : &:r1_3, r1_1 -# 148| m1_5(Point) = Chi : total:m0_18, partial:m1_4 +# 148| r148_1(glval) = VariableAddress[x1] : +# 148| r148_2(int) = Load : &:r148_1, m145_9 +# 148| r148_3(glval) = VariableAddress[a] : +# 148| r148_4(glval) = FieldAddress[x] : r148_3 +# 148| m148_5(int) = Store : &:r148_4, r148_2 +# 148| m148_6(Point) = Chi : total:m146_10, partial:m148_5 #-----| Goto -> Block 3 # 151| Block 2 -# 151| r2_0(glval) = VariableAddress[p] : -# 151| r2_1(Point) = Load : &:r2_0, m0_6 -# 151| r2_2(glval) = VariableAddress[a] : -# 151| m2_3(Point) = Store : &:r2_2, r2_1 +# 151| r151_1(glval) = VariableAddress[p] : +# 151| r151_2(Point) = Load : &:r151_1, m145_7 +# 151| r151_3(glval) = VariableAddress[a] : +# 151| m151_4(Point) = Store : &:r151_3, r151_2 #-----| Goto -> Block 3 # 153| Block 3 -# 153| m3_0(Point) = Phi : from 1:m1_5, from 2:m2_3 -# 153| r3_1(glval) = VariableAddress[b] : -# 153| r3_2(glval) = VariableAddress[a] : -# 153| r3_3(Point) = Load : &:r3_2, m3_0 -# 153| m3_4(Point) = Store : &:r3_1, r3_3 -# 154| v3_5(void) = NoOp : -# 145| v3_6(void) = ReturnVoid : -# 145| v3_7(void) = UnmodeledUse : mu* -# 145| v3_8(void) = AliasedUse : ~m0_1 -# 145| v3_9(void) = ExitFunction : +# 153| m153_1(Point) = Phi : from 1:m148_6, from 2:m151_4 +# 153| r153_2(glval) = VariableAddress[b] : +# 153| r153_3(glval) = VariableAddress[a] : +# 153| r153_4(Point) = Load : &:r153_3, m153_1 +# 153| m153_5(Point) = Store : &:r153_2, r153_4 +# 154| v154_1(void) = NoOp : +# 145| v145_10(void) = ReturnVoid : +# 145| v145_11(void) = UnmodeledUse : mu* +# 145| v145_12(void) = AliasedUse : ~m145_2 +# 145| v145_13(void) = ExitFunction : # 156| void MergeMustTotallyOverlapWithMayPartiallyOverlap(bool, Rect, int) # 156| Block 0 -# 156| v0_0(void) = EnterFunction : -# 156| m0_1(unknown) = AliasedDefinition : -# 156| mu0_2(unknown) = UnmodeledDefinition : -# 156| r0_3(glval) = VariableAddress[c] : -# 156| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 156| r0_5(glval) = VariableAddress[r] : -# 156| m0_6(Rect) = InitializeParameter[r] : &:r0_5 -# 156| r0_7(glval) = VariableAddress[x1] : -# 156| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 157| r0_9(glval) = VariableAddress[a] : -# 157| m0_10(Rect) = Uninitialized[a] : &:r0_9 -# 157| r0_11(glval) = FieldAddress[topLeft] : r0_9 -# 157| r0_12(Point) = Constant[0] : -# 157| m0_13(Point) = Store : &:r0_11, r0_12 -# 157| m0_14(Rect) = Chi : total:m0_10, partial:m0_13 -# 157| r0_15(glval) = FieldAddress[bottomRight] : r0_9 -# 157| r0_16(Point) = Constant[0] : -# 157| m0_17(Point) = Store : &:r0_15, r0_16 -# 157| m0_18(Rect) = Chi : total:m0_14, partial:m0_17 -# 158| r0_19(glval) = VariableAddress[c] : -# 158| r0_20(bool) = Load : &:r0_19, m0_4 -# 158| v0_21(void) = ConditionalBranch : r0_20 +# 156| v156_1(void) = EnterFunction : +# 156| m156_2(unknown) = AliasedDefinition : +# 156| mu156_3(unknown) = UnmodeledDefinition : +# 156| r156_4(glval) = VariableAddress[c] : +# 156| m156_5(bool) = InitializeParameter[c] : &:r156_4 +# 156| r156_6(glval) = VariableAddress[r] : +# 156| m156_7(Rect) = InitializeParameter[r] : &:r156_6 +# 156| r156_8(glval) = VariableAddress[x1] : +# 156| m156_9(int) = InitializeParameter[x1] : &:r156_8 +# 157| r157_1(glval) = VariableAddress[a] : +# 157| m157_2(Rect) = Uninitialized[a] : &:r157_1 +# 157| r157_3(glval) = FieldAddress[topLeft] : r157_1 +# 157| r157_4(Point) = Constant[0] : +# 157| m157_5(Point) = Store : &:r157_3, r157_4 +# 157| m157_6(Rect) = Chi : total:m157_2, partial:m157_5 +# 157| r157_7(glval) = FieldAddress[bottomRight] : r157_1 +# 157| r157_8(Point) = Constant[0] : +# 157| m157_9(Point) = Store : &:r157_7, r157_8 +# 157| m157_10(Rect) = Chi : total:m157_6, partial:m157_9 +# 158| r158_1(glval) = VariableAddress[c] : +# 158| r158_2(bool) = Load : &:r158_1, m156_5 +# 158| v158_3(void) = ConditionalBranch : r158_2 #-----| False -> Block 2 #-----| True -> Block 1 # 159| Block 1 -# 159| r1_0(glval) = VariableAddress[x1] : -# 159| r1_1(int) = Load : &:r1_0, m0_8 -# 159| r1_2(glval) = VariableAddress[a] : -# 159| r1_3(glval) = FieldAddress[topLeft] : r1_2 -# 159| r1_4(glval) = FieldAddress[x] : r1_3 -# 159| m1_5(int) = Store : &:r1_4, r1_1 -# 159| m1_6(Rect) = Chi : total:m0_18, partial:m1_5 +# 159| r159_1(glval) = VariableAddress[x1] : +# 159| r159_2(int) = Load : &:r159_1, m156_9 +# 159| r159_3(glval) = VariableAddress[a] : +# 159| r159_4(glval) = FieldAddress[topLeft] : r159_3 +# 159| r159_5(glval) = FieldAddress[x] : r159_4 +# 159| m159_6(int) = Store : &:r159_5, r159_2 +# 159| m159_7(Rect) = Chi : total:m157_10, partial:m159_6 #-----| Goto -> Block 3 # 162| Block 2 -# 162| r2_0(glval) = VariableAddress[r] : -# 162| r2_1(Rect) = Load : &:r2_0, m0_6 -# 162| r2_2(glval) = VariableAddress[a] : -# 162| m2_3(Rect) = Store : &:r2_2, r2_1 +# 162| r162_1(glval) = VariableAddress[r] : +# 162| r162_2(Rect) = Load : &:r162_1, m156_7 +# 162| r162_3(glval) = VariableAddress[a] : +# 162| m162_4(Rect) = Store : &:r162_3, r162_2 #-----| Goto -> Block 3 # 164| Block 3 -# 164| m3_0(Rect) = Phi : from 1:m1_6, from 2:m2_3 -# 164| r3_1(glval) = VariableAddress[b] : -# 164| r3_2(glval) = VariableAddress[a] : -# 164| r3_3(glval) = FieldAddress[topLeft] : r3_2 -# 164| r3_4(Point) = Load : &:r3_3, ~m3_0 -# 164| m3_5(Point) = Store : &:r3_1, r3_4 -# 165| v3_6(void) = NoOp : -# 156| v3_7(void) = ReturnVoid : -# 156| v3_8(void) = UnmodeledUse : mu* -# 156| v3_9(void) = AliasedUse : ~m0_1 -# 156| v3_10(void) = ExitFunction : +# 164| m164_1(Rect) = Phi : from 1:m159_7, from 2:m162_4 +# 164| r164_2(glval) = VariableAddress[b] : +# 164| r164_3(glval) = VariableAddress[a] : +# 164| r164_4(glval) = FieldAddress[topLeft] : r164_3 +# 164| r164_5(Point) = Load : &:r164_4, ~m164_1 +# 164| m164_6(Point) = Store : &:r164_2, r164_5 +# 165| v165_1(void) = NoOp : +# 156| v156_10(void) = ReturnVoid : +# 156| v156_11(void) = UnmodeledUse : mu* +# 156| v156_12(void) = AliasedUse : ~m156_2 +# 156| v156_13(void) = ExitFunction : # 171| void WrapperStruct(Wrapper) # 171| Block 0 -# 171| v0_0(void) = EnterFunction : -# 171| m0_1(unknown) = AliasedDefinition : -# 171| mu0_2(unknown) = UnmodeledDefinition : -# 171| r0_3(glval) = VariableAddress[w] : -# 171| m0_4(Wrapper) = InitializeParameter[w] : &:r0_3 -# 172| r0_5(glval) = VariableAddress[x] : -# 172| r0_6(glval) = VariableAddress[w] : -# 172| r0_7(Wrapper) = Load : &:r0_6, m0_4 -# 172| m0_8(Wrapper) = Store : &:r0_5, r0_7 -# 173| r0_9(glval) = VariableAddress[a] : -# 173| r0_10(glval) = VariableAddress[w] : -# 173| r0_11(glval) = FieldAddress[f] : r0_10 -# 173| r0_12(int) = Load : &:r0_11, ~m0_4 -# 173| m0_13(int) = Store : &:r0_9, r0_12 -# 174| r0_14(int) = Constant[5] : -# 174| r0_15(glval) = VariableAddress[w] : -# 174| r0_16(glval) = FieldAddress[f] : r0_15 -# 174| m0_17(int) = Store : &:r0_16, r0_14 -# 175| r0_18(glval) = VariableAddress[w] : -# 175| r0_19(glval) = FieldAddress[f] : r0_18 -# 175| r0_20(int) = Load : &:r0_19, m0_17 -# 175| r0_21(glval) = VariableAddress[a] : -# 175| m0_22(int) = Store : &:r0_21, r0_20 -# 176| r0_23(glval) = VariableAddress[w] : -# 176| r0_24(Wrapper) = Load : &:r0_23, ~m0_17 -# 176| r0_25(glval) = VariableAddress[x] : -# 176| m0_26(Wrapper) = Store : &:r0_25, r0_24 -# 177| v0_27(void) = NoOp : -# 171| v0_28(void) = ReturnVoid : -# 171| v0_29(void) = UnmodeledUse : mu* -# 171| v0_30(void) = AliasedUse : ~m0_1 -# 171| v0_31(void) = ExitFunction : +# 171| v171_1(void) = EnterFunction : +# 171| m171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[w] : +# 171| m171_5(Wrapper) = InitializeParameter[w] : &:r171_4 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| r172_2(glval) = VariableAddress[w] : +# 172| r172_3(Wrapper) = Load : &:r172_2, m171_5 +# 172| m172_4(Wrapper) = Store : &:r172_1, r172_3 +# 173| r173_1(glval) = VariableAddress[a] : +# 173| r173_2(glval) = VariableAddress[w] : +# 173| r173_3(glval) = FieldAddress[f] : r173_2 +# 173| r173_4(int) = Load : &:r173_3, ~m171_5 +# 173| m173_5(int) = Store : &:r173_1, r173_4 +# 174| r174_1(int) = Constant[5] : +# 174| r174_2(glval) = VariableAddress[w] : +# 174| r174_3(glval) = FieldAddress[f] : r174_2 +# 174| m174_4(int) = Store : &:r174_3, r174_1 +# 175| r175_1(glval) = VariableAddress[w] : +# 175| r175_2(glval) = FieldAddress[f] : r175_1 +# 175| r175_3(int) = Load : &:r175_2, m174_4 +# 175| r175_4(glval) = VariableAddress[a] : +# 175| m175_5(int) = Store : &:r175_4, r175_3 +# 176| r176_1(glval) = VariableAddress[w] : +# 176| r176_2(Wrapper) = Load : &:r176_1, ~m174_4 +# 176| r176_3(glval) = VariableAddress[x] : +# 176| m176_4(Wrapper) = Store : &:r176_3, r176_2 +# 177| v177_1(void) = NoOp : +# 171| v171_6(void) = ReturnVoid : +# 171| v171_7(void) = UnmodeledUse : mu* +# 171| v171_8(void) = AliasedUse : ~m171_2 +# 171| v171_9(void) = ExitFunction : # 179| int AsmStmt(int*) # 179| Block 0 -# 179| v0_0(void) = EnterFunction : -# 179| m0_1(unknown) = AliasedDefinition : -# 179| mu0_2(unknown) = UnmodeledDefinition : -# 179| r0_3(glval) = VariableAddress[p] : -# 179| m0_4(int *) = InitializeParameter[p] : &:r0_3 -# 180| m0_5(unknown) = InlineAsm : ~mu0_2 -# 180| m0_6(unknown) = Chi : total:m0_1, partial:m0_5 -# 181| r0_7(glval) = VariableAddress[#return] : -# 181| r0_8(glval) = VariableAddress[p] : -# 181| r0_9(int *) = Load : &:r0_8, m0_4 -# 181| r0_10(int) = Load : &:r0_9, ~m0_6 -# 181| m0_11(int) = Store : &:r0_7, r0_10 -# 179| r0_12(glval) = VariableAddress[#return] : -# 179| v0_13(void) = ReturnValue : &:r0_12, m0_11 -# 179| v0_14(void) = UnmodeledUse : mu* -# 179| v0_15(void) = AliasedUse : ~m0_6 -# 179| v0_16(void) = ExitFunction : +# 179| v179_1(void) = EnterFunction : +# 179| m179_2(unknown) = AliasedDefinition : +# 179| mu179_3(unknown) = UnmodeledDefinition : +# 179| r179_4(glval) = VariableAddress[p] : +# 179| m179_5(int *) = InitializeParameter[p] : &:r179_4 +# 180| m180_1(unknown) = InlineAsm : ~mu179_3 +# 180| m180_2(unknown) = Chi : total:m179_2, partial:m180_1 +# 181| r181_1(glval) = VariableAddress[#return] : +# 181| r181_2(glval) = VariableAddress[p] : +# 181| r181_3(int *) = Load : &:r181_2, m179_5 +# 181| r181_4(int) = Load : &:r181_3, ~m180_2 +# 181| m181_5(int) = Store : &:r181_1, r181_4 +# 179| r179_6(glval) = VariableAddress[#return] : +# 179| v179_7(void) = ReturnValue : &:r179_6, m181_5 +# 179| v179_8(void) = UnmodeledUse : mu* +# 179| v179_9(void) = AliasedUse : ~m180_2 +# 179| v179_10(void) = ExitFunction : # 184| void AsmStmtWithOutputs(unsigned int&, unsigned int&, unsigned int&, unsigned int&) # 184| Block 0 -# 184| v0_0(void) = EnterFunction : -# 184| m0_1(unknown) = AliasedDefinition : -# 184| mu0_2(unknown) = UnmodeledDefinition : -# 184| r0_3(glval) = VariableAddress[a] : -# 184| m0_4(unsigned int &) = InitializeParameter[a] : &:r0_3 -# 184| r0_5(glval) = VariableAddress[b] : -# 184| m0_6(unsigned int &) = InitializeParameter[b] : &:r0_5 -# 184| r0_7(glval) = VariableAddress[c] : -# 184| m0_8(unsigned int &) = InitializeParameter[c] : &:r0_7 -# 184| r0_9(glval) = VariableAddress[d] : -# 184| m0_10(unsigned int &) = InitializeParameter[d] : &:r0_9 -# 189| r0_11(glval) = VariableAddress[a] : -# 189| r0_12(unsigned int &) = Load : &:r0_11, m0_4 -# 189| r0_13(glval) = CopyValue : r0_12 -# 189| r0_14(glval) = VariableAddress[b] : -# 189| r0_15(unsigned int &) = Load : &:r0_14, m0_6 -# 189| r0_16(glval) = CopyValue : r0_15 -# 190| r0_17(glval) = VariableAddress[c] : -# 190| r0_18(unsigned int &) = Load : &:r0_17, m0_8 -# 190| r0_19(unsigned int) = Load : &:r0_18, ~m0_1 -# 190| r0_20(glval) = VariableAddress[d] : -# 190| r0_21(unsigned int &) = Load : &:r0_20, m0_10 -# 190| r0_22(unsigned int) = Load : &:r0_21, ~m0_1 -# 186| m0_23(unknown) = InlineAsm : ~mu0_2, 0:r0_13, 1:r0_16, 2:r0_19, 3:r0_22 -# 186| m0_24(unknown) = Chi : total:m0_1, partial:m0_23 -# 192| v0_25(void) = NoOp : -# 184| v0_26(void) = ReturnVoid : -# 184| v0_27(void) = UnmodeledUse : mu* -# 184| v0_28(void) = AliasedUse : ~m0_24 -# 184| v0_29(void) = ExitFunction : +# 184| v184_1(void) = EnterFunction : +# 184| m184_2(unknown) = AliasedDefinition : +# 184| mu184_3(unknown) = UnmodeledDefinition : +# 184| r184_4(glval) = VariableAddress[a] : +# 184| m184_5(unsigned int &) = InitializeParameter[a] : &:r184_4 +# 184| r184_6(glval) = VariableAddress[b] : +# 184| m184_7(unsigned int &) = InitializeParameter[b] : &:r184_6 +# 184| r184_8(glval) = VariableAddress[c] : +# 184| m184_9(unsigned int &) = InitializeParameter[c] : &:r184_8 +# 184| r184_10(glval) = VariableAddress[d] : +# 184| m184_11(unsigned int &) = InitializeParameter[d] : &:r184_10 +# 189| r189_1(glval) = VariableAddress[a] : +# 189| r189_2(unsigned int &) = Load : &:r189_1, m184_5 +# 189| r189_3(glval) = CopyValue : r189_2 +# 189| r189_4(glval) = VariableAddress[b] : +# 189| r189_5(unsigned int &) = Load : &:r189_4, m184_7 +# 189| r189_6(glval) = CopyValue : r189_5 +# 190| r190_1(glval) = VariableAddress[c] : +# 190| r190_2(unsigned int &) = Load : &:r190_1, m184_9 +# 190| r190_3(unsigned int) = Load : &:r190_2, ~m184_2 +# 190| r190_4(glval) = VariableAddress[d] : +# 190| r190_5(unsigned int &) = Load : &:r190_4, m184_11 +# 190| r190_6(unsigned int) = Load : &:r190_5, ~m184_2 +# 186| m186_1(unknown) = InlineAsm : ~mu184_3, 0:r189_3, 1:r189_6, 2:r190_3, 3:r190_6 +# 186| m186_2(unknown) = Chi : total:m184_2, partial:m186_1 +# 192| v192_1(void) = NoOp : +# 184| v184_12(void) = ReturnVoid : +# 184| v184_13(void) = UnmodeledUse : mu* +# 184| v184_14(void) = AliasedUse : ~m186_2 +# 184| v184_15(void) = ExitFunction : # 198| int PureFunctions(char*, char*, int) # 198| Block 0 -# 198| v0_0(void) = EnterFunction : -# 198| m0_1(unknown) = AliasedDefinition : -# 198| mu0_2(unknown) = UnmodeledDefinition : -# 198| r0_3(glval) = VariableAddress[str1] : -# 198| m0_4(char *) = InitializeParameter[str1] : &:r0_3 -# 198| r0_5(glval) = VariableAddress[str2] : -# 198| m0_6(char *) = InitializeParameter[str2] : &:r0_5 -# 198| r0_7(glval) = VariableAddress[x] : -# 198| m0_8(int) = InitializeParameter[x] : &:r0_7 -# 199| r0_9(glval) = VariableAddress[ret] : -# 199| r0_10(glval) = FunctionAddress[strcmp] : -# 199| r0_11(glval) = VariableAddress[str1] : -# 199| r0_12(char *) = Load : &:r0_11, m0_4 -# 199| r0_13(char *) = Convert : r0_12 -# 199| r0_14(glval) = VariableAddress[str2] : -# 199| r0_15(char *) = Load : &:r0_14, m0_6 -# 199| r0_16(char *) = Convert : r0_15 -# 199| r0_17(int) = Call : func:r0_10, 0:r0_13, 1:r0_16 -# 199| v0_18(void) = ^CallReadSideEffect : ~m0_1 -# 199| m0_19(int) = Store : &:r0_9, r0_17 -# 200| r0_20(glval) = FunctionAddress[strlen] : -# 200| r0_21(glval) = VariableAddress[str1] : -# 200| r0_22(char *) = Load : &:r0_21, m0_4 -# 200| r0_23(char *) = Convert : r0_22 -# 200| r0_24(int) = Call : func:r0_20, 0:r0_23 -# 200| v0_25(void) = ^CallReadSideEffect : ~m0_1 -# 200| r0_26(glval) = VariableAddress[ret] : -# 200| r0_27(int) = Load : &:r0_26, m0_19 -# 200| r0_28(int) = Add : r0_27, r0_24 -# 200| m0_29(int) = Store : &:r0_26, r0_28 -# 201| r0_30(glval) = FunctionAddress[abs] : -# 201| r0_31(glval) = VariableAddress[x] : -# 201| r0_32(int) = Load : &:r0_31, m0_8 -# 201| r0_33(int) = Call : func:r0_30, 0:r0_32 -# 201| r0_34(glval) = VariableAddress[ret] : -# 201| r0_35(int) = Load : &:r0_34, m0_29 -# 201| r0_36(int) = Add : r0_35, r0_33 -# 201| m0_37(int) = Store : &:r0_34, r0_36 -# 202| r0_38(glval) = VariableAddress[#return] : -# 202| r0_39(glval) = VariableAddress[ret] : -# 202| r0_40(int) = Load : &:r0_39, m0_37 -# 202| m0_41(int) = Store : &:r0_38, r0_40 -# 198| r0_42(glval) = VariableAddress[#return] : -# 198| v0_43(void) = ReturnValue : &:r0_42, m0_41 -# 198| v0_44(void) = UnmodeledUse : mu* -# 198| v0_45(void) = AliasedUse : ~m0_1 -# 198| v0_46(void) = ExitFunction : +# 198| v198_1(void) = EnterFunction : +# 198| m198_2(unknown) = AliasedDefinition : +# 198| mu198_3(unknown) = UnmodeledDefinition : +# 198| r198_4(glval) = VariableAddress[str1] : +# 198| m198_5(char *) = InitializeParameter[str1] : &:r198_4 +# 198| r198_6(glval) = VariableAddress[str2] : +# 198| m198_7(char *) = InitializeParameter[str2] : &:r198_6 +# 198| r198_8(glval) = VariableAddress[x] : +# 198| m198_9(int) = InitializeParameter[x] : &:r198_8 +# 199| r199_1(glval) = VariableAddress[ret] : +# 199| r199_2(glval) = FunctionAddress[strcmp] : +# 199| r199_3(glval) = VariableAddress[str1] : +# 199| r199_4(char *) = Load : &:r199_3, m198_5 +# 199| r199_5(char *) = Convert : r199_4 +# 199| r199_6(glval) = VariableAddress[str2] : +# 199| r199_7(char *) = Load : &:r199_6, m198_7 +# 199| r199_8(char *) = Convert : r199_7 +# 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 +# 199| v199_10(void) = ^CallReadSideEffect : ~m198_2 +# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 200| r200_1(glval) = FunctionAddress[strlen] : +# 200| r200_2(glval) = VariableAddress[str1] : +# 200| r200_3(char *) = Load : &:r200_2, m198_5 +# 200| r200_4(char *) = Convert : r200_3 +# 200| r200_5(int) = Call : func:r200_1, 0:r200_4 +# 200| v200_6(void) = ^CallReadSideEffect : ~m198_2 +# 200| r200_7(glval) = VariableAddress[ret] : +# 200| r200_8(int) = Load : &:r200_7, m199_11 +# 200| r200_9(int) = Add : r200_8, r200_5 +# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 201| r201_1(glval) = FunctionAddress[abs] : +# 201| r201_2(glval) = VariableAddress[x] : +# 201| r201_3(int) = Load : &:r201_2, m198_9 +# 201| r201_4(int) = Call : func:r201_1, 0:r201_3 +# 201| r201_5(glval) = VariableAddress[ret] : +# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_7(int) = Add : r201_6, r201_4 +# 201| m201_8(int) = Store : &:r201_5, r201_7 +# 202| r202_1(glval) = VariableAddress[#return] : +# 202| r202_2(glval) = VariableAddress[ret] : +# 202| r202_3(int) = Load : &:r202_2, m201_8 +# 202| m202_4(int) = Store : &:r202_1, r202_3 +# 198| r198_10(glval) = VariableAddress[#return] : +# 198| v198_11(void) = ReturnValue : &:r198_10, m202_4 +# 198| v198_12(void) = UnmodeledUse : mu* +# 198| v198_13(void) = AliasedUse : ~m198_2 +# 198| v198_14(void) = ExitFunction : # 207| int ModeledCallTarget(int) # 207| Block 0 -# 207| v0_0(void) = EnterFunction : -# 207| m0_1(unknown) = AliasedDefinition : -# 207| mu0_2(unknown) = UnmodeledDefinition : -# 207| r0_3(glval) = VariableAddress[x] : -# 207| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 207| m0_5(unknown) = Chi : total:m0_1, partial:m0_4 -# 208| r0_6(glval) = VariableAddress[y] : -# 208| m0_7(int) = Uninitialized[y] : &:r0_6 -# 208| m0_8(unknown) = Chi : total:m0_5, partial:m0_7 -# 209| r0_9(glval) = FunctionAddress[memcpy] : -# 209| r0_10(glval) = VariableAddress[y] : -# 209| r0_11(int *) = CopyValue : r0_10 -# 209| r0_12(void *) = Convert : r0_11 -# 209| r0_13(glval) = VariableAddress[x] : -# 209| r0_14(int *) = CopyValue : r0_13 -# 209| r0_15(void *) = Convert : r0_14 -# 209| r0_16(int) = Constant[4] : -# 209| r0_17(void *) = Call : func:r0_9, 0:r0_12, 1:r0_15, 2:r0_16 -# 209| v0_18(void) = ^SizedBufferReadSideEffect[1] : &:r0_15, r0_16, ~mu0_2 -# 209| m0_19(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r0_12, r0_16 -# 209| m0_20(unknown) = Chi : total:m0_8, partial:m0_19 -# 210| r0_21(glval) = VariableAddress[#return] : -# 210| r0_22(glval) = VariableAddress[y] : -# 210| r0_23(int) = Load : &:r0_22, ~m0_20 -# 210| m0_24(int) = Store : &:r0_21, r0_23 -# 207| r0_25(glval) = VariableAddress[#return] : -# 207| v0_26(void) = ReturnValue : &:r0_25, m0_24 -# 207| v0_27(void) = UnmodeledUse : mu* -# 207| v0_28(void) = AliasedUse : ~m0_1 -# 207| v0_29(void) = ExitFunction : +# 207| v207_1(void) = EnterFunction : +# 207| m207_2(unknown) = AliasedDefinition : +# 207| mu207_3(unknown) = UnmodeledDefinition : +# 207| r207_4(glval) = VariableAddress[x] : +# 207| m207_5(int) = InitializeParameter[x] : &:r207_4 +# 207| m207_6(unknown) = Chi : total:m207_2, partial:m207_5 +# 208| r208_1(glval) = VariableAddress[y] : +# 208| m208_2(int) = Uninitialized[y] : &:r208_1 +# 208| m208_3(unknown) = Chi : total:m207_6, partial:m208_2 +# 209| r209_1(glval) = FunctionAddress[memcpy] : +# 209| r209_2(glval) = VariableAddress[y] : +# 209| r209_3(int *) = CopyValue : r209_2 +# 209| r209_4(void *) = Convert : r209_3 +# 209| r209_5(glval) = VariableAddress[x] : +# 209| r209_6(int *) = CopyValue : r209_5 +# 209| r209_7(void *) = Convert : r209_6 +# 209| r209_8(int) = Constant[4] : +# 209| r209_9(void *) = Call : func:r209_1, 0:r209_4, 1:r209_7, 2:r209_8 +# 209| v209_10(void) = ^SizedBufferReadSideEffect[1] : &:r209_7, r209_8, ~mu207_3 +# 209| m209_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r209_4, r209_8 +# 209| m209_12(unknown) = Chi : total:m208_3, partial:m209_11 +# 210| r210_1(glval) = VariableAddress[#return] : +# 210| r210_2(glval) = VariableAddress[y] : +# 210| r210_3(int) = Load : &:r210_2, ~m209_12 +# 210| m210_4(int) = Store : &:r210_1, r210_3 +# 207| r207_7(glval) = VariableAddress[#return] : +# 207| v207_8(void) = ReturnValue : &:r207_7, m210_4 +# 207| v207_9(void) = UnmodeledUse : mu* +# 207| v207_10(void) = AliasedUse : ~m207_2 +# 207| v207_11(void) = ExitFunction : # 213| void InitArray() # 213| Block 0 -# 213| v0_0(void) = EnterFunction : -# 213| m0_1(unknown) = AliasedDefinition : -# 213| mu0_2(unknown) = UnmodeledDefinition : -# 214| r0_3(glval) = VariableAddress[a_pad] : -# 214| r0_4(glval) = StringConstant[""] : -# 214| r0_5(char[32]) = Load : &:r0_4, ~m0_1 -# 214| m0_6(char[32]) = Store : &:r0_3, r0_5 -# 215| r0_7(glval) = VariableAddress[a_nopad] : -# 215| r0_8(glval) = StringConstant["foo"] : -# 215| r0_9(char[4]) = Load : &:r0_8, ~m0_1 -# 215| m0_10(char[4]) = Store : &:r0_7, r0_9 -# 216| r0_11(glval) = VariableAddress[a_infer] : -# 216| r0_12(glval) = StringConstant["blah"] : -# 216| r0_13(char[5]) = Load : &:r0_12, ~m0_1 -# 216| m0_14(char[5]) = Store : &:r0_11, r0_13 -# 217| r0_15(glval) = VariableAddress[b] : -# 217| m0_16(char[2]) = Uninitialized[b] : &:r0_15 -# 218| r0_17(glval) = VariableAddress[c] : -# 218| m0_18(char[2]) = Uninitialized[c] : &:r0_17 -# 218| r0_19(int) = Constant[0] : -# 218| r0_20(glval) = PointerAdd[1] : r0_17, r0_19 -# 218| r0_21(unknown[2]) = Constant[0] : -# 218| m0_22(unknown[2]) = Store : &:r0_20, r0_21 -# 219| r0_23(glval) = VariableAddress[d] : -# 219| m0_24(char[2]) = Uninitialized[d] : &:r0_23 -# 219| r0_25(int) = Constant[0] : -# 219| r0_26(glval) = PointerAdd[1] : r0_23, r0_25 -# 219| r0_27(char) = Constant[0] : -# 219| m0_28(char) = Store : &:r0_26, r0_27 -# 219| m0_29(char[2]) = Chi : total:m0_24, partial:m0_28 -# 219| r0_30(int) = Constant[1] : -# 219| r0_31(glval) = PointerAdd[1] : r0_23, r0_30 -# 219| r0_32(char) = Constant[0] : -# 219| m0_33(char) = Store : &:r0_31, r0_32 -# 219| m0_34(char[2]) = Chi : total:m0_29, partial:m0_33 -# 220| r0_35(glval) = VariableAddress[e] : -# 220| m0_36(char[2]) = Uninitialized[e] : &:r0_35 -# 220| r0_37(int) = Constant[0] : -# 220| r0_38(glval) = PointerAdd[1] : r0_35, r0_37 -# 220| r0_39(char) = Constant[0] : -# 220| m0_40(char) = Store : &:r0_38, r0_39 -# 220| m0_41(char[2]) = Chi : total:m0_36, partial:m0_40 -# 220| r0_42(int) = Constant[1] : -# 220| r0_43(glval) = PointerAdd[1] : r0_35, r0_42 -# 220| r0_44(char) = Constant[1] : -# 220| m0_45(char) = Store : &:r0_43, r0_44 -# 220| m0_46(char[2]) = Chi : total:m0_41, partial:m0_45 -# 221| r0_47(glval) = VariableAddress[f] : -# 221| m0_48(char[3]) = Uninitialized[f] : &:r0_47 -# 221| r0_49(int) = Constant[0] : -# 221| r0_50(glval) = PointerAdd[1] : r0_47, r0_49 -# 221| r0_51(char) = Constant[0] : -# 221| m0_52(char) = Store : &:r0_50, r0_51 -# 221| m0_53(char[3]) = Chi : total:m0_48, partial:m0_52 -# 221| r0_54(int) = Constant[1] : -# 221| r0_55(glval) = PointerAdd[1] : r0_47, r0_54 -# 221| r0_56(unknown[2]) = Constant[0] : -# 221| m0_57(unknown[2]) = Store : &:r0_55, r0_56 -# 221| m0_58(char[3]) = Chi : total:m0_53, partial:m0_57 -# 222| v0_59(void) = NoOp : -# 213| v0_60(void) = ReturnVoid : -# 213| v0_61(void) = UnmodeledUse : mu* -# 213| v0_62(void) = AliasedUse : ~m0_1 -# 213| v0_63(void) = ExitFunction : +# 213| v213_1(void) = EnterFunction : +# 213| m213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 214| r214_1(glval) = VariableAddress[a_pad] : +# 214| r214_2(glval) = StringConstant[""] : +# 214| r214_3(char[32]) = Load : &:r214_2, ~m213_2 +# 214| m214_4(char[32]) = Store : &:r214_1, r214_3 +# 215| r215_1(glval) = VariableAddress[a_nopad] : +# 215| r215_2(glval) = StringConstant["foo"] : +# 215| r215_3(char[4]) = Load : &:r215_2, ~m213_2 +# 215| m215_4(char[4]) = Store : &:r215_1, r215_3 +# 216| r216_1(glval) = VariableAddress[a_infer] : +# 216| r216_2(glval) = StringConstant["blah"] : +# 216| r216_3(char[5]) = Load : &:r216_2, ~m213_2 +# 216| m216_4(char[5]) = Store : &:r216_1, r216_3 +# 217| r217_1(glval) = VariableAddress[b] : +# 217| m217_2(char[2]) = Uninitialized[b] : &:r217_1 +# 218| r218_1(glval) = VariableAddress[c] : +# 218| m218_2(char[2]) = Uninitialized[c] : &:r218_1 +# 218| r218_3(int) = Constant[0] : +# 218| r218_4(glval) = PointerAdd[1] : r218_1, r218_3 +# 218| r218_5(unknown[2]) = Constant[0] : +# 218| m218_6(unknown[2]) = Store : &:r218_4, r218_5 +# 219| r219_1(glval) = VariableAddress[d] : +# 219| m219_2(char[2]) = Uninitialized[d] : &:r219_1 +# 219| r219_3(int) = Constant[0] : +# 219| r219_4(glval) = PointerAdd[1] : r219_1, r219_3 +# 219| r219_5(char) = Constant[0] : +# 219| m219_6(char) = Store : &:r219_4, r219_5 +# 219| m219_7(char[2]) = Chi : total:m219_2, partial:m219_6 +# 219| r219_8(int) = Constant[1] : +# 219| r219_9(glval) = PointerAdd[1] : r219_1, r219_8 +# 219| r219_10(char) = Constant[0] : +# 219| m219_11(char) = Store : &:r219_9, r219_10 +# 219| m219_12(char[2]) = Chi : total:m219_7, partial:m219_11 +# 220| r220_1(glval) = VariableAddress[e] : +# 220| m220_2(char[2]) = Uninitialized[e] : &:r220_1 +# 220| r220_3(int) = Constant[0] : +# 220| r220_4(glval) = PointerAdd[1] : r220_1, r220_3 +# 220| r220_5(char) = Constant[0] : +# 220| m220_6(char) = Store : &:r220_4, r220_5 +# 220| m220_7(char[2]) = Chi : total:m220_2, partial:m220_6 +# 220| r220_8(int) = Constant[1] : +# 220| r220_9(glval) = PointerAdd[1] : r220_1, r220_8 +# 220| r220_10(char) = Constant[1] : +# 220| m220_11(char) = Store : &:r220_9, r220_10 +# 220| m220_12(char[2]) = Chi : total:m220_7, partial:m220_11 +# 221| r221_1(glval) = VariableAddress[f] : +# 221| m221_2(char[3]) = Uninitialized[f] : &:r221_1 +# 221| r221_3(int) = Constant[0] : +# 221| r221_4(glval) = PointerAdd[1] : r221_1, r221_3 +# 221| r221_5(char) = Constant[0] : +# 221| m221_6(char) = Store : &:r221_4, r221_5 +# 221| m221_7(char[3]) = Chi : total:m221_2, partial:m221_6 +# 221| r221_8(int) = Constant[1] : +# 221| r221_9(glval) = PointerAdd[1] : r221_1, r221_8 +# 221| r221_10(unknown[2]) = Constant[0] : +# 221| m221_11(unknown[2]) = Store : &:r221_9, r221_10 +# 221| m221_12(char[3]) = Chi : total:m221_7, partial:m221_11 +# 222| v222_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~m213_2 +# 213| v213_7(void) = ExitFunction : # 226| char StringLiteralAliasing() # 226| Block 0 -# 226| v0_0(void) = EnterFunction : -# 226| m0_1(unknown) = AliasedDefinition : -# 226| mu0_2(unknown) = UnmodeledDefinition : -# 227| r0_3(glval) = FunctionAddress[ExternalFunc] : -# 227| v0_4(void) = Call : func:r0_3 -# 227| m0_5(unknown) = ^CallSideEffect : ~m0_1 -# 227| m0_6(unknown) = Chi : total:m0_1, partial:m0_5 -# 229| r0_7(glval) = VariableAddress[s] : -# 229| r0_8(glval) = StringConstant["Literal"] : -# 229| r0_9(char *) = Convert : r0_8 -# 229| m0_10(char *) = Store : &:r0_7, r0_9 -# 230| r0_11(glval) = VariableAddress[#return] : -# 230| r0_12(glval) = VariableAddress[s] : -# 230| r0_13(char *) = Load : &:r0_12, m0_10 -# 230| r0_14(int) = Constant[2] : -# 230| r0_15(glval) = PointerAdd[1] : r0_13, r0_14 -# 230| r0_16(char) = Load : &:r0_15, ~m0_1 -# 230| m0_17(char) = Store : &:r0_11, r0_16 -# 226| r0_18(glval) = VariableAddress[#return] : -# 226| v0_19(void) = ReturnValue : &:r0_18, m0_17 -# 226| v0_20(void) = UnmodeledUse : mu* -# 226| v0_21(void) = AliasedUse : ~m0_6 -# 226| v0_22(void) = ExitFunction : +# 226| v226_1(void) = EnterFunction : +# 226| m226_2(unknown) = AliasedDefinition : +# 226| mu226_3(unknown) = UnmodeledDefinition : +# 227| r227_1(glval) = FunctionAddress[ExternalFunc] : +# 227| v227_2(void) = Call : func:r227_1 +# 227| m227_3(unknown) = ^CallSideEffect : ~m226_2 +# 227| m227_4(unknown) = Chi : total:m226_2, partial:m227_3 +# 229| r229_1(glval) = VariableAddress[s] : +# 229| r229_2(glval) = StringConstant["Literal"] : +# 229| r229_3(char *) = Convert : r229_2 +# 229| m229_4(char *) = Store : &:r229_1, r229_3 +# 230| r230_1(glval) = VariableAddress[#return] : +# 230| r230_2(glval) = VariableAddress[s] : +# 230| r230_3(char *) = Load : &:r230_2, m229_4 +# 230| r230_4(int) = Constant[2] : +# 230| r230_5(glval) = PointerAdd[1] : r230_3, r230_4 +# 230| r230_6(char) = Load : &:r230_5, ~m226_2 +# 230| m230_7(char) = Store : &:r230_1, r230_6 +# 226| r226_4(glval) = VariableAddress[#return] : +# 226| v226_5(void) = ReturnValue : &:r226_4, m230_7 +# 226| v226_6(void) = UnmodeledUse : mu* +# 226| v226_7(void) = AliasedUse : ~m227_4 +# 226| v226_8(void) = ExitFunction : # 235| void Constructible::Constructible(int) # 235| Block 0 -# 235| v0_0(void) = EnterFunction : -# 235| m0_1(unknown) = AliasedDefinition : -# 235| mu0_2(unknown) = UnmodeledDefinition : -# 235| r0_3(glval) = InitializeThis : -# 235| r0_4(glval) = VariableAddress[x] : -# 235| m0_5(int) = InitializeParameter[x] : &:r0_4 -# 235| v0_6(void) = NoOp : -# 235| v0_7(void) = ReturnVoid : -# 235| v0_8(void) = UnmodeledUse : mu* -# 235| v0_9(void) = AliasedUse : ~m0_1 -# 235| v0_10(void) = ExitFunction : +# 235| v235_1(void) = EnterFunction : +# 235| m235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = InitializeThis : +# 235| r235_5(glval) = VariableAddress[x] : +# 235| m235_6(int) = InitializeParameter[x] : &:r235_5 +# 235| v235_7(void) = NoOp : +# 235| v235_8(void) = ReturnVoid : +# 235| v235_9(void) = UnmodeledUse : mu* +# 235| v235_10(void) = AliasedUse : ~m235_2 +# 235| v235_11(void) = ExitFunction : # 236| void Constructible::g() # 236| Block 0 -# 236| v0_0(void) = EnterFunction : -# 236| m0_1(unknown) = AliasedDefinition : -# 236| mu0_2(unknown) = UnmodeledDefinition : -# 236| r0_3(glval) = InitializeThis : -# 236| v0_4(void) = NoOp : -# 236| v0_5(void) = ReturnVoid : -# 236| v0_6(void) = UnmodeledUse : mu* -# 236| v0_7(void) = AliasedUse : ~m0_1 -# 236| v0_8(void) = ExitFunction : +# 236| v236_1(void) = EnterFunction : +# 236| m236_2(unknown) = AliasedDefinition : +# 236| mu236_3(unknown) = UnmodeledDefinition : +# 236| r236_4(glval) = InitializeThis : +# 236| v236_5(void) = NoOp : +# 236| v236_6(void) = ReturnVoid : +# 236| v236_7(void) = UnmodeledUse : mu* +# 236| v236_8(void) = AliasedUse : ~m236_2 +# 236| v236_9(void) = ExitFunction : # 239| void ExplicitConstructorCalls() # 239| Block 0 -# 239| v0_0(void) = EnterFunction : -# 239| m0_1(unknown) = AliasedDefinition : -# 239| mu0_2(unknown) = UnmodeledDefinition : -# 240| r0_3(glval) = VariableAddress[c] : -# 240| m0_4(Constructible) = Uninitialized[c] : &:r0_3 -# 240| r0_5(glval) = FunctionAddress[Constructible] : -# 240| r0_6(int) = Constant[1] : -# 240| v0_7(void) = Call : func:r0_5, this:r0_3, 0:r0_6 -# 240| m0_8(unknown) = ^CallSideEffect : ~m0_1 -# 240| m0_9(unknown) = Chi : total:m0_1, partial:m0_8 -# 240| m0_10(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 240| m0_11(Constructible) = Chi : total:m0_4, partial:m0_10 -# 241| r0_12(glval) = VariableAddress[c] : -# 241| r0_13(glval) = FunctionAddress[g] : -# 241| v0_14(void) = Call : func:r0_13, this:r0_12 -# 241| m0_15(unknown) = ^CallSideEffect : ~m0_9 -# 241| m0_16(unknown) = Chi : total:m0_9, partial:m0_15 -# 241| v0_17(void) = ^BufferReadSideEffect[-1] : &:r0_12, ~m0_11 -# 241| m0_18(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_12 -# 241| m0_19(Constructible) = Chi : total:m0_11, partial:m0_18 -# 242| r0_20(glval) = VariableAddress[c] : -# 242| r0_21(glval) = FunctionAddress[g] : -# 242| v0_22(void) = Call : func:r0_21, this:r0_20 -# 242| m0_23(unknown) = ^CallSideEffect : ~m0_16 -# 242| m0_24(unknown) = Chi : total:m0_16, partial:m0_23 -# 242| v0_25(void) = ^BufferReadSideEffect[-1] : &:r0_20, ~m0_19 -# 242| m0_26(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_20 -# 242| m0_27(Constructible) = Chi : total:m0_19, partial:m0_26 -# 243| r0_28(glval) = VariableAddress[c2] : -# 243| m0_29(Constructible) = Uninitialized[c2] : &:r0_28 -# 243| r0_30(glval) = FunctionAddress[Constructible] : -# 243| r0_31(int) = Constant[2] : -# 243| v0_32(void) = Call : func:r0_30, this:r0_28, 0:r0_31 -# 243| m0_33(unknown) = ^CallSideEffect : ~m0_24 -# 243| m0_34(unknown) = Chi : total:m0_24, partial:m0_33 -# 243| m0_35(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_28 -# 243| m0_36(Constructible) = Chi : total:m0_29, partial:m0_35 -# 244| r0_37(glval) = VariableAddress[c2] : -# 244| r0_38(glval) = FunctionAddress[g] : -# 244| v0_39(void) = Call : func:r0_38, this:r0_37 -# 244| m0_40(unknown) = ^CallSideEffect : ~m0_34 -# 244| m0_41(unknown) = Chi : total:m0_34, partial:m0_40 -# 244| v0_42(void) = ^BufferReadSideEffect[-1] : &:r0_37, ~m0_36 -# 244| m0_43(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_37 -# 244| m0_44(Constructible) = Chi : total:m0_36, partial:m0_43 -# 245| v0_45(void) = NoOp : -# 239| v0_46(void) = ReturnVoid : -# 239| v0_47(void) = UnmodeledUse : mu* -# 239| v0_48(void) = AliasedUse : ~m0_41 -# 239| v0_49(void) = ExitFunction : +# 239| v239_1(void) = EnterFunction : +# 239| m239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 240| r240_1(glval) = VariableAddress[c] : +# 240| m240_2(Constructible) = Uninitialized[c] : &:r240_1 +# 240| r240_3(glval) = FunctionAddress[Constructible] : +# 240| r240_4(int) = Constant[1] : +# 240| v240_5(void) = Call : func:r240_3, this:r240_1, 0:r240_4 +# 240| m240_6(unknown) = ^CallSideEffect : ~m239_2 +# 240| m240_7(unknown) = Chi : total:m239_2, partial:m240_6 +# 240| m240_8(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r240_1 +# 240| m240_9(Constructible) = Chi : total:m240_2, partial:m240_8 +# 241| r241_1(glval) = VariableAddress[c] : +# 241| r241_2(glval) = FunctionAddress[g] : +# 241| v241_3(void) = Call : func:r241_2, this:r241_1 +# 241| m241_4(unknown) = ^CallSideEffect : ~m240_7 +# 241| m241_5(unknown) = Chi : total:m240_7, partial:m241_4 +# 241| v241_6(void) = ^BufferReadSideEffect[-1] : &:r241_1, ~m240_9 +# 241| m241_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r241_1 +# 241| m241_8(Constructible) = Chi : total:m240_9, partial:m241_7 +# 242| r242_1(glval) = VariableAddress[c] : +# 242| r242_2(glval) = FunctionAddress[g] : +# 242| v242_3(void) = Call : func:r242_2, this:r242_1 +# 242| m242_4(unknown) = ^CallSideEffect : ~m241_5 +# 242| m242_5(unknown) = Chi : total:m241_5, partial:m242_4 +# 242| v242_6(void) = ^BufferReadSideEffect[-1] : &:r242_1, ~m241_8 +# 242| m242_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r242_1 +# 242| m242_8(Constructible) = Chi : total:m241_8, partial:m242_7 +# 243| r243_1(glval) = VariableAddress[c2] : +# 243| m243_2(Constructible) = Uninitialized[c2] : &:r243_1 +# 243| r243_3(glval) = FunctionAddress[Constructible] : +# 243| r243_4(int) = Constant[2] : +# 243| v243_5(void) = Call : func:r243_3, this:r243_1, 0:r243_4 +# 243| m243_6(unknown) = ^CallSideEffect : ~m242_5 +# 243| m243_7(unknown) = Chi : total:m242_5, partial:m243_6 +# 243| m243_8(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r243_1 +# 243| m243_9(Constructible) = Chi : total:m243_2, partial:m243_8 +# 244| r244_1(glval) = VariableAddress[c2] : +# 244| r244_2(glval) = FunctionAddress[g] : +# 244| v244_3(void) = Call : func:r244_2, this:r244_1 +# 244| m244_4(unknown) = ^CallSideEffect : ~m243_7 +# 244| m244_5(unknown) = Chi : total:m243_7, partial:m244_4 +# 244| v244_6(void) = ^BufferReadSideEffect[-1] : &:r244_1, ~m243_9 +# 244| m244_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r244_1 +# 244| m244_8(Constructible) = Chi : total:m243_9, partial:m244_7 +# 245| v245_1(void) = NoOp : +# 239| v239_4(void) = ReturnVoid : +# 239| v239_5(void) = UnmodeledUse : mu* +# 239| v239_6(void) = AliasedUse : ~m244_5 +# 239| v239_7(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.expected b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.expected index 56c9d39e184..b44a576518a 100644 --- a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.expected +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.expected @@ -1,998 +1,998 @@ ssa.cpp: # 13| int ChiPhiNode(Point*, bool, bool) # 13| Block 0 -# 13| v0_0(void) = EnterFunction : -# 13| mu0_1(unknown) = AliasedDefinition : -# 13| mu0_2(unknown) = UnmodeledDefinition : -# 13| r0_3(glval) = VariableAddress[p] : -# 13| m0_4(Point *) = InitializeParameter[p] : &:r0_3 -# 13| r0_5(glval) = VariableAddress[which1] : -# 13| m0_6(bool) = InitializeParameter[which1] : &:r0_5 -# 13| r0_7(glval) = VariableAddress[which2] : -# 13| m0_8(bool) = InitializeParameter[which2] : &:r0_7 -# 14| r0_9(glval) = VariableAddress[which1] : -# 14| r0_10(bool) = Load : &:r0_9, m0_6 -# 14| v0_11(void) = ConditionalBranch : r0_10 +# 13| v13_1(void) = EnterFunction : +# 13| mu13_2(unknown) = AliasedDefinition : +# 13| mu13_3(unknown) = UnmodeledDefinition : +# 13| r13_4(glval) = VariableAddress[p] : +# 13| m13_5(Point *) = InitializeParameter[p] : &:r13_4 +# 13| r13_6(glval) = VariableAddress[which1] : +# 13| m13_7(bool) = InitializeParameter[which1] : &:r13_6 +# 13| r13_8(glval) = VariableAddress[which2] : +# 13| m13_9(bool) = InitializeParameter[which2] : &:r13_8 +# 14| r14_1(glval) = VariableAddress[which1] : +# 14| r14_2(bool) = Load : &:r14_1, m13_7 +# 14| v14_3(void) = ConditionalBranch : r14_2 #-----| False -> Block 2 #-----| True -> Block 1 # 15| Block 1 -# 15| r1_0(glval) = VariableAddress[p] : -# 15| r1_1(Point *) = Load : &:r1_0, m0_4 -# 15| r1_2(glval) = FieldAddress[x] : r1_1 -# 15| r1_3(int) = Load : &:r1_2, ~mu0_2 -# 15| r1_4(int) = Constant[1] : -# 15| r1_5(int) = Add : r1_3, r1_4 -# 15| mu1_6(int) = Store : &:r1_2, r1_5 +# 15| r15_1(glval) = VariableAddress[p] : +# 15| r15_2(Point *) = Load : &:r15_1, m13_5 +# 15| r15_3(glval) = FieldAddress[x] : r15_2 +# 15| r15_4(int) = Load : &:r15_3, ~mu13_3 +# 15| r15_5(int) = Constant[1] : +# 15| r15_6(int) = Add : r15_4, r15_5 +# 15| mu15_7(int) = Store : &:r15_3, r15_6 #-----| Goto -> Block 3 # 18| Block 2 -# 18| r2_0(glval) = VariableAddress[p] : -# 18| r2_1(Point *) = Load : &:r2_0, m0_4 -# 18| r2_2(glval) = FieldAddress[y] : r2_1 -# 18| r2_3(int) = Load : &:r2_2, ~mu0_2 -# 18| r2_4(int) = Constant[1] : -# 18| r2_5(int) = Add : r2_3, r2_4 -# 18| mu2_6(int) = Store : &:r2_2, r2_5 +# 18| r18_1(glval) = VariableAddress[p] : +# 18| r18_2(Point *) = Load : &:r18_1, m13_5 +# 18| r18_3(glval) = FieldAddress[y] : r18_2 +# 18| r18_4(int) = Load : &:r18_3, ~mu13_3 +# 18| r18_5(int) = Constant[1] : +# 18| r18_6(int) = Add : r18_4, r18_5 +# 18| mu18_7(int) = Store : &:r18_3, r18_6 #-----| Goto -> Block 3 # 21| Block 3 -# 21| r3_0(glval) = VariableAddress[which2] : -# 21| r3_1(bool) = Load : &:r3_0, m0_8 -# 21| v3_2(void) = ConditionalBranch : r3_1 +# 21| r21_1(glval) = VariableAddress[which2] : +# 21| r21_2(bool) = Load : &:r21_1, m13_9 +# 21| v21_3(void) = ConditionalBranch : r21_2 #-----| False -> Block 5 #-----| True -> Block 4 # 22| Block 4 -# 22| r4_0(glval) = VariableAddress[p] : -# 22| r4_1(Point *) = Load : &:r4_0, m0_4 -# 22| r4_2(glval) = FieldAddress[x] : r4_1 -# 22| r4_3(int) = Load : &:r4_2, ~mu0_2 -# 22| r4_4(int) = Constant[1] : -# 22| r4_5(int) = Add : r4_3, r4_4 -# 22| mu4_6(int) = Store : &:r4_2, r4_5 +# 22| r22_1(glval) = VariableAddress[p] : +# 22| r22_2(Point *) = Load : &:r22_1, m13_5 +# 22| r22_3(glval) = FieldAddress[x] : r22_2 +# 22| r22_4(int) = Load : &:r22_3, ~mu13_3 +# 22| r22_5(int) = Constant[1] : +# 22| r22_6(int) = Add : r22_4, r22_5 +# 22| mu22_7(int) = Store : &:r22_3, r22_6 #-----| Goto -> Block 6 # 25| Block 5 -# 25| r5_0(glval) = VariableAddress[p] : -# 25| r5_1(Point *) = Load : &:r5_0, m0_4 -# 25| r5_2(glval) = FieldAddress[y] : r5_1 -# 25| r5_3(int) = Load : &:r5_2, ~mu0_2 -# 25| r5_4(int) = Constant[1] : -# 25| r5_5(int) = Add : r5_3, r5_4 -# 25| mu5_6(int) = Store : &:r5_2, r5_5 +# 25| r25_1(glval) = VariableAddress[p] : +# 25| r25_2(Point *) = Load : &:r25_1, m13_5 +# 25| r25_3(glval) = FieldAddress[y] : r25_2 +# 25| r25_4(int) = Load : &:r25_3, ~mu13_3 +# 25| r25_5(int) = Constant[1] : +# 25| r25_6(int) = Add : r25_4, r25_5 +# 25| mu25_7(int) = Store : &:r25_3, r25_6 #-----| Goto -> Block 6 # 28| Block 6 -# 28| r6_0(glval) = VariableAddress[#return] : -# 28| r6_1(glval) = VariableAddress[p] : -# 28| r6_2(Point *) = Load : &:r6_1, m0_4 -# 28| r6_3(glval) = FieldAddress[x] : r6_2 -# 28| r6_4(int) = Load : &:r6_3, ~mu0_2 -# 28| r6_5(glval) = VariableAddress[p] : -# 28| r6_6(Point *) = Load : &:r6_5, m0_4 -# 28| r6_7(glval) = FieldAddress[y] : r6_6 -# 28| r6_8(int) = Load : &:r6_7, ~mu0_2 -# 28| r6_9(int) = Add : r6_4, r6_8 -# 28| m6_10(int) = Store : &:r6_0, r6_9 -# 13| r6_11(glval) = VariableAddress[#return] : -# 13| v6_12(void) = ReturnValue : &:r6_11, m6_10 -# 13| v6_13(void) = UnmodeledUse : mu* -# 13| v6_14(void) = AliasedUse : ~mu0_2 -# 13| v6_15(void) = ExitFunction : +# 28| r28_1(glval) = VariableAddress[#return] : +# 28| r28_2(glval) = VariableAddress[p] : +# 28| r28_3(Point *) = Load : &:r28_2, m13_5 +# 28| r28_4(glval) = FieldAddress[x] : r28_3 +# 28| r28_5(int) = Load : &:r28_4, ~mu13_3 +# 28| r28_6(glval) = VariableAddress[p] : +# 28| r28_7(Point *) = Load : &:r28_6, m13_5 +# 28| r28_8(glval) = FieldAddress[y] : r28_7 +# 28| r28_9(int) = Load : &:r28_8, ~mu13_3 +# 28| r28_10(int) = Add : r28_5, r28_9 +# 28| m28_11(int) = Store : &:r28_1, r28_10 +# 13| r13_10(glval) = VariableAddress[#return] : +# 13| v13_11(void) = ReturnValue : &:r13_10, m28_11 +# 13| v13_12(void) = UnmodeledUse : mu* +# 13| v13_13(void) = AliasedUse : ~mu13_3 +# 13| v13_14(void) = ExitFunction : # 31| int UnreachableViaGoto() # 31| Block 0 -# 31| v0_0(void) = EnterFunction : -# 31| mu0_1(unknown) = AliasedDefinition : -# 31| mu0_2(unknown) = UnmodeledDefinition : -# 32| v0_3(void) = NoOp : -# 34| v0_4(void) = NoOp : -# 35| r0_5(glval) = VariableAddress[#return] : -# 35| r0_6(int) = Constant[0] : -# 35| m0_7(int) = Store : &:r0_5, r0_6 -# 31| r0_8(glval) = VariableAddress[#return] : -# 31| v0_9(void) = ReturnValue : &:r0_8, m0_7 -# 31| v0_10(void) = UnmodeledUse : mu* -# 31| v0_11(void) = AliasedUse : ~mu0_2 -# 31| v0_12(void) = ExitFunction : +# 31| v31_1(void) = EnterFunction : +# 31| mu31_2(unknown) = AliasedDefinition : +# 31| mu31_3(unknown) = UnmodeledDefinition : +# 32| v32_1(void) = NoOp : +# 34| v34_1(void) = NoOp : +# 35| r35_1(glval) = VariableAddress[#return] : +# 35| r35_2(int) = Constant[0] : +# 35| m35_3(int) = Store : &:r35_1, r35_2 +# 31| r31_4(glval) = VariableAddress[#return] : +# 31| v31_5(void) = ReturnValue : &:r31_4, m35_3 +# 31| v31_6(void) = UnmodeledUse : mu* +# 31| v31_7(void) = AliasedUse : ~mu31_3 +# 31| v31_8(void) = ExitFunction : # 38| int UnreachableIf(bool) # 38| Block 0 -# 38| v0_0(void) = EnterFunction : -# 38| mu0_1(unknown) = AliasedDefinition : -# 38| mu0_2(unknown) = UnmodeledDefinition : -# 38| r0_3(glval) = VariableAddress[b] : -# 38| m0_4(bool) = InitializeParameter[b] : &:r0_3 -# 39| r0_5(glval) = VariableAddress[x] : -# 39| r0_6(int) = Constant[5] : -# 39| m0_7(int) = Store : &:r0_5, r0_6 -# 40| r0_8(glval) = VariableAddress[y] : -# 40| r0_9(int) = Constant[10] : -# 40| m0_10(int) = Store : &:r0_8, r0_9 -# 41| r0_11(glval) = VariableAddress[b] : -# 41| r0_12(bool) = Load : &:r0_11, m0_4 -# 41| v0_13(void) = ConditionalBranch : r0_12 +# 38| v38_1(void) = EnterFunction : +# 38| mu38_2(unknown) = AliasedDefinition : +# 38| mu38_3(unknown) = UnmodeledDefinition : +# 38| r38_4(glval) = VariableAddress[b] : +# 38| m38_5(bool) = InitializeParameter[b] : &:r38_4 +# 39| r39_1(glval) = VariableAddress[x] : +# 39| r39_2(int) = Constant[5] : +# 39| m39_3(int) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[y] : +# 40| r40_2(int) = Constant[10] : +# 40| m40_3(int) = Store : &:r40_1, r40_2 +# 41| r41_1(glval) = VariableAddress[b] : +# 41| r41_2(bool) = Load : &:r41_1, m38_5 +# 41| v41_3(void) = ConditionalBranch : r41_2 #-----| False -> Block 5 #-----| True -> Block 2 # 38| Block 1 -# 38| m1_0(int) = Phi : from 3:m3_2, from 4:m4_2, from 6:m6_2, from 7:m7_2 -# 38| r1_1(glval) = VariableAddress[#return] : -# 38| v1_2(void) = ReturnValue : &:r1_1, m1_0 -# 38| v1_3(void) = UnmodeledUse : mu* -# 38| v1_4(void) = AliasedUse : ~mu0_2 -# 38| v1_5(void) = ExitFunction : +# 38| m38_6(int) = Phi : from 3:m43_3, from 4:m46_3, from 6:m51_3, from 7:m54_3 +# 38| r38_7(glval) = VariableAddress[#return] : +# 38| v38_8(void) = ReturnValue : &:r38_7, m38_6 +# 38| v38_9(void) = UnmodeledUse : mu* +# 38| v38_10(void) = AliasedUse : ~mu38_3 +# 38| v38_11(void) = ExitFunction : # 42| Block 2 -# 42| r2_0(glval) = VariableAddress[x] : -# 42| r2_1(int) = Load : &:r2_0, m0_7 -# 42| r2_2(glval) = VariableAddress[y] : -# 42| r2_3(int) = Load : &:r2_2, m0_10 -# 42| r2_4(bool) = CompareEQ : r2_1, r2_3 -# 42| v2_5(void) = ConditionalBranch : r2_4 +# 42| r42_1(glval) = VariableAddress[x] : +# 42| r42_2(int) = Load : &:r42_1, m39_3 +# 42| r42_3(glval) = VariableAddress[y] : +# 42| r42_4(int) = Load : &:r42_3, m40_3 +# 42| r42_5(bool) = CompareEQ : r42_2, r42_4 +# 42| v42_6(void) = ConditionalBranch : r42_5 #-----| False -> Block 4 #-----| True -> Block 3 # 43| Block 3 -# 43| r3_0(glval) = VariableAddress[#return] : -# 43| r3_1(int) = Constant[1] : -# 43| m3_2(int) = Store : &:r3_0, r3_1 +# 43| r43_1(glval) = VariableAddress[#return] : +# 43| r43_2(int) = Constant[1] : +# 43| m43_3(int) = Store : &:r43_1, r43_2 #-----| Goto -> Block 1 # 46| Block 4 -# 46| r4_0(glval) = VariableAddress[#return] : -# 46| r4_1(int) = Constant[0] : -# 46| m4_2(int) = Store : &:r4_0, r4_1 +# 46| r46_1(glval) = VariableAddress[#return] : +# 46| r46_2(int) = Constant[0] : +# 46| m46_3(int) = Store : &:r46_1, r46_2 #-----| Goto -> Block 1 # 50| Block 5 -# 50| r5_0(glval) = VariableAddress[x] : -# 50| r5_1(int) = Load : &:r5_0, m0_7 -# 50| r5_2(glval) = VariableAddress[y] : -# 50| r5_3(int) = Load : &:r5_2, m0_10 -# 50| r5_4(bool) = CompareLT : r5_1, r5_3 -# 50| v5_5(void) = ConditionalBranch : r5_4 +# 50| r50_1(glval) = VariableAddress[x] : +# 50| r50_2(int) = Load : &:r50_1, m39_3 +# 50| r50_3(glval) = VariableAddress[y] : +# 50| r50_4(int) = Load : &:r50_3, m40_3 +# 50| r50_5(bool) = CompareLT : r50_2, r50_4 +# 50| v50_6(void) = ConditionalBranch : r50_5 #-----| False -> Block 7 #-----| True -> Block 6 # 51| Block 6 -# 51| r6_0(glval) = VariableAddress[#return] : -# 51| r6_1(int) = Constant[0] : -# 51| m6_2(int) = Store : &:r6_0, r6_1 +# 51| r51_1(glval) = VariableAddress[#return] : +# 51| r51_2(int) = Constant[0] : +# 51| m51_3(int) = Store : &:r51_1, r51_2 #-----| Goto -> Block 1 # 54| Block 7 -# 54| r7_0(glval) = VariableAddress[#return] : -# 54| r7_1(int) = Constant[1] : -# 54| m7_2(int) = Store : &:r7_0, r7_1 +# 54| r54_1(glval) = VariableAddress[#return] : +# 54| r54_2(int) = Constant[1] : +# 54| m54_3(int) = Store : &:r54_1, r54_2 #-----| Goto -> Block 1 # 59| int DoWhileFalse() # 59| Block 0 -# 59| v0_0(void) = EnterFunction : -# 59| mu0_1(unknown) = AliasedDefinition : -# 59| mu0_2(unknown) = UnmodeledDefinition : -# 60| r0_3(glval) = VariableAddress[i] : -# 60| r0_4(int) = Constant[0] : -# 60| m0_5(int) = Store : &:r0_3, r0_4 -# 62| r0_6(glval) = VariableAddress[i] : -# 62| r0_7(int) = Load : &:r0_6, m0_5 -# 62| r0_8(int) = Constant[1] : -# 62| r0_9(int) = Add : r0_7, r0_8 -# 62| m0_10(int) = Store : &:r0_6, r0_9 -# 63| r0_11(bool) = Constant[0] : -# 63| v0_12(void) = ConditionalBranch : r0_11 +# 59| v59_1(void) = EnterFunction : +# 59| mu59_2(unknown) = AliasedDefinition : +# 59| mu59_3(unknown) = UnmodeledDefinition : +# 60| r60_1(glval) = VariableAddress[i] : +# 60| r60_2(int) = Constant[0] : +# 60| m60_3(int) = Store : &:r60_1, r60_2 +# 62| r62_1(glval) = VariableAddress[i] : +# 62| r62_2(int) = Load : &:r62_1, m60_3 +# 62| r62_3(int) = Constant[1] : +# 62| r62_4(int) = Add : r62_2, r62_3 +# 62| m62_5(int) = Store : &:r62_1, r62_4 +# 63| r63_1(bool) = Constant[0] : +# 63| v63_2(void) = ConditionalBranch : r63_1 #-----| False -> Block 1 #-----| True -> Block 2 # 65| Block 1 -# 65| r1_0(glval) = VariableAddress[#return] : -# 65| r1_1(glval) = VariableAddress[i] : -# 65| r1_2(int) = Load : &:r1_1, m0_10 -# 65| m1_3(int) = Store : &:r1_0, r1_2 -# 59| r1_4(glval) = VariableAddress[#return] : -# 59| v1_5(void) = ReturnValue : &:r1_4, m1_3 -# 59| v1_6(void) = UnmodeledUse : mu* -# 59| v1_7(void) = AliasedUse : ~mu0_2 -# 59| v1_8(void) = ExitFunction : +# 65| r65_1(glval) = VariableAddress[#return] : +# 65| r65_2(glval) = VariableAddress[i] : +# 65| r65_3(int) = Load : &:r65_2, m62_5 +# 65| m65_4(int) = Store : &:r65_1, r65_3 +# 59| r59_4(glval) = VariableAddress[#return] : +# 59| v59_5(void) = ReturnValue : &:r59_4, m65_4 +# 59| v59_6(void) = UnmodeledUse : mu* +# 59| v59_7(void) = AliasedUse : ~mu59_3 +# 59| v59_8(void) = ExitFunction : # 59| Block 2 -# 59| v2_0(void) = Unreached : +# 59| v59_9(void) = Unreached : # 68| void chiNodeAtEndOfLoop(int, char*) # 68| Block 0 -# 68| v0_0(void) = EnterFunction : -# 68| mu0_1(unknown) = AliasedDefinition : -# 68| mu0_2(unknown) = UnmodeledDefinition : -# 68| r0_3(glval) = VariableAddress[n] : -# 68| m0_4(int) = InitializeParameter[n] : &:r0_3 -# 68| r0_5(glval) = VariableAddress[p] : -# 68| m0_6(char *) = InitializeParameter[p] : &:r0_5 +# 68| v68_1(void) = EnterFunction : +# 68| mu68_2(unknown) = AliasedDefinition : +# 68| mu68_3(unknown) = UnmodeledDefinition : +# 68| r68_4(glval) = VariableAddress[n] : +# 68| m68_5(int) = InitializeParameter[n] : &:r68_4 +# 68| r68_6(glval) = VariableAddress[p] : +# 68| m68_7(char *) = InitializeParameter[p] : &:r68_6 #-----| Goto -> Block 3 # 70| Block 1 -# 70| r1_0(char) = Constant[0] : -# 70| r1_1(glval) = VariableAddress[p] : -# 70| r1_2(char *) = Load : &:r1_1, m3_1 -# 70| r1_3(int) = Constant[1] : -# 70| r1_4(char *) = PointerAdd[1] : r1_2, r1_3 -# 70| m1_5(char *) = Store : &:r1_1, r1_4 -# 70| r1_6(glval) = CopyValue : r1_2 -# 70| mu1_7(char) = Store : &:r1_6, r1_0 +# 70| r70_1(char) = Constant[0] : +# 70| r70_2(glval) = VariableAddress[p] : +# 70| r70_3(char *) = Load : &:r70_2, m69_1 +# 70| r70_4(int) = Constant[1] : +# 70| r70_5(char *) = PointerAdd[1] : r70_3, r70_4 +# 70| m70_6(char *) = Store : &:r70_2, r70_5 +# 70| r70_7(glval) = CopyValue : r70_3 +# 70| mu70_8(char) = Store : &:r70_7, r70_1 #-----| Goto (back edge) -> Block 3 # 71| Block 2 -# 71| v2_0(void) = NoOp : -# 68| v2_1(void) = ReturnVoid : -# 68| v2_2(void) = UnmodeledUse : mu* -# 68| v2_3(void) = AliasedUse : ~mu0_2 -# 68| v2_4(void) = ExitFunction : +# 71| v71_1(void) = NoOp : +# 68| v68_8(void) = ReturnVoid : +# 68| v68_9(void) = UnmodeledUse : mu* +# 68| v68_10(void) = AliasedUse : ~mu68_3 +# 68| v68_11(void) = ExitFunction : # 69| Block 3 -# 69| m3_0(int) = Phi : from 0:m0_4, from 1:m3_6 -# 69| m3_1(char *) = Phi : from 0:m0_6, from 1:m1_5 -# 69| r3_2(glval) = VariableAddress[n] : -# 69| r3_3(int) = Load : &:r3_2, m3_0 -# 69| r3_4(int) = Constant[1] : -# 69| r3_5(int) = Sub : r3_3, r3_4 -# 69| m3_6(int) = Store : &:r3_2, r3_5 -# 69| r3_7(int) = Constant[0] : -# 69| r3_8(bool) = CompareGT : r3_3, r3_7 -# 69| v3_9(void) = ConditionalBranch : r3_8 +# 69| m69_1(char *) = Phi : from 0:m68_7, from 1:m70_6 +# 69| m69_2(int) = Phi : from 0:m68_5, from 1:m69_7 +# 69| r69_3(glval) = VariableAddress[n] : +# 69| r69_4(int) = Load : &:r69_3, m69_2 +# 69| r69_5(int) = Constant[1] : +# 69| r69_6(int) = Sub : r69_4, r69_5 +# 69| m69_7(int) = Store : &:r69_3, r69_6 +# 69| r69_8(int) = Constant[0] : +# 69| r69_9(bool) = CompareGT : r69_4, r69_8 +# 69| v69_10(void) = ConditionalBranch : r69_9 #-----| False -> Block 2 #-----| True -> Block 1 # 75| void ScalarPhi(bool) # 75| Block 0 -# 75| v0_0(void) = EnterFunction : -# 75| mu0_1(unknown) = AliasedDefinition : -# 75| mu0_2(unknown) = UnmodeledDefinition : -# 75| r0_3(glval) = VariableAddress[b] : -# 75| m0_4(bool) = InitializeParameter[b] : &:r0_3 -# 76| r0_5(glval) = VariableAddress[x] : -# 76| r0_6(int) = Constant[0] : -# 76| m0_7(int) = Store : &:r0_5, r0_6 -# 77| r0_8(glval) = VariableAddress[y] : -# 77| r0_9(int) = Constant[1] : -# 77| m0_10(int) = Store : &:r0_8, r0_9 -# 78| r0_11(glval) = VariableAddress[z] : -# 78| r0_12(int) = Constant[2] : -# 78| m0_13(int) = Store : &:r0_11, r0_12 -# 79| r0_14(glval) = VariableAddress[b] : -# 79| r0_15(bool) = Load : &:r0_14, m0_4 -# 79| v0_16(void) = ConditionalBranch : r0_15 +# 75| v75_1(void) = EnterFunction : +# 75| mu75_2(unknown) = AliasedDefinition : +# 75| mu75_3(unknown) = UnmodeledDefinition : +# 75| r75_4(glval) = VariableAddress[b] : +# 75| m75_5(bool) = InitializeParameter[b] : &:r75_4 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Constant[0] : +# 76| m76_3(int) = Store : &:r76_1, r76_2 +# 77| r77_1(glval) = VariableAddress[y] : +# 77| r77_2(int) = Constant[1] : +# 77| m77_3(int) = Store : &:r77_1, r77_2 +# 78| r78_1(glval) = VariableAddress[z] : +# 78| r78_2(int) = Constant[2] : +# 78| m78_3(int) = Store : &:r78_1, r78_2 +# 79| r79_1(glval) = VariableAddress[b] : +# 79| r79_2(bool) = Load : &:r79_1, m75_5 +# 79| v79_3(void) = ConditionalBranch : r79_2 #-----| False -> Block 2 #-----| True -> Block 1 # 80| Block 1 -# 80| r1_0(int) = Constant[3] : -# 80| r1_1(glval) = VariableAddress[x] : -# 80| m1_2(int) = Store : &:r1_1, r1_0 -# 81| r1_3(int) = Constant[4] : -# 81| r1_4(glval) = VariableAddress[y] : -# 81| m1_5(int) = Store : &:r1_4, r1_3 +# 80| r80_1(int) = Constant[3] : +# 80| r80_2(glval) = VariableAddress[x] : +# 80| m80_3(int) = Store : &:r80_2, r80_1 +# 81| r81_1(int) = Constant[4] : +# 81| r81_2(glval) = VariableAddress[y] : +# 81| m81_3(int) = Store : &:r81_2, r81_1 #-----| Goto -> Block 3 # 84| Block 2 -# 84| r2_0(int) = Constant[5] : -# 84| r2_1(glval) = VariableAddress[x] : -# 84| m2_2(int) = Store : &:r2_1, r2_0 +# 84| r84_1(int) = Constant[5] : +# 84| r84_2(glval) = VariableAddress[x] : +# 84| m84_3(int) = Store : &:r84_2, r84_1 #-----| Goto -> Block 3 # 86| Block 3 -# 86| m3_0(int) = Phi : from 1:m1_2, from 2:m2_2 -# 86| m3_1(int) = Phi : from 1:m1_5, from 2:m0_10 -# 86| r3_2(glval) = VariableAddress[x_merge] : -# 86| r3_3(glval) = VariableAddress[x] : -# 86| r3_4(int) = Load : &:r3_3, m3_0 -# 86| m3_5(int) = Store : &:r3_2, r3_4 -# 87| r3_6(glval) = VariableAddress[y_merge] : -# 87| r3_7(glval) = VariableAddress[y] : -# 87| r3_8(int) = Load : &:r3_7, m3_1 -# 87| m3_9(int) = Store : &:r3_6, r3_8 -# 88| r3_10(glval) = VariableAddress[z_merge] : -# 88| r3_11(glval) = VariableAddress[z] : -# 88| r3_12(int) = Load : &:r3_11, m0_13 -# 88| m3_13(int) = Store : &:r3_10, r3_12 -# 89| v3_14(void) = NoOp : -# 75| v3_15(void) = ReturnVoid : -# 75| v3_16(void) = UnmodeledUse : mu* -# 75| v3_17(void) = AliasedUse : ~mu0_2 -# 75| v3_18(void) = ExitFunction : +# 86| m86_1(int) = Phi : from 1:m81_3, from 2:m77_3 +# 86| m86_2(int) = Phi : from 1:m80_3, from 2:m84_3 +# 86| r86_3(glval) = VariableAddress[x_merge] : +# 86| r86_4(glval) = VariableAddress[x] : +# 86| r86_5(int) = Load : &:r86_4, m86_2 +# 86| m86_6(int) = Store : &:r86_3, r86_5 +# 87| r87_1(glval) = VariableAddress[y_merge] : +# 87| r87_2(glval) = VariableAddress[y] : +# 87| r87_3(int) = Load : &:r87_2, m86_1 +# 87| m87_4(int) = Store : &:r87_1, r87_3 +# 88| r88_1(glval) = VariableAddress[z_merge] : +# 88| r88_2(glval) = VariableAddress[z] : +# 88| r88_3(int) = Load : &:r88_2, m78_3 +# 88| m88_4(int) = Store : &:r88_1, r88_3 +# 89| v89_1(void) = NoOp : +# 75| v75_6(void) = ReturnVoid : +# 75| v75_7(void) = UnmodeledUse : mu* +# 75| v75_8(void) = AliasedUse : ~mu75_3 +# 75| v75_9(void) = ExitFunction : # 91| void MustExactlyOverlap(Point) # 91| Block 0 -# 91| v0_0(void) = EnterFunction : -# 91| mu0_1(unknown) = AliasedDefinition : -# 91| mu0_2(unknown) = UnmodeledDefinition : -# 91| r0_3(glval) = VariableAddress[a] : -# 91| m0_4(Point) = InitializeParameter[a] : &:r0_3 -# 92| r0_5(glval) = VariableAddress[b] : -# 92| r0_6(glval) = VariableAddress[a] : -# 92| r0_7(Point) = Load : &:r0_6, m0_4 -# 92| m0_8(Point) = Store : &:r0_5, r0_7 -# 93| v0_9(void) = NoOp : -# 91| v0_10(void) = ReturnVoid : -# 91| v0_11(void) = UnmodeledUse : mu* -# 91| v0_12(void) = AliasedUse : ~mu0_2 -# 91| v0_13(void) = ExitFunction : +# 91| v91_1(void) = EnterFunction : +# 91| mu91_2(unknown) = AliasedDefinition : +# 91| mu91_3(unknown) = UnmodeledDefinition : +# 91| r91_4(glval) = VariableAddress[a] : +# 91| m91_5(Point) = InitializeParameter[a] : &:r91_4 +# 92| r92_1(glval) = VariableAddress[b] : +# 92| r92_2(glval) = VariableAddress[a] : +# 92| r92_3(Point) = Load : &:r92_2, m91_5 +# 92| m92_4(Point) = Store : &:r92_1, r92_3 +# 93| v93_1(void) = NoOp : +# 91| v91_6(void) = ReturnVoid : +# 91| v91_7(void) = UnmodeledUse : mu* +# 91| v91_8(void) = AliasedUse : ~mu91_3 +# 91| v91_9(void) = ExitFunction : # 95| void MustExactlyOverlapEscaped(Point) # 95| Block 0 -# 95| v0_0(void) = EnterFunction : -# 95| mu0_1(unknown) = AliasedDefinition : -# 95| mu0_2(unknown) = UnmodeledDefinition : -# 95| r0_3(glval) = VariableAddress[a] : -# 95| mu0_4(Point) = InitializeParameter[a] : &:r0_3 -# 96| r0_5(glval) = VariableAddress[b] : -# 96| r0_6(glval) = VariableAddress[a] : -# 96| r0_7(Point) = Load : &:r0_6, ~mu0_2 -# 96| m0_8(Point) = Store : &:r0_5, r0_7 -# 97| r0_9(glval) = FunctionAddress[Escape] : -# 97| r0_10(glval) = VariableAddress[a] : -# 97| r0_11(Point *) = CopyValue : r0_10 -# 97| r0_12(void *) = Convert : r0_11 -# 97| v0_13(void) = Call : func:r0_9, 0:r0_12 -# 97| mu0_14(unknown) = ^CallSideEffect : ~mu0_2 -# 97| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_12, ~mu0_2 -# 97| mu0_16(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_12 -# 98| v0_17(void) = NoOp : -# 95| v0_18(void) = ReturnVoid : -# 95| v0_19(void) = UnmodeledUse : mu* -# 95| v0_20(void) = AliasedUse : ~mu0_2 -# 95| v0_21(void) = ExitFunction : +# 95| v95_1(void) = EnterFunction : +# 95| mu95_2(unknown) = AliasedDefinition : +# 95| mu95_3(unknown) = UnmodeledDefinition : +# 95| r95_4(glval) = VariableAddress[a] : +# 95| mu95_5(Point) = InitializeParameter[a] : &:r95_4 +# 96| r96_1(glval) = VariableAddress[b] : +# 96| r96_2(glval) = VariableAddress[a] : +# 96| r96_3(Point) = Load : &:r96_2, ~mu95_3 +# 96| m96_4(Point) = Store : &:r96_1, r96_3 +# 97| r97_1(glval) = FunctionAddress[Escape] : +# 97| r97_2(glval) = VariableAddress[a] : +# 97| r97_3(Point *) = CopyValue : r97_2 +# 97| r97_4(void *) = Convert : r97_3 +# 97| v97_5(void) = Call : func:r97_1, 0:r97_4 +# 97| mu97_6(unknown) = ^CallSideEffect : ~mu95_3 +# 97| v97_7(void) = ^BufferReadSideEffect[0] : &:r97_4, ~mu95_3 +# 97| mu97_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r97_4 +# 98| v98_1(void) = NoOp : +# 95| v95_6(void) = ReturnVoid : +# 95| v95_7(void) = UnmodeledUse : mu* +# 95| v95_8(void) = AliasedUse : ~mu95_3 +# 95| v95_9(void) = ExitFunction : # 100| void MustTotallyOverlap(Point) # 100| Block 0 -# 100| v0_0(void) = EnterFunction : -# 100| mu0_1(unknown) = AliasedDefinition : -# 100| mu0_2(unknown) = UnmodeledDefinition : -# 100| r0_3(glval) = VariableAddress[a] : -# 100| mu0_4(Point) = InitializeParameter[a] : &:r0_3 -# 101| r0_5(glval) = VariableAddress[x] : -# 101| r0_6(glval) = VariableAddress[a] : -# 101| r0_7(glval) = FieldAddress[x] : r0_6 -# 101| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 101| m0_9(int) = Store : &:r0_5, r0_8 -# 102| r0_10(glval) = VariableAddress[y] : -# 102| r0_11(glval) = VariableAddress[a] : -# 102| r0_12(glval) = FieldAddress[y] : r0_11 -# 102| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 102| m0_14(int) = Store : &:r0_10, r0_13 -# 103| v0_15(void) = NoOp : -# 100| v0_16(void) = ReturnVoid : -# 100| v0_17(void) = UnmodeledUse : mu* -# 100| v0_18(void) = AliasedUse : ~mu0_2 -# 100| v0_19(void) = ExitFunction : +# 100| v100_1(void) = EnterFunction : +# 100| mu100_2(unknown) = AliasedDefinition : +# 100| mu100_3(unknown) = UnmodeledDefinition : +# 100| r100_4(glval) = VariableAddress[a] : +# 100| mu100_5(Point) = InitializeParameter[a] : &:r100_4 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(glval) = VariableAddress[a] : +# 101| r101_3(glval) = FieldAddress[x] : r101_2 +# 101| r101_4(int) = Load : &:r101_3, ~mu100_3 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 102| r102_1(glval) = VariableAddress[y] : +# 102| r102_2(glval) = VariableAddress[a] : +# 102| r102_3(glval) = FieldAddress[y] : r102_2 +# 102| r102_4(int) = Load : &:r102_3, ~mu100_3 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 103| v103_1(void) = NoOp : +# 100| v100_6(void) = ReturnVoid : +# 100| v100_7(void) = UnmodeledUse : mu* +# 100| v100_8(void) = AliasedUse : ~mu100_3 +# 100| v100_9(void) = ExitFunction : # 105| void MustTotallyOverlapEscaped(Point) # 105| Block 0 -# 105| v0_0(void) = EnterFunction : -# 105| mu0_1(unknown) = AliasedDefinition : -# 105| mu0_2(unknown) = UnmodeledDefinition : -# 105| r0_3(glval) = VariableAddress[a] : -# 105| mu0_4(Point) = InitializeParameter[a] : &:r0_3 -# 106| r0_5(glval) = VariableAddress[x] : -# 106| r0_6(glval) = VariableAddress[a] : -# 106| r0_7(glval) = FieldAddress[x] : r0_6 -# 106| r0_8(int) = Load : &:r0_7, ~mu0_2 -# 106| m0_9(int) = Store : &:r0_5, r0_8 -# 107| r0_10(glval) = VariableAddress[y] : -# 107| r0_11(glval) = VariableAddress[a] : -# 107| r0_12(glval) = FieldAddress[y] : r0_11 -# 107| r0_13(int) = Load : &:r0_12, ~mu0_2 -# 107| m0_14(int) = Store : &:r0_10, r0_13 -# 108| r0_15(glval) = FunctionAddress[Escape] : -# 108| r0_16(glval) = VariableAddress[a] : -# 108| r0_17(Point *) = CopyValue : r0_16 -# 108| r0_18(void *) = Convert : r0_17 -# 108| v0_19(void) = Call : func:r0_15, 0:r0_18 -# 108| mu0_20(unknown) = ^CallSideEffect : ~mu0_2 -# 108| v0_21(void) = ^BufferReadSideEffect[0] : &:r0_18, ~mu0_2 -# 108| mu0_22(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_18 -# 109| v0_23(void) = NoOp : -# 105| v0_24(void) = ReturnVoid : -# 105| v0_25(void) = UnmodeledUse : mu* -# 105| v0_26(void) = AliasedUse : ~mu0_2 -# 105| v0_27(void) = ExitFunction : +# 105| v105_1(void) = EnterFunction : +# 105| mu105_2(unknown) = AliasedDefinition : +# 105| mu105_3(unknown) = UnmodeledDefinition : +# 105| r105_4(glval) = VariableAddress[a] : +# 105| mu105_5(Point) = InitializeParameter[a] : &:r105_4 +# 106| r106_1(glval) = VariableAddress[x] : +# 106| r106_2(glval) = VariableAddress[a] : +# 106| r106_3(glval) = FieldAddress[x] : r106_2 +# 106| r106_4(int) = Load : &:r106_3, ~mu105_3 +# 106| m106_5(int) = Store : &:r106_1, r106_4 +# 107| r107_1(glval) = VariableAddress[y] : +# 107| r107_2(glval) = VariableAddress[a] : +# 107| r107_3(glval) = FieldAddress[y] : r107_2 +# 107| r107_4(int) = Load : &:r107_3, ~mu105_3 +# 107| m107_5(int) = Store : &:r107_1, r107_4 +# 108| r108_1(glval) = FunctionAddress[Escape] : +# 108| r108_2(glval) = VariableAddress[a] : +# 108| r108_3(Point *) = CopyValue : r108_2 +# 108| r108_4(void *) = Convert : r108_3 +# 108| v108_5(void) = Call : func:r108_1, 0:r108_4 +# 108| mu108_6(unknown) = ^CallSideEffect : ~mu105_3 +# 108| v108_7(void) = ^BufferReadSideEffect[0] : &:r108_4, ~mu105_3 +# 108| mu108_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r108_4 +# 109| v109_1(void) = NoOp : +# 105| v105_6(void) = ReturnVoid : +# 105| v105_7(void) = UnmodeledUse : mu* +# 105| v105_8(void) = AliasedUse : ~mu105_3 +# 105| v105_9(void) = ExitFunction : # 111| void MayPartiallyOverlap(int, int) # 111| Block 0 -# 111| v0_0(void) = EnterFunction : -# 111| mu0_1(unknown) = AliasedDefinition : -# 111| mu0_2(unknown) = UnmodeledDefinition : -# 111| r0_3(glval) = VariableAddress[x] : -# 111| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 111| r0_5(glval) = VariableAddress[y] : -# 111| m0_6(int) = InitializeParameter[y] : &:r0_5 -# 112| r0_7(glval) = VariableAddress[a] : -# 112| mu0_8(Point) = Uninitialized[a] : &:r0_7 -# 112| r0_9(glval) = FieldAddress[x] : r0_7 -# 112| r0_10(glval) = VariableAddress[x] : -# 112| r0_11(int) = Load : &:r0_10, m0_4 -# 112| mu0_12(int) = Store : &:r0_9, r0_11 -# 112| r0_13(glval) = FieldAddress[y] : r0_7 -# 112| r0_14(glval) = VariableAddress[y] : -# 112| r0_15(int) = Load : &:r0_14, m0_6 -# 112| mu0_16(int) = Store : &:r0_13, r0_15 -# 113| r0_17(glval) = VariableAddress[b] : -# 113| r0_18(glval) = VariableAddress[a] : -# 113| r0_19(Point) = Load : &:r0_18, ~mu0_2 -# 113| m0_20(Point) = Store : &:r0_17, r0_19 -# 114| v0_21(void) = NoOp : -# 111| v0_22(void) = ReturnVoid : -# 111| v0_23(void) = UnmodeledUse : mu* -# 111| v0_24(void) = AliasedUse : ~mu0_2 -# 111| v0_25(void) = ExitFunction : +# 111| v111_1(void) = EnterFunction : +# 111| mu111_2(unknown) = AliasedDefinition : +# 111| mu111_3(unknown) = UnmodeledDefinition : +# 111| r111_4(glval) = VariableAddress[x] : +# 111| m111_5(int) = InitializeParameter[x] : &:r111_4 +# 111| r111_6(glval) = VariableAddress[y] : +# 111| m111_7(int) = InitializeParameter[y] : &:r111_6 +# 112| r112_1(glval) = VariableAddress[a] : +# 112| mu112_2(Point) = Uninitialized[a] : &:r112_1 +# 112| r112_3(glval) = FieldAddress[x] : r112_1 +# 112| r112_4(glval) = VariableAddress[x] : +# 112| r112_5(int) = Load : &:r112_4, m111_5 +# 112| mu112_6(int) = Store : &:r112_3, r112_5 +# 112| r112_7(glval) = FieldAddress[y] : r112_1 +# 112| r112_8(glval) = VariableAddress[y] : +# 112| r112_9(int) = Load : &:r112_8, m111_7 +# 112| mu112_10(int) = Store : &:r112_7, r112_9 +# 113| r113_1(glval) = VariableAddress[b] : +# 113| r113_2(glval) = VariableAddress[a] : +# 113| r113_3(Point) = Load : &:r113_2, ~mu111_3 +# 113| m113_4(Point) = Store : &:r113_1, r113_3 +# 114| v114_1(void) = NoOp : +# 111| v111_8(void) = ReturnVoid : +# 111| v111_9(void) = UnmodeledUse : mu* +# 111| v111_10(void) = AliasedUse : ~mu111_3 +# 111| v111_11(void) = ExitFunction : # 116| void MayPartiallyOverlapEscaped(int, int) # 116| Block 0 -# 116| v0_0(void) = EnterFunction : -# 116| mu0_1(unknown) = AliasedDefinition : -# 116| mu0_2(unknown) = UnmodeledDefinition : -# 116| r0_3(glval) = VariableAddress[x] : -# 116| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 116| r0_5(glval) = VariableAddress[y] : -# 116| m0_6(int) = InitializeParameter[y] : &:r0_5 -# 117| r0_7(glval) = VariableAddress[a] : -# 117| mu0_8(Point) = Uninitialized[a] : &:r0_7 -# 117| r0_9(glval) = FieldAddress[x] : r0_7 -# 117| r0_10(glval) = VariableAddress[x] : -# 117| r0_11(int) = Load : &:r0_10, m0_4 -# 117| mu0_12(int) = Store : &:r0_9, r0_11 -# 117| r0_13(glval) = FieldAddress[y] : r0_7 -# 117| r0_14(glval) = VariableAddress[y] : -# 117| r0_15(int) = Load : &:r0_14, m0_6 -# 117| mu0_16(int) = Store : &:r0_13, r0_15 -# 118| r0_17(glval) = VariableAddress[b] : -# 118| r0_18(glval) = VariableAddress[a] : -# 118| r0_19(Point) = Load : &:r0_18, ~mu0_2 -# 118| m0_20(Point) = Store : &:r0_17, r0_19 -# 119| r0_21(glval) = FunctionAddress[Escape] : -# 119| r0_22(glval) = VariableAddress[a] : -# 119| r0_23(Point *) = CopyValue : r0_22 -# 119| r0_24(void *) = Convert : r0_23 -# 119| v0_25(void) = Call : func:r0_21, 0:r0_24 -# 119| mu0_26(unknown) = ^CallSideEffect : ~mu0_2 -# 119| v0_27(void) = ^BufferReadSideEffect[0] : &:r0_24, ~mu0_2 -# 119| mu0_28(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_24 -# 120| v0_29(void) = NoOp : -# 116| v0_30(void) = ReturnVoid : -# 116| v0_31(void) = UnmodeledUse : mu* -# 116| v0_32(void) = AliasedUse : ~mu0_2 -# 116| v0_33(void) = ExitFunction : +# 116| v116_1(void) = EnterFunction : +# 116| mu116_2(unknown) = AliasedDefinition : +# 116| mu116_3(unknown) = UnmodeledDefinition : +# 116| r116_4(glval) = VariableAddress[x] : +# 116| m116_5(int) = InitializeParameter[x] : &:r116_4 +# 116| r116_6(glval) = VariableAddress[y] : +# 116| m116_7(int) = InitializeParameter[y] : &:r116_6 +# 117| r117_1(glval) = VariableAddress[a] : +# 117| mu117_2(Point) = Uninitialized[a] : &:r117_1 +# 117| r117_3(glval) = FieldAddress[x] : r117_1 +# 117| r117_4(glval) = VariableAddress[x] : +# 117| r117_5(int) = Load : &:r117_4, m116_5 +# 117| mu117_6(int) = Store : &:r117_3, r117_5 +# 117| r117_7(glval) = FieldAddress[y] : r117_1 +# 117| r117_8(glval) = VariableAddress[y] : +# 117| r117_9(int) = Load : &:r117_8, m116_7 +# 117| mu117_10(int) = Store : &:r117_7, r117_9 +# 118| r118_1(glval) = VariableAddress[b] : +# 118| r118_2(glval) = VariableAddress[a] : +# 118| r118_3(Point) = Load : &:r118_2, ~mu116_3 +# 118| m118_4(Point) = Store : &:r118_1, r118_3 +# 119| r119_1(glval) = FunctionAddress[Escape] : +# 119| r119_2(glval) = VariableAddress[a] : +# 119| r119_3(Point *) = CopyValue : r119_2 +# 119| r119_4(void *) = Convert : r119_3 +# 119| v119_5(void) = Call : func:r119_1, 0:r119_4 +# 119| mu119_6(unknown) = ^CallSideEffect : ~mu116_3 +# 119| v119_7(void) = ^BufferReadSideEffect[0] : &:r119_4, ~mu116_3 +# 119| mu119_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r119_4 +# 120| v120_1(void) = NoOp : +# 116| v116_8(void) = ReturnVoid : +# 116| v116_9(void) = UnmodeledUse : mu* +# 116| v116_10(void) = AliasedUse : ~mu116_3 +# 116| v116_11(void) = ExitFunction : # 122| void MergeMustExactlyOverlap(bool, int, int) # 122| Block 0 -# 122| v0_0(void) = EnterFunction : -# 122| mu0_1(unknown) = AliasedDefinition : -# 122| mu0_2(unknown) = UnmodeledDefinition : -# 122| r0_3(glval) = VariableAddress[c] : -# 122| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 122| r0_5(glval) = VariableAddress[x1] : -# 122| m0_6(int) = InitializeParameter[x1] : &:r0_5 -# 122| r0_7(glval) = VariableAddress[x2] : -# 122| m0_8(int) = InitializeParameter[x2] : &:r0_7 -# 123| r0_9(glval) = VariableAddress[a] : -# 123| mu0_10(Point) = Uninitialized[a] : &:r0_9 -# 123| r0_11(glval) = FieldAddress[x] : r0_9 -# 123| r0_12(int) = Constant[0] : -# 123| mu0_13(int) = Store : &:r0_11, r0_12 -# 123| r0_14(glval) = FieldAddress[y] : r0_9 -# 123| r0_15(int) = Constant[0] : -# 123| mu0_16(int) = Store : &:r0_14, r0_15 -# 124| r0_17(glval) = VariableAddress[c] : -# 124| r0_18(bool) = Load : &:r0_17, m0_4 -# 124| v0_19(void) = ConditionalBranch : r0_18 +# 122| v122_1(void) = EnterFunction : +# 122| mu122_2(unknown) = AliasedDefinition : +# 122| mu122_3(unknown) = UnmodeledDefinition : +# 122| r122_4(glval) = VariableAddress[c] : +# 122| m122_5(bool) = InitializeParameter[c] : &:r122_4 +# 122| r122_6(glval) = VariableAddress[x1] : +# 122| m122_7(int) = InitializeParameter[x1] : &:r122_6 +# 122| r122_8(glval) = VariableAddress[x2] : +# 122| m122_9(int) = InitializeParameter[x2] : &:r122_8 +# 123| r123_1(glval) = VariableAddress[a] : +# 123| mu123_2(Point) = Uninitialized[a] : &:r123_1 +# 123| r123_3(glval) = FieldAddress[x] : r123_1 +# 123| r123_4(int) = Constant[0] : +# 123| mu123_5(int) = Store : &:r123_3, r123_4 +# 123| r123_6(glval) = FieldAddress[y] : r123_1 +# 123| r123_7(int) = Constant[0] : +# 123| mu123_8(int) = Store : &:r123_6, r123_7 +# 124| r124_1(glval) = VariableAddress[c] : +# 124| r124_2(bool) = Load : &:r124_1, m122_5 +# 124| v124_3(void) = ConditionalBranch : r124_2 #-----| False -> Block 2 #-----| True -> Block 1 # 125| Block 1 -# 125| r1_0(glval) = VariableAddress[x1] : -# 125| r1_1(int) = Load : &:r1_0, m0_6 -# 125| r1_2(glval) = VariableAddress[a] : -# 125| r1_3(glval) = FieldAddress[x] : r1_2 -# 125| mu1_4(int) = Store : &:r1_3, r1_1 +# 125| r125_1(glval) = VariableAddress[x1] : +# 125| r125_2(int) = Load : &:r125_1, m122_7 +# 125| r125_3(glval) = VariableAddress[a] : +# 125| r125_4(glval) = FieldAddress[x] : r125_3 +# 125| mu125_5(int) = Store : &:r125_4, r125_2 #-----| Goto -> Block 3 # 128| Block 2 -# 128| r2_0(glval) = VariableAddress[x2] : -# 128| r2_1(int) = Load : &:r2_0, m0_8 -# 128| r2_2(glval) = VariableAddress[a] : -# 128| r2_3(glval) = FieldAddress[x] : r2_2 -# 128| mu2_4(int) = Store : &:r2_3, r2_1 +# 128| r128_1(glval) = VariableAddress[x2] : +# 128| r128_2(int) = Load : &:r128_1, m122_9 +# 128| r128_3(glval) = VariableAddress[a] : +# 128| r128_4(glval) = FieldAddress[x] : r128_3 +# 128| mu128_5(int) = Store : &:r128_4, r128_2 #-----| Goto -> Block 3 # 130| Block 3 -# 130| r3_0(glval) = VariableAddress[x] : -# 130| r3_1(glval) = VariableAddress[a] : -# 130| r3_2(glval) = FieldAddress[x] : r3_1 -# 130| r3_3(int) = Load : &:r3_2, ~mu0_2 -# 130| m3_4(int) = Store : &:r3_0, r3_3 -# 131| r3_5(glval) = VariableAddress[b] : -# 131| r3_6(glval) = VariableAddress[a] : -# 131| r3_7(Point) = Load : &:r3_6, ~mu0_2 -# 131| m3_8(Point) = Store : &:r3_5, r3_7 -# 132| v3_9(void) = NoOp : -# 122| v3_10(void) = ReturnVoid : -# 122| v3_11(void) = UnmodeledUse : mu* -# 122| v3_12(void) = AliasedUse : ~mu0_2 -# 122| v3_13(void) = ExitFunction : +# 130| r130_1(glval) = VariableAddress[x] : +# 130| r130_2(glval) = VariableAddress[a] : +# 130| r130_3(glval) = FieldAddress[x] : r130_2 +# 130| r130_4(int) = Load : &:r130_3, ~mu122_3 +# 130| m130_5(int) = Store : &:r130_1, r130_4 +# 131| r131_1(glval) = VariableAddress[b] : +# 131| r131_2(glval) = VariableAddress[a] : +# 131| r131_3(Point) = Load : &:r131_2, ~mu122_3 +# 131| m131_4(Point) = Store : &:r131_1, r131_3 +# 132| v132_1(void) = NoOp : +# 122| v122_10(void) = ReturnVoid : +# 122| v122_11(void) = UnmodeledUse : mu* +# 122| v122_12(void) = AliasedUse : ~mu122_3 +# 122| v122_13(void) = ExitFunction : # 134| void MergeMustExactlyWithMustTotallyOverlap(bool, Point, int) # 134| Block 0 -# 134| v0_0(void) = EnterFunction : -# 134| mu0_1(unknown) = AliasedDefinition : -# 134| mu0_2(unknown) = UnmodeledDefinition : -# 134| r0_3(glval) = VariableAddress[c] : -# 134| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 134| r0_5(glval) = VariableAddress[p] : -# 134| m0_6(Point) = InitializeParameter[p] : &:r0_5 -# 134| r0_7(glval) = VariableAddress[x1] : -# 134| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 135| r0_9(glval) = VariableAddress[a] : -# 135| mu0_10(Point) = Uninitialized[a] : &:r0_9 -# 135| r0_11(glval) = FieldAddress[x] : r0_9 -# 135| r0_12(int) = Constant[0] : -# 135| mu0_13(int) = Store : &:r0_11, r0_12 -# 135| r0_14(glval) = FieldAddress[y] : r0_9 -# 135| r0_15(int) = Constant[0] : -# 135| mu0_16(int) = Store : &:r0_14, r0_15 -# 136| r0_17(glval) = VariableAddress[c] : -# 136| r0_18(bool) = Load : &:r0_17, m0_4 -# 136| v0_19(void) = ConditionalBranch : r0_18 +# 134| v134_1(void) = EnterFunction : +# 134| mu134_2(unknown) = AliasedDefinition : +# 134| mu134_3(unknown) = UnmodeledDefinition : +# 134| r134_4(glval) = VariableAddress[c] : +# 134| m134_5(bool) = InitializeParameter[c] : &:r134_4 +# 134| r134_6(glval) = VariableAddress[p] : +# 134| m134_7(Point) = InitializeParameter[p] : &:r134_6 +# 134| r134_8(glval) = VariableAddress[x1] : +# 134| m134_9(int) = InitializeParameter[x1] : &:r134_8 +# 135| r135_1(glval) = VariableAddress[a] : +# 135| mu135_2(Point) = Uninitialized[a] : &:r135_1 +# 135| r135_3(glval) = FieldAddress[x] : r135_1 +# 135| r135_4(int) = Constant[0] : +# 135| mu135_5(int) = Store : &:r135_3, r135_4 +# 135| r135_6(glval) = FieldAddress[y] : r135_1 +# 135| r135_7(int) = Constant[0] : +# 135| mu135_8(int) = Store : &:r135_6, r135_7 +# 136| r136_1(glval) = VariableAddress[c] : +# 136| r136_2(bool) = Load : &:r136_1, m134_5 +# 136| v136_3(void) = ConditionalBranch : r136_2 #-----| False -> Block 2 #-----| True -> Block 1 # 137| Block 1 -# 137| r1_0(glval) = VariableAddress[x1] : -# 137| r1_1(int) = Load : &:r1_0, m0_8 -# 137| r1_2(glval) = VariableAddress[a] : -# 137| r1_3(glval) = FieldAddress[x] : r1_2 -# 137| mu1_4(int) = Store : &:r1_3, r1_1 +# 137| r137_1(glval) = VariableAddress[x1] : +# 137| r137_2(int) = Load : &:r137_1, m134_9 +# 137| r137_3(glval) = VariableAddress[a] : +# 137| r137_4(glval) = FieldAddress[x] : r137_3 +# 137| mu137_5(int) = Store : &:r137_4, r137_2 #-----| Goto -> Block 3 # 140| Block 2 -# 140| r2_0(glval) = VariableAddress[p] : -# 140| r2_1(Point) = Load : &:r2_0, m0_6 -# 140| r2_2(glval) = VariableAddress[a] : -# 140| mu2_3(Point) = Store : &:r2_2, r2_1 +# 140| r140_1(glval) = VariableAddress[p] : +# 140| r140_2(Point) = Load : &:r140_1, m134_7 +# 140| r140_3(glval) = VariableAddress[a] : +# 140| mu140_4(Point) = Store : &:r140_3, r140_2 #-----| Goto -> Block 3 # 142| Block 3 -# 142| r3_0(glval) = VariableAddress[x] : -# 142| r3_1(glval) = VariableAddress[a] : -# 142| r3_2(glval) = FieldAddress[x] : r3_1 -# 142| r3_3(int) = Load : &:r3_2, ~mu0_2 -# 142| m3_4(int) = Store : &:r3_0, r3_3 -# 143| v3_5(void) = NoOp : -# 134| v3_6(void) = ReturnVoid : -# 134| v3_7(void) = UnmodeledUse : mu* -# 134| v3_8(void) = AliasedUse : ~mu0_2 -# 134| v3_9(void) = ExitFunction : +# 142| r142_1(glval) = VariableAddress[x] : +# 142| r142_2(glval) = VariableAddress[a] : +# 142| r142_3(glval) = FieldAddress[x] : r142_2 +# 142| r142_4(int) = Load : &:r142_3, ~mu134_3 +# 142| m142_5(int) = Store : &:r142_1, r142_4 +# 143| v143_1(void) = NoOp : +# 134| v134_10(void) = ReturnVoid : +# 134| v134_11(void) = UnmodeledUse : mu* +# 134| v134_12(void) = AliasedUse : ~mu134_3 +# 134| v134_13(void) = ExitFunction : # 145| void MergeMustExactlyWithMayPartiallyOverlap(bool, Point, int) # 145| Block 0 -# 145| v0_0(void) = EnterFunction : -# 145| mu0_1(unknown) = AliasedDefinition : -# 145| mu0_2(unknown) = UnmodeledDefinition : -# 145| r0_3(glval) = VariableAddress[c] : -# 145| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 145| r0_5(glval) = VariableAddress[p] : -# 145| m0_6(Point) = InitializeParameter[p] : &:r0_5 -# 145| r0_7(glval) = VariableAddress[x1] : -# 145| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 146| r0_9(glval) = VariableAddress[a] : -# 146| mu0_10(Point) = Uninitialized[a] : &:r0_9 -# 146| r0_11(glval) = FieldAddress[x] : r0_9 -# 146| r0_12(int) = Constant[0] : -# 146| mu0_13(int) = Store : &:r0_11, r0_12 -# 146| r0_14(glval) = FieldAddress[y] : r0_9 -# 146| r0_15(int) = Constant[0] : -# 146| mu0_16(int) = Store : &:r0_14, r0_15 -# 147| r0_17(glval) = VariableAddress[c] : -# 147| r0_18(bool) = Load : &:r0_17, m0_4 -# 147| v0_19(void) = ConditionalBranch : r0_18 +# 145| v145_1(void) = EnterFunction : +# 145| mu145_2(unknown) = AliasedDefinition : +# 145| mu145_3(unknown) = UnmodeledDefinition : +# 145| r145_4(glval) = VariableAddress[c] : +# 145| m145_5(bool) = InitializeParameter[c] : &:r145_4 +# 145| r145_6(glval) = VariableAddress[p] : +# 145| m145_7(Point) = InitializeParameter[p] : &:r145_6 +# 145| r145_8(glval) = VariableAddress[x1] : +# 145| m145_9(int) = InitializeParameter[x1] : &:r145_8 +# 146| r146_1(glval) = VariableAddress[a] : +# 146| mu146_2(Point) = Uninitialized[a] : &:r146_1 +# 146| r146_3(glval) = FieldAddress[x] : r146_1 +# 146| r146_4(int) = Constant[0] : +# 146| mu146_5(int) = Store : &:r146_3, r146_4 +# 146| r146_6(glval) = FieldAddress[y] : r146_1 +# 146| r146_7(int) = Constant[0] : +# 146| mu146_8(int) = Store : &:r146_6, r146_7 +# 147| r147_1(glval) = VariableAddress[c] : +# 147| r147_2(bool) = Load : &:r147_1, m145_5 +# 147| v147_3(void) = ConditionalBranch : r147_2 #-----| False -> Block 2 #-----| True -> Block 1 # 148| Block 1 -# 148| r1_0(glval) = VariableAddress[x1] : -# 148| r1_1(int) = Load : &:r1_0, m0_8 -# 148| r1_2(glval) = VariableAddress[a] : -# 148| r1_3(glval) = FieldAddress[x] : r1_2 -# 148| mu1_4(int) = Store : &:r1_3, r1_1 +# 148| r148_1(glval) = VariableAddress[x1] : +# 148| r148_2(int) = Load : &:r148_1, m145_9 +# 148| r148_3(glval) = VariableAddress[a] : +# 148| r148_4(glval) = FieldAddress[x] : r148_3 +# 148| mu148_5(int) = Store : &:r148_4, r148_2 #-----| Goto -> Block 3 # 151| Block 2 -# 151| r2_0(glval) = VariableAddress[p] : -# 151| r2_1(Point) = Load : &:r2_0, m0_6 -# 151| r2_2(glval) = VariableAddress[a] : -# 151| mu2_3(Point) = Store : &:r2_2, r2_1 +# 151| r151_1(glval) = VariableAddress[p] : +# 151| r151_2(Point) = Load : &:r151_1, m145_7 +# 151| r151_3(glval) = VariableAddress[a] : +# 151| mu151_4(Point) = Store : &:r151_3, r151_2 #-----| Goto -> Block 3 # 153| Block 3 -# 153| r3_0(glval) = VariableAddress[b] : -# 153| r3_1(glval) = VariableAddress[a] : -# 153| r3_2(Point) = Load : &:r3_1, ~mu0_2 -# 153| m3_3(Point) = Store : &:r3_0, r3_2 -# 154| v3_4(void) = NoOp : -# 145| v3_5(void) = ReturnVoid : -# 145| v3_6(void) = UnmodeledUse : mu* -# 145| v3_7(void) = AliasedUse : ~mu0_2 -# 145| v3_8(void) = ExitFunction : +# 153| r153_1(glval) = VariableAddress[b] : +# 153| r153_2(glval) = VariableAddress[a] : +# 153| r153_3(Point) = Load : &:r153_2, ~mu145_3 +# 153| m153_4(Point) = Store : &:r153_1, r153_3 +# 154| v154_1(void) = NoOp : +# 145| v145_10(void) = ReturnVoid : +# 145| v145_11(void) = UnmodeledUse : mu* +# 145| v145_12(void) = AliasedUse : ~mu145_3 +# 145| v145_13(void) = ExitFunction : # 156| void MergeMustTotallyOverlapWithMayPartiallyOverlap(bool, Rect, int) # 156| Block 0 -# 156| v0_0(void) = EnterFunction : -# 156| mu0_1(unknown) = AliasedDefinition : -# 156| mu0_2(unknown) = UnmodeledDefinition : -# 156| r0_3(glval) = VariableAddress[c] : -# 156| m0_4(bool) = InitializeParameter[c] : &:r0_3 -# 156| r0_5(glval) = VariableAddress[r] : -# 156| m0_6(Rect) = InitializeParameter[r] : &:r0_5 -# 156| r0_7(glval) = VariableAddress[x1] : -# 156| m0_8(int) = InitializeParameter[x1] : &:r0_7 -# 157| r0_9(glval) = VariableAddress[a] : -# 157| mu0_10(Rect) = Uninitialized[a] : &:r0_9 -# 157| r0_11(glval) = FieldAddress[topLeft] : r0_9 -# 157| r0_12(Point) = Constant[0] : -# 157| mu0_13(Point) = Store : &:r0_11, r0_12 -# 157| r0_14(glval) = FieldAddress[bottomRight] : r0_9 -# 157| r0_15(Point) = Constant[0] : -# 157| mu0_16(Point) = Store : &:r0_14, r0_15 -# 158| r0_17(glval) = VariableAddress[c] : -# 158| r0_18(bool) = Load : &:r0_17, m0_4 -# 158| v0_19(void) = ConditionalBranch : r0_18 +# 156| v156_1(void) = EnterFunction : +# 156| mu156_2(unknown) = AliasedDefinition : +# 156| mu156_3(unknown) = UnmodeledDefinition : +# 156| r156_4(glval) = VariableAddress[c] : +# 156| m156_5(bool) = InitializeParameter[c] : &:r156_4 +# 156| r156_6(glval) = VariableAddress[r] : +# 156| m156_7(Rect) = InitializeParameter[r] : &:r156_6 +# 156| r156_8(glval) = VariableAddress[x1] : +# 156| m156_9(int) = InitializeParameter[x1] : &:r156_8 +# 157| r157_1(glval) = VariableAddress[a] : +# 157| mu157_2(Rect) = Uninitialized[a] : &:r157_1 +# 157| r157_3(glval) = FieldAddress[topLeft] : r157_1 +# 157| r157_4(Point) = Constant[0] : +# 157| mu157_5(Point) = Store : &:r157_3, r157_4 +# 157| r157_6(glval) = FieldAddress[bottomRight] : r157_1 +# 157| r157_7(Point) = Constant[0] : +# 157| mu157_8(Point) = Store : &:r157_6, r157_7 +# 158| r158_1(glval) = VariableAddress[c] : +# 158| r158_2(bool) = Load : &:r158_1, m156_5 +# 158| v158_3(void) = ConditionalBranch : r158_2 #-----| False -> Block 2 #-----| True -> Block 1 # 159| Block 1 -# 159| r1_0(glval) = VariableAddress[x1] : -# 159| r1_1(int) = Load : &:r1_0, m0_8 -# 159| r1_2(glval) = VariableAddress[a] : -# 159| r1_3(glval) = FieldAddress[topLeft] : r1_2 -# 159| r1_4(glval) = FieldAddress[x] : r1_3 -# 159| mu1_5(int) = Store : &:r1_4, r1_1 +# 159| r159_1(glval) = VariableAddress[x1] : +# 159| r159_2(int) = Load : &:r159_1, m156_9 +# 159| r159_3(glval) = VariableAddress[a] : +# 159| r159_4(glval) = FieldAddress[topLeft] : r159_3 +# 159| r159_5(glval) = FieldAddress[x] : r159_4 +# 159| mu159_6(int) = Store : &:r159_5, r159_2 #-----| Goto -> Block 3 # 162| Block 2 -# 162| r2_0(glval) = VariableAddress[r] : -# 162| r2_1(Rect) = Load : &:r2_0, m0_6 -# 162| r2_2(glval) = VariableAddress[a] : -# 162| mu2_3(Rect) = Store : &:r2_2, r2_1 +# 162| r162_1(glval) = VariableAddress[r] : +# 162| r162_2(Rect) = Load : &:r162_1, m156_7 +# 162| r162_3(glval) = VariableAddress[a] : +# 162| mu162_4(Rect) = Store : &:r162_3, r162_2 #-----| Goto -> Block 3 # 164| Block 3 -# 164| r3_0(glval) = VariableAddress[b] : -# 164| r3_1(glval) = VariableAddress[a] : -# 164| r3_2(glval) = FieldAddress[topLeft] : r3_1 -# 164| r3_3(Point) = Load : &:r3_2, ~mu0_2 -# 164| m3_4(Point) = Store : &:r3_0, r3_3 -# 165| v3_5(void) = NoOp : -# 156| v3_6(void) = ReturnVoid : -# 156| v3_7(void) = UnmodeledUse : mu* -# 156| v3_8(void) = AliasedUse : ~mu0_2 -# 156| v3_9(void) = ExitFunction : +# 164| r164_1(glval) = VariableAddress[b] : +# 164| r164_2(glval) = VariableAddress[a] : +# 164| r164_3(glval) = FieldAddress[topLeft] : r164_2 +# 164| r164_4(Point) = Load : &:r164_3, ~mu156_3 +# 164| m164_5(Point) = Store : &:r164_1, r164_4 +# 165| v165_1(void) = NoOp : +# 156| v156_10(void) = ReturnVoid : +# 156| v156_11(void) = UnmodeledUse : mu* +# 156| v156_12(void) = AliasedUse : ~mu156_3 +# 156| v156_13(void) = ExitFunction : # 171| void WrapperStruct(Wrapper) # 171| Block 0 -# 171| v0_0(void) = EnterFunction : -# 171| mu0_1(unknown) = AliasedDefinition : -# 171| mu0_2(unknown) = UnmodeledDefinition : -# 171| r0_3(glval) = VariableAddress[w] : -# 171| mu0_4(Wrapper) = InitializeParameter[w] : &:r0_3 -# 172| r0_5(glval) = VariableAddress[x] : -# 172| r0_6(glval) = VariableAddress[w] : -# 172| r0_7(Wrapper) = Load : &:r0_6, ~mu0_2 -# 172| m0_8(Wrapper) = Store : &:r0_5, r0_7 -# 173| r0_9(glval) = VariableAddress[a] : -# 173| r0_10(glval) = VariableAddress[w] : -# 173| r0_11(glval) = FieldAddress[f] : r0_10 -# 173| r0_12(int) = Load : &:r0_11, ~mu0_2 -# 173| m0_13(int) = Store : &:r0_9, r0_12 -# 174| r0_14(int) = Constant[5] : -# 174| r0_15(glval) = VariableAddress[w] : -# 174| r0_16(glval) = FieldAddress[f] : r0_15 -# 174| mu0_17(int) = Store : &:r0_16, r0_14 -# 175| r0_18(glval) = VariableAddress[w] : -# 175| r0_19(glval) = FieldAddress[f] : r0_18 -# 175| r0_20(int) = Load : &:r0_19, ~mu0_2 -# 175| r0_21(glval) = VariableAddress[a] : -# 175| m0_22(int) = Store : &:r0_21, r0_20 -# 176| r0_23(glval) = VariableAddress[w] : -# 176| r0_24(Wrapper) = Load : &:r0_23, ~mu0_2 -# 176| r0_25(glval) = VariableAddress[x] : -# 176| m0_26(Wrapper) = Store : &:r0_25, r0_24 -# 177| v0_27(void) = NoOp : -# 171| v0_28(void) = ReturnVoid : -# 171| v0_29(void) = UnmodeledUse : mu* -# 171| v0_30(void) = AliasedUse : ~mu0_2 -# 171| v0_31(void) = ExitFunction : +# 171| v171_1(void) = EnterFunction : +# 171| mu171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[w] : +# 171| mu171_5(Wrapper) = InitializeParameter[w] : &:r171_4 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| r172_2(glval) = VariableAddress[w] : +# 172| r172_3(Wrapper) = Load : &:r172_2, ~mu171_3 +# 172| m172_4(Wrapper) = Store : &:r172_1, r172_3 +# 173| r173_1(glval) = VariableAddress[a] : +# 173| r173_2(glval) = VariableAddress[w] : +# 173| r173_3(glval) = FieldAddress[f] : r173_2 +# 173| r173_4(int) = Load : &:r173_3, ~mu171_3 +# 173| m173_5(int) = Store : &:r173_1, r173_4 +# 174| r174_1(int) = Constant[5] : +# 174| r174_2(glval) = VariableAddress[w] : +# 174| r174_3(glval) = FieldAddress[f] : r174_2 +# 174| mu174_4(int) = Store : &:r174_3, r174_1 +# 175| r175_1(glval) = VariableAddress[w] : +# 175| r175_2(glval) = FieldAddress[f] : r175_1 +# 175| r175_3(int) = Load : &:r175_2, ~mu171_3 +# 175| r175_4(glval) = VariableAddress[a] : +# 175| m175_5(int) = Store : &:r175_4, r175_3 +# 176| r176_1(glval) = VariableAddress[w] : +# 176| r176_2(Wrapper) = Load : &:r176_1, ~mu171_3 +# 176| r176_3(glval) = VariableAddress[x] : +# 176| m176_4(Wrapper) = Store : &:r176_3, r176_2 +# 177| v177_1(void) = NoOp : +# 171| v171_6(void) = ReturnVoid : +# 171| v171_7(void) = UnmodeledUse : mu* +# 171| v171_8(void) = AliasedUse : ~mu171_3 +# 171| v171_9(void) = ExitFunction : # 179| int AsmStmt(int*) # 179| Block 0 -# 179| v0_0(void) = EnterFunction : -# 179| mu0_1(unknown) = AliasedDefinition : -# 179| mu0_2(unknown) = UnmodeledDefinition : -# 179| r0_3(glval) = VariableAddress[p] : -# 179| m0_4(int *) = InitializeParameter[p] : &:r0_3 -# 180| mu0_5(unknown) = InlineAsm : ~mu0_2 -# 181| r0_6(glval) = VariableAddress[#return] : -# 181| r0_7(glval) = VariableAddress[p] : -# 181| r0_8(int *) = Load : &:r0_7, m0_4 -# 181| r0_9(int) = Load : &:r0_8, ~mu0_2 -# 181| m0_10(int) = Store : &:r0_6, r0_9 -# 179| r0_11(glval) = VariableAddress[#return] : -# 179| v0_12(void) = ReturnValue : &:r0_11, m0_10 -# 179| v0_13(void) = UnmodeledUse : mu* -# 179| v0_14(void) = AliasedUse : ~mu0_2 -# 179| v0_15(void) = ExitFunction : +# 179| v179_1(void) = EnterFunction : +# 179| mu179_2(unknown) = AliasedDefinition : +# 179| mu179_3(unknown) = UnmodeledDefinition : +# 179| r179_4(glval) = VariableAddress[p] : +# 179| m179_5(int *) = InitializeParameter[p] : &:r179_4 +# 180| mu180_1(unknown) = InlineAsm : ~mu179_3 +# 181| r181_1(glval) = VariableAddress[#return] : +# 181| r181_2(glval) = VariableAddress[p] : +# 181| r181_3(int *) = Load : &:r181_2, m179_5 +# 181| r181_4(int) = Load : &:r181_3, ~mu179_3 +# 181| m181_5(int) = Store : &:r181_1, r181_4 +# 179| r179_6(glval) = VariableAddress[#return] : +# 179| v179_7(void) = ReturnValue : &:r179_6, m181_5 +# 179| v179_8(void) = UnmodeledUse : mu* +# 179| v179_9(void) = AliasedUse : ~mu179_3 +# 179| v179_10(void) = ExitFunction : # 184| void AsmStmtWithOutputs(unsigned int&, unsigned int&, unsigned int&, unsigned int&) # 184| Block 0 -# 184| v0_0(void) = EnterFunction : -# 184| mu0_1(unknown) = AliasedDefinition : -# 184| mu0_2(unknown) = UnmodeledDefinition : -# 184| r0_3(glval) = VariableAddress[a] : -# 184| m0_4(unsigned int &) = InitializeParameter[a] : &:r0_3 -# 184| r0_5(glval) = VariableAddress[b] : -# 184| m0_6(unsigned int &) = InitializeParameter[b] : &:r0_5 -# 184| r0_7(glval) = VariableAddress[c] : -# 184| m0_8(unsigned int &) = InitializeParameter[c] : &:r0_7 -# 184| r0_9(glval) = VariableAddress[d] : -# 184| m0_10(unsigned int &) = InitializeParameter[d] : &:r0_9 -# 189| r0_11(glval) = VariableAddress[a] : -# 189| r0_12(unsigned int &) = Load : &:r0_11, m0_4 -# 189| r0_13(glval) = CopyValue : r0_12 -# 189| r0_14(glval) = VariableAddress[b] : -# 189| r0_15(unsigned int &) = Load : &:r0_14, m0_6 -# 189| r0_16(glval) = CopyValue : r0_15 -# 190| r0_17(glval) = VariableAddress[c] : -# 190| r0_18(unsigned int &) = Load : &:r0_17, m0_8 -# 190| r0_19(unsigned int) = Load : &:r0_18, ~mu0_2 -# 190| r0_20(glval) = VariableAddress[d] : -# 190| r0_21(unsigned int &) = Load : &:r0_20, m0_10 -# 190| r0_22(unsigned int) = Load : &:r0_21, ~mu0_2 -# 186| mu0_23(unknown) = InlineAsm : ~mu0_2, 0:r0_13, 1:r0_16, 2:r0_19, 3:r0_22 -# 192| v0_24(void) = NoOp : -# 184| v0_25(void) = ReturnVoid : -# 184| v0_26(void) = UnmodeledUse : mu* -# 184| v0_27(void) = AliasedUse : ~mu0_2 -# 184| v0_28(void) = ExitFunction : +# 184| v184_1(void) = EnterFunction : +# 184| mu184_2(unknown) = AliasedDefinition : +# 184| mu184_3(unknown) = UnmodeledDefinition : +# 184| r184_4(glval) = VariableAddress[a] : +# 184| m184_5(unsigned int &) = InitializeParameter[a] : &:r184_4 +# 184| r184_6(glval) = VariableAddress[b] : +# 184| m184_7(unsigned int &) = InitializeParameter[b] : &:r184_6 +# 184| r184_8(glval) = VariableAddress[c] : +# 184| m184_9(unsigned int &) = InitializeParameter[c] : &:r184_8 +# 184| r184_10(glval) = VariableAddress[d] : +# 184| m184_11(unsigned int &) = InitializeParameter[d] : &:r184_10 +# 189| r189_1(glval) = VariableAddress[a] : +# 189| r189_2(unsigned int &) = Load : &:r189_1, m184_5 +# 189| r189_3(glval) = CopyValue : r189_2 +# 189| r189_4(glval) = VariableAddress[b] : +# 189| r189_5(unsigned int &) = Load : &:r189_4, m184_7 +# 189| r189_6(glval) = CopyValue : r189_5 +# 190| r190_1(glval) = VariableAddress[c] : +# 190| r190_2(unsigned int &) = Load : &:r190_1, m184_9 +# 190| r190_3(unsigned int) = Load : &:r190_2, ~mu184_3 +# 190| r190_4(glval) = VariableAddress[d] : +# 190| r190_5(unsigned int &) = Load : &:r190_4, m184_11 +# 190| r190_6(unsigned int) = Load : &:r190_5, ~mu184_3 +# 186| mu186_1(unknown) = InlineAsm : ~mu184_3, 0:r189_3, 1:r189_6, 2:r190_3, 3:r190_6 +# 192| v192_1(void) = NoOp : +# 184| v184_12(void) = ReturnVoid : +# 184| v184_13(void) = UnmodeledUse : mu* +# 184| v184_14(void) = AliasedUse : ~mu184_3 +# 184| v184_15(void) = ExitFunction : # 198| int PureFunctions(char*, char*, int) # 198| Block 0 -# 198| v0_0(void) = EnterFunction : -# 198| mu0_1(unknown) = AliasedDefinition : -# 198| mu0_2(unknown) = UnmodeledDefinition : -# 198| r0_3(glval) = VariableAddress[str1] : -# 198| m0_4(char *) = InitializeParameter[str1] : &:r0_3 -# 198| r0_5(glval) = VariableAddress[str2] : -# 198| m0_6(char *) = InitializeParameter[str2] : &:r0_5 -# 198| r0_7(glval) = VariableAddress[x] : -# 198| m0_8(int) = InitializeParameter[x] : &:r0_7 -# 199| r0_9(glval) = VariableAddress[ret] : -# 199| r0_10(glval) = FunctionAddress[strcmp] : -# 199| r0_11(glval) = VariableAddress[str1] : -# 199| r0_12(char *) = Load : &:r0_11, m0_4 -# 199| r0_13(char *) = Convert : r0_12 -# 199| r0_14(glval) = VariableAddress[str2] : -# 199| r0_15(char *) = Load : &:r0_14, m0_6 -# 199| r0_16(char *) = Convert : r0_15 -# 199| r0_17(int) = Call : func:r0_10, 0:r0_13, 1:r0_16 -# 199| v0_18(void) = ^CallReadSideEffect : ~mu0_2 -# 199| m0_19(int) = Store : &:r0_9, r0_17 -# 200| r0_20(glval) = FunctionAddress[strlen] : -# 200| r0_21(glval) = VariableAddress[str1] : -# 200| r0_22(char *) = Load : &:r0_21, m0_4 -# 200| r0_23(char *) = Convert : r0_22 -# 200| r0_24(int) = Call : func:r0_20, 0:r0_23 -# 200| v0_25(void) = ^CallReadSideEffect : ~mu0_2 -# 200| r0_26(glval) = VariableAddress[ret] : -# 200| r0_27(int) = Load : &:r0_26, m0_19 -# 200| r0_28(int) = Add : r0_27, r0_24 -# 200| m0_29(int) = Store : &:r0_26, r0_28 -# 201| r0_30(glval) = FunctionAddress[abs] : -# 201| r0_31(glval) = VariableAddress[x] : -# 201| r0_32(int) = Load : &:r0_31, m0_8 -# 201| r0_33(int) = Call : func:r0_30, 0:r0_32 -# 201| r0_34(glval) = VariableAddress[ret] : -# 201| r0_35(int) = Load : &:r0_34, m0_29 -# 201| r0_36(int) = Add : r0_35, r0_33 -# 201| m0_37(int) = Store : &:r0_34, r0_36 -# 202| r0_38(glval) = VariableAddress[#return] : -# 202| r0_39(glval) = VariableAddress[ret] : -# 202| r0_40(int) = Load : &:r0_39, m0_37 -# 202| m0_41(int) = Store : &:r0_38, r0_40 -# 198| r0_42(glval) = VariableAddress[#return] : -# 198| v0_43(void) = ReturnValue : &:r0_42, m0_41 -# 198| v0_44(void) = UnmodeledUse : mu* -# 198| v0_45(void) = AliasedUse : ~mu0_2 -# 198| v0_46(void) = ExitFunction : +# 198| v198_1(void) = EnterFunction : +# 198| mu198_2(unknown) = AliasedDefinition : +# 198| mu198_3(unknown) = UnmodeledDefinition : +# 198| r198_4(glval) = VariableAddress[str1] : +# 198| m198_5(char *) = InitializeParameter[str1] : &:r198_4 +# 198| r198_6(glval) = VariableAddress[str2] : +# 198| m198_7(char *) = InitializeParameter[str2] : &:r198_6 +# 198| r198_8(glval) = VariableAddress[x] : +# 198| m198_9(int) = InitializeParameter[x] : &:r198_8 +# 199| r199_1(glval) = VariableAddress[ret] : +# 199| r199_2(glval) = FunctionAddress[strcmp] : +# 199| r199_3(glval) = VariableAddress[str1] : +# 199| r199_4(char *) = Load : &:r199_3, m198_5 +# 199| r199_5(char *) = Convert : r199_4 +# 199| r199_6(glval) = VariableAddress[str2] : +# 199| r199_7(char *) = Load : &:r199_6, m198_7 +# 199| r199_8(char *) = Convert : r199_7 +# 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 +# 199| v199_10(void) = ^CallReadSideEffect : ~mu198_3 +# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 200| r200_1(glval) = FunctionAddress[strlen] : +# 200| r200_2(glval) = VariableAddress[str1] : +# 200| r200_3(char *) = Load : &:r200_2, m198_5 +# 200| r200_4(char *) = Convert : r200_3 +# 200| r200_5(int) = Call : func:r200_1, 0:r200_4 +# 200| v200_6(void) = ^CallReadSideEffect : ~mu198_3 +# 200| r200_7(glval) = VariableAddress[ret] : +# 200| r200_8(int) = Load : &:r200_7, m199_11 +# 200| r200_9(int) = Add : r200_8, r200_5 +# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 201| r201_1(glval) = FunctionAddress[abs] : +# 201| r201_2(glval) = VariableAddress[x] : +# 201| r201_3(int) = Load : &:r201_2, m198_9 +# 201| r201_4(int) = Call : func:r201_1, 0:r201_3 +# 201| r201_5(glval) = VariableAddress[ret] : +# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_7(int) = Add : r201_6, r201_4 +# 201| m201_8(int) = Store : &:r201_5, r201_7 +# 202| r202_1(glval) = VariableAddress[#return] : +# 202| r202_2(glval) = VariableAddress[ret] : +# 202| r202_3(int) = Load : &:r202_2, m201_8 +# 202| m202_4(int) = Store : &:r202_1, r202_3 +# 198| r198_10(glval) = VariableAddress[#return] : +# 198| v198_11(void) = ReturnValue : &:r198_10, m202_4 +# 198| v198_12(void) = UnmodeledUse : mu* +# 198| v198_13(void) = AliasedUse : ~mu198_3 +# 198| v198_14(void) = ExitFunction : # 207| int ModeledCallTarget(int) # 207| Block 0 -# 207| v0_0(void) = EnterFunction : -# 207| mu0_1(unknown) = AliasedDefinition : -# 207| mu0_2(unknown) = UnmodeledDefinition : -# 207| r0_3(glval) = VariableAddress[x] : -# 207| mu0_4(int) = InitializeParameter[x] : &:r0_3 -# 208| r0_5(glval) = VariableAddress[y] : -# 208| mu0_6(int) = Uninitialized[y] : &:r0_5 -# 209| r0_7(glval) = FunctionAddress[memcpy] : -# 209| r0_8(glval) = VariableAddress[y] : -# 209| r0_9(int *) = CopyValue : r0_8 -# 209| r0_10(void *) = Convert : r0_9 -# 209| r0_11(glval) = VariableAddress[x] : -# 209| r0_12(int *) = CopyValue : r0_11 -# 209| r0_13(void *) = Convert : r0_12 -# 209| r0_14(int) = Constant[4] : -# 209| r0_15(void *) = Call : func:r0_7, 0:r0_10, 1:r0_13, 2:r0_14 -# 209| v0_16(void) = ^SizedBufferReadSideEffect[1] : &:r0_13, r0_14, ~mu0_2 -# 209| mu0_17(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r0_10, r0_14 -# 210| r0_18(glval) = VariableAddress[#return] : -# 210| r0_19(glval) = VariableAddress[y] : -# 210| r0_20(int) = Load : &:r0_19, ~mu0_2 -# 210| m0_21(int) = Store : &:r0_18, r0_20 -# 207| r0_22(glval) = VariableAddress[#return] : -# 207| v0_23(void) = ReturnValue : &:r0_22, m0_21 -# 207| v0_24(void) = UnmodeledUse : mu* -# 207| v0_25(void) = AliasedUse : ~mu0_2 -# 207| v0_26(void) = ExitFunction : +# 207| v207_1(void) = EnterFunction : +# 207| mu207_2(unknown) = AliasedDefinition : +# 207| mu207_3(unknown) = UnmodeledDefinition : +# 207| r207_4(glval) = VariableAddress[x] : +# 207| mu207_5(int) = InitializeParameter[x] : &:r207_4 +# 208| r208_1(glval) = VariableAddress[y] : +# 208| mu208_2(int) = Uninitialized[y] : &:r208_1 +# 209| r209_1(glval) = FunctionAddress[memcpy] : +# 209| r209_2(glval) = VariableAddress[y] : +# 209| r209_3(int *) = CopyValue : r209_2 +# 209| r209_4(void *) = Convert : r209_3 +# 209| r209_5(glval) = VariableAddress[x] : +# 209| r209_6(int *) = CopyValue : r209_5 +# 209| r209_7(void *) = Convert : r209_6 +# 209| r209_8(int) = Constant[4] : +# 209| r209_9(void *) = Call : func:r209_1, 0:r209_4, 1:r209_7, 2:r209_8 +# 209| v209_10(void) = ^SizedBufferReadSideEffect[1] : &:r209_7, r209_8, ~mu207_3 +# 209| mu209_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r209_4, r209_8 +# 210| r210_1(glval) = VariableAddress[#return] : +# 210| r210_2(glval) = VariableAddress[y] : +# 210| r210_3(int) = Load : &:r210_2, ~mu207_3 +# 210| m210_4(int) = Store : &:r210_1, r210_3 +# 207| r207_6(glval) = VariableAddress[#return] : +# 207| v207_7(void) = ReturnValue : &:r207_6, m210_4 +# 207| v207_8(void) = UnmodeledUse : mu* +# 207| v207_9(void) = AliasedUse : ~mu207_3 +# 207| v207_10(void) = ExitFunction : # 213| void InitArray() # 213| Block 0 -# 213| v0_0(void) = EnterFunction : -# 213| mu0_1(unknown) = AliasedDefinition : -# 213| mu0_2(unknown) = UnmodeledDefinition : -# 214| r0_3(glval) = VariableAddress[a_pad] : -# 214| r0_4(glval) = StringConstant[""] : -# 214| r0_5(char[32]) = Load : &:r0_4, ~mu0_2 -# 214| m0_6(char[32]) = Store : &:r0_3, r0_5 -# 215| r0_7(glval) = VariableAddress[a_nopad] : -# 215| r0_8(glval) = StringConstant["foo"] : -# 215| r0_9(char[4]) = Load : &:r0_8, ~mu0_2 -# 215| m0_10(char[4]) = Store : &:r0_7, r0_9 -# 216| r0_11(glval) = VariableAddress[a_infer] : -# 216| r0_12(glval) = StringConstant["blah"] : -# 216| r0_13(char[5]) = Load : &:r0_12, ~mu0_2 -# 216| m0_14(char[5]) = Store : &:r0_11, r0_13 -# 217| r0_15(glval) = VariableAddress[b] : -# 217| m0_16(char[2]) = Uninitialized[b] : &:r0_15 -# 218| r0_17(glval) = VariableAddress[c] : -# 218| mu0_18(char[2]) = Uninitialized[c] : &:r0_17 -# 218| r0_19(int) = Constant[0] : -# 218| r0_20(glval) = PointerAdd[1] : r0_17, r0_19 -# 218| r0_21(unknown[2]) = Constant[0] : -# 218| mu0_22(unknown[2]) = Store : &:r0_20, r0_21 -# 219| r0_23(glval) = VariableAddress[d] : -# 219| mu0_24(char[2]) = Uninitialized[d] : &:r0_23 -# 219| r0_25(int) = Constant[0] : -# 219| r0_26(glval) = PointerAdd[1] : r0_23, r0_25 -# 219| r0_27(char) = Constant[0] : -# 219| mu0_28(char) = Store : &:r0_26, r0_27 -# 219| r0_29(int) = Constant[1] : -# 219| r0_30(glval) = PointerAdd[1] : r0_23, r0_29 -# 219| r0_31(char) = Constant[0] : -# 219| mu0_32(char) = Store : &:r0_30, r0_31 -# 220| r0_33(glval) = VariableAddress[e] : -# 220| mu0_34(char[2]) = Uninitialized[e] : &:r0_33 -# 220| r0_35(int) = Constant[0] : -# 220| r0_36(glval) = PointerAdd[1] : r0_33, r0_35 -# 220| r0_37(char) = Constant[0] : -# 220| mu0_38(char) = Store : &:r0_36, r0_37 -# 220| r0_39(int) = Constant[1] : -# 220| r0_40(glval) = PointerAdd[1] : r0_33, r0_39 -# 220| r0_41(char) = Constant[1] : -# 220| mu0_42(char) = Store : &:r0_40, r0_41 -# 221| r0_43(glval) = VariableAddress[f] : -# 221| mu0_44(char[3]) = Uninitialized[f] : &:r0_43 -# 221| r0_45(int) = Constant[0] : -# 221| r0_46(glval) = PointerAdd[1] : r0_43, r0_45 -# 221| r0_47(char) = Constant[0] : -# 221| mu0_48(char) = Store : &:r0_46, r0_47 -# 221| r0_49(int) = Constant[1] : -# 221| r0_50(glval) = PointerAdd[1] : r0_43, r0_49 -# 221| r0_51(unknown[2]) = Constant[0] : -# 221| mu0_52(unknown[2]) = Store : &:r0_50, r0_51 -# 222| v0_53(void) = NoOp : -# 213| v0_54(void) = ReturnVoid : -# 213| v0_55(void) = UnmodeledUse : mu* -# 213| v0_56(void) = AliasedUse : ~mu0_2 -# 213| v0_57(void) = ExitFunction : +# 213| v213_1(void) = EnterFunction : +# 213| mu213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 214| r214_1(glval) = VariableAddress[a_pad] : +# 214| r214_2(glval) = StringConstant[""] : +# 214| r214_3(char[32]) = Load : &:r214_2, ~mu213_3 +# 214| m214_4(char[32]) = Store : &:r214_1, r214_3 +# 215| r215_1(glval) = VariableAddress[a_nopad] : +# 215| r215_2(glval) = StringConstant["foo"] : +# 215| r215_3(char[4]) = Load : &:r215_2, ~mu213_3 +# 215| m215_4(char[4]) = Store : &:r215_1, r215_3 +# 216| r216_1(glval) = VariableAddress[a_infer] : +# 216| r216_2(glval) = StringConstant["blah"] : +# 216| r216_3(char[5]) = Load : &:r216_2, ~mu213_3 +# 216| m216_4(char[5]) = Store : &:r216_1, r216_3 +# 217| r217_1(glval) = VariableAddress[b] : +# 217| m217_2(char[2]) = Uninitialized[b] : &:r217_1 +# 218| r218_1(glval) = VariableAddress[c] : +# 218| mu218_2(char[2]) = Uninitialized[c] : &:r218_1 +# 218| r218_3(int) = Constant[0] : +# 218| r218_4(glval) = PointerAdd[1] : r218_1, r218_3 +# 218| r218_5(unknown[2]) = Constant[0] : +# 218| mu218_6(unknown[2]) = Store : &:r218_4, r218_5 +# 219| r219_1(glval) = VariableAddress[d] : +# 219| mu219_2(char[2]) = Uninitialized[d] : &:r219_1 +# 219| r219_3(int) = Constant[0] : +# 219| r219_4(glval) = PointerAdd[1] : r219_1, r219_3 +# 219| r219_5(char) = Constant[0] : +# 219| mu219_6(char) = Store : &:r219_4, r219_5 +# 219| r219_7(int) = Constant[1] : +# 219| r219_8(glval) = PointerAdd[1] : r219_1, r219_7 +# 219| r219_9(char) = Constant[0] : +# 219| mu219_10(char) = Store : &:r219_8, r219_9 +# 220| r220_1(glval) = VariableAddress[e] : +# 220| mu220_2(char[2]) = Uninitialized[e] : &:r220_1 +# 220| r220_3(int) = Constant[0] : +# 220| r220_4(glval) = PointerAdd[1] : r220_1, r220_3 +# 220| r220_5(char) = Constant[0] : +# 220| mu220_6(char) = Store : &:r220_4, r220_5 +# 220| r220_7(int) = Constant[1] : +# 220| r220_8(glval) = PointerAdd[1] : r220_1, r220_7 +# 220| r220_9(char) = Constant[1] : +# 220| mu220_10(char) = Store : &:r220_8, r220_9 +# 221| r221_1(glval) = VariableAddress[f] : +# 221| mu221_2(char[3]) = Uninitialized[f] : &:r221_1 +# 221| r221_3(int) = Constant[0] : +# 221| r221_4(glval) = PointerAdd[1] : r221_1, r221_3 +# 221| r221_5(char) = Constant[0] : +# 221| mu221_6(char) = Store : &:r221_4, r221_5 +# 221| r221_7(int) = Constant[1] : +# 221| r221_8(glval) = PointerAdd[1] : r221_1, r221_7 +# 221| r221_9(unknown[2]) = Constant[0] : +# 221| mu221_10(unknown[2]) = Store : &:r221_8, r221_9 +# 222| v222_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~mu213_3 +# 213| v213_7(void) = ExitFunction : # 226| char StringLiteralAliasing() # 226| Block 0 -# 226| v0_0(void) = EnterFunction : -# 226| mu0_1(unknown) = AliasedDefinition : -# 226| mu0_2(unknown) = UnmodeledDefinition : -# 227| r0_3(glval) = FunctionAddress[ExternalFunc] : -# 227| v0_4(void) = Call : func:r0_3 -# 227| mu0_5(unknown) = ^CallSideEffect : ~mu0_2 -# 229| r0_6(glval) = VariableAddress[s] : -# 229| r0_7(glval) = StringConstant["Literal"] : -# 229| r0_8(char *) = Convert : r0_7 -# 229| m0_9(char *) = Store : &:r0_6, r0_8 -# 230| r0_10(glval) = VariableAddress[#return] : -# 230| r0_11(glval) = VariableAddress[s] : -# 230| r0_12(char *) = Load : &:r0_11, m0_9 -# 230| r0_13(int) = Constant[2] : -# 230| r0_14(glval) = PointerAdd[1] : r0_12, r0_13 -# 230| r0_15(char) = Load : &:r0_14, ~mu0_2 -# 230| m0_16(char) = Store : &:r0_10, r0_15 -# 226| r0_17(glval) = VariableAddress[#return] : -# 226| v0_18(void) = ReturnValue : &:r0_17, m0_16 -# 226| v0_19(void) = UnmodeledUse : mu* -# 226| v0_20(void) = AliasedUse : ~mu0_2 -# 226| v0_21(void) = ExitFunction : +# 226| v226_1(void) = EnterFunction : +# 226| mu226_2(unknown) = AliasedDefinition : +# 226| mu226_3(unknown) = UnmodeledDefinition : +# 227| r227_1(glval) = FunctionAddress[ExternalFunc] : +# 227| v227_2(void) = Call : func:r227_1 +# 227| mu227_3(unknown) = ^CallSideEffect : ~mu226_3 +# 229| r229_1(glval) = VariableAddress[s] : +# 229| r229_2(glval) = StringConstant["Literal"] : +# 229| r229_3(char *) = Convert : r229_2 +# 229| m229_4(char *) = Store : &:r229_1, r229_3 +# 230| r230_1(glval) = VariableAddress[#return] : +# 230| r230_2(glval) = VariableAddress[s] : +# 230| r230_3(char *) = Load : &:r230_2, m229_4 +# 230| r230_4(int) = Constant[2] : +# 230| r230_5(glval) = PointerAdd[1] : r230_3, r230_4 +# 230| r230_6(char) = Load : &:r230_5, ~mu226_3 +# 230| m230_7(char) = Store : &:r230_1, r230_6 +# 226| r226_4(glval) = VariableAddress[#return] : +# 226| v226_5(void) = ReturnValue : &:r226_4, m230_7 +# 226| v226_6(void) = UnmodeledUse : mu* +# 226| v226_7(void) = AliasedUse : ~mu226_3 +# 226| v226_8(void) = ExitFunction : # 235| void Constructible::Constructible(int) # 235| Block 0 -# 235| v0_0(void) = EnterFunction : -# 235| mu0_1(unknown) = AliasedDefinition : -# 235| mu0_2(unknown) = UnmodeledDefinition : -# 235| r0_3(glval) = InitializeThis : -# 235| r0_4(glval) = VariableAddress[x] : -# 235| m0_5(int) = InitializeParameter[x] : &:r0_4 -# 235| v0_6(void) = NoOp : -# 235| v0_7(void) = ReturnVoid : -# 235| v0_8(void) = UnmodeledUse : mu* -# 235| v0_9(void) = AliasedUse : ~mu0_2 -# 235| v0_10(void) = ExitFunction : +# 235| v235_1(void) = EnterFunction : +# 235| mu235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = InitializeThis : +# 235| r235_5(glval) = VariableAddress[x] : +# 235| m235_6(int) = InitializeParameter[x] : &:r235_5 +# 235| v235_7(void) = NoOp : +# 235| v235_8(void) = ReturnVoid : +# 235| v235_9(void) = UnmodeledUse : mu* +# 235| v235_10(void) = AliasedUse : ~mu235_3 +# 235| v235_11(void) = ExitFunction : # 236| void Constructible::g() # 236| Block 0 -# 236| v0_0(void) = EnterFunction : -# 236| mu0_1(unknown) = AliasedDefinition : -# 236| mu0_2(unknown) = UnmodeledDefinition : -# 236| r0_3(glval) = InitializeThis : -# 236| v0_4(void) = NoOp : -# 236| v0_5(void) = ReturnVoid : -# 236| v0_6(void) = UnmodeledUse : mu* -# 236| v0_7(void) = AliasedUse : ~mu0_2 -# 236| v0_8(void) = ExitFunction : +# 236| v236_1(void) = EnterFunction : +# 236| mu236_2(unknown) = AliasedDefinition : +# 236| mu236_3(unknown) = UnmodeledDefinition : +# 236| r236_4(glval) = InitializeThis : +# 236| v236_5(void) = NoOp : +# 236| v236_6(void) = ReturnVoid : +# 236| v236_7(void) = UnmodeledUse : mu* +# 236| v236_8(void) = AliasedUse : ~mu236_3 +# 236| v236_9(void) = ExitFunction : # 239| void ExplicitConstructorCalls() # 239| Block 0 -# 239| v0_0(void) = EnterFunction : -# 239| mu0_1(unknown) = AliasedDefinition : -# 239| mu0_2(unknown) = UnmodeledDefinition : -# 240| r0_3(glval) = VariableAddress[c] : -# 240| mu0_4(Constructible) = Uninitialized[c] : &:r0_3 -# 240| r0_5(glval) = FunctionAddress[Constructible] : -# 240| r0_6(int) = Constant[1] : -# 240| v0_7(void) = Call : func:r0_5, this:r0_3, 0:r0_6 -# 240| mu0_8(unknown) = ^CallSideEffect : ~mu0_2 -# 240| mu0_9(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 241| r0_10(glval) = VariableAddress[c] : -# 241| r0_11(glval) = FunctionAddress[g] : -# 241| v0_12(void) = Call : func:r0_11, this:r0_10 -# 241| mu0_13(unknown) = ^CallSideEffect : ~mu0_2 -# 241| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_10, ~mu0_2 -# 241| mu0_15(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_10 -# 242| r0_16(glval) = VariableAddress[c] : -# 242| r0_17(glval) = FunctionAddress[g] : -# 242| v0_18(void) = Call : func:r0_17, this:r0_16 -# 242| mu0_19(unknown) = ^CallSideEffect : ~mu0_2 -# 242| v0_20(void) = ^BufferReadSideEffect[-1] : &:r0_16, ~mu0_2 -# 242| mu0_21(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_16 -# 243| r0_22(glval) = VariableAddress[c2] : -# 243| mu0_23(Constructible) = Uninitialized[c2] : &:r0_22 -# 243| r0_24(glval) = FunctionAddress[Constructible] : -# 243| r0_25(int) = Constant[2] : -# 243| v0_26(void) = Call : func:r0_24, this:r0_22, 0:r0_25 -# 243| mu0_27(unknown) = ^CallSideEffect : ~mu0_2 -# 243| mu0_28(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_22 -# 244| r0_29(glval) = VariableAddress[c2] : -# 244| r0_30(glval) = FunctionAddress[g] : -# 244| v0_31(void) = Call : func:r0_30, this:r0_29 -# 244| mu0_32(unknown) = ^CallSideEffect : ~mu0_2 -# 244| v0_33(void) = ^BufferReadSideEffect[-1] : &:r0_29, ~mu0_2 -# 244| mu0_34(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_29 -# 245| v0_35(void) = NoOp : -# 239| v0_36(void) = ReturnVoid : -# 239| v0_37(void) = UnmodeledUse : mu* -# 239| v0_38(void) = AliasedUse : ~mu0_2 -# 239| v0_39(void) = ExitFunction : +# 239| v239_1(void) = EnterFunction : +# 239| mu239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 240| r240_1(glval) = VariableAddress[c] : +# 240| mu240_2(Constructible) = Uninitialized[c] : &:r240_1 +# 240| r240_3(glval) = FunctionAddress[Constructible] : +# 240| r240_4(int) = Constant[1] : +# 240| v240_5(void) = Call : func:r240_3, this:r240_1, 0:r240_4 +# 240| mu240_6(unknown) = ^CallSideEffect : ~mu239_3 +# 240| mu240_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r240_1 +# 241| r241_1(glval) = VariableAddress[c] : +# 241| r241_2(glval) = FunctionAddress[g] : +# 241| v241_3(void) = Call : func:r241_2, this:r241_1 +# 241| mu241_4(unknown) = ^CallSideEffect : ~mu239_3 +# 241| v241_5(void) = ^BufferReadSideEffect[-1] : &:r241_1, ~mu239_3 +# 241| mu241_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r241_1 +# 242| r242_1(glval) = VariableAddress[c] : +# 242| r242_2(glval) = FunctionAddress[g] : +# 242| v242_3(void) = Call : func:r242_2, this:r242_1 +# 242| mu242_4(unknown) = ^CallSideEffect : ~mu239_3 +# 242| v242_5(void) = ^BufferReadSideEffect[-1] : &:r242_1, ~mu239_3 +# 242| mu242_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r242_1 +# 243| r243_1(glval) = VariableAddress[c2] : +# 243| mu243_2(Constructible) = Uninitialized[c2] : &:r243_1 +# 243| r243_3(glval) = FunctionAddress[Constructible] : +# 243| r243_4(int) = Constant[2] : +# 243| v243_5(void) = Call : func:r243_3, this:r243_1, 0:r243_4 +# 243| mu243_6(unknown) = ^CallSideEffect : ~mu239_3 +# 243| mu243_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r243_1 +# 244| r244_1(glval) = VariableAddress[c2] : +# 244| r244_2(glval) = FunctionAddress[g] : +# 244| v244_3(void) = Call : func:r244_2, this:r244_1 +# 244| mu244_4(unknown) = ^CallSideEffect : ~mu239_3 +# 244| v244_5(void) = ^BufferReadSideEffect[-1] : &:r244_1, ~mu239_3 +# 244| mu244_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r244_1 +# 245| v245_1(void) = NoOp : +# 239| v239_4(void) = ReturnVoid : +# 239| v239_5(void) = UnmodeledUse : mu* +# 239| v239_6(void) = AliasedUse : ~mu239_3 +# 239| v239_7(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/literal_locations/duplicate_literal_locations.ql b/cpp/ql/test/library-tests/literal_locations/duplicate_literal_locations.ql index 4bf86e1ae17..531cb0f7436 100644 --- a/cpp/ql/test/library-tests/literal_locations/duplicate_literal_locations.ql +++ b/cpp/ql/test/library-tests/literal_locations/duplicate_literal_locations.ql @@ -1,5 +1,5 @@ import cpp -from LocalScopeVariable v, ControlFlowNode def, Expr e +from StackVariable v, ControlFlowNode def, Expr e where exprDefinition(v, def, e) select v, def, e diff --git a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaCompleteness.ql b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaCompleteness.ql index 232f64e7154..6cfa00f08b4 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaCompleteness.ql +++ b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaCompleteness.ql @@ -10,12 +10,12 @@ import cpp import semmle.code.cpp.rangeanalysis.RangeSSA /* - * Count of number of uses of a LocalScopeVariable where no corresponding SSA definition exists, + * Count of number of uses of a StackVariable where no corresponding SSA definition exists, * but at least one SSA definition for that variable can reach that use. * Should always be zero *regardless* of the input */ -select count(LocalScopeVariable v, Expr use | +select count(StackVariable v, Expr use | exists(RangeSsaDefinition def, BasicBlock db, BasicBlock ub | def.getAUse(v) = use and db.contains(def.getDefinition()) and ub.contains(use) | diff --git a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDefUsePairs.ql b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDefUsePairs.ql index 762fcfa8a3b..5c0acadb9db 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDefUsePairs.ql +++ b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDefUsePairs.ql @@ -7,6 +7,6 @@ import cpp import semmle.code.cpp.rangeanalysis.RangeSSA -from RangeSsaDefinition def, LocalScopeVariable var, Expr use +from RangeSsaDefinition def, StackVariable var, Expr use where def.getAUse(var) = use select def, def.toString(var), use diff --git a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDominance.ql b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDominance.ql index 2f9fafef0ab..6dab291f125 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDominance.ql +++ b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaDominance.ql @@ -12,7 +12,7 @@ import semmle.code.cpp.rangeanalysis.RangeSSA * Should always be zero *regardless* of the input */ -select count(RangeSsaDefinition d, LocalScopeVariable v, Expr u | +select count(RangeSsaDefinition d, StackVariable v, Expr u | d.getAUse(v) = u and not exists(BasicBlock bd, BasicBlock bu | bd.contains(mkElement(d).(ControlFlowNode)) and bu.contains(u) diff --git a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaPhiInputs.ql b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaPhiInputs.ql index 2e1f038d136..b6808eccbc0 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaPhiInputs.ql +++ b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaPhiInputs.ql @@ -7,9 +7,7 @@ import cpp import semmle.code.cpp.rangeanalysis.RangeSSA -from - RangeSsaDefinition phi, LocalScopeVariable var, RangeSsaDefinition input, int philine, - int inputline +from RangeSsaDefinition phi, StackVariable var, RangeSsaDefinition input, int philine, int inputline where phi.getAPhiInput(var) = input and philine = phi.getLocation().getStartLine() and diff --git a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaUniqueness.ql b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaUniqueness.ql index fda74759074..2fb56b8ef89 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaUniqueness.ql +++ b/cpp/ql/test/library-tests/rangeanalysis/RangeSSA/RangeSsaUniqueness.ql @@ -12,7 +12,7 @@ import semmle.code.cpp.rangeanalysis.RangeSSA * Should always be zero *regardless* of the input */ -select count(RangeSsaDefinition d1, RangeSsaDefinition d2, Expr u, LocalScopeVariable v | +select count(RangeSsaDefinition d1, RangeSsaDefinition d2, Expr u, StackVariable v | d1.getAUse(v) = u and d2.getAUse(v) = u and not d1 = d2 diff --git a/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected b/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected index 4180c41eb5f..f7286de36cd 100644 --- a/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected +++ b/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected @@ -1,782 +1,782 @@ test.cpp: # 1| int test00(int, int) # 1| Block 0 -# 1| v0_0(void) = EnterFunction : -# 1| m0_1(unknown) = AliasedDefinition : +# 1| v1_1(void) = EnterFunction : +# 1| m1_2(unknown) = AliasedDefinition : # 1| valnum = unique -# 1| mu0_2(unknown) = UnmodeledDefinition : +# 1| mu1_3(unknown) = UnmodeledDefinition : # 1| valnum = unique -# 1| r0_3(glval) = VariableAddress[p0] : -# 1| valnum = r0_3 -# 1| m0_4(int) = InitializeParameter[p0] : &:r0_3 -# 1| valnum = m0_4 -# 1| r0_5(glval) = VariableAddress[p1] : -# 1| valnum = r0_5 -# 1| m0_6(int) = InitializeParameter[p1] : &:r0_5 -# 1| valnum = m0_6 -# 2| r0_7(glval) = VariableAddress[x] : -# 2| valnum = r0_7 -# 2| m0_8(int) = Uninitialized[x] : &:r0_7 +# 1| r1_4(glval) = VariableAddress[p0] : +# 1| valnum = r1_4 +# 1| m1_5(int) = InitializeParameter[p0] : &:r1_4 +# 1| valnum = m1_5 +# 1| r1_6(glval) = VariableAddress[p1] : +# 1| valnum = r1_6 +# 1| m1_7(int) = InitializeParameter[p1] : &:r1_6 +# 1| valnum = m1_7 +# 2| r2_1(glval) = VariableAddress[x] : +# 2| valnum = r2_1 +# 2| m2_2(int) = Uninitialized[x] : &:r2_1 # 2| valnum = unique -# 2| r0_9(glval) = VariableAddress[y] : -# 2| valnum = r0_9 -# 2| m0_10(int) = Uninitialized[y] : &:r0_9 +# 2| r2_3(glval) = VariableAddress[y] : +# 2| valnum = r2_3 +# 2| m2_4(int) = Uninitialized[y] : &:r2_3 # 2| valnum = unique -# 3| r0_11(glval) = VariableAddress[b] : +# 3| r3_1(glval) = VariableAddress[b] : # 3| valnum = unique -# 3| m0_12(unsigned char) = Uninitialized[b] : &:r0_11 +# 3| m3_2(unsigned char) = Uninitialized[b] : &:r3_1 # 3| valnum = unique -# 5| r0_13(glval) = VariableAddress[p0] : -# 5| valnum = r0_3 -# 5| r0_14(int) = Load : &:r0_13, m0_4 -# 5| valnum = m0_4 -# 5| r0_15(glval) = VariableAddress[p1] : -# 5| valnum = r0_5 -# 5| r0_16(int) = Load : &:r0_15, m0_6 -# 5| valnum = m0_6 -# 5| r0_17(int) = Add : r0_14, r0_16 -# 5| valnum = r0_17 -# 5| r0_18(glval) = VariableAddress[x] : -# 5| valnum = r0_7 -# 5| m0_19(int) = Store : &:r0_18, r0_17 -# 5| valnum = r0_17 -# 6| r0_20(glval) = VariableAddress[p0] : -# 6| valnum = r0_3 -# 6| r0_21(int) = Load : &:r0_20, m0_4 -# 6| valnum = m0_4 -# 6| r0_22(glval) = VariableAddress[p1] : -# 6| valnum = r0_5 -# 6| r0_23(int) = Load : &:r0_22, m0_6 -# 6| valnum = m0_6 -# 6| r0_24(int) = Add : r0_21, r0_23 -# 6| valnum = r0_17 -# 6| r0_25(glval) = VariableAddress[x] : -# 6| valnum = r0_7 -# 6| m0_26(int) = Store : &:r0_25, r0_24 -# 6| valnum = r0_17 -# 7| r0_27(glval) = VariableAddress[x] : -# 7| valnum = r0_7 -# 7| r0_28(int) = Load : &:r0_27, m0_26 -# 7| valnum = r0_17 -# 7| r0_29(glval) = VariableAddress[y] : -# 7| valnum = r0_9 -# 7| m0_30(int) = Store : &:r0_29, r0_28 -# 7| valnum = r0_17 -# 8| v0_31(void) = NoOp : -# 1| r0_32(glval) = VariableAddress[#return] : +# 5| r5_1(glval) = VariableAddress[p0] : +# 5| valnum = r1_4 +# 5| r5_2(int) = Load : &:r5_1, m1_5 +# 5| valnum = m1_5 +# 5| r5_3(glval) = VariableAddress[p1] : +# 5| valnum = r1_6 +# 5| r5_4(int) = Load : &:r5_3, m1_7 +# 5| valnum = m1_7 +# 5| r5_5(int) = Add : r5_2, r5_4 +# 5| valnum = r5_5 +# 5| r5_6(glval) = VariableAddress[x] : +# 5| valnum = r2_1 +# 5| m5_7(int) = Store : &:r5_6, r5_5 +# 5| valnum = r5_5 +# 6| r6_1(glval) = VariableAddress[p0] : +# 6| valnum = r1_4 +# 6| r6_2(int) = Load : &:r6_1, m1_5 +# 6| valnum = m1_5 +# 6| r6_3(glval) = VariableAddress[p1] : +# 6| valnum = r1_6 +# 6| r6_4(int) = Load : &:r6_3, m1_7 +# 6| valnum = m1_7 +# 6| r6_5(int) = Add : r6_2, r6_4 +# 6| valnum = r5_5 +# 6| r6_6(glval) = VariableAddress[x] : +# 6| valnum = r2_1 +# 6| m6_7(int) = Store : &:r6_6, r6_5 +# 6| valnum = r5_5 +# 7| r7_1(glval) = VariableAddress[x] : +# 7| valnum = r2_1 +# 7| r7_2(int) = Load : &:r7_1, m6_7 +# 7| valnum = r5_5 +# 7| r7_3(glval) = VariableAddress[y] : +# 7| valnum = r2_3 +# 7| m7_4(int) = Store : &:r7_3, r7_2 +# 7| valnum = r5_5 +# 8| v8_1(void) = NoOp : +# 1| r1_8(glval) = VariableAddress[#return] : # 1| valnum = unique -# 1| v0_33(void) = ReturnValue : &:r0_32 -# 1| v0_34(void) = UnmodeledUse : mu* -# 1| v0_35(void) = AliasedUse : ~m0_1 -# 1| v0_36(void) = ExitFunction : +# 1| v1_9(void) = ReturnValue : &:r1_8 +# 1| v1_10(void) = UnmodeledUse : mu* +# 1| v1_11(void) = AliasedUse : ~m1_2 +# 1| v1_12(void) = ExitFunction : # 12| int test01(int, int) # 12| Block 0 -# 12| v0_0(void) = EnterFunction : -# 12| m0_1(unknown) = AliasedDefinition : +# 12| v12_1(void) = EnterFunction : +# 12| m12_2(unknown) = AliasedDefinition : # 12| valnum = unique -# 12| mu0_2(unknown) = UnmodeledDefinition : +# 12| mu12_3(unknown) = UnmodeledDefinition : # 12| valnum = unique -# 12| r0_3(glval) = VariableAddress[p0] : -# 12| valnum = r0_3 -# 12| m0_4(int) = InitializeParameter[p0] : &:r0_3 -# 12| valnum = m0_4 -# 12| r0_5(glval) = VariableAddress[p1] : -# 12| valnum = r0_5 -# 12| m0_6(int) = InitializeParameter[p1] : &:r0_5 -# 12| valnum = m0_6 -# 13| r0_7(glval) = VariableAddress[x] : -# 13| valnum = r0_7 -# 13| m0_8(int) = Uninitialized[x] : &:r0_7 +# 12| r12_4(glval) = VariableAddress[p0] : +# 12| valnum = r12_4 +# 12| m12_5(int) = InitializeParameter[p0] : &:r12_4 +# 12| valnum = m12_5 +# 12| r12_6(glval) = VariableAddress[p1] : +# 12| valnum = r12_6 +# 12| m12_7(int) = InitializeParameter[p1] : &:r12_6 +# 12| valnum = m12_7 +# 13| r13_1(glval) = VariableAddress[x] : +# 13| valnum = r13_1 +# 13| m13_2(int) = Uninitialized[x] : &:r13_1 # 13| valnum = unique -# 13| r0_9(glval) = VariableAddress[y] : -# 13| valnum = r0_9 -# 13| m0_10(int) = Uninitialized[y] : &:r0_9 +# 13| r13_3(glval) = VariableAddress[y] : +# 13| valnum = r13_3 +# 13| m13_4(int) = Uninitialized[y] : &:r13_3 # 13| valnum = unique -# 14| r0_11(glval) = VariableAddress[b] : +# 14| r14_1(glval) = VariableAddress[b] : # 14| valnum = unique -# 14| m0_12(unsigned char) = Uninitialized[b] : &:r0_11 +# 14| m14_2(unsigned char) = Uninitialized[b] : &:r14_1 # 14| valnum = unique -# 16| r0_13(glval) = VariableAddress[p0] : -# 16| valnum = r0_3 -# 16| r0_14(int) = Load : &:r0_13, m0_4 -# 16| valnum = m0_4 -# 16| r0_15(glval) = VariableAddress[p1] : -# 16| valnum = r0_5 -# 16| r0_16(int) = Load : &:r0_15, m0_6 -# 16| valnum = m0_6 -# 16| r0_17(int) = Add : r0_14, r0_16 -# 16| valnum = r0_17 -# 16| r0_18(glval) = VariableAddress[global01] : -# 16| valnum = r0_18 -# 16| r0_19(int) = Load : &:r0_18, ~m0_1 +# 16| r16_1(glval) = VariableAddress[p0] : +# 16| valnum = r12_4 +# 16| r16_2(int) = Load : &:r16_1, m12_5 +# 16| valnum = m12_5 +# 16| r16_3(glval) = VariableAddress[p1] : +# 16| valnum = r12_6 +# 16| r16_4(int) = Load : &:r16_3, m12_7 +# 16| valnum = m12_7 +# 16| r16_5(int) = Add : r16_2, r16_4 +# 16| valnum = r16_5 +# 16| r16_6(glval) = VariableAddress[global01] : +# 16| valnum = r16_6 +# 16| r16_7(int) = Load : &:r16_6, ~m12_2 # 16| valnum = unique -# 16| r0_20(int) = Add : r0_17, r0_19 -# 16| valnum = r0_20 -# 16| r0_21(glval) = VariableAddress[x] : -# 16| valnum = r0_7 -# 16| m0_22(int) = Store : &:r0_21, r0_20 -# 16| valnum = r0_20 -# 17| r0_23(glval) = VariableAddress[p0] : -# 17| valnum = r0_3 -# 17| r0_24(int) = Load : &:r0_23, m0_4 -# 17| valnum = m0_4 -# 17| r0_25(glval) = VariableAddress[p1] : -# 17| valnum = r0_5 -# 17| r0_26(int) = Load : &:r0_25, m0_6 -# 17| valnum = m0_6 -# 17| r0_27(int) = Add : r0_24, r0_26 -# 17| valnum = r0_17 -# 17| r0_28(glval) = VariableAddress[global01] : -# 17| valnum = r0_18 -# 17| r0_29(int) = Load : &:r0_28, ~m0_1 +# 16| r16_8(int) = Add : r16_5, r16_7 +# 16| valnum = r16_8 +# 16| r16_9(glval) = VariableAddress[x] : +# 16| valnum = r13_1 +# 16| m16_10(int) = Store : &:r16_9, r16_8 +# 16| valnum = r16_8 +# 17| r17_1(glval) = VariableAddress[p0] : +# 17| valnum = r12_4 +# 17| r17_2(int) = Load : &:r17_1, m12_5 +# 17| valnum = m12_5 +# 17| r17_3(glval) = VariableAddress[p1] : +# 17| valnum = r12_6 +# 17| r17_4(int) = Load : &:r17_3, m12_7 +# 17| valnum = m12_7 +# 17| r17_5(int) = Add : r17_2, r17_4 +# 17| valnum = r16_5 +# 17| r17_6(glval) = VariableAddress[global01] : +# 17| valnum = r16_6 +# 17| r17_7(int) = Load : &:r17_6, ~m12_2 # 17| valnum = unique -# 17| r0_30(int) = Add : r0_27, r0_29 -# 17| valnum = r0_30 -# 17| r0_31(glval) = VariableAddress[x] : -# 17| valnum = r0_7 -# 17| m0_32(int) = Store : &:r0_31, r0_30 -# 17| valnum = r0_30 -# 18| r0_33(glval) = VariableAddress[x] : -# 18| valnum = r0_7 -# 18| r0_34(int) = Load : &:r0_33, m0_32 -# 18| valnum = r0_30 -# 18| r0_35(glval) = VariableAddress[y] : -# 18| valnum = r0_9 -# 18| m0_36(int) = Store : &:r0_35, r0_34 -# 18| valnum = r0_30 -# 19| v0_37(void) = NoOp : -# 12| r0_38(glval) = VariableAddress[#return] : +# 17| r17_8(int) = Add : r17_5, r17_7 +# 17| valnum = r17_8 +# 17| r17_9(glval) = VariableAddress[x] : +# 17| valnum = r13_1 +# 17| m17_10(int) = Store : &:r17_9, r17_8 +# 17| valnum = r17_8 +# 18| r18_1(glval) = VariableAddress[x] : +# 18| valnum = r13_1 +# 18| r18_2(int) = Load : &:r18_1, m17_10 +# 18| valnum = r17_8 +# 18| r18_3(glval) = VariableAddress[y] : +# 18| valnum = r13_3 +# 18| m18_4(int) = Store : &:r18_3, r18_2 +# 18| valnum = r17_8 +# 19| v19_1(void) = NoOp : +# 12| r12_8(glval) = VariableAddress[#return] : # 12| valnum = unique -# 12| v0_39(void) = ReturnValue : &:r0_38 -# 12| v0_40(void) = UnmodeledUse : mu* -# 12| v0_41(void) = AliasedUse : ~m0_1 -# 12| v0_42(void) = ExitFunction : +# 12| v12_9(void) = ReturnValue : &:r12_8 +# 12| v12_10(void) = UnmodeledUse : mu* +# 12| v12_11(void) = AliasedUse : ~m12_2 +# 12| v12_12(void) = ExitFunction : # 25| int test02(int, int) # 25| Block 0 -# 25| v0_0(void) = EnterFunction : -# 25| m0_1(unknown) = AliasedDefinition : +# 25| v25_1(void) = EnterFunction : +# 25| m25_2(unknown) = AliasedDefinition : # 25| valnum = unique -# 25| mu0_2(unknown) = UnmodeledDefinition : +# 25| mu25_3(unknown) = UnmodeledDefinition : # 25| valnum = unique -# 25| r0_3(glval) = VariableAddress[p0] : -# 25| valnum = r0_3 -# 25| m0_4(int) = InitializeParameter[p0] : &:r0_3 -# 25| valnum = m0_4 -# 25| r0_5(glval) = VariableAddress[p1] : -# 25| valnum = r0_5 -# 25| m0_6(int) = InitializeParameter[p1] : &:r0_5 -# 25| valnum = m0_6 -# 26| r0_7(glval) = VariableAddress[x] : -# 26| valnum = r0_7 -# 26| m0_8(int) = Uninitialized[x] : &:r0_7 +# 25| r25_4(glval) = VariableAddress[p0] : +# 25| valnum = r25_4 +# 25| m25_5(int) = InitializeParameter[p0] : &:r25_4 +# 25| valnum = m25_5 +# 25| r25_6(glval) = VariableAddress[p1] : +# 25| valnum = r25_6 +# 25| m25_7(int) = InitializeParameter[p1] : &:r25_6 +# 25| valnum = m25_7 +# 26| r26_1(glval) = VariableAddress[x] : +# 26| valnum = r26_1 +# 26| m26_2(int) = Uninitialized[x] : &:r26_1 # 26| valnum = unique -# 26| r0_9(glval) = VariableAddress[y] : -# 26| valnum = r0_9 -# 26| m0_10(int) = Uninitialized[y] : &:r0_9 +# 26| r26_3(glval) = VariableAddress[y] : +# 26| valnum = r26_3 +# 26| m26_4(int) = Uninitialized[y] : &:r26_3 # 26| valnum = unique -# 27| r0_11(glval) = VariableAddress[b] : +# 27| r27_1(glval) = VariableAddress[b] : # 27| valnum = unique -# 27| m0_12(unsigned char) = Uninitialized[b] : &:r0_11 +# 27| m27_2(unsigned char) = Uninitialized[b] : &:r27_1 # 27| valnum = unique -# 29| r0_13(glval) = VariableAddress[p0] : -# 29| valnum = r0_3 -# 29| r0_14(int) = Load : &:r0_13, m0_4 -# 29| valnum = m0_4 -# 29| r0_15(glval) = VariableAddress[p1] : -# 29| valnum = r0_5 -# 29| r0_16(int) = Load : &:r0_15, m0_6 -# 29| valnum = m0_6 -# 29| r0_17(int) = Add : r0_14, r0_16 -# 29| valnum = r0_17 -# 29| r0_18(glval) = VariableAddress[global02] : -# 29| valnum = r0_18 -# 29| r0_19(int) = Load : &:r0_18, ~m0_1 +# 29| r29_1(glval) = VariableAddress[p0] : +# 29| valnum = r25_4 +# 29| r29_2(int) = Load : &:r29_1, m25_5 +# 29| valnum = m25_5 +# 29| r29_3(glval) = VariableAddress[p1] : +# 29| valnum = r25_6 +# 29| r29_4(int) = Load : &:r29_3, m25_7 +# 29| valnum = m25_7 +# 29| r29_5(int) = Add : r29_2, r29_4 +# 29| valnum = r29_5 +# 29| r29_6(glval) = VariableAddress[global02] : +# 29| valnum = r29_6 +# 29| r29_7(int) = Load : &:r29_6, ~m25_2 # 29| valnum = unique -# 29| r0_20(int) = Add : r0_17, r0_19 -# 29| valnum = r0_20 -# 29| r0_21(glval) = VariableAddress[x] : -# 29| valnum = r0_7 -# 29| m0_22(int) = Store : &:r0_21, r0_20 -# 29| valnum = r0_20 -# 30| r0_23(glval) = FunctionAddress[change_global02] : +# 29| r29_8(int) = Add : r29_5, r29_7 +# 29| valnum = r29_8 +# 29| r29_9(glval) = VariableAddress[x] : +# 29| valnum = r26_1 +# 29| m29_10(int) = Store : &:r29_9, r29_8 +# 29| valnum = r29_8 +# 30| r30_1(glval) = FunctionAddress[change_global02] : # 30| valnum = unique -# 30| v0_24(void) = Call : func:r0_23 -# 30| m0_25(unknown) = ^CallSideEffect : ~m0_1 +# 30| v30_2(void) = Call : func:r30_1 +# 30| m30_3(unknown) = ^CallSideEffect : ~m25_2 # 30| valnum = unique -# 30| m0_26(unknown) = Chi : total:m0_1, partial:m0_25 +# 30| m30_4(unknown) = Chi : total:m25_2, partial:m30_3 # 30| valnum = unique -# 31| r0_27(glval) = VariableAddress[p0] : -# 31| valnum = r0_3 -# 31| r0_28(int) = Load : &:r0_27, m0_4 -# 31| valnum = m0_4 -# 31| r0_29(glval) = VariableAddress[p1] : -# 31| valnum = r0_5 -# 31| r0_30(int) = Load : &:r0_29, m0_6 -# 31| valnum = m0_6 -# 31| r0_31(int) = Add : r0_28, r0_30 -# 31| valnum = r0_17 -# 31| r0_32(glval) = VariableAddress[global02] : -# 31| valnum = r0_18 -# 31| r0_33(int) = Load : &:r0_32, ~m0_26 +# 31| r31_1(glval) = VariableAddress[p0] : +# 31| valnum = r25_4 +# 31| r31_2(int) = Load : &:r31_1, m25_5 +# 31| valnum = m25_5 +# 31| r31_3(glval) = VariableAddress[p1] : +# 31| valnum = r25_6 +# 31| r31_4(int) = Load : &:r31_3, m25_7 +# 31| valnum = m25_7 +# 31| r31_5(int) = Add : r31_2, r31_4 +# 31| valnum = r29_5 +# 31| r31_6(glval) = VariableAddress[global02] : +# 31| valnum = r29_6 +# 31| r31_7(int) = Load : &:r31_6, ~m30_4 # 31| valnum = unique -# 31| r0_34(int) = Add : r0_31, r0_33 -# 31| valnum = r0_34 -# 31| r0_35(glval) = VariableAddress[x] : -# 31| valnum = r0_7 -# 31| m0_36(int) = Store : &:r0_35, r0_34 -# 31| valnum = r0_34 -# 32| r0_37(glval) = VariableAddress[x] : -# 32| valnum = r0_7 -# 32| r0_38(int) = Load : &:r0_37, m0_36 -# 32| valnum = r0_34 -# 32| r0_39(glval) = VariableAddress[y] : -# 32| valnum = r0_9 -# 32| m0_40(int) = Store : &:r0_39, r0_38 -# 32| valnum = r0_34 -# 33| v0_41(void) = NoOp : -# 25| r0_42(glval) = VariableAddress[#return] : +# 31| r31_8(int) = Add : r31_5, r31_7 +# 31| valnum = r31_8 +# 31| r31_9(glval) = VariableAddress[x] : +# 31| valnum = r26_1 +# 31| m31_10(int) = Store : &:r31_9, r31_8 +# 31| valnum = r31_8 +# 32| r32_1(glval) = VariableAddress[x] : +# 32| valnum = r26_1 +# 32| r32_2(int) = Load : &:r32_1, m31_10 +# 32| valnum = r31_8 +# 32| r32_3(glval) = VariableAddress[y] : +# 32| valnum = r26_3 +# 32| m32_4(int) = Store : &:r32_3, r32_2 +# 32| valnum = r31_8 +# 33| v33_1(void) = NoOp : +# 25| r25_8(glval) = VariableAddress[#return] : # 25| valnum = unique -# 25| v0_43(void) = ReturnValue : &:r0_42 -# 25| v0_44(void) = UnmodeledUse : mu* -# 25| v0_45(void) = AliasedUse : ~m0_26 -# 25| v0_46(void) = ExitFunction : +# 25| v25_9(void) = ReturnValue : &:r25_8 +# 25| v25_10(void) = UnmodeledUse : mu* +# 25| v25_11(void) = AliasedUse : ~m30_4 +# 25| v25_12(void) = ExitFunction : # 39| int test03(int, int, int*) # 39| Block 0 -# 39| v0_0(void) = EnterFunction : -# 39| m0_1(unknown) = AliasedDefinition : +# 39| v39_1(void) = EnterFunction : +# 39| m39_2(unknown) = AliasedDefinition : # 39| valnum = unique -# 39| mu0_2(unknown) = UnmodeledDefinition : +# 39| mu39_3(unknown) = UnmodeledDefinition : # 39| valnum = unique -# 39| r0_3(glval) = VariableAddress[p0] : -# 39| valnum = r0_3 -# 39| m0_4(int) = InitializeParameter[p0] : &:r0_3 -# 39| valnum = m0_4 -# 39| r0_5(glval) = VariableAddress[p1] : -# 39| valnum = r0_5 -# 39| m0_6(int) = InitializeParameter[p1] : &:r0_5 -# 39| valnum = m0_6 -# 39| r0_7(glval) = VariableAddress[p2] : -# 39| valnum = r0_7 -# 39| m0_8(int *) = InitializeParameter[p2] : &:r0_7 -# 39| valnum = m0_8 -# 40| r0_9(glval) = VariableAddress[x] : -# 40| valnum = r0_9 -# 40| m0_10(int) = Uninitialized[x] : &:r0_9 +# 39| r39_4(glval) = VariableAddress[p0] : +# 39| valnum = r39_4 +# 39| m39_5(int) = InitializeParameter[p0] : &:r39_4 +# 39| valnum = m39_5 +# 39| r39_6(glval) = VariableAddress[p1] : +# 39| valnum = r39_6 +# 39| m39_7(int) = InitializeParameter[p1] : &:r39_6 +# 39| valnum = m39_7 +# 39| r39_8(glval) = VariableAddress[p2] : +# 39| valnum = r39_8 +# 39| m39_9(int *) = InitializeParameter[p2] : &:r39_8 +# 39| valnum = m39_9 +# 40| r40_1(glval) = VariableAddress[x] : +# 40| valnum = r40_1 +# 40| m40_2(int) = Uninitialized[x] : &:r40_1 # 40| valnum = unique -# 40| r0_11(glval) = VariableAddress[y] : -# 40| valnum = r0_11 -# 40| m0_12(int) = Uninitialized[y] : &:r0_11 +# 40| r40_3(glval) = VariableAddress[y] : +# 40| valnum = r40_3 +# 40| m40_4(int) = Uninitialized[y] : &:r40_3 # 40| valnum = unique -# 41| r0_13(glval) = VariableAddress[b] : +# 41| r41_1(glval) = VariableAddress[b] : # 41| valnum = unique -# 41| m0_14(unsigned char) = Uninitialized[b] : &:r0_13 +# 41| m41_2(unsigned char) = Uninitialized[b] : &:r41_1 # 41| valnum = unique -# 43| r0_15(glval) = VariableAddress[p0] : -# 43| valnum = r0_3 -# 43| r0_16(int) = Load : &:r0_15, m0_4 -# 43| valnum = m0_4 -# 43| r0_17(glval) = VariableAddress[p1] : -# 43| valnum = r0_5 -# 43| r0_18(int) = Load : &:r0_17, m0_6 -# 43| valnum = m0_6 -# 43| r0_19(int) = Add : r0_16, r0_18 -# 43| valnum = r0_19 -# 43| r0_20(glval) = VariableAddress[global03] : -# 43| valnum = r0_20 -# 43| r0_21(int) = Load : &:r0_20, ~m0_1 +# 43| r43_1(glval) = VariableAddress[p0] : +# 43| valnum = r39_4 +# 43| r43_2(int) = Load : &:r43_1, m39_5 +# 43| valnum = m39_5 +# 43| r43_3(glval) = VariableAddress[p1] : +# 43| valnum = r39_6 +# 43| r43_4(int) = Load : &:r43_3, m39_7 +# 43| valnum = m39_7 +# 43| r43_5(int) = Add : r43_2, r43_4 +# 43| valnum = r43_5 +# 43| r43_6(glval) = VariableAddress[global03] : +# 43| valnum = r43_6 +# 43| r43_7(int) = Load : &:r43_6, ~m39_2 # 43| valnum = unique -# 43| r0_22(int) = Add : r0_19, r0_21 -# 43| valnum = r0_22 -# 43| r0_23(glval) = VariableAddress[x] : -# 43| valnum = r0_9 -# 43| m0_24(int) = Store : &:r0_23, r0_22 -# 43| valnum = r0_22 -# 44| r0_25(int) = Constant[0] : -# 44| valnum = r0_25 -# 44| r0_26(glval) = VariableAddress[p2] : -# 44| valnum = r0_7 -# 44| r0_27(int *) = Load : &:r0_26, m0_8 -# 44| valnum = m0_8 -# 44| r0_28(glval) = CopyValue : r0_27 -# 44| valnum = m0_8 -# 44| m0_29(int) = Store : &:r0_28, r0_25 -# 44| valnum = r0_25 -# 44| m0_30(unknown) = Chi : total:m0_1, partial:m0_29 +# 43| r43_8(int) = Add : r43_5, r43_7 +# 43| valnum = r43_8 +# 43| r43_9(glval) = VariableAddress[x] : +# 43| valnum = r40_1 +# 43| m43_10(int) = Store : &:r43_9, r43_8 +# 43| valnum = r43_8 +# 44| r44_1(int) = Constant[0] : +# 44| valnum = r44_1 +# 44| r44_2(glval) = VariableAddress[p2] : +# 44| valnum = r39_8 +# 44| r44_3(int *) = Load : &:r44_2, m39_9 +# 44| valnum = m39_9 +# 44| r44_4(glval) = CopyValue : r44_3 +# 44| valnum = m39_9 +# 44| m44_5(int) = Store : &:r44_4, r44_1 +# 44| valnum = r44_1 +# 44| m44_6(unknown) = Chi : total:m39_2, partial:m44_5 # 44| valnum = unique -# 45| r0_31(glval) = VariableAddress[p0] : -# 45| valnum = r0_3 -# 45| r0_32(int) = Load : &:r0_31, m0_4 -# 45| valnum = m0_4 -# 45| r0_33(glval) = VariableAddress[p1] : -# 45| valnum = r0_5 -# 45| r0_34(int) = Load : &:r0_33, m0_6 -# 45| valnum = m0_6 -# 45| r0_35(int) = Add : r0_32, r0_34 -# 45| valnum = r0_19 -# 45| r0_36(glval) = VariableAddress[global03] : -# 45| valnum = r0_20 -# 45| r0_37(int) = Load : &:r0_36, ~m0_30 +# 45| r45_1(glval) = VariableAddress[p0] : +# 45| valnum = r39_4 +# 45| r45_2(int) = Load : &:r45_1, m39_5 +# 45| valnum = m39_5 +# 45| r45_3(glval) = VariableAddress[p1] : +# 45| valnum = r39_6 +# 45| r45_4(int) = Load : &:r45_3, m39_7 +# 45| valnum = m39_7 +# 45| r45_5(int) = Add : r45_2, r45_4 +# 45| valnum = r43_5 +# 45| r45_6(glval) = VariableAddress[global03] : +# 45| valnum = r43_6 +# 45| r45_7(int) = Load : &:r45_6, ~m44_6 # 45| valnum = unique -# 45| r0_38(int) = Add : r0_35, r0_37 -# 45| valnum = r0_38 -# 45| r0_39(glval) = VariableAddress[x] : -# 45| valnum = r0_9 -# 45| m0_40(int) = Store : &:r0_39, r0_38 -# 45| valnum = r0_38 -# 46| r0_41(glval) = VariableAddress[x] : -# 46| valnum = r0_9 -# 46| r0_42(int) = Load : &:r0_41, m0_40 -# 46| valnum = r0_38 -# 46| r0_43(glval) = VariableAddress[y] : -# 46| valnum = r0_11 -# 46| m0_44(int) = Store : &:r0_43, r0_42 -# 46| valnum = r0_38 -# 47| v0_45(void) = NoOp : -# 39| r0_46(glval) = VariableAddress[#return] : +# 45| r45_8(int) = Add : r45_5, r45_7 +# 45| valnum = r45_8 +# 45| r45_9(glval) = VariableAddress[x] : +# 45| valnum = r40_1 +# 45| m45_10(int) = Store : &:r45_9, r45_8 +# 45| valnum = r45_8 +# 46| r46_1(glval) = VariableAddress[x] : +# 46| valnum = r40_1 +# 46| r46_2(int) = Load : &:r46_1, m45_10 +# 46| valnum = r45_8 +# 46| r46_3(glval) = VariableAddress[y] : +# 46| valnum = r40_3 +# 46| m46_4(int) = Store : &:r46_3, r46_2 +# 46| valnum = r45_8 +# 47| v47_1(void) = NoOp : +# 39| r39_10(glval) = VariableAddress[#return] : # 39| valnum = unique -# 39| v0_47(void) = ReturnValue : &:r0_46 -# 39| v0_48(void) = UnmodeledUse : mu* -# 39| v0_49(void) = AliasedUse : ~m0_30 -# 39| v0_50(void) = ExitFunction : +# 39| v39_11(void) = ReturnValue : &:r39_10 +# 39| v39_12(void) = UnmodeledUse : mu* +# 39| v39_13(void) = AliasedUse : ~m44_6 +# 39| v39_14(void) = ExitFunction : # 49| unsigned int my_strspn(char const*, char const*) # 49| Block 0 -# 49| v0_0(void) = EnterFunction : -# 49| m0_1(unknown) = AliasedDefinition : +# 49| v49_1(void) = EnterFunction : +# 49| m49_2(unknown) = AliasedDefinition : # 49| valnum = unique -# 49| mu0_2(unknown) = UnmodeledDefinition : +# 49| mu49_3(unknown) = UnmodeledDefinition : # 49| valnum = unique -# 49| r0_3(glval) = VariableAddress[str] : -# 49| valnum = r0_3 -# 49| m0_4(char *) = InitializeParameter[str] : &:r0_3 -# 49| valnum = m0_4 -# 49| r0_5(glval) = VariableAddress[chars] : -# 49| valnum = r0_5 -# 49| m0_6(char *) = InitializeParameter[chars] : &:r0_5 -# 49| valnum = m0_6 -# 50| r0_7(glval) = VariableAddress[ptr] : -# 50| valnum = r0_7 -# 50| m0_8(char *) = Uninitialized[ptr] : &:r0_7 +# 49| r49_4(glval) = VariableAddress[str] : +# 49| valnum = r49_4 +# 49| m49_5(char *) = InitializeParameter[str] : &:r49_4 +# 49| valnum = m49_5 +# 49| r49_6(glval) = VariableAddress[chars] : +# 49| valnum = r49_6 +# 49| m49_7(char *) = InitializeParameter[chars] : &:r49_6 +# 49| valnum = m49_7 +# 50| r50_1(glval) = VariableAddress[ptr] : +# 50| valnum = r50_1 +# 50| m50_2(char *) = Uninitialized[ptr] : &:r50_1 # 50| valnum = unique -# 51| r0_9(glval) = VariableAddress[result] : -# 51| valnum = r0_9 -# 51| r0_10(unsigned int) = Constant[0] : -# 51| valnum = r0_10 -# 51| m0_11(unsigned int) = Store : &:r0_9, r0_10 -# 51| valnum = r0_10 +# 51| r51_1(glval) = VariableAddress[result] : +# 51| valnum = r51_1 +# 51| r51_2(unsigned int) = Constant[0] : +# 51| valnum = r51_2 +# 51| m51_3(unsigned int) = Store : &:r51_1, r51_2 +# 51| valnum = r51_2 #-----| Goto -> Block 1 # 53| Block 1 -# 53| m1_0(unsigned int) = Phi : from 0:m0_11, from 8:m8_4 -# 53| valnum = m1_0 -# 53| r1_1(glval) = VariableAddress[str] : -# 53| valnum = r0_3 -# 53| r1_2(char *) = Load : &:r1_1, m0_4 -# 53| valnum = m0_4 -# 53| r1_3(char) = Load : &:r1_2, ~m0_1 +# 53| m53_1(unsigned int) = Phi : from 0:m51_3, from 8:m62_5 +# 53| valnum = m53_1 +# 53| r53_2(glval) = VariableAddress[str] : +# 53| valnum = r49_4 +# 53| r53_3(char *) = Load : &:r53_2, m49_5 +# 53| valnum = m49_5 +# 53| r53_4(char) = Load : &:r53_3, ~m49_2 # 53| valnum = unique -# 53| r1_4(int) = Convert : r1_3 +# 53| r53_5(int) = Convert : r53_4 # 53| valnum = unique -# 53| r1_5(int) = Constant[0] : -# 53| valnum = r1_5 -# 53| r1_6(bool) = CompareNE : r1_4, r1_5 +# 53| r53_6(int) = Constant[0] : +# 53| valnum = r53_6 +# 53| r53_7(bool) = CompareNE : r53_5, r53_6 # 53| valnum = unique -# 53| v1_7(void) = ConditionalBranch : r1_6 +# 53| v53_8(void) = ConditionalBranch : r53_7 #-----| False -> Block 9 #-----| True -> Block 2 # 55| Block 2 -# 55| r2_0(glval) = VariableAddress[chars] : -# 55| valnum = r0_5 -# 55| r2_1(char *) = Load : &:r2_0, m0_6 -# 55| valnum = m0_6 -# 55| r2_2(glval) = VariableAddress[ptr] : -# 55| valnum = r0_7 -# 55| m2_3(char *) = Store : &:r2_2, r2_1 -# 55| valnum = m0_6 +# 55| r55_1(glval) = VariableAddress[chars] : +# 55| valnum = r49_6 +# 55| r55_2(char *) = Load : &:r55_1, m49_7 +# 55| valnum = m49_7 +# 55| r55_3(glval) = VariableAddress[ptr] : +# 55| valnum = r50_1 +# 55| m55_4(char *) = Store : &:r55_3, r55_2 +# 55| valnum = m49_7 #-----| Goto -> Block 3 # 56| Block 3 -# 56| m3_0(decltype(nullptr)) = Phi : from 2:m2_3, from 5:m5_4 -# 56| valnum = m3_0 -# 56| r3_1(glval) = VariableAddress[ptr] : -# 56| valnum = r0_7 -# 56| r3_2(char *) = Load : &:r3_1, m3_0 -# 56| valnum = m3_0 -# 56| r3_3(char) = Load : &:r3_2, ~m0_1 +# 56| m56_1(decltype(nullptr)) = Phi : from 2:m55_4, from 5:m56_23 +# 56| valnum = m56_1 +# 56| r56_2(glval) = VariableAddress[ptr] : +# 56| valnum = r50_1 +# 56| r56_3(char *) = Load : &:r56_2, m56_1 +# 56| valnum = m56_1 +# 56| r56_4(char) = Load : &:r56_3, ~m49_2 # 56| valnum = unique -# 56| r3_4(int) = Convert : r3_3 +# 56| r56_5(int) = Convert : r56_4 # 56| valnum = unique -# 56| r3_5(glval) = VariableAddress[str] : -# 56| valnum = r0_3 -# 56| r3_6(char *) = Load : &:r3_5, m0_4 -# 56| valnum = m0_4 -# 56| r3_7(char) = Load : &:r3_6, ~m0_1 +# 56| r56_6(glval) = VariableAddress[str] : +# 56| valnum = r49_4 +# 56| r56_7(char *) = Load : &:r56_6, m49_5 +# 56| valnum = m49_5 +# 56| r56_8(char) = Load : &:r56_7, ~m49_2 # 56| valnum = unique -# 56| r3_8(int) = Convert : r3_7 +# 56| r56_9(int) = Convert : r56_8 # 56| valnum = unique -# 56| r3_9(bool) = CompareNE : r3_4, r3_8 +# 56| r56_10(bool) = CompareNE : r56_5, r56_9 # 56| valnum = unique -# 56| v3_10(void) = ConditionalBranch : r3_9 +# 56| v56_11(void) = ConditionalBranch : r56_10 #-----| False -> Block 6 #-----| True -> Block 4 # 56| Block 4 -# 56| r4_0(glval) = VariableAddress[ptr] : -# 56| valnum = r0_7 -# 56| r4_1(char *) = Load : &:r4_0, m3_0 -# 56| valnum = m3_0 -# 56| r4_2(char) = Load : &:r4_1, ~m0_1 +# 56| r56_12(glval) = VariableAddress[ptr] : +# 56| valnum = r50_1 +# 56| r56_13(char *) = Load : &:r56_12, m56_1 +# 56| valnum = m56_1 +# 56| r56_14(char) = Load : &:r56_13, ~m49_2 # 56| valnum = unique -# 56| r4_3(int) = Convert : r4_2 +# 56| r56_15(int) = Convert : r56_14 # 56| valnum = unique -# 56| r4_4(int) = Constant[0] : -# 56| valnum = r1_5 -# 56| r4_5(bool) = CompareNE : r4_3, r4_4 +# 56| r56_16(int) = Constant[0] : +# 56| valnum = r53_6 +# 56| r56_17(bool) = CompareNE : r56_15, r56_16 # 56| valnum = unique -# 56| v4_6(void) = ConditionalBranch : r4_5 +# 56| v56_18(void) = ConditionalBranch : r56_17 #-----| False -> Block 6 #-----| True -> Block 5 # 56| Block 5 -# 56| r5_0(glval) = VariableAddress[ptr] : -# 56| valnum = r0_7 -# 56| r5_1(char *) = Load : &:r5_0, m3_0 -# 56| valnum = m3_0 -# 56| r5_2(int) = Constant[1] : +# 56| r56_19(glval) = VariableAddress[ptr] : +# 56| valnum = r50_1 +# 56| r56_20(char *) = Load : &:r56_19, m56_1 +# 56| valnum = m56_1 +# 56| r56_21(int) = Constant[1] : # 56| valnum = unique -# 56| r5_3(char *) = PointerAdd[1] : r5_1, r5_2 -# 56| valnum = r5_3 -# 56| m5_4(char *) = Store : &:r5_0, r5_3 -# 56| valnum = r5_3 +# 56| r56_22(char *) = PointerAdd[1] : r56_20, r56_21 +# 56| valnum = r56_22 +# 56| m56_23(char *) = Store : &:r56_19, r56_22 +# 56| valnum = r56_22 #-----| Goto (back edge) -> Block 3 # 59| Block 6 -# 59| r6_0(glval) = VariableAddress[ptr] : -# 59| valnum = r0_7 -# 59| r6_1(char *) = Load : &:r6_0, m3_0 -# 59| valnum = m3_0 -# 59| r6_2(char) = Load : &:r6_1, ~m0_1 +# 59| r59_1(glval) = VariableAddress[ptr] : +# 59| valnum = r50_1 +# 59| r59_2(char *) = Load : &:r59_1, m56_1 +# 59| valnum = m56_1 +# 59| r59_3(char) = Load : &:r59_2, ~m49_2 # 59| valnum = unique -# 59| r6_3(int) = Convert : r6_2 +# 59| r59_4(int) = Convert : r59_3 # 59| valnum = unique -# 59| r6_4(int) = Constant[0] : -# 59| valnum = r1_5 -# 59| r6_5(bool) = CompareEQ : r6_3, r6_4 +# 59| r59_5(int) = Constant[0] : +# 59| valnum = r53_6 +# 59| r59_6(bool) = CompareEQ : r59_4, r59_5 # 59| valnum = unique -# 59| v6_6(void) = ConditionalBranch : r6_5 +# 59| v59_7(void) = ConditionalBranch : r59_6 #-----| False -> Block 8 #-----| True -> Block 7 # 60| Block 7 -# 60| v7_0(void) = NoOp : +# 60| v60_1(void) = NoOp : #-----| Goto -> Block 9 # 62| Block 8 -# 62| r8_0(glval) = VariableAddress[result] : -# 62| valnum = r0_9 -# 62| r8_1(unsigned int) = Load : &:r8_0, m1_0 -# 62| valnum = m1_0 -# 62| r8_2(unsigned int) = Constant[1] : +# 62| r62_1(glval) = VariableAddress[result] : +# 62| valnum = r51_1 +# 62| r62_2(unsigned int) = Load : &:r62_1, m53_1 +# 62| valnum = m53_1 +# 62| r62_3(unsigned int) = Constant[1] : # 62| valnum = unique -# 62| r8_3(unsigned int) = Add : r8_1, r8_2 -# 62| valnum = r8_3 -# 62| m8_4(unsigned int) = Store : &:r8_0, r8_3 -# 62| valnum = r8_3 +# 62| r62_4(unsigned int) = Add : r62_2, r62_3 +# 62| valnum = r62_4 +# 62| m62_5(unsigned int) = Store : &:r62_1, r62_4 +# 62| valnum = r62_4 #-----| Goto (back edge) -> Block 1 # 63| Block 9 -# 63| v9_0(void) = NoOp : -# 65| r9_1(glval) = VariableAddress[#return] : -# 65| valnum = r9_1 -# 65| r9_2(glval) = VariableAddress[result] : -# 65| valnum = r0_9 -# 65| r9_3(unsigned int) = Load : &:r9_2, m1_0 -# 65| valnum = m1_0 -# 65| m9_4(unsigned int) = Store : &:r9_1, r9_3 -# 65| valnum = m1_0 -# 49| r9_5(glval) = VariableAddress[#return] : -# 49| valnum = r9_1 -# 49| v9_6(void) = ReturnValue : &:r9_5, m9_4 -# 49| v9_7(void) = UnmodeledUse : mu* -# 49| v9_8(void) = AliasedUse : ~m0_1 -# 49| v9_9(void) = ExitFunction : +# 63| v63_1(void) = NoOp : +# 65| r65_1(glval) = VariableAddress[#return] : +# 65| valnum = r65_1 +# 65| r65_2(glval) = VariableAddress[result] : +# 65| valnum = r51_1 +# 65| r65_3(unsigned int) = Load : &:r65_2, m53_1 +# 65| valnum = m53_1 +# 65| m65_4(unsigned int) = Store : &:r65_1, r65_3 +# 65| valnum = m53_1 +# 49| r49_8(glval) = VariableAddress[#return] : +# 49| valnum = r65_1 +# 49| v49_9(void) = ReturnValue : &:r49_8, m65_4 +# 49| v49_10(void) = UnmodeledUse : mu* +# 49| v49_11(void) = AliasedUse : ~m49_2 +# 49| v49_12(void) = ExitFunction : # 75| void test04(two_values*) # 75| Block 0 -# 75| v0_0(void) = EnterFunction : -# 75| m0_1(unknown) = AliasedDefinition : +# 75| v75_1(void) = EnterFunction : +# 75| m75_2(unknown) = AliasedDefinition : # 75| valnum = unique -# 75| mu0_2(unknown) = UnmodeledDefinition : +# 75| mu75_3(unknown) = UnmodeledDefinition : # 75| valnum = unique -# 75| r0_3(glval) = VariableAddress[vals] : -# 75| valnum = r0_3 -# 75| m0_4(two_values *) = InitializeParameter[vals] : &:r0_3 -# 75| valnum = m0_4 -# 77| r0_5(glval) = VariableAddress[v] : -# 77| valnum = r0_5 -# 77| r0_6(glval) = FunctionAddress[getAValue] : +# 75| r75_4(glval) = VariableAddress[vals] : +# 75| valnum = r75_4 +# 75| m75_5(two_values *) = InitializeParameter[vals] : &:r75_4 +# 75| valnum = m75_5 +# 77| r77_1(glval) = VariableAddress[v] : +# 77| valnum = r77_1 +# 77| r77_2(glval) = FunctionAddress[getAValue] : # 77| valnum = unique -# 77| r0_7(int) = Call : func:r0_6 +# 77| r77_3(int) = Call : func:r77_2 # 77| valnum = unique -# 77| m0_8(unknown) = ^CallSideEffect : ~m0_1 +# 77| m77_4(unknown) = ^CallSideEffect : ~m75_2 # 77| valnum = unique -# 77| m0_9(unknown) = Chi : total:m0_1, partial:m0_8 +# 77| m77_5(unknown) = Chi : total:m75_2, partial:m77_4 # 77| valnum = unique -# 77| r0_10(signed short) = Convert : r0_7 -# 77| valnum = r0_10 -# 77| m0_11(signed short) = Store : &:r0_5, r0_10 -# 77| valnum = r0_10 -# 79| r0_12(glval) = VariableAddress[v] : -# 79| valnum = r0_5 -# 79| r0_13(signed short) = Load : &:r0_12, m0_11 -# 79| valnum = r0_10 -# 79| r0_14(int) = Convert : r0_13 +# 77| r77_6(signed short) = Convert : r77_3 +# 77| valnum = r77_6 +# 77| m77_7(signed short) = Store : &:r77_1, r77_6 +# 77| valnum = r77_6 +# 79| r79_1(glval) = VariableAddress[v] : +# 79| valnum = r77_1 +# 79| r79_2(signed short) = Load : &:r79_1, m77_7 +# 79| valnum = r77_6 +# 79| r79_3(int) = Convert : r79_2 # 79| valnum = unique -# 79| r0_15(glval) = VariableAddress[vals] : -# 79| valnum = r0_3 -# 79| r0_16(two_values *) = Load : &:r0_15, m0_4 -# 79| valnum = m0_4 -# 79| r0_17(glval) = FieldAddress[val1] : r0_16 +# 79| r79_4(glval) = VariableAddress[vals] : +# 79| valnum = r75_4 +# 79| r79_5(two_values *) = Load : &:r79_4, m75_5 +# 79| valnum = m75_5 +# 79| r79_6(glval) = FieldAddress[val1] : r79_5 # 79| valnum = unique -# 79| r0_18(signed short) = Load : &:r0_17, ~m0_9 +# 79| r79_7(signed short) = Load : &:r79_6, ~m77_5 # 79| valnum = unique -# 79| r0_19(int) = Convert : r0_18 +# 79| r79_8(int) = Convert : r79_7 # 79| valnum = unique -# 79| r0_20(glval) = VariableAddress[vals] : -# 79| valnum = r0_3 -# 79| r0_21(two_values *) = Load : &:r0_20, m0_4 -# 79| valnum = m0_4 -# 79| r0_22(glval) = FieldAddress[val2] : r0_21 +# 79| r79_9(glval) = VariableAddress[vals] : +# 79| valnum = r75_4 +# 79| r79_10(two_values *) = Load : &:r79_9, m75_5 +# 79| valnum = m75_5 +# 79| r79_11(glval) = FieldAddress[val2] : r79_10 # 79| valnum = unique -# 79| r0_23(signed short) = Load : &:r0_22, ~m0_9 +# 79| r79_12(signed short) = Load : &:r79_11, ~m77_5 # 79| valnum = unique -# 79| r0_24(int) = Convert : r0_23 +# 79| r79_13(int) = Convert : r79_12 # 79| valnum = unique -# 79| r0_25(int) = Add : r0_19, r0_24 +# 79| r79_14(int) = Add : r79_8, r79_13 # 79| valnum = unique -# 79| r0_26(bool) = CompareLT : r0_14, r0_25 +# 79| r79_15(bool) = CompareLT : r79_3, r79_14 # 79| valnum = unique -# 79| v0_27(void) = ConditionalBranch : r0_26 +# 79| v79_16(void) = ConditionalBranch : r79_15 #-----| False -> Block 2 #-----| True -> Block 1 # 80| Block 1 -# 80| r1_0(glval) = FunctionAddress[getAValue] : +# 80| r80_1(glval) = FunctionAddress[getAValue] : # 80| valnum = unique -# 80| r1_1(int) = Call : func:r1_0 +# 80| r80_2(int) = Call : func:r80_1 # 80| valnum = unique -# 80| m1_2(unknown) = ^CallSideEffect : ~m0_9 +# 80| m80_3(unknown) = ^CallSideEffect : ~m77_5 # 80| valnum = unique -# 80| m1_3(unknown) = Chi : total:m0_9, partial:m1_2 +# 80| m80_4(unknown) = Chi : total:m77_5, partial:m80_3 # 80| valnum = unique -# 80| r1_4(signed short) = Convert : r1_1 -# 80| valnum = r1_4 -# 80| r1_5(glval) = VariableAddress[v] : -# 80| valnum = r0_5 -# 80| m1_6(signed short) = Store : &:r1_5, r1_4 -# 80| valnum = r1_4 +# 80| r80_5(signed short) = Convert : r80_2 +# 80| valnum = r80_5 +# 80| r80_6(glval) = VariableAddress[v] : +# 80| valnum = r77_1 +# 80| m80_7(signed short) = Store : &:r80_6, r80_5 +# 80| valnum = r80_5 #-----| Goto -> Block 2 # 82| Block 2 -# 82| m2_0(unknown) = Phi : from 0:~m0_9, from 1:~m1_3 +# 82| m82_1(unknown) = Phi : from 0:~m77_5, from 1:~m80_4 # 82| valnum = unique -# 82| v2_1(void) = NoOp : -# 75| v2_2(void) = ReturnVoid : -# 75| v2_3(void) = UnmodeledUse : mu* -# 75| v2_4(void) = AliasedUse : ~m2_0 -# 75| v2_5(void) = ExitFunction : +# 82| v82_2(void) = NoOp : +# 75| v75_6(void) = ReturnVoid : +# 75| v75_7(void) = UnmodeledUse : mu* +# 75| v75_8(void) = AliasedUse : ~m82_1 +# 75| v75_9(void) = ExitFunction : # 84| void test05(int, int, void*) # 84| Block 0 -# 84| v0_0(void) = EnterFunction : -# 84| m0_1(unknown) = AliasedDefinition : +# 84| v84_1(void) = EnterFunction : +# 84| m84_2(unknown) = AliasedDefinition : # 84| valnum = unique -# 84| mu0_2(unknown) = UnmodeledDefinition : +# 84| mu84_3(unknown) = UnmodeledDefinition : # 84| valnum = unique -# 84| r0_3(glval) = VariableAddress[x] : -# 84| valnum = r0_3 -# 84| m0_4(int) = InitializeParameter[x] : &:r0_3 -# 84| valnum = m0_4 -# 84| r0_5(glval) = VariableAddress[y] : -# 84| valnum = r0_5 -# 84| m0_6(int) = InitializeParameter[y] : &:r0_5 -# 84| valnum = m0_6 -# 84| r0_7(glval) = VariableAddress[p] : -# 84| valnum = r0_7 -# 84| m0_8(void *) = InitializeParameter[p] : &:r0_7 -# 84| valnum = m0_8 -# 86| r0_9(glval) = VariableAddress[v] : -# 86| valnum = r0_9 -# 86| m0_10(int) = Uninitialized[v] : &:r0_9 +# 84| r84_4(glval) = VariableAddress[x] : +# 84| valnum = r84_4 +# 84| m84_5(int) = InitializeParameter[x] : &:r84_4 +# 84| valnum = m84_5 +# 84| r84_6(glval) = VariableAddress[y] : +# 84| valnum = r84_6 +# 84| m84_7(int) = InitializeParameter[y] : &:r84_6 +# 84| valnum = m84_7 +# 84| r84_8(glval) = VariableAddress[p] : +# 84| valnum = r84_8 +# 84| m84_9(void *) = InitializeParameter[p] : &:r84_8 +# 84| valnum = m84_9 +# 86| r86_1(glval) = VariableAddress[v] : +# 86| valnum = r86_1 +# 86| m86_2(int) = Uninitialized[v] : &:r86_1 # 86| valnum = unique -# 88| r0_11(glval) = VariableAddress[p] : -# 88| valnum = r0_7 -# 88| r0_12(void *) = Load : &:r0_11, m0_8 -# 88| valnum = m0_8 -# 88| r0_13(void *) = Constant[0] : +# 88| r88_1(glval) = VariableAddress[p] : +# 88| valnum = r84_8 +# 88| r88_2(void *) = Load : &:r88_1, m84_9 +# 88| valnum = m84_9 +# 88| r88_3(void *) = Constant[0] : # 88| valnum = unique -# 88| r0_14(bool) = CompareNE : r0_12, r0_13 +# 88| r88_4(bool) = CompareNE : r88_2, r88_3 # 88| valnum = unique -# 88| v0_15(void) = ConditionalBranch : r0_14 +# 88| v88_5(void) = ConditionalBranch : r88_4 #-----| False -> Block 2 #-----| True -> Block 1 # 88| Block 1 -# 88| r1_0(glval) = VariableAddress[x] : -# 88| valnum = r0_3 -# 88| r1_1(int) = Load : &:r1_0, m0_4 -# 88| valnum = m0_4 -# 88| r1_2(glval) = VariableAddress[#temp88:7] : -# 88| valnum = r1_2 -# 88| m1_3(int) = Store : &:r1_2, r1_1 -# 88| valnum = m0_4 +# 88| r88_6(glval) = VariableAddress[x] : +# 88| valnum = r84_4 +# 88| r88_7(int) = Load : &:r88_6, m84_5 +# 88| valnum = m84_5 +# 88| r88_8(glval) = VariableAddress[#temp88:7] : +# 88| valnum = r88_8 +# 88| m88_9(int) = Store : &:r88_8, r88_7 +# 88| valnum = m84_5 #-----| Goto -> Block 3 # 88| Block 2 -# 88| r2_0(glval) = VariableAddress[y] : -# 88| valnum = r0_5 -# 88| r2_1(int) = Load : &:r2_0, m0_6 -# 88| valnum = m0_6 -# 88| r2_2(glval) = VariableAddress[#temp88:7] : -# 88| valnum = r1_2 -# 88| m2_3(int) = Store : &:r2_2, r2_1 -# 88| valnum = m0_6 +# 88| r88_10(glval) = VariableAddress[y] : +# 88| valnum = r84_6 +# 88| r88_11(int) = Load : &:r88_10, m84_7 +# 88| valnum = m84_7 +# 88| r88_12(glval) = VariableAddress[#temp88:7] : +# 88| valnum = r88_8 +# 88| m88_13(int) = Store : &:r88_12, r88_11 +# 88| valnum = m84_7 #-----| Goto -> Block 3 # 88| Block 3 -# 88| m3_0(int) = Phi : from 1:m1_3, from 2:m2_3 -# 88| valnum = m3_0 -# 88| r3_1(glval) = VariableAddress[#temp88:7] : -# 88| valnum = r1_2 -# 88| r3_2(int) = Load : &:r3_1, m3_0 -# 88| valnum = m3_0 -# 88| r3_3(glval) = VariableAddress[v] : -# 88| valnum = r0_9 -# 88| m3_4(int) = Store : &:r3_3, r3_2 -# 88| valnum = m3_0 -# 89| v3_5(void) = NoOp : -# 84| v3_6(void) = ReturnVoid : -# 84| v3_7(void) = UnmodeledUse : mu* -# 84| v3_8(void) = AliasedUse : ~m0_1 -# 84| v3_9(void) = ExitFunction : +# 88| m88_14(int) = Phi : from 1:m88_9, from 2:m88_13 +# 88| valnum = m88_14 +# 88| r88_15(glval) = VariableAddress[#temp88:7] : +# 88| valnum = r88_8 +# 88| r88_16(int) = Load : &:r88_15, m88_14 +# 88| valnum = m88_14 +# 88| r88_17(glval) = VariableAddress[v] : +# 88| valnum = r86_1 +# 88| m88_18(int) = Store : &:r88_17, r88_16 +# 88| valnum = m88_14 +# 89| v89_1(void) = NoOp : +# 84| v84_10(void) = ReturnVoid : +# 84| v84_11(void) = UnmodeledUse : mu* +# 84| v84_12(void) = AliasedUse : ~m84_2 +# 84| v84_13(void) = ExitFunction : # 91| int regression_test00() # 91| Block 0 -# 91| v0_0(void) = EnterFunction : -# 91| m0_1(unknown) = AliasedDefinition : +# 91| v91_1(void) = EnterFunction : +# 91| m91_2(unknown) = AliasedDefinition : # 91| valnum = unique -# 91| mu0_2(unknown) = UnmodeledDefinition : +# 91| mu91_3(unknown) = UnmodeledDefinition : # 91| valnum = unique -# 92| r0_3(glval) = VariableAddress[x] : -# 92| valnum = r0_3 -# 92| r0_4(int) = Constant[10] : -# 92| valnum = r0_4 -# 92| r0_5(glval) = VariableAddress[x] : -# 92| valnum = r0_3 -# 92| m0_6(int) = Store : &:r0_5, r0_4 -# 92| valnum = r0_4 -# 92| r0_7(int) = CopyValue : r0_4 -# 92| valnum = r0_4 -# 92| m0_8(int) = Store : &:r0_3, r0_7 -# 92| valnum = r0_4 -# 93| r0_9(glval) = VariableAddress[#return] : -# 93| valnum = r0_9 -# 93| r0_10(glval) = VariableAddress[x] : -# 93| valnum = r0_3 -# 93| r0_11(int) = Load : &:r0_10, m0_8 -# 93| valnum = r0_4 -# 93| m0_12(int) = Store : &:r0_9, r0_11 -# 93| valnum = r0_4 -# 91| r0_13(glval) = VariableAddress[#return] : -# 91| valnum = r0_9 -# 91| v0_14(void) = ReturnValue : &:r0_13, m0_12 -# 91| v0_15(void) = UnmodeledUse : mu* -# 91| v0_16(void) = AliasedUse : ~m0_1 -# 91| v0_17(void) = ExitFunction : +# 92| r92_1(glval) = VariableAddress[x] : +# 92| valnum = r92_1 +# 92| r92_2(int) = Constant[10] : +# 92| valnum = r92_2 +# 92| r92_3(glval) = VariableAddress[x] : +# 92| valnum = r92_1 +# 92| m92_4(int) = Store : &:r92_3, r92_2 +# 92| valnum = r92_2 +# 92| r92_5(int) = CopyValue : r92_2 +# 92| valnum = r92_2 +# 92| m92_6(int) = Store : &:r92_1, r92_5 +# 92| valnum = r92_2 +# 93| r93_1(glval) = VariableAddress[#return] : +# 93| valnum = r93_1 +# 93| r93_2(glval) = VariableAddress[x] : +# 93| valnum = r92_1 +# 93| r93_3(int) = Load : &:r93_2, m92_6 +# 93| valnum = r92_2 +# 93| m93_4(int) = Store : &:r93_1, r93_3 +# 93| valnum = r92_2 +# 91| r91_4(glval) = VariableAddress[#return] : +# 91| valnum = r93_1 +# 91| v91_5(void) = ReturnValue : &:r91_4, m93_4 +# 91| v91_6(void) = UnmodeledUse : mu* +# 91| v91_7(void) = AliasedUse : ~m91_2 +# 91| v91_8(void) = ExitFunction : # 104| int inheritanceConversions(Derived*) # 104| Block 0 -# 104| v0_0(void) = EnterFunction : -# 104| m0_1(unknown) = AliasedDefinition : +# 104| v104_1(void) = EnterFunction : +# 104| m104_2(unknown) = AliasedDefinition : # 104| valnum = unique -# 104| mu0_2(unknown) = UnmodeledDefinition : +# 104| mu104_3(unknown) = UnmodeledDefinition : # 104| valnum = unique -# 104| r0_3(glval) = VariableAddress[pd] : -# 104| valnum = r0_3 -# 104| m0_4(Derived *) = InitializeParameter[pd] : &:r0_3 -# 104| valnum = m0_4 -# 105| r0_5(glval) = VariableAddress[x] : +# 104| r104_4(glval) = VariableAddress[pd] : +# 104| valnum = r104_4 +# 104| m104_5(Derived *) = InitializeParameter[pd] : &:r104_4 +# 104| valnum = m104_5 +# 105| r105_1(glval) = VariableAddress[x] : # 105| valnum = unique -# 105| r0_6(glval) = VariableAddress[pd] : -# 105| valnum = r0_3 -# 105| r0_7(Derived *) = Load : &:r0_6, m0_4 -# 105| valnum = m0_4 -# 105| r0_8(Base *) = ConvertToNonVirtualBase[Derived : Base] : r0_7 -# 105| valnum = r0_8 -# 105| r0_9(glval) = FieldAddress[b] : r0_8 -# 105| valnum = r0_9 -# 105| r0_10(int) = Load : &:r0_9, ~m0_1 -# 105| valnum = r0_10 -# 105| m0_11(int) = Store : &:r0_5, r0_10 -# 105| valnum = r0_10 -# 106| r0_12(glval) = VariableAddress[pb] : -# 106| valnum = r0_12 -# 106| r0_13(glval) = VariableAddress[pd] : -# 106| valnum = r0_3 -# 106| r0_14(Derived *) = Load : &:r0_13, m0_4 -# 106| valnum = m0_4 -# 106| r0_15(Base *) = ConvertToNonVirtualBase[Derived : Base] : r0_14 -# 106| valnum = r0_8 -# 106| m0_16(Base *) = Store : &:r0_12, r0_15 -# 106| valnum = r0_8 -# 107| r0_17(glval) = VariableAddress[y] : -# 107| valnum = r0_17 -# 107| r0_18(glval) = VariableAddress[pb] : -# 107| valnum = r0_12 -# 107| r0_19(Base *) = Load : &:r0_18, m0_16 -# 107| valnum = r0_8 -# 107| r0_20(glval) = FieldAddress[b] : r0_19 -# 107| valnum = r0_9 -# 107| r0_21(int) = Load : &:r0_20, ~m0_1 -# 107| valnum = r0_21 -# 107| m0_22(int) = Store : &:r0_17, r0_21 -# 107| valnum = r0_21 -# 109| r0_23(glval) = VariableAddress[#return] : -# 109| valnum = r0_23 -# 109| r0_24(glval) = VariableAddress[y] : -# 109| valnum = r0_17 -# 109| r0_25(int) = Load : &:r0_24, m0_22 -# 109| valnum = r0_21 -# 109| m0_26(int) = Store : &:r0_23, r0_25 -# 109| valnum = r0_21 -# 104| r0_27(glval) = VariableAddress[#return] : -# 104| valnum = r0_23 -# 104| v0_28(void) = ReturnValue : &:r0_27, m0_26 -# 104| v0_29(void) = UnmodeledUse : mu* -# 104| v0_30(void) = AliasedUse : ~m0_1 -# 104| v0_31(void) = ExitFunction : +# 105| r105_2(glval) = VariableAddress[pd] : +# 105| valnum = r104_4 +# 105| r105_3(Derived *) = Load : &:r105_2, m104_5 +# 105| valnum = m104_5 +# 105| r105_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r105_3 +# 105| valnum = r105_4 +# 105| r105_5(glval) = FieldAddress[b] : r105_4 +# 105| valnum = r105_5 +# 105| r105_6(int) = Load : &:r105_5, ~m104_2 +# 105| valnum = r105_6 +# 105| m105_7(int) = Store : &:r105_1, r105_6 +# 105| valnum = r105_6 +# 106| r106_1(glval) = VariableAddress[pb] : +# 106| valnum = r106_1 +# 106| r106_2(glval) = VariableAddress[pd] : +# 106| valnum = r104_4 +# 106| r106_3(Derived *) = Load : &:r106_2, m104_5 +# 106| valnum = m104_5 +# 106| r106_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r106_3 +# 106| valnum = r105_4 +# 106| m106_5(Base *) = Store : &:r106_1, r106_4 +# 106| valnum = r105_4 +# 107| r107_1(glval) = VariableAddress[y] : +# 107| valnum = r107_1 +# 107| r107_2(glval) = VariableAddress[pb] : +# 107| valnum = r106_1 +# 107| r107_3(Base *) = Load : &:r107_2, m106_5 +# 107| valnum = r105_4 +# 107| r107_4(glval) = FieldAddress[b] : r107_3 +# 107| valnum = r105_5 +# 107| r107_5(int) = Load : &:r107_4, ~m104_2 +# 107| valnum = r107_5 +# 107| m107_6(int) = Store : &:r107_1, r107_5 +# 107| valnum = r107_5 +# 109| r109_1(glval) = VariableAddress[#return] : +# 109| valnum = r109_1 +# 109| r109_2(glval) = VariableAddress[y] : +# 109| valnum = r107_1 +# 109| r109_3(int) = Load : &:r109_2, m107_6 +# 109| valnum = r107_5 +# 109| m109_4(int) = Store : &:r109_1, r109_3 +# 109| valnum = r107_5 +# 104| r104_6(glval) = VariableAddress[#return] : +# 104| valnum = r109_1 +# 104| v104_7(void) = ReturnValue : &:r104_6, m109_4 +# 104| v104_8(void) = UnmodeledUse : mu* +# 104| v104_9(void) = AliasedUse : ~m104_2 +# 104| v104_10(void) = ExitFunction : # 112| void test06() # 112| Block 0 -# 112| v0_0(void) = EnterFunction : -# 112| m0_1(unknown) = AliasedDefinition : +# 112| v112_1(void) = EnterFunction : +# 112| m112_2(unknown) = AliasedDefinition : # 112| valnum = unique -# 112| mu0_2(unknown) = UnmodeledDefinition : +# 112| mu112_3(unknown) = UnmodeledDefinition : # 112| valnum = unique -# 113| r0_3(glval) = StringConstant["a"] : -# 113| valnum = r0_3 -# 114| r0_4(glval) = StringConstant["b"] : +# 113| r113_1(glval) = StringConstant["a"] : +# 113| valnum = r113_1 +# 114| r114_1(glval) = StringConstant["b"] : # 114| valnum = unique -# 115| r0_5(glval) = StringConstant["a"] : -# 115| valnum = r0_3 -# 116| r0_6(glval) = StringConstant["c"] : +# 115| r115_1(glval) = StringConstant["a"] : +# 115| valnum = r113_1 +# 116| r116_1(glval) = StringConstant["c"] : # 116| valnum = unique -# 117| v0_7(void) = NoOp : -# 112| v0_8(void) = ReturnVoid : -# 112| v0_9(void) = UnmodeledUse : mu* -# 112| v0_10(void) = AliasedUse : ~m0_1 -# 112| v0_11(void) = ExitFunction : +# 117| v117_1(void) = NoOp : +# 112| v112_4(void) = ReturnVoid : +# 112| v112_5(void) = UnmodeledUse : mu* +# 112| v112_6(void) = AliasedUse : ~m112_2 +# 112| v112_7(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/variables/variables/variable.expected b/cpp/ql/test/library-tests/variables/variables/variable.expected index 0599d840068..11a68882ddc 100644 --- a/cpp/ql/test/library-tests/variables/variables/variable.expected +++ b/cpp/ql/test/library-tests/variables/variables/variable.expected @@ -2,13 +2,9 @@ | file://:0:0:0:0 | gp_offset | file://:0:0:0:0 | unsigned int | Field | | | | file://:0:0:0:0 | overflow_arg_area | file://:0:0:0:0 | void * | Field | | | | file://:0:0:0:0 | p#0 | file://:0:0:0:0 | __va_list_tag && | SemanticStackVariable | | | -| file://:0:0:0:0 | p#0 | file://:0:0:0:0 | __va_list_tag && | StackVariable | | | | file://:0:0:0:0 | p#0 | file://:0:0:0:0 | address && | SemanticStackVariable | | | -| file://:0:0:0:0 | p#0 | file://:0:0:0:0 | address && | StackVariable | | | | file://:0:0:0:0 | p#0 | file://:0:0:0:0 | const __va_list_tag & | SemanticStackVariable | | | -| file://:0:0:0:0 | p#0 | file://:0:0:0:0 | const __va_list_tag & | StackVariable | | | | file://:0:0:0:0 | p#0 | file://:0:0:0:0 | const address & | SemanticStackVariable | | | -| file://:0:0:0:0 | p#0 | file://:0:0:0:0 | const address & | StackVariable | | | | file://:0:0:0:0 | reg_save_area | file://:0:0:0:0 | void * | Field | | | | variables.cpp:1:12:1:12 | i | file://:0:0:0:0 | int | GlobalVariable | | | | variables.cpp:2:12:2:12 | i | file://:0:0:0:0 | int | GlobalVariable | | | @@ -38,11 +34,10 @@ | variables.cpp:37:6:37:8 | ap3 | file://:0:0:0:0 | int * | GlobalVariable | | | | variables.cpp:41:7:41:11 | local | file://:0:0:0:0 | char[] | LocalVariable | | | | variables.cpp:41:7:41:11 | local | file://:0:0:0:0 | char[] | SemanticStackVariable | | | -| variables.cpp:41:7:41:11 | local | file://:0:0:0:0 | char[] | StackVariable | | | | variables.cpp:43:14:43:18 | local | file://:0:0:0:0 | int | LocalVariable | | static | -| variables.cpp:43:14:43:18 | local | file://:0:0:0:0 | int | StackVariable | | static | | variables.cpp:48:9:48:12 | name | file://:0:0:0:0 | char * | Field | | | | variables.cpp:49:12:49:17 | number | file://:0:0:0:0 | long | Field | | | | variables.cpp:50:9:50:14 | street | file://:0:0:0:0 | char * | Field | | | | variables.cpp:51:9:51:12 | town | file://:0:0:0:0 | char * | Field | | | | variables.cpp:52:16:52:22 | country | file://:0:0:0:0 | char * | MemberVariable | | static | +| variables.cpp:56:14:56:29 | externInFunction | file://:0:0:0:0 | int | GlobalVariable | | | diff --git a/cpp/ql/test/library-tests/variables/variables/variables.cpp b/cpp/ql/test/library-tests/variables/variables/variables.cpp index cbca2b3b822..6cbbacebc3c 100644 --- a/cpp/ql/test/library-tests/variables/variables/variables.cpp +++ b/cpp/ql/test/library-tests/variables/variables/variables.cpp @@ -51,3 +51,7 @@ struct address { char* town; static char* country; }; + +void hasExtern() { + extern int externInFunction; +} diff --git a/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.qhelp b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.qhelp new file mode 100644 index 00000000000..36b9065ba8b --- /dev/null +++ b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.qhelp @@ -0,0 +1,52 @@ + + + + +

+ The requestValidationMode attribute in ASP.NET is used to configure built-in validation to + protect applications against code injections. Downgrading or disabling + this configuration is not recommended. The default value of 4.5 + is the only recommended value, as previous versions only test a subset of requests. +

+ + + + +

+ Always set requestValidationMode to 4.5, or leave it at its default value. +

+ + + + +

+ The following example shows the requestValidationMode + attribute set to a value of 4.0, which disables some protections and + ignores individual Page directives: +

+ + + +

+ Setting the value to 4.5 enables request validation for all requests: +

+ + + + + + +
  • + Microsoft: + HttpRuntimeSection.RequestValidationMode Property + . +
    • +
  • + OWASP: + ASP.NET Request Validation. +
    • +     + + diff --git a/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.ql b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.ql new file mode 100644 index 00000000000..0e3e92fa821 --- /dev/null +++ b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationMode.ql @@ -0,0 +1,20 @@ +/** + * @name Insecure configuration for ASP.NET requestValidationMode + * @description Setting 'requestValidationMode' to less than 4.5 disables built-in validations + * included by default in ASP.NET. Disabling or downgrading this protection is not + * recommended. + * @kind problem + * @id cs/insecure-request-validation-mode + * @problem.severity warning + * @tags security + * external/cwe/cwe-016 + */ + +import csharp + +from XMLAttribute reqValidationMode +where + reqValidationMode.getName().toLowerCase() = "requestvalidationmode" and + reqValidationMode.getValue().toFloat() < 4.5 +select reqValidationMode, + "Insecure value for requestValidationMode (" + reqValidationMode.getValue() + ")." diff --git a/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeBad.config b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeBad.config new file mode 100644 index 00000000000..e2c8b8dc903 --- /dev/null +++ b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeBad.config @@ -0,0 +1,5 @@ + + + + + diff --git a/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeGood.config b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeGood.config new file mode 100644 index 00000000000..b050797ecc2 --- /dev/null +++ b/csharp/ql/src/Security Features/CWE-016/ASPNetRequestValidationModeGood.config @@ -0,0 +1,5 @@ + + + + + diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl.qll index 9519a74265f..1f322a02201 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl2.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl2.qll index 9519a74265f..1f322a02201 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl2.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl2.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl3.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl3.qll index 9519a74265f..1f322a02201 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl3.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl3.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl4.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl4.qll index 9519a74265f..1f322a02201 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl4.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl4.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl5.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl5.qll index 9519a74265f..1f322a02201 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl5.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImpl5.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImplCommon.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImplCommon.qll index 91f5aeacc9d..87b33a79b8b 100644 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImplCommon.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/DataFlowImplCommon.qll @@ -360,7 +360,7 @@ private module ImplCommon { */ cached predicate read(Node node1, Content f, Node node2) { - readStep(node1, f, node2) and storeStep(_, f, _) + readStep(node1, f, node2) or exists(DataFlowCall call, ReturnKind kind | read0(call, kind, node1, f) and diff --git a/csharp/ql/src/semmle/code/csharp/dataflow/internal/TaintTrackingPrivate.qll b/csharp/ql/src/semmle/code/csharp/dataflow/internal/TaintTrackingPrivate.qll index 8c24227f73a..ba3cc5b2dec 100755 --- a/csharp/ql/src/semmle/code/csharp/dataflow/internal/TaintTrackingPrivate.qll +++ b/csharp/ql/src/semmle/code/csharp/dataflow/internal/TaintTrackingPrivate.qll @@ -113,6 +113,12 @@ private class LocalTaintExprStepConfiguration extends ControlFlowReachabilityCon scope = e2 and isSuccessor = true ) + or + e2 = any(OperatorCall oc | + oc.getTarget().(ConversionOperator).fromLibrary() and + e1 = oc.getAnArgument() and + isSuccessor = true + ) ) } diff --git a/csharp/ql/src/semmle/code/csharp/dispatch/Dispatch.qll b/csharp/ql/src/semmle/code/csharp/dispatch/Dispatch.qll index 433f916fb57..438a74d1197 100644 --- a/csharp/ql/src/semmle/code/csharp/dispatch/Dispatch.qll +++ b/csharp/ql/src/semmle/code/csharp/dispatch/Dispatch.qll @@ -190,10 +190,16 @@ private module Internal { abstract RuntimeCallable getADynamicTarget(); } + pragma[noinline] + private predicate hasOverrider(OverridableCallable oc, ValueOrRefType t) { + exists(oc.getAnOverrider(t)) + } + pragma[noinline] private predicate hasCallable(OverridableCallable source, ValueOrRefType t, OverridableCallable c) { c.getSourceDeclaration() = source and t.hasCallable(c) and + hasOverrider(c, t) and hasQualifierTypeOverridden0(t, _) and hasQualifierTypeOverridden1(source, _) } @@ -215,15 +221,19 @@ private module Internal { pragma[noinline] private predicate hasQualifierTypeOverridden0(ValueOrRefType t, DispatchMethodOrAccessorCall call) { - exists(Type t0 | t0 = getAPossibleType(call.getQualifier(), false) | - t = t0 + hasOverrider(_, t) and + ( + exists(Type t0 | t0 = getAPossibleType(call.getQualifier(), false) | + t = t0 + or + Unification::subsumes(t0, t) + or + t = t0.(Unification::UnconstrainedTypeParameter).getAnUltimatelySuppliedType() + ) or - Unification::subsumes(t0, t) - or - t = t0.(Unification::UnconstrainedTypeParameter).getAnUltimatelySuppliedType() + constrainedTypeParameterQualifierTypeSubsumes(t, + getAConstrainedTypeParameterQualifierType(call)) ) - or - constrainedTypeParameterQualifierTypeSubsumes(t, getAConstrainedTypeParameterQualifierType(call)) } pragma[noinline] diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/raw/Instruction.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/raw/Instruction.qll index b325aeb1bf1..241de4406e8 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/raw/Instruction.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/raw/Instruction.qll @@ -359,24 +359,25 @@ class Instruction extends Construction::TInstruction { */ int getDisplayIndexInBlock() { exists(IRBlock block | - block = getBlock() and - ( - exists(int index, int phiCount | - phiCount = count(block.getAPhiInstruction()) and - this = block.getInstruction(index) and - result = index + phiCount + this = block.getInstruction(result) + or + this = rank[-result - 1](PhiInstruction phiInstr | + phiInstr = block.getAPhiInstruction() + | + phiInstr order by phiInstr.getUniqueId() ) - or - this instanceof PhiInstruction and - this = rank[result + 1](PhiInstruction phiInstr | - phiInstr = block.getAPhiInstruction() - | - phiInstr order by phiInstr.getUniqueId() - ) - ) ) } + private int getLineRank() { + this = rank[result](Instruction instr | + instr.getAST().getFile() = getAST().getFile() and + instr.getAST().getLocation().getStartLine() = getAST().getLocation().getStartLine() + | + instr order by instr.getBlock().getDisplayIndex(), instr.getDisplayIndexInBlock() + ) + } + /** * Gets a human-readable string that uniquely identifies this instruction * within the function. This string is used to refer to this instruction when @@ -385,8 +386,7 @@ class Instruction extends Construction::TInstruction { * Example: `r1_1` */ string getResultId() { - result = getResultPrefix() + getBlock().getDisplayIndex().toString() + "_" + - getDisplayIndexInBlock().toString() + result = getResultPrefix() + getAST().getLocation().getStartLine() + "_" + getLineRank() } /** diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/Instruction.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/Instruction.qll index b325aeb1bf1..241de4406e8 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/Instruction.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/Instruction.qll @@ -359,24 +359,25 @@ class Instruction extends Construction::TInstruction { */ int getDisplayIndexInBlock() { exists(IRBlock block | - block = getBlock() and - ( - exists(int index, int phiCount | - phiCount = count(block.getAPhiInstruction()) and - this = block.getInstruction(index) and - result = index + phiCount + this = block.getInstruction(result) + or + this = rank[-result - 1](PhiInstruction phiInstr | + phiInstr = block.getAPhiInstruction() + | + phiInstr order by phiInstr.getUniqueId() ) - or - this instanceof PhiInstruction and - this = rank[result + 1](PhiInstruction phiInstr | - phiInstr = block.getAPhiInstruction() - | - phiInstr order by phiInstr.getUniqueId() - ) - ) ) } + private int getLineRank() { + this = rank[result](Instruction instr | + instr.getAST().getFile() = getAST().getFile() and + instr.getAST().getLocation().getStartLine() = getAST().getLocation().getStartLine() + | + instr order by instr.getBlock().getDisplayIndex(), instr.getDisplayIndexInBlock() + ) + } + /** * Gets a human-readable string that uniquely identifies this instruction * within the function. This string is used to refer to this instruction when @@ -385,8 +386,7 @@ class Instruction extends Construction::TInstruction { * Example: `r1_1` */ string getResultId() { - result = getResultPrefix() + getBlock().getDisplayIndex().toString() + "_" + - getDisplayIndexInBlock().toString() + result = getResultPrefix() + getAST().getLocation().getStartLine() + "_" + getLineRank() } /** diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll index c6a6bc3fec9..3b44e6f555a 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll @@ -1,5 +1,6 @@ import AliasAnalysis private import SimpleSSAImports +import SimpleSSAPublicImports private class IntValue = Ints::IntValue; diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll index b6f92fda444..91d4124f558 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAImports.qll @@ -2,4 +2,3 @@ import semmle.code.csharp.ir.implementation.raw.IR import semmle.code.csharp.ir.internal.IntegerConstant as Ints import semmle.code.csharp.ir.implementation.internal.OperandTag import semmle.code.csharp.ir.internal.IRCSharpLanguage as Language -import semmle.code.csharp.ir.internal.Overlap diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll new file mode 100644 index 00000000000..555cb581d37 --- /dev/null +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/SimpleSSAPublicImports.qll @@ -0,0 +1 @@ +import semmle.code.csharp.ir.internal.Overlap diff --git a/csharp/ql/test/library-tests/dataflow/local/DataFlowStep.expected b/csharp/ql/test/library-tests/dataflow/local/DataFlowStep.expected index b7e8efea46d..63688aab59b 100644 --- a/csharp/ql/test/library-tests/dataflow/local/DataFlowStep.expected +++ b/csharp/ql/test/library-tests/dataflow/local/DataFlowStep.expected @@ -586,6 +586,9 @@ | LocalDataFlow.cs:480:67:480:68 | os | LocalDataFlow.cs:486:32:486:33 | access to parameter os | | LocalDataFlow.cs:483:21:483:21 | access to parameter x | LocalDataFlow.cs:483:16:483:21 | ... = ... | | LocalDataFlow.cs:486:32:486:33 | access to parameter os | LocalDataFlow.cs:486:26:486:33 | ... = ... | +| LocalDataFlow.cs:491:41:491:44 | args | LocalDataFlow.cs:493:29:493:32 | access to parameter args | +| LocalDataFlow.cs:493:29:493:32 | [post] access to parameter args | LocalDataFlow.cs:494:27:494:30 | access to parameter args | +| LocalDataFlow.cs:493:29:493:32 | access to parameter args | LocalDataFlow.cs:494:27:494:30 | access to parameter args | | SSA.cs:5:17:5:17 | SSA entry def(this.S) | SSA.cs:67:9:67:14 | access to field S | | SSA.cs:5:17:5:17 | this | SSA.cs:67:9:67:12 | this access | | SSA.cs:5:26:5:32 | tainted | SSA.cs:8:24:8:30 | access to parameter tainted | diff --git a/csharp/ql/test/library-tests/dataflow/local/LocalDataFlow.cs b/csharp/ql/test/library-tests/dataflow/local/LocalDataFlow.cs index 95878572758..6603abc50f1 100644 --- a/csharp/ql/test/library-tests/dataflow/local/LocalDataFlow.cs +++ b/csharp/ql/test/library-tests/dataflow/local/LocalDataFlow.cs @@ -485,4 +485,12 @@ public class LocalDataFlow IEnumerable os2; foreach(var o in os2 = os) { } } + + public static implicit operator LocalDataFlow(string[] args) => null; + + public void ConversionFlow(string[] args) + { + Span span = args; // flow (library operator) + LocalDataFlow x = args; // no flow (source code operator) + } } diff --git a/csharp/ql/test/library-tests/dataflow/local/TaintTrackingStep.expected b/csharp/ql/test/library-tests/dataflow/local/TaintTrackingStep.expected index 6ebbe0fadbe..120f6a20220 100644 --- a/csharp/ql/test/library-tests/dataflow/local/TaintTrackingStep.expected +++ b/csharp/ql/test/library-tests/dataflow/local/TaintTrackingStep.expected @@ -736,6 +736,11 @@ | LocalDataFlow.cs:480:67:480:68 | os | LocalDataFlow.cs:486:32:486:33 | access to parameter os | | LocalDataFlow.cs:483:21:483:21 | access to parameter x | LocalDataFlow.cs:483:16:483:21 | ... = ... | | LocalDataFlow.cs:486:32:486:33 | access to parameter os | LocalDataFlow.cs:486:26:486:33 | ... = ... | +| LocalDataFlow.cs:491:41:491:44 | args | LocalDataFlow.cs:491:41:491:44 | args | +| LocalDataFlow.cs:491:41:491:44 | args | LocalDataFlow.cs:493:29:493:32 | access to parameter args | +| LocalDataFlow.cs:493:29:493:32 | [post] access to parameter args | LocalDataFlow.cs:494:27:494:30 | access to parameter args | +| LocalDataFlow.cs:493:29:493:32 | access to parameter args | LocalDataFlow.cs:493:29:493:32 | call to operator implicit conversion | +| LocalDataFlow.cs:493:29:493:32 | access to parameter args | LocalDataFlow.cs:494:27:494:30 | access to parameter args | | SSA.cs:5:17:5:17 | SSA entry def(this.S) | SSA.cs:67:9:67:14 | access to field S | | SSA.cs:5:17:5:17 | this | SSA.cs:67:9:67:12 | this access | | SSA.cs:5:26:5:32 | tainted | SSA.cs:5:26:5:32 | tainted | diff --git a/csharp/ql/test/library-tests/frameworks/EntityFramework/EntityFrameworkCore.cs b/csharp/ql/test/library-tests/frameworks/EntityFramework/EntityFrameworkCore.cs index 8b4467f00ed..afb6320db0e 100644 --- a/csharp/ql/test/library-tests/frameworks/EntityFramework/EntityFrameworkCore.cs +++ b/csharp/ql/test/library-tests/frameworks/EntityFramework/EntityFrameworkCore.cs @@ -50,7 +50,7 @@ namespace EFCoreTests Sink(taintSource); // Tainted Sink(new RawSqlString(taintSource)); // Tainted Sink((RawSqlString)taintSource); // Tainted - Sink((RawSqlString)(FormattableString)$"{taintSource}"); // Not tainted + Sink((RawSqlString)(FormattableString)$"{taintSource}"); // Tainted, but not reported because conversion operator is in a stub .cs file // Tainted via database, even though technically there were no reads or writes to the database in this particular case. var p1 = new Person { Name = taintSource }; diff --git a/csharp/ql/test/library-tests/ir/ir/raw_ir.expected b/csharp/ql/test/library-tests/ir/ir/raw_ir.expected index 5e3701a4c5a..1a588756ecc 100644 --- a/csharp/ql/test/library-tests/ir/ir/raw_ir.expected +++ b/csharp/ql/test/library-tests/ir/ir/raw_ir.expected @@ -1,1737 +1,1737 @@ array.cs: # 2| System.Void ArrayTest.one_dim_init_acc() # 2| Block 0 -# 2| v0_0(Void) = EnterFunction : -# 2| mu0_1() = AliasedDefinition : -# 2| mu0_2() = UnmodeledDefinition : -# 2| r0_3(glval) = InitializeThis : -# 4| r0_4(glval) = VariableAddress[one_dim] : -# 4| mu0_5(Int32[]) = Uninitialized[one_dim] : &:r0_4 -# 4| r0_6(Int32) = Constant[0] : -# 4| r0_7(glval) = PointerAdd[4] : r0_4, r0_6 -# 4| r0_8(Int32) = Constant[100] : -# 4| mu0_9(Int32) = Store : &:r0_7, r0_8 -# 4| r0_10(Int32) = Constant[1] : -# 4| r0_11(glval) = PointerAdd[4] : r0_4, r0_10 -# 4| r0_12(Int32) = Constant[101] : -# 4| mu0_13(Int32) = Store : &:r0_11, r0_12 -# 4| r0_14(Int32) = Constant[2] : -# 4| r0_15(glval) = PointerAdd[4] : r0_4, r0_14 -# 4| r0_16(Int32) = Constant[102] : -# 4| mu0_17(Int32) = Store : &:r0_15, r0_16 -# 5| r0_18(Int32) = Constant[1000] : -# 5| r0_19(glval) = VariableAddress[one_dim] : -# 5| r0_20(Int32[]) = ElementsAddress : r0_19 -# 5| r0_21(Int32) = Constant[0] : -# 5| r0_22(Int32[]) = PointerAdd[4] : r0_20, r0_21 -# 5| mu0_23(Int32) = Store : &:r0_22, r0_18 -# 6| r0_24(glval) = VariableAddress[one_dim] : -# 6| r0_25(Int32[]) = ElementsAddress : r0_24 -# 6| r0_26(Int32) = Constant[0] : -# 6| r0_27(Int32[]) = PointerAdd[4] : r0_25, r0_26 -# 6| r0_28(Int32) = Load : &:r0_27, ~mu0_2 -# 6| r0_29(glval) = VariableAddress[one_dim] : -# 6| r0_30(Int32[]) = ElementsAddress : r0_29 -# 6| r0_31(Int32) = Constant[1] : -# 6| r0_32(Int32[]) = PointerAdd[4] : r0_30, r0_31 -# 6| mu0_33(Int32) = Store : &:r0_32, r0_28 -# 7| r0_34(Int32) = Constant[1003] : -# 7| r0_35(glval) = VariableAddress[one_dim] : -# 7| r0_36(Int32[]) = ElementsAddress : r0_35 -# 7| r0_37(Int32) = Constant[1] : -# 7| r0_38(Int32[]) = PointerAdd[4] : r0_36, r0_37 -# 7| mu0_39(Int32) = Store : &:r0_38, r0_34 -# 9| r0_40(glval) = VariableAddress[i] : -# 9| r0_41(Int32) = Constant[0] : -# 9| mu0_42(Int32) = Store : &:r0_40, r0_41 -# 10| r0_43(Int32) = Constant[0] : -# 10| r0_44(glval) = VariableAddress[one_dim] : -# 10| r0_45(Int32[]) = ElementsAddress : r0_44 -# 10| r0_46(glval) = VariableAddress[i] : -# 10| r0_47(Int32) = Load : &:r0_46, ~mu0_2 -# 10| r0_48(Int32[]) = PointerAdd[4] : r0_45, r0_47 -# 10| mu0_49(Int32) = Store : &:r0_48, r0_43 -# 2| v0_50(Void) = ReturnVoid : -# 2| v0_51(Void) = UnmodeledUse : mu* -# 2| v0_52(Void) = AliasedUse : ~mu0_2 -# 2| v0_53(Void) = ExitFunction : +# 2| v2_1(Void) = EnterFunction : +# 2| mu2_2() = AliasedDefinition : +# 2| mu2_3() = UnmodeledDefinition : +# 2| r2_4(glval) = InitializeThis : +# 4| r4_1(glval) = VariableAddress[one_dim] : +# 4| mu4_2(Int32[]) = Uninitialized[one_dim] : &:r4_1 +# 4| r4_3(Int32) = Constant[0] : +# 4| r4_4(glval) = PointerAdd[4] : r4_1, r4_3 +# 4| r4_5(Int32) = Constant[100] : +# 4| mu4_6(Int32) = Store : &:r4_4, r4_5 +# 4| r4_7(Int32) = Constant[1] : +# 4| r4_8(glval) = PointerAdd[4] : r4_1, r4_7 +# 4| r4_9(Int32) = Constant[101] : +# 4| mu4_10(Int32) = Store : &:r4_8, r4_9 +# 4| r4_11(Int32) = Constant[2] : +# 4| r4_12(glval) = PointerAdd[4] : r4_1, r4_11 +# 4| r4_13(Int32) = Constant[102] : +# 4| mu4_14(Int32) = Store : &:r4_12, r4_13 +# 5| r5_1(Int32) = Constant[1000] : +# 5| r5_2(glval) = VariableAddress[one_dim] : +# 5| r5_3(Int32[]) = ElementsAddress : r5_2 +# 5| r5_4(Int32) = Constant[0] : +# 5| r5_5(Int32[]) = PointerAdd[4] : r5_3, r5_4 +# 5| mu5_6(Int32) = Store : &:r5_5, r5_1 +# 6| r6_1(glval) = VariableAddress[one_dim] : +# 6| r6_2(Int32[]) = ElementsAddress : r6_1 +# 6| r6_3(Int32) = Constant[0] : +# 6| r6_4(Int32[]) = PointerAdd[4] : r6_2, r6_3 +# 6| r6_5(Int32) = Load : &:r6_4, ~mu2_3 +# 6| r6_6(glval) = VariableAddress[one_dim] : +# 6| r6_7(Int32[]) = ElementsAddress : r6_6 +# 6| r6_8(Int32) = Constant[1] : +# 6| r6_9(Int32[]) = PointerAdd[4] : r6_7, r6_8 +# 6| mu6_10(Int32) = Store : &:r6_9, r6_5 +# 7| r7_1(Int32) = Constant[1003] : +# 7| r7_2(glval) = VariableAddress[one_dim] : +# 7| r7_3(Int32[]) = ElementsAddress : r7_2 +# 7| r7_4(Int32) = Constant[1] : +# 7| r7_5(Int32[]) = PointerAdd[4] : r7_3, r7_4 +# 7| mu7_6(Int32) = Store : &:r7_5, r7_1 +# 9| r9_1(glval) = VariableAddress[i] : +# 9| r9_2(Int32) = Constant[0] : +# 9| mu9_3(Int32) = Store : &:r9_1, r9_2 +# 10| r10_1(Int32) = Constant[0] : +# 10| r10_2(glval) = VariableAddress[one_dim] : +# 10| r10_3(Int32[]) = ElementsAddress : r10_2 +# 10| r10_4(glval) = VariableAddress[i] : +# 10| r10_5(Int32) = Load : &:r10_4, ~mu2_3 +# 10| r10_6(Int32[]) = PointerAdd[4] : r10_3, r10_5 +# 10| mu10_7(Int32) = Store : &:r10_6, r10_1 +# 2| v2_5(Void) = ReturnVoid : +# 2| v2_6(Void) = UnmodeledUse : mu* +# 2| v2_7(Void) = AliasedUse : ~mu2_3 +# 2| v2_8(Void) = ExitFunction : # 13| System.Void ArrayTest.twod_and_init_acc() # 13| Block 0 -# 13| v0_0(Void) = EnterFunction : -# 13| mu0_1() = AliasedDefinition : -# 13| mu0_2() = UnmodeledDefinition : -# 13| r0_3(glval) = InitializeThis : -# 15| r0_4(glval) = VariableAddress[a] : -# 15| mu0_5(Int32[,]) = Uninitialized[a] : &:r0_4 -# 15| r0_6(Int32) = Constant[0] : -# 15| r0_7(glval) = PointerAdd[8] : r0_4, r0_6 -# 15| r0_8(Int32) = Constant[0] : -# 15| r0_9(glval) = PointerAdd[4] : r0_7, r0_8 -# 15| r0_10(Int32) = Constant[100] : -# 15| mu0_11(Int32) = Store : &:r0_9, r0_10 -# 15| r0_12(Int32) = Constant[1] : -# 15| r0_13(glval) = PointerAdd[4] : r0_7, r0_12 -# 15| r0_14(Int32) = Constant[101] : -# 15| mu0_15(Int32) = Store : &:r0_13, r0_14 -# 15| r0_16(Int32) = Constant[1] : -# 15| r0_17(glval) = PointerAdd[8] : r0_4, r0_16 -# 15| r0_18(Int32) = Constant[0] : -# 15| r0_19(glval) = PointerAdd[4] : r0_17, r0_18 -# 15| r0_20(Int32) = Constant[102] : -# 15| mu0_21(Int32) = Store : &:r0_19, r0_20 -# 15| r0_22(Int32) = Constant[1] : -# 15| r0_23(glval) = PointerAdd[4] : r0_17, r0_22 -# 15| r0_24(Int32) = Constant[103] : -# 15| mu0_25(Int32) = Store : &:r0_23, r0_24 -# 16| r0_26(glval) = VariableAddress[b] : -# 16| mu0_27(Int32[,]) = Uninitialized[b] : &:r0_26 -# 17| r0_28(glval) = VariableAddress[c] : -# 17| mu0_29(Int32[,]) = Uninitialized[c] : &:r0_28 -# 17| r0_30(Int32) = Constant[0] : -# 17| r0_31(glval) = PointerAdd[8] : r0_28, r0_30 -# 17| r0_32(Int32) = Constant[0] : -# 17| r0_33(glval) = PointerAdd[4] : r0_31, r0_32 -# 17| r0_34(Int32) = Constant[100] : -# 17| mu0_35(Int32) = Store : &:r0_33, r0_34 -# 17| r0_36(Int32) = Constant[1] : -# 17| r0_37(glval) = PointerAdd[4] : r0_31, r0_36 -# 17| r0_38(Int32) = Constant[101] : -# 17| mu0_39(Int32) = Store : &:r0_37, r0_38 -# 17| r0_40(Int32) = Constant[1] : -# 17| r0_41(glval) = PointerAdd[8] : r0_28, r0_40 -# 17| r0_42(Int32) = Constant[0] : -# 17| r0_43(glval) = PointerAdd[4] : r0_41, r0_42 -# 17| r0_44(Int32) = Constant[102] : -# 17| mu0_45(Int32) = Store : &:r0_43, r0_44 -# 17| r0_46(Int32) = Constant[1] : -# 17| r0_47(glval) = PointerAdd[4] : r0_41, r0_46 -# 17| r0_48(Int32) = Constant[103] : -# 17| mu0_49(Int32) = Store : &:r0_47, r0_48 -# 18| r0_50(glval) = VariableAddress[d] : -# 18| mu0_51(Int32[,]) = Uninitialized[d] : &:r0_50 -# 18| r0_52(Int32) = Constant[0] : -# 18| r0_53(glval) = PointerAdd[8] : r0_50, r0_52 -# 18| r0_54(Int32) = Constant[0] : -# 18| r0_55(glval) = PointerAdd[4] : r0_53, r0_54 -# 18| r0_56(Int32) = Constant[100] : -# 18| mu0_57(Int32) = Store : &:r0_55, r0_56 -# 18| r0_58(Int32) = Constant[1] : -# 18| r0_59(glval) = PointerAdd[4] : r0_53, r0_58 -# 18| r0_60(Int32) = Constant[101] : -# 18| mu0_61(Int32) = Store : &:r0_59, r0_60 -# 18| r0_62(Int32) = Constant[1] : -# 18| r0_63(glval) = PointerAdd[8] : r0_50, r0_62 -# 18| r0_64(Int32) = Constant[0] : -# 18| r0_65(glval) = PointerAdd[4] : r0_63, r0_64 -# 18| r0_66(Int32) = Constant[102] : -# 18| mu0_67(Int32) = Store : &:r0_65, r0_66 -# 18| r0_68(Int32) = Constant[1] : -# 18| r0_69(glval) = PointerAdd[4] : r0_63, r0_68 -# 18| r0_70(Int32) = Constant[103] : -# 18| mu0_71(Int32) = Store : &:r0_69, r0_70 -# 19| r0_72(glval) = VariableAddress[e] : -# 19| r0_73(glval) = VariableAddress[a] : -# 19| r0_74(Int32[,]) = Load : &:r0_73, ~mu0_2 -# 19| mu0_75(Int32[,]) = Store : &:r0_72, r0_74 -# 20| r0_76(Int32) = Constant[-1] : -# 20| r0_77(glval) = VariableAddress[e] : -# 20| r0_78(Int32[,]) = ElementsAddress : r0_77 -# 20| r0_79(Int32) = Constant[1] : -# 20| r0_80(Int32[,]) = PointerAdd[4] : r0_78, r0_79 -# 20| r0_81(Int32[]) = ElementsAddress : r0_80 -# 20| r0_82(Int32) = Constant[1] : -# 20| r0_83(Int32[]) = PointerAdd[4] : r0_81, r0_82 -# 20| mu0_84(Int32) = Store : &:r0_83, r0_76 -# 13| v0_85(Void) = ReturnVoid : -# 13| v0_86(Void) = UnmodeledUse : mu* -# 13| v0_87(Void) = AliasedUse : ~mu0_2 -# 13| v0_88(Void) = ExitFunction : +# 13| v13_1(Void) = EnterFunction : +# 13| mu13_2() = AliasedDefinition : +# 13| mu13_3() = UnmodeledDefinition : +# 13| r13_4(glval) = InitializeThis : +# 15| r15_1(glval) = VariableAddress[a] : +# 15| mu15_2(Int32[,]) = Uninitialized[a] : &:r15_1 +# 15| r15_3(Int32) = Constant[0] : +# 15| r15_4(glval) = PointerAdd[8] : r15_1, r15_3 +# 15| r15_5(Int32) = Constant[0] : +# 15| r15_6(glval) = PointerAdd[4] : r15_4, r15_5 +# 15| r15_7(Int32) = Constant[100] : +# 15| mu15_8(Int32) = Store : &:r15_6, r15_7 +# 15| r15_9(Int32) = Constant[1] : +# 15| r15_10(glval) = PointerAdd[4] : r15_4, r15_9 +# 15| r15_11(Int32) = Constant[101] : +# 15| mu15_12(Int32) = Store : &:r15_10, r15_11 +# 15| r15_13(Int32) = Constant[1] : +# 15| r15_14(glval) = PointerAdd[8] : r15_1, r15_13 +# 15| r15_15(Int32) = Constant[0] : +# 15| r15_16(glval) = PointerAdd[4] : r15_14, r15_15 +# 15| r15_17(Int32) = Constant[102] : +# 15| mu15_18(Int32) = Store : &:r15_16, r15_17 +# 15| r15_19(Int32) = Constant[1] : +# 15| r15_20(glval) = PointerAdd[4] : r15_14, r15_19 +# 15| r15_21(Int32) = Constant[103] : +# 15| mu15_22(Int32) = Store : &:r15_20, r15_21 +# 16| r16_1(glval) = VariableAddress[b] : +# 16| mu16_2(Int32[,]) = Uninitialized[b] : &:r16_1 +# 17| r17_1(glval) = VariableAddress[c] : +# 17| mu17_2(Int32[,]) = Uninitialized[c] : &:r17_1 +# 17| r17_3(Int32) = Constant[0] : +# 17| r17_4(glval) = PointerAdd[8] : r17_1, r17_3 +# 17| r17_5(Int32) = Constant[0] : +# 17| r17_6(glval) = PointerAdd[4] : r17_4, r17_5 +# 17| r17_7(Int32) = Constant[100] : +# 17| mu17_8(Int32) = Store : &:r17_6, r17_7 +# 17| r17_9(Int32) = Constant[1] : +# 17| r17_10(glval) = PointerAdd[4] : r17_4, r17_9 +# 17| r17_11(Int32) = Constant[101] : +# 17| mu17_12(Int32) = Store : &:r17_10, r17_11 +# 17| r17_13(Int32) = Constant[1] : +# 17| r17_14(glval) = PointerAdd[8] : r17_1, r17_13 +# 17| r17_15(Int32) = Constant[0] : +# 17| r17_16(glval) = PointerAdd[4] : r17_14, r17_15 +# 17| r17_17(Int32) = Constant[102] : +# 17| mu17_18(Int32) = Store : &:r17_16, r17_17 +# 17| r17_19(Int32) = Constant[1] : +# 17| r17_20(glval) = PointerAdd[4] : r17_14, r17_19 +# 17| r17_21(Int32) = Constant[103] : +# 17| mu17_22(Int32) = Store : &:r17_20, r17_21 +# 18| r18_1(glval) = VariableAddress[d] : +# 18| mu18_2(Int32[,]) = Uninitialized[d] : &:r18_1 +# 18| r18_3(Int32) = Constant[0] : +# 18| r18_4(glval) = PointerAdd[8] : r18_1, r18_3 +# 18| r18_5(Int32) = Constant[0] : +# 18| r18_6(glval) = PointerAdd[4] : r18_4, r18_5 +# 18| r18_7(Int32) = Constant[100] : +# 18| mu18_8(Int32) = Store : &:r18_6, r18_7 +# 18| r18_9(Int32) = Constant[1] : +# 18| r18_10(glval) = PointerAdd[4] : r18_4, r18_9 +# 18| r18_11(Int32) = Constant[101] : +# 18| mu18_12(Int32) = Store : &:r18_10, r18_11 +# 18| r18_13(Int32) = Constant[1] : +# 18| r18_14(glval) = PointerAdd[8] : r18_1, r18_13 +# 18| r18_15(Int32) = Constant[0] : +# 18| r18_16(glval) = PointerAdd[4] : r18_14, r18_15 +# 18| r18_17(Int32) = Constant[102] : +# 18| mu18_18(Int32) = Store : &:r18_16, r18_17 +# 18| r18_19(Int32) = Constant[1] : +# 18| r18_20(glval) = PointerAdd[4] : r18_14, r18_19 +# 18| r18_21(Int32) = Constant[103] : +# 18| mu18_22(Int32) = Store : &:r18_20, r18_21 +# 19| r19_1(glval) = VariableAddress[e] : +# 19| r19_2(glval) = VariableAddress[a] : +# 19| r19_3(Int32[,]) = Load : &:r19_2, ~mu13_3 +# 19| mu19_4(Int32[,]) = Store : &:r19_1, r19_3 +# 20| r20_1(Int32) = Constant[-1] : +# 20| r20_2(glval) = VariableAddress[e] : +# 20| r20_3(Int32[,]) = ElementsAddress : r20_2 +# 20| r20_4(Int32) = Constant[1] : +# 20| r20_5(Int32[,]) = PointerAdd[4] : r20_3, r20_4 +# 20| r20_6(Int32[]) = ElementsAddress : r20_5 +# 20| r20_7(Int32) = Constant[1] : +# 20| r20_8(Int32[]) = PointerAdd[4] : r20_6, r20_7 +# 20| mu20_9(Int32) = Store : &:r20_8, r20_1 +# 13| v13_5(Void) = ReturnVoid : +# 13| v13_6(Void) = UnmodeledUse : mu* +# 13| v13_7(Void) = AliasedUse : ~mu13_3 +# 13| v13_8(Void) = ExitFunction : assignop.cs: # 4| System.Void AssignOp.Main() # 4| Block 0 -# 4| v0_0(Void) = EnterFunction : -# 4| mu0_1() = AliasedDefinition : -# 4| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = VariableAddress[a] : -# 5| r0_4(Int32) = Constant[1] : -# 5| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 6| r0_6(glval) = VariableAddress[c] : -# 6| r0_7(Int32) = Constant[1] : -# 6| mu0_8(Int32) = Store : &:r0_6, r0_7 -# 8| r0_9(glval) = VariableAddress[a] : -# 8| r0_10(Int32) = Load : &:r0_9, ~mu0_2 -# 8| r0_11(glval) = VariableAddress[c] : -# 8| r0_12(Int32) = Load : &:r0_11, ~mu0_2 -# 8| r0_13(Int32) = Add : r0_12, r0_10 -# 8| mu0_14(Int32) = Store : &:r0_11, r0_13 -# 9| r0_15(glval) = VariableAddress[a] : -# 9| r0_16(Int32) = Load : &:r0_15, ~mu0_2 -# 9| r0_17(glval) = VariableAddress[c] : -# 9| r0_18(Int32) = Load : &:r0_17, ~mu0_2 -# 9| r0_19(Int32) = Sub : r0_18, r0_16 -# 9| mu0_20(Int32) = Store : &:r0_17, r0_19 -# 10| r0_21(glval) = VariableAddress[a] : -# 10| r0_22(Int32) = Load : &:r0_21, ~mu0_2 -# 10| r0_23(glval) = VariableAddress[c] : -# 10| r0_24(Int32) = Load : &:r0_23, ~mu0_2 -# 10| r0_25(Int32) = Mul : r0_24, r0_22 -# 10| mu0_26(Int32) = Store : &:r0_23, r0_25 -# 11| r0_27(glval) = VariableAddress[a] : -# 11| r0_28(Int32) = Load : &:r0_27, ~mu0_2 -# 11| r0_29(glval) = VariableAddress[c] : -# 11| r0_30(Int32) = Load : &:r0_29, ~mu0_2 -# 11| r0_31(Int32) = Div : r0_30, r0_28 -# 11| mu0_32(Int32) = Store : &:r0_29, r0_31 -# 12| r0_33(glval) = VariableAddress[a] : -# 12| r0_34(Int32) = Load : &:r0_33, ~mu0_2 -# 12| r0_35(glval) = VariableAddress[c] : -# 12| r0_36(Int32) = Load : &:r0_35, ~mu0_2 -# 12| r0_37(Int32) = Rem : r0_36, r0_34 -# 12| mu0_38(Int32) = Store : &:r0_35, r0_37 -# 13| r0_39(Int32) = Constant[2] : -# 13| r0_40(glval) = VariableAddress[c] : -# 13| r0_41(Int32) = Load : &:r0_40, ~mu0_2 -# 13| r0_42(Int32) = ShiftLeft : r0_41, r0_39 -# 13| mu0_43(Int32) = Store : &:r0_40, r0_42 -# 14| r0_44(Int32) = Constant[2] : -# 14| r0_45(glval) = VariableAddress[c] : -# 14| r0_46(Int32) = Load : &:r0_45, ~mu0_2 -# 14| r0_47(Int32) = ShiftRight : r0_46, r0_44 -# 14| mu0_48(Int32) = Store : &:r0_45, r0_47 -# 15| r0_49(Int32) = Constant[2] : -# 15| r0_50(glval) = VariableAddress[c] : -# 15| r0_51(Int32) = Load : &:r0_50, ~mu0_2 -# 15| r0_52(Int32) = BitAnd : r0_51, r0_49 -# 15| mu0_53(Int32) = Store : &:r0_50, r0_52 -# 16| r0_54(Int32) = Constant[2] : -# 16| r0_55(glval) = VariableAddress[c] : -# 16| r0_56(Int32) = Load : &:r0_55, ~mu0_2 -# 16| r0_57(Int32) = BitXor : r0_56, r0_54 -# 16| mu0_58(Int32) = Store : &:r0_55, r0_57 -# 17| r0_59(Int32) = Constant[2] : -# 17| r0_60(glval) = VariableAddress[c] : -# 17| r0_61(Int32) = Load : &:r0_60, ~mu0_2 -# 17| r0_62(Int32) = BitOr : r0_61, r0_59 -# 17| mu0_63(Int32) = Store : &:r0_60, r0_62 -# 4| v0_64(Void) = ReturnVoid : -# 4| v0_65(Void) = UnmodeledUse : mu* -# 4| v0_66(Void) = AliasedUse : ~mu0_2 -# 4| v0_67(Void) = ExitFunction : +# 4| v4_1(Void) = EnterFunction : +# 4| mu4_2() = AliasedDefinition : +# 4| mu4_3() = UnmodeledDefinition : +# 5| r5_1(glval) = VariableAddress[a] : +# 5| r5_2(Int32) = Constant[1] : +# 5| mu5_3(Int32) = Store : &:r5_1, r5_2 +# 6| r6_1(glval) = VariableAddress[c] : +# 6| r6_2(Int32) = Constant[1] : +# 6| mu6_3(Int32) = Store : &:r6_1, r6_2 +# 8| r8_1(glval) = VariableAddress[a] : +# 8| r8_2(Int32) = Load : &:r8_1, ~mu4_3 +# 8| r8_3(glval) = VariableAddress[c] : +# 8| r8_4(Int32) = Load : &:r8_3, ~mu4_3 +# 8| r8_5(Int32) = Add : r8_4, r8_2 +# 8| mu8_6(Int32) = Store : &:r8_3, r8_5 +# 9| r9_1(glval) = VariableAddress[a] : +# 9| r9_2(Int32) = Load : &:r9_1, ~mu4_3 +# 9| r9_3(glval) = VariableAddress[c] : +# 9| r9_4(Int32) = Load : &:r9_3, ~mu4_3 +# 9| r9_5(Int32) = Sub : r9_4, r9_2 +# 9| mu9_6(Int32) = Store : &:r9_3, r9_5 +# 10| r10_1(glval) = VariableAddress[a] : +# 10| r10_2(Int32) = Load : &:r10_1, ~mu4_3 +# 10| r10_3(glval) = VariableAddress[c] : +# 10| r10_4(Int32) = Load : &:r10_3, ~mu4_3 +# 10| r10_5(Int32) = Mul : r10_4, r10_2 +# 10| mu10_6(Int32) = Store : &:r10_3, r10_5 +# 11| r11_1(glval) = VariableAddress[a] : +# 11| r11_2(Int32) = Load : &:r11_1, ~mu4_3 +# 11| r11_3(glval) = VariableAddress[c] : +# 11| r11_4(Int32) = Load : &:r11_3, ~mu4_3 +# 11| r11_5(Int32) = Div : r11_4, r11_2 +# 11| mu11_6(Int32) = Store : &:r11_3, r11_5 +# 12| r12_1(glval) = VariableAddress[a] : +# 12| r12_2(Int32) = Load : &:r12_1, ~mu4_3 +# 12| r12_3(glval) = VariableAddress[c] : +# 12| r12_4(Int32) = Load : &:r12_3, ~mu4_3 +# 12| r12_5(Int32) = Rem : r12_4, r12_2 +# 12| mu12_6(Int32) = Store : &:r12_3, r12_5 +# 13| r13_1(Int32) = Constant[2] : +# 13| r13_2(glval) = VariableAddress[c] : +# 13| r13_3(Int32) = Load : &:r13_2, ~mu4_3 +# 13| r13_4(Int32) = ShiftLeft : r13_3, r13_1 +# 13| mu13_5(Int32) = Store : &:r13_2, r13_4 +# 14| r14_1(Int32) = Constant[2] : +# 14| r14_2(glval) = VariableAddress[c] : +# 14| r14_3(Int32) = Load : &:r14_2, ~mu4_3 +# 14| r14_4(Int32) = ShiftRight : r14_3, r14_1 +# 14| mu14_5(Int32) = Store : &:r14_2, r14_4 +# 15| r15_1(Int32) = Constant[2] : +# 15| r15_2(glval) = VariableAddress[c] : +# 15| r15_3(Int32) = Load : &:r15_2, ~mu4_3 +# 15| r15_4(Int32) = BitAnd : r15_3, r15_1 +# 15| mu15_5(Int32) = Store : &:r15_2, r15_4 +# 16| r16_1(Int32) = Constant[2] : +# 16| r16_2(glval) = VariableAddress[c] : +# 16| r16_3(Int32) = Load : &:r16_2, ~mu4_3 +# 16| r16_4(Int32) = BitXor : r16_3, r16_1 +# 16| mu16_5(Int32) = Store : &:r16_2, r16_4 +# 17| r17_1(Int32) = Constant[2] : +# 17| r17_2(glval) = VariableAddress[c] : +# 17| r17_3(Int32) = Load : &:r17_2, ~mu4_3 +# 17| r17_4(Int32) = BitOr : r17_3, r17_1 +# 17| mu17_5(Int32) = Store : &:r17_2, r17_4 +# 4| v4_4(Void) = ReturnVoid : +# 4| v4_5(Void) = UnmodeledUse : mu* +# 4| v4_6(Void) = AliasedUse : ~mu4_3 +# 4| v4_7(Void) = ExitFunction : casts.cs: # 11| System.Void Casts.Main() # 11| Block 0 -# 11| v0_0(Void) = EnterFunction : -# 11| mu0_1() = AliasedDefinition : -# 11| mu0_2() = UnmodeledDefinition : -# 13| r0_3(glval) = VariableAddress[Aobj] : -# 13| r0_4(Casts_A) = NewObj : -# 13| r0_5() = FunctionAddress[Casts_A] : -# 13| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 13| mu0_7() = ^CallSideEffect : ~mu0_2 -# 13| mu0_8(Casts_A) = Store : &:r0_3, r0_4 -# 14| r0_9(glval) = VariableAddress[bobjCE] : -# 14| r0_10(glval) = VariableAddress[Aobj] : -# 14| r0_11(Casts_A) = Load : &:r0_10, ~mu0_2 -# 14| r0_12(Casts_B) = CheckedConvertOrThrow : r0_11 -# 14| mu0_13(Casts_B) = Store : &:r0_9, r0_12 -# 15| r0_14(glval) = VariableAddress[bobjAS] : -# 15| r0_15(glval) = VariableAddress[Aobj] : -# 15| r0_16(Casts_A) = Load : &:r0_15, ~mu0_2 -# 15| r0_17(Casts_B) = CheckedConvertOrNull : r0_16 -# 15| mu0_18(Casts_B) = Store : &:r0_14, r0_17 -# 11| v0_19(Void) = ReturnVoid : -# 11| v0_20(Void) = UnmodeledUse : mu* -# 11| v0_21(Void) = AliasedUse : ~mu0_2 -# 11| v0_22(Void) = ExitFunction : +# 11| v11_1(Void) = EnterFunction : +# 11| mu11_2() = AliasedDefinition : +# 11| mu11_3() = UnmodeledDefinition : +# 13| r13_1(glval) = VariableAddress[Aobj] : +# 13| r13_2(Casts_A) = NewObj : +# 13| r13_3() = FunctionAddress[Casts_A] : +# 13| v13_4(Void) = Call : func:r13_3, this:r13_2 +# 13| mu13_5() = ^CallSideEffect : ~mu11_3 +# 13| mu13_6(Casts_A) = Store : &:r13_1, r13_2 +# 14| r14_1(glval) = VariableAddress[bobjCE] : +# 14| r14_2(glval) = VariableAddress[Aobj] : +# 14| r14_3(Casts_A) = Load : &:r14_2, ~mu11_3 +# 14| r14_4(Casts_B) = CheckedConvertOrThrow : r14_3 +# 14| mu14_5(Casts_B) = Store : &:r14_1, r14_4 +# 15| r15_1(glval) = VariableAddress[bobjAS] : +# 15| r15_2(glval) = VariableAddress[Aobj] : +# 15| r15_3(Casts_A) = Load : &:r15_2, ~mu11_3 +# 15| r15_4(Casts_B) = CheckedConvertOrNull : r15_3 +# 15| mu15_5(Casts_B) = Store : &:r15_1, r15_4 +# 11| v11_4(Void) = ReturnVoid : +# 11| v11_5(Void) = UnmodeledUse : mu* +# 11| v11_6(Void) = AliasedUse : ~mu11_3 +# 11| v11_7(Void) = ExitFunction : collections.cs: # 11| System.Void Collections.Main() # 11| Block 0 -# 11| v0_0(Void) = EnterFunction : -# 11| mu0_1() = AliasedDefinition : -# 11| mu0_2() = UnmodeledDefinition : -# 13| r0_3(glval>) = VariableAddress[dict] : -# 13| r0_4(Dictionary) = NewObj : -# 13| r0_5() = FunctionAddress[Dictionary] : -# 13| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 13| mu0_7() = ^CallSideEffect : ~mu0_2 -# 15| r0_8() = FunctionAddress[Add] : -# 15| r0_9(Int32) = Constant[0] : -# 15| r0_10(MyClass) = NewObj : -# 15| r0_11() = FunctionAddress[MyClass] : -# 15| v0_12(Void) = Call : func:r0_11, this:r0_10 -# 15| mu0_13() = ^CallSideEffect : ~mu0_2 -# 15| r0_14(String) = StringConstant["Hello"] : -# 15| r0_15(glval) = FieldAddress[a] : r0_10 -# 15| mu0_16(String) = Store : &:r0_15, r0_14 -# 15| r0_17(String) = StringConstant["World"] : -# 15| r0_18(glval) = FieldAddress[b] : r0_10 -# 15| mu0_19(String) = Store : &:r0_18, r0_17 -# 15| v0_20(Void) = Call : func:r0_8, this:r0_4, 0:r0_9, 1:r0_10 -# 15| mu0_21() = ^CallSideEffect : ~mu0_2 -# 16| r0_22() = FunctionAddress[Add] : -# 16| r0_23(Int32) = Constant[1] : -# 16| r0_24(MyClass) = NewObj : -# 16| r0_25() = FunctionAddress[MyClass] : -# 16| v0_26(Void) = Call : func:r0_25, this:r0_24 -# 16| mu0_27() = ^CallSideEffect : ~mu0_2 -# 16| r0_28(String) = StringConstant["Foo"] : -# 16| r0_29(glval) = FieldAddress[a] : r0_24 -# 16| mu0_30(String) = Store : &:r0_29, r0_28 -# 16| r0_31(String) = StringConstant["Bar"] : -# 16| r0_32(glval) = FieldAddress[b] : r0_24 -# 16| mu0_33(String) = Store : &:r0_32, r0_31 -# 16| v0_34(Void) = Call : func:r0_22, this:r0_4, 0:r0_23, 1:r0_24 -# 16| mu0_35() = ^CallSideEffect : ~mu0_2 -# 13| mu0_36(Dictionary) = Store : &:r0_3, r0_4 -# 11| v0_37(Void) = ReturnVoid : -# 11| v0_38(Void) = UnmodeledUse : mu* -# 11| v0_39(Void) = AliasedUse : ~mu0_2 -# 11| v0_40(Void) = ExitFunction : +# 11| v11_1(Void) = EnterFunction : +# 11| mu11_2() = AliasedDefinition : +# 11| mu11_3() = UnmodeledDefinition : +# 13| r13_1(glval>) = VariableAddress[dict] : +# 13| r13_2(Dictionary) = NewObj : +# 13| r13_3() = FunctionAddress[Dictionary] : +# 13| v13_4(Void) = Call : func:r13_3, this:r13_2 +# 13| mu13_5() = ^CallSideEffect : ~mu11_3 +# 15| r15_1() = FunctionAddress[Add] : +# 15| r15_2(Int32) = Constant[0] : +# 15| r15_3(MyClass) = NewObj : +# 15| r15_4() = FunctionAddress[MyClass] : +# 15| v15_5(Void) = Call : func:r15_4, this:r15_3 +# 15| mu15_6() = ^CallSideEffect : ~mu11_3 +# 15| r15_7(String) = StringConstant["Hello"] : +# 15| r15_8(glval) = FieldAddress[a] : r15_3 +# 15| mu15_9(String) = Store : &:r15_8, r15_7 +# 15| r15_10(String) = StringConstant["World"] : +# 15| r15_11(glval) = FieldAddress[b] : r15_3 +# 15| mu15_12(String) = Store : &:r15_11, r15_10 +# 15| v15_13(Void) = Call : func:r15_1, this:r13_2, 0:r15_2, 1:r15_3 +# 15| mu15_14() = ^CallSideEffect : ~mu11_3 +# 16| r16_1() = FunctionAddress[Add] : +# 16| r16_2(Int32) = Constant[1] : +# 16| r16_3(MyClass) = NewObj : +# 16| r16_4() = FunctionAddress[MyClass] : +# 16| v16_5(Void) = Call : func:r16_4, this:r16_3 +# 16| mu16_6() = ^CallSideEffect : ~mu11_3 +# 16| r16_7(String) = StringConstant["Foo"] : +# 16| r16_8(glval) = FieldAddress[a] : r16_3 +# 16| mu16_9(String) = Store : &:r16_8, r16_7 +# 16| r16_10(String) = StringConstant["Bar"] : +# 16| r16_11(glval) = FieldAddress[b] : r16_3 +# 16| mu16_12(String) = Store : &:r16_11, r16_10 +# 16| v16_13(Void) = Call : func:r16_1, this:r13_2, 0:r16_2, 1:r16_3 +# 16| mu16_14() = ^CallSideEffect : ~mu11_3 +# 13| mu13_6(Dictionary) = Store : &:r13_1, r13_2 +# 11| v11_4(Void) = ReturnVoid : +# 11| v11_5(Void) = UnmodeledUse : mu* +# 11| v11_6(Void) = AliasedUse : ~mu11_3 +# 11| v11_7(Void) = ExitFunction : constructor_init.cs: # 5| System.Void BaseClass..ctor() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = InitializeThis : -# 6| v0_4(Void) = NoOp : -# 5| v0_5(Void) = ReturnVoid : -# 5| v0_6(Void) = UnmodeledUse : mu* -# 5| v0_7(Void) = AliasedUse : ~mu0_2 -# 5| v0_8(Void) = ExitFunction : +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 5| r5_4(glval) = InitializeThis : +# 6| v6_1(Void) = NoOp : +# 5| v5_5(Void) = ReturnVoid : +# 5| v5_6(Void) = UnmodeledUse : mu* +# 5| v5_7(Void) = AliasedUse : ~mu5_3 +# 5| v5_8(Void) = ExitFunction : # 9| System.Void BaseClass..ctor(System.Int32) # 9| Block 0 -# 9| v0_0(Void) = EnterFunction : -# 9| mu0_1() = AliasedDefinition : -# 9| mu0_2() = UnmodeledDefinition : -# 9| r0_3(glval) = InitializeThis : -# 9| r0_4(glval) = VariableAddress[i] : -# 9| mu0_5(Int32) = InitializeParameter[i] : &:r0_4 -# 11| r0_6(glval) = VariableAddress[i] : -# 11| r0_7(Int32) = Load : &:r0_6, ~mu0_2 -# 11| r0_8(BaseClass) = CopyValue : r0_3 -# 11| r0_9(glval) = FieldAddress[num] : r0_8 -# 11| mu0_10(Int32) = Store : &:r0_9, r0_7 -# 9| v0_11(Void) = ReturnVoid : -# 9| v0_12(Void) = UnmodeledUse : mu* -# 9| v0_13(Void) = AliasedUse : ~mu0_2 -# 9| v0_14(Void) = ExitFunction : +# 9| v9_1(Void) = EnterFunction : +# 9| mu9_2() = AliasedDefinition : +# 9| mu9_3() = UnmodeledDefinition : +# 9| r9_4(glval) = InitializeThis : +# 9| r9_5(glval) = VariableAddress[i] : +# 9| mu9_6(Int32) = InitializeParameter[i] : &:r9_5 +# 11| r11_1(glval) = VariableAddress[i] : +# 11| r11_2(Int32) = Load : &:r11_1, ~mu9_3 +# 11| r11_3(BaseClass) = CopyValue : r9_4 +# 11| r11_4(glval) = FieldAddress[num] : r11_3 +# 11| mu11_5(Int32) = Store : &:r11_4, r11_2 +# 9| v9_7(Void) = ReturnVoid : +# 9| v9_8(Void) = UnmodeledUse : mu* +# 9| v9_9(Void) = AliasedUse : ~mu9_3 +# 9| v9_10(Void) = ExitFunction : # 17| System.Void DerivedClass..ctor() # 17| Block 0 -# 17| v0_0(Void) = EnterFunction : -# 17| mu0_1() = AliasedDefinition : -# 17| mu0_2() = UnmodeledDefinition : -# 17| r0_3(glval) = InitializeThis : -# 17| r0_4(glval) = Convert[DerivedClass : BaseClass] : r0_3 -# 17| r0_5() = FunctionAddress[BaseClass] : -# 17| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 17| mu0_7() = ^CallSideEffect : ~mu0_2 -# 18| v0_8(Void) = NoOp : -# 17| v0_9(Void) = ReturnVoid : -# 17| v0_10(Void) = UnmodeledUse : mu* -# 17| v0_11(Void) = AliasedUse : ~mu0_2 -# 17| v0_12(Void) = ExitFunction : +# 17| v17_1(Void) = EnterFunction : +# 17| mu17_2() = AliasedDefinition : +# 17| mu17_3() = UnmodeledDefinition : +# 17| r17_4(glval) = InitializeThis : +# 17| r17_5(glval) = Convert[DerivedClass : BaseClass] : r17_4 +# 17| r17_6() = FunctionAddress[BaseClass] : +# 17| v17_7(Void) = Call : func:r17_6, this:r17_5 +# 17| mu17_8() = ^CallSideEffect : ~mu17_3 +# 18| v18_1(Void) = NoOp : +# 17| v17_9(Void) = ReturnVoid : +# 17| v17_10(Void) = UnmodeledUse : mu* +# 17| v17_11(Void) = AliasedUse : ~mu17_3 +# 17| v17_12(Void) = ExitFunction : # 21| System.Void DerivedClass..ctor(System.Int32) # 21| Block 0 -# 21| v0_0(Void) = EnterFunction : -# 21| mu0_1() = AliasedDefinition : -# 21| mu0_2() = UnmodeledDefinition : -# 21| r0_3(glval) = InitializeThis : -# 21| r0_4(glval) = VariableAddress[i] : -# 21| mu0_5(Int32) = InitializeParameter[i] : &:r0_4 -# 21| r0_6(glval) = Convert[DerivedClass : BaseClass] : r0_3 -# 21| r0_7() = FunctionAddress[BaseClass] : -# 21| r0_8(glval) = VariableAddress[i] : -# 21| r0_9(Int32) = Load : &:r0_8, ~mu0_2 -# 21| v0_10(Void) = Call : func:r0_7, this:r0_6, 0:r0_9 -# 21| mu0_11() = ^CallSideEffect : ~mu0_2 -# 22| v0_12(Void) = NoOp : -# 21| v0_13(Void) = ReturnVoid : -# 21| v0_14(Void) = UnmodeledUse : mu* -# 21| v0_15(Void) = AliasedUse : ~mu0_2 -# 21| v0_16(Void) = ExitFunction : +# 21| v21_1(Void) = EnterFunction : +# 21| mu21_2() = AliasedDefinition : +# 21| mu21_3() = UnmodeledDefinition : +# 21| r21_4(glval) = InitializeThis : +# 21| r21_5(glval) = VariableAddress[i] : +# 21| mu21_6(Int32) = InitializeParameter[i] : &:r21_5 +# 21| r21_7(glval) = Convert[DerivedClass : BaseClass] : r21_4 +# 21| r21_8() = FunctionAddress[BaseClass] : +# 21| r21_9(glval) = VariableAddress[i] : +# 21| r21_10(Int32) = Load : &:r21_9, ~mu21_3 +# 21| v21_11(Void) = Call : func:r21_8, this:r21_7, 0:r21_10 +# 21| mu21_12() = ^CallSideEffect : ~mu21_3 +# 22| v22_1(Void) = NoOp : +# 21| v21_13(Void) = ReturnVoid : +# 21| v21_14(Void) = UnmodeledUse : mu* +# 21| v21_15(Void) = AliasedUse : ~mu21_3 +# 21| v21_16(Void) = ExitFunction : # 25| System.Void DerivedClass..ctor(System.Int32,System.Int32) # 25| Block 0 -# 25| v0_0(Void) = EnterFunction : -# 25| mu0_1() = AliasedDefinition : -# 25| mu0_2() = UnmodeledDefinition : -# 25| r0_3(glval) = InitializeThis : -# 25| r0_4(glval) = VariableAddress[i] : -# 25| mu0_5(Int32) = InitializeParameter[i] : &:r0_4 -# 25| r0_6(glval) = VariableAddress[j] : -# 25| mu0_7(Int32) = InitializeParameter[j] : &:r0_6 -# 25| r0_8() = FunctionAddress[DerivedClass] : -# 25| r0_9(glval) = VariableAddress[i] : -# 25| r0_10(Int32) = Load : &:r0_9, ~mu0_2 -# 25| v0_11(Void) = Call : func:r0_8, this:r0_3, 0:r0_10 -# 25| mu0_12() = ^CallSideEffect : ~mu0_2 -# 26| v0_13(Void) = NoOp : -# 25| v0_14(Void) = ReturnVoid : -# 25| v0_15(Void) = UnmodeledUse : mu* -# 25| v0_16(Void) = AliasedUse : ~mu0_2 -# 25| v0_17(Void) = ExitFunction : +# 25| v25_1(Void) = EnterFunction : +# 25| mu25_2() = AliasedDefinition : +# 25| mu25_3() = UnmodeledDefinition : +# 25| r25_4(glval) = InitializeThis : +# 25| r25_5(glval) = VariableAddress[i] : +# 25| mu25_6(Int32) = InitializeParameter[i] : &:r25_5 +# 25| r25_7(glval) = VariableAddress[j] : +# 25| mu25_8(Int32) = InitializeParameter[j] : &:r25_7 +# 25| r25_9() = FunctionAddress[DerivedClass] : +# 25| r25_10(glval) = VariableAddress[i] : +# 25| r25_11(Int32) = Load : &:r25_10, ~mu25_3 +# 25| v25_12(Void) = Call : func:r25_9, this:r25_4, 0:r25_11 +# 25| mu25_13() = ^CallSideEffect : ~mu25_3 +# 26| v26_1(Void) = NoOp : +# 25| v25_14(Void) = ReturnVoid : +# 25| v25_15(Void) = UnmodeledUse : mu* +# 25| v25_16(Void) = AliasedUse : ~mu25_3 +# 25| v25_17(Void) = ExitFunction : # 29| System.Void DerivedClass.Main() # 29| Block 0 -# 29| v0_0(Void) = EnterFunction : -# 29| mu0_1() = AliasedDefinition : -# 29| mu0_2() = UnmodeledDefinition : -# 31| r0_3(glval) = VariableAddress[obj1] : -# 31| r0_4(DerivedClass) = NewObj : -# 31| r0_5() = FunctionAddress[DerivedClass] : -# 31| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 31| mu0_7() = ^CallSideEffect : ~mu0_2 -# 31| mu0_8(DerivedClass) = Store : &:r0_3, r0_4 -# 32| r0_9(glval) = VariableAddress[obj2] : -# 32| r0_10(DerivedClass) = NewObj : -# 32| r0_11() = FunctionAddress[DerivedClass] : -# 32| r0_12(Int32) = Constant[1] : -# 32| v0_13(Void) = Call : func:r0_11, this:r0_10, 0:r0_12 -# 32| mu0_14() = ^CallSideEffect : ~mu0_2 -# 32| mu0_15(DerivedClass) = Store : &:r0_9, r0_10 -# 33| r0_16(glval) = VariableAddress[obj3] : -# 33| r0_17(DerivedClass) = NewObj : -# 33| r0_18() = FunctionAddress[DerivedClass] : -# 33| r0_19(Int32) = Constant[1] : -# 33| r0_20(Int32) = Constant[2] : -# 33| v0_21(Void) = Call : func:r0_18, this:r0_17, 0:r0_19, 1:r0_20 -# 33| mu0_22() = ^CallSideEffect : ~mu0_2 -# 33| mu0_23(DerivedClass) = Store : &:r0_16, r0_17 -# 29| v0_24(Void) = ReturnVoid : -# 29| v0_25(Void) = UnmodeledUse : mu* -# 29| v0_26(Void) = AliasedUse : ~mu0_2 -# 29| v0_27(Void) = ExitFunction : +# 29| v29_1(Void) = EnterFunction : +# 29| mu29_2() = AliasedDefinition : +# 29| mu29_3() = UnmodeledDefinition : +# 31| r31_1(glval) = VariableAddress[obj1] : +# 31| r31_2(DerivedClass) = NewObj : +# 31| r31_3() = FunctionAddress[DerivedClass] : +# 31| v31_4(Void) = Call : func:r31_3, this:r31_2 +# 31| mu31_5() = ^CallSideEffect : ~mu29_3 +# 31| mu31_6(DerivedClass) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[obj2] : +# 32| r32_2(DerivedClass) = NewObj : +# 32| r32_3() = FunctionAddress[DerivedClass] : +# 32| r32_4(Int32) = Constant[1] : +# 32| v32_5(Void) = Call : func:r32_3, this:r32_2, 0:r32_4 +# 32| mu32_6() = ^CallSideEffect : ~mu29_3 +# 32| mu32_7(DerivedClass) = Store : &:r32_1, r32_2 +# 33| r33_1(glval) = VariableAddress[obj3] : +# 33| r33_2(DerivedClass) = NewObj : +# 33| r33_3() = FunctionAddress[DerivedClass] : +# 33| r33_4(Int32) = Constant[1] : +# 33| r33_5(Int32) = Constant[2] : +# 33| v33_6(Void) = Call : func:r33_3, this:r33_2, 0:r33_4, 1:r33_5 +# 33| mu33_7() = ^CallSideEffect : ~mu29_3 +# 33| mu33_8(DerivedClass) = Store : &:r33_1, r33_2 +# 29| v29_4(Void) = ReturnVoid : +# 29| v29_5(Void) = UnmodeledUse : mu* +# 29| v29_6(Void) = AliasedUse : ~mu29_3 +# 29| v29_7(Void) = ExitFunction : crement.cs: # 3| System.Void CrementOpsTest.Main() # 3| Block 0 -# 3| v0_0(Void) = EnterFunction : -# 3| mu0_1() = AliasedDefinition : -# 3| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = VariableAddress[x] : -# 5| r0_4(Int32) = Constant[10] : -# 5| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 6| r0_6(glval) = VariableAddress[a] : -# 6| r0_7(glval) = VariableAddress[x] : -# 6| r0_8(Int32) = Load : &:r0_7, ~mu0_2 -# 6| r0_9(Int32) = Constant[1] : -# 6| r0_10(Int32) = Add : r0_8, r0_9 -# 6| mu0_11(Int32) = Store : &:r0_7, r0_10 -# 6| mu0_12(Int32) = Store : &:r0_6, r0_8 -# 7| r0_13(glval) = VariableAddress[b] : -# 7| r0_14(glval) = VariableAddress[x] : -# 7| r0_15(Int32) = Load : &:r0_14, ~mu0_2 -# 7| r0_16(Int32) = Constant[1] : -# 7| r0_17(Int32) = Sub : r0_15, r0_16 -# 7| mu0_18(Int32) = Store : &:r0_14, r0_17 -# 7| mu0_19(Int32) = Store : &:r0_13, r0_17 -# 8| r0_20(glval) = VariableAddress[c] : -# 8| r0_21(glval) = VariableAddress[x] : -# 8| r0_22(Int32) = Load : &:r0_21, ~mu0_2 -# 8| r0_23(Int32) = Constant[1] : -# 8| r0_24(Int32) = Add : r0_22, r0_23 -# 8| mu0_25(Int32) = Store : &:r0_21, r0_24 -# 8| mu0_26(Int32) = Store : &:r0_20, r0_24 -# 9| r0_27(glval) = VariableAddress[x] : -# 9| r0_28(Int32) = Load : &:r0_27, ~mu0_2 -# 9| r0_29(Int32) = Constant[1] : -# 9| r0_30(Int32) = Sub : r0_28, r0_29 -# 9| mu0_31(Int32) = Store : &:r0_27, r0_30 -# 9| r0_32(glval) = VariableAddress[x] : -# 9| mu0_33(Int32) = Store : &:r0_32, r0_28 -# 3| v0_34(Void) = ReturnVoid : -# 3| v0_35(Void) = UnmodeledUse : mu* -# 3| v0_36(Void) = AliasedUse : ~mu0_2 -# 3| v0_37(Void) = ExitFunction : +# 3| v3_1(Void) = EnterFunction : +# 3| mu3_2() = AliasedDefinition : +# 3| mu3_3() = UnmodeledDefinition : +# 5| r5_1(glval) = VariableAddress[x] : +# 5| r5_2(Int32) = Constant[10] : +# 5| mu5_3(Int32) = Store : &:r5_1, r5_2 +# 6| r6_1(glval) = VariableAddress[a] : +# 6| r6_2(glval) = VariableAddress[x] : +# 6| r6_3(Int32) = Load : &:r6_2, ~mu3_3 +# 6| r6_4(Int32) = Constant[1] : +# 6| r6_5(Int32) = Add : r6_3, r6_4 +# 6| mu6_6(Int32) = Store : &:r6_2, r6_5 +# 6| mu6_7(Int32) = Store : &:r6_1, r6_3 +# 7| r7_1(glval) = VariableAddress[b] : +# 7| r7_2(glval) = VariableAddress[x] : +# 7| r7_3(Int32) = Load : &:r7_2, ~mu3_3 +# 7| r7_4(Int32) = Constant[1] : +# 7| r7_5(Int32) = Sub : r7_3, r7_4 +# 7| mu7_6(Int32) = Store : &:r7_2, r7_5 +# 7| mu7_7(Int32) = Store : &:r7_1, r7_5 +# 8| r8_1(glval) = VariableAddress[c] : +# 8| r8_2(glval) = VariableAddress[x] : +# 8| r8_3(Int32) = Load : &:r8_2, ~mu3_3 +# 8| r8_4(Int32) = Constant[1] : +# 8| r8_5(Int32) = Add : r8_3, r8_4 +# 8| mu8_6(Int32) = Store : &:r8_2, r8_5 +# 8| mu8_7(Int32) = Store : &:r8_1, r8_5 +# 9| r9_1(glval) = VariableAddress[x] : +# 9| r9_2(Int32) = Load : &:r9_1, ~mu3_3 +# 9| r9_3(Int32) = Constant[1] : +# 9| r9_4(Int32) = Sub : r9_2, r9_3 +# 9| mu9_5(Int32) = Store : &:r9_1, r9_4 +# 9| r9_6(glval) = VariableAddress[x] : +# 9| mu9_7(Int32) = Store : &:r9_6, r9_2 +# 3| v3_4(Void) = ReturnVoid : +# 3| v3_5(Void) = UnmodeledUse : mu* +# 3| v3_6(Void) = AliasedUse : ~mu3_3 +# 3| v3_7(Void) = ExitFunction : delegates.cs: # 6| System.Int32 Delegates.returns(System.Int32) # 6| Block 0 -# 6| v0_0(Void) = EnterFunction : -# 6| mu0_1() = AliasedDefinition : -# 6| mu0_2() = UnmodeledDefinition : -# 6| r0_3(glval) = VariableAddress[ret] : -# 6| mu0_4(Int32) = InitializeParameter[ret] : &:r0_3 -# 8| r0_5(glval) = VariableAddress[#return] : -# 8| r0_6(glval) = VariableAddress[ret] : -# 8| r0_7(Int32) = Load : &:r0_6, ~mu0_2 -# 8| mu0_8(Int32) = Store : &:r0_5, r0_7 -# 6| r0_9(glval) = VariableAddress[#return] : -# 6| v0_10(Void) = ReturnValue : &:r0_9, ~mu0_2 -# 6| v0_11(Void) = UnmodeledUse : mu* -# 6| v0_12(Void) = AliasedUse : ~mu0_2 -# 6| v0_13(Void) = ExitFunction : +# 6| v6_1(Void) = EnterFunction : +# 6| mu6_2() = AliasedDefinition : +# 6| mu6_3() = UnmodeledDefinition : +# 6| r6_4(glval) = VariableAddress[ret] : +# 6| mu6_5(Int32) = InitializeParameter[ret] : &:r6_4 +# 8| r8_1(glval) = VariableAddress[#return] : +# 8| r8_2(glval) = VariableAddress[ret] : +# 8| r8_3(Int32) = Load : &:r8_2, ~mu6_3 +# 8| mu8_4(Int32) = Store : &:r8_1, r8_3 +# 6| r6_6(glval) = VariableAddress[#return] : +# 6| v6_7(Void) = ReturnValue : &:r6_6, ~mu6_3 +# 6| v6_8(Void) = UnmodeledUse : mu* +# 6| v6_9(Void) = AliasedUse : ~mu6_3 +# 6| v6_10(Void) = ExitFunction : # 11| System.Void Delegates.Main() # 11| Block 0 -# 11| v0_0(Void) = EnterFunction : -# 11| mu0_1() = AliasedDefinition : -# 11| mu0_2() = UnmodeledDefinition : -# 12| r0_3(glval) = VariableAddress[del1] : -# 12| r0_4(Del) = NewObj : -# 12| r0_5() = FunctionAddress[Del] : -# 12| r0_6(glval) = FunctionAddress[returns] : -# 12| v0_7(Void) = Call : func:r0_5, this:r0_4, 0:r0_6 -# 12| mu0_8() = ^CallSideEffect : ~mu0_2 -# 12| mu0_9(Del) = Store : &:r0_3, r0_4 -# 13| r0_10(glval) = VariableAddress[del1] : -# 13| r0_11(Del) = Load : &:r0_10, ~mu0_2 -# 13| r0_12() = FunctionAddress[Invoke] : -# 13| r0_13(Int32) = Constant[5] : -# 13| v0_14(Void) = Call : func:r0_12, this:r0_11, 0:r0_13 -# 13| mu0_15() = ^CallSideEffect : ~mu0_2 -# 11| v0_16(Void) = ReturnVoid : -# 11| v0_17(Void) = UnmodeledUse : mu* -# 11| v0_18(Void) = AliasedUse : ~mu0_2 -# 11| v0_19(Void) = ExitFunction : +# 11| v11_1(Void) = EnterFunction : +# 11| mu11_2() = AliasedDefinition : +# 11| mu11_3() = UnmodeledDefinition : +# 12| r12_1(glval) = VariableAddress[del1] : +# 12| r12_2(Del) = NewObj : +# 12| r12_3() = FunctionAddress[Del] : +# 12| r12_4(glval) = FunctionAddress[returns] : +# 12| v12_5(Void) = Call : func:r12_3, this:r12_2, 0:r12_4 +# 12| mu12_6() = ^CallSideEffect : ~mu11_3 +# 12| mu12_7(Del) = Store : &:r12_1, r12_2 +# 13| r13_1(glval) = VariableAddress[del1] : +# 13| r13_2(Del) = Load : &:r13_1, ~mu11_3 +# 13| r13_3() = FunctionAddress[Invoke] : +# 13| r13_4(Int32) = Constant[5] : +# 13| v13_5(Void) = Call : func:r13_3, this:r13_2, 0:r13_4 +# 13| mu13_6() = ^CallSideEffect : ~mu11_3 +# 11| v11_4(Void) = ReturnVoid : +# 11| v11_5(Void) = UnmodeledUse : mu* +# 11| v11_6(Void) = AliasedUse : ~mu11_3 +# 11| v11_7(Void) = ExitFunction : events.cs: # 8| System.Void Events..ctor() # 8| Block 0 -# 8| v0_0(Void) = EnterFunction : -# 8| mu0_1() = AliasedDefinition : -# 8| mu0_2() = UnmodeledDefinition : -# 8| r0_3(glval) = InitializeThis : -# 10| r0_4(MyDel) = NewObj : -# 10| r0_5() = FunctionAddress[MyDel] : -# 10| r0_6(glval) = FunctionAddress[Fun] : -# 10| v0_7(Void) = Call : func:r0_5, this:r0_4, 0:r0_6 -# 10| mu0_8() = ^CallSideEffect : ~mu0_2 -# 10| r0_9(Events) = CopyValue : r0_3 -# 10| r0_10(glval) = FieldAddress[Inst] : r0_9 -# 10| mu0_11(MyDel) = Store : &:r0_10, r0_4 -# 8| v0_12(Void) = ReturnVoid : -# 8| v0_13(Void) = UnmodeledUse : mu* -# 8| v0_14(Void) = AliasedUse : ~mu0_2 -# 8| v0_15(Void) = ExitFunction : +# 8| v8_1(Void) = EnterFunction : +# 8| mu8_2() = AliasedDefinition : +# 8| mu8_3() = UnmodeledDefinition : +# 8| r8_4(glval) = InitializeThis : +# 10| r10_1(MyDel) = NewObj : +# 10| r10_2() = FunctionAddress[MyDel] : +# 10| r10_3(glval) = FunctionAddress[Fun] : +# 10| v10_4(Void) = Call : func:r10_2, this:r10_1, 0:r10_3 +# 10| mu10_5() = ^CallSideEffect : ~mu8_3 +# 10| r10_6(Events) = CopyValue : r8_4 +# 10| r10_7(glval) = FieldAddress[Inst] : r10_6 +# 10| mu10_8(MyDel) = Store : &:r10_7, r10_1 +# 8| v8_5(Void) = ReturnVoid : +# 8| v8_6(Void) = UnmodeledUse : mu* +# 8| v8_7(Void) = AliasedUse : ~mu8_3 +# 8| v8_8(Void) = ExitFunction : # 13| System.Void Events.AddEvent() # 13| Block 0 -# 13| v0_0(Void) = EnterFunction : -# 13| mu0_1() = AliasedDefinition : -# 13| mu0_2() = UnmodeledDefinition : -# 13| r0_3(glval) = InitializeThis : -# 15| r0_4(Events) = CopyValue : r0_3 -# 15| r0_5() = FunctionAddress[add_MyEvent] : -# 15| r0_6(Events) = CopyValue : r0_3 -# 15| r0_7(glval) = FieldAddress[Inst] : r0_6 -# 15| r0_8(MyDel) = Load : &:r0_7, ~mu0_2 -# 15| v0_9(Void) = Call : func:r0_5, this:r0_4, 0:r0_8 -# 15| mu0_10() = ^CallSideEffect : ~mu0_2 -# 13| v0_11(Void) = ReturnVoid : -# 13| v0_12(Void) = UnmodeledUse : mu* -# 13| v0_13(Void) = AliasedUse : ~mu0_2 -# 13| v0_14(Void) = ExitFunction : +# 13| v13_1(Void) = EnterFunction : +# 13| mu13_2() = AliasedDefinition : +# 13| mu13_3() = UnmodeledDefinition : +# 13| r13_4(glval) = InitializeThis : +# 15| r15_1(Events) = CopyValue : r13_4 +# 15| r15_2() = FunctionAddress[add_MyEvent] : +# 15| r15_3(Events) = CopyValue : r13_4 +# 15| r15_4(glval) = FieldAddress[Inst] : r15_3 +# 15| r15_5(MyDel) = Load : &:r15_4, ~mu13_3 +# 15| v15_6(Void) = Call : func:r15_2, this:r15_1, 0:r15_5 +# 15| mu15_7() = ^CallSideEffect : ~mu13_3 +# 13| v13_5(Void) = ReturnVoid : +# 13| v13_6(Void) = UnmodeledUse : mu* +# 13| v13_7(Void) = AliasedUse : ~mu13_3 +# 13| v13_8(Void) = ExitFunction : # 18| System.Void Events.RemoveEvent() # 18| Block 0 -# 18| v0_0(Void) = EnterFunction : -# 18| mu0_1() = AliasedDefinition : -# 18| mu0_2() = UnmodeledDefinition : -# 18| r0_3(glval) = InitializeThis : -# 20| r0_4(Events) = CopyValue : r0_3 -# 20| r0_5() = FunctionAddress[remove_MyEvent] : -# 20| r0_6(Events) = CopyValue : r0_3 -# 20| r0_7(glval) = FieldAddress[Inst] : r0_6 -# 20| r0_8(MyDel) = Load : &:r0_7, ~mu0_2 -# 20| v0_9(Void) = Call : func:r0_5, this:r0_4, 0:r0_8 -# 20| mu0_10() = ^CallSideEffect : ~mu0_2 -# 18| v0_11(Void) = ReturnVoid : -# 18| v0_12(Void) = UnmodeledUse : mu* -# 18| v0_13(Void) = AliasedUse : ~mu0_2 -# 18| v0_14(Void) = ExitFunction : +# 18| v18_1(Void) = EnterFunction : +# 18| mu18_2() = AliasedDefinition : +# 18| mu18_3() = UnmodeledDefinition : +# 18| r18_4(glval) = InitializeThis : +# 20| r20_1(Events) = CopyValue : r18_4 +# 20| r20_2() = FunctionAddress[remove_MyEvent] : +# 20| r20_3(Events) = CopyValue : r18_4 +# 20| r20_4(glval) = FieldAddress[Inst] : r20_3 +# 20| r20_5(MyDel) = Load : &:r20_4, ~mu18_3 +# 20| v20_6(Void) = Call : func:r20_2, this:r20_1, 0:r20_5 +# 20| mu20_7() = ^CallSideEffect : ~mu18_3 +# 18| v18_5(Void) = ReturnVoid : +# 18| v18_6(Void) = UnmodeledUse : mu* +# 18| v18_7(Void) = AliasedUse : ~mu18_3 +# 18| v18_8(Void) = ExitFunction : # 23| System.String Events.Fun(System.String) # 23| Block 0 -# 23| v0_0(Void) = EnterFunction : -# 23| mu0_1() = AliasedDefinition : -# 23| mu0_2() = UnmodeledDefinition : -# 23| r0_3(glval) = InitializeThis : -# 23| r0_4(glval) = VariableAddress[str] : -# 23| mu0_5(String) = InitializeParameter[str] : &:r0_4 -# 25| r0_6(glval) = VariableAddress[#return] : -# 25| r0_7(glval) = VariableAddress[str] : -# 25| r0_8(String) = Load : &:r0_7, ~mu0_2 -# 25| mu0_9(String) = Store : &:r0_6, r0_8 -# 23| r0_10(glval) = VariableAddress[#return] : -# 23| v0_11(Void) = ReturnValue : &:r0_10, ~mu0_2 -# 23| v0_12(Void) = UnmodeledUse : mu* -# 23| v0_13(Void) = AliasedUse : ~mu0_2 -# 23| v0_14(Void) = ExitFunction : +# 23| v23_1(Void) = EnterFunction : +# 23| mu23_2() = AliasedDefinition : +# 23| mu23_3() = UnmodeledDefinition : +# 23| r23_4(glval) = InitializeThis : +# 23| r23_5(glval) = VariableAddress[str] : +# 23| mu23_6(String) = InitializeParameter[str] : &:r23_5 +# 25| r25_1(glval) = VariableAddress[#return] : +# 25| r25_2(glval) = VariableAddress[str] : +# 25| r25_3(String) = Load : &:r25_2, ~mu23_3 +# 25| mu25_4(String) = Store : &:r25_1, r25_3 +# 23| r23_7(glval) = VariableAddress[#return] : +# 23| v23_8(Void) = ReturnValue : &:r23_7, ~mu23_3 +# 23| v23_9(Void) = UnmodeledUse : mu* +# 23| v23_10(Void) = AliasedUse : ~mu23_3 +# 23| v23_11(Void) = ExitFunction : # 28| System.Void Events.Main(System.String[]) # 28| Block 0 -# 28| v0_0(Void) = EnterFunction : -# 28| mu0_1() = AliasedDefinition : -# 28| mu0_2() = UnmodeledDefinition : -# 28| r0_3(glval) = VariableAddress[args] : -# 28| mu0_4(String[]) = InitializeParameter[args] : &:r0_3 -# 30| r0_5(glval) = VariableAddress[obj] : -# 30| r0_6(Events) = NewObj : -# 30| r0_7() = FunctionAddress[Events] : -# 30| v0_8(Void) = Call : func:r0_7, this:r0_6 -# 30| mu0_9() = ^CallSideEffect : ~mu0_2 -# 30| mu0_10(Events) = Store : &:r0_5, r0_6 -# 31| r0_11(glval) = VariableAddress[obj] : -# 31| r0_12(Events) = Load : &:r0_11, ~mu0_2 -# 31| r0_13() = FunctionAddress[AddEvent] : -# 31| v0_14(Void) = Call : func:r0_13, this:r0_12 -# 31| mu0_15() = ^CallSideEffect : ~mu0_2 -# 32| r0_16(glval) = VariableAddress[result] : -# 32| r0_17(glval) = VariableAddress[obj] : -# 32| r0_18(Events) = Load : &:r0_17, ~mu0_2 -# 32| r0_19() = FunctionAddress[Invoke] : -# 32| r0_20(String) = StringConstant["string"] : -# 32| v0_21(Void) = Call : func:r0_19, this:r0_18, 0:r0_20 -# 32| mu0_22() = ^CallSideEffect : ~mu0_2 -# 32| mu0_23(String) = Store : &:r0_16, v0_21 -# 33| r0_24(glval) = VariableAddress[obj] : -# 33| r0_25(Events) = Load : &:r0_24, ~mu0_2 -# 33| r0_26() = FunctionAddress[RemoveEvent] : -# 33| v0_27(Void) = Call : func:r0_26, this:r0_25 -# 33| mu0_28() = ^CallSideEffect : ~mu0_2 -# 28| v0_29(Void) = ReturnVoid : -# 28| v0_30(Void) = UnmodeledUse : mu* -# 28| v0_31(Void) = AliasedUse : ~mu0_2 -# 28| v0_32(Void) = ExitFunction : +# 28| v28_1(Void) = EnterFunction : +# 28| mu28_2() = AliasedDefinition : +# 28| mu28_3() = UnmodeledDefinition : +# 28| r28_4(glval) = VariableAddress[args] : +# 28| mu28_5(String[]) = InitializeParameter[args] : &:r28_4 +# 30| r30_1(glval) = VariableAddress[obj] : +# 30| r30_2(Events) = NewObj : +# 30| r30_3() = FunctionAddress[Events] : +# 30| v30_4(Void) = Call : func:r30_3, this:r30_2 +# 30| mu30_5() = ^CallSideEffect : ~mu28_3 +# 30| mu30_6(Events) = Store : &:r30_1, r30_2 +# 31| r31_1(glval) = VariableAddress[obj] : +# 31| r31_2(Events) = Load : &:r31_1, ~mu28_3 +# 31| r31_3() = FunctionAddress[AddEvent] : +# 31| v31_4(Void) = Call : func:r31_3, this:r31_2 +# 31| mu31_5() = ^CallSideEffect : ~mu28_3 +# 32| r32_1(glval) = VariableAddress[result] : +# 32| r32_2(glval) = VariableAddress[obj] : +# 32| r32_3(Events) = Load : &:r32_2, ~mu28_3 +# 32| r32_4() = FunctionAddress[Invoke] : +# 32| r32_5(String) = StringConstant["string"] : +# 32| v32_6(Void) = Call : func:r32_4, this:r32_3, 0:r32_5 +# 32| mu32_7() = ^CallSideEffect : ~mu28_3 +# 32| mu32_8(String) = Store : &:r32_1, v32_6 +# 33| r33_1(glval) = VariableAddress[obj] : +# 33| r33_2(Events) = Load : &:r33_1, ~mu28_3 +# 33| r33_3() = FunctionAddress[RemoveEvent] : +# 33| v33_4(Void) = Call : func:r33_3, this:r33_2 +# 33| mu33_5() = ^CallSideEffect : ~mu28_3 +# 28| v28_6(Void) = ReturnVoid : +# 28| v28_7(Void) = UnmodeledUse : mu* +# 28| v28_8(Void) = AliasedUse : ~mu28_3 +# 28| v28_9(Void) = ExitFunction : foreach.cs: # 4| System.Void ForEach.Main() # 4| Block 0 -# 4| v0_0(Void) = EnterFunction : -# 4| mu0_1() = AliasedDefinition : -# 4| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = VariableAddress[a_array] : -# 5| mu0_4(Int32[]) = Uninitialized[a_array] : &:r0_3 -# 5| r0_5(Int32) = Constant[0] : -# 5| r0_6(glval) = PointerAdd[4] : r0_3, r0_5 -# 5| r0_7(Int32) = Constant[1] : -# 5| mu0_8(Int32) = Store : &:r0_6, r0_7 -# 5| r0_9(Int32) = Constant[1] : -# 5| r0_10(glval) = PointerAdd[4] : r0_3, r0_9 -# 5| r0_11(Int32) = Constant[2] : -# 5| mu0_12(Int32) = Store : &:r0_10, r0_11 -# 5| r0_13(Int32) = Constant[2] : -# 5| r0_14(glval) = PointerAdd[4] : r0_3, r0_13 -# 5| r0_15(Int32) = Constant[3] : -# 5| mu0_16(Int32) = Store : &:r0_14, r0_15 -# 5| r0_17(Int32) = Constant[3] : -# 5| r0_18(glval) = PointerAdd[4] : r0_3, r0_17 -# 5| r0_19(Int32) = Constant[4] : -# 5| mu0_20(Int32) = Store : &:r0_18, r0_19 -# 5| r0_21(Int32) = Constant[4] : -# 5| r0_22(glval) = PointerAdd[4] : r0_3, r0_21 -# 5| r0_23(Int32) = Constant[5] : -# 5| mu0_24(Int32) = Store : &:r0_22, r0_23 -# 5| r0_25(Int32) = Constant[5] : -# 5| r0_26(glval) = PointerAdd[4] : r0_3, r0_25 -# 5| r0_27(Int32) = Constant[6] : -# 5| mu0_28(Int32) = Store : &:r0_26, r0_27 -# 5| r0_29(Int32) = Constant[6] : -# 5| r0_30(glval) = PointerAdd[4] : r0_3, r0_29 -# 5| r0_31(Int32) = Constant[7] : -# 5| mu0_32(Int32) = Store : &:r0_30, r0_31 -# 7| r0_33(glval) = VariableAddress[#temp7:9] : -# 7| r0_34(glval) = VariableAddress[a_array] : -# 7| r0_35(Int32[]) = Load : &:r0_34, ~mu0_2 -# 7| r0_36() = FunctionAddress[GetEnumerator] : -# 7| r0_37(IEnumerator) = Call : func:r0_36, this:r0_35 -# 7| mu0_38() = ^CallSideEffect : ~mu0_2 -# 7| mu0_39(IEnumerator) = Store : &:r0_33, r0_37 +# 4| v4_1(Void) = EnterFunction : +# 4| mu4_2() = AliasedDefinition : +# 4| mu4_3() = UnmodeledDefinition : +# 5| r5_1(glval) = VariableAddress[a_array] : +# 5| mu5_2(Int32[]) = Uninitialized[a_array] : &:r5_1 +# 5| r5_3(Int32) = Constant[0] : +# 5| r5_4(glval) = PointerAdd[4] : r5_1, r5_3 +# 5| r5_5(Int32) = Constant[1] : +# 5| mu5_6(Int32) = Store : &:r5_4, r5_5 +# 5| r5_7(Int32) = Constant[1] : +# 5| r5_8(glval) = PointerAdd[4] : r5_1, r5_7 +# 5| r5_9(Int32) = Constant[2] : +# 5| mu5_10(Int32) = Store : &:r5_8, r5_9 +# 5| r5_11(Int32) = Constant[2] : +# 5| r5_12(glval) = PointerAdd[4] : r5_1, r5_11 +# 5| r5_13(Int32) = Constant[3] : +# 5| mu5_14(Int32) = Store : &:r5_12, r5_13 +# 5| r5_15(Int32) = Constant[3] : +# 5| r5_16(glval) = PointerAdd[4] : r5_1, r5_15 +# 5| r5_17(Int32) = Constant[4] : +# 5| mu5_18(Int32) = Store : &:r5_16, r5_17 +# 5| r5_19(Int32) = Constant[4] : +# 5| r5_20(glval) = PointerAdd[4] : r5_1, r5_19 +# 5| r5_21(Int32) = Constant[5] : +# 5| mu5_22(Int32) = Store : &:r5_20, r5_21 +# 5| r5_23(Int32) = Constant[5] : +# 5| r5_24(glval) = PointerAdd[4] : r5_1, r5_23 +# 5| r5_25(Int32) = Constant[6] : +# 5| mu5_26(Int32) = Store : &:r5_24, r5_25 +# 5| r5_27(Int32) = Constant[6] : +# 5| r5_28(glval) = PointerAdd[4] : r5_1, r5_27 +# 5| r5_29(Int32) = Constant[7] : +# 5| mu5_30(Int32) = Store : &:r5_28, r5_29 +# 7| r7_1(glval) = VariableAddress[#temp7:9] : +# 7| r7_2(glval) = VariableAddress[a_array] : +# 7| r7_3(Int32[]) = Load : &:r7_2, ~mu4_3 +# 7| r7_4() = FunctionAddress[GetEnumerator] : +# 7| r7_5(IEnumerator) = Call : func:r7_4, this:r7_3 +# 7| mu7_6() = ^CallSideEffect : ~mu4_3 +# 7| mu7_7(IEnumerator) = Store : &:r7_1, r7_5 #-----| Goto -> Block 1 # 7| Block 1 -# 7| r1_0(glval) = VariableAddress[#temp7:9] : -# 7| r1_1(Boolean) = Load : &:r1_0, ~mu0_2 -# 7| r1_2() = FunctionAddress[MoveNext] : -# 7| r1_3(Boolean) = Call : func:r1_2, this:r1_1 -# 7| mu1_4() = ^CallSideEffect : ~mu0_2 -# 7| v1_5(Void) = ConditionalBranch : r1_3 +# 7| r7_8(glval) = VariableAddress[#temp7:9] : +# 7| r7_9(Boolean) = Load : &:r7_8, ~mu4_3 +# 7| r7_10() = FunctionAddress[MoveNext] : +# 7| r7_11(Boolean) = Call : func:r7_10, this:r7_9 +# 7| mu7_12() = ^CallSideEffect : ~mu4_3 +# 7| v7_13(Void) = ConditionalBranch : r7_11 #-----| False -> Block 3 #-----| True -> Block 2 # 7| Block 2 -# 7| r2_0(glval) = VariableAddress[items] : -# 7| r2_1(glval) = VariableAddress[#temp7:9] : -# 7| r2_2(Boolean) = Load : &:r2_1, ~mu0_2 -# 7| r2_3() = FunctionAddress[get_Current] : -# 7| r2_4(Int32) = Call : func:r2_3, this:r2_2 -# 7| mu2_5() = ^CallSideEffect : ~mu0_2 -# 7| mu2_6(Int32) = Store : &:r2_0, r2_4 -# 9| r2_7(glval) = VariableAddress[x] : -# 9| r2_8(glval) = VariableAddress[items] : -# 9| r2_9(Int32) = Load : &:r2_8, ~mu0_2 -# 9| mu2_10(Int32) = Store : &:r2_7, r2_9 +# 7| r7_14(glval) = VariableAddress[items] : +# 7| r7_15(glval) = VariableAddress[#temp7:9] : +# 7| r7_16(Boolean) = Load : &:r7_15, ~mu4_3 +# 7| r7_17() = FunctionAddress[get_Current] : +# 7| r7_18(Int32) = Call : func:r7_17, this:r7_16 +# 7| mu7_19() = ^CallSideEffect : ~mu4_3 +# 7| mu7_20(Int32) = Store : &:r7_14, r7_18 +# 9| r9_1(glval) = VariableAddress[x] : +# 9| r9_2(glval) = VariableAddress[items] : +# 9| r9_3(Int32) = Load : &:r9_2, ~mu4_3 +# 9| mu9_4(Int32) = Store : &:r9_1, r9_3 #-----| Goto (back edge) -> Block 1 # 7| Block 3 -# 7| r3_0(glval) = VariableAddress[#temp7:9] : -# 7| r3_1(Boolean) = Load : &:r3_0, ~mu0_2 -# 7| r3_2() = FunctionAddress[Dispose] : -# 7| v3_3(Void) = Call : func:r3_2, this:r3_1 -# 7| mu3_4() = ^CallSideEffect : ~mu0_2 -# 4| v3_5(Void) = ReturnVoid : -# 4| v3_6(Void) = UnmodeledUse : mu* -# 4| v3_7(Void) = AliasedUse : ~mu0_2 -# 4| v3_8(Void) = ExitFunction : +# 7| r7_21(glval) = VariableAddress[#temp7:9] : +# 7| r7_22(Boolean) = Load : &:r7_21, ~mu4_3 +# 7| r7_23() = FunctionAddress[Dispose] : +# 7| v7_24(Void) = Call : func:r7_23, this:r7_22 +# 7| mu7_25() = ^CallSideEffect : ~mu4_3 +# 4| v4_4(Void) = ReturnVoid : +# 4| v4_5(Void) = UnmodeledUse : mu* +# 4| v4_6(Void) = AliasedUse : ~mu4_3 +# 4| v4_7(Void) = ExitFunction : func_with_param_call.cs: # 5| System.Int32 test_call_with_param.f(System.Int32,System.Int32) # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = VariableAddress[x] : -# 5| mu0_4(Int32) = InitializeParameter[x] : &:r0_3 -# 5| r0_5(glval) = VariableAddress[y] : -# 5| mu0_6(Int32) = InitializeParameter[y] : &:r0_5 -# 7| r0_7(glval) = VariableAddress[#return] : -# 7| r0_8(glval) = VariableAddress[x] : -# 7| r0_9(Int32) = Load : &:r0_8, ~mu0_2 -# 7| r0_10(glval) = VariableAddress[y] : -# 7| r0_11(Int32) = Load : &:r0_10, ~mu0_2 -# 7| r0_12(Int32) = Add : r0_9, r0_11 -# 7| mu0_13(Int32) = Store : &:r0_7, r0_12 -# 5| r0_14(glval) = VariableAddress[#return] : -# 5| v0_15(Void) = ReturnValue : &:r0_14, ~mu0_2 -# 5| v0_16(Void) = UnmodeledUse : mu* -# 5| v0_17(Void) = AliasedUse : ~mu0_2 -# 5| v0_18(Void) = ExitFunction : +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 5| r5_4(glval) = VariableAddress[x] : +# 5| mu5_5(Int32) = InitializeParameter[x] : &:r5_4 +# 5| r5_6(glval) = VariableAddress[y] : +# 5| mu5_7(Int32) = InitializeParameter[y] : &:r5_6 +# 7| r7_1(glval) = VariableAddress[#return] : +# 7| r7_2(glval) = VariableAddress[x] : +# 7| r7_3(Int32) = Load : &:r7_2, ~mu5_3 +# 7| r7_4(glval) = VariableAddress[y] : +# 7| r7_5(Int32) = Load : &:r7_4, ~mu5_3 +# 7| r7_6(Int32) = Add : r7_3, r7_5 +# 7| mu7_7(Int32) = Store : &:r7_1, r7_6 +# 5| r5_8(glval) = VariableAddress[#return] : +# 5| v5_9(Void) = ReturnValue : &:r5_8, ~mu5_3 +# 5| v5_10(Void) = UnmodeledUse : mu* +# 5| v5_11(Void) = AliasedUse : ~mu5_3 +# 5| v5_12(Void) = ExitFunction : # 10| System.Int32 test_call_with_param.g() # 10| Block 0 -# 10| v0_0(Void) = EnterFunction : -# 10| mu0_1() = AliasedDefinition : -# 10| mu0_2() = UnmodeledDefinition : -# 12| r0_3(glval) = VariableAddress[#return] : -# 12| r0_4() = FunctionAddress[f] : -# 12| r0_5(Int32) = Constant[2] : -# 12| r0_6(Int32) = Constant[3] : -# 12| r0_7(Int32) = Call : func:r0_4, 0:r0_5, 1:r0_6 -# 12| mu0_8() = ^CallSideEffect : ~mu0_2 -# 12| mu0_9(Int32) = Store : &:r0_3, r0_7 -# 10| r0_10(glval) = VariableAddress[#return] : -# 10| v0_11(Void) = ReturnValue : &:r0_10, ~mu0_2 -# 10| v0_12(Void) = UnmodeledUse : mu* -# 10| v0_13(Void) = AliasedUse : ~mu0_2 -# 10| v0_14(Void) = ExitFunction : +# 10| v10_1(Void) = EnterFunction : +# 10| mu10_2() = AliasedDefinition : +# 10| mu10_3() = UnmodeledDefinition : +# 12| r12_1(glval) = VariableAddress[#return] : +# 12| r12_2() = FunctionAddress[f] : +# 12| r12_3(Int32) = Constant[2] : +# 12| r12_4(Int32) = Constant[3] : +# 12| r12_5(Int32) = Call : func:r12_2, 0:r12_3, 1:r12_4 +# 12| mu12_6() = ^CallSideEffect : ~mu10_3 +# 12| mu12_7(Int32) = Store : &:r12_1, r12_5 +# 10| r10_4(glval) = VariableAddress[#return] : +# 10| v10_5(Void) = ReturnValue : &:r10_4, ~mu10_3 +# 10| v10_6(Void) = UnmodeledUse : mu* +# 10| v10_7(Void) = AliasedUse : ~mu10_3 +# 10| v10_8(Void) = ExitFunction : indexers.cs: # 8| System.String Indexers.MyClass.get_Item(System.Int32) # 8| Block 0 -# 8| v0_0(Void) = EnterFunction : -# 8| mu0_1() = AliasedDefinition : -# 8| mu0_2() = UnmodeledDefinition : -# 8| r0_3(glval) = InitializeThis : -# 6| r0_4(glval) = VariableAddress[index] : -# 6| mu0_5(Int32) = InitializeParameter[index] : &:r0_4 -# 10| r0_6(glval) = VariableAddress[#return] : -# 10| r0_7(MyClass) = CopyValue : r0_3 -# 10| r0_8(glval) = FieldAddress[address] : r0_7 -# 10| r0_9(String[]) = ElementsAddress : r0_8 -# 10| r0_10(glval) = VariableAddress[index] : -# 10| r0_11(Int32) = Load : &:r0_10, ~mu0_2 -# 10| r0_12(String[]) = PointerAdd[8] : r0_9, r0_11 -# 10| r0_13(String) = Load : &:r0_12, ~mu0_2 -# 10| mu0_14(String) = Store : &:r0_6, r0_13 -# 8| r0_15(glval) = VariableAddress[#return] : -# 8| v0_16(Void) = ReturnValue : &:r0_15, ~mu0_2 -# 8| v0_17(Void) = UnmodeledUse : mu* -# 8| v0_18(Void) = AliasedUse : ~mu0_2 -# 8| v0_19(Void) = ExitFunction : +# 8| v8_1(Void) = EnterFunction : +# 8| mu8_2() = AliasedDefinition : +# 8| mu8_3() = UnmodeledDefinition : +# 8| r8_4(glval) = InitializeThis : +# 6| r6_1(glval) = VariableAddress[index] : +# 6| mu6_3(Int32) = InitializeParameter[index] : &:r6_1 +# 10| r10_1(glval) = VariableAddress[#return] : +# 10| r10_2(MyClass) = CopyValue : r8_4 +# 10| r10_3(glval) = FieldAddress[address] : r10_2 +# 10| r10_4(String[]) = ElementsAddress : r10_3 +# 10| r10_5(glval) = VariableAddress[index] : +# 10| r10_6(Int32) = Load : &:r10_5, ~mu8_3 +# 10| r10_7(String[]) = PointerAdd[8] : r10_4, r10_6 +# 10| r10_8(String) = Load : &:r10_7, ~mu8_3 +# 10| mu10_9(String) = Store : &:r10_1, r10_8 +# 8| r8_5(glval) = VariableAddress[#return] : +# 8| v8_6(Void) = ReturnValue : &:r8_5, ~mu8_3 +# 8| v8_7(Void) = UnmodeledUse : mu* +# 8| v8_8(Void) = AliasedUse : ~mu8_3 +# 8| v8_9(Void) = ExitFunction : # 12| System.Void Indexers.MyClass.set_Item(System.Int32,System.String) # 12| Block 0 -# 12| v0_0(Void) = EnterFunction : -# 12| mu0_1() = AliasedDefinition : -# 12| mu0_2() = UnmodeledDefinition : -# 12| r0_3(glval) = InitializeThis : -# 6| r0_4(glval) = VariableAddress[index] : -# 6| mu0_5(Int32) = InitializeParameter[index] : &:r0_4 -# 12| r0_6(glval) = VariableAddress[value] : -# 12| mu0_7(String) = InitializeParameter[value] : &:r0_6 -# 14| r0_8(glval) = VariableAddress[value] : -# 14| r0_9(String) = Load : &:r0_8, ~mu0_2 -# 14| r0_10(MyClass) = CopyValue : r0_3 -# 14| r0_11(glval) = FieldAddress[address] : r0_10 -# 14| r0_12(String[]) = ElementsAddress : r0_11 -# 14| r0_13(glval) = VariableAddress[index] : -# 14| r0_14(Int32) = Load : &:r0_13, ~mu0_2 -# 14| r0_15(String[]) = PointerAdd[8] : r0_12, r0_14 -# 14| mu0_16(String) = Store : &:r0_15, r0_9 -# 12| v0_17(Void) = ReturnVoid : -# 12| v0_18(Void) = UnmodeledUse : mu* -# 12| v0_19(Void) = AliasedUse : ~mu0_2 -# 12| v0_20(Void) = ExitFunction : +# 12| v12_1(Void) = EnterFunction : +# 12| mu12_2() = AliasedDefinition : +# 12| mu12_3() = UnmodeledDefinition : +# 12| r12_4(glval) = InitializeThis : +# 6| r6_1(glval) = VariableAddress[index] : +# 6| mu6_3(Int32) = InitializeParameter[index] : &:r6_1 +# 12| r12_5(glval) = VariableAddress[value] : +# 12| mu12_6(String) = InitializeParameter[value] : &:r12_5 +# 14| r14_1(glval) = VariableAddress[value] : +# 14| r14_2(String) = Load : &:r14_1, ~mu12_3 +# 14| r14_3(MyClass) = CopyValue : r12_4 +# 14| r14_4(glval) = FieldAddress[address] : r14_3 +# 14| r14_5(String[]) = ElementsAddress : r14_4 +# 14| r14_6(glval) = VariableAddress[index] : +# 14| r14_7(Int32) = Load : &:r14_6, ~mu12_3 +# 14| r14_8(String[]) = PointerAdd[8] : r14_5, r14_7 +# 14| mu14_9(String) = Store : &:r14_8, r14_2 +# 12| v12_7(Void) = ReturnVoid : +# 12| v12_8(Void) = UnmodeledUse : mu* +# 12| v12_9(Void) = AliasedUse : ~mu12_3 +# 12| v12_10(Void) = ExitFunction : # 19| System.Void Indexers.Main() # 19| Block 0 -# 19| v0_0(Void) = EnterFunction : -# 19| mu0_1() = AliasedDefinition : -# 19| mu0_2() = UnmodeledDefinition : -# 21| r0_3(glval) = VariableAddress[inst] : -# 21| r0_4(MyClass) = NewObj : -# 21| r0_5() = FunctionAddress[MyClass] : -# 21| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 21| mu0_7() = ^CallSideEffect : ~mu0_2 -# 21| mu0_8(MyClass) = Store : &:r0_3, r0_4 -# 22| r0_9(glval) = VariableAddress[inst] : -# 22| r0_10(MyClass) = Load : &:r0_9, ~mu0_2 -# 22| r0_11() = FunctionAddress[set_Item] : -# 22| r0_12(Int32) = Constant[0] : -# 22| r0_13(String) = StringConstant["str1"] : -# 22| v0_14(Void) = Call : func:r0_11, this:r0_10, 0:r0_12, 1:r0_13 -# 22| mu0_15() = ^CallSideEffect : ~mu0_2 -# 23| r0_16(glval) = VariableAddress[inst] : -# 23| r0_17(MyClass) = Load : &:r0_16, ~mu0_2 -# 23| r0_18() = FunctionAddress[set_Item] : -# 23| r0_19(Int32) = Constant[1] : -# 23| r0_20(String) = StringConstant["str1"] : -# 23| v0_21(Void) = Call : func:r0_18, this:r0_17, 0:r0_19, 1:r0_20 -# 23| mu0_22() = ^CallSideEffect : ~mu0_2 -# 24| r0_23(glval) = VariableAddress[inst] : -# 24| r0_24(MyClass) = Load : &:r0_23, ~mu0_2 -# 24| r0_25() = FunctionAddress[set_Item] : -# 24| r0_26(Int32) = Constant[1] : -# 24| r0_27(glval) = VariableAddress[inst] : -# 24| r0_28(MyClass) = Load : &:r0_27, ~mu0_2 -# 24| r0_29() = FunctionAddress[get_Item] : -# 24| r0_30(Int32) = Constant[0] : -# 24| r0_31(String) = Call : func:r0_29, this:r0_28, 0:r0_30 -# 24| mu0_32() = ^CallSideEffect : ~mu0_2 -# 24| v0_33(Void) = Call : func:r0_25, this:r0_24, 0:r0_26, 1:r0_31 -# 24| mu0_34() = ^CallSideEffect : ~mu0_2 -# 19| v0_35(Void) = ReturnVoid : -# 19| v0_36(Void) = UnmodeledUse : mu* -# 19| v0_37(Void) = AliasedUse : ~mu0_2 -# 19| v0_38(Void) = ExitFunction : +# 19| v19_1(Void) = EnterFunction : +# 19| mu19_2() = AliasedDefinition : +# 19| mu19_3() = UnmodeledDefinition : +# 21| r21_1(glval) = VariableAddress[inst] : +# 21| r21_2(MyClass) = NewObj : +# 21| r21_3() = FunctionAddress[MyClass] : +# 21| v21_4(Void) = Call : func:r21_3, this:r21_2 +# 21| mu21_5() = ^CallSideEffect : ~mu19_3 +# 21| mu21_6(MyClass) = Store : &:r21_1, r21_2 +# 22| r22_1(glval) = VariableAddress[inst] : +# 22| r22_2(MyClass) = Load : &:r22_1, ~mu19_3 +# 22| r22_3() = FunctionAddress[set_Item] : +# 22| r22_4(Int32) = Constant[0] : +# 22| r22_5(String) = StringConstant["str1"] : +# 22| v22_6(Void) = Call : func:r22_3, this:r22_2, 0:r22_4, 1:r22_5 +# 22| mu22_7() = ^CallSideEffect : ~mu19_3 +# 23| r23_1(glval) = VariableAddress[inst] : +# 23| r23_2(MyClass) = Load : &:r23_1, ~mu19_3 +# 23| r23_3() = FunctionAddress[set_Item] : +# 23| r23_4(Int32) = Constant[1] : +# 23| r23_5(String) = StringConstant["str1"] : +# 23| v23_6(Void) = Call : func:r23_3, this:r23_2, 0:r23_4, 1:r23_5 +# 23| mu23_7() = ^CallSideEffect : ~mu19_3 +# 24| r24_1(glval) = VariableAddress[inst] : +# 24| r24_2(MyClass) = Load : &:r24_1, ~mu19_3 +# 24| r24_3() = FunctionAddress[set_Item] : +# 24| r24_4(Int32) = Constant[1] : +# 24| r24_5(glval) = VariableAddress[inst] : +# 24| r24_6(MyClass) = Load : &:r24_5, ~mu19_3 +# 24| r24_7() = FunctionAddress[get_Item] : +# 24| r24_8(Int32) = Constant[0] : +# 24| r24_9(String) = Call : func:r24_7, this:r24_6, 0:r24_8 +# 24| mu24_10() = ^CallSideEffect : ~mu19_3 +# 24| v24_11(Void) = Call : func:r24_3, this:r24_2, 0:r24_4, 1:r24_9 +# 24| mu24_12() = ^CallSideEffect : ~mu19_3 +# 19| v19_4(Void) = ReturnVoid : +# 19| v19_5(Void) = UnmodeledUse : mu* +# 19| v19_6(Void) = AliasedUse : ~mu19_3 +# 19| v19_7(Void) = ExitFunction : inheritance_polymorphism.cs: # 3| System.Int32 A.function() # 3| Block 0 -# 3| v0_0(Void) = EnterFunction : -# 3| mu0_1() = AliasedDefinition : -# 3| mu0_2() = UnmodeledDefinition : -# 3| r0_3(glval) = InitializeThis : -# 5| r0_4(glval) = VariableAddress[#return] : -# 5| r0_5(Int32) = Constant[0] : -# 5| mu0_6(Int32) = Store : &:r0_4, r0_5 -# 3| r0_7(glval) = VariableAddress[#return] : -# 3| v0_8(Void) = ReturnValue : &:r0_7, ~mu0_2 -# 3| v0_9(Void) = UnmodeledUse : mu* -# 3| v0_10(Void) = AliasedUse : ~mu0_2 -# 3| v0_11(Void) = ExitFunction : +# 3| v3_1(Void) = EnterFunction : +# 3| mu3_2() = AliasedDefinition : +# 3| mu3_3() = UnmodeledDefinition : +# 3| r3_4(glval) = InitializeThis : +# 5| r5_1(glval) = VariableAddress[#return] : +# 5| r5_2(Int32) = Constant[0] : +# 5| mu5_3(Int32) = Store : &:r5_1, r5_2 +# 3| r3_5(glval) = VariableAddress[#return] : +# 3| v3_6(Void) = ReturnValue : &:r3_5, ~mu3_3 +# 3| v3_7(Void) = UnmodeledUse : mu* +# 3| v3_8(Void) = AliasedUse : ~mu3_3 +# 3| v3_9(Void) = ExitFunction : # 15| System.Int32 C.function() # 15| Block 0 -# 15| v0_0(Void) = EnterFunction : -# 15| mu0_1() = AliasedDefinition : -# 15| mu0_2() = UnmodeledDefinition : -# 15| r0_3(glval) = InitializeThis : -# 17| r0_4(glval) = VariableAddress[#return] : -# 17| r0_5(Int32) = Constant[1] : -# 17| mu0_6(Int32) = Store : &:r0_4, r0_5 -# 15| r0_7(glval) = VariableAddress[#return] : -# 15| v0_8(Void) = ReturnValue : &:r0_7, ~mu0_2 -# 15| v0_9(Void) = UnmodeledUse : mu* -# 15| v0_10(Void) = AliasedUse : ~mu0_2 -# 15| v0_11(Void) = ExitFunction : +# 15| v15_1(Void) = EnterFunction : +# 15| mu15_2() = AliasedDefinition : +# 15| mu15_3() = UnmodeledDefinition : +# 15| r15_4(glval) = InitializeThis : +# 17| r17_1(glval) = VariableAddress[#return] : +# 17| r17_2(Int32) = Constant[1] : +# 17| mu17_3(Int32) = Store : &:r17_1, r17_2 +# 15| r15_5(glval) = VariableAddress[#return] : +# 15| v15_6(Void) = ReturnValue : &:r15_5, ~mu15_3 +# 15| v15_7(Void) = UnmodeledUse : mu* +# 15| v15_8(Void) = AliasedUse : ~mu15_3 +# 15| v15_9(Void) = ExitFunction : # 23| System.Void Program.Main() # 23| Block 0 -# 23| v0_0(Void) = EnterFunction : -# 23| mu0_1() = AliasedDefinition : -# 23| mu0_2() = UnmodeledDefinition : -# 25| r0_3(glval) = VariableAddress[objB] : -# 25| r0_4(B) = NewObj : -# 25| r0_5() = FunctionAddress[B] : -# 25| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 25| mu0_7() = ^CallSideEffect : ~mu0_2 -# 25| mu0_8(B) = Store : &:r0_3, r0_4 -# 26| r0_9(glval) = VariableAddress[objB] : -# 26| r0_10(B) = Load : &:r0_9, ~mu0_2 -# 26| r0_11() = FunctionAddress[function] : -# 26| r0_12(Int32) = Call : func:r0_11, this:r0_10 -# 26| mu0_13() = ^CallSideEffect : ~mu0_2 -# 29| r0_14(glval) = VariableAddress[objA] : -# 29| mu0_15(A) = Uninitialized[objA] : &:r0_14 -# 30| r0_16(glval) = VariableAddress[objB] : -# 30| r0_17(B) = Load : &:r0_16, ~mu0_2 -# 30| r0_18(A) = Convert : r0_17 -# 30| r0_19(glval) = VariableAddress[objA] : -# 30| mu0_20(A) = Store : &:r0_19, r0_18 -# 31| r0_21(glval) = VariableAddress[objA] : -# 31| r0_22(A) = Load : &:r0_21, ~mu0_2 -# 31| r0_23() = FunctionAddress[function] : -# 31| r0_24(Int32) = Call : func:r0_23, this:r0_22 -# 31| mu0_25() = ^CallSideEffect : ~mu0_2 -# 33| r0_26(glval) = VariableAddress[objC] : -# 33| r0_27(C) = NewObj : -# 33| r0_28() = FunctionAddress[C] : -# 33| v0_29(Void) = Call : func:r0_28, this:r0_27 -# 33| mu0_30() = ^CallSideEffect : ~mu0_2 -# 33| r0_31(A) = Convert : r0_27 -# 33| mu0_32(A) = Store : &:r0_26, r0_27 -# 34| r0_33(glval) = VariableAddress[objC] : -# 34| r0_34(A) = Load : &:r0_33, ~mu0_2 -# 34| r0_35() = FunctionAddress[function] : -# 34| r0_36(Int32) = Call : func:r0_35, this:r0_34 -# 34| mu0_37() = ^CallSideEffect : ~mu0_2 -# 23| v0_38(Void) = ReturnVoid : -# 23| v0_39(Void) = UnmodeledUse : mu* -# 23| v0_40(Void) = AliasedUse : ~mu0_2 -# 23| v0_41(Void) = ExitFunction : +# 23| v23_1(Void) = EnterFunction : +# 23| mu23_2() = AliasedDefinition : +# 23| mu23_3() = UnmodeledDefinition : +# 25| r25_1(glval) = VariableAddress[objB] : +# 25| r25_2(B) = NewObj : +# 25| r25_3() = FunctionAddress[B] : +# 25| v25_4(Void) = Call : func:r25_3, this:r25_2 +# 25| mu25_5() = ^CallSideEffect : ~mu23_3 +# 25| mu25_6(B) = Store : &:r25_1, r25_2 +# 26| r26_1(glval) = VariableAddress[objB] : +# 26| r26_2(B) = Load : &:r26_1, ~mu23_3 +# 26| r26_3() = FunctionAddress[function] : +# 26| r26_4(Int32) = Call : func:r26_3, this:r26_2 +# 26| mu26_5() = ^CallSideEffect : ~mu23_3 +# 29| r29_1(glval) = VariableAddress[objA] : +# 29| mu29_2(A) = Uninitialized[objA] : &:r29_1 +# 30| r30_1(glval) = VariableAddress[objB] : +# 30| r30_2(B) = Load : &:r30_1, ~mu23_3 +# 30| r30_3(A) = Convert : r30_2 +# 30| r30_4(glval) = VariableAddress[objA] : +# 30| mu30_5(A) = Store : &:r30_4, r30_3 +# 31| r31_1(glval) = VariableAddress[objA] : +# 31| r31_2(A) = Load : &:r31_1, ~mu23_3 +# 31| r31_3() = FunctionAddress[function] : +# 31| r31_4(Int32) = Call : func:r31_3, this:r31_2 +# 31| mu31_5() = ^CallSideEffect : ~mu23_3 +# 33| r33_1(glval) = VariableAddress[objC] : +# 33| r33_2(C) = NewObj : +# 33| r33_3() = FunctionAddress[C] : +# 33| v33_4(Void) = Call : func:r33_3, this:r33_2 +# 33| mu33_5() = ^CallSideEffect : ~mu23_3 +# 33| r33_6(A) = Convert : r33_2 +# 33| mu33_7(A) = Store : &:r33_1, r33_2 +# 34| r34_1(glval) = VariableAddress[objC] : +# 34| r34_2(A) = Load : &:r34_1, ~mu23_3 +# 34| r34_3() = FunctionAddress[function] : +# 34| r34_4(Int32) = Call : func:r34_3, this:r34_2 +# 34| mu34_5() = ^CallSideEffect : ~mu23_3 +# 23| v23_4(Void) = ReturnVoid : +# 23| v23_5(Void) = UnmodeledUse : mu* +# 23| v23_6(Void) = AliasedUse : ~mu23_3 +# 23| v23_7(Void) = ExitFunction : inoutref.cs: # 11| System.Void InOutRef.set(MyClass,MyClass) # 11| Block 0 -# 11| v0_0(Void) = EnterFunction : -# 11| mu0_1() = AliasedDefinition : -# 11| mu0_2() = UnmodeledDefinition : -# 11| r0_3(glval) = VariableAddress[o1] : -# 11| mu0_4(MyClass) = InitializeParameter[o1] : &:r0_3 -# 11| r0_5(glval) = VariableAddress[o2] : -# 11| mu0_6(MyClass) = InitializeParameter[o2] : &:r0_5 -# 13| r0_7(glval) = VariableAddress[o2] : -# 13| r0_8(MyClass) = Load : &:r0_7, ~mu0_2 -# 13| r0_9(glval) = VariableAddress[o1] : -# 13| r0_10(MyClass) = Load : &:r0_9, ~mu0_2 -# 13| mu0_11(MyClass) = Store : &:r0_10, r0_8 -# 11| v0_12(Void) = ReturnVoid : -# 11| v0_13(Void) = UnmodeledUse : mu* -# 11| v0_14(Void) = AliasedUse : ~mu0_2 -# 11| v0_15(Void) = ExitFunction : +# 11| v11_1(Void) = EnterFunction : +# 11| mu11_2() = AliasedDefinition : +# 11| mu11_3() = UnmodeledDefinition : +# 11| r11_4(glval) = VariableAddress[o1] : +# 11| mu11_5(MyClass) = InitializeParameter[o1] : &:r11_4 +# 11| r11_6(glval) = VariableAddress[o2] : +# 11| mu11_7(MyClass) = InitializeParameter[o2] : &:r11_6 +# 13| r13_1(glval) = VariableAddress[o2] : +# 13| r13_2(MyClass) = Load : &:r13_1, ~mu11_3 +# 13| r13_3(glval) = VariableAddress[o1] : +# 13| r13_4(MyClass) = Load : &:r13_3, ~mu11_3 +# 13| mu13_5(MyClass) = Store : &:r13_4, r13_2 +# 11| v11_8(Void) = ReturnVoid : +# 11| v11_9(Void) = UnmodeledUse : mu* +# 11| v11_10(Void) = AliasedUse : ~mu11_3 +# 11| v11_11(Void) = ExitFunction : # 16| System.Void InOutRef.F(System.Int32,MyStruct,MyStruct,MyClass,MyClass) # 16| Block 0 -# 16| v0_0(Void) = EnterFunction : -# 16| mu0_1() = AliasedDefinition : -# 16| mu0_2() = UnmodeledDefinition : -# 16| r0_3(glval) = VariableAddress[a] : -# 16| mu0_4(Int32) = InitializeParameter[a] : &:r0_3 -# 16| r0_5(glval) = VariableAddress[b] : -# 16| mu0_6(MyStruct) = InitializeParameter[b] : &:r0_5 -# 16| r0_7(glval) = VariableAddress[b1] : -# 16| mu0_8(MyStruct) = InitializeParameter[b1] : &:r0_7 -# 16| r0_9(glval) = VariableAddress[c] : -# 16| mu0_10(MyClass) = InitializeParameter[c] : &:r0_9 -# 16| r0_11(glval) = VariableAddress[c1] : -# 16| mu0_12(MyClass) = InitializeParameter[c1] : &:r0_11 -# 18| r0_13(Int32) = Constant[0] : -# 18| r0_14(glval) = VariableAddress[b] : -# 18| r0_15(MyStruct) = Load : &:r0_14, ~mu0_2 -# 18| r0_16(glval) = FieldAddress[fld] : r0_15 -# 18| mu0_17(Int32) = Store : &:r0_16, r0_13 -# 19| r0_18(glval) = VariableAddress[b] : -# 19| r0_19(MyStruct) = Load : &:r0_18, ~mu0_2 -# 19| r0_20(glval) = FieldAddress[fld] : r0_19 -# 19| r0_21(Int32) = Load : &:r0_20, ~mu0_2 -# 19| r0_22(glval) = VariableAddress[a] : -# 19| r0_23(Int32) = Load : &:r0_22, ~mu0_2 -# 19| mu0_24(Int32) = Store : &:r0_23, r0_21 -# 21| r0_25(Int32) = Constant[10] : -# 21| r0_26(glval) = VariableAddress[c] : -# 21| r0_27(MyClass) = Load : &:r0_26, ~mu0_2 -# 21| r0_28(MyClass) = Load : &:r0_27, ~mu0_2 -# 21| r0_29(glval) = FieldAddress[fld] : r0_28 -# 21| mu0_30(Int32) = Store : &:r0_29, r0_25 -# 22| r0_31(glval) = VariableAddress[c] : -# 22| r0_32(MyClass) = Load : &:r0_31, ~mu0_2 -# 22| r0_33(MyClass) = Load : &:r0_32, ~mu0_2 -# 22| r0_34(glval) = FieldAddress[fld] : r0_33 -# 22| r0_35(Int32) = Load : &:r0_34, ~mu0_2 -# 22| r0_36(glval) = VariableAddress[a] : -# 22| r0_37(Int32) = Load : &:r0_36, ~mu0_2 -# 22| mu0_38(Int32) = Store : &:r0_37, r0_35 -# 24| r0_39(glval) = VariableAddress[b1] : -# 24| r0_40(MyStruct) = Load : &:r0_39, ~mu0_2 -# 24| r0_41(MyStruct) = Load : &:r0_40, ~mu0_2 -# 24| r0_42(glval) = VariableAddress[b] : -# 24| r0_43(MyStruct) = Load : &:r0_42, ~mu0_2 -# 24| mu0_44(MyStruct) = Store : &:r0_43, r0_41 -# 26| r0_45() = FunctionAddress[set] : -# 26| r0_46(glval) = VariableAddress[c] : -# 26| r0_47(MyClass) = Load : &:r0_46, ~mu0_2 -# 26| r0_48(glval) = VariableAddress[c1] : -# 26| r0_49(MyClass) = Load : &:r0_48, ~mu0_2 -# 26| r0_50(MyClass) = Load : &:r0_49, ~mu0_2 -# 26| v0_51(Void) = Call : func:r0_45, 0:r0_47, 1:r0_50 -# 26| mu0_52() = ^CallSideEffect : ~mu0_2 -# 16| v0_53(Void) = ReturnVoid : -# 16| v0_54(Void) = UnmodeledUse : mu* -# 16| v0_55(Void) = AliasedUse : ~mu0_2 -# 16| v0_56(Void) = ExitFunction : +# 16| v16_1(Void) = EnterFunction : +# 16| mu16_2() = AliasedDefinition : +# 16| mu16_3() = UnmodeledDefinition : +# 16| r16_4(glval) = VariableAddress[a] : +# 16| mu16_5(Int32) = InitializeParameter[a] : &:r16_4 +# 16| r16_6(glval) = VariableAddress[b] : +# 16| mu16_7(MyStruct) = InitializeParameter[b] : &:r16_6 +# 16| r16_8(glval) = VariableAddress[b1] : +# 16| mu16_9(MyStruct) = InitializeParameter[b1] : &:r16_8 +# 16| r16_10(glval) = VariableAddress[c] : +# 16| mu16_11(MyClass) = InitializeParameter[c] : &:r16_10 +# 16| r16_12(glval) = VariableAddress[c1] : +# 16| mu16_13(MyClass) = InitializeParameter[c1] : &:r16_12 +# 18| r18_1(Int32) = Constant[0] : +# 18| r18_2(glval) = VariableAddress[b] : +# 18| r18_3(MyStruct) = Load : &:r18_2, ~mu16_3 +# 18| r18_4(glval) = FieldAddress[fld] : r18_3 +# 18| mu18_5(Int32) = Store : &:r18_4, r18_1 +# 19| r19_1(glval) = VariableAddress[b] : +# 19| r19_2(MyStruct) = Load : &:r19_1, ~mu16_3 +# 19| r19_3(glval) = FieldAddress[fld] : r19_2 +# 19| r19_4(Int32) = Load : &:r19_3, ~mu16_3 +# 19| r19_5(glval) = VariableAddress[a] : +# 19| r19_6(Int32) = Load : &:r19_5, ~mu16_3 +# 19| mu19_7(Int32) = Store : &:r19_6, r19_4 +# 21| r21_1(Int32) = Constant[10] : +# 21| r21_2(glval) = VariableAddress[c] : +# 21| r21_3(MyClass) = Load : &:r21_2, ~mu16_3 +# 21| r21_4(MyClass) = Load : &:r21_3, ~mu16_3 +# 21| r21_5(glval) = FieldAddress[fld] : r21_4 +# 21| mu21_6(Int32) = Store : &:r21_5, r21_1 +# 22| r22_1(glval) = VariableAddress[c] : +# 22| r22_2(MyClass) = Load : &:r22_1, ~mu16_3 +# 22| r22_3(MyClass) = Load : &:r22_2, ~mu16_3 +# 22| r22_4(glval) = FieldAddress[fld] : r22_3 +# 22| r22_5(Int32) = Load : &:r22_4, ~mu16_3 +# 22| r22_6(glval) = VariableAddress[a] : +# 22| r22_7(Int32) = Load : &:r22_6, ~mu16_3 +# 22| mu22_8(Int32) = Store : &:r22_7, r22_5 +# 24| r24_1(glval) = VariableAddress[b1] : +# 24| r24_2(MyStruct) = Load : &:r24_1, ~mu16_3 +# 24| r24_3(MyStruct) = Load : &:r24_2, ~mu16_3 +# 24| r24_4(glval) = VariableAddress[b] : +# 24| r24_5(MyStruct) = Load : &:r24_4, ~mu16_3 +# 24| mu24_6(MyStruct) = Store : &:r24_5, r24_3 +# 26| r26_1() = FunctionAddress[set] : +# 26| r26_2(glval) = VariableAddress[c] : +# 26| r26_3(MyClass) = Load : &:r26_2, ~mu16_3 +# 26| r26_4(glval) = VariableAddress[c1] : +# 26| r26_5(MyClass) = Load : &:r26_4, ~mu16_3 +# 26| r26_6(MyClass) = Load : &:r26_5, ~mu16_3 +# 26| v26_7(Void) = Call : func:r26_1, 0:r26_3, 1:r26_6 +# 26| mu26_8() = ^CallSideEffect : ~mu16_3 +# 16| v16_14(Void) = ReturnVoid : +# 16| v16_15(Void) = UnmodeledUse : mu* +# 16| v16_16(Void) = AliasedUse : ~mu16_3 +# 16| v16_17(Void) = ExitFunction : # 29| System.Void InOutRef.Main() # 29| Block 0 -# 29| v0_0(Void) = EnterFunction : -# 29| mu0_1() = AliasedDefinition : -# 29| mu0_2() = UnmodeledDefinition : -# 31| r0_3(glval) = VariableAddress[a] : -# 31| r0_4(Int32) = Constant[0] : -# 31| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 32| r0_6(glval) = VariableAddress[b] : -# 32| r0_7(MyStruct) = NewObj : -# 32| r0_8() = FunctionAddress[MyStruct] : -# 32| v0_9(Void) = Call : func:r0_8, this:r0_7 -# 32| mu0_10() = ^CallSideEffect : ~mu0_2 -# 32| r0_11(MyStruct) = Load : &:r0_7, ~mu0_2 -# 32| mu0_12(MyStruct) = Store : &:r0_6, r0_11 -# 33| r0_13(glval) = VariableAddress[c] : -# 33| r0_14(MyClass) = NewObj : -# 33| r0_15() = FunctionAddress[MyClass] : -# 33| v0_16(Void) = Call : func:r0_15, this:r0_14 -# 33| mu0_17() = ^CallSideEffect : ~mu0_2 -# 33| mu0_18(MyClass) = Store : &:r0_13, r0_14 -# 34| r0_19() = FunctionAddress[F] : -# 34| r0_20(glval) = VariableAddress[a] : -# 34| r0_21(glval) = VariableAddress[b] : -# 34| r0_22(glval) = VariableAddress[b] : -# 34| r0_23(glval) = VariableAddress[c] : -# 34| r0_24(glval) = VariableAddress[c] : -# 34| v0_25(Void) = Call : func:r0_19, 0:r0_20, 1:r0_21, 2:r0_22, 3:r0_23, 4:r0_24 -# 34| mu0_26() = ^CallSideEffect : ~mu0_2 -# 36| r0_27(glval) = VariableAddress[x] : -# 36| r0_28(glval) = VariableAddress[b] : -# 36| r0_29(glval) = FieldAddress[fld] : r0_28 -# 36| r0_30(Int32) = Load : &:r0_29, ~mu0_2 -# 36| mu0_31(Int32) = Store : &:r0_27, r0_30 -# 29| v0_32(Void) = ReturnVoid : -# 29| v0_33(Void) = UnmodeledUse : mu* -# 29| v0_34(Void) = AliasedUse : ~mu0_2 -# 29| v0_35(Void) = ExitFunction : +# 29| v29_1(Void) = EnterFunction : +# 29| mu29_2() = AliasedDefinition : +# 29| mu29_3() = UnmodeledDefinition : +# 31| r31_1(glval) = VariableAddress[a] : +# 31| r31_2(Int32) = Constant[0] : +# 31| mu31_3(Int32) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[b] : +# 32| r32_2(MyStruct) = NewObj : +# 32| r32_3() = FunctionAddress[MyStruct] : +# 32| v32_4(Void) = Call : func:r32_3, this:r32_2 +# 32| mu32_5() = ^CallSideEffect : ~mu29_3 +# 32| r32_6(MyStruct) = Load : &:r32_2, ~mu29_3 +# 32| mu32_7(MyStruct) = Store : &:r32_1, r32_6 +# 33| r33_1(glval) = VariableAddress[c] : +# 33| r33_2(MyClass) = NewObj : +# 33| r33_3() = FunctionAddress[MyClass] : +# 33| v33_4(Void) = Call : func:r33_3, this:r33_2 +# 33| mu33_5() = ^CallSideEffect : ~mu29_3 +# 33| mu33_6(MyClass) = Store : &:r33_1, r33_2 +# 34| r34_1() = FunctionAddress[F] : +# 34| r34_2(glval) = VariableAddress[a] : +# 34| r34_3(glval) = VariableAddress[b] : +# 34| r34_4(glval) = VariableAddress[b] : +# 34| r34_5(glval) = VariableAddress[c] : +# 34| r34_6(glval) = VariableAddress[c] : +# 34| v34_7(Void) = Call : func:r34_1, 0:r34_2, 1:r34_3, 2:r34_4, 3:r34_5, 4:r34_6 +# 34| mu34_8() = ^CallSideEffect : ~mu29_3 +# 36| r36_1(glval) = VariableAddress[x] : +# 36| r36_2(glval) = VariableAddress[b] : +# 36| r36_3(glval) = FieldAddress[fld] : r36_2 +# 36| r36_4(Int32) = Load : &:r36_3, ~mu29_3 +# 36| mu36_5(Int32) = Store : &:r36_1, r36_4 +# 29| v29_4(Void) = ReturnVoid : +# 29| v29_5(Void) = UnmodeledUse : mu* +# 29| v29_6(Void) = AliasedUse : ~mu29_3 +# 29| v29_7(Void) = ExitFunction : isexpr.cs: # 8| System.Void IsExpr.Main() # 8| Block 0 -# 8| v0_0(Void) = EnterFunction : -# 8| mu0_1() = AliasedDefinition : -# 8| mu0_2() = UnmodeledDefinition : -# 10| r0_3(glval) = VariableAddress[obj] : -# 10| r0_4(null) = Constant[null] : -# 10| r0_5(Is_A) = Convert : r0_4 -# 10| mu0_6(Is_A) = Store : &:r0_3, r0_4 -# 12| r0_7(glval) = VariableAddress[o] : -# 12| r0_8(glval) = VariableAddress[obj] : -# 12| r0_9(Is_A) = Load : &:r0_8, ~mu0_2 -# 12| r0_10(Object) = Convert : r0_9 -# 12| mu0_11(Object) = Store : &:r0_7, r0_9 -# 13| r0_12(glval) = VariableAddress[o] : -# 13| r0_13(Object) = Load : &:r0_12, ~mu0_2 -# 13| r0_14(Is_A) = CheckedConvertOrNull : r0_13 -# 13| r0_15(Is_A) = Constant[0] : -# 13| r0_16(glval) = VariableAddress[tmp] : -# 13| mu0_17(Is_A) = Uninitialized[tmp] : &:r0_16 -# 13| r0_18(Boolean) = CompareNE : r0_14, r0_15 -# 13| v0_19(Void) = ConditionalBranch : r0_18 +# 8| v8_1(Void) = EnterFunction : +# 8| mu8_2() = AliasedDefinition : +# 8| mu8_3() = UnmodeledDefinition : +# 10| r10_1(glval) = VariableAddress[obj] : +# 10| r10_2(null) = Constant[null] : +# 10| r10_3(Is_A) = Convert : r10_2 +# 10| mu10_4(Is_A) = Store : &:r10_1, r10_2 +# 12| r12_1(glval) = VariableAddress[o] : +# 12| r12_2(glval) = VariableAddress[obj] : +# 12| r12_3(Is_A) = Load : &:r12_2, ~mu8_3 +# 12| r12_4(Object) = Convert : r12_3 +# 12| mu12_5(Object) = Store : &:r12_1, r12_3 +# 13| r13_1(glval) = VariableAddress[o] : +# 13| r13_2(Object) = Load : &:r13_1, ~mu8_3 +# 13| r13_3(Is_A) = CheckedConvertOrNull : r13_2 +# 13| r13_4(Is_A) = Constant[0] : +# 13| r13_5(glval) = VariableAddress[tmp] : +# 13| mu13_6(Is_A) = Uninitialized[tmp] : &:r13_5 +# 13| r13_7(Boolean) = CompareNE : r13_3, r13_4 +# 13| v13_8(Void) = ConditionalBranch : r13_7 #-----| False -> Block 2 #-----| True -> Block 3 # 8| Block 1 -# 8| v1_0(Void) = ReturnVoid : -# 8| v1_1(Void) = UnmodeledUse : mu* -# 8| v1_2(Void) = AliasedUse : ~mu0_2 -# 8| v1_3(Void) = ExitFunction : +# 8| v8_4(Void) = ReturnVoid : +# 8| v8_5(Void) = UnmodeledUse : mu* +# 8| v8_6(Void) = AliasedUse : ~mu8_3 +# 8| v8_7(Void) = ExitFunction : # 13| Block 2 -# 13| v2_0(Void) = ConditionalBranch : r0_18 +# 13| v13_9(Void) = ConditionalBranch : r13_7 #-----| False -> Block 5 #-----| True -> Block 4 # 13| Block 3 -# 13| mu3_0(Is_A) = Store : &:r0_16, r0_14 +# 13| mu13_10(Is_A) = Store : &:r13_5, r13_3 #-----| Goto -> Block 2 # 15| Block 4 -# 15| r4_0(glval) = VariableAddress[res] : -# 15| r4_1(glval) = VariableAddress[tmp] : -# 15| r4_2(Is_A) = Load : &:r4_1, ~mu0_2 -# 15| r4_3(glval) = FieldAddress[x] : r4_2 -# 15| r4_4(Int32) = Load : &:r4_3, ~mu0_2 -# 15| mu4_5(Int32) = Store : &:r4_0, r4_4 +# 15| r15_1(glval) = VariableAddress[res] : +# 15| r15_2(glval) = VariableAddress[tmp] : +# 15| r15_3(Is_A) = Load : &:r15_2, ~mu8_3 +# 15| r15_4(glval) = FieldAddress[x] : r15_3 +# 15| r15_5(Int32) = Load : &:r15_4, ~mu8_3 +# 15| mu15_6(Int32) = Store : &:r15_1, r15_5 #-----| Goto -> Block 5 # 17| Block 5 -# 17| r5_0(glval) = VariableAddress[o] : -# 17| r5_1(Object) = Load : &:r5_0, ~mu0_2 -# 17| r5_2(Is_A) = CheckedConvertOrNull : r5_1 -# 17| r5_3(Is_A) = Constant[0] : -# 17| r5_4(Boolean) = CompareNE : r5_2, r5_3 -# 17| v5_5(Void) = ConditionalBranch : r5_4 +# 17| r17_1(glval) = VariableAddress[o] : +# 17| r17_2(Object) = Load : &:r17_1, ~mu8_3 +# 17| r17_3(Is_A) = CheckedConvertOrNull : r17_2 +# 17| r17_4(Is_A) = Constant[0] : +# 17| r17_5(Boolean) = CompareNE : r17_3, r17_4 +# 17| v17_6(Void) = ConditionalBranch : r17_5 #-----| False -> Block 1 #-----| True -> Block 6 # 18| Block 6 -# 18| v6_0(Void) = NoOp : +# 18| v18_1(Void) = NoOp : #-----| Goto -> Block 1 jumps.cs: # 5| System.Void Jumps.Main() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = VariableAddress[i] : -# 7| r0_4(Int32) = Constant[1] : -# 7| mu0_5(Int32) = Store : &:r0_3, r0_4 +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 7| r7_1(glval) = VariableAddress[i] : +# 7| r7_2(Int32) = Constant[1] : +# 7| mu7_3(Int32) = Store : &:r7_1, r7_2 #-----| Goto -> Block 1 # 7| Block 1 -# 7| r1_0(glval) = VariableAddress[i] : -# 7| r1_1(Int32) = Load : &:r1_0, ~mu0_2 -# 7| r1_2(Int32) = Constant[10] : -# 7| r1_3(Boolean) = CompareLE : r1_1, r1_2 -# 7| v1_4(Void) = ConditionalBranch : r1_3 +# 7| r7_4(glval) = VariableAddress[i] : +# 7| r7_5(Int32) = Load : &:r7_4, ~mu5_3 +# 7| r7_6(Int32) = Constant[10] : +# 7| r7_7(Boolean) = CompareLE : r7_5, r7_6 +# 7| v7_8(Void) = ConditionalBranch : r7_7 #-----| False -> Block 7 #-----| True -> Block 2 # 9| Block 2 -# 9| r2_0(glval) = VariableAddress[i] : -# 9| r2_1(Int32) = Load : &:r2_0, ~mu0_2 -# 9| r2_2(Int32) = Constant[3] : -# 9| r2_3(Boolean) = CompareEQ : r2_1, r2_2 -# 9| v2_4(Void) = ConditionalBranch : r2_3 +# 9| r9_1(glval) = VariableAddress[i] : +# 9| r9_2(Int32) = Load : &:r9_1, ~mu5_3 +# 9| r9_3(Int32) = Constant[3] : +# 9| r9_4(Boolean) = CompareEQ : r9_2, r9_3 +# 9| v9_5(Void) = ConditionalBranch : r9_4 #-----| False -> Block 4 #-----| True -> Block 3 # 10| Block 3 -# 10| v3_0(Void) = NoOp : +# 10| v10_1(Void) = NoOp : #-----| Goto -> Block 19 # 11| Block 4 -# 11| r4_0(glval) = VariableAddress[i] : -# 11| r4_1(Int32) = Load : &:r4_0, ~mu0_2 -# 11| r4_2(Int32) = Constant[5] : -# 11| r4_3(Boolean) = CompareEQ : r4_1, r4_2 -# 11| v4_4(Void) = ConditionalBranch : r4_3 +# 11| r11_1(glval) = VariableAddress[i] : +# 11| r11_2(Int32) = Load : &:r11_1, ~mu5_3 +# 11| r11_3(Int32) = Constant[5] : +# 11| r11_4(Boolean) = CompareEQ : r11_2, r11_3 +# 11| v11_5(Void) = ConditionalBranch : r11_4 #-----| False -> Block 6 #-----| True -> Block 5 # 12| Block 5 -# 12| v5_0(Void) = NoOp : +# 12| v12_1(Void) = NoOp : #-----| Goto -> Block 7 # 13| Block 6 -# 13| r6_0() = FunctionAddress[WriteLine] : -# 13| r6_1(String) = StringConstant["BreakAndContinue"] : -# 13| v6_2(Void) = Call : func:r6_0, 0:r6_1 -# 13| mu6_3() = ^CallSideEffect : ~mu0_2 +# 13| r13_1() = FunctionAddress[WriteLine] : +# 13| r13_2(String) = StringConstant["BreakAndContinue"] : +# 13| v13_3(Void) = Call : func:r13_1, 0:r13_2 +# 13| mu13_4() = ^CallSideEffect : ~mu5_3 #-----| Goto -> Block 19 # 16| Block 7 -# 16| r7_0(glval) = VariableAddress[i] : -# 16| r7_1(Int32) = Constant[0] : -# 16| mu7_2(Int32) = Store : &:r7_0, r7_1 +# 16| r16_1(glval) = VariableAddress[i] : +# 16| r16_2(Int32) = Constant[0] : +# 16| mu16_3(Int32) = Store : &:r16_1, r16_2 #-----| Goto -> Block 8 # 16| Block 8 -# 16| r8_0(glval) = VariableAddress[i] : -# 16| r8_1(Int32) = Load : &:r8_0, ~mu0_2 -# 16| r8_2(Int32) = Constant[10] : -# 16| r8_3(Boolean) = CompareLT : r8_1, r8_2 -# 16| v8_4(Void) = ConditionalBranch : r8_3 +# 16| r16_4(glval) = VariableAddress[i] : +# 16| r16_5(Int32) = Load : &:r16_4, ~mu5_3 +# 16| r16_6(Int32) = Constant[10] : +# 16| r16_7(Boolean) = CompareLT : r16_5, r16_6 +# 16| v16_8(Void) = ConditionalBranch : r16_7 #-----| False -> Block 10 #-----| True -> Block 9 # 18| Block 9 -# 18| r9_0(glval) = VariableAddress[i] : -# 18| r9_1(Int32) = Load : &:r9_0, ~mu0_2 -# 18| r9_2(Int32) = Constant[1] : -# 18| r9_3(Int32) = Add : r9_1, r9_2 -# 18| mu9_4(Int32) = Store : &:r9_0, r9_3 -# 19| v9_5(Void) = NoOp : +# 18| r18_1(glval) = VariableAddress[i] : +# 18| r18_2(Int32) = Load : &:r18_1, ~mu5_3 +# 18| r18_3(Int32) = Constant[1] : +# 18| r18_4(Int32) = Add : r18_2, r18_3 +# 18| mu18_5(Int32) = Store : &:r18_1, r18_4 +# 19| v19_1(Void) = NoOp : #-----| Goto (back edge) -> Block 8 # 22| Block 10 -# 22| r10_0(glval) = VariableAddress[a] : -# 22| r10_1(Int32) = Constant[0] : -# 22| mu10_2(Int32) = Store : &:r10_0, r10_1 +# 22| r22_1(glval) = VariableAddress[a] : +# 22| r22_2(Int32) = Constant[0] : +# 22| mu22_3(Int32) = Store : &:r22_1, r22_2 #-----| Goto -> Block 11 # 23| Block 11 -# 23| r11_0(Boolean) = Constant[true] : -# 23| v11_1(Void) = ConditionalBranch : r11_0 +# 23| r23_1(Boolean) = Constant[true] : +# 23| v23_2(Void) = ConditionalBranch : r23_1 #-----| False -> Block 16 #-----| True -> Block 12 # 25| Block 12 -# 25| r12_0(glval) = VariableAddress[a] : -# 25| r12_1(Int32) = Load : &:r12_0, ~mu0_2 -# 25| r12_2(Int32) = Constant[1] : -# 25| r12_3(Int32) = Add : r12_1, r12_2 -# 25| mu12_4(Int32) = Store : &:r12_0, r12_3 -# 26| r12_5(glval) = VariableAddress[a] : -# 26| r12_6(Int32) = Load : &:r12_5, ~mu0_2 -# 26| r12_7(Int32) = Constant[5] : -# 26| r12_8(Boolean) = CompareEQ : r12_6, r12_7 -# 26| v12_9(Void) = ConditionalBranch : r12_8 +# 25| r25_1(glval) = VariableAddress[a] : +# 25| r25_2(Int32) = Load : &:r25_1, ~mu5_3 +# 25| r25_3(Int32) = Constant[1] : +# 25| r25_4(Int32) = Add : r25_2, r25_3 +# 25| mu25_5(Int32) = Store : &:r25_1, r25_4 +# 26| r26_1(glval) = VariableAddress[a] : +# 26| r26_2(Int32) = Load : &:r26_1, ~mu5_3 +# 26| r26_3(Int32) = Constant[5] : +# 26| r26_4(Boolean) = CompareEQ : r26_2, r26_3 +# 26| v26_5(Void) = ConditionalBranch : r26_4 #-----| False -> Block 14 #-----| True -> Block 13 # 27| Block 13 -# 27| v13_0(Void) = NoOp : +# 27| v27_1(Void) = NoOp : #-----| Goto (back edge) -> Block 11 # 28| Block 14 -# 28| r14_0(glval) = VariableAddress[a] : -# 28| r14_1(Int32) = Load : &:r14_0, ~mu0_2 -# 28| r14_2(Int32) = Constant[10] : -# 28| r14_3(Boolean) = CompareEQ : r14_1, r14_2 -# 28| v14_4(Void) = ConditionalBranch : r14_3 +# 28| r28_1(glval) = VariableAddress[a] : +# 28| r28_2(Int32) = Load : &:r28_1, ~mu5_3 +# 28| r28_3(Int32) = Constant[10] : +# 28| r28_4(Boolean) = CompareEQ : r28_2, r28_3 +# 28| v28_5(Void) = ConditionalBranch : r28_4 #-----| False (back edge) -> Block 11 #-----| True -> Block 15 # 29| Block 15 -# 29| v15_0(Void) = NoOp : +# 29| v29_1(Void) = NoOp : #-----| Goto -> Block 16 # 32| Block 16 -# 32| r16_0(glval) = VariableAddress[i] : -# 32| r16_1(Int32) = Constant[1] : -# 32| mu16_2(Int32) = Store : &:r16_0, r16_1 +# 32| r32_1(glval) = VariableAddress[i] : +# 32| r32_2(Int32) = Constant[1] : +# 32| mu32_3(Int32) = Store : &:r32_1, r32_2 #-----| Goto -> Block 18 # 32| Block 17 -# 32| r17_0(glval) = VariableAddress[i] : -# 32| r17_1(Int32) = Load : &:r17_0, ~mu0_2 -# 32| r17_2(Int32) = Constant[1] : -# 32| r17_3(Int32) = Add : r17_1, r17_2 -# 32| mu17_4(Int32) = Store : &:r17_0, r17_3 +# 32| r32_4(glval) = VariableAddress[i] : +# 32| r32_5(Int32) = Load : &:r32_4, ~mu5_3 +# 32| r32_6(Int32) = Constant[1] : +# 32| r32_7(Int32) = Add : r32_5, r32_6 +# 32| mu32_8(Int32) = Store : &:r32_4, r32_7 #-----| Goto (back edge) -> Block 18 # 32| Block 18 -# 32| r18_0(glval) = VariableAddress[i] : -# 32| r18_1(Int32) = Load : &:r18_0, ~mu0_2 -# 32| r18_2(Int32) = Constant[10] : -# 32| r18_3(Boolean) = CompareLE : r18_1, r18_2 -# 32| v18_4(Void) = ConditionalBranch : r18_3 +# 32| r32_9(glval) = VariableAddress[i] : +# 32| r32_10(Int32) = Load : &:r32_9, ~mu5_3 +# 32| r32_11(Int32) = Constant[10] : +# 32| r32_12(Boolean) = CompareLE : r32_10, r32_11 +# 32| v32_13(Void) = ConditionalBranch : r32_12 #-----| False -> Block 22 #-----| True -> Block 20 # 7| Block 19 -# 7| r19_0(glval) = VariableAddress[i] : -# 7| r19_1(Int32) = Load : &:r19_0, ~mu0_2 -# 7| r19_2(Int32) = Constant[1] : -# 7| r19_3(Int32) = Add : r19_1, r19_2 -# 7| mu19_4(Int32) = Store : &:r19_0, r19_3 +# 7| r7_9(glval) = VariableAddress[i] : +# 7| r7_10(Int32) = Load : &:r7_9, ~mu5_3 +# 7| r7_11(Int32) = Constant[1] : +# 7| r7_12(Int32) = Add : r7_10, r7_11 +# 7| mu7_13(Int32) = Store : &:r7_9, r7_12 #-----| Goto (back edge) -> Block 1 # 34| Block 20 -# 34| r20_0(glval) = VariableAddress[i] : -# 34| r20_1(Int32) = Load : &:r20_0, ~mu0_2 -# 34| r20_2(Int32) = Constant[5] : -# 34| r20_3(Boolean) = CompareEQ : r20_1, r20_2 -# 34| v20_4(Void) = ConditionalBranch : r20_3 +# 34| r34_1(glval) = VariableAddress[i] : +# 34| r34_2(Int32) = Load : &:r34_1, ~mu5_3 +# 34| r34_3(Int32) = Constant[5] : +# 34| r34_4(Boolean) = CompareEQ : r34_2, r34_3 +# 34| v34_5(Void) = ConditionalBranch : r34_4 #-----| False -> Block 17 #-----| True -> Block 21 # 35| Block 21 -# 35| v21_0(Void) = NoOp : +# 35| v35_1(Void) = NoOp : #-----| Goto -> Block 22 # 37| Block 22 -# 37| v22_0(Void) = NoOp : -# 38| r22_1() = FunctionAddress[WriteLine] : -# 38| r22_2(String) = StringConstant["Done"] : -# 38| v22_3(Void) = Call : func:r22_1, 0:r22_2 -# 38| mu22_4() = ^CallSideEffect : ~mu0_2 -# 5| v22_5(Void) = ReturnVoid : -# 5| v22_6(Void) = UnmodeledUse : mu* -# 5| v22_7(Void) = AliasedUse : ~mu0_2 -# 5| v22_8(Void) = ExitFunction : +# 37| v37_1(Void) = NoOp : +# 38| r38_1() = FunctionAddress[WriteLine] : +# 38| r38_2(String) = StringConstant["Done"] : +# 38| v38_3(Void) = Call : func:r38_1, 0:r38_2 +# 38| mu38_4() = ^CallSideEffect : ~mu5_3 +# 5| v5_4(Void) = ReturnVoid : +# 5| v5_5(Void) = UnmodeledUse : mu* +# 5| v5_6(Void) = AliasedUse : ~mu5_3 +# 5| v5_7(Void) = ExitFunction : lock.cs: # 5| System.Void LockTest.A() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = VariableAddress[object] : -# 7| r0_4(Object) = NewObj : -# 7| r0_5() = FunctionAddress[Object] : -# 7| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 7| mu0_7() = ^CallSideEffect : ~mu0_2 -# 7| mu0_8(Object) = Store : &:r0_3, r0_4 -# 8| r0_9(glval) = VariableAddress[#temp8:9] : -# 8| r0_10(glval) = VariableAddress[object] : -# 8| r0_11(Object) = Load : &:r0_10, ~mu0_2 -# 8| mu0_12(Object) = Store : &:r0_9, r0_11 -# 8| r0_13(glval) = VariableAddress[#temp8:9] : -# 8| r0_14(Boolean) = Constant[false] : -# 8| mu0_15(Boolean) = Store : &:r0_13, r0_14 -# 8| r0_16() = FunctionAddress[Enter] : -# 8| r0_17(glval) = VariableAddress[#temp8:9] : -# 8| r0_18(Object) = Load : &:r0_17, ~mu0_2 -# 8| r0_19(glval) = VariableAddress[#temp8:9] : -# 8| v0_20(Void) = Call : func:r0_16, 0:r0_18, 1:r0_19 -# 8| mu0_21() = ^CallSideEffect : ~mu0_2 -# 10| r0_22() = FunctionAddress[WriteLine] : -# 10| r0_23(glval) = VariableAddress[object] : -# 10| r0_24(Object) = Load : &:r0_23, ~mu0_2 -# 10| r0_25() = FunctionAddress[ToString] : -# 10| r0_26(String) = Call : func:r0_25, this:r0_24 -# 10| mu0_27() = ^CallSideEffect : ~mu0_2 -# 10| v0_28(Void) = Call : func:r0_22, 0:r0_26 -# 10| mu0_29() = ^CallSideEffect : ~mu0_2 -# 8| r0_30(glval) = VariableAddress[#temp8:9] : -# 8| r0_31(Boolean) = Load : &:r0_30, ~mu0_2 -# 8| v0_32(Void) = ConditionalBranch : r0_31 +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 7| r7_1(glval) = VariableAddress[object] : +# 7| r7_2(Object) = NewObj : +# 7| r7_3() = FunctionAddress[Object] : +# 7| v7_4(Void) = Call : func:r7_3, this:r7_2 +# 7| mu7_5() = ^CallSideEffect : ~mu5_3 +# 7| mu7_6(Object) = Store : &:r7_1, r7_2 +# 8| r8_1(glval) = VariableAddress[#temp8:9] : +# 8| r8_2(glval) = VariableAddress[object] : +# 8| r8_3(Object) = Load : &:r8_2, ~mu5_3 +# 8| mu8_4(Object) = Store : &:r8_1, r8_3 +# 8| r8_5(glval) = VariableAddress[#temp8:9] : +# 8| r8_6(Boolean) = Constant[false] : +# 8| mu8_7(Boolean) = Store : &:r8_5, r8_6 +# 8| r8_8() = FunctionAddress[Enter] : +# 8| r8_9(glval) = VariableAddress[#temp8:9] : +# 8| r8_10(Object) = Load : &:r8_9, ~mu5_3 +# 8| r8_11(glval) = VariableAddress[#temp8:9] : +# 8| v8_12(Void) = Call : func:r8_8, 0:r8_10, 1:r8_11 +# 8| mu8_13() = ^CallSideEffect : ~mu5_3 +# 10| r10_1() = FunctionAddress[WriteLine] : +# 10| r10_2(glval) = VariableAddress[object] : +# 10| r10_3(Object) = Load : &:r10_2, ~mu5_3 +# 10| r10_4() = FunctionAddress[ToString] : +# 10| r10_5(String) = Call : func:r10_4, this:r10_3 +# 10| mu10_6() = ^CallSideEffect : ~mu5_3 +# 10| v10_7(Void) = Call : func:r10_1, 0:r10_5 +# 10| mu10_8() = ^CallSideEffect : ~mu5_3 +# 8| r8_14(glval) = VariableAddress[#temp8:9] : +# 8| r8_15(Boolean) = Load : &:r8_14, ~mu5_3 +# 8| v8_16(Void) = ConditionalBranch : r8_15 #-----| False -> Block 1 #-----| True -> Block 2 # 5| Block 1 -# 5| v1_0(Void) = ReturnVoid : -# 5| v1_1(Void) = UnmodeledUse : mu* -# 5| v1_2(Void) = AliasedUse : ~mu0_2 -# 5| v1_3(Void) = ExitFunction : +# 5| v5_4(Void) = ReturnVoid : +# 5| v5_5(Void) = UnmodeledUse : mu* +# 5| v5_6(Void) = AliasedUse : ~mu5_3 +# 5| v5_7(Void) = ExitFunction : # 8| Block 2 -# 8| r2_0() = FunctionAddress[Exit] : -# 8| r2_1(glval) = VariableAddress[#temp8:9] : -# 8| r2_2(Object) = Load : &:r2_1, ~mu0_2 -# 8| v2_3(Void) = Call : func:r2_0, 0:r2_2 -# 8| mu2_4() = ^CallSideEffect : ~mu0_2 +# 8| r8_17() = FunctionAddress[Exit] : +# 8| r8_18(glval) = VariableAddress[#temp8:9] : +# 8| r8_19(Object) = Load : &:r8_18, ~mu5_3 +# 8| v8_20(Void) = Call : func:r8_17, 0:r8_19 +# 8| mu8_21() = ^CallSideEffect : ~mu5_3 #-----| Goto -> Block 1 obj_creation.cs: # 7| System.Void ObjCreation.MyClass..ctor() # 7| Block 0 -# 7| v0_0(Void) = EnterFunction : -# 7| mu0_1() = AliasedDefinition : -# 7| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = InitializeThis : -# 8| v0_4(Void) = NoOp : -# 7| v0_5(Void) = ReturnVoid : -# 7| v0_6(Void) = UnmodeledUse : mu* -# 7| v0_7(Void) = AliasedUse : ~mu0_2 -# 7| v0_8(Void) = ExitFunction : +# 7| v7_1(Void) = EnterFunction : +# 7| mu7_2() = AliasedDefinition : +# 7| mu7_3() = UnmodeledDefinition : +# 7| r7_4(glval) = InitializeThis : +# 8| v8_1(Void) = NoOp : +# 7| v7_5(Void) = ReturnVoid : +# 7| v7_6(Void) = UnmodeledUse : mu* +# 7| v7_7(Void) = AliasedUse : ~mu7_3 +# 7| v7_8(Void) = ExitFunction : # 11| System.Void ObjCreation.MyClass..ctor(System.Int32) # 11| Block 0 -# 11| v0_0(Void) = EnterFunction : -# 11| mu0_1() = AliasedDefinition : -# 11| mu0_2() = UnmodeledDefinition : -# 11| r0_3(glval) = InitializeThis : -# 11| r0_4(glval) = VariableAddress[_x] : -# 11| mu0_5(Int32) = InitializeParameter[_x] : &:r0_4 -# 13| r0_6(glval) = VariableAddress[_x] : -# 13| r0_7(Int32) = Load : &:r0_6, ~mu0_2 -# 13| r0_8(MyClass) = CopyValue : r0_3 -# 13| r0_9(glval) = FieldAddress[x] : r0_8 -# 13| mu0_10(Int32) = Store : &:r0_9, r0_7 -# 11| v0_11(Void) = ReturnVoid : -# 11| v0_12(Void) = UnmodeledUse : mu* -# 11| v0_13(Void) = AliasedUse : ~mu0_2 -# 11| v0_14(Void) = ExitFunction : +# 11| v11_1(Void) = EnterFunction : +# 11| mu11_2() = AliasedDefinition : +# 11| mu11_3() = UnmodeledDefinition : +# 11| r11_4(glval) = InitializeThis : +# 11| r11_5(glval) = VariableAddress[_x] : +# 11| mu11_6(Int32) = InitializeParameter[_x] : &:r11_5 +# 13| r13_1(glval) = VariableAddress[_x] : +# 13| r13_2(Int32) = Load : &:r13_1, ~mu11_3 +# 13| r13_3(MyClass) = CopyValue : r11_4 +# 13| r13_4(glval) = FieldAddress[x] : r13_3 +# 13| mu13_5(Int32) = Store : &:r13_4, r13_2 +# 11| v11_7(Void) = ReturnVoid : +# 11| v11_8(Void) = UnmodeledUse : mu* +# 11| v11_9(Void) = AliasedUse : ~mu11_3 +# 11| v11_10(Void) = ExitFunction : # 17| System.Void ObjCreation.SomeFun(ObjCreation.MyClass) # 17| Block 0 -# 17| v0_0(Void) = EnterFunction : -# 17| mu0_1() = AliasedDefinition : -# 17| mu0_2() = UnmodeledDefinition : -# 17| r0_3(glval) = VariableAddress[x] : -# 17| mu0_4(MyClass) = InitializeParameter[x] : &:r0_3 -# 18| v0_5(Void) = NoOp : -# 17| v0_6(Void) = ReturnVoid : -# 17| v0_7(Void) = UnmodeledUse : mu* -# 17| v0_8(Void) = AliasedUse : ~mu0_2 -# 17| v0_9(Void) = ExitFunction : +# 17| v17_1(Void) = EnterFunction : +# 17| mu17_2() = AliasedDefinition : +# 17| mu17_3() = UnmodeledDefinition : +# 17| r17_4(glval) = VariableAddress[x] : +# 17| mu17_5(MyClass) = InitializeParameter[x] : &:r17_4 +# 18| v18_1(Void) = NoOp : +# 17| v17_6(Void) = ReturnVoid : +# 17| v17_7(Void) = UnmodeledUse : mu* +# 17| v17_8(Void) = AliasedUse : ~mu17_3 +# 17| v17_9(Void) = ExitFunction : # 21| System.Void ObjCreation.Main() # 21| Block 0 -# 21| v0_0(Void) = EnterFunction : -# 21| mu0_1() = AliasedDefinition : -# 21| mu0_2() = UnmodeledDefinition : -# 23| r0_3(glval) = VariableAddress[obj] : -# 23| r0_4(MyClass) = NewObj : -# 23| r0_5() = FunctionAddress[MyClass] : -# 23| r0_6(Int32) = Constant[100] : -# 23| v0_7(Void) = Call : func:r0_5, this:r0_4, 0:r0_6 -# 23| mu0_8() = ^CallSideEffect : ~mu0_2 -# 23| mu0_9(MyClass) = Store : &:r0_3, r0_4 -# 24| r0_10(glval) = VariableAddress[obj_initlist] : -# 24| r0_11(MyClass) = NewObj : -# 24| r0_12() = FunctionAddress[MyClass] : -# 24| v0_13(Void) = Call : func:r0_12, this:r0_11 -# 24| mu0_14() = ^CallSideEffect : ~mu0_2 -# 24| r0_15(Int32) = Constant[101] : -# 24| r0_16(glval) = FieldAddress[x] : r0_11 -# 24| mu0_17(Int32) = Store : &:r0_16, r0_15 -# 24| mu0_18(MyClass) = Store : &:r0_10, r0_11 -# 25| r0_19(glval) = VariableAddress[a] : -# 25| r0_20(glval) = VariableAddress[obj] : -# 25| r0_21(MyClass) = Load : &:r0_20, ~mu0_2 -# 25| r0_22(glval) = FieldAddress[x] : r0_21 -# 25| r0_23(Int32) = Load : &:r0_22, ~mu0_2 -# 25| mu0_24(Int32) = Store : &:r0_19, r0_23 -# 27| r0_25() = FunctionAddress[SomeFun] : -# 27| r0_26(MyClass) = NewObj : -# 27| r0_27() = FunctionAddress[MyClass] : -# 27| r0_28(Int32) = Constant[100] : -# 27| v0_29(Void) = Call : func:r0_27, this:r0_26, 0:r0_28 -# 27| mu0_30() = ^CallSideEffect : ~mu0_2 -# 27| v0_31(Void) = Call : func:r0_25, 0:r0_26 -# 27| mu0_32() = ^CallSideEffect : ~mu0_2 -# 21| v0_33(Void) = ReturnVoid : -# 21| v0_34(Void) = UnmodeledUse : mu* -# 21| v0_35(Void) = AliasedUse : ~mu0_2 -# 21| v0_36(Void) = ExitFunction : +# 21| v21_1(Void) = EnterFunction : +# 21| mu21_2() = AliasedDefinition : +# 21| mu21_3() = UnmodeledDefinition : +# 23| r23_1(glval) = VariableAddress[obj] : +# 23| r23_2(MyClass) = NewObj : +# 23| r23_3() = FunctionAddress[MyClass] : +# 23| r23_4(Int32) = Constant[100] : +# 23| v23_5(Void) = Call : func:r23_3, this:r23_2, 0:r23_4 +# 23| mu23_6() = ^CallSideEffect : ~mu21_3 +# 23| mu23_7(MyClass) = Store : &:r23_1, r23_2 +# 24| r24_1(glval) = VariableAddress[obj_initlist] : +# 24| r24_2(MyClass) = NewObj : +# 24| r24_3() = FunctionAddress[MyClass] : +# 24| v24_4(Void) = Call : func:r24_3, this:r24_2 +# 24| mu24_5() = ^CallSideEffect : ~mu21_3 +# 24| r24_6(Int32) = Constant[101] : +# 24| r24_7(glval) = FieldAddress[x] : r24_2 +# 24| mu24_8(Int32) = Store : &:r24_7, r24_6 +# 24| mu24_9(MyClass) = Store : &:r24_1, r24_2 +# 25| r25_1(glval) = VariableAddress[a] : +# 25| r25_2(glval) = VariableAddress[obj] : +# 25| r25_3(MyClass) = Load : &:r25_2, ~mu21_3 +# 25| r25_4(glval) = FieldAddress[x] : r25_3 +# 25| r25_5(Int32) = Load : &:r25_4, ~mu21_3 +# 25| mu25_6(Int32) = Store : &:r25_1, r25_5 +# 27| r27_1() = FunctionAddress[SomeFun] : +# 27| r27_2(MyClass) = NewObj : +# 27| r27_3() = FunctionAddress[MyClass] : +# 27| r27_4(Int32) = Constant[100] : +# 27| v27_5(Void) = Call : func:r27_3, this:r27_2, 0:r27_4 +# 27| mu27_6() = ^CallSideEffect : ~mu21_3 +# 27| v27_7(Void) = Call : func:r27_1, 0:r27_2 +# 27| mu27_8() = ^CallSideEffect : ~mu21_3 +# 21| v21_4(Void) = ReturnVoid : +# 21| v21_5(Void) = UnmodeledUse : mu* +# 21| v21_6(Void) = AliasedUse : ~mu21_3 +# 21| v21_7(Void) = ExitFunction : pointers.cs: # 3| System.Void Pointers.addone(System.Int32[]) # 3| Block 0 -# 3| v0_0(Void) = EnterFunction : -# 3| mu0_1() = AliasedDefinition : -# 3| mu0_2() = UnmodeledDefinition : -# 3| r0_3(glval) = VariableAddress[arr] : -# 3| mu0_4(Int32[]) = InitializeParameter[arr] : &:r0_3 -# 5| r0_5(glval) = VariableAddress[length] : -# 5| r0_6(glval) = VariableAddress[arr] : -# 5| r0_7(Int32[]) = Load : &:r0_6, ~mu0_2 -# 5| r0_8() = FunctionAddress[get_Length] : -# 5| r0_9(Int32) = Call : func:r0_8, this:r0_7 -# 5| mu0_10() = ^CallSideEffect : ~mu0_2 -# 5| mu0_11(Int32) = Store : &:r0_5, r0_9 -# 6| r0_12(glval) = VariableAddress[b] : -# 6| r0_13(glval) = VariableAddress[arr] : -# 6| r0_14(Int32[]) = Load : &:r0_13, ~mu0_2 -# 6| r0_15(Int32*) = Convert : r0_14 -# 6| mu0_16(Int32*) = Store : &:r0_12, r0_14 -# 8| r0_17(glval) = VariableAddress[p] : -# 8| r0_18(glval) = VariableAddress[b] : -# 8| r0_19(Int32*) = Load : &:r0_18, ~mu0_2 -# 8| mu0_20(Int32*) = Store : &:r0_17, r0_19 -# 9| r0_21(glval) = VariableAddress[i] : -# 9| r0_22(Int32) = Constant[0] : -# 9| mu0_23(Int32) = Store : &:r0_21, r0_22 +# 3| v3_1(Void) = EnterFunction : +# 3| mu3_2() = AliasedDefinition : +# 3| mu3_3() = UnmodeledDefinition : +# 3| r3_4(glval) = VariableAddress[arr] : +# 3| mu3_5(Int32[]) = InitializeParameter[arr] : &:r3_4 +# 5| r5_1(glval) = VariableAddress[length] : +# 5| r5_2(glval) = VariableAddress[arr] : +# 5| r5_3(Int32[]) = Load : &:r5_2, ~mu3_3 +# 5| r5_4() = FunctionAddress[get_Length] : +# 5| r5_5(Int32) = Call : func:r5_4, this:r5_3 +# 5| mu5_6() = ^CallSideEffect : ~mu3_3 +# 5| mu5_7(Int32) = Store : &:r5_1, r5_5 +# 6| r6_1(glval) = VariableAddress[b] : +# 6| r6_2(glval) = VariableAddress[arr] : +# 6| r6_3(Int32[]) = Load : &:r6_2, ~mu3_3 +# 6| r6_4(Int32*) = Convert : r6_3 +# 6| mu6_5(Int32*) = Store : &:r6_1, r6_3 +# 8| r8_1(glval) = VariableAddress[p] : +# 8| r8_2(glval) = VariableAddress[b] : +# 8| r8_3(Int32*) = Load : &:r8_2, ~mu3_3 +# 8| mu8_4(Int32*) = Store : &:r8_1, r8_3 +# 9| r9_1(glval) = VariableAddress[i] : +# 9| r9_2(Int32) = Constant[0] : +# 9| mu9_3(Int32) = Store : &:r9_1, r9_2 #-----| Goto -> Block 2 # 3| Block 1 -# 3| v1_0(Void) = ReturnVoid : -# 3| v1_1(Void) = UnmodeledUse : mu* -# 3| v1_2(Void) = AliasedUse : ~mu0_2 -# 3| v1_3(Void) = ExitFunction : +# 3| v3_6(Void) = ReturnVoid : +# 3| v3_7(Void) = UnmodeledUse : mu* +# 3| v3_8(Void) = AliasedUse : ~mu3_3 +# 3| v3_9(Void) = ExitFunction : # 9| Block 2 -# 9| r2_0(glval) = VariableAddress[i] : -# 9| r2_1(Int32) = Load : &:r2_0, ~mu0_2 -# 9| r2_2(glval) = VariableAddress[length] : -# 9| r2_3(Int32) = Load : &:r2_2, ~mu0_2 -# 9| r2_4(Boolean) = CompareLT : r2_1, r2_3 -# 9| v2_5(Void) = ConditionalBranch : r2_4 +# 9| r9_4(glval) = VariableAddress[i] : +# 9| r9_5(Int32) = Load : &:r9_4, ~mu3_3 +# 9| r9_6(glval) = VariableAddress[length] : +# 9| r9_7(Int32) = Load : &:r9_6, ~mu3_3 +# 9| r9_8(Boolean) = CompareLT : r9_5, r9_7 +# 9| v9_9(Void) = ConditionalBranch : r9_8 #-----| False -> Block 1 #-----| True -> Block 3 # 10| Block 3 -# 10| r3_0(Int32) = Constant[1] : -# 10| r3_1(glval) = VariableAddress[p] : -# 10| r3_2(Int32*) = Load : &:r3_1, ~mu0_2 -# 10| r3_3(Int32) = Constant[1] : -# 10| r3_4(Int32*) = PointerAdd[4] : r3_2, r3_3 -# 10| mu3_5(Int32*) = Store : &:r3_1, r3_4 -# 10| r3_6(Int32) = Load : &:r3_2, ~mu0_2 -# 10| r3_7(Int32) = Add : r3_6, r3_0 -# 10| mu3_8(Int32) = Store : &:r3_2, r3_7 -# 9| r3_9(glval) = VariableAddress[i] : -# 9| r3_10(Int32) = Load : &:r3_9, ~mu0_2 -# 9| r3_11(Int32) = Constant[1] : -# 9| r3_12(Int32) = Add : r3_10, r3_11 -# 9| mu3_13(Int32) = Store : &:r3_9, r3_12 +# 10| r10_1(Int32) = Constant[1] : +# 10| r10_2(glval) = VariableAddress[p] : +# 10| r10_3(Int32*) = Load : &:r10_2, ~mu3_3 +# 10| r10_4(Int32) = Constant[1] : +# 10| r10_5(Int32*) = PointerAdd[4] : r10_3, r10_4 +# 10| mu10_6(Int32*) = Store : &:r10_2, r10_5 +# 10| r10_7(Int32) = Load : &:r10_3, ~mu3_3 +# 10| r10_8(Int32) = Add : r10_7, r10_1 +# 10| mu10_9(Int32) = Store : &:r10_3, r10_8 +# 9| r9_10(glval) = VariableAddress[i] : +# 9| r9_11(Int32) = Load : &:r9_10, ~mu3_3 +# 9| r9_12(Int32) = Constant[1] : +# 9| r9_13(Int32) = Add : r9_11, r9_12 +# 9| mu9_14(Int32) = Store : &:r9_10, r9_13 #-----| Goto (back edge) -> Block 2 # 25| System.Void Pointers.Main() # 25| Block 0 -# 25| v0_0(Void) = EnterFunction : -# 25| mu0_1() = AliasedDefinition : -# 25| mu0_2() = UnmodeledDefinition : -# 26| r0_3(glval) = VariableAddress[o] : -# 26| r0_4(MyClass) = NewObj : -# 26| r0_5() = FunctionAddress[MyClass] : -# 26| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 26| mu0_7() = ^CallSideEffect : ~mu0_2 -# 26| mu0_8(MyClass) = Store : &:r0_3, r0_4 -# 27| r0_9(glval) = VariableAddress[s] : -# 27| r0_10(MyStruct) = NewObj : -# 27| r0_11() = FunctionAddress[MyStruct] : -# 27| v0_12(Void) = Call : func:r0_11, this:r0_10 -# 27| mu0_13() = ^CallSideEffect : ~mu0_2 -# 27| r0_14(MyStruct) = Load : &:r0_10, ~mu0_2 -# 27| mu0_15(MyStruct) = Store : &:r0_9, r0_14 -# 30| r0_16(glval) = VariableAddress[p] : -# 30| r0_17(glval) = VariableAddress[o] : -# 30| r0_18(MyClass) = Load : &:r0_17, ~mu0_2 -# 30| r0_19(glval) = FieldAddress[fld1] : r0_18 -# 30| mu0_20(Int32*) = Store : &:r0_16, r0_19 -# 30| r0_21(glval) = VariableAddress[q] : -# 30| r0_22(glval) = VariableAddress[o] : -# 30| r0_23(MyClass) = Load : &:r0_22, ~mu0_2 -# 30| r0_24(glval) = FieldAddress[fld2] : r0_23 -# 30| mu0_25(Int32*) = Store : &:r0_21, r0_24 -# 32| r0_26(Int32) = Constant[0] : -# 32| r0_27(glval) = VariableAddress[p] : -# 32| r0_28(Int32*) = Load : &:r0_27, ~mu0_2 -# 32| mu0_29(Int32) = Store : &:r0_28, r0_26 -# 33| r0_30(Int32) = Constant[0] : -# 33| r0_31(glval) = VariableAddress[q] : -# 33| r0_32(Int32*) = Load : &:r0_31, ~mu0_2 -# 33| mu0_33(Int32) = Store : &:r0_32, r0_30 -# 34| r0_34(glval) = VariableAddress[r] : -# 34| r0_35(glval) = VariableAddress[s] : -# 34| mu0_36(MyStruct*) = Store : &:r0_34, r0_35 -# 35| r0_37(Int32) = Constant[0] : -# 35| r0_38(glval) = VariableAddress[r] : -# 35| r0_39(MyStruct*) = Load : &:r0_38, ~mu0_2 -# 35| r0_40(MyStruct) = Load : &:r0_39, ~mu0_2 -# 35| r0_41(glval) = FieldAddress[fld] : r0_40 -# 35| mu0_42(Int32) = Store : &:r0_41, r0_37 -# 39| r0_43(glval) = VariableAddress[arr] : -# 39| mu0_44(Int32[]) = Uninitialized[arr] : &:r0_43 -# 39| r0_45(Int32) = Constant[0] : -# 39| r0_46(glval) = PointerAdd[4] : r0_43, r0_45 -# 39| r0_47(Int32) = Constant[1] : -# 39| mu0_48(Int32) = Store : &:r0_46, r0_47 -# 39| r0_49(Int32) = Constant[1] : -# 39| r0_50(glval) = PointerAdd[4] : r0_43, r0_49 -# 39| r0_51(Int32) = Constant[2] : -# 39| mu0_52(Int32) = Store : &:r0_50, r0_51 -# 39| r0_53(Int32) = Constant[2] : -# 39| r0_54(glval) = PointerAdd[4] : r0_43, r0_53 -# 39| r0_55(Int32) = Constant[3] : -# 39| mu0_56(Int32) = Store : &:r0_54, r0_55 -# 40| r0_57() = FunctionAddress[addone] : -# 40| r0_58(glval) = VariableAddress[arr] : -# 40| r0_59(Int32[]) = Load : &:r0_58, ~mu0_2 -# 40| v0_60(Void) = Call : func:r0_57, 0:r0_59 -# 40| mu0_61() = ^CallSideEffect : ~mu0_2 -# 25| v0_62(Void) = ReturnVoid : -# 25| v0_63(Void) = UnmodeledUse : mu* -# 25| v0_64(Void) = AliasedUse : ~mu0_2 -# 25| v0_65(Void) = ExitFunction : +# 25| v25_1(Void) = EnterFunction : +# 25| mu25_2() = AliasedDefinition : +# 25| mu25_3() = UnmodeledDefinition : +# 26| r26_1(glval) = VariableAddress[o] : +# 26| r26_2(MyClass) = NewObj : +# 26| r26_3() = FunctionAddress[MyClass] : +# 26| v26_4(Void) = Call : func:r26_3, this:r26_2 +# 26| mu26_5() = ^CallSideEffect : ~mu25_3 +# 26| mu26_6(MyClass) = Store : &:r26_1, r26_2 +# 27| r27_1(glval) = VariableAddress[s] : +# 27| r27_2(MyStruct) = NewObj : +# 27| r27_3() = FunctionAddress[MyStruct] : +# 27| v27_4(Void) = Call : func:r27_3, this:r27_2 +# 27| mu27_5() = ^CallSideEffect : ~mu25_3 +# 27| r27_6(MyStruct) = Load : &:r27_2, ~mu25_3 +# 27| mu27_7(MyStruct) = Store : &:r27_1, r27_6 +# 30| r30_1(glval) = VariableAddress[p] : +# 30| r30_2(glval) = VariableAddress[o] : +# 30| r30_3(MyClass) = Load : &:r30_2, ~mu25_3 +# 30| r30_4(glval) = FieldAddress[fld1] : r30_3 +# 30| mu30_5(Int32*) = Store : &:r30_1, r30_4 +# 30| r30_6(glval) = VariableAddress[q] : +# 30| r30_7(glval) = VariableAddress[o] : +# 30| r30_8(MyClass) = Load : &:r30_7, ~mu25_3 +# 30| r30_9(glval) = FieldAddress[fld2] : r30_8 +# 30| mu30_10(Int32*) = Store : &:r30_6, r30_9 +# 32| r32_1(Int32) = Constant[0] : +# 32| r32_2(glval) = VariableAddress[p] : +# 32| r32_3(Int32*) = Load : &:r32_2, ~mu25_3 +# 32| mu32_4(Int32) = Store : &:r32_3, r32_1 +# 33| r33_1(Int32) = Constant[0] : +# 33| r33_2(glval) = VariableAddress[q] : +# 33| r33_3(Int32*) = Load : &:r33_2, ~mu25_3 +# 33| mu33_4(Int32) = Store : &:r33_3, r33_1 +# 34| r34_1(glval) = VariableAddress[r] : +# 34| r34_2(glval) = VariableAddress[s] : +# 34| mu34_3(MyStruct*) = Store : &:r34_1, r34_2 +# 35| r35_1(Int32) = Constant[0] : +# 35| r35_2(glval) = VariableAddress[r] : +# 35| r35_3(MyStruct*) = Load : &:r35_2, ~mu25_3 +# 35| r35_4(MyStruct) = Load : &:r35_3, ~mu25_3 +# 35| r35_5(glval) = FieldAddress[fld] : r35_4 +# 35| mu35_6(Int32) = Store : &:r35_5, r35_1 +# 39| r39_1(glval) = VariableAddress[arr] : +# 39| mu39_2(Int32[]) = Uninitialized[arr] : &:r39_1 +# 39| r39_3(Int32) = Constant[0] : +# 39| r39_4(glval) = PointerAdd[4] : r39_1, r39_3 +# 39| r39_5(Int32) = Constant[1] : +# 39| mu39_6(Int32) = Store : &:r39_4, r39_5 +# 39| r39_7(Int32) = Constant[1] : +# 39| r39_8(glval) = PointerAdd[4] : r39_1, r39_7 +# 39| r39_9(Int32) = Constant[2] : +# 39| mu39_10(Int32) = Store : &:r39_8, r39_9 +# 39| r39_11(Int32) = Constant[2] : +# 39| r39_12(glval) = PointerAdd[4] : r39_1, r39_11 +# 39| r39_13(Int32) = Constant[3] : +# 39| mu39_14(Int32) = Store : &:r39_12, r39_13 +# 40| r40_1() = FunctionAddress[addone] : +# 40| r40_2(glval) = VariableAddress[arr] : +# 40| r40_3(Int32[]) = Load : &:r40_2, ~mu25_3 +# 40| v40_4(Void) = Call : func:r40_1, 0:r40_3 +# 40| mu40_5() = ^CallSideEffect : ~mu25_3 +# 25| v25_4(Void) = ReturnVoid : +# 25| v25_5(Void) = UnmodeledUse : mu* +# 25| v25_6(Void) = AliasedUse : ~mu25_3 +# 25| v25_7(Void) = ExitFunction : prop.cs: # 7| System.Int32 PropClass.get_Prop() # 7| Block 0 -# 7| v0_0(Void) = EnterFunction : -# 7| mu0_1() = AliasedDefinition : -# 7| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = InitializeThis : -# 9| r0_4(glval) = VariableAddress[#return] : -# 9| r0_5(PropClass) = CopyValue : r0_3 -# 9| r0_6() = FunctionAddress[func] : -# 9| r0_7(Int32) = Call : func:r0_6, this:r0_5 -# 9| mu0_8() = ^CallSideEffect : ~mu0_2 -# 9| mu0_9(Int32) = Store : &:r0_4, r0_7 -# 7| r0_10(glval) = VariableAddress[#return] : -# 7| v0_11(Void) = ReturnValue : &:r0_10, ~mu0_2 -# 7| v0_12(Void) = UnmodeledUse : mu* -# 7| v0_13(Void) = AliasedUse : ~mu0_2 -# 7| v0_14(Void) = ExitFunction : +# 7| v7_1(Void) = EnterFunction : +# 7| mu7_2() = AliasedDefinition : +# 7| mu7_3() = UnmodeledDefinition : +# 7| r7_4(glval) = InitializeThis : +# 9| r9_1(glval) = VariableAddress[#return] : +# 9| r9_2(PropClass) = CopyValue : r7_4 +# 9| r9_3() = FunctionAddress[func] : +# 9| r9_4(Int32) = Call : func:r9_3, this:r9_2 +# 9| mu9_5() = ^CallSideEffect : ~mu7_3 +# 9| mu9_6(Int32) = Store : &:r9_1, r9_4 +# 7| r7_5(glval) = VariableAddress[#return] : +# 7| v7_6(Void) = ReturnValue : &:r7_5, ~mu7_3 +# 7| v7_7(Void) = UnmodeledUse : mu* +# 7| v7_8(Void) = AliasedUse : ~mu7_3 +# 7| v7_9(Void) = ExitFunction : # 12| System.Void PropClass.set_Prop(System.Int32) # 12| Block 0 -# 12| v0_0(Void) = EnterFunction : -# 12| mu0_1() = AliasedDefinition : -# 12| mu0_2() = UnmodeledDefinition : -# 12| r0_3(glval) = InitializeThis : -# 12| r0_4(glval) = VariableAddress[value] : -# 12| mu0_5(Int32) = InitializeParameter[value] : &:r0_4 -# 14| r0_6(glval) = VariableAddress[value] : -# 14| r0_7(Int32) = Load : &:r0_6, ~mu0_2 -# 14| r0_8(glval) = VariableAddress[prop] : -# 14| mu0_9(Int32) = Store : &:r0_8, r0_7 -# 12| v0_10(Void) = ReturnVoid : -# 12| v0_11(Void) = UnmodeledUse : mu* -# 12| v0_12(Void) = AliasedUse : ~mu0_2 -# 12| v0_13(Void) = ExitFunction : +# 12| v12_1(Void) = EnterFunction : +# 12| mu12_2() = AliasedDefinition : +# 12| mu12_3() = UnmodeledDefinition : +# 12| r12_4(glval) = InitializeThis : +# 12| r12_5(glval) = VariableAddress[value] : +# 12| mu12_6(Int32) = InitializeParameter[value] : &:r12_5 +# 14| r14_1(glval) = VariableAddress[value] : +# 14| r14_2(Int32) = Load : &:r14_1, ~mu12_3 +# 14| r14_3(glval) = VariableAddress[prop] : +# 14| mu14_4(Int32) = Store : &:r14_3, r14_2 +# 12| v12_7(Void) = ReturnVoid : +# 12| v12_8(Void) = UnmodeledUse : mu* +# 12| v12_9(Void) = AliasedUse : ~mu12_3 +# 12| v12_10(Void) = ExitFunction : # 18| System.Int32 PropClass.func() # 18| Block 0 -# 18| v0_0(Void) = EnterFunction : -# 18| mu0_1() = AliasedDefinition : -# 18| mu0_2() = UnmodeledDefinition : -# 18| r0_3(glval) = InitializeThis : -# 20| r0_4(glval) = VariableAddress[#return] : -# 20| r0_5(Int32) = Constant[0] : -# 20| mu0_6(Int32) = Store : &:r0_4, r0_5 -# 18| r0_7(glval) = VariableAddress[#return] : -# 18| v0_8(Void) = ReturnValue : &:r0_7, ~mu0_2 -# 18| v0_9(Void) = UnmodeledUse : mu* -# 18| v0_10(Void) = AliasedUse : ~mu0_2 -# 18| v0_11(Void) = ExitFunction : +# 18| v18_1(Void) = EnterFunction : +# 18| mu18_2() = AliasedDefinition : +# 18| mu18_3() = UnmodeledDefinition : +# 18| r18_4(glval) = InitializeThis : +# 20| r20_1(glval) = VariableAddress[#return] : +# 20| r20_2(Int32) = Constant[0] : +# 20| mu20_3(Int32) = Store : &:r20_1, r20_2 +# 18| r18_5(glval) = VariableAddress[#return] : +# 18| v18_6(Void) = ReturnValue : &:r18_5, ~mu18_3 +# 18| v18_7(Void) = UnmodeledUse : mu* +# 18| v18_8(Void) = AliasedUse : ~mu18_3 +# 18| v18_9(Void) = ExitFunction : # 26| System.Void Prog.Main() # 26| Block 0 -# 26| v0_0(Void) = EnterFunction : -# 26| mu0_1() = AliasedDefinition : -# 26| mu0_2() = UnmodeledDefinition : -# 28| r0_3(glval) = VariableAddress[obj] : -# 28| r0_4(PropClass) = NewObj : -# 28| r0_5() = FunctionAddress[PropClass] : -# 28| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 28| mu0_7() = ^CallSideEffect : ~mu0_2 -# 28| mu0_8(PropClass) = Store : &:r0_3, r0_4 -# 29| r0_9(glval) = VariableAddress[obj] : -# 29| r0_10(PropClass) = Load : &:r0_9, ~mu0_2 -# 29| r0_11() = FunctionAddress[set_Prop] : -# 29| r0_12(Int32) = Constant[5] : -# 29| v0_13(Void) = Call : func:r0_11, this:r0_10, 0:r0_12 -# 29| mu0_14() = ^CallSideEffect : ~mu0_2 -# 30| r0_15(glval) = VariableAddress[x] : -# 30| r0_16(glval) = VariableAddress[obj] : -# 30| r0_17(PropClass) = Load : &:r0_16, ~mu0_2 -# 30| r0_18() = FunctionAddress[get_Prop] : -# 30| r0_19(Int32) = Call : func:r0_18, this:r0_17 -# 30| mu0_20() = ^CallSideEffect : ~mu0_2 -# 30| mu0_21(Int32) = Store : &:r0_15, r0_19 -# 26| v0_22(Void) = ReturnVoid : -# 26| v0_23(Void) = UnmodeledUse : mu* -# 26| v0_24(Void) = AliasedUse : ~mu0_2 -# 26| v0_25(Void) = ExitFunction : +# 26| v26_1(Void) = EnterFunction : +# 26| mu26_2() = AliasedDefinition : +# 26| mu26_3() = UnmodeledDefinition : +# 28| r28_1(glval) = VariableAddress[obj] : +# 28| r28_2(PropClass) = NewObj : +# 28| r28_3() = FunctionAddress[PropClass] : +# 28| v28_4(Void) = Call : func:r28_3, this:r28_2 +# 28| mu28_5() = ^CallSideEffect : ~mu26_3 +# 28| mu28_6(PropClass) = Store : &:r28_1, r28_2 +# 29| r29_1(glval) = VariableAddress[obj] : +# 29| r29_2(PropClass) = Load : &:r29_1, ~mu26_3 +# 29| r29_3() = FunctionAddress[set_Prop] : +# 29| r29_4(Int32) = Constant[5] : +# 29| v29_5(Void) = Call : func:r29_3, this:r29_2, 0:r29_4 +# 29| mu29_6() = ^CallSideEffect : ~mu26_3 +# 30| r30_1(glval) = VariableAddress[x] : +# 30| r30_2(glval) = VariableAddress[obj] : +# 30| r30_3(PropClass) = Load : &:r30_2, ~mu26_3 +# 30| r30_4() = FunctionAddress[get_Prop] : +# 30| r30_5(Int32) = Call : func:r30_4, this:r30_3 +# 30| mu30_6() = ^CallSideEffect : ~mu26_3 +# 30| mu30_7(Int32) = Store : &:r30_1, r30_5 +# 26| v26_4(Void) = ReturnVoid : +# 26| v26_5(Void) = UnmodeledUse : mu* +# 26| v26_6(Void) = AliasedUse : ~mu26_3 +# 26| v26_7(Void) = ExitFunction : simple_call.cs: # 5| System.Int32 test_simple_call.f() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = VariableAddress[#return] : -# 7| r0_4(Int32) = Constant[0] : -# 7| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 5| r0_6(glval) = VariableAddress[#return] : -# 5| v0_7(Void) = ReturnValue : &:r0_6, ~mu0_2 -# 5| v0_8(Void) = UnmodeledUse : mu* -# 5| v0_9(Void) = AliasedUse : ~mu0_2 -# 5| v0_10(Void) = ExitFunction : +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 7| r7_1(glval) = VariableAddress[#return] : +# 7| r7_2(Int32) = Constant[0] : +# 7| mu7_3(Int32) = Store : &:r7_1, r7_2 +# 5| r5_4(glval) = VariableAddress[#return] : +# 5| v5_5(Void) = ReturnValue : &:r5_4, ~mu5_3 +# 5| v5_6(Void) = UnmodeledUse : mu* +# 5| v5_7(Void) = AliasedUse : ~mu5_3 +# 5| v5_8(Void) = ExitFunction : # 10| System.Int32 test_simple_call.g() # 10| Block 0 -# 10| v0_0(Void) = EnterFunction : -# 10| mu0_1() = AliasedDefinition : -# 10| mu0_2() = UnmodeledDefinition : -# 10| r0_3(glval) = InitializeThis : -# 12| r0_4(glval) = VariableAddress[#return] : -# 12| r0_5() = FunctionAddress[f] : -# 12| r0_6(Int32) = Call : func:r0_5 -# 12| mu0_7() = ^CallSideEffect : ~mu0_2 -# 12| mu0_8(Int32) = Store : &:r0_4, r0_6 -# 10| r0_9(glval) = VariableAddress[#return] : -# 10| v0_10(Void) = ReturnValue : &:r0_9, ~mu0_2 -# 10| v0_11(Void) = UnmodeledUse : mu* -# 10| v0_12(Void) = AliasedUse : ~mu0_2 -# 10| v0_13(Void) = ExitFunction : +# 10| v10_1(Void) = EnterFunction : +# 10| mu10_2() = AliasedDefinition : +# 10| mu10_3() = UnmodeledDefinition : +# 10| r10_4(glval) = InitializeThis : +# 12| r12_1(glval) = VariableAddress[#return] : +# 12| r12_2() = FunctionAddress[f] : +# 12| r12_3(Int32) = Call : func:r12_2 +# 12| mu12_4() = ^CallSideEffect : ~mu10_3 +# 12| mu12_5(Int32) = Store : &:r12_1, r12_3 +# 10| r10_5(glval) = VariableAddress[#return] : +# 10| v10_6(Void) = ReturnValue : &:r10_5, ~mu10_3 +# 10| v10_7(Void) = UnmodeledUse : mu* +# 10| v10_8(Void) = AliasedUse : ~mu10_3 +# 10| v10_9(Void) = ExitFunction : simple_function.cs: # 5| System.Int32 test_simple_function.f() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = VariableAddress[#return] : -# 7| r0_4(Int32) = Constant[0] : -# 7| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 5| r0_6(glval) = VariableAddress[#return] : -# 5| v0_7(Void) = ReturnValue : &:r0_6, ~mu0_2 -# 5| v0_8(Void) = UnmodeledUse : mu* -# 5| v0_9(Void) = AliasedUse : ~mu0_2 -# 5| v0_10(Void) = ExitFunction : +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 7| r7_1(glval) = VariableAddress[#return] : +# 7| r7_2(Int32) = Constant[0] : +# 7| mu7_3(Int32) = Store : &:r7_1, r7_2 +# 5| r5_4(glval) = VariableAddress[#return] : +# 5| v5_5(Void) = ReturnValue : &:r5_4, ~mu5_3 +# 5| v5_6(Void) = UnmodeledUse : mu* +# 5| v5_7(Void) = AliasedUse : ~mu5_3 +# 5| v5_8(Void) = ExitFunction : stmts.cs: # 5| System.Int32 test_stmts.ifStmt(System.Int32) # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 5| r0_3(glval) = VariableAddress[x] : -# 5| mu0_4(Int32) = InitializeParameter[x] : &:r0_3 -# 7| r0_5(glval) = VariableAddress[x] : -# 7| r0_6(Int32) = Load : &:r0_5, ~mu0_2 -# 7| r0_7(Int32) = Constant[5] : -# 7| r0_8(Boolean) = CompareEQ : r0_6, r0_7 -# 7| v0_9(Void) = ConditionalBranch : r0_8 +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 5| r5_4(glval) = VariableAddress[x] : +# 5| mu5_5(Int32) = InitializeParameter[x] : &:r5_4 +# 7| r7_1(glval) = VariableAddress[x] : +# 7| r7_2(Int32) = Load : &:r7_1, ~mu5_3 +# 7| r7_3(Int32) = Constant[5] : +# 7| r7_4(Boolean) = CompareEQ : r7_2, r7_3 +# 7| v7_5(Void) = ConditionalBranch : r7_4 #-----| False -> Block 2 #-----| True -> Block 3 # 5| Block 1 -# 5| r1_0(glval) = VariableAddress[#return] : -# 5| v1_1(Void) = ReturnValue : &:r1_0, ~mu0_2 -# 5| v1_2(Void) = UnmodeledUse : mu* -# 5| v1_3(Void) = AliasedUse : ~mu0_2 -# 5| v1_4(Void) = ExitFunction : +# 5| r5_6(glval) = VariableAddress[#return] : +# 5| v5_7(Void) = ReturnValue : &:r5_6, ~mu5_3 +# 5| v5_8(Void) = UnmodeledUse : mu* +# 5| v5_9(Void) = AliasedUse : ~mu5_3 +# 5| v5_10(Void) = ExitFunction : # 10| Block 2 -# 10| r2_0(glval) = VariableAddress[#return] : -# 10| r2_1(Int32) = Constant[1] : -# 10| mu2_2(Int32) = Store : &:r2_0, r2_1 +# 10| r10_1(glval) = VariableAddress[#return] : +# 10| r10_2(Int32) = Constant[1] : +# 10| mu10_3(Int32) = Store : &:r10_1, r10_2 #-----| Goto -> Block 1 # 8| Block 3 -# 8| r3_0(glval) = VariableAddress[#return] : -# 8| r3_1(Int32) = Constant[0] : -# 8| mu3_2(Int32) = Store : &:r3_0, r3_1 +# 8| r8_1(glval) = VariableAddress[#return] : +# 8| r8_2(Int32) = Constant[0] : +# 8| mu8_3(Int32) = Store : &:r8_1, r8_2 #-----| Goto -> Block 1 # 13| System.Void test_stmts.whileStmt(System.Int32) # 13| Block 0 -# 13| v0_0(Void) = EnterFunction : -# 13| mu0_1() = AliasedDefinition : -# 13| mu0_2() = UnmodeledDefinition : -# 13| r0_3(glval) = VariableAddress[x] : -# 13| mu0_4(Int32) = InitializeParameter[x] : &:r0_3 -# 15| r0_5(glval) = VariableAddress[i] : -# 15| r0_6(Int32) = Constant[0] : -# 15| mu0_7(Int32) = Store : &:r0_5, r0_6 +# 13| v13_1(Void) = EnterFunction : +# 13| mu13_2() = AliasedDefinition : +# 13| mu13_3() = UnmodeledDefinition : +# 13| r13_4(glval) = VariableAddress[x] : +# 13| mu13_5(Int32) = InitializeParameter[x] : &:r13_4 +# 15| r15_1(glval) = VariableAddress[i] : +# 15| r15_2(Int32) = Constant[0] : +# 15| mu15_3(Int32) = Store : &:r15_1, r15_2 #-----| Goto -> Block 2 # 13| Block 1 -# 13| v1_0(Void) = ReturnVoid : -# 13| v1_1(Void) = UnmodeledUse : mu* -# 13| v1_2(Void) = AliasedUse : ~mu0_2 -# 13| v1_3(Void) = ExitFunction : +# 13| v13_6(Void) = ReturnVoid : +# 13| v13_7(Void) = UnmodeledUse : mu* +# 13| v13_8(Void) = AliasedUse : ~mu13_3 +# 13| v13_9(Void) = ExitFunction : # 16| Block 2 -# 16| r2_0(glval) = VariableAddress[i] : -# 16| r2_1(Int32) = Load : &:r2_0, ~mu0_2 -# 16| r2_2(Int32) = Constant[10] : -# 16| r2_3(Boolean) = CompareLT : r2_1, r2_2 -# 16| v2_4(Void) = ConditionalBranch : r2_3 +# 16| r16_1(glval) = VariableAddress[i] : +# 16| r16_2(Int32) = Load : &:r16_1, ~mu13_3 +# 16| r16_3(Int32) = Constant[10] : +# 16| r16_4(Boolean) = CompareLT : r16_2, r16_3 +# 16| v16_5(Void) = ConditionalBranch : r16_4 #-----| False -> Block 1 #-----| True -> Block 3 # 18| Block 3 -# 18| r3_0(glval) = VariableAddress[x] : -# 18| r3_1(Int32) = Load : &:r3_0, ~mu0_2 -# 18| r3_2(Int32) = Constant[1] : -# 18| r3_3(Int32) = Add : r3_1, r3_2 -# 18| r3_4(glval) = VariableAddress[x] : -# 18| mu3_5(Int32) = Store : &:r3_4, r3_3 +# 18| r18_1(glval) = VariableAddress[x] : +# 18| r18_2(Int32) = Load : &:r18_1, ~mu13_3 +# 18| r18_3(Int32) = Constant[1] : +# 18| r18_4(Int32) = Add : r18_2, r18_3 +# 18| r18_5(glval) = VariableAddress[x] : +# 18| mu18_6(Int32) = Store : &:r18_5, r18_4 #-----| Goto (back edge) -> Block 2 # 22| System.Int32 test_stmts.switchStmt() # 22| Block 0 -# 22| v0_0(Void) = EnterFunction : -# 22| mu0_1() = AliasedDefinition : -# 22| mu0_2() = UnmodeledDefinition : -# 24| r0_3(glval) = VariableAddress[caseSwitch] : -# 24| r0_4(Object) = NewObj : -# 24| r0_5() = FunctionAddress[Object] : -# 24| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 24| mu0_7() = ^CallSideEffect : ~mu0_2 -# 24| mu0_8(Object) = Store : &:r0_3, r0_4 -# 25| r0_9(glval) = VariableAddress[select] : -# 25| r0_10(Int32) = Constant[0] : -# 25| mu0_11(Int32) = Store : &:r0_9, r0_10 -# 27| r0_12(glval) = VariableAddress[caseSwitch] : -# 27| r0_13(Object) = Load : &:r0_12, ~mu0_2 -# 27| v0_14(Void) = Switch : r0_13 +# 22| v22_1(Void) = EnterFunction : +# 22| mu22_2() = AliasedDefinition : +# 22| mu22_3() = UnmodeledDefinition : +# 24| r24_1(glval) = VariableAddress[caseSwitch] : +# 24| r24_2(Object) = NewObj : +# 24| r24_3() = FunctionAddress[Object] : +# 24| v24_4(Void) = Call : func:r24_3, this:r24_2 +# 24| mu24_5() = ^CallSideEffect : ~mu22_3 +# 24| mu24_6(Object) = Store : &:r24_1, r24_2 +# 25| r25_1(glval) = VariableAddress[select] : +# 25| r25_2(Int32) = Constant[0] : +# 25| mu25_3(Int32) = Store : &:r25_1, r25_2 +# 27| r27_1(glval) = VariableAddress[caseSwitch] : +# 27| r27_2(Object) = Load : &:r27_1, ~mu22_3 +# 27| v27_3(Void) = Switch : r27_2 #-----| Case[-1] -> Block 2 #-----| Case[0] -> Block 3 #-----| Case[123] -> Block 4 @@ -1739,359 +1739,359 @@ stmts.cs: #-----| Default -> Block 6 # 22| Block 1 -# 22| r1_0(glval) = VariableAddress[#return] : -# 22| v1_1(Void) = ReturnValue : &:r1_0, ~mu0_2 -# 22| v1_2(Void) = UnmodeledUse : mu* -# 22| v1_3(Void) = AliasedUse : ~mu0_2 -# 22| v1_4(Void) = ExitFunction : +# 22| r22_4(glval) = VariableAddress[#return] : +# 22| v22_5(Void) = ReturnValue : &:r22_4, ~mu22_3 +# 22| v22_6(Void) = UnmodeledUse : mu* +# 22| v22_7(Void) = AliasedUse : ~mu22_3 +# 22| v22_8(Void) = ExitFunction : # 29| Block 2 -# 29| v2_0(Void) = NoOp : -# 30| v2_1(Void) = NoOp : +# 29| v29_1(Void) = NoOp : +# 30| v30_1(Void) = NoOp : #-----| Goto (back edge) -> Block 5 # 31| Block 3 -# 31| v3_0(Void) = NoOp : -# 32| v3_1(Void) = NoOp : +# 31| v31_1(Void) = NoOp : +# 32| v32_1(Void) = NoOp : #-----| Goto (back edge) -> Block 4 # 33| Block 4 -# 33| v4_0(Void) = NoOp : -# 34| r4_1(Int32) = Constant[100] : -# 34| r4_2(glval) = VariableAddress[select] : -# 34| mu4_3(Int32) = Store : &:r4_2, r4_1 -# 35| v4_4(Void) = NoOp : -# 42| r4_5(glval) = VariableAddress[#return] : -# 42| r4_6(Int32) = Constant[0] : -# 42| mu4_7(Int32) = Store : &:r4_5, r4_6 +# 33| v33_1(Void) = NoOp : +# 34| r34_1(Int32) = Constant[100] : +# 34| r34_2(glval) = VariableAddress[select] : +# 34| mu34_3(Int32) = Store : &:r34_2, r34_1 +# 35| v35_1(Void) = NoOp : +# 42| r42_1(glval) = VariableAddress[#return] : +# 42| r42_2(Int32) = Constant[0] : +# 42| mu42_3(Int32) = Store : &:r42_1, r42_2 #-----| Goto -> Block 1 # 36| Block 5 -# 36| v5_0(Void) = NoOp : -# 37| r5_1(Int32) = Constant[101] : -# 37| r5_2(glval) = VariableAddress[select] : -# 37| mu5_3(Int32) = Store : &:r5_2, r5_1 -# 38| v5_4(Void) = NoOp : +# 36| v36_1(Void) = NoOp : +# 37| r37_1(Int32) = Constant[101] : +# 37| r37_2(glval) = VariableAddress[select] : +# 37| mu37_3(Int32) = Store : &:r37_2, r37_1 +# 38| v38_1(Void) = NoOp : #-----| Goto (back edge) -> Block 6 # 39| Block 6 -# 39| v6_0(Void) = NoOp : -# 40| r6_1(glval) = VariableAddress[#return] : -# 40| r6_2(glval) = VariableAddress[select] : -# 40| r6_3(Int32) = Load : &:r6_2, ~mu0_2 -# 40| mu6_4(Int32) = Store : &:r6_1, r6_3 +# 39| v39_1(Void) = NoOp : +# 40| r40_1(glval) = VariableAddress[#return] : +# 40| r40_2(glval) = VariableAddress[select] : +# 40| r40_3(Int32) = Load : &:r40_2, ~mu22_3 +# 40| mu40_4(Int32) = Store : &:r40_1, r40_3 #-----| Goto -> Block 1 # 46| System.Void test_stmts.tryCatchFinally() # 46| Block 0 -# 46| v0_0(Void) = EnterFunction : -# 46| mu0_1() = AliasedDefinition : -# 46| mu0_2() = UnmodeledDefinition : -# 48| r0_3(glval) = VariableAddress[x] : -# 48| r0_4(Int32) = Constant[5] : -# 48| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 51| r0_6(glval) = VariableAddress[x] : -# 51| r0_7(Int32) = Load : &:r0_6, ~mu0_2 -# 51| r0_8(Int32) = Constant[0] : -# 51| r0_9(Boolean) = CompareNE : r0_7, r0_8 -# 51| v0_10(Void) = ConditionalBranch : r0_9 +# 46| v46_1(Void) = EnterFunction : +# 46| mu46_2() = AliasedDefinition : +# 46| mu46_3() = UnmodeledDefinition : +# 48| r48_1(glval) = VariableAddress[x] : +# 48| r48_2(Int32) = Constant[5] : +# 48| mu48_3(Int32) = Store : &:r48_1, r48_2 +# 51| r51_1(glval) = VariableAddress[x] : +# 51| r51_2(Int32) = Load : &:r51_1, ~mu46_3 +# 51| r51_3(Int32) = Constant[0] : +# 51| r51_4(Boolean) = CompareNE : r51_2, r51_3 +# 51| v51_5(Void) = ConditionalBranch : r51_4 #-----| False -> Block 4 #-----| True -> Block 3 # 46| Block 1 -# 46| v1_0(Void) = UnmodeledUse : mu* -# 46| v1_1(Void) = AliasedUse : ~mu0_2 -# 46| v1_2(Void) = ExitFunction : +# 46| v46_4(Void) = UnmodeledUse : mu* +# 46| v46_5(Void) = AliasedUse : ~mu46_3 +# 46| v46_6(Void) = ExitFunction : # 46| Block 2 -# 46| v2_0(Void) = Unwind : +# 46| v46_7(Void) = Unwind : #-----| Goto -> Block 1 # 52| Block 3 -# 52| r3_0(glval) = VariableAddress[#throw52:17] : -# 52| r3_1(Exception) = NewObj : -# 52| r3_2() = FunctionAddress[Exception] : -# 52| v3_3(Void) = Call : func:r3_2, this:r3_1 -# 52| mu3_4() = ^CallSideEffect : ~mu0_2 -# 52| mu3_5(Exception) = Store : &:r3_0, r3_1 -# 52| v3_6(Void) = ThrowValue : &:r3_0, ~mu0_2 +# 52| r52_1(glval) = VariableAddress[#throw52:17] : +# 52| r52_2(Exception) = NewObj : +# 52| r52_3() = FunctionAddress[Exception] : +# 52| v52_4(Void) = Call : func:r52_3, this:r52_2 +# 52| mu52_5() = ^CallSideEffect : ~mu46_3 +# 52| mu52_6(Exception) = Store : &:r52_1, r52_2 +# 52| v52_7(Void) = ThrowValue : &:r52_1, ~mu46_3 #-----| Exception -> Block 6 # 53| Block 4 -# 53| r4_0(Int32) = Constant[0] : -# 53| r4_1(glval) = VariableAddress[x] : -# 53| mu4_2(Int32) = Store : &:r4_1, r4_0 +# 53| r53_1(Int32) = Constant[0] : +# 53| r53_2(glval) = VariableAddress[x] : +# 53| mu53_3(Int32) = Store : &:r53_2, r53_1 #-----| Goto -> Block 5 # 65| Block 5 -# 65| r5_0(Int32) = Constant[2] : -# 65| r5_1(glval) = VariableAddress[x] : -# 65| mu5_2(Int32) = Store : &:r5_1, r5_0 -# 46| v5_3(Void) = ReturnVoid : +# 65| r65_1(Int32) = Constant[2] : +# 65| r65_2(glval) = VariableAddress[x] : +# 65| mu65_3(Int32) = Store : &:r65_2, r65_1 +# 46| v46_8(Void) = ReturnVoid : #-----| Goto -> Block 1 # 55| Block 6 -# 55| v6_0(Void) = CatchByType[Exception] : +# 55| v55_1(Void) = CatchByType[Exception] : #-----| Exception -> Block 8 #-----| Goto -> Block 7 # 55| Block 7 -# 55| r7_0(glval) = VariableAddress[ex] : -# 55| mu7_1(Exception) = Uninitialized[ex] : &:r7_0 -# 57| r7_2(Int32) = Constant[1] : -# 57| r7_3(glval) = VariableAddress[x] : -# 57| mu7_4(Int32) = Store : &:r7_3, r7_2 +# 55| r55_2(glval) = VariableAddress[ex] : +# 55| mu55_3(Exception) = Uninitialized[ex] : &:r55_2 +# 57| r57_1(Int32) = Constant[1] : +# 57| r57_2(glval) = VariableAddress[x] : +# 57| mu57_3(Int32) = Store : &:r57_2, r57_1 #-----| Goto -> Block 5 # 59| Block 8 -# 59| v8_0(Void) = CatchAny : -# 61| v8_1(Void) = ReThrow : +# 59| v59_1(Void) = CatchAny : +# 61| v61_1(Void) = ReThrow : #-----| Exception -> Block 2 # 69| System.Void test_stmts.forStmt() # 69| Block 0 -# 69| v0_0(Void) = EnterFunction : -# 69| mu0_1() = AliasedDefinition : -# 69| mu0_2() = UnmodeledDefinition : -# 71| r0_3(glval) = VariableAddress[x] : -# 71| r0_4(Int32) = Constant[0] : -# 71| mu0_5(Int32) = Store : &:r0_3, r0_4 -# 72| r0_6(glval) = VariableAddress[i] : -# 72| r0_7(Int32) = Constant[0] : -# 72| mu0_8(Int32) = Store : &:r0_6, r0_7 -# 72| r0_9(glval) = VariableAddress[j] : -# 72| r0_10(Int32) = Constant[10] : -# 72| mu0_11(Int32) = Store : &:r0_9, r0_10 +# 69| v69_1(Void) = EnterFunction : +# 69| mu69_2() = AliasedDefinition : +# 69| mu69_3() = UnmodeledDefinition : +# 71| r71_1(glval) = VariableAddress[x] : +# 71| r71_2(Int32) = Constant[0] : +# 71| mu71_3(Int32) = Store : &:r71_1, r71_2 +# 72| r72_1(glval) = VariableAddress[i] : +# 72| r72_2(Int32) = Constant[0] : +# 72| mu72_3(Int32) = Store : &:r72_1, r72_2 +# 72| r72_4(glval) = VariableAddress[j] : +# 72| r72_5(Int32) = Constant[10] : +# 72| mu72_6(Int32) = Store : &:r72_4, r72_5 #-----| Goto -> Block 2 # 69| Block 1 -# 69| v1_0(Void) = ReturnVoid : -# 69| v1_1(Void) = UnmodeledUse : mu* -# 69| v1_2(Void) = AliasedUse : ~mu0_2 -# 69| v1_3(Void) = ExitFunction : +# 69| v69_4(Void) = ReturnVoid : +# 69| v69_5(Void) = UnmodeledUse : mu* +# 69| v69_6(Void) = AliasedUse : ~mu69_3 +# 69| v69_7(Void) = ExitFunction : # 72| Block 2 -# 72| r2_0(glval) = VariableAddress[i] : -# 72| r2_1(Int32) = Load : &:r2_0, ~mu0_2 -# 72| r2_2(glval) = VariableAddress[j] : -# 72| r2_3(Int32) = Load : &:r2_2, ~mu0_2 -# 72| r2_4(Boolean) = CompareLT : r2_1, r2_3 -# 72| v2_5(Void) = ConditionalBranch : r2_4 +# 72| r72_7(glval) = VariableAddress[i] : +# 72| r72_8(Int32) = Load : &:r72_7, ~mu69_3 +# 72| r72_9(glval) = VariableAddress[j] : +# 72| r72_10(Int32) = Load : &:r72_9, ~mu69_3 +# 72| r72_11(Boolean) = CompareLT : r72_8, r72_10 +# 72| v72_12(Void) = ConditionalBranch : r72_11 #-----| False -> Block 4 #-----| True -> Block 3 # 74| Block 3 -# 74| r3_0(glval) = VariableAddress[x] : -# 74| r3_1(Int32) = Load : &:r3_0, ~mu0_2 -# 74| r3_2(Int32) = Constant[1] : -# 74| r3_3(Int32) = Sub : r3_1, r3_2 -# 74| r3_4(glval) = VariableAddress[x] : -# 74| mu3_5(Int32) = Store : &:r3_4, r3_3 -# 72| r3_6(glval) = VariableAddress[i] : -# 72| r3_7(Int32) = Load : &:r3_6, ~mu0_2 -# 72| r3_8(Int32) = Constant[1] : -# 72| r3_9(Int32) = Add : r3_7, r3_8 -# 72| mu3_10(Int32) = Store : &:r3_6, r3_9 -# 72| r3_11(glval) = VariableAddress[j] : -# 72| r3_12(Int32) = Load : &:r3_11, ~mu0_2 -# 72| r3_13(Int32) = Constant[1] : -# 72| r3_14(Int32) = Sub : r3_12, r3_13 -# 72| mu3_15(Int32) = Store : &:r3_11, r3_14 +# 74| r74_1(glval) = VariableAddress[x] : +# 74| r74_2(Int32) = Load : &:r74_1, ~mu69_3 +# 74| r74_3(Int32) = Constant[1] : +# 74| r74_4(Int32) = Sub : r74_2, r74_3 +# 74| r74_5(glval) = VariableAddress[x] : +# 74| mu74_6(Int32) = Store : &:r74_5, r74_4 +# 72| r72_13(glval) = VariableAddress[i] : +# 72| r72_14(Int32) = Load : &:r72_13, ~mu69_3 +# 72| r72_15(Int32) = Constant[1] : +# 72| r72_16(Int32) = Add : r72_14, r72_15 +# 72| mu72_17(Int32) = Store : &:r72_13, r72_16 +# 72| r72_18(glval) = VariableAddress[j] : +# 72| r72_19(Int32) = Load : &:r72_18, ~mu69_3 +# 72| r72_20(Int32) = Constant[1] : +# 72| r72_21(Int32) = Sub : r72_19, r72_20 +# 72| mu72_22(Int32) = Store : &:r72_18, r72_21 #-----| Goto (back edge) -> Block 2 # 77| Block 4 -# 77| r4_0(glval) = VariableAddress[a] : -# 77| mu4_1(Int32) = Uninitialized[a] : &:r4_0 -# 77| r4_2(glval) = VariableAddress[b] : -# 77| r4_3(Int32) = Constant[10] : -# 77| mu4_4(Int32) = Store : &:r4_2, r4_3 -# 78| r4_5(Int32) = Constant[0] : -# 78| r4_6(glval) = VariableAddress[a] : -# 78| mu4_7(Int32) = Store : &:r4_6, r4_5 +# 77| r77_1(glval) = VariableAddress[a] : +# 77| mu77_2(Int32) = Uninitialized[a] : &:r77_1 +# 77| r77_3(glval) = VariableAddress[b] : +# 77| r77_4(Int32) = Constant[10] : +# 77| mu77_5(Int32) = Store : &:r77_3, r77_4 +# 78| r78_1(Int32) = Constant[0] : +# 78| r78_2(glval) = VariableAddress[a] : +# 78| mu78_3(Int32) = Store : &:r78_2, r78_1 #-----| Goto -> Block 5 # 78| Block 5 -# 78| r5_0(glval) = VariableAddress[a] : -# 78| r5_1(Int32) = Load : &:r5_0, ~mu0_2 -# 78| r5_2(glval) = VariableAddress[b] : -# 78| r5_3(Int32) = Load : &:r5_2, ~mu0_2 -# 78| r5_4(Boolean) = CompareLT : r5_1, r5_3 -# 78| v5_5(Void) = ConditionalBranch : r5_4 +# 78| r78_4(glval) = VariableAddress[a] : +# 78| r78_5(Int32) = Load : &:r78_4, ~mu69_3 +# 78| r78_6(glval) = VariableAddress[b] : +# 78| r78_7(Int32) = Load : &:r78_6, ~mu69_3 +# 78| r78_8(Boolean) = CompareLT : r78_5, r78_7 +# 78| v78_9(Void) = ConditionalBranch : r78_8 #-----| False -> Block 7 #-----| True -> Block 6 # 80| Block 6 -# 80| r6_0(glval) = VariableAddress[a] : -# 80| r6_1(Int32) = Load : &:r6_0, ~mu0_2 -# 80| r6_2(Int32) = Constant[1] : -# 80| r6_3(Int32) = Add : r6_1, r6_2 -# 80| mu6_4(Int32) = Store : &:r6_0, r6_3 +# 80| r80_1(glval) = VariableAddress[a] : +# 80| r80_2(Int32) = Load : &:r80_1, ~mu69_3 +# 80| r80_3(Int32) = Constant[1] : +# 80| r80_4(Int32) = Add : r80_2, r80_3 +# 80| mu80_5(Int32) = Store : &:r80_1, r80_4 #-----| Goto (back edge) -> Block 5 # 84| Block 7 -# 84| v7_0(Void) = NoOp : +# 84| v84_1(Void) = NoOp : #-----| Goto (back edge) -> Block 7 # 89| System.Void test_stmts.doWhile() # 89| Block 0 -# 89| v0_0(Void) = EnterFunction : -# 89| mu0_1() = AliasedDefinition : -# 89| mu0_2() = UnmodeledDefinition : -# 91| r0_3(glval) = VariableAddress[x] : -# 91| r0_4(Int32) = Constant[0] : -# 91| mu0_5(Int32) = Store : &:r0_3, r0_4 +# 89| v89_1(Void) = EnterFunction : +# 89| mu89_2() = AliasedDefinition : +# 89| mu89_3() = UnmodeledDefinition : +# 91| r91_1(glval) = VariableAddress[x] : +# 91| r91_2(Int32) = Constant[0] : +# 91| mu91_3(Int32) = Store : &:r91_1, r91_2 #-----| Goto -> Block 2 # 89| Block 1 -# 89| v1_0(Void) = ReturnVoid : -# 89| v1_1(Void) = UnmodeledUse : mu* -# 89| v1_2(Void) = AliasedUse : ~mu0_2 -# 89| v1_3(Void) = ExitFunction : +# 89| v89_4(Void) = ReturnVoid : +# 89| v89_5(Void) = UnmodeledUse : mu* +# 89| v89_6(Void) = AliasedUse : ~mu89_3 +# 89| v89_7(Void) = ExitFunction : # 94| Block 2 -# 94| r2_0(glval) = VariableAddress[x] : -# 94| r2_1(Int32) = Load : &:r2_0, ~mu0_2 -# 94| r2_2(Int32) = Constant[1] : -# 94| r2_3(Int32) = Add : r2_1, r2_2 -# 94| r2_4(glval) = VariableAddress[x] : -# 94| mu2_5(Int32) = Store : &:r2_4, r2_3 -# 96| r2_6(glval) = VariableAddress[x] : -# 96| r2_7(Int32) = Load : &:r2_6, ~mu0_2 -# 96| r2_8(Int32) = Constant[10] : -# 96| r2_9(Boolean) = CompareLT : r2_7, r2_8 -# 96| v2_10(Void) = ConditionalBranch : r2_9 +# 94| r94_1(glval) = VariableAddress[x] : +# 94| r94_2(Int32) = Load : &:r94_1, ~mu89_3 +# 94| r94_3(Int32) = Constant[1] : +# 94| r94_4(Int32) = Add : r94_2, r94_3 +# 94| r94_5(glval) = VariableAddress[x] : +# 94| mu94_6(Int32) = Store : &:r94_5, r94_4 +# 96| r96_1(glval) = VariableAddress[x] : +# 96| r96_2(Int32) = Load : &:r96_1, ~mu89_3 +# 96| r96_3(Int32) = Constant[10] : +# 96| r96_4(Boolean) = CompareLT : r96_2, r96_3 +# 96| v96_5(Void) = ConditionalBranch : r96_4 #-----| False -> Block 1 #-----| True (back edge) -> Block 2 # 99| System.Void test_stmts.checkedUnchecked() # 99| Block 0 -# 99| v0_0(Void) = EnterFunction : -# 99| mu0_1() = AliasedDefinition : -# 99| mu0_2() = UnmodeledDefinition : -# 101| r0_3(glval) = VariableAddress[num] : -# 101| r0_4(Int32) = Constant[2147483647] : -# 101| r0_5(Int32) = Load : &:r0_4, ~mu0_2 -# 101| mu0_6(Int32) = Store : &:r0_3, r0_5 -# 104| r0_7(glval) = VariableAddress[num] : -# 104| r0_8(Int32) = Load : &:r0_7, ~mu0_2 -# 104| r0_9(Int32) = Constant[1] : -# 104| r0_10(Int32) = Add : r0_8, r0_9 -# 104| r0_11(glval) = VariableAddress[num] : -# 104| mu0_12(Int32) = Store : &:r0_11, r0_10 -# 108| r0_13(glval) = VariableAddress[num] : -# 108| r0_14(Int32) = Load : &:r0_13, ~mu0_2 -# 108| r0_15(Int32) = Constant[1] : -# 108| r0_16(Int32) = Add : r0_14, r0_15 -# 108| r0_17(glval) = VariableAddress[num] : -# 108| mu0_18(Int32) = Store : &:r0_17, r0_16 -# 99| v0_19(Void) = ReturnVoid : -# 99| v0_20(Void) = UnmodeledUse : mu* -# 99| v0_21(Void) = AliasedUse : ~mu0_2 -# 99| v0_22(Void) = ExitFunction : +# 99| v99_1(Void) = EnterFunction : +# 99| mu99_2() = AliasedDefinition : +# 99| mu99_3() = UnmodeledDefinition : +# 101| r101_1(glval) = VariableAddress[num] : +# 101| r101_2(Int32) = Constant[2147483647] : +# 101| r101_3(Int32) = Load : &:r101_2, ~mu99_3 +# 101| mu101_4(Int32) = Store : &:r101_1, r101_3 +# 104| r104_1(glval) = VariableAddress[num] : +# 104| r104_2(Int32) = Load : &:r104_1, ~mu99_3 +# 104| r104_3(Int32) = Constant[1] : +# 104| r104_4(Int32) = Add : r104_2, r104_3 +# 104| r104_5(glval) = VariableAddress[num] : +# 104| mu104_6(Int32) = Store : &:r104_5, r104_4 +# 108| r108_1(glval) = VariableAddress[num] : +# 108| r108_2(Int32) = Load : &:r108_1, ~mu99_3 +# 108| r108_3(Int32) = Constant[1] : +# 108| r108_4(Int32) = Add : r108_2, r108_3 +# 108| r108_5(glval) = VariableAddress[num] : +# 108| mu108_6(Int32) = Store : &:r108_5, r108_4 +# 99| v99_4(Void) = ReturnVoid : +# 99| v99_5(Void) = UnmodeledUse : mu* +# 99| v99_6(Void) = AliasedUse : ~mu99_3 +# 99| v99_7(Void) = ExitFunction : using.cs: # 7| System.Void UsingStmt.MyDisposable..ctor() # 7| Block 0 -# 7| v0_0(Void) = EnterFunction : -# 7| mu0_1() = AliasedDefinition : -# 7| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = InitializeThis : -# 7| v0_4(Void) = NoOp : -# 7| v0_5(Void) = ReturnVoid : -# 7| v0_6(Void) = UnmodeledUse : mu* -# 7| v0_7(Void) = AliasedUse : ~mu0_2 -# 7| v0_8(Void) = ExitFunction : +# 7| v7_1(Void) = EnterFunction : +# 7| mu7_2() = AliasedDefinition : +# 7| mu7_3() = UnmodeledDefinition : +# 7| r7_4(glval) = InitializeThis : +# 7| v7_5(Void) = NoOp : +# 7| v7_6(Void) = ReturnVoid : +# 7| v7_7(Void) = UnmodeledUse : mu* +# 7| v7_8(Void) = AliasedUse : ~mu7_3 +# 7| v7_9(Void) = ExitFunction : # 8| System.Void UsingStmt.MyDisposable.DoSomething() # 8| Block 0 -# 8| v0_0(Void) = EnterFunction : -# 8| mu0_1() = AliasedDefinition : -# 8| mu0_2() = UnmodeledDefinition : -# 8| r0_3(glval) = InitializeThis : -# 8| v0_4(Void) = NoOp : -# 8| v0_5(Void) = ReturnVoid : -# 8| v0_6(Void) = UnmodeledUse : mu* -# 8| v0_7(Void) = AliasedUse : ~mu0_2 -# 8| v0_8(Void) = ExitFunction : +# 8| v8_1(Void) = EnterFunction : +# 8| mu8_2() = AliasedDefinition : +# 8| mu8_3() = UnmodeledDefinition : +# 8| r8_4(glval) = InitializeThis : +# 8| v8_5(Void) = NoOp : +# 8| v8_6(Void) = ReturnVoid : +# 8| v8_7(Void) = UnmodeledUse : mu* +# 8| v8_8(Void) = AliasedUse : ~mu8_3 +# 8| v8_9(Void) = ExitFunction : # 9| System.Void UsingStmt.MyDisposable.Dispose() # 9| Block 0 -# 9| v0_0(Void) = EnterFunction : -# 9| mu0_1() = AliasedDefinition : -# 9| mu0_2() = UnmodeledDefinition : -# 9| r0_3(glval) = InitializeThis : -# 9| v0_4(Void) = NoOp : -# 9| v0_5(Void) = ReturnVoid : -# 9| v0_6(Void) = UnmodeledUse : mu* -# 9| v0_7(Void) = AliasedUse : ~mu0_2 -# 9| v0_8(Void) = ExitFunction : +# 9| v9_1(Void) = EnterFunction : +# 9| mu9_2() = AliasedDefinition : +# 9| mu9_3() = UnmodeledDefinition : +# 9| r9_4(glval) = InitializeThis : +# 9| v9_5(Void) = NoOp : +# 9| v9_6(Void) = ReturnVoid : +# 9| v9_7(Void) = UnmodeledUse : mu* +# 9| v9_8(Void) = AliasedUse : ~mu9_3 +# 9| v9_9(Void) = ExitFunction : # 12| System.Void UsingStmt.Main() # 12| Block 0 -# 12| v0_0(Void) = EnterFunction : -# 12| mu0_1() = AliasedDefinition : -# 12| mu0_2() = UnmodeledDefinition : -# 14| r0_3(glval) = VariableAddress[o1] : -# 14| r0_4(MyDisposable) = NewObj : -# 14| r0_5() = FunctionAddress[MyDisposable] : -# 14| v0_6(Void) = Call : func:r0_5, this:r0_4 -# 14| mu0_7() = ^CallSideEffect : ~mu0_2 -# 14| mu0_8(MyDisposable) = Store : &:r0_3, r0_4 -# 16| r0_9(glval) = VariableAddress[o1] : -# 16| r0_10(MyDisposable) = Load : &:r0_9, ~mu0_2 -# 16| r0_11() = FunctionAddress[DoSomething] : -# 16| v0_12(Void) = Call : func:r0_11, this:r0_10 -# 16| mu0_13() = ^CallSideEffect : ~mu0_2 -# 19| r0_14(glval) = VariableAddress[o2] : -# 19| r0_15(MyDisposable) = NewObj : -# 19| r0_16() = FunctionAddress[MyDisposable] : -# 19| v0_17(Void) = Call : func:r0_16, this:r0_15 -# 19| mu0_18() = ^CallSideEffect : ~mu0_2 -# 19| mu0_19(MyDisposable) = Store : &:r0_14, r0_15 -# 22| r0_20(glval) = VariableAddress[o2] : -# 22| r0_21(MyDisposable) = Load : &:r0_20, ~mu0_2 -# 22| r0_22() = FunctionAddress[DoSomething] : -# 22| v0_23(Void) = Call : func:r0_22, this:r0_21 -# 22| mu0_24() = ^CallSideEffect : ~mu0_2 -# 25| r0_25(glval) = VariableAddress[o3] : -# 25| r0_26(MyDisposable) = NewObj : -# 25| r0_27() = FunctionAddress[MyDisposable] : -# 25| v0_28(Void) = Call : func:r0_27, this:r0_26 -# 25| mu0_29() = ^CallSideEffect : ~mu0_2 -# 25| mu0_30(MyDisposable) = Store : &:r0_25, r0_26 -# 26| r0_31(glval) = VariableAddress[o3] : -# 26| r0_32(MyDisposable) = Load : &:r0_31, ~mu0_2 -# 26| r0_33() = FunctionAddress[DoSomething] : -# 26| v0_34(Void) = Call : func:r0_33, this:r0_32 -# 26| mu0_35() = ^CallSideEffect : ~mu0_2 -# 12| v0_36(Void) = ReturnVoid : -# 12| v0_37(Void) = UnmodeledUse : mu* -# 12| v0_38(Void) = AliasedUse : ~mu0_2 -# 12| v0_39(Void) = ExitFunction : +# 12| v12_1(Void) = EnterFunction : +# 12| mu12_2() = AliasedDefinition : +# 12| mu12_3() = UnmodeledDefinition : +# 14| r14_1(glval) = VariableAddress[o1] : +# 14| r14_2(MyDisposable) = NewObj : +# 14| r14_3() = FunctionAddress[MyDisposable] : +# 14| v14_4(Void) = Call : func:r14_3, this:r14_2 +# 14| mu14_5() = ^CallSideEffect : ~mu12_3 +# 14| mu14_6(MyDisposable) = Store : &:r14_1, r14_2 +# 16| r16_1(glval) = VariableAddress[o1] : +# 16| r16_2(MyDisposable) = Load : &:r16_1, ~mu12_3 +# 16| r16_3() = FunctionAddress[DoSomething] : +# 16| v16_4(Void) = Call : func:r16_3, this:r16_2 +# 16| mu16_5() = ^CallSideEffect : ~mu12_3 +# 19| r19_1(glval) = VariableAddress[o2] : +# 19| r19_2(MyDisposable) = NewObj : +# 19| r19_3() = FunctionAddress[MyDisposable] : +# 19| v19_4(Void) = Call : func:r19_3, this:r19_2 +# 19| mu19_5() = ^CallSideEffect : ~mu12_3 +# 19| mu19_6(MyDisposable) = Store : &:r19_1, r19_2 +# 22| r22_1(glval) = VariableAddress[o2] : +# 22| r22_2(MyDisposable) = Load : &:r22_1, ~mu12_3 +# 22| r22_3() = FunctionAddress[DoSomething] : +# 22| v22_4(Void) = Call : func:r22_3, this:r22_2 +# 22| mu22_5() = ^CallSideEffect : ~mu12_3 +# 25| r25_1(glval) = VariableAddress[o3] : +# 25| r25_2(MyDisposable) = NewObj : +# 25| r25_3() = FunctionAddress[MyDisposable] : +# 25| v25_4(Void) = Call : func:r25_3, this:r25_2 +# 25| mu25_5() = ^CallSideEffect : ~mu12_3 +# 25| mu25_6(MyDisposable) = Store : &:r25_1, r25_2 +# 26| r26_1(glval) = VariableAddress[o3] : +# 26| r26_2(MyDisposable) = Load : &:r26_1, ~mu12_3 +# 26| r26_3() = FunctionAddress[DoSomething] : +# 26| v26_4(Void) = Call : func:r26_3, this:r26_2 +# 26| mu26_5() = ^CallSideEffect : ~mu12_3 +# 12| v12_4(Void) = ReturnVoid : +# 12| v12_5(Void) = UnmodeledUse : mu* +# 12| v12_6(Void) = AliasedUse : ~mu12_3 +# 12| v12_7(Void) = ExitFunction : variables.cs: # 5| System.Void test_variables.f() # 5| Block 0 -# 5| v0_0(Void) = EnterFunction : -# 5| mu0_1() = AliasedDefinition : -# 5| mu0_2() = UnmodeledDefinition : -# 7| r0_3(glval) = VariableAddress[x] : -# 7| mu0_4(Int32) = Uninitialized[x] : &:r0_3 -# 7| r0_5(glval) = VariableAddress[y] : -# 7| r0_6(Int32) = Constant[5] : -# 7| mu0_7(Int32) = Store : &:r0_5, r0_6 -# 8| r0_8(Int32) = Constant[4] : -# 8| r0_9(glval) = VariableAddress[x] : -# 8| mu0_10(Int32) = Store : &:r0_9, r0_8 -# 9| r0_11(glval) = VariableAddress[y] : -# 9| r0_12(Int32) = Load : &:r0_11, ~mu0_2 -# 9| r0_13(glval) = VariableAddress[x] : -# 9| mu0_14(Int32) = Store : &:r0_13, r0_12 -# 10| r0_15(glval) = VariableAddress[z] : -# 10| r0_16(glval) = VariableAddress[y] : -# 10| r0_17(Int32) = Load : &:r0_16, ~mu0_2 -# 10| mu0_18(Int32) = Store : &:r0_15, r0_17 -# 5| v0_19(Void) = ReturnVoid : -# 5| v0_20(Void) = UnmodeledUse : mu* -# 5| v0_21(Void) = AliasedUse : ~mu0_2 -# 5| v0_22(Void) = ExitFunction : +# 5| v5_1(Void) = EnterFunction : +# 5| mu5_2() = AliasedDefinition : +# 5| mu5_3() = UnmodeledDefinition : +# 7| r7_1(glval) = VariableAddress[x] : +# 7| mu7_2(Int32) = Uninitialized[x] : &:r7_1 +# 7| r7_3(glval) = VariableAddress[y] : +# 7| r7_4(Int32) = Constant[5] : +# 7| mu7_5(Int32) = Store : &:r7_3, r7_4 +# 8| r8_1(Int32) = Constant[4] : +# 8| r8_2(glval) = VariableAddress[x] : +# 8| mu8_3(Int32) = Store : &:r8_2, r8_1 +# 9| r9_1(glval) = VariableAddress[y] : +# 9| r9_2(Int32) = Load : &:r9_1, ~mu5_3 +# 9| r9_3(glval) = VariableAddress[x] : +# 9| mu9_4(Int32) = Store : &:r9_3, r9_2 +# 10| r10_1(glval) = VariableAddress[z] : +# 10| r10_2(glval) = VariableAddress[y] : +# 10| r10_3(Int32) = Load : &:r10_2, ~mu5_3 +# 10| mu10_4(Int32) = Store : &:r10_1, r10_3 +# 5| v5_4(Void) = ReturnVoid : +# 5| v5_5(Void) = UnmodeledUse : mu* +# 5| v5_6(Void) = AliasedUse : ~mu5_3 +# 5| v5_7(Void) = ExitFunction : diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.cs b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.cs similarity index 100% rename from csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.cs rename to csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.cs diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.expected b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.expected similarity index 100% rename from csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.expected rename to csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.expected diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.qlref b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.qlref similarity index 100% rename from csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength.qlref rename to csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/ASPNetMaxRequestLength.qlref diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/Web.config b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/Web.config similarity index 100% rename from csharp/ql/test/query-tests/Security Features/CWE-016/Web.config rename to csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/Web.config diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/bad/Web.config b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/bad/Web.config similarity index 100% rename from csharp/ql/test/query-tests/Security Features/CWE-016/bad/Web.config rename to csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetMaxRequestLength/bad/Web.config diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.expected b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.expected new file mode 100644 index 00000000000..3309db50b8d --- /dev/null +++ b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.expected @@ -0,0 +1 @@ +| ASPNetRequestValidationModeBad.config:3:5:3:47 | requestValidationMode=4.0 | Insecure value for requestValidationMode (4.0). | diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.qlref b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.qlref new file mode 100644 index 00000000000..86ac5072842 --- /dev/null +++ b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationMode.qlref @@ -0,0 +1 @@ +Security Features/CWE-016/ASPNetRequestValidationMode.ql \ No newline at end of file diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeBad.config b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeBad.config new file mode 100644 index 00000000000..e2c8b8dc903 --- /dev/null +++ b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeBad.config @@ -0,0 +1,5 @@ + + + + + diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeGood.config b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeGood.config new file mode 100644 index 00000000000..b050797ecc2 --- /dev/null +++ b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/ASPNetRequestValidationModeGood.config @@ -0,0 +1,5 @@ + + + + + diff --git a/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/Program.cs b/csharp/ql/test/query-tests/Security Features/CWE-016/ASPNetRequestValidationMode/Program.cs new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/language/learn-ql/cpp/dataflow.rst b/docs/language/learn-ql/cpp/dataflow.rst index 89f25913fbc..f8d4c9c7611 100644 --- a/docs/language/learn-ql/cpp/dataflow.rst +++ b/docs/language/learn-ql/cpp/dataflow.rst @@ -244,6 +244,49 @@ The following data flow configuration tracks data flow from environment variable select fopen, "This 'fopen' uses data from $@.", getenv, "call to 'getenv'" +The following taint-tracking configuration tracks data from a call to ``ntohl`` to an array index operation. It uses the ``Guards`` library to recognize expressions that have been bounds-checked, and defines ``isSanitizer`` to prevent taint from propagating through them. It also uses ``isAdditionalTaintStep`` to add flow from loop bounds to loop indexes. + +.. code-block:: ql + + import cpp + import semmle.code.cpp.controlflow.Guards + import semmle.code.cpp.dataflow.TaintTracking + + class NetworkToBufferSizeConfiguration extends TaintTracking::Configuration { + NetworkToBufferSizeConfiguration() { this = "NetworkToBufferSizeConfiguration" } + + override predicate isSource(DataFlow::Node node) { + node.asExpr().(FunctionCall).getTarget().hasGlobalName("ntohl") + } + + override predicate isSink(DataFlow::Node node) { + exists(ArrayExpr ae | node.asExpr() = ae.getArrayOffset()) + } + + override predicate isAdditionalTaintStep(DataFlow::Node pred, DataFlow::Node succ) { + exists(Loop loop, LoopCounter lc | + loop = lc.getALoop() and + loop.getControllingExpr().(RelationalOperation).getGreaterOperand() = pred.asExpr() | + succ.asExpr() = lc.getVariableAccessInLoop(loop) + ) + } + + override predicate isSanitizer(DataFlow::Node node) { + exists(GuardCondition gc, Variable v | + gc.getAChild*() = v.getAnAccess() and + node.asExpr() = v.getAnAccess() and + gc.controls(node.asExpr().getBasicBlock(), _) + ) + } + } + + from DataFlow::Node ntohl, DataFlow::Node offset, NetworkToBufferSizeConfiguration conf + where conf.hasFlow(ntohl, offset) + select offset, "This array offset may be influenced by $@.", ntohl, + "converted data from the network" + + + Exercises ~~~~~~~~~ diff --git a/docs/language/learn-ql/ql-training.rst b/docs/language/learn-ql/ql-training.rst index 0972df7719a..70aeb21f69a 100644 --- a/docs/language/learn-ql/ql-training.rst +++ b/docs/language/learn-ql/ql-training.rst @@ -6,7 +6,7 @@ CodeQL and variant analysis `Variant analysis `__ is the process of using a known vulnerability as a seed to find similar problems in your code. Security engineers typically perform variant analysis to identify possible vulnerabilities and to ensure that these threats are properly fixed across multiple code bases. -`CodeQL `__ is the code analysis engine that underpins LGTM, Semmle's community driven security analysis platform. Together, CodeQL and LGTM provide continuous monitoring and scalable variant analysis for your projects, even if you don’t have your own team of dedicated security engineers. You can read more about using CodeQL and LGTM in variant analysis in the `Semmle blog `__. +`CodeQL `__ is the code analysis engine that underpins LGTM, Semmle's community driven security analysis platform. Together, CodeQL and LGTM provide continuous monitoring and scalable variant analysis for your projects, even if you don’t have your own team of dedicated security engineers. You can read more about using CodeQL and LGTM in variant analysis on the `Security Lab research page `__. CodeQL is easy to learn, and exploring code using CodeQL is the most efficient way to perform variant analysis. @@ -62,5 +62,4 @@ More resources - If you are completely new to CodeQL, look at our introductory topics in :doc:`Learning CodeQL `. - To find more detailed information about how to write queries for specific languages, visit the links in :ref:`Writing CodeQL queries `. -- To read more about how CodeQL queries have been used in Semmle's security research, and to read about new CodeQL developments, visit the `Semmle blog `__. -- Find more examples of queries written by Semmle's own security researchers in the `Semmle Demos repository `__ on GitHub. +- To see examples of CodeQL queries that have been used to find security vulnerabilities and bugs in open-source software projects, visit the `GitHub Security Lab website `__ and the associated `repository `__. \ No newline at end of file diff --git a/docs/language/learn-ql/writing-queries/introduction-to-queries.rst b/docs/language/learn-ql/writing-queries/introduction-to-queries.rst index d9ce2786a1f..abf8b942ecd 100644 --- a/docs/language/learn-ql/writing-queries/introduction-to-queries.rst +++ b/docs/language/learn-ql/writing-queries/introduction-to-queries.rst @@ -136,7 +136,7 @@ When you write a custom query, we also recommend that you write a query help fil What next? ========== -- See the queries used in real-life variant analysis on the `Semmle blog `__. +- See the queries used in real-life variant analysis on the `GitHub Security Lab website `__. - To learn more about writing path queries, see :doc:`Constructing path queries `. - Take a look at the `built-in queries `__ to see examples of the queries included in CodeQL. - Explore the `query cookbooks `__ to see how to access the basic language elements contained in the CodeQL libraries. diff --git a/docs/language/learn-ql/writing-queries/path-queries.rst b/docs/language/learn-ql/writing-queries/path-queries.rst index 90ef486efe9..7b3d52515c3 100644 --- a/docs/language/learn-ql/writing-queries/path-queries.rst +++ b/docs/language/learn-ql/writing-queries/path-queries.rst @@ -37,7 +37,7 @@ The easiest way to get started writing your own path query is to modify one of t - `JavaScript path queries `__ - `Python path queries `__ -The Semmle security research team have used path queries to find security vulnerabilities in various open source projects. To see articles describing how these queries were written, as well as other posts describing other aspects of security research such as exploiting vulnerabilities, browse the security posts on the `Semmle blog `__. +The Security Lab researchers have used path queries to find security vulnerabilities in various open source projects. To see articles describing how these queries were written, as well as other posts describing other aspects of security research such as exploiting vulnerabilities, see the `GitHub Security Lab website `__. Constructing a path query ========================= diff --git a/docs/language/learn-ql/writing-queries/writing-queries.rst b/docs/language/learn-ql/writing-queries/writing-queries.rst index bd183641b47..c51601b6838 100644 --- a/docs/language/learn-ql/writing-queries/writing-queries.rst +++ b/docs/language/learn-ql/writing-queries/writing-queries.rst @@ -33,7 +33,7 @@ Viewing existing CodeQL queries The easiest way to get started writing your own queries is to modify an existing query. To see these queries, or to try out the CodeQL query cookbooks, visit `Exploring CodeQL queries `__. You can also find all the CodeQL queries in our `open source repository on GitHub `__. -You can also find examples of queries developed to find security vulnerabilities and bugs in open-source software projects in the `Semmle demos GitHub repository `__ and the `Semmle blog `__. +You can also find examples of queries developed to find security vulnerabilities and bugs in open-source software projects on the `GitHub Security Lab website `__ and in the associated `repository `__. Contributing queries ******************** diff --git a/docs/language/ql-training/cpp/snprintf.rst b/docs/language/ql-training/cpp/snprintf.rst index c15bf74d286..3b76f1a4ce2 100644 --- a/docs/language/ql-training/cpp/snprintf.rst +++ b/docs/language/ql-training/cpp/snprintf.rst @@ -65,7 +65,7 @@ RCE in rsyslog } - Disclosed as `CVE-2018-1000140 `__. -- Blog post: `https://blog.semmle.com/librelp-buffer-overflow-cve-2018-1000140/ `__. +- Blog post: https://securitylab.github.com/research/librelp-buffer-overflow-cve-2018-1000140 Finding the RCE yourself ======================== diff --git a/docs/language/ql-training/java/apache-struts-java.rst b/docs/language/ql-training/java/apache-struts-java.rst index be071d41562..c21ad4608ca 100644 --- a/docs/language/ql-training/java/apache-struts-java.rst +++ b/docs/language/ql-training/java/apache-struts-java.rst @@ -58,7 +58,7 @@ RCE in Apache Struts - Disclosed as `CVE-2017-9805 `__ -- Blog post: https://blog.semmle.com/apache-struts-vulnerability-cve-2017-9805/ +- Blog post: https://securitylab.github.com/research/apache-struts-vulnerability-cve-2017-9805 Finding the RCE yourself ======================== @@ -134,4 +134,4 @@ Model answer, step 4 and sink.getNode() instanceof UnsafeDeserializationSink select sink.getNode().(UnsafeDeserializationSink).getMethodAccess(), source, sink, "Unsafe deserialization of $@.", source, "user input" -More full-featured version: https://github.com/Semmle/demos/tree/master/ql_demos/java/Apache_Struts_CVE-2017-9805 \ No newline at end of file +More full-featured version: https://github.com/github/security-lab/tree/master/CodeQL_Queries/java/Apache_Struts_CVE-2017-9805 \ No newline at end of file diff --git a/docs/language/ql-training/java/global-data-flow-java.rst b/docs/language/ql-training/java/global-data-flow-java.rst index 9edacde93c3..d65fd6133c5 100644 --- a/docs/language/ql-training/java/global-data-flow-java.rst +++ b/docs/language/ql-training/java/global-data-flow-java.rst @@ -53,8 +53,8 @@ Code injection in Apache struts .. note:: - More details on the CVE can be found here: https://blog.semmle.com/apache-struts-CVE-2018-11776/ and - https://github.com/Semmle/demos/tree/master/ql_demos/java/Apache_Struts_CVE-2018-11776 + More details on the CVE can be found here: https://securitylab.github.com/research/apache-struts-CVE-2018-11776 and + https://github.com/github/security-lab/tree/master/CodeQL_Queries/java/Apache_Struts_CVE-2018-11776 More details on OGNL can be found here: https://commons.apache.org/proper/commons-ognl/ diff --git a/docs/query-metadata-style-guide.md b/docs/query-metadata-style-guide.md index d5f5606002c..70cb083cb1a 100644 --- a/docs/query-metadata-style-guide.md +++ b/docs/query-metadata-style-guide.md @@ -113,7 +113,7 @@ Alert queries (`@kind problem` or `path-problem`) support two further properties * `low ` * `medium ` * `high ` - * `very high` + * `very-high` * `@problem.severity`–defines the level of severity of the alert: * `error`–an issue that is likely to cause incorrect program behavior, for example a crash or vulnerability. * `warning`–an issue that indicates a potential problem in the code, or makes the code fragile if another (unrelated) part of code is changed. diff --git a/java/ql/src/Security/CWE/CWE-078/ExecTainted.ql b/java/ql/src/Security/CWE/CWE-078/ExecTainted.ql index 8774de339b6..353df33afed 100644 --- a/java/ql/src/Security/CWE/CWE-078/ExecTainted.ql +++ b/java/ql/src/Security/CWE/CWE-078/ExecTainted.ql @@ -11,7 +11,7 @@ * external/cwe/cwe-088 */ -import semmle.code.java.Expr +import java import semmle.code.java.dataflow.FlowSources import semmle.code.java.security.ExternalProcess import ExecCommon diff --git a/java/ql/src/Security/CWE/CWE-078/ExecUnescaped.ql b/java/ql/src/Security/CWE/CWE-078/ExecUnescaped.ql index e80afa7f6eb..a0fa793872f 100644 --- a/java/ql/src/Security/CWE/CWE-078/ExecUnescaped.ql +++ b/java/ql/src/Security/CWE/CWE-078/ExecUnescaped.ql @@ -11,7 +11,7 @@ * external/cwe/cwe-088 */ -import semmle.code.java.Expr +import java import semmle.code.java.security.ExternalProcess import ExecCommon diff --git a/java/ql/src/Security/CWE/CWE-089/SqlTainted.ql b/java/ql/src/Security/CWE/CWE-089/SqlTainted.ql index 5b79c56a83c..5750829d7d6 100644 --- a/java/ql/src/Security/CWE/CWE-089/SqlTainted.ql +++ b/java/ql/src/Security/CWE/CWE-089/SqlTainted.ql @@ -10,7 +10,7 @@ * external/cwe/cwe-089 */ -import semmle.code.java.Expr +import java import semmle.code.java.dataflow.FlowSources import SqlInjectionLib import DataFlow::PathGraph diff --git a/java/ql/src/Security/CWE/CWE-089/SqlUnescaped.ql b/java/ql/src/Security/CWE/CWE-089/SqlUnescaped.ql index 83eaa50ea2c..e721cb7fba6 100644 --- a/java/ql/src/Security/CWE/CWE-089/SqlUnescaped.ql +++ b/java/ql/src/Security/CWE/CWE-089/SqlUnescaped.ql @@ -10,6 +10,7 @@ * external/cwe/cwe-089 */ +import java import semmle.code.java.security.SqlUnescapedLib import SqlInjectionLib diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl.qll index 9519a74265f..1f322a02201 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl2.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl2.qll index 9519a74265f..1f322a02201 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl2.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl2.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl3.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl3.qll index 9519a74265f..1f322a02201 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl3.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl3.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl4.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl4.qll index 9519a74265f..1f322a02201 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl4.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl4.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl5.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl5.qll index 9519a74265f..1f322a02201 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl5.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImpl5.qll @@ -510,13 +510,20 @@ private predicate simpleParameterFlow( pragma[noinline] private predicate simpleArgumentFlowsThrough0( + ParameterNode p, ReturnNode ret, ReturnKind kind, DataFlowType t, Configuration config +) { + simpleParameterFlow(p, ret, t, config) and + kind = ret.getKind() +} + +pragma[noinline] +private predicate simpleArgumentFlowsThrough1( DataFlowCall call, ArgumentNode arg, ReturnKind kind, DataFlowType t, Configuration config ) { nodeCand1(arg, unbind(config)) and not outBarrier(arg, config) and exists(ParameterNode p, ReturnNode ret | - simpleParameterFlow(p, ret, t, config) and - kind = ret.getKind() and + simpleArgumentFlowsThrough0(p, ret, kind, t, config) and viableParamArg(call, p, arg) ) } @@ -534,7 +541,7 @@ private predicate simpleArgumentFlowsThrough( exists(DataFlowCall call, ReturnKind kind | nodeCand1(out, unbind(config)) and not inBarrier(out, config) and - simpleArgumentFlowsThrough0(call, arg, kind, t, config) and + simpleArgumentFlowsThrough1(call, arg, kind, t, config) and out = getAnOutNode(call, kind) ) } diff --git a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImplCommon.qll b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImplCommon.qll index 91f5aeacc9d..87b33a79b8b 100644 --- a/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImplCommon.qll +++ b/java/ql/src/semmle/code/java/dataflow/internal/DataFlowImplCommon.qll @@ -360,7 +360,7 @@ private module ImplCommon { */ cached predicate read(Node node1, Content f, Node node2) { - readStep(node1, f, node2) and storeStep(_, f, _) + readStep(node1, f, node2) or exists(DataFlowCall call, ReturnKind kind | read0(call, kind, node1, f) and diff --git a/java/ql/test/library-tests/dataflow/fields/E.java b/java/ql/test/library-tests/dataflow/fields/E.java new file mode 100644 index 00000000000..3e825cfc8b3 --- /dev/null +++ b/java/ql/test/library-tests/dataflow/fields/E.java @@ -0,0 +1,32 @@ +public class E { + static Object src() { return new Object(); } + static void sink(Object obj) {} + + static class Buffer { Object content; } + static class BufHolder { Buffer buf; } + static class Packet { BufHolder data; } + + static void recv(Buffer buf) { + buf.content = src(); + } + + static void foo(Buffer raw, BufHolder bh, Packet p) { + recv(raw); + recv(bh.buf); + recv(p.data.buf); + + sink(raw.content); + + BufHolder bh2 = bh; + sink(bh2.buf.content); + + Packet p2 = p; + sink(p2.data.buf.content); + + handlepacket(p); + } + + static void handlepacket(Packet p) { + sink(p.data.buf.content); + } +} diff --git a/java/ql/test/library-tests/dataflow/fields/flow.expected b/java/ql/test/library-tests/dataflow/fields/flow.expected index 6c107f0752d..2cd605f1dea 100644 --- a/java/ql/test/library-tests/dataflow/fields/flow.expected +++ b/java/ql/test/library-tests/dataflow/fields/flow.expected @@ -22,3 +22,7 @@ | D.java:19:14:19:23 | new Elem(...) | D.java:33:10:33:31 | getElem(...) | | D.java:26:14:26:23 | new Elem(...) | D.java:33:10:33:31 | getElem(...) | | D.java:37:14:37:23 | new Elem(...) | D.java:44:10:44:26 | boxfield.box.elem | +| E.java:2:32:2:43 | new Object(...) | E.java:18:10:18:20 | raw.content | +| E.java:2:32:2:43 | new Object(...) | E.java:21:10:21:24 | bh2.buf.content | +| E.java:2:32:2:43 | new Object(...) | E.java:24:10:24:28 | p2.data.buf.content | +| E.java:2:32:2:43 | new Object(...) | E.java:30:10:30:27 | p.data.buf.content | diff --git a/java/ql/test/query-tests/EmptyInterface/EmptyInterface.expected b/java/ql/test/query-tests/EmptyInterface/EmptyInterface.expected deleted file mode 100644 index 5af84a6766d..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/EmptyInterface.expected +++ /dev/null @@ -1,3 +0,0 @@ -| IAmBad.java:1:18:1:23 | IAmBad | Do not use empty interfaces; put some of the behavior in the interface or (better) an abstract superclass. | -| IAmBadAsWell.java:1:18:1:29 | IAmBadAsWell | Do not use empty interfaces; put some of the behavior in the interface or (better) an abstract superclass. | -| IAmBadToo.java:1:18:1:26 | IAmBadToo | Do not use empty interfaces; put some of the behavior in the interface or (better) an abstract superclass. | diff --git a/java/ql/test/query-tests/EmptyInterface/EmptyInterface.qlref b/java/ql/test/query-tests/EmptyInterface/EmptyInterface.qlref deleted file mode 100644 index b891ccc4e97..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/EmptyInterface.qlref +++ /dev/null @@ -1 +0,0 @@ -general/EmptyInterface.ql \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmAlsoOK.java b/java/ql/test/query-tests/EmptyInterface/IAmAlsoOK.java deleted file mode 100644 index 5e58dd9bdde..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmAlsoOK.java +++ /dev/null @@ -1 +0,0 @@ -public interface IAmAlsoOK extends java.util.Collection {} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmBad.java b/java/ql/test/query-tests/EmptyInterface/IAmBad.java deleted file mode 100644 index 2c2de4fdb4d..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmBad.java +++ /dev/null @@ -1 +0,0 @@ -public interface IAmBad {} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmBadAsWell.java b/java/ql/test/query-tests/EmptyInterface/IAmBadAsWell.java deleted file mode 100644 index 3280300f531..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmBadAsWell.java +++ /dev/null @@ -1 +0,0 @@ -public interface IAmBadAsWell {} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmBadToo.java b/java/ql/test/query-tests/EmptyInterface/IAmBadToo.java deleted file mode 100644 index efa8664a8dd..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmBadToo.java +++ /dev/null @@ -1 +0,0 @@ -public interface IAmBadToo extends IAmBad {} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmNonEmpty.java b/java/ql/test/query-tests/EmptyInterface/IAmNonEmpty.java deleted file mode 100644 index c47df10be64..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmNonEmpty.java +++ /dev/null @@ -1,3 +0,0 @@ -public interface IAmNonEmpty { - public void m(); -} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyAsWell.java b/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyAsWell.java deleted file mode 100644 index 0ae9f728a58..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyAsWell.java +++ /dev/null @@ -1,5 +0,0 @@ -public interface IAmNonEmptyAsWell { - public class C { - int x; - } -} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyToo.java b/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyToo.java deleted file mode 100644 index 089fa0a13ed..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmNonEmptyToo.java +++ /dev/null @@ -1,3 +0,0 @@ -public interface IAmNonEmptyToo { - public String hello = "world"; -} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmOK.java b/java/ql/test/query-tests/EmptyInterface/IAmOK.java deleted file mode 100644 index 1a7ba87f8e4..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmOK.java +++ /dev/null @@ -1 +0,0 @@ -public interface IAmOK extends IAmBad, IAmBadToo {} \ No newline at end of file diff --git a/java/ql/test/query-tests/EmptyInterface/IAmUseful.java b/java/ql/test/query-tests/EmptyInterface/IAmUseful.java deleted file mode 100644 index 06aeeaf698a..00000000000 --- a/java/ql/test/query-tests/EmptyInterface/IAmUseful.java +++ /dev/null @@ -1 +0,0 @@ -public @interface IAmUseful {} \ No newline at end of file diff --git a/javascript/extractor/src/com/semmle/jcorn/flow/FlowParser.java b/javascript/extractor/src/com/semmle/jcorn/flow/FlowParser.java index 65a9dce89a3..fbd428e47df 100644 --- a/javascript/extractor/src/com/semmle/jcorn/flow/FlowParser.java +++ b/javascript/extractor/src/com/semmle/jcorn/flow/FlowParser.java @@ -541,7 +541,11 @@ public class FlowParser extends ESNextParser { if (isStatic && this.type == TokenType.colon) { this.parseIdent(false); } else if (allowSpread && this.eat(TokenType.ellipsis)) { - flowParseType(); + boolean hasType = + this.type != endDelim && this.type != TokenType.comma && this.type != TokenType.semi; + if (hasType) { + flowParseType(); + } flowObjectTypeSemicolon(); continue; } else { diff --git a/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java b/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java index 3a4160c2d1f..a57874201cb 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java +++ b/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java @@ -21,8 +21,10 @@ import com.semmle.util.language.LegacyLanguage; import com.semmle.util.process.Env; import com.semmle.util.projectstructure.ProjectLayout; import com.semmle.util.trap.TrapWriter; +import java.io.BufferedReader; import java.io.File; import java.io.IOException; +import java.io.InputStreamReader; import java.io.Reader; import java.lang.ProcessBuilder.Redirect; import java.net.URI; @@ -195,15 +197,25 @@ public class AutoBuild { private final String defaultEncoding; private ExecutorService threadPool; private volatile boolean seenCode = false; + private boolean installDependencies = false; + private int installDependenciesTimeout; + + /** The default timeout when running yarn, in milliseconds. */ + public static final int INSTALL_DEPENDENCIES_DEFAULT_TIMEOUT = 10 * 60 * 1000; // 10 minutes public AutoBuild() { this.LGTM_SRC = toRealPath(getPathFromEnvVar("LGTM_SRC")); - this.SEMMLE_DIST = getPathFromEnvVar(Env.Var.SEMMLE_DIST.toString()); + this.SEMMLE_DIST = Paths.get(EnvironmentVariables.getExtractorRoot()); this.outputConfig = new ExtractorOutputConfig(LegacyLanguage.JAVASCRIPT); this.trapCache = mkTrapCache(); this.typeScriptMode = getEnumFromEnvVar("LGTM_INDEX_TYPESCRIPT", TypeScriptMode.class, TypeScriptMode.FULL); this.defaultEncoding = getEnvVar("LGTM_INDEX_DEFAULT_ENCODING"); + this.installDependencies = Boolean.valueOf(getEnvVar("LGTM_INDEX_TYPESCRIPT_INSTALL_DEPS")); + this.installDependenciesTimeout = + Env.systemEnv() + .getInt( + "LGTM_INDEX_TYPESCRIPT_INSTALL_DEPS_TIMEOUT", INSTALL_DEPENDENCIES_DEFAULT_TIMEOUT); setupFileTypes(); setupXmlMode(); setupMatchers(); @@ -533,6 +545,10 @@ public class AutoBuild { List tsconfigFiles = new ArrayList<>(); findFilesToExtract(defaultExtractor, filesToExtract, tsconfigFiles); + if (!tsconfigFiles.isEmpty() && this.installDependencies) { + this.installDependencies(filesToExtract); + } + // extract TypeScript projects and files Set extractedFiles = extractTypeScript(defaultExtractor, filesToExtract, tsconfigFiles); @@ -549,6 +565,61 @@ public class AutoBuild { } } + /** Returns true if yarn is installed, otherwise prints a warning and returns false. */ + private boolean verifyYarnInstallation() { + ProcessBuilder pb = new ProcessBuilder(Arrays.asList("yarn", "-v")); + try { + Process process = pb.start(); + boolean completed = process.waitFor(this.installDependenciesTimeout, TimeUnit.MILLISECONDS); + if (!completed) { + System.err.println("Yarn could not be launched. Timeout during 'yarn -v'."); + return false; + } + BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); + String version = reader.readLine(); + System.out.println("Found yarn version: " + version); + return true; + } catch (IOException | InterruptedException ex) { + System.err.println( + "Yarn not found. Please put 'yarn' on the PATH for automatic dependency installation."); + Exceptions.ignore(ex, "Continue without dependency installation"); + return false; + } + } + + protected void installDependencies(Set filesToExtract) { + if (!verifyYarnInstallation()) { + return; + } + for (Path file : filesToExtract) { + if (file.getFileName().toString().equals("package.json")) { + System.out.println("Installing dependencies from " + file); + ProcessBuilder pb = + new ProcessBuilder( + Arrays.asList( + "yarn", + "install", + "--verbose", + "--non-interactive", + "--ignore-scripts", + "--ignore-platform", + "--ignore-engines", + "--ignore-optional", + "--no-default-rc", + "--no-bin-links", + "--pure-lockfile")); + pb.directory(file.getParent().toFile()); + pb.redirectOutput(Redirect.INHERIT); + pb.redirectError(Redirect.INHERIT); + try { + pb.start().waitFor(this.installDependenciesTimeout, TimeUnit.MILLISECONDS); + } catch (IOException | InterruptedException ex) { + throw new ResourceError("Could not install dependencies from " + file, ex); + } + } + } + } + private ExtractorConfig mkExtractorConfig() { ExtractorConfig config = new ExtractorConfig(true); config = config.withSourceType(getSourceType()); diff --git a/javascript/extractor/src/com/semmle/js/extractor/EnvironmentVariables.java b/javascript/extractor/src/com/semmle/js/extractor/EnvironmentVariables.java new file mode 100644 index 00000000000..4f991c42fa7 --- /dev/null +++ b/javascript/extractor/src/com/semmle/js/extractor/EnvironmentVariables.java @@ -0,0 +1,34 @@ +package com.semmle.js.extractor; + +import com.semmle.util.exception.UserError; +import com.semmle.util.process.Env; +import com.semmle.util.process.Env.Var; + +public class EnvironmentVariables { + public static final String CODEQL_EXTRACTOR_JAVASCRIPT_ROOT_ENV_VAR = + "CODEQL_EXTRACTOR_JAVASCRIPT_ROOT"; + + /** + * Gets the extractor root based on the CODEQL_EXTRACTOR_JAVASCRIPT_ROOT or + * SEMMLE_DIST or environment variable, or null if neither is set. + */ + public static String tryGetExtractorRoot() { + String env = Env.systemEnv().get(CODEQL_EXTRACTOR_JAVASCRIPT_ROOT_ENV_VAR); + if (env != null && !env.isEmpty()) return env; + env = Env.systemEnv().get(Var.SEMMLE_DIST); + if (env != null && !env.isEmpty()) return env; + return null; + } + + /** + * Gets the extractor root based on the CODEQL_EXTRACTOR_JAVASCRIPT_ROOT or + * SEMMLE_DIST or environment variable, or throws a UserError if neither is set. + */ + public static String getExtractorRoot() { + String env = tryGetExtractorRoot(); + if (env == null) { + throw new UserError("SEMMLE_DIST or CODEQL_EXTRACTOR_JAVASCRIPT_ROOT must be set"); + } + return env; + } +} diff --git a/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java b/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java index 308713c0c1a..cacc6b6cc9c 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java +++ b/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java @@ -1,16 +1,5 @@ package com.semmle.js.extractor; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileReader; -import java.io.IOException; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.util.LinkedHashSet; -import java.util.Set; -import java.util.regex.Pattern; - import com.semmle.js.extractor.ExtractionMetrics.ExtractionPhase; import com.semmle.js.extractor.trapcache.CachingTrapWriter; import com.semmle.js.extractor.trapcache.ITrapCache; @@ -21,6 +10,16 @@ import com.semmle.util.files.FileUtil; import com.semmle.util.io.WholeIO; import com.semmle.util.trap.TrapWriter; import com.semmle.util.trap.TrapWriter.Label; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.regex.Pattern; /** * The file extractor extracts a single file and handles source archive population and TRAP caching; @@ -156,8 +155,7 @@ public class FileExtractor { byte[] bytes = new byte[fileHeaderSize]; int length = fis.read(bytes); - if (length == -1) - return false; + if (length == -1) return false; // Avoid invalid or unprintable UTF-8 files. if (config.getDefaultEncoding().equals("UTF-8") && hasUnprintableUtf8(bytes, length)) { diff --git a/javascript/extractor/src/com/semmle/js/extractor/Main.java b/javascript/extractor/src/com/semmle/js/extractor/Main.java index 0a99e242ee9..8dc988c10d1 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/Main.java +++ b/javascript/extractor/src/com/semmle/js/extractor/Main.java @@ -37,7 +37,7 @@ public class Main { * A version identifier that should be updated every time the extractor changes in such a way that * it may produce different tuples for the same file under the same {@link ExtractorConfig}. */ - public static final String EXTRACTOR_VERSION = "2019-11-19"; + public static final String EXTRACTOR_VERSION = "2019-11-26"; public static final Pattern NEWLINE = Pattern.compile("\n"); diff --git a/javascript/extractor/src/com/semmle/js/extractor/test/AutoBuildTests.java b/javascript/extractor/src/com/semmle/js/extractor/test/AutoBuildTests.java index 8db4ca22da5..3e39cfc6706 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/test/AutoBuildTests.java +++ b/javascript/extractor/src/com/semmle/js/extractor/test/AutoBuildTests.java @@ -128,6 +128,11 @@ public class AutoBuildTests { } } + @Override + protected void installDependencies(Set filesToExtract) { + // never install dependencies during testing + } + @Override protected void extractXml() throws IOException { Files.walkFileTree( diff --git a/javascript/extractor/src/com/semmle/js/parser/TypeScriptParser.java b/javascript/extractor/src/com/semmle/js/parser/TypeScriptParser.java index 091806f4519..93a241b1e3d 100644 --- a/javascript/extractor/src/com/semmle/js/parser/TypeScriptParser.java +++ b/javascript/extractor/src/com/semmle/js/parser/TypeScriptParser.java @@ -7,6 +7,7 @@ import com.google.gson.JsonObject; import com.google.gson.JsonParseException; import com.google.gson.JsonParser; import com.google.gson.JsonPrimitive; +import com.semmle.js.extractor.EnvironmentVariables; import com.semmle.js.extractor.ExtractionMetrics; import com.semmle.js.parser.JSParser.Result; import com.semmle.ts.extractor.TypeTable; @@ -290,14 +291,12 @@ public class TypeScriptParser { File parserWrapper; LogbackUtils.getLogger(AbstractProcessBuilder.class).setLevel(Level.INFO); String explicitPath = Env.systemEnv().get(PARSER_WRAPPER_PATH_ENV_VAR); - String semmleDistVar = Env.systemEnv().get(Env.Var.SEMMLE_DIST.name()); if (explicitPath != null) { parserWrapper = new File(explicitPath); - } else if (semmleDistVar != null && !semmleDistVar.isEmpty()) { - parserWrapper = new File(semmleDistVar, "tools/typescript-parser-wrapper/main.js"); } else { - throw new CatastrophicError( - "Could not find TypeScript parser: " + Env.Var.SEMMLE_DIST.name() + " is not set."); + parserWrapper = + new File( + EnvironmentVariables.getExtractorRoot(), "tools/typescript-parser-wrapper/main.js"); } if (!parserWrapper.isFile()) throw new ResourceError( diff --git a/javascript/extractor/tests/flow/input/objectTypeSpread.js b/javascript/extractor/tests/flow/input/objectTypeSpread.js index 955c4c22272..9730c6c49be 100644 --- a/javascript/extractor/tests/flow/input/objectTypeSpread.js +++ b/javascript/extractor/tests/flow/input/objectTypeSpread.js @@ -1,2 +1,4 @@ type A = { x: int }; -type B = { ...A, y: string }; \ No newline at end of file +type B = { ...A, y: string }; +type C = {c: null | T, ...} | ((r: null | T) => mixed); +type D = { d: D, ..., }; \ No newline at end of file diff --git a/javascript/extractor/tests/flow/output/trap/objectTypeSpread.js.trap b/javascript/extractor/tests/flow/output/trap/objectTypeSpread.js.trap index b3a181e0469..f7c948b9ba8 100644 --- a/javascript/extractor/tests/flow/output/trap/objectTypeSpread.js.trap +++ b/javascript/extractor/tests/flow/output/trap/objectTypeSpread.js.trap @@ -16,133 +16,345 @@ lines(#20002,#20001,"type A = { x: int };"," locations_default(#20003,#10000,1,1,1,20) hasLocation(#20002,#20003) #20004=* -lines(#20004,#20001,"type B = { ...A, y: string };","") +lines(#20004,#20001,"type B = { ...A, y: string };"," +") #20005=@"loc,{#10000},2,1,2,29" locations_default(#20005,#10000,2,1,2,29) hasLocation(#20004,#20005) -numlines(#20001,2,2,0) #20006=* -tokeninfo(#20006,6,#20001,0,"type") -#20007=@"loc,{#10000},1,1,1,4" -locations_default(#20007,#10000,1,1,1,4) +lines(#20006,#20001,"type C = {c: null | T, ...} | ((r: null | T) => mixed);"," +") +#20007=@"loc,{#10000},3,1,3,58" +locations_default(#20007,#10000,3,1,3,58) hasLocation(#20006,#20007) #20008=* -tokeninfo(#20008,6,#20001,1,"A") -#20009=@"loc,{#10000},1,6,1,6" -locations_default(#20009,#10000,1,6,1,6) +lines(#20008,#20001,"type D = { d: D, ..., };","") +#20009=@"loc,{#10000},4,1,4,24" +locations_default(#20009,#10000,4,1,4,24) hasLocation(#20008,#20009) +numlines(#20001,4,4,0) #20010=* -tokeninfo(#20010,8,#20001,2,"=") -#20011=@"loc,{#10000},1,8,1,8" -locations_default(#20011,#10000,1,8,1,8) +tokeninfo(#20010,6,#20001,0,"type") +#20011=@"loc,{#10000},1,1,1,4" +locations_default(#20011,#10000,1,1,1,4) hasLocation(#20010,#20011) #20012=* -tokeninfo(#20012,8,#20001,3,"{") -#20013=@"loc,{#10000},1,10,1,10" -locations_default(#20013,#10000,1,10,1,10) +tokeninfo(#20012,6,#20001,1,"A") +#20013=@"loc,{#10000},1,6,1,6" +locations_default(#20013,#10000,1,6,1,6) hasLocation(#20012,#20013) #20014=* -tokeninfo(#20014,6,#20001,4,"x") -#20015=@"loc,{#10000},1,12,1,12" -locations_default(#20015,#10000,1,12,1,12) +tokeninfo(#20014,8,#20001,2,"=") +#20015=@"loc,{#10000},1,8,1,8" +locations_default(#20015,#10000,1,8,1,8) hasLocation(#20014,#20015) #20016=* -tokeninfo(#20016,8,#20001,5,":") -#20017=@"loc,{#10000},1,13,1,13" -locations_default(#20017,#10000,1,13,1,13) +tokeninfo(#20016,8,#20001,3,"{") +#20017=@"loc,{#10000},1,10,1,10" +locations_default(#20017,#10000,1,10,1,10) hasLocation(#20016,#20017) #20018=* -tokeninfo(#20018,6,#20001,6,"int") -#20019=@"loc,{#10000},1,15,1,17" -locations_default(#20019,#10000,1,15,1,17) +tokeninfo(#20018,6,#20001,4,"x") +#20019=@"loc,{#10000},1,12,1,12" +locations_default(#20019,#10000,1,12,1,12) hasLocation(#20018,#20019) #20020=* -tokeninfo(#20020,8,#20001,7,"}") -#20021=@"loc,{#10000},1,19,1,19" -locations_default(#20021,#10000,1,19,1,19) +tokeninfo(#20020,8,#20001,5,":") +#20021=@"loc,{#10000},1,13,1,13" +locations_default(#20021,#10000,1,13,1,13) hasLocation(#20020,#20021) #20022=* -tokeninfo(#20022,8,#20001,8,";") -#20023=@"loc,{#10000},1,20,1,20" -locations_default(#20023,#10000,1,20,1,20) +tokeninfo(#20022,6,#20001,6,"int") +#20023=@"loc,{#10000},1,15,1,17" +locations_default(#20023,#10000,1,15,1,17) hasLocation(#20022,#20023) #20024=* -tokeninfo(#20024,6,#20001,9,"type") -#20025=@"loc,{#10000},2,1,2,4" -locations_default(#20025,#10000,2,1,2,4) +tokeninfo(#20024,8,#20001,7,"}") +#20025=@"loc,{#10000},1,19,1,19" +locations_default(#20025,#10000,1,19,1,19) hasLocation(#20024,#20025) #20026=* -tokeninfo(#20026,6,#20001,10,"B") -#20027=@"loc,{#10000},2,6,2,6" -locations_default(#20027,#10000,2,6,2,6) +tokeninfo(#20026,8,#20001,8,";") +#20027=@"loc,{#10000},1,20,1,20" +locations_default(#20027,#10000,1,20,1,20) hasLocation(#20026,#20027) #20028=* -tokeninfo(#20028,8,#20001,11,"=") -#20029=@"loc,{#10000},2,8,2,8" -locations_default(#20029,#10000,2,8,2,8) +tokeninfo(#20028,6,#20001,9,"type") +#20029=@"loc,{#10000},2,1,2,4" +locations_default(#20029,#10000,2,1,2,4) hasLocation(#20028,#20029) #20030=* -tokeninfo(#20030,8,#20001,12,"{") -#20031=@"loc,{#10000},2,10,2,10" -locations_default(#20031,#10000,2,10,2,10) +tokeninfo(#20030,6,#20001,10,"B") +#20031=@"loc,{#10000},2,6,2,6" +locations_default(#20031,#10000,2,6,2,6) hasLocation(#20030,#20031) #20032=* -tokeninfo(#20032,8,#20001,13,"...") -#20033=@"loc,{#10000},2,12,2,14" -locations_default(#20033,#10000,2,12,2,14) +tokeninfo(#20032,8,#20001,11,"=") +#20033=@"loc,{#10000},2,8,2,8" +locations_default(#20033,#10000,2,8,2,8) hasLocation(#20032,#20033) #20034=* -tokeninfo(#20034,6,#20001,14,"A") -#20035=@"loc,{#10000},2,15,2,15" -locations_default(#20035,#10000,2,15,2,15) +tokeninfo(#20034,8,#20001,12,"{") +#20035=@"loc,{#10000},2,10,2,10" +locations_default(#20035,#10000,2,10,2,10) hasLocation(#20034,#20035) #20036=* -tokeninfo(#20036,8,#20001,15,",") -#20037=@"loc,{#10000},2,16,2,16" -locations_default(#20037,#10000,2,16,2,16) +tokeninfo(#20036,8,#20001,13,"...") +#20037=@"loc,{#10000},2,12,2,14" +locations_default(#20037,#10000,2,12,2,14) hasLocation(#20036,#20037) #20038=* -tokeninfo(#20038,6,#20001,16,"y") -#20039=@"loc,{#10000},2,18,2,18" -locations_default(#20039,#10000,2,18,2,18) +tokeninfo(#20038,6,#20001,14,"A") +#20039=@"loc,{#10000},2,15,2,15" +locations_default(#20039,#10000,2,15,2,15) hasLocation(#20038,#20039) #20040=* -tokeninfo(#20040,8,#20001,17,":") -#20041=@"loc,{#10000},2,19,2,19" -locations_default(#20041,#10000,2,19,2,19) +tokeninfo(#20040,8,#20001,15,",") +#20041=@"loc,{#10000},2,16,2,16" +locations_default(#20041,#10000,2,16,2,16) hasLocation(#20040,#20041) #20042=* -tokeninfo(#20042,6,#20001,18,"string") -#20043=@"loc,{#10000},2,21,2,26" -locations_default(#20043,#10000,2,21,2,26) +tokeninfo(#20042,6,#20001,16,"y") +#20043=@"loc,{#10000},2,18,2,18" +locations_default(#20043,#10000,2,18,2,18) hasLocation(#20042,#20043) #20044=* -tokeninfo(#20044,8,#20001,19,"}") -#20045=@"loc,{#10000},2,28,2,28" -locations_default(#20045,#10000,2,28,2,28) +tokeninfo(#20044,8,#20001,17,":") +#20045=@"loc,{#10000},2,19,2,19" +locations_default(#20045,#10000,2,19,2,19) hasLocation(#20044,#20045) #20046=* -tokeninfo(#20046,8,#20001,20,";") -#20047=@"loc,{#10000},2,29,2,29" -locations_default(#20047,#10000,2,29,2,29) +tokeninfo(#20046,6,#20001,18,"string") +#20047=@"loc,{#10000},2,21,2,26" +locations_default(#20047,#10000,2,21,2,26) hasLocation(#20046,#20047) #20048=* -tokeninfo(#20048,0,#20001,21,"") -#20049=@"loc,{#10000},2,30,2,29" -locations_default(#20049,#10000,2,30,2,29) +tokeninfo(#20048,8,#20001,19,"}") +#20049=@"loc,{#10000},2,28,2,28" +locations_default(#20049,#10000,2,28,2,28) hasLocation(#20048,#20049) +#20050=* +tokeninfo(#20050,8,#20001,20,";") +#20051=@"loc,{#10000},2,29,2,29" +locations_default(#20051,#10000,2,29,2,29) +hasLocation(#20050,#20051) +#20052=* +tokeninfo(#20052,6,#20001,21,"type") +#20053=@"loc,{#10000},3,1,3,4" +locations_default(#20053,#10000,3,1,3,4) +hasLocation(#20052,#20053) +#20054=* +tokeninfo(#20054,6,#20001,22,"C") +#20055=@"loc,{#10000},3,6,3,6" +locations_default(#20055,#10000,3,6,3,6) +hasLocation(#20054,#20055) +#20056=* +tokeninfo(#20056,8,#20001,23,"<") +#20057=@"loc,{#10000},3,7,3,7" +locations_default(#20057,#10000,3,7,3,7) +hasLocation(#20056,#20057) +#20058=* +tokeninfo(#20058,6,#20001,24,"T") +#20059=@"loc,{#10000},3,8,3,8" +locations_default(#20059,#10000,3,8,3,8) +hasLocation(#20058,#20059) +#20060=* +tokeninfo(#20060,8,#20001,25,">") +#20061=@"loc,{#10000},3,9,3,9" +locations_default(#20061,#10000,3,9,3,9) +hasLocation(#20060,#20061) +#20062=* +tokeninfo(#20062,8,#20001,26,"=") +#20063=@"loc,{#10000},3,11,3,11" +locations_default(#20063,#10000,3,11,3,11) +hasLocation(#20062,#20063) +#20064=* +tokeninfo(#20064,8,#20001,27,"{") +#20065=@"loc,{#10000},3,13,3,13" +locations_default(#20065,#10000,3,13,3,13) +hasLocation(#20064,#20065) +#20066=* +tokeninfo(#20066,6,#20001,28,"c") +#20067=@"loc,{#10000},3,14,3,14" +locations_default(#20067,#10000,3,14,3,14) +hasLocation(#20066,#20067) +#20068=* +tokeninfo(#20068,8,#20001,29,":") +#20069=@"loc,{#10000},3,15,3,15" +locations_default(#20069,#10000,3,15,3,15) +hasLocation(#20068,#20069) +#20070=* +tokeninfo(#20070,1,#20001,30,"null") +#20071=@"loc,{#10000},3,17,3,20" +locations_default(#20071,#10000,3,17,3,20) +hasLocation(#20070,#20071) +#20072=* +tokeninfo(#20072,8,#20001,31,"|") +#20073=@"loc,{#10000},3,22,3,22" +locations_default(#20073,#10000,3,22,3,22) +hasLocation(#20072,#20073) +#20074=* +tokeninfo(#20074,6,#20001,32,"T") +#20075=@"loc,{#10000},3,24,3,24" +locations_default(#20075,#10000,3,24,3,24) +hasLocation(#20074,#20075) +#20076=* +tokeninfo(#20076,8,#20001,33,",") +#20077=@"loc,{#10000},3,25,3,25" +locations_default(#20077,#10000,3,25,3,25) +hasLocation(#20076,#20077) +#20078=* +tokeninfo(#20078,8,#20001,34,"...") +#20079=@"loc,{#10000},3,27,3,29" +locations_default(#20079,#10000,3,27,3,29) +hasLocation(#20078,#20079) +#20080=* +tokeninfo(#20080,8,#20001,35,"}") +#20081=@"loc,{#10000},3,30,3,30" +locations_default(#20081,#10000,3,30,3,30) +hasLocation(#20080,#20081) +#20082=* +tokeninfo(#20082,8,#20001,36,"|") +#20083=@"loc,{#10000},3,32,3,32" +locations_default(#20083,#10000,3,32,3,32) +hasLocation(#20082,#20083) +#20084=* +tokeninfo(#20084,8,#20001,37,"(") +#20085=@"loc,{#10000},3,34,3,34" +locations_default(#20085,#10000,3,34,3,34) +hasLocation(#20084,#20085) +#20086=* +tokeninfo(#20086,8,#20001,38,"(") +#20087=@"loc,{#10000},3,35,3,35" +locations_default(#20087,#10000,3,35,3,35) +hasLocation(#20086,#20087) +#20088=* +tokeninfo(#20088,6,#20001,39,"r") +#20089=@"loc,{#10000},3,36,3,36" +locations_default(#20089,#10000,3,36,3,36) +hasLocation(#20088,#20089) +#20090=* +tokeninfo(#20090,8,#20001,40,":") +#20091=@"loc,{#10000},3,37,3,37" +locations_default(#20091,#10000,3,37,3,37) +hasLocation(#20090,#20091) +#20092=* +tokeninfo(#20092,1,#20001,41,"null") +#20093=@"loc,{#10000},3,39,3,42" +locations_default(#20093,#10000,3,39,3,42) +hasLocation(#20092,#20093) +#20094=* +tokeninfo(#20094,8,#20001,42,"|") +#20095=@"loc,{#10000},3,44,3,44" +locations_default(#20095,#10000,3,44,3,44) +hasLocation(#20094,#20095) +#20096=* +tokeninfo(#20096,6,#20001,43,"T") +#20097=@"loc,{#10000},3,46,3,46" +locations_default(#20097,#10000,3,46,3,46) +hasLocation(#20096,#20097) +#20098=* +tokeninfo(#20098,8,#20001,44,")") +#20099=@"loc,{#10000},3,47,3,47" +locations_default(#20099,#10000,3,47,3,47) +hasLocation(#20098,#20099) +#20100=* +tokeninfo(#20100,8,#20001,45,"=>") +#20101=@"loc,{#10000},3,49,3,50" +locations_default(#20101,#10000,3,49,3,50) +hasLocation(#20100,#20101) +#20102=* +tokeninfo(#20102,6,#20001,46,"mixed") +#20103=@"loc,{#10000},3,52,3,56" +locations_default(#20103,#10000,3,52,3,56) +hasLocation(#20102,#20103) +#20104=* +tokeninfo(#20104,8,#20001,47,")") +#20105=@"loc,{#10000},3,57,3,57" +locations_default(#20105,#10000,3,57,3,57) +hasLocation(#20104,#20105) +#20106=* +tokeninfo(#20106,8,#20001,48,";") +#20107=@"loc,{#10000},3,58,3,58" +locations_default(#20107,#10000,3,58,3,58) +hasLocation(#20106,#20107) +#20108=* +tokeninfo(#20108,6,#20001,49,"type") +#20109=@"loc,{#10000},4,1,4,4" +locations_default(#20109,#10000,4,1,4,4) +hasLocation(#20108,#20109) +#20110=* +tokeninfo(#20110,6,#20001,50,"D") +#20111=@"loc,{#10000},4,6,4,6" +locations_default(#20111,#10000,4,6,4,6) +hasLocation(#20110,#20111) +#20112=* +tokeninfo(#20112,8,#20001,51,"=") +#20113=@"loc,{#10000},4,8,4,8" +locations_default(#20113,#10000,4,8,4,8) +hasLocation(#20112,#20113) +#20114=* +tokeninfo(#20114,8,#20001,52,"{") +#20115=@"loc,{#10000},4,10,4,10" +locations_default(#20115,#10000,4,10,4,10) +hasLocation(#20114,#20115) +#20116=* +tokeninfo(#20116,6,#20001,53,"d") +#20117=@"loc,{#10000},4,12,4,12" +locations_default(#20117,#10000,4,12,4,12) +hasLocation(#20116,#20117) +#20118=* +tokeninfo(#20118,8,#20001,54,":") +#20119=@"loc,{#10000},4,13,4,13" +locations_default(#20119,#10000,4,13,4,13) +hasLocation(#20118,#20119) +#20120=* +tokeninfo(#20120,6,#20001,55,"D") +#20121=@"loc,{#10000},4,15,4,15" +locations_default(#20121,#10000,4,15,4,15) +hasLocation(#20120,#20121) +#20122=* +tokeninfo(#20122,8,#20001,56,",") +#20123=@"loc,{#10000},4,16,4,16" +locations_default(#20123,#10000,4,16,4,16) +hasLocation(#20122,#20123) +#20124=* +tokeninfo(#20124,8,#20001,57,"...") +#20125=@"loc,{#10000},4,18,4,20" +locations_default(#20125,#10000,4,18,4,20) +hasLocation(#20124,#20125) +#20126=* +tokeninfo(#20126,8,#20001,58,",") +#20127=@"loc,{#10000},4,21,4,21" +locations_default(#20127,#10000,4,21,4,21) +hasLocation(#20126,#20127) +#20128=* +tokeninfo(#20128,8,#20001,59,"}") +#20129=@"loc,{#10000},4,23,4,23" +locations_default(#20129,#10000,4,23,4,23) +hasLocation(#20128,#20129) +#20130=* +tokeninfo(#20130,8,#20001,60,";") +#20131=@"loc,{#10000},4,24,4,24" +locations_default(#20131,#10000,4,24,4,24) +hasLocation(#20130,#20131) +#20132=* +tokeninfo(#20132,0,#20001,61,"") +#20133=@"loc,{#10000},4,25,4,24" +locations_default(#20133,#10000,4,25,4,24) +hasLocation(#20132,#20133) toplevels(#20001,0) -#20050=@"loc,{#10000},1,1,2,29" -locations_default(#20050,#10000,1,1,2,29) -hasLocation(#20001,#20050) -#20051=* -entry_cfg_node(#20051,#20001) -#20052=@"loc,{#10000},1,1,1,0" -locations_default(#20052,#10000,1,1,1,0) -hasLocation(#20051,#20052) -#20053=* -exit_cfg_node(#20053,#20001) -hasLocation(#20053,#20049) -successor(#20051,#20053) -numlines(#10000,2,2,0) +#20134=@"loc,{#10000},1,1,4,24" +locations_default(#20134,#10000,1,1,4,24) +hasLocation(#20001,#20134) +#20135=* +entry_cfg_node(#20135,#20001) +#20136=@"loc,{#10000},1,1,1,0" +locations_default(#20136,#10000,1,1,1,0) +hasLocation(#20135,#20136) +#20137=* +exit_cfg_node(#20137,#20001) +hasLocation(#20137,#20133) +successor(#20135,#20137) +numlines(#10000,4,4,0) filetype(#10000,"javascript") diff --git a/javascript/ql/src/Security/CWE-079/ExceptionXss.qhelp b/javascript/ql/src/Security/CWE-079/ExceptionXss.qhelp new file mode 100644 index 00000000000..f815794f6b8 --- /dev/null +++ b/javascript/ql/src/Security/CWE-079/ExceptionXss.qhelp @@ -0,0 +1,54 @@ + + + + +

    +Directly writing exceptions to a webpage without sanitization allows for a cross-site scripting +vulnerability if the value of the exception can be influenced by a user. +

    +     + + +

    +To guard against cross-site scripting, consider using contextual output encoding/escaping before +writing user input to the page, or one of the other solutions that are mentioned in the +references. +

    +     + + +

    +The following example shows an exception being written directly to the document, +and this exception can potentially be influenced by the page URL, +leaving the website vulnerable to cross-site scripting. +

    + +     + + +
  • +OWASP: +DOM based +XSS Prevention Cheat Sheet. +
    • +
  • +OWASP: +XSS +(Cross Site Scripting) Prevention Cheat Sheet. +
    • +
  • +OWASP +DOM Based XSS. +
    • +
  • +OWASP +Types of Cross-Site +Scripting. +
    • +
  • +Wikipedia: Cross-site scripting. +
    • +     +     diff --git a/javascript/ql/src/Security/CWE-079/ExceptionXss.ql b/javascript/ql/src/Security/CWE-079/ExceptionXss.ql new file mode 100644 index 00000000000..cf22b54e465 --- /dev/null +++ b/javascript/ql/src/Security/CWE-079/ExceptionXss.ql @@ -0,0 +1,24 @@ +/** + * @name Cross-site scripting through exception + * @description Inserting data from an exception containing user + * input into the DOM may enable cross-site scripting. + * @kind path-problem + * @problem.severity error + * @precision medium + * @id js/xss-through-exception + * @tags security + * external/cwe/cwe-079 + * external/cwe/cwe-116 + */ + +import javascript +import semmle.javascript.security.dataflow.ExceptionXss::ExceptionXss +import DataFlow::PathGraph + +from + Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink +where + cfg.hasFlowPath(source, sink) +select sink.getNode(), source, sink, + sink.getNode().(Xss::Shared::Sink).getVulnerabilityKind() + " vulnerability due to $@.", source.getNode(), + "user-provided value" diff --git a/javascript/ql/src/Security/CWE-079/examples/ExceptionXss.js b/javascript/ql/src/Security/CWE-079/examples/ExceptionXss.js new file mode 100644 index 00000000000..7f8897387ff --- /dev/null +++ b/javascript/ql/src/Security/CWE-079/examples/ExceptionXss.js @@ -0,0 +1,10 @@ +function setLanguageOptions() { + var href = document.location.href, + deflt = href.substring(href.indexOf("default=")+8); + + try { + var parsed = unknownParseFunction(deflt); + } catch(e) { + document.write("Had an error: " + e + "."); + } +} diff --git a/javascript/ql/src/Statements/UseOfReturnlessFunction.ql b/javascript/ql/src/Statements/UseOfReturnlessFunction.ql index 5b431c33489..35825b01bb4 100644 --- a/javascript/ql/src/Statements/UseOfReturnlessFunction.ql +++ b/javascript/ql/src/Statements/UseOfReturnlessFunction.ql @@ -68,7 +68,7 @@ predicate benignContext(Expr e) { any(InvokeExpr invoke).getCallee() = e or // arguments to Promise.resolve (and promise library variants) are benign. - e = any(ResolvedPromiseDefinition promise).getValue().asExpr() + e = any(PromiseCreationCall promise).getValue().asExpr() } predicate oneshotClosure(DataFlow::CallNode call) { @@ -198,7 +198,7 @@ module Deferred { /** * A resolved promise created by a `new Deferred().resolve()` call. */ - class ResolvedDeferredPromiseDefinition extends ResolvedPromiseDefinition { + class ResolvedDeferredPromiseDefinition extends PromiseCreationCall { ResolvedDeferredPromiseDefinition() { this = any(DeferredPromiseDefinition def).ref().getAMethodCall("resolve") } diff --git a/javascript/ql/src/javascript.qll b/javascript/ql/src/javascript.qll index 08b305c159b..4648ca9e01f 100644 --- a/javascript/ql/src/javascript.qll +++ b/javascript/ql/src/javascript.qll @@ -92,6 +92,7 @@ import semmle.javascript.frameworks.SQL import semmle.javascript.frameworks.SocketIO import semmle.javascript.frameworks.StringFormatters import semmle.javascript.frameworks.TorrentLibraries +import semmle.javascript.frameworks.Typeahead import semmle.javascript.frameworks.UriLibraries import semmle.javascript.frameworks.Vue import semmle.javascript.frameworks.XmlParsers diff --git a/javascript/ql/src/semmle/javascript/Expr.qll b/javascript/ql/src/semmle/javascript/Expr.qll index c6464767e8f..258a85904d2 100644 --- a/javascript/ql/src/semmle/javascript/Expr.qll +++ b/javascript/ql/src/semmle/javascript/Expr.qll @@ -245,6 +245,21 @@ class Expr extends @expr, ExprOrStmt, ExprOrType, AST::ValueNode { ctx.(ConditionalExpr).inNullSensitiveContext() ) } + + /** + * Gets the data-flow node where exceptions thrown by this expression will + * propagate if this expression causes an exception to be thrown. + */ + DataFlow::Node getExceptionTarget() { + if exists(this.getEnclosingStmt().getEnclosingTryCatchStmt()) + then + result = DataFlow::parameterNode(this + .getEnclosingStmt() + .getEnclosingTryCatchStmt() + .getACatchClause() + .getAParameter()) + else result = any(DataFlow::FunctionNode f | f.getFunction() = this.getContainer()).getExceptionalReturn() + } } /** diff --git a/javascript/ql/src/semmle/javascript/Files.qll b/javascript/ql/src/semmle/javascript/Files.qll index 88efd373769..09b31bd7915 100644 --- a/javascript/ql/src/semmle/javascript/Files.qll +++ b/javascript/ql/src/semmle/javascript/Files.qll @@ -198,8 +198,13 @@ class Folder extends Container, @folder { } /** A file. */ -class File extends Container, @file, Locatable { - override Location getLocation() { hasLocation(this, result) } +class File extends Container, @file { + /** + * Gets the location of this file. + * + * Note that files have special locations starting and ending at line zero, column zero. + */ + Location getLocation() { hasLocation(this, result) } override string getAbsolutePath() { files(this, result, _, _, _) } diff --git a/javascript/ql/src/semmle/javascript/JSDoc.qll b/javascript/ql/src/semmle/javascript/JSDoc.qll index c080061bc7c..f418eea0629 100644 --- a/javascript/ql/src/semmle/javascript/JSDoc.qll +++ b/javascript/ql/src/semmle/javascript/JSDoc.qll @@ -74,6 +74,7 @@ abstract class Documentable extends ASTNode { class JSDocTypeExprParent extends @jsdoc_type_expr_parent, Locatable { override Location getLocation() { hasLocation(this, result) } + /** Gets the JSDoc comment to which this element belongs. */ JSDoc getJSDocComment() { none() } } diff --git a/javascript/ql/src/semmle/javascript/Locations.qll b/javascript/ql/src/semmle/javascript/Locations.qll index 165975d9905..aa7dc6210b3 100644 --- a/javascript/ql/src/semmle/javascript/Locations.qll +++ b/javascript/ql/src/semmle/javascript/Locations.qll @@ -132,3 +132,15 @@ class Locatable extends @locatable { none() } } + +/** + * A `File`, considered as a `Locatable`. + * + * For reasons of backwards compatibility, @file is a subtype of @locatable. This class exists to + * provide an override of `Locatable.getLocation()` for @files, since it would otherwise default + * to `none()`, which is unhelpful. + */ +private class FileLocatable extends File, Locatable { + override Location getLocation() { result = File.super.getLocation() } + override string toString() { result = File.super.toString() } +} diff --git a/javascript/ql/src/semmle/javascript/Modules.qll b/javascript/ql/src/semmle/javascript/Modules.qll index 55a8a6acd0e..97be97d8f50 100644 --- a/javascript/ql/src/semmle/javascript/Modules.qll +++ b/javascript/ql/src/semmle/javascript/Modules.qll @@ -83,9 +83,13 @@ abstract class Module extends TopLevel { result = c.(Folder).getJavaScriptFile("index") ) or - // handle the case where the import path is missing an extension + // handle the case where the import path is missing the extension exists(Folder f | f = path.resolveUpTo(path.getNumComponent() - 1) | result = f.getJavaScriptFile(path.getBaseName()) + or + // If a js file was not found look for a file that compiles to js + not exists(f.getJavaScriptFile(path.getBaseName())) and + result = f.getJavaScriptFile(path.getStem()) ) ) } diff --git a/javascript/ql/src/semmle/javascript/NodeJS.qll b/javascript/ql/src/semmle/javascript/NodeJS.qll index d567dc501a6..bf88039ff77 100644 --- a/javascript/ql/src/semmle/javascript/NodeJS.qll +++ b/javascript/ql/src/semmle/javascript/NodeJS.qll @@ -162,12 +162,11 @@ private predicate moduleInFile(Module m, File f) { m.getFile() = f } * ``` */ class Require extends CallExpr, Import { + cached Require() { - exists(RequireVariable req | - this.getCallee() = req.getAnAccess() and - // `mjs` files explicitly disallow `require` - not getFile().getExtension() = "mjs" - ) + any(RequireVariable req).getAnAccess() = getCallee() and + // `mjs` files explicitly disallow `require` + not getFile().getExtension() = "mjs" } override PathExpr getImportedPath() { result = getArgument(0) } diff --git a/javascript/ql/src/semmle/javascript/Paths.qll b/javascript/ql/src/semmle/javascript/Paths.qll index f15345bd94b..754b38133c8 100644 --- a/javascript/ql/src/semmle/javascript/Paths.qll +++ b/javascript/ql/src/semmle/javascript/Paths.qll @@ -205,6 +205,9 @@ abstract class PathExpr extends PathExprBase { /** Gets the base name of the folder or file this path refers to. */ string getBaseName() { result = getValue().(PathString).getBaseName() } + /** Gets the stem, that is, base name without extension, of the folder or file this path refers to. */ + string getStem() { result = getValue().(PathString).getStem() } + /** * Gets the file or folder that the first `n` components of this path refer to * when resolved relative to the root folder of the given `priority`. diff --git a/javascript/ql/src/semmle/javascript/Promises.qll b/javascript/ql/src/semmle/javascript/Promises.qll index 858064e85a0..d74aafc265c 100644 --- a/javascript/ql/src/semmle/javascript/Promises.qll +++ b/javascript/ql/src/semmle/javascript/Promises.qll @@ -30,6 +30,22 @@ module Bluebird { override DataFlow::Node getValue() { result = getArgument(0) } } + + /** + * An aggregated promise produced either by `Promise.all`, `Promise.race` or `Promise.map`. + */ + class AggregateBluebirdPromiseDefinition extends PromiseCreationCall { + AggregateBluebirdPromiseDefinition() { + exists(string m | m = "all" or m = "race" or m = "map" | + this = bluebird().getAMemberCall(m) + ) + } + + override DataFlow::Node getValue() { + result = getArgument(0).getALocalSource().(DataFlow::ArrayCreationNode).getAnElement() + } + } + } /** diff --git a/javascript/ql/src/semmle/javascript/Regexp.qll b/javascript/ql/src/semmle/javascript/Regexp.qll index 42c29e3e9e2..c79548e04c5 100644 --- a/javascript/ql/src/semmle/javascript/Regexp.qll +++ b/javascript/ql/src/semmle/javascript/Regexp.qll @@ -73,21 +73,21 @@ class RegExpTerm extends Locatable, @regexpterm { /** Holds if this regular expression term can match the empty string. */ predicate isNullable() { none() } // Overridden in subclasses. - /** Gets the regular expression term that is matched before this one, if any. */ + /** Gets the regular expression term that is matched (textually) before this one, if any. */ RegExpTerm getPredecessor() { exists(RegExpSequence seq, int i | seq.getChild(i) = this and - seq.getChild(i - getDirection()) = result + seq.getChild(i - 1) = result ) or result = getParent().(RegExpTerm).getPredecessor() } - /** Gets the regular expression term that is matched after this one, if any. */ + /** Gets the regular expression term that is matched (textually) after this one, if any. */ RegExpTerm getSuccessor() { exists(RegExpSequence seq, int i | seq.getChild(i) = this and - seq.getChild(i + getDirection()) = result + seq.getChild(i + 1) = result ) or exists(RegExpTerm parent | @@ -98,12 +98,6 @@ class RegExpTerm extends Locatable, @regexpterm { ) } - /** - * Gets the matching direction of this term: `1` if it is in a forward-matching - * context, `-1` if it is in a backward-matching context. - */ - private int getDirection() { if isInBackwardMatchingContext() then result = -1 else result = 1 } - /** * Holds if this regular term is in a forward-matching context, that is, * it has no enclosing lookbehind assertions. diff --git a/javascript/ql/src/semmle/javascript/StandardLibrary.qll b/javascript/ql/src/semmle/javascript/StandardLibrary.qll index b57271940c5..8d9df11a419 100644 --- a/javascript/ql/src/semmle/javascript/StandardLibrary.qll +++ b/javascript/ql/src/semmle/javascript/StandardLibrary.qll @@ -152,15 +152,20 @@ private class ES2015PromiseDefinition extends PromiseDefinition, DataFlow::NewNo } /** - * A promise that is resolved with the given value. + * A promise that is created and resolved with one or more value. */ -abstract class ResolvedPromiseDefinition extends DataFlow::CallNode { +abstract class PromiseCreationCall extends DataFlow::CallNode { /** * Gets the value this promise is resolved with. */ abstract DataFlow::Node getValue(); } +/** + * A promise that is created using a `.resolve()` call. + */ +abstract class ResolvedPromiseDefinition extends PromiseCreationCall {} + /** * A resolved promise created by the standard ECMAScript 2015 `Promise.resolve` function. */ @@ -172,6 +177,21 @@ class ResolvedES2015PromiseDefinition extends ResolvedPromiseDefinition { override DataFlow::Node getValue() { result = getArgument(0) } } +/** + * An aggregated promise produced either by `Promise.all` or `Promise.race`. + */ +class AggregateES2015PromiseDefinition extends PromiseCreationCall { + AggregateES2015PromiseDefinition() { + exists(string m | m = "all" or m = "race" | + this = DataFlow::globalVarRef("Promise").getAMemberCall(m) + ) + } + + override DataFlow::Node getValue() { + result = getArgument(0).getALocalSource().(DataFlow::ArrayCreationNode).getAnElement() + } +} + /** * A data flow edge from a promise reaction to the corresponding handler. */ @@ -197,7 +217,7 @@ predicate promiseTaintStep(DataFlow::Node pred, DataFlow::Node succ) { pred = succ.(PromiseDefinition).getResolveParameter().getACall().getArgument(0) or // from `x` to `Promise.resolve(x)` - pred = succ.(ResolvedPromiseDefinition).getValue() + pred = succ.(PromiseCreationCall).getValue() or exists(DataFlow::MethodCallNode thn, DataFlow::FunctionNode cb | thn.getMethodName() = "then" and cb = thn.getCallback(0) diff --git a/javascript/ql/src/semmle/javascript/Stmt.qll b/javascript/ql/src/semmle/javascript/Stmt.qll index eca791ba565..c96d6509e8d 100644 --- a/javascript/ql/src/semmle/javascript/Stmt.qll +++ b/javascript/ql/src/semmle/javascript/Stmt.qll @@ -55,6 +55,18 @@ class Stmt extends @stmt, ExprOrStmt, Documentable { } override predicate isAmbient() { hasDeclareKeyword(this) or getParent().isAmbient() } + + /** + * Gets the `try` statement with a catch block containing this statement without + * crossing function boundaries or other `try ` statements with catch blocks. + */ + TryStmt getEnclosingTryCatchStmt() { + getParentStmt+() = result.getBody() and + exists(result.getACatchClause()) and + not exists(TryStmt mid | exists(mid.getACatchClause()) | + getParentStmt+() = mid.getBody() and mid.getParentStmt+() = result.getBody() + ) + } } /** diff --git a/javascript/ql/src/semmle/javascript/dataflow/Configuration.qll b/javascript/ql/src/semmle/javascript/dataflow/Configuration.qll index 426a2069fd5..9e61c627cdf 100644 --- a/javascript/ql/src/semmle/javascript/dataflow/Configuration.qll +++ b/javascript/ql/src/semmle/javascript/dataflow/Configuration.qll @@ -1125,6 +1125,9 @@ class MidPathNode extends PathNode, MkMidNode { // Skip to the top of big left-leaning string concatenation trees. nd = any(AddExpr add).flow() and nd = any(AddExpr add).getAnOperand().flow() + or + // Skip the exceptional return on functions, as this highlights the entire function. + nd = any(DataFlow::FunctionNode f).getExceptionalReturn() } } diff --git a/javascript/ql/src/semmle/javascript/dataflow/DataFlow.qll b/javascript/ql/src/semmle/javascript/dataflow/DataFlow.qll index 74bcc428393..58fcf4b1d4d 100644 --- a/javascript/ql/src/semmle/javascript/dataflow/DataFlow.qll +++ b/javascript/ql/src/semmle/javascript/dataflow/DataFlow.qll @@ -840,16 +840,18 @@ module DataFlow { * An array element pattern viewed as a property read; for instance, in * `var [ x, y ] = arr`, `x` is a read of property 0 of `arr` and similar * for `y`. - * - * Note: We currently do not expose the array index as the property name, - * instead treating it as a read of an unknown property. */ private class ElementPatternAsPropRead extends PropRead, ElementPatternNode { override Node getBase() { result = TDestructuringPatternNode(pattern) } override Expr getPropertyNameExpr() { none() } - override string getPropertyName() { none() } + override string getPropertyName() { + exists (int i | + elt = pattern.getElement(i) and + result = i.toString() + ) + } } /** @@ -1573,4 +1575,6 @@ module DataFlow { import Configuration import TrackedNodes import TypeTracking + + predicate localTaintStep = TaintTracking::localTaintStep/2; } diff --git a/javascript/ql/src/semmle/javascript/dataflow/TaintTracking.qll b/javascript/ql/src/semmle/javascript/dataflow/TaintTracking.qll index c4106ffa17f..d99863b6294 100644 --- a/javascript/ql/src/semmle/javascript/dataflow/TaintTracking.qll +++ b/javascript/ql/src/semmle/javascript/dataflow/TaintTracking.qll @@ -558,6 +558,23 @@ module TaintTracking { succ = this } } + + + /** + * A taint propagating data flow edge arising from calling `String.prototype.match()`. + */ + private class StringMatchTaintStep extends AdditionalTaintStep, DataFlow::MethodCallNode { + StringMatchTaintStep() { + this.getMethodName() = "match" and + this.getNumArgument() = 1 and + this.getArgument(0) .analyze().getAType() = TTRegExp() + } + + override predicate step(DataFlow::Node pred, DataFlow::Node succ) { + pred = this.getReceiver() and + succ = this + } + } /** * A taint propagating data flow edge arising from JSON unparsing. @@ -885,4 +902,12 @@ module TaintTracking { override predicate appliesTo(Configuration cfg) { any() } } + + /** + * Holds if taint propagates from `pred` to `succ` in one local (intra-procedural) step. + */ + predicate localTaintStep(DataFlow::Node pred, DataFlow::Node succ) { + DataFlow::localFlowStep(pred, succ) or + any(AdditionalTaintStep s).step(pred, succ) + } } diff --git a/javascript/ql/src/semmle/javascript/dataflow/internal/FlowSteps.qll b/javascript/ql/src/semmle/javascript/dataflow/internal/FlowSteps.qll index e6154902fad..5544d7d03ff 100644 --- a/javascript/ql/src/semmle/javascript/dataflow/internal/FlowSteps.qll +++ b/javascript/ql/src/semmle/javascript/dataflow/internal/FlowSteps.qll @@ -66,19 +66,7 @@ predicate localExceptionStep(DataFlow::Node pred, DataFlow::Node succ) { or DataFlow::exceptionalInvocationReturnNode(pred, expr) | - // Propagate out of enclosing function. - not exists(getEnclosingTryStmt(expr.getEnclosingStmt())) and - exists(Function f | - f = expr.getEnclosingFunction() and - DataFlow::exceptionalFunctionReturnNode(succ, f) - ) - or - // Propagate to enclosing try/catch. - // To avoid false flow, we only propagate to an unguarded catch clause. - exists(TryStmt try | - try = getEnclosingTryStmt(expr.getEnclosingStmt()) and - DataFlow::parameterNode(succ, try.getCatchClause().getAParameter()) - ) + succ = expr.getExceptionTarget() ) } @@ -156,19 +144,6 @@ private module CachedSteps { cached predicate callStep(DataFlow::Node pred, DataFlow::Node succ) { argumentPassing(_, pred, _, succ) } - /** - * Gets the `try` statement containing `stmt` without crossing function boundaries - * or other `try ` statements. - */ - cached - TryStmt getEnclosingTryStmt(Stmt stmt) { - result.getBody() = stmt - or - not stmt instanceof Function and - not stmt = any(TryStmt try).getBody() and - result = getEnclosingTryStmt(stmt.getParentStmt()) - } - /** * Holds if there is a flow step from `pred` to `succ` through: * - returning a value from a function call, or diff --git a/javascript/ql/src/semmle/javascript/dependencies/Dependencies.qll b/javascript/ql/src/semmle/javascript/dependencies/Dependencies.qll index ec0bd272e60..1fd21dc24dd 100644 --- a/javascript/ql/src/semmle/javascript/dependencies/Dependencies.qll +++ b/javascript/ql/src/semmle/javascript/dependencies/Dependencies.qll @@ -194,7 +194,8 @@ abstract class ScriptDependency extends Dependency { abstract Expr getAnApiUse(); override Locatable getAUse(string kind) { - kind = "import" and result.(HTML::HtmlFile) = this.getFile() + kind = "import" and + result = this.getFile().(HTML::HtmlFile).getATopLevel() or kind = "use" and result = getAnApiUse() } diff --git a/javascript/ql/src/semmle/javascript/frameworks/Typeahead.qll b/javascript/ql/src/semmle/javascript/frameworks/Typeahead.qll new file mode 100644 index 00000000000..161c738b311 --- /dev/null +++ b/javascript/ql/src/semmle/javascript/frameworks/Typeahead.qll @@ -0,0 +1,135 @@ +/** + * Provides classes for working with typeahead.js code (https://www.npmjs.com/package/typeahead.js). + */ + +import javascript + +module Typeahead { + /** + * A reference to the Bloodhound class, which is a utility-class for generating auto-complete suggestions. + */ + private class Bloodhound extends DataFlow::SourceNode { + Bloodhound() { + this = DataFlow::moduleImport("typeahead.js/dist/bloodhound.js") + or + this = DataFlow::moduleImport("bloodhound-js") + or + this.accessesGlobal("Bloodhound") + } + } + + /** + * An instance of the Bloodhound class. + */ + private class BloodhoundInstance extends DataFlow::NewNode { + BloodhoundInstance() { this = any(Bloodhound b).getAnInstantiation() } + } + + /** + * An instance of of the Bloodhound class that is used to fetch data from a remote server. + */ + private class RemoteBloodhoundClientRequest extends ClientRequest::Range, BloodhoundInstance { + DataFlow::ValueNode option; + + RemoteBloodhoundClientRequest() { + exists(string optionName | optionName = "remote" or optionName = "prefetch" | + option = this.getOptionArgument(0, optionName) + ) + } + + /** + * Gets the URL for this Bloodhound instance. + * The Bloodhound API specifies that the "remote" and "prefetch" options are either strings, + * or an object containing an "url" property. + */ + override DataFlow::Node getUrl() { + result = option.getALocalSource().getAPropertyWrite("url").getRhs() + or + result = option + } + + override DataFlow::Node getHost() { none() } + + override DataFlow::Node getADataNode() { none() } + + /** Gets a Bloodhound instance that fetches remote server data. */ + private DataFlow::SourceNode ref(DataFlow::TypeTracker t) { + t.start() and result = this + or + exists(DataFlow::TypeTracker t2 | result = ref(t2).track(t2, t)) + } + + /** Gets a Bloodhound instance that fetches remote server data. */ + private DataFlow::SourceNode ref() { result = ref(DataFlow::TypeTracker::end()) } + + override DataFlow::Node getAResponseDataNode(string responseType, boolean promise) { + responseType = "json" and + promise = false and + exists(TypeaheadSource source | + ref() = source.getALocalSource() or ref().getAMethodCall("ttAdapter") = source + | + result = source.getASuggestion() + ) + } + } + + /** + * An invocation of the `typeahead.js` library. + */ + private class TypeaheadCall extends DataFlow::CallNode { + TypeaheadCall() { + // Matches `$(...).typeahead(..)` + this = JQuery::objectRef().getAMethodCall("typeahead") + } + } + + /** + * A function that generates suggestions to typeahead.js. + */ + class TypeaheadSuggestionFunction extends DataFlow::FunctionNode { + TypeaheadCall typeaheadCall; + + TypeaheadSuggestionFunction() { + // Matches `$(...).typeahead({..}, { templates: { suggestion: } })`. + this = typeaheadCall + .getOptionArgument(1, "templates") + .getALocalSource() + .getAPropertyWrite("suggestion") + .getRhs() + .getAFunctionValue() + } + + /** + * Gets the call to typeahead.js where this suggestion function is used. + */ + TypeaheadCall getTypeaheadCall() { result = typeaheadCall } + } + + /** + * A `source` option for a typeahead.js plugin instance. + */ + private class TypeaheadSource extends DataFlow::ValueNode { + TypeaheadCall typeaheadCall; + + TypeaheadSource() { this = typeaheadCall.getOptionArgument(1, "source") } + + /** Gets a node for a suggestion that this source motivates. */ + DataFlow::Node getASuggestion() { + exists(TypeaheadSuggestionFunction suggestionCallback | + suggestionCallback.getTypeaheadCall() = typeaheadCall and + result = suggestionCallback.getParameter(0) + ) + } + } + + /** + * A taint step that models that a function in the `source` of typeahead.js is used to determine the input to the suggestion function. + */ + private class TypeaheadSourceTaintStep extends TypeaheadSource, TaintTracking::AdditionalTaintStep { + override predicate step(DataFlow::Node pred, DataFlow::Node succ) { + // Matches `$(...).typeahead({..}, {source: function(q, cb) {..;cb();..}, templates: { suggestion: function() {} } })`. + pred = this.getAFunctionValue().getParameter([1 .. 2]).getACall().getAnArgument() and + succ = this.getASuggestion() + } + } +} diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/DOM.qll b/javascript/ql/src/semmle/javascript/security/dataflow/DOM.qll index 299042cc281..5b639abfa11 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/DOM.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/DOM.qll @@ -211,7 +211,7 @@ private class WindowNameAccess extends RemoteFlowSource { this = DataFlow::globalObjectRef().getAPropertyRead("name") or // Reference to `name` on a container that does not assign to it. - this.accessesGlobal("name") and + this.asExpr().(GlobalVarAccess).getName() = "name" and not exists(VarDef def | def.getAVariable().(GlobalVariable).getName() = "name" and def.getContainer() = this.asExpr().getContainer() diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXss.qll b/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXss.qll index 1946099777d..24634eec94c 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXss.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXss.qll @@ -6,7 +6,7 @@ import javascript module DomBasedXss { - import Xss::DomBasedXss + import DomBasedXssCustomizations::DomBasedXss /** * A taint-tracking configuration for reasoning about XSS. @@ -33,16 +33,4 @@ module DomBasedXss { node instanceof Sanitizer } } - - /** A source of remote user input, considered as a flow source for DOM-based XSS. */ - class RemoteFlowSourceAsSource extends Source { - RemoteFlowSourceAsSource() { this instanceof RemoteFlowSource } - } - - /** - * An access of the URL of this page, or of the referrer to this page. - */ - class LocationSource extends Source { - LocationSource() { this = DOM::locationSource() } - } } diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXssCustomizations.qll b/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXssCustomizations.qll new file mode 100644 index 00000000000..b74977c8cb5 --- /dev/null +++ b/javascript/ql/src/semmle/javascript/security/dataflow/DomBasedXssCustomizations.qll @@ -0,0 +1,23 @@ +/** + * Provides default sources for reasoning about DOM-based + * cross-site scripting vulnerabilities. + */ + + +import javascript + +module DomBasedXss { + import Xss::DomBasedXss + + /** A source of remote user input, considered as a flow source for DOM-based XSS. */ + class RemoteFlowSourceAsSource extends Source { + RemoteFlowSourceAsSource() { this instanceof RemoteFlowSource } + } + + /** + * An access of the URL of this page, or of the referrer to this page. + */ + class LocationSource extends Source { + LocationSource() { this = DOM::locationSource() } + } +} diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/ExceptionXss.qll b/javascript/ql/src/semmle/javascript/security/dataflow/ExceptionXss.qll new file mode 100644 index 00000000000..2d088f42fa0 --- /dev/null +++ b/javascript/ql/src/semmle/javascript/security/dataflow/ExceptionXss.qll @@ -0,0 +1,80 @@ +/** + * Provides a taint-tracking configuration for reasoning about cross-site + * scripting vulnerabilities where the taint-flow passes through a thrown + * exception. + */ + +import javascript + +module ExceptionXss { + import DomBasedXssCustomizations::DomBasedXss as DomBasedXssCustom + import ReflectedXssCustomizations::ReflectedXss as ReflectedXssCustom + import Xss as Xss + + /** + * Holds if `node` is unlikely to cause an exception containing sensitive information to be thrown. + */ + private predicate isUnlikelyToThrowSensitiveInformation(DataFlow::Node node) { + node = any(DataFlow::CallNode call | call.getCalleeName() = "getElementById").getAnArgument() + or + node = any(DataFlow::CallNode call | call.getCalleeName() = "indexOf").getAnArgument() + or + node = any(DataFlow::CallNode call | call.getCalleeName() = "stringify").getAnArgument() + or + node = DataFlow::globalVarRef("console").getAMemberCall(_).getAnArgument() + } + + /** + * Holds if `node` can possibly cause an exception containing sensitive information to be thrown. + */ + predicate canThrowSensitiveInformation(DataFlow::Node node) { + not isUnlikelyToThrowSensitiveInformation(node) and + ( + // in the case of reflective calls the below ensures that both InvokeNodes have no known callee. + forex(DataFlow::InvokeNode call | node = call.getAnArgument() | not exists(call.getACallee())) + or + node.asExpr().getEnclosingStmt() instanceof ThrowStmt + ) + } + + /** + * A FlowLabel representing tainted data that has not been thrown in an exception. + * In the js/xss-through-exception query data-flow can only reach a sink after + * the data has been thrown as an exception, and data that has not been thrown + * as an exception therefore has this flow label, and only this flow label, associated with it. + */ + class NotYetThrown extends DataFlow::FlowLabel { + NotYetThrown() { this = "NotYetThrown" } + } + + /** + * A taint-tracking configuration for reasoning about XSS with possible exceptional flow. + * Flow labels are used to ensure that we only report taint-flow that has been thrown in + * an exception. + */ + class Configuration extends TaintTracking::Configuration { + Configuration() { this = "ExceptionXss" } + + override predicate isSource(DataFlow::Node source, DataFlow::FlowLabel label) { + source instanceof Xss::Shared::Source and label instanceof NotYetThrown + } + + override predicate isSink(DataFlow::Node sink, DataFlow::FlowLabel label) { + sink instanceof Xss::Shared::Sink and not label instanceof NotYetThrown + } + + override predicate isSanitizer(DataFlow::Node node) { node instanceof Xss::Shared::Sanitizer } + + override predicate isAdditionalFlowStep( + DataFlow::Node pred, DataFlow::Node succ, DataFlow::FlowLabel inlbl, + DataFlow::FlowLabel outlbl + ) { + inlbl instanceof NotYetThrown and (outlbl.isTaint() or outlbl instanceof NotYetThrown) and + succ = pred.asExpr().getExceptionTarget() and + canThrowSensitiveInformation(pred) + or + // All the usual taint-flow steps apply on data-flow before it has been thrown in an exception. + this.isAdditionalFlowStep(pred, succ) and inlbl instanceof NotYetThrown and outlbl instanceof NotYetThrown + } + } +} diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXss.qll b/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXss.qll index e84fd372337..ece299d7fa0 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXss.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXss.qll @@ -6,7 +6,7 @@ import javascript module ReflectedXss { - import Xss::ReflectedXss + import ReflectedXssCustomizations::ReflectedXss /** * A taint-tracking configuration for reasoning about XSS. @@ -23,13 +23,4 @@ module ReflectedXss { node instanceof Sanitizer } } - - /** A third-party controllable request input, considered as a flow source for reflected XSS. */ - class ThirdPartyRequestInputAccessAsSource extends Source { - ThirdPartyRequestInputAccessAsSource() { - this.(HTTP::RequestInputAccess).isThirdPartyControllable() - or - this.(HTTP::RequestHeaderAccess).getAHeaderName() = "referer" - } - } } diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXssCustomizations.qll b/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXssCustomizations.qll new file mode 100644 index 00000000000..6906d5122f6 --- /dev/null +++ b/javascript/ql/src/semmle/javascript/security/dataflow/ReflectedXssCustomizations.qll @@ -0,0 +1,19 @@ +/** + * Provides default sources for reasoning about reflected + * cross-site scripting vulnerabilities. + */ + +import javascript + +module ReflectedXss { + import Xss::ReflectedXss + + /** A third-party controllable request input, considered as a flow source for reflected XSS. */ + class ThirdPartyRequestInputAccessAsSource extends Source { + ThirdPartyRequestInputAccessAsSource() { + this.(HTTP::RequestInputAccess).isThirdPartyControllable() + or + this.(HTTP::RequestHeaderAccess).getAHeaderName() = "referer" + } + } +} diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/Xss.qll b/javascript/ql/src/semmle/javascript/security/dataflow/Xss.qll index 76c4a29f971..71b2a463f7a 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/Xss.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/Xss.qll @@ -96,6 +96,8 @@ module DomBasedXss { this = mcn.getArgument(1) ) or + this = any(Typeahead::TypeaheadSuggestionFunction f).getAReturn() + or this = any(Handlebars::SafeString s).getAnArgument() } } diff --git a/javascript/ql/test/library-tests/Modules/import-ts-with-js-extension.ts b/javascript/ql/test/library-tests/Modules/import-ts-with-js-extension.ts new file mode 100644 index 00000000000..a2b4a8a3a7f --- /dev/null +++ b/javascript/ql/test/library-tests/Modules/import-ts-with-js-extension.ts @@ -0,0 +1,3 @@ +import { foo } from "./f.js"; + +foo(); diff --git a/javascript/ql/test/library-tests/Modules/tests.expected b/javascript/ql/test/library-tests/Modules/tests.expected index 39d24b09700..6858d546fa9 100644 --- a/javascript/ql/test/library-tests/Modules/tests.expected +++ b/javascript/ql/test/library-tests/Modules/tests.expected @@ -6,6 +6,7 @@ test_ImportSpecifiers | f.ts:1:8:1:8 | g | f.ts:1:8:1:8 | g | | g.ts:1:9:1:11 | foo | g.ts:1:9:1:11 | foo | | import-in-mjs.mjs:1:8:1:24 | exported_from_mjs | import-in-mjs.mjs:1:8:1:24 | exported_from_mjs | +| import-ts-with-js-extension.ts:1:10:1:12 | foo | import-ts-with-js-extension.ts:1:10:1:12 | foo | | m/c.js:1:8:1:13 | * as b | m/c.js:1:13:1:13 | b | | tst.html:5:10:5:10 | f | tst.html:5:10:5:10 | f | | unresolved.js:1:8:1:8 | f | unresolved.js:1:8:1:8 | f | @@ -43,6 +44,7 @@ test_getImportedName | f.ts:1:8:1:8 | g | default | | g.ts:1:9:1:11 | foo | foo | | import-in-mjs.mjs:1:8:1:24 | exported_from_mjs | default | +| import-ts-with-js-extension.ts:1:10:1:12 | foo | foo | | tst.html:5:10:5:10 | f | default | | unresolved.js:1:8:1:8 | f | default | test_ExportDeclarations @@ -65,6 +67,7 @@ test_getAnImportedModule | es2015_require.js | d.js | | f.ts | e.js | | g.ts | f.ts | +| import-ts-with-js-extension.ts | f.ts | | m/c.js | b.js | test_getSourceNode | a.js:1:1:3:1 | export ... n 23;\\n} | default | a.js:1:16:3:1 | functio ... n 23;\\n} | @@ -87,6 +90,7 @@ test_Imports | f.ts:1:1:1:19 | import g from './e' | f.ts:1:15:1:19 | './e' | 1 | | g.ts:1:1:1:23 | import ... m './f' | g.ts:1:19:1:23 | './f' | 1 | | import-in-mjs.mjs:1:1:1:46 | import ... n-mjs'; | import-in-mjs.mjs:1:31:1:45 | 'export-in-mjs' | 1 | +| import-ts-with-js-extension.ts:1:1:1:29 | import ... /f.js"; | import-ts-with-js-extension.ts:1:21:1:28 | "./f.js" | 1 | | m/c.js:1:1:1:26 | import ... '../b'; | m/c.js:1:20:1:25 | '../b' | 1 | | tst.html:5:3:5:20 | import f from 'a'; | tst.html:5:17:5:19 | 'a' | 1 | | unresolved.js:1:1:1:18 | import f from 'a'; | unresolved.js:1:15:1:17 | 'a' | 1 | @@ -94,6 +98,7 @@ test_NamedImportSpecifier | d.js:1:10:1:21 | default as g | | d.js:1:24:1:29 | x as y | | g.ts:1:9:1:11 | foo | +| import-ts-with-js-extension.ts:1:10:1:12 | foo | test_GlobalVariableRef | a.js:5:31:5:31 | o | | exports.js:3:9:3:15 | exports | diff --git a/javascript/ql/test/library-tests/Promises/ResolvedPromiseDefinition.qll b/javascript/ql/test/library-tests/Promises/ResolvedPromiseDefinition.qll index a7bade78412..5efd8896141 100644 --- a/javascript/ql/test/library-tests/Promises/ResolvedPromiseDefinition.qll +++ b/javascript/ql/test/library-tests/Promises/ResolvedPromiseDefinition.qll @@ -1,7 +1,7 @@ import javascript query predicate test_ResolvedPromiseDefinition( - ResolvedPromiseDefinition resolved, DataFlow::Node res + PromiseCreationCall resolved, DataFlow::Node res ) { res = resolved.getValue() } diff --git a/javascript/ql/test/library-tests/PropWrite/tests.expected b/javascript/ql/test/library-tests/PropWrite/tests.expected index beb4916f397..9e5872b991b 100644 --- a/javascript/ql/test/library-tests/PropWrite/tests.expected +++ b/javascript/ql/test/library-tests/PropWrite/tests.expected @@ -10,6 +10,9 @@ test_getAPropertyRead | tst.js:34:6:34:12 | vvv.ppp | tst.js:34:6:34:16 | vvv.ppp.qqq | | tst.js:44:3:44:9 | console | tst.js:44:3:44:13 | console.log | | tst.js:44:15:44:17 | obj | tst.js:44:15:44:20 | obj[p] | +| tst.js:46:17:46:21 | array | tst.js:47:10:47:10 | x | +| tst.js:46:17:46:21 | array | tst.js:47:13:47:13 | y | +| tst.js:46:17:46:21 | array | tst.js:47:16:47:16 | z | test_getAPropertyReference | classes.ts:3:21:3:20 | this | classes.ts:4:3:4:24 | instanc ... foo(); | | classes.ts:8:3:8:2 | this | classes.ts:8:15:8:35 | public ... erField | @@ -50,6 +53,9 @@ test_getAPropertyReference | tst.js:41:12:41:30 | ["a", ...arr3, "d"] | tst.js:41:27:41:29 | "d" | | tst.js:44:3:44:9 | console | tst.js:44:3:44:13 | console.log | | tst.js:44:15:44:17 | obj | tst.js:44:15:44:20 | obj[p] | +| tst.js:46:17:46:21 | array | tst.js:47:10:47:10 | x | +| tst.js:46:17:46:21 | array | tst.js:47:13:47:13 | y | +| tst.js:46:17:46:21 | array | tst.js:47:16:47:16 | z | test_getAPropertySource | classes.ts:3:21:3:20 | this | instanceField | classes.ts:4:19:4:23 | foo() | | classes.ts:8:3:8:2 | this | parameterField | classes.ts:8:22:8:35 | parameterField | @@ -92,6 +98,9 @@ test_getAPropertyRead2 | tst.js:34:6:34:8 | vvv | ppp | tst.js:34:6:34:12 | vvv.ppp | | tst.js:34:6:34:12 | vvv.ppp | qqq | tst.js:34:6:34:16 | vvv.ppp.qqq | | tst.js:44:3:44:9 | console | log | tst.js:44:3:44:13 | console.log | +| tst.js:46:17:46:21 | array | 0 | tst.js:47:10:47:10 | x | +| tst.js:46:17:46:21 | array | 1 | tst.js:47:13:47:13 | y | +| tst.js:46:17:46:21 | array | 2 | tst.js:47:16:47:16 | z | test_getAPropertyReference2 | classes.ts:3:21:3:20 | this | instanceField | classes.ts:4:3:4:24 | instanc ... foo(); | | classes.ts:8:3:8:2 | this | parameterField | classes.ts:8:15:8:35 | public ... erField | @@ -116,6 +125,9 @@ test_getAPropertyReference2 | tst.js:34:6:34:8 | vvv | ppp | tst.js:34:6:34:12 | vvv.ppp | | tst.js:34:6:34:12 | vvv.ppp | qqq | tst.js:34:6:34:16 | vvv.ppp.qqq | | tst.js:44:3:44:9 | console | log | tst.js:44:3:44:13 | console.log | +| tst.js:46:17:46:21 | array | 0 | tst.js:47:10:47:10 | x | +| tst.js:46:17:46:21 | array | 1 | tst.js:47:13:47:13 | y | +| tst.js:46:17:46:21 | array | 2 | tst.js:47:16:47:16 | z | test_hasPropertyWrite | classes.ts:3:21:3:20 | this | instanceField | classes.ts:4:19:4:23 | foo() | | classes.ts:8:3:8:2 | this | parameterField | classes.ts:8:22:8:35 | parameterField | diff --git a/javascript/ql/test/library-tests/PropWrite/tst.js b/javascript/ql/test/library-tests/PropWrite/tst.js index 99e9d5ffb1c..4f18284968d 100644 --- a/javascript/ql/test/library-tests/PropWrite/tst.js +++ b/javascript/ql/test/library-tests/PropWrite/tst.js @@ -42,3 +42,8 @@ var arr1 = ["a", "b", "c"], for (var p in obj) console.log(obj[p]); + + function test(array) { + let [x, y, z] = array; + } + \ No newline at end of file diff --git a/javascript/ql/test/library-tests/dependencies/DependencyUses.expected b/javascript/ql/test/library-tests/dependencies/DependencyUses.expected index 951a5e52c48..37fa73e4de4 100644 --- a/javascript/ql/test/library-tests/dependencies/DependencyUses.expected +++ b/javascript/ql/test/library-tests/dependencies/DependencyUses.expected @@ -1,50 +1,108 @@ -| angular-ui-bootstrap-2.1.2 | import | src/tst.html:0:0:0:0 | src/tst.html | -| angularjs-1.5.8 | import | src/tst.html:0:0:0:0 | src/tst.html | -| angularjs-2.0.0-beta.17 | import | src/tst.html:0:0:0:0 | src/tst.html | -| bootstrap-3.3.7 | import | src/tst.html:0:0:0:0 | src/tst.html | +| angular-ui-bootstrap-2.1.2 | import | src/tst.html:2:11:5:2 | | +| angular-ui-bootstrap-2.1.2 | import | src/tst.html:6:11:8:2 | | +| angular-ui-bootstrap-2.1.2 | import | src/tst.html:50:11:53:2 | | +| angularjs-1.5.8 | import | src/tst.html:2:11:5:2 | | +| angularjs-1.5.8 | import | src/tst.html:6:11:8:2 | | +| angularjs-1.5.8 | import | src/tst.html:50:11:53:2 | | +| angularjs-2.0.0-beta.17 | import | src/tst.html:2:11:5:2 | | +| angularjs-2.0.0-beta.17 | import | src/tst.html:6:11:8:2 | | +| angularjs-2.0.0-beta.17 | import | src/tst.html:50:11:53:2 | | +| bootstrap-3.3.7 | import | src/tst.html:2:11:5:2 | | +| bootstrap-3.3.7 | import | src/tst.html:6:11:8:2 | | +| bootstrap-3.3.7 | import | src/tst.html:50:11:53:2 | | | bootstrap-3.3.7 | use | src/tst.html:52:5:52:5 | $ | | bundled-package-23.42.0 | import | src/tst.js:1:1:1:26 | require ... ckage") | | closure-unknown | import | src/closure-test.js:1:1:3:20 | | -| dojo-1.11.2 | import | src/tst.html:0:0:0:0 | src/tst.html | +| dojo-1.11.2 | import | src/tst.html:2:11:5:2 | | +| dojo-1.11.2 | import | src/tst.html:6:11:8:2 | | +| dojo-1.11.2 | import | src/tst.html:50:11:53:2 | | | esprima-0.9.0 | import | src/tst.js:2:1:2:18 | require("esprima") | -| extjs-6.0.1 | import | src/tst.html:0:0:0:0 | src/tst.html | -| footools-1.2.3 | import | src/tst.html:0:0:0:0 | src/tst.html | -| jquery-1.12.4 | import | src/tst.html:0:0:0:0 | src/tst.html | +| extjs-6.0.1 | import | src/tst.html:2:11:5:2 | | +| extjs-6.0.1 | import | src/tst.html:6:11:8:2 | | +| extjs-6.0.1 | import | src/tst.html:50:11:53:2 | | +| footools-1.2.3 | import | src/tst.html:2:11:5:2 | | +| footools-1.2.3 | import | src/tst.html:6:11:8:2 | | +| footools-1.2.3 | import | src/tst.html:50:11:53:2 | | +| jquery-1.12.4 | import | src/tst.html:2:11:5:2 | | +| jquery-1.12.4 | import | src/tst.html:6:11:8:2 | | +| jquery-1.12.4 | import | src/tst.html:50:11:53:2 | | | jquery-1.12.4 | use | src/tst.html:52:5:52:5 | $ | -| jquery-2.0.1 | import | src/tst.html:0:0:0:0 | src/tst.html | +| jquery-2.0.1 | import | src/tst.html:2:11:5:2 | | +| jquery-2.0.1 | import | src/tst.html:6:11:8:2 | | +| jquery-2.0.1 | import | src/tst.html:50:11:53:2 | | | jquery-2.0.1 | use | src/tst.html:4:3:4:3 | _ | | jquery-2.0.1 | use | src/tst.html:7:5:7:5 | _ | | jquery-2.0.1 | use | src/tst.html:52:5:52:5 | $ | -| jquery-2.2.4 | import | src/tst.html:0:0:0:0 | src/tst.html | +| jquery-2.2.4 | import | src/tst.html:2:11:5:2 | | +| jquery-2.2.4 | import | src/tst.html:6:11:8:2 | | +| jquery-2.2.4 | import | src/tst.html:50:11:53:2 | | | jquery-2.2.4 | use | src/tst.html:52:5:52:5 | $ | -| jquery-3.1.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| jquery-3.1.0 | import | src/tst.html:2:11:5:2 | | +| jquery-3.1.0 | import | src/tst.html:6:11:8:2 | | +| jquery-3.1.0 | import | src/tst.html:50:11:53:2 | | | jquery-3.1.0 | use | src/tst.html:52:5:52:5 | $ | -| jquery-mobile-1.4.5 | import | src/tst.html:0:0:0:0 | src/tst.html | -| jquery-textext-1.3.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| jquery-ui-1.7.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| jquery-mobile-1.4.5 | import | src/tst.html:2:11:5:2 | | +| jquery-mobile-1.4.5 | import | src/tst.html:6:11:8:2 | | +| jquery-mobile-1.4.5 | import | src/tst.html:50:11:53:2 | | +| jquery-textext-1.3.0 | import | src/tst.html:2:11:5:2 | | +| jquery-textext-1.3.0 | import | src/tst.html:6:11:8:2 | | +| jquery-textext-1.3.0 | import | src/tst.html:50:11:53:2 | | +| jquery-ui-1.7.0 | import | src/tst.html:2:11:5:2 | | +| jquery-ui-1.7.0 | import | src/tst.html:6:11:8:2 | | +| jquery-ui-1.7.0 | import | src/tst.html:50:11:53:2 | | | jquery-ui-1.7.0 | use | src/tst.html:52:5:52:8 | $.ui | -| jquery-ui-1.12.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| jquery-ui-1.12.0 | import | src/tst.html:2:11:5:2 | | +| jquery-ui-1.12.0 | import | src/tst.html:6:11:8:2 | | +| jquery-ui-1.12.0 | import | src/tst.html:50:11:53:2 | | | jquery-ui-1.12.0 | use | src/tst.html:52:5:52:8 | $.ui | -| knockout-3.4.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| lodash-2.0.2 | import | src/tst.html:0:0:0:0 | src/tst.html | +| knockout-3.4.0 | import | src/tst.html:2:11:5:2 | | +| knockout-3.4.0 | import | src/tst.html:6:11:8:2 | | +| knockout-3.4.0 | import | src/tst.html:50:11:53:2 | | +| lodash-2.0.2 | import | src/tst.html:2:11:5:2 | | +| lodash-2.0.2 | import | src/tst.html:6:11:8:2 | | +| lodash-2.0.2 | import | src/tst.html:50:11:53:2 | | | lodash-2.0.2 | use | src/tst.html:4:3:4:3 | _ | | lodash-2.0.2 | use | src/tst.html:7:5:7:5 | _ | | lodash-2.0.2 | use | src/tst.html:52:5:52:5 | $ | -| lodash-3.4.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| lodash-3.4.0 | import | src/tst.html:2:11:5:2 | | +| lodash-3.4.0 | import | src/tst.html:6:11:8:2 | | +| lodash-3.4.0 | import | src/tst.html:50:11:53:2 | | | lodash-3.4.0 | use | src/tst.html:4:3:4:3 | _ | | lodash-3.4.0 | use | src/tst.html:7:5:7:5 | _ | -| lodash-4.15.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| lodash-4.15.0 | import | src/tst.html:2:11:5:2 | | +| lodash-4.15.0 | import | src/tst.html:6:11:8:2 | | +| lodash-4.15.0 | import | src/tst.html:50:11:53:2 | | | lodash-4.15.0 | use | src/tst.html:4:3:4:3 | _ | | lodash-4.15.0 | use | src/tst.html:7:5:7:5 | _ | -| modernizr-2.8.3 | import | src/tst.html:0:0:0:0 | src/tst.html | -| mootools-1.6.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| polymer-0.3.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| prototype-1.7.3 | import | src/tst.html:0:0:0:0 | src/tst.html | -| react-15.3.1 | import | src/tst.html:0:0:0:0 | src/tst.html | -| scriptaculous-1.9.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| swagger-ui-1.0.12 | import | src/tst.html:0:0:0:0 | src/tst.html | -| underscore-1.8.3 | import | src/tst.html:0:0:0:0 | src/tst.html | +| modernizr-2.8.3 | import | src/tst.html:2:11:5:2 | | +| modernizr-2.8.3 | import | src/tst.html:6:11:8:2 | | +| modernizr-2.8.3 | import | src/tst.html:50:11:53:2 | | +| mootools-1.6.0 | import | src/tst.html:2:11:5:2 | | +| mootools-1.6.0 | import | src/tst.html:6:11:8:2 | | +| mootools-1.6.0 | import | src/tst.html:50:11:53:2 | | +| polymer-0.3.0 | import | src/tst.html:2:11:5:2 | | +| polymer-0.3.0 | import | src/tst.html:6:11:8:2 | | +| polymer-0.3.0 | import | src/tst.html:50:11:53:2 | | +| prototype-1.7.3 | import | src/tst.html:2:11:5:2 | | +| prototype-1.7.3 | import | src/tst.html:6:11:8:2 | | +| prototype-1.7.3 | import | src/tst.html:50:11:53:2 | | +| react-15.3.1 | import | src/tst.html:2:11:5:2 | | +| react-15.3.1 | import | src/tst.html:6:11:8:2 | | +| react-15.3.1 | import | src/tst.html:50:11:53:2 | | +| scriptaculous-1.9.0 | import | src/tst.html:2:11:5:2 | | +| scriptaculous-1.9.0 | import | src/tst.html:6:11:8:2 | | +| scriptaculous-1.9.0 | import | src/tst.html:50:11:53:2 | | +| swagger-ui-1.0.12 | import | src/tst.html:2:11:5:2 | | +| swagger-ui-1.0.12 | import | src/tst.html:6:11:8:2 | | +| swagger-ui-1.0.12 | import | src/tst.html:50:11:53:2 | | +| underscore-1.8.3 | import | src/tst.html:2:11:5:2 | | +| underscore-1.8.3 | import | src/tst.html:6:11:8:2 | | +| underscore-1.8.3 | import | src/tst.html:50:11:53:2 | | | underscore-1.8.3 | use | src/tst.html:4:3:4:3 | _ | | underscore-1.8.3 | use | src/tst.html:7:5:7:5 | _ | -| vue-0.7.0 | import | src/tst.html:0:0:0:0 | src/tst.html | -| yui-3.18.0 | import | src/tst.html:0:0:0:0 | src/tst.html | +| vue-0.7.0 | import | src/tst.html:2:11:5:2 | | +| vue-0.7.0 | import | src/tst.html:6:11:8:2 | | +| vue-0.7.0 | import | src/tst.html:50:11:53:2 | | +| yui-3.18.0 | import | src/tst.html:2:11:5:2 | | +| yui-3.18.0 | import | src/tst.html:6:11:8:2 | | +| yui-3.18.0 | import | src/tst.html:50:11:53:2 | | diff --git a/javascript/ql/test/library-tests/frameworks/typeahead/test.expected b/javascript/ql/test/library-tests/frameworks/typeahead/test.expected new file mode 100644 index 00000000000..f8f3d7a81cd --- /dev/null +++ b/javascript/ql/test/library-tests/frameworks/typeahead/test.expected @@ -0,0 +1,8 @@ +url +| tst.js:3:14:5:6 | {\\n\\t ... \\n\\t } | +| tst.js:4:15:4:52 | '/api/d ... %QUERY' | +| tst.js:8:16:8:29 | searchIndexUrl | +response +| json | false | tst.js:15:35:15:46 | taintedParam | +suggestionFunction +| tst.js:15:25:17:4 | functio ... \\n\\t\\n\\t\\t\\t} | diff --git a/javascript/ql/test/library-tests/frameworks/typeahead/test.ql b/javascript/ql/test/library-tests/frameworks/typeahead/test.ql new file mode 100644 index 00000000000..4b444d66bd0 --- /dev/null +++ b/javascript/ql/test/library-tests/frameworks/typeahead/test.ql @@ -0,0 +1,13 @@ +import javascript + +query DataFlow::Node url() { + result = any(ClientRequest r).getUrl() +} + +query DataFlow::Node response(string responseType, boolean promise) { + result = any(ClientRequest r).getAResponseDataNode(responseType, promise) +} + +query DataFlow::Node suggestionFunction() { + result = any(Typeahead::TypeaheadSuggestionFunction t) +} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/frameworks/typeahead/tst.js b/javascript/ql/test/library-tests/frameworks/typeahead/tst.js new file mode 100644 index 00000000000..32af3b3abd1 --- /dev/null +++ b/javascript/ql/test/library-tests/frameworks/typeahead/tst.js @@ -0,0 +1,20 @@ +(function () { + var foo = new Bloodhound({ + remote: { + url: '/api/destinations/search?text=%QUERY' + } + }); + var bar = new Bloodhound({ + prefetch: searchIndexUrl + }); + + $('.typeahead').typeahead({}, { + name: 'prefetchedCities', + source: bar.ttAdapter(), + templates: { + suggestion: function (taintedParam) { + + }, + } + }); +})(); \ No newline at end of file diff --git a/javascript/ql/test/query-tests/Metrics/ExternalDependencies/ExternalDependencies.expected b/javascript/ql/test/query-tests/Metrics/ExternalDependencies/ExternalDependencies.expected index 1eade4130a3..39b6d8ffcad 100644 --- a/javascript/ql/test/query-tests/Metrics/ExternalDependencies/ExternalDependencies.expected +++ b/javascript/ql/test/query-tests/Metrics/ExternalDependencies/ExternalDependencies.expected @@ -1,8 +1,8 @@ +| /src/tst.html<\|>jquery<\|>23.0.0 | 4 | | /src/a.js<\|>lib3<\|>unknown | 3 | -| /src/tst.html<\|>jquery<\|>23.0.0 | 3 | +| /src/tst.html<\|>jquery<\|>42.0.0 | 3 | | /src/a.js<\|>lib1<\|>1.0.2 | 2 | | /src/b.js<\|>lib3<\|>unknown | 2 | -| /src/tst.html<\|>jquery<\|>42.0.0 | 2 | | /src/a.js<\|>lib2<\|>1.0.0 | 1 | | /src/b.js<\|>lib2<\|>1.0.0 | 1 | | /src/sub/c.js<\|>lib1<\|>1.0.2 | 1 | diff --git a/javascript/ql/test/query-tests/RegExp/UnmatchableCaret/tst.js b/javascript/ql/test/query-tests/RegExp/UnmatchableCaret/tst.js index d2124572861..50d70094dd6 100644 --- a/javascript/ql/test/query-tests/RegExp/UnmatchableCaret/tst.js +++ b/javascript/ql/test/query-tests/RegExp/UnmatchableCaret/tst.js @@ -26,4 +26,7 @@ /^(^y|^z)(u$|v$)$/; // OK -/x*^y/; \ No newline at end of file +/x*^y/; + +// OK +/(?<=(^|\/)(\.|\.\.))$/; diff --git a/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/UnmatchableDollar.expected b/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/UnmatchableDollar.expected index 9b5a291f2e9..6e57f22c18a 100644 --- a/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/UnmatchableDollar.expected +++ b/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/UnmatchableDollar.expected @@ -1,3 +1,4 @@ | tst.js:2:10:2:10 | $ | This assertion can never match. | | tst.js:11:3:11:3 | $ | This assertion can never match. | | tst.js:20:3:20:3 | $ | This assertion can never match. | +| tst.js:38:6:38:6 | $ | This assertion can never match. | diff --git a/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/tst.js b/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/tst.js index 78e6b9f179d..95708b3cd0e 100644 --- a/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/tst.js +++ b/javascript/ql/test/query-tests/RegExp/UnmatchableDollar/tst.js @@ -32,4 +32,7 @@ /x(?!y+$).*y.*/; // OK -/x(?=[yz]+$).*yz.*/; \ No newline at end of file +/x(?=[yz]+$).*yz.*/; + +// NOT OK +/(?<=$x)yz/; diff --git a/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.expected b/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.expected new file mode 100644 index 00000000000..bd07494e0f2 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.expected @@ -0,0 +1,151 @@ +nodes +| exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:9:11:9:13 | foo | +| exception-xss.js:10:10:10:10 | e | +| exception-xss.js:11:18:11:18 | e | +| exception-xss.js:11:18:11:18 | e | +| exception-xss.js:15:3:15:12 | exceptional return of inner(foo) | +| exception-xss.js:15:9:15:11 | foo | +| exception-xss.js:16:10:16:10 | e | +| exception-xss.js:17:18:17:18 | e | +| exception-xss.js:17:18:17:18 | e | +| exception-xss.js:21:11:21:13 | foo | +| exception-xss.js:21:11:21:21 | foo + "bar" | +| exception-xss.js:22:10:22:10 | e | +| exception-xss.js:23:18:23:18 | e | +| exception-xss.js:23:18:23:18 | e | +| exception-xss.js:33:11:33:22 | ["bar", foo] | +| exception-xss.js:33:19:33:21 | foo | +| exception-xss.js:34:10:34:10 | e | +| exception-xss.js:35:18:35:18 | e | +| exception-xss.js:35:18:35:18 | e | +| exception-xss.js:46:3:46:19 | exceptional return of deep("bar" + foo) | +| exception-xss.js:46:8:46:18 | "bar" + foo | +| exception-xss.js:46:16:46:18 | foo | +| exception-xss.js:47:10:47:10 | e | +| exception-xss.js:48:18:48:18 | e | +| exception-xss.js:48:18:48:18 | e | +| exception-xss.js:81:3:81:19 | exceptional return of myWeirdInner(foo) | +| exception-xss.js:81:16:81:18 | foo | +| exception-xss.js:82:10:82:10 | e | +| exception-xss.js:83:18:83:18 | e | +| exception-xss.js:83:18:83:18 | e | +| exception-xss.js:89:11:89:13 | foo | +| exception-xss.js:89:11:89:26 | foo.match(/foo/) | +| exception-xss.js:90:10:90:10 | e | +| exception-xss.js:91:18:91:18 | e | +| exception-xss.js:91:18:91:18 | e | +| exception-xss.js:95:11:95:22 | [foo, "bar"] | +| exception-xss.js:95:12:95:14 | foo | +| exception-xss.js:96:10:96:10 | e | +| exception-xss.js:97:18:97:18 | e | +| exception-xss.js:97:18:97:18 | e | +| exception-xss.js:102:12:102:14 | foo | +| exception-xss.js:106:10:106:10 | e | +| exception-xss.js:107:18:107:18 | e | +| exception-xss.js:107:18:107:18 | e | +| exception-xss.js:117:13:117:25 | req.params.id | +| exception-xss.js:117:13:117:25 | req.params.id | +| exception-xss.js:118:11:118:11 | e | +| exception-xss.js:119:14:119:30 | "Exception: " + e | +| exception-xss.js:119:14:119:30 | "Exception: " + e | +| exception-xss.js:119:30:119:30 | e | +| exception-xss.js:125:48:125:64 | document.location | +| exception-xss.js:125:48:125:64 | document.location | +| exception-xss.js:125:48:125:71 | documen ... .search | +| exception-xss.js:128:11:128:52 | session ... ssion') | +| exception-xss.js:129:10:129:10 | e | +| exception-xss.js:130:18:130:18 | e | +| exception-xss.js:130:18:130:18 | e | +| tst.js:298:9:298:16 | location | +| tst.js:298:9:298:16 | location | +| tst.js:299:10:299:10 | e | +| tst.js:300:20:300:20 | e | +| tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | +| tst.js:305:10:305:17 | location | +| tst.js:307:10:307:10 | e | +| tst.js:308:20:308:20 | e | +| tst.js:308:20:308:20 | e | +edges +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:9:11:9:13 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:15:9:15:11 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:21:11:21:13 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:33:19:33:21 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:46:16:46:18 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:81:16:81:18 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:89:11:89:13 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:95:12:95:14 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:102:12:102:14 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:9:11:9:13 | foo | exception-xss.js:10:10:10:10 | e | +| exception-xss.js:10:10:10:10 | e | exception-xss.js:11:18:11:18 | e | +| exception-xss.js:10:10:10:10 | e | exception-xss.js:11:18:11:18 | e | +| exception-xss.js:15:3:15:12 | exceptional return of inner(foo) | exception-xss.js:16:10:16:10 | e | +| exception-xss.js:15:9:15:11 | foo | exception-xss.js:15:3:15:12 | exceptional return of inner(foo) | +| exception-xss.js:16:10:16:10 | e | exception-xss.js:17:18:17:18 | e | +| exception-xss.js:16:10:16:10 | e | exception-xss.js:17:18:17:18 | e | +| exception-xss.js:21:11:21:13 | foo | exception-xss.js:21:11:21:21 | foo + "bar" | +| exception-xss.js:21:11:21:21 | foo + "bar" | exception-xss.js:22:10:22:10 | e | +| exception-xss.js:22:10:22:10 | e | exception-xss.js:23:18:23:18 | e | +| exception-xss.js:22:10:22:10 | e | exception-xss.js:23:18:23:18 | e | +| exception-xss.js:33:11:33:22 | ["bar", foo] | exception-xss.js:34:10:34:10 | e | +| exception-xss.js:33:19:33:21 | foo | exception-xss.js:33:11:33:22 | ["bar", foo] | +| exception-xss.js:34:10:34:10 | e | exception-xss.js:35:18:35:18 | e | +| exception-xss.js:34:10:34:10 | e | exception-xss.js:35:18:35:18 | e | +| exception-xss.js:46:3:46:19 | exceptional return of deep("bar" + foo) | exception-xss.js:47:10:47:10 | e | +| exception-xss.js:46:8:46:18 | "bar" + foo | exception-xss.js:46:3:46:19 | exceptional return of deep("bar" + foo) | +| exception-xss.js:46:16:46:18 | foo | exception-xss.js:46:8:46:18 | "bar" + foo | +| exception-xss.js:47:10:47:10 | e | exception-xss.js:48:18:48:18 | e | +| exception-xss.js:47:10:47:10 | e | exception-xss.js:48:18:48:18 | e | +| exception-xss.js:81:3:81:19 | exceptional return of myWeirdInner(foo) | exception-xss.js:82:10:82:10 | e | +| exception-xss.js:81:16:81:18 | foo | exception-xss.js:81:3:81:19 | exceptional return of myWeirdInner(foo) | +| exception-xss.js:82:10:82:10 | e | exception-xss.js:83:18:83:18 | e | +| exception-xss.js:82:10:82:10 | e | exception-xss.js:83:18:83:18 | e | +| exception-xss.js:89:11:89:13 | foo | exception-xss.js:89:11:89:26 | foo.match(/foo/) | +| exception-xss.js:89:11:89:26 | foo.match(/foo/) | exception-xss.js:90:10:90:10 | e | +| exception-xss.js:90:10:90:10 | e | exception-xss.js:91:18:91:18 | e | +| exception-xss.js:90:10:90:10 | e | exception-xss.js:91:18:91:18 | e | +| exception-xss.js:95:11:95:22 | [foo, "bar"] | exception-xss.js:96:10:96:10 | e | +| exception-xss.js:95:12:95:14 | foo | exception-xss.js:95:11:95:22 | [foo, "bar"] | +| exception-xss.js:96:10:96:10 | e | exception-xss.js:97:18:97:18 | e | +| exception-xss.js:96:10:96:10 | e | exception-xss.js:97:18:97:18 | e | +| exception-xss.js:102:12:102:14 | foo | exception-xss.js:106:10:106:10 | e | +| exception-xss.js:106:10:106:10 | e | exception-xss.js:107:18:107:18 | e | +| exception-xss.js:106:10:106:10 | e | exception-xss.js:107:18:107:18 | e | +| exception-xss.js:117:13:117:25 | req.params.id | exception-xss.js:118:11:118:11 | e | +| exception-xss.js:117:13:117:25 | req.params.id | exception-xss.js:118:11:118:11 | e | +| exception-xss.js:118:11:118:11 | e | exception-xss.js:119:30:119:30 | e | +| exception-xss.js:119:30:119:30 | e | exception-xss.js:119:14:119:30 | "Exception: " + e | +| exception-xss.js:119:30:119:30 | e | exception-xss.js:119:14:119:30 | "Exception: " + e | +| exception-xss.js:125:48:125:64 | document.location | exception-xss.js:125:48:125:71 | documen ... .search | +| exception-xss.js:125:48:125:64 | document.location | exception-xss.js:125:48:125:71 | documen ... .search | +| exception-xss.js:125:48:125:71 | documen ... .search | exception-xss.js:128:11:128:52 | session ... ssion') | +| exception-xss.js:128:11:128:52 | session ... ssion') | exception-xss.js:129:10:129:10 | e | +| exception-xss.js:129:10:129:10 | e | exception-xss.js:130:18:130:18 | e | +| exception-xss.js:129:10:129:10 | e | exception-xss.js:130:18:130:18 | e | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +#select +| exception-xss.js:11:18:11:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:11:18:11:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:17:18:17:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:17:18:17:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:23:18:23:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:23:18:23:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:35:18:35:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:35:18:35:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:48:18:48:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:48:18:48:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:83:18:83:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:83:18:83:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:91:18:91:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:91:18:91:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:97:18:97:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:97:18:97:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:107:18:107:18 | e | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:107:18:107:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | +| exception-xss.js:119:14:119:30 | "Exception: " + e | exception-xss.js:117:13:117:25 | req.params.id | exception-xss.js:119:14:119:30 | "Exception: " + e | Cross-site scripting vulnerability due to $@. | exception-xss.js:117:13:117:25 | req.params.id | user-provided value | +| exception-xss.js:130:18:130:18 | e | exception-xss.js:125:48:125:64 | document.location | exception-xss.js:130:18:130:18 | e | Cross-site scripting vulnerability due to $@. | exception-xss.js:125:48:125:64 | document.location | user-provided value | +| tst.js:300:20:300:20 | e | tst.js:298:9:298:16 | location | tst.js:300:20:300:20 | e | Cross-site scripting vulnerability due to $@. | tst.js:298:9:298:16 | location | user-provided value | +| tst.js:308:20:308:20 | e | tst.js:305:10:305:17 | location | tst.js:308:20:308:20 | e | Cross-site scripting vulnerability due to $@. | tst.js:305:10:305:17 | location | user-provided value | diff --git a/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.qlref b/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.qlref new file mode 100644 index 00000000000..5fae24d64c4 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/ExceptionXss.qlref @@ -0,0 +1 @@ +Security/CWE-079/ExceptionXss.ql \ No newline at end of file diff --git a/javascript/ql/test/query-tests/Security/CWE-079/Xss.expected b/javascript/ql/test/query-tests/Security/CWE-079/Xss.expected index 2e986a06dea..033406f0df9 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/Xss.expected +++ b/javascript/ql/test/query-tests/Security/CWE-079/Xss.expected @@ -15,6 +15,11 @@ nodes | addEventListener.js:12:24:12:28 | event | | addEventListener.js:12:24:12:33 | event.data | | addEventListener.js:12:24:12:33 | event.data | +| exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:86:17:86:19 | foo | | jquery.js:2:7:2:40 | tainted | | jquery.js:2:17:2:33 | document.location | | jquery.js:2:17:2:33 | document.location | @@ -309,15 +314,31 @@ nodes | tst.js:277:22:277:29 | location | | tst.js:277:22:277:29 | location | | tst.js:282:9:282:29 | tainted | -| tst.js:282:9:282:29 | tainted | | tst.js:282:19:282:29 | window.name | | tst.js:282:19:282:29 | window.name | | tst.js:285:59:285:65 | tainted | | tst.js:285:59:285:65 | tainted | -| tst.js:285:59:285:65 | tainted | -| tst.js:297:35:297:42 | location | -| tst.js:297:35:297:42 | location | -| tst.js:297:35:297:42 | location | +| tst.js:298:9:298:16 | location | +| tst.js:298:9:298:16 | location | +| tst.js:299:10:299:10 | e | +| tst.js:300:20:300:20 | e | +| tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | +| tst.js:305:10:305:17 | location | +| tst.js:307:10:307:10 | e | +| tst.js:308:20:308:20 | e | +| tst.js:308:20:308:20 | e | +| tst.js:313:35:313:42 | location | +| tst.js:313:35:313:42 | location | +| tst.js:313:35:313:42 | location | +| typeahead.js:20:13:20:45 | target | +| typeahead.js:20:22:20:38 | document.location | +| typeahead.js:20:22:20:38 | document.location | +| typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:21:12:21:17 | target | +| typeahead.js:24:30:24:32 | val | +| typeahead.js:25:18:25:20 | val | +| typeahead.js:25:18:25:20 | val | | v-html.vue:2:8:2:23 | v-html=tainted | | v-html.vue:2:8:2:23 | v-html=tainted | | v-html.vue:6:42:6:58 | document.location | @@ -345,6 +366,10 @@ edges | addEventListener.js:10:21:10:25 | event | addEventListener.js:12:24:12:28 | event | | addEventListener.js:12:24:12:28 | event | addEventListener.js:12:24:12:33 | event.data | | addEventListener.js:12:24:12:28 | event | addEventListener.js:12:24:12:33 | event.data | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | | jquery.js:2:7:2:40 | tainted | jquery.js:4:5:4:11 | tainted | | jquery.js:2:7:2:40 | tainted | jquery.js:4:5:4:11 | tainted | | jquery.js:2:7:2:40 | tainted | jquery.js:7:20:7:26 | tainted | @@ -602,12 +627,24 @@ edges | tst.js:277:22:277:29 | location | tst.js:277:22:277:29 | location | | tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | | tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | -| tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | -| tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | | tst.js:282:19:282:29 | window.name | tst.js:282:9:282:29 | tainted | | tst.js:282:19:282:29 | window.name | tst.js:282:9:282:29 | tainted | -| tst.js:285:59:285:65 | tainted | tst.js:285:59:285:65 | tainted | -| tst.js:297:35:297:42 | location | tst.js:297:35:297:42 | location | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +| tst.js:313:35:313:42 | location | tst.js:313:35:313:42 | location | +| typeahead.js:20:13:20:45 | target | typeahead.js:21:12:21:17 | target | +| typeahead.js:20:22:20:38 | document.location | typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:20:22:20:38 | document.location | typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:20:22:20:45 | documen ... .search | typeahead.js:20:13:20:45 | target | +| typeahead.js:21:12:21:17 | target | typeahead.js:24:30:24:32 | val | +| typeahead.js:24:30:24:32 | val | typeahead.js:25:18:25:20 | val | +| typeahead.js:24:30:24:32 | val | typeahead.js:25:18:25:20 | val | | v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | | v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | | v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | @@ -624,6 +661,7 @@ edges | addEventListener.js:2:20:2:29 | event.data | addEventListener.js:1:43:1:47 | event | addEventListener.js:2:20:2:29 | event.data | Cross-site scripting vulnerability due to $@. | addEventListener.js:1:43:1:47 | event | user-provided value | | addEventListener.js:6:20:6:23 | data | addEventListener.js:5:43:5:48 | {data} | addEventListener.js:6:20:6:23 | data | Cross-site scripting vulnerability due to $@. | addEventListener.js:5:43:5:48 | {data} | user-provided value | | addEventListener.js:12:24:12:33 | event.data | addEventListener.js:10:21:10:25 | event | addEventListener.js:12:24:12:33 | event.data | Cross-site scripting vulnerability due to $@. | addEventListener.js:10:21:10:25 | event | user-provided value | +| exception-xss.js:86:17:86:19 | foo | exception-xss.js:2:15:2:31 | document.location | exception-xss.js:86:17:86:19 | foo | Cross-site scripting vulnerability due to $@. | exception-xss.js:2:15:2:31 | document.location | user-provided value | | jquery.js:4:5:4:11 | tainted | jquery.js:2:17:2:33 | document.location | jquery.js:4:5:4:11 | tainted | Cross-site scripting vulnerability due to $@. | jquery.js:2:17:2:33 | document.location | user-provided value | | jquery.js:7:5:7:34 | "
    " | jquery.js:2:17:2:33 | document.location | jquery.js:7:5:7:34 | "
    " | Cross-site scripting vulnerability due to $@. | jquery.js:2:17:2:33 | document.location | user-provided value | | jquery.js:8:18:8:34 | "XSS: " + tainted | jquery.js:2:17:2:33 | document.location | jquery.js:8:18:8:34 | "XSS: " + tainted | Cross-site scripting vulnerability due to $@. | jquery.js:2:17:2:33 | document.location | user-provided value | @@ -694,10 +732,11 @@ edges | tst.js:257:7:257:10 | name | tst.js:257:7:257:10 | name | tst.js:257:7:257:10 | name | Cross-site scripting vulnerability due to $@. | tst.js:257:7:257:10 | name | user-provided value | | tst.js:261:11:261:21 | window.name | tst.js:261:11:261:21 | window.name | tst.js:261:11:261:21 | window.name | Cross-site scripting vulnerability due to $@. | tst.js:261:11:261:21 | window.name | user-provided value | | tst.js:277:22:277:29 | location | tst.js:277:22:277:29 | location | tst.js:277:22:277:29 | location | Cross-site scripting vulnerability due to $@. | tst.js:277:22:277:29 | location | user-provided value | -| tst.js:285:59:285:65 | tainted | tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | Cross-site scripting vulnerability due to $@. | tst.js:282:9:282:29 | tainted | user-provided value | | tst.js:285:59:285:65 | tainted | tst.js:282:19:282:29 | window.name | tst.js:285:59:285:65 | tainted | Cross-site scripting vulnerability due to $@. | tst.js:282:19:282:29 | window.name | user-provided value | -| tst.js:285:59:285:65 | tainted | tst.js:285:59:285:65 | tainted | tst.js:285:59:285:65 | tainted | Cross-site scripting vulnerability due to $@. | tst.js:285:59:285:65 | tainted | user-provided value | -| tst.js:297:35:297:42 | location | tst.js:297:35:297:42 | location | tst.js:297:35:297:42 | location | Cross-site scripting vulnerability due to $@. | tst.js:297:35:297:42 | location | user-provided value | +| tst.js:300:20:300:20 | e | tst.js:298:9:298:16 | location | tst.js:300:20:300:20 | e | Cross-site scripting vulnerability due to $@. | tst.js:298:9:298:16 | location | user-provided value | +| tst.js:308:20:308:20 | e | tst.js:305:10:305:17 | location | tst.js:308:20:308:20 | e | Cross-site scripting vulnerability due to $@. | tst.js:305:10:305:17 | location | user-provided value | +| tst.js:313:35:313:42 | location | tst.js:313:35:313:42 | location | tst.js:313:35:313:42 | location | Cross-site scripting vulnerability due to $@. | tst.js:313:35:313:42 | location | user-provided value | +| typeahead.js:25:18:25:20 | val | typeahead.js:20:22:20:38 | document.location | typeahead.js:25:18:25:20 | val | Cross-site scripting vulnerability due to $@. | typeahead.js:20:22:20:38 | document.location | user-provided value | | v-html.vue:2:8:2:23 | v-html=tainted | v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | Cross-site scripting vulnerability due to $@. | v-html.vue:6:42:6:58 | document.location | user-provided value | | winjs.js:3:43:3:49 | tainted | winjs.js:2:17:2:33 | document.location | winjs.js:3:43:3:49 | tainted | Cross-site scripting vulnerability due to $@. | winjs.js:2:17:2:33 | document.location | user-provided value | | winjs.js:4:43:4:49 | tainted | winjs.js:2:17:2:33 | document.location | winjs.js:4:43:4:49 | tainted | Cross-site scripting vulnerability due to $@. | winjs.js:2:17:2:33 | document.location | user-provided value | diff --git a/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.expected b/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.expected new file mode 100644 index 00000000000..85eed820b2e --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.expected @@ -0,0 +1,669 @@ +nodes +| addEventListener.js:1:43:1:47 | event | +| addEventListener.js:1:43:1:47 | event | +| addEventListener.js:2:20:2:24 | event | +| addEventListener.js:2:20:2:29 | event.data | +| addEventListener.js:2:20:2:29 | event.data | +| addEventListener.js:5:43:5:48 | data | +| addEventListener.js:5:43:5:48 | {data} | +| addEventListener.js:5:43:5:48 | {data} | +| addEventListener.js:5:44:5:47 | data | +| addEventListener.js:6:20:6:23 | data | +| addEventListener.js:6:20:6:23 | data | +| addEventListener.js:10:21:10:25 | event | +| addEventListener.js:10:21:10:25 | event | +| addEventListener.js:12:24:12:28 | event | +| addEventListener.js:12:24:12:33 | event.data | +| addEventListener.js:12:24:12:33 | event.data | +| exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:2:15:2:31 | document.location | +| exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:86:17:86:19 | foo | +| jquery.js:2:7:2:40 | tainted | +| jquery.js:2:17:2:33 | document.location | +| jquery.js:2:17:2:33 | document.location | +| jquery.js:2:17:2:40 | documen ... .search | +| jquery.js:4:5:4:11 | tainted | +| jquery.js:4:5:4:11 | tainted | +| jquery.js:7:5:7:34 | "
    " | +| jquery.js:7:5:7:34 | "
    " | +| jquery.js:7:20:7:26 | tainted | +| jquery.js:8:18:8:34 | "XSS: " + tainted | +| jquery.js:8:18:8:34 | "XSS: " + tainted | +| jquery.js:8:28:8:34 | tainted | +| nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| nodemailer.js:13:50:13:66 | req.query.message | +| nodemailer.js:13:50:13:66 | req.query.message | +| react-native.js:7:7:7:33 | tainted | +| react-native.js:7:17:7:33 | req.param("code") | +| react-native.js:7:17:7:33 | req.param("code") | +| react-native.js:8:18:8:24 | tainted | +| react-native.js:8:18:8:24 | tainted | +| react-native.js:9:27:9:33 | tainted | +| react-native.js:9:27:9:33 | tainted | +| stored-xss.js:2:39:2:55 | document.location | +| stored-xss.js:2:39:2:55 | document.location | +| stored-xss.js:2:39:2:62 | documen ... .search | +| stored-xss.js:3:35:3:51 | document.location | +| stored-xss.js:3:35:3:51 | document.location | +| stored-xss.js:3:35:3:58 | documen ... .search | +| stored-xss.js:5:20:5:52 | session ... ssion') | +| stored-xss.js:5:20:5:52 | session ... ssion') | +| stored-xss.js:8:20:8:48 | localSt ... local') | +| stored-xss.js:8:20:8:48 | localSt ... local') | +| string-manipulations.js:3:16:3:32 | document.location | +| string-manipulations.js:3:16:3:32 | document.location | +| string-manipulations.js:3:16:3:32 | document.location | +| string-manipulations.js:4:16:4:32 | document.location | +| string-manipulations.js:4:16:4:32 | document.location | +| string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:5:16:5:32 | document.location | +| string-manipulations.js:5:16:5:32 | document.location | +| string-manipulations.js:5:16:5:37 | documen ... on.href | +| string-manipulations.js:5:16:5:47 | documen ... lueOf() | +| string-manipulations.js:5:16:5:47 | documen ... lueOf() | +| string-manipulations.js:6:16:6:32 | document.location | +| string-manipulations.js:6:16:6:32 | document.location | +| string-manipulations.js:6:16:6:37 | documen ... on.href | +| string-manipulations.js:6:16:6:43 | documen ... f.sup() | +| string-manipulations.js:6:16:6:43 | documen ... f.sup() | +| string-manipulations.js:7:16:7:32 | document.location | +| string-manipulations.js:7:16:7:32 | document.location | +| string-manipulations.js:7:16:7:37 | documen ... on.href | +| string-manipulations.js:7:16:7:51 | documen ... rCase() | +| string-manipulations.js:7:16:7:51 | documen ... rCase() | +| string-manipulations.js:8:16:8:32 | document.location | +| string-manipulations.js:8:16:8:32 | document.location | +| string-manipulations.js:8:16:8:37 | documen ... on.href | +| string-manipulations.js:8:16:8:48 | documen ... mLeft() | +| string-manipulations.js:8:16:8:48 | documen ... mLeft() | +| string-manipulations.js:9:16:9:58 | String. ... n.href) | +| string-manipulations.js:9:16:9:58 | String. ... n.href) | +| string-manipulations.js:9:36:9:52 | document.location | +| string-manipulations.js:9:36:9:52 | document.location | +| string-manipulations.js:9:36:9:57 | documen ... on.href | +| string-manipulations.js:10:16:10:45 | String( ... n.href) | +| string-manipulations.js:10:16:10:45 | String( ... n.href) | +| string-manipulations.js:10:23:10:39 | document.location | +| string-manipulations.js:10:23:10:39 | document.location | +| string-manipulations.js:10:23:10:44 | documen ... on.href | +| translate.js:6:7:6:39 | target | +| translate.js:6:16:6:32 | document.location | +| translate.js:6:16:6:32 | document.location | +| translate.js:6:16:6:39 | documen ... .search | +| translate.js:7:42:7:47 | target | +| translate.js:7:42:7:60 | target.substring(1) | +| translate.js:9:27:9:50 | searchP ... 'term') | +| translate.js:9:27:9:50 | searchP ... 'term') | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | +| tst3.js:2:23:2:74 | decodeU ... str(1)) | +| tst3.js:2:42:2:56 | window.location | +| tst3.js:2:42:2:56 | window.location | +| tst3.js:2:42:2:63 | window. ... .search | +| tst3.js:2:42:2:73 | window. ... bstr(1) | +| tst3.js:4:25:4:28 | data | +| tst3.js:4:25:4:32 | data.src | +| tst3.js:4:25:4:32 | data.src | +| tst3.js:5:26:5:29 | data | +| tst3.js:5:26:5:31 | data.p | +| tst3.js:5:26:5:31 | data.p | +| tst3.js:7:32:7:35 | data | +| tst3.js:7:32:7:37 | data.p | +| tst3.js:7:32:7:37 | data.p | +| tst3.js:9:37:9:40 | data | +| tst3.js:9:37:9:42 | data.p | +| tst3.js:9:37:9:42 | data.p | +| tst3.js:10:38:10:41 | data | +| tst3.js:10:38:10:43 | data.p | +| tst3.js:10:38:10:43 | data.p | +| tst.js:2:7:2:39 | target | +| tst.js:2:16:2:32 | document.location | +| tst.js:2:16:2:32 | document.location | +| tst.js:2:16:2:39 | documen ... .search | +| tst.js:5:18:5:23 | target | +| tst.js:5:18:5:23 | target | +| tst.js:8:18:8:126 | "" | +| tst.js:8:18:8:126 | "" | +| tst.js:8:37:8:53 | document.location | +| tst.js:8:37:8:53 | document.location | +| tst.js:8:37:8:58 | documen ... on.href | +| tst.js:8:37:8:114 | documen ... t=")+8) | +| tst.js:12:5:12:42 | '
    ' | +| tst.js:12:5:12:42 | '
    ' | +| tst.js:12:28:12:33 | target | +| tst.js:19:25:19:41 | document.location | +| tst.js:19:25:19:41 | document.location | +| tst.js:20:18:20:35 | params.get('name') | +| tst.js:20:18:20:35 | params.get('name') | +| tst.js:23:42:23:47 | target | +| tst.js:23:42:23:60 | target.substring(1) | +| tst.js:24:18:24:41 | searchP ... 'name') | +| tst.js:24:18:24:41 | searchP ... 'name') | +| tst.js:27:14:27:19 | target | +| tst.js:29:18:29:23 | target | +| tst.js:29:18:29:23 | target | +| tst.js:31:5:31:21 | document.location | +| tst.js:31:5:31:21 | document.location | +| tst.js:31:5:31:28 | documen ... .search | +| tst.js:34:10:34:26 | document.location | +| tst.js:34:10:34:26 | document.location | +| tst.js:34:10:34:33 | documen ... .search | +| tst.js:37:16:37:20 | bar() | +| tst.js:37:16:37:20 | bar() | +| tst.js:43:16:43:44 | baz(doc ... search) | +| tst.js:43:16:43:44 | baz(doc ... search) | +| tst.js:43:20:43:36 | document.location | +| tst.js:43:20:43:36 | document.location | +| tst.js:43:20:43:43 | documen ... .search | +| tst.js:49:16:49:45 | wrap(do ... search) | +| tst.js:49:16:49:45 | wrap(do ... search) | +| tst.js:49:21:49:37 | document.location | +| tst.js:49:21:49:37 | document.location | +| tst.js:49:21:49:44 | documen ... .search | +| tst.js:57:16:57:45 | chop(do ... search) | +| tst.js:57:16:57:45 | chop(do ... search) | +| tst.js:57:21:57:37 | document.location | +| tst.js:57:21:57:37 | document.location | +| tst.js:57:21:57:44 | documen ... .search | +| tst.js:59:16:59:45 | chop(do ... search) | +| tst.js:59:16:59:45 | chop(do ... search) | +| tst.js:59:21:59:37 | document.location | +| tst.js:59:21:59:37 | document.location | +| tst.js:59:21:59:44 | documen ... .search | +| tst.js:61:16:61:32 | wrap(chop(bar())) | +| tst.js:61:16:61:32 | wrap(chop(bar())) | +| tst.js:61:21:61:31 | chop(bar()) | +| tst.js:61:26:61:30 | bar() | +| tst.js:63:34:63:34 | s | +| tst.js:65:18:65:18 | s | +| tst.js:65:18:65:18 | s | +| tst.js:67:25:67:41 | document.location | +| tst.js:67:25:67:41 | document.location | +| tst.js:67:25:67:48 | documen ... .search | +| tst.js:68:25:68:41 | document.location | +| tst.js:68:25:68:41 | document.location | +| tst.js:68:25:68:48 | documen ... .search | +| tst.js:71:16:71:20 | bar() | +| tst.js:71:16:71:20 | bar() | +| tst.js:73:1:73:27 | [,docum ... search] | +| tst.js:73:3:73:19 | document.location | +| tst.js:73:3:73:19 | document.location | +| tst.js:73:3:73:26 | documen ... .search | +| tst.js:73:46:73:46 | x | +| tst.js:76:20:76:20 | x | +| tst.js:76:20:76:20 | x | +| tst.js:80:49:80:65 | document.location | +| tst.js:80:49:80:65 | document.location | +| tst.js:80:49:80:72 | documen ... .search | +| tst.js:80:49:80:72 | documen ... .search | +| tst.js:84:26:84:42 | document.location | +| tst.js:84:26:84:42 | document.location | +| tst.js:84:26:84:49 | documen ... .search | +| tst.js:84:26:84:49 | documen ... .search | +| tst.js:85:25:85:41 | document.location | +| tst.js:85:25:85:41 | document.location | +| tst.js:85:25:85:48 | documen ... .search | +| tst.js:85:25:85:48 | documen ... .search | +| tst.js:87:33:87:49 | document.location | +| tst.js:87:33:87:49 | document.location | +| tst.js:87:33:87:56 | documen ... .search | +| tst.js:87:33:87:56 | documen ... .search | +| tst.js:88:32:88:48 | document.location | +| tst.js:88:32:88:48 | document.location | +| tst.js:88:32:88:55 | documen ... .search | +| tst.js:88:32:88:55 | documen ... .search | +| tst.js:93:39:93:55 | document.location | +| tst.js:93:39:93:55 | document.location | +| tst.js:93:39:93:62 | documen ... .search | +| tst.js:93:39:93:62 | documen ... .search | +| tst.js:99:30:99:46 | document.location | +| tst.js:99:30:99:46 | document.location | +| tst.js:99:30:99:53 | documen ... .search | +| tst.js:99:30:99:53 | documen ... .search | +| tst.js:105:25:105:41 | document.location | +| tst.js:105:25:105:41 | document.location | +| tst.js:105:25:105:48 | documen ... .search | +| tst.js:105:25:105:48 | documen ... .search | +| tst.js:110:7:110:44 | v | +| tst.js:110:11:110:27 | document.location | +| tst.js:110:11:110:27 | document.location | +| tst.js:110:11:110:34 | documen ... .search | +| tst.js:110:11:110:44 | documen ... bstr(1) | +| tst.js:113:18:113:18 | v | +| tst.js:113:18:113:18 | v | +| tst.js:145:29:145:43 | window.location | +| tst.js:145:29:145:43 | window.location | +| tst.js:145:29:145:50 | window. ... .search | +| tst.js:148:29:148:29 | v | +| tst.js:148:49:148:49 | v | +| tst.js:148:49:148:49 | v | +| tst.js:152:29:152:46 | xssSourceService() | +| tst.js:152:29:152:46 | xssSourceService() | +| tst.js:155:40:155:54 | window.location | +| tst.js:155:40:155:54 | window.location | +| tst.js:155:40:155:61 | window. ... .search | +| tst.js:174:9:174:41 | target | +| tst.js:174:18:174:34 | document.location | +| tst.js:174:18:174:34 | document.location | +| tst.js:174:18:174:41 | documen ... .search | +| tst.js:177:28:177:33 | target | +| tst.js:177:28:177:33 | target | +| tst.js:181:9:181:42 | tainted | +| tst.js:181:19:181:35 | document.location | +| tst.js:181:19:181:35 | document.location | +| tst.js:181:19:181:42 | documen ... .search | +| tst.js:183:31:183:37 | tainted | +| tst.js:183:31:183:37 | tainted | +| tst.js:185:42:185:48 | tainted | +| tst.js:185:42:185:48 | tainted | +| tst.js:186:33:186:39 | tainted | +| tst.js:186:33:186:39 | tainted | +| tst.js:188:54:188:60 | tainted | +| tst.js:188:54:188:60 | tainted | +| tst.js:189:45:189:51 | tainted | +| tst.js:189:45:189:51 | tainted | +| tst.js:194:9:194:42 | tainted | +| tst.js:194:19:194:35 | document.location | +| tst.js:194:19:194:35 | document.location | +| tst.js:194:19:194:42 | documen ... .search | +| tst.js:196:67:196:73 | tainted | +| tst.js:196:67:196:73 | tainted | +| tst.js:197:67:197:73 | tainted | +| tst.js:197:67:197:73 | tainted | +| tst.js:201:35:201:41 | tainted | +| tst.js:203:46:203:52 | tainted | +| tst.js:204:38:204:44 | tainted | +| tst.js:205:35:205:41 | tainted | +| tst.js:209:28:209:46 | this.state.tainted1 | +| tst.js:209:28:209:46 | this.state.tainted1 | +| tst.js:210:28:210:46 | this.state.tainted2 | +| tst.js:210:28:210:46 | this.state.tainted2 | +| tst.js:211:28:211:46 | this.state.tainted3 | +| tst.js:211:28:211:46 | this.state.tainted3 | +| tst.js:215:32:215:49 | prevState.tainted4 | +| tst.js:215:32:215:49 | prevState.tainted4 | +| tst.js:222:28:222:46 | this.props.tainted1 | +| tst.js:222:28:222:46 | this.props.tainted1 | +| tst.js:223:28:223:46 | this.props.tainted2 | +| tst.js:223:28:223:46 | this.props.tainted2 | +| tst.js:224:28:224:46 | this.props.tainted3 | +| tst.js:224:28:224:46 | this.props.tainted3 | +| tst.js:228:32:228:49 | prevProps.tainted4 | +| tst.js:228:32:228:49 | prevProps.tainted4 | +| tst.js:233:35:233:41 | tainted | +| tst.js:235:20:235:26 | tainted | +| tst.js:237:23:237:29 | tainted | +| tst.js:238:23:238:29 | tainted | +| tst.js:244:39:244:55 | props.propTainted | +| tst.js:248:60:248:82 | this.st ... Tainted | +| tst.js:248:60:248:82 | this.st ... Tainted | +| tst.js:252:23:252:29 | tainted | +| tst.js:256:7:256:17 | window.name | +| tst.js:256:7:256:17 | window.name | +| tst.js:256:7:256:17 | window.name | +| tst.js:257:7:257:10 | name | +| tst.js:257:7:257:10 | name | +| tst.js:257:7:257:10 | name | +| tst.js:261:11:261:21 | window.name | +| tst.js:261:11:261:21 | window.name | +| tst.js:261:11:261:21 | window.name | +| tst.js:277:22:277:29 | location | +| tst.js:277:22:277:29 | location | +| tst.js:277:22:277:29 | location | +| tst.js:282:9:282:29 | tainted | +| tst.js:282:19:282:29 | window.name | +| tst.js:282:19:282:29 | window.name | +| tst.js:285:59:285:65 | tainted | +| tst.js:285:59:285:65 | tainted | +| tst.js:298:9:298:16 | location | +| tst.js:298:9:298:16 | location | +| tst.js:299:10:299:10 | e | +| tst.js:300:20:300:20 | e | +| tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | +| tst.js:305:10:305:17 | location | +| tst.js:307:10:307:10 | e | +| tst.js:308:20:308:20 | e | +| tst.js:308:20:308:20 | e | +| tst.js:313:35:313:42 | location | +| tst.js:313:35:313:42 | location | +| tst.js:313:35:313:42 | location | +| typeahead.js:9:28:9:30 | loc | +| typeahead.js:9:28:9:30 | loc | +| typeahead.js:10:16:10:18 | loc | +| typeahead.js:10:16:10:18 | loc | +| typeahead.js:20:13:20:45 | target | +| typeahead.js:20:22:20:38 | document.location | +| typeahead.js:20:22:20:38 | document.location | +| typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:21:12:21:17 | target | +| typeahead.js:24:30:24:32 | val | +| typeahead.js:25:18:25:20 | val | +| typeahead.js:25:18:25:20 | val | +| v-html.vue:2:8:2:23 | v-html=tainted | +| v-html.vue:2:8:2:23 | v-html=tainted | +| v-html.vue:6:42:6:58 | document.location | +| v-html.vue:6:42:6:58 | document.location | +| winjs.js:2:7:2:53 | tainted | +| winjs.js:2:17:2:33 | document.location | +| winjs.js:2:17:2:33 | document.location | +| winjs.js:2:17:2:40 | documen ... .search | +| winjs.js:2:17:2:53 | documen ... ring(1) | +| winjs.js:3:43:3:49 | tainted | +| winjs.js:3:43:3:49 | tainted | +| winjs.js:4:43:4:49 | tainted | +| winjs.js:4:43:4:49 | tainted | +edges +| addEventListener.js:1:43:1:47 | event | addEventListener.js:2:20:2:24 | event | +| addEventListener.js:1:43:1:47 | event | addEventListener.js:2:20:2:24 | event | +| addEventListener.js:2:20:2:24 | event | addEventListener.js:2:20:2:29 | event.data | +| addEventListener.js:2:20:2:24 | event | addEventListener.js:2:20:2:29 | event.data | +| addEventListener.js:5:43:5:48 | data | addEventListener.js:6:20:6:23 | data | +| addEventListener.js:5:43:5:48 | data | addEventListener.js:6:20:6:23 | data | +| addEventListener.js:5:43:5:48 | {data} | addEventListener.js:5:44:5:47 | data | +| addEventListener.js:5:43:5:48 | {data} | addEventListener.js:5:44:5:47 | data | +| addEventListener.js:5:44:5:47 | data | addEventListener.js:5:43:5:48 | data | +| addEventListener.js:10:21:10:25 | event | addEventListener.js:12:24:12:28 | event | +| addEventListener.js:10:21:10:25 | event | addEventListener.js:12:24:12:28 | event | +| addEventListener.js:12:24:12:28 | event | addEventListener.js:12:24:12:33 | event.data | +| addEventListener.js:12:24:12:28 | event | addEventListener.js:12:24:12:33 | event.data | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:2:9:2:31 | foo | exception-xss.js:86:17:86:19 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | +| exception-xss.js:2:15:2:31 | document.location | exception-xss.js:2:9:2:31 | foo | +| jquery.js:2:7:2:40 | tainted | jquery.js:4:5:4:11 | tainted | +| jquery.js:2:7:2:40 | tainted | jquery.js:4:5:4:11 | tainted | +| jquery.js:2:7:2:40 | tainted | jquery.js:7:20:7:26 | tainted | +| jquery.js:2:7:2:40 | tainted | jquery.js:8:28:8:34 | tainted | +| jquery.js:2:17:2:33 | document.location | jquery.js:2:17:2:40 | documen ... .search | +| jquery.js:2:17:2:33 | document.location | jquery.js:2:17:2:40 | documen ... .search | +| jquery.js:2:17:2:40 | documen ... .search | jquery.js:2:7:2:40 | tainted | +| jquery.js:7:20:7:26 | tainted | jquery.js:7:5:7:34 | "
    " | +| jquery.js:7:20:7:26 | tainted | jquery.js:7:5:7:34 | "
    " | +| jquery.js:8:28:8:34 | tainted | jquery.js:8:18:8:34 | "XSS: " + tainted | +| jquery.js:8:28:8:34 | tainted | jquery.js:8:18:8:34 | "XSS: " + tainted | +| nodemailer.js:13:50:13:66 | req.query.message | nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| nodemailer.js:13:50:13:66 | req.query.message | nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| nodemailer.js:13:50:13:66 | req.query.message | nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| nodemailer.js:13:50:13:66 | req.query.message | nodemailer.js:13:11:13:69 | `Hi, yo ... sage}.` | +| react-native.js:7:7:7:33 | tainted | react-native.js:8:18:8:24 | tainted | +| react-native.js:7:7:7:33 | tainted | react-native.js:8:18:8:24 | tainted | +| react-native.js:7:7:7:33 | tainted | react-native.js:9:27:9:33 | tainted | +| react-native.js:7:7:7:33 | tainted | react-native.js:9:27:9:33 | tainted | +| react-native.js:7:17:7:33 | req.param("code") | react-native.js:7:7:7:33 | tainted | +| react-native.js:7:17:7:33 | req.param("code") | react-native.js:7:7:7:33 | tainted | +| stored-xss.js:2:39:2:55 | document.location | stored-xss.js:2:39:2:62 | documen ... .search | +| stored-xss.js:2:39:2:55 | document.location | stored-xss.js:2:39:2:62 | documen ... .search | +| stored-xss.js:2:39:2:62 | documen ... .search | stored-xss.js:5:20:5:52 | session ... ssion') | +| stored-xss.js:2:39:2:62 | documen ... .search | stored-xss.js:5:20:5:52 | session ... ssion') | +| stored-xss.js:3:35:3:51 | document.location | stored-xss.js:3:35:3:58 | documen ... .search | +| stored-xss.js:3:35:3:51 | document.location | stored-xss.js:3:35:3:58 | documen ... .search | +| stored-xss.js:3:35:3:58 | documen ... .search | stored-xss.js:8:20:8:48 | localSt ... local') | +| stored-xss.js:3:35:3:58 | documen ... .search | stored-xss.js:8:20:8:48 | localSt ... local') | +| string-manipulations.js:3:16:3:32 | document.location | string-manipulations.js:3:16:3:32 | document.location | +| string-manipulations.js:4:16:4:32 | document.location | string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:4:16:4:32 | document.location | string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:4:16:4:32 | document.location | string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:4:16:4:32 | document.location | string-manipulations.js:4:16:4:37 | documen ... on.href | +| string-manipulations.js:5:16:5:32 | document.location | string-manipulations.js:5:16:5:37 | documen ... on.href | +| string-manipulations.js:5:16:5:32 | document.location | string-manipulations.js:5:16:5:37 | documen ... on.href | +| string-manipulations.js:5:16:5:37 | documen ... on.href | string-manipulations.js:5:16:5:47 | documen ... lueOf() | +| string-manipulations.js:5:16:5:37 | documen ... on.href | string-manipulations.js:5:16:5:47 | documen ... lueOf() | +| string-manipulations.js:6:16:6:32 | document.location | string-manipulations.js:6:16:6:37 | documen ... on.href | +| string-manipulations.js:6:16:6:32 | document.location | string-manipulations.js:6:16:6:37 | documen ... on.href | +| string-manipulations.js:6:16:6:37 | documen ... on.href | string-manipulations.js:6:16:6:43 | documen ... f.sup() | +| string-manipulations.js:6:16:6:37 | documen ... on.href | string-manipulations.js:6:16:6:43 | documen ... f.sup() | +| string-manipulations.js:7:16:7:32 | document.location | string-manipulations.js:7:16:7:37 | documen ... on.href | +| string-manipulations.js:7:16:7:32 | document.location | string-manipulations.js:7:16:7:37 | documen ... on.href | +| string-manipulations.js:7:16:7:37 | documen ... on.href | string-manipulations.js:7:16:7:51 | documen ... rCase() | +| string-manipulations.js:7:16:7:37 | documen ... on.href | string-manipulations.js:7:16:7:51 | documen ... rCase() | +| string-manipulations.js:8:16:8:32 | document.location | string-manipulations.js:8:16:8:37 | documen ... on.href | +| string-manipulations.js:8:16:8:32 | document.location | string-manipulations.js:8:16:8:37 | documen ... on.href | +| string-manipulations.js:8:16:8:37 | documen ... on.href | string-manipulations.js:8:16:8:48 | documen ... mLeft() | +| string-manipulations.js:8:16:8:37 | documen ... on.href | string-manipulations.js:8:16:8:48 | documen ... mLeft() | +| string-manipulations.js:9:36:9:52 | document.location | string-manipulations.js:9:36:9:57 | documen ... on.href | +| string-manipulations.js:9:36:9:52 | document.location | string-manipulations.js:9:36:9:57 | documen ... on.href | +| string-manipulations.js:9:36:9:57 | documen ... on.href | string-manipulations.js:9:16:9:58 | String. ... n.href) | +| string-manipulations.js:9:36:9:57 | documen ... on.href | string-manipulations.js:9:16:9:58 | String. ... n.href) | +| string-manipulations.js:10:23:10:39 | document.location | string-manipulations.js:10:23:10:44 | documen ... on.href | +| string-manipulations.js:10:23:10:39 | document.location | string-manipulations.js:10:23:10:44 | documen ... on.href | +| string-manipulations.js:10:23:10:44 | documen ... on.href | string-manipulations.js:10:16:10:45 | String( ... n.href) | +| string-manipulations.js:10:23:10:44 | documen ... on.href | string-manipulations.js:10:16:10:45 | String( ... n.href) | +| translate.js:6:7:6:39 | target | translate.js:7:42:7:47 | target | +| translate.js:6:16:6:32 | document.location | translate.js:6:16:6:39 | documen ... .search | +| translate.js:6:16:6:32 | document.location | translate.js:6:16:6:39 | documen ... .search | +| translate.js:6:16:6:39 | documen ... .search | translate.js:6:7:6:39 | target | +| translate.js:7:42:7:47 | target | translate.js:7:42:7:60 | target.substring(1) | +| translate.js:7:42:7:60 | target.substring(1) | translate.js:9:27:9:50 | searchP ... 'term') | +| translate.js:7:42:7:60 | target.substring(1) | translate.js:9:27:9:50 | searchP ... 'term') | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | tst3.js:4:25:4:28 | data | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | tst3.js:5:26:5:29 | data | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | tst3.js:7:32:7:35 | data | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | tst3.js:9:37:9:40 | data | +| tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | tst3.js:10:38:10:41 | data | +| tst3.js:2:23:2:74 | decodeU ... str(1)) | tst3.js:2:12:2:75 | JSON.pa ... tr(1))) | +| tst3.js:2:42:2:56 | window.location | tst3.js:2:42:2:63 | window. ... .search | +| tst3.js:2:42:2:56 | window.location | tst3.js:2:42:2:63 | window. ... .search | +| tst3.js:2:42:2:63 | window. ... .search | tst3.js:2:42:2:73 | window. ... bstr(1) | +| tst3.js:2:42:2:73 | window. ... bstr(1) | tst3.js:2:23:2:74 | decodeU ... str(1)) | +| tst3.js:4:25:4:28 | data | tst3.js:4:25:4:32 | data.src | +| tst3.js:4:25:4:28 | data | tst3.js:4:25:4:32 | data.src | +| tst3.js:5:26:5:29 | data | tst3.js:5:26:5:31 | data.p | +| tst3.js:5:26:5:29 | data | tst3.js:5:26:5:31 | data.p | +| tst3.js:7:32:7:35 | data | tst3.js:7:32:7:37 | data.p | +| tst3.js:7:32:7:35 | data | tst3.js:7:32:7:37 | data.p | +| tst3.js:9:37:9:40 | data | tst3.js:9:37:9:42 | data.p | +| tst3.js:9:37:9:40 | data | tst3.js:9:37:9:42 | data.p | +| tst3.js:10:38:10:41 | data | tst3.js:10:38:10:43 | data.p | +| tst3.js:10:38:10:41 | data | tst3.js:10:38:10:43 | data.p | +| tst.js:2:7:2:39 | target | tst.js:5:18:5:23 | target | +| tst.js:2:7:2:39 | target | tst.js:5:18:5:23 | target | +| tst.js:2:7:2:39 | target | tst.js:12:28:12:33 | target | +| tst.js:2:7:2:39 | target | tst.js:23:42:23:47 | target | +| tst.js:2:16:2:32 | document.location | tst.js:2:16:2:39 | documen ... .search | +| tst.js:2:16:2:32 | document.location | tst.js:2:16:2:39 | documen ... .search | +| tst.js:2:16:2:39 | documen ... .search | tst.js:2:7:2:39 | target | +| tst.js:8:37:8:53 | document.location | tst.js:8:37:8:58 | documen ... on.href | +| tst.js:8:37:8:53 | document.location | tst.js:8:37:8:58 | documen ... on.href | +| tst.js:8:37:8:58 | documen ... on.href | tst.js:8:37:8:114 | documen ... t=")+8) | +| tst.js:8:37:8:114 | documen ... t=")+8) | tst.js:8:18:8:126 | "" | +| tst.js:8:37:8:114 | documen ... t=")+8) | tst.js:8:18:8:126 | "" | +| tst.js:12:28:12:33 | target | tst.js:12:5:12:42 | '
    ' | +| tst.js:12:28:12:33 | target | tst.js:12:5:12:42 | '
    ' | +| tst.js:19:25:19:41 | document.location | tst.js:20:18:20:35 | params.get('name') | +| tst.js:19:25:19:41 | document.location | tst.js:20:18:20:35 | params.get('name') | +| tst.js:19:25:19:41 | document.location | tst.js:20:18:20:35 | params.get('name') | +| tst.js:19:25:19:41 | document.location | tst.js:20:18:20:35 | params.get('name') | +| tst.js:23:42:23:47 | target | tst.js:23:42:23:60 | target.substring(1) | +| tst.js:23:42:23:60 | target.substring(1) | tst.js:24:18:24:41 | searchP ... 'name') | +| tst.js:23:42:23:60 | target.substring(1) | tst.js:24:18:24:41 | searchP ... 'name') | +| tst.js:27:14:27:19 | target | tst.js:29:18:29:23 | target | +| tst.js:27:14:27:19 | target | tst.js:29:18:29:23 | target | +| tst.js:31:5:31:21 | document.location | tst.js:31:5:31:28 | documen ... .search | +| tst.js:31:5:31:21 | document.location | tst.js:31:5:31:28 | documen ... .search | +| tst.js:31:5:31:28 | documen ... .search | tst.js:27:14:27:19 | target | +| tst.js:34:10:34:26 | document.location | tst.js:34:10:34:33 | documen ... .search | +| tst.js:34:10:34:26 | document.location | tst.js:34:10:34:33 | documen ... .search | +| tst.js:34:10:34:33 | documen ... .search | tst.js:37:16:37:20 | bar() | +| tst.js:34:10:34:33 | documen ... .search | tst.js:37:16:37:20 | bar() | +| tst.js:34:10:34:33 | documen ... .search | tst.js:61:26:61:30 | bar() | +| tst.js:34:10:34:33 | documen ... .search | tst.js:71:16:71:20 | bar() | +| tst.js:34:10:34:33 | documen ... .search | tst.js:71:16:71:20 | bar() | +| tst.js:43:20:43:36 | document.location | tst.js:43:20:43:43 | documen ... .search | +| tst.js:43:20:43:36 | document.location | tst.js:43:20:43:43 | documen ... .search | +| tst.js:43:20:43:43 | documen ... .search | tst.js:43:16:43:44 | baz(doc ... search) | +| tst.js:43:20:43:43 | documen ... .search | tst.js:43:16:43:44 | baz(doc ... search) | +| tst.js:49:21:49:37 | document.location | tst.js:49:21:49:44 | documen ... .search | +| tst.js:49:21:49:37 | document.location | tst.js:49:21:49:44 | documen ... .search | +| tst.js:49:21:49:44 | documen ... .search | tst.js:49:16:49:45 | wrap(do ... search) | +| tst.js:49:21:49:44 | documen ... .search | tst.js:49:16:49:45 | wrap(do ... search) | +| tst.js:57:21:57:37 | document.location | tst.js:57:21:57:44 | documen ... .search | +| tst.js:57:21:57:37 | document.location | tst.js:57:21:57:44 | documen ... .search | +| tst.js:57:21:57:44 | documen ... .search | tst.js:57:16:57:45 | chop(do ... search) | +| tst.js:57:21:57:44 | documen ... .search | tst.js:57:16:57:45 | chop(do ... search) | +| tst.js:59:21:59:37 | document.location | tst.js:59:21:59:44 | documen ... .search | +| tst.js:59:21:59:37 | document.location | tst.js:59:21:59:44 | documen ... .search | +| tst.js:59:21:59:44 | documen ... .search | tst.js:59:16:59:45 | chop(do ... search) | +| tst.js:59:21:59:44 | documen ... .search | tst.js:59:16:59:45 | chop(do ... search) | +| tst.js:61:21:61:31 | chop(bar()) | tst.js:61:16:61:32 | wrap(chop(bar())) | +| tst.js:61:21:61:31 | chop(bar()) | tst.js:61:16:61:32 | wrap(chop(bar())) | +| tst.js:61:26:61:30 | bar() | tst.js:61:21:61:31 | chop(bar()) | +| tst.js:63:34:63:34 | s | tst.js:65:18:65:18 | s | +| tst.js:63:34:63:34 | s | tst.js:65:18:65:18 | s | +| tst.js:67:25:67:41 | document.location | tst.js:67:25:67:48 | documen ... .search | +| tst.js:67:25:67:41 | document.location | tst.js:67:25:67:48 | documen ... .search | +| tst.js:67:25:67:48 | documen ... .search | tst.js:63:34:63:34 | s | +| tst.js:68:25:68:41 | document.location | tst.js:68:25:68:48 | documen ... .search | +| tst.js:68:25:68:41 | document.location | tst.js:68:25:68:48 | documen ... .search | +| tst.js:68:25:68:48 | documen ... .search | tst.js:63:34:63:34 | s | +| tst.js:73:1:73:27 | [,docum ... search] | tst.js:73:46:73:46 | x | +| tst.js:73:3:73:19 | document.location | tst.js:73:3:73:26 | documen ... .search | +| tst.js:73:3:73:19 | document.location | tst.js:73:3:73:26 | documen ... .search | +| tst.js:73:3:73:26 | documen ... .search | tst.js:73:1:73:27 | [,docum ... search] | +| tst.js:73:46:73:46 | x | tst.js:76:20:76:20 | x | +| tst.js:73:46:73:46 | x | tst.js:76:20:76:20 | x | +| tst.js:80:49:80:65 | document.location | tst.js:80:49:80:72 | documen ... .search | +| tst.js:80:49:80:65 | document.location | tst.js:80:49:80:72 | documen ... .search | +| tst.js:80:49:80:65 | document.location | tst.js:80:49:80:72 | documen ... .search | +| tst.js:80:49:80:65 | document.location | tst.js:80:49:80:72 | documen ... .search | +| tst.js:84:26:84:42 | document.location | tst.js:84:26:84:49 | documen ... .search | +| tst.js:84:26:84:42 | document.location | tst.js:84:26:84:49 | documen ... .search | +| tst.js:84:26:84:42 | document.location | tst.js:84:26:84:49 | documen ... .search | +| tst.js:84:26:84:42 | document.location | tst.js:84:26:84:49 | documen ... .search | +| tst.js:85:25:85:41 | document.location | tst.js:85:25:85:48 | documen ... .search | +| tst.js:85:25:85:41 | document.location | tst.js:85:25:85:48 | documen ... .search | +| tst.js:85:25:85:41 | document.location | tst.js:85:25:85:48 | documen ... .search | +| tst.js:85:25:85:41 | document.location | tst.js:85:25:85:48 | documen ... .search | +| tst.js:87:33:87:49 | document.location | tst.js:87:33:87:56 | documen ... .search | +| tst.js:87:33:87:49 | document.location | tst.js:87:33:87:56 | documen ... .search | +| tst.js:87:33:87:49 | document.location | tst.js:87:33:87:56 | documen ... .search | +| tst.js:87:33:87:49 | document.location | tst.js:87:33:87:56 | documen ... .search | +| tst.js:88:32:88:48 | document.location | tst.js:88:32:88:55 | documen ... .search | +| tst.js:88:32:88:48 | document.location | tst.js:88:32:88:55 | documen ... .search | +| tst.js:88:32:88:48 | document.location | tst.js:88:32:88:55 | documen ... .search | +| tst.js:88:32:88:48 | document.location | tst.js:88:32:88:55 | documen ... .search | +| tst.js:93:39:93:55 | document.location | tst.js:93:39:93:62 | documen ... .search | +| tst.js:93:39:93:55 | document.location | tst.js:93:39:93:62 | documen ... .search | +| tst.js:93:39:93:55 | document.location | tst.js:93:39:93:62 | documen ... .search | +| tst.js:93:39:93:55 | document.location | tst.js:93:39:93:62 | documen ... .search | +| tst.js:99:30:99:46 | document.location | tst.js:99:30:99:53 | documen ... .search | +| tst.js:99:30:99:46 | document.location | tst.js:99:30:99:53 | documen ... .search | +| tst.js:99:30:99:46 | document.location | tst.js:99:30:99:53 | documen ... .search | +| tst.js:99:30:99:46 | document.location | tst.js:99:30:99:53 | documen ... .search | +| tst.js:105:25:105:41 | document.location | tst.js:105:25:105:48 | documen ... .search | +| tst.js:105:25:105:41 | document.location | tst.js:105:25:105:48 | documen ... .search | +| tst.js:105:25:105:41 | document.location | tst.js:105:25:105:48 | documen ... .search | +| tst.js:105:25:105:41 | document.location | tst.js:105:25:105:48 | documen ... .search | +| tst.js:110:7:110:44 | v | tst.js:113:18:113:18 | v | +| tst.js:110:7:110:44 | v | tst.js:113:18:113:18 | v | +| tst.js:110:11:110:27 | document.location | tst.js:110:11:110:34 | documen ... .search | +| tst.js:110:11:110:27 | document.location | tst.js:110:11:110:34 | documen ... .search | +| tst.js:110:11:110:34 | documen ... .search | tst.js:110:11:110:44 | documen ... bstr(1) | +| tst.js:110:11:110:44 | documen ... bstr(1) | tst.js:110:7:110:44 | v | +| tst.js:145:29:145:43 | window.location | tst.js:145:29:145:50 | window. ... .search | +| tst.js:145:29:145:43 | window.location | tst.js:145:29:145:50 | window. ... .search | +| tst.js:145:29:145:50 | window. ... .search | tst.js:148:29:148:29 | v | +| tst.js:148:29:148:29 | v | tst.js:148:49:148:49 | v | +| tst.js:148:29:148:29 | v | tst.js:148:49:148:49 | v | +| tst.js:155:40:155:54 | window.location | tst.js:155:40:155:61 | window. ... .search | +| tst.js:155:40:155:54 | window.location | tst.js:155:40:155:61 | window. ... .search | +| tst.js:155:40:155:61 | window. ... .search | tst.js:152:29:152:46 | xssSourceService() | +| tst.js:155:40:155:61 | window. ... .search | tst.js:152:29:152:46 | xssSourceService() | +| tst.js:174:9:174:41 | target | tst.js:177:28:177:33 | target | +| tst.js:174:9:174:41 | target | tst.js:177:28:177:33 | target | +| tst.js:174:18:174:34 | document.location | tst.js:174:18:174:41 | documen ... .search | +| tst.js:174:18:174:34 | document.location | tst.js:174:18:174:41 | documen ... .search | +| tst.js:174:18:174:41 | documen ... .search | tst.js:174:9:174:41 | target | +| tst.js:181:9:181:42 | tainted | tst.js:183:31:183:37 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:183:31:183:37 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:185:42:185:48 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:185:42:185:48 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:186:33:186:39 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:186:33:186:39 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:188:54:188:60 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:188:54:188:60 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:189:45:189:51 | tainted | +| tst.js:181:9:181:42 | tainted | tst.js:189:45:189:51 | tainted | +| tst.js:181:19:181:35 | document.location | tst.js:181:19:181:42 | documen ... .search | +| tst.js:181:19:181:35 | document.location | tst.js:181:19:181:42 | documen ... .search | +| tst.js:181:19:181:42 | documen ... .search | tst.js:181:9:181:42 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:196:67:196:73 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:196:67:196:73 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:197:67:197:73 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:197:67:197:73 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:201:35:201:41 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:203:46:203:52 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:204:38:204:44 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:205:35:205:41 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:233:35:233:41 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:235:20:235:26 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:237:23:237:29 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:238:23:238:29 | tainted | +| tst.js:194:9:194:42 | tainted | tst.js:252:23:252:29 | tainted | +| tst.js:194:19:194:35 | document.location | tst.js:194:19:194:42 | documen ... .search | +| tst.js:194:19:194:35 | document.location | tst.js:194:19:194:42 | documen ... .search | +| tst.js:194:19:194:42 | documen ... .search | tst.js:194:9:194:42 | tainted | +| tst.js:201:35:201:41 | tainted | tst.js:209:28:209:46 | this.state.tainted1 | +| tst.js:201:35:201:41 | tainted | tst.js:209:28:209:46 | this.state.tainted1 | +| tst.js:203:46:203:52 | tainted | tst.js:210:28:210:46 | this.state.tainted2 | +| tst.js:203:46:203:52 | tainted | tst.js:210:28:210:46 | this.state.tainted2 | +| tst.js:204:38:204:44 | tainted | tst.js:211:28:211:46 | this.state.tainted3 | +| tst.js:204:38:204:44 | tainted | tst.js:211:28:211:46 | this.state.tainted3 | +| tst.js:205:35:205:41 | tainted | tst.js:215:32:215:49 | prevState.tainted4 | +| tst.js:205:35:205:41 | tainted | tst.js:215:32:215:49 | prevState.tainted4 | +| tst.js:233:35:233:41 | tainted | tst.js:222:28:222:46 | this.props.tainted1 | +| tst.js:233:35:233:41 | tainted | tst.js:222:28:222:46 | this.props.tainted1 | +| tst.js:235:20:235:26 | tainted | tst.js:223:28:223:46 | this.props.tainted2 | +| tst.js:235:20:235:26 | tainted | tst.js:223:28:223:46 | this.props.tainted2 | +| tst.js:237:23:237:29 | tainted | tst.js:224:28:224:46 | this.props.tainted3 | +| tst.js:237:23:237:29 | tainted | tst.js:224:28:224:46 | this.props.tainted3 | +| tst.js:238:23:238:29 | tainted | tst.js:228:32:228:49 | prevProps.tainted4 | +| tst.js:238:23:238:29 | tainted | tst.js:228:32:228:49 | prevProps.tainted4 | +| tst.js:244:39:244:55 | props.propTainted | tst.js:248:60:248:82 | this.st ... Tainted | +| tst.js:244:39:244:55 | props.propTainted | tst.js:248:60:248:82 | this.st ... Tainted | +| tst.js:252:23:252:29 | tainted | tst.js:244:39:244:55 | props.propTainted | +| tst.js:256:7:256:17 | window.name | tst.js:256:7:256:17 | window.name | +| tst.js:257:7:257:10 | name | tst.js:257:7:257:10 | name | +| tst.js:261:11:261:21 | window.name | tst.js:261:11:261:21 | window.name | +| tst.js:277:22:277:29 | location | tst.js:277:22:277:29 | location | +| tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | +| tst.js:282:9:282:29 | tainted | tst.js:285:59:285:65 | tainted | +| tst.js:282:19:282:29 | window.name | tst.js:282:9:282:29 | tainted | +| tst.js:282:19:282:29 | window.name | tst.js:282:9:282:29 | tainted | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:298:9:298:16 | location | tst.js:299:10:299:10 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:299:10:299:10 | e | tst.js:300:20:300:20 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:305:10:305:17 | location | tst.js:307:10:307:10 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +| tst.js:307:10:307:10 | e | tst.js:308:20:308:20 | e | +| tst.js:313:35:313:42 | location | tst.js:313:35:313:42 | location | +| typeahead.js:9:28:9:30 | loc | typeahead.js:10:16:10:18 | loc | +| typeahead.js:9:28:9:30 | loc | typeahead.js:10:16:10:18 | loc | +| typeahead.js:9:28:9:30 | loc | typeahead.js:10:16:10:18 | loc | +| typeahead.js:9:28:9:30 | loc | typeahead.js:10:16:10:18 | loc | +| typeahead.js:20:13:20:45 | target | typeahead.js:21:12:21:17 | target | +| typeahead.js:20:22:20:38 | document.location | typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:20:22:20:38 | document.location | typeahead.js:20:22:20:45 | documen ... .search | +| typeahead.js:20:22:20:45 | documen ... .search | typeahead.js:20:13:20:45 | target | +| typeahead.js:21:12:21:17 | target | typeahead.js:24:30:24:32 | val | +| typeahead.js:24:30:24:32 | val | typeahead.js:25:18:25:20 | val | +| typeahead.js:24:30:24:32 | val | typeahead.js:25:18:25:20 | val | +| v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | +| v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | +| v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | +| v-html.vue:6:42:6:58 | document.location | v-html.vue:2:8:2:23 | v-html=tainted | +| winjs.js:2:7:2:53 | tainted | winjs.js:3:43:3:49 | tainted | +| winjs.js:2:7:2:53 | tainted | winjs.js:3:43:3:49 | tainted | +| winjs.js:2:7:2:53 | tainted | winjs.js:4:43:4:49 | tainted | +| winjs.js:2:7:2:53 | tainted | winjs.js:4:43:4:49 | tainted | +| winjs.js:2:17:2:33 | document.location | winjs.js:2:17:2:40 | documen ... .search | +| winjs.js:2:17:2:33 | document.location | winjs.js:2:17:2:40 | documen ... .search | +| winjs.js:2:17:2:40 | documen ... .search | winjs.js:2:17:2:53 | documen ... ring(1) | +| winjs.js:2:17:2:53 | documen ... ring(1) | winjs.js:2:7:2:53 | tainted | +#select +| typeahead.js:10:16:10:18 | loc | typeahead.js:9:28:9:30 | loc | typeahead.js:10:16:10:18 | loc | Cross-site scripting vulnerability due to $@. | typeahead.js:9:28:9:30 | loc | user-provided value | diff --git a/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.ql b/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.ql new file mode 100644 index 00000000000..543c2537253 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/XssWithAdditionalSources.ql @@ -0,0 +1,24 @@ +/** + * @name Client-side cross-site scripting + * @description Writing user input directly to the DOM allows for + * a cross-site scripting vulnerability. + * @kind path-problem + * @problem.severity error + * @precision high + * @id js/xss + * @tags security + * external/cwe/cwe-079 + * external/cwe/cwe-116 + */ + +import javascript +import semmle.javascript.security.dataflow.DomBasedXss::DomBasedXss +import DataFlow::PathGraph +import semmle.javascript.heuristics.AdditionalSources + + +from Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink +where cfg.hasFlowPath(source, sink) and source.getNode() instanceof HeuristicSource +select sink.getNode(), source, sink, + sink.getNode().(Sink).getVulnerabilityKind() + " vulnerability due to $@.", source.getNode(), + "user-provided value" diff --git a/javascript/ql/test/query-tests/Security/CWE-079/exception-xss.js b/javascript/ql/test/query-tests/Security/CWE-079/exception-xss.js new file mode 100644 index 00000000000..ac15527209e --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/exception-xss.js @@ -0,0 +1,132 @@ +(function() { + var foo = document.location; + + function inner(x) { + unknown(x); + } + + try { + unknown(foo); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + inner(foo); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + unknown(foo + "bar"); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + unknown({prop: foo}); + } catch(e) { + $('myId').html(e); // We don't flag this for now. + } + + try { + unknown(["bar", foo]); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + function deep(x) { + deep2(x); + } + function deep2(x) { + inner(x); + } + + try { + deep("bar" + foo); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + var tmp = "bar" + foo; + } catch(e) { + $('myId').html(e); // OK + } + + function safe(x) { + var foo = x + "bar"; + } + + try { + safe(foo); + } catch(e) { + $('myId').html(e); // OK + } + + try { + safe.call(null, foo); + } catch(e) { + $('myId').html(e); // OK + } + var myWeirdInner; + try { + myWeirdInner = function (x) { + inner(x); + } + } catch(e) { + $('myId').html(e); // OK + } + try { + myWeirdInner(foo); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + $('myId').html(foo); // Direct leak, reported by other query. + + try { + unknown(foo.match(/foo/)); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + unknown([foo, "bar"]); + } catch(e) { + $('myId').html(e); // NOT OK! + } + + try { + try { + unknown(foo); + } finally { + // nothing + } + } catch(e) { + $('myId').html(e); // NOT OK! + } +}); + +var express = require('express'); + +var app = express(); + +app.get('/user/:id', function(req, res) { + try { + unknown(req.params.id); + } catch(e) { + res.send("Exception: " + e); // NOT OK! + } +}); + + +(function () { + sessionStorage.setItem('exceptionSession', document.location.search); + + try { + unknown(sessionStorage.getItem('exceptionSession')); + } catch(e) { + $('myId').html(e); // NOT OK + } +})(); diff --git a/javascript/ql/test/query-tests/Security/CWE-079/tst.js b/javascript/ql/test/query-tests/Security/CWE-079/tst.js index 780d56e90e1..907f1be9299 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/tst.js +++ b/javascript/ql/test/query-tests/Security/CWE-079/tst.js @@ -293,6 +293,22 @@ function flowThroughPropertyNames() { $(p); // OK } +function basicExceptions() { + try { + throw location; + } catch(e) { + $("body").append(e); // NOT OK + } + + try { + try { + throw location + } finally {} + } catch(e) { + $("body").append(e); // NOT OK + } +} + function handlebarsSafeString() { return new Handlebars.SafeString(location); // NOT OK! } diff --git a/javascript/ql/test/query-tests/Security/CWE-079/typeahead.js b/javascript/ql/test/query-tests/Security/CWE-079/typeahead.js new file mode 100644 index 00000000000..a7271a08135 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/typeahead.js @@ -0,0 +1,30 @@ +(function () { + var autocompleter = new Bloodhound({ + prefetch: remoteUrl + }) + autocompleter.initialize(); + $('.typeahead').typeahead({}, { + source: autocompleter.ttAdapter(), + templates: { + suggestion: function(loc) { + return loc; // NOT OK! + } + } + }) + + + $('.typeahead').typeahead({}, + { + name: 'dashboards', + source: function (query, cb) { + var target = document.location.search + cb(target); + }, + templates: { + suggestion: function(val) { + return val; // NOT OK + } + } + } + ) +}) \ No newline at end of file diff --git a/javascript/ql/test/query-tests/Statements/UseOfReturnlessFunction/tst.js b/javascript/ql/test/query-tests/Statements/UseOfReturnlessFunction/tst.js index abdc41143f0..dbedb3dee3c 100644 --- a/javascript/ql/test/query-tests/Statements/UseOfReturnlessFunction/tst.js +++ b/javascript/ql/test/query-tests/Statements/UseOfReturnlessFunction/tst.js @@ -88,6 +88,8 @@ } new Deferred().resolve(onlySideEffects()); // OK + + Promise.all([onlySideEffects(), onlySideEffects()]) })(); +function() { @@ -104,4 +106,4 @@ class Bar extends Foo { constructor() { console.log(super()); // OK. } -} \ No newline at end of file +} diff --git a/python/ql/src/Filters/NotGenerated.ql b/python/ql/src/Filters/NotGenerated.ql index 121fc3c7a45..c59368eb9d8 100644 --- a/python/ql/src/Filters/NotGenerated.ql +++ b/python/ql/src/Filters/NotGenerated.ql @@ -1,9 +1,10 @@ /** * @name Filter: non-generated files * @description Only keep results that aren't (or don't appear to be) generated. - * @kind file-classifier + * @kind problem * @id py/not-generated-file-filter */ +import python import external.DefectFilter import semmle.python.filters.GeneratedCode diff --git a/python/ql/src/Filters/NotTest.ql b/python/ql/src/Filters/NotTest.ql index 4d6b0ec5162..ddea7fd212b 100644 --- a/python/ql/src/Filters/NotTest.ql +++ b/python/ql/src/Filters/NotTest.ql @@ -1,9 +1,10 @@ /** * @name Filter: non-test files * @description Only keep results that aren't in tests - * @kind file-classifier + * @kind problem * @id py/not-test-file-filter */ +import python import external.DefectFilter import semmle.python.filters.Tests diff --git a/python/ql/src/Imports/Cyclic.qll b/python/ql/src/Imports/Cyclic.qll index c550c163c66..29c05b08209 100644 --- a/python/ql/src/Imports/Cyclic.qll +++ b/python/ql/src/Imports/Cyclic.qll @@ -60,7 +60,8 @@ predicate import_time_module_use(ModuleValue m, ModuleValue enclosing, Expr use, exists(Expr mod | use.getEnclosingModule() = enclosing.getScope() and not use.getScope+() instanceof Function and - mod.pointsTo(m) + mod.pointsTo(m) and + not is_annotation_with_from_future_import_annotations(use) | // either 'M.foo' use.(Attribute).getObject() = mod and use.(Attribute).getName() = attr @@ -70,6 +71,30 @@ predicate import_time_module_use(ModuleValue m, ModuleValue enclosing, Expr use, ) } +/** + * Holds if `use` appears inside an annotation. + */ +predicate is_used_in_annotation(Expr use) { + exists(FunctionExpr f | + f.getReturns().getASubExpression*() = use or + f.getArgs().getAnAnnotation().getASubExpression*() = use + ) + or + exists(AnnAssign a | a.getAnnotation().getASubExpression*() = use) +} + +/** + * Holds if `use` appears as a subexpression of an annotation, _and_ if the + * postponed evaluation of annotations presented in PEP 563 is in effect. + * See https://www.python.org/dev/peps/pep-0563/ + */ +predicate is_annotation_with_from_future_import_annotations(Expr use) { + exists(ImportMember i | i.getScope() = use.getEnclosingModule() | + i.getModule().pointsTo().getName() = "__future__" and i.getName() = "annotations" + ) and + is_used_in_annotation(use) +} + /** * Whether importing module 'first' before importing module 'other' will fail at runtime, due to an * AttributeError at 'use' (in module 'other') caused by 'first.attr' not being defined as its definition can diff --git a/python/ql/src/Security/CWE-798/HardcodedCredentials.ql b/python/ql/src/Security/CWE-798/HardcodedCredentials.ql index 205b477196f..c9fb63ac121 100644 --- a/python/ql/src/Security/CWE-798/HardcodedCredentials.ql +++ b/python/ql/src/Security/CWE-798/HardcodedCredentials.ql @@ -11,6 +11,7 @@ * external/cwe/cwe-798 */ +import python import semmle.python.security.TaintTracking import semmle.python.filters.Tests diff --git a/python/ql/src/external/DuplicateBlock.ql b/python/ql/src/external/DuplicateBlock.ql index 1a892b87900..7bf1bb6da83 100644 --- a/python/ql/src/external/DuplicateBlock.ql +++ b/python/ql/src/external/DuplicateBlock.ql @@ -14,6 +14,7 @@ * @precision medium * @id py/duplicate-block */ +import python import CodeDuplication predicate sorted_by_location(DuplicateBlock x, DuplicateBlock y) { diff --git a/python/ql/src/semmle/python/web/turbogears/Request.qll b/python/ql/src/semmle/python/web/turbogears/Request.qll index 0003c3dc830..dc7ef63ab56 100644 --- a/python/ql/src/semmle/python/web/turbogears/Request.qll +++ b/python/ql/src/semmle/python/web/turbogears/Request.qll @@ -1,21 +1,17 @@ import python import semmle.python.security.strings.Untrusted - import TurboGears private class ValidatedMethodParameter extends Parameter { - ValidatedMethodParameter() { exists(string name, TurboGearsControllerMethod method | method.getArgByName(name) = this and method.getValidationDict().getItem(_).(KeyValuePair).getKey().(StrConst).getText() = name ) } - } class UnvalidatedControllerMethodParameter extends TaintSource { - UnvalidatedControllerMethodParameter() { exists(Parameter p | any(TurboGearsControllerMethod m | not m.getName() = "onerror").getAnArg() = p and @@ -25,9 +21,5 @@ class UnvalidatedControllerMethodParameter extends TaintSource { ) } - override predicate isSourceOf(TaintKind kind) { - kind instanceof UntrustedStringKind - } - + override predicate isSourceOf(TaintKind kind) { kind instanceof UntrustedStringKind } } - diff --git a/python/ql/src/semmle/python/web/turbogears/Response.qll b/python/ql/src/semmle/python/web/turbogears/Response.qll index b8640a6fcdd..ddd3d6f711f 100644 --- a/python/ql/src/semmle/python/web/turbogears/Response.qll +++ b/python/ql/src/semmle/python/web/turbogears/Response.qll @@ -1,14 +1,10 @@ import python - import semmle.python.security.TaintTracking import semmle.python.security.strings.Basic import semmle.python.web.Http import TurboGears - - class ControllerMethodReturnValue extends HttpResponseTaintSink { - ControllerMethodReturnValue() { exists(TurboGearsControllerMethod m | m.getAReturnValueFlowNode() = this and @@ -16,14 +12,10 @@ class ControllerMethodReturnValue extends HttpResponseTaintSink { ) } - override predicate sinks(TaintKind kind) { - kind instanceof StringKind - } - + override predicate sinks(TaintKind kind) { kind instanceof StringKind } } class ControllerMethodTemplatedReturnValue extends HttpResponseTaintSink { - ControllerMethodTemplatedReturnValue() { exists(TurboGearsControllerMethod m | m.getAReturnValueFlowNode() = this and @@ -31,8 +23,5 @@ class ControllerMethodTemplatedReturnValue extends HttpResponseTaintSink { ) } - override predicate sinks(TaintKind kind) { - kind instanceof StringDictKind - } - + override predicate sinks(TaintKind kind) { kind instanceof StringDictKind } } diff --git a/python/ql/src/semmle/python/web/turbogears/TurboGears.qll b/python/ql/src/semmle/python/web/turbogears/TurboGears.qll index c3d417c012e..1cef2f51c84 100644 --- a/python/ql/src/semmle/python/web/turbogears/TurboGears.qll +++ b/python/ql/src/semmle/python/web/turbogears/TurboGears.qll @@ -1,55 +1,33 @@ import python - import semmle.python.security.TaintTracking -private ClassObject theTurboGearsControllerClass() { - result = ModuleObject::named("tg").attr("TGController") -} - - -ClassObject aTurboGearsControllerClass() { - result.getASuperType() = theTurboGearsControllerClass() -} +private ClassValue theTurboGearsControllerClass() { result = Value::named("tg.TGController") } +ClassValue aTurboGearsControllerClass() { result.getABaseType+() = theTurboGearsControllerClass() } class TurboGearsControllerMethod extends Function { - ControlFlowNode decorator; TurboGearsControllerMethod() { - aTurboGearsControllerClass().getPyClass() = this.getScope() and + aTurboGearsControllerClass().getScope() = this.getScope() and decorator = this.getADecorator().getAFlowNode() and /* Is decorated with @expose() or @expose(path) */ ( decorator.(CallNode).getFunction().(NameNode).getId() = "expose" or - decorator.refersTo(_, ModuleObject::named("tg").attr("expose"), _) + decorator.pointsTo().getClass() = Value::named("tg.expose") ) } - private ControlFlowNode templateName() { - result = decorator.(CallNode).getArg(0) - } + private ControlFlowNode templateName() { result = decorator.(CallNode).getArg(0) } - predicate isTemplated() { - exists(templateName()) - } - - string getTemplateName() { - exists(StringObject str | - templateName().refersTo(str) and - result = str.getText() - ) - } + predicate isTemplated() { exists(templateName()) } Dict getValidationDict() { - exists(Call call, Object dict | + exists(Call call, Value dict | call = this.getADecorator() and call.getFunc().(Name).getId() = "validate" and - call.getArg(0).refersTo(dict) and - result = dict.getOrigin() + call.getArg(0).pointsTo(dict, result) ) } - } - diff --git a/python/ql/test/library-tests/web/turbogears/Controller.expected b/python/ql/test/library-tests/web/turbogears/Controller.expected index 9b65e8843fa..549934145a0 100644 --- a/python/ql/test/library-tests/web/turbogears/Controller.expected +++ b/python/ql/test/library-tests/web/turbogears/Controller.expected @@ -2,3 +2,4 @@ | test.py:13:5:13:50 | Function ok_validated | | test.py:18:5:18:57 | Function partially_validated | | test.py:22:5:22:51 | Function not_validated | +| test.py:26:5:26:28 | Function with_template | diff --git a/python/ql/test/library-tests/web/turbogears/Sinks.expected b/python/ql/test/library-tests/web/turbogears/Sinks.expected index 5f2b9b8999f..b528861c340 100644 --- a/python/ql/test/library-tests/web/turbogears/Sinks.expected +++ b/python/ql/test/library-tests/web/turbogears/Sinks.expected @@ -2,3 +2,4 @@ | test.py:14 | BinaryExpr | externally controlled string | | test.py:19 | BinaryExpr | externally controlled string | | test.py:23 | BinaryExpr | externally controlled string | +| test.py:27 | Dict | {externally controlled string} | diff --git a/python/ql/test/library-tests/web/turbogears/test.py b/python/ql/test/library-tests/web/turbogears/test.py index e4347ee5f6f..bae3a460f43 100644 --- a/python/ql/test/library-tests/web/turbogears/test.py +++ b/python/ql/test/library-tests/web/turbogears/test.py @@ -21,3 +21,7 @@ class RootController(TGController): @expose() def not_validated(self, a=None, b=None, *args): return 'Values: %s, %s, %s' % (a, b, args) + + @expose("") + def with_template(self): + return {'template_var': 'foo'} diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.expected b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.expected new file mode 100644 index 00000000000..1a5f4c8f9e8 --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.expected @@ -0,0 +1,2 @@ +| module3.py:8:23:8:33 | Attribute | 'Bar' may not be defined if module $@ is imported before module $@, as the $@ of Bar occurs after the cyclic $@ of module3. | module4.py:0:0:0:0 | Module module4 | module4 | module3.py:0:0:0:0 | Module module3 | module3 | module4.py:7:7:7:9 | ControlFlowNode for Bar | definition | module4.py:4:1:4:14 | Import | import | +| module4.py:8:30:8:40 | Attribute | 'Foo' may not be defined if module $@ is imported before module $@, as the $@ of Foo occurs after the cyclic $@ of module4. | module3.py:0:0:0:0 | Module module3 | module3 | module4.py:0:0:0:0 | Module module4 | module4 | module3.py:7:7:7:9 | ControlFlowNode for Foo | definition | module3.py:4:1:4:14 | Import | import | diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.qlref b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.qlref new file mode 100644 index 00000000000..8b9bc8c123a --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/ModuleLevelCyclicImport.qlref @@ -0,0 +1 @@ +Imports/ModuleLevelCyclicImport.ql diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module1.py b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module1.py new file mode 100644 index 00000000000..66d263464e2 --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module1.py @@ -0,0 +1,10 @@ +from __future__ import annotations + +import dataclasses +import typing + +import module2 + +@dataclasses.dataclass() +class Foo: + bars: typing.List[module2.Bar] diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module2.py b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module2.py new file mode 100644 index 00000000000..1a26c3a2c52 --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module2.py @@ -0,0 +1,11 @@ +from __future__ import annotations + +import dataclasses +import typing + +import module1 + +@dataclasses.dataclass() +class Bar: + def is_in_foo(self, foo: module1.Foo): + return self in foo.bars diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module3.py b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module3.py new file mode 100644 index 00000000000..83f5eda9557 --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module3.py @@ -0,0 +1,8 @@ +import dataclasses +import typing + +import module4 + +@dataclasses.dataclass() +class Foo: + bars: typing.List[module4.Bar] diff --git a/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module4.py b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module4.py new file mode 100644 index 00000000000..b6da208fbe3 --- /dev/null +++ b/python/ql/test/query-tests/Imports/cyclic-module-annotations-fp/module4.py @@ -0,0 +1,9 @@ +import dataclasses +import typing + +import module3 + +@dataclasses.dataclass() +class Bar: + def is_in_foo(self, foo: module3.Foo): + return self in foo.bars