diff --git a/change-notes/1.19/analysis-cpp.md b/change-notes/1.19/analysis-cpp.md index edbab04f34e..f7391c150fb 100644 --- a/change-notes/1.19/analysis-cpp.md +++ b/change-notes/1.19/analysis-cpp.md @@ -23,8 +23,12 @@ | Expression has no effect | Fewer false positive results | Expressions in template instantiations are now excluded from this query. | | Global could be static | Fewer false positive results | Variables with declarations in header files are now excluded from this query. | | Resource not released in destructor | Fewer false positive results | Placement new is now excluded from the query. Also fixed an issue where false positives could occur if the destructor body was not in the snapshot. | +| Memory is never freed | Fewer false positive results | This query now accounts for C++ _placement new_, which returns a pointer that does not need to be freed. | | Missing return statement (`cpp/missing-return`) | Visible by default | The precision of this query has been increased from 'medium' to 'high', which makes it visible by default in LGTM. It was 'medium' in release 1.17 and 1.18 because it had false positives due to an extractor bug that was fixed in 1.18. | | Missing return statement | Fewer false positive results | The query is now produces correct results when a function returns a template-dependent type, or makes a non-returning call to another function. | +| Multiplication result converted to larger type (`cpp/integer-multiplication-cast-to-long`) | Fewer false positive results | Char-typed numbers are no longer considered to be potentially large. | +| Non-virtual destructor in base class (`cpp/virtual-destructor`) | Fewer false positive results | This query was copied from file `AV Rule 78.ql` to `NonVirtualDestructorInBaseClass.ql` and renamed from "No virtual destructor" to "Non-virtual destructor in base class". The new version ignores base classes with non-public destructors since we consider those to be adequately protected. The new version retains the query id `cpp/virtual-destructor` and is displayed by default on LGTM, while `AV Rule 78.ql` is not run on LGTM. | +| Overloaded assignment does not return 'this' (`cpp/assignment-does-not-return-this`) | Fewer false positive results | This query now ignores any return statements that are unreachable. | | Static array access may cause overflow | More correct results | Data flow to the size argument of a buffer operation is now checked in this query. | | Call to memory access function may overflow buffer | More correct results | Array indexing with a negative index is now detected by this query. | | Self comparison | Fewer false positive results | Code inside macro invocations is now excluded from the query. | @@ -39,6 +43,8 @@ ## Changes to QL libraries -* Added a hash consing library for structural comparison of expressions. -* `getBufferSize` now detects variable size structs more reliably. -* Buffer.qll now treats arrays of zero size as a special case. +* Added a hash consing library (`semmle.code.cpp.valuenumbering.HashCons`) for structural comparison of expressions. Unlike the existing library for global value numbering, this library implements a pure syntactic comparison of expressions and will equate expressions even if they may not compute the same value. +* The `Buffer.qll` library has more conservative treatment of arrays embedded in structs. This reduces false positives in a number of security queries, especially `cpp/overflow-buffer`. + * Pre-C99 encodings of _flexible array members_ are recognized more reliably. + * Arrays of zero size are now treated as a special case. +* The library `semmle.code.cpp.dataflow.RecursionPrevention` is now deprecated. It was an aid for transitioning data-flow queries from 1.16 to 1.17, and it no longer has any function. Imports of this library should simply be deleted. diff --git a/change-notes/1.19/analysis-javascript.md b/change-notes/1.19/analysis-javascript.md index d9244d2abcc..ce0a38a1559 100644 --- a/change-notes/1.19/analysis-javascript.md +++ b/change-notes/1.19/analysis-javascript.md @@ -2,7 +2,7 @@ ## General improvements -* Modelling of taint flow through array operations has been improved. This may give additional results for the security queries. +* Modeling of taint flow through array and buffer operations has been improved. This may give additional results for the security queries. * Support for AMD modules has been improved. This may give additional results for the security queries as well as any queries that use type inference on code bases that use such modules. @@ -23,12 +23,14 @@ |-----------------------------------------------|------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Enabling Node.js integration for Electron web content renderers (`js/enabling-electron-renderer-node-integration`) | security, frameworks/electron, external/cwe/cwe-094 | Highlights Electron web content renderer preferences with Node.js integration enabled, indicating a violation of [CWE-94](https://cwe.mitre.org/data/definitions/94.html). Results are not shown on LGTM by default. | | File data in outbound network request | security, external/cwe/cwe-200 | Highlights locations where file data is sent in a network request. Results are not shown on LGTM by default. | +| Hard-coded data interpreted as code | security, external/cwe/cwe-506 | Highlights locations where hard-coded data is transformed and then executed as code or interpreted as an import path, which may indicate embedded malicious code ([CWE-506](https://cwe.mitre.org/data/definitions/506.html)). Results are shown on LGTM by default. | | Host header poisoning in email generation | security, external/cwe/cwe-640 | Highlights code that generates emails with links that can be hijacked by HTTP host header poisoning, indicating a violation of [CWE-640](https://cwe.mitre.org/data/definitions/640.html). Results shown on LGTM by default. | -| Unsafe dynamic method access (`js/unsafe-dynamic-method-access` ) | security, external/cwe/cwe-094 | Highlights code that invokes a user-controlled method on an object with unsafe methods. Results are shown on LGTM by default. | | Replacement of a substring with itself (`js/identity-replacement`) | correctness, security, external/cwe/cwe-116 | Highlights string replacements that replace a string with itself, which usually indicates a mistake. Results shown on LGTM by default. | | Stored cross-site scripting (`js/stored-xss`) | security, external/cwe/cwe-079, external/cwe/cwe-116 | Highlights uncontrolled stored values flowing into HTML content, indicating a violation of [CWE-079](https://cwe.mitre.org/data/definitions/79.html). Results shown on LGTM by default. | | Unclear precedence of nested operators (`js/unclear-operator-precedence`) | maintainability, correctness, external/cwe/cwe-783 | Highlights nested binary operators whose relative precedence is easy to misunderstand. Results shown on LGTM by default. | | Unneeded defensive code | correctness, external/cwe/cwe-570, external/cwe/cwe-571 | Highlights locations where defensive code is not needed. Results are shown on LGTM by default. | +| Unsafe dynamic method access (`js/unsafe-dynamic-method-access` ) | security, external/cwe/cwe-094 | Highlights code that invokes a user-controlled method on an object with unsafe methods. Results are shown on LGTM by default. | +| Unvalidated dynamic method access (`js/unvalidated-dynamic-method-call` ) | security, external/cwe/cwe-754 | Highlights code that invokes a user-controlled method without guarding against exceptional circumstances. Results are shown on LGTM by default. | | Useless assignment to property | maintainability | Highlights property assignments whose value is always overwritten. Results are shown on LGTM by default. | | User-controlled data in file | security, external/cwe/cwe-912 | Highlights locations where user-controlled data is written to a file. Results are not shown on LGTM by default. | @@ -43,12 +45,13 @@ | Conflicting HTML element attributes | Lower severity | The severity of this rule has been revised to "warning". | | Duplicate 'if' condition | Lower severity | The severity of this rule has been revised to "warning". | | Duplicate switch case | Lower severity | The severity of this rule has been revised to "warning". | +| Inconsistent use of 'new' | Simpler result presentation | This rule now only shows one call with `new` and one without. | | Information exposure through a stack trace | More results | This rule now also flags cases where the entire exception object (including the stack trace) may be exposed. | -| Missing CSRF middleware | Fewer false-positive results | This rule now recognizes additional CSRF protection middlewares. | | Missing 'this' qualifier | Fewer false-positive results | This rule now recognizes additional intentional calls to global functions. | +| Missing CSRF middleware | Fewer false-positive results | This rule now recognizes additional CSRF protection middlewares. | | Missing variable declaration | Lower severity | The severity of this rule has been revised to "warning". | | Regular expression injection | Fewer false-positive results | This rule now identifies calls to `String.prototype.search` with more precision. | -| Remote property injection | Fewer results | The precision of this rule has been revised to "medium". Results are no longer shown on LGTM by default. | +| Remote property injection | Fewer results | The precision of this rule has been revised to "medium". Furthermore, it no longer flags dynamic method calls, which are now handled by two new queries. Results are no longer shown on LGTM by default. | | Self assignment | Fewer false-positive results | This rule now ignores self-assignments preceded by a JSDoc comment with a `@type` tag. | | Server-side URL redirect | Fewer false-positive results | This rule now recognizes safe redirects in more cases. | | Server-side URL redirect | More results | This rule now recognizes redirection calls in more cases. | @@ -59,6 +62,7 @@ | Unused variable, import, function or class | Fewer false-positive results | This rule now flags fewer variables that may be used by `eval` calls. | | Unused variable, import, function or class | Fewer results | This rule now flags import statements with multiple unused imports once. | | Useless assignment to local variable | Fewer false-positive results | This rule now recognizes additional ways default values can be set. | +| Useless conditional | More results, fewer false-positive results | This rule now recognizes conditionals in more cases, but no longer flags certain defensive coding patterns. | | Whitespace contradicts operator precedence | Fewer false-positive results | This rule no longer flags operators with asymmetric whitespace. | | Wrong use of 'this' for static method | More results, fewer false-positive results | This rule now recognizes inherited methods. | diff --git a/change-notes/1.19/analysis-python.md b/change-notes/1.19/analysis-python.md index d4e7212593f..7dcfd91f6db 100644 --- a/change-notes/1.19/analysis-python.md +++ b/change-notes/1.19/analysis-python.md @@ -1,14 +1,12 @@ # Improvements to Python analysis - ## General improvements -> Changes that affect alerts in many files or from many queries -> For example, changes to file classification - ### Representation of the control flow graph -The representation of the control flow graph (CFG) has been modified to better reflect the semantics of Python. +The representation of the control flow graph (CFG) has been modified to better reflect the semantics of Python. As part of these changes, a new predicate `Stmt.getAnEntryNode()` has been added to make it easier to write reachability queries involving statements. + +#### CFG nodes removed The following statement types no longer have a CFG node for the statement itself, as their sub-expressions already contain all the semantically significant information: @@ -20,14 +18,15 @@ semantically significant information: For example, the CFG for `if cond: foo else bar` now starts with the CFG node for `cond`. -For the following statement types, the CFG node for the statement now follows the CFG nodes of its sub-expressions to better reflect the semantics: +#### CFG nodes reordered + +For the following statement types, the CFG node for the statement now follows the CFG nodes of its sub-expressions to follow Python semantics: * `Print` * `TemplateWrite` * `ImportStar` -For example the CFG for `print foo` (in Python 2) has changed from `print -> foo` to `foo -> print`, better reflecting the runtime behavior. - +For example the CFG for `print foo` (in Python 2) has changed from `print -> foo` to `foo -> print`, to reflect the runtime behavior. The CFG for the `with` statement has been re-ordered to more closely reflect the semantics. For the `with` statement: @@ -35,61 +34,51 @@ For the `with` statement: with cm as var: body ``` -The order of the CFG changes from: - - - cm - var - body - -to: - - cm - - var - body - -A new predicate `Stmt.getAnEntryNode()` has been added to make it easier to write reachability queries involving statements. +* Previous CFG node order: `` -> `cm` -> `var` -> `body` +* New CFG node order: `cm` -> `` -> `var` -> `body` ## New queries | **Query** | **Tags** | **Purpose** | |-----------------------------|-----------|--------------------------------------------------------------------| -| Information exposure through an exception (`py/stack-trace-exposure`) | security, external/cwe/cwe-209, external/cwe/cwe-497 | Finds instances where information about an exception may be leaked to an external user. Enabled on LGTM by default. | +| Assert statement tests the truth value of a literal constant (`py/assert-literal-constant`) | reliability, correctness | Checks whether an assert statement is testing the truth of a literal constant value. Results are hidden on LGTM by default. | +| Flask app is run in debug mode (`py/flask-debug`) | security, external/cwe/cwe-215, external/cwe/cwe-489 | Finds instances where a Flask application is run in debug mode. Results are shown on LGTM by default. | +| Information exposure through an exception (`py/stack-trace-exposure`) | security, external/cwe/cwe-209, external/cwe/cwe-497 | Finds instances where information about an exception may be leaked to an external user. Results are shown on LGTM by default. | +| Jinja2 templating with autoescape=False (`py/jinja2/autoescape-false`) | security, external/cwe/cwe-079 | Finds instantiations of `jinja2.Environment` with `autoescape=False` which may allow XSS attacks. Results are hidden on LGTM by default. | +| Request without certificate validation (`py/request-without-cert-validation`) | security, external/cwe/cwe-295 | Finds requests where certificate verification has been explicitly turned off, possibly allowing man-in-the-middle attacks. Results are hidden on LGTM by default. | +| Use of weak cryptographic key (`py/weak-crypto-key`) | security, external/cwe/cwe-326 | Finds creation of weak cryptographic keys. Results are shown on LGTM by default. | ## Changes to existing queries All taint-tracking queries now support visualization of paths in QL for Eclipse. -Most security alerts are now visible on LGTM by default. +Most security alerts are now visible on LGTM by default. This means that you may see results that were previously hidden for the following queries: + +* Code injection (`py/code-injection`) +* Reflected server-side cross-site scripting (`py/reflective-xss`) +* SQL query built from user-controlled sources (`py/sql-injection`) +* Uncontrolled data used in path expression (`py/path-injection`) +* Uncontrolled command line (`py/command-line-injection`) | **Query** | **Expected impact** | **Change** | |----------------------------|------------------------|------------------------------------------------------------------| -| Assert statement tests the truth value of a literal constant (`py/assert-literal-constant`) | reliability, correctness | Checks whether an assert statement is testing the truth of a literal constant value. Not shown by default. | -| Code injection (`py/code-injection`) | Supports path visualization and is now visible on LGTM by default | No change to expected results | -| Command injection (`py/command-line-injection`) | Additional sinks in the `os`, and `popen` modules | Possibility of new results | -| Deserializing untrusted input (`py/unsafe-deserialization`) | Supports path visualization | No change to expected results | -| Encoding error (`py/encoding-error`) | Better alert location | Alert is now shown at the position of the first offending character, rather than at the top of the file. | +| Command injection (`py/command-line-injection`) | More results | Additional sinks in the `os`, and `popen` modules may find more results in some projects. | +| Encoding error (`py/encoding-error`) | Better alert location | Alerts are now shown at the start of the encoding error, rather than at the top of the file. | | Missing call to \_\_init\_\_ during object initialization (`py/missing-call-to-init`) | Fewer false positive results | Results where it is likely that the full call chain has not been analyzed are no longer reported. | -| Reflected server-side cross-site scripting (`py/reflective-xss`) | Supports path visualization and is now visible on LGTM by default | No change to expected results | -| SQL query built from user-controlled sources (`py/sql-injection`) | Supports path visualization and is now visible on LGTM by default | No change to expected results | -| Uncontrolled data used in path expression (`py/path-injection`) | Supports path visualization and is now visible on LGTM by default | No change to expected results | -| Uncontrolled command line (`py/command-line-injection`) | Supports path visualization and is now visible on LGTM by default | No change to expected results | -| URL redirection from remote source (`py/url-redirection`) | Fewer false positive results and now supports path visualization | Taint is no longer tracked from the right hand side of binary expressions. In other words `SAFE + TAINTED` is now treated as safe. | +| URL redirection from remote source (`py/url-redirection`) | Fewer false positive results | Taint is no longer tracked from the right-hand side of binary expressions. In other words `SAFE + TAINTED` is now treated as safe. | ## Changes to code extraction * Improved scalability: Scaling is near linear to at least 20 CPU cores. -* Five levels of logging can be selected: `ERROR`, `WARN`, `INFO`, `DEBUG` and `TRACE`. `WARN` is the stand-alone default, but `INFO` will be used when run by LGTM. +* Five levels of logging can be selected: `ERROR`, `WARN`, `INFO`, `DEBUG` and `TRACE`. LGTM uses `INFO` level logging. QL tools use `WARN` level logging by default. * The `-v` flag can be specified multiple times to increase logging level by one per `-v`. * The `-q` flag has been added and can be specified multiple times to reduce the logging level by one per `-q`. * Log lines are now in the `[SEVERITY] message` style and never overlap. -* Extractor now outputs the location of the first offending character when an EncodingError is encountered. +* The extractor now outputs the location of the first character that triggers an EncodingError. ## Changes to QL libraries -* Taint tracking analysis now understands HTTP requests in the `twisted` library. - +* Taint-tracking analysis now understands HTTP requests in the `twisted` library. * The analysis now handles `isinstance` and `issubclass` tests involving the basic abstract base classes better. For example, the test `issubclass(list, collections.Sequence)` is now understood to be `True` * Taint tracking automatically tracks tainted mappings and collections, without you having to add additional taint kinds. This means that custom taints are tracked from `x` to `y` in the following flow: `l = [x]; y =l[0]`. diff --git a/config/identical-files.json b/config/identical-files.json index 1a7813948ce..f4098f6bef9 100644 --- a/config/identical-files.json +++ b/config/identical-files.json @@ -43,14 +43,6 @@ "cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll", "cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll" ], - "C++ SSA SimpleSSA": [ - "cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll", - "cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSA.qll" - ], - "C++ SSA IRBlockConstruction": [ - "cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/IRBlockConstruction.qll", - "cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/IRBlockConstruction.qll" - ], "C++ SSA SSAConstruction": [ "cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SSAConstruction.qll", "cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstruction.qll" diff --git a/cpp/ql/src/Security/CWE/CWE-428/UnsafeCreateProcessCall.ql b/cpp/ql/src/Security/CWE/CWE-428/UnsafeCreateProcessCall.ql index 1518c6c1f0f..c32ce5aae52 100644 --- a/cpp/ql/src/Security/CWE/CWE-428/UnsafeCreateProcessCall.ql +++ b/cpp/ql/src/Security/CWE/CWE-428/UnsafeCreateProcessCall.ql @@ -68,7 +68,7 @@ class NullAppNameCreateProcessFunctionConfiguration extends DataFlow::Configurat } override predicate isSource(DataFlow::Node source) { - nullValue(source.asExpr()) + source.asExpr() instanceof NullValue } override predicate isSink(DataFlow::Node sink) { diff --git a/cpp/ql/src/jsf/4.10 Classes/AV Rule 79.ql b/cpp/ql/src/jsf/4.10 Classes/AV Rule 79.ql index 1b2f4080992..d35508b4a3f 100644 --- a/cpp/ql/src/jsf/4.10 Classes/AV Rule 79.ql +++ b/cpp/ql/src/jsf/4.10 Classes/AV Rule 79.ql @@ -189,28 +189,31 @@ predicate freedInSameMethod(Resource r, Expr acquire) { */ predicate leakedInSameMethod(Resource r, Expr acquire) { unreleasedResource(r, acquire, _, _) and - ( - exists(FunctionCall fc | - // `r` (or something computed from it) is passed to another function - // near to where it's acquired, and might be stored elsewhere. - fc.getAnArgument().getAChild*() = r.getAnAccess() and - fc.getEnclosingFunction() = acquire.getEnclosingFunction() - ) or exists(Variable v, Expr e | - // `r` (or something computed from it) is stored in another variable - // near to where it's acquired, and might be released through that - // variable. - v.getAnAssignedValue() = e and - e.getAChild*() = r.getAnAccess() and - e.getEnclosingFunction() = acquire.getEnclosingFunction() - ) or exists(FunctionCall fc | - // `this` (i.e. the class where `r` is acquired) is passed into `r` via a - // method, or the constructor. `r` may use this to register itself with - // `this` in some way, ensuring it is later deleted. - fc.getEnclosingFunction() = acquire.getEnclosingFunction() and - fc.getAnArgument() instanceof ThisExpr and - ( - fc.getQualifier() = r.getAnAccess() or // e.g. `r->setOwner(this)` - fc = acquire.getAChild*() // e.g. `r = new MyClass(this)` + exists(Function f | + acquire.getEnclosingFunction() = f and + ( + exists(FunctionCall fc | + // `r` (or something computed from it) is passed to another function + // near to where it's acquired, and might be stored elsewhere. + fc.getAnArgument().getAChild*() = r.getAnAccess() and + fc.getEnclosingFunction() = f + ) or exists(Variable v, Expr e | + // `r` (or something computed from it) is stored in another variable + // near to where it's acquired, and might be released through that + // variable. + v.getAnAssignedValue() = e and + e.getAChild*() = r.getAnAccess() and + e.getEnclosingFunction() = f + ) or exists(FunctionCall fc | + // `this` (i.e. the class where `r` is acquired) is passed into `r` via a + // method, or the constructor. `r` may use this to register itself with + // `this` in some way, ensuring it is later deleted. + fc.getEnclosingFunction() = f and + fc.getAnArgument() instanceof ThisExpr and + ( + fc.getQualifier() = r.getAnAccess() or // e.g. `r->setOwner(this)` + fc = acquire.getAChild*() // e.g. `r = new MyClass(this)` + ) ) ) ) diff --git a/cpp/ql/src/semmle/code/cpp/PrintAST.qll b/cpp/ql/src/semmle/code/cpp/PrintAST.qll index 803758f986c..378b94dbbbb 100644 --- a/cpp/ql/src/semmle/code/cpp/PrintAST.qll +++ b/cpp/ql/src/semmle/code/cpp/PrintAST.qll @@ -542,6 +542,42 @@ class FunctionNode extends ASTNode { } } +/** + * A node representing an `ClassAggregateLiteral`. + */ +class ClassAggregateLiteralNode extends ExprNode { + ClassAggregateLiteral list; + + ClassAggregateLiteralNode() { + list = ast + } + + override string getChildEdgeLabel(int childIndex) { + exists(Field field | + list.getFieldExpr(field) = list.getChild(childIndex) and + result = "." + field.getName() + ) + } +} + +/** + * A node representing an `ArrayAggregateLiteral`. + */ +class ArrayAggregateLiteralNode extends ExprNode { + ArrayAggregateLiteral list; + + ArrayAggregateLiteralNode() { + list = ast + } + + override string getChildEdgeLabel(int childIndex) { + exists(int elementIndex | + list.getElementExpr(elementIndex) = list.getChild(childIndex) and + result = "[" + elementIndex.toString() + "]" + ) + } +} + query predicate nodes(PrintASTNode node, string key, string value) { node.shouldPrint() and value = node.getProperty(key) diff --git a/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll b/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll index f8917126395..bdd641f9338 100644 --- a/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll +++ b/cpp/ql/src/semmle/code/cpp/controlflow/LocalScopeVariableReachability.qll @@ -96,10 +96,18 @@ abstract class LocalScopeVariableReachability extends string { private predicate bbEntryReachesLocally(BasicBlock bb, SemanticStackVariable 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)) + 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)) + } } /** diff --git a/cpp/ql/src/semmle/code/cpp/dataflow/RecursionPrevention.qll b/cpp/ql/src/semmle/code/cpp/dataflow/RecursionPrevention.qll index 75f22a077fd..fd65f87990a 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/RecursionPrevention.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/RecursionPrevention.qll @@ -1,4 +1,9 @@ /** + * DEPRECATED: Recursion through `DataFlow::Configuration` is impossible in + * Semmle Core 1.17 and above. There is no need for this module because it's + * impossible to accidentally depend on recursion through + * `DataFlow::Configuration` in current releases. + * * When this module is imported, recursive use of `DataFlow::Configuration` is * disallowed. Importing this module will guarantee the absence of such * recursion, which is unsupported and will be unconditionally disallowed in a 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 1e22c1b1997..75d5d300bae 100644 --- a/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll +++ b/cpp/ql/src/semmle/code/cpp/dataflow/internal/FlowVar.qll @@ -292,10 +292,7 @@ module FlowVar_internal { * Gets a variable that is assigned in this loop and read outside the loop. */ private Variable getARelevantVariable() { - exists(BasicBlock bbAssign | - assignmentLikeOperation(bbAssign.getANode(), result, _) and - this.bbInLoop(bbAssign) - ) and + result = this.getAVariableAssignedInLoop() and exists(VariableAccess va | va.getTarget() = result and readAccess(va) and @@ -303,6 +300,15 @@ module FlowVar_internal { ) } + /** Gets a variable that is assigned in this loop. */ + pragma[noinline] + private Variable getAVariableAssignedInLoop() { + exists(BasicBlock bbAssign | + assignmentLikeOperation(bbAssign.getANode(), result, _) and + this.bbInLoop(bbAssign) + ) + } + private predicate bbInLoopCondition(BasicBlock bb) { getCFNParent*(bb.getANode()) = this.(Loop).getCondition() } diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/MemoryAccessKind.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/MemoryAccessKind.qll index 6cfa61861ff..28299b8c33a 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/MemoryAccessKind.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/MemoryAccessKind.qll @@ -1,10 +1,15 @@ import cpp -newtype TMemoryAccessKind = +private newtype TMemoryAccessKind = TIndirectMemoryAccess() or + TIndirectMayMemoryAccess() or + TBufferMemoryAccess() or + TBufferMayMemoryAccess() or TEscapedMemoryAccess() or TPhiMemoryAccess() or - TUnmodeledMemoryAccess() + TUnmodeledMemoryAccess() or + TChiTotalMemoryAccess() or + TChiPartialMemoryAccess() /** * Describes the set of memory locations memory accessed by a memory operand or @@ -15,8 +20,8 @@ class MemoryAccessKind extends TMemoryAccessKind { } /** - * The operand or result accesses memory at the address specified by the - * `AddressOperand` on the same instruction. + * The operand or result accesses memory at the address specified by the `AddressOperand` on the + * same instruction. */ class IndirectMemoryAccess extends MemoryAccessKind, TIndirectMemoryAccess { override string toString() { @@ -24,6 +29,38 @@ class IndirectMemoryAccess extends MemoryAccessKind, TIndirectMemoryAccess { } } +/** + * The operand or result may access some, all, or none of the memory at the address specified by the + * `AddressOperand` on the same instruction. + */ +class IndirectMayMemoryAccess extends MemoryAccessKind, TIndirectMayMemoryAccess { + override string toString() { + result = "indirect(may)" + } +} + +/** + * The operand or result accesses memory starting at the address specified by the `AddressOperand` + * on the same instruction, accessing a number of consecutive elements given by the + * `BufferSizeOperand`. + */ +class BufferMemoryAccess extends MemoryAccessKind, TBufferMemoryAccess { + override string toString() { + result = "buffer" + } +} + +/** + * The operand or result may access some, all, or none of the memory starting at the address + * specified by the `AddressOperand` on the same instruction, accessing a number of consecutive + * elements given by the `BufferSizeOperand`. + */ +class BufferMayMemoryAccess extends MemoryAccessKind, TBufferMayMemoryAccess { + override string toString() { + result = "buffer(may)" + } +} + /** * The operand or result accesses all memory whose address has escaped. */ @@ -43,6 +80,26 @@ class PhiMemoryAccess extends MemoryAccessKind, TPhiMemoryAccess { } } +/** + * The operand is a ChiTotal operand, which accesses the same memory as its + * definition. + */ +class ChiTotalMemoryAccess extends MemoryAccessKind, TChiTotalMemoryAccess { + override string toString() { + result = "chi(total)" + } +} + +/** + * The operand is a ChiPartial operand, which accesses the same memory as its + * definition. + */ +class ChiPartialMemoryAccess extends MemoryAccessKind, TChiPartialMemoryAccess { + override string toString() { + result = "chi(partial)" + } +} + /** * The operand accesses memory not modeled in SSA. Used only on the result of * `UnmodeledDefinition` and on the operands of `UnmodeledUse`. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/Opcode.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/Opcode.qll index 992dde33bcc..ce2d5be7e14 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/Opcode.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/Opcode.qll @@ -54,11 +54,21 @@ private newtype TOpcode = TUnwind() or TUnmodeledDefinition() or TUnmodeledUse() or + TAliasedDefinition() or TPhi() or TVarArgsStart() or TVarArgsEnd() or TVarArg() or - TVarArgCopy() + TVarArgCopy() or + TCallSideEffect() or + TCallReadSideEffect() or + TIndirectReadSideEffect() or + TIndirectWriteSideEffect() or + TIndirectMayWriteSideEffect() or + TBufferReadSideEffect() or + TBufferWriteSideEffect() or + TBufferMayWriteSideEffect() or + TChi() class Opcode extends TOpcode { string toString() { @@ -92,6 +102,29 @@ abstract class OpcodeWithCondition extends Opcode {} abstract class BuiltInOpcode extends Opcode {} +abstract class SideEffectOpcode extends Opcode {} + +/** + * An opcode that reads from a set of memory locations as a side effect. + */ +abstract class ReadSideEffectOpcode extends SideEffectOpcode {} + +/** + * An opcode that writes to a set of memory locations as a side effect. + */ +abstract class WriteSideEffectOpcode extends SideEffectOpcode {} + +/** + * An opcode that may overwrite some, all, or none of an existing set of memory locations. Modeled + * as a read of the original contents, plus a "may" write of the new contents. + */ +abstract class MayWriteSideEffectOpcode extends SideEffectOpcode {} + +/** + * An opcode that accesses a buffer via an `AddressOperand` and a `BufferSizeOperand`. + */ +abstract class BufferAccessOpcode extends MemoryAccessOpcode {} + module Opcode { class NoOp extends Opcode, TNoOp { override final string toString() { result = "NoOp" } } class Uninitialized extends MemoryAccessOpcode, TUninitialized { override final string toString() { result = "Uninitialized" } } @@ -148,9 +181,19 @@ module Opcode { class Unwind extends Opcode, TUnwind { override final string toString() { result = "Unwind" } } class UnmodeledDefinition extends Opcode, TUnmodeledDefinition { override final string toString() { result = "UnmodeledDefinition" } } class UnmodeledUse extends Opcode, TUnmodeledUse { override final string toString() { result = "UnmodeledUse" } } + class AliasedDefinition extends Opcode, TAliasedDefinition { override final string toString() { result = "AliasedDefinition" } } class Phi extends Opcode, TPhi { override final string toString() { result = "Phi" } } class VarArgsStart extends BuiltInOpcode, TVarArgsStart { override final string toString() { result = "VarArgsStart" } } class VarArgsEnd extends BuiltInOpcode, TVarArgsEnd { override final string toString() { result = "VarArgsEnd" } } class VarArg extends BuiltInOpcode, TVarArg { override final string toString() { result = "VarArg" } } class VarArgCopy extends BuiltInOpcode, TVarArgCopy { override final string toString() { result = "VarArgCopy" } } + class CallSideEffect extends MayWriteSideEffectOpcode, TCallSideEffect { override final string toString() { result = "CallSideEffect" } } + class CallReadSideEffect extends ReadSideEffectOpcode, TCallReadSideEffect { override final string toString() { result = "CallReadSideEffect" } } + class IndirectReadSideEffect extends ReadSideEffectOpcode, MemoryAccessOpcode, TIndirectReadSideEffect { override final string toString() { result = "IndirectReadSideEffect" } } + class IndirectWriteSideEffect extends WriteSideEffectOpcode, MemoryAccessOpcode, TIndirectWriteSideEffect { override final string toString() { result = "IndirectWriteSideEffect" } } + class IndirectMayWriteSideEffect extends MayWriteSideEffectOpcode, MemoryAccessOpcode, TIndirectMayWriteSideEffect { override final string toString() { result = "IndirectMayWriteSideEffect" } } + class BufferReadSideEffect extends ReadSideEffectOpcode, BufferAccessOpcode, TBufferReadSideEffect { override final string toString() { result = "BufferReadSideEffect" } } + class BufferWriteSideEffect extends WriteSideEffectOpcode, BufferAccessOpcode, TBufferWriteSideEffect { override final string toString() { result = "BufferWriteSideEffect" } } + class BufferMayWriteSideEffect extends MayWriteSideEffectOpcode, BufferAccessOpcode, TBufferMayWriteSideEffect { override final string toString() { result = "BufferMayWriteSideEffect" } } + class Chi extends Opcode, TChi {override final string toString() { result = "Chi" } } } diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll index c51b05a073b..c325e77509c 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll @@ -1,7 +1,7 @@ private import internal.IRInternal import Instruction import semmle.code.cpp.ir.implementation.EdgeKind -private import Construction::BlockConstruction +import Cached class IRBlock extends TIRBlock { final string toString() { @@ -98,3 +98,82 @@ class IRBlock extends TIRBlock { getAPredecessor().isReachableFromFunctionEntry() } } + +private predicate startsBasicBlock(Instruction instr) { + not instr instanceof PhiInstruction and + ( + count(Instruction predecessor | + instr = predecessor.getASuccessor() + ) != 1 or // Multiple predecessors or no predecessor + exists(Instruction predecessor | + instr = predecessor.getASuccessor() and + strictcount(Instruction other | + other = predecessor.getASuccessor() + ) > 1 + ) or // Predecessor has multiple successors + exists(Instruction predecessor, EdgeKind kind | + instr = predecessor.getSuccessor(kind) and + not kind instanceof GotoEdge + ) // Incoming edge is not a GotoEdge + ) +} + +private predicate isEntryBlock(TIRBlock block) { + block = MkIRBlock(any(EnterFunctionInstruction enter)) +} + +private cached module Cached { + cached newtype TIRBlock = + MkIRBlock(Instruction firstInstr) { + startsBasicBlock(firstInstr) + } + + /** Holds if `i2` follows `i1` in a `IRBlock`. */ + private predicate adjacentInBlock(Instruction i1, Instruction i2) { + exists(GotoEdge edgeKind | i2 = i1.getSuccessor(edgeKind)) and + not startsBasicBlock(i2) + } + + /** Gets the index of `i` in its `IRBlock`. */ + private int getMemberIndex(Instruction i) { + startsBasicBlock(i) and + result = 0 + or + exists(Instruction iPrev | + adjacentInBlock(iPrev, i) and + result = getMemberIndex(iPrev) + 1 + ) + } + + /** Holds if `i` is the `index`th instruction in `block`. */ + cached Instruction getInstruction(TIRBlock block, int index) { + exists(Instruction first | + block = MkIRBlock(first) and + index = getMemberIndex(result) and + adjacentInBlock*(first, result) + ) + } + + cached int getInstructionCount(TIRBlock block) { + result = strictcount(getInstruction(block, _)) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { + exists(Instruction predLast, Instruction succFirst | + predLast = getInstruction(pred, getInstructionCount(pred) - 1) and + succFirst = predLast.getSuccessor(kind) and + succ = MkIRBlock(succFirst) + ) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { + blockSuccessor(pred, succ, _) + } + + cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) = + idominance(isEntryBlock/1, blockSuccessor/2)(_, dominator, block) +} + +Instruction getFirstInstruction(TIRBlock block) { + block = MkIRBlock(result) +} 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 99255b8ffa5..de3087770ea 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 @@ -33,11 +33,18 @@ module InstructionSanity { ) or opcode instanceof CopyOpcode and tag instanceof CopySourceOperandTag or opcode instanceof MemoryAccessOpcode and tag instanceof AddressOperandTag or + opcode instanceof BufferAccessOpcode and tag instanceof BufferSizeOperand or opcode instanceof OpcodeWithCondition and tag instanceof ConditionOperandTag or opcode instanceof Opcode::ReturnValue and tag instanceof ReturnValueOperandTag or opcode instanceof Opcode::ThrowValue and tag instanceof ExceptionOperandTag or opcode instanceof Opcode::UnmodeledUse and tag instanceof UnmodeledUseOperandTag or - opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag + opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiTotalOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiPartialOperandTag or + ( + (opcode instanceof ReadSideEffectOpcode or opcode instanceof MayWriteSideEffectOpcode) and + tag instanceof SideEffectOperandTag + ) ) ) } @@ -162,9 +169,9 @@ class Instruction extends Construction::TInstruction { */ final string getOperationString() { if exists(getImmediateString()) then - result = opcode.toString() + "[" + getImmediateString() + "]" + result = getOperationPrefix() + opcode.toString() + "[" + getImmediateString() + "]" else - result = opcode.toString() + result = getOperationPrefix() + opcode.toString() } /** @@ -174,6 +181,13 @@ class Instruction extends Construction::TInstruction { none() } + private string getOperationPrefix() { + if this instanceof SideEffectInstruction then + result = "^" + else + result = "" + } + private string getResultPrefix() { if resultType instanceof VoidType then result = "v" @@ -1084,6 +1098,9 @@ class SwitchInstruction extends Instruction { } } +/** + * An instruction that calls a function. + */ class CallInstruction extends Instruction { CallInstruction() { opcode instanceof Opcode::Call @@ -1094,6 +1111,116 @@ class CallInstruction extends Instruction { } } +/** + * An instruction representing a side effect of a function call. + */ +class SideEffectInstruction extends Instruction { + SideEffectInstruction() { + opcode instanceof SideEffectOpcode + } + + final Instruction getPrimaryInstruction() { + result = Construction::getPrimaryInstructionForSideEffect(this) + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be + * accessed by that call. + */ +class CallSideEffectInstruction extends SideEffectInstruction { + CallSideEffectInstruction() { + opcode instanceof Opcode::CallSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be read + * by that call. + */ +class CallReadSideEffectInstruction extends SideEffectInstruction { + CallReadSideEffectInstruction() { + opcode instanceof Opcode::CallReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect parameter within a function call. + */ +class IndirectReadSideEffectInstruction extends SideEffectInstruction { + IndirectReadSideEffectInstruction() { + opcode instanceof Opcode::IndirectReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect buffer parameter within a function call. + */ +class BufferReadSideEffectInstruction extends SideEffectInstruction { + BufferReadSideEffectInstruction() { + opcode instanceof Opcode::BufferReadSideEffect + } +} + +/** + * An instruction representing the write of an indirect parameter within a function call. + */ +class IndirectWriteSideEffectInstruction extends SideEffectInstruction { + IndirectWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. The + * entire buffer is overwritten. + */ +class BufferWriteSideEffectInstruction extends SideEffectInstruction { + BufferWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMemoryAccess + } +} + +/** + * An instruction representing the potential write of an indirect parameter within a function call. + * Unlike `IndirectWriteSideEffectInstruction`, the location might not be completely overwritten. + * written. + */ +class IndirectMayWriteSideEffectInstruction extends SideEffectInstruction { + IndirectMayWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectMayWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMayMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. + * Unlike `BufferWriteSideEffectInstruction`, the buffer might not be completely overwritten. + */ +class BufferMayWriteSideEffectInstruction extends SideEffectInstruction { + BufferMayWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferMayWriteSideEffect + } + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMayMemoryAccess + } +} + /** * An instruction that throws an exception. */ @@ -1195,6 +1322,19 @@ class UnmodeledDefinitionInstruction extends Instruction { } } +/** + * An instruction that initializes all escaped memory. + */ +class AliasedDefinitionInstruction extends Instruction { + AliasedDefinitionInstruction() { + opcode instanceof Opcode::AliasedDefinition + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + class UnmodeledUseInstruction extends Instruction { UnmodeledUseInstruction() { opcode instanceof Opcode::UnmodeledUse @@ -1205,6 +1345,16 @@ class UnmodeledUseInstruction extends Instruction { } } +/** + * An instruction representing the choice of one of multiple input values based on control flow. + * + * A `PhiInstruction` is inserted at the beginning of a block whenever two different definitions of + * the same variable reach that block. The `PhiInstruction` will have one operand corresponding to + * each control flow predecessor of the block, with that operand representing the version of the + * variable that flows from that predecessor. The result value of the `PhiInstruction` will be + * a copy of whichever operand corresponds to the actual predecessor that entered the block at + * runtime. + */ class PhiInstruction extends Instruction { PhiInstruction() { opcode instanceof Opcode::Phi @@ -1215,6 +1365,73 @@ class PhiInstruction extends Instruction { } } +/** + * An instruction representing the effect that a write to a memory may have on potential aliases of + * that memory. + * + * A `ChiInstruction` is inserted immediately after an instruction that writes to memory. The + * `ChiInstruction` has two operands. The first operand, given by `getTotalOperand()`, represents + * the previous state of all of the memory that might be alised by the memory write. The second + * operand, given by `getPartialOperand()`, represents the memory that was actually modified by the + * memory write. The result of the `ChiInstruction` represents the same memory as + * `getTotalOperand()`, updated to include the changes due to the value that was actually stored by + * the memory write. + * + * As an example, suppose that variable `p` and `q` are pointers that may or may not point to the + * same memory: + * ``` + * *p = 5; + * x = *q; + * ``` + * + * The IR would look like: + * ``` + * r1_1 = VariableAddress[p] + * r1_2 = Load r1_1, m0_0 // Load the value of `p` + * r1_3 = Constant[5] + * m1_4 = Store r1_2, r1_3 // Store to `*p` + * m1_5 = ^Chi m0_1, m1_4 // Side effect of the previous Store on aliased memory + * r1_6 = VariableAddress[x] + * r1_7 = VariableAddress[q] + * r1_8 = Load r1_7, m0_2 // Load the value of `q` + * r1_9 = Load r1_8, m1_5 // Load the value of `*q` + * m1_10 = Store r1_6, r1_9 // Store to x + * ``` + * + * Note the `Chi` instruction after the store to `*p`. The indicates that the previous contents of + * aliased memory (`m0_1`) are merged with the new value written by the store (`m1_4`), producing a + * new version of aliased memory (`m1_5`). On the subsequent load from `*q`, the source operand of + * `*q` is `m1_5`, indicating that the store to `*p` may (or may not) have updated the memory + * pointed to by `q`. + * + * For more information about how `Chi` instructions are used to model memory side effects, see + * https://link.springer.com/content/pdf/10.1007%2F3-540-61053-7_66.pdf. + */ +class ChiInstruction extends Instruction { + ChiInstruction() { + opcode instanceof Opcode::Chi + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } + + /** + * Gets the operand that represents the previous state of all memory that might be aliased by the + * memory write. + */ + final Instruction getTotalOperand() { + result = getAnOperand().(ChiTotalOperand).getDefinitionInstruction() + } + + /** + * Gets the operand that represents the new value written by the memory write. + */ + final Instruction getPartialOperand() { + result = getAnOperand().(ChiPartialOperand).getDefinitionInstruction() + } +} + /** * An instruction representing a built-in operation. This is used to represent * operations such as access to variable argument lists. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Operand.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Operand.qll index 4cc82d0906c..6fc6af477fa 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Operand.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/Operand.qll @@ -306,6 +306,38 @@ class PositionalArgumentOperand extends ArgumentOperand { } } +class SideEffectOperand extends NonPhiOperand { + SideEffectOperand() { + this = TNonPhiOperand(_, sideEffectOperand(), _) + } + + override MemoryAccessKind getMemoryAccess() { + instr instanceof CallSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof CallReadSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof IndirectReadSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferReadSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectWriteSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferWriteSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectMayWriteSideEffectInstruction and + result instanceof IndirectMayMemoryAccess + or + instr instanceof BufferMayWriteSideEffectInstruction and + result instanceof BufferMayMemoryAccess + } +} + /** * An operand of a `PhiInstruction`. */ @@ -358,3 +390,38 @@ class MemoryOperand extends Operand { exists(getMemoryAccess()) } } + +/** + * The total operand of a Chi node, representing the previous value of the memory. + */ +class ChiTotalOperand extends Operand { + ChiTotalOperand() { + this = TNonPhiOperand(_, chiTotalOperand(), _) + } + + override string toString() { + result = "ChiTotal" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } +} + + +/** + * The partial operand of a Chi node, representing the value being written to part of the memory. + */ +class ChiPartialOperand extends Operand { + ChiPartialOperand() { + this = TNonPhiOperand(_, chiPartialOperand(), _) + } + + override string toString() { + result = "ChiPartial" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiPartialMemoryAccess + } +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasedSSA.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasedSSA.qll new file mode 100644 index 00000000000..37a14222ea3 --- /dev/null +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasedSSA.qll @@ -0,0 +1,268 @@ +import cpp +import AliasAnalysis +private import semmle.code.cpp.ir.implementation.unaliased_ssa.IR +private import semmle.code.cpp.ir.internal.OperandTag +private import semmle.code.cpp.ir.internal.Overlap + +import semmle.code.cpp.ir.internal.Overlap +private import semmle.code.cpp.ir.internal.IntegerConstant as Ints + +private class IntValue = Ints::IntValue; + +private newtype TVirtualVariable = + TVirtualIRVariable(IRVariable var) { + not variableAddressEscapes(var) + } or + TUnknownVirtualVariable(FunctionIR f) + +private VirtualIRVariable getVirtualVariable(IRVariable var) { + result.getIRVariable() = var +} + +class VirtualVariable extends TVirtualVariable { + string toString() { + none() + } + + string getUniqueId() { + none() + } + + Type getType() { + none() + } +} + +class VirtualIRVariable extends VirtualVariable, TVirtualIRVariable { + IRVariable var; + + VirtualIRVariable() { + this = TVirtualIRVariable(var) + } + + override final string toString() { + result = var.toString() + } + + final IRVariable getIRVariable() { + result = var + } + + // REVIEW: This should just be on MemoryAccess + override final Type getType() { + result = var.getType() + } + + override final string getUniqueId() { + result = var.getUniqueId() + } +} + +class UnknownVirtualVariable extends VirtualVariable, TUnknownVirtualVariable { + FunctionIR f; + + UnknownVirtualVariable() { + this = TUnknownVirtualVariable(f) + } + + override final string toString() { + result = "UnknownVvar(" + f + ")" + } + + override final string getUniqueId() { + result = "UnknownVvar(" + f + ")" + } + + override final Type getType() { + result instanceof UnknownType + } + + final FunctionIR getFunctionIR() { + result = f + } +} + +private newtype TMemoryAccess = + TVariableMemoryAccess(VirtualIRVariable vvar, IntValue offset, IntValue size) { + exists(Instruction instr | + exists(MemoryAccessKind mak | instr.getResultMemoryAccess() = mak and not mak instanceof PhiMemoryAccess) and + resultPointsTo(instr.getAnOperand().(AddressOperand).getDefinitionInstruction(), vvar.getIRVariable(), offset) and + if exists(instr.getResultSize()) + then instr.getResultSize() = size + else size = Ints::unknown() + ) + } + or + TUnknownMemoryAccess(UnknownVirtualVariable uvv) or + TTotalUnknownMemoryAccess(UnknownVirtualVariable uvv) + +private VariableMemoryAccess getVariableMemoryAccess(IRVariable var, IntValue offset, IntValue size) { + result.getVirtualVariable() = getVirtualVariable(var) and + result.getOffset() = offset and + result.getSize() = size +} + +class MemoryAccess extends TMemoryAccess { + string toString() { + none() + } + + VirtualVariable getVirtualVariable() { + none() + } + + predicate isPartialMemoryAccess() { + none() + } +} + +class VariableMemoryAccess extends TVariableMemoryAccess, MemoryAccess { + VirtualIRVariable vvar; + IntValue offset; + IntValue size; + + VariableMemoryAccess() { + this = TVariableMemoryAccess(vvar, offset, size) + } + + override final string toString() { + result = vvar.toString() + } + + final override VirtualVariable getVirtualVariable() { + result = vvar + } + + IntValue getOffset() { + result = offset + } + + IntValue getSize() { + result = size + } + + final override predicate isPartialMemoryAccess() { + getOffset() != 0 + or + getSize() != vvar.getType().getSize() + } +} + +class UnknownMemoryAccess extends TUnknownMemoryAccess, MemoryAccess { + UnknownVirtualVariable vvar; + + UnknownMemoryAccess() { + this = TUnknownMemoryAccess(vvar) + } + + final override string toString() { + result = vvar.toString() + } + + final override VirtualVariable getVirtualVariable() { + result = vvar + } + + final override predicate isPartialMemoryAccess() { + any() + } + Type getType() { + result instanceof UnknownType + } +} + +class TotalUnknownMemoryAccess extends TTotalUnknownMemoryAccess, MemoryAccess { + UnknownVirtualVariable vvar; + + TotalUnknownMemoryAccess() { + this = TTotalUnknownMemoryAccess(vvar) + } + + final override string toString() { + result = vvar.toString() + } + + final override VirtualVariable getVirtualVariable() { + result = vvar + } + + Type getType() { + result instanceof UnknownType + } +} + +Overlap getOverlap(MemoryAccess def, MemoryAccess use) { + def instanceof VariableMemoryAccess and + def = use and + result instanceof MustExactlyOverlap + or + exists(VariableMemoryAccess defVMA, VariableMemoryAccess useVMA, int defOffset, int defEnd, + int useOffset, int useEnd | + defVMA = def and + useVMA = use and + defVMA.getVirtualVariable() = useVMA.getVirtualVariable() and + defVMA != useVMA and + defOffset = Ints::getValue(defVMA.getOffset()) and + defEnd = Ints::getValue(Ints::add(defVMA.getOffset(), defVMA.getSize())) and + useOffset = Ints::getValue(useVMA.getOffset()) and + useEnd = Ints::getValue(Ints::add(useVMA.getOffset(), useVMA.getSize())) + | + defOffset <= useOffset and + defEnd >= useEnd and + result instanceof MustTotallyOverlap + or + defOffset > useOffset and + defOffset < useEnd and + result instanceof MayPartiallyOverlap + or + defOffset = useOffset and + defEnd < useEnd and + result instanceof MayPartiallyOverlap + ) + or + exists(UnknownVirtualVariable uvv | + def = TUnknownMemoryAccess(uvv) and + uvv = use.getVirtualVariable() and + result instanceof MayPartiallyOverlap + ) + or + exists(UnknownVirtualVariable uvv | + def = TTotalUnknownMemoryAccess(uvv) and + uvv = use.getVirtualVariable() and + result instanceof MustTotallyOverlap + ) +} + +MemoryAccess getResultMemoryAccess(Instruction instr) { + exists(instr.getResultMemoryAccess()) and + if exists(IRVariable var, IntValue i | + resultPointsTo(instr.getAnOperand().(AddressOperand).getDefinitionInstruction(), var, i) + ) + then exists(IRVariable var, IntValue i | + resultPointsTo(instr.getAnOperand().(AddressOperand).getDefinitionInstruction(), var, i) and + result = getVariableMemoryAccess(var, i, instr.getResultSize()) + ) + else ( + result = TUnknownMemoryAccess(TUnknownVirtualVariable(instr.getFunctionIR())) and + not instr instanceof UnmodeledDefinitionInstruction and + not instr instanceof AliasedDefinitionInstruction + or + result = TTotalUnknownMemoryAccess(TUnknownVirtualVariable(instr.getFunctionIR())) and + instr instanceof AliasedDefinitionInstruction + ) +} + +MemoryAccess getOperandMemoryAccess(Operand operand) { + exists(operand.getMemoryAccess()) and + if exists(IRVariable var, IntValue i | + resultPointsTo(operand.getAddressOperand().getDefinitionInstruction(), var, i) + ) + then exists(IRVariable var, IntValue i | + resultPointsTo(operand.getAddressOperand().getDefinitionInstruction(), var, i) and + result = getVariableMemoryAccess(var, i, operand.getDefinitionInstruction().getResultSize()) + ) + else ( + result = TUnknownMemoryAccess(TUnknownVirtualVariable(operand.getInstruction().getFunctionIR())) and + not operand.getInstruction() instanceof UnmodeledUseInstruction + ) +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/IRBlockConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/IRBlockConstruction.qll deleted file mode 100644 index 3d670b225da..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/IRBlockConstruction.qll +++ /dev/null @@ -1,38 +0,0 @@ -import SSAConstructionInternal -private import SSAConstruction as Construction -private import NewIR - -import Cached -private cached module Cached { - cached newtype TIRBlock = MkIRBlock(OldIR::IRBlock oldBlock) - - private OldIR::IRBlock getOldBlock(TIRBlock block) { - block = MkIRBlock(result) - } - - cached Instruction getInstruction(TIRBlock block, int index) { - Construction::getOldInstruction(result) = - getOldBlock(block).getInstruction(index) - } - - cached int getInstructionCount(TIRBlock block) { - result = getOldBlock(block).getInstructionCount() - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { - succ = MkIRBlock(getOldBlock(pred).getSuccessor(kind)) - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { - blockSuccessor(pred, succ, _) - } - - cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) { - getOldBlock(dominator).immediatelyDominates(getOldBlock(block)) - } - - cached Instruction getFirstInstruction(TIRBlock block) { - Construction::getOldInstruction(result) = - getOldBlock(block).getFirstInstruction() - } -} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstruction.qll index 5dbf34cb6c3..76899995426 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstruction.qll @@ -3,7 +3,6 @@ import cpp private import semmle.code.cpp.ir.implementation.Opcode private import semmle.code.cpp.ir.internal.OperandTag private import NewIR -import IRBlockConstruction as BlockConstruction import Cached cached private module Cached { @@ -18,6 +17,10 @@ cached private module Cached { } or PhiTag(Alias::VirtualVariable vvar, OldIR::IRBlock block) { hasPhiNode(vvar, block) + } or + ChiTag(OldIR::Instruction oldInstruction) { + not oldInstruction instanceof OldIR::PhiInstruction and + hasChiNode(_, oldInstruction) } cached class InstructionTagType extends TInstructionTag { @@ -40,12 +43,28 @@ cached private module Cached { getOldInstruction(result) = instr } + /** + * Gets the chi node corresponding to `instr` if one is present, or the new `Instruction` + * corresponding to `instr` if there is no `Chi` node. + */ + private Instruction getNewFinalInstruction(OldIR::Instruction instr) { + result = getChiInstruction(instr) + or + not exists(getChiInstruction(instr)) and + result = getNewInstruction(instr) + } + private PhiInstruction getPhiInstruction(Function func, OldIR::IRBlock oldBlock, Alias::VirtualVariable vvar) { result.getFunction() = func and result.getAST() = oldBlock.getFirstInstruction().getAST() and result.getTag() = PhiTag(vvar, oldBlock) } + + private ChiInstruction getChiInstruction (OldIR::Instruction instr) { + hasChiNode(_, instr) and + result.getTag() = ChiTag(instr) + } private IRVariable getNewIRVariable(OldIR::IRVariable var) { result.getFunction() = var.getFunction() and @@ -92,6 +111,15 @@ cached private module Cached { tag = PhiTag(vvar, block) and resultType = vvar.getType() and isGLValue = false + ) or + exists(OldIR::Instruction instr, Alias::VirtualVariable vvar | + hasChiNode(vvar, instr) and + instr.getFunction() = func and + opcode instanceof Opcode::Chi and + ast = instr.getAST() and + tag = ChiTag(instr) and + resultType = vvar.getType() and + isGLValue = false ) } @@ -125,11 +153,11 @@ cached private module Cached { hasUseAtRank(vvar, useBlock, useRank, oldInstruction) and definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and if defIndex >= 0 then - result = getNewInstruction(defBlock.getInstruction(defIndex)) + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) else - result = getPhiInstruction(instruction.getFunction(), defBlock, vvar) + result = getPhiInstruction(instruction.getFunction(), defBlock, vvar) ) - ) + ) else ( result = instruction.getFunctionIR().getUnmodeledDefinitionInstruction() ) @@ -146,7 +174,17 @@ cached private module Cached { ) else result = getNewInstruction(oldOperand.getDefinitionInstruction()) - ) + ) or + instruction.getTag() = ChiTag(getOldInstruction(result)) and + tag instanceof ChiPartialOperandTag + or + instruction instanceof UnmodeledUseInstruction and + tag instanceof UnmodeledUseOperandTag and + result instanceof UnmodeledDefinitionInstruction and + instruction.getFunction() = result.getFunction() + or + tag instanceof ChiTotalOperandTag and + result = getChiInstructionTotalOperand(instruction) } cached Instruction getPhiInstructionOperandDefinition(PhiInstruction instr, @@ -160,12 +198,27 @@ cached private module Cached { hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and definitionReachesEndOfBlock(vvar, defBlock, defRank, predBlock) and if defIndex >= 0 then - result = getNewInstruction(defBlock.getInstruction(defIndex)) + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) else result = getPhiInstruction(instr.getFunction(), defBlock, vvar) ) } + cached Instruction getChiInstructionTotalOperand(ChiInstruction chiInstr) { + exists(Alias::VirtualVariable vvar, OldIR::Instruction oldInstr, OldIR::IRBlock defBlock, + int defRank, int defIndex, OldIR::IRBlock useBlock, int useRank | + ChiTag(oldInstr) = chiInstr.getTag() and + vvar = Alias::getResultMemoryAccess(oldInstr).getVirtualVariable() and + hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and + hasUseAtRank(vvar, useBlock, useRank, oldInstr) and + definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and + if defIndex >= 0 then + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) + else + result = getPhiInstruction(chiInstr.getFunction(), defBlock, vvar) + ) + } + cached Instruction getPhiInstructionBlockStart(PhiInstruction instr) { exists(OldIR::IRBlock oldBlock | instr.getTag() = PhiTag(_, oldBlock) and @@ -181,8 +234,24 @@ cached private module Cached { result = getOldInstruction(instruction).getUnconvertedResultExpression() } + /* + * This adds Chi nodes to the instruction successor relation; if an instruction has a Chi node, + * that node is its successor in the new successor relation, and the Chi node's successors are + * the new instructions generated from the successors of the old instruction + */ cached Instruction getInstructionSuccessor(Instruction instruction, EdgeKind kind) { - result = getNewInstruction(getOldInstruction(instruction).getSuccessor(kind)) + if(hasChiNode(_, getOldInstruction(instruction))) + then + result = getChiInstruction(getOldInstruction(instruction)) and + kind instanceof GotoEdge + else ( + result = getNewInstruction(getOldInstruction(instruction).getSuccessor(kind)) + or + exists(OldIR::Instruction oldInstruction | + instruction = getChiInstruction(oldInstruction) and + result = getNewInstruction(oldInstruction.getSuccessor(kind)) + ) + ) } cached IRVariable getInstructionVariable(Instruction instruction) { @@ -228,6 +297,18 @@ cached private module Cached { ) } + cached Instruction getPrimaryInstructionForSideEffect(Instruction instruction) { + exists(OldIR::SideEffectInstruction oldInstruction | + oldInstruction = getOldInstruction(instruction) and + result = getNewInstruction(oldInstruction.getPrimaryInstruction()) + ) + or + exists(OldIR::Instruction oldInstruction | + instruction.getTag() = ChiTag(oldInstruction) and + result = getNewInstruction(oldInstruction) + ) + } + private predicate ssa_variableUpdate(Alias::VirtualVariable vvar, OldIR::Instruction instr, OldIR::IRBlock block, int index) { block.getInstruction(index) = instr and @@ -253,7 +334,16 @@ cached private module Cached { private predicate hasUse(Alias::VirtualVariable vvar, OldIR::Instruction use, OldIR::IRBlock block, int index) { exists(Alias::MemoryAccess access | - access = Alias::getOperandMemoryAccess(use.getAnOperand()) and + ( + access = Alias::getOperandMemoryAccess(use.getAnOperand()) + or + /* + * a partial write to a virtual variable is going to generate a use of that variable when + * Chi nodes are inserted, so we need to mark it as a use in the old IR + */ + access = Alias::getResultMemoryAccess(use) and + access.isPartialMemoryAccess() + ) and block.getInstruction(index) = use and vvar = access.getVirtualVariable() ) @@ -384,6 +474,15 @@ cached private module Cached { hasFrontierPhiNode(vvar, phiBlock) //or ssa_sanitized_custom_phi_node(vvar, block) } + + private predicate hasChiNode(Alias::VirtualVariable vvar, + OldIR::Instruction def) { + exists(Alias::MemoryAccess ma | + ma = Alias::getResultMemoryAccess(def) and + ma.isPartialMemoryAccess() and + ma.getVirtualVariable() = vvar + ) + } } import CachedForDebugging diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstructionInternal.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstructionInternal.qll index 8caf1ce0616..5a4d3779e1e 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstructionInternal.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SSAConstructionInternal.qll @@ -1,3 +1,3 @@ import semmle.code.cpp.ir.implementation.unaliased_ssa.IR as OldIR import semmle.code.cpp.ir.implementation.aliased_ssa.IR as NewIR -import SimpleSSA as Alias +import AliasedSSA as Alias diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSA.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSA.qll deleted file mode 100644 index fdf596267a9..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSA.qll +++ /dev/null @@ -1,84 +0,0 @@ -import SimpleSSAInternal -import cpp -import Alias -private import InputIR -private import semmle.code.cpp.ir.internal.OperandTag -private import semmle.code.cpp.ir.internal.Overlap - -private newtype TVirtualVariable = - MkVirtualVariable(IRVariable var) { - not variableAddressEscapes(var) - } - -private VirtualVariable getVirtualVariable(IRVariable var) { - result.getIRVariable() = var -} - -class VirtualVariable extends TVirtualVariable { - IRVariable var; - - VirtualVariable() { - this = MkVirtualVariable(var) - } - - final string toString() { - result = var.toString() - } - - final IRVariable getIRVariable() { - result = var - } - - // REVIEW: This should just be on MemoryAccess - final Type getType() { - result = var.getType() - } - - final string getUniqueId() { - result = var.getUniqueId() - } -} - -private newtype TMemoryAccess = - MkMemoryAccess(VirtualVariable vvar) - -private MemoryAccess getMemoryAccess(IRVariable var) { - result.getVirtualVariable() = getVirtualVariable(var) -} - -class MemoryAccess extends TMemoryAccess { - VirtualVariable vvar; - - MemoryAccess() { - this = MkMemoryAccess(vvar) - } - - string toString() { - result = vvar.toString() - } - - VirtualVariable getVirtualVariable() { - result = vvar - } -} - -Overlap getOverlap(MemoryAccess def, MemoryAccess use) { - def.getVirtualVariable() = use.getVirtualVariable() and - result instanceof MustExactlyOverlap -} - -MemoryAccess getResultMemoryAccess(Instruction instr) { - exists(IRVariable var | - instr.getResultMemoryAccess() instanceof IndirectMemoryAccess and - resultPointsTo(instr.getAnOperand().(AddressOperand).getDefinitionInstruction(), - var, 0) and - result = getMemoryAccess(var) - ) -} - -MemoryAccess getOperandMemoryAccess(Operand operand) { - exists(IRVariable var | - resultPointsTo(operand.getAddressOperand().getDefinitionInstruction(), var, 0) and - result = getMemoryAccess(var) - ) -} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSAInternal.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSAInternal.qll deleted file mode 100644 index 5322ea0ef0b..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/SimpleSSAInternal.qll +++ /dev/null @@ -1,3 +0,0 @@ -import AliasAnalysis as Alias -import semmle.code.cpp.ir.implementation.unaliased_ssa.IR as InputIR - diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/IRBlock.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/IRBlock.qll index c51b05a073b..c325e77509c 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/IRBlock.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/IRBlock.qll @@ -1,7 +1,7 @@ private import internal.IRInternal import Instruction import semmle.code.cpp.ir.implementation.EdgeKind -private import Construction::BlockConstruction +import Cached class IRBlock extends TIRBlock { final string toString() { @@ -98,3 +98,82 @@ class IRBlock extends TIRBlock { getAPredecessor().isReachableFromFunctionEntry() } } + +private predicate startsBasicBlock(Instruction instr) { + not instr instanceof PhiInstruction and + ( + count(Instruction predecessor | + instr = predecessor.getASuccessor() + ) != 1 or // Multiple predecessors or no predecessor + exists(Instruction predecessor | + instr = predecessor.getASuccessor() and + strictcount(Instruction other | + other = predecessor.getASuccessor() + ) > 1 + ) or // Predecessor has multiple successors + exists(Instruction predecessor, EdgeKind kind | + instr = predecessor.getSuccessor(kind) and + not kind instanceof GotoEdge + ) // Incoming edge is not a GotoEdge + ) +} + +private predicate isEntryBlock(TIRBlock block) { + block = MkIRBlock(any(EnterFunctionInstruction enter)) +} + +private cached module Cached { + cached newtype TIRBlock = + MkIRBlock(Instruction firstInstr) { + startsBasicBlock(firstInstr) + } + + /** Holds if `i2` follows `i1` in a `IRBlock`. */ + private predicate adjacentInBlock(Instruction i1, Instruction i2) { + exists(GotoEdge edgeKind | i2 = i1.getSuccessor(edgeKind)) and + not startsBasicBlock(i2) + } + + /** Gets the index of `i` in its `IRBlock`. */ + private int getMemberIndex(Instruction i) { + startsBasicBlock(i) and + result = 0 + or + exists(Instruction iPrev | + adjacentInBlock(iPrev, i) and + result = getMemberIndex(iPrev) + 1 + ) + } + + /** Holds if `i` is the `index`th instruction in `block`. */ + cached Instruction getInstruction(TIRBlock block, int index) { + exists(Instruction first | + block = MkIRBlock(first) and + index = getMemberIndex(result) and + adjacentInBlock*(first, result) + ) + } + + cached int getInstructionCount(TIRBlock block) { + result = strictcount(getInstruction(block, _)) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { + exists(Instruction predLast, Instruction succFirst | + predLast = getInstruction(pred, getInstructionCount(pred) - 1) and + succFirst = predLast.getSuccessor(kind) and + succ = MkIRBlock(succFirst) + ) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { + blockSuccessor(pred, succ, _) + } + + cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) = + idominance(isEntryBlock/1, blockSuccessor/2)(_, dominator, block) +} + +Instruction getFirstInstruction(TIRBlock block) { + block = MkIRBlock(result) +} 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 99255b8ffa5..de3087770ea 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 @@ -33,11 +33,18 @@ module InstructionSanity { ) or opcode instanceof CopyOpcode and tag instanceof CopySourceOperandTag or opcode instanceof MemoryAccessOpcode and tag instanceof AddressOperandTag or + opcode instanceof BufferAccessOpcode and tag instanceof BufferSizeOperand or opcode instanceof OpcodeWithCondition and tag instanceof ConditionOperandTag or opcode instanceof Opcode::ReturnValue and tag instanceof ReturnValueOperandTag or opcode instanceof Opcode::ThrowValue and tag instanceof ExceptionOperandTag or opcode instanceof Opcode::UnmodeledUse and tag instanceof UnmodeledUseOperandTag or - opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag + opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiTotalOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiPartialOperandTag or + ( + (opcode instanceof ReadSideEffectOpcode or opcode instanceof MayWriteSideEffectOpcode) and + tag instanceof SideEffectOperandTag + ) ) ) } @@ -162,9 +169,9 @@ class Instruction extends Construction::TInstruction { */ final string getOperationString() { if exists(getImmediateString()) then - result = opcode.toString() + "[" + getImmediateString() + "]" + result = getOperationPrefix() + opcode.toString() + "[" + getImmediateString() + "]" else - result = opcode.toString() + result = getOperationPrefix() + opcode.toString() } /** @@ -174,6 +181,13 @@ class Instruction extends Construction::TInstruction { none() } + private string getOperationPrefix() { + if this instanceof SideEffectInstruction then + result = "^" + else + result = "" + } + private string getResultPrefix() { if resultType instanceof VoidType then result = "v" @@ -1084,6 +1098,9 @@ class SwitchInstruction extends Instruction { } } +/** + * An instruction that calls a function. + */ class CallInstruction extends Instruction { CallInstruction() { opcode instanceof Opcode::Call @@ -1094,6 +1111,116 @@ class CallInstruction extends Instruction { } } +/** + * An instruction representing a side effect of a function call. + */ +class SideEffectInstruction extends Instruction { + SideEffectInstruction() { + opcode instanceof SideEffectOpcode + } + + final Instruction getPrimaryInstruction() { + result = Construction::getPrimaryInstructionForSideEffect(this) + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be + * accessed by that call. + */ +class CallSideEffectInstruction extends SideEffectInstruction { + CallSideEffectInstruction() { + opcode instanceof Opcode::CallSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be read + * by that call. + */ +class CallReadSideEffectInstruction extends SideEffectInstruction { + CallReadSideEffectInstruction() { + opcode instanceof Opcode::CallReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect parameter within a function call. + */ +class IndirectReadSideEffectInstruction extends SideEffectInstruction { + IndirectReadSideEffectInstruction() { + opcode instanceof Opcode::IndirectReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect buffer parameter within a function call. + */ +class BufferReadSideEffectInstruction extends SideEffectInstruction { + BufferReadSideEffectInstruction() { + opcode instanceof Opcode::BufferReadSideEffect + } +} + +/** + * An instruction representing the write of an indirect parameter within a function call. + */ +class IndirectWriteSideEffectInstruction extends SideEffectInstruction { + IndirectWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. The + * entire buffer is overwritten. + */ +class BufferWriteSideEffectInstruction extends SideEffectInstruction { + BufferWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMemoryAccess + } +} + +/** + * An instruction representing the potential write of an indirect parameter within a function call. + * Unlike `IndirectWriteSideEffectInstruction`, the location might not be completely overwritten. + * written. + */ +class IndirectMayWriteSideEffectInstruction extends SideEffectInstruction { + IndirectMayWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectMayWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMayMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. + * Unlike `BufferWriteSideEffectInstruction`, the buffer might not be completely overwritten. + */ +class BufferMayWriteSideEffectInstruction extends SideEffectInstruction { + BufferMayWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferMayWriteSideEffect + } + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMayMemoryAccess + } +} + /** * An instruction that throws an exception. */ @@ -1195,6 +1322,19 @@ class UnmodeledDefinitionInstruction extends Instruction { } } +/** + * An instruction that initializes all escaped memory. + */ +class AliasedDefinitionInstruction extends Instruction { + AliasedDefinitionInstruction() { + opcode instanceof Opcode::AliasedDefinition + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + class UnmodeledUseInstruction extends Instruction { UnmodeledUseInstruction() { opcode instanceof Opcode::UnmodeledUse @@ -1205,6 +1345,16 @@ class UnmodeledUseInstruction extends Instruction { } } +/** + * An instruction representing the choice of one of multiple input values based on control flow. + * + * A `PhiInstruction` is inserted at the beginning of a block whenever two different definitions of + * the same variable reach that block. The `PhiInstruction` will have one operand corresponding to + * each control flow predecessor of the block, with that operand representing the version of the + * variable that flows from that predecessor. The result value of the `PhiInstruction` will be + * a copy of whichever operand corresponds to the actual predecessor that entered the block at + * runtime. + */ class PhiInstruction extends Instruction { PhiInstruction() { opcode instanceof Opcode::Phi @@ -1215,6 +1365,73 @@ class PhiInstruction extends Instruction { } } +/** + * An instruction representing the effect that a write to a memory may have on potential aliases of + * that memory. + * + * A `ChiInstruction` is inserted immediately after an instruction that writes to memory. The + * `ChiInstruction` has two operands. The first operand, given by `getTotalOperand()`, represents + * the previous state of all of the memory that might be alised by the memory write. The second + * operand, given by `getPartialOperand()`, represents the memory that was actually modified by the + * memory write. The result of the `ChiInstruction` represents the same memory as + * `getTotalOperand()`, updated to include the changes due to the value that was actually stored by + * the memory write. + * + * As an example, suppose that variable `p` and `q` are pointers that may or may not point to the + * same memory: + * ``` + * *p = 5; + * x = *q; + * ``` + * + * The IR would look like: + * ``` + * r1_1 = VariableAddress[p] + * r1_2 = Load r1_1, m0_0 // Load the value of `p` + * r1_3 = Constant[5] + * m1_4 = Store r1_2, r1_3 // Store to `*p` + * m1_5 = ^Chi m0_1, m1_4 // Side effect of the previous Store on aliased memory + * r1_6 = VariableAddress[x] + * r1_7 = VariableAddress[q] + * r1_8 = Load r1_7, m0_2 // Load the value of `q` + * r1_9 = Load r1_8, m1_5 // Load the value of `*q` + * m1_10 = Store r1_6, r1_9 // Store to x + * ``` + * + * Note the `Chi` instruction after the store to `*p`. The indicates that the previous contents of + * aliased memory (`m0_1`) are merged with the new value written by the store (`m1_4`), producing a + * new version of aliased memory (`m1_5`). On the subsequent load from `*q`, the source operand of + * `*q` is `m1_5`, indicating that the store to `*p` may (or may not) have updated the memory + * pointed to by `q`. + * + * For more information about how `Chi` instructions are used to model memory side effects, see + * https://link.springer.com/content/pdf/10.1007%2F3-540-61053-7_66.pdf. + */ +class ChiInstruction extends Instruction { + ChiInstruction() { + opcode instanceof Opcode::Chi + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } + + /** + * Gets the operand that represents the previous state of all memory that might be aliased by the + * memory write. + */ + final Instruction getTotalOperand() { + result = getAnOperand().(ChiTotalOperand).getDefinitionInstruction() + } + + /** + * Gets the operand that represents the new value written by the memory write. + */ + final Instruction getPartialOperand() { + result = getAnOperand().(ChiPartialOperand).getDefinitionInstruction() + } +} + /** * An instruction representing a built-in operation. This is used to represent * operations such as access to variable argument lists. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Operand.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Operand.qll index 4cc82d0906c..6fc6af477fa 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Operand.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/Operand.qll @@ -306,6 +306,38 @@ class PositionalArgumentOperand extends ArgumentOperand { } } +class SideEffectOperand extends NonPhiOperand { + SideEffectOperand() { + this = TNonPhiOperand(_, sideEffectOperand(), _) + } + + override MemoryAccessKind getMemoryAccess() { + instr instanceof CallSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof CallReadSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof IndirectReadSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferReadSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectWriteSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferWriteSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectMayWriteSideEffectInstruction and + result instanceof IndirectMayMemoryAccess + or + instr instanceof BufferMayWriteSideEffectInstruction and + result instanceof BufferMayMemoryAccess + } +} + /** * An operand of a `PhiInstruction`. */ @@ -358,3 +390,38 @@ class MemoryOperand extends Operand { exists(getMemoryAccess()) } } + +/** + * The total operand of a Chi node, representing the previous value of the memory. + */ +class ChiTotalOperand extends Operand { + ChiTotalOperand() { + this = TNonPhiOperand(_, chiTotalOperand(), _) + } + + override string toString() { + result = "ChiTotal" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } +} + + +/** + * The partial operand of a Chi node, representing the value being written to part of the memory. + */ +class ChiPartialOperand extends Operand { + ChiPartialOperand() { + this = TNonPhiOperand(_, chiPartialOperand(), _) + } + + override string toString() { + result = "ChiPartial" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiPartialMemoryAccess + } +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRBlockConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRBlockConstruction.qll deleted file mode 100644 index d608798ab26..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRBlockConstruction.qll +++ /dev/null @@ -1,83 +0,0 @@ -import semmle.code.cpp.ir.implementation.raw.Instruction -import cpp -import semmle.code.cpp.ir.implementation.EdgeKind - -private predicate startsBasicBlock(Instruction instr) { - not instr instanceof PhiInstruction and - ( - count(Instruction predecessor | - instr = predecessor.getASuccessor() - ) != 1 or // Multiple predecessors or no predecessor - exists(Instruction predecessor | - instr = predecessor.getASuccessor() and - strictcount(Instruction other | - other = predecessor.getASuccessor() - ) > 1 - ) or // Predecessor has multiple successors - exists(Instruction predecessor, EdgeKind kind | - instr = predecessor.getSuccessor(kind) and - not kind instanceof GotoEdge - ) // Incoming edge is not a GotoEdge - ) -} - -private predicate isEntryBlock(TIRBlock block) { - block = MkIRBlock(any(EnterFunctionInstruction enter)) -} - -import Cached -private cached module Cached { - cached newtype TIRBlock = - MkIRBlock(Instruction firstInstr) { - startsBasicBlock(firstInstr) - } - - /** Holds if `i2` follows `i1` in a `IRBlock`. */ - private predicate adjacentInBlock(Instruction i1, Instruction i2) { - exists(GotoEdge edgeKind | i2 = i1.getSuccessor(edgeKind)) and - not startsBasicBlock(i2) - } - - /** Gets the index of `i` in its `IRBlock`. */ - private int getMemberIndex(Instruction i) { - startsBasicBlock(i) and - result = 0 - or - exists(Instruction iPrev | - adjacentInBlock(iPrev, i) and - result = getMemberIndex(iPrev) + 1 - ) - } - - /** Holds if `i` is the `index`th instruction in `block`. */ - cached Instruction getInstruction(TIRBlock block, int index) { - exists(Instruction first | - block = MkIRBlock(first) and - index = getMemberIndex(result) and - adjacentInBlock*(first, result) - ) - } - - cached int getInstructionCount(TIRBlock block) { - result = strictcount(getInstruction(block, _)) - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { - exists(Instruction predLast, Instruction succFirst | - predLast = getInstruction(pred, getInstructionCount(pred) - 1) and - succFirst = predLast.getSuccessor(kind) and - succ = MkIRBlock(succFirst) - ) - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { - blockSuccessor(pred, succ, _) - } - - cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) = - idominance(isEntryBlock/1, blockSuccessor/2)(_, dominator, block) -} - -Instruction getFirstInstruction(TIRBlock block) { - block = MkIRBlock(result) -} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRConstruction.qll index 9fdece58e41..64a2a539ca2 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRConstruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/IRConstruction.qll @@ -1,6 +1,5 @@ import cpp import semmle.code.cpp.ir.implementation.raw.IR -import IRBlockConstruction as BlockConstruction private import semmle.code.cpp.ir.internal.OperandTag private import semmle.code.cpp.ir.internal.TempVariableTag private import InstructionTag @@ -168,6 +167,13 @@ cached private module Cached { result = element.getInstructionResultSize(tag) ) } + + cached Instruction getPrimaryInstructionForSideEffect(Instruction instruction) { + exists(TranslatedElement element, InstructionTag tag | + instructionOrigin(instruction, element, tag) and + result = element.getPrimaryInstructionForSideEffect(tag) + ) + } } import CachedForDebugging diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/InstructionTag.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/InstructionTag.qll index d15e1aad65f..34cbdaa1ee3 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/InstructionTag.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/InstructionTag.qll @@ -40,9 +40,11 @@ newtype TInstructionTag = ExitFunctionTag() or UnmodeledDefinitionTag() or UnmodeledUseTag() or + AliasedDefinitionTag() or SwitchBranchTag() or CallTargetTag() or CallTag() or + CallSideEffectTag() or AllocationSizeTag() or AllocationElementSizeTag() or AllocationExtentConvertTag() or @@ -61,6 +63,7 @@ newtype TInstructionTag = CatchTag() or ThrowTag() or UnwindTag() or + InitializerUninitializedTag() or InitializerFieldAddressTag(Field field) { fieldIsInitialized(field) } or @@ -91,6 +94,7 @@ string getInstructionTagId(TInstructionTag tag) { tag = OnlyInstructionTag() and result = "Only" or // Single instruction (not including implicit Load) tag = InitializerVariableAddressTag() and result = "InitVarAddr" or tag = InitializerStoreTag() and result = "InitStore" or + tag = InitializerUninitializedTag() and result = "InitUninit" or tag = ZeroPadStringConstantTag() and result = "ZeroPadConst" or tag = ZeroPadStringElementIndexTag() and result = "ZeroPadElemIndex" or tag = ZeroPadStringElementAddressTag() and result = "ZeroPadElemAddr" or @@ -110,9 +114,11 @@ string getInstructionTagId(TInstructionTag tag) { tag = ExitFunctionTag() and result = "ExitFunc" or tag = UnmodeledDefinitionTag() and result = "UnmodeledDef" or tag = UnmodeledUseTag() and result = "UnmodeledUse" or + tag = AliasedDefinitionTag() and result = "AliasedDef" or tag = SwitchBranchTag() and result = "SwitchBranch" or tag = CallTargetTag() and result = "CallTarget" or tag = CallTag() and result = "Call" or + tag = CallSideEffectTag() and result = "CallSideEffect" or tag = AllocationSizeTag() and result = "AllocSize" or tag = AllocationElementSizeTag() and result = "AllocElemSize" or tag = AllocationExtentConvertTag() and result = "AllocExtConv" or diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedCall.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedCall.qll new file mode 100644 index 00000000000..5f831993755 --- /dev/null +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedCall.qll @@ -0,0 +1,305 @@ +import cpp +private import semmle.code.cpp.ir.implementation.Opcode +private import semmle.code.cpp.ir.internal.OperandTag +private import InstructionTag +private import TranslatedElement +private import TranslatedExpr + +/** + * The IR translation of a call to a function. The call may be from an actual + * call in the source code, or could be a call that is part of the translation + * of a higher-level constructor (e.g. the allocator call in a `NewExpr`). + */ +abstract class TranslatedCall extends TranslatedExpr { + override final TranslatedElement getChild(int id) { + // We choose the child's id in the order of evaluation. + // The qualifier is evaluated before the call target, because the value of + // the call target may depend on the value of the qualifier for virtual + // calls. + id = -2 and result = getQualifier() or + id = -1 and result = getCallTarget() or + result = getArgument(id) + } + + override final Instruction getFirstInstruction() { + if exists(getQualifier()) then + result = getQualifier().getFirstInstruction() + else + result = getFirstCallTargetInstruction() + } + + override predicate hasInstruction(Opcode opcode, InstructionTag tag, + Type resultType, boolean isGLValue) { + ( + tag = CallTag() and + opcode instanceof Opcode::Call and + resultType = getCallResultType() and + isGLValue = false + ) or + ( + tag = CallSideEffectTag() and + opcode instanceof Opcode::CallSideEffect and + resultType instanceof UnknownType and + isGLValue = false + ) + } + + override Instruction getChildSuccessor(TranslatedElement child) { + ( + child = getQualifier() and + result = getFirstCallTargetInstruction() + ) or + ( + child = getCallTarget() and + result = getFirstArgumentOrCallInstruction() + ) or + exists(int argIndex | + child = getArgument(argIndex) and + if exists(getArgument(argIndex + 1)) then + result = getArgument(argIndex + 1).getFirstInstruction() + else + result = getInstruction(CallTag()) + ) + } + + override Instruction getInstructionSuccessor(InstructionTag tag, + EdgeKind kind) { + kind instanceof GotoEdge and + ( + ( + tag = CallTag() and + result = getInstruction(CallSideEffectTag()) + ) or + ( + tag = CallSideEffectTag() and + result = getParent().getChildSuccessor(this) + ) + ) + } + + override Instruction getInstructionOperand(InstructionTag tag, + OperandTag operandTag) { + ( + tag = CallTag() and + ( + ( + operandTag instanceof CallTargetOperandTag and + result = getCallTargetResult() + ) or + ( + operandTag instanceof ThisArgumentOperandTag and + result = getQualifierResult() + ) or + exists(PositionalArgumentOperandTag argTag | + argTag = operandTag and + result = getArgument(argTag.getArgIndex()).getResult() + ) + ) + ) or + ( + tag = CallSideEffectTag() and + operandTag instanceof SideEffectOperandTag and + result = getEnclosingFunction().getUnmodeledDefinitionInstruction() + ) + } + + override final Instruction getResult() { + result = getInstruction(CallTag()) + } + + /** + * Gets the result type of the call. + */ + abstract Type getCallResultType(); + + /** + * Holds if the call has a `this` argument. + */ + predicate hasQualifier() { + exists(getQualifier()) + } + + /** + * Gets the `TranslatedExpr` for the indirect target of the call, if any. + */ + TranslatedExpr getCallTarget() { + none() + } + + /** + * Gets the first instruction of the sequence to evaluate the call target. + * By default, this is just the first instruction of `getCallTarget()`, but + * it can be overridden by a subclass for cases where there is a call target + * that is not computed from an expression (e.g. a direct call). + */ + Instruction getFirstCallTargetInstruction() { + result = getCallTarget().getFirstInstruction() + } + + /** + * Gets the instruction whose result value is the target of the call. By + * default, this is just the result of `getCallTarget()`, but it can be + * overridden by a subclass for cases where there is a call target that is not + * computed from an expression (e.g. a direct call). + */ + Instruction getCallTargetResult() { + result = getCallTarget().getResult() + } + + /** + * Gets the `TranslatedExpr` for the qualifier of the call (i.e. the value + * that is passed as the `this` argument. + */ + abstract TranslatedExpr getQualifier(); + + /** + * Gets the instruction whose result value is the `this` argument of the call. + * By default, this is just the result of `getQualifier()`, but it can be + * overridden by a subclass for cases where there is a `this` argument that is + * not computed from a child expression (e.g. a constructor call). + */ + Instruction getQualifierResult() { + result = getQualifier().getResult() + } + + /** + * Gets the argument with the specified `index`. Does not include the `this` + * argument. + */ + abstract TranslatedExpr getArgument(int index); + + /** + * If there are any arguments, gets the first instruction of the first + * argument. Otherwise, returns the call instruction. + */ + final Instruction getFirstArgumentOrCallInstruction() { + if hasArguments() then + result = getArgument(0).getFirstInstruction() + else + result = getInstruction(CallTag()) + } + + /** + * Holds if the call has any arguments, not counting the `this` argument. + */ + abstract predicate hasArguments(); +} + +/** + * IR translation of a direct call to a specific function. Used for both + * explicit calls (`TranslatedFunctionCall`) and implicit calls + * (`TranslatedAllocatorCall`). + */ +abstract class TranslatedDirectCall extends TranslatedCall { + override final Instruction getFirstCallTargetInstruction() { + result = getInstruction(CallTargetTag()) + } + + override final Instruction getCallTargetResult() { + result = getInstruction(CallTargetTag()) + } + + override predicate hasInstruction(Opcode opcode, InstructionTag tag, + Type resultType, boolean isGLValue) { + TranslatedCall.super.hasInstruction(opcode, tag, resultType, isGLValue) or + ( + tag = CallTargetTag() and + opcode instanceof Opcode::FunctionAddress and + // The database does not contain a `FunctionType` for a function unless + // its address was taken, so we'll just use glval instead of + // glval. + resultType instanceof UnknownType and + isGLValue = true + ) + } + + override Instruction getInstructionSuccessor(InstructionTag tag, + EdgeKind kind) { + result = TranslatedCall.super.getInstructionSuccessor(tag, kind) or + ( + tag = CallTargetTag() and + kind instanceof GotoEdge and + result = getFirstArgumentOrCallInstruction() + ) + } +} + +/** + * The IR translation of a call to a function. + */ +abstract class TranslatedCallExpr extends TranslatedNonConstantExpr, + TranslatedCall { + Call call; + + TranslatedCallExpr() { + expr = call + } + + override final Type getCallResultType() { + result = getResultType() + } + + override final predicate hasArguments() { + exists(call.getArgument(0)) + } + + override final TranslatedExpr getQualifier() { + result = getTranslatedExpr(call.getQualifier().getFullyConverted()) + } + + override final TranslatedExpr getArgument(int index) { + result = getTranslatedExpr(call.getArgument(index).getFullyConverted()) + } +} + +/** + * Represents the IR translation of a call through a function pointer. + */ +class TranslatedExprCall extends TranslatedCallExpr { + ExprCall exprCall; + + TranslatedExprCall() { + expr = exprCall + } + + override TranslatedExpr getCallTarget() { + result = getTranslatedExpr(exprCall.getExpr().getFullyConverted()) + } +} + +/** + * Represents the IR translation of a direct function call. + */ +class TranslatedFunctionCall extends TranslatedCallExpr, TranslatedDirectCall { + FunctionCall funcCall; + + TranslatedFunctionCall() { + expr = funcCall + } + + override Function getInstructionFunction(InstructionTag tag) { + tag = CallTargetTag() and result = funcCall.getTarget() + } +} + +/** + * Represents the IR translation of a call to a constructor. + */ +class TranslatedStructorCall extends TranslatedFunctionCall { + TranslatedStructorCall() { + funcCall instanceof ConstructorCall or + funcCall instanceof DestructorCall + } + + override Instruction getQualifierResult() { + exists(StructorCallContext context | + context = getParent() and + result = context.getReceiver() + ) + } + + override predicate hasQualifier() { + any() + } +} + diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll index b701c1a3f5d..6ca38c6505d 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll @@ -534,6 +534,14 @@ abstract class TranslatedElement extends TTranslatedElement { result = getParent().getExceptionSuccessorInstruction() } + /** + * Gets the primary instruction for the side effect instruction that was + * generated by this element for tag `tag`. + */ + Instruction getPrimaryInstructionForSideEffect(InstructionTag tag) { + none() + } + /** * Holds if this element generates a temporary variable with type `type`. * `tag` must be unique for each variable generated from the same AST node diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedExpr.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedExpr.qll index 175f710f265..53103ae4ca1 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedExpr.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedExpr.qll @@ -8,6 +8,7 @@ private import TranslatedDeclarationEntry private import TranslatedElement private import TranslatedFunction private import TranslatedInitialization +import TranslatedCall /** * Gets the TranslatedExpr for the specified expression. If `expr` is a load, @@ -1769,163 +1770,6 @@ class TranslatedAssignOperation extends TranslatedAssignment { } } -/** - * The IR translation of a call to a function. The call may be from an actual - * call in the source code, or could be a call that is part of the translation - * of a higher-level constructor (e.g. the allocator call in a `NewExpr`). - */ -abstract class TranslatedCall extends TranslatedExpr { - override final TranslatedElement getChild(int id) { - // We choose the child's id in the order of evaluation. - // The qualifier is evaluated before the call target, because the value of - // the call target may depend on the value of the qualifier for virtual - // calls. - id = -2 and result = getQualifier() or - id = -1 and result = getCallTarget() or - result = getArgument(id) - } - - override final Instruction getFirstInstruction() { - if exists(getQualifier()) then - result = getQualifier().getFirstInstruction() - else - result = getFirstCallTargetInstruction() - } - - override predicate hasInstruction(Opcode opcode, InstructionTag tag, - Type resultType, boolean isGLValue) { - tag = CallTag() and - opcode instanceof Opcode::Call and - resultType = getCallResultType() and - isGLValue = false - } - - override Instruction getChildSuccessor(TranslatedElement child) { - ( - child = getQualifier() and - result = getFirstCallTargetInstruction() - ) or - ( - child = getCallTarget() and - result = getFirstArgumentOrCallInstruction() - ) or - exists(int argIndex | - child = getArgument(argIndex) and - if exists(getArgument(argIndex + 1)) then - result = getArgument(argIndex + 1).getFirstInstruction() - else - result = getInstruction(CallTag()) - ) - } - - override Instruction getInstructionSuccessor(InstructionTag tag, - EdgeKind kind) { - kind instanceof GotoEdge and - tag = CallTag() and - result = getParent().getChildSuccessor(this) - } - - override Instruction getInstructionOperand(InstructionTag tag, - OperandTag operandTag) { - tag = CallTag() and - ( - ( - operandTag instanceof CallTargetOperandTag and - result = getCallTargetResult() - ) or - ( - operandTag instanceof ThisArgumentOperandTag and - result = getQualifierResult() - ) or - exists(PositionalArgumentOperandTag argTag | - argTag = operandTag and - result = getArgument(argTag.getArgIndex()).getResult() - ) - ) - } - - override final Instruction getResult() { - result = getInstruction(CallTag()) - } - - /** - * Gets the result type of the call. - */ - abstract Type getCallResultType(); - - /** - * Holds if the call has a `this` argument. - */ - predicate hasQualifier() { - exists(getQualifier()) - } - - /** - * Gets the `TranslatedExpr` for the indirect target of the call, if any. - */ - TranslatedExpr getCallTarget() { - none() - } - - /** - * Gets the first instruction of the sequence to evaluate the call target. - * By default, this is just the first instruction of `getCallTarget()`, but - * it can be overridden by a subclass for cases where there is a call target - * that is not computed from an expression (e.g. a direct call). - */ - Instruction getFirstCallTargetInstruction() { - result = getCallTarget().getFirstInstruction() - } - - /** - * Gets the instruction whose result value is the target of the call. By - * default, this is just the result of `getCallTarget()`, but it can be - * overridden by a subclass for cases where there is a call target that is not - * computed from an expression (e.g. a direct call). - */ - Instruction getCallTargetResult() { - result = getCallTarget().getResult() - } - - /** - * Gets the `TranslatedExpr` for the qualifier of the call (i.e. the value - * that is passed as the `this` argument. - */ - abstract TranslatedExpr getQualifier(); - - /** - * Gets the instruction whose result value is the `this` argument of the call. - * By default, this is just the result of `getQualifier()`, but it can be - * overridden by a subclass for cases where there is a `this` argument that is - * not computed from a child expression (e.g. a constructor call). - */ - Instruction getQualifierResult() { - result = getQualifier().getResult() - } - - /** - * Gets the argument with the specified `index`. Does not include the `this` - * argument. - */ - abstract TranslatedExpr getArgument(int index); - - /** - * If there are any arguments, gets the first instruction of the first - * argument. Otherwise, returns the call instruction. - */ - final Instruction getFirstArgumentOrCallInstruction() { - if hasArguments() then - result = getArgument(0).getFirstInstruction() - else - result = getInstruction(CallTag()) - } - - /** - * Holds if the call has any arguments, not counting the `this` argument. - */ - abstract predicate hasArguments(); -} - /** * The IR translation of the allocation size argument passed to `operator new` * in a `new` expression. @@ -2089,45 +1933,6 @@ class TranslatedNonConstantAllocationSize extends TranslatedAllocationSize { } } -/** - * IR translation of a direct call to a specific function. Used for both - * explicit calls (`TranslatedFunctionCall`) and implicit calls - * (`TranslatedAllocatorCall`). - */ -abstract class TranslatedDirectCall extends TranslatedCall { - override final Instruction getFirstCallTargetInstruction() { - result = getInstruction(CallTargetTag()) - } - - override final Instruction getCallTargetResult() { - result = getInstruction(CallTargetTag()) - } - - override predicate hasInstruction(Opcode opcode, InstructionTag tag, - Type resultType, boolean isGLValue) { - TranslatedCall.super.hasInstruction(opcode, tag, resultType, isGLValue) or - ( - tag = CallTargetTag() and - opcode instanceof Opcode::FunctionAddress and - // The database does not contain a `FunctionType` for a function unless - // its address was taken, so we'll just use glval instead of - // glval. - resultType instanceof UnknownType and - isGLValue = true - ) - } - - override Instruction getInstructionSuccessor(InstructionTag tag, - EdgeKind kind) { - result = TranslatedCall.super.getInstructionSuccessor(tag, kind) or - ( - tag = CallTargetTag() and - kind instanceof GotoEdge and - result = getFirstArgumentOrCallInstruction() - ) - } -} - /** * The IR translation of a call to `operator new` as part of a `new` or `new[]` * expression. @@ -2185,65 +1990,6 @@ class TranslatedAllocatorCall extends TTranslatedAllocatorCall, TranslatedAllocatorCall getTranslatedAllocatorCall(NewOrNewArrayExpr newExpr) { result.getAST() = newExpr } - -/** - * The IR translation of a call to a function. - */ -abstract class TranslatedCallExpr extends TranslatedNonConstantExpr, - TranslatedCall { - Call call; - - TranslatedCallExpr() { - expr = call - } - - override final Type getCallResultType() { - result = getResultType() - } - - override final predicate hasArguments() { - exists(call.getArgument(0)) - } - - override final TranslatedExpr getQualifier() { - result = getTranslatedExpr(call.getQualifier().getFullyConverted()) - } - - override final TranslatedExpr getArgument(int index) { - result = getTranslatedExpr(call.getArgument(index).getFullyConverted()) - } -} - -/** - * Represents the IR translation of a call through a function pointer. - */ -class TranslatedExprCall extends TranslatedCallExpr { - ExprCall exprCall; - - TranslatedExprCall() { - expr = exprCall - } - - override TranslatedExpr getCallTarget() { - result = getTranslatedExpr(exprCall.getExpr().getFullyConverted()) - } -} - -/** - * Represents the IR translation of a direct function call. - */ -class TranslatedFunctionCall extends TranslatedCallExpr, TranslatedDirectCall { - FunctionCall funcCall; - - TranslatedFunctionCall() { - expr = funcCall - } - - override Function getInstructionFunction(InstructionTag tag) { - tag = CallTargetTag() and result = funcCall.getTarget() - } -} - /** * Abstract class implemented by any `TranslatedElement` that has a child * expression that is a call to a constructor or destructor, in order to @@ -2257,27 +2003,6 @@ abstract class StructorCallContext extends TranslatedElement { abstract Instruction getReceiver(); } -/** - * Represents the IR translation of a call to a constructor. - */ -class TranslatedStructorCall extends TranslatedFunctionCall { - TranslatedStructorCall() { - funcCall instanceof ConstructorCall or - funcCall instanceof DestructorCall - } - - override Instruction getQualifierResult() { - exists(StructorCallContext context | - context = getParent() and - result = context.getReceiver() - ) - } - - override predicate hasQualifier() { - any() - } -} - /** * Represents the IR translation of the destruction of a field from within * the destructor of the field's declaring class. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedFunction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedFunction.qll index be1c3a606d9..e90d773516e 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedFunction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedFunction.qll @@ -76,6 +76,9 @@ class TranslatedFunction extends TranslatedElement, ( ( tag = EnterFunctionTag() and + result = getInstruction(AliasedDefinitionTag()) + ) or ( + tag = AliasedDefinitionTag() and result = getInstruction(UnmodeledDefinitionTag()) ) or ( @@ -153,6 +156,12 @@ class TranslatedFunction extends TranslatedElement, resultType instanceof UnknownType and isGLValue = false ) or + ( + tag = AliasedDefinitionTag() and + opcode instanceof Opcode::AliasedDefinition and + resultType instanceof UnknownType and + isGLValue = false + ) or ( tag = InitializeThisTag() and opcode instanceof Opcode::InitializeThis and @@ -218,6 +227,11 @@ class TranslatedFunction extends TranslatedElement, result.getFunction() = func and result.hasMemoryResult() ) or + ( + tag = UnmodeledUseTag() and + operandTag instanceof UnmodeledUseOperandTag and + result = getUnmodeledDefinitionInstruction() + ) or ( tag = ReturnTag() and not getReturnType() instanceof VoidType and diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedInitialization.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedInitialization.qll index 49194bd176b..6d026f0c2bf 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedInitialization.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedInitialization.qll @@ -148,7 +148,11 @@ class TranslatedArrayListInitialization extends } override TranslatedElement getChild(int id) { - result = getTranslatedElementInitialization(initList, id) + // The children are in initialization order + result = rank[id + 1](TranslatedElementInitialization init | + init.getInitList() = initList | + init order by init.getElementIndex() + ) } } @@ -668,15 +672,6 @@ class TranslatedFieldValueInitialization extends } } -/** - * Gets the `TranslatedElementInitialization` for element `elementIndex` in - * initializer list `initList`. - */ -TranslatedElementInitialization getTranslatedElementInitialization( - ArrayAggregateLiteral initList, int elementIndex) { - result.getInitList() = initList and result.getElementIndex() = elementIndex -} - /** * Represents the IR translation of the initialization of an array element from * an element of an initializer list. @@ -717,7 +712,7 @@ abstract class TranslatedElementInitialization extends TranslatedElement { } override Instruction getInstructionSuccessor(InstructionTag tag, - EdgeKind kind) { + EdgeKind kind) { tag = getElementIndexTag() and result = getInstruction(getElementAddressTag()) and kind instanceof GotoEdge @@ -767,9 +762,8 @@ abstract class TranslatedElementInitialization extends TranslatedElement { * Represents the IR translation of the initialization of an array element from * an explicit element in an initializer list. */ -class TranslatedExplicitElementInitialization extends - TranslatedElementInitialization, TTranslatedExplicitElementInitialization, - InitializationContext { +class TranslatedExplicitElementInitialization extends TranslatedElementInitialization, + TTranslatedExplicitElementInitialization, InitializationContext { int elementIndex; TranslatedExplicitElementInitialization() { @@ -785,7 +779,7 @@ class TranslatedExplicitElementInitialization extends } override Instruction getInstructionSuccessor(InstructionTag tag, - EdgeKind kind) { + EdgeKind kind) { result = TranslatedElementInitialization.super.getInstructionSuccessor(tag, kind) or ( tag = getElementAddressTag() and @@ -816,8 +810,8 @@ class TranslatedExplicitElementInitialization extends * Represents the IR translation of the initialization of a range of array * elements without corresponding elements in the initializer list. */ -class TranslatedElementValueInitialization extends - TranslatedElementInitialization, TTranslatedElementValueInitialization { +class TranslatedElementValueInitialization extends TranslatedElementInitialization, + TTranslatedElementValueInitialization { int elementIndex; int elementCount; diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll index c51b05a073b..c325e77509c 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll @@ -1,7 +1,7 @@ private import internal.IRInternal import Instruction import semmle.code.cpp.ir.implementation.EdgeKind -private import Construction::BlockConstruction +import Cached class IRBlock extends TIRBlock { final string toString() { @@ -98,3 +98,82 @@ class IRBlock extends TIRBlock { getAPredecessor().isReachableFromFunctionEntry() } } + +private predicate startsBasicBlock(Instruction instr) { + not instr instanceof PhiInstruction and + ( + count(Instruction predecessor | + instr = predecessor.getASuccessor() + ) != 1 or // Multiple predecessors or no predecessor + exists(Instruction predecessor | + instr = predecessor.getASuccessor() and + strictcount(Instruction other | + other = predecessor.getASuccessor() + ) > 1 + ) or // Predecessor has multiple successors + exists(Instruction predecessor, EdgeKind kind | + instr = predecessor.getSuccessor(kind) and + not kind instanceof GotoEdge + ) // Incoming edge is not a GotoEdge + ) +} + +private predicate isEntryBlock(TIRBlock block) { + block = MkIRBlock(any(EnterFunctionInstruction enter)) +} + +private cached module Cached { + cached newtype TIRBlock = + MkIRBlock(Instruction firstInstr) { + startsBasicBlock(firstInstr) + } + + /** Holds if `i2` follows `i1` in a `IRBlock`. */ + private predicate adjacentInBlock(Instruction i1, Instruction i2) { + exists(GotoEdge edgeKind | i2 = i1.getSuccessor(edgeKind)) and + not startsBasicBlock(i2) + } + + /** Gets the index of `i` in its `IRBlock`. */ + private int getMemberIndex(Instruction i) { + startsBasicBlock(i) and + result = 0 + or + exists(Instruction iPrev | + adjacentInBlock(iPrev, i) and + result = getMemberIndex(iPrev) + 1 + ) + } + + /** Holds if `i` is the `index`th instruction in `block`. */ + cached Instruction getInstruction(TIRBlock block, int index) { + exists(Instruction first | + block = MkIRBlock(first) and + index = getMemberIndex(result) and + adjacentInBlock*(first, result) + ) + } + + cached int getInstructionCount(TIRBlock block) { + result = strictcount(getInstruction(block, _)) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { + exists(Instruction predLast, Instruction succFirst | + predLast = getInstruction(pred, getInstructionCount(pred) - 1) and + succFirst = predLast.getSuccessor(kind) and + succ = MkIRBlock(succFirst) + ) + } + + cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { + blockSuccessor(pred, succ, _) + } + + cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) = + idominance(isEntryBlock/1, blockSuccessor/2)(_, dominator, block) +} + +Instruction getFirstInstruction(TIRBlock block) { + block = MkIRBlock(result) +} 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 99255b8ffa5..de3087770ea 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 @@ -33,11 +33,18 @@ module InstructionSanity { ) or opcode instanceof CopyOpcode and tag instanceof CopySourceOperandTag or opcode instanceof MemoryAccessOpcode and tag instanceof AddressOperandTag or + opcode instanceof BufferAccessOpcode and tag instanceof BufferSizeOperand or opcode instanceof OpcodeWithCondition and tag instanceof ConditionOperandTag or opcode instanceof Opcode::ReturnValue and tag instanceof ReturnValueOperandTag or opcode instanceof Opcode::ThrowValue and tag instanceof ExceptionOperandTag or opcode instanceof Opcode::UnmodeledUse and tag instanceof UnmodeledUseOperandTag or - opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag + opcode instanceof Opcode::Call and tag instanceof CallTargetOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiTotalOperandTag or + opcode instanceof Opcode::Chi and tag instanceof ChiPartialOperandTag or + ( + (opcode instanceof ReadSideEffectOpcode or opcode instanceof MayWriteSideEffectOpcode) and + tag instanceof SideEffectOperandTag + ) ) ) } @@ -162,9 +169,9 @@ class Instruction extends Construction::TInstruction { */ final string getOperationString() { if exists(getImmediateString()) then - result = opcode.toString() + "[" + getImmediateString() + "]" + result = getOperationPrefix() + opcode.toString() + "[" + getImmediateString() + "]" else - result = opcode.toString() + result = getOperationPrefix() + opcode.toString() } /** @@ -174,6 +181,13 @@ class Instruction extends Construction::TInstruction { none() } + private string getOperationPrefix() { + if this instanceof SideEffectInstruction then + result = "^" + else + result = "" + } + private string getResultPrefix() { if resultType instanceof VoidType then result = "v" @@ -1084,6 +1098,9 @@ class SwitchInstruction extends Instruction { } } +/** + * An instruction that calls a function. + */ class CallInstruction extends Instruction { CallInstruction() { opcode instanceof Opcode::Call @@ -1094,6 +1111,116 @@ class CallInstruction extends Instruction { } } +/** + * An instruction representing a side effect of a function call. + */ +class SideEffectInstruction extends Instruction { + SideEffectInstruction() { + opcode instanceof SideEffectOpcode + } + + final Instruction getPrimaryInstruction() { + result = Construction::getPrimaryInstructionForSideEffect(this) + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be + * accessed by that call. + */ +class CallSideEffectInstruction extends SideEffectInstruction { + CallSideEffectInstruction() { + opcode instanceof Opcode::CallSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + +/** + * An instruction representing the side effect of a function call on any memory that might be read + * by that call. + */ +class CallReadSideEffectInstruction extends SideEffectInstruction { + CallReadSideEffectInstruction() { + opcode instanceof Opcode::CallReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect parameter within a function call. + */ +class IndirectReadSideEffectInstruction extends SideEffectInstruction { + IndirectReadSideEffectInstruction() { + opcode instanceof Opcode::IndirectReadSideEffect + } +} + +/** + * An instruction representing the read of an indirect buffer parameter within a function call. + */ +class BufferReadSideEffectInstruction extends SideEffectInstruction { + BufferReadSideEffectInstruction() { + opcode instanceof Opcode::BufferReadSideEffect + } +} + +/** + * An instruction representing the write of an indirect parameter within a function call. + */ +class IndirectWriteSideEffectInstruction extends SideEffectInstruction { + IndirectWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. The + * entire buffer is overwritten. + */ +class BufferWriteSideEffectInstruction extends SideEffectInstruction { + BufferWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMemoryAccess + } +} + +/** + * An instruction representing the potential write of an indirect parameter within a function call. + * Unlike `IndirectWriteSideEffectInstruction`, the location might not be completely overwritten. + * written. + */ +class IndirectMayWriteSideEffectInstruction extends SideEffectInstruction { + IndirectMayWriteSideEffectInstruction() { + opcode instanceof Opcode::IndirectMayWriteSideEffect + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof IndirectMayMemoryAccess + } +} + +/** + * An instruction representing the write of an indirect buffer parameter within a function call. + * Unlike `BufferWriteSideEffectInstruction`, the buffer might not be completely overwritten. + */ +class BufferMayWriteSideEffectInstruction extends SideEffectInstruction { + BufferMayWriteSideEffectInstruction() { + opcode instanceof Opcode::BufferMayWriteSideEffect + } + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof BufferMayMemoryAccess + } +} + /** * An instruction that throws an exception. */ @@ -1195,6 +1322,19 @@ class UnmodeledDefinitionInstruction extends Instruction { } } +/** + * An instruction that initializes all escaped memory. + */ +class AliasedDefinitionInstruction extends Instruction { + AliasedDefinitionInstruction() { + opcode instanceof Opcode::AliasedDefinition + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof EscapedMemoryAccess + } +} + class UnmodeledUseInstruction extends Instruction { UnmodeledUseInstruction() { opcode instanceof Opcode::UnmodeledUse @@ -1205,6 +1345,16 @@ class UnmodeledUseInstruction extends Instruction { } } +/** + * An instruction representing the choice of one of multiple input values based on control flow. + * + * A `PhiInstruction` is inserted at the beginning of a block whenever two different definitions of + * the same variable reach that block. The `PhiInstruction` will have one operand corresponding to + * each control flow predecessor of the block, with that operand representing the version of the + * variable that flows from that predecessor. The result value of the `PhiInstruction` will be + * a copy of whichever operand corresponds to the actual predecessor that entered the block at + * runtime. + */ class PhiInstruction extends Instruction { PhiInstruction() { opcode instanceof Opcode::Phi @@ -1215,6 +1365,73 @@ class PhiInstruction extends Instruction { } } +/** + * An instruction representing the effect that a write to a memory may have on potential aliases of + * that memory. + * + * A `ChiInstruction` is inserted immediately after an instruction that writes to memory. The + * `ChiInstruction` has two operands. The first operand, given by `getTotalOperand()`, represents + * the previous state of all of the memory that might be alised by the memory write. The second + * operand, given by `getPartialOperand()`, represents the memory that was actually modified by the + * memory write. The result of the `ChiInstruction` represents the same memory as + * `getTotalOperand()`, updated to include the changes due to the value that was actually stored by + * the memory write. + * + * As an example, suppose that variable `p` and `q` are pointers that may or may not point to the + * same memory: + * ``` + * *p = 5; + * x = *q; + * ``` + * + * The IR would look like: + * ``` + * r1_1 = VariableAddress[p] + * r1_2 = Load r1_1, m0_0 // Load the value of `p` + * r1_3 = Constant[5] + * m1_4 = Store r1_2, r1_3 // Store to `*p` + * m1_5 = ^Chi m0_1, m1_4 // Side effect of the previous Store on aliased memory + * r1_6 = VariableAddress[x] + * r1_7 = VariableAddress[q] + * r1_8 = Load r1_7, m0_2 // Load the value of `q` + * r1_9 = Load r1_8, m1_5 // Load the value of `*q` + * m1_10 = Store r1_6, r1_9 // Store to x + * ``` + * + * Note the `Chi` instruction after the store to `*p`. The indicates that the previous contents of + * aliased memory (`m0_1`) are merged with the new value written by the store (`m1_4`), producing a + * new version of aliased memory (`m1_5`). On the subsequent load from `*q`, the source operand of + * `*q` is `m1_5`, indicating that the store to `*p` may (or may not) have updated the memory + * pointed to by `q`. + * + * For more information about how `Chi` instructions are used to model memory side effects, see + * https://link.springer.com/content/pdf/10.1007%2F3-540-61053-7_66.pdf. + */ +class ChiInstruction extends Instruction { + ChiInstruction() { + opcode instanceof Opcode::Chi + } + + override final MemoryAccessKind getResultMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } + + /** + * Gets the operand that represents the previous state of all memory that might be aliased by the + * memory write. + */ + final Instruction getTotalOperand() { + result = getAnOperand().(ChiTotalOperand).getDefinitionInstruction() + } + + /** + * Gets the operand that represents the new value written by the memory write. + */ + final Instruction getPartialOperand() { + result = getAnOperand().(ChiPartialOperand).getDefinitionInstruction() + } +} + /** * An instruction representing a built-in operation. This is used to represent * operations such as access to variable argument lists. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Operand.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Operand.qll index 4cc82d0906c..6fc6af477fa 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Operand.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/Operand.qll @@ -306,6 +306,38 @@ class PositionalArgumentOperand extends ArgumentOperand { } } +class SideEffectOperand extends NonPhiOperand { + SideEffectOperand() { + this = TNonPhiOperand(_, sideEffectOperand(), _) + } + + override MemoryAccessKind getMemoryAccess() { + instr instanceof CallSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof CallReadSideEffectInstruction and + result instanceof EscapedMemoryAccess + or + instr instanceof IndirectReadSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferReadSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectWriteSideEffectInstruction and + result instanceof IndirectMemoryAccess + or + instr instanceof BufferWriteSideEffectInstruction and + result instanceof BufferMemoryAccess + or + instr instanceof IndirectMayWriteSideEffectInstruction and + result instanceof IndirectMayMemoryAccess + or + instr instanceof BufferMayWriteSideEffectInstruction and + result instanceof BufferMayMemoryAccess + } +} + /** * An operand of a `PhiInstruction`. */ @@ -358,3 +390,38 @@ class MemoryOperand extends Operand { exists(getMemoryAccess()) } } + +/** + * The total operand of a Chi node, representing the previous value of the memory. + */ +class ChiTotalOperand extends Operand { + ChiTotalOperand() { + this = TNonPhiOperand(_, chiTotalOperand(), _) + } + + override string toString() { + result = "ChiTotal" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiTotalMemoryAccess + } +} + + +/** + * The partial operand of a Chi node, representing the value being written to part of the memory. + */ +class ChiPartialOperand extends Operand { + ChiPartialOperand() { + this = TNonPhiOperand(_, chiPartialOperand(), _) + } + + override string toString() { + result = "ChiPartial" + } + + override final MemoryAccessKind getMemoryAccess() { + result instanceof ChiPartialMemoryAccess + } +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/IRBlockConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/IRBlockConstruction.qll deleted file mode 100644 index 3d670b225da..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/IRBlockConstruction.qll +++ /dev/null @@ -1,38 +0,0 @@ -import SSAConstructionInternal -private import SSAConstruction as Construction -private import NewIR - -import Cached -private cached module Cached { - cached newtype TIRBlock = MkIRBlock(OldIR::IRBlock oldBlock) - - private OldIR::IRBlock getOldBlock(TIRBlock block) { - block = MkIRBlock(result) - } - - cached Instruction getInstruction(TIRBlock block, int index) { - Construction::getOldInstruction(result) = - getOldBlock(block).getInstruction(index) - } - - cached int getInstructionCount(TIRBlock block) { - result = getOldBlock(block).getInstructionCount() - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ, EdgeKind kind) { - succ = MkIRBlock(getOldBlock(pred).getSuccessor(kind)) - } - - cached predicate blockSuccessor(TIRBlock pred, TIRBlock succ) { - blockSuccessor(pred, succ, _) - } - - cached predicate blockImmediatelyDominates(TIRBlock dominator, TIRBlock block) { - getOldBlock(dominator).immediatelyDominates(getOldBlock(block)) - } - - cached Instruction getFirstInstruction(TIRBlock block) { - Construction::getOldInstruction(result) = - getOldBlock(block).getFirstInstruction() - } -} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SSAConstruction.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SSAConstruction.qll index 5dbf34cb6c3..76899995426 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SSAConstruction.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SSAConstruction.qll @@ -3,7 +3,6 @@ import cpp private import semmle.code.cpp.ir.implementation.Opcode private import semmle.code.cpp.ir.internal.OperandTag private import NewIR -import IRBlockConstruction as BlockConstruction import Cached cached private module Cached { @@ -18,6 +17,10 @@ cached private module Cached { } or PhiTag(Alias::VirtualVariable vvar, OldIR::IRBlock block) { hasPhiNode(vvar, block) + } or + ChiTag(OldIR::Instruction oldInstruction) { + not oldInstruction instanceof OldIR::PhiInstruction and + hasChiNode(_, oldInstruction) } cached class InstructionTagType extends TInstructionTag { @@ -40,12 +43,28 @@ cached private module Cached { getOldInstruction(result) = instr } + /** + * Gets the chi node corresponding to `instr` if one is present, or the new `Instruction` + * corresponding to `instr` if there is no `Chi` node. + */ + private Instruction getNewFinalInstruction(OldIR::Instruction instr) { + result = getChiInstruction(instr) + or + not exists(getChiInstruction(instr)) and + result = getNewInstruction(instr) + } + private PhiInstruction getPhiInstruction(Function func, OldIR::IRBlock oldBlock, Alias::VirtualVariable vvar) { result.getFunction() = func and result.getAST() = oldBlock.getFirstInstruction().getAST() and result.getTag() = PhiTag(vvar, oldBlock) } + + private ChiInstruction getChiInstruction (OldIR::Instruction instr) { + hasChiNode(_, instr) and + result.getTag() = ChiTag(instr) + } private IRVariable getNewIRVariable(OldIR::IRVariable var) { result.getFunction() = var.getFunction() and @@ -92,6 +111,15 @@ cached private module Cached { tag = PhiTag(vvar, block) and resultType = vvar.getType() and isGLValue = false + ) or + exists(OldIR::Instruction instr, Alias::VirtualVariable vvar | + hasChiNode(vvar, instr) and + instr.getFunction() = func and + opcode instanceof Opcode::Chi and + ast = instr.getAST() and + tag = ChiTag(instr) and + resultType = vvar.getType() and + isGLValue = false ) } @@ -125,11 +153,11 @@ cached private module Cached { hasUseAtRank(vvar, useBlock, useRank, oldInstruction) and definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and if defIndex >= 0 then - result = getNewInstruction(defBlock.getInstruction(defIndex)) + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) else - result = getPhiInstruction(instruction.getFunction(), defBlock, vvar) + result = getPhiInstruction(instruction.getFunction(), defBlock, vvar) ) - ) + ) else ( result = instruction.getFunctionIR().getUnmodeledDefinitionInstruction() ) @@ -146,7 +174,17 @@ cached private module Cached { ) else result = getNewInstruction(oldOperand.getDefinitionInstruction()) - ) + ) or + instruction.getTag() = ChiTag(getOldInstruction(result)) and + tag instanceof ChiPartialOperandTag + or + instruction instanceof UnmodeledUseInstruction and + tag instanceof UnmodeledUseOperandTag and + result instanceof UnmodeledDefinitionInstruction and + instruction.getFunction() = result.getFunction() + or + tag instanceof ChiTotalOperandTag and + result = getChiInstructionTotalOperand(instruction) } cached Instruction getPhiInstructionOperandDefinition(PhiInstruction instr, @@ -160,12 +198,27 @@ cached private module Cached { hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and definitionReachesEndOfBlock(vvar, defBlock, defRank, predBlock) and if defIndex >= 0 then - result = getNewInstruction(defBlock.getInstruction(defIndex)) + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) else result = getPhiInstruction(instr.getFunction(), defBlock, vvar) ) } + cached Instruction getChiInstructionTotalOperand(ChiInstruction chiInstr) { + exists(Alias::VirtualVariable vvar, OldIR::Instruction oldInstr, OldIR::IRBlock defBlock, + int defRank, int defIndex, OldIR::IRBlock useBlock, int useRank | + ChiTag(oldInstr) = chiInstr.getTag() and + vvar = Alias::getResultMemoryAccess(oldInstr).getVirtualVariable() and + hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and + hasUseAtRank(vvar, useBlock, useRank, oldInstr) and + definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and + if defIndex >= 0 then + result = getNewFinalInstruction(defBlock.getInstruction(defIndex)) + else + result = getPhiInstruction(chiInstr.getFunction(), defBlock, vvar) + ) + } + cached Instruction getPhiInstructionBlockStart(PhiInstruction instr) { exists(OldIR::IRBlock oldBlock | instr.getTag() = PhiTag(_, oldBlock) and @@ -181,8 +234,24 @@ cached private module Cached { result = getOldInstruction(instruction).getUnconvertedResultExpression() } + /* + * This adds Chi nodes to the instruction successor relation; if an instruction has a Chi node, + * that node is its successor in the new successor relation, and the Chi node's successors are + * the new instructions generated from the successors of the old instruction + */ cached Instruction getInstructionSuccessor(Instruction instruction, EdgeKind kind) { - result = getNewInstruction(getOldInstruction(instruction).getSuccessor(kind)) + if(hasChiNode(_, getOldInstruction(instruction))) + then + result = getChiInstruction(getOldInstruction(instruction)) and + kind instanceof GotoEdge + else ( + result = getNewInstruction(getOldInstruction(instruction).getSuccessor(kind)) + or + exists(OldIR::Instruction oldInstruction | + instruction = getChiInstruction(oldInstruction) and + result = getNewInstruction(oldInstruction.getSuccessor(kind)) + ) + ) } cached IRVariable getInstructionVariable(Instruction instruction) { @@ -228,6 +297,18 @@ cached private module Cached { ) } + cached Instruction getPrimaryInstructionForSideEffect(Instruction instruction) { + exists(OldIR::SideEffectInstruction oldInstruction | + oldInstruction = getOldInstruction(instruction) and + result = getNewInstruction(oldInstruction.getPrimaryInstruction()) + ) + or + exists(OldIR::Instruction oldInstruction | + instruction.getTag() = ChiTag(oldInstruction) and + result = getNewInstruction(oldInstruction) + ) + } + private predicate ssa_variableUpdate(Alias::VirtualVariable vvar, OldIR::Instruction instr, OldIR::IRBlock block, int index) { block.getInstruction(index) = instr and @@ -253,7 +334,16 @@ cached private module Cached { private predicate hasUse(Alias::VirtualVariable vvar, OldIR::Instruction use, OldIR::IRBlock block, int index) { exists(Alias::MemoryAccess access | - access = Alias::getOperandMemoryAccess(use.getAnOperand()) and + ( + access = Alias::getOperandMemoryAccess(use.getAnOperand()) + or + /* + * a partial write to a virtual variable is going to generate a use of that variable when + * Chi nodes are inserted, so we need to mark it as a use in the old IR + */ + access = Alias::getResultMemoryAccess(use) and + access.isPartialMemoryAccess() + ) and block.getInstruction(index) = use and vvar = access.getVirtualVariable() ) @@ -384,6 +474,15 @@ cached private module Cached { hasFrontierPhiNode(vvar, phiBlock) //or ssa_sanitized_custom_phi_node(vvar, block) } + + private predicate hasChiNode(Alias::VirtualVariable vvar, + OldIR::Instruction def) { + exists(Alias::MemoryAccess ma | + ma = Alias::getResultMemoryAccess(def) and + ma.isPartialMemoryAccess() and + ma.getVirtualVariable() = vvar + ) + } } import CachedForDebugging 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 fdf596267a9..379e27dd891 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,7 +1,6 @@ -import SimpleSSAInternal +import AliasAnalysis import cpp -import Alias -private import InputIR +private import semmle.code.cpp.ir.implementation.raw.IR private import semmle.code.cpp.ir.internal.OperandTag private import semmle.code.cpp.ir.internal.Overlap @@ -60,11 +59,17 @@ class MemoryAccess extends TMemoryAccess { VirtualVariable getVirtualVariable() { result = vvar } + + predicate isPartialMemoryAccess() { + none() + } } Overlap getOverlap(MemoryAccess def, MemoryAccess use) { def.getVirtualVariable() = use.getVirtualVariable() and result instanceof MustExactlyOverlap + or + none() // Avoid compiler error in SSAConstruction } MemoryAccess getResultMemoryAccess(Instruction instr) { diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAInternal.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAInternal.qll deleted file mode 100644 index fd62cce7aa2..00000000000 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSAInternal.qll +++ /dev/null @@ -1,2 +0,0 @@ -import AliasAnalysis as Alias -import semmle.code.cpp.ir.implementation.raw.IR as InputIR diff --git a/cpp/ql/src/semmle/code/cpp/ir/internal/OperandTag.qll b/cpp/ql/src/semmle/code/cpp/ir/internal/OperandTag.qll index a8063aaaf9d..6ddef2fb4cc 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/internal/OperandTag.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/internal/OperandTag.qll @@ -10,6 +10,8 @@ private int getMaxCallArgIndex() { private newtype TOperandTag = TAddressOperand() or + TBufferSizeOperand() or + TSideEffectOperand() or TCopySourceOperand() or TUnaryOperand() or TLeftOperand() or @@ -25,7 +27,9 @@ private newtype TOperandTag = exists(BuiltInOperation op | exists(op.getChild(argIndex)) ) - } + } or + TChiTotalOperand() or + TChiPartialOperand() /** * Identifies the kind of operand on an instruction. Each `Instruction` has at @@ -47,7 +51,7 @@ abstract class OperandTag extends TOperandTag { /** * The address operand of an instruction that loads or stores a value from - * memory (e.g. `Load`, `Store`). + * memory (e.g. `Load`, `Store`, `InitializeParameter`, `IndirectReadSideEffect`). */ class AddressOperandTag extends OperandTag, TAddressOperand { override final string toString() { @@ -63,6 +67,37 @@ AddressOperandTag addressOperand() { result = TAddressOperand() } +/** + * The buffer size operand of an instruction that represents a read or write of + * a buffer. + */ +class BufferSizeOperand extends OperandTag, TBufferSizeOperand { + override final string toString() { + result = "BufferSize" + } + + override final int getSortOrder() { + result = 1 + } +} + +/** + * The operand representing the read side effect of a `SideEffectInstruction`. + */ +class SideEffectOperandTag extends OperandTag, TSideEffectOperand { + override final string toString() { + result = "SideEffect" + } + + override final int getSortOrder() { + result = 2 + } +} + +SideEffectOperandTag sideEffectOperand() { + result = TSideEffectOperand() +} + /** * The source value operand of an instruction that copies this value to its * result (e.g. `Copy`, `Load`, `Store`). @@ -73,7 +108,7 @@ class CopySourceOperandTag extends OperandTag, TCopySourceOperand { } override final int getSortOrder() { - result = 1 + result = 3 } } @@ -90,7 +125,7 @@ class UnaryOperandTag extends OperandTag, TUnaryOperand { } override final int getSortOrder() { - result = 2 + result = 4 } } @@ -107,7 +142,7 @@ class LeftOperandTag extends OperandTag, TLeftOperand { } override final int getSortOrder() { - result = 3 + result = 5 } } @@ -124,7 +159,7 @@ class RightOperandTag extends OperandTag, TRightOperand { } override final int getSortOrder() { - result = 4 + result = 6 } } @@ -141,7 +176,7 @@ class ReturnValueOperandTag extends OperandTag, TReturnValueOperand { } override final int getSortOrder() { - result = 5 + result = 7 } } @@ -158,7 +193,7 @@ class ExceptionOperandTag extends OperandTag, TExceptionOperand { } override final int getSortOrder() { - result = 6 + result = 8 } } @@ -175,7 +210,7 @@ class ConditionOperandTag extends OperandTag, TConditionOperand { } override final int getSortOrder() { - result = 7 + result = 9 } } @@ -193,7 +228,7 @@ class UnmodeledUseOperandTag extends OperandTag, TUnmodeledUseOperand { } override final int getSortOrder() { - result = 8 + result = 10 } } @@ -210,7 +245,7 @@ class CallTargetOperandTag extends OperandTag, TCallTargetOperand { } override final int getSortOrder() { - result = 9 + result = 11 } } @@ -240,7 +275,7 @@ class ThisArgumentOperandTag extends ArgumentOperandTag, TThisArgumentOperand { } override final int getSortOrder() { - result = 10 + result = 12 } override final string getLabel() { @@ -268,7 +303,7 @@ class PositionalArgumentOperandTag extends ArgumentOperandTag, } override final int getSortOrder() { - result = 11 + argIndex + result = 14 + argIndex } final int getArgIndex() { @@ -279,3 +314,31 @@ class PositionalArgumentOperandTag extends ArgumentOperandTag, PositionalArgumentOperandTag positionalArgumentOperand(int argIndex) { result = TPositionalArgumentOperand(argIndex) } + +class ChiTotalOperandTag extends OperandTag, TChiTotalOperand { + override final string toString() { + result = "ChiTotal" + } + + override final int getSortOrder() { + result = 14 + } +} + +ChiTotalOperandTag chiTotalOperand() { + result = TChiTotalOperand() +} + +class ChiPartialOperandTag extends OperandTag, TChiPartialOperand { + override final string toString() { + result = "ChiPartial" + } + + override final int getSortOrder() { + result = 15 + } +} + +ChiPartialOperandTag chiPartialOperand() { + result = TChiPartialOperand() +} diff --git a/cpp/ql/src/semmle/code/cpp/rangeanalysis/SignAnalysis.qll b/cpp/ql/src/semmle/code/cpp/rangeanalysis/SignAnalysis.qll index 5e38b45602c..e70208e079f 100644 --- a/cpp/ql/src/semmle/code/cpp/rangeanalysis/SignAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/rangeanalysis/SignAnalysis.qll @@ -193,6 +193,13 @@ private Sign castSign(Sign s, boolean fromSigned, boolean toSigned, CastKind ck) /** Holds if the sign of `e` is too complicated to determine. */ private predicate unknownSign(Instruction i) { + // REVIEW: This should probably be a list of the instructions that we _do_ understand, rather than + // the ones we don't understand. Currently, if we try to compute the sign of an instruction that + // we don't understand, and it isn't on this list, we incorrectly compute the sign as "none" + // instead of "+,0,-". + // Even better, we could track the state of each instruction as a power set of {non-negative, + // non-positive, non-zero}, which would mean that the representation of the sign of an unknown + // value would be the empty set. ( i instanceof UnmodeledDefinitionInstruction or @@ -203,6 +210,8 @@ private predicate unknownSign(Instruction i) { i instanceof BuiltInInstruction or i instanceof CallInstruction + or + i instanceof ChiInstruction ) } diff --git a/cpp/ql/test/library-tests/ir/ir/PrintAST.expected b/cpp/ql/test/library-tests/ir/ir/PrintAST.expected index b01c82d135d..915145d77ee 100644 --- a/cpp/ql/test/library-tests/ir/ir/PrintAST.expected +++ b/cpp/ql/test/library-tests/ir/ir/PrintAST.expected @@ -3325,10 +3325,10 @@ ir.cpp: # 504| expr: {...} # 504| Type = Point # 504| ValueCategory = prvalue -# 504| 0: x +# 504| .x: x # 504| Type = int # 504| ValueCategory = prvalue(load) -# 504| 1: (int)... +# 504| .y: (int)... # 504| Conversion = floating point to integral conversion # 504| Type = int # 504| ValueCategory = prvalue @@ -3342,7 +3342,7 @@ ir.cpp: # 505| expr: {...} # 505| Type = Point # 505| ValueCategory = prvalue -# 505| 0: x +# 505| .x: x # 505| Type = int # 505| ValueCategory = prvalue(load) # 506| 2: declaration @@ -3390,13 +3390,13 @@ ir.cpp: # 514| expr: {...} # 514| Type = Rect # 514| ValueCategory = prvalue -# 514| 0: {...} +# 514| .topLeft: {...} # 514| Type = Point # 514| ValueCategory = prvalue -# 514| 0: x +# 514| .x: x # 514| Type = int # 514| ValueCategory = prvalue(load) -# 514| 1: (int)... +# 514| .y: (int)... # 514| Conversion = floating point to integral conversion # 514| Type = int # 514| ValueCategory = prvalue @@ -3410,26 +3410,26 @@ ir.cpp: # 515| expr: {...} # 515| Type = Rect # 515| ValueCategory = prvalue -# 515| 0: {...} +# 515| .topLeft: {...} # 515| Type = Point # 515| ValueCategory = prvalue -# 515| 0: x +# 515| .x: x # 515| Type = int # 515| ValueCategory = prvalue(load) -# 515| 1: (int)... +# 515| .y: (int)... # 515| Conversion = floating point to integral conversion # 515| Type = int # 515| ValueCategory = prvalue # 515| expr: f # 515| Type = float # 515| ValueCategory = prvalue(load) -# 515| 1: {...} +# 515| .bottomRight: {...} # 515| Type = Point # 515| ValueCategory = prvalue -# 515| 0: x +# 515| .x: x # 515| Type = int # 515| ValueCategory = prvalue(load) -# 515| 1: (int)... +# 515| .y: (int)... # 515| Conversion = floating point to integral conversion # 515| Type = int # 515| ValueCategory = prvalue @@ -3443,16 +3443,16 @@ ir.cpp: # 516| expr: {...} # 516| Type = Rect # 516| ValueCategory = prvalue -# 516| 0: {...} +# 516| .topLeft: {...} # 516| Type = Point # 516| ValueCategory = prvalue -# 516| 0: x +# 516| .x: x # 516| Type = int # 516| ValueCategory = prvalue(load) -# 516| 1: {...} +# 516| .bottomRight: {...} # 516| Type = Point # 516| ValueCategory = prvalue -# 516| 0: x +# 516| .x: x # 516| Type = int # 516| ValueCategory = prvalue(load) # 517| 4: return ... @@ -3477,17 +3477,17 @@ ir.cpp: # 521| expr: {...} # 521| Type = int[3] # 521| ValueCategory = prvalue -# 521| 0: x +# 521| [0]: x # 521| Type = int # 521| ValueCategory = prvalue(load) -# 521| 1: (int)... +# 521| [1]: (int)... # 521| Conversion = floating point to integral conversion # 521| Type = int # 521| ValueCategory = prvalue # 521| expr: f # 521| Type = float # 521| ValueCategory = prvalue(load) -# 521| 2: 0 +# 521| [2]: 0 # 521| Type = int # 521| Value = 0 # 521| ValueCategory = prvalue @@ -3498,7 +3498,7 @@ ir.cpp: # 522| expr: {...} # 522| Type = int[3] # 522| ValueCategory = prvalue -# 522| 0: x +# 522| [0]: x # 522| Type = int # 522| ValueCategory = prvalue(load) # 523| 3: return ... @@ -3524,7 +3524,7 @@ ir.cpp: # 531| expr: {...} # 531| Type = U # 531| ValueCategory = prvalue -# 531| 0: (double)... +# 531| .d: (double)... # 531| Conversion = floating point conversion # 531| Type = double # 531| ValueCategory = prvalue @@ -3708,7 +3708,7 @@ ir.cpp: # 577| expr: {...} # 577| Type = char[2] # 577| ValueCategory = prvalue -# 577| 0: (char)... +# 577| [0]: (char)... # 577| Conversion = integral conversion # 577| Type = char # 577| Value = 0 @@ -3724,7 +3724,7 @@ ir.cpp: # 578| expr: {...} # 578| Type = char[2] # 578| ValueCategory = prvalue -# 578| 0: (char)... +# 578| [0]: (char)... # 578| Conversion = integral conversion # 578| Type = char # 578| Value = 0 @@ -3733,7 +3733,7 @@ ir.cpp: # 578| Type = int # 578| Value = 0 # 578| ValueCategory = prvalue -# 578| 1: (char)... +# 578| [1]: (char)... # 578| Conversion = integral conversion # 578| Type = char # 578| Value = 1 @@ -3749,7 +3749,7 @@ ir.cpp: # 579| expr: {...} # 579| Type = char[3] # 579| ValueCategory = prvalue -# 579| 0: (char)... +# 579| [0]: (char)... # 579| Conversion = integral conversion # 579| Type = char # 579| Value = 0 @@ -6372,7 +6372,7 @@ ir.cpp: # 954| 1: {...} # 954| Type = String[] # 954| ValueCategory = prvalue -# 954| 0: call to String +# 954| [0]: call to String # 954| Type = void # 954| ValueCategory = prvalue # 954| 2: n @@ -6414,7 +6414,7 @@ ir.cpp: # 957| 1: {...} # 957| Type = DefaultCtorWithDefaultParam[] # 957| ValueCategory = prvalue -# 957| 0: call to DefaultCtorWithDefaultParam +# 957| [0]: call to DefaultCtorWithDefaultParam # 957| Type = void # 957| ValueCategory = prvalue # 957| 2: n @@ -6427,15 +6427,15 @@ ir.cpp: # 958| 1: {...} # 958| Type = int[3] # 958| ValueCategory = prvalue -# 958| 0: 0 +# 958| [0]: 0 # 958| Type = int # 958| Value = 0 # 958| ValueCategory = prvalue -# 958| 1: 1 +# 958| [1]: 1 # 958| Type = int # 958| Value = 1 # 958| ValueCategory = prvalue -# 958| 2: 2 +# 958| [2]: 2 # 958| Type = int # 958| Value = 2 # 958| ValueCategory = prvalue @@ -6453,11 +6453,11 @@ ir.cpp: # 962| expr: {...} # 962| Type = int[1000] # 962| ValueCategory = prvalue -# 962| 0: 10002 +# 962| [2]: 10002 # 962| Type = int # 962| Value = 10002 # 962| ValueCategory = prvalue -# 962| 1: 10900 +# 962| [900]: 10900 # 962| Type = int # 962| Value = 10900 # 962| ValueCategory = prvalue @@ -6591,3 +6591,80 @@ ir.cpp: # 983| ValueCategory = prvalue(load) # 983| 1: { ... } # 985| 3: return ... +# 1005| ChiPhiNode(Point *, bool, bool) -> int +# 1005| params: +# 1005| 0: p +# 1005| Type = Point * +# 1005| 1: which1 +# 1005| Type = bool +# 1005| 2: which2 +# 1005| Type = bool +# 1005| body: { ... } +# 1006| 0: if (...) ... +# 1006| 0: which1 +# 1006| Type = bool +# 1006| ValueCategory = prvalue(load) +# 1006| 1: { ... } +# 1007| 0: ExprStmt +# 1007| 0: ... ++ +# 1007| Type = int +# 1007| ValueCategory = prvalue +# 1007| 0: x +# 1007| Type = int +# 1007| ValueCategory = lvalue +# 1007| -1: p +# 1007| Type = Point * +# 1007| ValueCategory = prvalue(load) +# 1008| 2: { ... } +# 1009| 0: ExprStmt +# 1009| 0: ... ++ +# 1009| Type = int +# 1009| ValueCategory = prvalue +# 1009| 0: y +# 1009| Type = int +# 1009| ValueCategory = lvalue +# 1009| -1: p +# 1009| Type = Point * +# 1009| ValueCategory = prvalue(load) +# 1012| 1: if (...) ... +# 1012| 0: which2 +# 1012| Type = bool +# 1012| ValueCategory = prvalue(load) +# 1012| 1: { ... } +# 1013| 0: ExprStmt +# 1013| 0: ... ++ +# 1013| Type = int +# 1013| ValueCategory = prvalue +# 1013| 0: x +# 1013| Type = int +# 1013| ValueCategory = lvalue +# 1013| -1: p +# 1013| Type = Point * +# 1013| ValueCategory = prvalue(load) +# 1014| 2: { ... } +# 1015| 0: ExprStmt +# 1015| 0: ... ++ +# 1015| Type = int +# 1015| ValueCategory = prvalue +# 1015| 0: y +# 1015| Type = int +# 1015| ValueCategory = lvalue +# 1015| -1: p +# 1015| Type = Point * +# 1015| ValueCategory = prvalue(load) +# 1018| 2: return ... +# 1018| 0: ... + ... +# 1018| Type = int +# 1018| ValueCategory = prvalue +# 1018| 0: x +# 1018| Type = int +# 1018| ValueCategory = prvalue(load) +# 1018| -1: p +# 1018| Type = Point * +# 1018| ValueCategory = prvalue(load) +# 1018| 1: y +# 1018| Type = int +# 1018| ValueCategory = prvalue(load) +# 1018| -1: p +# 1018| Type = Point * +# 1018| ValueCategory = prvalue(load) diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected index ab7f7ae43cb..2eb23da7a69 100644 --- a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected @@ -2,1046 +2,1073 @@ bad_asts.cpp: # 14| Bad::CallBadMemberFunction() -> void # 14| Block 0 # 14| v0_0(void) = EnterFunction : -# 14| mu0_1(unknown) = UnmodeledDefinition : -# 15| r0_2(glval) = VariableAddress[s] : -# 15| mu0_3(S) = Uninitialized : r0_2 -# 15| r0_4(glval) = FieldAddress[x] : r0_2 -# 15| r0_5(int) = Constant[0] : -# 15| mu0_6(int) = Store : r0_4, r0_5 -# 16| r0_7(glval) = VariableAddress[s] : -# 16| r0_8(glval) = FunctionAddress[MemberFunction] : -# 16| r0_9(int) = Constant[1] : -# 16| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -# 17| v0_11(void) = NoOp : -# 14| v0_12(void) = ReturnVoid : -# 14| v0_13(void) = UnmodeledUse : mu* -# 14| v0_14(void) = ExitFunction : +# 14| m0_1(unknown) = AliasedDefinition : +# 14| mu0_2(unknown) = UnmodeledDefinition : +# 15| r0_3(glval) = VariableAddress[s] : +# 15| mu0_4(S) = Uninitialized : 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 : r0_9, this:r0_8, r0_10 +# 16| m0_12(unknown) = ^CallSideEffect : m0_1 +# 16| m0_13(unknown) = Chi : m0_1, m0_12 +# 17| v0_14(void) = NoOp : +# 14| v0_15(void) = ReturnVoid : +# 14| v0_16(void) = UnmodeledUse : mu* +# 14| v0_17(void) = ExitFunction : # 22| Bad::Point::Point() -> void # 22| Block 0 # 22| v0_0(void) = EnterFunction : -# 22| mu0_1(unknown) = UnmodeledDefinition : -# 22| r0_2(glval) = InitializeThis : -# 23| v0_3(void) = NoOp : -# 22| v0_4(void) = ReturnVoid : -# 22| v0_5(void) = UnmodeledUse : mu* -# 22| v0_6(void) = ExitFunction : +# 22| m0_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) = ExitFunction : # 26| Bad::CallCopyConstructor(const Point &) -> void # 26| Block 0 # 26| v0_0(void) = EnterFunction : -# 26| mu0_1(unknown) = UnmodeledDefinition : -# 26| r0_2(glval) = VariableAddress[a] : -# 26| m0_3(Point &) = InitializeParameter[a] : r0_2 -# 27| r0_4(glval) = VariableAddress[b] : -# 27| r0_5(glval) = VariableAddress[a] : -# 27| r0_6(Point &) = Load : r0_5, m0_3 -# 27| r0_7(glval) = Convert : r0_6 -# 27| r0_8(Point) = Load : r0_7, mu0_1 -# 27| m0_9(Point) = Store : r0_4, r0_8 -# 28| v0_10(void) = NoOp : -# 26| v0_11(void) = ReturnVoid : -# 26| v0_12(void) = UnmodeledUse : mu* -# 26| v0_13(void) = ExitFunction : +# 26| m0_1(unknown) = AliasedDefinition : +# 26| mu0_2(unknown) = UnmodeledDefinition : +# 26| r0_3(glval) = VariableAddress[a] : +# 26| m0_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, m0_4 +# 27| r0_8(glval) = Convert : r0_7 +# 27| r0_9(Point) = Load : r0_8, m0_1 +# 27| m0_10(Point) = Store : r0_5, r0_9 +# 28| v0_11(void) = NoOp : +# 26| v0_12(void) = ReturnVoid : +# 26| v0_13(void) = UnmodeledUse : mu* +# 26| v0_14(void) = ExitFunction : ir.cpp: # 1| Constants() -> void # 1| Block 0 # 1| v0_0(void) = EnterFunction : -# 1| mu0_1(unknown) = UnmodeledDefinition : -# 2| r0_2(glval) = VariableAddress[c_i] : -# 2| r0_3(char) = Constant[1] : -# 2| m0_4(char) = Store : r0_2, r0_3 -# 3| r0_5(glval) = VariableAddress[c_c] : -# 3| r0_6(char) = Constant[65] : -# 3| m0_7(char) = Store : r0_5, r0_6 -# 5| r0_8(glval) = VariableAddress[sc_i] : -# 5| r0_9(signed char) = Constant[-1] : -# 5| m0_10(signed char) = Store : r0_8, r0_9 -# 6| r0_11(glval) = VariableAddress[sc_c] : -# 6| r0_12(signed char) = Constant[65] : -# 6| m0_13(signed char) = Store : r0_11, r0_12 -# 8| r0_14(glval) = VariableAddress[uc_i] : -# 8| r0_15(unsigned char) = Constant[5] : -# 8| m0_16(unsigned char) = Store : r0_14, r0_15 -# 9| r0_17(glval) = VariableAddress[uc_c] : -# 9| r0_18(unsigned char) = Constant[65] : -# 9| m0_19(unsigned char) = Store : r0_17, r0_18 -# 11| r0_20(glval) = VariableAddress[s] : -# 11| r0_21(short) = Constant[5] : -# 11| m0_22(short) = Store : r0_20, r0_21 -# 12| r0_23(glval) = VariableAddress[us] : -# 12| r0_24(unsigned short) = Constant[5] : -# 12| m0_25(unsigned short) = Store : r0_23, r0_24 -# 14| r0_26(glval) = VariableAddress[i] : -# 14| r0_27(int) = Constant[5] : -# 14| m0_28(int) = Store : r0_26, r0_27 -# 15| r0_29(glval) = VariableAddress[ui] : -# 15| r0_30(unsigned int) = Constant[5] : -# 15| m0_31(unsigned int) = Store : r0_29, r0_30 -# 17| r0_32(glval) = VariableAddress[l] : -# 17| r0_33(long) = Constant[5] : -# 17| m0_34(long) = Store : r0_32, r0_33 -# 18| r0_35(glval) = VariableAddress[ul] : -# 18| r0_36(unsigned long) = Constant[5] : -# 18| m0_37(unsigned long) = Store : r0_35, r0_36 -# 20| r0_38(glval) = VariableAddress[ll_i] : -# 20| r0_39(long long) = Constant[5] : -# 20| m0_40(long long) = Store : r0_38, r0_39 -# 21| r0_41(glval) = VariableAddress[ll_ll] : -# 21| r0_42(long long) = Constant[5] : -# 21| m0_43(long long) = Store : r0_41, r0_42 -# 22| r0_44(glval) = VariableAddress[ull_i] : -# 22| r0_45(unsigned long long) = Constant[5] : -# 22| m0_46(unsigned long long) = Store : r0_44, r0_45 -# 23| r0_47(glval) = VariableAddress[ull_ull] : -# 23| r0_48(unsigned long long) = Constant[5] : -# 23| m0_49(unsigned long long) = Store : r0_47, r0_48 -# 25| r0_50(glval) = VariableAddress[b_t] : -# 25| r0_51(bool) = Constant[1] : -# 25| m0_52(bool) = Store : r0_50, r0_51 -# 26| r0_53(glval) = VariableAddress[b_f] : -# 26| r0_54(bool) = Constant[0] : -# 26| m0_55(bool) = Store : r0_53, r0_54 -# 28| r0_56(glval) = VariableAddress[wc_i] : -# 28| r0_57(wchar_t) = Constant[5] : -# 28| m0_58(wchar_t) = Store : r0_56, r0_57 -# 29| r0_59(glval) = VariableAddress[wc_c] : -# 29| r0_60(wchar_t) = Constant[65] : -# 29| m0_61(wchar_t) = Store : r0_59, r0_60 -# 31| r0_62(glval) = VariableAddress[c16] : -# 31| r0_63(char16_t) = Constant[65] : -# 31| m0_64(char16_t) = Store : r0_62, r0_63 -# 32| r0_65(glval) = VariableAddress[c32] : -# 32| r0_66(char32_t) = Constant[65] : -# 32| m0_67(char32_t) = Store : r0_65, r0_66 -# 34| r0_68(glval) = VariableAddress[f_i] : -# 34| r0_69(float) = Constant[1.0] : -# 34| m0_70(float) = Store : r0_68, r0_69 -# 35| r0_71(glval) = VariableAddress[f_f] : -# 35| r0_72(float) = Constant[1.0] : -# 35| m0_73(float) = Store : r0_71, r0_72 -# 36| r0_74(glval) = VariableAddress[f_d] : -# 36| r0_75(float) = Constant[1.0] : -# 36| m0_76(float) = Store : r0_74, r0_75 -# 38| r0_77(glval) = VariableAddress[d_i] : -# 38| r0_78(double) = Constant[1.0] : -# 38| m0_79(double) = Store : r0_77, r0_78 -# 39| r0_80(glval) = VariableAddress[d_f] : -# 39| r0_81(double) = Constant[1.0] : -# 39| m0_82(double) = Store : r0_80, r0_81 -# 40| r0_83(glval) = VariableAddress[d_d] : -# 40| r0_84(double) = Constant[1.0] : -# 40| m0_85(double) = Store : r0_83, r0_84 -# 41| v0_86(void) = NoOp : -# 1| v0_87(void) = ReturnVoid : -# 1| v0_88(void) = UnmodeledUse : mu* -# 1| v0_89(void) = ExitFunction : +# 1| m0_1(unknown) = AliasedDefinition : +# 1| mu0_2(unknown) = UnmodeledDefinition : +# 2| r0_3(glval) = VariableAddress[c_i] : +# 2| r0_4(char) = Constant[1] : +# 2| m0_5(char) = Store : r0_3, r0_4 +# 3| r0_6(glval) = VariableAddress[c_c] : +# 3| r0_7(char) = Constant[65] : +# 3| m0_8(char) = Store : r0_6, r0_7 +# 5| r0_9(glval) = VariableAddress[sc_i] : +# 5| r0_10(signed char) = Constant[-1] : +# 5| m0_11(signed char) = Store : r0_9, r0_10 +# 6| r0_12(glval) = VariableAddress[sc_c] : +# 6| r0_13(signed char) = Constant[65] : +# 6| m0_14(signed char) = Store : r0_12, r0_13 +# 8| r0_15(glval) = VariableAddress[uc_i] : +# 8| r0_16(unsigned char) = Constant[5] : +# 8| m0_17(unsigned char) = Store : r0_15, r0_16 +# 9| r0_18(glval) = VariableAddress[uc_c] : +# 9| r0_19(unsigned char) = Constant[65] : +# 9| m0_20(unsigned char) = Store : r0_18, r0_19 +# 11| r0_21(glval) = VariableAddress[s] : +# 11| r0_22(short) = Constant[5] : +# 11| m0_23(short) = Store : r0_21, r0_22 +# 12| r0_24(glval) = VariableAddress[us] : +# 12| r0_25(unsigned short) = Constant[5] : +# 12| m0_26(unsigned short) = Store : r0_24, r0_25 +# 14| r0_27(glval) = VariableAddress[i] : +# 14| r0_28(int) = Constant[5] : +# 14| m0_29(int) = Store : r0_27, r0_28 +# 15| r0_30(glval) = VariableAddress[ui] : +# 15| r0_31(unsigned int) = Constant[5] : +# 15| m0_32(unsigned int) = Store : r0_30, r0_31 +# 17| r0_33(glval) = VariableAddress[l] : +# 17| r0_34(long) = Constant[5] : +# 17| m0_35(long) = Store : r0_33, r0_34 +# 18| r0_36(glval) = VariableAddress[ul] : +# 18| r0_37(unsigned long) = Constant[5] : +# 18| m0_38(unsigned long) = Store : r0_36, r0_37 +# 20| r0_39(glval) = VariableAddress[ll_i] : +# 20| r0_40(long long) = Constant[5] : +# 20| m0_41(long long) = Store : r0_39, r0_40 +# 21| r0_42(glval) = VariableAddress[ll_ll] : +# 21| r0_43(long long) = Constant[5] : +# 21| m0_44(long long) = Store : r0_42, r0_43 +# 22| r0_45(glval) = VariableAddress[ull_i] : +# 22| r0_46(unsigned long long) = Constant[5] : +# 22| m0_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| m0_50(unsigned long long) = Store : r0_48, r0_49 +# 25| r0_51(glval) = VariableAddress[b_t] : +# 25| r0_52(bool) = Constant[1] : +# 25| m0_53(bool) = Store : r0_51, r0_52 +# 26| r0_54(glval) = VariableAddress[b_f] : +# 26| r0_55(bool) = Constant[0] : +# 26| m0_56(bool) = Store : r0_54, r0_55 +# 28| r0_57(glval) = VariableAddress[wc_i] : +# 28| r0_58(wchar_t) = Constant[5] : +# 28| m0_59(wchar_t) = Store : r0_57, r0_58 +# 29| r0_60(glval) = VariableAddress[wc_c] : +# 29| r0_61(wchar_t) = Constant[65] : +# 29| m0_62(wchar_t) = Store : r0_60, r0_61 +# 31| r0_63(glval) = VariableAddress[c16] : +# 31| r0_64(char16_t) = Constant[65] : +# 31| m0_65(char16_t) = Store : r0_63, r0_64 +# 32| r0_66(glval) = VariableAddress[c32] : +# 32| r0_67(char32_t) = Constant[65] : +# 32| m0_68(char32_t) = Store : r0_66, r0_67 +# 34| r0_69(glval) = VariableAddress[f_i] : +# 34| r0_70(float) = Constant[1.0] : +# 34| m0_71(float) = Store : r0_69, r0_70 +# 35| r0_72(glval) = VariableAddress[f_f] : +# 35| r0_73(float) = Constant[1.0] : +# 35| m0_74(float) = Store : r0_72, r0_73 +# 36| r0_75(glval) = VariableAddress[f_d] : +# 36| r0_76(float) = Constant[1.0] : +# 36| m0_77(float) = Store : r0_75, r0_76 +# 38| r0_78(glval) = VariableAddress[d_i] : +# 38| r0_79(double) = Constant[1.0] : +# 38| m0_80(double) = Store : r0_78, r0_79 +# 39| r0_81(glval) = VariableAddress[d_f] : +# 39| r0_82(double) = Constant[1.0] : +# 39| m0_83(double) = Store : r0_81, r0_82 +# 40| r0_84(glval) = VariableAddress[d_d] : +# 40| r0_85(double) = Constant[1.0] : +# 40| m0_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) = ExitFunction : # 43| Foo() -> void # 43| Block 0 # 43| v0_0(void) = EnterFunction : -# 43| mu0_1(unknown) = UnmodeledDefinition : -# 44| r0_2(glval) = VariableAddress[x] : -# 44| r0_3(int) = Constant[17] : -# 44| m0_4(int) = Store : r0_2, r0_3 -# 45| r0_5(glval) = VariableAddress[y] : -# 45| r0_6(short) = Constant[7] : -# 45| m0_7(short) = Store : r0_5, r0_6 -# 46| r0_8(glval) = VariableAddress[x] : -# 46| r0_9(int) = Load : r0_8, m0_4 -# 46| r0_10(glval) = VariableAddress[y] : -# 46| r0_11(short) = Load : r0_10, m0_7 -# 46| r0_12(int) = Convert : r0_11 -# 46| r0_13(int) = Add : r0_9, r0_12 -# 46| r0_14(short) = Convert : r0_13 -# 46| r0_15(glval) = VariableAddress[y] : -# 46| m0_16(short) = Store : r0_15, r0_14 -# 47| r0_17(glval) = VariableAddress[x] : -# 47| r0_18(int) = Load : r0_17, m0_4 -# 47| r0_19(glval) = VariableAddress[y] : -# 47| r0_20(short) = Load : r0_19, m0_16 -# 47| r0_21(int) = Convert : r0_20 -# 47| r0_22(int) = Mul : r0_18, r0_21 -# 47| r0_23(glval) = VariableAddress[x] : -# 47| m0_24(int) = Store : r0_23, r0_22 -# 48| v0_25(void) = NoOp : -# 43| v0_26(void) = ReturnVoid : -# 43| v0_27(void) = UnmodeledUse : mu* -# 43| v0_28(void) = ExitFunction : +# 43| m0_1(unknown) = AliasedDefinition : +# 43| mu0_2(unknown) = UnmodeledDefinition : +# 44| r0_3(glval) = VariableAddress[x] : +# 44| r0_4(int) = Constant[17] : +# 44| m0_5(int) = Store : r0_3, r0_4 +# 45| r0_6(glval) = VariableAddress[y] : +# 45| r0_7(short) = Constant[7] : +# 45| m0_8(short) = Store : r0_6, r0_7 +# 46| r0_9(glval) = VariableAddress[x] : +# 46| r0_10(int) = Load : r0_9, m0_5 +# 46| r0_11(glval) = VariableAddress[y] : +# 46| r0_12(short) = Load : r0_11, m0_8 +# 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| m0_17(short) = Store : r0_16, r0_15 +# 47| r0_18(glval) = VariableAddress[x] : +# 47| r0_19(int) = Load : r0_18, m0_5 +# 47| r0_20(glval) = VariableAddress[y] : +# 47| r0_21(short) = Load : r0_20, m0_17 +# 47| r0_22(int) = Convert : r0_21 +# 47| r0_23(int) = Mul : r0_19, r0_22 +# 47| r0_24(glval) = VariableAddress[x] : +# 47| m0_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) = ExitFunction : # 50| IntegerOps(int, int) -> void # 50| Block 0 # 50| v0_0(void) = EnterFunction : -# 50| mu0_1(unknown) = UnmodeledDefinition : -# 50| r0_2(glval) = VariableAddress[x] : -# 50| m0_3(int) = InitializeParameter[x] : r0_2 -# 50| r0_4(glval) = VariableAddress[y] : -# 50| m0_5(int) = InitializeParameter[y] : r0_4 -# 51| r0_6(glval) = VariableAddress[z] : -# 51| m0_7(int) = Uninitialized : r0_6 -# 53| r0_8(glval) = VariableAddress[x] : -# 53| r0_9(int) = Load : r0_8, m0_3 -# 53| r0_10(glval) = VariableAddress[y] : -# 53| r0_11(int) = Load : r0_10, m0_5 -# 53| r0_12(int) = Add : r0_9, r0_11 -# 53| r0_13(glval) = VariableAddress[z] : -# 53| m0_14(int) = Store : r0_13, r0_12 -# 54| r0_15(glval) = VariableAddress[x] : -# 54| r0_16(int) = Load : r0_15, m0_3 -# 54| r0_17(glval) = VariableAddress[y] : -# 54| r0_18(int) = Load : r0_17, m0_5 -# 54| r0_19(int) = Sub : r0_16, r0_18 -# 54| r0_20(glval) = VariableAddress[z] : -# 54| m0_21(int) = Store : r0_20, r0_19 -# 55| r0_22(glval) = VariableAddress[x] : -# 55| r0_23(int) = Load : r0_22, m0_3 -# 55| r0_24(glval) = VariableAddress[y] : -# 55| r0_25(int) = Load : r0_24, m0_5 -# 55| r0_26(int) = Mul : r0_23, r0_25 -# 55| r0_27(glval) = VariableAddress[z] : -# 55| m0_28(int) = Store : r0_27, r0_26 -# 56| r0_29(glval) = VariableAddress[x] : -# 56| r0_30(int) = Load : r0_29, m0_3 -# 56| r0_31(glval) = VariableAddress[y] : -# 56| r0_32(int) = Load : r0_31, m0_5 -# 56| r0_33(int) = Div : r0_30, r0_32 -# 56| r0_34(glval) = VariableAddress[z] : -# 56| m0_35(int) = Store : r0_34, r0_33 -# 57| r0_36(glval) = VariableAddress[x] : -# 57| r0_37(int) = Load : r0_36, m0_3 -# 57| r0_38(glval) = VariableAddress[y] : -# 57| r0_39(int) = Load : r0_38, m0_5 -# 57| r0_40(int) = Rem : r0_37, r0_39 -# 57| r0_41(glval) = VariableAddress[z] : -# 57| m0_42(int) = Store : r0_41, r0_40 -# 59| r0_43(glval) = VariableAddress[x] : -# 59| r0_44(int) = Load : r0_43, m0_3 -# 59| r0_45(glval) = VariableAddress[y] : -# 59| r0_46(int) = Load : r0_45, m0_5 -# 59| r0_47(int) = BitAnd : r0_44, r0_46 -# 59| r0_48(glval) = VariableAddress[z] : -# 59| m0_49(int) = Store : r0_48, r0_47 -# 60| r0_50(glval) = VariableAddress[x] : -# 60| r0_51(int) = Load : r0_50, m0_3 -# 60| r0_52(glval) = VariableAddress[y] : -# 60| r0_53(int) = Load : r0_52, m0_5 -# 60| r0_54(int) = BitOr : r0_51, r0_53 -# 60| r0_55(glval) = VariableAddress[z] : -# 60| m0_56(int) = Store : r0_55, r0_54 -# 61| r0_57(glval) = VariableAddress[x] : -# 61| r0_58(int) = Load : r0_57, m0_3 -# 61| r0_59(glval) = VariableAddress[y] : -# 61| r0_60(int) = Load : r0_59, m0_5 -# 61| r0_61(int) = BitXor : r0_58, r0_60 -# 61| r0_62(glval) = VariableAddress[z] : -# 61| m0_63(int) = Store : r0_62, r0_61 -# 63| r0_64(glval) = VariableAddress[x] : -# 63| r0_65(int) = Load : r0_64, m0_3 -# 63| r0_66(glval) = VariableAddress[y] : -# 63| r0_67(int) = Load : r0_66, m0_5 -# 63| r0_68(int) = ShiftLeft : r0_65, r0_67 -# 63| r0_69(glval) = VariableAddress[z] : -# 63| m0_70(int) = Store : r0_69, r0_68 -# 64| r0_71(glval) = VariableAddress[x] : -# 64| r0_72(int) = Load : r0_71, m0_3 -# 64| r0_73(glval) = VariableAddress[y] : -# 64| r0_74(int) = Load : r0_73, m0_5 -# 64| r0_75(int) = ShiftRight : r0_72, r0_74 -# 64| r0_76(glval) = VariableAddress[z] : -# 64| m0_77(int) = Store : r0_76, r0_75 -# 66| r0_78(glval) = VariableAddress[x] : -# 66| r0_79(int) = Load : r0_78, m0_3 -# 66| r0_80(glval) = VariableAddress[z] : -# 66| m0_81(int) = Store : r0_80, r0_79 -# 68| r0_82(glval) = VariableAddress[x] : -# 68| r0_83(int) = Load : r0_82, m0_3 -# 68| r0_84(glval) = VariableAddress[z] : -# 68| r0_85(int) = Load : r0_84, m0_81 -# 68| r0_86(int) = Add : r0_85, r0_83 -# 68| m0_87(int) = Store : r0_84, r0_86 -# 69| r0_88(glval) = VariableAddress[x] : -# 69| r0_89(int) = Load : r0_88, m0_3 -# 69| r0_90(glval) = VariableAddress[z] : -# 69| r0_91(int) = Load : r0_90, m0_87 -# 69| r0_92(int) = Sub : r0_91, r0_89 -# 69| m0_93(int) = Store : r0_90, r0_92 -# 70| r0_94(glval) = VariableAddress[x] : -# 70| r0_95(int) = Load : r0_94, m0_3 -# 70| r0_96(glval) = VariableAddress[z] : -# 70| r0_97(int) = Load : r0_96, m0_93 -# 70| r0_98(int) = Mul : r0_97, r0_95 -# 70| m0_99(int) = Store : r0_96, r0_98 -# 71| r0_100(glval) = VariableAddress[x] : -# 71| r0_101(int) = Load : r0_100, m0_3 -# 71| r0_102(glval) = VariableAddress[z] : -# 71| r0_103(int) = Load : r0_102, m0_99 -# 71| r0_104(int) = Div : r0_103, r0_101 -# 71| m0_105(int) = Store : r0_102, r0_104 -# 72| r0_106(glval) = VariableAddress[x] : -# 72| r0_107(int) = Load : r0_106, m0_3 -# 72| r0_108(glval) = VariableAddress[z] : -# 72| r0_109(int) = Load : r0_108, m0_105 -# 72| r0_110(int) = Rem : r0_109, r0_107 -# 72| m0_111(int) = Store : r0_108, r0_110 -# 74| r0_112(glval) = VariableAddress[x] : -# 74| r0_113(int) = Load : r0_112, m0_3 -# 74| r0_114(glval) = VariableAddress[z] : -# 74| r0_115(int) = Load : r0_114, m0_111 -# 74| r0_116(int) = BitAnd : r0_115, r0_113 -# 74| m0_117(int) = Store : r0_114, r0_116 -# 75| r0_118(glval) = VariableAddress[x] : -# 75| r0_119(int) = Load : r0_118, m0_3 -# 75| r0_120(glval) = VariableAddress[z] : -# 75| r0_121(int) = Load : r0_120, m0_117 -# 75| r0_122(int) = BitOr : r0_121, r0_119 -# 75| m0_123(int) = Store : r0_120, r0_122 -# 76| r0_124(glval) = VariableAddress[x] : -# 76| r0_125(int) = Load : r0_124, m0_3 -# 76| r0_126(glval) = VariableAddress[z] : -# 76| r0_127(int) = Load : r0_126, m0_123 -# 76| r0_128(int) = BitXor : r0_127, r0_125 -# 76| m0_129(int) = Store : r0_126, r0_128 -# 78| r0_130(glval) = VariableAddress[x] : -# 78| r0_131(int) = Load : r0_130, m0_3 -# 78| r0_132(glval) = VariableAddress[z] : -# 78| r0_133(int) = Load : r0_132, m0_129 -# 78| r0_134(int) = ShiftLeft : r0_133, r0_131 -# 78| m0_135(int) = Store : r0_132, r0_134 -# 79| r0_136(glval) = VariableAddress[x] : -# 79| r0_137(int) = Load : r0_136, m0_3 -# 79| r0_138(glval) = VariableAddress[z] : -# 79| r0_139(int) = Load : r0_138, m0_135 -# 79| r0_140(int) = ShiftRight : r0_139, r0_137 -# 79| m0_141(int) = Store : r0_138, r0_140 -# 81| r0_142(glval) = VariableAddress[x] : -# 81| r0_143(int) = Load : r0_142, m0_3 -# 81| r0_144(int) = CopyValue : r0_143 -# 81| r0_145(glval) = VariableAddress[z] : -# 81| m0_146(int) = Store : r0_145, r0_144 -# 82| r0_147(glval) = VariableAddress[x] : -# 82| r0_148(int) = Load : r0_147, m0_3 -# 82| r0_149(int) = Negate : r0_148 -# 82| r0_150(glval) = VariableAddress[z] : -# 82| m0_151(int) = Store : r0_150, r0_149 -# 83| r0_152(glval) = VariableAddress[x] : -# 83| r0_153(int) = Load : r0_152, m0_3 -# 83| r0_154(int) = BitComplement : r0_153 -# 83| r0_155(glval) = VariableAddress[z] : -# 83| m0_156(int) = Store : r0_155, r0_154 -# 84| r0_157(glval) = VariableAddress[x] : -# 84| r0_158(int) = Load : r0_157, m0_3 -# 84| r0_159(int) = Constant[0] : -# 84| r0_160(bool) = CompareNE : r0_158, r0_159 -# 84| r0_161(bool) = LogicalNot : r0_160 -# 84| r0_162(int) = Convert : r0_161 -# 84| r0_163(glval) = VariableAddress[z] : -# 84| m0_164(int) = Store : r0_163, r0_162 -# 85| v0_165(void) = NoOp : -# 50| v0_166(void) = ReturnVoid : -# 50| v0_167(void) = UnmodeledUse : mu* -# 50| v0_168(void) = ExitFunction : +# 50| m0_1(unknown) = AliasedDefinition : +# 50| mu0_2(unknown) = UnmodeledDefinition : +# 50| r0_3(glval) = VariableAddress[x] : +# 50| m0_4(int) = InitializeParameter[x] : r0_3 +# 50| r0_5(glval) = VariableAddress[y] : +# 50| m0_6(int) = InitializeParameter[y] : r0_5 +# 51| r0_7(glval) = VariableAddress[z] : +# 51| m0_8(int) = Uninitialized : r0_7 +# 53| r0_9(glval) = VariableAddress[x] : +# 53| r0_10(int) = Load : r0_9, m0_4 +# 53| r0_11(glval) = VariableAddress[y] : +# 53| r0_12(int) = Load : r0_11, m0_6 +# 53| r0_13(int) = Add : r0_10, r0_12 +# 53| r0_14(glval) = VariableAddress[z] : +# 53| m0_15(int) = Store : r0_14, r0_13 +# 54| r0_16(glval) = VariableAddress[x] : +# 54| r0_17(int) = Load : r0_16, m0_4 +# 54| r0_18(glval) = VariableAddress[y] : +# 54| r0_19(int) = Load : r0_18, m0_6 +# 54| r0_20(int) = Sub : r0_17, r0_19 +# 54| r0_21(glval) = VariableAddress[z] : +# 54| m0_22(int) = Store : r0_21, r0_20 +# 55| r0_23(glval) = VariableAddress[x] : +# 55| r0_24(int) = Load : r0_23, m0_4 +# 55| r0_25(glval) = VariableAddress[y] : +# 55| r0_26(int) = Load : r0_25, m0_6 +# 55| r0_27(int) = Mul : r0_24, r0_26 +# 55| r0_28(glval) = VariableAddress[z] : +# 55| m0_29(int) = Store : r0_28, r0_27 +# 56| r0_30(glval) = VariableAddress[x] : +# 56| r0_31(int) = Load : r0_30, m0_4 +# 56| r0_32(glval) = VariableAddress[y] : +# 56| r0_33(int) = Load : r0_32, m0_6 +# 56| r0_34(int) = Div : r0_31, r0_33 +# 56| r0_35(glval) = VariableAddress[z] : +# 56| m0_36(int) = Store : r0_35, r0_34 +# 57| r0_37(glval) = VariableAddress[x] : +# 57| r0_38(int) = Load : r0_37, m0_4 +# 57| r0_39(glval) = VariableAddress[y] : +# 57| r0_40(int) = Load : r0_39, m0_6 +# 57| r0_41(int) = Rem : r0_38, r0_40 +# 57| r0_42(glval) = VariableAddress[z] : +# 57| m0_43(int) = Store : r0_42, r0_41 +# 59| r0_44(glval) = VariableAddress[x] : +# 59| r0_45(int) = Load : r0_44, m0_4 +# 59| r0_46(glval) = VariableAddress[y] : +# 59| r0_47(int) = Load : r0_46, m0_6 +# 59| r0_48(int) = BitAnd : r0_45, r0_47 +# 59| r0_49(glval) = VariableAddress[z] : +# 59| m0_50(int) = Store : r0_49, r0_48 +# 60| r0_51(glval) = VariableAddress[x] : +# 60| r0_52(int) = Load : r0_51, m0_4 +# 60| r0_53(glval) = VariableAddress[y] : +# 60| r0_54(int) = Load : r0_53, m0_6 +# 60| r0_55(int) = BitOr : r0_52, r0_54 +# 60| r0_56(glval) = VariableAddress[z] : +# 60| m0_57(int) = Store : r0_56, r0_55 +# 61| r0_58(glval) = VariableAddress[x] : +# 61| r0_59(int) = Load : r0_58, m0_4 +# 61| r0_60(glval) = VariableAddress[y] : +# 61| r0_61(int) = Load : r0_60, m0_6 +# 61| r0_62(int) = BitXor : r0_59, r0_61 +# 61| r0_63(glval) = VariableAddress[z] : +# 61| m0_64(int) = Store : r0_63, r0_62 +# 63| r0_65(glval) = VariableAddress[x] : +# 63| r0_66(int) = Load : r0_65, m0_4 +# 63| r0_67(glval) = VariableAddress[y] : +# 63| r0_68(int) = Load : r0_67, m0_6 +# 63| r0_69(int) = ShiftLeft : r0_66, r0_68 +# 63| r0_70(glval) = VariableAddress[z] : +# 63| m0_71(int) = Store : r0_70, r0_69 +# 64| r0_72(glval) = VariableAddress[x] : +# 64| r0_73(int) = Load : r0_72, m0_4 +# 64| r0_74(glval) = VariableAddress[y] : +# 64| r0_75(int) = Load : r0_74, m0_6 +# 64| r0_76(int) = ShiftRight : r0_73, r0_75 +# 64| r0_77(glval) = VariableAddress[z] : +# 64| m0_78(int) = Store : r0_77, r0_76 +# 66| r0_79(glval) = VariableAddress[x] : +# 66| r0_80(int) = Load : r0_79, m0_4 +# 66| r0_81(glval) = VariableAddress[z] : +# 66| m0_82(int) = Store : r0_81, r0_80 +# 68| r0_83(glval) = VariableAddress[x] : +# 68| r0_84(int) = Load : r0_83, m0_4 +# 68| r0_85(glval) = VariableAddress[z] : +# 68| r0_86(int) = Load : r0_85, m0_82 +# 68| r0_87(int) = Add : r0_86, r0_84 +# 68| m0_88(int) = Store : r0_85, r0_87 +# 69| r0_89(glval) = VariableAddress[x] : +# 69| r0_90(int) = Load : r0_89, m0_4 +# 69| r0_91(glval) = VariableAddress[z] : +# 69| r0_92(int) = Load : r0_91, m0_88 +# 69| r0_93(int) = Sub : r0_92, r0_90 +# 69| m0_94(int) = Store : r0_91, r0_93 +# 70| r0_95(glval) = VariableAddress[x] : +# 70| r0_96(int) = Load : r0_95, m0_4 +# 70| r0_97(glval) = VariableAddress[z] : +# 70| r0_98(int) = Load : r0_97, m0_94 +# 70| r0_99(int) = Mul : r0_98, r0_96 +# 70| m0_100(int) = Store : r0_97, r0_99 +# 71| r0_101(glval) = VariableAddress[x] : +# 71| r0_102(int) = Load : r0_101, m0_4 +# 71| r0_103(glval) = VariableAddress[z] : +# 71| r0_104(int) = Load : r0_103, m0_100 +# 71| r0_105(int) = Div : r0_104, r0_102 +# 71| m0_106(int) = Store : r0_103, r0_105 +# 72| r0_107(glval) = VariableAddress[x] : +# 72| r0_108(int) = Load : r0_107, m0_4 +# 72| r0_109(glval) = VariableAddress[z] : +# 72| r0_110(int) = Load : r0_109, m0_106 +# 72| r0_111(int) = Rem : r0_110, r0_108 +# 72| m0_112(int) = Store : r0_109, r0_111 +# 74| r0_113(glval) = VariableAddress[x] : +# 74| r0_114(int) = Load : r0_113, m0_4 +# 74| r0_115(glval) = VariableAddress[z] : +# 74| r0_116(int) = Load : r0_115, m0_112 +# 74| r0_117(int) = BitAnd : r0_116, r0_114 +# 74| m0_118(int) = Store : r0_115, r0_117 +# 75| r0_119(glval) = VariableAddress[x] : +# 75| r0_120(int) = Load : r0_119, m0_4 +# 75| r0_121(glval) = VariableAddress[z] : +# 75| r0_122(int) = Load : r0_121, m0_118 +# 75| r0_123(int) = BitOr : r0_122, r0_120 +# 75| m0_124(int) = Store : r0_121, r0_123 +# 76| r0_125(glval) = VariableAddress[x] : +# 76| r0_126(int) = Load : r0_125, m0_4 +# 76| r0_127(glval) = VariableAddress[z] : +# 76| r0_128(int) = Load : r0_127, m0_124 +# 76| r0_129(int) = BitXor : r0_128, r0_126 +# 76| m0_130(int) = Store : r0_127, r0_129 +# 78| r0_131(glval) = VariableAddress[x] : +# 78| r0_132(int) = Load : r0_131, m0_4 +# 78| r0_133(glval) = VariableAddress[z] : +# 78| r0_134(int) = Load : r0_133, m0_130 +# 78| r0_135(int) = ShiftLeft : r0_134, r0_132 +# 78| m0_136(int) = Store : r0_133, r0_135 +# 79| r0_137(glval) = VariableAddress[x] : +# 79| r0_138(int) = Load : r0_137, m0_4 +# 79| r0_139(glval) = VariableAddress[z] : +# 79| r0_140(int) = Load : r0_139, m0_136 +# 79| r0_141(int) = ShiftRight : r0_140, r0_138 +# 79| m0_142(int) = Store : r0_139, r0_141 +# 81| r0_143(glval) = VariableAddress[x] : +# 81| r0_144(int) = Load : r0_143, m0_4 +# 81| r0_145(int) = CopyValue : r0_144 +# 81| r0_146(glval) = VariableAddress[z] : +# 81| m0_147(int) = Store : r0_146, r0_145 +# 82| r0_148(glval) = VariableAddress[x] : +# 82| r0_149(int) = Load : r0_148, m0_4 +# 82| r0_150(int) = Negate : r0_149 +# 82| r0_151(glval) = VariableAddress[z] : +# 82| m0_152(int) = Store : r0_151, r0_150 +# 83| r0_153(glval) = VariableAddress[x] : +# 83| r0_154(int) = Load : r0_153, m0_4 +# 83| r0_155(int) = BitComplement : r0_154 +# 83| r0_156(glval) = VariableAddress[z] : +# 83| m0_157(int) = Store : r0_156, r0_155 +# 84| r0_158(glval) = VariableAddress[x] : +# 84| r0_159(int) = Load : r0_158, m0_4 +# 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| m0_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) = ExitFunction : # 87| IntegerCompare(int, int) -> void # 87| Block 0 # 87| v0_0(void) = EnterFunction : -# 87| mu0_1(unknown) = UnmodeledDefinition : -# 87| r0_2(glval) = VariableAddress[x] : -# 87| m0_3(int) = InitializeParameter[x] : r0_2 -# 87| r0_4(glval) = VariableAddress[y] : -# 87| m0_5(int) = InitializeParameter[y] : r0_4 -# 88| r0_6(glval) = VariableAddress[b] : -# 88| m0_7(bool) = Uninitialized : r0_6 -# 90| r0_8(glval) = VariableAddress[x] : -# 90| r0_9(int) = Load : r0_8, m0_3 -# 90| r0_10(glval) = VariableAddress[y] : -# 90| r0_11(int) = Load : r0_10, m0_5 -# 90| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 90| r0_13(glval) = VariableAddress[b] : -# 90| m0_14(bool) = Store : r0_13, r0_12 -# 91| r0_15(glval) = VariableAddress[x] : -# 91| r0_16(int) = Load : r0_15, m0_3 -# 91| r0_17(glval) = VariableAddress[y] : -# 91| r0_18(int) = Load : r0_17, m0_5 -# 91| r0_19(bool) = CompareNE : r0_16, r0_18 -# 91| r0_20(glval) = VariableAddress[b] : -# 91| m0_21(bool) = Store : r0_20, r0_19 -# 92| r0_22(glval) = VariableAddress[x] : -# 92| r0_23(int) = Load : r0_22, m0_3 -# 92| r0_24(glval) = VariableAddress[y] : -# 92| r0_25(int) = Load : r0_24, m0_5 -# 92| r0_26(bool) = CompareLT : r0_23, r0_25 -# 92| r0_27(glval) = VariableAddress[b] : -# 92| m0_28(bool) = Store : r0_27, r0_26 -# 93| r0_29(glval) = VariableAddress[x] : -# 93| r0_30(int) = Load : r0_29, m0_3 -# 93| r0_31(glval) = VariableAddress[y] : -# 93| r0_32(int) = Load : r0_31, m0_5 -# 93| r0_33(bool) = CompareGT : r0_30, r0_32 -# 93| r0_34(glval) = VariableAddress[b] : -# 93| m0_35(bool) = Store : r0_34, r0_33 -# 94| r0_36(glval) = VariableAddress[x] : -# 94| r0_37(int) = Load : r0_36, m0_3 -# 94| r0_38(glval) = VariableAddress[y] : -# 94| r0_39(int) = Load : r0_38, m0_5 -# 94| r0_40(bool) = CompareLE : r0_37, r0_39 -# 94| r0_41(glval) = VariableAddress[b] : -# 94| m0_42(bool) = Store : r0_41, r0_40 -# 95| r0_43(glval) = VariableAddress[x] : -# 95| r0_44(int) = Load : r0_43, m0_3 -# 95| r0_45(glval) = VariableAddress[y] : -# 95| r0_46(int) = Load : r0_45, m0_5 -# 95| r0_47(bool) = CompareGE : r0_44, r0_46 -# 95| r0_48(glval) = VariableAddress[b] : -# 95| m0_49(bool) = Store : r0_48, r0_47 -# 96| v0_50(void) = NoOp : -# 87| v0_51(void) = ReturnVoid : -# 87| v0_52(void) = UnmodeledUse : mu* -# 87| v0_53(void) = ExitFunction : +# 87| m0_1(unknown) = AliasedDefinition : +# 87| mu0_2(unknown) = UnmodeledDefinition : +# 87| r0_3(glval) = VariableAddress[x] : +# 87| m0_4(int) = InitializeParameter[x] : r0_3 +# 87| r0_5(glval) = VariableAddress[y] : +# 87| m0_6(int) = InitializeParameter[y] : r0_5 +# 88| r0_7(glval) = VariableAddress[b] : +# 88| m0_8(bool) = Uninitialized : r0_7 +# 90| r0_9(glval) = VariableAddress[x] : +# 90| r0_10(int) = Load : r0_9, m0_4 +# 90| r0_11(glval) = VariableAddress[y] : +# 90| r0_12(int) = Load : r0_11, m0_6 +# 90| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 90| r0_14(glval) = VariableAddress[b] : +# 90| m0_15(bool) = Store : r0_14, r0_13 +# 91| r0_16(glval) = VariableAddress[x] : +# 91| r0_17(int) = Load : r0_16, m0_4 +# 91| r0_18(glval) = VariableAddress[y] : +# 91| r0_19(int) = Load : r0_18, m0_6 +# 91| r0_20(bool) = CompareNE : r0_17, r0_19 +# 91| r0_21(glval) = VariableAddress[b] : +# 91| m0_22(bool) = Store : r0_21, r0_20 +# 92| r0_23(glval) = VariableAddress[x] : +# 92| r0_24(int) = Load : r0_23, m0_4 +# 92| r0_25(glval) = VariableAddress[y] : +# 92| r0_26(int) = Load : r0_25, m0_6 +# 92| r0_27(bool) = CompareLT : r0_24, r0_26 +# 92| r0_28(glval) = VariableAddress[b] : +# 92| m0_29(bool) = Store : r0_28, r0_27 +# 93| r0_30(glval) = VariableAddress[x] : +# 93| r0_31(int) = Load : r0_30, m0_4 +# 93| r0_32(glval) = VariableAddress[y] : +# 93| r0_33(int) = Load : r0_32, m0_6 +# 93| r0_34(bool) = CompareGT : r0_31, r0_33 +# 93| r0_35(glval) = VariableAddress[b] : +# 93| m0_36(bool) = Store : r0_35, r0_34 +# 94| r0_37(glval) = VariableAddress[x] : +# 94| r0_38(int) = Load : r0_37, m0_4 +# 94| r0_39(glval) = VariableAddress[y] : +# 94| r0_40(int) = Load : r0_39, m0_6 +# 94| r0_41(bool) = CompareLE : r0_38, r0_40 +# 94| r0_42(glval) = VariableAddress[b] : +# 94| m0_43(bool) = Store : r0_42, r0_41 +# 95| r0_44(glval) = VariableAddress[x] : +# 95| r0_45(int) = Load : r0_44, m0_4 +# 95| r0_46(glval) = VariableAddress[y] : +# 95| r0_47(int) = Load : r0_46, m0_6 +# 95| r0_48(bool) = CompareGE : r0_45, r0_47 +# 95| r0_49(glval) = VariableAddress[b] : +# 95| m0_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) = ExitFunction : # 98| IntegerCrement(int) -> void # 98| Block 0 # 98| v0_0(void) = EnterFunction : -# 98| mu0_1(unknown) = UnmodeledDefinition : -# 98| r0_2(glval) = VariableAddress[x] : -# 98| m0_3(int) = InitializeParameter[x] : r0_2 -# 99| r0_4(glval) = VariableAddress[y] : -# 99| m0_5(int) = Uninitialized : r0_4 -# 101| r0_6(glval) = VariableAddress[x] : -# 101| r0_7(int) = Load : r0_6, m0_3 -# 101| r0_8(int) = Constant[1] : -# 101| r0_9(int) = Add : r0_7, r0_8 -# 101| m0_10(int) = Store : r0_6, r0_9 -# 101| r0_11(glval) = VariableAddress[y] : -# 101| m0_12(int) = Store : r0_11, r0_9 -# 102| r0_13(glval) = VariableAddress[x] : -# 102| r0_14(int) = Load : r0_13, m0_10 -# 102| r0_15(int) = Constant[1] : -# 102| r0_16(int) = Sub : r0_14, r0_15 -# 102| m0_17(int) = Store : r0_13, r0_16 -# 102| r0_18(glval) = VariableAddress[y] : -# 102| m0_19(int) = Store : r0_18, r0_16 -# 103| r0_20(glval) = VariableAddress[x] : -# 103| r0_21(int) = Load : r0_20, m0_17 -# 103| r0_22(int) = Constant[1] : -# 103| r0_23(int) = Add : r0_21, r0_22 -# 103| m0_24(int) = Store : r0_20, r0_23 -# 103| r0_25(glval) = VariableAddress[y] : -# 103| m0_26(int) = Store : r0_25, r0_21 -# 104| r0_27(glval) = VariableAddress[x] : -# 104| r0_28(int) = Load : r0_27, m0_24 -# 104| r0_29(int) = Constant[1] : -# 104| r0_30(int) = Sub : r0_28, r0_29 -# 104| m0_31(int) = Store : r0_27, r0_30 -# 104| r0_32(glval) = VariableAddress[y] : -# 104| m0_33(int) = Store : r0_32, r0_28 -# 105| v0_34(void) = NoOp : -# 98| v0_35(void) = ReturnVoid : -# 98| v0_36(void) = UnmodeledUse : mu* -# 98| v0_37(void) = ExitFunction : +# 98| m0_1(unknown) = AliasedDefinition : +# 98| mu0_2(unknown) = UnmodeledDefinition : +# 98| r0_3(glval) = VariableAddress[x] : +# 98| m0_4(int) = InitializeParameter[x] : r0_3 +# 99| r0_5(glval) = VariableAddress[y] : +# 99| m0_6(int) = Uninitialized : r0_5 +# 101| r0_7(glval) = VariableAddress[x] : +# 101| r0_8(int) = Load : r0_7, m0_4 +# 101| r0_9(int) = Constant[1] : +# 101| r0_10(int) = Add : r0_8, r0_9 +# 101| m0_11(int) = Store : r0_7, r0_10 +# 101| r0_12(glval) = VariableAddress[y] : +# 101| m0_13(int) = Store : r0_12, r0_10 +# 102| r0_14(glval) = VariableAddress[x] : +# 102| r0_15(int) = Load : r0_14, m0_11 +# 102| r0_16(int) = Constant[1] : +# 102| r0_17(int) = Sub : r0_15, r0_16 +# 102| m0_18(int) = Store : r0_14, r0_17 +# 102| r0_19(glval) = VariableAddress[y] : +# 102| m0_20(int) = Store : r0_19, r0_17 +# 103| r0_21(glval) = VariableAddress[x] : +# 103| r0_22(int) = Load : r0_21, m0_18 +# 103| r0_23(int) = Constant[1] : +# 103| r0_24(int) = Add : r0_22, r0_23 +# 103| m0_25(int) = Store : r0_21, r0_24 +# 103| r0_26(glval) = VariableAddress[y] : +# 103| m0_27(int) = Store : r0_26, r0_22 +# 104| r0_28(glval) = VariableAddress[x] : +# 104| r0_29(int) = Load : r0_28, m0_25 +# 104| r0_30(int) = Constant[1] : +# 104| r0_31(int) = Sub : r0_29, r0_30 +# 104| m0_32(int) = Store : r0_28, r0_31 +# 104| r0_33(glval) = VariableAddress[y] : +# 104| m0_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) = ExitFunction : # 107| IntegerCrement_LValue(int) -> void # 107| Block 0 # 107| v0_0(void) = EnterFunction : -# 107| mu0_1(unknown) = UnmodeledDefinition : -# 107| r0_2(glval) = VariableAddress[x] : -# 107| m0_3(int) = InitializeParameter[x] : r0_2 -# 108| r0_4(glval) = VariableAddress[p] : -# 108| m0_5(int *) = Uninitialized : r0_4 -# 110| r0_6(glval) = VariableAddress[x] : -# 110| r0_7(int) = Load : r0_6, m0_3 -# 110| r0_8(int) = Constant[1] : -# 110| r0_9(int) = Add : r0_7, r0_8 -# 110| m0_10(int) = Store : r0_6, r0_9 -# 110| r0_11(glval) = VariableAddress[p] : -# 110| m0_12(int *) = Store : r0_11, r0_6 -# 111| r0_13(glval) = VariableAddress[x] : -# 111| r0_14(int) = Load : r0_13, m0_10 -# 111| r0_15(int) = Constant[1] : -# 111| r0_16(int) = Sub : r0_14, r0_15 -# 111| m0_17(int) = Store : r0_13, r0_16 -# 111| r0_18(glval) = VariableAddress[p] : -# 111| m0_19(int *) = Store : r0_18, r0_13 -# 112| v0_20(void) = NoOp : -# 107| v0_21(void) = ReturnVoid : -# 107| v0_22(void) = UnmodeledUse : mu* -# 107| v0_23(void) = ExitFunction : +# 107| m0_1(unknown) = AliasedDefinition : +# 107| mu0_2(unknown) = UnmodeledDefinition : +# 107| r0_3(glval) = VariableAddress[x] : +# 107| m0_4(int) = InitializeParameter[x] : r0_3 +# 108| r0_5(glval) = VariableAddress[p] : +# 108| m0_6(int *) = Uninitialized : 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| m0_11(int) = Store : r0_7, r0_10 +# 110| r0_12(glval) = VariableAddress[p] : +# 110| m0_13(int *) = Store : r0_12, r0_7 +# 111| r0_14(glval) = VariableAddress[x] : +# 111| r0_15(int) = Load : r0_14, mu0_2 +# 111| r0_16(int) = Constant[1] : +# 111| r0_17(int) = Sub : r0_15, r0_16 +# 111| m0_18(int) = Store : r0_14, r0_17 +# 111| r0_19(glval) = VariableAddress[p] : +# 111| m0_20(int *) = Store : r0_19, r0_14 +# 112| v0_21(void) = NoOp : +# 107| v0_22(void) = ReturnVoid : +# 107| v0_23(void) = UnmodeledUse : mu* +# 107| v0_24(void) = ExitFunction : # 114| FloatOps(double, double) -> void # 114| Block 0 # 114| v0_0(void) = EnterFunction : -# 114| mu0_1(unknown) = UnmodeledDefinition : -# 114| r0_2(glval) = VariableAddress[x] : -# 114| m0_3(double) = InitializeParameter[x] : r0_2 -# 114| r0_4(glval) = VariableAddress[y] : -# 114| m0_5(double) = InitializeParameter[y] : r0_4 -# 115| r0_6(glval) = VariableAddress[z] : -# 115| m0_7(double) = Uninitialized : r0_6 -# 117| r0_8(glval) = VariableAddress[x] : -# 117| r0_9(double) = Load : r0_8, m0_3 -# 117| r0_10(glval) = VariableAddress[y] : -# 117| r0_11(double) = Load : r0_10, m0_5 -# 117| r0_12(double) = Add : r0_9, r0_11 -# 117| r0_13(glval) = VariableAddress[z] : -# 117| m0_14(double) = Store : r0_13, r0_12 -# 118| r0_15(glval) = VariableAddress[x] : -# 118| r0_16(double) = Load : r0_15, m0_3 -# 118| r0_17(glval) = VariableAddress[y] : -# 118| r0_18(double) = Load : r0_17, m0_5 -# 118| r0_19(double) = Sub : r0_16, r0_18 -# 118| r0_20(glval) = VariableAddress[z] : -# 118| m0_21(double) = Store : r0_20, r0_19 -# 119| r0_22(glval) = VariableAddress[x] : -# 119| r0_23(double) = Load : r0_22, m0_3 -# 119| r0_24(glval) = VariableAddress[y] : -# 119| r0_25(double) = Load : r0_24, m0_5 -# 119| r0_26(double) = Mul : r0_23, r0_25 -# 119| r0_27(glval) = VariableAddress[z] : -# 119| m0_28(double) = Store : r0_27, r0_26 -# 120| r0_29(glval) = VariableAddress[x] : -# 120| r0_30(double) = Load : r0_29, m0_3 -# 120| r0_31(glval) = VariableAddress[y] : -# 120| r0_32(double) = Load : r0_31, m0_5 -# 120| r0_33(double) = Div : r0_30, r0_32 -# 120| r0_34(glval) = VariableAddress[z] : -# 120| m0_35(double) = Store : r0_34, r0_33 -# 122| r0_36(glval) = VariableAddress[x] : -# 122| r0_37(double) = Load : r0_36, m0_3 -# 122| r0_38(glval) = VariableAddress[z] : -# 122| m0_39(double) = Store : r0_38, r0_37 -# 124| r0_40(glval) = VariableAddress[x] : -# 124| r0_41(double) = Load : r0_40, m0_3 -# 124| r0_42(glval) = VariableAddress[z] : -# 124| r0_43(double) = Load : r0_42, m0_39 -# 124| r0_44(double) = Add : r0_43, r0_41 -# 124| m0_45(double) = Store : r0_42, r0_44 -# 125| r0_46(glval) = VariableAddress[x] : -# 125| r0_47(double) = Load : r0_46, m0_3 -# 125| r0_48(glval) = VariableAddress[z] : -# 125| r0_49(double) = Load : r0_48, m0_45 -# 125| r0_50(double) = Sub : r0_49, r0_47 -# 125| m0_51(double) = Store : r0_48, r0_50 -# 126| r0_52(glval) = VariableAddress[x] : -# 126| r0_53(double) = Load : r0_52, m0_3 -# 126| r0_54(glval) = VariableAddress[z] : -# 126| r0_55(double) = Load : r0_54, m0_51 -# 126| r0_56(double) = Mul : r0_55, r0_53 -# 126| m0_57(double) = Store : r0_54, r0_56 -# 127| r0_58(glval) = VariableAddress[x] : -# 127| r0_59(double) = Load : r0_58, m0_3 -# 127| r0_60(glval) = VariableAddress[z] : -# 127| r0_61(double) = Load : r0_60, m0_57 -# 127| r0_62(double) = Div : r0_61, r0_59 -# 127| m0_63(double) = Store : r0_60, r0_62 -# 129| r0_64(glval) = VariableAddress[x] : -# 129| r0_65(double) = Load : r0_64, m0_3 -# 129| r0_66(double) = CopyValue : r0_65 -# 129| r0_67(glval) = VariableAddress[z] : -# 129| m0_68(double) = Store : r0_67, r0_66 -# 130| r0_69(glval) = VariableAddress[x] : -# 130| r0_70(double) = Load : r0_69, m0_3 -# 130| r0_71(double) = Negate : r0_70 -# 130| r0_72(glval) = VariableAddress[z] : -# 130| m0_73(double) = Store : r0_72, r0_71 -# 131| v0_74(void) = NoOp : -# 114| v0_75(void) = ReturnVoid : -# 114| v0_76(void) = UnmodeledUse : mu* -# 114| v0_77(void) = ExitFunction : +# 114| m0_1(unknown) = AliasedDefinition : +# 114| mu0_2(unknown) = UnmodeledDefinition : +# 114| r0_3(glval) = VariableAddress[x] : +# 114| m0_4(double) = InitializeParameter[x] : r0_3 +# 114| r0_5(glval) = VariableAddress[y] : +# 114| m0_6(double) = InitializeParameter[y] : r0_5 +# 115| r0_7(glval) = VariableAddress[z] : +# 115| m0_8(double) = Uninitialized : r0_7 +# 117| r0_9(glval) = VariableAddress[x] : +# 117| r0_10(double) = Load : r0_9, m0_4 +# 117| r0_11(glval) = VariableAddress[y] : +# 117| r0_12(double) = Load : r0_11, m0_6 +# 117| r0_13(double) = Add : r0_10, r0_12 +# 117| r0_14(glval) = VariableAddress[z] : +# 117| m0_15(double) = Store : r0_14, r0_13 +# 118| r0_16(glval) = VariableAddress[x] : +# 118| r0_17(double) = Load : r0_16, m0_4 +# 118| r0_18(glval) = VariableAddress[y] : +# 118| r0_19(double) = Load : r0_18, m0_6 +# 118| r0_20(double) = Sub : r0_17, r0_19 +# 118| r0_21(glval) = VariableAddress[z] : +# 118| m0_22(double) = Store : r0_21, r0_20 +# 119| r0_23(glval) = VariableAddress[x] : +# 119| r0_24(double) = Load : r0_23, m0_4 +# 119| r0_25(glval) = VariableAddress[y] : +# 119| r0_26(double) = Load : r0_25, m0_6 +# 119| r0_27(double) = Mul : r0_24, r0_26 +# 119| r0_28(glval) = VariableAddress[z] : +# 119| m0_29(double) = Store : r0_28, r0_27 +# 120| r0_30(glval) = VariableAddress[x] : +# 120| r0_31(double) = Load : r0_30, m0_4 +# 120| r0_32(glval) = VariableAddress[y] : +# 120| r0_33(double) = Load : r0_32, m0_6 +# 120| r0_34(double) = Div : r0_31, r0_33 +# 120| r0_35(glval) = VariableAddress[z] : +# 120| m0_36(double) = Store : r0_35, r0_34 +# 122| r0_37(glval) = VariableAddress[x] : +# 122| r0_38(double) = Load : r0_37, m0_4 +# 122| r0_39(glval) = VariableAddress[z] : +# 122| m0_40(double) = Store : r0_39, r0_38 +# 124| r0_41(glval) = VariableAddress[x] : +# 124| r0_42(double) = Load : r0_41, m0_4 +# 124| r0_43(glval) = VariableAddress[z] : +# 124| r0_44(double) = Load : r0_43, m0_40 +# 124| r0_45(double) = Add : r0_44, r0_42 +# 124| m0_46(double) = Store : r0_43, r0_45 +# 125| r0_47(glval) = VariableAddress[x] : +# 125| r0_48(double) = Load : r0_47, m0_4 +# 125| r0_49(glval) = VariableAddress[z] : +# 125| r0_50(double) = Load : r0_49, m0_46 +# 125| r0_51(double) = Sub : r0_50, r0_48 +# 125| m0_52(double) = Store : r0_49, r0_51 +# 126| r0_53(glval) = VariableAddress[x] : +# 126| r0_54(double) = Load : r0_53, m0_4 +# 126| r0_55(glval) = VariableAddress[z] : +# 126| r0_56(double) = Load : r0_55, m0_52 +# 126| r0_57(double) = Mul : r0_56, r0_54 +# 126| m0_58(double) = Store : r0_55, r0_57 +# 127| r0_59(glval) = VariableAddress[x] : +# 127| r0_60(double) = Load : r0_59, m0_4 +# 127| r0_61(glval) = VariableAddress[z] : +# 127| r0_62(double) = Load : r0_61, m0_58 +# 127| r0_63(double) = Div : r0_62, r0_60 +# 127| m0_64(double) = Store : r0_61, r0_63 +# 129| r0_65(glval) = VariableAddress[x] : +# 129| r0_66(double) = Load : r0_65, m0_4 +# 129| r0_67(double) = CopyValue : r0_66 +# 129| r0_68(glval) = VariableAddress[z] : +# 129| m0_69(double) = Store : r0_68, r0_67 +# 130| r0_70(glval) = VariableAddress[x] : +# 130| r0_71(double) = Load : r0_70, m0_4 +# 130| r0_72(double) = Negate : r0_71 +# 130| r0_73(glval) = VariableAddress[z] : +# 130| m0_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) = ExitFunction : # 133| FloatCompare(double, double) -> void # 133| Block 0 # 133| v0_0(void) = EnterFunction : -# 133| mu0_1(unknown) = UnmodeledDefinition : -# 133| r0_2(glval) = VariableAddress[x] : -# 133| m0_3(double) = InitializeParameter[x] : r0_2 -# 133| r0_4(glval) = VariableAddress[y] : -# 133| m0_5(double) = InitializeParameter[y] : r0_4 -# 134| r0_6(glval) = VariableAddress[b] : -# 134| m0_7(bool) = Uninitialized : r0_6 -# 136| r0_8(glval) = VariableAddress[x] : -# 136| r0_9(double) = Load : r0_8, m0_3 -# 136| r0_10(glval) = VariableAddress[y] : -# 136| r0_11(double) = Load : r0_10, m0_5 -# 136| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 136| r0_13(glval) = VariableAddress[b] : -# 136| m0_14(bool) = Store : r0_13, r0_12 -# 137| r0_15(glval) = VariableAddress[x] : -# 137| r0_16(double) = Load : r0_15, m0_3 -# 137| r0_17(glval) = VariableAddress[y] : -# 137| r0_18(double) = Load : r0_17, m0_5 -# 137| r0_19(bool) = CompareNE : r0_16, r0_18 -# 137| r0_20(glval) = VariableAddress[b] : -# 137| m0_21(bool) = Store : r0_20, r0_19 -# 138| r0_22(glval) = VariableAddress[x] : -# 138| r0_23(double) = Load : r0_22, m0_3 -# 138| r0_24(glval) = VariableAddress[y] : -# 138| r0_25(double) = Load : r0_24, m0_5 -# 138| r0_26(bool) = CompareLT : r0_23, r0_25 -# 138| r0_27(glval) = VariableAddress[b] : -# 138| m0_28(bool) = Store : r0_27, r0_26 -# 139| r0_29(glval) = VariableAddress[x] : -# 139| r0_30(double) = Load : r0_29, m0_3 -# 139| r0_31(glval) = VariableAddress[y] : -# 139| r0_32(double) = Load : r0_31, m0_5 -# 139| r0_33(bool) = CompareGT : r0_30, r0_32 -# 139| r0_34(glval) = VariableAddress[b] : -# 139| m0_35(bool) = Store : r0_34, r0_33 -# 140| r0_36(glval) = VariableAddress[x] : -# 140| r0_37(double) = Load : r0_36, m0_3 -# 140| r0_38(glval) = VariableAddress[y] : -# 140| r0_39(double) = Load : r0_38, m0_5 -# 140| r0_40(bool) = CompareLE : r0_37, r0_39 -# 140| r0_41(glval) = VariableAddress[b] : -# 140| m0_42(bool) = Store : r0_41, r0_40 -# 141| r0_43(glval) = VariableAddress[x] : -# 141| r0_44(double) = Load : r0_43, m0_3 -# 141| r0_45(glval) = VariableAddress[y] : -# 141| r0_46(double) = Load : r0_45, m0_5 -# 141| r0_47(bool) = CompareGE : r0_44, r0_46 -# 141| r0_48(glval) = VariableAddress[b] : -# 141| m0_49(bool) = Store : r0_48, r0_47 -# 142| v0_50(void) = NoOp : -# 133| v0_51(void) = ReturnVoid : -# 133| v0_52(void) = UnmodeledUse : mu* -# 133| v0_53(void) = ExitFunction : +# 133| m0_1(unknown) = AliasedDefinition : +# 133| mu0_2(unknown) = UnmodeledDefinition : +# 133| r0_3(glval) = VariableAddress[x] : +# 133| m0_4(double) = InitializeParameter[x] : r0_3 +# 133| r0_5(glval) = VariableAddress[y] : +# 133| m0_6(double) = InitializeParameter[y] : r0_5 +# 134| r0_7(glval) = VariableAddress[b] : +# 134| m0_8(bool) = Uninitialized : r0_7 +# 136| r0_9(glval) = VariableAddress[x] : +# 136| r0_10(double) = Load : r0_9, m0_4 +# 136| r0_11(glval) = VariableAddress[y] : +# 136| r0_12(double) = Load : r0_11, m0_6 +# 136| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 136| r0_14(glval) = VariableAddress[b] : +# 136| m0_15(bool) = Store : r0_14, r0_13 +# 137| r0_16(glval) = VariableAddress[x] : +# 137| r0_17(double) = Load : r0_16, m0_4 +# 137| r0_18(glval) = VariableAddress[y] : +# 137| r0_19(double) = Load : r0_18, m0_6 +# 137| r0_20(bool) = CompareNE : r0_17, r0_19 +# 137| r0_21(glval) = VariableAddress[b] : +# 137| m0_22(bool) = Store : r0_21, r0_20 +# 138| r0_23(glval) = VariableAddress[x] : +# 138| r0_24(double) = Load : r0_23, m0_4 +# 138| r0_25(glval) = VariableAddress[y] : +# 138| r0_26(double) = Load : r0_25, m0_6 +# 138| r0_27(bool) = CompareLT : r0_24, r0_26 +# 138| r0_28(glval) = VariableAddress[b] : +# 138| m0_29(bool) = Store : r0_28, r0_27 +# 139| r0_30(glval) = VariableAddress[x] : +# 139| r0_31(double) = Load : r0_30, m0_4 +# 139| r0_32(glval) = VariableAddress[y] : +# 139| r0_33(double) = Load : r0_32, m0_6 +# 139| r0_34(bool) = CompareGT : r0_31, r0_33 +# 139| r0_35(glval) = VariableAddress[b] : +# 139| m0_36(bool) = Store : r0_35, r0_34 +# 140| r0_37(glval) = VariableAddress[x] : +# 140| r0_38(double) = Load : r0_37, m0_4 +# 140| r0_39(glval) = VariableAddress[y] : +# 140| r0_40(double) = Load : r0_39, m0_6 +# 140| r0_41(bool) = CompareLE : r0_38, r0_40 +# 140| r0_42(glval) = VariableAddress[b] : +# 140| m0_43(bool) = Store : r0_42, r0_41 +# 141| r0_44(glval) = VariableAddress[x] : +# 141| r0_45(double) = Load : r0_44, m0_4 +# 141| r0_46(glval) = VariableAddress[y] : +# 141| r0_47(double) = Load : r0_46, m0_6 +# 141| r0_48(bool) = CompareGE : r0_45, r0_47 +# 141| r0_49(glval) = VariableAddress[b] : +# 141| m0_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) = ExitFunction : # 144| FloatCrement(float) -> void # 144| Block 0 # 144| v0_0(void) = EnterFunction : -# 144| mu0_1(unknown) = UnmodeledDefinition : -# 144| r0_2(glval) = VariableAddress[x] : -# 144| m0_3(float) = InitializeParameter[x] : r0_2 -# 145| r0_4(glval) = VariableAddress[y] : -# 145| m0_5(float) = Uninitialized : r0_4 -# 147| r0_6(glval) = VariableAddress[x] : -# 147| r0_7(float) = Load : r0_6, m0_3 -# 147| r0_8(float) = Constant[1.0] : -# 147| r0_9(float) = Add : r0_7, r0_8 -# 147| m0_10(float) = Store : r0_6, r0_9 -# 147| r0_11(glval) = VariableAddress[y] : -# 147| m0_12(float) = Store : r0_11, r0_9 -# 148| r0_13(glval) = VariableAddress[x] : -# 148| r0_14(float) = Load : r0_13, m0_10 -# 148| r0_15(float) = Constant[1.0] : -# 148| r0_16(float) = Sub : r0_14, r0_15 -# 148| m0_17(float) = Store : r0_13, r0_16 -# 148| r0_18(glval) = VariableAddress[y] : -# 148| m0_19(float) = Store : r0_18, r0_16 -# 149| r0_20(glval) = VariableAddress[x] : -# 149| r0_21(float) = Load : r0_20, m0_17 -# 149| r0_22(float) = Constant[1.0] : -# 149| r0_23(float) = Add : r0_21, r0_22 -# 149| m0_24(float) = Store : r0_20, r0_23 -# 149| r0_25(glval) = VariableAddress[y] : -# 149| m0_26(float) = Store : r0_25, r0_21 -# 150| r0_27(glval) = VariableAddress[x] : -# 150| r0_28(float) = Load : r0_27, m0_24 -# 150| r0_29(float) = Constant[1.0] : -# 150| r0_30(float) = Sub : r0_28, r0_29 -# 150| m0_31(float) = Store : r0_27, r0_30 -# 150| r0_32(glval) = VariableAddress[y] : -# 150| m0_33(float) = Store : r0_32, r0_28 -# 151| v0_34(void) = NoOp : -# 144| v0_35(void) = ReturnVoid : -# 144| v0_36(void) = UnmodeledUse : mu* -# 144| v0_37(void) = ExitFunction : +# 144| m0_1(unknown) = AliasedDefinition : +# 144| mu0_2(unknown) = UnmodeledDefinition : +# 144| r0_3(glval) = VariableAddress[x] : +# 144| m0_4(float) = InitializeParameter[x] : r0_3 +# 145| r0_5(glval) = VariableAddress[y] : +# 145| m0_6(float) = Uninitialized : r0_5 +# 147| r0_7(glval) = VariableAddress[x] : +# 147| r0_8(float) = Load : r0_7, m0_4 +# 147| r0_9(float) = Constant[1.0] : +# 147| r0_10(float) = Add : r0_8, r0_9 +# 147| m0_11(float) = Store : r0_7, r0_10 +# 147| r0_12(glval) = VariableAddress[y] : +# 147| m0_13(float) = Store : r0_12, r0_10 +# 148| r0_14(glval) = VariableAddress[x] : +# 148| r0_15(float) = Load : r0_14, m0_11 +# 148| r0_16(float) = Constant[1.0] : +# 148| r0_17(float) = Sub : r0_15, r0_16 +# 148| m0_18(float) = Store : r0_14, r0_17 +# 148| r0_19(glval) = VariableAddress[y] : +# 148| m0_20(float) = Store : r0_19, r0_17 +# 149| r0_21(glval) = VariableAddress[x] : +# 149| r0_22(float) = Load : r0_21, m0_18 +# 149| r0_23(float) = Constant[1.0] : +# 149| r0_24(float) = Add : r0_22, r0_23 +# 149| m0_25(float) = Store : r0_21, r0_24 +# 149| r0_26(glval) = VariableAddress[y] : +# 149| m0_27(float) = Store : r0_26, r0_22 +# 150| r0_28(glval) = VariableAddress[x] : +# 150| r0_29(float) = Load : r0_28, m0_25 +# 150| r0_30(float) = Constant[1.0] : +# 150| r0_31(float) = Sub : r0_29, r0_30 +# 150| m0_32(float) = Store : r0_28, r0_31 +# 150| r0_33(glval) = VariableAddress[y] : +# 150| m0_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) = ExitFunction : # 153| PointerOps(int *, int) -> void # 153| Block 0 # 153| v0_0(void) = EnterFunction : -# 153| mu0_1(unknown) = UnmodeledDefinition : -# 153| r0_2(glval) = VariableAddress[p] : -# 153| m0_3(int *) = InitializeParameter[p] : r0_2 -# 153| r0_4(glval) = VariableAddress[i] : -# 153| m0_5(int) = InitializeParameter[i] : r0_4 -# 154| r0_6(glval) = VariableAddress[q] : -# 154| m0_7(int *) = Uninitialized : r0_6 -# 155| r0_8(glval) = VariableAddress[b] : -# 155| m0_9(bool) = Uninitialized : r0_8 -# 157| r0_10(glval) = VariableAddress[p] : -# 157| r0_11(int *) = Load : r0_10, m0_3 -# 157| r0_12(glval) = VariableAddress[i] : -# 157| r0_13(int) = Load : r0_12, m0_5 -# 157| r0_14(int *) = PointerAdd[4] : r0_11, r0_13 -# 157| r0_15(glval) = VariableAddress[q] : -# 157| m0_16(int *) = Store : r0_15, r0_14 -# 158| r0_17(glval) = VariableAddress[i] : -# 158| r0_18(int) = Load : r0_17, m0_5 -# 158| r0_19(glval) = VariableAddress[p] : -# 158| r0_20(int *) = Load : r0_19, m0_3 -# 158| r0_21(int *) = PointerAdd[4] : r0_20, r0_18 -# 158| r0_22(glval) = VariableAddress[q] : -# 158| m0_23(int *) = Store : r0_22, r0_21 -# 159| r0_24(glval) = VariableAddress[p] : -# 159| r0_25(int *) = Load : r0_24, m0_3 -# 159| r0_26(glval) = VariableAddress[i] : -# 159| r0_27(int) = Load : r0_26, m0_5 -# 159| r0_28(int *) = PointerSub[4] : r0_25, r0_27 -# 159| r0_29(glval) = VariableAddress[q] : -# 159| m0_30(int *) = Store : r0_29, r0_28 -# 160| r0_31(glval) = VariableAddress[p] : -# 160| r0_32(int *) = Load : r0_31, m0_3 -# 160| r0_33(glval) = VariableAddress[q] : -# 160| r0_34(int *) = Load : r0_33, m0_30 -# 160| r0_35(long) = PointerDiff[4] : r0_32, r0_34 -# 160| r0_36(int) = Convert : r0_35 -# 160| r0_37(glval) = VariableAddress[i] : -# 160| m0_38(int) = Store : r0_37, r0_36 -# 162| r0_39(glval) = VariableAddress[p] : -# 162| r0_40(int *) = Load : r0_39, m0_3 -# 162| r0_41(glval) = VariableAddress[q] : -# 162| m0_42(int *) = Store : r0_41, r0_40 -# 164| r0_43(glval) = VariableAddress[i] : -# 164| r0_44(int) = Load : r0_43, m0_38 -# 164| r0_45(glval) = VariableAddress[q] : -# 164| r0_46(int *) = Load : r0_45, m0_42 -# 164| r0_47(int *) = PointerAdd[4] : r0_46, r0_44 -# 164| m0_48(int *) = Store : r0_45, r0_47 -# 165| r0_49(glval) = VariableAddress[i] : -# 165| r0_50(int) = Load : r0_49, m0_38 -# 165| r0_51(glval) = VariableAddress[q] : -# 165| r0_52(int *) = Load : r0_51, m0_48 -# 165| r0_53(int *) = PointerSub[4] : r0_52, r0_50 -# 165| m0_54(int *) = Store : r0_51, r0_53 -# 167| r0_55(glval) = VariableAddress[p] : -# 167| r0_56(int *) = Load : r0_55, m0_3 -# 167| r0_57(int *) = Constant[0] : -# 167| r0_58(bool) = CompareNE : r0_56, r0_57 -# 167| r0_59(glval) = VariableAddress[b] : -# 167| m0_60(bool) = Store : r0_59, r0_58 -# 168| r0_61(glval) = VariableAddress[p] : -# 168| r0_62(int *) = Load : r0_61, m0_3 -# 168| r0_63(int *) = Constant[0] : -# 168| r0_64(bool) = CompareNE : r0_62, r0_63 -# 168| r0_65(bool) = LogicalNot : r0_64 -# 168| r0_66(glval) = VariableAddress[b] : -# 168| m0_67(bool) = Store : r0_66, r0_65 -# 169| v0_68(void) = NoOp : -# 153| v0_69(void) = ReturnVoid : -# 153| v0_70(void) = UnmodeledUse : mu* -# 153| v0_71(void) = ExitFunction : +# 153| m0_1(unknown) = AliasedDefinition : +# 153| mu0_2(unknown) = UnmodeledDefinition : +# 153| r0_3(glval) = VariableAddress[p] : +# 153| m0_4(int *) = InitializeParameter[p] : r0_3 +# 153| r0_5(glval) = VariableAddress[i] : +# 153| m0_6(int) = InitializeParameter[i] : r0_5 +# 154| r0_7(glval) = VariableAddress[q] : +# 154| m0_8(int *) = Uninitialized : r0_7 +# 155| r0_9(glval) = VariableAddress[b] : +# 155| m0_10(bool) = Uninitialized : r0_9 +# 157| r0_11(glval) = VariableAddress[p] : +# 157| r0_12(int *) = Load : r0_11, m0_4 +# 157| r0_13(glval) = VariableAddress[i] : +# 157| r0_14(int) = Load : r0_13, m0_6 +# 157| r0_15(int *) = PointerAdd[4] : r0_12, r0_14 +# 157| r0_16(glval) = VariableAddress[q] : +# 157| m0_17(int *) = Store : r0_16, r0_15 +# 158| r0_18(glval) = VariableAddress[i] : +# 158| r0_19(int) = Load : r0_18, m0_6 +# 158| r0_20(glval) = VariableAddress[p] : +# 158| r0_21(int *) = Load : r0_20, m0_4 +# 158| r0_22(int *) = PointerAdd[4] : r0_21, r0_19 +# 158| r0_23(glval) = VariableAddress[q] : +# 158| m0_24(int *) = Store : r0_23, r0_22 +# 159| r0_25(glval) = VariableAddress[p] : +# 159| r0_26(int *) = Load : r0_25, m0_4 +# 159| r0_27(glval) = VariableAddress[i] : +# 159| r0_28(int) = Load : r0_27, m0_6 +# 159| r0_29(int *) = PointerSub[4] : r0_26, r0_28 +# 159| r0_30(glval) = VariableAddress[q] : +# 159| m0_31(int *) = Store : r0_30, r0_29 +# 160| r0_32(glval) = VariableAddress[p] : +# 160| r0_33(int *) = Load : r0_32, m0_4 +# 160| r0_34(glval) = VariableAddress[q] : +# 160| r0_35(int *) = Load : r0_34, m0_31 +# 160| r0_36(long) = PointerDiff[4] : r0_33, r0_35 +# 160| r0_37(int) = Convert : r0_36 +# 160| r0_38(glval) = VariableAddress[i] : +# 160| m0_39(int) = Store : r0_38, r0_37 +# 162| r0_40(glval) = VariableAddress[p] : +# 162| r0_41(int *) = Load : r0_40, m0_4 +# 162| r0_42(glval) = VariableAddress[q] : +# 162| m0_43(int *) = Store : r0_42, r0_41 +# 164| r0_44(glval) = VariableAddress[i] : +# 164| r0_45(int) = Load : r0_44, m0_39 +# 164| r0_46(glval) = VariableAddress[q] : +# 164| r0_47(int *) = Load : r0_46, m0_43 +# 164| r0_48(int *) = PointerAdd[4] : r0_47, r0_45 +# 164| m0_49(int *) = Store : r0_46, r0_48 +# 165| r0_50(glval) = VariableAddress[i] : +# 165| r0_51(int) = Load : r0_50, m0_39 +# 165| r0_52(glval) = VariableAddress[q] : +# 165| r0_53(int *) = Load : r0_52, m0_49 +# 165| r0_54(int *) = PointerSub[4] : r0_53, r0_51 +# 165| m0_55(int *) = Store : r0_52, r0_54 +# 167| r0_56(glval) = VariableAddress[p] : +# 167| r0_57(int *) = Load : r0_56, m0_4 +# 167| r0_58(int *) = Constant[0] : +# 167| r0_59(bool) = CompareNE : r0_57, r0_58 +# 167| r0_60(glval) = VariableAddress[b] : +# 167| m0_61(bool) = Store : r0_60, r0_59 +# 168| r0_62(glval) = VariableAddress[p] : +# 168| r0_63(int *) = Load : r0_62, m0_4 +# 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| m0_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) = ExitFunction : # 171| ArrayAccess(int *, int) -> void # 171| Block 0 # 171| v0_0(void) = EnterFunction : -# 171| mu0_1(unknown) = UnmodeledDefinition : -# 171| r0_2(glval) = VariableAddress[p] : -# 171| m0_3(int *) = InitializeParameter[p] : r0_2 -# 171| r0_4(glval) = VariableAddress[i] : -# 171| m0_5(int) = InitializeParameter[i] : r0_4 -# 172| r0_6(glval) = VariableAddress[x] : -# 172| m0_7(int) = Uninitialized : r0_6 -# 174| r0_8(glval) = VariableAddress[p] : -# 174| r0_9(int *) = Load : r0_8, m0_3 -# 174| r0_10(glval) = VariableAddress[i] : -# 174| r0_11(int) = Load : r0_10, m0_5 -# 174| r0_12(int *) = PointerAdd[4] : r0_9, r0_11 -# 174| r0_13(int) = Load : r0_12, mu0_1 -# 174| r0_14(glval) = VariableAddress[x] : -# 174| m0_15(int) = Store : r0_14, r0_13 -# 175| r0_16(glval) = VariableAddress[p] : -# 175| r0_17(int *) = Load : r0_16, m0_3 -# 175| r0_18(glval) = VariableAddress[i] : -# 175| r0_19(int) = Load : r0_18, m0_5 -# 175| r0_20(int *) = PointerAdd[4] : r0_17, r0_19 -# 175| r0_21(int) = Load : r0_20, mu0_1 -# 175| r0_22(glval) = VariableAddress[x] : -# 175| m0_23(int) = Store : r0_22, r0_21 -# 177| r0_24(glval) = VariableAddress[x] : -# 177| r0_25(int) = Load : r0_24, m0_23 -# 177| r0_26(glval) = VariableAddress[p] : -# 177| r0_27(int *) = Load : r0_26, m0_3 -# 177| r0_28(glval) = VariableAddress[i] : -# 177| r0_29(int) = Load : r0_28, m0_5 -# 177| r0_30(int *) = PointerAdd[4] : r0_27, r0_29 -# 177| mu0_31(int) = Store : r0_30, r0_25 -# 178| r0_32(glval) = VariableAddress[x] : -# 178| r0_33(int) = Load : r0_32, m0_23 -# 178| r0_34(glval) = VariableAddress[p] : -# 178| r0_35(int *) = Load : r0_34, m0_3 -# 178| r0_36(glval) = VariableAddress[i] : -# 178| r0_37(int) = Load : r0_36, m0_5 -# 178| r0_38(int *) = PointerAdd[4] : r0_35, r0_37 -# 178| mu0_39(int) = Store : r0_38, r0_33 -# 180| r0_40(glval) = VariableAddress[a] : -# 180| m0_41(int[10]) = Uninitialized : r0_40 -# 181| r0_42(glval) = VariableAddress[a] : -# 181| r0_43(int *) = Convert : r0_42 -# 181| r0_44(glval) = VariableAddress[i] : -# 181| r0_45(int) = Load : r0_44, m0_5 -# 181| r0_46(int *) = PointerAdd[4] : r0_43, r0_45 -# 181| r0_47(int) = Load : r0_46, mu0_1 -# 181| r0_48(glval) = VariableAddress[x] : -# 181| m0_49(int) = Store : r0_48, r0_47 -# 182| r0_50(glval) = VariableAddress[a] : -# 182| r0_51(int *) = Convert : r0_50 -# 182| r0_52(glval) = VariableAddress[i] : -# 182| r0_53(int) = Load : r0_52, m0_5 -# 182| r0_54(int *) = PointerAdd[4] : r0_51, r0_53 -# 182| r0_55(int) = Load : r0_54, mu0_1 -# 182| r0_56(glval) = VariableAddress[x] : -# 182| m0_57(int) = Store : r0_56, r0_55 -# 183| r0_58(glval) = VariableAddress[x] : -# 183| r0_59(int) = Load : r0_58, m0_57 -# 183| r0_60(glval) = VariableAddress[a] : -# 183| r0_61(int *) = Convert : r0_60 -# 183| r0_62(glval) = VariableAddress[i] : -# 183| r0_63(int) = Load : r0_62, m0_5 -# 183| r0_64(int *) = PointerAdd[4] : r0_61, r0_63 -# 183| mu0_65(int) = Store : r0_64, r0_59 -# 184| r0_66(glval) = VariableAddress[x] : -# 184| r0_67(int) = Load : r0_66, m0_57 -# 184| r0_68(glval) = VariableAddress[a] : -# 184| r0_69(int *) = Convert : r0_68 -# 184| r0_70(glval) = VariableAddress[i] : -# 184| r0_71(int) = Load : r0_70, m0_5 -# 184| r0_72(int *) = PointerAdd[4] : r0_69, r0_71 -# 184| mu0_73(int) = Store : r0_72, r0_67 -# 185| v0_74(void) = NoOp : -# 171| v0_75(void) = ReturnVoid : -# 171| v0_76(void) = UnmodeledUse : mu* -# 171| v0_77(void) = ExitFunction : +# 171| m0_1(unknown) = AliasedDefinition : +# 171| mu0_2(unknown) = UnmodeledDefinition : +# 171| r0_3(glval) = VariableAddress[p] : +# 171| m0_4(int *) = InitializeParameter[p] : r0_3 +# 171| r0_5(glval) = VariableAddress[i] : +# 171| m0_6(int) = InitializeParameter[i] : r0_5 +# 172| r0_7(glval) = VariableAddress[x] : +# 172| m0_8(int) = Uninitialized : r0_7 +# 174| r0_9(glval) = VariableAddress[p] : +# 174| r0_10(int *) = Load : r0_9, m0_4 +# 174| r0_11(glval) = VariableAddress[i] : +# 174| r0_12(int) = Load : r0_11, m0_6 +# 174| r0_13(int *) = PointerAdd[4] : r0_10, r0_12 +# 174| r0_14(int) = Load : r0_13, m0_1 +# 174| r0_15(glval) = VariableAddress[x] : +# 174| m0_16(int) = Store : r0_15, r0_14 +# 175| r0_17(glval) = VariableAddress[p] : +# 175| r0_18(int *) = Load : r0_17, m0_4 +# 175| r0_19(glval) = VariableAddress[i] : +# 175| r0_20(int) = Load : r0_19, m0_6 +# 175| r0_21(int *) = PointerAdd[4] : r0_18, r0_20 +# 175| r0_22(int) = Load : r0_21, m0_1 +# 175| r0_23(glval) = VariableAddress[x] : +# 175| m0_24(int) = Store : r0_23, r0_22 +# 177| r0_25(glval) = VariableAddress[x] : +# 177| r0_26(int) = Load : r0_25, m0_24 +# 177| r0_27(glval) = VariableAddress[p] : +# 177| r0_28(int *) = Load : r0_27, m0_4 +# 177| r0_29(glval) = VariableAddress[i] : +# 177| r0_30(int) = Load : r0_29, m0_6 +# 177| r0_31(int *) = PointerAdd[4] : r0_28, r0_30 +# 177| m0_32(int) = Store : r0_31, r0_26 +# 177| m0_33(unknown) = Chi : m0_1, m0_32 +# 178| r0_34(glval) = VariableAddress[x] : +# 178| r0_35(int) = Load : r0_34, m0_24 +# 178| r0_36(glval) = VariableAddress[p] : +# 178| r0_37(int *) = Load : r0_36, m0_4 +# 178| r0_38(glval) = VariableAddress[i] : +# 178| r0_39(int) = Load : r0_38, m0_6 +# 178| r0_40(int *) = PointerAdd[4] : r0_37, r0_39 +# 178| m0_41(int) = Store : r0_40, r0_35 +# 178| m0_42(unknown) = Chi : m0_33, m0_41 +# 180| r0_43(glval) = VariableAddress[a] : +# 180| m0_44(int[10]) = Uninitialized : r0_43 +# 181| r0_45(glval) = VariableAddress[a] : +# 181| r0_46(int *) = Convert : r0_45 +# 181| r0_47(glval) = VariableAddress[i] : +# 181| r0_48(int) = Load : r0_47, m0_6 +# 181| r0_49(int *) = PointerAdd[4] : r0_46, r0_48 +# 181| r0_50(int) = Load : r0_49, mu0_2 +# 181| r0_51(glval) = VariableAddress[x] : +# 181| m0_52(int) = Store : r0_51, r0_50 +# 182| r0_53(glval) = VariableAddress[a] : +# 182| r0_54(int *) = Convert : r0_53 +# 182| r0_55(glval) = VariableAddress[i] : +# 182| r0_56(int) = Load : r0_55, m0_6 +# 182| r0_57(int *) = PointerAdd[4] : r0_54, r0_56 +# 182| r0_58(int) = Load : r0_57, mu0_2 +# 182| r0_59(glval) = VariableAddress[x] : +# 182| m0_60(int) = Store : r0_59, r0_58 +# 183| r0_61(glval) = VariableAddress[x] : +# 183| r0_62(int) = Load : r0_61, m0_60 +# 183| r0_63(glval) = VariableAddress[a] : +# 183| r0_64(int *) = Convert : r0_63 +# 183| r0_65(glval) = VariableAddress[i] : +# 183| r0_66(int) = Load : r0_65, m0_6 +# 183| r0_67(int *) = PointerAdd[4] : r0_64, r0_66 +# 183| m0_68(int) = Store : r0_67, r0_62 +# 183| m0_69(int[10]) = Chi : m0_44, m0_68 +# 184| r0_70(glval) = VariableAddress[x] : +# 184| r0_71(int) = Load : r0_70, m0_60 +# 184| r0_72(glval) = VariableAddress[a] : +# 184| r0_73(int *) = Convert : r0_72 +# 184| r0_74(glval) = VariableAddress[i] : +# 184| r0_75(int) = Load : r0_74, m0_6 +# 184| r0_76(int *) = PointerAdd[4] : r0_73, r0_75 +# 184| m0_77(int) = Store : r0_76, r0_71 +# 184| m0_78(int[10]) = Chi : m0_69, m0_77 +# 185| v0_79(void) = NoOp : +# 171| v0_80(void) = ReturnVoid : +# 171| v0_81(void) = UnmodeledUse : mu* +# 171| v0_82(void) = ExitFunction : # 187| StringLiteral(int) -> void # 187| Block 0 # 187| v0_0(void) = EnterFunction : -# 187| mu0_1(unknown) = UnmodeledDefinition : -# 187| r0_2(glval) = VariableAddress[i] : -# 187| m0_3(int) = InitializeParameter[i] : r0_2 -# 188| r0_4(glval) = VariableAddress[c] : -# 188| r0_5(glval) = StringConstant["Foo"] : -# 188| r0_6(char *) = Convert : r0_5 -# 188| r0_7(glval) = VariableAddress[i] : -# 188| r0_8(int) = Load : r0_7, m0_3 -# 188| r0_9(char *) = PointerAdd[1] : r0_6, r0_8 -# 188| r0_10(char) = Load : r0_9, mu0_1 -# 188| m0_11(char) = Store : r0_4, r0_10 -# 189| r0_12(glval) = VariableAddress[pwc] : -# 189| r0_13(glval) = StringConstant[L"Bar"] : -# 189| r0_14(wchar_t *) = Convert : r0_13 +# 187| m0_1(unknown) = AliasedDefinition : +# 187| mu0_2(unknown) = UnmodeledDefinition : +# 187| r0_3(glval) = VariableAddress[i] : +# 187| m0_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, m0_4 +# 188| r0_10(char *) = PointerAdd[1] : r0_7, r0_9 +# 188| r0_11(char) = Load : r0_10, m0_1 +# 188| m0_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| m0_16(wchar_t *) = Store : r0_12, r0_15 -# 190| r0_17(glval) = VariableAddress[wc] : -# 190| r0_18(glval) = VariableAddress[pwc] : -# 190| r0_19(wchar_t *) = Load : r0_18, m0_16 -# 190| r0_20(glval) = VariableAddress[i] : -# 190| r0_21(int) = Load : r0_20, m0_3 -# 190| r0_22(wchar_t *) = PointerAdd[4] : r0_19, r0_21 -# 190| r0_23(wchar_t) = Load : r0_22, mu0_1 -# 190| m0_24(wchar_t) = Store : r0_17, r0_23 -# 191| v0_25(void) = NoOp : -# 187| v0_26(void) = ReturnVoid : -# 187| v0_27(void) = UnmodeledUse : mu* -# 187| v0_28(void) = ExitFunction : +# 189| r0_16(wchar_t *) = Convert : r0_15 +# 189| m0_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, m0_17 +# 190| r0_21(glval) = VariableAddress[i] : +# 190| r0_22(int) = Load : r0_21, m0_4 +# 190| r0_23(wchar_t *) = PointerAdd[4] : r0_20, r0_22 +# 190| r0_24(wchar_t) = Load : r0_23, m0_1 +# 190| m0_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) = ExitFunction : # 193| PointerCompare(int *, int *) -> void # 193| Block 0 # 193| v0_0(void) = EnterFunction : -# 193| mu0_1(unknown) = UnmodeledDefinition : -# 193| r0_2(glval) = VariableAddress[p] : -# 193| m0_3(int *) = InitializeParameter[p] : r0_2 -# 193| r0_4(glval) = VariableAddress[q] : -# 193| m0_5(int *) = InitializeParameter[q] : r0_4 -# 194| r0_6(glval) = VariableAddress[b] : -# 194| m0_7(bool) = Uninitialized : r0_6 -# 196| r0_8(glval) = VariableAddress[p] : -# 196| r0_9(int *) = Load : r0_8, m0_3 -# 196| r0_10(glval) = VariableAddress[q] : -# 196| r0_11(int *) = Load : r0_10, m0_5 -# 196| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 196| r0_13(glval) = VariableAddress[b] : -# 196| m0_14(bool) = Store : r0_13, r0_12 -# 197| r0_15(glval) = VariableAddress[p] : -# 197| r0_16(int *) = Load : r0_15, m0_3 -# 197| r0_17(glval) = VariableAddress[q] : -# 197| r0_18(int *) = Load : r0_17, m0_5 -# 197| r0_19(bool) = CompareNE : r0_16, r0_18 -# 197| r0_20(glval) = VariableAddress[b] : -# 197| m0_21(bool) = Store : r0_20, r0_19 -# 198| r0_22(glval) = VariableAddress[p] : -# 198| r0_23(int *) = Load : r0_22, m0_3 -# 198| r0_24(glval) = VariableAddress[q] : -# 198| r0_25(int *) = Load : r0_24, m0_5 -# 198| r0_26(bool) = CompareLT : r0_23, r0_25 -# 198| r0_27(glval) = VariableAddress[b] : -# 198| m0_28(bool) = Store : r0_27, r0_26 -# 199| r0_29(glval) = VariableAddress[p] : -# 199| r0_30(int *) = Load : r0_29, m0_3 -# 199| r0_31(glval) = VariableAddress[q] : -# 199| r0_32(int *) = Load : r0_31, m0_5 -# 199| r0_33(bool) = CompareGT : r0_30, r0_32 -# 199| r0_34(glval) = VariableAddress[b] : -# 199| m0_35(bool) = Store : r0_34, r0_33 -# 200| r0_36(glval) = VariableAddress[p] : -# 200| r0_37(int *) = Load : r0_36, m0_3 -# 200| r0_38(glval) = VariableAddress[q] : -# 200| r0_39(int *) = Load : r0_38, m0_5 -# 200| r0_40(bool) = CompareLE : r0_37, r0_39 -# 200| r0_41(glval) = VariableAddress[b] : -# 200| m0_42(bool) = Store : r0_41, r0_40 -# 201| r0_43(glval) = VariableAddress[p] : -# 201| r0_44(int *) = Load : r0_43, m0_3 -# 201| r0_45(glval) = VariableAddress[q] : -# 201| r0_46(int *) = Load : r0_45, m0_5 -# 201| r0_47(bool) = CompareGE : r0_44, r0_46 -# 201| r0_48(glval) = VariableAddress[b] : -# 201| m0_49(bool) = Store : r0_48, r0_47 -# 202| v0_50(void) = NoOp : -# 193| v0_51(void) = ReturnVoid : -# 193| v0_52(void) = UnmodeledUse : mu* -# 193| v0_53(void) = ExitFunction : +# 193| m0_1(unknown) = AliasedDefinition : +# 193| mu0_2(unknown) = UnmodeledDefinition : +# 193| r0_3(glval) = VariableAddress[p] : +# 193| m0_4(int *) = InitializeParameter[p] : r0_3 +# 193| r0_5(glval) = VariableAddress[q] : +# 193| m0_6(int *) = InitializeParameter[q] : r0_5 +# 194| r0_7(glval) = VariableAddress[b] : +# 194| m0_8(bool) = Uninitialized : r0_7 +# 196| r0_9(glval) = VariableAddress[p] : +# 196| r0_10(int *) = Load : r0_9, m0_4 +# 196| r0_11(glval) = VariableAddress[q] : +# 196| r0_12(int *) = Load : r0_11, m0_6 +# 196| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 196| r0_14(glval) = VariableAddress[b] : +# 196| m0_15(bool) = Store : r0_14, r0_13 +# 197| r0_16(glval) = VariableAddress[p] : +# 197| r0_17(int *) = Load : r0_16, m0_4 +# 197| r0_18(glval) = VariableAddress[q] : +# 197| r0_19(int *) = Load : r0_18, m0_6 +# 197| r0_20(bool) = CompareNE : r0_17, r0_19 +# 197| r0_21(glval) = VariableAddress[b] : +# 197| m0_22(bool) = Store : r0_21, r0_20 +# 198| r0_23(glval) = VariableAddress[p] : +# 198| r0_24(int *) = Load : r0_23, m0_4 +# 198| r0_25(glval) = VariableAddress[q] : +# 198| r0_26(int *) = Load : r0_25, m0_6 +# 198| r0_27(bool) = CompareLT : r0_24, r0_26 +# 198| r0_28(glval) = VariableAddress[b] : +# 198| m0_29(bool) = Store : r0_28, r0_27 +# 199| r0_30(glval) = VariableAddress[p] : +# 199| r0_31(int *) = Load : r0_30, m0_4 +# 199| r0_32(glval) = VariableAddress[q] : +# 199| r0_33(int *) = Load : r0_32, m0_6 +# 199| r0_34(bool) = CompareGT : r0_31, r0_33 +# 199| r0_35(glval) = VariableAddress[b] : +# 199| m0_36(bool) = Store : r0_35, r0_34 +# 200| r0_37(glval) = VariableAddress[p] : +# 200| r0_38(int *) = Load : r0_37, m0_4 +# 200| r0_39(glval) = VariableAddress[q] : +# 200| r0_40(int *) = Load : r0_39, m0_6 +# 200| r0_41(bool) = CompareLE : r0_38, r0_40 +# 200| r0_42(glval) = VariableAddress[b] : +# 200| m0_43(bool) = Store : r0_42, r0_41 +# 201| r0_44(glval) = VariableAddress[p] : +# 201| r0_45(int *) = Load : r0_44, m0_4 +# 201| r0_46(glval) = VariableAddress[q] : +# 201| r0_47(int *) = Load : r0_46, m0_6 +# 201| r0_48(bool) = CompareGE : r0_45, r0_47 +# 201| r0_49(glval) = VariableAddress[b] : +# 201| m0_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) = ExitFunction : # 204| PointerCrement(int *) -> void # 204| Block 0 # 204| v0_0(void) = EnterFunction : -# 204| mu0_1(unknown) = UnmodeledDefinition : -# 204| r0_2(glval) = VariableAddress[p] : -# 204| m0_3(int *) = InitializeParameter[p] : r0_2 -# 205| r0_4(glval) = VariableAddress[q] : -# 205| m0_5(int *) = Uninitialized : r0_4 -# 207| r0_6(glval) = VariableAddress[p] : -# 207| r0_7(int *) = Load : r0_6, m0_3 -# 207| r0_8(int) = Constant[1] : -# 207| r0_9(int *) = PointerAdd[4] : r0_7, r0_8 -# 207| m0_10(int *) = Store : r0_6, r0_9 -# 207| r0_11(glval) = VariableAddress[q] : -# 207| m0_12(int *) = Store : r0_11, r0_9 -# 208| r0_13(glval) = VariableAddress[p] : -# 208| r0_14(int *) = Load : r0_13, m0_10 -# 208| r0_15(int) = Constant[1] : -# 208| r0_16(int *) = PointerSub[4] : r0_14, r0_15 -# 208| m0_17(int *) = Store : r0_13, r0_16 -# 208| r0_18(glval) = VariableAddress[q] : -# 208| m0_19(int *) = Store : r0_18, r0_16 -# 209| r0_20(glval) = VariableAddress[p] : -# 209| r0_21(int *) = Load : r0_20, m0_17 -# 209| r0_22(int) = Constant[1] : -# 209| r0_23(int *) = PointerAdd[4] : r0_21, r0_22 -# 209| m0_24(int *) = Store : r0_20, r0_23 -# 209| r0_25(glval) = VariableAddress[q] : -# 209| m0_26(int *) = Store : r0_25, r0_21 -# 210| r0_27(glval) = VariableAddress[p] : -# 210| r0_28(int *) = Load : r0_27, m0_24 -# 210| r0_29(int) = Constant[1] : -# 210| r0_30(int *) = PointerSub[4] : r0_28, r0_29 -# 210| m0_31(int *) = Store : r0_27, r0_30 -# 210| r0_32(glval) = VariableAddress[q] : -# 210| m0_33(int *) = Store : r0_32, r0_28 -# 211| v0_34(void) = NoOp : -# 204| v0_35(void) = ReturnVoid : -# 204| v0_36(void) = UnmodeledUse : mu* -# 204| v0_37(void) = ExitFunction : +# 204| m0_1(unknown) = AliasedDefinition : +# 204| mu0_2(unknown) = UnmodeledDefinition : +# 204| r0_3(glval) = VariableAddress[p] : +# 204| m0_4(int *) = InitializeParameter[p] : r0_3 +# 205| r0_5(glval) = VariableAddress[q] : +# 205| m0_6(int *) = Uninitialized : r0_5 +# 207| r0_7(glval) = VariableAddress[p] : +# 207| r0_8(int *) = Load : r0_7, m0_4 +# 207| r0_9(int) = Constant[1] : +# 207| r0_10(int *) = PointerAdd[4] : r0_8, r0_9 +# 207| m0_11(int *) = Store : r0_7, r0_10 +# 207| r0_12(glval) = VariableAddress[q] : +# 207| m0_13(int *) = Store : r0_12, r0_10 +# 208| r0_14(glval) = VariableAddress[p] : +# 208| r0_15(int *) = Load : r0_14, m0_11 +# 208| r0_16(int) = Constant[1] : +# 208| r0_17(int *) = PointerSub[4] : r0_15, r0_16 +# 208| m0_18(int *) = Store : r0_14, r0_17 +# 208| r0_19(glval) = VariableAddress[q] : +# 208| m0_20(int *) = Store : r0_19, r0_17 +# 209| r0_21(glval) = VariableAddress[p] : +# 209| r0_22(int *) = Load : r0_21, m0_18 +# 209| r0_23(int) = Constant[1] : +# 209| r0_24(int *) = PointerAdd[4] : r0_22, r0_23 +# 209| m0_25(int *) = Store : r0_21, r0_24 +# 209| r0_26(glval) = VariableAddress[q] : +# 209| m0_27(int *) = Store : r0_26, r0_22 +# 210| r0_28(glval) = VariableAddress[p] : +# 210| r0_29(int *) = Load : r0_28, m0_25 +# 210| r0_30(int) = Constant[1] : +# 210| r0_31(int *) = PointerSub[4] : r0_29, r0_30 +# 210| m0_32(int *) = Store : r0_28, r0_31 +# 210| r0_33(glval) = VariableAddress[q] : +# 210| m0_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) = ExitFunction : # 213| CompoundAssignment() -> void # 213| Block 0 # 213| v0_0(void) = EnterFunction : -# 213| mu0_1(unknown) = UnmodeledDefinition : -# 215| r0_2(glval) = VariableAddress[x] : -# 215| r0_3(int) = Constant[5] : -# 215| m0_4(int) = Store : r0_2, r0_3 -# 216| r0_5(int) = Constant[7] : -# 216| r0_6(glval) = VariableAddress[x] : -# 216| r0_7(int) = Load : r0_6, m0_4 -# 216| r0_8(int) = Add : r0_7, r0_5 -# 216| m0_9(int) = Store : r0_6, r0_8 -# 219| r0_10(glval) = VariableAddress[y] : -# 219| r0_11(short) = Constant[5] : -# 219| m0_12(short) = Store : r0_10, r0_11 -# 220| r0_13(glval) = VariableAddress[x] : -# 220| r0_14(int) = Load : r0_13, m0_9 -# 220| r0_15(glval) = VariableAddress[y] : -# 220| r0_16(short) = Load : r0_15, m0_12 -# 220| r0_17(int) = Convert : r0_16 -# 220| r0_18(int) = Add : r0_17, r0_14 -# 220| r0_19(short) = Convert : r0_18 -# 220| m0_20(short) = Store : r0_15, r0_19 -# 223| r0_21(int) = Constant[1] : -# 223| r0_22(glval) = VariableAddress[y] : -# 223| r0_23(short) = Load : r0_22, m0_20 -# 223| r0_24(short) = ShiftLeft : r0_23, r0_21 -# 223| m0_25(short) = Store : r0_22, r0_24 -# 226| r0_26(glval) = VariableAddress[z] : -# 226| r0_27(long) = Constant[7] : -# 226| m0_28(long) = Store : r0_26, r0_27 -# 227| r0_29(float) = Constant[2.0] : -# 227| r0_30(glval) = VariableAddress[z] : -# 227| r0_31(long) = Load : r0_30, m0_28 -# 227| r0_32(float) = Convert : r0_31 -# 227| r0_33(float) = Add : r0_32, r0_29 -# 227| r0_34(long) = Convert : r0_33 -# 227| m0_35(long) = Store : r0_30, r0_34 -# 228| v0_36(void) = NoOp : -# 213| v0_37(void) = ReturnVoid : -# 213| v0_38(void) = UnmodeledUse : mu* -# 213| v0_39(void) = ExitFunction : +# 213| m0_1(unknown) = AliasedDefinition : +# 213| mu0_2(unknown) = UnmodeledDefinition : +# 215| r0_3(glval) = VariableAddress[x] : +# 215| r0_4(int) = Constant[5] : +# 215| m0_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, m0_5 +# 216| r0_9(int) = Add : r0_8, r0_6 +# 216| m0_10(int) = Store : r0_7, r0_9 +# 219| r0_11(glval) = VariableAddress[y] : +# 219| r0_12(short) = Constant[5] : +# 219| m0_13(short) = Store : r0_11, r0_12 +# 220| r0_14(glval) = VariableAddress[x] : +# 220| r0_15(int) = Load : r0_14, m0_10 +# 220| r0_16(glval) = VariableAddress[y] : +# 220| r0_17(short) = Load : r0_16, m0_13 +# 220| r0_18(int) = Convert : r0_17 +# 220| r0_19(int) = Add : r0_18, r0_15 +# 220| r0_20(short) = Convert : r0_19 +# 220| m0_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, m0_21 +# 223| r0_25(short) = ShiftLeft : r0_24, r0_22 +# 223| m0_26(short) = Store : r0_23, r0_25 +# 226| r0_27(glval) = VariableAddress[z] : +# 226| r0_28(long) = Constant[7] : +# 226| m0_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, m0_29 +# 227| r0_33(float) = Convert : r0_32 +# 227| r0_34(float) = Add : r0_33, r0_30 +# 227| r0_35(long) = Convert : r0_34 +# 227| m0_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) = ExitFunction : # 230| UninitializedVariables() -> void # 230| Block 0 # 230| v0_0(void) = EnterFunction : -# 230| mu0_1(unknown) = UnmodeledDefinition : -# 231| r0_2(glval) = VariableAddress[x] : -# 231| m0_3(int) = Uninitialized : r0_2 -# 232| r0_4(glval) = VariableAddress[y] : -# 232| r0_5(glval) = VariableAddress[x] : -# 232| r0_6(int) = Load : r0_5, m0_3 -# 232| m0_7(int) = Store : r0_4, r0_6 -# 233| v0_8(void) = NoOp : -# 230| v0_9(void) = ReturnVoid : -# 230| v0_10(void) = UnmodeledUse : mu* -# 230| v0_11(void) = ExitFunction : +# 230| m0_1(unknown) = AliasedDefinition : +# 230| mu0_2(unknown) = UnmodeledDefinition : +# 231| r0_3(glval) = VariableAddress[x] : +# 231| m0_4(int) = Uninitialized : r0_3 +# 232| r0_5(glval) = VariableAddress[y] : +# 232| r0_6(glval) = VariableAddress[x] : +# 232| r0_7(int) = Load : r0_6, m0_4 +# 232| m0_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) = ExitFunction : # 235| Parameters(int, int) -> int # 235| Block 0 # 235| v0_0(void) = EnterFunction : -# 235| mu0_1(unknown) = UnmodeledDefinition : -# 235| r0_2(glval) = VariableAddress[x] : -# 235| m0_3(int) = InitializeParameter[x] : r0_2 -# 235| r0_4(glval) = VariableAddress[y] : -# 235| m0_5(int) = InitializeParameter[y] : r0_4 -# 236| r0_6(glval) = VariableAddress[#return] : -# 236| r0_7(glval) = VariableAddress[x] : -# 236| r0_8(int) = Load : r0_7, m0_3 -# 236| r0_9(glval) = VariableAddress[y] : -# 236| r0_10(int) = Load : r0_9, m0_5 -# 236| r0_11(int) = Rem : r0_8, r0_10 -# 236| m0_12(int) = Store : r0_6, r0_11 -# 235| r0_13(glval) = VariableAddress[#return] : -# 235| v0_14(void) = ReturnValue : r0_13, m0_12 -# 235| v0_15(void) = UnmodeledUse : mu* -# 235| v0_16(void) = ExitFunction : +# 235| m0_1(unknown) = AliasedDefinition : +# 235| mu0_2(unknown) = UnmodeledDefinition : +# 235| r0_3(glval) = VariableAddress[x] : +# 235| m0_4(int) = InitializeParameter[x] : r0_3 +# 235| r0_5(glval) = VariableAddress[y] : +# 235| m0_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, m0_4 +# 236| r0_10(glval) = VariableAddress[y] : +# 236| r0_11(int) = Load : r0_10, m0_6 +# 236| r0_12(int) = Rem : r0_9, r0_11 +# 236| m0_13(int) = Store : r0_7, r0_12 +# 235| r0_14(glval) = VariableAddress[#return] : +# 235| v0_15(void) = ReturnValue : r0_14, m0_13 +# 235| v0_16(void) = UnmodeledUse : mu* +# 235| v0_17(void) = ExitFunction : # 239| IfStatements(bool, int, int) -> void # 239| Block 0 # 239| v0_0(void) = EnterFunction : -# 239| mu0_1(unknown) = UnmodeledDefinition : -# 239| r0_2(glval) = VariableAddress[b] : -# 239| m0_3(bool) = InitializeParameter[b] : r0_2 -# 239| r0_4(glval) = VariableAddress[x] : -# 239| m0_5(int) = InitializeParameter[x] : r0_4 -# 239| r0_6(glval) = VariableAddress[y] : -# 239| m0_7(int) = InitializeParameter[y] : r0_6 -# 240| r0_8(glval) = VariableAddress[b] : -# 240| r0_9(bool) = Load : r0_8, m0_3 -# 240| v0_10(void) = ConditionalBranch : r0_9 +# 239| m0_1(unknown) = AliasedDefinition : +# 239| mu0_2(unknown) = UnmodeledDefinition : +# 239| r0_3(glval) = VariableAddress[b] : +# 239| m0_4(bool) = InitializeParameter[b] : r0_3 +# 239| r0_5(glval) = VariableAddress[x] : +# 239| m0_6(int) = InitializeParameter[x] : r0_5 +# 239| r0_7(glval) = VariableAddress[y] : +# 239| m0_8(int) = InitializeParameter[y] : r0_7 +# 240| r0_9(glval) = VariableAddress[b] : +# 240| r0_10(bool) = Load : r0_9, m0_4 +# 240| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 7 # 243| Block 1 # 243| r1_0(glval) = VariableAddress[b] : -# 243| r1_1(bool) = Load : r1_0, m0_3 +# 243| r1_1(bool) = Load : r1_0, m0_4 # 243| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 # 244| Block 2 # 244| r2_0(glval) = VariableAddress[y] : -# 244| r2_1(int) = Load : r2_0, m0_7 +# 244| r2_1(int) = Load : r2_0, m0_8 # 244| r2_2(glval) = VariableAddress[x] : # 244| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 # 247| Block 3 -# 247| m3_0(int) = Phi : from 1:m0_5, from 2:m2_3 +# 247| m3_0(int) = Phi : from 1:m0_6, from 2:m2_3 # 247| r3_1(glval) = VariableAddress[x] : # 247| r3_2(int) = Load : r3_1, m3_0 # 247| r3_3(int) = Constant[7] : @@ -1075,9 +1102,10 @@ ir.cpp: # 253| WhileStatements(int) -> void # 253| Block 0 # 253| v0_0(void) = EnterFunction : -# 253| mu0_1(unknown) = UnmodeledDefinition : -# 253| r0_2(glval) = VariableAddress[n] : -# 253| m0_3(int) = InitializeParameter[n] : r0_2 +# 253| m0_1(unknown) = AliasedDefinition : +# 253| mu0_2(unknown) = UnmodeledDefinition : +# 253| r0_3(glval) = VariableAddress[n] : +# 253| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 3 # 255| Block 1 @@ -1095,7 +1123,7 @@ ir.cpp: # 253| v2_3(void) = ExitFunction : # 254| Block 3 -# 254| m3_0(int) = Phi : from 0:m0_3, from 1:m1_4 +# 254| m3_0(int) = Phi : from 0:m0_4, from 1:m1_4 # 254| r3_1(glval) = VariableAddress[n] : # 254| r3_2(int) = Load : r3_1, m3_0 # 254| r3_3(int) = Constant[0] : @@ -1107,13 +1135,14 @@ ir.cpp: # 259| DoStatements(int) -> void # 259| Block 0 # 259| v0_0(void) = EnterFunction : -# 259| mu0_1(unknown) = UnmodeledDefinition : -# 259| r0_2(glval) = VariableAddress[n] : -# 259| m0_3(int) = InitializeParameter[n] : r0_2 +# 259| m0_1(unknown) = AliasedDefinition : +# 259| mu0_2(unknown) = UnmodeledDefinition : +# 259| r0_3(glval) = VariableAddress[n] : +# 259| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 1 # 261| Block 1 -# 261| m1_0(int) = Phi : from 0:m0_3, from 1:m1_5 +# 261| m1_0(int) = Phi : from 0:m0_4, from 1:m1_5 # 261| r1_1(int) = Constant[1] : # 261| r1_2(glval) = VariableAddress[n] : # 261| r1_3(int) = Load : r1_2, m1_0 @@ -1136,9 +1165,10 @@ ir.cpp: # 265| For_Empty() -> void # 265| Block 0 # 265| v0_0(void) = EnterFunction : -# 265| mu0_1(unknown) = UnmodeledDefinition : -# 266| r0_2(glval) = VariableAddress[j] : -# 266| m0_3(int) = Uninitialized : r0_2 +# 265| m0_1(unknown) = AliasedDefinition : +# 265| mu0_2(unknown) = UnmodeledDefinition : +# 266| r0_3(glval) = VariableAddress[j] : +# 266| m0_4(int) = Uninitialized : r0_3 #-----| Goto -> Block 2 # 265| Block 1 @@ -1153,10 +1183,11 @@ ir.cpp: # 272| For_Init() -> void # 272| Block 0 # 272| v0_0(void) = EnterFunction : -# 272| mu0_1(unknown) = UnmodeledDefinition : -# 273| r0_2(glval) = VariableAddress[i] : -# 273| r0_3(int) = Constant[0] : -# 273| m0_4(int) = Store : r0_2, r0_3 +# 272| m0_1(unknown) = AliasedDefinition : +# 272| mu0_2(unknown) = UnmodeledDefinition : +# 273| r0_3(glval) = VariableAddress[i] : +# 273| r0_4(int) = Constant[0] : +# 273| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 272| Block 1 @@ -1171,15 +1202,16 @@ ir.cpp: # 278| For_Condition() -> void # 278| Block 0 # 278| v0_0(void) = EnterFunction : -# 278| mu0_1(unknown) = UnmodeledDefinition : -# 279| r0_2(glval) = VariableAddress[i] : -# 279| r0_3(int) = Constant[0] : -# 279| m0_4(int) = Store : r0_2, r0_3 +# 278| m0_1(unknown) = AliasedDefinition : +# 278| mu0_2(unknown) = UnmodeledDefinition : +# 279| r0_3(glval) = VariableAddress[i] : +# 279| r0_4(int) = Constant[0] : +# 279| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 280| Block 1 # 280| r1_0(glval) = VariableAddress[i] : -# 280| r1_1(int) = Load : r1_0, m0_4 +# 280| r1_1(int) = Load : r1_0, m0_5 # 280| r1_2(int) = Constant[10] : # 280| r1_3(bool) = CompareLT : r1_1, r1_2 # 280| v1_4(void) = ConditionalBranch : r1_3 @@ -1199,10 +1231,11 @@ ir.cpp: # 285| For_Update() -> void # 285| Block 0 # 285| v0_0(void) = EnterFunction : -# 285| mu0_1(unknown) = UnmodeledDefinition : -# 286| r0_2(glval) = VariableAddress[i] : -# 286| r0_3(int) = Constant[0] : -# 286| m0_4(int) = Store : r0_2, r0_3 +# 285| m0_1(unknown) = AliasedDefinition : +# 285| mu0_2(unknown) = UnmodeledDefinition : +# 286| r0_3(glval) = VariableAddress[i] : +# 286| r0_4(int) = Constant[0] : +# 286| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 285| Block 1 @@ -1211,7 +1244,7 @@ ir.cpp: # 285| v1_2(void) = ExitFunction : # 288| Block 2 -# 288| m2_0(int) = Phi : from 0:m0_4, from 2:m2_6 +# 288| m2_0(int) = Phi : from 0:m0_5, from 2:m2_6 # 288| v2_1(void) = NoOp : # 287| r2_2(int) = Constant[1] : # 287| r2_3(glval) = VariableAddress[i] : @@ -1223,15 +1256,16 @@ ir.cpp: # 292| For_InitCondition() -> void # 292| Block 0 # 292| v0_0(void) = EnterFunction : -# 292| mu0_1(unknown) = UnmodeledDefinition : -# 293| r0_2(glval) = VariableAddress[i] : -# 293| r0_3(int) = Constant[0] : -# 293| m0_4(int) = Store : r0_2, r0_3 +# 292| m0_1(unknown) = AliasedDefinition : +# 292| mu0_2(unknown) = UnmodeledDefinition : +# 293| r0_3(glval) = VariableAddress[i] : +# 293| r0_4(int) = Constant[0] : +# 293| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 293| Block 1 # 293| r1_0(glval) = VariableAddress[i] : -# 293| r1_1(int) = Load : r1_0, m0_4 +# 293| r1_1(int) = Load : r1_0, m0_5 # 293| r1_2(int) = Constant[10] : # 293| r1_3(bool) = CompareLT : r1_1, r1_2 # 293| v1_4(void) = ConditionalBranch : r1_3 @@ -1251,10 +1285,11 @@ ir.cpp: # 298| For_InitUpdate() -> void # 298| Block 0 # 298| v0_0(void) = EnterFunction : -# 298| mu0_1(unknown) = UnmodeledDefinition : -# 299| r0_2(glval) = VariableAddress[i] : -# 299| r0_3(int) = Constant[0] : -# 299| m0_4(int) = Store : r0_2, r0_3 +# 298| m0_1(unknown) = AliasedDefinition : +# 298| mu0_2(unknown) = UnmodeledDefinition : +# 299| r0_3(glval) = VariableAddress[i] : +# 299| r0_4(int) = Constant[0] : +# 299| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 298| Block 1 @@ -1263,7 +1298,7 @@ ir.cpp: # 298| v1_2(void) = ExitFunction : # 300| Block 2 -# 300| m2_0(int) = Phi : from 0:m0_4, from 2:m2_6 +# 300| m2_0(int) = Phi : from 0:m0_5, from 2:m2_6 # 300| v2_1(void) = NoOp : # 299| r2_2(int) = Constant[1] : # 299| r2_3(glval) = VariableAddress[i] : @@ -1275,14 +1310,15 @@ ir.cpp: # 304| For_ConditionUpdate() -> void # 304| Block 0 # 304| v0_0(void) = EnterFunction : -# 304| mu0_1(unknown) = UnmodeledDefinition : -# 305| r0_2(glval) = VariableAddress[i] : -# 305| r0_3(int) = Constant[0] : -# 305| m0_4(int) = Store : r0_2, r0_3 +# 304| m0_1(unknown) = AliasedDefinition : +# 304| mu0_2(unknown) = UnmodeledDefinition : +# 305| r0_3(glval) = VariableAddress[i] : +# 305| r0_4(int) = Constant[0] : +# 305| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 306| Block 1 -# 306| m1_0(int) = Phi : from 0:m0_4, from 2:m2_5 +# 306| m1_0(int) = Phi : from 0:m0_5, from 2:m2_5 # 306| r1_1(glval) = VariableAddress[i] : # 306| r1_2(int) = Load : r1_1, m1_0 # 306| r1_3(int) = Constant[10] : @@ -1309,14 +1345,15 @@ ir.cpp: # 311| For_InitConditionUpdate() -> void # 311| Block 0 # 311| v0_0(void) = EnterFunction : -# 311| mu0_1(unknown) = UnmodeledDefinition : -# 312| r0_2(glval) = VariableAddress[i] : -# 312| r0_3(int) = Constant[0] : -# 312| m0_4(int) = Store : r0_2, r0_3 +# 311| m0_1(unknown) = AliasedDefinition : +# 311| mu0_2(unknown) = UnmodeledDefinition : +# 312| r0_3(glval) = VariableAddress[i] : +# 312| r0_4(int) = Constant[0] : +# 312| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 312| Block 1 -# 312| m1_0(int) = Phi : from 0:m0_4, from 2:m2_5 +# 312| m1_0(int) = Phi : from 0:m0_5, from 2:m2_5 # 312| r1_1(glval) = VariableAddress[i] : # 312| r1_2(int) = Load : r1_1, m1_0 # 312| r1_3(int) = Constant[10] : @@ -1343,14 +1380,15 @@ ir.cpp: # 317| For_Break() -> void # 317| Block 0 # 317| v0_0(void) = EnterFunction : -# 317| mu0_1(unknown) = UnmodeledDefinition : -# 318| r0_2(glval) = VariableAddress[i] : -# 318| r0_3(int) = Constant[0] : -# 318| m0_4(int) = Store : r0_2, r0_3 +# 317| m0_1(unknown) = AliasedDefinition : +# 317| mu0_2(unknown) = UnmodeledDefinition : +# 318| r0_3(glval) = VariableAddress[i] : +# 318| r0_4(int) = Constant[0] : +# 318| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 318| Block 1 -# 318| m1_0(int) = Phi : from 0:m0_4, from 2:m2_4 +# 318| m1_0(int) = Phi : from 0:m0_5, from 2:m2_4 # 318| r1_1(glval) = VariableAddress[i] : # 318| r1_2(int) = Load : r1_1, m1_0 # 318| r1_3(int) = Constant[10] : @@ -1390,14 +1428,15 @@ ir.cpp: # 325| For_Continue_Update() -> void # 325| Block 0 # 325| v0_0(void) = EnterFunction : -# 325| mu0_1(unknown) = UnmodeledDefinition : -# 326| r0_2(glval) = VariableAddress[i] : -# 326| r0_3(int) = Constant[0] : -# 326| m0_4(int) = Store : r0_2, r0_3 +# 325| m0_1(unknown) = AliasedDefinition : +# 325| mu0_2(unknown) = UnmodeledDefinition : +# 326| r0_3(glval) = VariableAddress[i] : +# 326| r0_4(int) = Constant[0] : +# 326| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 326| Block 1 -# 326| m1_0(int) = Phi : from 0:m0_4, from 4:m4_5 +# 326| m1_0(int) = Phi : from 0:m0_5, from 4:m4_5 # 326| r1_1(glval) = VariableAddress[i] : # 326| r1_2(int) = Load : r1_1, m1_0 # 326| r1_3(int) = Constant[10] : @@ -1437,15 +1476,16 @@ ir.cpp: # 333| For_Continue_NoUpdate() -> void # 333| Block 0 # 333| v0_0(void) = EnterFunction : -# 333| mu0_1(unknown) = UnmodeledDefinition : -# 334| r0_2(glval) = VariableAddress[i] : -# 334| r0_3(int) = Constant[0] : -# 334| m0_4(int) = Store : r0_2, r0_3 +# 333| m0_1(unknown) = AliasedDefinition : +# 333| mu0_2(unknown) = UnmodeledDefinition : +# 334| r0_3(glval) = VariableAddress[i] : +# 334| r0_4(int) = Constant[0] : +# 334| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 334| Block 1 # 334| r1_0(glval) = VariableAddress[i] : -# 334| r1_1(int) = Load : r1_0, m0_4 +# 334| r1_1(int) = Load : r1_0, m0_5 # 334| r1_2(int) = Constant[10] : # 334| r1_3(bool) = CompareLT : r1_1, r1_2 # 334| v1_4(void) = ConditionalBranch : r1_3 @@ -1454,7 +1494,7 @@ ir.cpp: # 335| Block 2 # 335| r2_0(glval) = VariableAddress[i] : -# 335| r2_1(int) = Load : r2_0, m0_4 +# 335| r2_1(int) = Load : r2_0, m0_5 # 335| r2_2(int) = Constant[5] : # 335| r2_3(bool) = CompareEQ : r2_1, r2_2 # 335| v2_4(void) = ConditionalBranch : r2_3 @@ -1477,42 +1517,46 @@ ir.cpp: # 341| Dereference(int *) -> int # 341| Block 0 -# 341| v0_0(void) = EnterFunction : -# 341| mu0_1(unknown) = UnmodeledDefinition : -# 341| r0_2(glval) = VariableAddress[p] : -# 341| m0_3(int *) = InitializeParameter[p] : r0_2 -# 342| r0_4(int) = Constant[1] : -# 342| r0_5(glval) = VariableAddress[p] : -# 342| r0_6(int *) = Load : r0_5, m0_3 -# 342| mu0_7(int) = Store : r0_6, r0_4 -# 343| r0_8(glval) = VariableAddress[#return] : -# 343| r0_9(glval) = VariableAddress[p] : -# 343| r0_10(int *) = Load : r0_9, m0_3 -# 343| r0_11(int) = Load : r0_10, mu0_1 -# 343| m0_12(int) = Store : r0_8, r0_11 -# 341| r0_13(glval) = VariableAddress[#return] : -# 341| v0_14(void) = ReturnValue : r0_13, m0_12 -# 341| v0_15(void) = UnmodeledUse : mu* -# 341| v0_16(void) = ExitFunction : +# 341| v0_0(void) = EnterFunction : +# 341| m0_1(unknown) = AliasedDefinition : +# 341| mu0_2(unknown) = UnmodeledDefinition : +# 341| r0_3(glval) = VariableAddress[p] : +# 341| m0_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, m0_4 +# 342| m0_8(int) = Store : r0_7, r0_5 +# 342| m0_9(unknown) = Chi : m0_1, m0_8 +# 343| r0_10(glval) = VariableAddress[#return] : +# 343| r0_11(glval) = VariableAddress[p] : +# 343| r0_12(int *) = Load : r0_11, m0_4 +# 343| r0_13(int) = Load : r0_12, m0_9 +# 343| m0_14(int) = Store : r0_10, r0_13 +# 341| r0_15(glval) = VariableAddress[#return] : +# 341| v0_16(void) = ReturnValue : r0_15, m0_14 +# 341| v0_17(void) = UnmodeledUse : mu* +# 341| v0_18(void) = ExitFunction : # 348| AddressOf() -> int * # 348| Block 0 # 348| v0_0(void) = EnterFunction : -# 348| mu0_1(unknown) = UnmodeledDefinition : -# 349| r0_2(glval) = VariableAddress[#return] : -# 349| r0_3(glval) = VariableAddress[g] : -# 349| m0_4(int *) = Store : r0_2, r0_3 -# 348| r0_5(glval) = VariableAddress[#return] : -# 348| v0_6(void) = ReturnValue : r0_5, m0_4 -# 348| v0_7(void) = UnmodeledUse : mu* -# 348| v0_8(void) = ExitFunction : +# 348| m0_1(unknown) = AliasedDefinition : +# 348| mu0_2(unknown) = UnmodeledDefinition : +# 349| r0_3(glval) = VariableAddress[#return] : +# 349| r0_4(glval) = VariableAddress[g] : +# 349| m0_5(int *) = Store : r0_3, r0_4 +# 348| r0_6(glval) = VariableAddress[#return] : +# 348| v0_7(void) = ReturnValue : r0_6, m0_5 +# 348| v0_8(void) = UnmodeledUse : mu* +# 348| v0_9(void) = ExitFunction : # 352| Break(int) -> void # 352| Block 0 # 352| v0_0(void) = EnterFunction : -# 352| mu0_1(unknown) = UnmodeledDefinition : -# 352| r0_2(glval) = VariableAddress[n] : -# 352| m0_3(int) = InitializeParameter[n] : r0_2 +# 352| m0_1(unknown) = AliasedDefinition : +# 352| mu0_2(unknown) = UnmodeledDefinition : +# 352| r0_3(glval) = VariableAddress[n] : +# 352| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 5 # 354| Block 1 @@ -1544,7 +1588,7 @@ ir.cpp: # 352| v4_4(void) = ExitFunction : # 353| Block 5 -# 353| m5_0(int) = Phi : from 0:m0_3, from 3:m3_4 +# 353| m5_0(int) = Phi : from 0:m0_4, from 3:m3_4 # 353| r5_1(glval) = VariableAddress[n] : # 353| r5_2(int) = Load : r5_1, m5_0 # 353| r5_3(int) = Constant[0] : @@ -1556,13 +1600,14 @@ ir.cpp: # 360| Continue(int) -> void # 360| Block 0 # 360| v0_0(void) = EnterFunction : -# 360| mu0_1(unknown) = UnmodeledDefinition : -# 360| r0_2(glval) = VariableAddress[n] : -# 360| m0_3(int) = InitializeParameter[n] : r0_2 +# 360| m0_1(unknown) = AliasedDefinition : +# 360| mu0_2(unknown) = UnmodeledDefinition : +# 360| r0_3(glval) = VariableAddress[n] : +# 360| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 1 # 362| Block 1 -# 362| m1_0(int) = Phi : from 0:m0_3, from 4:m4_0 +# 362| m1_0(int) = Phi : from 0:m0_4, from 4:m4_0 # 362| r1_1(glval) = VariableAddress[n] : # 362| r1_2(int) = Load : r1_1, m1_0 # 362| r1_3(int) = Constant[1] : @@ -1603,69 +1648,81 @@ ir.cpp: # 372| Call() -> void # 372| Block 0 # 372| v0_0(void) = EnterFunction : -# 372| mu0_1(unknown) = UnmodeledDefinition : -# 373| r0_2(glval) = FunctionAddress[VoidFunc] : -# 373| v0_3(void) = Call : r0_2 -# 374| v0_4(void) = NoOp : -# 372| v0_5(void) = ReturnVoid : -# 372| v0_6(void) = UnmodeledUse : mu* -# 372| v0_7(void) = ExitFunction : +# 372| m0_1(unknown) = AliasedDefinition : +# 372| mu0_2(unknown) = UnmodeledDefinition : +# 373| r0_3(glval) = FunctionAddress[VoidFunc] : +# 373| v0_4(void) = Call : r0_3 +# 373| m0_5(unknown) = ^CallSideEffect : m0_1 +# 373| m0_6(unknown) = Chi : m0_1, m0_5 +# 374| v0_7(void) = NoOp : +# 372| v0_8(void) = ReturnVoid : +# 372| v0_9(void) = UnmodeledUse : mu* +# 372| v0_10(void) = ExitFunction : # 376| CallAdd(int, int) -> int # 376| Block 0 # 376| v0_0(void) = EnterFunction : -# 376| mu0_1(unknown) = UnmodeledDefinition : -# 376| r0_2(glval) = VariableAddress[x] : -# 376| m0_3(int) = InitializeParameter[x] : r0_2 -# 376| r0_4(glval) = VariableAddress[y] : -# 376| m0_5(int) = InitializeParameter[y] : r0_4 -# 377| r0_6(glval) = VariableAddress[#return] : -# 377| r0_7(glval) = FunctionAddress[Add] : -# 377| r0_8(glval) = VariableAddress[x] : -# 377| r0_9(int) = Load : r0_8, m0_3 -# 377| r0_10(glval) = VariableAddress[y] : -# 377| r0_11(int) = Load : r0_10, m0_5 -# 377| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 377| m0_13(int) = Store : r0_6, r0_12 -# 376| r0_14(glval) = VariableAddress[#return] : -# 376| v0_15(void) = ReturnValue : r0_14, m0_13 -# 376| v0_16(void) = UnmodeledUse : mu* -# 376| v0_17(void) = ExitFunction : +# 376| m0_1(unknown) = AliasedDefinition : +# 376| mu0_2(unknown) = UnmodeledDefinition : +# 376| r0_3(glval) = VariableAddress[x] : +# 376| m0_4(int) = InitializeParameter[x] : r0_3 +# 376| r0_5(glval) = VariableAddress[y] : +# 376| m0_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, m0_4 +# 377| r0_11(glval) = VariableAddress[y] : +# 377| r0_12(int) = Load : r0_11, m0_6 +# 377| r0_13(int) = Call : r0_8, r0_10, r0_12 +# 377| m0_14(unknown) = ^CallSideEffect : m0_1 +# 377| m0_15(unknown) = Chi : m0_1, m0_14 +# 377| m0_16(int) = Store : r0_7, r0_13 +# 376| r0_17(glval) = VariableAddress[#return] : +# 376| v0_18(void) = ReturnValue : r0_17, m0_16 +# 376| v0_19(void) = UnmodeledUse : mu* +# 376| v0_20(void) = ExitFunction : # 380| Comma(int, int) -> int # 380| Block 0 -# 380| v0_0(void) = EnterFunction : -# 380| mu0_1(unknown) = UnmodeledDefinition : -# 380| r0_2(glval) = VariableAddress[x] : -# 380| m0_3(int) = InitializeParameter[x] : r0_2 -# 380| r0_4(glval) = VariableAddress[y] : -# 380| m0_5(int) = InitializeParameter[y] : r0_4 -# 381| r0_6(glval) = VariableAddress[#return] : -# 381| r0_7(glval) = FunctionAddress[VoidFunc] : -# 381| v0_8(void) = Call : r0_7 -# 381| r0_9(glval) = FunctionAddress[CallAdd] : -# 381| r0_10(glval) = VariableAddress[x] : -# 381| r0_11(int) = Load : r0_10, m0_3 -# 381| r0_12(glval) = VariableAddress[y] : -# 381| r0_13(int) = Load : r0_12, m0_5 -# 381| r0_14(int) = Call : r0_9, r0_11, r0_13 -# 381| m0_15(int) = Store : r0_6, r0_14 -# 380| r0_16(glval) = VariableAddress[#return] : -# 380| v0_17(void) = ReturnValue : r0_16, m0_15 -# 380| v0_18(void) = UnmodeledUse : mu* -# 380| v0_19(void) = ExitFunction : +# 380| v0_0(void) = EnterFunction : +# 380| m0_1(unknown) = AliasedDefinition : +# 380| mu0_2(unknown) = UnmodeledDefinition : +# 380| r0_3(glval) = VariableAddress[x] : +# 380| m0_4(int) = InitializeParameter[x] : r0_3 +# 380| r0_5(glval) = VariableAddress[y] : +# 380| m0_6(int) = InitializeParameter[y] : r0_5 +# 381| r0_7(glval) = VariableAddress[#return] : +# 381| r0_8(glval) = FunctionAddress[VoidFunc] : +# 381| v0_9(void) = Call : r0_8 +# 381| m0_10(unknown) = ^CallSideEffect : m0_1 +# 381| m0_11(unknown) = Chi : m0_1, m0_10 +# 381| r0_12(glval) = FunctionAddress[CallAdd] : +# 381| r0_13(glval) = VariableAddress[x] : +# 381| r0_14(int) = Load : r0_13, m0_4 +# 381| r0_15(glval) = VariableAddress[y] : +# 381| r0_16(int) = Load : r0_15, m0_6 +# 381| r0_17(int) = Call : r0_12, r0_14, r0_16 +# 381| m0_18(unknown) = ^CallSideEffect : m0_11 +# 381| m0_19(unknown) = Chi : m0_11, m0_18 +# 381| m0_20(int) = Store : r0_7, r0_17 +# 380| r0_21(glval) = VariableAddress[#return] : +# 380| v0_22(void) = ReturnValue : r0_21, m0_20 +# 380| v0_23(void) = UnmodeledUse : mu* +# 380| v0_24(void) = ExitFunction : # 384| Switch(int) -> void # 384| Block 0 # 384| v0_0(void) = EnterFunction : -# 384| mu0_1(unknown) = UnmodeledDefinition : -# 384| r0_2(glval) = VariableAddress[x] : -# 384| m0_3(int) = InitializeParameter[x] : r0_2 -# 385| r0_4(glval) = VariableAddress[y] : -# 385| m0_5(int) = Uninitialized : r0_4 -# 386| r0_6(glval) = VariableAddress[x] : -# 386| r0_7(int) = Load : r0_6, m0_3 -# 386| v0_8(void) = Switch : r0_7 +# 384| m0_1(unknown) = AliasedDefinition : +# 384| mu0_2(unknown) = UnmodeledDefinition : +# 384| r0_3(glval) = VariableAddress[x] : +# 384| m0_4(int) = InitializeParameter[x] : r0_3 +# 385| r0_5(glval) = VariableAddress[y] : +# 385| m0_6(int) = Uninitialized : r0_5 +# 386| r0_7(glval) = VariableAddress[x] : +# 386| r0_8(int) = Load : r0_7, m0_4 +# 386| v0_9(void) = Switch : r0_8 #-----| Case[-1] -> Block 2 #-----| Case[1] -> Block 3 #-----| Case[2] -> Block 4 @@ -1738,62 +1795,67 @@ ir.cpp: # 422| ReturnStruct(Point) -> Point # 422| Block 0 # 422| v0_0(void) = EnterFunction : -# 422| mu0_1(unknown) = UnmodeledDefinition : -# 422| r0_2(glval) = VariableAddress[pt] : -# 422| m0_3(Point) = InitializeParameter[pt] : r0_2 -# 423| r0_4(glval) = VariableAddress[#return] : -# 423| r0_5(glval) = VariableAddress[pt] : -# 423| r0_6(Point) = Load : r0_5, m0_3 -# 423| m0_7(Point) = Store : r0_4, r0_6 -# 422| r0_8(glval) = VariableAddress[#return] : -# 422| v0_9(void) = ReturnValue : r0_8, m0_7 -# 422| v0_10(void) = UnmodeledUse : mu* -# 422| v0_11(void) = ExitFunction : +# 422| m0_1(unknown) = AliasedDefinition : +# 422| mu0_2(unknown) = UnmodeledDefinition : +# 422| r0_3(glval) = VariableAddress[pt] : +# 422| m0_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, m0_4 +# 423| m0_8(Point) = Store : r0_5, r0_7 +# 422| r0_9(glval) = VariableAddress[#return] : +# 422| v0_10(void) = ReturnValue : r0_9, m0_8 +# 422| v0_11(void) = UnmodeledUse : mu* +# 422| v0_12(void) = ExitFunction : # 426| FieldAccess() -> void # 426| Block 0 # 426| v0_0(void) = EnterFunction : -# 426| mu0_1(unknown) = UnmodeledDefinition : -# 427| r0_2(glval) = VariableAddress[pt] : -# 427| m0_3(Point) = Uninitialized : r0_2 -# 428| r0_4(int) = Constant[5] : -# 428| r0_5(glval) = VariableAddress[pt] : -# 428| r0_6(glval) = FieldAddress[x] : r0_5 -# 428| m0_7(int) = Store : r0_6, r0_4 -# 429| r0_8(glval) = VariableAddress[pt] : -# 429| r0_9(glval) = FieldAddress[x] : r0_8 -# 429| r0_10(int) = Load : r0_9, m0_7 -# 429| r0_11(glval) = VariableAddress[pt] : -# 429| r0_12(glval) = FieldAddress[y] : r0_11 -# 429| mu0_13(int) = Store : r0_12, r0_10 -# 430| r0_14(glval) = VariableAddress[p] : -# 430| r0_15(glval) = VariableAddress[pt] : -# 430| r0_16(glval) = FieldAddress[y] : r0_15 -# 430| m0_17(int *) = Store : r0_14, r0_16 -# 431| v0_18(void) = NoOp : -# 426| v0_19(void) = ReturnVoid : -# 426| v0_20(void) = UnmodeledUse : mu* -# 426| v0_21(void) = ExitFunction : +# 426| m0_1(unknown) = AliasedDefinition : +# 426| mu0_2(unknown) = UnmodeledDefinition : +# 427| r0_3(glval) = VariableAddress[pt] : +# 427| m0_4(Point) = Uninitialized : r0_3 +# 428| r0_5(int) = Constant[5] : +# 428| r0_6(glval) = VariableAddress[pt] : +# 428| r0_7(glval) = FieldAddress[x] : r0_6 +# 428| m0_8(int) = Store : r0_7, r0_5 +# 428| m0_9(Point) = Chi : m0_4, m0_8 +# 429| r0_10(glval) = VariableAddress[pt] : +# 429| r0_11(glval) = FieldAddress[x] : r0_10 +# 429| r0_12(int) = Load : r0_11, mu0_2 +# 429| r0_13(glval) = VariableAddress[pt] : +# 429| r0_14(glval) = FieldAddress[y] : r0_13 +# 429| m0_15(int) = Store : r0_14, r0_12 +# 429| m0_16(Point) = Chi : m0_9, m0_15 +# 430| r0_17(glval) = VariableAddress[p] : +# 430| r0_18(glval) = VariableAddress[pt] : +# 430| r0_19(glval) = FieldAddress[y] : r0_18 +# 430| m0_20(int *) = Store : r0_17, r0_19 +# 431| v0_21(void) = NoOp : +# 426| v0_22(void) = ReturnVoid : +# 426| v0_23(void) = UnmodeledUse : mu* +# 426| v0_24(void) = ExitFunction : # 433| LogicalOr(bool, bool) -> void # 433| Block 0 # 433| v0_0(void) = EnterFunction : -# 433| mu0_1(unknown) = UnmodeledDefinition : -# 433| r0_2(glval) = VariableAddress[a] : -# 433| m0_3(bool) = InitializeParameter[a] : r0_2 -# 433| r0_4(glval) = VariableAddress[b] : -# 433| m0_5(bool) = InitializeParameter[b] : r0_4 -# 434| r0_6(glval) = VariableAddress[x] : -# 434| m0_7(int) = Uninitialized : r0_6 -# 435| r0_8(glval) = VariableAddress[a] : -# 435| r0_9(bool) = Load : r0_8, m0_3 -# 435| v0_10(void) = ConditionalBranch : r0_9 +# 433| m0_1(unknown) = AliasedDefinition : +# 433| mu0_2(unknown) = UnmodeledDefinition : +# 433| r0_3(glval) = VariableAddress[a] : +# 433| m0_4(bool) = InitializeParameter[a] : r0_3 +# 433| r0_5(glval) = VariableAddress[b] : +# 433| m0_6(bool) = InitializeParameter[b] : r0_5 +# 434| r0_7(glval) = VariableAddress[x] : +# 434| m0_8(int) = Uninitialized : r0_7 +# 435| r0_9(glval) = VariableAddress[a] : +# 435| r0_10(bool) = Load : r0_9, m0_4 +# 435| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 # 435| Block 1 # 435| r1_0(glval) = VariableAddress[b] : -# 435| r1_1(bool) = Load : r1_0, m0_5 +# 435| r1_1(bool) = Load : r1_0, m0_6 # 435| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1806,14 +1868,14 @@ ir.cpp: # 439| Block 3 # 439| r3_0(glval) = VariableAddress[a] : -# 439| r3_1(bool) = Load : r3_0, m0_3 +# 439| r3_1(bool) = Load : r3_0, m0_4 # 439| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 # 439| Block 4 # 439| r4_0(glval) = VariableAddress[b] : -# 439| r4_1(bool) = Load : r4_0, m0_5 +# 439| r4_1(bool) = Load : r4_0, m0_6 # 439| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1839,22 +1901,23 @@ ir.cpp: # 447| LogicalAnd(bool, bool) -> void # 447| Block 0 # 447| v0_0(void) = EnterFunction : -# 447| mu0_1(unknown) = UnmodeledDefinition : -# 447| r0_2(glval) = VariableAddress[a] : -# 447| m0_3(bool) = InitializeParameter[a] : r0_2 -# 447| r0_4(glval) = VariableAddress[b] : -# 447| m0_5(bool) = InitializeParameter[b] : r0_4 -# 448| r0_6(glval) = VariableAddress[x] : -# 448| m0_7(int) = Uninitialized : r0_6 -# 449| r0_8(glval) = VariableAddress[a] : -# 449| r0_9(bool) = Load : r0_8, m0_3 -# 449| v0_10(void) = ConditionalBranch : r0_9 +# 447| m0_1(unknown) = AliasedDefinition : +# 447| mu0_2(unknown) = UnmodeledDefinition : +# 447| r0_3(glval) = VariableAddress[a] : +# 447| m0_4(bool) = InitializeParameter[a] : r0_3 +# 447| r0_5(glval) = VariableAddress[b] : +# 447| m0_6(bool) = InitializeParameter[b] : r0_5 +# 448| r0_7(glval) = VariableAddress[x] : +# 448| m0_8(int) = Uninitialized : r0_7 +# 449| r0_9(glval) = VariableAddress[a] : +# 449| r0_10(bool) = Load : r0_9, m0_4 +# 449| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 3 #-----| True -> Block 1 # 449| Block 1 # 449| r1_0(glval) = VariableAddress[b] : -# 449| r1_1(bool) = Load : r1_0, m0_5 +# 449| r1_1(bool) = Load : r1_0, m0_6 # 449| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1867,14 +1930,14 @@ ir.cpp: # 453| Block 3 # 453| r3_0(glval) = VariableAddress[a] : -# 453| r3_1(bool) = Load : r3_0, m0_3 +# 453| r3_1(bool) = Load : r3_0, m0_4 # 453| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 6 #-----| True -> Block 4 # 453| Block 4 # 453| r4_0(glval) = VariableAddress[b] : -# 453| r4_1(bool) = Load : r4_0, m0_5 +# 453| r4_1(bool) = Load : r4_0, m0_6 # 453| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1900,16 +1963,17 @@ ir.cpp: # 461| LogicalNot(bool, bool) -> void # 461| Block 0 # 461| v0_0(void) = EnterFunction : -# 461| mu0_1(unknown) = UnmodeledDefinition : -# 461| r0_2(glval) = VariableAddress[a] : -# 461| m0_3(bool) = InitializeParameter[a] : r0_2 -# 461| r0_4(glval) = VariableAddress[b] : -# 461| m0_5(bool) = InitializeParameter[b] : r0_4 -# 462| r0_6(glval) = VariableAddress[x] : -# 462| m0_7(int) = Uninitialized : r0_6 -# 463| r0_8(glval) = VariableAddress[a] : -# 463| r0_9(bool) = Load : r0_8, m0_3 -# 463| v0_10(void) = ConditionalBranch : r0_9 +# 461| m0_1(unknown) = AliasedDefinition : +# 461| mu0_2(unknown) = UnmodeledDefinition : +# 461| r0_3(glval) = VariableAddress[a] : +# 461| m0_4(bool) = InitializeParameter[a] : r0_3 +# 461| r0_5(glval) = VariableAddress[b] : +# 461| m0_6(bool) = InitializeParameter[b] : r0_5 +# 462| r0_7(glval) = VariableAddress[x] : +# 462| m0_8(int) = Uninitialized : r0_7 +# 463| r0_9(glval) = VariableAddress[a] : +# 463| r0_10(bool) = Load : r0_9, m0_4 +# 463| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 @@ -1921,14 +1985,14 @@ ir.cpp: # 467| Block 2 # 467| r2_0(glval) = VariableAddress[a] : -# 467| r2_1(bool) = Load : r2_0, m0_3 +# 467| r2_1(bool) = Load : r2_0, m0_4 # 467| v2_2(void) = ConditionalBranch : r2_1 #-----| False -> Block 4 #-----| True -> Block 3 # 467| Block 3 # 467| r3_0(glval) = VariableAddress[b] : -# 467| r3_1(bool) = Load : r3_0, m0_5 +# 467| r3_1(bool) = Load : r3_0, m0_6 # 467| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 @@ -1954,22 +2018,23 @@ ir.cpp: # 475| ConditionValues(bool, bool) -> void # 475| Block 0 # 475| v0_0(void) = EnterFunction : -# 475| mu0_1(unknown) = UnmodeledDefinition : -# 475| r0_2(glval) = VariableAddress[a] : -# 475| m0_3(bool) = InitializeParameter[a] : r0_2 -# 475| r0_4(glval) = VariableAddress[b] : -# 475| m0_5(bool) = InitializeParameter[b] : r0_4 -# 476| r0_6(glval) = VariableAddress[x] : -# 476| m0_7(bool) = Uninitialized : r0_6 -# 477| r0_8(glval) = VariableAddress[a] : -# 477| r0_9(bool) = Load : r0_8, m0_3 -# 477| v0_10(void) = ConditionalBranch : r0_9 +# 475| m0_1(unknown) = AliasedDefinition : +# 475| mu0_2(unknown) = UnmodeledDefinition : +# 475| r0_3(glval) = VariableAddress[a] : +# 475| m0_4(bool) = InitializeParameter[a] : r0_3 +# 475| r0_5(glval) = VariableAddress[b] : +# 475| m0_6(bool) = InitializeParameter[b] : r0_5 +# 476| r0_7(glval) = VariableAddress[x] : +# 476| m0_8(bool) = Uninitialized : r0_7 +# 477| r0_9(glval) = VariableAddress[a] : +# 477| r0_10(bool) = Load : r0_9, m0_4 +# 477| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 10 #-----| True -> Block 1 # 477| Block 1 # 477| r1_0(glval) = VariableAddress[b] : -# 477| r1_1(bool) = Load : r1_0, m0_5 +# 477| r1_1(bool) = Load : r1_0, m0_6 # 477| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 10 #-----| True -> Block 12 @@ -1987,7 +2052,7 @@ ir.cpp: # 478| r3_3(glval) = VariableAddress[x] : # 478| m3_4(bool) = Store : r3_3, r3_2 # 479| r3_5(glval) = VariableAddress[a] : -# 479| r3_6(bool) = Load : r3_5, m0_3 +# 479| r3_6(bool) = Load : r3_5, m0_4 # 479| v3_7(void) = ConditionalBranch : r3_6 #-----| False -> Block 9 #-----| True -> Block 8 @@ -2000,7 +2065,7 @@ ir.cpp: # 478| Block 5 # 478| r5_0(glval) = VariableAddress[b] : -# 478| r5_1(bool) = Load : r5_0, m0_5 +# 478| r5_1(bool) = Load : r5_0, m0_6 # 478| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 2 #-----| True -> Block 4 @@ -2031,7 +2096,7 @@ ir.cpp: # 479| Block 9 # 479| r9_0(glval) = VariableAddress[b] : -# 479| r9_1(bool) = Load : r9_0, m0_5 +# 479| r9_1(bool) = Load : r9_0, m0_6 # 479| v9_2(void) = ConditionalBranch : r9_1 #-----| False -> Block 6 #-----| True -> Block 8 @@ -2049,7 +2114,7 @@ ir.cpp: # 477| r11_3(glval) = VariableAddress[x] : # 477| m11_4(bool) = Store : r11_3, r11_2 # 478| r11_5(glval) = VariableAddress[a] : -# 478| r11_6(bool) = Load : r11_5, m0_3 +# 478| r11_6(bool) = Load : r11_5, m0_4 # 478| v11_7(void) = ConditionalBranch : r11_6 #-----| False -> Block 5 #-----| True -> Block 4 @@ -2062,31 +2127,32 @@ ir.cpp: # 482| Conditional(bool, int, int) -> void # 482| Block 0 -# 482| v0_0(void) = EnterFunction : -# 482| mu0_1(unknown) = UnmodeledDefinition : -# 482| r0_2(glval) = VariableAddress[a] : -# 482| m0_3(bool) = InitializeParameter[a] : r0_2 -# 482| r0_4(glval) = VariableAddress[x] : -# 482| m0_5(int) = InitializeParameter[x] : r0_4 -# 482| r0_6(glval) = VariableAddress[y] : -# 482| m0_7(int) = InitializeParameter[y] : r0_6 -# 483| r0_8(glval) = VariableAddress[z] : -# 483| r0_9(glval) = VariableAddress[a] : -# 483| r0_10(bool) = Load : r0_9, m0_3 -# 483| v0_11(void) = ConditionalBranch : r0_10 +# 482| v0_0(void) = EnterFunction : +# 482| m0_1(unknown) = AliasedDefinition : +# 482| mu0_2(unknown) = UnmodeledDefinition : +# 482| r0_3(glval) = VariableAddress[a] : +# 482| m0_4(bool) = InitializeParameter[a] : r0_3 +# 482| r0_5(glval) = VariableAddress[x] : +# 482| m0_6(int) = InitializeParameter[x] : r0_5 +# 482| r0_7(glval) = VariableAddress[y] : +# 482| m0_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, m0_4 +# 483| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 2 #-----| True -> Block 1 # 483| Block 1 # 483| r1_0(glval) = VariableAddress[x] : -# 483| r1_1(int) = Load : r1_0, m0_5 +# 483| r1_1(int) = Load : r1_0, m0_6 # 483| r1_2(glval) = VariableAddress[#temp483:13] : # 483| m1_3(int) = Store : r1_2, r1_1 #-----| Goto -> Block 3 # 483| Block 2 # 483| r2_0(glval) = VariableAddress[y] : -# 483| r2_1(int) = Load : r2_0, m0_7 +# 483| r2_1(int) = Load : r2_0, m0_8 # 483| r2_2(glval) = VariableAddress[#temp483:13] : # 483| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 @@ -2095,7 +2161,7 @@ ir.cpp: # 483| m3_0(int) = Phi : from 1:m1_3, from 2:m2_3 # 483| r3_1(glval) = VariableAddress[#temp483:13] : # 483| r3_2(int) = Load : r3_1, m3_0 -# 483| m3_3(int) = Store : r0_8, r3_2 +# 483| m3_3(int) = Store : r0_9, r3_2 # 484| v3_4(void) = NoOp : # 482| v3_5(void) = ReturnVoid : # 482| v3_6(void) = UnmodeledUse : mu* @@ -2103,18 +2169,19 @@ ir.cpp: # 486| Conditional_LValue(bool) -> void # 486| Block 0 -# 486| v0_0(void) = EnterFunction : -# 486| mu0_1(unknown) = UnmodeledDefinition : -# 486| r0_2(glval) = VariableAddress[a] : -# 486| m0_3(bool) = InitializeParameter[a] : r0_2 -# 487| r0_4(glval) = VariableAddress[x] : -# 487| mu0_5(int) = Uninitialized : r0_4 -# 488| r0_6(glval) = VariableAddress[y] : -# 488| mu0_7(int) = Uninitialized : r0_6 -# 489| r0_8(int) = Constant[5] : -# 489| r0_9(glval) = VariableAddress[a] : -# 489| r0_10(bool) = Load : r0_9, m0_3 -# 489| v0_11(void) = ConditionalBranch : r0_10 +# 486| v0_0(void) = EnterFunction : +# 486| m0_1(unknown) = AliasedDefinition : +# 486| mu0_2(unknown) = UnmodeledDefinition : +# 486| r0_3(glval) = VariableAddress[a] : +# 486| m0_4(bool) = InitializeParameter[a] : r0_3 +# 487| r0_5(glval) = VariableAddress[x] : +# 487| mu0_6(int) = Uninitialized : r0_5 +# 488| r0_7(glval) = VariableAddress[y] : +# 488| mu0_8(int) = Uninitialized : r0_7 +# 489| r0_9(int) = Constant[5] : +# 489| r0_10(glval) = VariableAddress[a] : +# 489| r0_11(bool) = Load : r0_10, m0_4 +# 489| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2122,11 +2189,12 @@ ir.cpp: # 489| m1_0(int) = Phi : from 2:m2_2, from 3:m3_2 # 489| r1_1(glval) = VariableAddress[#temp489:6] : # 489| r1_2(glval) = Load : r1_1, m1_0 -# 489| mu1_3(int) = Store : r1_2, r0_8 -# 490| v1_4(void) = NoOp : -# 486| v1_5(void) = ReturnVoid : -# 486| v1_6(void) = UnmodeledUse : mu* -# 486| v1_7(void) = ExitFunction : +# 489| m1_3(int) = Store : r1_2, r0_9 +# 489| m1_4(unknown) = Chi : m0_1, m1_3 +# 490| v1_5(void) = NoOp : +# 486| v1_6(void) = ReturnVoid : +# 486| v1_7(void) = UnmodeledUse : mu* +# 486| v1_8(void) = ExitFunction : # 489| Block 2 # 489| r2_0(glval) = VariableAddress[x] : @@ -2143,12 +2211,13 @@ ir.cpp: # 492| Conditional_Void(bool) -> void # 492| Block 0 # 492| v0_0(void) = EnterFunction : -# 492| mu0_1(unknown) = UnmodeledDefinition : -# 492| r0_2(glval) = VariableAddress[a] : -# 492| m0_3(bool) = InitializeParameter[a] : r0_2 -# 493| r0_4(glval) = VariableAddress[a] : -# 493| r0_5(bool) = Load : r0_4, m0_3 -# 493| v0_6(void) = ConditionalBranch : r0_5 +# 492| m0_1(unknown) = AliasedDefinition : +# 492| mu0_2(unknown) = UnmodeledDefinition : +# 492| r0_3(glval) = VariableAddress[a] : +# 492| m0_4(bool) = InitializeParameter[a] : r0_3 +# 493| r0_5(glval) = VariableAddress[a] : +# 493| r0_6(bool) = Load : r0_5, m0_4 +# 493| v0_7(void) = ConditionalBranch : r0_6 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2161,238 +2230,273 @@ ir.cpp: # 493| Block 2 # 493| r2_0(glval) = FunctionAddress[VoidFunc] : # 493| v2_1(void) = Call : r2_0 +# 493| m2_2(unknown) = ^CallSideEffect : m0_1 +# 493| m2_3(unknown) = Chi : m0_1, m2_2 #-----| Goto -> Block 1 # 493| Block 3 # 493| r3_0(glval) = FunctionAddress[VoidFunc] : # 493| v3_1(void) = Call : r3_0 +# 493| m3_2(unknown) = ^CallSideEffect : m0_1 +# 493| m3_3(unknown) = Chi : m0_1, m3_2 #-----| Goto -> Block 1 # 496| Nullptr() -> void # 496| Block 0 # 496| v0_0(void) = EnterFunction : -# 496| mu0_1(unknown) = UnmodeledDefinition : -# 497| r0_2(glval) = VariableAddress[p] : -# 497| r0_3(int *) = Constant[0] : -# 497| m0_4(int *) = Store : r0_2, r0_3 -# 498| r0_5(glval) = VariableAddress[q] : -# 498| r0_6(int *) = Constant[0] : -# 498| m0_7(int *) = Store : r0_5, r0_6 -# 499| r0_8(int *) = Constant[0] : -# 499| r0_9(glval) = VariableAddress[p] : -# 499| m0_10(int *) = Store : r0_9, r0_8 -# 500| r0_11(int *) = Constant[0] : -# 500| r0_12(glval) = VariableAddress[q] : -# 500| m0_13(int *) = Store : r0_12, r0_11 -# 501| v0_14(void) = NoOp : -# 496| v0_15(void) = ReturnVoid : -# 496| v0_16(void) = UnmodeledUse : mu* -# 496| v0_17(void) = ExitFunction : +# 496| m0_1(unknown) = AliasedDefinition : +# 496| mu0_2(unknown) = UnmodeledDefinition : +# 497| r0_3(glval) = VariableAddress[p] : +# 497| r0_4(int *) = Constant[0] : +# 497| m0_5(int *) = Store : r0_3, r0_4 +# 498| r0_6(glval) = VariableAddress[q] : +# 498| r0_7(int *) = Constant[0] : +# 498| m0_8(int *) = Store : r0_6, r0_7 +# 499| r0_9(int *) = Constant[0] : +# 499| r0_10(glval) = VariableAddress[p] : +# 499| m0_11(int *) = Store : r0_10, r0_9 +# 500| r0_12(int *) = Constant[0] : +# 500| r0_13(glval) = VariableAddress[q] : +# 500| m0_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) = ExitFunction : # 503| InitList(int, float) -> void # 503| Block 0 # 503| v0_0(void) = EnterFunction : -# 503| mu0_1(unknown) = UnmodeledDefinition : -# 503| r0_2(glval) = VariableAddress[x] : -# 503| m0_3(int) = InitializeParameter[x] : r0_2 -# 503| r0_4(glval) = VariableAddress[f] : -# 503| m0_5(float) = InitializeParameter[f] : r0_4 -# 504| r0_6(glval) = VariableAddress[pt1] : -# 504| m0_7(Point) = Uninitialized : r0_6 -# 504| r0_8(glval) = FieldAddress[x] : r0_6 -# 504| r0_9(glval) = VariableAddress[x] : -# 504| r0_10(int) = Load : r0_9, m0_3 -# 504| m0_11(int) = Store : r0_8, r0_10 -# 504| r0_12(glval) = FieldAddress[y] : r0_6 -# 504| r0_13(glval) = VariableAddress[f] : -# 504| r0_14(float) = Load : r0_13, m0_5 -# 504| r0_15(int) = Convert : r0_14 -# 504| mu0_16(int) = Store : r0_12, r0_15 -# 505| r0_17(glval) = VariableAddress[pt2] : -# 505| m0_18(Point) = Uninitialized : r0_17 -# 505| r0_19(glval) = FieldAddress[x] : r0_17 -# 505| r0_20(glval) = VariableAddress[x] : -# 505| r0_21(int) = Load : r0_20, m0_3 -# 505| m0_22(int) = Store : r0_19, r0_21 -# 505| r0_23(glval) = FieldAddress[y] : r0_17 -# 505| r0_24(int) = Constant[0] : -# 505| mu0_25(int) = Store : r0_23, r0_24 -# 506| r0_26(glval) = VariableAddress[pt3] : -# 506| m0_27(Point) = Uninitialized : r0_26 -# 506| r0_28(glval) = FieldAddress[x] : r0_26 -# 506| r0_29(int) = Constant[0] : -# 506| m0_30(int) = Store : r0_28, r0_29 -# 506| r0_31(glval) = FieldAddress[y] : r0_26 -# 506| r0_32(int) = Constant[0] : -# 506| mu0_33(int) = Store : r0_31, r0_32 -# 508| r0_34(glval) = VariableAddress[x1] : -# 508| r0_35(int) = Constant[1] : -# 508| m0_36(int) = Store : r0_34, r0_35 -# 509| r0_37(glval) = VariableAddress[x2] : -# 509| r0_38(int) = Constant[0] : -# 509| m0_39(int) = Store : r0_37, r0_38 -# 510| v0_40(void) = NoOp : -# 503| v0_41(void) = ReturnVoid : -# 503| v0_42(void) = UnmodeledUse : mu* -# 503| v0_43(void) = ExitFunction : +# 503| m0_1(unknown) = AliasedDefinition : +# 503| mu0_2(unknown) = UnmodeledDefinition : +# 503| r0_3(glval) = VariableAddress[x] : +# 503| m0_4(int) = InitializeParameter[x] : r0_3 +# 503| r0_5(glval) = VariableAddress[f] : +# 503| m0_6(float) = InitializeParameter[f] : r0_5 +# 504| r0_7(glval) = VariableAddress[pt1] : +# 504| m0_8(Point) = Uninitialized : r0_7 +# 504| r0_9(glval) = FieldAddress[x] : r0_7 +# 504| r0_10(glval) = VariableAddress[x] : +# 504| r0_11(int) = Load : r0_10, m0_4 +# 504| m0_12(int) = Store : r0_9, r0_11 +# 504| m0_13(Point) = Chi : m0_8, m0_12 +# 504| r0_14(glval) = FieldAddress[y] : r0_7 +# 504| r0_15(glval) = VariableAddress[f] : +# 504| r0_16(float) = Load : r0_15, m0_6 +# 504| r0_17(int) = Convert : r0_16 +# 504| m0_18(int) = Store : r0_14, r0_17 +# 504| m0_19(Point) = Chi : m0_13, m0_18 +# 505| r0_20(glval) = VariableAddress[pt2] : +# 505| m0_21(Point) = Uninitialized : r0_20 +# 505| r0_22(glval) = FieldAddress[x] : r0_20 +# 505| r0_23(glval) = VariableAddress[x] : +# 505| r0_24(int) = Load : r0_23, m0_4 +# 505| m0_25(int) = Store : r0_22, r0_24 +# 505| m0_26(Point) = Chi : m0_21, m0_25 +# 505| r0_27(glval) = FieldAddress[y] : r0_20 +# 505| r0_28(int) = Constant[0] : +# 505| m0_29(int) = Store : r0_27, r0_28 +# 505| m0_30(Point) = Chi : m0_26, m0_29 +# 506| r0_31(glval) = VariableAddress[pt3] : +# 506| m0_32(Point) = Uninitialized : r0_31 +# 506| r0_33(glval) = FieldAddress[x] : r0_31 +# 506| r0_34(int) = Constant[0] : +# 506| m0_35(int) = Store : r0_33, r0_34 +# 506| m0_36(Point) = Chi : m0_32, m0_35 +# 506| r0_37(glval) = FieldAddress[y] : r0_31 +# 506| r0_38(int) = Constant[0] : +# 506| m0_39(int) = Store : r0_37, r0_38 +# 506| m0_40(Point) = Chi : m0_36, m0_39 +# 508| r0_41(glval) = VariableAddress[x1] : +# 508| r0_42(int) = Constant[1] : +# 508| m0_43(int) = Store : r0_41, r0_42 +# 509| r0_44(glval) = VariableAddress[x2] : +# 509| r0_45(int) = Constant[0] : +# 509| m0_46(int) = Store : r0_44, r0_45 +# 510| v0_47(void) = NoOp : +# 503| v0_48(void) = ReturnVoid : +# 503| v0_49(void) = UnmodeledUse : mu* +# 503| v0_50(void) = ExitFunction : # 512| NestedInitList(int, float) -> void # 512| Block 0 # 512| v0_0(void) = EnterFunction : -# 512| mu0_1(unknown) = UnmodeledDefinition : -# 512| r0_2(glval) = VariableAddress[x] : -# 512| m0_3(int) = InitializeParameter[x] : r0_2 -# 512| r0_4(glval) = VariableAddress[f] : -# 512| m0_5(float) = InitializeParameter[f] : r0_4 -# 513| r0_6(glval) = VariableAddress[r1] : -# 513| m0_7(Rect) = Uninitialized : r0_6 -# 513| r0_8(glval) = FieldAddress[topLeft] : r0_6 -# 513| r0_9(Point) = Constant[0] : -# 513| m0_10(Point) = Store : r0_8, r0_9 -# 513| r0_11(glval) = FieldAddress[bottomRight] : r0_6 -# 513| r0_12(Point) = Constant[0] : -# 513| mu0_13(Point) = Store : r0_11, r0_12 -# 514| r0_14(glval) = VariableAddress[r2] : -# 514| m0_15(Rect) = Uninitialized : r0_14 -# 514| r0_16(glval) = FieldAddress[topLeft] : r0_14 -# 514| r0_17(glval) = FieldAddress[x] : r0_16 -# 514| r0_18(glval) = VariableAddress[x] : -# 514| r0_19(int) = Load : r0_18, m0_3 -# 514| m0_20(int) = Store : r0_17, r0_19 -# 514| r0_21(glval) = FieldAddress[y] : r0_16 -# 514| r0_22(glval) = VariableAddress[f] : -# 514| r0_23(float) = Load : r0_22, m0_5 -# 514| r0_24(int) = Convert : r0_23 -# 514| mu0_25(int) = Store : r0_21, r0_24 -# 514| r0_26(glval) = FieldAddress[bottomRight] : r0_14 -# 514| r0_27(Point) = Constant[0] : -# 514| mu0_28(Point) = Store : r0_26, r0_27 -# 515| r0_29(glval) = VariableAddress[r3] : -# 515| m0_30(Rect) = Uninitialized : r0_29 -# 515| r0_31(glval) = FieldAddress[topLeft] : r0_29 -# 515| r0_32(glval) = FieldAddress[x] : r0_31 -# 515| r0_33(glval) = VariableAddress[x] : -# 515| r0_34(int) = Load : r0_33, m0_3 -# 515| m0_35(int) = Store : r0_32, r0_34 -# 515| r0_36(glval) = FieldAddress[y] : r0_31 -# 515| r0_37(glval) = VariableAddress[f] : -# 515| r0_38(float) = Load : r0_37, m0_5 -# 515| r0_39(int) = Convert : r0_38 -# 515| mu0_40(int) = Store : r0_36, r0_39 -# 515| r0_41(glval) = FieldAddress[bottomRight] : r0_29 -# 515| r0_42(glval) = FieldAddress[x] : r0_41 -# 515| r0_43(glval) = VariableAddress[x] : -# 515| r0_44(int) = Load : r0_43, m0_3 -# 515| mu0_45(int) = Store : r0_42, r0_44 -# 515| r0_46(glval) = FieldAddress[y] : r0_41 -# 515| r0_47(glval) = VariableAddress[f] : -# 515| r0_48(float) = Load : r0_47, m0_5 -# 515| r0_49(int) = Convert : r0_48 -# 515| mu0_50(int) = Store : r0_46, r0_49 -# 516| r0_51(glval) = VariableAddress[r4] : -# 516| m0_52(Rect) = Uninitialized : r0_51 -# 516| r0_53(glval) = FieldAddress[topLeft] : r0_51 -# 516| r0_54(glval) = FieldAddress[x] : r0_53 -# 516| r0_55(glval) = VariableAddress[x] : -# 516| r0_56(int) = Load : r0_55, m0_3 -# 516| m0_57(int) = Store : r0_54, r0_56 -# 516| r0_58(glval) = FieldAddress[y] : r0_53 -# 516| r0_59(int) = Constant[0] : -# 516| mu0_60(int) = Store : r0_58, r0_59 -# 516| r0_61(glval) = FieldAddress[bottomRight] : r0_51 -# 516| r0_62(glval) = FieldAddress[x] : r0_61 -# 516| r0_63(glval) = VariableAddress[x] : -# 516| r0_64(int) = Load : r0_63, m0_3 -# 516| mu0_65(int) = Store : r0_62, r0_64 -# 516| r0_66(glval) = FieldAddress[y] : r0_61 -# 516| r0_67(int) = Constant[0] : -# 516| mu0_68(int) = Store : r0_66, r0_67 -# 517| v0_69(void) = NoOp : -# 512| v0_70(void) = ReturnVoid : -# 512| v0_71(void) = UnmodeledUse : mu* -# 512| v0_72(void) = ExitFunction : +# 512| m0_1(unknown) = AliasedDefinition : +# 512| mu0_2(unknown) = UnmodeledDefinition : +# 512| r0_3(glval) = VariableAddress[x] : +# 512| m0_4(int) = InitializeParameter[x] : r0_3 +# 512| r0_5(glval) = VariableAddress[f] : +# 512| m0_6(float) = InitializeParameter[f] : r0_5 +# 513| r0_7(glval) = VariableAddress[r1] : +# 513| m0_8(Rect) = Uninitialized : r0_7 +# 513| r0_9(glval) = FieldAddress[topLeft] : r0_7 +# 513| r0_10(Point) = Constant[0] : +# 513| m0_11(Point) = Store : r0_9, r0_10 +# 513| m0_12(Rect) = Chi : m0_8, m0_11 +# 513| r0_13(glval) = FieldAddress[bottomRight] : r0_7 +# 513| r0_14(Point) = Constant[0] : +# 513| m0_15(Point) = Store : r0_13, r0_14 +# 513| m0_16(Rect) = Chi : m0_12, m0_15 +# 514| r0_17(glval) = VariableAddress[r2] : +# 514| m0_18(Rect) = Uninitialized : r0_17 +# 514| r0_19(glval) = FieldAddress[topLeft] : r0_17 +# 514| r0_20(glval) = FieldAddress[x] : r0_19 +# 514| r0_21(glval) = VariableAddress[x] : +# 514| r0_22(int) = Load : r0_21, m0_4 +# 514| m0_23(int) = Store : r0_20, r0_22 +# 514| m0_24(Rect) = Chi : m0_18, m0_23 +# 514| r0_25(glval) = FieldAddress[y] : r0_19 +# 514| r0_26(glval) = VariableAddress[f] : +# 514| r0_27(float) = Load : r0_26, m0_6 +# 514| r0_28(int) = Convert : r0_27 +# 514| m0_29(int) = Store : r0_25, r0_28 +# 514| m0_30(Rect) = Chi : m0_24, m0_29 +# 514| r0_31(glval) = FieldAddress[bottomRight] : r0_17 +# 514| r0_32(Point) = Constant[0] : +# 514| m0_33(Point) = Store : r0_31, r0_32 +# 514| m0_34(Rect) = Chi : m0_30, m0_33 +# 515| r0_35(glval) = VariableAddress[r3] : +# 515| m0_36(Rect) = Uninitialized : r0_35 +# 515| r0_37(glval) = FieldAddress[topLeft] : r0_35 +# 515| r0_38(glval) = FieldAddress[x] : r0_37 +# 515| r0_39(glval) = VariableAddress[x] : +# 515| r0_40(int) = Load : r0_39, m0_4 +# 515| m0_41(int) = Store : r0_38, r0_40 +# 515| m0_42(Rect) = Chi : m0_36, m0_41 +# 515| r0_43(glval) = FieldAddress[y] : r0_37 +# 515| r0_44(glval) = VariableAddress[f] : +# 515| r0_45(float) = Load : r0_44, m0_6 +# 515| r0_46(int) = Convert : r0_45 +# 515| m0_47(int) = Store : r0_43, r0_46 +# 515| m0_48(Rect) = Chi : m0_42, m0_47 +# 515| r0_49(glval) = FieldAddress[bottomRight] : r0_35 +# 515| r0_50(glval) = FieldAddress[x] : r0_49 +# 515| r0_51(glval) = VariableAddress[x] : +# 515| r0_52(int) = Load : r0_51, m0_4 +# 515| m0_53(int) = Store : r0_50, r0_52 +# 515| m0_54(Rect) = Chi : m0_48, m0_53 +# 515| r0_55(glval) = FieldAddress[y] : r0_49 +# 515| r0_56(glval) = VariableAddress[f] : +# 515| r0_57(float) = Load : r0_56, m0_6 +# 515| r0_58(int) = Convert : r0_57 +# 515| m0_59(int) = Store : r0_55, r0_58 +# 515| m0_60(Rect) = Chi : m0_54, m0_59 +# 516| r0_61(glval) = VariableAddress[r4] : +# 516| m0_62(Rect) = Uninitialized : r0_61 +# 516| r0_63(glval) = FieldAddress[topLeft] : r0_61 +# 516| r0_64(glval) = FieldAddress[x] : r0_63 +# 516| r0_65(glval) = VariableAddress[x] : +# 516| r0_66(int) = Load : r0_65, m0_4 +# 516| m0_67(int) = Store : r0_64, r0_66 +# 516| m0_68(Rect) = Chi : m0_62, m0_67 +# 516| r0_69(glval) = FieldAddress[y] : r0_63 +# 516| r0_70(int) = Constant[0] : +# 516| m0_71(int) = Store : r0_69, r0_70 +# 516| m0_72(Rect) = Chi : m0_68, m0_71 +# 516| r0_73(glval) = FieldAddress[bottomRight] : r0_61 +# 516| r0_74(glval) = FieldAddress[x] : r0_73 +# 516| r0_75(glval) = VariableAddress[x] : +# 516| r0_76(int) = Load : r0_75, m0_4 +# 516| m0_77(int) = Store : r0_74, r0_76 +# 516| m0_78(Rect) = Chi : m0_72, m0_77 +# 516| r0_79(glval) = FieldAddress[y] : r0_73 +# 516| r0_80(int) = Constant[0] : +# 516| m0_81(int) = Store : r0_79, r0_80 +# 516| m0_82(Rect) = Chi : m0_78, m0_81 +# 517| v0_83(void) = NoOp : +# 512| v0_84(void) = ReturnVoid : +# 512| v0_85(void) = UnmodeledUse : mu* +# 512| v0_86(void) = ExitFunction : # 519| ArrayInit(int, float) -> void # 519| Block 0 # 519| v0_0(void) = EnterFunction : -# 519| mu0_1(unknown) = UnmodeledDefinition : -# 519| r0_2(glval) = VariableAddress[x] : -# 519| m0_3(int) = InitializeParameter[x] : r0_2 -# 519| r0_4(glval) = VariableAddress[f] : -# 519| m0_5(float) = InitializeParameter[f] : r0_4 -# 520| r0_6(glval) = VariableAddress[a1] : -# 520| mu0_7(int[3]) = Uninitialized : r0_6 -# 520| r0_8(int) = Constant[0] : -# 520| r0_9(glval) = PointerAdd : r0_6, r0_8 -# 520| r0_10(unknown[12]) = Constant[0] : -# 520| mu0_11(unknown[12]) = Store : r0_9, r0_10 -# 521| r0_12(glval) = VariableAddress[a2] : -# 521| mu0_13(int[3]) = Uninitialized : r0_12 -# 521| r0_14(int) = Constant[0] : -# 521| r0_15(glval) = PointerAdd : r0_12, r0_14 -# 521| r0_16(glval) = VariableAddress[x] : -# 521| r0_17(int) = Load : r0_16, m0_3 -# 521| mu0_18(int) = Store : r0_15, r0_17 -# 521| r0_19(int) = Constant[1] : -# 521| r0_20(glval) = PointerAdd : r0_12, r0_19 -# 521| r0_21(glval) = VariableAddress[f] : -# 521| r0_22(float) = Load : r0_21, m0_5 -# 521| r0_23(int) = Convert : r0_22 -# 521| mu0_24(int) = Store : r0_20, r0_23 -# 521| r0_25(int) = Constant[2] : -# 521| r0_26(glval) = PointerAdd : r0_12, r0_25 -# 521| r0_27(int) = Constant[0] : -# 521| mu0_28(int) = Store : r0_26, r0_27 -# 522| r0_29(glval) = VariableAddress[a3] : -# 522| mu0_30(int[3]) = Uninitialized : r0_29 -# 522| r0_31(int) = Constant[0] : -# 522| r0_32(glval) = PointerAdd : r0_29, r0_31 -# 522| r0_33(glval) = VariableAddress[x] : -# 522| r0_34(int) = Load : r0_33, m0_3 -# 522| mu0_35(int) = Store : r0_32, r0_34 -# 522| r0_36(int) = Constant[1] : -# 522| r0_37(glval) = PointerAdd : r0_29, r0_36 -# 522| r0_38(unknown[8]) = Constant[0] : -# 522| mu0_39(unknown[8]) = Store : r0_37, r0_38 -# 523| v0_40(void) = NoOp : -# 519| v0_41(void) = ReturnVoid : -# 519| v0_42(void) = UnmodeledUse : mu* -# 519| v0_43(void) = ExitFunction : +# 519| m0_1(unknown) = AliasedDefinition : +# 519| mu0_2(unknown) = UnmodeledDefinition : +# 519| r0_3(glval) = VariableAddress[x] : +# 519| m0_4(int) = InitializeParameter[x] : r0_3 +# 519| r0_5(glval) = VariableAddress[f] : +# 519| m0_6(float) = InitializeParameter[f] : r0_5 +# 520| r0_7(glval) = VariableAddress[a1] : +# 520| mu0_8(int[3]) = Uninitialized : r0_7 +# 520| r0_9(int) = Constant[0] : +# 520| r0_10(glval) = PointerAdd : r0_7, r0_9 +# 520| r0_11(unknown[12]) = Constant[0] : +# 520| m0_12(unknown[12]) = Store : r0_10, r0_11 +# 520| m0_13(unknown) = Chi : m0_1, m0_12 +# 521| r0_14(glval) = VariableAddress[a2] : +# 521| mu0_15(int[3]) = Uninitialized : r0_14 +# 521| r0_16(int) = Constant[0] : +# 521| r0_17(glval) = PointerAdd : r0_14, r0_16 +# 521| r0_18(glval) = VariableAddress[x] : +# 521| r0_19(int) = Load : r0_18, m0_4 +# 521| m0_20(int) = Store : r0_17, r0_19 +# 521| m0_21(unknown) = Chi : m0_13, m0_20 +# 521| r0_22(int) = Constant[1] : +# 521| r0_23(glval) = PointerAdd : r0_14, r0_22 +# 521| r0_24(glval) = VariableAddress[f] : +# 521| r0_25(float) = Load : r0_24, m0_6 +# 521| r0_26(int) = Convert : r0_25 +# 521| m0_27(int) = Store : r0_23, r0_26 +# 521| m0_28(unknown) = Chi : m0_21, m0_27 +# 521| r0_29(int) = Constant[2] : +# 521| r0_30(glval) = PointerAdd : r0_14, r0_29 +# 521| r0_31(int) = Constant[0] : +# 521| m0_32(int) = Store : r0_30, r0_31 +# 521| m0_33(unknown) = Chi : m0_28, m0_32 +# 522| r0_34(glval) = VariableAddress[a3] : +# 522| mu0_35(int[3]) = Uninitialized : r0_34 +# 522| r0_36(int) = Constant[0] : +# 522| r0_37(glval) = PointerAdd : r0_34, r0_36 +# 522| r0_38(glval) = VariableAddress[x] : +# 522| r0_39(int) = Load : r0_38, m0_4 +# 522| m0_40(int) = Store : r0_37, r0_39 +# 522| m0_41(unknown) = Chi : m0_33, m0_40 +# 522| r0_42(int) = Constant[1] : +# 522| r0_43(glval) = PointerAdd : r0_34, r0_42 +# 522| r0_44(unknown[8]) = Constant[0] : +# 522| m0_45(unknown[8]) = Store : r0_43, r0_44 +# 522| m0_46(unknown) = Chi : m0_41, m0_45 +# 523| v0_47(void) = NoOp : +# 519| v0_48(void) = ReturnVoid : +# 519| v0_49(void) = UnmodeledUse : mu* +# 519| v0_50(void) = ExitFunction : # 530| UnionInit(int, float) -> void # 530| Block 0 # 530| v0_0(void) = EnterFunction : -# 530| mu0_1(unknown) = UnmodeledDefinition : -# 530| r0_2(glval) = VariableAddress[x] : -# 530| m0_3(int) = InitializeParameter[x] : r0_2 -# 530| r0_4(glval) = VariableAddress[f] : -# 530| m0_5(float) = InitializeParameter[f] : r0_4 -# 531| r0_6(glval) = VariableAddress[u1] : -# 531| m0_7(U) = Uninitialized : r0_6 -# 531| r0_8(glval) = FieldAddress[d] : r0_6 -# 531| r0_9(glval) = VariableAddress[f] : -# 531| r0_10(float) = Load : r0_9, m0_5 -# 531| r0_11(double) = Convert : r0_10 -# 531| m0_12(double) = Store : r0_8, r0_11 -# 533| v0_13(void) = NoOp : -# 530| v0_14(void) = ReturnVoid : -# 530| v0_15(void) = UnmodeledUse : mu* -# 530| v0_16(void) = ExitFunction : +# 530| m0_1(unknown) = AliasedDefinition : +# 530| mu0_2(unknown) = UnmodeledDefinition : +# 530| r0_3(glval) = VariableAddress[x] : +# 530| m0_4(int) = InitializeParameter[x] : r0_3 +# 530| r0_5(glval) = VariableAddress[f] : +# 530| m0_6(float) = InitializeParameter[f] : r0_5 +# 531| r0_7(glval) = VariableAddress[u1] : +# 531| m0_8(U) = Uninitialized : r0_7 +# 531| r0_9(glval) = FieldAddress[d] : r0_7 +# 531| r0_10(glval) = VariableAddress[f] : +# 531| r0_11(float) = Load : r0_10, m0_6 +# 531| r0_12(double) = Convert : r0_11 +# 531| m0_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) = ExitFunction : # 535| EarlyReturn(int, int) -> void # 535| Block 0 # 535| v0_0(void) = EnterFunction : -# 535| mu0_1(unknown) = UnmodeledDefinition : -# 535| r0_2(glval) = VariableAddress[x] : -# 535| m0_3(int) = InitializeParameter[x] : r0_2 -# 535| r0_4(glval) = VariableAddress[y] : -# 535| m0_5(int) = InitializeParameter[y] : r0_4 -# 536| r0_6(glval) = VariableAddress[x] : -# 536| r0_7(int) = Load : r0_6, m0_3 -# 536| r0_8(glval) = VariableAddress[y] : -# 536| r0_9(int) = Load : r0_8, m0_5 -# 536| r0_10(bool) = CompareLT : r0_7, r0_9 -# 536| v0_11(void) = ConditionalBranch : r0_10 +# 535| m0_1(unknown) = AliasedDefinition : +# 535| mu0_2(unknown) = UnmodeledDefinition : +# 535| r0_3(glval) = VariableAddress[x] : +# 535| m0_4(int) = InitializeParameter[x] : r0_3 +# 535| r0_5(glval) = VariableAddress[y] : +# 535| m0_6(int) = InitializeParameter[y] : r0_5 +# 536| r0_7(glval) = VariableAddress[x] : +# 536| r0_8(int) = Load : r0_7, m0_4 +# 536| r0_9(glval) = VariableAddress[y] : +# 536| r0_10(int) = Load : r0_9, m0_6 +# 536| r0_11(bool) = CompareLT : r0_8, r0_10 +# 536| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2407,7 +2511,7 @@ ir.cpp: # 540| Block 3 # 540| r3_0(glval) = VariableAddress[x] : -# 540| r3_1(int) = Load : r3_0, m0_3 +# 540| r3_1(int) = Load : r3_0, m0_4 # 540| r3_2(glval) = VariableAddress[y] : # 540| m3_3(int) = Store : r3_2, r3_1 # 541| v3_4(void) = NoOp : @@ -2416,17 +2520,18 @@ ir.cpp: # 543| EarlyReturnValue(int, int) -> int # 543| Block 0 # 543| v0_0(void) = EnterFunction : -# 543| mu0_1(unknown) = UnmodeledDefinition : -# 543| r0_2(glval) = VariableAddress[x] : -# 543| m0_3(int) = InitializeParameter[x] : r0_2 -# 543| r0_4(glval) = VariableAddress[y] : -# 543| m0_5(int) = InitializeParameter[y] : r0_4 -# 544| r0_6(glval) = VariableAddress[x] : -# 544| r0_7(int) = Load : r0_6, m0_3 -# 544| r0_8(glval) = VariableAddress[y] : -# 544| r0_9(int) = Load : r0_8, m0_5 -# 544| r0_10(bool) = CompareLT : r0_7, r0_9 -# 544| v0_11(void) = ConditionalBranch : r0_10 +# 543| m0_1(unknown) = AliasedDefinition : +# 543| mu0_2(unknown) = UnmodeledDefinition : +# 543| r0_3(glval) = VariableAddress[x] : +# 543| m0_4(int) = InitializeParameter[x] : r0_3 +# 543| r0_5(glval) = VariableAddress[y] : +# 543| m0_6(int) = InitializeParameter[y] : r0_5 +# 544| r0_7(glval) = VariableAddress[x] : +# 544| r0_8(int) = Load : r0_7, m0_4 +# 544| r0_9(glval) = VariableAddress[y] : +# 544| r0_10(int) = Load : r0_9, m0_6 +# 544| r0_11(bool) = CompareLT : r0_8, r0_10 +# 544| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2440,16 +2545,16 @@ ir.cpp: # 545| Block 2 # 545| r2_0(glval) = VariableAddress[#return] : # 545| r2_1(glval) = VariableAddress[x] : -# 545| r2_2(int) = Load : r2_1, m0_3 +# 545| r2_2(int) = Load : r2_1, m0_4 # 545| m2_3(int) = Store : r2_0, r2_2 #-----| 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, m0_3 +# 548| r3_2(int) = Load : r3_1, m0_4 # 548| r3_3(glval) = VariableAddress[y] : -# 548| r3_4(int) = Load : r3_3, m0_5 +# 548| r3_4(int) = Load : r3_3, m0_6 # 548| r3_5(int) = Add : r3_2, r3_4 # 548| m3_6(int) = Store : r3_0, r3_5 #-----| Goto -> Block 1 @@ -2457,30 +2562,34 @@ ir.cpp: # 551| CallViaFuncPtr(..(*)(..)) -> int # 551| Block 0 # 551| v0_0(void) = EnterFunction : -# 551| mu0_1(unknown) = UnmodeledDefinition : -# 551| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| m0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 552| r0_4(glval) = VariableAddress[#return] : -# 552| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r0_6(..(*)(..)) = Load : r0_5, m0_3 -# 552| r0_7(int) = Constant[5] : -# 552| r0_8(int) = Call : r0_6, r0_7 -# 552| m0_9(int) = Store : r0_4, r0_8 -# 551| r0_10(glval) = VariableAddress[#return] : -# 551| v0_11(void) = ReturnValue : r0_10, m0_9 -# 551| v0_12(void) = UnmodeledUse : mu* -# 551| v0_13(void) = ExitFunction : +# 551| m0_1(unknown) = AliasedDefinition : +# 551| mu0_2(unknown) = UnmodeledDefinition : +# 551| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 551| m0_4(..(*)(..)) = InitializeParameter[pfn] : r0_3 +# 552| r0_5(glval) = VariableAddress[#return] : +# 552| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 552| r0_7(..(*)(..)) = Load : r0_6, m0_4 +# 552| r0_8(int) = Constant[5] : +# 552| r0_9(int) = Call : r0_7, r0_8 +# 552| m0_10(unknown) = ^CallSideEffect : m0_1 +# 552| m0_11(unknown) = Chi : m0_1, m0_10 +# 552| m0_12(int) = Store : r0_5, r0_9 +# 551| r0_13(glval) = VariableAddress[#return] : +# 551| v0_14(void) = ReturnValue : r0_13, m0_12 +# 551| v0_15(void) = UnmodeledUse : mu* +# 551| v0_16(void) = ExitFunction : # 560| EnumSwitch(E) -> int # 560| Block 0 # 560| v0_0(void) = EnterFunction : -# 560| mu0_1(unknown) = UnmodeledDefinition : -# 560| r0_2(glval) = VariableAddress[e] : -# 560| m0_3(E) = InitializeParameter[e] : r0_2 -# 561| r0_4(glval) = VariableAddress[e] : -# 561| r0_5(E) = Load : r0_4, m0_3 -# 561| r0_6(int) = Convert : r0_5 -# 561| v0_7(void) = Switch : r0_6 +# 560| m0_1(unknown) = AliasedDefinition : +# 560| mu0_2(unknown) = UnmodeledDefinition : +# 560| r0_3(glval) = VariableAddress[e] : +# 560| m0_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 #-----| Case[0] -> Block 4 #-----| Case[1] -> Block 2 #-----| Default -> Block 3 @@ -2516,414 +2625,475 @@ ir.cpp: # 571| InitArray() -> void # 571| Block 0 # 571| v0_0(void) = EnterFunction : -# 571| mu0_1(unknown) = UnmodeledDefinition : -# 572| r0_2(glval) = VariableAddress[a_pad] : -# 572| r0_3(glval) = StringConstant[""] : -# 572| r0_4(char[1]) = Load : r0_3, mu0_1 -# 572| mu0_5(char[1]) = Store : r0_2, r0_4 -# 572| r0_6(unknown[31]) = Constant[0] : -# 572| r0_7(int) = Constant[1] : -# 572| r0_8(glval) = PointerAdd : r0_2, r0_7 -# 572| mu0_9(unknown[31]) = Store : r0_8, r0_6 -# 573| r0_10(glval) = VariableAddress[a_nopad] : -# 573| r0_11(glval) = StringConstant["foo"] : -# 573| r0_12(char[4]) = Load : r0_11, mu0_1 -# 573| m0_13(char[4]) = Store : r0_10, r0_12 -# 574| r0_14(glval) = VariableAddress[a_infer] : -# 574| r0_15(glval) = StringConstant["blah"] : -# 574| r0_16(char[5]) = Load : r0_15, mu0_1 -# 574| m0_17(char[5]) = Store : r0_14, r0_16 -# 575| r0_18(glval) = VariableAddress[b] : -# 575| m0_19(char[2]) = Uninitialized : r0_18 -# 576| r0_20(glval) = VariableAddress[c] : -# 576| mu0_21(char[2]) = Uninitialized : r0_20 -# 576| r0_22(int) = Constant[0] : -# 576| r0_23(glval) = PointerAdd : r0_20, r0_22 -# 576| r0_24(unknown[2]) = Constant[0] : -# 576| mu0_25(unknown[2]) = Store : r0_23, r0_24 -# 577| r0_26(glval) = VariableAddress[d] : -# 577| mu0_27(char[2]) = Uninitialized : r0_26 -# 577| r0_28(int) = Constant[0] : -# 577| r0_29(glval) = PointerAdd : r0_26, r0_28 -# 577| r0_30(char) = Constant[0] : -# 577| mu0_31(char) = Store : r0_29, r0_30 -# 577| r0_32(int) = Constant[1] : -# 577| r0_33(glval) = PointerAdd : r0_26, r0_32 -# 577| r0_34(char) = Constant[0] : -# 577| mu0_35(char) = Store : r0_33, r0_34 -# 578| r0_36(glval) = VariableAddress[e] : -# 578| mu0_37(char[2]) = Uninitialized : r0_36 -# 578| r0_38(int) = Constant[0] : -# 578| r0_39(glval) = PointerAdd : r0_36, r0_38 -# 578| r0_40(char) = Constant[0] : -# 578| mu0_41(char) = Store : r0_39, r0_40 -# 578| r0_42(int) = Constant[1] : -# 578| r0_43(glval) = PointerAdd : r0_36, r0_42 -# 578| r0_44(char) = Constant[1] : -# 578| mu0_45(char) = Store : r0_43, r0_44 -# 579| r0_46(glval) = VariableAddress[f] : -# 579| mu0_47(char[3]) = Uninitialized : r0_46 -# 579| r0_48(int) = Constant[0] : -# 579| r0_49(glval) = PointerAdd : r0_46, r0_48 -# 579| r0_50(char) = Constant[0] : -# 579| mu0_51(char) = Store : r0_49, r0_50 -# 579| r0_52(int) = Constant[1] : -# 579| r0_53(glval) = PointerAdd : r0_46, r0_52 -# 579| r0_54(unknown[2]) = Constant[0] : -# 579| mu0_55(unknown[2]) = Store : r0_53, r0_54 -# 580| v0_56(void) = NoOp : -# 571| v0_57(void) = ReturnVoid : -# 571| v0_58(void) = UnmodeledUse : mu* -# 571| v0_59(void) = ExitFunction : +# 571| m0_1(unknown) = AliasedDefinition : +# 571| mu0_2(unknown) = UnmodeledDefinition : +# 572| r0_3(glval) = VariableAddress[a_pad] : +# 572| r0_4(glval) = StringConstant[""] : +# 572| r0_5(char[1]) = Load : r0_4, m0_1 +# 572| mu0_6(char[1]) = Store : r0_3, r0_5 +# 572| r0_7(unknown[31]) = Constant[0] : +# 572| r0_8(int) = Constant[1] : +# 572| r0_9(glval) = PointerAdd : r0_3, r0_8 +# 572| m0_10(unknown[31]) = Store : r0_9, r0_7 +# 572| m0_11(unknown) = Chi : m0_1, m0_10 +# 573| r0_12(glval) = VariableAddress[a_nopad] : +# 573| r0_13(glval) = StringConstant["foo"] : +# 573| r0_14(char[4]) = Load : r0_13, m0_11 +# 573| m0_15(char[4]) = Store : r0_12, r0_14 +# 574| r0_16(glval) = VariableAddress[a_infer] : +# 574| r0_17(glval) = StringConstant["blah"] : +# 574| r0_18(char[5]) = Load : r0_17, m0_11 +# 574| m0_19(char[5]) = Store : r0_16, r0_18 +# 575| r0_20(glval) = VariableAddress[b] : +# 575| m0_21(char[2]) = Uninitialized : r0_20 +# 576| r0_22(glval) = VariableAddress[c] : +# 576| mu0_23(char[2]) = Uninitialized : r0_22 +# 576| r0_24(int) = Constant[0] : +# 576| r0_25(glval) = PointerAdd : r0_22, r0_24 +# 576| r0_26(unknown[2]) = Constant[0] : +# 576| m0_27(unknown[2]) = Store : r0_25, r0_26 +# 576| m0_28(unknown) = Chi : m0_11, m0_27 +# 577| r0_29(glval) = VariableAddress[d] : +# 577| mu0_30(char[2]) = Uninitialized : r0_29 +# 577| r0_31(int) = Constant[0] : +# 577| r0_32(glval) = PointerAdd : r0_29, r0_31 +# 577| r0_33(char) = Constant[0] : +# 577| m0_34(char) = Store : r0_32, r0_33 +# 577| m0_35(unknown) = Chi : m0_28, m0_34 +# 577| r0_36(int) = Constant[1] : +# 577| r0_37(glval) = PointerAdd : r0_29, r0_36 +# 577| r0_38(char) = Constant[0] : +# 577| m0_39(char) = Store : r0_37, r0_38 +# 577| m0_40(unknown) = Chi : m0_35, m0_39 +# 578| r0_41(glval) = VariableAddress[e] : +# 578| mu0_42(char[2]) = Uninitialized : r0_41 +# 578| r0_43(int) = Constant[0] : +# 578| r0_44(glval) = PointerAdd : r0_41, r0_43 +# 578| r0_45(char) = Constant[0] : +# 578| m0_46(char) = Store : r0_44, r0_45 +# 578| m0_47(unknown) = Chi : m0_40, m0_46 +# 578| r0_48(int) = Constant[1] : +# 578| r0_49(glval) = PointerAdd : r0_41, r0_48 +# 578| r0_50(char) = Constant[1] : +# 578| m0_51(char) = Store : r0_49, r0_50 +# 578| m0_52(unknown) = Chi : m0_47, m0_51 +# 579| r0_53(glval) = VariableAddress[f] : +# 579| mu0_54(char[3]) = Uninitialized : r0_53 +# 579| r0_55(int) = Constant[0] : +# 579| r0_56(glval) = PointerAdd : r0_53, r0_55 +# 579| r0_57(char) = Constant[0] : +# 579| m0_58(char) = Store : r0_56, r0_57 +# 579| m0_59(unknown) = Chi : m0_52, m0_58 +# 579| r0_60(int) = Constant[1] : +# 579| r0_61(glval) = PointerAdd : r0_53, r0_60 +# 579| r0_62(unknown[2]) = Constant[0] : +# 579| m0_63(unknown[2]) = Store : r0_61, r0_62 +# 579| m0_64(unknown) = Chi : m0_59, m0_63 +# 580| v0_65(void) = NoOp : +# 571| v0_66(void) = ReturnVoid : +# 571| v0_67(void) = UnmodeledUse : mu* +# 571| v0_68(void) = ExitFunction : # 584| VarArgs() -> void # 584| Block 0 # 584| v0_0(void) = EnterFunction : -# 584| mu0_1(unknown) = UnmodeledDefinition : -# 585| r0_2(glval) = FunctionAddress[VarArgFunction] : -# 585| r0_3(glval) = StringConstant["%d %s"] : -# 585| r0_4(char *) = Convert : r0_3 -# 585| r0_5(int) = Constant[1] : -# 585| r0_6(glval) = StringConstant["string"] : -# 585| r0_7(char *) = Convert : r0_6 -# 585| v0_8(void) = Call : r0_2, r0_4, r0_5, r0_7 -# 586| v0_9(void) = NoOp : -# 584| v0_10(void) = ReturnVoid : -# 584| v0_11(void) = UnmodeledUse : mu* -# 584| v0_12(void) = ExitFunction : +# 584| m0_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 : r0_3, r0_5, r0_6, r0_8 +# 585| m0_10(unknown) = ^CallSideEffect : m0_1 +# 585| m0_11(unknown) = Chi : m0_1, m0_10 +# 586| v0_12(void) = NoOp : +# 584| v0_13(void) = ReturnVoid : +# 584| v0_14(void) = UnmodeledUse : mu* +# 584| v0_15(void) = ExitFunction : # 590| SetFuncPtr() -> void # 590| Block 0 # 590| v0_0(void) = EnterFunction : -# 590| mu0_1(unknown) = UnmodeledDefinition : -# 591| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r0_3(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 591| m0_4(..(*)(..)) = Store : r0_2, r0_3 -# 592| r0_5(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| m0_7(..(*)(..)) = Store : r0_6, r0_5 -# 593| r0_8(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 593| r0_9(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| m0_10(..(*)(..)) = Store : r0_9, r0_8 -# 594| r0_11(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r0_12(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| m0_13(..(*)(..)) = Store : r0_12, r0_11 -# 595| v0_14(void) = NoOp : -# 590| v0_15(void) = ReturnVoid : -# 590| v0_16(void) = UnmodeledUse : mu* -# 590| v0_17(void) = ExitFunction : +# 590| m0_1(unknown) = AliasedDefinition : +# 590| mu0_2(unknown) = UnmodeledDefinition : +# 591| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r0_4(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 591| m0_5(..(*)(..)) = Store : r0_3, r0_4 +# 592| r0_6(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| m0_8(..(*)(..)) = Store : r0_7, r0_6 +# 593| r0_9(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 593| r0_10(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| m0_11(..(*)(..)) = Store : r0_10, r0_9 +# 594| r0_12(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r0_13(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| m0_14(..(*)(..)) = Store : r0_13, r0_12 +# 595| v0_15(void) = NoOp : +# 590| v0_16(void) = ReturnVoid : +# 590| v0_17(void) = UnmodeledUse : mu* +# 590| v0_18(void) = ExitFunction : # 615| DeclareObject() -> void # 615| Block 0 # 615| v0_0(void) = EnterFunction : -# 615| mu0_1(unknown) = UnmodeledDefinition : -# 616| r0_2(glval) = VariableAddress[s1] : -# 616| r0_3(glval) = FunctionAddress[String] : -# 616| v0_4(void) = Call : r0_3, this:r0_2 -# 617| r0_5(glval) = VariableAddress[s2] : -# 617| r0_6(glval) = FunctionAddress[String] : -# 617| r0_7(glval) = StringConstant["hello"] : -# 617| r0_8(char *) = Convert : r0_7 -# 617| v0_9(void) = Call : r0_6, this:r0_5, r0_8 -# 618| r0_10(glval) = VariableAddress[s3] : -# 618| r0_11(glval) = FunctionAddress[ReturnObject] : -# 618| r0_12(String) = Call : r0_11 -# 618| m0_13(String) = Store : r0_10, r0_12 -# 619| r0_14(glval) = VariableAddress[s4] : -# 619| r0_15(glval) = FunctionAddress[String] : -# 619| r0_16(glval) = StringConstant["test"] : -# 619| r0_17(char *) = Convert : r0_16 -# 619| v0_18(void) = Call : r0_15, this:r0_14, r0_17 -# 620| v0_19(void) = NoOp : -# 615| v0_20(void) = ReturnVoid : -# 615| v0_21(void) = UnmodeledUse : mu* -# 615| v0_22(void) = ExitFunction : +# 615| m0_1(unknown) = AliasedDefinition : +# 615| mu0_2(unknown) = UnmodeledDefinition : +# 616| r0_3(glval) = VariableAddress[s1] : +# 616| r0_4(glval) = FunctionAddress[String] : +# 616| v0_5(void) = Call : r0_4, this:r0_3 +# 616| m0_6(unknown) = ^CallSideEffect : m0_1 +# 616| m0_7(unknown) = Chi : m0_1, m0_6 +# 617| r0_8(glval) = VariableAddress[s2] : +# 617| r0_9(glval) = FunctionAddress[String] : +# 617| r0_10(glval) = StringConstant["hello"] : +# 617| r0_11(char *) = Convert : r0_10 +# 617| v0_12(void) = Call : r0_9, this:r0_8, r0_11 +# 617| m0_13(unknown) = ^CallSideEffect : m0_7 +# 617| m0_14(unknown) = Chi : m0_7, m0_13 +# 618| r0_15(glval) = VariableAddress[s3] : +# 618| r0_16(glval) = FunctionAddress[ReturnObject] : +# 618| r0_17(String) = Call : r0_16 +# 618| m0_18(unknown) = ^CallSideEffect : m0_14 +# 618| m0_19(unknown) = Chi : m0_14, m0_18 +# 618| m0_20(String) = Store : r0_15, r0_17 +# 619| r0_21(glval) = VariableAddress[s4] : +# 619| r0_22(glval) = FunctionAddress[String] : +# 619| r0_23(glval) = StringConstant["test"] : +# 619| r0_24(char *) = Convert : r0_23 +# 619| v0_25(void) = Call : r0_22, this:r0_21, r0_24 +# 619| m0_26(unknown) = ^CallSideEffect : m0_19 +# 619| m0_27(unknown) = Chi : m0_19, m0_26 +# 620| v0_28(void) = NoOp : +# 615| v0_29(void) = ReturnVoid : +# 615| v0_30(void) = UnmodeledUse : mu* +# 615| v0_31(void) = ExitFunction : # 622| CallMethods(String &, String *, String) -> void # 622| Block 0 # 622| v0_0(void) = EnterFunction : -# 622| mu0_1(unknown) = UnmodeledDefinition : -# 622| r0_2(glval) = VariableAddress[r] : -# 622| m0_3(String &) = InitializeParameter[r] : r0_2 -# 622| r0_4(glval) = VariableAddress[p] : -# 622| m0_5(String *) = InitializeParameter[p] : r0_4 -# 622| r0_6(glval) = VariableAddress[s] : -# 622| mu0_7(String) = InitializeParameter[s] : r0_6 -# 623| r0_8(glval) = VariableAddress[r] : -# 623| r0_9(String &) = Load : r0_8, m0_3 -# 623| r0_10(glval) = Convert : r0_9 -# 623| r0_11(glval) = FunctionAddress[c_str] : -# 623| r0_12(char *) = Call : r0_11, this:r0_10 -# 624| r0_13(glval) = VariableAddress[p] : -# 624| r0_14(String *) = Load : r0_13, m0_5 -# 624| r0_15(String *) = Convert : r0_14 -# 624| r0_16(glval) = FunctionAddress[c_str] : -# 624| r0_17(char *) = Call : r0_16, this:r0_15 -# 625| r0_18(glval) = VariableAddress[s] : -# 625| r0_19(glval) = Convert : r0_18 -# 625| r0_20(glval) = FunctionAddress[c_str] : -# 625| r0_21(char *) = Call : r0_20, this:r0_19 -# 626| v0_22(void) = NoOp : -# 622| v0_23(void) = ReturnVoid : -# 622| v0_24(void) = UnmodeledUse : mu* -# 622| v0_25(void) = ExitFunction : +# 622| m0_1(unknown) = AliasedDefinition : +# 622| mu0_2(unknown) = UnmodeledDefinition : +# 622| r0_3(glval) = VariableAddress[r] : +# 622| m0_4(String &) = InitializeParameter[r] : r0_3 +# 622| r0_5(glval) = VariableAddress[p] : +# 622| m0_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, m0_4 +# 623| r0_11(glval) = Convert : r0_10 +# 623| r0_12(glval) = FunctionAddress[c_str] : +# 623| r0_13(char *) = Call : r0_12, this:r0_11 +# 623| m0_14(unknown) = ^CallSideEffect : m0_1 +# 623| m0_15(unknown) = Chi : m0_1, m0_14 +# 624| r0_16(glval) = VariableAddress[p] : +# 624| r0_17(String *) = Load : r0_16, m0_6 +# 624| r0_18(String *) = Convert : r0_17 +# 624| r0_19(glval) = FunctionAddress[c_str] : +# 624| r0_20(char *) = Call : r0_19, this:r0_18 +# 624| m0_21(unknown) = ^CallSideEffect : m0_15 +# 624| m0_22(unknown) = Chi : m0_15, m0_21 +# 625| r0_23(glval) = VariableAddress[s] : +# 625| r0_24(glval) = Convert : r0_23 +# 625| r0_25(glval) = FunctionAddress[c_str] : +# 625| r0_26(char *) = Call : r0_25, this:r0_24 +# 625| m0_27(unknown) = ^CallSideEffect : m0_22 +# 625| m0_28(unknown) = Chi : m0_22, m0_27 +# 626| v0_29(void) = NoOp : +# 622| v0_30(void) = ReturnVoid : +# 622| v0_31(void) = UnmodeledUse : mu* +# 622| v0_32(void) = ExitFunction : # 630| C::StaticMemberFunction(int) -> int # 630| Block 0 # 630| v0_0(void) = EnterFunction : -# 630| mu0_1(unknown) = UnmodeledDefinition : -# 630| r0_2(glval) = VariableAddress[x] : -# 630| m0_3(int) = InitializeParameter[x] : r0_2 -# 631| r0_4(glval) = VariableAddress[#return] : -# 631| r0_5(glval) = VariableAddress[x] : -# 631| r0_6(int) = Load : r0_5, m0_3 -# 631| m0_7(int) = Store : r0_4, r0_6 -# 630| r0_8(glval) = VariableAddress[#return] : -# 630| v0_9(void) = ReturnValue : r0_8, m0_7 -# 630| v0_10(void) = UnmodeledUse : mu* -# 630| v0_11(void) = ExitFunction : +# 630| m0_1(unknown) = AliasedDefinition : +# 630| mu0_2(unknown) = UnmodeledDefinition : +# 630| r0_3(glval) = VariableAddress[x] : +# 630| m0_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, m0_4 +# 631| m0_8(int) = Store : r0_5, r0_7 +# 630| r0_9(glval) = VariableAddress[#return] : +# 630| v0_10(void) = ReturnValue : r0_9, m0_8 +# 630| v0_11(void) = UnmodeledUse : mu* +# 630| v0_12(void) = ExitFunction : # 634| C::InstanceMemberFunction(int) -> int # 634| Block 0 -# 634| v0_0(void) = EnterFunction : -# 634| mu0_1(unknown) = UnmodeledDefinition : -# 634| r0_2(glval) = InitializeThis : -# 634| r0_3(glval) = VariableAddress[x] : -# 634| m0_4(int) = InitializeParameter[x] : r0_3 -# 635| r0_5(glval) = VariableAddress[#return] : -# 635| r0_6(glval) = VariableAddress[x] : -# 635| r0_7(int) = Load : r0_6, m0_4 -# 635| m0_8(int) = Store : r0_5, r0_7 -# 634| r0_9(glval) = VariableAddress[#return] : -# 634| v0_10(void) = ReturnValue : r0_9, m0_8 -# 634| v0_11(void) = UnmodeledUse : mu* -# 634| v0_12(void) = ExitFunction : +# 634| v0_0(void) = EnterFunction : +# 634| m0_1(unknown) = AliasedDefinition : +# 634| mu0_2(unknown) = UnmodeledDefinition : +# 634| r0_3(glval) = InitializeThis : +# 634| r0_4(glval) = VariableAddress[x] : +# 634| m0_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, m0_5 +# 635| m0_9(int) = Store : r0_6, r0_8 +# 634| r0_10(glval) = VariableAddress[#return] : +# 634| v0_11(void) = ReturnValue : r0_10, m0_9 +# 634| v0_12(void) = UnmodeledUse : mu* +# 634| v0_13(void) = ExitFunction : # 638| C::VirtualMemberFunction(int) -> int # 638| Block 0 -# 638| v0_0(void) = EnterFunction : -# 638| mu0_1(unknown) = UnmodeledDefinition : -# 638| r0_2(glval) = InitializeThis : -# 638| r0_3(glval) = VariableAddress[x] : -# 638| m0_4(int) = InitializeParameter[x] : r0_3 -# 639| r0_5(glval) = VariableAddress[#return] : -# 639| r0_6(glval) = VariableAddress[x] : -# 639| r0_7(int) = Load : r0_6, m0_4 -# 639| m0_8(int) = Store : r0_5, r0_7 -# 638| r0_9(glval) = VariableAddress[#return] : -# 638| v0_10(void) = ReturnValue : r0_9, m0_8 -# 638| v0_11(void) = UnmodeledUse : mu* -# 638| v0_12(void) = ExitFunction : +# 638| v0_0(void) = EnterFunction : +# 638| m0_1(unknown) = AliasedDefinition : +# 638| mu0_2(unknown) = UnmodeledDefinition : +# 638| r0_3(glval) = InitializeThis : +# 638| r0_4(glval) = VariableAddress[x] : +# 638| m0_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, m0_5 +# 639| m0_9(int) = Store : r0_6, r0_8 +# 638| r0_10(glval) = VariableAddress[#return] : +# 638| v0_11(void) = ReturnValue : r0_10, m0_9 +# 638| v0_12(void) = UnmodeledUse : mu* +# 638| v0_13(void) = ExitFunction : # 642| C::FieldAccess() -> void # 642| Block 0 # 642| v0_0(void) = EnterFunction : -# 642| mu0_1(unknown) = UnmodeledDefinition : -# 642| r0_2(glval) = InitializeThis : -# 643| r0_3(int) = Constant[0] : -# 643| r0_4(C *) = CopyValue : r0_2 -# 643| r0_5(glval) = FieldAddress[m_a] : r0_4 -# 643| mu0_6(int) = Store : r0_5, r0_3 -# 644| r0_7(int) = Constant[1] : -# 644| r0_8(C *) = CopyValue : r0_2 -# 644| r0_9(glval) = FieldAddress[m_a] : r0_8 -# 644| mu0_10(int) = Store : r0_9, r0_7 -# 645| r0_11(int) = Constant[2] : -#-----| r0_12(C *) = CopyValue : r0_2 -# 645| r0_13(glval) = FieldAddress[m_a] : r0_12 -# 645| mu0_14(int) = Store : r0_13, r0_11 -# 646| r0_15(glval) = VariableAddress[x] : -# 646| m0_16(int) = Uninitialized : r0_15 -# 647| r0_17(C *) = CopyValue : r0_2 -# 647| r0_18(glval) = FieldAddress[m_a] : r0_17 -# 647| r0_19(int) = Load : r0_18, mu0_1 -# 647| r0_20(glval) = VariableAddress[x] : -# 647| m0_21(int) = Store : r0_20, r0_19 -# 648| r0_22(C *) = CopyValue : r0_2 -# 648| r0_23(glval) = FieldAddress[m_a] : r0_22 -# 648| r0_24(int) = Load : r0_23, mu0_1 -# 648| r0_25(glval) = VariableAddress[x] : -# 648| m0_26(int) = Store : r0_25, r0_24 -#-----| r0_27(C *) = CopyValue : r0_2 -# 649| r0_28(glval) = FieldAddress[m_a] : r0_27 -# 649| r0_29(int) = Load : r0_28, mu0_1 -# 649| r0_30(glval) = VariableAddress[x] : -# 649| m0_31(int) = Store : r0_30, r0_29 -# 650| v0_32(void) = NoOp : -# 642| v0_33(void) = ReturnVoid : -# 642| v0_34(void) = UnmodeledUse : mu* -# 642| v0_35(void) = ExitFunction : +# 642| m0_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| m0_7(int) = Store : r0_6, r0_4 +# 643| m0_8(unknown) = Chi : m0_1, m0_7 +# 644| r0_9(int) = Constant[1] : +# 644| r0_10(C *) = CopyValue : r0_3 +# 644| r0_11(glval) = FieldAddress[m_a] : r0_10 +# 644| m0_12(int) = Store : r0_11, r0_9 +# 644| m0_13(unknown) = Chi : m0_8, m0_12 +# 645| r0_14(int) = Constant[2] : +#-----| r0_15(C *) = CopyValue : r0_3 +# 645| r0_16(glval) = FieldAddress[m_a] : r0_15 +# 645| m0_17(int) = Store : r0_16, r0_14 +# 645| m0_18(unknown) = Chi : m0_13, m0_17 +# 646| r0_19(glval) = VariableAddress[x] : +# 646| m0_20(int) = Uninitialized : r0_19 +# 647| r0_21(C *) = CopyValue : r0_3 +# 647| r0_22(glval) = FieldAddress[m_a] : r0_21 +# 647| r0_23(int) = Load : r0_22, m0_18 +# 647| r0_24(glval) = VariableAddress[x] : +# 647| m0_25(int) = Store : r0_24, r0_23 +# 648| r0_26(C *) = CopyValue : r0_3 +# 648| r0_27(glval) = FieldAddress[m_a] : r0_26 +# 648| r0_28(int) = Load : r0_27, m0_18 +# 648| r0_29(glval) = VariableAddress[x] : +# 648| m0_30(int) = Store : r0_29, r0_28 +#-----| r0_31(C *) = CopyValue : r0_3 +# 649| r0_32(glval) = FieldAddress[m_a] : r0_31 +# 649| r0_33(int) = Load : r0_32, m0_18 +# 649| r0_34(glval) = VariableAddress[x] : +# 649| m0_35(int) = Store : r0_34, r0_33 +# 650| v0_36(void) = NoOp : +# 642| v0_37(void) = ReturnVoid : +# 642| v0_38(void) = UnmodeledUse : mu* +# 642| v0_39(void) = ExitFunction : # 652| C::MethodCalls() -> void # 652| Block 0 # 652| v0_0(void) = EnterFunction : -# 652| mu0_1(unknown) = UnmodeledDefinition : -# 652| r0_2(glval) = InitializeThis : -# 653| r0_3(C *) = CopyValue : r0_2 -# 653| r0_4(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r0_5(int) = Constant[0] : -# 653| r0_6(int) = Call : r0_4, this:r0_3, r0_5 -# 654| r0_7(C *) = CopyValue : r0_2 -# 654| r0_8(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r0_9(int) = Constant[1] : -# 654| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -#-----| r0_11(C *) = CopyValue : r0_2 -# 655| r0_12(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r0_13(int) = Constant[2] : -# 655| r0_14(int) = Call : r0_12, this:r0_11, r0_13 -# 656| v0_15(void) = NoOp : -# 652| v0_16(void) = ReturnVoid : -# 652| v0_17(void) = UnmodeledUse : mu* -# 652| v0_18(void) = ExitFunction : +# 652| m0_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 : r0_5, this:r0_4, r0_6 +# 653| m0_8(unknown) = ^CallSideEffect : m0_1 +# 653| m0_9(unknown) = Chi : m0_1, m0_8 +# 654| r0_10(C *) = CopyValue : r0_3 +# 654| r0_11(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r0_12(int) = Constant[1] : +# 654| r0_13(int) = Call : r0_11, this:r0_10, r0_12 +# 654| m0_14(unknown) = ^CallSideEffect : m0_9 +# 654| m0_15(unknown) = Chi : m0_9, m0_14 +#-----| r0_16(C *) = CopyValue : r0_3 +# 655| r0_17(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r0_18(int) = Constant[2] : +# 655| r0_19(int) = Call : r0_17, this:r0_16, r0_18 +# 655| m0_20(unknown) = ^CallSideEffect : m0_15 +# 655| m0_21(unknown) = Chi : m0_15, m0_20 +# 656| v0_22(void) = NoOp : +# 652| v0_23(void) = ReturnVoid : +# 652| v0_24(void) = UnmodeledUse : mu* +# 652| v0_25(void) = ExitFunction : # 658| C::C() -> void # 658| Block 0 # 658| v0_0(void) = EnterFunction : -# 658| mu0_1(unknown) = UnmodeledDefinition : -# 658| r0_2(glval) = InitializeThis : -# 659| r0_3(glval) = FieldAddress[m_a] : r0_2 -# 659| r0_4(int) = Constant[1] : -# 659| mu0_5(int) = Store : r0_3, r0_4 -# 663| r0_6(glval) = FieldAddress[m_b] : r0_2 -# 663| r0_7(glval) = FunctionAddress[String] : -# 663| v0_8(void) = Call : r0_7, this:r0_6 -# 660| r0_9(glval) = FieldAddress[m_c] : r0_2 -# 660| r0_10(char) = Constant[3] : -# 660| mu0_11(char) = Store : r0_9, r0_10 -# 661| r0_12(glval) = FieldAddress[m_e] : r0_2 -# 661| r0_13(void *) = Constant[0] : -# 661| mu0_14(void *) = Store : r0_12, r0_13 -# 662| r0_15(glval) = FieldAddress[m_f] : r0_2 -# 662| r0_16(glval) = FunctionAddress[String] : -# 662| r0_17(glval) = StringConstant["test"] : -# 662| r0_18(char *) = Convert : r0_17 -# 662| v0_19(void) = Call : r0_16, this:r0_15, r0_18 -# 664| v0_20(void) = NoOp : -# 658| v0_21(void) = ReturnVoid : -# 658| v0_22(void) = UnmodeledUse : mu* -# 658| v0_23(void) = ExitFunction : +# 658| m0_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| m0_6(int) = Store : r0_4, r0_5 +# 659| m0_7(unknown) = Chi : m0_1, m0_6 +# 663| r0_8(glval) = FieldAddress[m_b] : r0_3 +# 663| r0_9(glval) = FunctionAddress[String] : +# 663| v0_10(void) = Call : r0_9, this:r0_8 +# 663| m0_11(unknown) = ^CallSideEffect : m0_7 +# 663| m0_12(unknown) = Chi : m0_7, m0_11 +# 660| r0_13(glval) = FieldAddress[m_c] : r0_3 +# 660| r0_14(char) = Constant[3] : +# 660| m0_15(char) = Store : r0_13, r0_14 +# 660| m0_16(unknown) = Chi : m0_12, m0_15 +# 661| r0_17(glval) = FieldAddress[m_e] : r0_3 +# 661| r0_18(void *) = Constant[0] : +# 661| m0_19(void *) = Store : r0_17, r0_18 +# 661| m0_20(unknown) = Chi : m0_16, m0_19 +# 662| r0_21(glval) = FieldAddress[m_f] : r0_3 +# 662| r0_22(glval) = FunctionAddress[String] : +# 662| r0_23(glval) = StringConstant["test"] : +# 662| r0_24(char *) = Convert : r0_23 +# 662| v0_25(void) = Call : r0_22, this:r0_21, r0_24 +# 662| m0_26(unknown) = ^CallSideEffect : m0_20 +# 662| m0_27(unknown) = Chi : m0_20, m0_26 +# 664| v0_28(void) = NoOp : +# 658| v0_29(void) = ReturnVoid : +# 658| v0_30(void) = UnmodeledUse : mu* +# 658| v0_31(void) = ExitFunction : # 675| DerefReference(int &) -> int # 675| Block 0 # 675| v0_0(void) = EnterFunction : -# 675| mu0_1(unknown) = UnmodeledDefinition : -# 675| r0_2(glval) = VariableAddress[r] : -# 675| m0_3(int &) = InitializeParameter[r] : r0_2 -# 676| r0_4(glval) = VariableAddress[#return] : -# 676| r0_5(glval) = VariableAddress[r] : -# 676| r0_6(int &) = Load : r0_5, m0_3 -# 676| r0_7(int) = Load : r0_6, mu0_1 -# 676| m0_8(int) = Store : r0_4, r0_7 -# 675| r0_9(glval) = VariableAddress[#return] : -# 675| v0_10(void) = ReturnValue : r0_9, m0_8 -# 675| v0_11(void) = UnmodeledUse : mu* -# 675| v0_12(void) = ExitFunction : +# 675| m0_1(unknown) = AliasedDefinition : +# 675| mu0_2(unknown) = UnmodeledDefinition : +# 675| r0_3(glval) = VariableAddress[r] : +# 675| m0_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, m0_4 +# 676| r0_8(int) = Load : r0_7, m0_1 +# 676| m0_9(int) = Store : r0_5, r0_8 +# 675| r0_10(glval) = VariableAddress[#return] : +# 675| v0_11(void) = ReturnValue : r0_10, m0_9 +# 675| v0_12(void) = UnmodeledUse : mu* +# 675| v0_13(void) = ExitFunction : # 679| TakeReference() -> int & # 679| Block 0 # 679| v0_0(void) = EnterFunction : -# 679| mu0_1(unknown) = UnmodeledDefinition : -# 680| r0_2(glval) = VariableAddress[#return] : -# 680| r0_3(glval) = VariableAddress[g] : -# 680| m0_4(int &) = Store : r0_2, r0_3 -# 679| r0_5(glval) = VariableAddress[#return] : -# 679| v0_6(void) = ReturnValue : r0_5, m0_4 -# 679| v0_7(void) = UnmodeledUse : mu* -# 679| v0_8(void) = ExitFunction : +# 679| m0_1(unknown) = AliasedDefinition : +# 679| mu0_2(unknown) = UnmodeledDefinition : +# 680| r0_3(glval) = VariableAddress[#return] : +# 680| r0_4(glval) = VariableAddress[g] : +# 680| m0_5(int &) = Store : r0_3, r0_4 +# 679| r0_6(glval) = VariableAddress[#return] : +# 679| v0_7(void) = ReturnValue : r0_6, m0_5 +# 679| v0_8(void) = UnmodeledUse : mu* +# 679| v0_9(void) = ExitFunction : # 685| InitReference(int) -> void # 685| Block 0 # 685| v0_0(void) = EnterFunction : -# 685| mu0_1(unknown) = UnmodeledDefinition : -# 685| r0_2(glval) = VariableAddress[x] : -# 685| m0_3(int) = InitializeParameter[x] : r0_2 -# 686| r0_4(glval) = VariableAddress[r] : -# 686| r0_5(glval) = VariableAddress[x] : -# 686| m0_6(int &) = Store : r0_4, r0_5 -# 687| r0_7(glval) = VariableAddress[r2] : -# 687| r0_8(glval) = VariableAddress[r] : -# 687| r0_9(int &) = Load : r0_8, m0_6 -# 687| m0_10(int &) = Store : r0_7, r0_9 -# 688| r0_11(glval) = VariableAddress[r3] : -# 688| r0_12(glval) = FunctionAddress[ReturnReference] : -# 688| r0_13(String &) = Call : r0_12 -# 688| r0_14(glval) = Convert : r0_13 -# 688| m0_15(String &) = Store : r0_11, r0_14 -# 689| v0_16(void) = NoOp : -# 685| v0_17(void) = ReturnVoid : -# 685| v0_18(void) = UnmodeledUse : mu* -# 685| v0_19(void) = ExitFunction : +# 685| m0_1(unknown) = AliasedDefinition : +# 685| mu0_2(unknown) = UnmodeledDefinition : +# 685| r0_3(glval) = VariableAddress[x] : +# 685| m0_4(int) = InitializeParameter[x] : r0_3 +# 686| r0_5(glval) = VariableAddress[r] : +# 686| r0_6(glval) = VariableAddress[x] : +# 686| m0_7(int &) = Store : r0_5, r0_6 +# 687| r0_8(glval) = VariableAddress[r2] : +# 687| r0_9(glval) = VariableAddress[r] : +# 687| r0_10(int &) = Load : r0_9, m0_7 +# 687| m0_11(int &) = Store : r0_8, r0_10 +# 688| r0_12(glval) = VariableAddress[r3] : +# 688| r0_13(glval) = FunctionAddress[ReturnReference] : +# 688| r0_14(String &) = Call : r0_13 +# 688| m0_15(unknown) = ^CallSideEffect : m0_1 +# 688| m0_16(unknown) = Chi : m0_1, m0_15 +# 688| r0_17(glval) = Convert : r0_14 +# 688| m0_18(String &) = Store : r0_12, r0_17 +# 689| v0_19(void) = NoOp : +# 685| v0_20(void) = ReturnVoid : +# 685| v0_21(void) = UnmodeledUse : mu* +# 685| v0_22(void) = ExitFunction : # 691| ArrayReferences() -> void # 691| Block 0 # 691| v0_0(void) = EnterFunction : -# 691| mu0_1(unknown) = UnmodeledDefinition : -# 692| r0_2(glval) = VariableAddress[a] : -# 692| m0_3(int[10]) = Uninitialized : r0_2 -# 693| r0_4(glval) = VariableAddress[ra] : -# 693| r0_5(glval) = VariableAddress[a] : -# 693| m0_6(int(&)[10]) = Store : r0_4, r0_5 -# 694| r0_7(glval) = VariableAddress[x] : -# 694| r0_8(glval) = VariableAddress[ra] : -# 694| r0_9(int(&)[10]) = Load : r0_8, m0_6 -# 694| r0_10(int *) = Convert : r0_9 -# 694| r0_11(int) = Constant[5] : -# 694| r0_12(int *) = PointerAdd[4] : r0_10, r0_11 -# 694| r0_13(int) = Load : r0_12, mu0_1 -# 694| m0_14(int) = Store : r0_7, r0_13 -# 695| v0_15(void) = NoOp : -# 691| v0_16(void) = ReturnVoid : -# 691| v0_17(void) = UnmodeledUse : mu* -# 691| v0_18(void) = ExitFunction : +# 691| m0_1(unknown) = AliasedDefinition : +# 691| mu0_2(unknown) = UnmodeledDefinition : +# 692| r0_3(glval) = VariableAddress[a] : +# 692| m0_4(int[10]) = Uninitialized : r0_3 +# 693| r0_5(glval) = VariableAddress[ra] : +# 693| r0_6(glval) = VariableAddress[a] : +# 693| m0_7(int(&)[10]) = Store : r0_5, r0_6 +# 694| r0_8(glval) = VariableAddress[x] : +# 694| r0_9(glval) = VariableAddress[ra] : +# 694| r0_10(int(&)[10]) = Load : r0_9, m0_7 +# 694| r0_11(int *) = Convert : r0_10 +# 694| r0_12(int) = Constant[5] : +# 694| r0_13(int *) = PointerAdd[4] : r0_11, r0_12 +# 694| r0_14(int) = Load : r0_13, mu0_2 +# 694| m0_15(int) = Store : r0_8, r0_14 +# 695| v0_16(void) = NoOp : +# 691| v0_17(void) = ReturnVoid : +# 691| v0_18(void) = UnmodeledUse : mu* +# 691| v0_19(void) = ExitFunction : # 697| FunctionReferences() -> void # 697| Block 0 -# 697| v0_0(void) = EnterFunction : -# 697| mu0_1(unknown) = UnmodeledDefinition : -# 698| r0_2(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r0_3(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| m0_4(..(&)(..)) = Store : r0_2, r0_3 -# 699| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r0_6(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r0_7(..(&)(..)) = Load : r0_6, m0_4 -# 699| m0_8(..(*)(..)) = Store : r0_5, r0_7 -# 700| r0_9(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r0_10(..(&)(..)) = Load : r0_9, m0_4 -# 700| r0_11(int) = Constant[5] : -# 700| r0_12(int) = Call : r0_10, r0_11 -# 701| v0_13(void) = NoOp : -# 697| v0_14(void) = ReturnVoid : -# 697| v0_15(void) = UnmodeledUse : mu* -# 697| v0_16(void) = ExitFunction : +# 697| v0_0(void) = EnterFunction : +# 697| m0_1(unknown) = AliasedDefinition : +# 697| mu0_2(unknown) = UnmodeledDefinition : +# 698| r0_3(glval<..(&)(..)>) = VariableAddress[rfn] : +# 698| r0_4(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 698| m0_5(..(&)(..)) = Store : r0_3, r0_4 +# 699| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r0_7(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r0_8(..(&)(..)) = Load : r0_7, m0_5 +# 699| m0_9(..(*)(..)) = Store : r0_6, r0_8 +# 700| r0_10(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r0_11(..(&)(..)) = Load : r0_10, m0_5 +# 700| r0_12(int) = Constant[5] : +# 700| r0_13(int) = Call : r0_11, r0_12 +# 700| m0_14(unknown) = ^CallSideEffect : m0_1 +# 700| m0_15(unknown) = Chi : m0_1, m0_14 +# 701| v0_16(void) = NoOp : +# 697| v0_17(void) = ReturnVoid : +# 697| v0_18(void) = UnmodeledUse : mu* +# 697| v0_19(void) = ExitFunction : # 704| min(int, int) -> int # 704| Block 0 -# 704| v0_0(void) = EnterFunction : -# 704| mu0_1(unknown) = UnmodeledDefinition : -# 704| r0_2(glval) = VariableAddress[x] : -# 704| m0_3(int) = InitializeParameter[x] : r0_2 -# 704| r0_4(glval) = VariableAddress[y] : -# 704| m0_5(int) = InitializeParameter[y] : r0_4 -# 705| r0_6(glval) = VariableAddress[#return] : -# 705| r0_7(glval) = VariableAddress[x] : -# 705| r0_8(int) = Load : r0_7, m0_3 -# 705| r0_9(glval) = VariableAddress[y] : -# 705| r0_10(int) = Load : r0_9, m0_5 -# 705| r0_11(bool) = CompareLT : r0_8, r0_10 -# 705| v0_12(void) = ConditionalBranch : r0_11 +# 704| v0_0(void) = EnterFunction : +# 704| m0_1(unknown) = AliasedDefinition : +# 704| mu0_2(unknown) = UnmodeledDefinition : +# 704| r0_3(glval) = VariableAddress[x] : +# 704| m0_4(int) = InitializeParameter[x] : r0_3 +# 704| r0_5(glval) = VariableAddress[y] : +# 704| m0_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, m0_4 +# 705| r0_10(glval) = VariableAddress[y] : +# 705| r0_11(int) = Load : r0_10, m0_6 +# 705| r0_12(bool) = CompareLT : r0_9, r0_11 +# 705| v0_13(void) = ConditionalBranch : r0_12 #-----| False -> Block 2 #-----| True -> Block 1 # 705| Block 1 # 705| r1_0(glval) = VariableAddress[x] : -# 705| r1_1(int) = Load : r1_0, m0_3 +# 705| r1_1(int) = Load : r1_0, m0_4 # 705| r1_2(glval) = VariableAddress[#temp705:10] : # 705| m1_3(int) = Store : r1_2, r1_1 #-----| Goto -> Block 3 # 705| Block 2 # 705| r2_0(glval) = VariableAddress[y] : -# 705| r2_1(int) = Load : r2_0, m0_5 +# 705| r2_1(int) = Load : r2_0, m0_6 # 705| r2_2(glval) = VariableAddress[#temp705:10] : # 705| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 @@ -2932,7 +3102,7 @@ ir.cpp: # 705| m3_0(int) = Phi : from 1:m1_3, from 2:m2_3 # 705| r3_1(glval) = VariableAddress[#temp705:10] : # 705| r3_2(int) = Load : r3_1, m3_0 -# 705| m3_3(int) = Store : r0_6, r3_2 +# 705| m3_3(int) = Store : r0_7, r3_2 # 704| r3_4(glval) = VariableAddress[#return] : # 704| v3_5(void) = ReturnValue : r3_4, m3_3 # 704| v3_6(void) = UnmodeledUse : mu* @@ -2941,68 +3111,76 @@ ir.cpp: # 708| CallMin(int, int) -> int # 708| Block 0 # 708| v0_0(void) = EnterFunction : -# 708| mu0_1(unknown) = UnmodeledDefinition : -# 708| r0_2(glval) = VariableAddress[x] : -# 708| m0_3(int) = InitializeParameter[x] : r0_2 -# 708| r0_4(glval) = VariableAddress[y] : -# 708| m0_5(int) = InitializeParameter[y] : r0_4 -# 709| r0_6(glval) = VariableAddress[#return] : -# 709| r0_7(glval) = FunctionAddress[min] : -# 709| r0_8(glval) = VariableAddress[x] : -# 709| r0_9(int) = Load : r0_8, m0_3 -# 709| r0_10(glval) = VariableAddress[y] : -# 709| r0_11(int) = Load : r0_10, m0_5 -# 709| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 709| m0_13(int) = Store : r0_6, r0_12 -# 708| r0_14(glval) = VariableAddress[#return] : -# 708| v0_15(void) = ReturnValue : r0_14, m0_13 -# 708| v0_16(void) = UnmodeledUse : mu* -# 708| v0_17(void) = ExitFunction : +# 708| m0_1(unknown) = AliasedDefinition : +# 708| mu0_2(unknown) = UnmodeledDefinition : +# 708| r0_3(glval) = VariableAddress[x] : +# 708| m0_4(int) = InitializeParameter[x] : r0_3 +# 708| r0_5(glval) = VariableAddress[y] : +# 708| m0_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, m0_4 +# 709| r0_11(glval) = VariableAddress[y] : +# 709| r0_12(int) = Load : r0_11, m0_6 +# 709| r0_13(int) = Call : r0_8, r0_10, r0_12 +# 709| m0_14(unknown) = ^CallSideEffect : m0_1 +# 709| m0_15(unknown) = Chi : m0_1, m0_14 +# 709| m0_16(int) = Store : r0_7, r0_13 +# 708| r0_17(glval) = VariableAddress[#return] : +# 708| v0_18(void) = ReturnValue : r0_17, m0_16 +# 708| v0_19(void) = UnmodeledUse : mu* +# 708| v0_20(void) = ExitFunction : # 715| Outer::Func(void *, char) -> long # 715| Block 0 # 715| v0_0(void) = EnterFunction : -# 715| mu0_1(unknown) = UnmodeledDefinition : -# 715| r0_2(glval) = VariableAddress[x] : -# 715| m0_3(void *) = InitializeParameter[x] : r0_2 -# 715| r0_4(glval) = VariableAddress[y] : -# 715| m0_5(char) = InitializeParameter[y] : r0_4 -# 716| r0_6(glval) = VariableAddress[#return] : -# 716| r0_7(long) = Constant[0] : -# 716| m0_8(long) = Store : r0_6, r0_7 -# 715| r0_9(glval) = VariableAddress[#return] : -# 715| v0_10(void) = ReturnValue : r0_9, m0_8 -# 715| v0_11(void) = UnmodeledUse : mu* -# 715| v0_12(void) = ExitFunction : +# 715| m0_1(unknown) = AliasedDefinition : +# 715| mu0_2(unknown) = UnmodeledDefinition : +# 715| r0_3(glval) = VariableAddress[x] : +# 715| m0_4(void *) = InitializeParameter[x] : r0_3 +# 715| r0_5(glval) = VariableAddress[y] : +# 715| m0_6(char) = InitializeParameter[y] : r0_5 +# 716| r0_7(glval) = VariableAddress[#return] : +# 716| r0_8(long) = Constant[0] : +# 716| m0_9(long) = Store : r0_7, r0_8 +# 715| r0_10(glval) = VariableAddress[#return] : +# 715| v0_11(void) = ReturnValue : r0_10, m0_9 +# 715| v0_12(void) = UnmodeledUse : mu* +# 715| v0_13(void) = ExitFunction : # 720| CallNestedTemplateFunc() -> double # 720| Block 0 # 720| v0_0(void) = EnterFunction : -# 720| mu0_1(unknown) = UnmodeledDefinition : -# 721| r0_2(glval) = VariableAddress[#return] : -# 721| r0_3(glval) = FunctionAddress[Func] : -# 721| r0_4(void *) = Constant[0] : -# 721| r0_5(char) = Constant[111] : -# 721| r0_6(long) = Call : r0_3, r0_4, r0_5 -# 721| r0_7(double) = Convert : r0_6 -# 721| m0_8(double) = Store : r0_2, r0_7 -# 720| r0_9(glval) = VariableAddress[#return] : -# 720| v0_10(void) = ReturnValue : r0_9, m0_8 -# 720| v0_11(void) = UnmodeledUse : mu* -# 720| v0_12(void) = ExitFunction : +# 720| m0_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 : r0_4, r0_5, r0_6 +# 721| m0_8(unknown) = ^CallSideEffect : m0_1 +# 721| m0_9(unknown) = Chi : m0_1, m0_8 +# 721| r0_10(double) = Convert : r0_7 +# 721| m0_11(double) = Store : r0_3, r0_10 +# 720| r0_12(glval) = VariableAddress[#return] : +# 720| v0_13(void) = ReturnValue : r0_12, m0_11 +# 720| v0_14(void) = UnmodeledUse : mu* +# 720| v0_15(void) = ExitFunction : # 724| TryCatch(bool) -> void # 724| Block 0 # 724| v0_0(void) = EnterFunction : -# 724| mu0_1(unknown) = UnmodeledDefinition : -# 724| r0_2(glval) = VariableAddress[b] : -# 724| m0_3(bool) = InitializeParameter[b] : r0_2 -# 726| r0_4(glval) = VariableAddress[x] : -# 726| r0_5(int) = Constant[5] : -# 726| m0_6(int) = Store : r0_4, r0_5 -# 727| r0_7(glval) = VariableAddress[b] : -# 727| r0_8(bool) = Load : r0_7, m0_3 -# 727| v0_9(void) = ConditionalBranch : r0_8 +# 724| m0_1(unknown) = AliasedDefinition : +# 724| mu0_2(unknown) = UnmodeledDefinition : +# 724| r0_3(glval) = VariableAddress[b] : +# 724| m0_4(bool) = InitializeParameter[b] : r0_3 +# 726| r0_5(glval) = VariableAddress[x] : +# 726| r0_6(int) = Constant[5] : +# 726| m0_7(int) = Store : r0_5, r0_6 +# 727| r0_8(glval) = VariableAddress[b] : +# 727| r0_9(bool) = Load : r0_8, m0_4 +# 727| v0_10(void) = ConditionalBranch : r0_9 #-----| False -> Block 4 #-----| True -> Block 3 @@ -3024,7 +3202,7 @@ ir.cpp: # 730| Block 4 # 730| r4_0(glval) = VariableAddress[x] : -# 730| r4_1(int) = Load : r4_0, m0_6 +# 730| r4_1(int) = Load : r4_0, m0_7 # 730| r4_2(int) = Constant[2] : # 730| r4_3(bool) = CompareLT : r4_1, r4_2 # 730| v4_4(void) = ConditionalBranch : r4_3 @@ -3033,7 +3211,7 @@ ir.cpp: # 731| Block 5 # 731| r5_0(glval) = VariableAddress[b] : -# 731| r5_1(bool) = Load : r5_0, m0_3 +# 731| r5_1(bool) = Load : r5_0, m0_4 # 731| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 7 #-----| True -> Block 6 @@ -3054,7 +3232,9 @@ ir.cpp: # 731| r7_2(glval) = StringConstant["String object"] : # 731| r7_3(char *) = Convert : r7_2 # 731| v7_4(void) = Call : r7_1, this:r7_0, r7_3 -# 731| v7_5(void) = ThrowValue : r7_0, mu0_1 +# 731| m7_5(unknown) = ^CallSideEffect : m0_1 +# 731| m7_6(unknown) = Chi : m0_1, m7_5 +# 731| v7_7(void) = ThrowValue : r7_0, mu0_2 #-----| Exception -> Block 9 # 733| Block 8 @@ -3064,7 +3244,8 @@ ir.cpp: #-----| Goto -> Block 14 # 735| Block 9 -# 735| v9_0(void) = CatchByType[const char *] : +# 735| m9_0(unknown) = Phi : from 3:m0_1, from 7:m7_6 +# 735| v9_1(void) = CatchByType[const char *] : #-----| Exception -> Block 11 #-----| Goto -> Block 10 @@ -3076,7 +3257,9 @@ ir.cpp: # 736| r10_4(glval) = VariableAddress[s] : # 736| r10_5(char *) = Load : r10_4, m10_1 # 736| v10_6(void) = Call : r10_3, this:r10_2, r10_5 -# 736| v10_7(void) = ThrowValue : r10_2, mu0_1 +# 736| m10_7(unknown) = ^CallSideEffect : m9_0 +# 736| m10_8(unknown) = Chi : m9_0, m10_7 +# 736| v10_9(void) = ThrowValue : r10_2, mu0_2 #-----| Exception -> Block 2 # 738| Block 11 @@ -3103,721 +3286,856 @@ ir.cpp: # 745| Base::Base(const Base &) -> void # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Base &) = InitializeParameter[p#0] : r0_3 -# 745| r0_5(glval) = FieldAddress[base_s] : r0_2 -# 745| r0_6(glval) = FunctionAddress[String] : -# 745| v0_7(void) = Call : r0_6, this:r0_5 -# 745| v0_8(void) = NoOp : -# 745| v0_9(void) = ReturnVoid : -# 745| v0_10(void) = UnmodeledUse : mu* -# 745| v0_11(void) = ExitFunction : +# 745| m0_1(unknown) = AliasedDefinition : +# 745| mu0_2(unknown) = UnmodeledDefinition : +# 745| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_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 : r0_7, this:r0_6 +# 745| m0_9(unknown) = ^CallSideEffect : m0_1 +# 745| m0_10(unknown) = Chi : m0_1, m0_9 +# 745| v0_11(void) = NoOp : +# 745| v0_12(void) = ReturnVoid : +# 745| v0_13(void) = UnmodeledUse : mu* +# 745| v0_14(void) = ExitFunction : # 745| Base::operator=(const Base &) -> Base & # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Base &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Base *) = CopyValue : r0_2 -#-----| r0_6(glval) = FieldAddress[base_s] : r0_5 -# 745| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Base &) = Load : r0_8, m0_4 -#-----| r0_10(glval) = FieldAddress[base_s] : r0_9 -# 745| r0_11(String &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(glval) = VariableAddress[#return] : -#-----| r0_13(Base *) = CopyValue : r0_2 -#-----| m0_14(Base &) = Store : r0_12, r0_13 -# 745| r0_15(glval) = VariableAddress[#return] : -# 745| v0_16(void) = ReturnValue : r0_15, m0_14 -# 745| v0_17(void) = UnmodeledUse : mu* -# 745| v0_18(void) = ExitFunction : +# 745| m0_1(unknown) = AliasedDefinition : +# 745| mu0_2(unknown) = UnmodeledDefinition : +# 745| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Base &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Base *) = CopyValue : r0_3 +#-----| r0_7(glval) = FieldAddress[base_s] : r0_6 +# 745| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Base &) = Load : r0_9, m0_5 +#-----| r0_11(glval) = FieldAddress[base_s] : r0_10 +# 745| r0_12(String &) = Call : r0_8, this:r0_7, r0_11 +# 745| m0_13(unknown) = ^CallSideEffect : m0_1 +# 745| m0_14(unknown) = Chi : m0_1, m0_13 +#-----| r0_15(glval) = VariableAddress[#return] : +#-----| r0_16(Base *) = CopyValue : r0_3 +#-----| m0_17(Base &) = Store : r0_15, r0_16 +# 745| r0_18(glval) = VariableAddress[#return] : +# 745| v0_19(void) = ReturnValue : r0_18, m0_17 +# 745| v0_20(void) = UnmodeledUse : mu* +# 745| v0_21(void) = ExitFunction : # 748| Base::Base() -> void # 748| Block 0 # 748| v0_0(void) = EnterFunction : -# 748| mu0_1(unknown) = UnmodeledDefinition : -# 748| r0_2(glval) = InitializeThis : -# 748| r0_3(glval) = FieldAddress[base_s] : r0_2 -# 748| r0_4(glval) = FunctionAddress[String] : -# 748| v0_5(void) = Call : r0_4, this:r0_3 -# 749| v0_6(void) = NoOp : -# 748| v0_7(void) = ReturnVoid : -# 748| v0_8(void) = UnmodeledUse : mu* -# 748| v0_9(void) = ExitFunction : +# 748| m0_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 : r0_5, this:r0_4 +# 748| m0_7(unknown) = ^CallSideEffect : m0_1 +# 748| m0_8(unknown) = Chi : m0_1, m0_7 +# 749| v0_9(void) = NoOp : +# 748| v0_10(void) = ReturnVoid : +# 748| v0_11(void) = UnmodeledUse : mu* +# 748| v0_12(void) = ExitFunction : # 750| Base::~Base() -> void # 750| Block 0 # 750| v0_0(void) = EnterFunction : -# 750| mu0_1(unknown) = UnmodeledDefinition : -# 750| r0_2(glval) = InitializeThis : -# 751| v0_3(void) = NoOp : -# 751| r0_4(glval) = FieldAddress[base_s] : r0_2 -# 751| r0_5(glval) = FunctionAddress[~String] : -# 751| v0_6(void) = Call : r0_5, this:r0_4 -# 750| v0_7(void) = ReturnVoid : -# 750| v0_8(void) = UnmodeledUse : mu* -# 750| v0_9(void) = ExitFunction : +# 750| m0_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 : r0_6, this:r0_5 +# 751| m0_8(unknown) = ^CallSideEffect : m0_1 +# 751| m0_9(unknown) = Chi : m0_1, m0_8 +# 750| v0_10(void) = ReturnVoid : +# 750| v0_11(void) = UnmodeledUse : mu* +# 750| v0_12(void) = ExitFunction : # 754| Middle::operator=(const Middle &) -> Middle & # 754| Block 0 # 754| v0_0(void) = EnterFunction : -# 754| mu0_1(unknown) = UnmodeledDefinition : -# 754| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Middle &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Middle *) = CopyValue : r0_2 -#-----| r0_6(Base *) = ConvertToBase[Middle : Base] : r0_5 -# 754| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Middle &) = Load : r0_8, m0_4 -#-----| r0_10(Base *) = ConvertToBase[Middle : Base] : r0_9 -# 754| r0_11(Base &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Middle *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[middle_s] : r0_12 -# 754| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Middle &) = Load : r0_15, m0_4 -#-----| r0_17(glval) = FieldAddress[middle_s] : r0_16 -# 754| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Middle *) = CopyValue : r0_2 -#-----| m0_21(Middle &) = Store : r0_19, r0_20 -# 754| r0_22(glval) = VariableAddress[#return] : -# 754| v0_23(void) = ReturnValue : r0_22, m0_21 -# 754| v0_24(void) = UnmodeledUse : mu* -# 754| v0_25(void) = ExitFunction : +# 754| m0_1(unknown) = AliasedDefinition : +# 754| mu0_2(unknown) = UnmodeledDefinition : +# 754| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Middle &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Middle *) = CopyValue : r0_3 +#-----| r0_7(Base *) = ConvertToBase[Middle : Base] : r0_6 +# 754| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Middle &) = Load : r0_9, m0_5 +#-----| r0_11(Base *) = ConvertToBase[Middle : Base] : r0_10 +# 754| r0_12(Base &) = Call : r0_8, this:r0_7, r0_11 +# 754| m0_13(unknown) = ^CallSideEffect : m0_1 +# 754| m0_14(unknown) = Chi : m0_1, m0_13 +#-----| r0_15(Middle *) = CopyValue : r0_3 +#-----| r0_16(glval) = FieldAddress[middle_s] : r0_15 +# 754| r0_17(glval) = FunctionAddress[operator=] : +#-----| r0_18(glval) = VariableAddress[p#0] : +#-----| r0_19(Middle &) = Load : r0_18, m0_5 +#-----| r0_20(glval) = FieldAddress[middle_s] : r0_19 +# 754| r0_21(String &) = Call : r0_17, this:r0_16, r0_20 +# 754| m0_22(unknown) = ^CallSideEffect : m0_14 +# 754| m0_23(unknown) = Chi : m0_14, m0_22 +#-----| r0_24(glval) = VariableAddress[#return] : +#-----| r0_25(Middle *) = CopyValue : r0_3 +#-----| m0_26(Middle &) = Store : r0_24, r0_25 +# 754| r0_27(glval) = VariableAddress[#return] : +# 754| v0_28(void) = ReturnValue : r0_27, m0_26 +# 754| v0_29(void) = UnmodeledUse : mu* +# 754| v0_30(void) = ExitFunction : # 757| Middle::Middle() -> void # 757| Block 0 -# 757| v0_0(void) = EnterFunction : -# 757| mu0_1(unknown) = UnmodeledDefinition : -# 757| r0_2(glval) = InitializeThis : -# 757| r0_3(glval) = ConvertToBase[Middle : Base] : r0_2 -# 757| r0_4(glval) = FunctionAddress[Base] : -# 757| v0_5(void) = Call : r0_4, this:r0_3 -# 757| r0_6(glval) = FieldAddress[middle_s] : r0_2 -# 757| r0_7(glval) = FunctionAddress[String] : -# 757| v0_8(void) = Call : r0_7, this:r0_6 -# 758| v0_9(void) = NoOp : -# 757| v0_10(void) = ReturnVoid : -# 757| v0_11(void) = UnmodeledUse : mu* -# 757| v0_12(void) = ExitFunction : +# 757| v0_0(void) = EnterFunction : +# 757| m0_1(unknown) = AliasedDefinition : +# 757| mu0_2(unknown) = UnmodeledDefinition : +# 757| r0_3(glval) = InitializeThis : +# 757| r0_4(glval) = ConvertToBase[Middle : Base] : r0_3 +# 757| r0_5(glval) = FunctionAddress[Base] : +# 757| v0_6(void) = Call : r0_5, this:r0_4 +# 757| m0_7(unknown) = ^CallSideEffect : m0_1 +# 757| m0_8(unknown) = Chi : m0_1, m0_7 +# 757| r0_9(glval) = FieldAddress[middle_s] : r0_3 +# 757| r0_10(glval) = FunctionAddress[String] : +# 757| v0_11(void) = Call : r0_10, this:r0_9 +# 757| m0_12(unknown) = ^CallSideEffect : m0_8 +# 757| m0_13(unknown) = Chi : m0_8, m0_12 +# 758| v0_14(void) = NoOp : +# 757| v0_15(void) = ReturnVoid : +# 757| v0_16(void) = UnmodeledUse : mu* +# 757| v0_17(void) = ExitFunction : # 759| Middle::~Middle() -> void # 759| Block 0 -# 759| v0_0(void) = EnterFunction : -# 759| mu0_1(unknown) = UnmodeledDefinition : -# 759| r0_2(glval) = InitializeThis : -# 760| v0_3(void) = NoOp : -# 760| r0_4(glval) = FieldAddress[middle_s] : r0_2 -# 760| r0_5(glval) = FunctionAddress[~String] : -# 760| v0_6(void) = Call : r0_5, this:r0_4 -# 760| r0_7(glval) = ConvertToBase[Middle : Base] : r0_2 -# 760| r0_8(glval) = FunctionAddress[~Base] : -# 760| v0_9(void) = Call : r0_8, this:r0_7 -# 759| v0_10(void) = ReturnVoid : -# 759| v0_11(void) = UnmodeledUse : mu* -# 759| v0_12(void) = ExitFunction : +# 759| v0_0(void) = EnterFunction : +# 759| m0_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 : r0_6, this:r0_5 +# 760| m0_8(unknown) = ^CallSideEffect : m0_1 +# 760| m0_9(unknown) = Chi : m0_1, m0_8 +# 760| r0_10(glval) = ConvertToBase[Middle : Base] : r0_3 +# 760| r0_11(glval) = FunctionAddress[~Base] : +# 760| v0_12(void) = Call : r0_11, this:r0_10 +# 760| m0_13(unknown) = ^CallSideEffect : m0_9 +# 760| m0_14(unknown) = Chi : m0_9, m0_13 +# 759| v0_15(void) = ReturnVoid : +# 759| v0_16(void) = UnmodeledUse : mu* +# 759| v0_17(void) = ExitFunction : # 763| Derived::operator=(const Derived &) -> Derived & # 763| Block 0 # 763| v0_0(void) = EnterFunction : -# 763| mu0_1(unknown) = UnmodeledDefinition : -# 763| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Derived &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Derived *) = CopyValue : r0_2 -#-----| r0_6(Middle *) = ConvertToBase[Derived : Middle] : r0_5 -# 763| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Derived &) = Load : r0_8, m0_4 -#-----| r0_10(Middle *) = ConvertToBase[Derived : Middle] : r0_9 -# 763| r0_11(Middle &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Derived *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[derived_s] : r0_12 -# 763| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Derived &) = Load : r0_15, m0_4 -#-----| r0_17(glval) = FieldAddress[derived_s] : r0_16 -# 763| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Derived *) = CopyValue : r0_2 -#-----| m0_21(Derived &) = Store : r0_19, r0_20 -# 763| r0_22(glval) = VariableAddress[#return] : -# 763| v0_23(void) = ReturnValue : r0_22, m0_21 -# 763| v0_24(void) = UnmodeledUse : mu* -# 763| v0_25(void) = ExitFunction : +# 763| m0_1(unknown) = AliasedDefinition : +# 763| mu0_2(unknown) = UnmodeledDefinition : +# 763| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Derived &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Derived *) = CopyValue : r0_3 +#-----| r0_7(Middle *) = ConvertToBase[Derived : Middle] : r0_6 +# 763| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Derived &) = Load : r0_9, m0_5 +#-----| r0_11(Middle *) = ConvertToBase[Derived : Middle] : r0_10 +# 763| r0_12(Middle &) = Call : r0_8, this:r0_7, r0_11 +# 763| m0_13(unknown) = ^CallSideEffect : m0_1 +# 763| m0_14(unknown) = Chi : m0_1, m0_13 +#-----| r0_15(Derived *) = CopyValue : r0_3 +#-----| r0_16(glval) = FieldAddress[derived_s] : r0_15 +# 763| r0_17(glval) = FunctionAddress[operator=] : +#-----| r0_18(glval) = VariableAddress[p#0] : +#-----| r0_19(Derived &) = Load : r0_18, m0_5 +#-----| r0_20(glval) = FieldAddress[derived_s] : r0_19 +# 763| r0_21(String &) = Call : r0_17, this:r0_16, r0_20 +# 763| m0_22(unknown) = ^CallSideEffect : m0_14 +# 763| m0_23(unknown) = Chi : m0_14, m0_22 +#-----| r0_24(glval) = VariableAddress[#return] : +#-----| r0_25(Derived *) = CopyValue : r0_3 +#-----| m0_26(Derived &) = Store : r0_24, r0_25 +# 763| r0_27(glval) = VariableAddress[#return] : +# 763| v0_28(void) = ReturnValue : r0_27, m0_26 +# 763| v0_29(void) = UnmodeledUse : mu* +# 763| v0_30(void) = ExitFunction : # 766| Derived::Derived() -> void # 766| Block 0 -# 766| v0_0(void) = EnterFunction : -# 766| mu0_1(unknown) = UnmodeledDefinition : -# 766| r0_2(glval) = InitializeThis : -# 766| r0_3(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 766| r0_4(glval) = FunctionAddress[Middle] : -# 766| v0_5(void) = Call : r0_4, this:r0_3 -# 766| r0_6(glval) = FieldAddress[derived_s] : r0_2 -# 766| r0_7(glval) = FunctionAddress[String] : -# 766| v0_8(void) = Call : r0_7, this:r0_6 -# 767| v0_9(void) = NoOp : -# 766| v0_10(void) = ReturnVoid : -# 766| v0_11(void) = UnmodeledUse : mu* -# 766| v0_12(void) = ExitFunction : +# 766| v0_0(void) = EnterFunction : +# 766| m0_1(unknown) = AliasedDefinition : +# 766| mu0_2(unknown) = UnmodeledDefinition : +# 766| r0_3(glval) = InitializeThis : +# 766| r0_4(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 766| r0_5(glval) = FunctionAddress[Middle] : +# 766| v0_6(void) = Call : r0_5, this:r0_4 +# 766| m0_7(unknown) = ^CallSideEffect : m0_1 +# 766| m0_8(unknown) = Chi : m0_1, m0_7 +# 766| r0_9(glval) = FieldAddress[derived_s] : r0_3 +# 766| r0_10(glval) = FunctionAddress[String] : +# 766| v0_11(void) = Call : r0_10, this:r0_9 +# 766| m0_12(unknown) = ^CallSideEffect : m0_8 +# 766| m0_13(unknown) = Chi : m0_8, m0_12 +# 767| v0_14(void) = NoOp : +# 766| v0_15(void) = ReturnVoid : +# 766| v0_16(void) = UnmodeledUse : mu* +# 766| v0_17(void) = ExitFunction : # 768| Derived::~Derived() -> void # 768| Block 0 -# 768| v0_0(void) = EnterFunction : -# 768| mu0_1(unknown) = UnmodeledDefinition : -# 768| r0_2(glval) = InitializeThis : -# 769| v0_3(void) = NoOp : -# 769| r0_4(glval) = FieldAddress[derived_s] : r0_2 -# 769| r0_5(glval) = FunctionAddress[~String] : -# 769| v0_6(void) = Call : r0_5, this:r0_4 -# 769| r0_7(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 769| r0_8(glval) = FunctionAddress[~Middle] : -# 769| v0_9(void) = Call : r0_8, this:r0_7 -# 768| v0_10(void) = ReturnVoid : -# 768| v0_11(void) = UnmodeledUse : mu* -# 768| v0_12(void) = ExitFunction : +# 768| v0_0(void) = EnterFunction : +# 768| m0_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 : r0_6, this:r0_5 +# 769| m0_8(unknown) = ^CallSideEffect : m0_1 +# 769| m0_9(unknown) = Chi : m0_1, m0_8 +# 769| r0_10(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 769| r0_11(glval) = FunctionAddress[~Middle] : +# 769| v0_12(void) = Call : r0_11, this:r0_10 +# 769| m0_13(unknown) = ^CallSideEffect : m0_9 +# 769| m0_14(unknown) = Chi : m0_9, m0_13 +# 768| v0_15(void) = ReturnVoid : +# 768| v0_16(void) = UnmodeledUse : mu* +# 768| v0_17(void) = ExitFunction : # 775| MiddleVB1::MiddleVB1() -> void # 775| Block 0 # 775| v0_0(void) = EnterFunction : -# 775| mu0_1(unknown) = UnmodeledDefinition : -# 775| r0_2(glval) = InitializeThis : -# 775| r0_3(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 775| r0_4(glval) = FunctionAddress[Base] : -# 775| v0_5(void) = Call : r0_4, this:r0_3 -# 775| r0_6(glval) = FieldAddress[middlevb1_s] : r0_2 -# 775| r0_7(glval) = FunctionAddress[String] : -# 775| v0_8(void) = Call : r0_7, this:r0_6 -# 776| v0_9(void) = NoOp : -# 775| v0_10(void) = ReturnVoid : -# 775| v0_11(void) = UnmodeledUse : mu* -# 775| v0_12(void) = ExitFunction : +# 775| m0_1(unknown) = AliasedDefinition : +# 775| mu0_2(unknown) = UnmodeledDefinition : +# 775| r0_3(glval) = InitializeThis : +# 775| r0_4(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 775| r0_5(glval) = FunctionAddress[Base] : +# 775| v0_6(void) = Call : r0_5, this:r0_4 +# 775| m0_7(unknown) = ^CallSideEffect : m0_1 +# 775| m0_8(unknown) = Chi : m0_1, m0_7 +# 775| r0_9(glval) = FieldAddress[middlevb1_s] : r0_3 +# 775| r0_10(glval) = FunctionAddress[String] : +# 775| v0_11(void) = Call : r0_10, this:r0_9 +# 775| m0_12(unknown) = ^CallSideEffect : m0_8 +# 775| m0_13(unknown) = Chi : m0_8, m0_12 +# 776| v0_14(void) = NoOp : +# 775| v0_15(void) = ReturnVoid : +# 775| v0_16(void) = UnmodeledUse : mu* +# 775| v0_17(void) = ExitFunction : # 777| MiddleVB1::~MiddleVB1() -> void # 777| Block 0 # 777| v0_0(void) = EnterFunction : -# 777| mu0_1(unknown) = UnmodeledDefinition : -# 777| r0_2(glval) = InitializeThis : -# 778| v0_3(void) = NoOp : -# 778| r0_4(glval) = FieldAddress[middlevb1_s] : r0_2 -# 778| r0_5(glval) = FunctionAddress[~String] : -# 778| v0_6(void) = Call : r0_5, this:r0_4 -# 778| r0_7(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 778| r0_8(glval) = FunctionAddress[~Base] : -# 778| v0_9(void) = Call : r0_8, this:r0_7 -# 777| v0_10(void) = ReturnVoid : -# 777| v0_11(void) = UnmodeledUse : mu* -# 777| v0_12(void) = ExitFunction : +# 777| m0_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 : r0_6, this:r0_5 +# 778| m0_8(unknown) = ^CallSideEffect : m0_1 +# 778| m0_9(unknown) = Chi : m0_1, m0_8 +# 778| r0_10(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 778| r0_11(glval) = FunctionAddress[~Base] : +# 778| v0_12(void) = Call : r0_11, this:r0_10 +# 778| m0_13(unknown) = ^CallSideEffect : m0_9 +# 778| m0_14(unknown) = Chi : m0_9, m0_13 +# 777| v0_15(void) = ReturnVoid : +# 777| v0_16(void) = UnmodeledUse : mu* +# 777| v0_17(void) = ExitFunction : # 784| MiddleVB2::MiddleVB2() -> void # 784| Block 0 # 784| v0_0(void) = EnterFunction : -# 784| mu0_1(unknown) = UnmodeledDefinition : -# 784| r0_2(glval) = InitializeThis : -# 784| r0_3(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 784| r0_4(glval) = FunctionAddress[Base] : -# 784| v0_5(void) = Call : r0_4, this:r0_3 -# 784| r0_6(glval) = FieldAddress[middlevb2_s] : r0_2 -# 784| r0_7(glval) = FunctionAddress[String] : -# 784| v0_8(void) = Call : r0_7, this:r0_6 -# 785| v0_9(void) = NoOp : -# 784| v0_10(void) = ReturnVoid : -# 784| v0_11(void) = UnmodeledUse : mu* -# 784| v0_12(void) = ExitFunction : +# 784| m0_1(unknown) = AliasedDefinition : +# 784| mu0_2(unknown) = UnmodeledDefinition : +# 784| r0_3(glval) = InitializeThis : +# 784| r0_4(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 784| r0_5(glval) = FunctionAddress[Base] : +# 784| v0_6(void) = Call : r0_5, this:r0_4 +# 784| m0_7(unknown) = ^CallSideEffect : m0_1 +# 784| m0_8(unknown) = Chi : m0_1, m0_7 +# 784| r0_9(glval) = FieldAddress[middlevb2_s] : r0_3 +# 784| r0_10(glval) = FunctionAddress[String] : +# 784| v0_11(void) = Call : r0_10, this:r0_9 +# 784| m0_12(unknown) = ^CallSideEffect : m0_8 +# 784| m0_13(unknown) = Chi : m0_8, m0_12 +# 785| v0_14(void) = NoOp : +# 784| v0_15(void) = ReturnVoid : +# 784| v0_16(void) = UnmodeledUse : mu* +# 784| v0_17(void) = ExitFunction : # 786| MiddleVB2::~MiddleVB2() -> void # 786| Block 0 # 786| v0_0(void) = EnterFunction : -# 786| mu0_1(unknown) = UnmodeledDefinition : -# 786| r0_2(glval) = InitializeThis : -# 787| v0_3(void) = NoOp : -# 787| r0_4(glval) = FieldAddress[middlevb2_s] : r0_2 -# 787| r0_5(glval) = FunctionAddress[~String] : -# 787| v0_6(void) = Call : r0_5, this:r0_4 -# 787| r0_7(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 787| r0_8(glval) = FunctionAddress[~Base] : -# 787| v0_9(void) = Call : r0_8, this:r0_7 -# 786| v0_10(void) = ReturnVoid : -# 786| v0_11(void) = UnmodeledUse : mu* -# 786| v0_12(void) = ExitFunction : +# 786| m0_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 : r0_6, this:r0_5 +# 787| m0_8(unknown) = ^CallSideEffect : m0_1 +# 787| m0_9(unknown) = Chi : m0_1, m0_8 +# 787| r0_10(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 787| r0_11(glval) = FunctionAddress[~Base] : +# 787| v0_12(void) = Call : r0_11, this:r0_10 +# 787| m0_13(unknown) = ^CallSideEffect : m0_9 +# 787| m0_14(unknown) = Chi : m0_9, m0_13 +# 786| v0_15(void) = ReturnVoid : +# 786| v0_16(void) = UnmodeledUse : mu* +# 786| v0_17(void) = ExitFunction : # 793| DerivedVB::DerivedVB() -> void # 793| Block 0 -# 793| v0_0(void) = EnterFunction : -# 793| mu0_1(unknown) = UnmodeledDefinition : -# 793| r0_2(glval) = InitializeThis : -# 793| r0_3(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 793| r0_4(glval) = FunctionAddress[Base] : -# 793| v0_5(void) = Call : r0_4, this:r0_3 -# 793| r0_6(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 793| r0_7(glval) = FunctionAddress[MiddleVB1] : -# 793| v0_8(void) = Call : r0_7, this:r0_6 -# 793| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 793| r0_10(glval) = FunctionAddress[MiddleVB2] : -# 793| v0_11(void) = Call : r0_10, this:r0_9 -# 793| r0_12(glval) = FieldAddress[derivedvb_s] : r0_2 -# 793| r0_13(glval) = FunctionAddress[String] : -# 793| v0_14(void) = Call : r0_13, this:r0_12 -# 794| v0_15(void) = NoOp : -# 793| v0_16(void) = ReturnVoid : -# 793| v0_17(void) = UnmodeledUse : mu* -# 793| v0_18(void) = ExitFunction : +# 793| v0_0(void) = EnterFunction : +# 793| m0_1(unknown) = AliasedDefinition : +# 793| mu0_2(unknown) = UnmodeledDefinition : +# 793| r0_3(glval) = InitializeThis : +# 793| r0_4(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 793| r0_5(glval) = FunctionAddress[Base] : +# 793| v0_6(void) = Call : r0_5, this:r0_4 +# 793| m0_7(unknown) = ^CallSideEffect : m0_1 +# 793| m0_8(unknown) = Chi : m0_1, m0_7 +# 793| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 793| r0_10(glval) = FunctionAddress[MiddleVB1] : +# 793| v0_11(void) = Call : r0_10, this:r0_9 +# 793| m0_12(unknown) = ^CallSideEffect : m0_8 +# 793| m0_13(unknown) = Chi : m0_8, m0_12 +# 793| r0_14(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 793| r0_15(glval) = FunctionAddress[MiddleVB2] : +# 793| v0_16(void) = Call : r0_15, this:r0_14 +# 793| m0_17(unknown) = ^CallSideEffect : m0_13 +# 793| m0_18(unknown) = Chi : m0_13, m0_17 +# 793| r0_19(glval) = FieldAddress[derivedvb_s] : r0_3 +# 793| r0_20(glval) = FunctionAddress[String] : +# 793| v0_21(void) = Call : r0_20, this:r0_19 +# 793| m0_22(unknown) = ^CallSideEffect : m0_18 +# 793| m0_23(unknown) = Chi : m0_18, m0_22 +# 794| v0_24(void) = NoOp : +# 793| v0_25(void) = ReturnVoid : +# 793| v0_26(void) = UnmodeledUse : mu* +# 793| v0_27(void) = ExitFunction : # 795| DerivedVB::~DerivedVB() -> void # 795| Block 0 # 795| v0_0(void) = EnterFunction : -# 795| mu0_1(unknown) = UnmodeledDefinition : -# 795| r0_2(glval) = InitializeThis : -# 796| v0_3(void) = NoOp : -# 796| r0_4(glval) = FieldAddress[derivedvb_s] : r0_2 -# 796| r0_5(glval) = FunctionAddress[~String] : -# 796| v0_6(void) = Call : r0_5, this:r0_4 -# 796| r0_7(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 796| r0_8(glval) = FunctionAddress[~MiddleVB2] : -# 796| v0_9(void) = Call : r0_8, this:r0_7 -# 796| r0_10(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 796| r0_11(glval) = FunctionAddress[~MiddleVB1] : +# 795| m0_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 : r0_6, this:r0_5 +# 796| m0_8(unknown) = ^CallSideEffect : m0_1 +# 796| m0_9(unknown) = Chi : m0_1, m0_8 +# 796| r0_10(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 796| r0_11(glval) = FunctionAddress[~MiddleVB2] : # 796| v0_12(void) = Call : r0_11, this:r0_10 -# 796| r0_13(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 796| r0_14(glval) = FunctionAddress[~Base] : -# 796| v0_15(void) = Call : r0_14, this:r0_13 -# 795| v0_16(void) = ReturnVoid : -# 795| v0_17(void) = UnmodeledUse : mu* -# 795| v0_18(void) = ExitFunction : +# 796| m0_13(unknown) = ^CallSideEffect : m0_9 +# 796| m0_14(unknown) = Chi : m0_9, m0_13 +# 796| r0_15(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 796| r0_16(glval) = FunctionAddress[~MiddleVB1] : +# 796| v0_17(void) = Call : r0_16, this:r0_15 +# 796| m0_18(unknown) = ^CallSideEffect : m0_14 +# 796| m0_19(unknown) = Chi : m0_14, m0_18 +# 796| r0_20(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 796| r0_21(glval) = FunctionAddress[~Base] : +# 796| v0_22(void) = Call : r0_21, this:r0_20 +# 796| m0_23(unknown) = ^CallSideEffect : m0_19 +# 796| m0_24(unknown) = Chi : m0_19, m0_23 +# 795| v0_25(void) = ReturnVoid : +# 795| v0_26(void) = UnmodeledUse : mu* +# 795| v0_27(void) = ExitFunction : # 799| HierarchyConversions() -> void # 799| Block 0 # 799| v0_0(void) = EnterFunction : -# 799| mu0_1(unknown) = UnmodeledDefinition : -# 800| r0_2(glval) = VariableAddress[b] : -# 800| r0_3(glval) = FunctionAddress[Base] : -# 800| v0_4(void) = Call : r0_3, this:r0_2 -# 801| r0_5(glval) = VariableAddress[m] : -# 801| r0_6(glval) = FunctionAddress[Middle] : -# 801| v0_7(void) = Call : r0_6, this:r0_5 -# 802| r0_8(glval) = VariableAddress[d] : -# 802| r0_9(glval) = FunctionAddress[Derived] : -# 802| v0_10(void) = Call : r0_9, this:r0_8 -# 804| r0_11(glval) = VariableAddress[pb] : -# 804| r0_12(glval) = VariableAddress[b] : -# 804| m0_13(Base *) = Store : r0_11, r0_12 -# 805| r0_14(glval) = VariableAddress[pm] : -# 805| r0_15(glval) = VariableAddress[m] : -# 805| m0_16(Middle *) = Store : r0_14, r0_15 -# 806| r0_17(glval) = VariableAddress[pd] : -# 806| r0_18(glval) = VariableAddress[d] : -# 806| m0_19(Derived *) = Store : r0_17, r0_18 -# 808| r0_20(glval) = VariableAddress[b] : -# 808| r0_21(glval) = FunctionAddress[operator=] : -# 808| r0_22(glval) = VariableAddress[m] : -# 808| r0_23(glval) = ConvertToBase[Middle : Base] : r0_22 -# 808| r0_24(Base &) = Call : r0_21, this:r0_20, r0_23 -# 809| r0_25(glval) = VariableAddress[b] : -# 809| r0_26(glval) = FunctionAddress[operator=] : -# 809| r0_27(glval) = FunctionAddress[Base] : -# 809| r0_28(glval) = VariableAddress[m] : -# 809| r0_29(glval) = ConvertToBase[Middle : Base] : r0_28 -# 809| v0_30(void) = Call : r0_27, r0_29 -# 809| r0_31(Base) = Convert : v0_30 -# 809| r0_32(Base &) = Call : r0_26, this:r0_25, r0_31 -# 810| r0_33(glval) = VariableAddress[b] : -# 810| r0_34(glval) = FunctionAddress[operator=] : -# 810| r0_35(glval) = FunctionAddress[Base] : -# 810| r0_36(glval) = VariableAddress[m] : -# 810| r0_37(glval) = ConvertToBase[Middle : Base] : r0_36 -# 810| v0_38(void) = Call : r0_35, r0_37 -# 810| r0_39(Base) = Convert : v0_38 -# 810| r0_40(Base &) = Call : r0_34, this:r0_33, r0_39 -# 811| r0_41(glval) = VariableAddress[pm] : -# 811| r0_42(Middle *) = Load : r0_41, m0_16 -# 811| r0_43(Base *) = ConvertToBase[Middle : Base] : r0_42 -# 811| r0_44(glval) = VariableAddress[pb] : -# 811| m0_45(Base *) = Store : r0_44, r0_43 -# 812| r0_46(glval) = VariableAddress[pm] : -# 812| r0_47(Middle *) = Load : r0_46, m0_16 -# 812| r0_48(Base *) = ConvertToBase[Middle : Base] : r0_47 -# 812| r0_49(glval) = VariableAddress[pb] : -# 812| m0_50(Base *) = Store : r0_49, r0_48 -# 813| r0_51(glval) = VariableAddress[pm] : -# 813| r0_52(Middle *) = Load : r0_51, m0_16 -# 813| r0_53(Base *) = ConvertToBase[Middle : Base] : r0_52 -# 813| r0_54(glval) = VariableAddress[pb] : -# 813| m0_55(Base *) = Store : r0_54, r0_53 -# 814| r0_56(glval) = VariableAddress[pm] : -# 814| r0_57(Middle *) = Load : r0_56, m0_16 -# 814| r0_58(Base *) = Convert : r0_57 -# 814| r0_59(glval) = VariableAddress[pb] : -# 814| m0_60(Base *) = Store : r0_59, r0_58 -# 816| r0_61(glval) = VariableAddress[m] : -# 816| r0_62(glval) = FunctionAddress[operator=] : -# 816| r0_63(glval) = VariableAddress[b] : -# 816| r0_64(glval) = ConvertToDerived[Middle : Base] : r0_63 -# 816| r0_65(glval) = Convert : r0_64 -# 816| r0_66(Middle &) = Call : r0_62, this:r0_61, r0_65 -# 817| r0_67(glval) = VariableAddress[m] : -# 817| r0_68(glval) = FunctionAddress[operator=] : -# 817| r0_69(glval) = VariableAddress[b] : -# 817| r0_70(glval) = ConvertToDerived[Middle : Base] : r0_69 -# 817| r0_71(glval) = Convert : r0_70 -# 817| r0_72(Middle &) = Call : r0_68, this:r0_67, r0_71 -# 818| r0_73(glval) = VariableAddress[pb] : -# 818| r0_74(Base *) = Load : r0_73, m0_60 -# 818| r0_75(Middle *) = ConvertToDerived[Middle : Base] : r0_74 -# 818| r0_76(glval) = VariableAddress[pm] : -# 818| m0_77(Middle *) = Store : r0_76, r0_75 -# 819| r0_78(glval) = VariableAddress[pb] : -# 819| r0_79(Base *) = Load : r0_78, m0_60 -# 819| r0_80(Middle *) = ConvertToDerived[Middle : Base] : r0_79 -# 819| r0_81(glval) = VariableAddress[pm] : -# 819| m0_82(Middle *) = Store : r0_81, r0_80 -# 820| r0_83(glval) = VariableAddress[pb] : -# 820| r0_84(Base *) = Load : r0_83, m0_60 -# 820| r0_85(Middle *) = Convert : r0_84 -# 820| r0_86(glval) = VariableAddress[pm] : -# 820| m0_87(Middle *) = Store : r0_86, r0_85 -# 822| r0_88(glval) = VariableAddress[b] : -# 822| r0_89(glval) = FunctionAddress[operator=] : -# 822| r0_90(glval) = VariableAddress[d] : -# 822| r0_91(glval) = ConvertToBase[Derived : Middle] : r0_90 -# 822| r0_92(glval) = ConvertToBase[Middle : Base] : r0_91 -# 822| r0_93(Base &) = Call : r0_89, this:r0_88, r0_92 -# 823| r0_94(glval) = VariableAddress[b] : -# 823| r0_95(glval) = FunctionAddress[operator=] : -# 823| r0_96(glval) = FunctionAddress[Base] : -# 823| r0_97(glval) = VariableAddress[d] : -# 823| r0_98(glval) = ConvertToBase[Derived : Middle] : r0_97 -# 823| r0_99(glval) = ConvertToBase[Middle : Base] : r0_98 -# 823| v0_100(void) = Call : r0_96, r0_99 -# 823| r0_101(Base) = Convert : v0_100 -# 823| r0_102(Base &) = Call : r0_95, this:r0_94, r0_101 -# 824| r0_103(glval) = VariableAddress[b] : -# 824| r0_104(glval) = FunctionAddress[operator=] : -# 824| r0_105(glval) = FunctionAddress[Base] : -# 824| r0_106(glval) = VariableAddress[d] : -# 824| r0_107(glval) = ConvertToBase[Derived : Middle] : r0_106 -# 824| r0_108(glval) = ConvertToBase[Middle : Base] : r0_107 -# 824| v0_109(void) = Call : r0_105, r0_108 -# 824| r0_110(Base) = Convert : v0_109 -# 824| r0_111(Base &) = Call : r0_104, this:r0_103, r0_110 -# 825| r0_112(glval) = VariableAddress[pd] : -# 825| r0_113(Derived *) = Load : r0_112, m0_19 -# 825| r0_114(Middle *) = ConvertToBase[Derived : Middle] : r0_113 -# 825| r0_115(Base *) = ConvertToBase[Middle : Base] : r0_114 -# 825| r0_116(glval) = VariableAddress[pb] : -# 825| m0_117(Base *) = Store : r0_116, r0_115 -# 826| r0_118(glval) = VariableAddress[pd] : -# 826| r0_119(Derived *) = Load : r0_118, m0_19 -# 826| r0_120(Middle *) = ConvertToBase[Derived : Middle] : r0_119 -# 826| r0_121(Base *) = ConvertToBase[Middle : Base] : r0_120 -# 826| r0_122(glval) = VariableAddress[pb] : -# 826| m0_123(Base *) = Store : r0_122, r0_121 -# 827| r0_124(glval) = VariableAddress[pd] : -# 827| r0_125(Derived *) = Load : r0_124, m0_19 -# 827| r0_126(Middle *) = ConvertToBase[Derived : Middle] : r0_125 -# 827| r0_127(Base *) = ConvertToBase[Middle : Base] : r0_126 -# 827| r0_128(glval) = VariableAddress[pb] : -# 827| m0_129(Base *) = Store : r0_128, r0_127 -# 828| r0_130(glval) = VariableAddress[pd] : -# 828| r0_131(Derived *) = Load : r0_130, m0_19 -# 828| r0_132(Base *) = Convert : r0_131 -# 828| r0_133(glval) = VariableAddress[pb] : -# 828| m0_134(Base *) = Store : r0_133, r0_132 -# 830| r0_135(glval) = VariableAddress[d] : -# 830| r0_136(glval) = FunctionAddress[operator=] : -# 830| r0_137(glval) = VariableAddress[b] : -# 830| r0_138(glval) = ConvertToDerived[Middle : Base] : r0_137 -# 830| r0_139(glval) = ConvertToDerived[Derived : Middle] : r0_138 -# 830| r0_140(glval) = Convert : r0_139 -# 830| r0_141(Derived &) = Call : r0_136, this:r0_135, r0_140 -# 831| r0_142(glval) = VariableAddress[d] : -# 831| r0_143(glval) = FunctionAddress[operator=] : -# 831| r0_144(glval) = VariableAddress[b] : -# 831| r0_145(glval) = ConvertToDerived[Middle : Base] : r0_144 -# 831| r0_146(glval) = ConvertToDerived[Derived : Middle] : r0_145 -# 831| r0_147(glval) = Convert : r0_146 -# 831| r0_148(Derived &) = Call : r0_143, this:r0_142, r0_147 -# 832| r0_149(glval) = VariableAddress[pb] : -# 832| r0_150(Base *) = Load : r0_149, m0_134 -# 832| r0_151(Middle *) = ConvertToDerived[Middle : Base] : r0_150 -# 832| r0_152(Derived *) = ConvertToDerived[Derived : Middle] : r0_151 -# 832| r0_153(glval) = VariableAddress[pd] : -# 832| m0_154(Derived *) = Store : r0_153, r0_152 -# 833| r0_155(glval) = VariableAddress[pb] : -# 833| r0_156(Base *) = Load : r0_155, m0_134 -# 833| r0_157(Middle *) = ConvertToDerived[Middle : Base] : r0_156 -# 833| r0_158(Derived *) = ConvertToDerived[Derived : Middle] : r0_157 -# 833| r0_159(glval) = VariableAddress[pd] : -# 833| m0_160(Derived *) = Store : r0_159, r0_158 -# 834| r0_161(glval) = VariableAddress[pb] : -# 834| r0_162(Base *) = Load : r0_161, m0_134 -# 834| r0_163(Derived *) = Convert : r0_162 -# 834| r0_164(glval) = VariableAddress[pd] : -# 834| m0_165(Derived *) = Store : r0_164, r0_163 -# 836| r0_166(glval) = VariableAddress[pmv] : -# 836| r0_167(MiddleVB1 *) = Constant[0] : -# 836| m0_168(MiddleVB1 *) = Store : r0_166, r0_167 -# 837| r0_169(glval) = VariableAddress[pdv] : -# 837| r0_170(DerivedVB *) = Constant[0] : -# 837| m0_171(DerivedVB *) = Store : r0_169, r0_170 -# 838| r0_172(glval) = VariableAddress[pmv] : -# 838| r0_173(MiddleVB1 *) = Load : r0_172, m0_168 -# 838| r0_174(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_173 -# 838| r0_175(glval) = VariableAddress[pb] : -# 838| m0_176(Base *) = Store : r0_175, r0_174 -# 839| r0_177(glval) = VariableAddress[pdv] : -# 839| r0_178(DerivedVB *) = Load : r0_177, m0_171 -# 839| r0_179(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_178 -# 839| r0_180(glval) = VariableAddress[pb] : -# 839| m0_181(Base *) = Store : r0_180, r0_179 -# 840| v0_182(void) = NoOp : -# 799| v0_183(void) = ReturnVoid : -# 799| v0_184(void) = UnmodeledUse : mu* -# 799| v0_185(void) = ExitFunction : +# 799| m0_1(unknown) = AliasedDefinition : +# 799| mu0_2(unknown) = UnmodeledDefinition : +# 800| r0_3(glval) = VariableAddress[b] : +# 800| r0_4(glval) = FunctionAddress[Base] : +# 800| v0_5(void) = Call : r0_4, this:r0_3 +# 800| m0_6(unknown) = ^CallSideEffect : m0_1 +# 800| m0_7(unknown) = Chi : m0_1, m0_6 +# 801| r0_8(glval) = VariableAddress[m] : +# 801| r0_9(glval) = FunctionAddress[Middle] : +# 801| v0_10(void) = Call : r0_9, this:r0_8 +# 801| m0_11(unknown) = ^CallSideEffect : m0_7 +# 801| m0_12(unknown) = Chi : m0_7, m0_11 +# 802| r0_13(glval) = VariableAddress[d] : +# 802| r0_14(glval) = FunctionAddress[Derived] : +# 802| v0_15(void) = Call : r0_14, this:r0_13 +# 802| m0_16(unknown) = ^CallSideEffect : m0_12 +# 802| m0_17(unknown) = Chi : m0_12, m0_16 +# 804| r0_18(glval) = VariableAddress[pb] : +# 804| r0_19(glval) = VariableAddress[b] : +# 804| m0_20(Base *) = Store : r0_18, r0_19 +# 805| r0_21(glval) = VariableAddress[pm] : +# 805| r0_22(glval) = VariableAddress[m] : +# 805| m0_23(Middle *) = Store : r0_21, r0_22 +# 806| r0_24(glval) = VariableAddress[pd] : +# 806| r0_25(glval) = VariableAddress[d] : +# 806| m0_26(Derived *) = Store : r0_24, r0_25 +# 808| r0_27(glval) = VariableAddress[b] : +# 808| r0_28(glval) = FunctionAddress[operator=] : +# 808| r0_29(glval) = VariableAddress[m] : +# 808| r0_30(glval) = ConvertToBase[Middle : Base] : r0_29 +# 808| r0_31(Base &) = Call : r0_28, this:r0_27, r0_30 +# 808| m0_32(unknown) = ^CallSideEffect : m0_17 +# 808| m0_33(unknown) = Chi : m0_17, m0_32 +# 809| r0_34(glval) = VariableAddress[b] : +# 809| r0_35(glval) = FunctionAddress[operator=] : +# 809| r0_36(glval) = FunctionAddress[Base] : +# 809| r0_37(glval) = VariableAddress[m] : +# 809| r0_38(glval) = ConvertToBase[Middle : Base] : r0_37 +# 809| v0_39(void) = Call : r0_36, r0_38 +# 809| m0_40(unknown) = ^CallSideEffect : m0_33 +# 809| m0_41(unknown) = Chi : m0_33, m0_40 +# 809| r0_42(Base) = Convert : v0_39 +# 809| r0_43(Base &) = Call : r0_35, this:r0_34, r0_42 +# 809| m0_44(unknown) = ^CallSideEffect : m0_41 +# 809| m0_45(unknown) = Chi : m0_41, m0_44 +# 810| r0_46(glval) = VariableAddress[b] : +# 810| r0_47(glval) = FunctionAddress[operator=] : +# 810| r0_48(glval) = FunctionAddress[Base] : +# 810| r0_49(glval) = VariableAddress[m] : +# 810| r0_50(glval) = ConvertToBase[Middle : Base] : r0_49 +# 810| v0_51(void) = Call : r0_48, r0_50 +# 810| m0_52(unknown) = ^CallSideEffect : m0_45 +# 810| m0_53(unknown) = Chi : m0_45, m0_52 +# 810| r0_54(Base) = Convert : v0_51 +# 810| r0_55(Base &) = Call : r0_47, this:r0_46, r0_54 +# 810| m0_56(unknown) = ^CallSideEffect : m0_53 +# 810| m0_57(unknown) = Chi : m0_53, m0_56 +# 811| r0_58(glval) = VariableAddress[pm] : +# 811| r0_59(Middle *) = Load : r0_58, m0_23 +# 811| r0_60(Base *) = ConvertToBase[Middle : Base] : r0_59 +# 811| r0_61(glval) = VariableAddress[pb] : +# 811| m0_62(Base *) = Store : r0_61, r0_60 +# 812| r0_63(glval) = VariableAddress[pm] : +# 812| r0_64(Middle *) = Load : r0_63, m0_23 +# 812| r0_65(Base *) = ConvertToBase[Middle : Base] : r0_64 +# 812| r0_66(glval) = VariableAddress[pb] : +# 812| m0_67(Base *) = Store : r0_66, r0_65 +# 813| r0_68(glval) = VariableAddress[pm] : +# 813| r0_69(Middle *) = Load : r0_68, m0_23 +# 813| r0_70(Base *) = ConvertToBase[Middle : Base] : r0_69 +# 813| r0_71(glval) = VariableAddress[pb] : +# 813| m0_72(Base *) = Store : r0_71, r0_70 +# 814| r0_73(glval) = VariableAddress[pm] : +# 814| r0_74(Middle *) = Load : r0_73, m0_23 +# 814| r0_75(Base *) = Convert : r0_74 +# 814| r0_76(glval) = VariableAddress[pb] : +# 814| m0_77(Base *) = Store : r0_76, r0_75 +# 816| r0_78(glval) = VariableAddress[m] : +# 816| r0_79(glval) = FunctionAddress[operator=] : +# 816| r0_80(glval) = VariableAddress[b] : +# 816| r0_81(glval) = ConvertToDerived[Middle : Base] : r0_80 +# 816| r0_82(glval) = Convert : r0_81 +# 816| r0_83(Middle &) = Call : r0_79, this:r0_78, r0_82 +# 816| m0_84(unknown) = ^CallSideEffect : m0_57 +# 816| m0_85(unknown) = Chi : m0_57, m0_84 +# 817| r0_86(glval) = VariableAddress[m] : +# 817| r0_87(glval) = FunctionAddress[operator=] : +# 817| r0_88(glval) = VariableAddress[b] : +# 817| r0_89(glval) = ConvertToDerived[Middle : Base] : r0_88 +# 817| r0_90(glval) = Convert : r0_89 +# 817| r0_91(Middle &) = Call : r0_87, this:r0_86, r0_90 +# 817| m0_92(unknown) = ^CallSideEffect : m0_85 +# 817| m0_93(unknown) = Chi : m0_85, m0_92 +# 818| r0_94(glval) = VariableAddress[pb] : +# 818| r0_95(Base *) = Load : r0_94, m0_77 +# 818| r0_96(Middle *) = ConvertToDerived[Middle : Base] : r0_95 +# 818| r0_97(glval) = VariableAddress[pm] : +# 818| m0_98(Middle *) = Store : r0_97, r0_96 +# 819| r0_99(glval) = VariableAddress[pb] : +# 819| r0_100(Base *) = Load : r0_99, m0_77 +# 819| r0_101(Middle *) = ConvertToDerived[Middle : Base] : r0_100 +# 819| r0_102(glval) = VariableAddress[pm] : +# 819| m0_103(Middle *) = Store : r0_102, r0_101 +# 820| r0_104(glval) = VariableAddress[pb] : +# 820| r0_105(Base *) = Load : r0_104, m0_77 +# 820| r0_106(Middle *) = Convert : r0_105 +# 820| r0_107(glval) = VariableAddress[pm] : +# 820| m0_108(Middle *) = Store : r0_107, r0_106 +# 822| r0_109(glval) = VariableAddress[b] : +# 822| r0_110(glval) = FunctionAddress[operator=] : +# 822| r0_111(glval) = VariableAddress[d] : +# 822| r0_112(glval) = ConvertToBase[Derived : Middle] : r0_111 +# 822| r0_113(glval) = ConvertToBase[Middle : Base] : r0_112 +# 822| r0_114(Base &) = Call : r0_110, this:r0_109, r0_113 +# 822| m0_115(unknown) = ^CallSideEffect : m0_93 +# 822| m0_116(unknown) = Chi : m0_93, m0_115 +# 823| r0_117(glval) = VariableAddress[b] : +# 823| r0_118(glval) = FunctionAddress[operator=] : +# 823| r0_119(glval) = FunctionAddress[Base] : +# 823| r0_120(glval) = VariableAddress[d] : +# 823| r0_121(glval) = ConvertToBase[Derived : Middle] : r0_120 +# 823| r0_122(glval) = ConvertToBase[Middle : Base] : r0_121 +# 823| v0_123(void) = Call : r0_119, r0_122 +# 823| m0_124(unknown) = ^CallSideEffect : m0_116 +# 823| m0_125(unknown) = Chi : m0_116, m0_124 +# 823| r0_126(Base) = Convert : v0_123 +# 823| r0_127(Base &) = Call : r0_118, this:r0_117, r0_126 +# 823| m0_128(unknown) = ^CallSideEffect : m0_125 +# 823| m0_129(unknown) = Chi : m0_125, m0_128 +# 824| r0_130(glval) = VariableAddress[b] : +# 824| r0_131(glval) = FunctionAddress[operator=] : +# 824| r0_132(glval) = FunctionAddress[Base] : +# 824| r0_133(glval) = VariableAddress[d] : +# 824| r0_134(glval) = ConvertToBase[Derived : Middle] : r0_133 +# 824| r0_135(glval) = ConvertToBase[Middle : Base] : r0_134 +# 824| v0_136(void) = Call : r0_132, r0_135 +# 824| m0_137(unknown) = ^CallSideEffect : m0_129 +# 824| m0_138(unknown) = Chi : m0_129, m0_137 +# 824| r0_139(Base) = Convert : v0_136 +# 824| r0_140(Base &) = Call : r0_131, this:r0_130, r0_139 +# 824| m0_141(unknown) = ^CallSideEffect : m0_138 +# 824| m0_142(unknown) = Chi : m0_138, m0_141 +# 825| r0_143(glval) = VariableAddress[pd] : +# 825| r0_144(Derived *) = Load : r0_143, m0_26 +# 825| r0_145(Middle *) = ConvertToBase[Derived : Middle] : r0_144 +# 825| r0_146(Base *) = ConvertToBase[Middle : Base] : r0_145 +# 825| r0_147(glval) = VariableAddress[pb] : +# 825| m0_148(Base *) = Store : r0_147, r0_146 +# 826| r0_149(glval) = VariableAddress[pd] : +# 826| r0_150(Derived *) = Load : r0_149, m0_26 +# 826| r0_151(Middle *) = ConvertToBase[Derived : Middle] : r0_150 +# 826| r0_152(Base *) = ConvertToBase[Middle : Base] : r0_151 +# 826| r0_153(glval) = VariableAddress[pb] : +# 826| m0_154(Base *) = Store : r0_153, r0_152 +# 827| r0_155(glval) = VariableAddress[pd] : +# 827| r0_156(Derived *) = Load : r0_155, m0_26 +# 827| r0_157(Middle *) = ConvertToBase[Derived : Middle] : r0_156 +# 827| r0_158(Base *) = ConvertToBase[Middle : Base] : r0_157 +# 827| r0_159(glval) = VariableAddress[pb] : +# 827| m0_160(Base *) = Store : r0_159, r0_158 +# 828| r0_161(glval) = VariableAddress[pd] : +# 828| r0_162(Derived *) = Load : r0_161, m0_26 +# 828| r0_163(Base *) = Convert : r0_162 +# 828| r0_164(glval) = VariableAddress[pb] : +# 828| m0_165(Base *) = Store : r0_164, r0_163 +# 830| r0_166(glval) = VariableAddress[d] : +# 830| r0_167(glval) = FunctionAddress[operator=] : +# 830| r0_168(glval) = VariableAddress[b] : +# 830| r0_169(glval) = ConvertToDerived[Middle : Base] : r0_168 +# 830| r0_170(glval) = ConvertToDerived[Derived : Middle] : r0_169 +# 830| r0_171(glval) = Convert : r0_170 +# 830| r0_172(Derived &) = Call : r0_167, this:r0_166, r0_171 +# 830| m0_173(unknown) = ^CallSideEffect : m0_142 +# 830| m0_174(unknown) = Chi : m0_142, m0_173 +# 831| r0_175(glval) = VariableAddress[d] : +# 831| r0_176(glval) = FunctionAddress[operator=] : +# 831| r0_177(glval) = VariableAddress[b] : +# 831| r0_178(glval) = ConvertToDerived[Middle : Base] : r0_177 +# 831| r0_179(glval) = ConvertToDerived[Derived : Middle] : r0_178 +# 831| r0_180(glval) = Convert : r0_179 +# 831| r0_181(Derived &) = Call : r0_176, this:r0_175, r0_180 +# 831| m0_182(unknown) = ^CallSideEffect : m0_174 +# 831| m0_183(unknown) = Chi : m0_174, m0_182 +# 832| r0_184(glval) = VariableAddress[pb] : +# 832| r0_185(Base *) = Load : r0_184, m0_165 +# 832| r0_186(Middle *) = ConvertToDerived[Middle : Base] : r0_185 +# 832| r0_187(Derived *) = ConvertToDerived[Derived : Middle] : r0_186 +# 832| r0_188(glval) = VariableAddress[pd] : +# 832| m0_189(Derived *) = Store : r0_188, r0_187 +# 833| r0_190(glval) = VariableAddress[pb] : +# 833| r0_191(Base *) = Load : r0_190, m0_165 +# 833| r0_192(Middle *) = ConvertToDerived[Middle : Base] : r0_191 +# 833| r0_193(Derived *) = ConvertToDerived[Derived : Middle] : r0_192 +# 833| r0_194(glval) = VariableAddress[pd] : +# 833| m0_195(Derived *) = Store : r0_194, r0_193 +# 834| r0_196(glval) = VariableAddress[pb] : +# 834| r0_197(Base *) = Load : r0_196, m0_165 +# 834| r0_198(Derived *) = Convert : r0_197 +# 834| r0_199(glval) = VariableAddress[pd] : +# 834| m0_200(Derived *) = Store : r0_199, r0_198 +# 836| r0_201(glval) = VariableAddress[pmv] : +# 836| r0_202(MiddleVB1 *) = Constant[0] : +# 836| m0_203(MiddleVB1 *) = Store : r0_201, r0_202 +# 837| r0_204(glval) = VariableAddress[pdv] : +# 837| r0_205(DerivedVB *) = Constant[0] : +# 837| m0_206(DerivedVB *) = Store : r0_204, r0_205 +# 838| r0_207(glval) = VariableAddress[pmv] : +# 838| r0_208(MiddleVB1 *) = Load : r0_207, m0_203 +# 838| r0_209(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_208 +# 838| r0_210(glval) = VariableAddress[pb] : +# 838| m0_211(Base *) = Store : r0_210, r0_209 +# 839| r0_212(glval) = VariableAddress[pdv] : +# 839| r0_213(DerivedVB *) = Load : r0_212, m0_206 +# 839| r0_214(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_213 +# 839| r0_215(glval) = VariableAddress[pb] : +# 839| m0_216(Base *) = Store : r0_215, r0_214 +# 840| v0_217(void) = NoOp : +# 799| v0_218(void) = ReturnVoid : +# 799| v0_219(void) = UnmodeledUse : mu* +# 799| v0_220(void) = ExitFunction : # 842| PolymorphicBase::PolymorphicBase() -> void # 842| Block 0 # 842| v0_0(void) = EnterFunction : -# 842| mu0_1(unknown) = UnmodeledDefinition : -# 842| r0_2(glval) = InitializeThis : -# 842| v0_3(void) = NoOp : -# 842| v0_4(void) = ReturnVoid : -# 842| v0_5(void) = UnmodeledUse : mu* -# 842| v0_6(void) = ExitFunction : +# 842| m0_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) = ExitFunction : # 846| PolymorphicDerived::PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -# 846| r0_3(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_4(glval) = FunctionAddress[PolymorphicBase] : -# 846| v0_5(void) = Call : r0_4, this:r0_3 -# 846| v0_6(void) = NoOp : -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| m0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_5(glval) = FunctionAddress[PolymorphicBase] : +# 846| v0_6(void) = Call : r0_5, this:r0_4 +# 846| m0_7(unknown) = ^CallSideEffect : m0_1 +# 846| m0_8(unknown) = Chi : m0_1, m0_7 +# 846| v0_9(void) = NoOp : +# 846| v0_10(void) = ReturnVoid : +# 846| v0_11(void) = UnmodeledUse : mu* +# 846| v0_12(void) = ExitFunction : # 846| PolymorphicDerived::~PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -#-----| v0_3(void) = NoOp : -# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_5(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v0_6(void) = Call : r0_5, this:r0_4 -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| m0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +#-----| v0_4(void) = NoOp : +# 846| r0_5(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_6(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v0_7(void) = Call : r0_6, this:r0_5 +# 846| m0_8(unknown) = ^CallSideEffect : m0_1 +# 846| m0_9(unknown) = Chi : m0_1, m0_8 +# 846| v0_10(void) = ReturnVoid : +# 846| v0_11(void) = UnmodeledUse : mu* +# 846| v0_12(void) = ExitFunction : # 849| DynamicCast() -> void # 849| Block 0 # 849| v0_0(void) = EnterFunction : -# 849| mu0_1(unknown) = UnmodeledDefinition : -# 850| r0_2(glval) = VariableAddress[b] : -#-----| r0_3(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_4(void) = Call : r0_3, this:r0_2 -# 851| r0_5(glval) = VariableAddress[d] : -# 851| r0_6(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v0_7(void) = Call : r0_6, this:r0_5 -# 853| r0_8(glval) = VariableAddress[pb] : -# 853| r0_9(glval) = VariableAddress[b] : -# 853| m0_10(PolymorphicBase *) = Store : r0_8, r0_9 -# 854| r0_11(glval) = VariableAddress[pd] : -# 854| r0_12(glval) = VariableAddress[d] : -# 854| m0_13(PolymorphicDerived *) = Store : r0_11, r0_12 -# 857| r0_14(glval) = VariableAddress[pd] : -# 857| r0_15(PolymorphicDerived *) = Load : r0_14, m0_13 -# 857| r0_16(PolymorphicBase *) = CheckedConvertOrNull : r0_15 -# 857| r0_17(glval) = VariableAddress[pb] : -# 857| m0_18(PolymorphicBase *) = Store : r0_17, r0_16 -# 858| r0_19(glval) = VariableAddress[rb] : -# 858| r0_20(glval) = VariableAddress[d] : -# 858| r0_21(glval) = CheckedConvertOrThrow : r0_20 -# 858| m0_22(PolymorphicBase &) = Store : r0_19, r0_21 -# 860| r0_23(glval) = VariableAddress[pb] : -# 860| r0_24(PolymorphicBase *) = Load : r0_23, m0_18 -# 860| r0_25(PolymorphicDerived *) = CheckedConvertOrNull : r0_24 -# 860| r0_26(glval) = VariableAddress[pd] : -# 860| m0_27(PolymorphicDerived *) = Store : r0_26, r0_25 -# 861| r0_28(glval) = VariableAddress[rd] : -# 861| r0_29(glval) = VariableAddress[b] : -# 861| r0_30(glval) = CheckedConvertOrThrow : r0_29 -# 861| m0_31(PolymorphicDerived &) = Store : r0_28, r0_30 -# 863| r0_32(glval) = VariableAddress[pv] : -# 863| r0_33(glval) = VariableAddress[pb] : -# 863| r0_34(PolymorphicBase *) = Load : r0_33, m0_18 -# 863| r0_35(void *) = DynamicCastToVoid : r0_34 -# 863| m0_36(void *) = Store : r0_32, r0_35 -# 864| r0_37(glval) = VariableAddress[pcv] : -# 864| r0_38(glval) = VariableAddress[pd] : -# 864| r0_39(PolymorphicDerived *) = Load : r0_38, m0_27 -# 864| r0_40(void *) = DynamicCastToVoid : r0_39 -# 864| m0_41(void *) = Store : r0_37, r0_40 -# 865| v0_42(void) = NoOp : -# 849| v0_43(void) = ReturnVoid : -# 849| v0_44(void) = UnmodeledUse : mu* -# 849| v0_45(void) = ExitFunction : +# 849| m0_1(unknown) = AliasedDefinition : +# 849| mu0_2(unknown) = UnmodeledDefinition : +# 850| r0_3(glval) = VariableAddress[b] : +#-----| r0_4(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_5(void) = Call : r0_4, this:r0_3 +#-----| m0_6(unknown) = ^CallSideEffect : m0_1 +#-----| m0_7(unknown) = Chi : m0_1, m0_6 +# 851| r0_8(glval) = VariableAddress[d] : +# 851| r0_9(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v0_10(void) = Call : r0_9, this:r0_8 +# 851| m0_11(unknown) = ^CallSideEffect : m0_7 +# 851| m0_12(unknown) = Chi : m0_7, m0_11 +# 853| r0_13(glval) = VariableAddress[pb] : +# 853| r0_14(glval) = VariableAddress[b] : +# 853| m0_15(PolymorphicBase *) = Store : r0_13, r0_14 +# 854| r0_16(glval) = VariableAddress[pd] : +# 854| r0_17(glval) = VariableAddress[d] : +# 854| m0_18(PolymorphicDerived *) = Store : r0_16, r0_17 +# 857| r0_19(glval) = VariableAddress[pd] : +# 857| r0_20(PolymorphicDerived *) = Load : r0_19, m0_18 +# 857| r0_21(PolymorphicBase *) = CheckedConvertOrNull : r0_20 +# 857| r0_22(glval) = VariableAddress[pb] : +# 857| m0_23(PolymorphicBase *) = Store : r0_22, r0_21 +# 858| r0_24(glval) = VariableAddress[rb] : +# 858| r0_25(glval) = VariableAddress[d] : +# 858| r0_26(glval) = CheckedConvertOrThrow : r0_25 +# 858| m0_27(PolymorphicBase &) = Store : r0_24, r0_26 +# 860| r0_28(glval) = VariableAddress[pb] : +# 860| r0_29(PolymorphicBase *) = Load : r0_28, m0_23 +# 860| r0_30(PolymorphicDerived *) = CheckedConvertOrNull : r0_29 +# 860| r0_31(glval) = VariableAddress[pd] : +# 860| m0_32(PolymorphicDerived *) = Store : r0_31, r0_30 +# 861| r0_33(glval) = VariableAddress[rd] : +# 861| r0_34(glval) = VariableAddress[b] : +# 861| r0_35(glval) = CheckedConvertOrThrow : r0_34 +# 861| m0_36(PolymorphicDerived &) = Store : r0_33, r0_35 +# 863| r0_37(glval) = VariableAddress[pv] : +# 863| r0_38(glval) = VariableAddress[pb] : +# 863| r0_39(PolymorphicBase *) = Load : r0_38, m0_23 +# 863| r0_40(void *) = DynamicCastToVoid : r0_39 +# 863| m0_41(void *) = Store : r0_37, r0_40 +# 864| r0_42(glval) = VariableAddress[pcv] : +# 864| r0_43(glval) = VariableAddress[pd] : +# 864| r0_44(PolymorphicDerived *) = Load : r0_43, m0_32 +# 864| r0_45(void *) = DynamicCastToVoid : r0_44 +# 864| m0_46(void *) = Store : r0_42, r0_45 +# 865| v0_47(void) = NoOp : +# 849| v0_48(void) = ReturnVoid : +# 849| v0_49(void) = UnmodeledUse : mu* +# 849| v0_50(void) = ExitFunction : # 867| String::String() -> void # 867| Block 0 # 867| v0_0(void) = EnterFunction : -# 867| mu0_1(unknown) = UnmodeledDefinition : -# 867| r0_2(glval) = InitializeThis : -# 868| r0_3(glval) = FunctionAddress[String] : -# 868| r0_4(glval) = StringConstant[""] : -# 868| r0_5(char *) = Convert : r0_4 -# 868| v0_6(void) = Call : r0_3, this:r0_2, r0_5 -# 869| v0_7(void) = NoOp : -# 867| v0_8(void) = ReturnVoid : -# 867| v0_9(void) = UnmodeledUse : mu* -# 867| v0_10(void) = ExitFunction : +# 867| m0_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 : r0_4, this:r0_3, r0_6 +# 868| m0_8(unknown) = ^CallSideEffect : m0_1 +# 868| m0_9(unknown) = Chi : m0_1, m0_8 +# 869| v0_10(void) = NoOp : +# 867| v0_11(void) = ReturnVoid : +# 867| v0_12(void) = UnmodeledUse : mu* +# 867| v0_13(void) = ExitFunction : # 871| ArrayConversions() -> void # 871| Block 0 # 871| v0_0(void) = EnterFunction : -# 871| mu0_1(unknown) = UnmodeledDefinition : -# 872| r0_2(glval) = VariableAddress[a] : -# 872| m0_3(char[5]) = Uninitialized : r0_2 -# 873| r0_4(glval) = VariableAddress[p] : -# 873| r0_5(glval) = VariableAddress[a] : -# 873| r0_6(char *) = Convert : r0_5 +# 871| m0_1(unknown) = AliasedDefinition : +# 871| mu0_2(unknown) = UnmodeledDefinition : +# 872| r0_3(glval) = VariableAddress[a] : +# 872| m0_4(char[5]) = Uninitialized : r0_3 +# 873| r0_5(glval) = VariableAddress[p] : +# 873| r0_6(glval) = VariableAddress[a] : # 873| r0_7(char *) = Convert : r0_6 -# 873| m0_8(char *) = Store : r0_4, r0_7 -# 874| r0_9(glval) = StringConstant["test"] : -# 874| r0_10(char *) = Convert : r0_9 -# 874| r0_11(glval) = VariableAddress[p] : -# 874| m0_12(char *) = Store : r0_11, r0_10 -# 875| r0_13(glval) = VariableAddress[a] : -# 875| r0_14(char *) = Convert : r0_13 -# 875| r0_15(int) = Constant[0] : -# 875| r0_16(char *) = PointerAdd[1] : r0_14, r0_15 -# 875| r0_17(char *) = Convert : r0_16 -# 875| r0_18(glval) = VariableAddress[p] : -# 875| m0_19(char *) = Store : r0_18, r0_17 -# 876| r0_20(glval) = StringConstant["test"] : -# 876| r0_21(char *) = Convert : r0_20 -# 876| r0_22(int) = Constant[0] : -# 876| r0_23(char *) = PointerAdd[1] : r0_21, r0_22 -# 876| r0_24(glval) = VariableAddress[p] : -# 876| m0_25(char *) = Store : r0_24, r0_23 -# 877| r0_26(glval) = VariableAddress[ra] : -# 877| r0_27(glval) = VariableAddress[a] : -# 877| m0_28(char(&)[5]) = Store : r0_26, r0_27 -# 878| r0_29(glval) = VariableAddress[rs] : -# 878| r0_30(glval) = StringConstant["test"] : -# 878| m0_31(char(&)[5]) = Store : r0_29, r0_30 -# 879| r0_32(glval) = VariableAddress[pa] : -# 879| r0_33(glval) = VariableAddress[a] : -# 879| r0_34(char(*)[5]) = Convert : r0_33 -# 879| m0_35(char(*)[5]) = Store : r0_32, r0_34 -# 880| r0_36(glval) = StringConstant["test"] : -# 880| r0_37(glval) = VariableAddress[pa] : -# 880| m0_38(char(*)[5]) = Store : r0_37, r0_36 -# 881| v0_39(void) = NoOp : -# 871| v0_40(void) = ReturnVoid : -# 871| v0_41(void) = UnmodeledUse : mu* -# 871| v0_42(void) = ExitFunction : +# 873| r0_8(char *) = Convert : r0_7 +# 873| m0_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| m0_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(char *) = PointerAdd[1] : r0_15, r0_16 +# 875| r0_18(char *) = Convert : r0_17 +# 875| r0_19(glval) = VariableAddress[p] : +# 875| m0_20(char *) = Store : r0_19, r0_18 +# 876| r0_21(glval) = StringConstant["test"] : +# 876| r0_22(char *) = Convert : r0_21 +# 876| r0_23(int) = Constant[0] : +# 876| r0_24(char *) = PointerAdd[1] : r0_22, r0_23 +# 876| r0_25(glval) = VariableAddress[p] : +# 876| m0_26(char *) = Store : r0_25, r0_24 +# 877| r0_27(glval) = VariableAddress[ra] : +# 877| r0_28(glval) = VariableAddress[a] : +# 877| m0_29(char(&)[5]) = Store : r0_27, r0_28 +# 878| r0_30(glval) = VariableAddress[rs] : +# 878| r0_31(glval) = StringConstant["test"] : +# 878| m0_32(char(&)[5]) = Store : r0_30, r0_31 +# 879| r0_33(glval) = VariableAddress[pa] : +# 879| r0_34(glval) = VariableAddress[a] : +# 879| r0_35(char(*)[5]) = Convert : r0_34 +# 879| m0_36(char(*)[5]) = Store : r0_33, r0_35 +# 880| r0_37(glval) = StringConstant["test"] : +# 880| r0_38(glval) = VariableAddress[pa] : +# 880| m0_39(char(*)[5]) = Store : r0_38, r0_37 +# 881| v0_40(void) = NoOp : +# 871| v0_41(void) = ReturnVoid : +# 871| v0_42(void) = UnmodeledUse : mu* +# 871| v0_43(void) = ExitFunction : # 883| FuncPtrConversions(..(*)(..), void *) -> void # 883| Block 0 # 883| v0_0(void) = EnterFunction : -# 883| mu0_1(unknown) = UnmodeledDefinition : -# 883| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| m0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 883| r0_4(glval) = VariableAddress[p] : -# 883| m0_5(void *) = InitializeParameter[p] : r0_4 -# 884| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r0_7(..(*)(..)) = Load : r0_6, m0_3 -# 884| r0_8(void *) = Convert : r0_7 -# 884| r0_9(glval) = VariableAddress[p] : -# 884| m0_10(void *) = Store : r0_9, r0_8 -# 885| r0_11(glval) = VariableAddress[p] : -# 885| r0_12(void *) = Load : r0_11, m0_10 -# 885| r0_13(..(*)(..)) = Convert : r0_12 -# 885| r0_14(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| m0_15(..(*)(..)) = Store : r0_14, r0_13 -# 886| v0_16(void) = NoOp : -# 883| v0_17(void) = ReturnVoid : -# 883| v0_18(void) = UnmodeledUse : mu* -# 883| v0_19(void) = ExitFunction : +# 883| m0_1(unknown) = AliasedDefinition : +# 883| mu0_2(unknown) = UnmodeledDefinition : +# 883| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 883| m0_4(..(*)(..)) = InitializeParameter[pfn] : r0_3 +# 883| r0_5(glval) = VariableAddress[p] : +# 883| m0_6(void *) = InitializeParameter[p] : r0_5 +# 884| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : +# 884| r0_8(..(*)(..)) = Load : r0_7, m0_4 +# 884| r0_9(void *) = Convert : r0_8 +# 884| r0_10(glval) = VariableAddress[p] : +# 884| m0_11(void *) = Store : r0_10, r0_9 +# 885| r0_12(glval) = VariableAddress[p] : +# 885| r0_13(void *) = Load : r0_12, m0_11 +# 885| r0_14(..(*)(..)) = Convert : r0_13 +# 885| r0_15(glval<..(*)(..)>) = VariableAddress[pfn] : +# 885| m0_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) = ExitFunction : # 888| VarArgUsage(int) -> void # 888| Block 0 # 888| v0_0(void) = EnterFunction : -# 888| mu0_1(unknown) = UnmodeledDefinition : -# 888| r0_2(glval) = VariableAddress[x] : -# 888| mu0_3(int) = InitializeParameter[x] : r0_2 -# 889| r0_4(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| mu0_5(__va_list_tag[1]) = Uninitialized : r0_4 -# 891| r0_6(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r0_7(__va_list_tag *) = Convert : r0_6 -# 891| r0_8(glval) = VariableAddress[x] : -# 891| v0_9(void) = VarArgsStart : r0_7, r0_8 -# 892| r0_10(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| mu0_11(__va_list_tag[1]) = Uninitialized : r0_10 -# 893| r0_12(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r0_13(__va_list_tag *) = Convert : r0_12 -# 893| r0_14(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r0_15(__va_list_tag *) = Convert : r0_14 -# 893| v0_16(void) = VarArgsStart : r0_13, r0_15 -# 894| r0_17(glval) = VariableAddress[d] : -# 894| r0_18(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r0_19(__va_list_tag *) = Convert : r0_18 -# 894| r0_20(glval) = VarArg : r0_19 -# 894| r0_21(double) = Load : r0_20, mu0_1 -# 894| m0_22(double) = Store : r0_17, r0_21 -# 895| r0_23(glval) = VariableAddress[f] : -# 895| r0_24(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r0_25(__va_list_tag *) = Convert : r0_24 -# 895| r0_26(glval) = VarArg : r0_25 -# 895| r0_27(double) = Load : r0_26, mu0_1 -# 895| r0_28(float) = Convert : r0_27 -# 895| m0_29(float) = Store : r0_23, r0_28 -# 896| r0_30(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r0_31(__va_list_tag *) = Convert : r0_30 -# 896| v0_32(void) = VarArgsEnd : r0_31 -# 897| r0_33(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r0_34(__va_list_tag *) = Convert : r0_33 -# 897| v0_35(void) = VarArgsEnd : r0_34 -# 898| v0_36(void) = NoOp : -# 888| v0_37(void) = ReturnVoid : -# 888| v0_38(void) = UnmodeledUse : mu* -# 888| v0_39(void) = ExitFunction : +# 888| m0_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 : 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 : r0_8, r0_9 +# 892| r0_11(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| mu0_12(__va_list_tag[1]) = Uninitialized : 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 : r0_14, 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 : r0_20 +# 894| r0_22(double) = Load : r0_21, m0_1 +# 894| m0_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 : r0_26 +# 895| r0_28(double) = Load : r0_27, m0_1 +# 895| r0_29(float) = Convert : r0_28 +# 895| m0_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 : 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 : r0_35 +# 898| v0_37(void) = NoOp : +# 888| v0_38(void) = ReturnVoid : +# 888| v0_39(void) = UnmodeledUse : mu* +# 888| v0_40(void) = ExitFunction : # 900| CastToVoid(int) -> void # 900| Block 0 # 900| v0_0(void) = EnterFunction : -# 900| mu0_1(unknown) = UnmodeledDefinition : -# 900| r0_2(glval) = VariableAddress[x] : -# 900| mu0_3(int) = InitializeParameter[x] : r0_2 -# 901| r0_4(glval) = VariableAddress[x] : -# 901| v0_5(void) = Convert : r0_4 -# 902| v0_6(void) = NoOp : -# 900| v0_7(void) = ReturnVoid : -# 900| v0_8(void) = UnmodeledUse : mu* -# 900| v0_9(void) = ExitFunction : +# 900| m0_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) = ExitFunction : # 904| ConstantConditions(int) -> void # 904| Block 0 # 904| v0_0(void) = EnterFunction : -# 904| mu0_1(unknown) = UnmodeledDefinition : -# 904| r0_2(glval) = VariableAddress[x] : -# 904| m0_3(int) = InitializeParameter[x] : r0_2 -# 905| r0_4(glval) = VariableAddress[a] : -# 905| r0_5(bool) = Constant[1] : -# 905| m0_6(bool) = Store : r0_4, r0_5 -# 906| r0_7(glval) = VariableAddress[b] : -# 906| r0_8(bool) = Constant[1] : -# 906| v0_9(void) = ConditionalBranch : r0_8 +# 904| m0_1(unknown) = AliasedDefinition : +# 904| mu0_2(unknown) = UnmodeledDefinition : +# 904| r0_3(glval) = VariableAddress[x] : +# 904| m0_4(int) = InitializeParameter[x] : r0_3 +# 905| r0_5(glval) = VariableAddress[a] : +# 905| r0_6(bool) = Constant[1] : +# 905| m0_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 #-----| False -> Block 3 #-----| True -> Block 2 @@ -3825,7 +4143,7 @@ ir.cpp: # 906| m1_0(int) = Phi : from 2:m2_3, from 3:m3_3 # 906| r1_1(glval) = VariableAddress[#temp906:11] : # 906| r1_2(int) = Load : r1_1, m1_0 -# 906| m1_3(int) = Store : r0_7, r1_2 +# 906| m1_3(int) = Store : r0_8, r1_2 # 907| v1_4(void) = NoOp : # 904| v1_5(void) = ReturnVoid : # 904| v1_6(void) = UnmodeledUse : mu* @@ -3833,14 +4151,14 @@ ir.cpp: # 906| Block 2 # 906| r2_0(glval) = VariableAddress[x] : -# 906| r2_1(int) = Load : r2_0, m0_3 +# 906| r2_1(int) = Load : r2_0, m0_4 # 906| r2_2(glval) = VariableAddress[#temp906:11] : # 906| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 1 # 906| Block 3 # 906| r3_0(glval) = VariableAddress[x] : -# 906| r3_1(int) = Load : r3_0, m0_3 +# 906| r3_1(int) = Load : r3_0, m0_4 # 906| r3_2(glval) = VariableAddress[#temp906:11] : # 906| m3_3(int) = Store : r3_2, r3_1 #-----| Goto -> Block 1 @@ -3848,191 +4166,227 @@ ir.cpp: # 940| OperatorNew() -> void # 940| Block 0 # 940| v0_0(void) = EnterFunction : -# 940| mu0_1(unknown) = UnmodeledDefinition : -# 941| r0_2(glval) = FunctionAddress[operator new] : -# 941| r0_3(unsigned long) = Constant[4] : -# 941| r0_4(void *) = Call : r0_2, r0_3 -# 941| r0_5(int *) = Convert : r0_4 -# 942| r0_6(glval) = FunctionAddress[operator new] : -# 942| r0_7(unsigned long) = Constant[4] : -# 942| r0_8(float) = Constant[1.0] : -# 942| r0_9(void *) = Call : r0_6, r0_7, r0_8 -# 942| r0_10(int *) = Convert : r0_9 -# 943| r0_11(glval) = FunctionAddress[operator new] : -# 943| r0_12(unsigned long) = Constant[4] : -# 943| r0_13(void *) = Call : r0_11, r0_12 -# 943| r0_14(int *) = Convert : r0_13 -# 943| r0_15(int) = Constant[0] : -# 943| mu0_16(int) = Store : r0_14, r0_15 -# 944| r0_17(glval) = FunctionAddress[operator new] : -# 944| r0_18(unsigned long) = Constant[8] : -# 944| r0_19(void *) = Call : r0_17, r0_18 -# 944| r0_20(String *) = Convert : r0_19 -# 944| r0_21(glval) = FunctionAddress[String] : -# 944| v0_22(void) = Call : r0_21, this:r0_20 -# 945| r0_23(glval) = FunctionAddress[operator new] : -# 945| r0_24(unsigned long) = Constant[8] : -# 945| r0_25(float) = Constant[1.0] : -# 945| r0_26(void *) = Call : r0_23, r0_24, r0_25 -# 945| r0_27(String *) = Convert : r0_26 -# 945| r0_28(glval) = FunctionAddress[String] : -# 945| r0_29(glval) = StringConstant["hello"] : -# 945| r0_30(char *) = Convert : r0_29 -# 945| v0_31(void) = Call : r0_28, this:r0_27, r0_30 -# 946| r0_32(glval) = FunctionAddress[operator new] : -# 946| r0_33(unsigned long) = Constant[256] : -# 946| r0_34(align_val_t) = Constant[128] : -# 946| r0_35(void *) = Call : r0_32, r0_33, r0_34 -# 946| r0_36(Overaligned *) = Convert : r0_35 -# 947| r0_37(glval) = FunctionAddress[operator new] : -# 947| r0_38(unsigned long) = Constant[256] : -# 947| r0_39(align_val_t) = Constant[128] : -# 947| r0_40(float) = Constant[1.0] : -# 947| r0_41(void *) = Call : r0_37, r0_38, r0_39, r0_40 -# 947| r0_42(Overaligned *) = Convert : r0_41 -# 947| r0_43(Overaligned) = Constant[0] : -# 947| mu0_44(Overaligned) = Store : r0_42, r0_43 -# 948| v0_45(void) = NoOp : -# 940| v0_46(void) = ReturnVoid : -# 940| v0_47(void) = UnmodeledUse : mu* -# 940| v0_48(void) = ExitFunction : +# 940| m0_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 : r0_3, r0_4 +# 941| m0_6(unknown) = ^CallSideEffect : m0_1 +# 941| m0_7(unknown) = Chi : m0_1, m0_6 +# 941| r0_8(int *) = Convert : r0_5 +# 942| r0_9(glval) = FunctionAddress[operator new] : +# 942| r0_10(unsigned long) = Constant[4] : +# 942| r0_11(float) = Constant[1.0] : +# 942| r0_12(void *) = Call : r0_9, r0_10, r0_11 +# 942| m0_13(unknown) = ^CallSideEffect : m0_7 +# 942| m0_14(unknown) = Chi : m0_7, m0_13 +# 942| r0_15(int *) = Convert : r0_12 +# 943| r0_16(glval) = FunctionAddress[operator new] : +# 943| r0_17(unsigned long) = Constant[4] : +# 943| r0_18(void *) = Call : r0_16, r0_17 +# 943| m0_19(unknown) = ^CallSideEffect : m0_14 +# 943| m0_20(unknown) = Chi : m0_14, m0_19 +# 943| r0_21(int *) = Convert : r0_18 +# 943| r0_22(int) = Constant[0] : +# 943| m0_23(int) = Store : r0_21, r0_22 +# 943| m0_24(unknown) = Chi : m0_20, m0_23 +# 944| r0_25(glval) = FunctionAddress[operator new] : +# 944| r0_26(unsigned long) = Constant[8] : +# 944| r0_27(void *) = Call : r0_25, r0_26 +# 944| m0_28(unknown) = ^CallSideEffect : m0_24 +# 944| m0_29(unknown) = Chi : m0_24, m0_28 +# 944| r0_30(String *) = Convert : r0_27 +# 944| r0_31(glval) = FunctionAddress[String] : +# 944| v0_32(void) = Call : r0_31, this:r0_30 +# 944| m0_33(unknown) = ^CallSideEffect : m0_29 +# 944| m0_34(unknown) = Chi : m0_29, m0_33 +# 945| r0_35(glval) = FunctionAddress[operator new] : +# 945| r0_36(unsigned long) = Constant[8] : +# 945| r0_37(float) = Constant[1.0] : +# 945| r0_38(void *) = Call : r0_35, r0_36, r0_37 +# 945| m0_39(unknown) = ^CallSideEffect : m0_34 +# 945| m0_40(unknown) = Chi : m0_34, m0_39 +# 945| r0_41(String *) = Convert : r0_38 +# 945| r0_42(glval) = FunctionAddress[String] : +# 945| r0_43(glval) = StringConstant["hello"] : +# 945| r0_44(char *) = Convert : r0_43 +# 945| v0_45(void) = Call : r0_42, this:r0_41, r0_44 +# 945| m0_46(unknown) = ^CallSideEffect : m0_40 +# 945| m0_47(unknown) = Chi : m0_40, m0_46 +# 946| r0_48(glval) = FunctionAddress[operator new] : +# 946| r0_49(unsigned long) = Constant[256] : +# 946| r0_50(align_val_t) = Constant[128] : +# 946| r0_51(void *) = Call : r0_48, r0_49, r0_50 +# 946| m0_52(unknown) = ^CallSideEffect : m0_47 +# 946| m0_53(unknown) = Chi : m0_47, m0_52 +# 946| r0_54(Overaligned *) = Convert : r0_51 +# 947| r0_55(glval) = FunctionAddress[operator new] : +# 947| r0_56(unsigned long) = Constant[256] : +# 947| r0_57(align_val_t) = Constant[128] : +# 947| r0_58(float) = Constant[1.0] : +# 947| r0_59(void *) = Call : r0_55, r0_56, r0_57, r0_58 +# 947| m0_60(unknown) = ^CallSideEffect : m0_53 +# 947| m0_61(unknown) = Chi : m0_53, m0_60 +# 947| r0_62(Overaligned *) = Convert : r0_59 +# 947| r0_63(Overaligned) = Constant[0] : +# 947| m0_64(Overaligned) = Store : r0_62, r0_63 +# 947| m0_65(unknown) = Chi : m0_61, m0_64 +# 948| v0_66(void) = NoOp : +# 940| v0_67(void) = ReturnVoid : +# 940| v0_68(void) = UnmodeledUse : mu* +# 940| v0_69(void) = ExitFunction : # 950| OperatorNewArray(int) -> void # 950| Block 0 # 950| v0_0(void) = EnterFunction : -# 950| mu0_1(unknown) = UnmodeledDefinition : -# 950| r0_2(glval) = VariableAddress[n] : -# 950| m0_3(int) = InitializeParameter[n] : r0_2 -# 951| r0_4(glval) = FunctionAddress[operator new[]] : -# 951| r0_5(unsigned long) = Constant[40] : -# 951| r0_6(void *) = Call : r0_4, r0_5 -# 951| r0_7(int *) = Convert : r0_6 -# 952| r0_8(glval) = FunctionAddress[operator new[]] : -# 952| r0_9(glval) = VariableAddress[n] : -# 952| r0_10(int) = Load : r0_9, m0_3 -# 952| r0_11(unsigned long) = Convert : r0_10 -# 952| r0_12(unsigned long) = Constant[4] : -# 952| r0_13(unsigned long) = Mul : r0_11, r0_12 -# 952| r0_14(void *) = Call : r0_8, r0_13 -# 952| r0_15(int *) = Convert : r0_14 -# 953| r0_16(glval) = FunctionAddress[operator new[]] : -# 953| r0_17(glval) = VariableAddress[n] : -# 953| r0_18(int) = Load : r0_17, m0_3 -# 953| r0_19(unsigned long) = Convert : r0_18 -# 953| r0_20(unsigned long) = Constant[4] : -# 953| r0_21(unsigned long) = Mul : r0_19, r0_20 -# 953| r0_22(float) = Constant[1.0] : -# 953| r0_23(void *) = Call : r0_16, r0_21, r0_22 -# 953| r0_24(int *) = Convert : r0_23 -# 954| r0_25(glval) = FunctionAddress[operator new[]] : -# 954| r0_26(glval) = VariableAddress[n] : -# 954| r0_27(int) = Load : r0_26, m0_3 -# 954| r0_28(unsigned long) = Convert : r0_27 -# 954| r0_29(unsigned long) = Constant[8] : -# 954| r0_30(unsigned long) = Mul : r0_28, r0_29 -# 954| r0_31(void *) = Call : r0_25, r0_30 -# 954| r0_32(String *) = Convert : r0_31 -# 955| r0_33(glval) = FunctionAddress[operator new[]] : -# 955| r0_34(glval) = VariableAddress[n] : -# 955| r0_35(int) = Load : r0_34, m0_3 -# 955| r0_36(unsigned long) = Convert : r0_35 -# 955| r0_37(unsigned long) = Constant[256] : -# 955| r0_38(unsigned long) = Mul : r0_36, r0_37 -# 955| r0_39(align_val_t) = Constant[128] : -# 955| r0_40(void *) = Call : r0_33, r0_38, r0_39 -# 955| r0_41(Overaligned *) = Convert : r0_40 -# 956| r0_42(glval) = FunctionAddress[operator new[]] : -# 956| r0_43(unsigned long) = Constant[2560] : -# 956| r0_44(align_val_t) = Constant[128] : -# 956| r0_45(float) = Constant[1.0] : -# 956| r0_46(void *) = Call : r0_42, r0_43, r0_44, r0_45 -# 956| r0_47(Overaligned *) = Convert : r0_46 -# 957| r0_48(glval) = FunctionAddress[operator new[]] : -# 957| r0_49(glval) = VariableAddress[n] : -# 957| r0_50(int) = Load : r0_49, m0_3 -# 957| r0_51(unsigned long) = Convert : r0_50 -# 957| r0_52(unsigned long) = Constant[1] : -# 957| r0_53(unsigned long) = Mul : r0_51, r0_52 -# 957| r0_54(void *) = Call : r0_48, r0_53 -# 957| r0_55(DefaultCtorWithDefaultParam *) = Convert : r0_54 -# 958| r0_56(glval) = FunctionAddress[operator new[]] : -# 958| r0_57(glval) = VariableAddress[n] : -# 958| r0_58(int) = Load : r0_57, m0_3 -# 958| r0_59(unsigned long) = Convert : r0_58 -# 958| r0_60(unsigned long) = Constant[4] : -# 958| r0_61(unsigned long) = Mul : r0_59, r0_60 -# 958| r0_62(void *) = Call : r0_56, r0_61 -# 958| r0_63(int *) = Convert : r0_62 -# 959| v0_64(void) = NoOp : -# 950| v0_65(void) = ReturnVoid : -# 950| v0_66(void) = UnmodeledUse : mu* -# 950| v0_67(void) = ExitFunction : +# 950| m0_1(unknown) = AliasedDefinition : +# 950| mu0_2(unknown) = UnmodeledDefinition : +# 950| r0_3(glval) = VariableAddress[n] : +# 950| m0_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 : r0_5, r0_6 +# 951| m0_8(unknown) = ^CallSideEffect : m0_1 +# 951| m0_9(unknown) = Chi : m0_1, m0_8 +# 951| r0_10(int *) = Convert : r0_7 +# 952| r0_11(glval) = FunctionAddress[operator new[]] : +# 952| r0_12(glval) = VariableAddress[n] : +# 952| r0_13(int) = Load : r0_12, m0_4 +# 952| r0_14(unsigned long) = Convert : r0_13 +# 952| r0_15(unsigned long) = Constant[4] : +# 952| r0_16(unsigned long) = Mul : r0_14, r0_15 +# 952| r0_17(void *) = Call : r0_11, r0_16 +# 952| m0_18(unknown) = ^CallSideEffect : m0_9 +# 952| m0_19(unknown) = Chi : m0_9, m0_18 +# 952| r0_20(int *) = Convert : r0_17 +# 953| r0_21(glval) = FunctionAddress[operator new[]] : +# 953| r0_22(glval) = VariableAddress[n] : +# 953| r0_23(int) = Load : r0_22, m0_4 +# 953| r0_24(unsigned long) = Convert : r0_23 +# 953| r0_25(unsigned long) = Constant[4] : +# 953| r0_26(unsigned long) = Mul : r0_24, r0_25 +# 953| r0_27(float) = Constant[1.0] : +# 953| r0_28(void *) = Call : r0_21, r0_26, r0_27 +# 953| m0_29(unknown) = ^CallSideEffect : m0_19 +# 953| m0_30(unknown) = Chi : m0_19, m0_29 +# 953| r0_31(int *) = Convert : r0_28 +# 954| r0_32(glval) = FunctionAddress[operator new[]] : +# 954| r0_33(glval) = VariableAddress[n] : +# 954| r0_34(int) = Load : r0_33, m0_4 +# 954| r0_35(unsigned long) = Convert : r0_34 +# 954| r0_36(unsigned long) = Constant[8] : +# 954| r0_37(unsigned long) = Mul : r0_35, r0_36 +# 954| r0_38(void *) = Call : r0_32, r0_37 +# 954| m0_39(unknown) = ^CallSideEffect : m0_30 +# 954| m0_40(unknown) = Chi : m0_30, m0_39 +# 954| r0_41(String *) = Convert : r0_38 +# 955| r0_42(glval) = FunctionAddress[operator new[]] : +# 955| r0_43(glval) = VariableAddress[n] : +# 955| r0_44(int) = Load : r0_43, m0_4 +# 955| r0_45(unsigned long) = Convert : r0_44 +# 955| r0_46(unsigned long) = Constant[256] : +# 955| r0_47(unsigned long) = Mul : r0_45, r0_46 +# 955| r0_48(align_val_t) = Constant[128] : +# 955| r0_49(void *) = Call : r0_42, r0_47, r0_48 +# 955| m0_50(unknown) = ^CallSideEffect : m0_40 +# 955| m0_51(unknown) = Chi : m0_40, m0_50 +# 955| r0_52(Overaligned *) = Convert : r0_49 +# 956| r0_53(glval) = FunctionAddress[operator new[]] : +# 956| r0_54(unsigned long) = Constant[2560] : +# 956| r0_55(align_val_t) = Constant[128] : +# 956| r0_56(float) = Constant[1.0] : +# 956| r0_57(void *) = Call : r0_53, r0_54, r0_55, r0_56 +# 956| m0_58(unknown) = ^CallSideEffect : m0_51 +# 956| m0_59(unknown) = Chi : m0_51, m0_58 +# 956| r0_60(Overaligned *) = Convert : r0_57 +# 957| r0_61(glval) = FunctionAddress[operator new[]] : +# 957| r0_62(glval) = VariableAddress[n] : +# 957| r0_63(int) = Load : r0_62, m0_4 +# 957| r0_64(unsigned long) = Convert : r0_63 +# 957| r0_65(unsigned long) = Constant[1] : +# 957| r0_66(unsigned long) = Mul : r0_64, r0_65 +# 957| r0_67(void *) = Call : r0_61, r0_66 +# 957| m0_68(unknown) = ^CallSideEffect : m0_59 +# 957| m0_69(unknown) = Chi : m0_59, m0_68 +# 957| r0_70(DefaultCtorWithDefaultParam *) = Convert : r0_67 +# 958| r0_71(glval) = FunctionAddress[operator new[]] : +# 958| r0_72(glval) = VariableAddress[n] : +# 958| r0_73(int) = Load : r0_72, m0_4 +# 958| r0_74(unsigned long) = Convert : r0_73 +# 958| r0_75(unsigned long) = Constant[4] : +# 958| r0_76(unsigned long) = Mul : r0_74, r0_75 +# 958| r0_77(void *) = Call : r0_71, r0_76 +# 958| m0_78(unknown) = ^CallSideEffect : m0_69 +# 958| m0_79(unknown) = Chi : m0_69, m0_78 +# 958| r0_80(int *) = Convert : r0_77 +# 959| v0_81(void) = NoOp : +# 950| v0_82(void) = ReturnVoid : +# 950| v0_83(void) = UnmodeledUse : mu* +# 950| v0_84(void) = ExitFunction : # 961| designatedInit() -> int # 961| Block 0 -# 961| v0_0(void) = EnterFunction : -# 961| mu0_1(unknown) = UnmodeledDefinition : -# 962| r0_2(glval) = VariableAddress[a1] : -# 962| mu0_3(int[1000]) = Uninitialized : r0_2 -# 962| r0_4(int) = Constant[0] : -# 962| r0_5(glval) = PointerAdd : r0_2, r0_4 -# 962| r0_6(unknown[8]) = Constant[0] : -# 962| mu0_7(unknown[8]) = Store : r0_5, r0_6 -#-----| Goto -> Block 2 - -# 962| Block 1 -# 962| r1_0(int) = Constant[900] : -# 962| r1_1(glval) = PointerAdd : r0_2, r1_0 -# 962| r1_2(int) = Constant[10900] : -# 962| mu1_3(int) = Store : r1_1, r1_2 -# 962| r1_4(int) = Constant[901] : -# 962| r1_5(glval) = PointerAdd : r0_2, r1_4 -# 962| r1_6(unknown[396]) = Constant[0] : -# 962| mu1_7(unknown[396]) = Store : r1_5, r1_6 -#-----| Goto -> Block 2 - -# 963| Block 2 -# 963| r2_0(glval) = VariableAddress[#return] : -# 963| r2_1(glval) = VariableAddress[a1] : -# 963| r2_2(int *) = Convert : r2_1 -# 963| r2_3(int) = Constant[900] : -# 963| r2_4(int *) = PointerAdd[4] : r2_2, r2_3 -# 963| r2_5(int) = Load : r2_4, mu0_1 -# 963| m2_6(int) = Store : r2_0, r2_5 -# 961| r2_7(glval) = VariableAddress[#return] : -# 961| v2_8(void) = ReturnValue : r2_7, m2_6 -# 961| v2_9(void) = UnmodeledUse : mu* -# 961| v2_10(void) = ExitFunction : - -# 962| Block 3 -# 962| r3_0(int) = Constant[2] : -# 962| r3_1(glval) = PointerAdd : r0_2, r3_0 -# 962| r3_2(int) = Constant[10002] : -# 962| mu3_3(int) = Store : r3_1, r3_2 -# 962| r3_4(int) = Constant[3] : -# 962| r3_5(glval) = PointerAdd : r0_2, r3_4 -# 962| r3_6(unknown[3588]) = Constant[0] : -# 962| mu3_7(unknown[3588]) = Store : r3_5, r3_6 -#-----| Goto -> Block 2 +# 961| v0_0(void) = EnterFunction : +# 961| m0_1(unknown) = AliasedDefinition : +# 961| mu0_2(unknown) = UnmodeledDefinition : +# 962| r0_3(glval) = VariableAddress[a1] : +# 962| mu0_4(int[1000]) = Uninitialized : r0_3 +# 962| r0_5(int) = Constant[0] : +# 962| r0_6(glval) = PointerAdd : r0_3, r0_5 +# 962| r0_7(unknown[8]) = Constant[0] : +# 962| m0_8(unknown[8]) = Store : r0_6, r0_7 +# 962| m0_9(unknown) = Chi : m0_1, m0_8 +# 962| r0_10(int) = Constant[2] : +# 962| r0_11(glval) = PointerAdd : r0_3, r0_10 +# 962| r0_12(int) = Constant[10002] : +# 962| m0_13(int) = Store : r0_11, r0_12 +# 962| m0_14(unknown) = Chi : m0_9, m0_13 +# 962| r0_15(int) = Constant[3] : +# 962| r0_16(glval) = PointerAdd : r0_3, r0_15 +# 962| r0_17(unknown[3588]) = Constant[0] : +# 962| m0_18(unknown[3588]) = Store : r0_16, r0_17 +# 962| m0_19(unknown) = Chi : m0_14, m0_18 +# 962| r0_20(int) = Constant[900] : +# 962| r0_21(glval) = PointerAdd : r0_3, r0_20 +# 962| r0_22(int) = Constant[10900] : +# 962| m0_23(int) = Store : r0_21, r0_22 +# 962| m0_24(unknown) = Chi : m0_19, m0_23 +# 962| r0_25(int) = Constant[901] : +# 962| r0_26(glval) = PointerAdd : r0_3, r0_25 +# 962| r0_27(unknown[396]) = Constant[0] : +# 962| m0_28(unknown[396]) = Store : r0_26, r0_27 +# 962| m0_29(unknown) = Chi : m0_24, m0_28 +# 963| r0_30(glval) = VariableAddress[#return] : +# 963| r0_31(glval) = VariableAddress[a1] : +# 963| r0_32(int *) = Convert : r0_31 +# 963| r0_33(int) = Constant[900] : +# 963| r0_34(int *) = PointerAdd[4] : r0_32, r0_33 +# 963| r0_35(int) = Load : r0_34, mu0_2 +# 963| m0_36(int) = Store : r0_30, r0_35 +# 961| r0_37(glval) = VariableAddress[#return] : +# 961| v0_38(void) = ReturnValue : r0_37, m0_36 +# 961| v0_39(void) = UnmodeledUse : mu* +# 961| v0_40(void) = ExitFunction : # 966| IfStmtWithDeclaration(int, int) -> void # 966| Block 0 # 966| v0_0(void) = EnterFunction : -# 966| mu0_1(unknown) = UnmodeledDefinition : -# 966| r0_2(glval) = VariableAddress[x] : -# 966| m0_3(int) = InitializeParameter[x] : r0_2 -# 966| r0_4(glval) = VariableAddress[y] : -# 966| m0_5(int) = InitializeParameter[y] : r0_4 -# 967| r0_6(glval) = VariableAddress[b] : -# 967| r0_7(glval) = VariableAddress[x] : -# 967| r0_8(int) = Load : r0_7, m0_3 -# 967| r0_9(glval) = VariableAddress[y] : -# 967| r0_10(int) = Load : r0_9, m0_5 -# 967| r0_11(bool) = CompareLT : r0_8, r0_10 -# 967| m0_12(bool) = Store : r0_6, r0_11 -# 967| r0_13(glval) = VariableAddress[b] : -# 967| r0_14(bool) = Load : r0_13, m0_12 -# 967| v0_15(void) = ConditionalBranch : r0_14 +# 966| m0_1(unknown) = AliasedDefinition : +# 966| mu0_2(unknown) = UnmodeledDefinition : +# 966| r0_3(glval) = VariableAddress[x] : +# 966| m0_4(int) = InitializeParameter[x] : r0_3 +# 966| r0_5(glval) = VariableAddress[y] : +# 966| m0_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, m0_6 +# 967| r0_12(bool) = CompareLT : r0_9, r0_11 +# 967| m0_13(bool) = Store : r0_7, r0_12 +# 967| r0_14(glval) = VariableAddress[b] : +# 967| r0_15(bool) = Load : r0_14, m0_13 +# 967| v0_16(void) = ConditionalBranch : r0_15 #-----| False -> Block 2 #-----| True -> Block 1 @@ -4045,9 +4399,9 @@ ir.cpp: # 970| Block 2 # 970| r2_0(glval) = VariableAddress[z] : # 970| r2_1(glval) = VariableAddress[x] : -# 970| r2_2(int) = Load : r2_1, m0_3 +# 970| r2_2(int) = Load : r2_1, mu0_2 # 970| r2_3(glval) = VariableAddress[y] : -# 970| r2_4(int) = Load : r2_3, m0_5 +# 970| r2_4(int) = Load : r2_3, m0_6 # 970| r2_5(int) = Add : r2_2, r2_4 # 970| m2_6(int) = Store : r2_0, r2_5 # 970| r2_7(glval) = VariableAddress[z] : @@ -4092,11 +4446,12 @@ ir.cpp: # 978| WhileStmtWithDeclaration(int, int) -> void # 978| Block 0 # 978| v0_0(void) = EnterFunction : -# 978| mu0_1(unknown) = UnmodeledDefinition : -# 978| r0_2(glval) = VariableAddress[x] : -# 978| m0_3(int) = InitializeParameter[x] : r0_2 -# 978| r0_4(glval) = VariableAddress[y] : -# 978| m0_5(int) = InitializeParameter[y] : r0_4 +# 978| m0_1(unknown) = AliasedDefinition : +# 978| mu0_2(unknown) = UnmodeledDefinition : +# 978| r0_3(glval) = VariableAddress[x] : +# 978| m0_4(int) = InitializeParameter[x] : r0_3 +# 978| r0_5(glval) = VariableAddress[y] : +# 978| m0_6(int) = InitializeParameter[y] : r0_5 #-----| Goto -> Block 7 # 979| Block 1 @@ -4106,9 +4461,9 @@ ir.cpp: # 981| Block 2 # 981| r2_0(glval) = VariableAddress[z] : # 981| r2_1(glval) = VariableAddress[x] : -# 981| r2_2(int) = Load : r2_1, m0_3 +# 981| r2_2(int) = Load : r2_1, mu0_2 # 981| r2_3(glval) = VariableAddress[y] : -# 981| r2_4(int) = Load : r2_3, m0_5 +# 981| r2_4(int) = Load : r2_3, m0_6 # 981| r2_5(int) = Add : r2_2, r2_4 # 981| m2_6(int) = Store : r2_0, r2_5 # 981| r2_7(glval) = VariableAddress[z] : @@ -4148,9 +4503,9 @@ ir.cpp: # 979| Block 7 # 979| r7_0(glval) = VariableAddress[b] : # 979| r7_1(glval) = VariableAddress[x] : -# 979| r7_2(int) = Load : r7_1, m0_3 +# 979| r7_2(int) = Load : r7_1, mu0_2 # 979| r7_3(glval) = VariableAddress[y] : -# 979| r7_4(int) = Load : r7_3, m0_5 +# 979| r7_4(int) = Load : r7_3, m0_6 # 979| r7_5(bool) = CompareLT : r7_2, r7_4 # 979| m7_6(bool) = Store : r7_0, r7_5 # 979| r7_7(glval) = VariableAddress[b] : @@ -4158,3 +4513,90 @@ ir.cpp: # 979| v7_9(void) = ConditionalBranch : r7_8 #-----| False -> Block 2 #-----| True -> Block 1 + +# 1005| ChiPhiNode(Point *, bool, bool) -> int +# 1005| Block 0 +# 1005| v0_0(void) = EnterFunction : +# 1005| m0_1(unknown) = AliasedDefinition : +# 1005| mu0_2(unknown) = UnmodeledDefinition : +# 1005| r0_3(glval) = VariableAddress[p] : +# 1005| m0_4(Point *) = InitializeParameter[p] : r0_3 +# 1005| r0_5(glval) = VariableAddress[which1] : +# 1005| m0_6(bool) = InitializeParameter[which1] : r0_5 +# 1005| r0_7(glval) = VariableAddress[which2] : +# 1005| m0_8(bool) = InitializeParameter[which2] : r0_7 +# 1006| r0_9(glval) = VariableAddress[which1] : +# 1006| r0_10(bool) = Load : r0_9, m0_6 +# 1006| v0_11(void) = ConditionalBranch : r0_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 1007| Block 1 +# 1007| r1_0(glval) = VariableAddress[p] : +# 1007| r1_1(Point *) = Load : r1_0, m0_4 +# 1007| r1_2(glval) = FieldAddress[x] : r1_1 +# 1007| r1_3(int) = Load : r1_2, m0_1 +# 1007| r1_4(int) = Constant[1] : +# 1007| r1_5(int) = Add : r1_3, r1_4 +# 1007| m1_6(int) = Store : r1_2, r1_5 +# 1007| m1_7(unknown) = Chi : m0_1, m1_6 +#-----| Goto -> Block 3 + +# 1009| Block 2 +# 1009| r2_0(glval) = VariableAddress[p] : +# 1009| r2_1(Point *) = Load : r2_0, m0_4 +# 1009| r2_2(glval) = FieldAddress[y] : r2_1 +# 1009| r2_3(int) = Load : r2_2, m0_1 +# 1009| r2_4(int) = Constant[1] : +# 1009| r2_5(int) = Add : r2_3, r2_4 +# 1009| m2_6(int) = Store : r2_2, r2_5 +# 1009| m2_7(unknown) = Chi : m0_1, m2_6 +#-----| Goto -> Block 3 + +# 1012| Block 3 +# 1012| m3_0(unknown) = Phi : from 1:m1_7, from 2:m2_7 +# 1012| r3_1(glval) = VariableAddress[which2] : +# 1012| r3_2(bool) = Load : r3_1, m0_8 +# 1012| v3_3(void) = ConditionalBranch : r3_2 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 1013| Block 4 +# 1013| r4_0(glval) = VariableAddress[p] : +# 1013| r4_1(Point *) = Load : r4_0, m0_4 +# 1013| r4_2(glval) = FieldAddress[x] : r4_1 +# 1013| r4_3(int) = Load : r4_2, m3_0 +# 1013| r4_4(int) = Constant[1] : +# 1013| r4_5(int) = Add : r4_3, r4_4 +# 1013| m4_6(int) = Store : r4_2, r4_5 +# 1013| m4_7(unknown) = Chi : m3_0, m4_6 +#-----| Goto -> Block 6 + +# 1015| Block 5 +# 1015| r5_0(glval) = VariableAddress[p] : +# 1015| r5_1(Point *) = Load : r5_0, m0_4 +# 1015| r5_2(glval) = FieldAddress[y] : r5_1 +# 1015| r5_3(int) = Load : r5_2, m3_0 +# 1015| r5_4(int) = Constant[1] : +# 1015| r5_5(int) = Add : r5_3, r5_4 +# 1015| m5_6(int) = Store : r5_2, r5_5 +# 1015| m5_7(unknown) = Chi : m3_0, m5_6 +#-----| Goto -> Block 6 + +# 1018| Block 6 +# 1018| m6_0(unknown) = Phi : from 4:m4_7, from 5:m5_7 +# 1018| r6_1(glval) = VariableAddress[#return] : +# 1018| r6_2(glval) = VariableAddress[p] : +# 1018| r6_3(Point *) = Load : r6_2, m0_4 +# 1018| r6_4(glval) = FieldAddress[x] : r6_3 +# 1018| r6_5(int) = Load : r6_4, m6_0 +# 1018| r6_6(glval) = VariableAddress[p] : +# 1018| r6_7(Point *) = Load : r6_6, m0_4 +# 1018| r6_8(glval) = FieldAddress[y] : r6_7 +# 1018| r6_9(int) = Load : r6_8, m6_0 +# 1018| r6_10(int) = Add : r6_5, r6_9 +# 1018| m6_11(int) = Store : r6_1, r6_10 +# 1005| r6_12(glval) = VariableAddress[#return] : +# 1005| v6_13(void) = ReturnValue : r6_12, m6_11 +# 1005| v6_14(void) = UnmodeledUse : mu* +# 1005| v6_15(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ir/ir.cpp b/cpp/ql/test/library-tests/ir/ir/ir.cpp index 95486aa55e1..143ee8595c2 100644 --- a/cpp/ql/test/library-tests/ir/ir/ir.cpp +++ b/cpp/ql/test/library-tests/ir/ir/ir.cpp @@ -1002,4 +1002,20 @@ void OperatorDeleteArray() { } #endif +int ChiPhiNode(Point *p, bool which1, bool which2) { + if (which1) { + p->x++; + } else { + p->y++; + } + + if (which2) { + p->x++; + } else { + p->y++; + } + + return p->x + p->y; +} + // semmle-extractor-options: -std=c++17 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 15f3f0867ac..6ad6fd5a685 100644 --- a/cpp/ql/test/library-tests/ir/ir/raw_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/raw_ir.expected @@ -2,1047 +2,1069 @@ bad_asts.cpp: # 14| Bad::CallBadMemberFunction() -> void # 14| Block 0 # 14| v0_0(void) = EnterFunction : -# 14| mu0_1(unknown) = UnmodeledDefinition : -# 15| r0_2(glval) = VariableAddress[s] : -# 15| mu0_3(S) = Uninitialized : r0_2 -# 15| r0_4(glval) = FieldAddress[x] : r0_2 -# 15| r0_5(int) = Constant[0] : -# 15| mu0_6(int) = Store : r0_4, r0_5 -# 16| r0_7(glval) = VariableAddress[s] : -# 16| r0_8(glval) = FunctionAddress[MemberFunction] : -# 16| r0_9(int) = Constant[1] : -# 16| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -# 17| v0_11(void) = NoOp : -# 14| v0_12(void) = ReturnVoid : -# 14| v0_13(void) = UnmodeledUse : mu* -# 14| v0_14(void) = ExitFunction : +# 14| mu0_1(unknown) = AliasedDefinition : +# 14| mu0_2(unknown) = UnmodeledDefinition : +# 15| r0_3(glval) = VariableAddress[s] : +# 15| mu0_4(S) = Uninitialized : 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 : r0_9, this:r0_8, r0_10 +# 16| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 17| v0_13(void) = NoOp : +# 14| v0_14(void) = ReturnVoid : +# 14| v0_15(void) = UnmodeledUse : mu* +# 14| v0_16(void) = ExitFunction : # 22| Bad::Point::Point() -> void # 22| Block 0 # 22| v0_0(void) = EnterFunction : -# 22| mu0_1(unknown) = UnmodeledDefinition : -# 22| r0_2(glval) = InitializeThis : -# 23| v0_3(void) = NoOp : -# 22| v0_4(void) = ReturnVoid : -# 22| v0_5(void) = UnmodeledUse : mu* -# 22| v0_6(void) = ExitFunction : +# 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) = ExitFunction : # 26| Bad::CallCopyConstructor(const Point &) -> void # 26| Block 0 # 26| v0_0(void) = EnterFunction : -# 26| mu0_1(unknown) = UnmodeledDefinition : -# 26| r0_2(glval) = VariableAddress[a] : -# 26| mu0_3(Point &) = InitializeParameter[a] : r0_2 -# 27| r0_4(glval) = VariableAddress[b] : -# 27| r0_5(glval) = VariableAddress[a] : -# 27| r0_6(Point &) = Load : r0_5, mu0_1 -# 27| r0_7(glval) = Convert : r0_6 -# 27| r0_8(Point) = Load : r0_7, mu0_1 -# 27| mu0_9(Point) = Store : r0_4, r0_8 -# 28| v0_10(void) = NoOp : -# 26| v0_11(void) = ReturnVoid : -# 26| v0_12(void) = UnmodeledUse : mu* -# 26| v0_13(void) = ExitFunction : +# 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) = Convert : r0_7 +# 27| r0_9(Point) = Load : r0_8, mu0_2 +# 27| mu0_10(Point) = Store : r0_5, r0_9 +# 28| v0_11(void) = NoOp : +# 26| v0_12(void) = ReturnVoid : +# 26| v0_13(void) = UnmodeledUse : mu* +# 26| v0_14(void) = ExitFunction : ir.cpp: # 1| Constants() -> void # 1| Block 0 # 1| v0_0(void) = EnterFunction : -# 1| mu0_1(unknown) = UnmodeledDefinition : -# 2| r0_2(glval) = VariableAddress[c_i] : -# 2| r0_3(char) = Constant[1] : -# 2| mu0_4(char) = Store : r0_2, r0_3 -# 3| r0_5(glval) = VariableAddress[c_c] : -# 3| r0_6(char) = Constant[65] : -# 3| mu0_7(char) = Store : r0_5, r0_6 -# 5| r0_8(glval) = VariableAddress[sc_i] : -# 5| r0_9(signed char) = Constant[-1] : -# 5| mu0_10(signed char) = Store : r0_8, r0_9 -# 6| r0_11(glval) = VariableAddress[sc_c] : -# 6| r0_12(signed char) = Constant[65] : -# 6| mu0_13(signed char) = Store : r0_11, r0_12 -# 8| r0_14(glval) = VariableAddress[uc_i] : -# 8| r0_15(unsigned char) = Constant[5] : -# 8| mu0_16(unsigned char) = Store : r0_14, r0_15 -# 9| r0_17(glval) = VariableAddress[uc_c] : -# 9| r0_18(unsigned char) = Constant[65] : -# 9| mu0_19(unsigned char) = Store : r0_17, r0_18 -# 11| r0_20(glval) = VariableAddress[s] : -# 11| r0_21(short) = Constant[5] : -# 11| mu0_22(short) = Store : r0_20, r0_21 -# 12| r0_23(glval) = VariableAddress[us] : -# 12| r0_24(unsigned short) = Constant[5] : -# 12| mu0_25(unsigned short) = Store : r0_23, r0_24 -# 14| r0_26(glval) = VariableAddress[i] : -# 14| r0_27(int) = Constant[5] : -# 14| mu0_28(int) = Store : r0_26, r0_27 -# 15| r0_29(glval) = VariableAddress[ui] : -# 15| r0_30(unsigned int) = Constant[5] : -# 15| mu0_31(unsigned int) = Store : r0_29, r0_30 -# 17| r0_32(glval) = VariableAddress[l] : -# 17| r0_33(long) = Constant[5] : -# 17| mu0_34(long) = Store : r0_32, r0_33 -# 18| r0_35(glval) = VariableAddress[ul] : -# 18| r0_36(unsigned long) = Constant[5] : -# 18| mu0_37(unsigned long) = Store : r0_35, r0_36 -# 20| r0_38(glval) = VariableAddress[ll_i] : -# 20| r0_39(long long) = Constant[5] : -# 20| mu0_40(long long) = Store : r0_38, r0_39 -# 21| r0_41(glval) = VariableAddress[ll_ll] : -# 21| r0_42(long long) = Constant[5] : -# 21| mu0_43(long long) = Store : r0_41, r0_42 -# 22| r0_44(glval) = VariableAddress[ull_i] : -# 22| r0_45(unsigned long long) = Constant[5] : -# 22| mu0_46(unsigned long long) = Store : r0_44, r0_45 -# 23| r0_47(glval) = VariableAddress[ull_ull] : -# 23| r0_48(unsigned long long) = Constant[5] : -# 23| mu0_49(unsigned long long) = Store : r0_47, r0_48 -# 25| r0_50(glval) = VariableAddress[b_t] : -# 25| r0_51(bool) = Constant[1] : -# 25| mu0_52(bool) = Store : r0_50, r0_51 -# 26| r0_53(glval) = VariableAddress[b_f] : -# 26| r0_54(bool) = Constant[0] : -# 26| mu0_55(bool) = Store : r0_53, r0_54 -# 28| r0_56(glval) = VariableAddress[wc_i] : -# 28| r0_57(wchar_t) = Constant[5] : -# 28| mu0_58(wchar_t) = Store : r0_56, r0_57 -# 29| r0_59(glval) = VariableAddress[wc_c] : -# 29| r0_60(wchar_t) = Constant[65] : -# 29| mu0_61(wchar_t) = Store : r0_59, r0_60 -# 31| r0_62(glval) = VariableAddress[c16] : -# 31| r0_63(char16_t) = Constant[65] : -# 31| mu0_64(char16_t) = Store : r0_62, r0_63 -# 32| r0_65(glval) = VariableAddress[c32] : -# 32| r0_66(char32_t) = Constant[65] : -# 32| mu0_67(char32_t) = Store : r0_65, r0_66 -# 34| r0_68(glval) = VariableAddress[f_i] : -# 34| r0_69(float) = Constant[1.0] : -# 34| mu0_70(float) = Store : r0_68, r0_69 -# 35| r0_71(glval) = VariableAddress[f_f] : -# 35| r0_72(float) = Constant[1.0] : -# 35| mu0_73(float) = Store : r0_71, r0_72 -# 36| r0_74(glval) = VariableAddress[f_d] : -# 36| r0_75(float) = Constant[1.0] : -# 36| mu0_76(float) = Store : r0_74, r0_75 -# 38| r0_77(glval) = VariableAddress[d_i] : -# 38| r0_78(double) = Constant[1.0] : -# 38| mu0_79(double) = Store : r0_77, r0_78 -# 39| r0_80(glval) = VariableAddress[d_f] : -# 39| r0_81(double) = Constant[1.0] : -# 39| mu0_82(double) = Store : r0_80, r0_81 -# 40| r0_83(glval) = VariableAddress[d_d] : -# 40| r0_84(double) = Constant[1.0] : -# 40| mu0_85(double) = Store : r0_83, r0_84 -# 41| v0_86(void) = NoOp : -# 1| v0_87(void) = ReturnVoid : -# 1| v0_88(void) = UnmodeledUse : mu* -# 1| v0_89(void) = ExitFunction : +# 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) = ExitFunction : # 43| Foo() -> void # 43| Block 0 # 43| v0_0(void) = EnterFunction : -# 43| mu0_1(unknown) = UnmodeledDefinition : -# 44| r0_2(glval) = VariableAddress[x] : -# 44| r0_3(int) = Constant[17] : -# 44| mu0_4(int) = Store : r0_2, r0_3 -# 45| r0_5(glval) = VariableAddress[y] : -# 45| r0_6(short) = Constant[7] : -# 45| mu0_7(short) = Store : r0_5, r0_6 -# 46| r0_8(glval) = VariableAddress[x] : -# 46| r0_9(int) = Load : r0_8, mu0_1 -# 46| r0_10(glval) = VariableAddress[y] : -# 46| r0_11(short) = Load : r0_10, mu0_1 -# 46| r0_12(int) = Convert : r0_11 -# 46| r0_13(int) = Add : r0_9, r0_12 -# 46| r0_14(short) = Convert : r0_13 -# 46| r0_15(glval) = VariableAddress[y] : -# 46| mu0_16(short) = Store : r0_15, r0_14 -# 47| r0_17(glval) = VariableAddress[x] : -# 47| r0_18(int) = Load : r0_17, mu0_1 -# 47| r0_19(glval) = VariableAddress[y] : -# 47| r0_20(short) = Load : r0_19, mu0_1 -# 47| r0_21(int) = Convert : r0_20 -# 47| r0_22(int) = Mul : r0_18, r0_21 -# 47| r0_23(glval) = VariableAddress[x] : -# 47| mu0_24(int) = Store : r0_23, r0_22 -# 48| v0_25(void) = NoOp : -# 43| v0_26(void) = ReturnVoid : -# 43| v0_27(void) = UnmodeledUse : mu* -# 43| v0_28(void) = ExitFunction : +# 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) = ExitFunction : # 50| IntegerOps(int, int) -> void # 50| Block 0 # 50| v0_0(void) = EnterFunction : -# 50| mu0_1(unknown) = UnmodeledDefinition : -# 50| r0_2(glval) = VariableAddress[x] : -# 50| mu0_3(int) = InitializeParameter[x] : r0_2 -# 50| r0_4(glval) = VariableAddress[y] : -# 50| mu0_5(int) = InitializeParameter[y] : r0_4 -# 51| r0_6(glval) = VariableAddress[z] : -# 51| mu0_7(int) = Uninitialized : r0_6 -# 53| r0_8(glval) = VariableAddress[x] : -# 53| r0_9(int) = Load : r0_8, mu0_1 -# 53| r0_10(glval) = VariableAddress[y] : -# 53| r0_11(int) = Load : r0_10, mu0_1 -# 53| r0_12(int) = Add : r0_9, r0_11 -# 53| r0_13(glval) = VariableAddress[z] : -# 53| mu0_14(int) = Store : r0_13, r0_12 -# 54| r0_15(glval) = VariableAddress[x] : -# 54| r0_16(int) = Load : r0_15, mu0_1 -# 54| r0_17(glval) = VariableAddress[y] : -# 54| r0_18(int) = Load : r0_17, mu0_1 -# 54| r0_19(int) = Sub : r0_16, r0_18 -# 54| r0_20(glval) = VariableAddress[z] : -# 54| mu0_21(int) = Store : r0_20, r0_19 -# 55| r0_22(glval) = VariableAddress[x] : -# 55| r0_23(int) = Load : r0_22, mu0_1 -# 55| r0_24(glval) = VariableAddress[y] : -# 55| r0_25(int) = Load : r0_24, mu0_1 -# 55| r0_26(int) = Mul : r0_23, r0_25 -# 55| r0_27(glval) = VariableAddress[z] : -# 55| mu0_28(int) = Store : r0_27, r0_26 -# 56| r0_29(glval) = VariableAddress[x] : -# 56| r0_30(int) = Load : r0_29, mu0_1 -# 56| r0_31(glval) = VariableAddress[y] : -# 56| r0_32(int) = Load : r0_31, mu0_1 -# 56| r0_33(int) = Div : r0_30, r0_32 -# 56| r0_34(glval) = VariableAddress[z] : -# 56| mu0_35(int) = Store : r0_34, r0_33 -# 57| r0_36(glval) = VariableAddress[x] : -# 57| r0_37(int) = Load : r0_36, mu0_1 -# 57| r0_38(glval) = VariableAddress[y] : -# 57| r0_39(int) = Load : r0_38, mu0_1 -# 57| r0_40(int) = Rem : r0_37, r0_39 -# 57| r0_41(glval) = VariableAddress[z] : -# 57| mu0_42(int) = Store : r0_41, r0_40 -# 59| r0_43(glval) = VariableAddress[x] : -# 59| r0_44(int) = Load : r0_43, mu0_1 -# 59| r0_45(glval) = VariableAddress[y] : -# 59| r0_46(int) = Load : r0_45, mu0_1 -# 59| r0_47(int) = BitAnd : r0_44, r0_46 -# 59| r0_48(glval) = VariableAddress[z] : -# 59| mu0_49(int) = Store : r0_48, r0_47 -# 60| r0_50(glval) = VariableAddress[x] : -# 60| r0_51(int) = Load : r0_50, mu0_1 -# 60| r0_52(glval) = VariableAddress[y] : -# 60| r0_53(int) = Load : r0_52, mu0_1 -# 60| r0_54(int) = BitOr : r0_51, r0_53 -# 60| r0_55(glval) = VariableAddress[z] : -# 60| mu0_56(int) = Store : r0_55, r0_54 -# 61| r0_57(glval) = VariableAddress[x] : -# 61| r0_58(int) = Load : r0_57, mu0_1 -# 61| r0_59(glval) = VariableAddress[y] : -# 61| r0_60(int) = Load : r0_59, mu0_1 -# 61| r0_61(int) = BitXor : r0_58, r0_60 -# 61| r0_62(glval) = VariableAddress[z] : -# 61| mu0_63(int) = Store : r0_62, r0_61 -# 63| r0_64(glval) = VariableAddress[x] : -# 63| r0_65(int) = Load : r0_64, mu0_1 -# 63| r0_66(glval) = VariableAddress[y] : -# 63| r0_67(int) = Load : r0_66, mu0_1 -# 63| r0_68(int) = ShiftLeft : r0_65, r0_67 -# 63| r0_69(glval) = VariableAddress[z] : -# 63| mu0_70(int) = Store : r0_69, r0_68 -# 64| r0_71(glval) = VariableAddress[x] : -# 64| r0_72(int) = Load : r0_71, mu0_1 -# 64| r0_73(glval) = VariableAddress[y] : -# 64| r0_74(int) = Load : r0_73, mu0_1 -# 64| r0_75(int) = ShiftRight : r0_72, r0_74 -# 64| r0_76(glval) = VariableAddress[z] : -# 64| mu0_77(int) = Store : r0_76, r0_75 -# 66| r0_78(glval) = VariableAddress[x] : -# 66| r0_79(int) = Load : r0_78, mu0_1 -# 66| r0_80(glval) = VariableAddress[z] : -# 66| mu0_81(int) = Store : r0_80, r0_79 -# 68| r0_82(glval) = VariableAddress[x] : -# 68| r0_83(int) = Load : r0_82, mu0_1 -# 68| r0_84(glval) = VariableAddress[z] : -# 68| r0_85(int) = Load : r0_84, mu0_1 -# 68| r0_86(int) = Add : r0_85, r0_83 -# 68| mu0_87(int) = Store : r0_84, r0_86 -# 69| r0_88(glval) = VariableAddress[x] : -# 69| r0_89(int) = Load : r0_88, mu0_1 -# 69| r0_90(glval) = VariableAddress[z] : -# 69| r0_91(int) = Load : r0_90, mu0_1 -# 69| r0_92(int) = Sub : r0_91, r0_89 -# 69| mu0_93(int) = Store : r0_90, r0_92 -# 70| r0_94(glval) = VariableAddress[x] : -# 70| r0_95(int) = Load : r0_94, mu0_1 -# 70| r0_96(glval) = VariableAddress[z] : -# 70| r0_97(int) = Load : r0_96, mu0_1 -# 70| r0_98(int) = Mul : r0_97, r0_95 -# 70| mu0_99(int) = Store : r0_96, r0_98 -# 71| r0_100(glval) = VariableAddress[x] : -# 71| r0_101(int) = Load : r0_100, mu0_1 -# 71| r0_102(glval) = VariableAddress[z] : -# 71| r0_103(int) = Load : r0_102, mu0_1 -# 71| r0_104(int) = Div : r0_103, r0_101 -# 71| mu0_105(int) = Store : r0_102, r0_104 -# 72| r0_106(glval) = VariableAddress[x] : -# 72| r0_107(int) = Load : r0_106, mu0_1 -# 72| r0_108(glval) = VariableAddress[z] : -# 72| r0_109(int) = Load : r0_108, mu0_1 -# 72| r0_110(int) = Rem : r0_109, r0_107 -# 72| mu0_111(int) = Store : r0_108, r0_110 -# 74| r0_112(glval) = VariableAddress[x] : -# 74| r0_113(int) = Load : r0_112, mu0_1 -# 74| r0_114(glval) = VariableAddress[z] : -# 74| r0_115(int) = Load : r0_114, mu0_1 -# 74| r0_116(int) = BitAnd : r0_115, r0_113 -# 74| mu0_117(int) = Store : r0_114, r0_116 -# 75| r0_118(glval) = VariableAddress[x] : -# 75| r0_119(int) = Load : r0_118, mu0_1 -# 75| r0_120(glval) = VariableAddress[z] : -# 75| r0_121(int) = Load : r0_120, mu0_1 -# 75| r0_122(int) = BitOr : r0_121, r0_119 -# 75| mu0_123(int) = Store : r0_120, r0_122 -# 76| r0_124(glval) = VariableAddress[x] : -# 76| r0_125(int) = Load : r0_124, mu0_1 -# 76| r0_126(glval) = VariableAddress[z] : -# 76| r0_127(int) = Load : r0_126, mu0_1 -# 76| r0_128(int) = BitXor : r0_127, r0_125 -# 76| mu0_129(int) = Store : r0_126, r0_128 -# 78| r0_130(glval) = VariableAddress[x] : -# 78| r0_131(int) = Load : r0_130, mu0_1 -# 78| r0_132(glval) = VariableAddress[z] : -# 78| r0_133(int) = Load : r0_132, mu0_1 -# 78| r0_134(int) = ShiftLeft : r0_133, r0_131 -# 78| mu0_135(int) = Store : r0_132, r0_134 -# 79| r0_136(glval) = VariableAddress[x] : -# 79| r0_137(int) = Load : r0_136, mu0_1 -# 79| r0_138(glval) = VariableAddress[z] : -# 79| r0_139(int) = Load : r0_138, mu0_1 -# 79| r0_140(int) = ShiftRight : r0_139, r0_137 -# 79| mu0_141(int) = Store : r0_138, r0_140 -# 81| r0_142(glval) = VariableAddress[x] : -# 81| r0_143(int) = Load : r0_142, mu0_1 -# 81| r0_144(int) = CopyValue : r0_143 -# 81| r0_145(glval) = VariableAddress[z] : -# 81| mu0_146(int) = Store : r0_145, r0_144 -# 82| r0_147(glval) = VariableAddress[x] : -# 82| r0_148(int) = Load : r0_147, mu0_1 -# 82| r0_149(int) = Negate : r0_148 -# 82| r0_150(glval) = VariableAddress[z] : -# 82| mu0_151(int) = Store : r0_150, r0_149 -# 83| r0_152(glval) = VariableAddress[x] : -# 83| r0_153(int) = Load : r0_152, mu0_1 -# 83| r0_154(int) = BitComplement : r0_153 -# 83| r0_155(glval) = VariableAddress[z] : -# 83| mu0_156(int) = Store : r0_155, r0_154 -# 84| r0_157(glval) = VariableAddress[x] : -# 84| r0_158(int) = Load : r0_157, mu0_1 -# 84| r0_159(int) = Constant[0] : -# 84| r0_160(bool) = CompareNE : r0_158, r0_159 -# 84| r0_161(bool) = LogicalNot : r0_160 -# 84| r0_162(int) = Convert : r0_161 -# 84| r0_163(glval) = VariableAddress[z] : -# 84| mu0_164(int) = Store : r0_163, r0_162 -# 85| v0_165(void) = NoOp : -# 50| v0_166(void) = ReturnVoid : -# 50| v0_167(void) = UnmodeledUse : mu* -# 50| v0_168(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 87| IntegerCompare(int, int) -> void # 87| Block 0 # 87| v0_0(void) = EnterFunction : -# 87| mu0_1(unknown) = UnmodeledDefinition : -# 87| r0_2(glval) = VariableAddress[x] : -# 87| mu0_3(int) = InitializeParameter[x] : r0_2 -# 87| r0_4(glval) = VariableAddress[y] : -# 87| mu0_5(int) = InitializeParameter[y] : r0_4 -# 88| r0_6(glval) = VariableAddress[b] : -# 88| mu0_7(bool) = Uninitialized : r0_6 -# 90| r0_8(glval) = VariableAddress[x] : -# 90| r0_9(int) = Load : r0_8, mu0_1 -# 90| r0_10(glval) = VariableAddress[y] : -# 90| r0_11(int) = Load : r0_10, mu0_1 -# 90| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 90| r0_13(glval) = VariableAddress[b] : -# 90| mu0_14(bool) = Store : r0_13, r0_12 -# 91| r0_15(glval) = VariableAddress[x] : -# 91| r0_16(int) = Load : r0_15, mu0_1 -# 91| r0_17(glval) = VariableAddress[y] : -# 91| r0_18(int) = Load : r0_17, mu0_1 -# 91| r0_19(bool) = CompareNE : r0_16, r0_18 -# 91| r0_20(glval) = VariableAddress[b] : -# 91| mu0_21(bool) = Store : r0_20, r0_19 -# 92| r0_22(glval) = VariableAddress[x] : -# 92| r0_23(int) = Load : r0_22, mu0_1 -# 92| r0_24(glval) = VariableAddress[y] : -# 92| r0_25(int) = Load : r0_24, mu0_1 -# 92| r0_26(bool) = CompareLT : r0_23, r0_25 -# 92| r0_27(glval) = VariableAddress[b] : -# 92| mu0_28(bool) = Store : r0_27, r0_26 -# 93| r0_29(glval) = VariableAddress[x] : -# 93| r0_30(int) = Load : r0_29, mu0_1 -# 93| r0_31(glval) = VariableAddress[y] : -# 93| r0_32(int) = Load : r0_31, mu0_1 -# 93| r0_33(bool) = CompareGT : r0_30, r0_32 -# 93| r0_34(glval) = VariableAddress[b] : -# 93| mu0_35(bool) = Store : r0_34, r0_33 -# 94| r0_36(glval) = VariableAddress[x] : -# 94| r0_37(int) = Load : r0_36, mu0_1 -# 94| r0_38(glval) = VariableAddress[y] : -# 94| r0_39(int) = Load : r0_38, mu0_1 -# 94| r0_40(bool) = CompareLE : r0_37, r0_39 -# 94| r0_41(glval) = VariableAddress[b] : -# 94| mu0_42(bool) = Store : r0_41, r0_40 -# 95| r0_43(glval) = VariableAddress[x] : -# 95| r0_44(int) = Load : r0_43, mu0_1 -# 95| r0_45(glval) = VariableAddress[y] : -# 95| r0_46(int) = Load : r0_45, mu0_1 -# 95| r0_47(bool) = CompareGE : r0_44, r0_46 -# 95| r0_48(glval) = VariableAddress[b] : -# 95| mu0_49(bool) = Store : r0_48, r0_47 -# 96| v0_50(void) = NoOp : -# 87| v0_51(void) = ReturnVoid : -# 87| v0_52(void) = UnmodeledUse : mu* -# 87| v0_53(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 98| IntegerCrement(int) -> void # 98| Block 0 # 98| v0_0(void) = EnterFunction : -# 98| mu0_1(unknown) = UnmodeledDefinition : -# 98| r0_2(glval) = VariableAddress[x] : -# 98| mu0_3(int) = InitializeParameter[x] : r0_2 -# 99| r0_4(glval) = VariableAddress[y] : -# 99| mu0_5(int) = Uninitialized : r0_4 -# 101| r0_6(glval) = VariableAddress[x] : -# 101| r0_7(int) = Load : r0_6, mu0_1 -# 101| r0_8(int) = Constant[1] : -# 101| r0_9(int) = Add : r0_7, r0_8 -# 101| mu0_10(int) = Store : r0_6, r0_9 -# 101| r0_11(glval) = VariableAddress[y] : -# 101| mu0_12(int) = Store : r0_11, r0_9 -# 102| r0_13(glval) = VariableAddress[x] : -# 102| r0_14(int) = Load : r0_13, mu0_1 -# 102| r0_15(int) = Constant[1] : -# 102| r0_16(int) = Sub : r0_14, r0_15 -# 102| mu0_17(int) = Store : r0_13, r0_16 -# 102| r0_18(glval) = VariableAddress[y] : -# 102| mu0_19(int) = Store : r0_18, r0_16 -# 103| r0_20(glval) = VariableAddress[x] : -# 103| r0_21(int) = Load : r0_20, mu0_1 -# 103| r0_22(int) = Constant[1] : -# 103| r0_23(int) = Add : r0_21, r0_22 -# 103| mu0_24(int) = Store : r0_20, r0_23 -# 103| r0_25(glval) = VariableAddress[y] : -# 103| mu0_26(int) = Store : r0_25, r0_21 -# 104| r0_27(glval) = VariableAddress[x] : -# 104| r0_28(int) = Load : r0_27, mu0_1 -# 104| r0_29(int) = Constant[1] : -# 104| r0_30(int) = Sub : r0_28, r0_29 -# 104| mu0_31(int) = Store : r0_27, r0_30 -# 104| r0_32(glval) = VariableAddress[y] : -# 104| mu0_33(int) = Store : r0_32, r0_28 -# 105| v0_34(void) = NoOp : -# 98| v0_35(void) = ReturnVoid : -# 98| v0_36(void) = UnmodeledUse : mu* -# 98| v0_37(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 107| IntegerCrement_LValue(int) -> void # 107| Block 0 # 107| v0_0(void) = EnterFunction : -# 107| mu0_1(unknown) = UnmodeledDefinition : -# 107| r0_2(glval) = VariableAddress[x] : -# 107| mu0_3(int) = InitializeParameter[x] : r0_2 -# 108| r0_4(glval) = VariableAddress[p] : -# 108| mu0_5(int *) = Uninitialized : r0_4 -# 110| r0_6(glval) = VariableAddress[x] : -# 110| r0_7(int) = Load : r0_6, mu0_1 -# 110| r0_8(int) = Constant[1] : -# 110| r0_9(int) = Add : r0_7, r0_8 -# 110| mu0_10(int) = Store : r0_6, r0_9 -# 110| r0_11(glval) = VariableAddress[p] : -# 110| mu0_12(int *) = Store : r0_11, r0_6 -# 111| r0_13(glval) = VariableAddress[x] : -# 111| r0_14(int) = Load : r0_13, mu0_1 -# 111| r0_15(int) = Constant[1] : -# 111| r0_16(int) = Sub : r0_14, r0_15 -# 111| mu0_17(int) = Store : r0_13, r0_16 -# 111| r0_18(glval) = VariableAddress[p] : -# 111| mu0_19(int *) = Store : r0_18, r0_13 -# 112| v0_20(void) = NoOp : -# 107| v0_21(void) = ReturnVoid : -# 107| v0_22(void) = UnmodeledUse : mu* -# 107| v0_23(void) = ExitFunction : +# 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 : 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) = VariableAddress[p] : +# 110| mu0_13(int *) = Store : r0_12, r0_7 +# 111| r0_14(glval) = VariableAddress[x] : +# 111| r0_15(int) = Load : r0_14, mu0_2 +# 111| r0_16(int) = Constant[1] : +# 111| r0_17(int) = Sub : r0_15, r0_16 +# 111| mu0_18(int) = Store : r0_14, r0_17 +# 111| r0_19(glval) = VariableAddress[p] : +# 111| mu0_20(int *) = Store : r0_19, r0_14 +# 112| v0_21(void) = NoOp : +# 107| v0_22(void) = ReturnVoid : +# 107| v0_23(void) = UnmodeledUse : mu* +# 107| v0_24(void) = ExitFunction : # 114| FloatOps(double, double) -> void # 114| Block 0 # 114| v0_0(void) = EnterFunction : -# 114| mu0_1(unknown) = UnmodeledDefinition : -# 114| r0_2(glval) = VariableAddress[x] : -# 114| mu0_3(double) = InitializeParameter[x] : r0_2 -# 114| r0_4(glval) = VariableAddress[y] : -# 114| mu0_5(double) = InitializeParameter[y] : r0_4 -# 115| r0_6(glval) = VariableAddress[z] : -# 115| mu0_7(double) = Uninitialized : r0_6 -# 117| r0_8(glval) = VariableAddress[x] : -# 117| r0_9(double) = Load : r0_8, mu0_1 -# 117| r0_10(glval) = VariableAddress[y] : -# 117| r0_11(double) = Load : r0_10, mu0_1 -# 117| r0_12(double) = Add : r0_9, r0_11 -# 117| r0_13(glval) = VariableAddress[z] : -# 117| mu0_14(double) = Store : r0_13, r0_12 -# 118| r0_15(glval) = VariableAddress[x] : -# 118| r0_16(double) = Load : r0_15, mu0_1 -# 118| r0_17(glval) = VariableAddress[y] : -# 118| r0_18(double) = Load : r0_17, mu0_1 -# 118| r0_19(double) = Sub : r0_16, r0_18 -# 118| r0_20(glval) = VariableAddress[z] : -# 118| mu0_21(double) = Store : r0_20, r0_19 -# 119| r0_22(glval) = VariableAddress[x] : -# 119| r0_23(double) = Load : r0_22, mu0_1 -# 119| r0_24(glval) = VariableAddress[y] : -# 119| r0_25(double) = Load : r0_24, mu0_1 -# 119| r0_26(double) = Mul : r0_23, r0_25 -# 119| r0_27(glval) = VariableAddress[z] : -# 119| mu0_28(double) = Store : r0_27, r0_26 -# 120| r0_29(glval) = VariableAddress[x] : -# 120| r0_30(double) = Load : r0_29, mu0_1 -# 120| r0_31(glval) = VariableAddress[y] : -# 120| r0_32(double) = Load : r0_31, mu0_1 -# 120| r0_33(double) = Div : r0_30, r0_32 -# 120| r0_34(glval) = VariableAddress[z] : -# 120| mu0_35(double) = Store : r0_34, r0_33 -# 122| r0_36(glval) = VariableAddress[x] : -# 122| r0_37(double) = Load : r0_36, mu0_1 -# 122| r0_38(glval) = VariableAddress[z] : -# 122| mu0_39(double) = Store : r0_38, r0_37 -# 124| r0_40(glval) = VariableAddress[x] : -# 124| r0_41(double) = Load : r0_40, mu0_1 -# 124| r0_42(glval) = VariableAddress[z] : -# 124| r0_43(double) = Load : r0_42, mu0_1 -# 124| r0_44(double) = Add : r0_43, r0_41 -# 124| mu0_45(double) = Store : r0_42, r0_44 -# 125| r0_46(glval) = VariableAddress[x] : -# 125| r0_47(double) = Load : r0_46, mu0_1 -# 125| r0_48(glval) = VariableAddress[z] : -# 125| r0_49(double) = Load : r0_48, mu0_1 -# 125| r0_50(double) = Sub : r0_49, r0_47 -# 125| mu0_51(double) = Store : r0_48, r0_50 -# 126| r0_52(glval) = VariableAddress[x] : -# 126| r0_53(double) = Load : r0_52, mu0_1 -# 126| r0_54(glval) = VariableAddress[z] : -# 126| r0_55(double) = Load : r0_54, mu0_1 -# 126| r0_56(double) = Mul : r0_55, r0_53 -# 126| mu0_57(double) = Store : r0_54, r0_56 -# 127| r0_58(glval) = VariableAddress[x] : -# 127| r0_59(double) = Load : r0_58, mu0_1 -# 127| r0_60(glval) = VariableAddress[z] : -# 127| r0_61(double) = Load : r0_60, mu0_1 -# 127| r0_62(double) = Div : r0_61, r0_59 -# 127| mu0_63(double) = Store : r0_60, r0_62 -# 129| r0_64(glval) = VariableAddress[x] : -# 129| r0_65(double) = Load : r0_64, mu0_1 -# 129| r0_66(double) = CopyValue : r0_65 -# 129| r0_67(glval) = VariableAddress[z] : -# 129| mu0_68(double) = Store : r0_67, r0_66 -# 130| r0_69(glval) = VariableAddress[x] : -# 130| r0_70(double) = Load : r0_69, mu0_1 -# 130| r0_71(double) = Negate : r0_70 -# 130| r0_72(glval) = VariableAddress[z] : -# 130| mu0_73(double) = Store : r0_72, r0_71 -# 131| v0_74(void) = NoOp : -# 114| v0_75(void) = ReturnVoid : -# 114| v0_76(void) = UnmodeledUse : mu* -# 114| v0_77(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 133| FloatCompare(double, double) -> void # 133| Block 0 # 133| v0_0(void) = EnterFunction : -# 133| mu0_1(unknown) = UnmodeledDefinition : -# 133| r0_2(glval) = VariableAddress[x] : -# 133| mu0_3(double) = InitializeParameter[x] : r0_2 -# 133| r0_4(glval) = VariableAddress[y] : -# 133| mu0_5(double) = InitializeParameter[y] : r0_4 -# 134| r0_6(glval) = VariableAddress[b] : -# 134| mu0_7(bool) = Uninitialized : r0_6 -# 136| r0_8(glval) = VariableAddress[x] : -# 136| r0_9(double) = Load : r0_8, mu0_1 -# 136| r0_10(glval) = VariableAddress[y] : -# 136| r0_11(double) = Load : r0_10, mu0_1 -# 136| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 136| r0_13(glval) = VariableAddress[b] : -# 136| mu0_14(bool) = Store : r0_13, r0_12 -# 137| r0_15(glval) = VariableAddress[x] : -# 137| r0_16(double) = Load : r0_15, mu0_1 -# 137| r0_17(glval) = VariableAddress[y] : -# 137| r0_18(double) = Load : r0_17, mu0_1 -# 137| r0_19(bool) = CompareNE : r0_16, r0_18 -# 137| r0_20(glval) = VariableAddress[b] : -# 137| mu0_21(bool) = Store : r0_20, r0_19 -# 138| r0_22(glval) = VariableAddress[x] : -# 138| r0_23(double) = Load : r0_22, mu0_1 -# 138| r0_24(glval) = VariableAddress[y] : -# 138| r0_25(double) = Load : r0_24, mu0_1 -# 138| r0_26(bool) = CompareLT : r0_23, r0_25 -# 138| r0_27(glval) = VariableAddress[b] : -# 138| mu0_28(bool) = Store : r0_27, r0_26 -# 139| r0_29(glval) = VariableAddress[x] : -# 139| r0_30(double) = Load : r0_29, mu0_1 -# 139| r0_31(glval) = VariableAddress[y] : -# 139| r0_32(double) = Load : r0_31, mu0_1 -# 139| r0_33(bool) = CompareGT : r0_30, r0_32 -# 139| r0_34(glval) = VariableAddress[b] : -# 139| mu0_35(bool) = Store : r0_34, r0_33 -# 140| r0_36(glval) = VariableAddress[x] : -# 140| r0_37(double) = Load : r0_36, mu0_1 -# 140| r0_38(glval) = VariableAddress[y] : -# 140| r0_39(double) = Load : r0_38, mu0_1 -# 140| r0_40(bool) = CompareLE : r0_37, r0_39 -# 140| r0_41(glval) = VariableAddress[b] : -# 140| mu0_42(bool) = Store : r0_41, r0_40 -# 141| r0_43(glval) = VariableAddress[x] : -# 141| r0_44(double) = Load : r0_43, mu0_1 -# 141| r0_45(glval) = VariableAddress[y] : -# 141| r0_46(double) = Load : r0_45, mu0_1 -# 141| r0_47(bool) = CompareGE : r0_44, r0_46 -# 141| r0_48(glval) = VariableAddress[b] : -# 141| mu0_49(bool) = Store : r0_48, r0_47 -# 142| v0_50(void) = NoOp : -# 133| v0_51(void) = ReturnVoid : -# 133| v0_52(void) = UnmodeledUse : mu* -# 133| v0_53(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 144| FloatCrement(float) -> void # 144| Block 0 # 144| v0_0(void) = EnterFunction : -# 144| mu0_1(unknown) = UnmodeledDefinition : -# 144| r0_2(glval) = VariableAddress[x] : -# 144| mu0_3(float) = InitializeParameter[x] : r0_2 -# 145| r0_4(glval) = VariableAddress[y] : -# 145| mu0_5(float) = Uninitialized : r0_4 -# 147| r0_6(glval) = VariableAddress[x] : -# 147| r0_7(float) = Load : r0_6, mu0_1 -# 147| r0_8(float) = Constant[1.0] : -# 147| r0_9(float) = Add : r0_7, r0_8 -# 147| mu0_10(float) = Store : r0_6, r0_9 -# 147| r0_11(glval) = VariableAddress[y] : -# 147| mu0_12(float) = Store : r0_11, r0_9 -# 148| r0_13(glval) = VariableAddress[x] : -# 148| r0_14(float) = Load : r0_13, mu0_1 -# 148| r0_15(float) = Constant[1.0] : -# 148| r0_16(float) = Sub : r0_14, r0_15 -# 148| mu0_17(float) = Store : r0_13, r0_16 -# 148| r0_18(glval) = VariableAddress[y] : -# 148| mu0_19(float) = Store : r0_18, r0_16 -# 149| r0_20(glval) = VariableAddress[x] : -# 149| r0_21(float) = Load : r0_20, mu0_1 -# 149| r0_22(float) = Constant[1.0] : -# 149| r0_23(float) = Add : r0_21, r0_22 -# 149| mu0_24(float) = Store : r0_20, r0_23 -# 149| r0_25(glval) = VariableAddress[y] : -# 149| mu0_26(float) = Store : r0_25, r0_21 -# 150| r0_27(glval) = VariableAddress[x] : -# 150| r0_28(float) = Load : r0_27, mu0_1 -# 150| r0_29(float) = Constant[1.0] : -# 150| r0_30(float) = Sub : r0_28, r0_29 -# 150| mu0_31(float) = Store : r0_27, r0_30 -# 150| r0_32(glval) = VariableAddress[y] : -# 150| mu0_33(float) = Store : r0_32, r0_28 -# 151| v0_34(void) = NoOp : -# 144| v0_35(void) = ReturnVoid : -# 144| v0_36(void) = UnmodeledUse : mu* -# 144| v0_37(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 153| PointerOps(int *, int) -> void # 153| Block 0 # 153| v0_0(void) = EnterFunction : -# 153| mu0_1(unknown) = UnmodeledDefinition : -# 153| r0_2(glval) = VariableAddress[p] : -# 153| mu0_3(int *) = InitializeParameter[p] : r0_2 -# 153| r0_4(glval) = VariableAddress[i] : -# 153| mu0_5(int) = InitializeParameter[i] : r0_4 -# 154| r0_6(glval) = VariableAddress[q] : -# 154| mu0_7(int *) = Uninitialized : r0_6 -# 155| r0_8(glval) = VariableAddress[b] : -# 155| mu0_9(bool) = Uninitialized : r0_8 -# 157| r0_10(glval) = VariableAddress[p] : -# 157| r0_11(int *) = Load : r0_10, mu0_1 -# 157| r0_12(glval) = VariableAddress[i] : -# 157| r0_13(int) = Load : r0_12, mu0_1 -# 157| r0_14(int *) = PointerAdd[4] : r0_11, r0_13 -# 157| r0_15(glval) = VariableAddress[q] : -# 157| mu0_16(int *) = Store : r0_15, r0_14 -# 158| r0_17(glval) = VariableAddress[i] : -# 158| r0_18(int) = Load : r0_17, mu0_1 -# 158| r0_19(glval) = VariableAddress[p] : -# 158| r0_20(int *) = Load : r0_19, mu0_1 -# 158| r0_21(int *) = PointerAdd[4] : r0_20, r0_18 -# 158| r0_22(glval) = VariableAddress[q] : -# 158| mu0_23(int *) = Store : r0_22, r0_21 -# 159| r0_24(glval) = VariableAddress[p] : -# 159| r0_25(int *) = Load : r0_24, mu0_1 -# 159| r0_26(glval) = VariableAddress[i] : -# 159| r0_27(int) = Load : r0_26, mu0_1 -# 159| r0_28(int *) = PointerSub[4] : r0_25, r0_27 -# 159| r0_29(glval) = VariableAddress[q] : -# 159| mu0_30(int *) = Store : r0_29, r0_28 -# 160| r0_31(glval) = VariableAddress[p] : -# 160| r0_32(int *) = Load : r0_31, mu0_1 -# 160| r0_33(glval) = VariableAddress[q] : -# 160| r0_34(int *) = Load : r0_33, mu0_1 -# 160| r0_35(long) = PointerDiff[4] : r0_32, r0_34 -# 160| r0_36(int) = Convert : r0_35 -# 160| r0_37(glval) = VariableAddress[i] : -# 160| mu0_38(int) = Store : r0_37, r0_36 -# 162| r0_39(glval) = VariableAddress[p] : -# 162| r0_40(int *) = Load : r0_39, mu0_1 -# 162| r0_41(glval) = VariableAddress[q] : -# 162| mu0_42(int *) = Store : r0_41, r0_40 -# 164| r0_43(glval) = VariableAddress[i] : -# 164| r0_44(int) = Load : r0_43, mu0_1 -# 164| r0_45(glval) = VariableAddress[q] : -# 164| r0_46(int *) = Load : r0_45, mu0_1 -# 164| r0_47(int *) = PointerAdd[4] : r0_46, r0_44 -# 164| mu0_48(int *) = Store : r0_45, r0_47 -# 165| r0_49(glval) = VariableAddress[i] : -# 165| r0_50(int) = Load : r0_49, mu0_1 -# 165| r0_51(glval) = VariableAddress[q] : -# 165| r0_52(int *) = Load : r0_51, mu0_1 -# 165| r0_53(int *) = PointerSub[4] : r0_52, r0_50 -# 165| mu0_54(int *) = Store : r0_51, r0_53 -# 167| r0_55(glval) = VariableAddress[p] : -# 167| r0_56(int *) = Load : r0_55, mu0_1 -# 167| r0_57(int *) = Constant[0] : -# 167| r0_58(bool) = CompareNE : r0_56, r0_57 -# 167| r0_59(glval) = VariableAddress[b] : -# 167| mu0_60(bool) = Store : r0_59, r0_58 -# 168| r0_61(glval) = VariableAddress[p] : -# 168| r0_62(int *) = Load : r0_61, mu0_1 -# 168| r0_63(int *) = Constant[0] : -# 168| r0_64(bool) = CompareNE : r0_62, r0_63 -# 168| r0_65(bool) = LogicalNot : r0_64 -# 168| r0_66(glval) = VariableAddress[b] : -# 168| mu0_67(bool) = Store : r0_66, r0_65 -# 169| v0_68(void) = NoOp : -# 153| v0_69(void) = ReturnVoid : -# 153| v0_70(void) = UnmodeledUse : mu* -# 153| v0_71(void) = ExitFunction : +# 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 : r0_7 +# 155| r0_9(glval) = VariableAddress[b] : +# 155| mu0_10(bool) = Uninitialized : 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) = ExitFunction : # 171| ArrayAccess(int *, int) -> void # 171| Block 0 # 171| v0_0(void) = EnterFunction : -# 171| mu0_1(unknown) = UnmodeledDefinition : -# 171| r0_2(glval) = VariableAddress[p] : -# 171| mu0_3(int *) = InitializeParameter[p] : r0_2 -# 171| r0_4(glval) = VariableAddress[i] : -# 171| mu0_5(int) = InitializeParameter[i] : r0_4 -# 172| r0_6(glval) = VariableAddress[x] : -# 172| mu0_7(int) = Uninitialized : r0_6 -# 174| r0_8(glval) = VariableAddress[p] : -# 174| r0_9(int *) = Load : r0_8, mu0_1 -# 174| r0_10(glval) = VariableAddress[i] : -# 174| r0_11(int) = Load : r0_10, mu0_1 -# 174| r0_12(int *) = PointerAdd[4] : r0_9, r0_11 -# 174| r0_13(int) = Load : r0_12, mu0_1 -# 174| r0_14(glval) = VariableAddress[x] : -# 174| mu0_15(int) = Store : r0_14, r0_13 -# 175| r0_16(glval) = VariableAddress[p] : -# 175| r0_17(int *) = Load : r0_16, mu0_1 -# 175| r0_18(glval) = VariableAddress[i] : -# 175| r0_19(int) = Load : r0_18, mu0_1 -# 175| r0_20(int *) = PointerAdd[4] : r0_17, r0_19 -# 175| r0_21(int) = Load : r0_20, mu0_1 -# 175| r0_22(glval) = VariableAddress[x] : -# 175| mu0_23(int) = Store : r0_22, r0_21 -# 177| r0_24(glval) = VariableAddress[x] : -# 177| r0_25(int) = Load : r0_24, mu0_1 -# 177| r0_26(glval) = VariableAddress[p] : -# 177| r0_27(int *) = Load : r0_26, mu0_1 -# 177| r0_28(glval) = VariableAddress[i] : -# 177| r0_29(int) = Load : r0_28, mu0_1 -# 177| r0_30(int *) = PointerAdd[4] : r0_27, r0_29 -# 177| mu0_31(int) = Store : r0_30, r0_25 -# 178| r0_32(glval) = VariableAddress[x] : -# 178| r0_33(int) = Load : r0_32, mu0_1 -# 178| r0_34(glval) = VariableAddress[p] : -# 178| r0_35(int *) = Load : r0_34, mu0_1 -# 178| r0_36(glval) = VariableAddress[i] : -# 178| r0_37(int) = Load : r0_36, mu0_1 -# 178| r0_38(int *) = PointerAdd[4] : r0_35, r0_37 -# 178| mu0_39(int) = Store : r0_38, r0_33 -# 180| r0_40(glval) = VariableAddress[a] : -# 180| mu0_41(int[10]) = Uninitialized : r0_40 -# 181| r0_42(glval) = VariableAddress[a] : -# 181| r0_43(int *) = Convert : r0_42 -# 181| r0_44(glval) = VariableAddress[i] : -# 181| r0_45(int) = Load : r0_44, mu0_1 -# 181| r0_46(int *) = PointerAdd[4] : r0_43, r0_45 -# 181| r0_47(int) = Load : r0_46, mu0_1 -# 181| r0_48(glval) = VariableAddress[x] : -# 181| mu0_49(int) = Store : r0_48, r0_47 -# 182| r0_50(glval) = VariableAddress[a] : -# 182| r0_51(int *) = Convert : r0_50 -# 182| r0_52(glval) = VariableAddress[i] : -# 182| r0_53(int) = Load : r0_52, mu0_1 -# 182| r0_54(int *) = PointerAdd[4] : r0_51, r0_53 -# 182| r0_55(int) = Load : r0_54, mu0_1 -# 182| r0_56(glval) = VariableAddress[x] : -# 182| mu0_57(int) = Store : r0_56, r0_55 -# 183| r0_58(glval) = VariableAddress[x] : -# 183| r0_59(int) = Load : r0_58, mu0_1 -# 183| r0_60(glval) = VariableAddress[a] : -# 183| r0_61(int *) = Convert : r0_60 -# 183| r0_62(glval) = VariableAddress[i] : -# 183| r0_63(int) = Load : r0_62, mu0_1 -# 183| r0_64(int *) = PointerAdd[4] : r0_61, r0_63 -# 183| mu0_65(int) = Store : r0_64, r0_59 -# 184| r0_66(glval) = VariableAddress[x] : -# 184| r0_67(int) = Load : r0_66, mu0_1 -# 184| r0_68(glval) = VariableAddress[a] : -# 184| r0_69(int *) = Convert : r0_68 -# 184| r0_70(glval) = VariableAddress[i] : -# 184| r0_71(int) = Load : r0_70, mu0_1 -# 184| r0_72(int *) = PointerAdd[4] : r0_69, r0_71 -# 184| mu0_73(int) = Store : r0_72, r0_67 -# 185| v0_74(void) = NoOp : -# 171| v0_75(void) = ReturnVoid : -# 171| v0_76(void) = UnmodeledUse : mu* -# 171| v0_77(void) = ExitFunction : +# 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 : 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(int *) = 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(int *) = 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(int *) = 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(int *) = 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 : 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(int *) = 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(int *) = 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(int *) = 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(int *) = 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) = ExitFunction : # 187| StringLiteral(int) -> void # 187| Block 0 # 187| v0_0(void) = EnterFunction : -# 187| mu0_1(unknown) = UnmodeledDefinition : -# 187| r0_2(glval) = VariableAddress[i] : -# 187| mu0_3(int) = InitializeParameter[i] : r0_2 -# 188| r0_4(glval) = VariableAddress[c] : -# 188| r0_5(glval) = StringConstant["Foo"] : -# 188| r0_6(char *) = Convert : r0_5 -# 188| r0_7(glval) = VariableAddress[i] : -# 188| r0_8(int) = Load : r0_7, mu0_1 -# 188| r0_9(char *) = PointerAdd[1] : r0_6, r0_8 -# 188| r0_10(char) = Load : r0_9, mu0_1 -# 188| mu0_11(char) = Store : r0_4, r0_10 -# 189| r0_12(glval) = VariableAddress[pwc] : -# 189| r0_13(glval) = StringConstant[L"Bar"] : -# 189| r0_14(wchar_t *) = Convert : r0_13 +# 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(char *) = 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| mu0_16(wchar_t *) = Store : r0_12, r0_15 -# 190| r0_17(glval) = VariableAddress[wc] : -# 190| r0_18(glval) = VariableAddress[pwc] : -# 190| r0_19(wchar_t *) = Load : r0_18, mu0_1 -# 190| r0_20(glval) = VariableAddress[i] : -# 190| r0_21(int) = Load : r0_20, mu0_1 -# 190| r0_22(wchar_t *) = PointerAdd[4] : r0_19, r0_21 -# 190| r0_23(wchar_t) = Load : r0_22, mu0_1 -# 190| mu0_24(wchar_t) = Store : r0_17, r0_23 -# 191| v0_25(void) = NoOp : -# 187| v0_26(void) = ReturnVoid : -# 187| v0_27(void) = UnmodeledUse : mu* -# 187| v0_28(void) = ExitFunction : +# 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(wchar_t *) = 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) = ExitFunction : # 193| PointerCompare(int *, int *) -> void # 193| Block 0 # 193| v0_0(void) = EnterFunction : -# 193| mu0_1(unknown) = UnmodeledDefinition : -# 193| r0_2(glval) = VariableAddress[p] : -# 193| mu0_3(int *) = InitializeParameter[p] : r0_2 -# 193| r0_4(glval) = VariableAddress[q] : -# 193| mu0_5(int *) = InitializeParameter[q] : r0_4 -# 194| r0_6(glval) = VariableAddress[b] : -# 194| mu0_7(bool) = Uninitialized : r0_6 -# 196| r0_8(glval) = VariableAddress[p] : -# 196| r0_9(int *) = Load : r0_8, mu0_1 -# 196| r0_10(glval) = VariableAddress[q] : -# 196| r0_11(int *) = Load : r0_10, mu0_1 -# 196| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 196| r0_13(glval) = VariableAddress[b] : -# 196| mu0_14(bool) = Store : r0_13, r0_12 -# 197| r0_15(glval) = VariableAddress[p] : -# 197| r0_16(int *) = Load : r0_15, mu0_1 -# 197| r0_17(glval) = VariableAddress[q] : -# 197| r0_18(int *) = Load : r0_17, mu0_1 -# 197| r0_19(bool) = CompareNE : r0_16, r0_18 -# 197| r0_20(glval) = VariableAddress[b] : -# 197| mu0_21(bool) = Store : r0_20, r0_19 -# 198| r0_22(glval) = VariableAddress[p] : -# 198| r0_23(int *) = Load : r0_22, mu0_1 -# 198| r0_24(glval) = VariableAddress[q] : -# 198| r0_25(int *) = Load : r0_24, mu0_1 -# 198| r0_26(bool) = CompareLT : r0_23, r0_25 -# 198| r0_27(glval) = VariableAddress[b] : -# 198| mu0_28(bool) = Store : r0_27, r0_26 -# 199| r0_29(glval) = VariableAddress[p] : -# 199| r0_30(int *) = Load : r0_29, mu0_1 -# 199| r0_31(glval) = VariableAddress[q] : -# 199| r0_32(int *) = Load : r0_31, mu0_1 -# 199| r0_33(bool) = CompareGT : r0_30, r0_32 -# 199| r0_34(glval) = VariableAddress[b] : -# 199| mu0_35(bool) = Store : r0_34, r0_33 -# 200| r0_36(glval) = VariableAddress[p] : -# 200| r0_37(int *) = Load : r0_36, mu0_1 -# 200| r0_38(glval) = VariableAddress[q] : -# 200| r0_39(int *) = Load : r0_38, mu0_1 -# 200| r0_40(bool) = CompareLE : r0_37, r0_39 -# 200| r0_41(glval) = VariableAddress[b] : -# 200| mu0_42(bool) = Store : r0_41, r0_40 -# 201| r0_43(glval) = VariableAddress[p] : -# 201| r0_44(int *) = Load : r0_43, mu0_1 -# 201| r0_45(glval) = VariableAddress[q] : -# 201| r0_46(int *) = Load : r0_45, mu0_1 -# 201| r0_47(bool) = CompareGE : r0_44, r0_46 -# 201| r0_48(glval) = VariableAddress[b] : -# 201| mu0_49(bool) = Store : r0_48, r0_47 -# 202| v0_50(void) = NoOp : -# 193| v0_51(void) = ReturnVoid : -# 193| v0_52(void) = UnmodeledUse : mu* -# 193| v0_53(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 204| PointerCrement(int *) -> void # 204| Block 0 # 204| v0_0(void) = EnterFunction : -# 204| mu0_1(unknown) = UnmodeledDefinition : -# 204| r0_2(glval) = VariableAddress[p] : -# 204| mu0_3(int *) = InitializeParameter[p] : r0_2 -# 205| r0_4(glval) = VariableAddress[q] : -# 205| mu0_5(int *) = Uninitialized : r0_4 -# 207| r0_6(glval) = VariableAddress[p] : -# 207| r0_7(int *) = Load : r0_6, mu0_1 -# 207| r0_8(int) = Constant[1] : -# 207| r0_9(int *) = PointerAdd[4] : r0_7, r0_8 -# 207| mu0_10(int *) = Store : r0_6, r0_9 -# 207| r0_11(glval) = VariableAddress[q] : -# 207| mu0_12(int *) = Store : r0_11, r0_9 -# 208| r0_13(glval) = VariableAddress[p] : -# 208| r0_14(int *) = Load : r0_13, mu0_1 -# 208| r0_15(int) = Constant[1] : -# 208| r0_16(int *) = PointerSub[4] : r0_14, r0_15 -# 208| mu0_17(int *) = Store : r0_13, r0_16 -# 208| r0_18(glval) = VariableAddress[q] : -# 208| mu0_19(int *) = Store : r0_18, r0_16 -# 209| r0_20(glval) = VariableAddress[p] : -# 209| r0_21(int *) = Load : r0_20, mu0_1 -# 209| r0_22(int) = Constant[1] : -# 209| r0_23(int *) = PointerAdd[4] : r0_21, r0_22 -# 209| mu0_24(int *) = Store : r0_20, r0_23 -# 209| r0_25(glval) = VariableAddress[q] : -# 209| mu0_26(int *) = Store : r0_25, r0_21 -# 210| r0_27(glval) = VariableAddress[p] : -# 210| r0_28(int *) = Load : r0_27, mu0_1 -# 210| r0_29(int) = Constant[1] : -# 210| r0_30(int *) = PointerSub[4] : r0_28, r0_29 -# 210| mu0_31(int *) = Store : r0_27, r0_30 -# 210| r0_32(glval) = VariableAddress[q] : -# 210| mu0_33(int *) = Store : r0_32, r0_28 -# 211| v0_34(void) = NoOp : -# 204| v0_35(void) = ReturnVoid : -# 204| v0_36(void) = UnmodeledUse : mu* -# 204| v0_37(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 213| CompoundAssignment() -> void # 213| Block 0 # 213| v0_0(void) = EnterFunction : -# 213| mu0_1(unknown) = UnmodeledDefinition : -# 215| r0_2(glval) = VariableAddress[x] : -# 215| r0_3(int) = Constant[5] : -# 215| mu0_4(int) = Store : r0_2, r0_3 -# 216| r0_5(int) = Constant[7] : -# 216| r0_6(glval) = VariableAddress[x] : -# 216| r0_7(int) = Load : r0_6, mu0_1 -# 216| r0_8(int) = Add : r0_7, r0_5 -# 216| mu0_9(int) = Store : r0_6, r0_8 -# 219| r0_10(glval) = VariableAddress[y] : -# 219| r0_11(short) = Constant[5] : -# 219| mu0_12(short) = Store : r0_10, r0_11 -# 220| r0_13(glval) = VariableAddress[x] : -# 220| r0_14(int) = Load : r0_13, mu0_1 -# 220| r0_15(glval) = VariableAddress[y] : -# 220| r0_16(short) = Load : r0_15, mu0_1 -# 220| r0_17(int) = Convert : r0_16 -# 220| r0_18(int) = Add : r0_17, r0_14 -# 220| r0_19(short) = Convert : r0_18 -# 220| mu0_20(short) = Store : r0_15, r0_19 -# 223| r0_21(int) = Constant[1] : -# 223| r0_22(glval) = VariableAddress[y] : -# 223| r0_23(short) = Load : r0_22, mu0_1 -# 223| r0_24(short) = ShiftLeft : r0_23, r0_21 -# 223| mu0_25(short) = Store : r0_22, r0_24 -# 226| r0_26(glval) = VariableAddress[z] : -# 226| r0_27(long) = Constant[7] : -# 226| mu0_28(long) = Store : r0_26, r0_27 -# 227| r0_29(float) = Constant[2.0] : -# 227| r0_30(glval) = VariableAddress[z] : -# 227| r0_31(long) = Load : r0_30, mu0_1 -# 227| r0_32(float) = Convert : r0_31 -# 227| r0_33(float) = Add : r0_32, r0_29 -# 227| r0_34(long) = Convert : r0_33 -# 227| mu0_35(long) = Store : r0_30, r0_34 -# 228| v0_36(void) = NoOp : -# 213| v0_37(void) = ReturnVoid : -# 213| v0_38(void) = UnmodeledUse : mu* -# 213| v0_39(void) = ExitFunction : +# 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) = ExitFunction : # 230| UninitializedVariables() -> void # 230| Block 0 # 230| v0_0(void) = EnterFunction : -# 230| mu0_1(unknown) = UnmodeledDefinition : -# 231| r0_2(glval) = VariableAddress[x] : -# 231| mu0_3(int) = Uninitialized : r0_2 -# 232| r0_4(glval) = VariableAddress[y] : -# 232| r0_5(glval) = VariableAddress[x] : -# 232| r0_6(int) = Load : r0_5, mu0_1 -# 232| mu0_7(int) = Store : r0_4, r0_6 -# 233| v0_8(void) = NoOp : -# 230| v0_9(void) = ReturnVoid : -# 230| v0_10(void) = UnmodeledUse : mu* -# 230| v0_11(void) = ExitFunction : +# 230| mu0_1(unknown) = AliasedDefinition : +# 230| mu0_2(unknown) = UnmodeledDefinition : +# 231| r0_3(glval) = VariableAddress[x] : +# 231| mu0_4(int) = Uninitialized : 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) = ExitFunction : # 235| Parameters(int, int) -> int # 235| Block 0 # 235| v0_0(void) = EnterFunction : -# 235| mu0_1(unknown) = UnmodeledDefinition : -# 235| r0_2(glval) = VariableAddress[x] : -# 235| mu0_3(int) = InitializeParameter[x] : r0_2 -# 235| r0_4(glval) = VariableAddress[y] : -# 235| mu0_5(int) = InitializeParameter[y] : r0_4 -# 236| r0_6(glval) = VariableAddress[#return] : -# 236| r0_7(glval) = VariableAddress[x] : -# 236| r0_8(int) = Load : r0_7, mu0_1 -# 236| r0_9(glval) = VariableAddress[y] : -# 236| r0_10(int) = Load : r0_9, mu0_1 -# 236| r0_11(int) = Rem : r0_8, r0_10 -# 236| mu0_12(int) = Store : r0_6, r0_11 -# 235| r0_13(glval) = VariableAddress[#return] : -# 235| v0_14(void) = ReturnValue : r0_13, mu0_1 -# 235| v0_15(void) = UnmodeledUse : mu* -# 235| v0_16(void) = ExitFunction : +# 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) = ExitFunction : # 239| IfStatements(bool, int, int) -> void # 239| Block 0 # 239| v0_0(void) = EnterFunction : -# 239| mu0_1(unknown) = UnmodeledDefinition : -# 239| r0_2(glval) = VariableAddress[b] : -# 239| mu0_3(bool) = InitializeParameter[b] : r0_2 -# 239| r0_4(glval) = VariableAddress[x] : -# 239| mu0_5(int) = InitializeParameter[x] : r0_4 -# 239| r0_6(glval) = VariableAddress[y] : -# 239| mu0_7(int) = InitializeParameter[y] : r0_6 -# 240| r0_8(glval) = VariableAddress[b] : -# 240| r0_9(bool) = Load : r0_8, mu0_1 -# 240| v0_10(void) = ConditionalBranch : r0_9 +# 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 #-----| False -> Block 1 #-----| True -> Block 7 # 243| Block 1 # 243| r1_0(glval) = VariableAddress[b] : -# 243| r1_1(bool) = Load : r1_0, mu0_1 +# 243| r1_1(bool) = Load : r1_0, mu0_2 # 243| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 # 244| Block 2 # 244| r2_0(glval) = VariableAddress[y] : -# 244| r2_1(int) = Load : r2_0, mu0_1 +# 244| r2_1(int) = Load : r2_0, mu0_2 # 244| r2_2(glval) = VariableAddress[x] : # 244| mu2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 # 247| Block 3 # 247| r3_0(glval) = VariableAddress[x] : -# 247| r3_1(int) = Load : r3_0, mu0_1 +# 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 @@ -1074,15 +1096,16 @@ ir.cpp: # 253| WhileStatements(int) -> void # 253| Block 0 # 253| v0_0(void) = EnterFunction : -# 253| mu0_1(unknown) = UnmodeledDefinition : -# 253| r0_2(glval) = VariableAddress[n] : -# 253| mu0_3(int) = InitializeParameter[n] : r0_2 +# 253| mu0_1(unknown) = AliasedDefinition : +# 253| mu0_2(unknown) = UnmodeledDefinition : +# 253| r0_3(glval) = VariableAddress[n] : +# 253| mu0_4(int) = InitializeParameter[n] : r0_3 #-----| 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_1 +# 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 #-----| Goto -> Block 3 @@ -1095,7 +1118,7 @@ ir.cpp: # 254| Block 3 # 254| r3_0(glval) = VariableAddress[n] : -# 254| r3_1(int) = Load : r3_0, mu0_1 +# 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 @@ -1105,19 +1128,20 @@ ir.cpp: # 259| DoStatements(int) -> void # 259| Block 0 # 259| v0_0(void) = EnterFunction : -# 259| mu0_1(unknown) = UnmodeledDefinition : -# 259| r0_2(glval) = VariableAddress[n] : -# 259| mu0_3(int) = InitializeParameter[n] : r0_2 +# 259| mu0_1(unknown) = AliasedDefinition : +# 259| mu0_2(unknown) = UnmodeledDefinition : +# 259| r0_3(glval) = VariableAddress[n] : +# 259| mu0_4(int) = InitializeParameter[n] : r0_3 #-----| 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_1 +# 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_1 +# 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 @@ -1133,9 +1157,10 @@ ir.cpp: # 265| For_Empty() -> void # 265| Block 0 # 265| v0_0(void) = EnterFunction : -# 265| mu0_1(unknown) = UnmodeledDefinition : -# 266| r0_2(glval) = VariableAddress[j] : -# 266| mu0_3(int) = Uninitialized : r0_2 +# 265| mu0_1(unknown) = AliasedDefinition : +# 265| mu0_2(unknown) = UnmodeledDefinition : +# 266| r0_3(glval) = VariableAddress[j] : +# 266| mu0_4(int) = Uninitialized : r0_3 #-----| Goto -> Block 2 # 265| Block 1 @@ -1150,10 +1175,11 @@ ir.cpp: # 272| For_Init() -> void # 272| Block 0 # 272| v0_0(void) = EnterFunction : -# 272| mu0_1(unknown) = UnmodeledDefinition : -# 273| r0_2(glval) = VariableAddress[i] : -# 273| r0_3(int) = Constant[0] : -# 273| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 2 # 272| Block 1 @@ -1168,15 +1194,16 @@ ir.cpp: # 278| For_Condition() -> void # 278| Block 0 # 278| v0_0(void) = EnterFunction : -# 278| mu0_1(unknown) = UnmodeledDefinition : -# 279| r0_2(glval) = VariableAddress[i] : -# 279| r0_3(int) = Constant[0] : -# 279| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 280| Block 1 # 280| r1_0(glval) = VariableAddress[i] : -# 280| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1196,10 +1223,11 @@ ir.cpp: # 285| For_Update() -> void # 285| Block 0 # 285| v0_0(void) = EnterFunction : -# 285| mu0_1(unknown) = UnmodeledDefinition : -# 286| r0_2(glval) = VariableAddress[i] : -# 286| r0_3(int) = Constant[0] : -# 286| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 2 # 285| Block 1 @@ -1211,7 +1239,7 @@ ir.cpp: # 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_1 +# 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 #-----| Goto -> Block 2 @@ -1219,15 +1247,16 @@ ir.cpp: # 292| For_InitCondition() -> void # 292| Block 0 # 292| v0_0(void) = EnterFunction : -# 292| mu0_1(unknown) = UnmodeledDefinition : -# 293| r0_2(glval) = VariableAddress[i] : -# 293| r0_3(int) = Constant[0] : -# 293| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 293| Block 1 # 293| r1_0(glval) = VariableAddress[i] : -# 293| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1247,10 +1276,11 @@ ir.cpp: # 298| For_InitUpdate() -> void # 298| Block 0 # 298| v0_0(void) = EnterFunction : -# 298| mu0_1(unknown) = UnmodeledDefinition : -# 299| r0_2(glval) = VariableAddress[i] : -# 299| r0_3(int) = Constant[0] : -# 299| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 2 # 298| Block 1 @@ -1262,7 +1292,7 @@ ir.cpp: # 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_1 +# 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 #-----| Goto -> Block 2 @@ -1270,15 +1300,16 @@ ir.cpp: # 304| For_ConditionUpdate() -> void # 304| Block 0 # 304| v0_0(void) = EnterFunction : -# 304| mu0_1(unknown) = UnmodeledDefinition : -# 305| r0_2(glval) = VariableAddress[i] : -# 305| r0_3(int) = Constant[0] : -# 305| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 306| Block 1 # 306| r1_0(glval) = VariableAddress[i] : -# 306| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1289,7 +1320,7 @@ ir.cpp: # 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_1 +# 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 #-----| Goto -> Block 1 @@ -1303,15 +1334,16 @@ ir.cpp: # 311| For_InitConditionUpdate() -> void # 311| Block 0 # 311| v0_0(void) = EnterFunction : -# 311| mu0_1(unknown) = UnmodeledDefinition : -# 312| r0_2(glval) = VariableAddress[i] : -# 312| r0_3(int) = Constant[0] : -# 312| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 312| Block 1 # 312| r1_0(glval) = VariableAddress[i] : -# 312| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1322,7 +1354,7 @@ ir.cpp: # 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_1 +# 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 #-----| Goto -> Block 1 @@ -1336,15 +1368,16 @@ ir.cpp: # 317| For_Break() -> void # 317| Block 0 # 317| v0_0(void) = EnterFunction : -# 317| mu0_1(unknown) = UnmodeledDefinition : -# 318| r0_2(glval) = VariableAddress[i] : -# 318| r0_3(int) = Constant[0] : -# 318| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 318| Block 1 # 318| r1_0(glval) = VariableAddress[i] : -# 318| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1354,14 +1387,14 @@ ir.cpp: # 318| Block 2 # 318| r2_0(int) = Constant[1] : # 318| r2_1(glval) = VariableAddress[i] : -# 318| r2_2(int) = Load : r2_1, mu0_1 +# 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 #-----| Goto -> Block 1 # 319| Block 3 # 319| r3_0(glval) = VariableAddress[i] : -# 319| r3_1(int) = Load : r3_0, mu0_1 +# 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 @@ -1382,15 +1415,16 @@ ir.cpp: # 325| For_Continue_Update() -> void # 325| Block 0 # 325| v0_0(void) = EnterFunction : -# 325| mu0_1(unknown) = UnmodeledDefinition : -# 326| r0_2(glval) = VariableAddress[i] : -# 326| r0_3(int) = Constant[0] : -# 326| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 326| Block 1 # 326| r1_0(glval) = VariableAddress[i] : -# 326| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1399,7 +1433,7 @@ ir.cpp: # 327| Block 2 # 327| r2_0(glval) = VariableAddress[i] : -# 327| r2_1(int) = Load : r2_0, mu0_1 +# 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 @@ -1414,7 +1448,7 @@ ir.cpp: # 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_1 +# 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 #-----| Goto -> Block 1 @@ -1428,15 +1462,16 @@ ir.cpp: # 333| For_Continue_NoUpdate() -> void # 333| Block 0 # 333| v0_0(void) = EnterFunction : -# 333| mu0_1(unknown) = UnmodeledDefinition : -# 334| r0_2(glval) = VariableAddress[i] : -# 334| r0_3(int) = Constant[0] : -# 334| mu0_4(int) = Store : r0_2, r0_3 +# 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 #-----| Goto -> Block 1 # 334| Block 1 # 334| r1_0(glval) = VariableAddress[i] : -# 334| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1445,7 +1480,7 @@ ir.cpp: # 335| Block 2 # 335| r2_0(glval) = VariableAddress[i] : -# 335| r2_1(int) = Load : r2_0, mu0_1 +# 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 @@ -1468,47 +1503,50 @@ ir.cpp: # 341| Dereference(int *) -> int # 341| Block 0 -# 341| v0_0(void) = EnterFunction : -# 341| mu0_1(unknown) = UnmodeledDefinition : -# 341| r0_2(glval) = VariableAddress[p] : -# 341| mu0_3(int *) = InitializeParameter[p] : r0_2 -# 342| r0_4(int) = Constant[1] : -# 342| r0_5(glval) = VariableAddress[p] : -# 342| r0_6(int *) = Load : r0_5, mu0_1 -# 342| mu0_7(int) = Store : r0_6, r0_4 -# 343| r0_8(glval) = VariableAddress[#return] : -# 343| r0_9(glval) = VariableAddress[p] : -# 343| r0_10(int *) = Load : r0_9, mu0_1 -# 343| r0_11(int) = Load : r0_10, mu0_1 -# 343| mu0_12(int) = Store : r0_8, r0_11 -# 341| r0_13(glval) = VariableAddress[#return] : -# 341| v0_14(void) = ReturnValue : r0_13, mu0_1 -# 341| v0_15(void) = UnmodeledUse : mu* -# 341| v0_16(void) = ExitFunction : +# 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| mu0_8(int) = Store : r0_7, r0_5 +# 343| r0_9(glval) = VariableAddress[#return] : +# 343| r0_10(glval) = VariableAddress[p] : +# 343| r0_11(int *) = Load : r0_10, mu0_2 +# 343| r0_12(int) = Load : r0_11, mu0_2 +# 343| mu0_13(int) = Store : r0_9, r0_12 +# 341| r0_14(glval) = VariableAddress[#return] : +# 341| v0_15(void) = ReturnValue : r0_14, mu0_2 +# 341| v0_16(void) = UnmodeledUse : mu* +# 341| v0_17(void) = ExitFunction : # 348| AddressOf() -> int * # 348| Block 0 # 348| v0_0(void) = EnterFunction : -# 348| mu0_1(unknown) = UnmodeledDefinition : -# 349| r0_2(glval) = VariableAddress[#return] : -# 349| r0_3(glval) = VariableAddress[g] : -# 349| mu0_4(int *) = Store : r0_2, r0_3 -# 348| r0_5(glval) = VariableAddress[#return] : -# 348| v0_6(void) = ReturnValue : r0_5, mu0_1 -# 348| v0_7(void) = UnmodeledUse : mu* -# 348| v0_8(void) = ExitFunction : +# 348| mu0_1(unknown) = AliasedDefinition : +# 348| mu0_2(unknown) = UnmodeledDefinition : +# 349| r0_3(glval) = VariableAddress[#return] : +# 349| r0_4(glval) = VariableAddress[g] : +# 349| mu0_5(int *) = Store : r0_3, r0_4 +# 348| r0_6(glval) = VariableAddress[#return] : +# 348| v0_7(void) = ReturnValue : r0_6, mu0_2 +# 348| v0_8(void) = UnmodeledUse : mu* +# 348| v0_9(void) = ExitFunction : # 352| Break(int) -> void # 352| Block 0 # 352| v0_0(void) = EnterFunction : -# 352| mu0_1(unknown) = UnmodeledDefinition : -# 352| r0_2(glval) = VariableAddress[n] : -# 352| mu0_3(int) = InitializeParameter[n] : r0_2 +# 352| mu0_1(unknown) = AliasedDefinition : +# 352| mu0_2(unknown) = UnmodeledDefinition : +# 352| r0_3(glval) = VariableAddress[n] : +# 352| mu0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 5 # 354| Block 1 # 354| r1_0(glval) = VariableAddress[n] : -# 354| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1522,7 +1560,7 @@ ir.cpp: # 356| Block 3 # 356| r3_0(int) = Constant[1] : # 356| r3_1(glval) = VariableAddress[n] : -# 356| r3_2(int) = Load : r3_1, mu0_1 +# 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 #-----| Goto -> Block 5 @@ -1536,7 +1574,7 @@ ir.cpp: # 353| Block 5 # 353| r5_0(glval) = VariableAddress[n] : -# 353| r5_1(int) = Load : r5_0, mu0_1 +# 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 @@ -1546,14 +1584,15 @@ ir.cpp: # 360| Continue(int) -> void # 360| Block 0 # 360| v0_0(void) = EnterFunction : -# 360| mu0_1(unknown) = UnmodeledDefinition : -# 360| r0_2(glval) = VariableAddress[n] : -# 360| mu0_3(int) = InitializeParameter[n] : r0_2 +# 360| mu0_1(unknown) = AliasedDefinition : +# 360| mu0_2(unknown) = UnmodeledDefinition : +# 360| r0_3(glval) = VariableAddress[n] : +# 360| mu0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 1 # 362| Block 1 # 362| r1_0(glval) = VariableAddress[n] : -# 362| r1_1(int) = Load : r1_0, mu0_1 +# 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 @@ -1567,7 +1606,7 @@ ir.cpp: # 365| Block 3 # 365| r3_0(int) = Constant[1] : # 365| r3_1(glval) = VariableAddress[n] : -# 365| r3_2(int) = Load : r3_1, mu0_1 +# 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 #-----| Goto -> Block 4 @@ -1575,7 +1614,7 @@ ir.cpp: # 361| Block 4 # 361| v4_0(void) = NoOp : # 366| r4_1(glval) = VariableAddress[n] : -# 366| r4_2(int) = Load : r4_1, mu0_1 +# 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 @@ -1591,69 +1630,77 @@ ir.cpp: # 372| Call() -> void # 372| Block 0 # 372| v0_0(void) = EnterFunction : -# 372| mu0_1(unknown) = UnmodeledDefinition : -# 373| r0_2(glval) = FunctionAddress[VoidFunc] : -# 373| v0_3(void) = Call : r0_2 -# 374| v0_4(void) = NoOp : -# 372| v0_5(void) = ReturnVoid : -# 372| v0_6(void) = UnmodeledUse : mu* -# 372| v0_7(void) = ExitFunction : +# 372| mu0_1(unknown) = AliasedDefinition : +# 372| mu0_2(unknown) = UnmodeledDefinition : +# 373| r0_3(glval) = FunctionAddress[VoidFunc] : +# 373| v0_4(void) = Call : 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) = ExitFunction : # 376| CallAdd(int, int) -> int # 376| Block 0 # 376| v0_0(void) = EnterFunction : -# 376| mu0_1(unknown) = UnmodeledDefinition : -# 376| r0_2(glval) = VariableAddress[x] : -# 376| mu0_3(int) = InitializeParameter[x] : r0_2 -# 376| r0_4(glval) = VariableAddress[y] : -# 376| mu0_5(int) = InitializeParameter[y] : r0_4 -# 377| r0_6(glval) = VariableAddress[#return] : -# 377| r0_7(glval) = FunctionAddress[Add] : -# 377| r0_8(glval) = VariableAddress[x] : -# 377| r0_9(int) = Load : r0_8, mu0_1 -# 377| r0_10(glval) = VariableAddress[y] : -# 377| r0_11(int) = Load : r0_10, mu0_1 -# 377| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 377| mu0_13(int) = Store : r0_6, r0_12 -# 376| r0_14(glval) = VariableAddress[#return] : -# 376| v0_15(void) = ReturnValue : r0_14, mu0_1 -# 376| v0_16(void) = UnmodeledUse : mu* -# 376| v0_17(void) = ExitFunction : +# 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 : r0_8, r0_10, 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) = ExitFunction : # 380| Comma(int, int) -> int # 380| Block 0 -# 380| v0_0(void) = EnterFunction : -# 380| mu0_1(unknown) = UnmodeledDefinition : -# 380| r0_2(glval) = VariableAddress[x] : -# 380| mu0_3(int) = InitializeParameter[x] : r0_2 -# 380| r0_4(glval) = VariableAddress[y] : -# 380| mu0_5(int) = InitializeParameter[y] : r0_4 -# 381| r0_6(glval) = VariableAddress[#return] : -# 381| r0_7(glval) = FunctionAddress[VoidFunc] : -# 381| v0_8(void) = Call : r0_7 -# 381| r0_9(glval) = FunctionAddress[CallAdd] : -# 381| r0_10(glval) = VariableAddress[x] : -# 381| r0_11(int) = Load : r0_10, mu0_1 -# 381| r0_12(glval) = VariableAddress[y] : -# 381| r0_13(int) = Load : r0_12, mu0_1 -# 381| r0_14(int) = Call : r0_9, r0_11, r0_13 -# 381| mu0_15(int) = Store : r0_6, r0_14 -# 380| r0_16(glval) = VariableAddress[#return] : -# 380| v0_17(void) = ReturnValue : r0_16, mu0_1 -# 380| v0_18(void) = UnmodeledUse : mu* -# 380| v0_19(void) = ExitFunction : +# 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 : 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 : r0_11, r0_13, r0_15 +# 381| mu0_17(unknown) = ^CallSideEffect : mu0_2 +# 381| mu0_18(int) = Store : r0_7, r0_16 +# 380| r0_19(glval) = VariableAddress[#return] : +# 380| v0_20(void) = ReturnValue : r0_19, mu0_2 +# 380| v0_21(void) = UnmodeledUse : mu* +# 380| v0_22(void) = ExitFunction : # 384| Switch(int) -> void # 384| Block 0 # 384| v0_0(void) = EnterFunction : -# 384| mu0_1(unknown) = UnmodeledDefinition : -# 384| r0_2(glval) = VariableAddress[x] : -# 384| mu0_3(int) = InitializeParameter[x] : r0_2 -# 385| r0_4(glval) = VariableAddress[y] : -# 385| mu0_5(int) = Uninitialized : r0_4 -# 386| r0_6(glval) = VariableAddress[x] : -# 386| r0_7(int) = Load : r0_6, mu0_1 -# 386| v0_8(void) = Switch : r0_7 +# 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 : r0_5 +# 386| r0_7(glval) = VariableAddress[x] : +# 386| r0_8(int) = Load : r0_7, mu0_2 +# 386| v0_9(void) = Switch : r0_8 #-----| Case[-1] -> Block 2 #-----| Case[1] -> Block 3 #-----| Case[2] -> Block 4 @@ -1726,62 +1773,65 @@ ir.cpp: # 422| ReturnStruct(Point) -> Point # 422| Block 0 # 422| v0_0(void) = EnterFunction : -# 422| mu0_1(unknown) = UnmodeledDefinition : -# 422| r0_2(glval) = VariableAddress[pt] : -# 422| mu0_3(Point) = InitializeParameter[pt] : r0_2 -# 423| r0_4(glval) = VariableAddress[#return] : -# 423| r0_5(glval) = VariableAddress[pt] : -# 423| r0_6(Point) = Load : r0_5, mu0_1 -# 423| mu0_7(Point) = Store : r0_4, r0_6 -# 422| r0_8(glval) = VariableAddress[#return] : -# 422| v0_9(void) = ReturnValue : r0_8, mu0_1 -# 422| v0_10(void) = UnmodeledUse : mu* -# 422| v0_11(void) = ExitFunction : +# 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) = ExitFunction : # 426| FieldAccess() -> void # 426| Block 0 # 426| v0_0(void) = EnterFunction : -# 426| mu0_1(unknown) = UnmodeledDefinition : -# 427| r0_2(glval) = VariableAddress[pt] : -# 427| mu0_3(Point) = Uninitialized : r0_2 -# 428| r0_4(int) = Constant[5] : -# 428| r0_5(glval) = VariableAddress[pt] : -# 428| r0_6(glval) = FieldAddress[x] : r0_5 -# 428| mu0_7(int) = Store : r0_6, r0_4 -# 429| r0_8(glval) = VariableAddress[pt] : -# 429| r0_9(glval) = FieldAddress[x] : r0_8 -# 429| r0_10(int) = Load : r0_9, mu0_1 -# 429| r0_11(glval) = VariableAddress[pt] : -# 429| r0_12(glval) = FieldAddress[y] : r0_11 -# 429| mu0_13(int) = Store : r0_12, r0_10 -# 430| r0_14(glval) = VariableAddress[p] : -# 430| r0_15(glval) = VariableAddress[pt] : -# 430| r0_16(glval) = FieldAddress[y] : r0_15 -# 430| mu0_17(int *) = Store : r0_14, r0_16 -# 431| v0_18(void) = NoOp : -# 426| v0_19(void) = ReturnVoid : -# 426| v0_20(void) = UnmodeledUse : mu* -# 426| v0_21(void) = ExitFunction : +# 426| mu0_1(unknown) = AliasedDefinition : +# 426| mu0_2(unknown) = UnmodeledDefinition : +# 427| r0_3(glval) = VariableAddress[pt] : +# 427| mu0_4(Point) = Uninitialized : 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| mu0_18(int *) = Store : r0_15, r0_17 +# 431| v0_19(void) = NoOp : +# 426| v0_20(void) = ReturnVoid : +# 426| v0_21(void) = UnmodeledUse : mu* +# 426| v0_22(void) = ExitFunction : # 433| LogicalOr(bool, bool) -> void # 433| Block 0 # 433| v0_0(void) = EnterFunction : -# 433| mu0_1(unknown) = UnmodeledDefinition : -# 433| r0_2(glval) = VariableAddress[a] : -# 433| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 433| r0_4(glval) = VariableAddress[b] : -# 433| mu0_5(bool) = InitializeParameter[b] : r0_4 -# 434| r0_6(glval) = VariableAddress[x] : -# 434| mu0_7(int) = Uninitialized : r0_6 -# 435| r0_8(glval) = VariableAddress[a] : -# 435| r0_9(bool) = Load : r0_8, mu0_1 -# 435| v0_10(void) = ConditionalBranch : r0_9 +# 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 : r0_7 +# 435| r0_9(glval) = VariableAddress[a] : +# 435| r0_10(bool) = Load : r0_9, mu0_2 +# 435| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 # 435| Block 1 # 435| r1_0(glval) = VariableAddress[b] : -# 435| r1_1(bool) = Load : r1_0, mu0_1 +# 435| r1_1(bool) = Load : r1_0, mu0_2 # 435| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1794,14 +1844,14 @@ ir.cpp: # 439| Block 3 # 439| r3_0(glval) = VariableAddress[a] : -# 439| r3_1(bool) = Load : r3_0, mu0_1 +# 439| r3_1(bool) = Load : r3_0, mu0_2 # 439| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 # 439| Block 4 # 439| r4_0(glval) = VariableAddress[b] : -# 439| r4_1(bool) = Load : r4_0, mu0_1 +# 439| r4_1(bool) = Load : r4_0, mu0_2 # 439| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1827,22 +1877,23 @@ ir.cpp: # 447| LogicalAnd(bool, bool) -> void # 447| Block 0 # 447| v0_0(void) = EnterFunction : -# 447| mu0_1(unknown) = UnmodeledDefinition : -# 447| r0_2(glval) = VariableAddress[a] : -# 447| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 447| r0_4(glval) = VariableAddress[b] : -# 447| mu0_5(bool) = InitializeParameter[b] : r0_4 -# 448| r0_6(glval) = VariableAddress[x] : -# 448| mu0_7(int) = Uninitialized : r0_6 -# 449| r0_8(glval) = VariableAddress[a] : -# 449| r0_9(bool) = Load : r0_8, mu0_1 -# 449| v0_10(void) = ConditionalBranch : r0_9 +# 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 : r0_7 +# 449| r0_9(glval) = VariableAddress[a] : +# 449| r0_10(bool) = Load : r0_9, mu0_2 +# 449| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 3 #-----| True -> Block 1 # 449| Block 1 # 449| r1_0(glval) = VariableAddress[b] : -# 449| r1_1(bool) = Load : r1_0, mu0_1 +# 449| r1_1(bool) = Load : r1_0, mu0_2 # 449| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1855,14 +1906,14 @@ ir.cpp: # 453| Block 3 # 453| r3_0(glval) = VariableAddress[a] : -# 453| r3_1(bool) = Load : r3_0, mu0_1 +# 453| r3_1(bool) = Load : r3_0, mu0_2 # 453| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 6 #-----| True -> Block 4 # 453| Block 4 # 453| r4_0(glval) = VariableAddress[b] : -# 453| r4_1(bool) = Load : r4_0, mu0_1 +# 453| r4_1(bool) = Load : r4_0, mu0_2 # 453| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1888,16 +1939,17 @@ ir.cpp: # 461| LogicalNot(bool, bool) -> void # 461| Block 0 # 461| v0_0(void) = EnterFunction : -# 461| mu0_1(unknown) = UnmodeledDefinition : -# 461| r0_2(glval) = VariableAddress[a] : -# 461| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 461| r0_4(glval) = VariableAddress[b] : -# 461| mu0_5(bool) = InitializeParameter[b] : r0_4 -# 462| r0_6(glval) = VariableAddress[x] : -# 462| mu0_7(int) = Uninitialized : r0_6 -# 463| r0_8(glval) = VariableAddress[a] : -# 463| r0_9(bool) = Load : r0_8, mu0_1 -# 463| v0_10(void) = ConditionalBranch : r0_9 +# 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 : r0_7 +# 463| r0_9(glval) = VariableAddress[a] : +# 463| r0_10(bool) = Load : r0_9, mu0_2 +# 463| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 @@ -1909,14 +1961,14 @@ ir.cpp: # 467| Block 2 # 467| r2_0(glval) = VariableAddress[a] : -# 467| r2_1(bool) = Load : r2_0, mu0_1 +# 467| r2_1(bool) = Load : r2_0, mu0_2 # 467| v2_2(void) = ConditionalBranch : r2_1 #-----| False -> Block 4 #-----| True -> Block 3 # 467| Block 3 # 467| r3_0(glval) = VariableAddress[b] : -# 467| r3_1(bool) = Load : r3_0, mu0_1 +# 467| r3_1(bool) = Load : r3_0, mu0_2 # 467| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 @@ -1942,22 +1994,23 @@ ir.cpp: # 475| ConditionValues(bool, bool) -> void # 475| Block 0 # 475| v0_0(void) = EnterFunction : -# 475| mu0_1(unknown) = UnmodeledDefinition : -# 475| r0_2(glval) = VariableAddress[a] : -# 475| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 475| r0_4(glval) = VariableAddress[b] : -# 475| mu0_5(bool) = InitializeParameter[b] : r0_4 -# 476| r0_6(glval) = VariableAddress[x] : -# 476| mu0_7(bool) = Uninitialized : r0_6 -# 477| r0_8(glval) = VariableAddress[a] : -# 477| r0_9(bool) = Load : r0_8, mu0_1 -# 477| v0_10(void) = ConditionalBranch : r0_9 +# 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 : r0_7 +# 477| r0_9(glval) = VariableAddress[a] : +# 477| r0_10(bool) = Load : r0_9, mu0_2 +# 477| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 10 #-----| True -> Block 1 # 477| Block 1 # 477| r1_0(glval) = VariableAddress[b] : -# 477| r1_1(bool) = Load : r1_0, mu0_1 +# 477| r1_1(bool) = Load : r1_0, mu0_2 # 477| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 10 #-----| True -> Block 12 @@ -1970,11 +2023,11 @@ ir.cpp: # 478| Block 3 # 478| r3_0(glval) = VariableAddress[#temp478:9] : -# 478| r3_1(bool) = Load : r3_0, mu0_1 +# 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_1 +# 479| r3_5(bool) = Load : r3_4, mu0_2 # 479| v3_6(void) = ConditionalBranch : r3_5 #-----| False -> Block 9 #-----| True -> Block 8 @@ -1987,7 +2040,7 @@ ir.cpp: # 478| Block 5 # 478| r5_0(glval) = VariableAddress[b] : -# 478| r5_1(bool) = Load : r5_0, mu0_1 +# 478| r5_1(bool) = Load : r5_0, mu0_2 # 478| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 2 #-----| True -> Block 4 @@ -2000,7 +2053,7 @@ ir.cpp: # 479| Block 7 # 479| r7_0(glval) = VariableAddress[#temp479:11] : -# 479| r7_1(bool) = Load : r7_0, mu0_1 +# 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 @@ -2017,7 +2070,7 @@ ir.cpp: # 479| Block 9 # 479| r9_0(glval) = VariableAddress[b] : -# 479| r9_1(bool) = Load : r9_0, mu0_1 +# 479| r9_1(bool) = Load : r9_0, mu0_2 # 479| v9_2(void) = ConditionalBranch : r9_1 #-----| False -> Block 6 #-----| True -> Block 8 @@ -2030,11 +2083,11 @@ ir.cpp: # 477| Block 11 # 477| r11_0(glval) = VariableAddress[#temp477:9] : -# 477| r11_1(bool) = Load : r11_0, mu0_1 +# 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_1 +# 478| r11_5(bool) = Load : r11_4, mu0_2 # 478| v11_6(void) = ConditionalBranch : r11_5 #-----| False -> Block 5 #-----| True -> Block 4 @@ -2047,39 +2100,40 @@ ir.cpp: # 482| Conditional(bool, int, int) -> void # 482| Block 0 -# 482| v0_0(void) = EnterFunction : -# 482| mu0_1(unknown) = UnmodeledDefinition : -# 482| r0_2(glval) = VariableAddress[a] : -# 482| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 482| r0_4(glval) = VariableAddress[x] : -# 482| mu0_5(int) = InitializeParameter[x] : r0_4 -# 482| r0_6(glval) = VariableAddress[y] : -# 482| mu0_7(int) = InitializeParameter[y] : r0_6 -# 483| r0_8(glval) = VariableAddress[z] : -# 483| r0_9(glval) = VariableAddress[a] : -# 483| r0_10(bool) = Load : r0_9, mu0_1 -# 483| v0_11(void) = ConditionalBranch : r0_10 +# 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 #-----| False -> Block 2 #-----| True -> Block 1 # 483| Block 1 # 483| r1_0(glval) = VariableAddress[x] : -# 483| r1_1(int) = Load : r1_0, mu0_1 +# 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 #-----| Goto -> Block 3 # 483| Block 2 # 483| r2_0(glval) = VariableAddress[y] : -# 483| r2_1(int) = Load : r2_0, mu0_1 +# 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 #-----| Goto -> Block 3 # 483| Block 3 # 483| r3_0(glval) = VariableAddress[#temp483:13] : -# 483| r3_1(int) = Load : r3_0, mu0_1 -# 483| mu3_2(int) = Store : r0_8, r3_1 +# 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* @@ -2087,25 +2141,26 @@ ir.cpp: # 486| Conditional_LValue(bool) -> void # 486| Block 0 -# 486| v0_0(void) = EnterFunction : -# 486| mu0_1(unknown) = UnmodeledDefinition : -# 486| r0_2(glval) = VariableAddress[a] : -# 486| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 487| r0_4(glval) = VariableAddress[x] : -# 487| mu0_5(int) = Uninitialized : r0_4 -# 488| r0_6(glval) = VariableAddress[y] : -# 488| mu0_7(int) = Uninitialized : r0_6 -# 489| r0_8(int) = Constant[5] : -# 489| r0_9(glval) = VariableAddress[a] : -# 489| r0_10(bool) = Load : r0_9, mu0_1 -# 489| v0_11(void) = ConditionalBranch : r0_10 +# 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 : r0_5 +# 488| r0_7(glval) = VariableAddress[y] : +# 488| mu0_8(int) = Uninitialized : 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 #-----| False -> Block 3 #-----| True -> Block 2 # 489| Block 1 # 489| r1_0(glval) = VariableAddress[#temp489:6] : -# 489| r1_1(glval) = Load : r1_0, mu0_1 -# 489| mu1_2(int) = Store : r1_1, r0_8 +# 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* @@ -2126,12 +2181,13 @@ ir.cpp: # 492| Conditional_Void(bool) -> void # 492| Block 0 # 492| v0_0(void) = EnterFunction : -# 492| mu0_1(unknown) = UnmodeledDefinition : -# 492| r0_2(glval) = VariableAddress[a] : -# 492| mu0_3(bool) = InitializeParameter[a] : r0_2 -# 493| r0_4(glval) = VariableAddress[a] : -# 493| r0_5(bool) = Load : r0_4, mu0_1 -# 493| v0_6(void) = ConditionalBranch : r0_5 +# 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 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2144,238 +2200,246 @@ ir.cpp: # 493| Block 2 # 493| r2_0(glval) = FunctionAddress[VoidFunc] : # 493| v2_1(void) = Call : r2_0 +# 493| mu2_2(unknown) = ^CallSideEffect : mu0_2 #-----| Goto -> Block 1 # 493| Block 3 # 493| r3_0(glval) = FunctionAddress[VoidFunc] : # 493| v3_1(void) = Call : r3_0 +# 493| mu3_2(unknown) = ^CallSideEffect : mu0_2 #-----| Goto -> Block 1 # 496| Nullptr() -> void # 496| Block 0 # 496| v0_0(void) = EnterFunction : -# 496| mu0_1(unknown) = UnmodeledDefinition : -# 497| r0_2(glval) = VariableAddress[p] : -# 497| r0_3(int *) = Constant[0] : -# 497| mu0_4(int *) = Store : r0_2, r0_3 -# 498| r0_5(glval) = VariableAddress[q] : -# 498| r0_6(int *) = Constant[0] : -# 498| mu0_7(int *) = Store : r0_5, r0_6 -# 499| r0_8(int *) = Constant[0] : -# 499| r0_9(glval) = VariableAddress[p] : -# 499| mu0_10(int *) = Store : r0_9, r0_8 -# 500| r0_11(int *) = Constant[0] : -# 500| r0_12(glval) = VariableAddress[q] : -# 500| mu0_13(int *) = Store : r0_12, r0_11 -# 501| v0_14(void) = NoOp : -# 496| v0_15(void) = ReturnVoid : -# 496| v0_16(void) = UnmodeledUse : mu* -# 496| v0_17(void) = ExitFunction : +# 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) = ExitFunction : # 503| InitList(int, float) -> void # 503| Block 0 # 503| v0_0(void) = EnterFunction : -# 503| mu0_1(unknown) = UnmodeledDefinition : -# 503| r0_2(glval) = VariableAddress[x] : -# 503| mu0_3(int) = InitializeParameter[x] : r0_2 -# 503| r0_4(glval) = VariableAddress[f] : -# 503| mu0_5(float) = InitializeParameter[f] : r0_4 -# 504| r0_6(glval) = VariableAddress[pt1] : -# 504| mu0_7(Point) = Uninitialized : r0_6 -# 504| r0_8(glval) = FieldAddress[x] : r0_6 -# 504| r0_9(glval) = VariableAddress[x] : -# 504| r0_10(int) = Load : r0_9, mu0_1 -# 504| mu0_11(int) = Store : r0_8, r0_10 -# 504| r0_12(glval) = FieldAddress[y] : r0_6 -# 504| r0_13(glval) = VariableAddress[f] : -# 504| r0_14(float) = Load : r0_13, mu0_1 -# 504| r0_15(int) = Convert : r0_14 -# 504| mu0_16(int) = Store : r0_12, r0_15 -# 505| r0_17(glval) = VariableAddress[pt2] : -# 505| mu0_18(Point) = Uninitialized : r0_17 -# 505| r0_19(glval) = FieldAddress[x] : r0_17 -# 505| r0_20(glval) = VariableAddress[x] : -# 505| r0_21(int) = Load : r0_20, mu0_1 -# 505| mu0_22(int) = Store : r0_19, r0_21 -# 505| r0_23(glval) = FieldAddress[y] : r0_17 -# 505| r0_24(int) = Constant[0] : -# 505| mu0_25(int) = Store : r0_23, r0_24 -# 506| r0_26(glval) = VariableAddress[pt3] : -# 506| mu0_27(Point) = Uninitialized : r0_26 -# 506| r0_28(glval) = FieldAddress[x] : r0_26 -# 506| r0_29(int) = Constant[0] : -# 506| mu0_30(int) = Store : r0_28, r0_29 -# 506| r0_31(glval) = FieldAddress[y] : r0_26 -# 506| r0_32(int) = Constant[0] : -# 506| mu0_33(int) = Store : r0_31, r0_32 -# 508| r0_34(glval) = VariableAddress[x1] : -# 508| r0_35(int) = Constant[1] : -# 508| mu0_36(int) = Store : r0_34, r0_35 -# 509| r0_37(glval) = VariableAddress[x2] : -# 509| r0_38(int) = Constant[0] : -# 509| mu0_39(int) = Store : r0_37, r0_38 -# 510| v0_40(void) = NoOp : -# 503| v0_41(void) = ReturnVoid : -# 503| v0_42(void) = UnmodeledUse : mu* -# 503| v0_43(void) = ExitFunction : +# 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 : 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 : 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 : 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) = ExitFunction : # 512| NestedInitList(int, float) -> void # 512| Block 0 # 512| v0_0(void) = EnterFunction : -# 512| mu0_1(unknown) = UnmodeledDefinition : -# 512| r0_2(glval) = VariableAddress[x] : -# 512| mu0_3(int) = InitializeParameter[x] : r0_2 -# 512| r0_4(glval) = VariableAddress[f] : -# 512| mu0_5(float) = InitializeParameter[f] : r0_4 -# 513| r0_6(glval) = VariableAddress[r1] : -# 513| mu0_7(Rect) = Uninitialized : r0_6 -# 513| r0_8(glval) = FieldAddress[topLeft] : r0_6 -# 513| r0_9(Point) = Constant[0] : -# 513| mu0_10(Point) = Store : r0_8, r0_9 -# 513| r0_11(glval) = FieldAddress[bottomRight] : r0_6 -# 513| r0_12(Point) = Constant[0] : -# 513| mu0_13(Point) = Store : r0_11, r0_12 -# 514| r0_14(glval) = VariableAddress[r2] : -# 514| mu0_15(Rect) = Uninitialized : r0_14 -# 514| r0_16(glval) = FieldAddress[topLeft] : r0_14 -# 514| r0_17(glval) = FieldAddress[x] : r0_16 -# 514| r0_18(glval) = VariableAddress[x] : -# 514| r0_19(int) = Load : r0_18, mu0_1 -# 514| mu0_20(int) = Store : r0_17, r0_19 -# 514| r0_21(glval) = FieldAddress[y] : r0_16 -# 514| r0_22(glval) = VariableAddress[f] : -# 514| r0_23(float) = Load : r0_22, mu0_1 -# 514| r0_24(int) = Convert : r0_23 -# 514| mu0_25(int) = Store : r0_21, r0_24 -# 514| r0_26(glval) = FieldAddress[bottomRight] : r0_14 -# 514| r0_27(Point) = Constant[0] : -# 514| mu0_28(Point) = Store : r0_26, r0_27 -# 515| r0_29(glval) = VariableAddress[r3] : -# 515| mu0_30(Rect) = Uninitialized : r0_29 -# 515| r0_31(glval) = FieldAddress[topLeft] : r0_29 -# 515| r0_32(glval) = FieldAddress[x] : r0_31 -# 515| r0_33(glval) = VariableAddress[x] : -# 515| r0_34(int) = Load : r0_33, mu0_1 -# 515| mu0_35(int) = Store : r0_32, r0_34 -# 515| r0_36(glval) = FieldAddress[y] : r0_31 -# 515| r0_37(glval) = VariableAddress[f] : -# 515| r0_38(float) = Load : r0_37, mu0_1 -# 515| r0_39(int) = Convert : r0_38 -# 515| mu0_40(int) = Store : r0_36, r0_39 -# 515| r0_41(glval) = FieldAddress[bottomRight] : r0_29 -# 515| r0_42(glval) = FieldAddress[x] : r0_41 -# 515| r0_43(glval) = VariableAddress[x] : -# 515| r0_44(int) = Load : r0_43, mu0_1 -# 515| mu0_45(int) = Store : r0_42, r0_44 -# 515| r0_46(glval) = FieldAddress[y] : r0_41 -# 515| r0_47(glval) = VariableAddress[f] : -# 515| r0_48(float) = Load : r0_47, mu0_1 -# 515| r0_49(int) = Convert : r0_48 -# 515| mu0_50(int) = Store : r0_46, r0_49 -# 516| r0_51(glval) = VariableAddress[r4] : -# 516| mu0_52(Rect) = Uninitialized : r0_51 -# 516| r0_53(glval) = FieldAddress[topLeft] : r0_51 -# 516| r0_54(glval) = FieldAddress[x] : r0_53 -# 516| r0_55(glval) = VariableAddress[x] : -# 516| r0_56(int) = Load : r0_55, mu0_1 -# 516| mu0_57(int) = Store : r0_54, r0_56 -# 516| r0_58(glval) = FieldAddress[y] : r0_53 -# 516| r0_59(int) = Constant[0] : -# 516| mu0_60(int) = Store : r0_58, r0_59 -# 516| r0_61(glval) = FieldAddress[bottomRight] : r0_51 -# 516| r0_62(glval) = FieldAddress[x] : r0_61 -# 516| r0_63(glval) = VariableAddress[x] : -# 516| r0_64(int) = Load : r0_63, mu0_1 -# 516| mu0_65(int) = Store : r0_62, r0_64 -# 516| r0_66(glval) = FieldAddress[y] : r0_61 -# 516| r0_67(int) = Constant[0] : -# 516| mu0_68(int) = Store : r0_66, r0_67 -# 517| v0_69(void) = NoOp : -# 512| v0_70(void) = ReturnVoid : -# 512| v0_71(void) = UnmodeledUse : mu* -# 512| v0_72(void) = ExitFunction : +# 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 : 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 : 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 : 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 : 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) = ExitFunction : # 519| ArrayInit(int, float) -> void # 519| Block 0 # 519| v0_0(void) = EnterFunction : -# 519| mu0_1(unknown) = UnmodeledDefinition : -# 519| r0_2(glval) = VariableAddress[x] : -# 519| mu0_3(int) = InitializeParameter[x] : r0_2 -# 519| r0_4(glval) = VariableAddress[f] : -# 519| mu0_5(float) = InitializeParameter[f] : r0_4 -# 520| r0_6(glval) = VariableAddress[a1] : -# 520| mu0_7(int[3]) = Uninitialized : r0_6 -# 520| r0_8(int) = Constant[0] : -# 520| r0_9(glval) = PointerAdd : r0_6, r0_8 -# 520| r0_10(unknown[12]) = Constant[0] : -# 520| mu0_11(unknown[12]) = Store : r0_9, r0_10 -# 521| r0_12(glval) = VariableAddress[a2] : -# 521| mu0_13(int[3]) = Uninitialized : r0_12 -# 521| r0_14(int) = Constant[0] : -# 521| r0_15(glval) = PointerAdd : r0_12, r0_14 -# 521| r0_16(glval) = VariableAddress[x] : -# 521| r0_17(int) = Load : r0_16, mu0_1 -# 521| mu0_18(int) = Store : r0_15, r0_17 -# 521| r0_19(int) = Constant[1] : -# 521| r0_20(glval) = PointerAdd : r0_12, r0_19 -# 521| r0_21(glval) = VariableAddress[f] : -# 521| r0_22(float) = Load : r0_21, mu0_1 -# 521| r0_23(int) = Convert : r0_22 -# 521| mu0_24(int) = Store : r0_20, r0_23 -# 521| r0_25(int) = Constant[2] : -# 521| r0_26(glval) = PointerAdd : r0_12, r0_25 -# 521| r0_27(int) = Constant[0] : -# 521| mu0_28(int) = Store : r0_26, r0_27 -# 522| r0_29(glval) = VariableAddress[a3] : -# 522| mu0_30(int[3]) = Uninitialized : r0_29 -# 522| r0_31(int) = Constant[0] : -# 522| r0_32(glval) = PointerAdd : r0_29, r0_31 -# 522| r0_33(glval) = VariableAddress[x] : -# 522| r0_34(int) = Load : r0_33, mu0_1 -# 522| mu0_35(int) = Store : r0_32, r0_34 -# 522| r0_36(int) = Constant[1] : -# 522| r0_37(glval) = PointerAdd : r0_29, r0_36 -# 522| r0_38(unknown[8]) = Constant[0] : -# 522| mu0_39(unknown[8]) = Store : r0_37, r0_38 -# 523| v0_40(void) = NoOp : -# 519| v0_41(void) = ReturnVoid : -# 519| v0_42(void) = UnmodeledUse : mu* -# 519| v0_43(void) = ExitFunction : +# 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 : r0_7 +# 520| r0_9(int) = Constant[0] : +# 520| r0_10(glval) = PointerAdd : 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 : r0_13 +# 521| r0_15(int) = Constant[0] : +# 521| r0_16(glval) = PointerAdd : 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 : 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 : 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 : r0_30 +# 522| r0_32(int) = Constant[0] : +# 522| r0_33(glval) = PointerAdd : 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 : 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) = ExitFunction : # 530| UnionInit(int, float) -> void # 530| Block 0 # 530| v0_0(void) = EnterFunction : -# 530| mu0_1(unknown) = UnmodeledDefinition : -# 530| r0_2(glval) = VariableAddress[x] : -# 530| mu0_3(int) = InitializeParameter[x] : r0_2 -# 530| r0_4(glval) = VariableAddress[f] : -# 530| mu0_5(float) = InitializeParameter[f] : r0_4 -# 531| r0_6(glval) = VariableAddress[u1] : -# 531| mu0_7(U) = Uninitialized : r0_6 -# 531| r0_8(glval) = FieldAddress[d] : r0_6 -# 531| r0_9(glval) = VariableAddress[f] : -# 531| r0_10(float) = Load : r0_9, mu0_1 -# 531| r0_11(double) = Convert : r0_10 -# 531| mu0_12(double) = Store : r0_8, r0_11 -# 533| v0_13(void) = NoOp : -# 530| v0_14(void) = ReturnVoid : -# 530| v0_15(void) = UnmodeledUse : mu* -# 530| v0_16(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 535| EarlyReturn(int, int) -> void # 535| Block 0 # 535| v0_0(void) = EnterFunction : -# 535| mu0_1(unknown) = UnmodeledDefinition : -# 535| r0_2(glval) = VariableAddress[x] : -# 535| mu0_3(int) = InitializeParameter[x] : r0_2 -# 535| r0_4(glval) = VariableAddress[y] : -# 535| mu0_5(int) = InitializeParameter[y] : r0_4 -# 536| r0_6(glval) = VariableAddress[x] : -# 536| r0_7(int) = Load : r0_6, mu0_1 -# 536| r0_8(glval) = VariableAddress[y] : -# 536| r0_9(int) = Load : r0_8, mu0_1 -# 536| r0_10(bool) = CompareLT : r0_7, r0_9 -# 536| v0_11(void) = ConditionalBranch : r0_10 +# 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 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2390,7 +2454,7 @@ ir.cpp: # 540| Block 3 # 540| r3_0(glval) = VariableAddress[x] : -# 540| r3_1(int) = Load : r3_0, mu0_1 +# 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 : @@ -2399,39 +2463,40 @@ ir.cpp: # 543| EarlyReturnValue(int, int) -> int # 543| Block 0 # 543| v0_0(void) = EnterFunction : -# 543| mu0_1(unknown) = UnmodeledDefinition : -# 543| r0_2(glval) = VariableAddress[x] : -# 543| mu0_3(int) = InitializeParameter[x] : r0_2 -# 543| r0_4(glval) = VariableAddress[y] : -# 543| mu0_5(int) = InitializeParameter[y] : r0_4 -# 544| r0_6(glval) = VariableAddress[x] : -# 544| r0_7(int) = Load : r0_6, mu0_1 -# 544| r0_8(glval) = VariableAddress[y] : -# 544| r0_9(int) = Load : r0_8, mu0_1 -# 544| r0_10(bool) = CompareLT : r0_7, r0_9 -# 544| v0_11(void) = ConditionalBranch : r0_10 +# 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 #-----| False -> Block 3 #-----| True -> Block 2 # 543| Block 1 # 543| r1_0(glval) = VariableAddress[#return] : -# 543| v1_1(void) = ReturnValue : r1_0, mu0_1 +# 543| v1_1(void) = ReturnValue : r1_0, mu0_2 # 543| v1_2(void) = UnmodeledUse : mu* # 543| v1_3(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_1 +# 545| r2_2(int) = Load : r2_1, mu0_2 # 545| mu2_3(int) = Store : r2_0, r2_2 #-----| 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_1 +# 548| r3_2(int) = Load : r3_1, mu0_2 # 548| r3_3(glval) = VariableAddress[y] : -# 548| r3_4(int) = Load : r3_3, mu0_1 +# 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 #-----| Goto -> Block 1 @@ -2439,37 +2504,40 @@ ir.cpp: # 551| CallViaFuncPtr(..(*)(..)) -> int # 551| Block 0 # 551| v0_0(void) = EnterFunction : -# 551| mu0_1(unknown) = UnmodeledDefinition : -# 551| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| mu0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 552| r0_4(glval) = VariableAddress[#return] : -# 552| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r0_6(..(*)(..)) = Load : r0_5, mu0_1 -# 552| r0_7(int) = Constant[5] : -# 552| r0_8(int) = Call : r0_6, r0_7 -# 552| mu0_9(int) = Store : r0_4, r0_8 -# 551| r0_10(glval) = VariableAddress[#return] : -# 551| v0_11(void) = ReturnValue : r0_10, mu0_1 -# 551| v0_12(void) = UnmodeledUse : mu* -# 551| v0_13(void) = ExitFunction : +# 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 : r0_7, 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) = ExitFunction : # 560| EnumSwitch(E) -> int # 560| Block 0 # 560| v0_0(void) = EnterFunction : -# 560| mu0_1(unknown) = UnmodeledDefinition : -# 560| r0_2(glval) = VariableAddress[e] : -# 560| mu0_3(E) = InitializeParameter[e] : r0_2 -# 561| r0_4(glval) = VariableAddress[e] : -# 561| r0_5(E) = Load : r0_4, mu0_1 -# 561| r0_6(int) = Convert : r0_5 -# 561| v0_7(void) = Switch : r0_6 +# 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 #-----| 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_1 +# 560| v1_1(void) = ReturnValue : r1_0, mu0_2 # 560| v1_2(void) = UnmodeledUse : mu* # 560| v1_3(void) = ExitFunction : @@ -2497,492 +2565,530 @@ ir.cpp: # 571| InitArray() -> void # 571| Block 0 # 571| v0_0(void) = EnterFunction : -# 571| mu0_1(unknown) = UnmodeledDefinition : -# 572| r0_2(glval) = VariableAddress[a_pad] : -# 572| r0_3(glval) = StringConstant[""] : -# 572| r0_4(char[1]) = Load : r0_3, mu0_1 -# 572| mu0_5(char[1]) = Store : r0_2, r0_4 -# 572| r0_6(unknown[31]) = Constant[0] : -# 572| r0_7(int) = Constant[1] : -# 572| r0_8(glval) = PointerAdd : r0_2, r0_7 -# 572| mu0_9(unknown[31]) = Store : r0_8, r0_6 -# 573| r0_10(glval) = VariableAddress[a_nopad] : -# 573| r0_11(glval) = StringConstant["foo"] : -# 573| r0_12(char[4]) = Load : r0_11, mu0_1 -# 573| mu0_13(char[4]) = Store : r0_10, r0_12 -# 574| r0_14(glval) = VariableAddress[a_infer] : -# 574| r0_15(glval) = StringConstant["blah"] : -# 574| r0_16(char[5]) = Load : r0_15, mu0_1 -# 574| mu0_17(char[5]) = Store : r0_14, r0_16 -# 575| r0_18(glval) = VariableAddress[b] : -# 575| mu0_19(char[2]) = Uninitialized : r0_18 -# 576| r0_20(glval) = VariableAddress[c] : -# 576| mu0_21(char[2]) = Uninitialized : r0_20 -# 576| r0_22(int) = Constant[0] : -# 576| r0_23(glval) = PointerAdd : r0_20, r0_22 -# 576| r0_24(unknown[2]) = Constant[0] : -# 576| mu0_25(unknown[2]) = Store : r0_23, r0_24 -# 577| r0_26(glval) = VariableAddress[d] : -# 577| mu0_27(char[2]) = Uninitialized : r0_26 -# 577| r0_28(int) = Constant[0] : -# 577| r0_29(glval) = PointerAdd : r0_26, r0_28 -# 577| r0_30(char) = Constant[0] : -# 577| mu0_31(char) = Store : r0_29, r0_30 -# 577| r0_32(int) = Constant[1] : -# 577| r0_33(glval) = PointerAdd : r0_26, r0_32 -# 577| r0_34(char) = Constant[0] : -# 577| mu0_35(char) = Store : r0_33, r0_34 -# 578| r0_36(glval) = VariableAddress[e] : -# 578| mu0_37(char[2]) = Uninitialized : r0_36 -# 578| r0_38(int) = Constant[0] : -# 578| r0_39(glval) = PointerAdd : r0_36, r0_38 -# 578| r0_40(char) = Constant[0] : -# 578| mu0_41(char) = Store : r0_39, r0_40 -# 578| r0_42(int) = Constant[1] : -# 578| r0_43(glval) = PointerAdd : r0_36, r0_42 -# 578| r0_44(char) = Constant[1] : -# 578| mu0_45(char) = Store : r0_43, r0_44 -# 579| r0_46(glval) = VariableAddress[f] : -# 579| mu0_47(char[3]) = Uninitialized : r0_46 -# 579| r0_48(int) = Constant[0] : -# 579| r0_49(glval) = PointerAdd : r0_46, r0_48 -# 579| r0_50(char) = Constant[0] : -# 579| mu0_51(char) = Store : r0_49, r0_50 -# 579| r0_52(int) = Constant[1] : -# 579| r0_53(glval) = PointerAdd : r0_46, r0_52 -# 579| r0_54(unknown[2]) = Constant[0] : -# 579| mu0_55(unknown[2]) = Store : r0_53, r0_54 -# 580| v0_56(void) = NoOp : -# 571| v0_57(void) = ReturnVoid : -# 571| v0_58(void) = UnmodeledUse : mu* -# 571| v0_59(void) = ExitFunction : +# 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[1]) = Load : r0_4, mu0_2 +# 572| mu0_6(char[1]) = Store : r0_3, r0_5 +# 572| r0_7(unknown[31]) = Constant[0] : +# 572| r0_8(int) = Constant[1] : +# 572| r0_9(glval) = PointerAdd : r0_3, r0_8 +# 572| mu0_10(unknown[31]) = Store : r0_9, r0_7 +# 573| r0_11(glval) = VariableAddress[a_nopad] : +# 573| r0_12(glval) = StringConstant["foo"] : +# 573| r0_13(char[4]) = Load : r0_12, mu0_2 +# 573| mu0_14(char[4]) = Store : r0_11, r0_13 +# 574| r0_15(glval) = VariableAddress[a_infer] : +# 574| r0_16(glval) = StringConstant["blah"] : +# 574| r0_17(char[5]) = Load : r0_16, mu0_2 +# 574| mu0_18(char[5]) = Store : r0_15, r0_17 +# 575| r0_19(glval) = VariableAddress[b] : +# 575| mu0_20(char[2]) = Uninitialized : r0_19 +# 576| r0_21(glval) = VariableAddress[c] : +# 576| mu0_22(char[2]) = Uninitialized : r0_21 +# 576| r0_23(int) = Constant[0] : +# 576| r0_24(glval) = PointerAdd : r0_21, r0_23 +# 576| r0_25(unknown[2]) = Constant[0] : +# 576| mu0_26(unknown[2]) = Store : r0_24, r0_25 +# 577| r0_27(glval) = VariableAddress[d] : +# 577| mu0_28(char[2]) = Uninitialized : r0_27 +# 577| r0_29(int) = Constant[0] : +# 577| r0_30(glval) = PointerAdd : r0_27, r0_29 +# 577| r0_31(char) = Constant[0] : +# 577| mu0_32(char) = Store : r0_30, r0_31 +# 577| r0_33(int) = Constant[1] : +# 577| r0_34(glval) = PointerAdd : r0_27, r0_33 +# 577| r0_35(char) = Constant[0] : +# 577| mu0_36(char) = Store : r0_34, r0_35 +# 578| r0_37(glval) = VariableAddress[e] : +# 578| mu0_38(char[2]) = Uninitialized : r0_37 +# 578| r0_39(int) = Constant[0] : +# 578| r0_40(glval) = PointerAdd : r0_37, r0_39 +# 578| r0_41(char) = Constant[0] : +# 578| mu0_42(char) = Store : r0_40, r0_41 +# 578| r0_43(int) = Constant[1] : +# 578| r0_44(glval) = PointerAdd : r0_37, r0_43 +# 578| r0_45(char) = Constant[1] : +# 578| mu0_46(char) = Store : r0_44, r0_45 +# 579| r0_47(glval) = VariableAddress[f] : +# 579| mu0_48(char[3]) = Uninitialized : r0_47 +# 579| r0_49(int) = Constant[0] : +# 579| r0_50(glval) = PointerAdd : r0_47, r0_49 +# 579| r0_51(char) = Constant[0] : +# 579| mu0_52(char) = Store : r0_50, r0_51 +# 579| r0_53(int) = Constant[1] : +# 579| r0_54(glval) = PointerAdd : r0_47, r0_53 +# 579| r0_55(unknown[2]) = Constant[0] : +# 579| mu0_56(unknown[2]) = Store : r0_54, r0_55 +# 580| v0_57(void) = NoOp : +# 571| v0_58(void) = ReturnVoid : +# 571| v0_59(void) = UnmodeledUse : mu* +# 571| v0_60(void) = ExitFunction : # 584| VarArgs() -> void # 584| Block 0 # 584| v0_0(void) = EnterFunction : -# 584| mu0_1(unknown) = UnmodeledDefinition : -# 585| r0_2(glval) = FunctionAddress[VarArgFunction] : -# 585| r0_3(glval) = StringConstant["%d %s"] : -# 585| r0_4(char *) = Convert : r0_3 -# 585| r0_5(int) = Constant[1] : -# 585| r0_6(glval) = StringConstant["string"] : -# 585| r0_7(char *) = Convert : r0_6 -# 585| v0_8(void) = Call : r0_2, r0_4, r0_5, r0_7 -# 586| v0_9(void) = NoOp : -# 584| v0_10(void) = ReturnVoid : -# 584| v0_11(void) = UnmodeledUse : mu* -# 584| v0_12(void) = ExitFunction : +# 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 : r0_3, r0_5, r0_6, r0_8 +# 585| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 586| v0_11(void) = NoOp : +# 584| v0_12(void) = ReturnVoid : +# 584| v0_13(void) = UnmodeledUse : mu* +# 584| v0_14(void) = ExitFunction : # 590| SetFuncPtr() -> void # 590| Block 0 # 590| v0_0(void) = EnterFunction : -# 590| mu0_1(unknown) = UnmodeledDefinition : -# 591| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r0_3(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 591| mu0_4(..(*)(..)) = Store : r0_2, r0_3 -# 592| r0_5(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| mu0_7(..(*)(..)) = Store : r0_6, r0_5 -# 593| r0_8(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 593| r0_9(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| mu0_10(..(*)(..)) = Store : r0_9, r0_8 -# 594| r0_11(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r0_12(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| mu0_13(..(*)(..)) = Store : r0_12, r0_11 -# 595| v0_14(void) = NoOp : -# 590| v0_15(void) = ReturnVoid : -# 590| v0_16(void) = UnmodeledUse : mu* -# 590| v0_17(void) = ExitFunction : +# 590| mu0_1(unknown) = AliasedDefinition : +# 590| mu0_2(unknown) = UnmodeledDefinition : +# 591| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r0_4(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 591| mu0_5(..(*)(..)) = Store : r0_3, r0_4 +# 592| r0_6(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| mu0_8(..(*)(..)) = Store : r0_7, r0_6 +# 593| r0_9(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 593| r0_10(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| mu0_11(..(*)(..)) = Store : r0_10, r0_9 +# 594| r0_12(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r0_13(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| mu0_14(..(*)(..)) = Store : r0_13, r0_12 +# 595| v0_15(void) = NoOp : +# 590| v0_16(void) = ReturnVoid : +# 590| v0_17(void) = UnmodeledUse : mu* +# 590| v0_18(void) = ExitFunction : # 615| DeclareObject() -> void # 615| Block 0 # 615| v0_0(void) = EnterFunction : -# 615| mu0_1(unknown) = UnmodeledDefinition : -# 616| r0_2(glval) = VariableAddress[s1] : -# 616| r0_3(glval) = FunctionAddress[String] : -# 616| v0_4(void) = Call : r0_3, this:r0_2 -# 617| r0_5(glval) = VariableAddress[s2] : -# 617| r0_6(glval) = FunctionAddress[String] : -# 617| r0_7(glval) = StringConstant["hello"] : -# 617| r0_8(char *) = Convert : r0_7 -# 617| v0_9(void) = Call : r0_6, this:r0_5, r0_8 -# 618| r0_10(glval) = VariableAddress[s3] : -# 618| r0_11(glval) = FunctionAddress[ReturnObject] : -# 618| r0_12(String) = Call : r0_11 -# 618| mu0_13(String) = Store : r0_10, r0_12 -# 619| r0_14(glval) = VariableAddress[s4] : -# 619| r0_15(glval) = FunctionAddress[String] : -# 619| r0_16(glval) = StringConstant["test"] : -# 619| r0_17(char *) = Convert : r0_16 -# 619| v0_18(void) = Call : r0_15, this:r0_14, r0_17 -# 620| v0_19(void) = NoOp : -# 615| v0_20(void) = ReturnVoid : -# 615| v0_21(void) = UnmodeledUse : mu* -# 615| v0_22(void) = ExitFunction : +# 615| mu0_1(unknown) = AliasedDefinition : +# 615| mu0_2(unknown) = UnmodeledDefinition : +# 616| r0_3(glval) = VariableAddress[s1] : +# 616| r0_4(glval) = FunctionAddress[String] : +# 616| v0_5(void) = Call : r0_4, this:r0_3 +# 616| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 617| r0_7(glval) = VariableAddress[s2] : +# 617| r0_8(glval) = FunctionAddress[String] : +# 617| r0_9(glval) = StringConstant["hello"] : +# 617| r0_10(char *) = Convert : r0_9 +# 617| v0_11(void) = Call : r0_8, this:r0_7, r0_10 +# 617| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 618| r0_13(glval) = VariableAddress[s3] : +# 618| r0_14(glval) = FunctionAddress[ReturnObject] : +# 618| r0_15(String) = Call : r0_14 +# 618| mu0_16(unknown) = ^CallSideEffect : mu0_2 +# 618| mu0_17(String) = Store : r0_13, r0_15 +# 619| r0_18(glval) = VariableAddress[s4] : +# 619| r0_19(glval) = FunctionAddress[String] : +# 619| r0_20(glval) = StringConstant["test"] : +# 619| r0_21(char *) = Convert : r0_20 +# 619| v0_22(void) = Call : r0_19, this:r0_18, r0_21 +# 619| mu0_23(unknown) = ^CallSideEffect : mu0_2 +# 620| v0_24(void) = NoOp : +# 615| v0_25(void) = ReturnVoid : +# 615| v0_26(void) = UnmodeledUse : mu* +# 615| v0_27(void) = ExitFunction : # 622| CallMethods(String &, String *, String) -> void # 622| Block 0 # 622| v0_0(void) = EnterFunction : -# 622| mu0_1(unknown) = UnmodeledDefinition : -# 622| r0_2(glval) = VariableAddress[r] : -# 622| mu0_3(String &) = InitializeParameter[r] : r0_2 -# 622| r0_4(glval) = VariableAddress[p] : -# 622| mu0_5(String *) = InitializeParameter[p] : r0_4 -# 622| r0_6(glval) = VariableAddress[s] : -# 622| mu0_7(String) = InitializeParameter[s] : r0_6 -# 623| r0_8(glval) = VariableAddress[r] : -# 623| r0_9(String &) = Load : r0_8, mu0_1 -# 623| r0_10(glval) = Convert : r0_9 -# 623| r0_11(glval) = FunctionAddress[c_str] : -# 623| r0_12(char *) = Call : r0_11, this:r0_10 -# 624| r0_13(glval) = VariableAddress[p] : -# 624| r0_14(String *) = Load : r0_13, mu0_1 -# 624| r0_15(String *) = Convert : r0_14 -# 624| r0_16(glval) = FunctionAddress[c_str] : -# 624| r0_17(char *) = Call : r0_16, this:r0_15 -# 625| r0_18(glval) = VariableAddress[s] : -# 625| r0_19(glval) = Convert : r0_18 -# 625| r0_20(glval) = FunctionAddress[c_str] : -# 625| r0_21(char *) = Call : r0_20, this:r0_19 -# 626| v0_22(void) = NoOp : -# 622| v0_23(void) = ReturnVoid : -# 622| v0_24(void) = UnmodeledUse : mu* -# 622| v0_25(void) = ExitFunction : +# 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) = Convert : r0_10 +# 623| r0_12(glval) = FunctionAddress[c_str] : +# 623| r0_13(char *) = Call : r0_12, this:r0_11 +# 623| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 624| r0_15(glval) = VariableAddress[p] : +# 624| r0_16(String *) = Load : r0_15, mu0_2 +# 624| r0_17(String *) = Convert : r0_16 +# 624| r0_18(glval) = FunctionAddress[c_str] : +# 624| r0_19(char *) = Call : r0_18, this:r0_17 +# 624| mu0_20(unknown) = ^CallSideEffect : mu0_2 +# 625| r0_21(glval) = VariableAddress[s] : +# 625| r0_22(glval) = Convert : r0_21 +# 625| r0_23(glval) = FunctionAddress[c_str] : +# 625| r0_24(char *) = Call : r0_23, this:r0_22 +# 625| mu0_25(unknown) = ^CallSideEffect : mu0_2 +# 626| v0_26(void) = NoOp : +# 622| v0_27(void) = ReturnVoid : +# 622| v0_28(void) = UnmodeledUse : mu* +# 622| v0_29(void) = ExitFunction : # 630| C::StaticMemberFunction(int) -> int # 630| Block 0 # 630| v0_0(void) = EnterFunction : -# 630| mu0_1(unknown) = UnmodeledDefinition : -# 630| r0_2(glval) = VariableAddress[x] : -# 630| mu0_3(int) = InitializeParameter[x] : r0_2 -# 631| r0_4(glval) = VariableAddress[#return] : -# 631| r0_5(glval) = VariableAddress[x] : -# 631| r0_6(int) = Load : r0_5, mu0_1 -# 631| mu0_7(int) = Store : r0_4, r0_6 -# 630| r0_8(glval) = VariableAddress[#return] : -# 630| v0_9(void) = ReturnValue : r0_8, mu0_1 -# 630| v0_10(void) = UnmodeledUse : mu* -# 630| v0_11(void) = ExitFunction : +# 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) = ExitFunction : # 634| C::InstanceMemberFunction(int) -> int # 634| Block 0 -# 634| v0_0(void) = EnterFunction : -# 634| mu0_1(unknown) = UnmodeledDefinition : -# 634| r0_2(glval) = InitializeThis : -# 634| r0_3(glval) = VariableAddress[x] : -# 634| mu0_4(int) = InitializeParameter[x] : r0_3 -# 635| r0_5(glval) = VariableAddress[#return] : -# 635| r0_6(glval) = VariableAddress[x] : -# 635| r0_7(int) = Load : r0_6, mu0_1 -# 635| mu0_8(int) = Store : r0_5, r0_7 -# 634| r0_9(glval) = VariableAddress[#return] : -# 634| v0_10(void) = ReturnValue : r0_9, mu0_1 -# 634| v0_11(void) = UnmodeledUse : mu* -# 634| v0_12(void) = ExitFunction : +# 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) = ExitFunction : # 638| C::VirtualMemberFunction(int) -> int # 638| Block 0 -# 638| v0_0(void) = EnterFunction : -# 638| mu0_1(unknown) = UnmodeledDefinition : -# 638| r0_2(glval) = InitializeThis : -# 638| r0_3(glval) = VariableAddress[x] : -# 638| mu0_4(int) = InitializeParameter[x] : r0_3 -# 639| r0_5(glval) = VariableAddress[#return] : -# 639| r0_6(glval) = VariableAddress[x] : -# 639| r0_7(int) = Load : r0_6, mu0_1 -# 639| mu0_8(int) = Store : r0_5, r0_7 -# 638| r0_9(glval) = VariableAddress[#return] : -# 638| v0_10(void) = ReturnValue : r0_9, mu0_1 -# 638| v0_11(void) = UnmodeledUse : mu* -# 638| v0_12(void) = ExitFunction : +# 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) = ExitFunction : # 642| C::FieldAccess() -> void # 642| Block 0 # 642| v0_0(void) = EnterFunction : -# 642| mu0_1(unknown) = UnmodeledDefinition : -# 642| r0_2(glval) = InitializeThis : -# 643| r0_3(int) = Constant[0] : -# 643| r0_4(C *) = CopyValue : r0_2 -# 643| r0_5(glval) = FieldAddress[m_a] : r0_4 -# 643| mu0_6(int) = Store : r0_5, r0_3 -# 644| r0_7(int) = Constant[1] : -# 644| r0_8(C *) = CopyValue : r0_2 -# 644| r0_9(glval) = FieldAddress[m_a] : r0_8 -# 644| mu0_10(int) = Store : r0_9, r0_7 -# 645| r0_11(int) = Constant[2] : -#-----| r0_12(C *) = CopyValue : r0_2 -# 645| r0_13(glval) = FieldAddress[m_a] : r0_12 -# 645| mu0_14(int) = Store : r0_13, r0_11 -# 646| r0_15(glval) = VariableAddress[x] : -# 646| mu0_16(int) = Uninitialized : r0_15 -# 647| r0_17(C *) = CopyValue : r0_2 -# 647| r0_18(glval) = FieldAddress[m_a] : r0_17 -# 647| r0_19(int) = Load : r0_18, mu0_1 -# 647| r0_20(glval) = VariableAddress[x] : -# 647| mu0_21(int) = Store : r0_20, r0_19 -# 648| r0_22(C *) = CopyValue : r0_2 -# 648| r0_23(glval) = FieldAddress[m_a] : r0_22 -# 648| r0_24(int) = Load : r0_23, mu0_1 -# 648| r0_25(glval) = VariableAddress[x] : -# 648| mu0_26(int) = Store : r0_25, r0_24 -#-----| r0_27(C *) = CopyValue : r0_2 -# 649| r0_28(glval) = FieldAddress[m_a] : r0_27 -# 649| r0_29(int) = Load : r0_28, mu0_1 -# 649| r0_30(glval) = VariableAddress[x] : -# 649| mu0_31(int) = Store : r0_30, r0_29 -# 650| v0_32(void) = NoOp : -# 642| v0_33(void) = ReturnVoid : -# 642| v0_34(void) = UnmodeledUse : mu* -# 642| v0_35(void) = ExitFunction : +# 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) = FieldAddress[m_a] : r0_9 +# 644| mu0_11(int) = Store : r0_10, r0_8 +# 645| r0_12(int) = Constant[2] : +#-----| r0_13(C *) = CopyValue : r0_3 +# 645| r0_14(glval) = FieldAddress[m_a] : r0_13 +# 645| mu0_15(int) = Store : r0_14, r0_12 +# 646| r0_16(glval) = VariableAddress[x] : +# 646| mu0_17(int) = Uninitialized : r0_16 +# 647| r0_18(C *) = CopyValue : r0_3 +# 647| r0_19(glval) = FieldAddress[m_a] : r0_18 +# 647| r0_20(int) = Load : r0_19, mu0_2 +# 647| r0_21(glval) = VariableAddress[x] : +# 647| mu0_22(int) = Store : r0_21, r0_20 +# 648| r0_23(C *) = CopyValue : r0_3 +# 648| r0_24(glval) = FieldAddress[m_a] : r0_23 +# 648| r0_25(int) = Load : r0_24, mu0_2 +# 648| r0_26(glval) = VariableAddress[x] : +# 648| mu0_27(int) = Store : r0_26, r0_25 +#-----| r0_28(C *) = CopyValue : r0_3 +# 649| r0_29(glval) = FieldAddress[m_a] : r0_28 +# 649| r0_30(int) = Load : r0_29, mu0_2 +# 649| r0_31(glval) = VariableAddress[x] : +# 649| mu0_32(int) = Store : r0_31, r0_30 +# 650| v0_33(void) = NoOp : +# 642| v0_34(void) = ReturnVoid : +# 642| v0_35(void) = UnmodeledUse : mu* +# 642| v0_36(void) = ExitFunction : # 652| C::MethodCalls() -> void # 652| Block 0 # 652| v0_0(void) = EnterFunction : -# 652| mu0_1(unknown) = UnmodeledDefinition : -# 652| r0_2(glval) = InitializeThis : -# 653| r0_3(C *) = CopyValue : r0_2 -# 653| r0_4(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r0_5(int) = Constant[0] : -# 653| r0_6(int) = Call : r0_4, this:r0_3, r0_5 -# 654| r0_7(C *) = CopyValue : r0_2 -# 654| r0_8(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r0_9(int) = Constant[1] : -# 654| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -#-----| r0_11(C *) = CopyValue : r0_2 -# 655| r0_12(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r0_13(int) = Constant[2] : -# 655| r0_14(int) = Call : r0_12, this:r0_11, r0_13 -# 656| v0_15(void) = NoOp : -# 652| v0_16(void) = ReturnVoid : -# 652| v0_17(void) = UnmodeledUse : mu* -# 652| v0_18(void) = ExitFunction : +# 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 : r0_5, this:r0_4, r0_6 +# 653| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 654| r0_9(C *) = CopyValue : r0_3 +# 654| r0_10(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r0_11(int) = Constant[1] : +# 654| r0_12(int) = Call : r0_10, this:r0_9, r0_11 +# 654| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(C *) = CopyValue : r0_3 +# 655| r0_15(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r0_16(int) = Constant[2] : +# 655| r0_17(int) = Call : r0_15, this:r0_14, r0_16 +# 655| mu0_18(unknown) = ^CallSideEffect : mu0_2 +# 656| v0_19(void) = NoOp : +# 652| v0_20(void) = ReturnVoid : +# 652| v0_21(void) = UnmodeledUse : mu* +# 652| v0_22(void) = ExitFunction : # 658| C::C() -> void # 658| Block 0 # 658| v0_0(void) = EnterFunction : -# 658| mu0_1(unknown) = UnmodeledDefinition : -# 658| r0_2(glval) = InitializeThis : -# 659| r0_3(glval) = FieldAddress[m_a] : r0_2 -# 659| r0_4(int) = Constant[1] : -# 659| mu0_5(int) = Store : r0_3, r0_4 -# 663| r0_6(glval) = FieldAddress[m_b] : r0_2 -# 663| r0_7(glval) = FunctionAddress[String] : -# 663| v0_8(void) = Call : r0_7, this:r0_6 -# 660| r0_9(glval) = FieldAddress[m_c] : r0_2 -# 660| r0_10(char) = Constant[3] : -# 660| mu0_11(char) = Store : r0_9, r0_10 -# 661| r0_12(glval) = FieldAddress[m_e] : r0_2 -# 661| r0_13(void *) = Constant[0] : -# 661| mu0_14(void *) = Store : r0_12, r0_13 -# 662| r0_15(glval) = FieldAddress[m_f] : r0_2 -# 662| r0_16(glval) = FunctionAddress[String] : -# 662| r0_17(glval) = StringConstant["test"] : -# 662| r0_18(char *) = Convert : r0_17 -# 662| v0_19(void) = Call : r0_16, this:r0_15, r0_18 -# 664| v0_20(void) = NoOp : -# 658| v0_21(void) = ReturnVoid : -# 658| v0_22(void) = UnmodeledUse : mu* -# 658| v0_23(void) = ExitFunction : +# 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 : r0_8, this:r0_7 +# 663| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 660| r0_11(glval) = FieldAddress[m_c] : r0_3 +# 660| r0_12(char) = Constant[3] : +# 660| mu0_13(char) = Store : r0_11, r0_12 +# 661| r0_14(glval) = FieldAddress[m_e] : r0_3 +# 661| r0_15(void *) = Constant[0] : +# 661| mu0_16(void *) = Store : r0_14, r0_15 +# 662| r0_17(glval) = FieldAddress[m_f] : r0_3 +# 662| r0_18(glval) = FunctionAddress[String] : +# 662| r0_19(glval) = StringConstant["test"] : +# 662| r0_20(char *) = Convert : r0_19 +# 662| v0_21(void) = Call : r0_18, this:r0_17, r0_20 +# 662| mu0_22(unknown) = ^CallSideEffect : mu0_2 +# 664| v0_23(void) = NoOp : +# 658| v0_24(void) = ReturnVoid : +# 658| v0_25(void) = UnmodeledUse : mu* +# 658| v0_26(void) = ExitFunction : # 675| DerefReference(int &) -> int # 675| Block 0 # 675| v0_0(void) = EnterFunction : -# 675| mu0_1(unknown) = UnmodeledDefinition : -# 675| r0_2(glval) = VariableAddress[r] : -# 675| mu0_3(int &) = InitializeParameter[r] : r0_2 -# 676| r0_4(glval) = VariableAddress[#return] : -# 676| r0_5(glval) = VariableAddress[r] : -# 676| r0_6(int &) = Load : r0_5, mu0_1 -# 676| r0_7(int) = Load : r0_6, mu0_1 -# 676| mu0_8(int) = Store : r0_4, r0_7 -# 675| r0_9(glval) = VariableAddress[#return] : -# 675| v0_10(void) = ReturnValue : r0_9, mu0_1 -# 675| v0_11(void) = UnmodeledUse : mu* -# 675| v0_12(void) = ExitFunction : +# 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) = ExitFunction : # 679| TakeReference() -> int & # 679| Block 0 # 679| v0_0(void) = EnterFunction : -# 679| mu0_1(unknown) = UnmodeledDefinition : -# 680| r0_2(glval) = VariableAddress[#return] : -# 680| r0_3(glval) = VariableAddress[g] : -# 680| mu0_4(int &) = Store : r0_2, r0_3 -# 679| r0_5(glval) = VariableAddress[#return] : -# 679| v0_6(void) = ReturnValue : r0_5, mu0_1 -# 679| v0_7(void) = UnmodeledUse : mu* -# 679| v0_8(void) = ExitFunction : +# 679| mu0_1(unknown) = AliasedDefinition : +# 679| mu0_2(unknown) = UnmodeledDefinition : +# 680| r0_3(glval) = VariableAddress[#return] : +# 680| r0_4(glval) = VariableAddress[g] : +# 680| mu0_5(int &) = Store : r0_3, r0_4 +# 679| r0_6(glval) = VariableAddress[#return] : +# 679| v0_7(void) = ReturnValue : r0_6, mu0_2 +# 679| v0_8(void) = UnmodeledUse : mu* +# 679| v0_9(void) = ExitFunction : # 685| InitReference(int) -> void # 685| Block 0 # 685| v0_0(void) = EnterFunction : -# 685| mu0_1(unknown) = UnmodeledDefinition : -# 685| r0_2(glval) = VariableAddress[x] : -# 685| mu0_3(int) = InitializeParameter[x] : r0_2 -# 686| r0_4(glval) = VariableAddress[r] : -# 686| r0_5(glval) = VariableAddress[x] : -# 686| mu0_6(int &) = Store : r0_4, r0_5 -# 687| r0_7(glval) = VariableAddress[r2] : -# 687| r0_8(glval) = VariableAddress[r] : -# 687| r0_9(int &) = Load : r0_8, mu0_1 -# 687| mu0_10(int &) = Store : r0_7, r0_9 -# 688| r0_11(glval) = VariableAddress[r3] : -# 688| r0_12(glval) = FunctionAddress[ReturnReference] : -# 688| r0_13(String &) = Call : r0_12 -# 688| r0_14(glval) = Convert : r0_13 -# 688| mu0_15(String &) = Store : r0_11, r0_14 -# 689| v0_16(void) = NoOp : -# 685| v0_17(void) = ReturnVoid : -# 685| v0_18(void) = UnmodeledUse : mu* -# 685| v0_19(void) = ExitFunction : +# 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| mu0_7(int &) = Store : r0_5, r0_6 +# 687| r0_8(glval) = VariableAddress[r2] : +# 687| r0_9(glval) = VariableAddress[r] : +# 687| r0_10(int &) = Load : r0_9, mu0_2 +# 687| mu0_11(int &) = Store : r0_8, r0_10 +# 688| r0_12(glval) = VariableAddress[r3] : +# 688| r0_13(glval) = FunctionAddress[ReturnReference] : +# 688| r0_14(String &) = Call : r0_13 +# 688| mu0_15(unknown) = ^CallSideEffect : mu0_2 +# 688| r0_16(glval) = Convert : r0_14 +# 688| mu0_17(String &) = Store : r0_12, r0_16 +# 689| v0_18(void) = NoOp : +# 685| v0_19(void) = ReturnVoid : +# 685| v0_20(void) = UnmodeledUse : mu* +# 685| v0_21(void) = ExitFunction : # 691| ArrayReferences() -> void # 691| Block 0 # 691| v0_0(void) = EnterFunction : -# 691| mu0_1(unknown) = UnmodeledDefinition : -# 692| r0_2(glval) = VariableAddress[a] : -# 692| mu0_3(int[10]) = Uninitialized : r0_2 -# 693| r0_4(glval) = VariableAddress[ra] : -# 693| r0_5(glval) = VariableAddress[a] : -# 693| mu0_6(int(&)[10]) = Store : r0_4, r0_5 -# 694| r0_7(glval) = VariableAddress[x] : -# 694| r0_8(glval) = VariableAddress[ra] : -# 694| r0_9(int(&)[10]) = Load : r0_8, mu0_1 -# 694| r0_10(int *) = Convert : r0_9 -# 694| r0_11(int) = Constant[5] : -# 694| r0_12(int *) = PointerAdd[4] : r0_10, r0_11 -# 694| r0_13(int) = Load : r0_12, mu0_1 -# 694| mu0_14(int) = Store : r0_7, r0_13 -# 695| v0_15(void) = NoOp : -# 691| v0_16(void) = ReturnVoid : -# 691| v0_17(void) = UnmodeledUse : mu* -# 691| v0_18(void) = ExitFunction : +# 691| mu0_1(unknown) = AliasedDefinition : +# 691| mu0_2(unknown) = UnmodeledDefinition : +# 692| r0_3(glval) = VariableAddress[a] : +# 692| mu0_4(int[10]) = Uninitialized : r0_3 +# 693| r0_5(glval) = VariableAddress[ra] : +# 693| r0_6(glval) = VariableAddress[a] : +# 693| mu0_7(int(&)[10]) = Store : r0_5, r0_6 +# 694| r0_8(glval) = VariableAddress[x] : +# 694| r0_9(glval) = VariableAddress[ra] : +# 694| r0_10(int(&)[10]) = Load : r0_9, mu0_2 +# 694| r0_11(int *) = Convert : r0_10 +# 694| r0_12(int) = Constant[5] : +# 694| r0_13(int *) = PointerAdd[4] : r0_11, r0_12 +# 694| r0_14(int) = Load : r0_13, mu0_2 +# 694| mu0_15(int) = Store : r0_8, r0_14 +# 695| v0_16(void) = NoOp : +# 691| v0_17(void) = ReturnVoid : +# 691| v0_18(void) = UnmodeledUse : mu* +# 691| v0_19(void) = ExitFunction : # 697| FunctionReferences() -> void # 697| Block 0 -# 697| v0_0(void) = EnterFunction : -# 697| mu0_1(unknown) = UnmodeledDefinition : -# 698| r0_2(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r0_3(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| mu0_4(..(&)(..)) = Store : r0_2, r0_3 -# 699| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r0_6(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r0_7(..(&)(..)) = Load : r0_6, mu0_1 -# 699| mu0_8(..(*)(..)) = Store : r0_5, r0_7 -# 700| r0_9(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r0_10(..(&)(..)) = Load : r0_9, mu0_1 -# 700| r0_11(int) = Constant[5] : -# 700| r0_12(int) = Call : r0_10, r0_11 -# 701| v0_13(void) = NoOp : -# 697| v0_14(void) = ReturnVoid : -# 697| v0_15(void) = UnmodeledUse : mu* -# 697| v0_16(void) = ExitFunction : +# 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| mu0_5(..(&)(..)) = Store : r0_3, r0_4 +# 699| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r0_7(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r0_8(..(&)(..)) = Load : r0_7, mu0_2 +# 699| mu0_9(..(*)(..)) = Store : r0_6, r0_8 +# 700| r0_10(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r0_11(..(&)(..)) = Load : r0_10, mu0_2 +# 700| r0_12(int) = Constant[5] : +# 700| r0_13(int) = Call : r0_11, r0_12 +# 700| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 701| v0_15(void) = NoOp : +# 697| v0_16(void) = ReturnVoid : +# 697| v0_17(void) = UnmodeledUse : mu* +# 697| v0_18(void) = ExitFunction : # 704| min(int, int) -> int # 704| Block 0 -# 704| v0_0(void) = EnterFunction : -# 704| mu0_1(unknown) = UnmodeledDefinition : -# 704| r0_2(glval) = VariableAddress[x] : -# 704| mu0_3(int) = InitializeParameter[x] : r0_2 -# 704| r0_4(glval) = VariableAddress[y] : -# 704| mu0_5(int) = InitializeParameter[y] : r0_4 -# 705| r0_6(glval) = VariableAddress[#return] : -# 705| r0_7(glval) = VariableAddress[x] : -# 705| r0_8(int) = Load : r0_7, mu0_1 -# 705| r0_9(glval) = VariableAddress[y] : -# 705| r0_10(int) = Load : r0_9, mu0_1 -# 705| r0_11(bool) = CompareLT : r0_8, r0_10 -# 705| v0_12(void) = ConditionalBranch : r0_11 +# 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 #-----| False -> Block 2 #-----| True -> Block 1 # 705| Block 1 # 705| r1_0(glval) = VariableAddress[x] : -# 705| r1_1(int) = Load : r1_0, mu0_1 +# 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 #-----| Goto -> Block 3 # 705| Block 2 # 705| r2_0(glval) = VariableAddress[y] : -# 705| r2_1(int) = Load : r2_0, mu0_1 +# 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 #-----| Goto -> Block 3 # 705| Block 3 # 705| r3_0(glval) = VariableAddress[#temp705:10] : -# 705| r3_1(int) = Load : r3_0, mu0_1 -# 705| mu3_2(int) = Store : r0_6, r3_1 +# 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_1 +# 704| v3_4(void) = ReturnValue : r3_3, mu0_2 # 704| v3_5(void) = UnmodeledUse : mu* # 704| v3_6(void) = ExitFunction : # 708| CallMin(int, int) -> int # 708| Block 0 # 708| v0_0(void) = EnterFunction : -# 708| mu0_1(unknown) = UnmodeledDefinition : -# 708| r0_2(glval) = VariableAddress[x] : -# 708| mu0_3(int) = InitializeParameter[x] : r0_2 -# 708| r0_4(glval) = VariableAddress[y] : -# 708| mu0_5(int) = InitializeParameter[y] : r0_4 -# 709| r0_6(glval) = VariableAddress[#return] : -# 709| r0_7(glval) = FunctionAddress[min] : -# 709| r0_8(glval) = VariableAddress[x] : -# 709| r0_9(int) = Load : r0_8, mu0_1 -# 709| r0_10(glval) = VariableAddress[y] : -# 709| r0_11(int) = Load : r0_10, mu0_1 -# 709| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 709| mu0_13(int) = Store : r0_6, r0_12 -# 708| r0_14(glval) = VariableAddress[#return] : -# 708| v0_15(void) = ReturnValue : r0_14, mu0_1 -# 708| v0_16(void) = UnmodeledUse : mu* -# 708| v0_17(void) = ExitFunction : +# 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 : r0_8, r0_10, 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) = ExitFunction : # 715| Outer::Func(void *, char) -> long # 715| Block 0 # 715| v0_0(void) = EnterFunction : -# 715| mu0_1(unknown) = UnmodeledDefinition : -# 715| r0_2(glval) = VariableAddress[x] : -# 715| mu0_3(void *) = InitializeParameter[x] : r0_2 -# 715| r0_4(glval) = VariableAddress[y] : -# 715| mu0_5(char) = InitializeParameter[y] : r0_4 -# 716| r0_6(glval) = VariableAddress[#return] : -# 716| r0_7(long) = Constant[0] : -# 716| mu0_8(long) = Store : r0_6, r0_7 -# 715| r0_9(glval) = VariableAddress[#return] : -# 715| v0_10(void) = ReturnValue : r0_9, mu0_1 -# 715| v0_11(void) = UnmodeledUse : mu* -# 715| v0_12(void) = ExitFunction : +# 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) = ExitFunction : # 720| CallNestedTemplateFunc() -> double # 720| Block 0 # 720| v0_0(void) = EnterFunction : -# 720| mu0_1(unknown) = UnmodeledDefinition : -# 721| r0_2(glval) = VariableAddress[#return] : -# 721| r0_3(glval) = FunctionAddress[Func] : -# 721| r0_4(void *) = Constant[0] : -# 721| r0_5(char) = Constant[111] : -# 721| r0_6(long) = Call : r0_3, r0_4, r0_5 -# 721| r0_7(double) = Convert : r0_6 -# 721| mu0_8(double) = Store : r0_2, r0_7 -# 720| r0_9(glval) = VariableAddress[#return] : -# 720| v0_10(void) = ReturnValue : r0_9, mu0_1 -# 720| v0_11(void) = UnmodeledUse : mu* -# 720| v0_12(void) = ExitFunction : +# 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 : r0_4, r0_5, r0_6 +# 721| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 721| r0_9(double) = Convert : r0_7 +# 721| mu0_10(double) = Store : r0_3, r0_9 +# 720| r0_11(glval) = VariableAddress[#return] : +# 720| v0_12(void) = ReturnValue : r0_11, mu0_2 +# 720| v0_13(void) = UnmodeledUse : mu* +# 720| v0_14(void) = ExitFunction : # 724| TryCatch(bool) -> void # 724| Block 0 # 724| v0_0(void) = EnterFunction : -# 724| mu0_1(unknown) = UnmodeledDefinition : -# 724| r0_2(glval) = VariableAddress[b] : -# 724| mu0_3(bool) = InitializeParameter[b] : r0_2 -# 726| r0_4(glval) = VariableAddress[x] : -# 726| r0_5(int) = Constant[5] : -# 726| mu0_6(int) = Store : r0_4, r0_5 -# 727| r0_7(glval) = VariableAddress[b] : -# 727| r0_8(bool) = Load : r0_7, mu0_1 -# 727| v0_9(void) = ConditionalBranch : r0_8 +# 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 #-----| False -> Block 4 #-----| True -> Block 3 @@ -2999,12 +3105,12 @@ ir.cpp: # 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_1 +# 728| v3_4(void) = ThrowValue : r3_0, mu0_2 #-----| Exception -> Block 9 # 730| Block 4 # 730| r4_0(glval) = VariableAddress[x] : -# 730| r4_1(int) = Load : r4_0, mu0_1 +# 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 @@ -3013,7 +3119,7 @@ ir.cpp: # 731| Block 5 # 731| r5_0(glval) = VariableAddress[b] : -# 731| r5_1(bool) = Load : r5_0, mu0_1 +# 731| r5_1(bool) = Load : r5_0, mu0_2 # 731| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 7 #-----| True -> Block 6 @@ -3023,7 +3129,7 @@ ir.cpp: # 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_1 +# 731| r6_4(int) = Load : r6_3, mu0_2 # 731| r6_5(glval) = VariableAddress[x] : # 731| mu6_6(int) = Store : r6_5, r6_4 #-----| Goto -> Block 8 @@ -3034,7 +3140,8 @@ ir.cpp: # 731| r7_2(glval) = StringConstant["String object"] : # 731| r7_3(char *) = Convert : r7_2 # 731| v7_4(void) = Call : r7_1, this:r7_0, r7_3 -# 731| v7_5(void) = ThrowValue : r7_0, mu0_1 +# 731| mu7_5(unknown) = ^CallSideEffect : mu0_2 +# 731| v7_6(void) = ThrowValue : r7_0, mu0_2 #-----| Exception -> Block 9 # 733| Block 8 @@ -3054,9 +3161,10 @@ ir.cpp: # 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_1 +# 736| r10_5(char *) = Load : r10_4, mu0_2 # 736| v10_6(void) = Call : r10_3, this:r10_2, r10_5 -# 736| v10_7(void) = ThrowValue : r10_2, mu0_1 +# 736| mu10_7(unknown) = ^CallSideEffect : mu0_2 +# 736| v10_8(void) = ThrowValue : r10_2, mu0_2 #-----| Exception -> Block 2 # 738| Block 11 @@ -3083,728 +3191,809 @@ ir.cpp: # 745| Base::Base(const Base &) -> void # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| mu0_4(Base &) = InitializeParameter[p#0] : r0_3 -# 745| r0_5(glval) = FieldAddress[base_s] : r0_2 -# 745| r0_6(glval) = FunctionAddress[String] : -# 745| v0_7(void) = Call : r0_6, this:r0_5 -# 745| v0_8(void) = NoOp : -# 745| v0_9(void) = ReturnVoid : -# 745| v0_10(void) = UnmodeledUse : mu* -# 745| v0_11(void) = ExitFunction : +# 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 : r0_7, this:r0_6 +# 745| mu0_9(unknown) = ^CallSideEffect : mu0_2 +# 745| v0_10(void) = NoOp : +# 745| v0_11(void) = ReturnVoid : +# 745| v0_12(void) = UnmodeledUse : mu* +# 745| v0_13(void) = ExitFunction : # 745| Base::operator=(const Base &) -> Base & # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| mu0_4(Base &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Base *) = CopyValue : r0_2 -#-----| r0_6(glval) = FieldAddress[base_s] : r0_5 -# 745| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Base &) = Load : r0_8, mu0_1 -#-----| r0_10(glval) = FieldAddress[base_s] : r0_9 -# 745| r0_11(String &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(glval) = VariableAddress[#return] : -#-----| r0_13(Base *) = CopyValue : r0_2 -#-----| mu0_14(Base &) = Store : r0_12, r0_13 -# 745| r0_15(glval) = VariableAddress[#return] : -# 745| v0_16(void) = ReturnValue : r0_15, mu0_1 -# 745| v0_17(void) = UnmodeledUse : mu* -# 745| v0_18(void) = ExitFunction : +# 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 +# 745| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Base &) = Load : r0_9, mu0_2 +#-----| r0_11(glval) = FieldAddress[base_s] : r0_10 +# 745| r0_12(String &) = Call : r0_8, this:r0_7, r0_11 +# 745| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(glval) = VariableAddress[#return] : +#-----| r0_15(Base *) = CopyValue : r0_3 +#-----| mu0_16(Base &) = Store : r0_14, r0_15 +# 745| r0_17(glval) = VariableAddress[#return] : +# 745| v0_18(void) = ReturnValue : r0_17, mu0_2 +# 745| v0_19(void) = UnmodeledUse : mu* +# 745| v0_20(void) = ExitFunction : # 748| Base::Base() -> void # 748| Block 0 # 748| v0_0(void) = EnterFunction : -# 748| mu0_1(unknown) = UnmodeledDefinition : -# 748| r0_2(glval) = InitializeThis : -# 748| r0_3(glval) = FieldAddress[base_s] : r0_2 -# 748| r0_4(glval) = FunctionAddress[String] : -# 748| v0_5(void) = Call : r0_4, this:r0_3 -# 749| v0_6(void) = NoOp : -# 748| v0_7(void) = ReturnVoid : -# 748| v0_8(void) = UnmodeledUse : mu* -# 748| v0_9(void) = ExitFunction : +# 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 : r0_5, this:r0_4 +# 748| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 749| v0_8(void) = NoOp : +# 748| v0_9(void) = ReturnVoid : +# 748| v0_10(void) = UnmodeledUse : mu* +# 748| v0_11(void) = ExitFunction : # 750| Base::~Base() -> void # 750| Block 0 # 750| v0_0(void) = EnterFunction : -# 750| mu0_1(unknown) = UnmodeledDefinition : -# 750| r0_2(glval) = InitializeThis : -# 751| v0_3(void) = NoOp : -# 751| r0_4(glval) = FieldAddress[base_s] : r0_2 -# 751| r0_5(glval) = FunctionAddress[~String] : -# 751| v0_6(void) = Call : r0_5, this:r0_4 -# 750| v0_7(void) = ReturnVoid : -# 750| v0_8(void) = UnmodeledUse : mu* -# 750| v0_9(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 754| Middle::operator=(const Middle &) -> Middle & # 754| Block 0 # 754| v0_0(void) = EnterFunction : -# 754| mu0_1(unknown) = UnmodeledDefinition : -# 754| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| mu0_4(Middle &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Middle *) = CopyValue : r0_2 -#-----| r0_6(Base *) = ConvertToBase[Middle : Base] : r0_5 -# 754| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Middle &) = Load : r0_8, mu0_1 -#-----| r0_10(Base *) = ConvertToBase[Middle : Base] : r0_9 -# 754| r0_11(Base &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Middle *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[middle_s] : r0_12 -# 754| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Middle &) = Load : r0_15, mu0_1 -#-----| r0_17(glval) = FieldAddress[middle_s] : r0_16 -# 754| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Middle *) = CopyValue : r0_2 -#-----| mu0_21(Middle &) = Store : r0_19, r0_20 -# 754| r0_22(glval) = VariableAddress[#return] : -# 754| v0_23(void) = ReturnValue : r0_22, mu0_1 -# 754| v0_24(void) = UnmodeledUse : mu* -# 754| v0_25(void) = ExitFunction : +# 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 *) = ConvertToBase[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(Base *) = ConvertToBase[Middle : Base] : r0_10 +# 754| r0_12(Base &) = Call : r0_8, this:r0_7, r0_11 +# 754| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(Middle *) = CopyValue : r0_3 +#-----| r0_15(glval) = FieldAddress[middle_s] : r0_14 +# 754| r0_16(glval) = FunctionAddress[operator=] : +#-----| r0_17(glval) = VariableAddress[p#0] : +#-----| r0_18(Middle &) = Load : r0_17, mu0_2 +#-----| r0_19(glval) = FieldAddress[middle_s] : r0_18 +# 754| r0_20(String &) = Call : r0_16, this:r0_15, r0_19 +# 754| mu0_21(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_22(glval) = VariableAddress[#return] : +#-----| r0_23(Middle *) = CopyValue : r0_3 +#-----| mu0_24(Middle &) = Store : r0_22, r0_23 +# 754| r0_25(glval) = VariableAddress[#return] : +# 754| v0_26(void) = ReturnValue : r0_25, mu0_2 +# 754| v0_27(void) = UnmodeledUse : mu* +# 754| v0_28(void) = ExitFunction : # 757| Middle::Middle() -> void # 757| Block 0 # 757| v0_0(void) = EnterFunction : -# 757| mu0_1(unknown) = UnmodeledDefinition : -# 757| r0_2(glval) = InitializeThis : -# 757| r0_3(glval) = ConvertToBase[Middle : Base] : r0_2 -# 757| r0_4(glval) = FunctionAddress[Base] : -# 757| v0_5(void) = Call : r0_4, this:r0_3 -# 757| r0_6(glval) = FieldAddress[middle_s] : r0_2 -# 757| r0_7(glval) = FunctionAddress[String] : -# 757| v0_8(void) = Call : r0_7, this:r0_6 -# 758| v0_9(void) = NoOp : -# 757| v0_10(void) = ReturnVoid : -# 757| v0_11(void) = UnmodeledUse : mu* -# 757| v0_12(void) = ExitFunction : +# 757| mu0_1(unknown) = AliasedDefinition : +# 757| mu0_2(unknown) = UnmodeledDefinition : +# 757| r0_3(glval) = InitializeThis : +# 757| r0_4(glval) = ConvertToBase[Middle : Base] : r0_3 +# 757| r0_5(glval) = FunctionAddress[Base] : +# 757| v0_6(void) = Call : r0_5, this:r0_4 +# 757| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 757| r0_8(glval) = FieldAddress[middle_s] : r0_3 +# 757| r0_9(glval) = FunctionAddress[String] : +# 757| v0_10(void) = Call : r0_9, this:r0_8 +# 757| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 758| v0_12(void) = NoOp : +# 757| v0_13(void) = ReturnVoid : +# 757| v0_14(void) = UnmodeledUse : mu* +# 757| v0_15(void) = ExitFunction : # 759| Middle::~Middle() -> void # 759| Block 0 -# 759| v0_0(void) = EnterFunction : -# 759| mu0_1(unknown) = UnmodeledDefinition : -# 759| r0_2(glval) = InitializeThis : -# 760| v0_3(void) = NoOp : -# 760| r0_4(glval) = FieldAddress[middle_s] : r0_2 -# 760| r0_5(glval) = FunctionAddress[~String] : -# 760| v0_6(void) = Call : r0_5, this:r0_4 -# 760| r0_7(glval) = ConvertToBase[Middle : Base] : r0_2 -# 760| r0_8(glval) = FunctionAddress[~Base] : -# 760| v0_9(void) = Call : r0_8, this:r0_7 -# 759| v0_10(void) = ReturnVoid : -# 759| v0_11(void) = UnmodeledUse : mu* -# 759| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 760| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 760| r0_9(glval) = ConvertToBase[Middle : Base] : r0_3 +# 760| r0_10(glval) = FunctionAddress[~Base] : +# 760| v0_11(void) = Call : 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) = ExitFunction : # 763| Derived::operator=(const Derived &) -> Derived & # 763| Block 0 # 763| v0_0(void) = EnterFunction : -# 763| mu0_1(unknown) = UnmodeledDefinition : -# 763| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| mu0_4(Derived &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Derived *) = CopyValue : r0_2 -#-----| r0_6(Middle *) = ConvertToBase[Derived : Middle] : r0_5 -# 763| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Derived &) = Load : r0_8, mu0_1 -#-----| r0_10(Middle *) = ConvertToBase[Derived : Middle] : r0_9 -# 763| r0_11(Middle &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Derived *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[derived_s] : r0_12 -# 763| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Derived &) = Load : r0_15, mu0_1 -#-----| r0_17(glval) = FieldAddress[derived_s] : r0_16 -# 763| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Derived *) = CopyValue : r0_2 -#-----| mu0_21(Derived &) = Store : r0_19, r0_20 -# 763| r0_22(glval) = VariableAddress[#return] : -# 763| v0_23(void) = ReturnValue : r0_22, mu0_1 -# 763| v0_24(void) = UnmodeledUse : mu* -# 763| v0_25(void) = ExitFunction : +# 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 *) = ConvertToBase[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(Middle *) = ConvertToBase[Derived : Middle] : r0_10 +# 763| r0_12(Middle &) = Call : r0_8, this:r0_7, r0_11 +# 763| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(Derived *) = CopyValue : r0_3 +#-----| r0_15(glval) = FieldAddress[derived_s] : r0_14 +# 763| r0_16(glval) = FunctionAddress[operator=] : +#-----| r0_17(glval) = VariableAddress[p#0] : +#-----| r0_18(Derived &) = Load : r0_17, mu0_2 +#-----| r0_19(glval) = FieldAddress[derived_s] : r0_18 +# 763| r0_20(String &) = Call : r0_16, this:r0_15, r0_19 +# 763| mu0_21(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_22(glval) = VariableAddress[#return] : +#-----| r0_23(Derived *) = CopyValue : r0_3 +#-----| mu0_24(Derived &) = Store : r0_22, r0_23 +# 763| r0_25(glval) = VariableAddress[#return] : +# 763| v0_26(void) = ReturnValue : r0_25, mu0_2 +# 763| v0_27(void) = UnmodeledUse : mu* +# 763| v0_28(void) = ExitFunction : # 766| Derived::Derived() -> void # 766| Block 0 # 766| v0_0(void) = EnterFunction : -# 766| mu0_1(unknown) = UnmodeledDefinition : -# 766| r0_2(glval) = InitializeThis : -# 766| r0_3(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 766| r0_4(glval) = FunctionAddress[Middle] : -# 766| v0_5(void) = Call : r0_4, this:r0_3 -# 766| r0_6(glval) = FieldAddress[derived_s] : r0_2 -# 766| r0_7(glval) = FunctionAddress[String] : -# 766| v0_8(void) = Call : r0_7, this:r0_6 -# 767| v0_9(void) = NoOp : -# 766| v0_10(void) = ReturnVoid : -# 766| v0_11(void) = UnmodeledUse : mu* -# 766| v0_12(void) = ExitFunction : +# 766| mu0_1(unknown) = AliasedDefinition : +# 766| mu0_2(unknown) = UnmodeledDefinition : +# 766| r0_3(glval) = InitializeThis : +# 766| r0_4(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 766| r0_5(glval) = FunctionAddress[Middle] : +# 766| v0_6(void) = Call : r0_5, this:r0_4 +# 766| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 766| r0_8(glval) = FieldAddress[derived_s] : r0_3 +# 766| r0_9(glval) = FunctionAddress[String] : +# 766| v0_10(void) = Call : r0_9, this:r0_8 +# 766| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 767| v0_12(void) = NoOp : +# 766| v0_13(void) = ReturnVoid : +# 766| v0_14(void) = UnmodeledUse : mu* +# 766| v0_15(void) = ExitFunction : # 768| Derived::~Derived() -> void # 768| Block 0 -# 768| v0_0(void) = EnterFunction : -# 768| mu0_1(unknown) = UnmodeledDefinition : -# 768| r0_2(glval) = InitializeThis : -# 769| v0_3(void) = NoOp : -# 769| r0_4(glval) = FieldAddress[derived_s] : r0_2 -# 769| r0_5(glval) = FunctionAddress[~String] : -# 769| v0_6(void) = Call : r0_5, this:r0_4 -# 769| r0_7(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 769| r0_8(glval) = FunctionAddress[~Middle] : -# 769| v0_9(void) = Call : r0_8, this:r0_7 -# 768| v0_10(void) = ReturnVoid : -# 768| v0_11(void) = UnmodeledUse : mu* -# 768| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 769| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 769| r0_9(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 769| r0_10(glval) = FunctionAddress[~Middle] : +# 769| v0_11(void) = Call : 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) = ExitFunction : # 775| MiddleVB1::MiddleVB1() -> void # 775| Block 0 # 775| v0_0(void) = EnterFunction : -# 775| mu0_1(unknown) = UnmodeledDefinition : -# 775| r0_2(glval) = InitializeThis : -# 775| r0_3(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 775| r0_4(glval) = FunctionAddress[Base] : -# 775| v0_5(void) = Call : r0_4, this:r0_3 -# 775| r0_6(glval) = FieldAddress[middlevb1_s] : r0_2 -# 775| r0_7(glval) = FunctionAddress[String] : -# 775| v0_8(void) = Call : r0_7, this:r0_6 -# 776| v0_9(void) = NoOp : -# 775| v0_10(void) = ReturnVoid : -# 775| v0_11(void) = UnmodeledUse : mu* -# 775| v0_12(void) = ExitFunction : +# 775| mu0_1(unknown) = AliasedDefinition : +# 775| mu0_2(unknown) = UnmodeledDefinition : +# 775| r0_3(glval) = InitializeThis : +# 775| r0_4(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 775| r0_5(glval) = FunctionAddress[Base] : +# 775| v0_6(void) = Call : r0_5, this:r0_4 +# 775| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 775| r0_8(glval) = FieldAddress[middlevb1_s] : r0_3 +# 775| r0_9(glval) = FunctionAddress[String] : +# 775| v0_10(void) = Call : r0_9, this:r0_8 +# 775| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 776| v0_12(void) = NoOp : +# 775| v0_13(void) = ReturnVoid : +# 775| v0_14(void) = UnmodeledUse : mu* +# 775| v0_15(void) = ExitFunction : # 777| MiddleVB1::~MiddleVB1() -> void # 777| Block 0 # 777| v0_0(void) = EnterFunction : -# 777| mu0_1(unknown) = UnmodeledDefinition : -# 777| r0_2(glval) = InitializeThis : -# 778| v0_3(void) = NoOp : -# 778| r0_4(glval) = FieldAddress[middlevb1_s] : r0_2 -# 778| r0_5(glval) = FunctionAddress[~String] : -# 778| v0_6(void) = Call : r0_5, this:r0_4 -# 778| r0_7(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 778| r0_8(glval) = FunctionAddress[~Base] : -# 778| v0_9(void) = Call : r0_8, this:r0_7 -# 777| v0_10(void) = ReturnVoid : -# 777| v0_11(void) = UnmodeledUse : mu* -# 777| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 778| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 778| r0_9(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 778| r0_10(glval) = FunctionAddress[~Base] : +# 778| v0_11(void) = Call : 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) = ExitFunction : # 784| MiddleVB2::MiddleVB2() -> void # 784| Block 0 # 784| v0_0(void) = EnterFunction : -# 784| mu0_1(unknown) = UnmodeledDefinition : -# 784| r0_2(glval) = InitializeThis : -# 784| r0_3(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 784| r0_4(glval) = FunctionAddress[Base] : -# 784| v0_5(void) = Call : r0_4, this:r0_3 -# 784| r0_6(glval) = FieldAddress[middlevb2_s] : r0_2 -# 784| r0_7(glval) = FunctionAddress[String] : -# 784| v0_8(void) = Call : r0_7, this:r0_6 -# 785| v0_9(void) = NoOp : -# 784| v0_10(void) = ReturnVoid : -# 784| v0_11(void) = UnmodeledUse : mu* -# 784| v0_12(void) = ExitFunction : +# 784| mu0_1(unknown) = AliasedDefinition : +# 784| mu0_2(unknown) = UnmodeledDefinition : +# 784| r0_3(glval) = InitializeThis : +# 784| r0_4(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 784| r0_5(glval) = FunctionAddress[Base] : +# 784| v0_6(void) = Call : r0_5, this:r0_4 +# 784| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 784| r0_8(glval) = FieldAddress[middlevb2_s] : r0_3 +# 784| r0_9(glval) = FunctionAddress[String] : +# 784| v0_10(void) = Call : r0_9, this:r0_8 +# 784| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 785| v0_12(void) = NoOp : +# 784| v0_13(void) = ReturnVoid : +# 784| v0_14(void) = UnmodeledUse : mu* +# 784| v0_15(void) = ExitFunction : # 786| MiddleVB2::~MiddleVB2() -> void # 786| Block 0 # 786| v0_0(void) = EnterFunction : -# 786| mu0_1(unknown) = UnmodeledDefinition : -# 786| r0_2(glval) = InitializeThis : -# 787| v0_3(void) = NoOp : -# 787| r0_4(glval) = FieldAddress[middlevb2_s] : r0_2 -# 787| r0_5(glval) = FunctionAddress[~String] : -# 787| v0_6(void) = Call : r0_5, this:r0_4 -# 787| r0_7(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 787| r0_8(glval) = FunctionAddress[~Base] : -# 787| v0_9(void) = Call : r0_8, this:r0_7 -# 786| v0_10(void) = ReturnVoid : -# 786| v0_11(void) = UnmodeledUse : mu* -# 786| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 787| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 787| r0_9(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 787| r0_10(glval) = FunctionAddress[~Base] : +# 787| v0_11(void) = Call : 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) = ExitFunction : # 793| DerivedVB::DerivedVB() -> void # 793| Block 0 -# 793| v0_0(void) = EnterFunction : -# 793| mu0_1(unknown) = UnmodeledDefinition : -# 793| r0_2(glval) = InitializeThis : -# 793| r0_3(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 793| r0_4(glval) = FunctionAddress[Base] : -# 793| v0_5(void) = Call : r0_4, this:r0_3 -# 793| r0_6(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 793| r0_7(glval) = FunctionAddress[MiddleVB1] : -# 793| v0_8(void) = Call : r0_7, this:r0_6 -# 793| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 793| r0_10(glval) = FunctionAddress[MiddleVB2] : -# 793| v0_11(void) = Call : r0_10, this:r0_9 -# 793| r0_12(glval) = FieldAddress[derivedvb_s] : r0_2 -# 793| r0_13(glval) = FunctionAddress[String] : -# 793| v0_14(void) = Call : r0_13, this:r0_12 -# 794| v0_15(void) = NoOp : -# 793| v0_16(void) = ReturnVoid : -# 793| v0_17(void) = UnmodeledUse : mu* -# 793| v0_18(void) = ExitFunction : +# 793| v0_0(void) = EnterFunction : +# 793| mu0_1(unknown) = AliasedDefinition : +# 793| mu0_2(unknown) = UnmodeledDefinition : +# 793| r0_3(glval) = InitializeThis : +# 793| r0_4(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 793| r0_5(glval) = FunctionAddress[Base] : +# 793| v0_6(void) = Call : r0_5, this:r0_4 +# 793| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_8(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 793| r0_9(glval) = FunctionAddress[MiddleVB1] : +# 793| v0_10(void) = Call : r0_9, this:r0_8 +# 793| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_12(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 793| r0_13(glval) = FunctionAddress[MiddleVB2] : +# 793| v0_14(void) = Call : r0_13, this:r0_12 +# 793| mu0_15(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_16(glval) = FieldAddress[derivedvb_s] : r0_3 +# 793| r0_17(glval) = FunctionAddress[String] : +# 793| v0_18(void) = Call : r0_17, this:r0_16 +# 793| mu0_19(unknown) = ^CallSideEffect : mu0_2 +# 794| v0_20(void) = NoOp : +# 793| v0_21(void) = ReturnVoid : +# 793| v0_22(void) = UnmodeledUse : mu* +# 793| v0_23(void) = ExitFunction : # 795| DerivedVB::~DerivedVB() -> void # 795| Block 0 # 795| v0_0(void) = EnterFunction : -# 795| mu0_1(unknown) = UnmodeledDefinition : -# 795| r0_2(glval) = InitializeThis : -# 796| v0_3(void) = NoOp : -# 796| r0_4(glval) = FieldAddress[derivedvb_s] : r0_2 -# 796| r0_5(glval) = FunctionAddress[~String] : -# 796| v0_6(void) = Call : r0_5, this:r0_4 -# 796| r0_7(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 796| r0_8(glval) = FunctionAddress[~MiddleVB2] : -# 796| v0_9(void) = Call : r0_8, this:r0_7 -# 796| r0_10(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 796| r0_11(glval) = FunctionAddress[~MiddleVB1] : -# 796| v0_12(void) = Call : r0_11, this:r0_10 -# 796| r0_13(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 796| r0_14(glval) = FunctionAddress[~Base] : +# 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 : r0_6, this:r0_5 +# 796| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 796| r0_10(glval) = FunctionAddress[~MiddleVB2] : +# 796| v0_11(void) = Call : r0_10, this:r0_9 +# 796| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_13(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 796| r0_14(glval) = FunctionAddress[~MiddleVB1] : # 796| v0_15(void) = Call : r0_14, this:r0_13 -# 795| v0_16(void) = ReturnVoid : -# 795| v0_17(void) = UnmodeledUse : mu* -# 795| v0_18(void) = ExitFunction : +# 796| mu0_16(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_17(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 796| r0_18(glval) = FunctionAddress[~Base] : +# 796| v0_19(void) = Call : 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) = ExitFunction : # 799| HierarchyConversions() -> void # 799| Block 0 # 799| v0_0(void) = EnterFunction : -# 799| mu0_1(unknown) = UnmodeledDefinition : -# 800| r0_2(glval) = VariableAddress[b] : -# 800| r0_3(glval) = FunctionAddress[Base] : -# 800| v0_4(void) = Call : r0_3, this:r0_2 -# 801| r0_5(glval) = VariableAddress[m] : -# 801| r0_6(glval) = FunctionAddress[Middle] : -# 801| v0_7(void) = Call : r0_6, this:r0_5 -# 802| r0_8(glval) = VariableAddress[d] : -# 802| r0_9(glval) = FunctionAddress[Derived] : -# 802| v0_10(void) = Call : r0_9, this:r0_8 -# 804| r0_11(glval) = VariableAddress[pb] : -# 804| r0_12(glval) = VariableAddress[b] : -# 804| mu0_13(Base *) = Store : r0_11, r0_12 -# 805| r0_14(glval) = VariableAddress[pm] : -# 805| r0_15(glval) = VariableAddress[m] : -# 805| mu0_16(Middle *) = Store : r0_14, r0_15 -# 806| r0_17(glval) = VariableAddress[pd] : -# 806| r0_18(glval) = VariableAddress[d] : -# 806| mu0_19(Derived *) = Store : r0_17, r0_18 -# 808| r0_20(glval) = VariableAddress[b] : -# 808| r0_21(glval) = FunctionAddress[operator=] : -# 808| r0_22(glval) = VariableAddress[m] : -# 808| r0_23(glval) = ConvertToBase[Middle : Base] : r0_22 -# 808| r0_24(Base &) = Call : r0_21, this:r0_20, r0_23 -# 809| r0_25(glval) = VariableAddress[b] : -# 809| r0_26(glval) = FunctionAddress[operator=] : -# 809| r0_27(glval) = FunctionAddress[Base] : -# 809| r0_28(glval) = VariableAddress[m] : -# 809| r0_29(glval) = ConvertToBase[Middle : Base] : r0_28 -# 809| v0_30(void) = Call : r0_27, r0_29 -# 809| r0_31(Base) = Convert : v0_30 -# 809| r0_32(Base &) = Call : r0_26, this:r0_25, r0_31 -# 810| r0_33(glval) = VariableAddress[b] : -# 810| r0_34(glval) = FunctionAddress[operator=] : -# 810| r0_35(glval) = FunctionAddress[Base] : -# 810| r0_36(glval) = VariableAddress[m] : -# 810| r0_37(glval) = ConvertToBase[Middle : Base] : r0_36 -# 810| v0_38(void) = Call : r0_35, r0_37 -# 810| r0_39(Base) = Convert : v0_38 -# 810| r0_40(Base &) = Call : r0_34, this:r0_33, r0_39 -# 811| r0_41(glval) = VariableAddress[pm] : -# 811| r0_42(Middle *) = Load : r0_41, mu0_1 -# 811| r0_43(Base *) = ConvertToBase[Middle : Base] : r0_42 -# 811| r0_44(glval) = VariableAddress[pb] : -# 811| mu0_45(Base *) = Store : r0_44, r0_43 -# 812| r0_46(glval) = VariableAddress[pm] : -# 812| r0_47(Middle *) = Load : r0_46, mu0_1 -# 812| r0_48(Base *) = ConvertToBase[Middle : Base] : r0_47 -# 812| r0_49(glval) = VariableAddress[pb] : -# 812| mu0_50(Base *) = Store : r0_49, r0_48 -# 813| r0_51(glval) = VariableAddress[pm] : -# 813| r0_52(Middle *) = Load : r0_51, mu0_1 -# 813| r0_53(Base *) = ConvertToBase[Middle : Base] : r0_52 -# 813| r0_54(glval) = VariableAddress[pb] : -# 813| mu0_55(Base *) = Store : r0_54, r0_53 -# 814| r0_56(glval) = VariableAddress[pm] : -# 814| r0_57(Middle *) = Load : r0_56, mu0_1 -# 814| r0_58(Base *) = Convert : r0_57 -# 814| r0_59(glval) = VariableAddress[pb] : -# 814| mu0_60(Base *) = Store : r0_59, r0_58 -# 816| r0_61(glval) = VariableAddress[m] : -# 816| r0_62(glval) = FunctionAddress[operator=] : -# 816| r0_63(glval) = VariableAddress[b] : -# 816| r0_64(glval) = ConvertToDerived[Middle : Base] : r0_63 -# 816| r0_65(glval) = Convert : r0_64 -# 816| r0_66(Middle &) = Call : r0_62, this:r0_61, r0_65 -# 817| r0_67(glval) = VariableAddress[m] : -# 817| r0_68(glval) = FunctionAddress[operator=] : -# 817| r0_69(glval) = VariableAddress[b] : -# 817| r0_70(glval) = ConvertToDerived[Middle : Base] : r0_69 -# 817| r0_71(glval) = Convert : r0_70 -# 817| r0_72(Middle &) = Call : r0_68, this:r0_67, r0_71 -# 818| r0_73(glval) = VariableAddress[pb] : -# 818| r0_74(Base *) = Load : r0_73, mu0_1 -# 818| r0_75(Middle *) = ConvertToDerived[Middle : Base] : r0_74 -# 818| r0_76(glval) = VariableAddress[pm] : -# 818| mu0_77(Middle *) = Store : r0_76, r0_75 -# 819| r0_78(glval) = VariableAddress[pb] : -# 819| r0_79(Base *) = Load : r0_78, mu0_1 -# 819| r0_80(Middle *) = ConvertToDerived[Middle : Base] : r0_79 -# 819| r0_81(glval) = VariableAddress[pm] : -# 819| mu0_82(Middle *) = Store : r0_81, r0_80 -# 820| r0_83(glval) = VariableAddress[pb] : -# 820| r0_84(Base *) = Load : r0_83, mu0_1 -# 820| r0_85(Middle *) = Convert : r0_84 -# 820| r0_86(glval) = VariableAddress[pm] : -# 820| mu0_87(Middle *) = Store : r0_86, r0_85 -# 822| r0_88(glval) = VariableAddress[b] : -# 822| r0_89(glval) = FunctionAddress[operator=] : -# 822| r0_90(glval) = VariableAddress[d] : -# 822| r0_91(glval) = ConvertToBase[Derived : Middle] : r0_90 -# 822| r0_92(glval) = ConvertToBase[Middle : Base] : r0_91 -# 822| r0_93(Base &) = Call : r0_89, this:r0_88, r0_92 -# 823| r0_94(glval) = VariableAddress[b] : -# 823| r0_95(glval) = FunctionAddress[operator=] : -# 823| r0_96(glval) = FunctionAddress[Base] : -# 823| r0_97(glval) = VariableAddress[d] : -# 823| r0_98(glval) = ConvertToBase[Derived : Middle] : r0_97 -# 823| r0_99(glval) = ConvertToBase[Middle : Base] : r0_98 -# 823| v0_100(void) = Call : r0_96, r0_99 -# 823| r0_101(Base) = Convert : v0_100 -# 823| r0_102(Base &) = Call : r0_95, this:r0_94, r0_101 -# 824| r0_103(glval) = VariableAddress[b] : -# 824| r0_104(glval) = FunctionAddress[operator=] : -# 824| r0_105(glval) = FunctionAddress[Base] : -# 824| r0_106(glval) = VariableAddress[d] : -# 824| r0_107(glval) = ConvertToBase[Derived : Middle] : r0_106 -# 824| r0_108(glval) = ConvertToBase[Middle : Base] : r0_107 -# 824| v0_109(void) = Call : r0_105, r0_108 -# 824| r0_110(Base) = Convert : v0_109 -# 824| r0_111(Base &) = Call : r0_104, this:r0_103, r0_110 -# 825| r0_112(glval) = VariableAddress[pd] : -# 825| r0_113(Derived *) = Load : r0_112, mu0_1 -# 825| r0_114(Middle *) = ConvertToBase[Derived : Middle] : r0_113 -# 825| r0_115(Base *) = ConvertToBase[Middle : Base] : r0_114 -# 825| r0_116(glval) = VariableAddress[pb] : -# 825| mu0_117(Base *) = Store : r0_116, r0_115 -# 826| r0_118(glval) = VariableAddress[pd] : -# 826| r0_119(Derived *) = Load : r0_118, mu0_1 -# 826| r0_120(Middle *) = ConvertToBase[Derived : Middle] : r0_119 -# 826| r0_121(Base *) = ConvertToBase[Middle : Base] : r0_120 -# 826| r0_122(glval) = VariableAddress[pb] : -# 826| mu0_123(Base *) = Store : r0_122, r0_121 -# 827| r0_124(glval) = VariableAddress[pd] : -# 827| r0_125(Derived *) = Load : r0_124, mu0_1 -# 827| r0_126(Middle *) = ConvertToBase[Derived : Middle] : r0_125 -# 827| r0_127(Base *) = ConvertToBase[Middle : Base] : r0_126 -# 827| r0_128(glval) = VariableAddress[pb] : -# 827| mu0_129(Base *) = Store : r0_128, r0_127 -# 828| r0_130(glval) = VariableAddress[pd] : -# 828| r0_131(Derived *) = Load : r0_130, mu0_1 -# 828| r0_132(Base *) = Convert : r0_131 -# 828| r0_133(glval) = VariableAddress[pb] : -# 828| mu0_134(Base *) = Store : r0_133, r0_132 -# 830| r0_135(glval) = VariableAddress[d] : -# 830| r0_136(glval) = FunctionAddress[operator=] : -# 830| r0_137(glval) = VariableAddress[b] : -# 830| r0_138(glval) = ConvertToDerived[Middle : Base] : r0_137 -# 830| r0_139(glval) = ConvertToDerived[Derived : Middle] : r0_138 -# 830| r0_140(glval) = Convert : r0_139 -# 830| r0_141(Derived &) = Call : r0_136, this:r0_135, r0_140 -# 831| r0_142(glval) = VariableAddress[d] : -# 831| r0_143(glval) = FunctionAddress[operator=] : -# 831| r0_144(glval) = VariableAddress[b] : -# 831| r0_145(glval) = ConvertToDerived[Middle : Base] : r0_144 -# 831| r0_146(glval) = ConvertToDerived[Derived : Middle] : r0_145 -# 831| r0_147(glval) = Convert : r0_146 -# 831| r0_148(Derived &) = Call : r0_143, this:r0_142, r0_147 -# 832| r0_149(glval) = VariableAddress[pb] : -# 832| r0_150(Base *) = Load : r0_149, mu0_1 -# 832| r0_151(Middle *) = ConvertToDerived[Middle : Base] : r0_150 -# 832| r0_152(Derived *) = ConvertToDerived[Derived : Middle] : r0_151 -# 832| r0_153(glval) = VariableAddress[pd] : -# 832| mu0_154(Derived *) = Store : r0_153, r0_152 -# 833| r0_155(glval) = VariableAddress[pb] : -# 833| r0_156(Base *) = Load : r0_155, mu0_1 -# 833| r0_157(Middle *) = ConvertToDerived[Middle : Base] : r0_156 -# 833| r0_158(Derived *) = ConvertToDerived[Derived : Middle] : r0_157 -# 833| r0_159(glval) = VariableAddress[pd] : -# 833| mu0_160(Derived *) = Store : r0_159, r0_158 -# 834| r0_161(glval) = VariableAddress[pb] : -# 834| r0_162(Base *) = Load : r0_161, mu0_1 -# 834| r0_163(Derived *) = Convert : r0_162 -# 834| r0_164(glval) = VariableAddress[pd] : -# 834| mu0_165(Derived *) = Store : r0_164, r0_163 -# 836| r0_166(glval) = VariableAddress[pmv] : -# 836| r0_167(MiddleVB1 *) = Constant[0] : -# 836| mu0_168(MiddleVB1 *) = Store : r0_166, r0_167 -# 837| r0_169(glval) = VariableAddress[pdv] : -# 837| r0_170(DerivedVB *) = Constant[0] : -# 837| mu0_171(DerivedVB *) = Store : r0_169, r0_170 -# 838| r0_172(glval) = VariableAddress[pmv] : -# 838| r0_173(MiddleVB1 *) = Load : r0_172, mu0_1 -# 838| r0_174(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_173 -# 838| r0_175(glval) = VariableAddress[pb] : -# 838| mu0_176(Base *) = Store : r0_175, r0_174 -# 839| r0_177(glval) = VariableAddress[pdv] : -# 839| r0_178(DerivedVB *) = Load : r0_177, mu0_1 -# 839| r0_179(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_178 -# 839| r0_180(glval) = VariableAddress[pb] : -# 839| mu0_181(Base *) = Store : r0_180, r0_179 -# 840| v0_182(void) = NoOp : -# 799| v0_183(void) = ReturnVoid : -# 799| v0_184(void) = UnmodeledUse : mu* -# 799| v0_185(void) = ExitFunction : +# 799| mu0_1(unknown) = AliasedDefinition : +# 799| mu0_2(unknown) = UnmodeledDefinition : +# 800| r0_3(glval) = VariableAddress[b] : +# 800| r0_4(glval) = FunctionAddress[Base] : +# 800| v0_5(void) = Call : r0_4, this:r0_3 +# 800| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 801| r0_7(glval) = VariableAddress[m] : +# 801| r0_8(glval) = FunctionAddress[Middle] : +# 801| v0_9(void) = Call : r0_8, this:r0_7 +# 801| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 802| r0_11(glval) = VariableAddress[d] : +# 802| r0_12(glval) = FunctionAddress[Derived] : +# 802| v0_13(void) = Call : r0_12, this:r0_11 +# 802| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 804| r0_15(glval) = VariableAddress[pb] : +# 804| r0_16(glval) = VariableAddress[b] : +# 804| mu0_17(Base *) = Store : r0_15, r0_16 +# 805| r0_18(glval) = VariableAddress[pm] : +# 805| r0_19(glval) = VariableAddress[m] : +# 805| mu0_20(Middle *) = Store : r0_18, r0_19 +# 806| r0_21(glval) = VariableAddress[pd] : +# 806| r0_22(glval) = VariableAddress[d] : +# 806| mu0_23(Derived *) = Store : r0_21, r0_22 +# 808| r0_24(glval) = VariableAddress[b] : +# 808| r0_25(glval) = FunctionAddress[operator=] : +# 808| r0_26(glval) = VariableAddress[m] : +# 808| r0_27(glval) = ConvertToBase[Middle : Base] : r0_26 +# 808| r0_28(Base &) = Call : r0_25, this:r0_24, r0_27 +# 808| mu0_29(unknown) = ^CallSideEffect : mu0_2 +# 809| r0_30(glval) = VariableAddress[b] : +# 809| r0_31(glval) = FunctionAddress[operator=] : +# 809| r0_32(glval) = FunctionAddress[Base] : +# 809| r0_33(glval) = VariableAddress[m] : +# 809| r0_34(glval) = ConvertToBase[Middle : Base] : r0_33 +# 809| v0_35(void) = Call : r0_32, r0_34 +# 809| mu0_36(unknown) = ^CallSideEffect : mu0_2 +# 809| r0_37(Base) = Convert : v0_35 +# 809| r0_38(Base &) = Call : r0_31, this:r0_30, r0_37 +# 809| mu0_39(unknown) = ^CallSideEffect : mu0_2 +# 810| r0_40(glval) = VariableAddress[b] : +# 810| r0_41(glval) = FunctionAddress[operator=] : +# 810| r0_42(glval) = FunctionAddress[Base] : +# 810| r0_43(glval) = VariableAddress[m] : +# 810| r0_44(glval) = ConvertToBase[Middle : Base] : r0_43 +# 810| v0_45(void) = Call : r0_42, r0_44 +# 810| mu0_46(unknown) = ^CallSideEffect : mu0_2 +# 810| r0_47(Base) = Convert : v0_45 +# 810| r0_48(Base &) = Call : r0_41, this:r0_40, r0_47 +# 810| mu0_49(unknown) = ^CallSideEffect : mu0_2 +# 811| r0_50(glval) = VariableAddress[pm] : +# 811| r0_51(Middle *) = Load : r0_50, mu0_2 +# 811| r0_52(Base *) = ConvertToBase[Middle : Base] : r0_51 +# 811| r0_53(glval) = VariableAddress[pb] : +# 811| mu0_54(Base *) = Store : r0_53, r0_52 +# 812| r0_55(glval) = VariableAddress[pm] : +# 812| r0_56(Middle *) = Load : r0_55, mu0_2 +# 812| r0_57(Base *) = ConvertToBase[Middle : Base] : r0_56 +# 812| r0_58(glval) = VariableAddress[pb] : +# 812| mu0_59(Base *) = Store : r0_58, r0_57 +# 813| r0_60(glval) = VariableAddress[pm] : +# 813| r0_61(Middle *) = Load : r0_60, mu0_2 +# 813| r0_62(Base *) = ConvertToBase[Middle : Base] : r0_61 +# 813| r0_63(glval) = VariableAddress[pb] : +# 813| mu0_64(Base *) = Store : r0_63, r0_62 +# 814| r0_65(glval) = VariableAddress[pm] : +# 814| r0_66(Middle *) = Load : r0_65, mu0_2 +# 814| r0_67(Base *) = Convert : r0_66 +# 814| r0_68(glval) = VariableAddress[pb] : +# 814| mu0_69(Base *) = Store : r0_68, r0_67 +# 816| r0_70(glval) = VariableAddress[m] : +# 816| r0_71(glval) = FunctionAddress[operator=] : +# 816| r0_72(glval) = VariableAddress[b] : +# 816| r0_73(glval) = ConvertToDerived[Middle : Base] : r0_72 +# 816| r0_74(glval) = Convert : r0_73 +# 816| r0_75(Middle &) = Call : r0_71, this:r0_70, r0_74 +# 816| mu0_76(unknown) = ^CallSideEffect : mu0_2 +# 817| r0_77(glval) = VariableAddress[m] : +# 817| r0_78(glval) = FunctionAddress[operator=] : +# 817| r0_79(glval) = VariableAddress[b] : +# 817| r0_80(glval) = ConvertToDerived[Middle : Base] : r0_79 +# 817| r0_81(glval) = Convert : r0_80 +# 817| r0_82(Middle &) = Call : r0_78, this:r0_77, r0_81 +# 817| mu0_83(unknown) = ^CallSideEffect : mu0_2 +# 818| r0_84(glval) = VariableAddress[pb] : +# 818| r0_85(Base *) = Load : r0_84, mu0_2 +# 818| r0_86(Middle *) = ConvertToDerived[Middle : Base] : r0_85 +# 818| r0_87(glval) = VariableAddress[pm] : +# 818| mu0_88(Middle *) = Store : r0_87, r0_86 +# 819| r0_89(glval) = VariableAddress[pb] : +# 819| r0_90(Base *) = Load : r0_89, mu0_2 +# 819| r0_91(Middle *) = ConvertToDerived[Middle : Base] : r0_90 +# 819| r0_92(glval) = VariableAddress[pm] : +# 819| mu0_93(Middle *) = Store : r0_92, r0_91 +# 820| r0_94(glval) = VariableAddress[pb] : +# 820| r0_95(Base *) = Load : r0_94, mu0_2 +# 820| r0_96(Middle *) = Convert : r0_95 +# 820| r0_97(glval) = VariableAddress[pm] : +# 820| mu0_98(Middle *) = Store : r0_97, r0_96 +# 822| r0_99(glval) = VariableAddress[b] : +# 822| r0_100(glval) = FunctionAddress[operator=] : +# 822| r0_101(glval) = VariableAddress[d] : +# 822| r0_102(glval) = ConvertToBase[Derived : Middle] : r0_101 +# 822| r0_103(glval) = ConvertToBase[Middle : Base] : r0_102 +# 822| r0_104(Base &) = Call : r0_100, this:r0_99, r0_103 +# 822| mu0_105(unknown) = ^CallSideEffect : mu0_2 +# 823| r0_106(glval) = VariableAddress[b] : +# 823| r0_107(glval) = FunctionAddress[operator=] : +# 823| r0_108(glval) = FunctionAddress[Base] : +# 823| r0_109(glval) = VariableAddress[d] : +# 823| r0_110(glval) = ConvertToBase[Derived : Middle] : r0_109 +# 823| r0_111(glval) = ConvertToBase[Middle : Base] : r0_110 +# 823| v0_112(void) = Call : r0_108, r0_111 +# 823| mu0_113(unknown) = ^CallSideEffect : mu0_2 +# 823| r0_114(Base) = Convert : v0_112 +# 823| r0_115(Base &) = Call : r0_107, this:r0_106, r0_114 +# 823| mu0_116(unknown) = ^CallSideEffect : mu0_2 +# 824| r0_117(glval) = VariableAddress[b] : +# 824| r0_118(glval) = FunctionAddress[operator=] : +# 824| r0_119(glval) = FunctionAddress[Base] : +# 824| r0_120(glval) = VariableAddress[d] : +# 824| r0_121(glval) = ConvertToBase[Derived : Middle] : r0_120 +# 824| r0_122(glval) = ConvertToBase[Middle : Base] : r0_121 +# 824| v0_123(void) = Call : r0_119, r0_122 +# 824| mu0_124(unknown) = ^CallSideEffect : mu0_2 +# 824| r0_125(Base) = Convert : v0_123 +# 824| r0_126(Base &) = Call : r0_118, this:r0_117, r0_125 +# 824| mu0_127(unknown) = ^CallSideEffect : mu0_2 +# 825| r0_128(glval) = VariableAddress[pd] : +# 825| r0_129(Derived *) = Load : r0_128, mu0_2 +# 825| r0_130(Middle *) = ConvertToBase[Derived : Middle] : r0_129 +# 825| r0_131(Base *) = ConvertToBase[Middle : Base] : r0_130 +# 825| r0_132(glval) = VariableAddress[pb] : +# 825| mu0_133(Base *) = Store : r0_132, r0_131 +# 826| r0_134(glval) = VariableAddress[pd] : +# 826| r0_135(Derived *) = Load : r0_134, mu0_2 +# 826| r0_136(Middle *) = ConvertToBase[Derived : Middle] : r0_135 +# 826| r0_137(Base *) = ConvertToBase[Middle : Base] : r0_136 +# 826| r0_138(glval) = VariableAddress[pb] : +# 826| mu0_139(Base *) = Store : r0_138, r0_137 +# 827| r0_140(glval) = VariableAddress[pd] : +# 827| r0_141(Derived *) = Load : r0_140, mu0_2 +# 827| r0_142(Middle *) = ConvertToBase[Derived : Middle] : r0_141 +# 827| r0_143(Base *) = ConvertToBase[Middle : Base] : r0_142 +# 827| r0_144(glval) = VariableAddress[pb] : +# 827| mu0_145(Base *) = Store : r0_144, r0_143 +# 828| r0_146(glval) = VariableAddress[pd] : +# 828| r0_147(Derived *) = Load : r0_146, mu0_2 +# 828| r0_148(Base *) = Convert : r0_147 +# 828| r0_149(glval) = VariableAddress[pb] : +# 828| mu0_150(Base *) = Store : r0_149, r0_148 +# 830| r0_151(glval) = VariableAddress[d] : +# 830| r0_152(glval) = FunctionAddress[operator=] : +# 830| r0_153(glval) = VariableAddress[b] : +# 830| r0_154(glval) = ConvertToDerived[Middle : Base] : r0_153 +# 830| r0_155(glval) = ConvertToDerived[Derived : Middle] : r0_154 +# 830| r0_156(glval) = Convert : r0_155 +# 830| r0_157(Derived &) = Call : r0_152, this:r0_151, r0_156 +# 830| mu0_158(unknown) = ^CallSideEffect : mu0_2 +# 831| r0_159(glval) = VariableAddress[d] : +# 831| r0_160(glval) = FunctionAddress[operator=] : +# 831| r0_161(glval) = VariableAddress[b] : +# 831| r0_162(glval) = ConvertToDerived[Middle : Base] : r0_161 +# 831| r0_163(glval) = ConvertToDerived[Derived : Middle] : r0_162 +# 831| r0_164(glval) = Convert : r0_163 +# 831| r0_165(Derived &) = Call : r0_160, this:r0_159, r0_164 +# 831| mu0_166(unknown) = ^CallSideEffect : mu0_2 +# 832| r0_167(glval) = VariableAddress[pb] : +# 832| r0_168(Base *) = Load : r0_167, mu0_2 +# 832| r0_169(Middle *) = ConvertToDerived[Middle : Base] : r0_168 +# 832| r0_170(Derived *) = ConvertToDerived[Derived : Middle] : r0_169 +# 832| r0_171(glval) = VariableAddress[pd] : +# 832| mu0_172(Derived *) = Store : r0_171, r0_170 +# 833| r0_173(glval) = VariableAddress[pb] : +# 833| r0_174(Base *) = Load : r0_173, mu0_2 +# 833| r0_175(Middle *) = ConvertToDerived[Middle : Base] : r0_174 +# 833| r0_176(Derived *) = ConvertToDerived[Derived : Middle] : r0_175 +# 833| r0_177(glval) = VariableAddress[pd] : +# 833| mu0_178(Derived *) = Store : r0_177, r0_176 +# 834| r0_179(glval) = VariableAddress[pb] : +# 834| r0_180(Base *) = Load : r0_179, mu0_2 +# 834| r0_181(Derived *) = Convert : r0_180 +# 834| r0_182(glval) = VariableAddress[pd] : +# 834| mu0_183(Derived *) = Store : r0_182, r0_181 +# 836| r0_184(glval) = VariableAddress[pmv] : +# 836| r0_185(MiddleVB1 *) = Constant[0] : +# 836| mu0_186(MiddleVB1 *) = Store : r0_184, r0_185 +# 837| r0_187(glval) = VariableAddress[pdv] : +# 837| r0_188(DerivedVB *) = Constant[0] : +# 837| mu0_189(DerivedVB *) = Store : r0_187, r0_188 +# 838| r0_190(glval) = VariableAddress[pmv] : +# 838| r0_191(MiddleVB1 *) = Load : r0_190, mu0_2 +# 838| r0_192(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_191 +# 838| r0_193(glval) = VariableAddress[pb] : +# 838| mu0_194(Base *) = Store : r0_193, r0_192 +# 839| r0_195(glval) = VariableAddress[pdv] : +# 839| r0_196(DerivedVB *) = Load : r0_195, mu0_2 +# 839| r0_197(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_196 +# 839| r0_198(glval) = VariableAddress[pb] : +# 839| mu0_199(Base *) = Store : r0_198, r0_197 +# 840| v0_200(void) = NoOp : +# 799| v0_201(void) = ReturnVoid : +# 799| v0_202(void) = UnmodeledUse : mu* +# 799| v0_203(void) = ExitFunction : # 842| PolymorphicBase::PolymorphicBase() -> void # 842| Block 0 # 842| v0_0(void) = EnterFunction : -# 842| mu0_1(unknown) = UnmodeledDefinition : -# 842| r0_2(glval) = InitializeThis : -# 842| v0_3(void) = NoOp : -# 842| v0_4(void) = ReturnVoid : -# 842| v0_5(void) = UnmodeledUse : mu* -# 842| v0_6(void) = ExitFunction : +# 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) = ExitFunction : # 846| PolymorphicDerived::PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -# 846| r0_3(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_4(glval) = FunctionAddress[PolymorphicBase] : -# 846| v0_5(void) = Call : r0_4, this:r0_3 -# 846| v0_6(void) = NoOp : -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| mu0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_5(glval) = FunctionAddress[PolymorphicBase] : +# 846| v0_6(void) = Call : r0_5, this:r0_4 +# 846| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 846| v0_8(void) = NoOp : +# 846| v0_9(void) = ReturnVoid : +# 846| v0_10(void) = UnmodeledUse : mu* +# 846| v0_11(void) = ExitFunction : # 846| PolymorphicDerived::~PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -#-----| v0_3(void) = NoOp : -# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_5(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v0_6(void) = Call : r0_5, this:r0_4 -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| mu0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +#-----| v0_4(void) = NoOp : +# 846| r0_5(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_6(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v0_7(void) = Call : 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) = ExitFunction : # 849| DynamicCast() -> void # 849| Block 0 # 849| v0_0(void) = EnterFunction : -# 849| mu0_1(unknown) = UnmodeledDefinition : -# 850| r0_2(glval) = VariableAddress[b] : -#-----| r0_3(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_4(void) = Call : r0_3, this:r0_2 -# 851| r0_5(glval) = VariableAddress[d] : -# 851| r0_6(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v0_7(void) = Call : r0_6, this:r0_5 -# 853| r0_8(glval) = VariableAddress[pb] : -# 853| r0_9(glval) = VariableAddress[b] : -# 853| mu0_10(PolymorphicBase *) = Store : r0_8, r0_9 -# 854| r0_11(glval) = VariableAddress[pd] : -# 854| r0_12(glval) = VariableAddress[d] : -# 854| mu0_13(PolymorphicDerived *) = Store : r0_11, r0_12 -# 857| r0_14(glval) = VariableAddress[pd] : -# 857| r0_15(PolymorphicDerived *) = Load : r0_14, mu0_1 -# 857| r0_16(PolymorphicBase *) = CheckedConvertOrNull : r0_15 -# 857| r0_17(glval) = VariableAddress[pb] : -# 857| mu0_18(PolymorphicBase *) = Store : r0_17, r0_16 -# 858| r0_19(glval) = VariableAddress[rb] : -# 858| r0_20(glval) = VariableAddress[d] : -# 858| r0_21(glval) = CheckedConvertOrThrow : r0_20 -# 858| mu0_22(PolymorphicBase &) = Store : r0_19, r0_21 -# 860| r0_23(glval) = VariableAddress[pb] : -# 860| r0_24(PolymorphicBase *) = Load : r0_23, mu0_1 -# 860| r0_25(PolymorphicDerived *) = CheckedConvertOrNull : r0_24 -# 860| r0_26(glval) = VariableAddress[pd] : -# 860| mu0_27(PolymorphicDerived *) = Store : r0_26, r0_25 -# 861| r0_28(glval) = VariableAddress[rd] : -# 861| r0_29(glval) = VariableAddress[b] : -# 861| r0_30(glval) = CheckedConvertOrThrow : r0_29 -# 861| mu0_31(PolymorphicDerived &) = Store : r0_28, r0_30 -# 863| r0_32(glval) = VariableAddress[pv] : -# 863| r0_33(glval) = VariableAddress[pb] : -# 863| r0_34(PolymorphicBase *) = Load : r0_33, mu0_1 -# 863| r0_35(void *) = DynamicCastToVoid : r0_34 -# 863| mu0_36(void *) = Store : r0_32, r0_35 -# 864| r0_37(glval) = VariableAddress[pcv] : -# 864| r0_38(glval) = VariableAddress[pd] : -# 864| r0_39(PolymorphicDerived *) = Load : r0_38, mu0_1 -# 864| r0_40(void *) = DynamicCastToVoid : r0_39 -# 864| mu0_41(void *) = Store : r0_37, r0_40 -# 865| v0_42(void) = NoOp : -# 849| v0_43(void) = ReturnVoid : -# 849| v0_44(void) = UnmodeledUse : mu* -# 849| v0_45(void) = ExitFunction : +# 849| mu0_1(unknown) = AliasedDefinition : +# 849| mu0_2(unknown) = UnmodeledDefinition : +# 850| r0_3(glval) = VariableAddress[b] : +#-----| r0_4(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_5(void) = Call : r0_4, this:r0_3 +#-----| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 851| r0_7(glval) = VariableAddress[d] : +# 851| r0_8(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v0_9(void) = Call : r0_8, this:r0_7 +# 851| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 853| r0_11(glval) = VariableAddress[pb] : +# 853| r0_12(glval) = VariableAddress[b] : +# 853| mu0_13(PolymorphicBase *) = Store : r0_11, r0_12 +# 854| r0_14(glval) = VariableAddress[pd] : +# 854| r0_15(glval) = VariableAddress[d] : +# 854| mu0_16(PolymorphicDerived *) = Store : r0_14, r0_15 +# 857| r0_17(glval) = VariableAddress[pd] : +# 857| r0_18(PolymorphicDerived *) = Load : r0_17, mu0_2 +# 857| r0_19(PolymorphicBase *) = CheckedConvertOrNull : r0_18 +# 857| r0_20(glval) = VariableAddress[pb] : +# 857| mu0_21(PolymorphicBase *) = Store : r0_20, r0_19 +# 858| r0_22(glval) = VariableAddress[rb] : +# 858| r0_23(glval) = VariableAddress[d] : +# 858| r0_24(glval) = CheckedConvertOrThrow : r0_23 +# 858| mu0_25(PolymorphicBase &) = Store : r0_22, r0_24 +# 860| r0_26(glval) = VariableAddress[pb] : +# 860| r0_27(PolymorphicBase *) = Load : r0_26, mu0_2 +# 860| r0_28(PolymorphicDerived *) = CheckedConvertOrNull : r0_27 +# 860| r0_29(glval) = VariableAddress[pd] : +# 860| mu0_30(PolymorphicDerived *) = Store : r0_29, r0_28 +# 861| r0_31(glval) = VariableAddress[rd] : +# 861| r0_32(glval) = VariableAddress[b] : +# 861| r0_33(glval) = CheckedConvertOrThrow : r0_32 +# 861| mu0_34(PolymorphicDerived &) = Store : r0_31, r0_33 +# 863| r0_35(glval) = VariableAddress[pv] : +# 863| r0_36(glval) = VariableAddress[pb] : +# 863| r0_37(PolymorphicBase *) = Load : r0_36, mu0_2 +# 863| r0_38(void *) = DynamicCastToVoid : r0_37 +# 863| mu0_39(void *) = Store : r0_35, r0_38 +# 864| r0_40(glval) = VariableAddress[pcv] : +# 864| r0_41(glval) = VariableAddress[pd] : +# 864| r0_42(PolymorphicDerived *) = Load : r0_41, mu0_2 +# 864| r0_43(void *) = DynamicCastToVoid : r0_42 +# 864| mu0_44(void *) = Store : r0_40, r0_43 +# 865| v0_45(void) = NoOp : +# 849| v0_46(void) = ReturnVoid : +# 849| v0_47(void) = UnmodeledUse : mu* +# 849| v0_48(void) = ExitFunction : # 867| String::String() -> void # 867| Block 0 # 867| v0_0(void) = EnterFunction : -# 867| mu0_1(unknown) = UnmodeledDefinition : -# 867| r0_2(glval) = InitializeThis : -# 868| r0_3(glval) = FunctionAddress[String] : -# 868| r0_4(glval) = StringConstant[""] : -# 868| r0_5(char *) = Convert : r0_4 -# 868| v0_6(void) = Call : r0_3, this:r0_2, r0_5 -# 869| v0_7(void) = NoOp : -# 867| v0_8(void) = ReturnVoid : -# 867| v0_9(void) = UnmodeledUse : mu* -# 867| v0_10(void) = ExitFunction : +# 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 : r0_4, this:r0_3, r0_6 +# 868| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 869| v0_9(void) = NoOp : +# 867| v0_10(void) = ReturnVoid : +# 867| v0_11(void) = UnmodeledUse : mu* +# 867| v0_12(void) = ExitFunction : # 871| ArrayConversions() -> void # 871| Block 0 # 871| v0_0(void) = EnterFunction : -# 871| mu0_1(unknown) = UnmodeledDefinition : -# 872| r0_2(glval) = VariableAddress[a] : -# 872| mu0_3(char[5]) = Uninitialized : r0_2 -# 873| r0_4(glval) = VariableAddress[p] : -# 873| r0_5(glval) = VariableAddress[a] : -# 873| r0_6(char *) = Convert : r0_5 +# 871| mu0_1(unknown) = AliasedDefinition : +# 871| mu0_2(unknown) = UnmodeledDefinition : +# 872| r0_3(glval) = VariableAddress[a] : +# 872| mu0_4(char[5]) = Uninitialized : r0_3 +# 873| r0_5(glval) = VariableAddress[p] : +# 873| r0_6(glval) = VariableAddress[a] : # 873| r0_7(char *) = Convert : r0_6 -# 873| mu0_8(char *) = Store : r0_4, r0_7 -# 874| r0_9(glval) = StringConstant["test"] : -# 874| r0_10(char *) = Convert : r0_9 -# 874| r0_11(glval) = VariableAddress[p] : -# 874| mu0_12(char *) = Store : r0_11, r0_10 -# 875| r0_13(glval) = VariableAddress[a] : -# 875| r0_14(char *) = Convert : r0_13 -# 875| r0_15(int) = Constant[0] : -# 875| r0_16(char *) = PointerAdd[1] : r0_14, r0_15 -# 875| r0_17(char *) = Convert : r0_16 -# 875| r0_18(glval) = VariableAddress[p] : -# 875| mu0_19(char *) = Store : r0_18, r0_17 -# 876| r0_20(glval) = StringConstant["test"] : -# 876| r0_21(char *) = Convert : r0_20 -# 876| r0_22(int) = Constant[0] : -# 876| r0_23(char *) = PointerAdd[1] : r0_21, r0_22 -# 876| r0_24(glval) = VariableAddress[p] : -# 876| mu0_25(char *) = Store : r0_24, r0_23 -# 877| r0_26(glval) = VariableAddress[ra] : -# 877| r0_27(glval) = VariableAddress[a] : -# 877| mu0_28(char(&)[5]) = Store : r0_26, r0_27 -# 878| r0_29(glval) = VariableAddress[rs] : -# 878| r0_30(glval) = StringConstant["test"] : -# 878| mu0_31(char(&)[5]) = Store : r0_29, r0_30 -# 879| r0_32(glval) = VariableAddress[pa] : -# 879| r0_33(glval) = VariableAddress[a] : -# 879| r0_34(char(*)[5]) = Convert : r0_33 -# 879| mu0_35(char(*)[5]) = Store : r0_32, r0_34 -# 880| r0_36(glval) = StringConstant["test"] : -# 880| r0_37(glval) = VariableAddress[pa] : -# 880| mu0_38(char(*)[5]) = Store : r0_37, r0_36 -# 881| v0_39(void) = NoOp : -# 871| v0_40(void) = ReturnVoid : -# 871| v0_41(void) = UnmodeledUse : mu* -# 871| v0_42(void) = ExitFunction : +# 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(char *) = PointerAdd[1] : r0_15, r0_16 +# 875| r0_18(char *) = Convert : r0_17 +# 875| r0_19(glval) = VariableAddress[p] : +# 875| mu0_20(char *) = Store : r0_19, r0_18 +# 876| r0_21(glval) = StringConstant["test"] : +# 876| r0_22(char *) = Convert : r0_21 +# 876| r0_23(int) = Constant[0] : +# 876| r0_24(char *) = PointerAdd[1] : r0_22, r0_23 +# 876| r0_25(glval) = VariableAddress[p] : +# 876| mu0_26(char *) = Store : r0_25, r0_24 +# 877| r0_27(glval) = VariableAddress[ra] : +# 877| r0_28(glval) = VariableAddress[a] : +# 877| mu0_29(char(&)[5]) = Store : r0_27, r0_28 +# 878| r0_30(glval) = VariableAddress[rs] : +# 878| r0_31(glval) = StringConstant["test"] : +# 878| mu0_32(char(&)[5]) = Store : r0_30, r0_31 +# 879| r0_33(glval) = VariableAddress[pa] : +# 879| r0_34(glval) = VariableAddress[a] : +# 879| r0_35(char(*)[5]) = Convert : r0_34 +# 879| mu0_36(char(*)[5]) = Store : r0_33, r0_35 +# 880| r0_37(glval) = StringConstant["test"] : +# 880| r0_38(glval) = VariableAddress[pa] : +# 880| mu0_39(char(*)[5]) = Store : r0_38, r0_37 +# 881| v0_40(void) = NoOp : +# 871| v0_41(void) = ReturnVoid : +# 871| v0_42(void) = UnmodeledUse : mu* +# 871| v0_43(void) = ExitFunction : # 883| FuncPtrConversions(..(*)(..), void *) -> void # 883| Block 0 # 883| v0_0(void) = EnterFunction : -# 883| mu0_1(unknown) = UnmodeledDefinition : -# 883| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| mu0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 883| r0_4(glval) = VariableAddress[p] : -# 883| mu0_5(void *) = InitializeParameter[p] : r0_4 -# 884| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r0_7(..(*)(..)) = Load : r0_6, mu0_1 -# 884| r0_8(void *) = Convert : r0_7 -# 884| r0_9(glval) = VariableAddress[p] : -# 884| mu0_10(void *) = Store : r0_9, r0_8 -# 885| r0_11(glval) = VariableAddress[p] : -# 885| r0_12(void *) = Load : r0_11, mu0_1 -# 885| r0_13(..(*)(..)) = Convert : r0_12 -# 885| r0_14(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| mu0_15(..(*)(..)) = Store : r0_14, r0_13 -# 886| v0_16(void) = NoOp : -# 883| v0_17(void) = ReturnVoid : -# 883| v0_18(void) = UnmodeledUse : mu* -# 883| v0_19(void) = ExitFunction : +# 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) = ExitFunction : # 888| VarArgUsage(int) -> void # 888| Block 0 # 888| v0_0(void) = EnterFunction : -# 888| mu0_1(unknown) = UnmodeledDefinition : -# 888| r0_2(glval) = VariableAddress[x] : -# 888| mu0_3(int) = InitializeParameter[x] : r0_2 -# 889| r0_4(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| mu0_5(__va_list_tag[1]) = Uninitialized : r0_4 -# 891| r0_6(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r0_7(__va_list_tag *) = Convert : r0_6 -# 891| r0_8(glval) = VariableAddress[x] : -# 891| v0_9(void) = VarArgsStart : r0_7, r0_8 -# 892| r0_10(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| mu0_11(__va_list_tag[1]) = Uninitialized : r0_10 -# 893| r0_12(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r0_13(__va_list_tag *) = Convert : r0_12 -# 893| r0_14(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r0_15(__va_list_tag *) = Convert : r0_14 -# 893| v0_16(void) = VarArgsStart : r0_13, r0_15 -# 894| r0_17(glval) = VariableAddress[d] : -# 894| r0_18(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r0_19(__va_list_tag *) = Convert : r0_18 -# 894| r0_20(glval) = VarArg : r0_19 -# 894| r0_21(double) = Load : r0_20, mu0_1 -# 894| mu0_22(double) = Store : r0_17, r0_21 -# 895| r0_23(glval) = VariableAddress[f] : -# 895| r0_24(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r0_25(__va_list_tag *) = Convert : r0_24 -# 895| r0_26(glval) = VarArg : r0_25 -# 895| r0_27(double) = Load : r0_26, mu0_1 -# 895| r0_28(float) = Convert : r0_27 -# 895| mu0_29(float) = Store : r0_23, r0_28 -# 896| r0_30(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r0_31(__va_list_tag *) = Convert : r0_30 -# 896| v0_32(void) = VarArgsEnd : r0_31 -# 897| r0_33(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r0_34(__va_list_tag *) = Convert : r0_33 -# 897| v0_35(void) = VarArgsEnd : r0_34 -# 898| v0_36(void) = NoOp : -# 888| v0_37(void) = ReturnVoid : -# 888| v0_38(void) = UnmodeledUse : mu* -# 888| v0_39(void) = ExitFunction : +# 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 : 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 : r0_8, r0_9 +# 892| r0_11(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| mu0_12(__va_list_tag[1]) = Uninitialized : 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 : r0_14, 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 : 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 : 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 : 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 : r0_35 +# 898| v0_37(void) = NoOp : +# 888| v0_38(void) = ReturnVoid : +# 888| v0_39(void) = UnmodeledUse : mu* +# 888| v0_40(void) = ExitFunction : # 900| CastToVoid(int) -> void # 900| Block 0 # 900| v0_0(void) = EnterFunction : -# 900| mu0_1(unknown) = UnmodeledDefinition : -# 900| r0_2(glval) = VariableAddress[x] : -# 900| mu0_3(int) = InitializeParameter[x] : r0_2 -# 901| r0_4(glval) = VariableAddress[x] : -# 901| v0_5(void) = Convert : r0_4 -# 902| v0_6(void) = NoOp : -# 900| v0_7(void) = ReturnVoid : -# 900| v0_8(void) = UnmodeledUse : mu* -# 900| v0_9(void) = ExitFunction : +# 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) = ExitFunction : # 904| ConstantConditions(int) -> void # 904| Block 0 # 904| v0_0(void) = EnterFunction : -# 904| mu0_1(unknown) = UnmodeledDefinition : -# 904| r0_2(glval) = VariableAddress[x] : -# 904| mu0_3(int) = InitializeParameter[x] : r0_2 -# 905| r0_4(glval) = VariableAddress[a] : -# 905| r0_5(bool) = Constant[1] : -# 905| mu0_6(bool) = Store : r0_4, r0_5 -# 906| r0_7(glval) = VariableAddress[b] : -# 906| r0_8(bool) = Constant[1] : -# 906| v0_9(void) = ConditionalBranch : r0_8 +# 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 #-----| False -> Block 3 #-----| True -> Block 2 # 906| Block 1 # 906| r1_0(glval) = VariableAddress[#temp906:11] : -# 906| r1_1(int) = Load : r1_0, mu0_1 -# 906| mu1_2(int) = Store : r0_7, r1_1 +# 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* @@ -3812,14 +4001,14 @@ ir.cpp: # 906| Block 2 # 906| r2_0(glval) = VariableAddress[x] : -# 906| r2_1(int) = Load : r2_0, mu0_1 +# 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 #-----| Goto -> Block 1 # 906| Block 3 # 906| r3_0(glval) = VariableAddress[x] : -# 906| r3_1(int) = Load : r3_0, mu0_1 +# 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 #-----| Goto -> Block 1 @@ -3827,191 +4016,203 @@ ir.cpp: # 940| OperatorNew() -> void # 940| Block 0 # 940| v0_0(void) = EnterFunction : -# 940| mu0_1(unknown) = UnmodeledDefinition : -# 941| r0_2(glval) = FunctionAddress[operator new] : -# 941| r0_3(unsigned long) = Constant[4] : -# 941| r0_4(void *) = Call : r0_2, r0_3 -# 941| r0_5(int *) = Convert : r0_4 -# 942| r0_6(glval) = FunctionAddress[operator new] : -# 942| r0_7(unsigned long) = Constant[4] : -# 942| r0_8(float) = Constant[1.0] : -# 942| r0_9(void *) = Call : r0_6, r0_7, r0_8 -# 942| r0_10(int *) = Convert : r0_9 -# 943| r0_11(glval) = FunctionAddress[operator new] : -# 943| r0_12(unsigned long) = Constant[4] : -# 943| r0_13(void *) = Call : r0_11, r0_12 -# 943| r0_14(int *) = Convert : r0_13 -# 943| r0_15(int) = Constant[0] : -# 943| mu0_16(int) = Store : r0_14, r0_15 -# 944| r0_17(glval) = FunctionAddress[operator new] : -# 944| r0_18(unsigned long) = Constant[8] : -# 944| r0_19(void *) = Call : r0_17, r0_18 -# 944| r0_20(String *) = Convert : r0_19 -# 944| r0_21(glval) = FunctionAddress[String] : -# 944| v0_22(void) = Call : r0_21, this:r0_20 -# 945| r0_23(glval) = FunctionAddress[operator new] : -# 945| r0_24(unsigned long) = Constant[8] : -# 945| r0_25(float) = Constant[1.0] : -# 945| r0_26(void *) = Call : r0_23, r0_24, r0_25 -# 945| r0_27(String *) = Convert : r0_26 -# 945| r0_28(glval) = FunctionAddress[String] : -# 945| r0_29(glval) = StringConstant["hello"] : -# 945| r0_30(char *) = Convert : r0_29 -# 945| v0_31(void) = Call : r0_28, this:r0_27, r0_30 -# 946| r0_32(glval) = FunctionAddress[operator new] : -# 946| r0_33(unsigned long) = Constant[256] : -# 946| r0_34(align_val_t) = Constant[128] : -# 946| r0_35(void *) = Call : r0_32, r0_33, r0_34 -# 946| r0_36(Overaligned *) = Convert : r0_35 -# 947| r0_37(glval) = FunctionAddress[operator new] : -# 947| r0_38(unsigned long) = Constant[256] : -# 947| r0_39(align_val_t) = Constant[128] : -# 947| r0_40(float) = Constant[1.0] : -# 947| r0_41(void *) = Call : r0_37, r0_38, r0_39, r0_40 -# 947| r0_42(Overaligned *) = Convert : r0_41 -# 947| r0_43(Overaligned) = Constant[0] : -# 947| mu0_44(Overaligned) = Store : r0_42, r0_43 -# 948| v0_45(void) = NoOp : -# 940| v0_46(void) = ReturnVoid : -# 940| v0_47(void) = UnmodeledUse : mu* -# 940| v0_48(void) = ExitFunction : +# 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 : r0_3, 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 : r0_8, r0_9, 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 : r0_14, 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 : r0_21, 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 : r0_26, this:r0_25 +# 944| mu0_28(unknown) = ^CallSideEffect : mu0_2 +# 945| r0_29(glval) = FunctionAddress[operator new] : +# 945| r0_30(unsigned long) = Constant[8] : +# 945| r0_31(float) = Constant[1.0] : +# 945| r0_32(void *) = Call : r0_29, r0_30, r0_31 +# 945| mu0_33(unknown) = ^CallSideEffect : mu0_2 +# 945| r0_34(String *) = Convert : r0_32 +# 945| r0_35(glval) = FunctionAddress[String] : +# 945| r0_36(glval) = StringConstant["hello"] : +# 945| r0_37(char *) = Convert : r0_36 +# 945| v0_38(void) = Call : r0_35, this:r0_34, r0_37 +# 945| mu0_39(unknown) = ^CallSideEffect : mu0_2 +# 946| r0_40(glval) = FunctionAddress[operator new] : +# 946| r0_41(unsigned long) = Constant[256] : +# 946| r0_42(align_val_t) = Constant[128] : +# 946| r0_43(void *) = Call : r0_40, r0_41, r0_42 +# 946| mu0_44(unknown) = ^CallSideEffect : mu0_2 +# 946| r0_45(Overaligned *) = Convert : r0_43 +# 947| r0_46(glval) = FunctionAddress[operator new] : +# 947| r0_47(unsigned long) = Constant[256] : +# 947| r0_48(align_val_t) = Constant[128] : +# 947| r0_49(float) = Constant[1.0] : +# 947| r0_50(void *) = Call : r0_46, r0_47, r0_48, r0_49 +# 947| mu0_51(unknown) = ^CallSideEffect : mu0_2 +# 947| r0_52(Overaligned *) = Convert : r0_50 +# 947| r0_53(Overaligned) = Constant[0] : +# 947| mu0_54(Overaligned) = Store : r0_52, r0_53 +# 948| v0_55(void) = NoOp : +# 940| v0_56(void) = ReturnVoid : +# 940| v0_57(void) = UnmodeledUse : mu* +# 940| v0_58(void) = ExitFunction : # 950| OperatorNewArray(int) -> void # 950| Block 0 # 950| v0_0(void) = EnterFunction : -# 950| mu0_1(unknown) = UnmodeledDefinition : -# 950| r0_2(glval) = VariableAddress[n] : -# 950| mu0_3(int) = InitializeParameter[n] : r0_2 -# 951| r0_4(glval) = FunctionAddress[operator new[]] : -# 951| r0_5(unsigned long) = Constant[40] : -# 951| r0_6(void *) = Call : r0_4, r0_5 -# 951| r0_7(int *) = Convert : r0_6 -# 952| r0_8(glval) = FunctionAddress[operator new[]] : -# 952| r0_9(glval) = VariableAddress[n] : -# 952| r0_10(int) = Load : r0_9, mu0_1 -# 952| r0_11(unsigned long) = Convert : r0_10 -# 952| r0_12(unsigned long) = Constant[4] : -# 952| r0_13(unsigned long) = Mul : r0_11, r0_12 -# 952| r0_14(void *) = Call : r0_8, r0_13 -# 952| r0_15(int *) = Convert : r0_14 -# 953| r0_16(glval) = FunctionAddress[operator new[]] : -# 953| r0_17(glval) = VariableAddress[n] : -# 953| r0_18(int) = Load : r0_17, mu0_1 -# 953| r0_19(unsigned long) = Convert : r0_18 -# 953| r0_20(unsigned long) = Constant[4] : -# 953| r0_21(unsigned long) = Mul : r0_19, r0_20 -# 953| r0_22(float) = Constant[1.0] : -# 953| r0_23(void *) = Call : r0_16, r0_21, r0_22 -# 953| r0_24(int *) = Convert : r0_23 -# 954| r0_25(glval) = FunctionAddress[operator new[]] : -# 954| r0_26(glval) = VariableAddress[n] : -# 954| r0_27(int) = Load : r0_26, mu0_1 -# 954| r0_28(unsigned long) = Convert : r0_27 -# 954| r0_29(unsigned long) = Constant[8] : -# 954| r0_30(unsigned long) = Mul : r0_28, r0_29 -# 954| r0_31(void *) = Call : r0_25, r0_30 -# 954| r0_32(String *) = Convert : r0_31 -# 955| r0_33(glval) = FunctionAddress[operator new[]] : -# 955| r0_34(glval) = VariableAddress[n] : -# 955| r0_35(int) = Load : r0_34, mu0_1 -# 955| r0_36(unsigned long) = Convert : r0_35 -# 955| r0_37(unsigned long) = Constant[256] : -# 955| r0_38(unsigned long) = Mul : r0_36, r0_37 -# 955| r0_39(align_val_t) = Constant[128] : -# 955| r0_40(void *) = Call : r0_33, r0_38, r0_39 -# 955| r0_41(Overaligned *) = Convert : r0_40 -# 956| r0_42(glval) = FunctionAddress[operator new[]] : -# 956| r0_43(unsigned long) = Constant[2560] : -# 956| r0_44(align_val_t) = Constant[128] : -# 956| r0_45(float) = Constant[1.0] : -# 956| r0_46(void *) = Call : r0_42, r0_43, r0_44, r0_45 -# 956| r0_47(Overaligned *) = Convert : r0_46 -# 957| r0_48(glval) = FunctionAddress[operator new[]] : -# 957| r0_49(glval) = VariableAddress[n] : -# 957| r0_50(int) = Load : r0_49, mu0_1 -# 957| r0_51(unsigned long) = Convert : r0_50 -# 957| r0_52(unsigned long) = Constant[1] : -# 957| r0_53(unsigned long) = Mul : r0_51, r0_52 -# 957| r0_54(void *) = Call : r0_48, r0_53 -# 957| r0_55(DefaultCtorWithDefaultParam *) = Convert : r0_54 -# 958| r0_56(glval) = FunctionAddress[operator new[]] : -# 958| r0_57(glval) = VariableAddress[n] : -# 958| r0_58(int) = Load : r0_57, mu0_1 -# 958| r0_59(unsigned long) = Convert : r0_58 -# 958| r0_60(unsigned long) = Constant[4] : -# 958| r0_61(unsigned long) = Mul : r0_59, r0_60 -# 958| r0_62(void *) = Call : r0_56, r0_61 -# 958| r0_63(int *) = Convert : r0_62 -# 959| v0_64(void) = NoOp : -# 950| v0_65(void) = ReturnVoid : -# 950| v0_66(void) = UnmodeledUse : mu* -# 950| v0_67(void) = ExitFunction : +# 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 : r0_5, 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 : r0_10, 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 : r0_19, r0_24, 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 : r0_29, 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 : r0_38, r0_43, 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 : r0_48, r0_49, r0_50, 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 : r0_55, 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 : r0_64, 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) = ExitFunction : # 961| designatedInit() -> int # 961| Block 0 -# 961| v0_0(void) = EnterFunction : -# 961| mu0_1(unknown) = UnmodeledDefinition : -# 962| r0_2(glval) = VariableAddress[a1] : -# 962| mu0_3(int[1000]) = Uninitialized : r0_2 -# 962| r0_4(int) = Constant[0] : -# 962| r0_5(glval) = PointerAdd : r0_2, r0_4 -# 962| r0_6(unknown[8]) = Constant[0] : -# 962| mu0_7(unknown[8]) = Store : r0_5, r0_6 -#-----| Goto -> Block 2 - -# 962| Block 1 -# 962| r1_0(int) = Constant[900] : -# 962| r1_1(glval) = PointerAdd : r0_2, r1_0 -# 962| r1_2(int) = Constant[10900] : -# 962| mu1_3(int) = Store : r1_1, r1_2 -# 962| r1_4(int) = Constant[901] : -# 962| r1_5(glval) = PointerAdd : r0_2, r1_4 -# 962| r1_6(unknown[396]) = Constant[0] : -# 962| mu1_7(unknown[396]) = Store : r1_5, r1_6 -#-----| Goto -> Block 2 - -# 963| Block 2 -# 963| r2_0(glval) = VariableAddress[#return] : -# 963| r2_1(glval) = VariableAddress[a1] : -# 963| r2_2(int *) = Convert : r2_1 -# 963| r2_3(int) = Constant[900] : -# 963| r2_4(int *) = PointerAdd[4] : r2_2, r2_3 -# 963| r2_5(int) = Load : r2_4, mu0_1 -# 963| mu2_6(int) = Store : r2_0, r2_5 -# 961| r2_7(glval) = VariableAddress[#return] : -# 961| v2_8(void) = ReturnValue : r2_7, mu0_1 -# 961| v2_9(void) = UnmodeledUse : mu* -# 961| v2_10(void) = ExitFunction : - -# 962| Block 3 -# 962| r3_0(int) = Constant[2] : -# 962| r3_1(glval) = PointerAdd : r0_2, r3_0 -# 962| r3_2(int) = Constant[10002] : -# 962| mu3_3(int) = Store : r3_1, r3_2 -# 962| r3_4(int) = Constant[3] : -# 962| r3_5(glval) = PointerAdd : r0_2, r3_4 -# 962| r3_6(unknown[3588]) = Constant[0] : -# 962| mu3_7(unknown[3588]) = Store : r3_5, r3_6 -#-----| Goto -> Block 2 +# 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 : r0_3 +# 962| r0_5(int) = Constant[0] : +# 962| r0_6(glval) = PointerAdd : 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 : 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 : 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 : 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 : 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(int *) = 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) = ExitFunction : # 966| IfStmtWithDeclaration(int, int) -> void # 966| Block 0 # 966| v0_0(void) = EnterFunction : -# 966| mu0_1(unknown) = UnmodeledDefinition : -# 966| r0_2(glval) = VariableAddress[x] : -# 966| mu0_3(int) = InitializeParameter[x] : r0_2 -# 966| r0_4(glval) = VariableAddress[y] : -# 966| mu0_5(int) = InitializeParameter[y] : r0_4 -# 967| r0_6(glval) = VariableAddress[b] : -# 967| r0_7(glval) = VariableAddress[x] : -# 967| r0_8(int) = Load : r0_7, mu0_1 -# 967| r0_9(glval) = VariableAddress[y] : -# 967| r0_10(int) = Load : r0_9, mu0_1 -# 967| r0_11(bool) = CompareLT : r0_8, r0_10 -# 967| mu0_12(bool) = Store : r0_6, r0_11 -# 967| r0_13(glval) = VariableAddress[b] : -# 967| r0_14(bool) = Load : r0_13, mu0_1 -# 967| v0_15(void) = ConditionalBranch : r0_14 +# 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| v0_16(void) = ConditionalBranch : r0_15 #-----| False -> Block 2 #-----| True -> Block 1 @@ -4024,13 +4225,13 @@ ir.cpp: # 970| Block 2 # 970| r2_0(glval) = VariableAddress[z] : # 970| r2_1(glval) = VariableAddress[x] : -# 970| r2_2(int) = Load : r2_1, mu0_1 +# 970| r2_2(int) = Load : r2_1, mu0_2 # 970| r2_3(glval) = VariableAddress[y] : -# 970| r2_4(int) = Load : r2_3, mu0_1 +# 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_1 +# 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| v2_11(void) = ConditionalBranch : r2_10 @@ -4048,7 +4249,7 @@ ir.cpp: # 973| r4_1(glval) = VariableAddress[x] : # 973| mu4_2(int *) = Store : r4_0, r4_1 # 973| r4_3(glval) = VariableAddress[p] : -# 973| r4_4(int *) = Load : r4_3, mu0_1 +# 973| r4_4(int *) = Load : r4_3, mu0_2 # 973| r4_5(int *) = Constant[0] : # 973| r4_6(bool) = CompareNE : r4_4, r4_5 # 973| v4_7(void) = ConditionalBranch : r4_6 @@ -4058,7 +4259,7 @@ ir.cpp: # 974| Block 5 # 974| r5_0(int) = Constant[2] : # 974| r5_1(glval) = VariableAddress[p] : -# 974| r5_2(int *) = Load : r5_1, mu0_1 +# 974| r5_2(int *) = Load : r5_1, mu0_2 # 974| mu5_3(int) = Store : r5_2, r5_0 #-----| Goto -> Block 6 @@ -4071,11 +4272,12 @@ ir.cpp: # 978| WhileStmtWithDeclaration(int, int) -> void # 978| Block 0 # 978| v0_0(void) = EnterFunction : -# 978| mu0_1(unknown) = UnmodeledDefinition : -# 978| r0_2(glval) = VariableAddress[x] : -# 978| mu0_3(int) = InitializeParameter[x] : r0_2 -# 978| r0_4(glval) = VariableAddress[y] : -# 978| mu0_5(int) = InitializeParameter[y] : r0_4 +# 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 #-----| Goto -> Block 7 # 979| Block 1 @@ -4085,13 +4287,13 @@ ir.cpp: # 981| Block 2 # 981| r2_0(glval) = VariableAddress[z] : # 981| r2_1(glval) = VariableAddress[x] : -# 981| r2_2(int) = Load : r2_1, mu0_1 +# 981| r2_2(int) = Load : r2_1, mu0_2 # 981| r2_3(glval) = VariableAddress[y] : -# 981| r2_4(int) = Load : r2_3, mu0_1 +# 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_1 +# 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| v2_11(void) = ConditionalBranch : r2_10 @@ -4107,7 +4309,7 @@ ir.cpp: # 983| r4_1(glval) = VariableAddress[x] : # 983| mu4_2(int *) = Store : r4_0, r4_1 # 983| r4_3(glval) = VariableAddress[p] : -# 983| r4_4(int *) = Load : r4_3, mu0_1 +# 983| r4_4(int *) = Load : r4_3, mu0_2 # 983| r4_5(int *) = Constant[0] : # 983| r4_6(bool) = CompareNE : r4_4, r4_5 # 983| v4_7(void) = ConditionalBranch : r4_6 @@ -4127,13 +4329,94 @@ ir.cpp: # 979| Block 7 # 979| r7_0(glval) = VariableAddress[b] : # 979| r7_1(glval) = VariableAddress[x] : -# 979| r7_2(int) = Load : r7_1, mu0_1 +# 979| r7_2(int) = Load : r7_1, mu0_2 # 979| r7_3(glval) = VariableAddress[y] : -# 979| r7_4(int) = Load : r7_3, mu0_1 +# 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_1 +# 979| r7_8(bool) = Load : r7_7, mu0_2 # 979| v7_9(void) = ConditionalBranch : r7_8 #-----| False -> Block 2 #-----| True -> Block 1 + +# 1005| ChiPhiNode(Point *, bool, bool) -> int +# 1005| Block 0 +# 1005| v0_0(void) = EnterFunction : +# 1005| mu0_1(unknown) = AliasedDefinition : +# 1005| mu0_2(unknown) = UnmodeledDefinition : +# 1005| r0_3(glval) = VariableAddress[p] : +# 1005| mu0_4(Point *) = InitializeParameter[p] : r0_3 +# 1005| r0_5(glval) = VariableAddress[which1] : +# 1005| mu0_6(bool) = InitializeParameter[which1] : r0_5 +# 1005| r0_7(glval) = VariableAddress[which2] : +# 1005| mu0_8(bool) = InitializeParameter[which2] : r0_7 +# 1006| r0_9(glval) = VariableAddress[which1] : +# 1006| r0_10(bool) = Load : r0_9, mu0_2 +# 1006| v0_11(void) = ConditionalBranch : r0_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 1007| Block 1 +# 1007| r1_0(glval) = VariableAddress[p] : +# 1007| r1_1(Point *) = Load : r1_0, mu0_2 +# 1007| r1_2(glval) = FieldAddress[x] : r1_1 +# 1007| r1_3(int) = Load : r1_2, mu0_2 +# 1007| r1_4(int) = Constant[1] : +# 1007| r1_5(int) = Add : r1_3, r1_4 +# 1007| mu1_6(int) = Store : r1_2, r1_5 +#-----| Goto -> Block 3 + +# 1009| Block 2 +# 1009| r2_0(glval) = VariableAddress[p] : +# 1009| r2_1(Point *) = Load : r2_0, mu0_2 +# 1009| r2_2(glval) = FieldAddress[y] : r2_1 +# 1009| r2_3(int) = Load : r2_2, mu0_2 +# 1009| r2_4(int) = Constant[1] : +# 1009| r2_5(int) = Add : r2_3, r2_4 +# 1009| mu2_6(int) = Store : r2_2, r2_5 +#-----| Goto -> Block 3 + +# 1012| Block 3 +# 1012| r3_0(glval) = VariableAddress[which2] : +# 1012| r3_1(bool) = Load : r3_0, mu0_2 +# 1012| v3_2(void) = ConditionalBranch : r3_1 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 1013| Block 4 +# 1013| r4_0(glval) = VariableAddress[p] : +# 1013| r4_1(Point *) = Load : r4_0, mu0_2 +# 1013| r4_2(glval) = FieldAddress[x] : r4_1 +# 1013| r4_3(int) = Load : r4_2, mu0_2 +# 1013| r4_4(int) = Constant[1] : +# 1013| r4_5(int) = Add : r4_3, r4_4 +# 1013| mu4_6(int) = Store : r4_2, r4_5 +#-----| Goto -> Block 6 + +# 1015| Block 5 +# 1015| r5_0(glval) = VariableAddress[p] : +# 1015| r5_1(Point *) = Load : r5_0, mu0_2 +# 1015| r5_2(glval) = FieldAddress[y] : r5_1 +# 1015| r5_3(int) = Load : r5_2, mu0_2 +# 1015| r5_4(int) = Constant[1] : +# 1015| r5_5(int) = Add : r5_3, r5_4 +# 1015| mu5_6(int) = Store : r5_2, r5_5 +#-----| Goto -> Block 6 + +# 1018| Block 6 +# 1018| r6_0(glval) = VariableAddress[#return] : +# 1018| r6_1(glval) = VariableAddress[p] : +# 1018| r6_2(Point *) = Load : r6_1, mu0_2 +# 1018| r6_3(glval) = FieldAddress[x] : r6_2 +# 1018| r6_4(int) = Load : r6_3, mu0_2 +# 1018| r6_5(glval) = VariableAddress[p] : +# 1018| r6_6(Point *) = Load : r6_5, mu0_2 +# 1018| r6_7(glval) = FieldAddress[y] : r6_6 +# 1018| r6_8(int) = Load : r6_7, mu0_2 +# 1018| r6_9(int) = Add : r6_4, r6_8 +# 1018| mu6_10(int) = Store : r6_0, r6_9 +# 1005| r6_11(glval) = VariableAddress[#return] : +# 1005| v6_12(void) = ReturnValue : r6_11, mu0_2 +# 1005| v6_13(void) = UnmodeledUse : mu* +# 1005| v6_14(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ir/ssa_block_count.expected b/cpp/ql/test/library-tests/ir/ir/ssa_block_count.expected index 1c30402ee65..ecc8e867e9e 100644 --- a/cpp/ql/test/library-tests/ir/ir/ssa_block_count.expected +++ b/cpp/ql/test/library-tests/ir/ir/ssa_block_count.expected @@ -15,6 +15,7 @@ | IR: CallNestedTemplateFunc | 1 | | IR: CallViaFuncPtr | 1 | | IR: CastToVoid | 1 | +| IR: ChiPhiNode | 7 | | IR: Comma | 1 | | IR: CompoundAssignment | 1 | | IR: ConditionValues | 13 | @@ -97,7 +98,7 @@ | IR: VirtualMemberFunction | 1 | | IR: WhileStatements | 4 | | IR: WhileStmtWithDeclaration | 8 | -| IR: designatedInit | 4 | +| IR: designatedInit | 1 | | IR: min | 4 | | IR: operator= | 1 | | IR: ~Base | 1 | diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected index 8aa58507f26..a7a282ac558 100644 --- a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected @@ -2,1046 +2,1068 @@ bad_asts.cpp: # 14| Bad::CallBadMemberFunction() -> void # 14| Block 0 # 14| v0_0(void) = EnterFunction : -# 14| mu0_1(unknown) = UnmodeledDefinition : -# 15| r0_2(glval) = VariableAddress[s] : -# 15| mu0_3(S) = Uninitialized : r0_2 -# 15| r0_4(glval) = FieldAddress[x] : r0_2 -# 15| r0_5(int) = Constant[0] : -# 15| mu0_6(int) = Store : r0_4, r0_5 -# 16| r0_7(glval) = VariableAddress[s] : -# 16| r0_8(glval) = FunctionAddress[MemberFunction] : -# 16| r0_9(int) = Constant[1] : -# 16| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -# 17| v0_11(void) = NoOp : -# 14| v0_12(void) = ReturnVoid : -# 14| v0_13(void) = UnmodeledUse : mu* -# 14| v0_14(void) = ExitFunction : +# 14| mu0_1(unknown) = AliasedDefinition : +# 14| mu0_2(unknown) = UnmodeledDefinition : +# 15| r0_3(glval) = VariableAddress[s] : +# 15| mu0_4(S) = Uninitialized : 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 : r0_9, this:r0_8, r0_10 +# 16| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 17| v0_13(void) = NoOp : +# 14| v0_14(void) = ReturnVoid : +# 14| v0_15(void) = UnmodeledUse : mu* +# 14| v0_16(void) = ExitFunction : # 22| Bad::Point::Point() -> void # 22| Block 0 # 22| v0_0(void) = EnterFunction : -# 22| mu0_1(unknown) = UnmodeledDefinition : -# 22| r0_2(glval) = InitializeThis : -# 23| v0_3(void) = NoOp : -# 22| v0_4(void) = ReturnVoid : -# 22| v0_5(void) = UnmodeledUse : mu* -# 22| v0_6(void) = ExitFunction : +# 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) = ExitFunction : # 26| Bad::CallCopyConstructor(const Point &) -> void # 26| Block 0 # 26| v0_0(void) = EnterFunction : -# 26| mu0_1(unknown) = UnmodeledDefinition : -# 26| r0_2(glval) = VariableAddress[a] : -# 26| m0_3(Point &) = InitializeParameter[a] : r0_2 -# 27| r0_4(glval) = VariableAddress[b] : -# 27| r0_5(glval) = VariableAddress[a] : -# 27| r0_6(Point &) = Load : r0_5, m0_3 -# 27| r0_7(glval) = Convert : r0_6 -# 27| r0_8(Point) = Load : r0_7, mu0_1 -# 27| m0_9(Point) = Store : r0_4, r0_8 -# 28| v0_10(void) = NoOp : -# 26| v0_11(void) = ReturnVoid : -# 26| v0_12(void) = UnmodeledUse : mu* -# 26| v0_13(void) = ExitFunction : +# 26| mu0_1(unknown) = AliasedDefinition : +# 26| mu0_2(unknown) = UnmodeledDefinition : +# 26| r0_3(glval) = VariableAddress[a] : +# 26| m0_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, m0_4 +# 27| r0_8(glval) = Convert : r0_7 +# 27| r0_9(Point) = Load : r0_8, mu0_2 +# 27| m0_10(Point) = Store : r0_5, r0_9 +# 28| v0_11(void) = NoOp : +# 26| v0_12(void) = ReturnVoid : +# 26| v0_13(void) = UnmodeledUse : mu* +# 26| v0_14(void) = ExitFunction : ir.cpp: # 1| Constants() -> void # 1| Block 0 # 1| v0_0(void) = EnterFunction : -# 1| mu0_1(unknown) = UnmodeledDefinition : -# 2| r0_2(glval) = VariableAddress[c_i] : -# 2| r0_3(char) = Constant[1] : -# 2| m0_4(char) = Store : r0_2, r0_3 -# 3| r0_5(glval) = VariableAddress[c_c] : -# 3| r0_6(char) = Constant[65] : -# 3| m0_7(char) = Store : r0_5, r0_6 -# 5| r0_8(glval) = VariableAddress[sc_i] : -# 5| r0_9(signed char) = Constant[-1] : -# 5| m0_10(signed char) = Store : r0_8, r0_9 -# 6| r0_11(glval) = VariableAddress[sc_c] : -# 6| r0_12(signed char) = Constant[65] : -# 6| m0_13(signed char) = Store : r0_11, r0_12 -# 8| r0_14(glval) = VariableAddress[uc_i] : -# 8| r0_15(unsigned char) = Constant[5] : -# 8| m0_16(unsigned char) = Store : r0_14, r0_15 -# 9| r0_17(glval) = VariableAddress[uc_c] : -# 9| r0_18(unsigned char) = Constant[65] : -# 9| m0_19(unsigned char) = Store : r0_17, r0_18 -# 11| r0_20(glval) = VariableAddress[s] : -# 11| r0_21(short) = Constant[5] : -# 11| m0_22(short) = Store : r0_20, r0_21 -# 12| r0_23(glval) = VariableAddress[us] : -# 12| r0_24(unsigned short) = Constant[5] : -# 12| m0_25(unsigned short) = Store : r0_23, r0_24 -# 14| r0_26(glval) = VariableAddress[i] : -# 14| r0_27(int) = Constant[5] : -# 14| m0_28(int) = Store : r0_26, r0_27 -# 15| r0_29(glval) = VariableAddress[ui] : -# 15| r0_30(unsigned int) = Constant[5] : -# 15| m0_31(unsigned int) = Store : r0_29, r0_30 -# 17| r0_32(glval) = VariableAddress[l] : -# 17| r0_33(long) = Constant[5] : -# 17| m0_34(long) = Store : r0_32, r0_33 -# 18| r0_35(glval) = VariableAddress[ul] : -# 18| r0_36(unsigned long) = Constant[5] : -# 18| m0_37(unsigned long) = Store : r0_35, r0_36 -# 20| r0_38(glval) = VariableAddress[ll_i] : -# 20| r0_39(long long) = Constant[5] : -# 20| m0_40(long long) = Store : r0_38, r0_39 -# 21| r0_41(glval) = VariableAddress[ll_ll] : -# 21| r0_42(long long) = Constant[5] : -# 21| m0_43(long long) = Store : r0_41, r0_42 -# 22| r0_44(glval) = VariableAddress[ull_i] : -# 22| r0_45(unsigned long long) = Constant[5] : -# 22| m0_46(unsigned long long) = Store : r0_44, r0_45 -# 23| r0_47(glval) = VariableAddress[ull_ull] : -# 23| r0_48(unsigned long long) = Constant[5] : -# 23| m0_49(unsigned long long) = Store : r0_47, r0_48 -# 25| r0_50(glval) = VariableAddress[b_t] : -# 25| r0_51(bool) = Constant[1] : -# 25| m0_52(bool) = Store : r0_50, r0_51 -# 26| r0_53(glval) = VariableAddress[b_f] : -# 26| r0_54(bool) = Constant[0] : -# 26| m0_55(bool) = Store : r0_53, r0_54 -# 28| r0_56(glval) = VariableAddress[wc_i] : -# 28| r0_57(wchar_t) = Constant[5] : -# 28| m0_58(wchar_t) = Store : r0_56, r0_57 -# 29| r0_59(glval) = VariableAddress[wc_c] : -# 29| r0_60(wchar_t) = Constant[65] : -# 29| m0_61(wchar_t) = Store : r0_59, r0_60 -# 31| r0_62(glval) = VariableAddress[c16] : -# 31| r0_63(char16_t) = Constant[65] : -# 31| m0_64(char16_t) = Store : r0_62, r0_63 -# 32| r0_65(glval) = VariableAddress[c32] : -# 32| r0_66(char32_t) = Constant[65] : -# 32| m0_67(char32_t) = Store : r0_65, r0_66 -# 34| r0_68(glval) = VariableAddress[f_i] : -# 34| r0_69(float) = Constant[1.0] : -# 34| m0_70(float) = Store : r0_68, r0_69 -# 35| r0_71(glval) = VariableAddress[f_f] : -# 35| r0_72(float) = Constant[1.0] : -# 35| m0_73(float) = Store : r0_71, r0_72 -# 36| r0_74(glval) = VariableAddress[f_d] : -# 36| r0_75(float) = Constant[1.0] : -# 36| m0_76(float) = Store : r0_74, r0_75 -# 38| r0_77(glval) = VariableAddress[d_i] : -# 38| r0_78(double) = Constant[1.0] : -# 38| m0_79(double) = Store : r0_77, r0_78 -# 39| r0_80(glval) = VariableAddress[d_f] : -# 39| r0_81(double) = Constant[1.0] : -# 39| m0_82(double) = Store : r0_80, r0_81 -# 40| r0_83(glval) = VariableAddress[d_d] : -# 40| r0_84(double) = Constant[1.0] : -# 40| m0_85(double) = Store : r0_83, r0_84 -# 41| v0_86(void) = NoOp : -# 1| v0_87(void) = ReturnVoid : -# 1| v0_88(void) = UnmodeledUse : mu* -# 1| v0_89(void) = ExitFunction : +# 1| mu0_1(unknown) = AliasedDefinition : +# 1| mu0_2(unknown) = UnmodeledDefinition : +# 2| r0_3(glval) = VariableAddress[c_i] : +# 2| r0_4(char) = Constant[1] : +# 2| m0_5(char) = Store : r0_3, r0_4 +# 3| r0_6(glval) = VariableAddress[c_c] : +# 3| r0_7(char) = Constant[65] : +# 3| m0_8(char) = Store : r0_6, r0_7 +# 5| r0_9(glval) = VariableAddress[sc_i] : +# 5| r0_10(signed char) = Constant[-1] : +# 5| m0_11(signed char) = Store : r0_9, r0_10 +# 6| r0_12(glval) = VariableAddress[sc_c] : +# 6| r0_13(signed char) = Constant[65] : +# 6| m0_14(signed char) = Store : r0_12, r0_13 +# 8| r0_15(glval) = VariableAddress[uc_i] : +# 8| r0_16(unsigned char) = Constant[5] : +# 8| m0_17(unsigned char) = Store : r0_15, r0_16 +# 9| r0_18(glval) = VariableAddress[uc_c] : +# 9| r0_19(unsigned char) = Constant[65] : +# 9| m0_20(unsigned char) = Store : r0_18, r0_19 +# 11| r0_21(glval) = VariableAddress[s] : +# 11| r0_22(short) = Constant[5] : +# 11| m0_23(short) = Store : r0_21, r0_22 +# 12| r0_24(glval) = VariableAddress[us] : +# 12| r0_25(unsigned short) = Constant[5] : +# 12| m0_26(unsigned short) = Store : r0_24, r0_25 +# 14| r0_27(glval) = VariableAddress[i] : +# 14| r0_28(int) = Constant[5] : +# 14| m0_29(int) = Store : r0_27, r0_28 +# 15| r0_30(glval) = VariableAddress[ui] : +# 15| r0_31(unsigned int) = Constant[5] : +# 15| m0_32(unsigned int) = Store : r0_30, r0_31 +# 17| r0_33(glval) = VariableAddress[l] : +# 17| r0_34(long) = Constant[5] : +# 17| m0_35(long) = Store : r0_33, r0_34 +# 18| r0_36(glval) = VariableAddress[ul] : +# 18| r0_37(unsigned long) = Constant[5] : +# 18| m0_38(unsigned long) = Store : r0_36, r0_37 +# 20| r0_39(glval) = VariableAddress[ll_i] : +# 20| r0_40(long long) = Constant[5] : +# 20| m0_41(long long) = Store : r0_39, r0_40 +# 21| r0_42(glval) = VariableAddress[ll_ll] : +# 21| r0_43(long long) = Constant[5] : +# 21| m0_44(long long) = Store : r0_42, r0_43 +# 22| r0_45(glval) = VariableAddress[ull_i] : +# 22| r0_46(unsigned long long) = Constant[5] : +# 22| m0_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| m0_50(unsigned long long) = Store : r0_48, r0_49 +# 25| r0_51(glval) = VariableAddress[b_t] : +# 25| r0_52(bool) = Constant[1] : +# 25| m0_53(bool) = Store : r0_51, r0_52 +# 26| r0_54(glval) = VariableAddress[b_f] : +# 26| r0_55(bool) = Constant[0] : +# 26| m0_56(bool) = Store : r0_54, r0_55 +# 28| r0_57(glval) = VariableAddress[wc_i] : +# 28| r0_58(wchar_t) = Constant[5] : +# 28| m0_59(wchar_t) = Store : r0_57, r0_58 +# 29| r0_60(glval) = VariableAddress[wc_c] : +# 29| r0_61(wchar_t) = Constant[65] : +# 29| m0_62(wchar_t) = Store : r0_60, r0_61 +# 31| r0_63(glval) = VariableAddress[c16] : +# 31| r0_64(char16_t) = Constant[65] : +# 31| m0_65(char16_t) = Store : r0_63, r0_64 +# 32| r0_66(glval) = VariableAddress[c32] : +# 32| r0_67(char32_t) = Constant[65] : +# 32| m0_68(char32_t) = Store : r0_66, r0_67 +# 34| r0_69(glval) = VariableAddress[f_i] : +# 34| r0_70(float) = Constant[1.0] : +# 34| m0_71(float) = Store : r0_69, r0_70 +# 35| r0_72(glval) = VariableAddress[f_f] : +# 35| r0_73(float) = Constant[1.0] : +# 35| m0_74(float) = Store : r0_72, r0_73 +# 36| r0_75(glval) = VariableAddress[f_d] : +# 36| r0_76(float) = Constant[1.0] : +# 36| m0_77(float) = Store : r0_75, r0_76 +# 38| r0_78(glval) = VariableAddress[d_i] : +# 38| r0_79(double) = Constant[1.0] : +# 38| m0_80(double) = Store : r0_78, r0_79 +# 39| r0_81(glval) = VariableAddress[d_f] : +# 39| r0_82(double) = Constant[1.0] : +# 39| m0_83(double) = Store : r0_81, r0_82 +# 40| r0_84(glval) = VariableAddress[d_d] : +# 40| r0_85(double) = Constant[1.0] : +# 40| m0_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) = ExitFunction : # 43| Foo() -> void # 43| Block 0 # 43| v0_0(void) = EnterFunction : -# 43| mu0_1(unknown) = UnmodeledDefinition : -# 44| r0_2(glval) = VariableAddress[x] : -# 44| r0_3(int) = Constant[17] : -# 44| m0_4(int) = Store : r0_2, r0_3 -# 45| r0_5(glval) = VariableAddress[y] : -# 45| r0_6(short) = Constant[7] : -# 45| m0_7(short) = Store : r0_5, r0_6 -# 46| r0_8(glval) = VariableAddress[x] : -# 46| r0_9(int) = Load : r0_8, m0_4 -# 46| r0_10(glval) = VariableAddress[y] : -# 46| r0_11(short) = Load : r0_10, m0_7 -# 46| r0_12(int) = Convert : r0_11 -# 46| r0_13(int) = Add : r0_9, r0_12 -# 46| r0_14(short) = Convert : r0_13 -# 46| r0_15(glval) = VariableAddress[y] : -# 46| m0_16(short) = Store : r0_15, r0_14 -# 47| r0_17(glval) = VariableAddress[x] : -# 47| r0_18(int) = Load : r0_17, m0_4 -# 47| r0_19(glval) = VariableAddress[y] : -# 47| r0_20(short) = Load : r0_19, m0_16 -# 47| r0_21(int) = Convert : r0_20 -# 47| r0_22(int) = Mul : r0_18, r0_21 -# 47| r0_23(glval) = VariableAddress[x] : -# 47| m0_24(int) = Store : r0_23, r0_22 -# 48| v0_25(void) = NoOp : -# 43| v0_26(void) = ReturnVoid : -# 43| v0_27(void) = UnmodeledUse : mu* -# 43| v0_28(void) = ExitFunction : +# 43| mu0_1(unknown) = AliasedDefinition : +# 43| mu0_2(unknown) = UnmodeledDefinition : +# 44| r0_3(glval) = VariableAddress[x] : +# 44| r0_4(int) = Constant[17] : +# 44| m0_5(int) = Store : r0_3, r0_4 +# 45| r0_6(glval) = VariableAddress[y] : +# 45| r0_7(short) = Constant[7] : +# 45| m0_8(short) = Store : r0_6, r0_7 +# 46| r0_9(glval) = VariableAddress[x] : +# 46| r0_10(int) = Load : r0_9, m0_5 +# 46| r0_11(glval) = VariableAddress[y] : +# 46| r0_12(short) = Load : r0_11, m0_8 +# 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| m0_17(short) = Store : r0_16, r0_15 +# 47| r0_18(glval) = VariableAddress[x] : +# 47| r0_19(int) = Load : r0_18, m0_5 +# 47| r0_20(glval) = VariableAddress[y] : +# 47| r0_21(short) = Load : r0_20, m0_17 +# 47| r0_22(int) = Convert : r0_21 +# 47| r0_23(int) = Mul : r0_19, r0_22 +# 47| r0_24(glval) = VariableAddress[x] : +# 47| m0_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) = ExitFunction : # 50| IntegerOps(int, int) -> void # 50| Block 0 # 50| v0_0(void) = EnterFunction : -# 50| mu0_1(unknown) = UnmodeledDefinition : -# 50| r0_2(glval) = VariableAddress[x] : -# 50| m0_3(int) = InitializeParameter[x] : r0_2 -# 50| r0_4(glval) = VariableAddress[y] : -# 50| m0_5(int) = InitializeParameter[y] : r0_4 -# 51| r0_6(glval) = VariableAddress[z] : -# 51| m0_7(int) = Uninitialized : r0_6 -# 53| r0_8(glval) = VariableAddress[x] : -# 53| r0_9(int) = Load : r0_8, m0_3 -# 53| r0_10(glval) = VariableAddress[y] : -# 53| r0_11(int) = Load : r0_10, m0_5 -# 53| r0_12(int) = Add : r0_9, r0_11 -# 53| r0_13(glval) = VariableAddress[z] : -# 53| m0_14(int) = Store : r0_13, r0_12 -# 54| r0_15(glval) = VariableAddress[x] : -# 54| r0_16(int) = Load : r0_15, m0_3 -# 54| r0_17(glval) = VariableAddress[y] : -# 54| r0_18(int) = Load : r0_17, m0_5 -# 54| r0_19(int) = Sub : r0_16, r0_18 -# 54| r0_20(glval) = VariableAddress[z] : -# 54| m0_21(int) = Store : r0_20, r0_19 -# 55| r0_22(glval) = VariableAddress[x] : -# 55| r0_23(int) = Load : r0_22, m0_3 -# 55| r0_24(glval) = VariableAddress[y] : -# 55| r0_25(int) = Load : r0_24, m0_5 -# 55| r0_26(int) = Mul : r0_23, r0_25 -# 55| r0_27(glval) = VariableAddress[z] : -# 55| m0_28(int) = Store : r0_27, r0_26 -# 56| r0_29(glval) = VariableAddress[x] : -# 56| r0_30(int) = Load : r0_29, m0_3 -# 56| r0_31(glval) = VariableAddress[y] : -# 56| r0_32(int) = Load : r0_31, m0_5 -# 56| r0_33(int) = Div : r0_30, r0_32 -# 56| r0_34(glval) = VariableAddress[z] : -# 56| m0_35(int) = Store : r0_34, r0_33 -# 57| r0_36(glval) = VariableAddress[x] : -# 57| r0_37(int) = Load : r0_36, m0_3 -# 57| r0_38(glval) = VariableAddress[y] : -# 57| r0_39(int) = Load : r0_38, m0_5 -# 57| r0_40(int) = Rem : r0_37, r0_39 -# 57| r0_41(glval) = VariableAddress[z] : -# 57| m0_42(int) = Store : r0_41, r0_40 -# 59| r0_43(glval) = VariableAddress[x] : -# 59| r0_44(int) = Load : r0_43, m0_3 -# 59| r0_45(glval) = VariableAddress[y] : -# 59| r0_46(int) = Load : r0_45, m0_5 -# 59| r0_47(int) = BitAnd : r0_44, r0_46 -# 59| r0_48(glval) = VariableAddress[z] : -# 59| m0_49(int) = Store : r0_48, r0_47 -# 60| r0_50(glval) = VariableAddress[x] : -# 60| r0_51(int) = Load : r0_50, m0_3 -# 60| r0_52(glval) = VariableAddress[y] : -# 60| r0_53(int) = Load : r0_52, m0_5 -# 60| r0_54(int) = BitOr : r0_51, r0_53 -# 60| r0_55(glval) = VariableAddress[z] : -# 60| m0_56(int) = Store : r0_55, r0_54 -# 61| r0_57(glval) = VariableAddress[x] : -# 61| r0_58(int) = Load : r0_57, m0_3 -# 61| r0_59(glval) = VariableAddress[y] : -# 61| r0_60(int) = Load : r0_59, m0_5 -# 61| r0_61(int) = BitXor : r0_58, r0_60 -# 61| r0_62(glval) = VariableAddress[z] : -# 61| m0_63(int) = Store : r0_62, r0_61 -# 63| r0_64(glval) = VariableAddress[x] : -# 63| r0_65(int) = Load : r0_64, m0_3 -# 63| r0_66(glval) = VariableAddress[y] : -# 63| r0_67(int) = Load : r0_66, m0_5 -# 63| r0_68(int) = ShiftLeft : r0_65, r0_67 -# 63| r0_69(glval) = VariableAddress[z] : -# 63| m0_70(int) = Store : r0_69, r0_68 -# 64| r0_71(glval) = VariableAddress[x] : -# 64| r0_72(int) = Load : r0_71, m0_3 -# 64| r0_73(glval) = VariableAddress[y] : -# 64| r0_74(int) = Load : r0_73, m0_5 -# 64| r0_75(int) = ShiftRight : r0_72, r0_74 -# 64| r0_76(glval) = VariableAddress[z] : -# 64| m0_77(int) = Store : r0_76, r0_75 -# 66| r0_78(glval) = VariableAddress[x] : -# 66| r0_79(int) = Load : r0_78, m0_3 -# 66| r0_80(glval) = VariableAddress[z] : -# 66| m0_81(int) = Store : r0_80, r0_79 -# 68| r0_82(glval) = VariableAddress[x] : -# 68| r0_83(int) = Load : r0_82, m0_3 -# 68| r0_84(glval) = VariableAddress[z] : -# 68| r0_85(int) = Load : r0_84, m0_81 -# 68| r0_86(int) = Add : r0_85, r0_83 -# 68| m0_87(int) = Store : r0_84, r0_86 -# 69| r0_88(glval) = VariableAddress[x] : -# 69| r0_89(int) = Load : r0_88, m0_3 -# 69| r0_90(glval) = VariableAddress[z] : -# 69| r0_91(int) = Load : r0_90, m0_87 -# 69| r0_92(int) = Sub : r0_91, r0_89 -# 69| m0_93(int) = Store : r0_90, r0_92 -# 70| r0_94(glval) = VariableAddress[x] : -# 70| r0_95(int) = Load : r0_94, m0_3 -# 70| r0_96(glval) = VariableAddress[z] : -# 70| r0_97(int) = Load : r0_96, m0_93 -# 70| r0_98(int) = Mul : r0_97, r0_95 -# 70| m0_99(int) = Store : r0_96, r0_98 -# 71| r0_100(glval) = VariableAddress[x] : -# 71| r0_101(int) = Load : r0_100, m0_3 -# 71| r0_102(glval) = VariableAddress[z] : -# 71| r0_103(int) = Load : r0_102, m0_99 -# 71| r0_104(int) = Div : r0_103, r0_101 -# 71| m0_105(int) = Store : r0_102, r0_104 -# 72| r0_106(glval) = VariableAddress[x] : -# 72| r0_107(int) = Load : r0_106, m0_3 -# 72| r0_108(glval) = VariableAddress[z] : -# 72| r0_109(int) = Load : r0_108, m0_105 -# 72| r0_110(int) = Rem : r0_109, r0_107 -# 72| m0_111(int) = Store : r0_108, r0_110 -# 74| r0_112(glval) = VariableAddress[x] : -# 74| r0_113(int) = Load : r0_112, m0_3 -# 74| r0_114(glval) = VariableAddress[z] : -# 74| r0_115(int) = Load : r0_114, m0_111 -# 74| r0_116(int) = BitAnd : r0_115, r0_113 -# 74| m0_117(int) = Store : r0_114, r0_116 -# 75| r0_118(glval) = VariableAddress[x] : -# 75| r0_119(int) = Load : r0_118, m0_3 -# 75| r0_120(glval) = VariableAddress[z] : -# 75| r0_121(int) = Load : r0_120, m0_117 -# 75| r0_122(int) = BitOr : r0_121, r0_119 -# 75| m0_123(int) = Store : r0_120, r0_122 -# 76| r0_124(glval) = VariableAddress[x] : -# 76| r0_125(int) = Load : r0_124, m0_3 -# 76| r0_126(glval) = VariableAddress[z] : -# 76| r0_127(int) = Load : r0_126, m0_123 -# 76| r0_128(int) = BitXor : r0_127, r0_125 -# 76| m0_129(int) = Store : r0_126, r0_128 -# 78| r0_130(glval) = VariableAddress[x] : -# 78| r0_131(int) = Load : r0_130, m0_3 -# 78| r0_132(glval) = VariableAddress[z] : -# 78| r0_133(int) = Load : r0_132, m0_129 -# 78| r0_134(int) = ShiftLeft : r0_133, r0_131 -# 78| m0_135(int) = Store : r0_132, r0_134 -# 79| r0_136(glval) = VariableAddress[x] : -# 79| r0_137(int) = Load : r0_136, m0_3 -# 79| r0_138(glval) = VariableAddress[z] : -# 79| r0_139(int) = Load : r0_138, m0_135 -# 79| r0_140(int) = ShiftRight : r0_139, r0_137 -# 79| m0_141(int) = Store : r0_138, r0_140 -# 81| r0_142(glval) = VariableAddress[x] : -# 81| r0_143(int) = Load : r0_142, m0_3 -# 81| r0_144(int) = CopyValue : r0_143 -# 81| r0_145(glval) = VariableAddress[z] : -# 81| m0_146(int) = Store : r0_145, r0_144 -# 82| r0_147(glval) = VariableAddress[x] : -# 82| r0_148(int) = Load : r0_147, m0_3 -# 82| r0_149(int) = Negate : r0_148 -# 82| r0_150(glval) = VariableAddress[z] : -# 82| m0_151(int) = Store : r0_150, r0_149 -# 83| r0_152(glval) = VariableAddress[x] : -# 83| r0_153(int) = Load : r0_152, m0_3 -# 83| r0_154(int) = BitComplement : r0_153 -# 83| r0_155(glval) = VariableAddress[z] : -# 83| m0_156(int) = Store : r0_155, r0_154 -# 84| r0_157(glval) = VariableAddress[x] : -# 84| r0_158(int) = Load : r0_157, m0_3 -# 84| r0_159(int) = Constant[0] : -# 84| r0_160(bool) = CompareNE : r0_158, r0_159 -# 84| r0_161(bool) = LogicalNot : r0_160 -# 84| r0_162(int) = Convert : r0_161 -# 84| r0_163(glval) = VariableAddress[z] : -# 84| m0_164(int) = Store : r0_163, r0_162 -# 85| v0_165(void) = NoOp : -# 50| v0_166(void) = ReturnVoid : -# 50| v0_167(void) = UnmodeledUse : mu* -# 50| v0_168(void) = ExitFunction : +# 50| mu0_1(unknown) = AliasedDefinition : +# 50| mu0_2(unknown) = UnmodeledDefinition : +# 50| r0_3(glval) = VariableAddress[x] : +# 50| m0_4(int) = InitializeParameter[x] : r0_3 +# 50| r0_5(glval) = VariableAddress[y] : +# 50| m0_6(int) = InitializeParameter[y] : r0_5 +# 51| r0_7(glval) = VariableAddress[z] : +# 51| m0_8(int) = Uninitialized : r0_7 +# 53| r0_9(glval) = VariableAddress[x] : +# 53| r0_10(int) = Load : r0_9, m0_4 +# 53| r0_11(glval) = VariableAddress[y] : +# 53| r0_12(int) = Load : r0_11, m0_6 +# 53| r0_13(int) = Add : r0_10, r0_12 +# 53| r0_14(glval) = VariableAddress[z] : +# 53| m0_15(int) = Store : r0_14, r0_13 +# 54| r0_16(glval) = VariableAddress[x] : +# 54| r0_17(int) = Load : r0_16, m0_4 +# 54| r0_18(glval) = VariableAddress[y] : +# 54| r0_19(int) = Load : r0_18, m0_6 +# 54| r0_20(int) = Sub : r0_17, r0_19 +# 54| r0_21(glval) = VariableAddress[z] : +# 54| m0_22(int) = Store : r0_21, r0_20 +# 55| r0_23(glval) = VariableAddress[x] : +# 55| r0_24(int) = Load : r0_23, m0_4 +# 55| r0_25(glval) = VariableAddress[y] : +# 55| r0_26(int) = Load : r0_25, m0_6 +# 55| r0_27(int) = Mul : r0_24, r0_26 +# 55| r0_28(glval) = VariableAddress[z] : +# 55| m0_29(int) = Store : r0_28, r0_27 +# 56| r0_30(glval) = VariableAddress[x] : +# 56| r0_31(int) = Load : r0_30, m0_4 +# 56| r0_32(glval) = VariableAddress[y] : +# 56| r0_33(int) = Load : r0_32, m0_6 +# 56| r0_34(int) = Div : r0_31, r0_33 +# 56| r0_35(glval) = VariableAddress[z] : +# 56| m0_36(int) = Store : r0_35, r0_34 +# 57| r0_37(glval) = VariableAddress[x] : +# 57| r0_38(int) = Load : r0_37, m0_4 +# 57| r0_39(glval) = VariableAddress[y] : +# 57| r0_40(int) = Load : r0_39, m0_6 +# 57| r0_41(int) = Rem : r0_38, r0_40 +# 57| r0_42(glval) = VariableAddress[z] : +# 57| m0_43(int) = Store : r0_42, r0_41 +# 59| r0_44(glval) = VariableAddress[x] : +# 59| r0_45(int) = Load : r0_44, m0_4 +# 59| r0_46(glval) = VariableAddress[y] : +# 59| r0_47(int) = Load : r0_46, m0_6 +# 59| r0_48(int) = BitAnd : r0_45, r0_47 +# 59| r0_49(glval) = VariableAddress[z] : +# 59| m0_50(int) = Store : r0_49, r0_48 +# 60| r0_51(glval) = VariableAddress[x] : +# 60| r0_52(int) = Load : r0_51, m0_4 +# 60| r0_53(glval) = VariableAddress[y] : +# 60| r0_54(int) = Load : r0_53, m0_6 +# 60| r0_55(int) = BitOr : r0_52, r0_54 +# 60| r0_56(glval) = VariableAddress[z] : +# 60| m0_57(int) = Store : r0_56, r0_55 +# 61| r0_58(glval) = VariableAddress[x] : +# 61| r0_59(int) = Load : r0_58, m0_4 +# 61| r0_60(glval) = VariableAddress[y] : +# 61| r0_61(int) = Load : r0_60, m0_6 +# 61| r0_62(int) = BitXor : r0_59, r0_61 +# 61| r0_63(glval) = VariableAddress[z] : +# 61| m0_64(int) = Store : r0_63, r0_62 +# 63| r0_65(glval) = VariableAddress[x] : +# 63| r0_66(int) = Load : r0_65, m0_4 +# 63| r0_67(glval) = VariableAddress[y] : +# 63| r0_68(int) = Load : r0_67, m0_6 +# 63| r0_69(int) = ShiftLeft : r0_66, r0_68 +# 63| r0_70(glval) = VariableAddress[z] : +# 63| m0_71(int) = Store : r0_70, r0_69 +# 64| r0_72(glval) = VariableAddress[x] : +# 64| r0_73(int) = Load : r0_72, m0_4 +# 64| r0_74(glval) = VariableAddress[y] : +# 64| r0_75(int) = Load : r0_74, m0_6 +# 64| r0_76(int) = ShiftRight : r0_73, r0_75 +# 64| r0_77(glval) = VariableAddress[z] : +# 64| m0_78(int) = Store : r0_77, r0_76 +# 66| r0_79(glval) = VariableAddress[x] : +# 66| r0_80(int) = Load : r0_79, m0_4 +# 66| r0_81(glval) = VariableAddress[z] : +# 66| m0_82(int) = Store : r0_81, r0_80 +# 68| r0_83(glval) = VariableAddress[x] : +# 68| r0_84(int) = Load : r0_83, m0_4 +# 68| r0_85(glval) = VariableAddress[z] : +# 68| r0_86(int) = Load : r0_85, m0_82 +# 68| r0_87(int) = Add : r0_86, r0_84 +# 68| m0_88(int) = Store : r0_85, r0_87 +# 69| r0_89(glval) = VariableAddress[x] : +# 69| r0_90(int) = Load : r0_89, m0_4 +# 69| r0_91(glval) = VariableAddress[z] : +# 69| r0_92(int) = Load : r0_91, m0_88 +# 69| r0_93(int) = Sub : r0_92, r0_90 +# 69| m0_94(int) = Store : r0_91, r0_93 +# 70| r0_95(glval) = VariableAddress[x] : +# 70| r0_96(int) = Load : r0_95, m0_4 +# 70| r0_97(glval) = VariableAddress[z] : +# 70| r0_98(int) = Load : r0_97, m0_94 +# 70| r0_99(int) = Mul : r0_98, r0_96 +# 70| m0_100(int) = Store : r0_97, r0_99 +# 71| r0_101(glval) = VariableAddress[x] : +# 71| r0_102(int) = Load : r0_101, m0_4 +# 71| r0_103(glval) = VariableAddress[z] : +# 71| r0_104(int) = Load : r0_103, m0_100 +# 71| r0_105(int) = Div : r0_104, r0_102 +# 71| m0_106(int) = Store : r0_103, r0_105 +# 72| r0_107(glval) = VariableAddress[x] : +# 72| r0_108(int) = Load : r0_107, m0_4 +# 72| r0_109(glval) = VariableAddress[z] : +# 72| r0_110(int) = Load : r0_109, m0_106 +# 72| r0_111(int) = Rem : r0_110, r0_108 +# 72| m0_112(int) = Store : r0_109, r0_111 +# 74| r0_113(glval) = VariableAddress[x] : +# 74| r0_114(int) = Load : r0_113, m0_4 +# 74| r0_115(glval) = VariableAddress[z] : +# 74| r0_116(int) = Load : r0_115, m0_112 +# 74| r0_117(int) = BitAnd : r0_116, r0_114 +# 74| m0_118(int) = Store : r0_115, r0_117 +# 75| r0_119(glval) = VariableAddress[x] : +# 75| r0_120(int) = Load : r0_119, m0_4 +# 75| r0_121(glval) = VariableAddress[z] : +# 75| r0_122(int) = Load : r0_121, m0_118 +# 75| r0_123(int) = BitOr : r0_122, r0_120 +# 75| m0_124(int) = Store : r0_121, r0_123 +# 76| r0_125(glval) = VariableAddress[x] : +# 76| r0_126(int) = Load : r0_125, m0_4 +# 76| r0_127(glval) = VariableAddress[z] : +# 76| r0_128(int) = Load : r0_127, m0_124 +# 76| r0_129(int) = BitXor : r0_128, r0_126 +# 76| m0_130(int) = Store : r0_127, r0_129 +# 78| r0_131(glval) = VariableAddress[x] : +# 78| r0_132(int) = Load : r0_131, m0_4 +# 78| r0_133(glval) = VariableAddress[z] : +# 78| r0_134(int) = Load : r0_133, m0_130 +# 78| r0_135(int) = ShiftLeft : r0_134, r0_132 +# 78| m0_136(int) = Store : r0_133, r0_135 +# 79| r0_137(glval) = VariableAddress[x] : +# 79| r0_138(int) = Load : r0_137, m0_4 +# 79| r0_139(glval) = VariableAddress[z] : +# 79| r0_140(int) = Load : r0_139, m0_136 +# 79| r0_141(int) = ShiftRight : r0_140, r0_138 +# 79| m0_142(int) = Store : r0_139, r0_141 +# 81| r0_143(glval) = VariableAddress[x] : +# 81| r0_144(int) = Load : r0_143, m0_4 +# 81| r0_145(int) = CopyValue : r0_144 +# 81| r0_146(glval) = VariableAddress[z] : +# 81| m0_147(int) = Store : r0_146, r0_145 +# 82| r0_148(glval) = VariableAddress[x] : +# 82| r0_149(int) = Load : r0_148, m0_4 +# 82| r0_150(int) = Negate : r0_149 +# 82| r0_151(glval) = VariableAddress[z] : +# 82| m0_152(int) = Store : r0_151, r0_150 +# 83| r0_153(glval) = VariableAddress[x] : +# 83| r0_154(int) = Load : r0_153, m0_4 +# 83| r0_155(int) = BitComplement : r0_154 +# 83| r0_156(glval) = VariableAddress[z] : +# 83| m0_157(int) = Store : r0_156, r0_155 +# 84| r0_158(glval) = VariableAddress[x] : +# 84| r0_159(int) = Load : r0_158, m0_4 +# 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| m0_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) = ExitFunction : # 87| IntegerCompare(int, int) -> void # 87| Block 0 # 87| v0_0(void) = EnterFunction : -# 87| mu0_1(unknown) = UnmodeledDefinition : -# 87| r0_2(glval) = VariableAddress[x] : -# 87| m0_3(int) = InitializeParameter[x] : r0_2 -# 87| r0_4(glval) = VariableAddress[y] : -# 87| m0_5(int) = InitializeParameter[y] : r0_4 -# 88| r0_6(glval) = VariableAddress[b] : -# 88| m0_7(bool) = Uninitialized : r0_6 -# 90| r0_8(glval) = VariableAddress[x] : -# 90| r0_9(int) = Load : r0_8, m0_3 -# 90| r0_10(glval) = VariableAddress[y] : -# 90| r0_11(int) = Load : r0_10, m0_5 -# 90| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 90| r0_13(glval) = VariableAddress[b] : -# 90| m0_14(bool) = Store : r0_13, r0_12 -# 91| r0_15(glval) = VariableAddress[x] : -# 91| r0_16(int) = Load : r0_15, m0_3 -# 91| r0_17(glval) = VariableAddress[y] : -# 91| r0_18(int) = Load : r0_17, m0_5 -# 91| r0_19(bool) = CompareNE : r0_16, r0_18 -# 91| r0_20(glval) = VariableAddress[b] : -# 91| m0_21(bool) = Store : r0_20, r0_19 -# 92| r0_22(glval) = VariableAddress[x] : -# 92| r0_23(int) = Load : r0_22, m0_3 -# 92| r0_24(glval) = VariableAddress[y] : -# 92| r0_25(int) = Load : r0_24, m0_5 -# 92| r0_26(bool) = CompareLT : r0_23, r0_25 -# 92| r0_27(glval) = VariableAddress[b] : -# 92| m0_28(bool) = Store : r0_27, r0_26 -# 93| r0_29(glval) = VariableAddress[x] : -# 93| r0_30(int) = Load : r0_29, m0_3 -# 93| r0_31(glval) = VariableAddress[y] : -# 93| r0_32(int) = Load : r0_31, m0_5 -# 93| r0_33(bool) = CompareGT : r0_30, r0_32 -# 93| r0_34(glval) = VariableAddress[b] : -# 93| m0_35(bool) = Store : r0_34, r0_33 -# 94| r0_36(glval) = VariableAddress[x] : -# 94| r0_37(int) = Load : r0_36, m0_3 -# 94| r0_38(glval) = VariableAddress[y] : -# 94| r0_39(int) = Load : r0_38, m0_5 -# 94| r0_40(bool) = CompareLE : r0_37, r0_39 -# 94| r0_41(glval) = VariableAddress[b] : -# 94| m0_42(bool) = Store : r0_41, r0_40 -# 95| r0_43(glval) = VariableAddress[x] : -# 95| r0_44(int) = Load : r0_43, m0_3 -# 95| r0_45(glval) = VariableAddress[y] : -# 95| r0_46(int) = Load : r0_45, m0_5 -# 95| r0_47(bool) = CompareGE : r0_44, r0_46 -# 95| r0_48(glval) = VariableAddress[b] : -# 95| m0_49(bool) = Store : r0_48, r0_47 -# 96| v0_50(void) = NoOp : -# 87| v0_51(void) = ReturnVoid : -# 87| v0_52(void) = UnmodeledUse : mu* -# 87| v0_53(void) = ExitFunction : +# 87| mu0_1(unknown) = AliasedDefinition : +# 87| mu0_2(unknown) = UnmodeledDefinition : +# 87| r0_3(glval) = VariableAddress[x] : +# 87| m0_4(int) = InitializeParameter[x] : r0_3 +# 87| r0_5(glval) = VariableAddress[y] : +# 87| m0_6(int) = InitializeParameter[y] : r0_5 +# 88| r0_7(glval) = VariableAddress[b] : +# 88| m0_8(bool) = Uninitialized : r0_7 +# 90| r0_9(glval) = VariableAddress[x] : +# 90| r0_10(int) = Load : r0_9, m0_4 +# 90| r0_11(glval) = VariableAddress[y] : +# 90| r0_12(int) = Load : r0_11, m0_6 +# 90| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 90| r0_14(glval) = VariableAddress[b] : +# 90| m0_15(bool) = Store : r0_14, r0_13 +# 91| r0_16(glval) = VariableAddress[x] : +# 91| r0_17(int) = Load : r0_16, m0_4 +# 91| r0_18(glval) = VariableAddress[y] : +# 91| r0_19(int) = Load : r0_18, m0_6 +# 91| r0_20(bool) = CompareNE : r0_17, r0_19 +# 91| r0_21(glval) = VariableAddress[b] : +# 91| m0_22(bool) = Store : r0_21, r0_20 +# 92| r0_23(glval) = VariableAddress[x] : +# 92| r0_24(int) = Load : r0_23, m0_4 +# 92| r0_25(glval) = VariableAddress[y] : +# 92| r0_26(int) = Load : r0_25, m0_6 +# 92| r0_27(bool) = CompareLT : r0_24, r0_26 +# 92| r0_28(glval) = VariableAddress[b] : +# 92| m0_29(bool) = Store : r0_28, r0_27 +# 93| r0_30(glval) = VariableAddress[x] : +# 93| r0_31(int) = Load : r0_30, m0_4 +# 93| r0_32(glval) = VariableAddress[y] : +# 93| r0_33(int) = Load : r0_32, m0_6 +# 93| r0_34(bool) = CompareGT : r0_31, r0_33 +# 93| r0_35(glval) = VariableAddress[b] : +# 93| m0_36(bool) = Store : r0_35, r0_34 +# 94| r0_37(glval) = VariableAddress[x] : +# 94| r0_38(int) = Load : r0_37, m0_4 +# 94| r0_39(glval) = VariableAddress[y] : +# 94| r0_40(int) = Load : r0_39, m0_6 +# 94| r0_41(bool) = CompareLE : r0_38, r0_40 +# 94| r0_42(glval) = VariableAddress[b] : +# 94| m0_43(bool) = Store : r0_42, r0_41 +# 95| r0_44(glval) = VariableAddress[x] : +# 95| r0_45(int) = Load : r0_44, m0_4 +# 95| r0_46(glval) = VariableAddress[y] : +# 95| r0_47(int) = Load : r0_46, m0_6 +# 95| r0_48(bool) = CompareGE : r0_45, r0_47 +# 95| r0_49(glval) = VariableAddress[b] : +# 95| m0_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) = ExitFunction : # 98| IntegerCrement(int) -> void # 98| Block 0 # 98| v0_0(void) = EnterFunction : -# 98| mu0_1(unknown) = UnmodeledDefinition : -# 98| r0_2(glval) = VariableAddress[x] : -# 98| m0_3(int) = InitializeParameter[x] : r0_2 -# 99| r0_4(glval) = VariableAddress[y] : -# 99| m0_5(int) = Uninitialized : r0_4 -# 101| r0_6(glval) = VariableAddress[x] : -# 101| r0_7(int) = Load : r0_6, m0_3 -# 101| r0_8(int) = Constant[1] : -# 101| r0_9(int) = Add : r0_7, r0_8 -# 101| m0_10(int) = Store : r0_6, r0_9 -# 101| r0_11(glval) = VariableAddress[y] : -# 101| m0_12(int) = Store : r0_11, r0_9 -# 102| r0_13(glval) = VariableAddress[x] : -# 102| r0_14(int) = Load : r0_13, m0_10 -# 102| r0_15(int) = Constant[1] : -# 102| r0_16(int) = Sub : r0_14, r0_15 -# 102| m0_17(int) = Store : r0_13, r0_16 -# 102| r0_18(glval) = VariableAddress[y] : -# 102| m0_19(int) = Store : r0_18, r0_16 -# 103| r0_20(glval) = VariableAddress[x] : -# 103| r0_21(int) = Load : r0_20, m0_17 -# 103| r0_22(int) = Constant[1] : -# 103| r0_23(int) = Add : r0_21, r0_22 -# 103| m0_24(int) = Store : r0_20, r0_23 -# 103| r0_25(glval) = VariableAddress[y] : -# 103| m0_26(int) = Store : r0_25, r0_21 -# 104| r0_27(glval) = VariableAddress[x] : -# 104| r0_28(int) = Load : r0_27, m0_24 -# 104| r0_29(int) = Constant[1] : -# 104| r0_30(int) = Sub : r0_28, r0_29 -# 104| m0_31(int) = Store : r0_27, r0_30 -# 104| r0_32(glval) = VariableAddress[y] : -# 104| m0_33(int) = Store : r0_32, r0_28 -# 105| v0_34(void) = NoOp : -# 98| v0_35(void) = ReturnVoid : -# 98| v0_36(void) = UnmodeledUse : mu* -# 98| v0_37(void) = ExitFunction : +# 98| mu0_1(unknown) = AliasedDefinition : +# 98| mu0_2(unknown) = UnmodeledDefinition : +# 98| r0_3(glval) = VariableAddress[x] : +# 98| m0_4(int) = InitializeParameter[x] : r0_3 +# 99| r0_5(glval) = VariableAddress[y] : +# 99| m0_6(int) = Uninitialized : r0_5 +# 101| r0_7(glval) = VariableAddress[x] : +# 101| r0_8(int) = Load : r0_7, m0_4 +# 101| r0_9(int) = Constant[1] : +# 101| r0_10(int) = Add : r0_8, r0_9 +# 101| m0_11(int) = Store : r0_7, r0_10 +# 101| r0_12(glval) = VariableAddress[y] : +# 101| m0_13(int) = Store : r0_12, r0_10 +# 102| r0_14(glval) = VariableAddress[x] : +# 102| r0_15(int) = Load : r0_14, m0_11 +# 102| r0_16(int) = Constant[1] : +# 102| r0_17(int) = Sub : r0_15, r0_16 +# 102| m0_18(int) = Store : r0_14, r0_17 +# 102| r0_19(glval) = VariableAddress[y] : +# 102| m0_20(int) = Store : r0_19, r0_17 +# 103| r0_21(glval) = VariableAddress[x] : +# 103| r0_22(int) = Load : r0_21, m0_18 +# 103| r0_23(int) = Constant[1] : +# 103| r0_24(int) = Add : r0_22, r0_23 +# 103| m0_25(int) = Store : r0_21, r0_24 +# 103| r0_26(glval) = VariableAddress[y] : +# 103| m0_27(int) = Store : r0_26, r0_22 +# 104| r0_28(glval) = VariableAddress[x] : +# 104| r0_29(int) = Load : r0_28, m0_25 +# 104| r0_30(int) = Constant[1] : +# 104| r0_31(int) = Sub : r0_29, r0_30 +# 104| m0_32(int) = Store : r0_28, r0_31 +# 104| r0_33(glval) = VariableAddress[y] : +# 104| m0_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) = ExitFunction : # 107| IntegerCrement_LValue(int) -> void # 107| Block 0 # 107| v0_0(void) = EnterFunction : -# 107| mu0_1(unknown) = UnmodeledDefinition : -# 107| r0_2(glval) = VariableAddress[x] : -# 107| mu0_3(int) = InitializeParameter[x] : r0_2 -# 108| r0_4(glval) = VariableAddress[p] : -# 108| m0_5(int *) = Uninitialized : r0_4 -# 110| r0_6(glval) = VariableAddress[x] : -# 110| r0_7(int) = Load : r0_6, mu0_1 -# 110| r0_8(int) = Constant[1] : -# 110| r0_9(int) = Add : r0_7, r0_8 -# 110| mu0_10(int) = Store : r0_6, r0_9 -# 110| r0_11(glval) = VariableAddress[p] : -# 110| m0_12(int *) = Store : r0_11, r0_6 -# 111| r0_13(glval) = VariableAddress[x] : -# 111| r0_14(int) = Load : r0_13, mu0_1 -# 111| r0_15(int) = Constant[1] : -# 111| r0_16(int) = Sub : r0_14, r0_15 -# 111| mu0_17(int) = Store : r0_13, r0_16 -# 111| r0_18(glval) = VariableAddress[p] : -# 111| m0_19(int *) = Store : r0_18, r0_13 -# 112| v0_20(void) = NoOp : -# 107| v0_21(void) = ReturnVoid : -# 107| v0_22(void) = UnmodeledUse : mu* -# 107| v0_23(void) = ExitFunction : +# 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| m0_6(int *) = Uninitialized : 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) = VariableAddress[p] : +# 110| m0_13(int *) = Store : r0_12, r0_7 +# 111| r0_14(glval) = VariableAddress[x] : +# 111| r0_15(int) = Load : r0_14, mu0_2 +# 111| r0_16(int) = Constant[1] : +# 111| r0_17(int) = Sub : r0_15, r0_16 +# 111| mu0_18(int) = Store : r0_14, r0_17 +# 111| r0_19(glval) = VariableAddress[p] : +# 111| m0_20(int *) = Store : r0_19, r0_14 +# 112| v0_21(void) = NoOp : +# 107| v0_22(void) = ReturnVoid : +# 107| v0_23(void) = UnmodeledUse : mu* +# 107| v0_24(void) = ExitFunction : # 114| FloatOps(double, double) -> void # 114| Block 0 # 114| v0_0(void) = EnterFunction : -# 114| mu0_1(unknown) = UnmodeledDefinition : -# 114| r0_2(glval) = VariableAddress[x] : -# 114| m0_3(double) = InitializeParameter[x] : r0_2 -# 114| r0_4(glval) = VariableAddress[y] : -# 114| m0_5(double) = InitializeParameter[y] : r0_4 -# 115| r0_6(glval) = VariableAddress[z] : -# 115| m0_7(double) = Uninitialized : r0_6 -# 117| r0_8(glval) = VariableAddress[x] : -# 117| r0_9(double) = Load : r0_8, m0_3 -# 117| r0_10(glval) = VariableAddress[y] : -# 117| r0_11(double) = Load : r0_10, m0_5 -# 117| r0_12(double) = Add : r0_9, r0_11 -# 117| r0_13(glval) = VariableAddress[z] : -# 117| m0_14(double) = Store : r0_13, r0_12 -# 118| r0_15(glval) = VariableAddress[x] : -# 118| r0_16(double) = Load : r0_15, m0_3 -# 118| r0_17(glval) = VariableAddress[y] : -# 118| r0_18(double) = Load : r0_17, m0_5 -# 118| r0_19(double) = Sub : r0_16, r0_18 -# 118| r0_20(glval) = VariableAddress[z] : -# 118| m0_21(double) = Store : r0_20, r0_19 -# 119| r0_22(glval) = VariableAddress[x] : -# 119| r0_23(double) = Load : r0_22, m0_3 -# 119| r0_24(glval) = VariableAddress[y] : -# 119| r0_25(double) = Load : r0_24, m0_5 -# 119| r0_26(double) = Mul : r0_23, r0_25 -# 119| r0_27(glval) = VariableAddress[z] : -# 119| m0_28(double) = Store : r0_27, r0_26 -# 120| r0_29(glval) = VariableAddress[x] : -# 120| r0_30(double) = Load : r0_29, m0_3 -# 120| r0_31(glval) = VariableAddress[y] : -# 120| r0_32(double) = Load : r0_31, m0_5 -# 120| r0_33(double) = Div : r0_30, r0_32 -# 120| r0_34(glval) = VariableAddress[z] : -# 120| m0_35(double) = Store : r0_34, r0_33 -# 122| r0_36(glval) = VariableAddress[x] : -# 122| r0_37(double) = Load : r0_36, m0_3 -# 122| r0_38(glval) = VariableAddress[z] : -# 122| m0_39(double) = Store : r0_38, r0_37 -# 124| r0_40(glval) = VariableAddress[x] : -# 124| r0_41(double) = Load : r0_40, m0_3 -# 124| r0_42(glval) = VariableAddress[z] : -# 124| r0_43(double) = Load : r0_42, m0_39 -# 124| r0_44(double) = Add : r0_43, r0_41 -# 124| m0_45(double) = Store : r0_42, r0_44 -# 125| r0_46(glval) = VariableAddress[x] : -# 125| r0_47(double) = Load : r0_46, m0_3 -# 125| r0_48(glval) = VariableAddress[z] : -# 125| r0_49(double) = Load : r0_48, m0_45 -# 125| r0_50(double) = Sub : r0_49, r0_47 -# 125| m0_51(double) = Store : r0_48, r0_50 -# 126| r0_52(glval) = VariableAddress[x] : -# 126| r0_53(double) = Load : r0_52, m0_3 -# 126| r0_54(glval) = VariableAddress[z] : -# 126| r0_55(double) = Load : r0_54, m0_51 -# 126| r0_56(double) = Mul : r0_55, r0_53 -# 126| m0_57(double) = Store : r0_54, r0_56 -# 127| r0_58(glval) = VariableAddress[x] : -# 127| r0_59(double) = Load : r0_58, m0_3 -# 127| r0_60(glval) = VariableAddress[z] : -# 127| r0_61(double) = Load : r0_60, m0_57 -# 127| r0_62(double) = Div : r0_61, r0_59 -# 127| m0_63(double) = Store : r0_60, r0_62 -# 129| r0_64(glval) = VariableAddress[x] : -# 129| r0_65(double) = Load : r0_64, m0_3 -# 129| r0_66(double) = CopyValue : r0_65 -# 129| r0_67(glval) = VariableAddress[z] : -# 129| m0_68(double) = Store : r0_67, r0_66 -# 130| r0_69(glval) = VariableAddress[x] : -# 130| r0_70(double) = Load : r0_69, m0_3 -# 130| r0_71(double) = Negate : r0_70 -# 130| r0_72(glval) = VariableAddress[z] : -# 130| m0_73(double) = Store : r0_72, r0_71 -# 131| v0_74(void) = NoOp : -# 114| v0_75(void) = ReturnVoid : -# 114| v0_76(void) = UnmodeledUse : mu* -# 114| v0_77(void) = ExitFunction : +# 114| mu0_1(unknown) = AliasedDefinition : +# 114| mu0_2(unknown) = UnmodeledDefinition : +# 114| r0_3(glval) = VariableAddress[x] : +# 114| m0_4(double) = InitializeParameter[x] : r0_3 +# 114| r0_5(glval) = VariableAddress[y] : +# 114| m0_6(double) = InitializeParameter[y] : r0_5 +# 115| r0_7(glval) = VariableAddress[z] : +# 115| m0_8(double) = Uninitialized : r0_7 +# 117| r0_9(glval) = VariableAddress[x] : +# 117| r0_10(double) = Load : r0_9, m0_4 +# 117| r0_11(glval) = VariableAddress[y] : +# 117| r0_12(double) = Load : r0_11, m0_6 +# 117| r0_13(double) = Add : r0_10, r0_12 +# 117| r0_14(glval) = VariableAddress[z] : +# 117| m0_15(double) = Store : r0_14, r0_13 +# 118| r0_16(glval) = VariableAddress[x] : +# 118| r0_17(double) = Load : r0_16, m0_4 +# 118| r0_18(glval) = VariableAddress[y] : +# 118| r0_19(double) = Load : r0_18, m0_6 +# 118| r0_20(double) = Sub : r0_17, r0_19 +# 118| r0_21(glval) = VariableAddress[z] : +# 118| m0_22(double) = Store : r0_21, r0_20 +# 119| r0_23(glval) = VariableAddress[x] : +# 119| r0_24(double) = Load : r0_23, m0_4 +# 119| r0_25(glval) = VariableAddress[y] : +# 119| r0_26(double) = Load : r0_25, m0_6 +# 119| r0_27(double) = Mul : r0_24, r0_26 +# 119| r0_28(glval) = VariableAddress[z] : +# 119| m0_29(double) = Store : r0_28, r0_27 +# 120| r0_30(glval) = VariableAddress[x] : +# 120| r0_31(double) = Load : r0_30, m0_4 +# 120| r0_32(glval) = VariableAddress[y] : +# 120| r0_33(double) = Load : r0_32, m0_6 +# 120| r0_34(double) = Div : r0_31, r0_33 +# 120| r0_35(glval) = VariableAddress[z] : +# 120| m0_36(double) = Store : r0_35, r0_34 +# 122| r0_37(glval) = VariableAddress[x] : +# 122| r0_38(double) = Load : r0_37, m0_4 +# 122| r0_39(glval) = VariableAddress[z] : +# 122| m0_40(double) = Store : r0_39, r0_38 +# 124| r0_41(glval) = VariableAddress[x] : +# 124| r0_42(double) = Load : r0_41, m0_4 +# 124| r0_43(glval) = VariableAddress[z] : +# 124| r0_44(double) = Load : r0_43, m0_40 +# 124| r0_45(double) = Add : r0_44, r0_42 +# 124| m0_46(double) = Store : r0_43, r0_45 +# 125| r0_47(glval) = VariableAddress[x] : +# 125| r0_48(double) = Load : r0_47, m0_4 +# 125| r0_49(glval) = VariableAddress[z] : +# 125| r0_50(double) = Load : r0_49, m0_46 +# 125| r0_51(double) = Sub : r0_50, r0_48 +# 125| m0_52(double) = Store : r0_49, r0_51 +# 126| r0_53(glval) = VariableAddress[x] : +# 126| r0_54(double) = Load : r0_53, m0_4 +# 126| r0_55(glval) = VariableAddress[z] : +# 126| r0_56(double) = Load : r0_55, m0_52 +# 126| r0_57(double) = Mul : r0_56, r0_54 +# 126| m0_58(double) = Store : r0_55, r0_57 +# 127| r0_59(glval) = VariableAddress[x] : +# 127| r0_60(double) = Load : r0_59, m0_4 +# 127| r0_61(glval) = VariableAddress[z] : +# 127| r0_62(double) = Load : r0_61, m0_58 +# 127| r0_63(double) = Div : r0_62, r0_60 +# 127| m0_64(double) = Store : r0_61, r0_63 +# 129| r0_65(glval) = VariableAddress[x] : +# 129| r0_66(double) = Load : r0_65, m0_4 +# 129| r0_67(double) = CopyValue : r0_66 +# 129| r0_68(glval) = VariableAddress[z] : +# 129| m0_69(double) = Store : r0_68, r0_67 +# 130| r0_70(glval) = VariableAddress[x] : +# 130| r0_71(double) = Load : r0_70, m0_4 +# 130| r0_72(double) = Negate : r0_71 +# 130| r0_73(glval) = VariableAddress[z] : +# 130| m0_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) = ExitFunction : # 133| FloatCompare(double, double) -> void # 133| Block 0 # 133| v0_0(void) = EnterFunction : -# 133| mu0_1(unknown) = UnmodeledDefinition : -# 133| r0_2(glval) = VariableAddress[x] : -# 133| m0_3(double) = InitializeParameter[x] : r0_2 -# 133| r0_4(glval) = VariableAddress[y] : -# 133| m0_5(double) = InitializeParameter[y] : r0_4 -# 134| r0_6(glval) = VariableAddress[b] : -# 134| m0_7(bool) = Uninitialized : r0_6 -# 136| r0_8(glval) = VariableAddress[x] : -# 136| r0_9(double) = Load : r0_8, m0_3 -# 136| r0_10(glval) = VariableAddress[y] : -# 136| r0_11(double) = Load : r0_10, m0_5 -# 136| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 136| r0_13(glval) = VariableAddress[b] : -# 136| m0_14(bool) = Store : r0_13, r0_12 -# 137| r0_15(glval) = VariableAddress[x] : -# 137| r0_16(double) = Load : r0_15, m0_3 -# 137| r0_17(glval) = VariableAddress[y] : -# 137| r0_18(double) = Load : r0_17, m0_5 -# 137| r0_19(bool) = CompareNE : r0_16, r0_18 -# 137| r0_20(glval) = VariableAddress[b] : -# 137| m0_21(bool) = Store : r0_20, r0_19 -# 138| r0_22(glval) = VariableAddress[x] : -# 138| r0_23(double) = Load : r0_22, m0_3 -# 138| r0_24(glval) = VariableAddress[y] : -# 138| r0_25(double) = Load : r0_24, m0_5 -# 138| r0_26(bool) = CompareLT : r0_23, r0_25 -# 138| r0_27(glval) = VariableAddress[b] : -# 138| m0_28(bool) = Store : r0_27, r0_26 -# 139| r0_29(glval) = VariableAddress[x] : -# 139| r0_30(double) = Load : r0_29, m0_3 -# 139| r0_31(glval) = VariableAddress[y] : -# 139| r0_32(double) = Load : r0_31, m0_5 -# 139| r0_33(bool) = CompareGT : r0_30, r0_32 -# 139| r0_34(glval) = VariableAddress[b] : -# 139| m0_35(bool) = Store : r0_34, r0_33 -# 140| r0_36(glval) = VariableAddress[x] : -# 140| r0_37(double) = Load : r0_36, m0_3 -# 140| r0_38(glval) = VariableAddress[y] : -# 140| r0_39(double) = Load : r0_38, m0_5 -# 140| r0_40(bool) = CompareLE : r0_37, r0_39 -# 140| r0_41(glval) = VariableAddress[b] : -# 140| m0_42(bool) = Store : r0_41, r0_40 -# 141| r0_43(glval) = VariableAddress[x] : -# 141| r0_44(double) = Load : r0_43, m0_3 -# 141| r0_45(glval) = VariableAddress[y] : -# 141| r0_46(double) = Load : r0_45, m0_5 -# 141| r0_47(bool) = CompareGE : r0_44, r0_46 -# 141| r0_48(glval) = VariableAddress[b] : -# 141| m0_49(bool) = Store : r0_48, r0_47 -# 142| v0_50(void) = NoOp : -# 133| v0_51(void) = ReturnVoid : -# 133| v0_52(void) = UnmodeledUse : mu* -# 133| v0_53(void) = ExitFunction : +# 133| mu0_1(unknown) = AliasedDefinition : +# 133| mu0_2(unknown) = UnmodeledDefinition : +# 133| r0_3(glval) = VariableAddress[x] : +# 133| m0_4(double) = InitializeParameter[x] : r0_3 +# 133| r0_5(glval) = VariableAddress[y] : +# 133| m0_6(double) = InitializeParameter[y] : r0_5 +# 134| r0_7(glval) = VariableAddress[b] : +# 134| m0_8(bool) = Uninitialized : r0_7 +# 136| r0_9(glval) = VariableAddress[x] : +# 136| r0_10(double) = Load : r0_9, m0_4 +# 136| r0_11(glval) = VariableAddress[y] : +# 136| r0_12(double) = Load : r0_11, m0_6 +# 136| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 136| r0_14(glval) = VariableAddress[b] : +# 136| m0_15(bool) = Store : r0_14, r0_13 +# 137| r0_16(glval) = VariableAddress[x] : +# 137| r0_17(double) = Load : r0_16, m0_4 +# 137| r0_18(glval) = VariableAddress[y] : +# 137| r0_19(double) = Load : r0_18, m0_6 +# 137| r0_20(bool) = CompareNE : r0_17, r0_19 +# 137| r0_21(glval) = VariableAddress[b] : +# 137| m0_22(bool) = Store : r0_21, r0_20 +# 138| r0_23(glval) = VariableAddress[x] : +# 138| r0_24(double) = Load : r0_23, m0_4 +# 138| r0_25(glval) = VariableAddress[y] : +# 138| r0_26(double) = Load : r0_25, m0_6 +# 138| r0_27(bool) = CompareLT : r0_24, r0_26 +# 138| r0_28(glval) = VariableAddress[b] : +# 138| m0_29(bool) = Store : r0_28, r0_27 +# 139| r0_30(glval) = VariableAddress[x] : +# 139| r0_31(double) = Load : r0_30, m0_4 +# 139| r0_32(glval) = VariableAddress[y] : +# 139| r0_33(double) = Load : r0_32, m0_6 +# 139| r0_34(bool) = CompareGT : r0_31, r0_33 +# 139| r0_35(glval) = VariableAddress[b] : +# 139| m0_36(bool) = Store : r0_35, r0_34 +# 140| r0_37(glval) = VariableAddress[x] : +# 140| r0_38(double) = Load : r0_37, m0_4 +# 140| r0_39(glval) = VariableAddress[y] : +# 140| r0_40(double) = Load : r0_39, m0_6 +# 140| r0_41(bool) = CompareLE : r0_38, r0_40 +# 140| r0_42(glval) = VariableAddress[b] : +# 140| m0_43(bool) = Store : r0_42, r0_41 +# 141| r0_44(glval) = VariableAddress[x] : +# 141| r0_45(double) = Load : r0_44, m0_4 +# 141| r0_46(glval) = VariableAddress[y] : +# 141| r0_47(double) = Load : r0_46, m0_6 +# 141| r0_48(bool) = CompareGE : r0_45, r0_47 +# 141| r0_49(glval) = VariableAddress[b] : +# 141| m0_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) = ExitFunction : # 144| FloatCrement(float) -> void # 144| Block 0 # 144| v0_0(void) = EnterFunction : -# 144| mu0_1(unknown) = UnmodeledDefinition : -# 144| r0_2(glval) = VariableAddress[x] : -# 144| m0_3(float) = InitializeParameter[x] : r0_2 -# 145| r0_4(glval) = VariableAddress[y] : -# 145| m0_5(float) = Uninitialized : r0_4 -# 147| r0_6(glval) = VariableAddress[x] : -# 147| r0_7(float) = Load : r0_6, m0_3 -# 147| r0_8(float) = Constant[1.0] : -# 147| r0_9(float) = Add : r0_7, r0_8 -# 147| m0_10(float) = Store : r0_6, r0_9 -# 147| r0_11(glval) = VariableAddress[y] : -# 147| m0_12(float) = Store : r0_11, r0_9 -# 148| r0_13(glval) = VariableAddress[x] : -# 148| r0_14(float) = Load : r0_13, m0_10 -# 148| r0_15(float) = Constant[1.0] : -# 148| r0_16(float) = Sub : r0_14, r0_15 -# 148| m0_17(float) = Store : r0_13, r0_16 -# 148| r0_18(glval) = VariableAddress[y] : -# 148| m0_19(float) = Store : r0_18, r0_16 -# 149| r0_20(glval) = VariableAddress[x] : -# 149| r0_21(float) = Load : r0_20, m0_17 -# 149| r0_22(float) = Constant[1.0] : -# 149| r0_23(float) = Add : r0_21, r0_22 -# 149| m0_24(float) = Store : r0_20, r0_23 -# 149| r0_25(glval) = VariableAddress[y] : -# 149| m0_26(float) = Store : r0_25, r0_21 -# 150| r0_27(glval) = VariableAddress[x] : -# 150| r0_28(float) = Load : r0_27, m0_24 -# 150| r0_29(float) = Constant[1.0] : -# 150| r0_30(float) = Sub : r0_28, r0_29 -# 150| m0_31(float) = Store : r0_27, r0_30 -# 150| r0_32(glval) = VariableAddress[y] : -# 150| m0_33(float) = Store : r0_32, r0_28 -# 151| v0_34(void) = NoOp : -# 144| v0_35(void) = ReturnVoid : -# 144| v0_36(void) = UnmodeledUse : mu* -# 144| v0_37(void) = ExitFunction : +# 144| mu0_1(unknown) = AliasedDefinition : +# 144| mu0_2(unknown) = UnmodeledDefinition : +# 144| r0_3(glval) = VariableAddress[x] : +# 144| m0_4(float) = InitializeParameter[x] : r0_3 +# 145| r0_5(glval) = VariableAddress[y] : +# 145| m0_6(float) = Uninitialized : r0_5 +# 147| r0_7(glval) = VariableAddress[x] : +# 147| r0_8(float) = Load : r0_7, m0_4 +# 147| r0_9(float) = Constant[1.0] : +# 147| r0_10(float) = Add : r0_8, r0_9 +# 147| m0_11(float) = Store : r0_7, r0_10 +# 147| r0_12(glval) = VariableAddress[y] : +# 147| m0_13(float) = Store : r0_12, r0_10 +# 148| r0_14(glval) = VariableAddress[x] : +# 148| r0_15(float) = Load : r0_14, m0_11 +# 148| r0_16(float) = Constant[1.0] : +# 148| r0_17(float) = Sub : r0_15, r0_16 +# 148| m0_18(float) = Store : r0_14, r0_17 +# 148| r0_19(glval) = VariableAddress[y] : +# 148| m0_20(float) = Store : r0_19, r0_17 +# 149| r0_21(glval) = VariableAddress[x] : +# 149| r0_22(float) = Load : r0_21, m0_18 +# 149| r0_23(float) = Constant[1.0] : +# 149| r0_24(float) = Add : r0_22, r0_23 +# 149| m0_25(float) = Store : r0_21, r0_24 +# 149| r0_26(glval) = VariableAddress[y] : +# 149| m0_27(float) = Store : r0_26, r0_22 +# 150| r0_28(glval) = VariableAddress[x] : +# 150| r0_29(float) = Load : r0_28, m0_25 +# 150| r0_30(float) = Constant[1.0] : +# 150| r0_31(float) = Sub : r0_29, r0_30 +# 150| m0_32(float) = Store : r0_28, r0_31 +# 150| r0_33(glval) = VariableAddress[y] : +# 150| m0_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) = ExitFunction : # 153| PointerOps(int *, int) -> void # 153| Block 0 # 153| v0_0(void) = EnterFunction : -# 153| mu0_1(unknown) = UnmodeledDefinition : -# 153| r0_2(glval) = VariableAddress[p] : -# 153| m0_3(int *) = InitializeParameter[p] : r0_2 -# 153| r0_4(glval) = VariableAddress[i] : -# 153| m0_5(int) = InitializeParameter[i] : r0_4 -# 154| r0_6(glval) = VariableAddress[q] : -# 154| m0_7(int *) = Uninitialized : r0_6 -# 155| r0_8(glval) = VariableAddress[b] : -# 155| m0_9(bool) = Uninitialized : r0_8 -# 157| r0_10(glval) = VariableAddress[p] : -# 157| r0_11(int *) = Load : r0_10, m0_3 -# 157| r0_12(glval) = VariableAddress[i] : -# 157| r0_13(int) = Load : r0_12, m0_5 -# 157| r0_14(int *) = PointerAdd[4] : r0_11, r0_13 -# 157| r0_15(glval) = VariableAddress[q] : -# 157| m0_16(int *) = Store : r0_15, r0_14 -# 158| r0_17(glval) = VariableAddress[i] : -# 158| r0_18(int) = Load : r0_17, m0_5 -# 158| r0_19(glval) = VariableAddress[p] : -# 158| r0_20(int *) = Load : r0_19, m0_3 -# 158| r0_21(int *) = PointerAdd[4] : r0_20, r0_18 -# 158| r0_22(glval) = VariableAddress[q] : -# 158| m0_23(int *) = Store : r0_22, r0_21 -# 159| r0_24(glval) = VariableAddress[p] : -# 159| r0_25(int *) = Load : r0_24, m0_3 -# 159| r0_26(glval) = VariableAddress[i] : -# 159| r0_27(int) = Load : r0_26, m0_5 -# 159| r0_28(int *) = PointerSub[4] : r0_25, r0_27 -# 159| r0_29(glval) = VariableAddress[q] : -# 159| m0_30(int *) = Store : r0_29, r0_28 -# 160| r0_31(glval) = VariableAddress[p] : -# 160| r0_32(int *) = Load : r0_31, m0_3 -# 160| r0_33(glval) = VariableAddress[q] : -# 160| r0_34(int *) = Load : r0_33, m0_30 -# 160| r0_35(long) = PointerDiff[4] : r0_32, r0_34 -# 160| r0_36(int) = Convert : r0_35 -# 160| r0_37(glval) = VariableAddress[i] : -# 160| m0_38(int) = Store : r0_37, r0_36 -# 162| r0_39(glval) = VariableAddress[p] : -# 162| r0_40(int *) = Load : r0_39, m0_3 -# 162| r0_41(glval) = VariableAddress[q] : -# 162| m0_42(int *) = Store : r0_41, r0_40 -# 164| r0_43(glval) = VariableAddress[i] : -# 164| r0_44(int) = Load : r0_43, m0_38 -# 164| r0_45(glval) = VariableAddress[q] : -# 164| r0_46(int *) = Load : r0_45, m0_42 -# 164| r0_47(int *) = PointerAdd[4] : r0_46, r0_44 -# 164| m0_48(int *) = Store : r0_45, r0_47 -# 165| r0_49(glval) = VariableAddress[i] : -# 165| r0_50(int) = Load : r0_49, m0_38 -# 165| r0_51(glval) = VariableAddress[q] : -# 165| r0_52(int *) = Load : r0_51, m0_48 -# 165| r0_53(int *) = PointerSub[4] : r0_52, r0_50 -# 165| m0_54(int *) = Store : r0_51, r0_53 -# 167| r0_55(glval) = VariableAddress[p] : -# 167| r0_56(int *) = Load : r0_55, m0_3 -# 167| r0_57(int *) = Constant[0] : -# 167| r0_58(bool) = CompareNE : r0_56, r0_57 -# 167| r0_59(glval) = VariableAddress[b] : -# 167| m0_60(bool) = Store : r0_59, r0_58 -# 168| r0_61(glval) = VariableAddress[p] : -# 168| r0_62(int *) = Load : r0_61, m0_3 -# 168| r0_63(int *) = Constant[0] : -# 168| r0_64(bool) = CompareNE : r0_62, r0_63 -# 168| r0_65(bool) = LogicalNot : r0_64 -# 168| r0_66(glval) = VariableAddress[b] : -# 168| m0_67(bool) = Store : r0_66, r0_65 -# 169| v0_68(void) = NoOp : -# 153| v0_69(void) = ReturnVoid : -# 153| v0_70(void) = UnmodeledUse : mu* -# 153| v0_71(void) = ExitFunction : +# 153| mu0_1(unknown) = AliasedDefinition : +# 153| mu0_2(unknown) = UnmodeledDefinition : +# 153| r0_3(glval) = VariableAddress[p] : +# 153| m0_4(int *) = InitializeParameter[p] : r0_3 +# 153| r0_5(glval) = VariableAddress[i] : +# 153| m0_6(int) = InitializeParameter[i] : r0_5 +# 154| r0_7(glval) = VariableAddress[q] : +# 154| m0_8(int *) = Uninitialized : r0_7 +# 155| r0_9(glval) = VariableAddress[b] : +# 155| m0_10(bool) = Uninitialized : r0_9 +# 157| r0_11(glval) = VariableAddress[p] : +# 157| r0_12(int *) = Load : r0_11, m0_4 +# 157| r0_13(glval) = VariableAddress[i] : +# 157| r0_14(int) = Load : r0_13, m0_6 +# 157| r0_15(int *) = PointerAdd[4] : r0_12, r0_14 +# 157| r0_16(glval) = VariableAddress[q] : +# 157| m0_17(int *) = Store : r0_16, r0_15 +# 158| r0_18(glval) = VariableAddress[i] : +# 158| r0_19(int) = Load : r0_18, m0_6 +# 158| r0_20(glval) = VariableAddress[p] : +# 158| r0_21(int *) = Load : r0_20, m0_4 +# 158| r0_22(int *) = PointerAdd[4] : r0_21, r0_19 +# 158| r0_23(glval) = VariableAddress[q] : +# 158| m0_24(int *) = Store : r0_23, r0_22 +# 159| r0_25(glval) = VariableAddress[p] : +# 159| r0_26(int *) = Load : r0_25, m0_4 +# 159| r0_27(glval) = VariableAddress[i] : +# 159| r0_28(int) = Load : r0_27, m0_6 +# 159| r0_29(int *) = PointerSub[4] : r0_26, r0_28 +# 159| r0_30(glval) = VariableAddress[q] : +# 159| m0_31(int *) = Store : r0_30, r0_29 +# 160| r0_32(glval) = VariableAddress[p] : +# 160| r0_33(int *) = Load : r0_32, m0_4 +# 160| r0_34(glval) = VariableAddress[q] : +# 160| r0_35(int *) = Load : r0_34, m0_31 +# 160| r0_36(long) = PointerDiff[4] : r0_33, r0_35 +# 160| r0_37(int) = Convert : r0_36 +# 160| r0_38(glval) = VariableAddress[i] : +# 160| m0_39(int) = Store : r0_38, r0_37 +# 162| r0_40(glval) = VariableAddress[p] : +# 162| r0_41(int *) = Load : r0_40, m0_4 +# 162| r0_42(glval) = VariableAddress[q] : +# 162| m0_43(int *) = Store : r0_42, r0_41 +# 164| r0_44(glval) = VariableAddress[i] : +# 164| r0_45(int) = Load : r0_44, m0_39 +# 164| r0_46(glval) = VariableAddress[q] : +# 164| r0_47(int *) = Load : r0_46, m0_43 +# 164| r0_48(int *) = PointerAdd[4] : r0_47, r0_45 +# 164| m0_49(int *) = Store : r0_46, r0_48 +# 165| r0_50(glval) = VariableAddress[i] : +# 165| r0_51(int) = Load : r0_50, m0_39 +# 165| r0_52(glval) = VariableAddress[q] : +# 165| r0_53(int *) = Load : r0_52, m0_49 +# 165| r0_54(int *) = PointerSub[4] : r0_53, r0_51 +# 165| m0_55(int *) = Store : r0_52, r0_54 +# 167| r0_56(glval) = VariableAddress[p] : +# 167| r0_57(int *) = Load : r0_56, m0_4 +# 167| r0_58(int *) = Constant[0] : +# 167| r0_59(bool) = CompareNE : r0_57, r0_58 +# 167| r0_60(glval) = VariableAddress[b] : +# 167| m0_61(bool) = Store : r0_60, r0_59 +# 168| r0_62(glval) = VariableAddress[p] : +# 168| r0_63(int *) = Load : r0_62, m0_4 +# 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| m0_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) = ExitFunction : # 171| ArrayAccess(int *, int) -> void # 171| Block 0 # 171| v0_0(void) = EnterFunction : -# 171| mu0_1(unknown) = UnmodeledDefinition : -# 171| r0_2(glval) = VariableAddress[p] : -# 171| m0_3(int *) = InitializeParameter[p] : r0_2 -# 171| r0_4(glval) = VariableAddress[i] : -# 171| m0_5(int) = InitializeParameter[i] : r0_4 -# 172| r0_6(glval) = VariableAddress[x] : -# 172| m0_7(int) = Uninitialized : r0_6 -# 174| r0_8(glval) = VariableAddress[p] : -# 174| r0_9(int *) = Load : r0_8, m0_3 -# 174| r0_10(glval) = VariableAddress[i] : -# 174| r0_11(int) = Load : r0_10, m0_5 -# 174| r0_12(int *) = PointerAdd[4] : r0_9, r0_11 -# 174| r0_13(int) = Load : r0_12, mu0_1 -# 174| r0_14(glval) = VariableAddress[x] : -# 174| m0_15(int) = Store : r0_14, r0_13 -# 175| r0_16(glval) = VariableAddress[p] : -# 175| r0_17(int *) = Load : r0_16, m0_3 -# 175| r0_18(glval) = VariableAddress[i] : -# 175| r0_19(int) = Load : r0_18, m0_5 -# 175| r0_20(int *) = PointerAdd[4] : r0_17, r0_19 -# 175| r0_21(int) = Load : r0_20, mu0_1 -# 175| r0_22(glval) = VariableAddress[x] : -# 175| m0_23(int) = Store : r0_22, r0_21 -# 177| r0_24(glval) = VariableAddress[x] : -# 177| r0_25(int) = Load : r0_24, m0_23 -# 177| r0_26(glval) = VariableAddress[p] : -# 177| r0_27(int *) = Load : r0_26, m0_3 -# 177| r0_28(glval) = VariableAddress[i] : -# 177| r0_29(int) = Load : r0_28, m0_5 -# 177| r0_30(int *) = PointerAdd[4] : r0_27, r0_29 -# 177| mu0_31(int) = Store : r0_30, r0_25 -# 178| r0_32(glval) = VariableAddress[x] : -# 178| r0_33(int) = Load : r0_32, m0_23 -# 178| r0_34(glval) = VariableAddress[p] : -# 178| r0_35(int *) = Load : r0_34, m0_3 -# 178| r0_36(glval) = VariableAddress[i] : -# 178| r0_37(int) = Load : r0_36, m0_5 -# 178| r0_38(int *) = PointerAdd[4] : r0_35, r0_37 -# 178| mu0_39(int) = Store : r0_38, r0_33 -# 180| r0_40(glval) = VariableAddress[a] : -# 180| m0_41(int[10]) = Uninitialized : r0_40 -# 181| r0_42(glval) = VariableAddress[a] : -# 181| r0_43(int *) = Convert : r0_42 -# 181| r0_44(glval) = VariableAddress[i] : -# 181| r0_45(int) = Load : r0_44, m0_5 -# 181| r0_46(int *) = PointerAdd[4] : r0_43, r0_45 -# 181| r0_47(int) = Load : r0_46, mu0_1 -# 181| r0_48(glval) = VariableAddress[x] : -# 181| m0_49(int) = Store : r0_48, r0_47 -# 182| r0_50(glval) = VariableAddress[a] : -# 182| r0_51(int *) = Convert : r0_50 -# 182| r0_52(glval) = VariableAddress[i] : -# 182| r0_53(int) = Load : r0_52, m0_5 -# 182| r0_54(int *) = PointerAdd[4] : r0_51, r0_53 -# 182| r0_55(int) = Load : r0_54, mu0_1 -# 182| r0_56(glval) = VariableAddress[x] : -# 182| m0_57(int) = Store : r0_56, r0_55 -# 183| r0_58(glval) = VariableAddress[x] : -# 183| r0_59(int) = Load : r0_58, m0_57 -# 183| r0_60(glval) = VariableAddress[a] : -# 183| r0_61(int *) = Convert : r0_60 -# 183| r0_62(glval) = VariableAddress[i] : -# 183| r0_63(int) = Load : r0_62, m0_5 -# 183| r0_64(int *) = PointerAdd[4] : r0_61, r0_63 -# 183| mu0_65(int) = Store : r0_64, r0_59 -# 184| r0_66(glval) = VariableAddress[x] : -# 184| r0_67(int) = Load : r0_66, m0_57 -# 184| r0_68(glval) = VariableAddress[a] : -# 184| r0_69(int *) = Convert : r0_68 -# 184| r0_70(glval) = VariableAddress[i] : -# 184| r0_71(int) = Load : r0_70, m0_5 -# 184| r0_72(int *) = PointerAdd[4] : r0_69, r0_71 -# 184| mu0_73(int) = Store : r0_72, r0_67 -# 185| v0_74(void) = NoOp : -# 171| v0_75(void) = ReturnVoid : -# 171| v0_76(void) = UnmodeledUse : mu* -# 171| v0_77(void) = ExitFunction : +# 171| mu0_1(unknown) = AliasedDefinition : +# 171| mu0_2(unknown) = UnmodeledDefinition : +# 171| r0_3(glval) = VariableAddress[p] : +# 171| m0_4(int *) = InitializeParameter[p] : r0_3 +# 171| r0_5(glval) = VariableAddress[i] : +# 171| m0_6(int) = InitializeParameter[i] : r0_5 +# 172| r0_7(glval) = VariableAddress[x] : +# 172| m0_8(int) = Uninitialized : r0_7 +# 174| r0_9(glval) = VariableAddress[p] : +# 174| r0_10(int *) = Load : r0_9, m0_4 +# 174| r0_11(glval) = VariableAddress[i] : +# 174| r0_12(int) = Load : r0_11, m0_6 +# 174| r0_13(int *) = PointerAdd[4] : r0_10, r0_12 +# 174| r0_14(int) = Load : r0_13, mu0_2 +# 174| r0_15(glval) = VariableAddress[x] : +# 174| m0_16(int) = Store : r0_15, r0_14 +# 175| r0_17(glval) = VariableAddress[p] : +# 175| r0_18(int *) = Load : r0_17, m0_4 +# 175| r0_19(glval) = VariableAddress[i] : +# 175| r0_20(int) = Load : r0_19, m0_6 +# 175| r0_21(int *) = PointerAdd[4] : r0_18, r0_20 +# 175| r0_22(int) = Load : r0_21, mu0_2 +# 175| r0_23(glval) = VariableAddress[x] : +# 175| m0_24(int) = Store : r0_23, r0_22 +# 177| r0_25(glval) = VariableAddress[x] : +# 177| r0_26(int) = Load : r0_25, m0_24 +# 177| r0_27(glval) = VariableAddress[p] : +# 177| r0_28(int *) = Load : r0_27, m0_4 +# 177| r0_29(glval) = VariableAddress[i] : +# 177| r0_30(int) = Load : r0_29, m0_6 +# 177| r0_31(int *) = 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, m0_24 +# 178| r0_35(glval) = VariableAddress[p] : +# 178| r0_36(int *) = Load : r0_35, m0_4 +# 178| r0_37(glval) = VariableAddress[i] : +# 178| r0_38(int) = Load : r0_37, m0_6 +# 178| r0_39(int *) = PointerAdd[4] : r0_36, r0_38 +# 178| mu0_40(int) = Store : r0_39, r0_34 +# 180| r0_41(glval) = VariableAddress[a] : +# 180| m0_42(int[10]) = Uninitialized : 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, m0_6 +# 181| r0_47(int *) = PointerAdd[4] : r0_44, r0_46 +# 181| r0_48(int) = Load : r0_47, mu0_2 +# 181| r0_49(glval) = VariableAddress[x] : +# 181| m0_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, m0_6 +# 182| r0_55(int *) = PointerAdd[4] : r0_52, r0_54 +# 182| r0_56(int) = Load : r0_55, mu0_2 +# 182| r0_57(glval) = VariableAddress[x] : +# 182| m0_58(int) = Store : r0_57, r0_56 +# 183| r0_59(glval) = VariableAddress[x] : +# 183| r0_60(int) = Load : r0_59, m0_58 +# 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, m0_6 +# 183| r0_65(int *) = 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, m0_58 +# 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, m0_6 +# 184| r0_73(int *) = 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) = ExitFunction : # 187| StringLiteral(int) -> void # 187| Block 0 # 187| v0_0(void) = EnterFunction : -# 187| mu0_1(unknown) = UnmodeledDefinition : -# 187| r0_2(glval) = VariableAddress[i] : -# 187| m0_3(int) = InitializeParameter[i] : r0_2 -# 188| r0_4(glval) = VariableAddress[c] : -# 188| r0_5(glval) = StringConstant["Foo"] : -# 188| r0_6(char *) = Convert : r0_5 -# 188| r0_7(glval) = VariableAddress[i] : -# 188| r0_8(int) = Load : r0_7, m0_3 -# 188| r0_9(char *) = PointerAdd[1] : r0_6, r0_8 -# 188| r0_10(char) = Load : r0_9, mu0_1 -# 188| m0_11(char) = Store : r0_4, r0_10 -# 189| r0_12(glval) = VariableAddress[pwc] : -# 189| r0_13(glval) = StringConstant[L"Bar"] : -# 189| r0_14(wchar_t *) = Convert : r0_13 +# 187| mu0_1(unknown) = AliasedDefinition : +# 187| mu0_2(unknown) = UnmodeledDefinition : +# 187| r0_3(glval) = VariableAddress[i] : +# 187| m0_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, m0_4 +# 188| r0_10(char *) = PointerAdd[1] : r0_7, r0_9 +# 188| r0_11(char) = Load : r0_10, mu0_2 +# 188| m0_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| m0_16(wchar_t *) = Store : r0_12, r0_15 -# 190| r0_17(glval) = VariableAddress[wc] : -# 190| r0_18(glval) = VariableAddress[pwc] : -# 190| r0_19(wchar_t *) = Load : r0_18, m0_16 -# 190| r0_20(glval) = VariableAddress[i] : -# 190| r0_21(int) = Load : r0_20, m0_3 -# 190| r0_22(wchar_t *) = PointerAdd[4] : r0_19, r0_21 -# 190| r0_23(wchar_t) = Load : r0_22, mu0_1 -# 190| m0_24(wchar_t) = Store : r0_17, r0_23 -# 191| v0_25(void) = NoOp : -# 187| v0_26(void) = ReturnVoid : -# 187| v0_27(void) = UnmodeledUse : mu* -# 187| v0_28(void) = ExitFunction : +# 189| r0_16(wchar_t *) = Convert : r0_15 +# 189| m0_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, m0_17 +# 190| r0_21(glval) = VariableAddress[i] : +# 190| r0_22(int) = Load : r0_21, m0_4 +# 190| r0_23(wchar_t *) = PointerAdd[4] : r0_20, r0_22 +# 190| r0_24(wchar_t) = Load : r0_23, mu0_2 +# 190| m0_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) = ExitFunction : # 193| PointerCompare(int *, int *) -> void # 193| Block 0 # 193| v0_0(void) = EnterFunction : -# 193| mu0_1(unknown) = UnmodeledDefinition : -# 193| r0_2(glval) = VariableAddress[p] : -# 193| m0_3(int *) = InitializeParameter[p] : r0_2 -# 193| r0_4(glval) = VariableAddress[q] : -# 193| m0_5(int *) = InitializeParameter[q] : r0_4 -# 194| r0_6(glval) = VariableAddress[b] : -# 194| m0_7(bool) = Uninitialized : r0_6 -# 196| r0_8(glval) = VariableAddress[p] : -# 196| r0_9(int *) = Load : r0_8, m0_3 -# 196| r0_10(glval) = VariableAddress[q] : -# 196| r0_11(int *) = Load : r0_10, m0_5 -# 196| r0_12(bool) = CompareEQ : r0_9, r0_11 -# 196| r0_13(glval) = VariableAddress[b] : -# 196| m0_14(bool) = Store : r0_13, r0_12 -# 197| r0_15(glval) = VariableAddress[p] : -# 197| r0_16(int *) = Load : r0_15, m0_3 -# 197| r0_17(glval) = VariableAddress[q] : -# 197| r0_18(int *) = Load : r0_17, m0_5 -# 197| r0_19(bool) = CompareNE : r0_16, r0_18 -# 197| r0_20(glval) = VariableAddress[b] : -# 197| m0_21(bool) = Store : r0_20, r0_19 -# 198| r0_22(glval) = VariableAddress[p] : -# 198| r0_23(int *) = Load : r0_22, m0_3 -# 198| r0_24(glval) = VariableAddress[q] : -# 198| r0_25(int *) = Load : r0_24, m0_5 -# 198| r0_26(bool) = CompareLT : r0_23, r0_25 -# 198| r0_27(glval) = VariableAddress[b] : -# 198| m0_28(bool) = Store : r0_27, r0_26 -# 199| r0_29(glval) = VariableAddress[p] : -# 199| r0_30(int *) = Load : r0_29, m0_3 -# 199| r0_31(glval) = VariableAddress[q] : -# 199| r0_32(int *) = Load : r0_31, m0_5 -# 199| r0_33(bool) = CompareGT : r0_30, r0_32 -# 199| r0_34(glval) = VariableAddress[b] : -# 199| m0_35(bool) = Store : r0_34, r0_33 -# 200| r0_36(glval) = VariableAddress[p] : -# 200| r0_37(int *) = Load : r0_36, m0_3 -# 200| r0_38(glval) = VariableAddress[q] : -# 200| r0_39(int *) = Load : r0_38, m0_5 -# 200| r0_40(bool) = CompareLE : r0_37, r0_39 -# 200| r0_41(glval) = VariableAddress[b] : -# 200| m0_42(bool) = Store : r0_41, r0_40 -# 201| r0_43(glval) = VariableAddress[p] : -# 201| r0_44(int *) = Load : r0_43, m0_3 -# 201| r0_45(glval) = VariableAddress[q] : -# 201| r0_46(int *) = Load : r0_45, m0_5 -# 201| r0_47(bool) = CompareGE : r0_44, r0_46 -# 201| r0_48(glval) = VariableAddress[b] : -# 201| m0_49(bool) = Store : r0_48, r0_47 -# 202| v0_50(void) = NoOp : -# 193| v0_51(void) = ReturnVoid : -# 193| v0_52(void) = UnmodeledUse : mu* -# 193| v0_53(void) = ExitFunction : +# 193| mu0_1(unknown) = AliasedDefinition : +# 193| mu0_2(unknown) = UnmodeledDefinition : +# 193| r0_3(glval) = VariableAddress[p] : +# 193| m0_4(int *) = InitializeParameter[p] : r0_3 +# 193| r0_5(glval) = VariableAddress[q] : +# 193| m0_6(int *) = InitializeParameter[q] : r0_5 +# 194| r0_7(glval) = VariableAddress[b] : +# 194| m0_8(bool) = Uninitialized : r0_7 +# 196| r0_9(glval) = VariableAddress[p] : +# 196| r0_10(int *) = Load : r0_9, m0_4 +# 196| r0_11(glval) = VariableAddress[q] : +# 196| r0_12(int *) = Load : r0_11, m0_6 +# 196| r0_13(bool) = CompareEQ : r0_10, r0_12 +# 196| r0_14(glval) = VariableAddress[b] : +# 196| m0_15(bool) = Store : r0_14, r0_13 +# 197| r0_16(glval) = VariableAddress[p] : +# 197| r0_17(int *) = Load : r0_16, m0_4 +# 197| r0_18(glval) = VariableAddress[q] : +# 197| r0_19(int *) = Load : r0_18, m0_6 +# 197| r0_20(bool) = CompareNE : r0_17, r0_19 +# 197| r0_21(glval) = VariableAddress[b] : +# 197| m0_22(bool) = Store : r0_21, r0_20 +# 198| r0_23(glval) = VariableAddress[p] : +# 198| r0_24(int *) = Load : r0_23, m0_4 +# 198| r0_25(glval) = VariableAddress[q] : +# 198| r0_26(int *) = Load : r0_25, m0_6 +# 198| r0_27(bool) = CompareLT : r0_24, r0_26 +# 198| r0_28(glval) = VariableAddress[b] : +# 198| m0_29(bool) = Store : r0_28, r0_27 +# 199| r0_30(glval) = VariableAddress[p] : +# 199| r0_31(int *) = Load : r0_30, m0_4 +# 199| r0_32(glval) = VariableAddress[q] : +# 199| r0_33(int *) = Load : r0_32, m0_6 +# 199| r0_34(bool) = CompareGT : r0_31, r0_33 +# 199| r0_35(glval) = VariableAddress[b] : +# 199| m0_36(bool) = Store : r0_35, r0_34 +# 200| r0_37(glval) = VariableAddress[p] : +# 200| r0_38(int *) = Load : r0_37, m0_4 +# 200| r0_39(glval) = VariableAddress[q] : +# 200| r0_40(int *) = Load : r0_39, m0_6 +# 200| r0_41(bool) = CompareLE : r0_38, r0_40 +# 200| r0_42(glval) = VariableAddress[b] : +# 200| m0_43(bool) = Store : r0_42, r0_41 +# 201| r0_44(glval) = VariableAddress[p] : +# 201| r0_45(int *) = Load : r0_44, m0_4 +# 201| r0_46(glval) = VariableAddress[q] : +# 201| r0_47(int *) = Load : r0_46, m0_6 +# 201| r0_48(bool) = CompareGE : r0_45, r0_47 +# 201| r0_49(glval) = VariableAddress[b] : +# 201| m0_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) = ExitFunction : # 204| PointerCrement(int *) -> void # 204| Block 0 # 204| v0_0(void) = EnterFunction : -# 204| mu0_1(unknown) = UnmodeledDefinition : -# 204| r0_2(glval) = VariableAddress[p] : -# 204| m0_3(int *) = InitializeParameter[p] : r0_2 -# 205| r0_4(glval) = VariableAddress[q] : -# 205| m0_5(int *) = Uninitialized : r0_4 -# 207| r0_6(glval) = VariableAddress[p] : -# 207| r0_7(int *) = Load : r0_6, m0_3 -# 207| r0_8(int) = Constant[1] : -# 207| r0_9(int *) = PointerAdd[4] : r0_7, r0_8 -# 207| m0_10(int *) = Store : r0_6, r0_9 -# 207| r0_11(glval) = VariableAddress[q] : -# 207| m0_12(int *) = Store : r0_11, r0_9 -# 208| r0_13(glval) = VariableAddress[p] : -# 208| r0_14(int *) = Load : r0_13, m0_10 -# 208| r0_15(int) = Constant[1] : -# 208| r0_16(int *) = PointerSub[4] : r0_14, r0_15 -# 208| m0_17(int *) = Store : r0_13, r0_16 -# 208| r0_18(glval) = VariableAddress[q] : -# 208| m0_19(int *) = Store : r0_18, r0_16 -# 209| r0_20(glval) = VariableAddress[p] : -# 209| r0_21(int *) = Load : r0_20, m0_17 -# 209| r0_22(int) = Constant[1] : -# 209| r0_23(int *) = PointerAdd[4] : r0_21, r0_22 -# 209| m0_24(int *) = Store : r0_20, r0_23 -# 209| r0_25(glval) = VariableAddress[q] : -# 209| m0_26(int *) = Store : r0_25, r0_21 -# 210| r0_27(glval) = VariableAddress[p] : -# 210| r0_28(int *) = Load : r0_27, m0_24 -# 210| r0_29(int) = Constant[1] : -# 210| r0_30(int *) = PointerSub[4] : r0_28, r0_29 -# 210| m0_31(int *) = Store : r0_27, r0_30 -# 210| r0_32(glval) = VariableAddress[q] : -# 210| m0_33(int *) = Store : r0_32, r0_28 -# 211| v0_34(void) = NoOp : -# 204| v0_35(void) = ReturnVoid : -# 204| v0_36(void) = UnmodeledUse : mu* -# 204| v0_37(void) = ExitFunction : +# 204| mu0_1(unknown) = AliasedDefinition : +# 204| mu0_2(unknown) = UnmodeledDefinition : +# 204| r0_3(glval) = VariableAddress[p] : +# 204| m0_4(int *) = InitializeParameter[p] : r0_3 +# 205| r0_5(glval) = VariableAddress[q] : +# 205| m0_6(int *) = Uninitialized : r0_5 +# 207| r0_7(glval) = VariableAddress[p] : +# 207| r0_8(int *) = Load : r0_7, m0_4 +# 207| r0_9(int) = Constant[1] : +# 207| r0_10(int *) = PointerAdd[4] : r0_8, r0_9 +# 207| m0_11(int *) = Store : r0_7, r0_10 +# 207| r0_12(glval) = VariableAddress[q] : +# 207| m0_13(int *) = Store : r0_12, r0_10 +# 208| r0_14(glval) = VariableAddress[p] : +# 208| r0_15(int *) = Load : r0_14, m0_11 +# 208| r0_16(int) = Constant[1] : +# 208| r0_17(int *) = PointerSub[4] : r0_15, r0_16 +# 208| m0_18(int *) = Store : r0_14, r0_17 +# 208| r0_19(glval) = VariableAddress[q] : +# 208| m0_20(int *) = Store : r0_19, r0_17 +# 209| r0_21(glval) = VariableAddress[p] : +# 209| r0_22(int *) = Load : r0_21, m0_18 +# 209| r0_23(int) = Constant[1] : +# 209| r0_24(int *) = PointerAdd[4] : r0_22, r0_23 +# 209| m0_25(int *) = Store : r0_21, r0_24 +# 209| r0_26(glval) = VariableAddress[q] : +# 209| m0_27(int *) = Store : r0_26, r0_22 +# 210| r0_28(glval) = VariableAddress[p] : +# 210| r0_29(int *) = Load : r0_28, m0_25 +# 210| r0_30(int) = Constant[1] : +# 210| r0_31(int *) = PointerSub[4] : r0_29, r0_30 +# 210| m0_32(int *) = Store : r0_28, r0_31 +# 210| r0_33(glval) = VariableAddress[q] : +# 210| m0_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) = ExitFunction : # 213| CompoundAssignment() -> void # 213| Block 0 # 213| v0_0(void) = EnterFunction : -# 213| mu0_1(unknown) = UnmodeledDefinition : -# 215| r0_2(glval) = VariableAddress[x] : -# 215| r0_3(int) = Constant[5] : -# 215| m0_4(int) = Store : r0_2, r0_3 -# 216| r0_5(int) = Constant[7] : -# 216| r0_6(glval) = VariableAddress[x] : -# 216| r0_7(int) = Load : r0_6, m0_4 -# 216| r0_8(int) = Add : r0_7, r0_5 -# 216| m0_9(int) = Store : r0_6, r0_8 -# 219| r0_10(glval) = VariableAddress[y] : -# 219| r0_11(short) = Constant[5] : -# 219| m0_12(short) = Store : r0_10, r0_11 -# 220| r0_13(glval) = VariableAddress[x] : -# 220| r0_14(int) = Load : r0_13, m0_9 -# 220| r0_15(glval) = VariableAddress[y] : -# 220| r0_16(short) = Load : r0_15, m0_12 -# 220| r0_17(int) = Convert : r0_16 -# 220| r0_18(int) = Add : r0_17, r0_14 -# 220| r0_19(short) = Convert : r0_18 -# 220| m0_20(short) = Store : r0_15, r0_19 -# 223| r0_21(int) = Constant[1] : -# 223| r0_22(glval) = VariableAddress[y] : -# 223| r0_23(short) = Load : r0_22, m0_20 -# 223| r0_24(short) = ShiftLeft : r0_23, r0_21 -# 223| m0_25(short) = Store : r0_22, r0_24 -# 226| r0_26(glval) = VariableAddress[z] : -# 226| r0_27(long) = Constant[7] : -# 226| m0_28(long) = Store : r0_26, r0_27 -# 227| r0_29(float) = Constant[2.0] : -# 227| r0_30(glval) = VariableAddress[z] : -# 227| r0_31(long) = Load : r0_30, m0_28 -# 227| r0_32(float) = Convert : r0_31 -# 227| r0_33(float) = Add : r0_32, r0_29 -# 227| r0_34(long) = Convert : r0_33 -# 227| m0_35(long) = Store : r0_30, r0_34 -# 228| v0_36(void) = NoOp : -# 213| v0_37(void) = ReturnVoid : -# 213| v0_38(void) = UnmodeledUse : mu* -# 213| v0_39(void) = ExitFunction : +# 213| mu0_1(unknown) = AliasedDefinition : +# 213| mu0_2(unknown) = UnmodeledDefinition : +# 215| r0_3(glval) = VariableAddress[x] : +# 215| r0_4(int) = Constant[5] : +# 215| m0_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, m0_5 +# 216| r0_9(int) = Add : r0_8, r0_6 +# 216| m0_10(int) = Store : r0_7, r0_9 +# 219| r0_11(glval) = VariableAddress[y] : +# 219| r0_12(short) = Constant[5] : +# 219| m0_13(short) = Store : r0_11, r0_12 +# 220| r0_14(glval) = VariableAddress[x] : +# 220| r0_15(int) = Load : r0_14, m0_10 +# 220| r0_16(glval) = VariableAddress[y] : +# 220| r0_17(short) = Load : r0_16, m0_13 +# 220| r0_18(int) = Convert : r0_17 +# 220| r0_19(int) = Add : r0_18, r0_15 +# 220| r0_20(short) = Convert : r0_19 +# 220| m0_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, m0_21 +# 223| r0_25(short) = ShiftLeft : r0_24, r0_22 +# 223| m0_26(short) = Store : r0_23, r0_25 +# 226| r0_27(glval) = VariableAddress[z] : +# 226| r0_28(long) = Constant[7] : +# 226| m0_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, m0_29 +# 227| r0_33(float) = Convert : r0_32 +# 227| r0_34(float) = Add : r0_33, r0_30 +# 227| r0_35(long) = Convert : r0_34 +# 227| m0_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) = ExitFunction : # 230| UninitializedVariables() -> void # 230| Block 0 # 230| v0_0(void) = EnterFunction : -# 230| mu0_1(unknown) = UnmodeledDefinition : -# 231| r0_2(glval) = VariableAddress[x] : -# 231| m0_3(int) = Uninitialized : r0_2 -# 232| r0_4(glval) = VariableAddress[y] : -# 232| r0_5(glval) = VariableAddress[x] : -# 232| r0_6(int) = Load : r0_5, m0_3 -# 232| m0_7(int) = Store : r0_4, r0_6 -# 233| v0_8(void) = NoOp : -# 230| v0_9(void) = ReturnVoid : -# 230| v0_10(void) = UnmodeledUse : mu* -# 230| v0_11(void) = ExitFunction : +# 230| mu0_1(unknown) = AliasedDefinition : +# 230| mu0_2(unknown) = UnmodeledDefinition : +# 231| r0_3(glval) = VariableAddress[x] : +# 231| m0_4(int) = Uninitialized : r0_3 +# 232| r0_5(glval) = VariableAddress[y] : +# 232| r0_6(glval) = VariableAddress[x] : +# 232| r0_7(int) = Load : r0_6, m0_4 +# 232| m0_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) = ExitFunction : # 235| Parameters(int, int) -> int # 235| Block 0 # 235| v0_0(void) = EnterFunction : -# 235| mu0_1(unknown) = UnmodeledDefinition : -# 235| r0_2(glval) = VariableAddress[x] : -# 235| m0_3(int) = InitializeParameter[x] : r0_2 -# 235| r0_4(glval) = VariableAddress[y] : -# 235| m0_5(int) = InitializeParameter[y] : r0_4 -# 236| r0_6(glval) = VariableAddress[#return] : -# 236| r0_7(glval) = VariableAddress[x] : -# 236| r0_8(int) = Load : r0_7, m0_3 -# 236| r0_9(glval) = VariableAddress[y] : -# 236| r0_10(int) = Load : r0_9, m0_5 -# 236| r0_11(int) = Rem : r0_8, r0_10 -# 236| m0_12(int) = Store : r0_6, r0_11 -# 235| r0_13(glval) = VariableAddress[#return] : -# 235| v0_14(void) = ReturnValue : r0_13, m0_12 -# 235| v0_15(void) = UnmodeledUse : mu* -# 235| v0_16(void) = ExitFunction : +# 235| mu0_1(unknown) = AliasedDefinition : +# 235| mu0_2(unknown) = UnmodeledDefinition : +# 235| r0_3(glval) = VariableAddress[x] : +# 235| m0_4(int) = InitializeParameter[x] : r0_3 +# 235| r0_5(glval) = VariableAddress[y] : +# 235| m0_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, m0_4 +# 236| r0_10(glval) = VariableAddress[y] : +# 236| r0_11(int) = Load : r0_10, m0_6 +# 236| r0_12(int) = Rem : r0_9, r0_11 +# 236| m0_13(int) = Store : r0_7, r0_12 +# 235| r0_14(glval) = VariableAddress[#return] : +# 235| v0_15(void) = ReturnValue : r0_14, m0_13 +# 235| v0_16(void) = UnmodeledUse : mu* +# 235| v0_17(void) = ExitFunction : # 239| IfStatements(bool, int, int) -> void # 239| Block 0 # 239| v0_0(void) = EnterFunction : -# 239| mu0_1(unknown) = UnmodeledDefinition : -# 239| r0_2(glval) = VariableAddress[b] : -# 239| m0_3(bool) = InitializeParameter[b] : r0_2 -# 239| r0_4(glval) = VariableAddress[x] : -# 239| m0_5(int) = InitializeParameter[x] : r0_4 -# 239| r0_6(glval) = VariableAddress[y] : -# 239| m0_7(int) = InitializeParameter[y] : r0_6 -# 240| r0_8(glval) = VariableAddress[b] : -# 240| r0_9(bool) = Load : r0_8, m0_3 -# 240| v0_10(void) = ConditionalBranch : r0_9 +# 239| mu0_1(unknown) = AliasedDefinition : +# 239| mu0_2(unknown) = UnmodeledDefinition : +# 239| r0_3(glval) = VariableAddress[b] : +# 239| m0_4(bool) = InitializeParameter[b] : r0_3 +# 239| r0_5(glval) = VariableAddress[x] : +# 239| m0_6(int) = InitializeParameter[x] : r0_5 +# 239| r0_7(glval) = VariableAddress[y] : +# 239| m0_8(int) = InitializeParameter[y] : r0_7 +# 240| r0_9(glval) = VariableAddress[b] : +# 240| r0_10(bool) = Load : r0_9, m0_4 +# 240| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 7 # 243| Block 1 # 243| r1_0(glval) = VariableAddress[b] : -# 243| r1_1(bool) = Load : r1_0, m0_3 +# 243| r1_1(bool) = Load : r1_0, m0_4 # 243| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 # 244| Block 2 # 244| r2_0(glval) = VariableAddress[y] : -# 244| r2_1(int) = Load : r2_0, m0_7 +# 244| r2_1(int) = Load : r2_0, m0_8 # 244| r2_2(glval) = VariableAddress[x] : # 244| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 # 247| Block 3 -# 247| m3_0(int) = Phi : from 1:m0_5, from 2:m2_3 +# 247| m3_0(int) = Phi : from 1:m0_6, from 2:m2_3 # 247| r3_1(glval) = VariableAddress[x] : # 247| r3_2(int) = Load : r3_1, m3_0 # 247| r3_3(int) = Constant[7] : @@ -1075,9 +1097,10 @@ ir.cpp: # 253| WhileStatements(int) -> void # 253| Block 0 # 253| v0_0(void) = EnterFunction : -# 253| mu0_1(unknown) = UnmodeledDefinition : -# 253| r0_2(glval) = VariableAddress[n] : -# 253| m0_3(int) = InitializeParameter[n] : r0_2 +# 253| mu0_1(unknown) = AliasedDefinition : +# 253| mu0_2(unknown) = UnmodeledDefinition : +# 253| r0_3(glval) = VariableAddress[n] : +# 253| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 3 # 255| Block 1 @@ -1095,7 +1118,7 @@ ir.cpp: # 253| v2_3(void) = ExitFunction : # 254| Block 3 -# 254| m3_0(int) = Phi : from 0:m0_3, from 1:m1_4 +# 254| m3_0(int) = Phi : from 0:m0_4, from 1:m1_4 # 254| r3_1(glval) = VariableAddress[n] : # 254| r3_2(int) = Load : r3_1, m3_0 # 254| r3_3(int) = Constant[0] : @@ -1107,13 +1130,14 @@ ir.cpp: # 259| DoStatements(int) -> void # 259| Block 0 # 259| v0_0(void) = EnterFunction : -# 259| mu0_1(unknown) = UnmodeledDefinition : -# 259| r0_2(glval) = VariableAddress[n] : -# 259| m0_3(int) = InitializeParameter[n] : r0_2 +# 259| mu0_1(unknown) = AliasedDefinition : +# 259| mu0_2(unknown) = UnmodeledDefinition : +# 259| r0_3(glval) = VariableAddress[n] : +# 259| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 1 # 261| Block 1 -# 261| m1_0(int) = Phi : from 0:m0_3, from 1:m1_5 +# 261| m1_0(int) = Phi : from 0:m0_4, from 1:m1_5 # 261| r1_1(int) = Constant[1] : # 261| r1_2(glval) = VariableAddress[n] : # 261| r1_3(int) = Load : r1_2, m1_0 @@ -1136,9 +1160,10 @@ ir.cpp: # 265| For_Empty() -> void # 265| Block 0 # 265| v0_0(void) = EnterFunction : -# 265| mu0_1(unknown) = UnmodeledDefinition : -# 266| r0_2(glval) = VariableAddress[j] : -# 266| m0_3(int) = Uninitialized : r0_2 +# 265| mu0_1(unknown) = AliasedDefinition : +# 265| mu0_2(unknown) = UnmodeledDefinition : +# 266| r0_3(glval) = VariableAddress[j] : +# 266| m0_4(int) = Uninitialized : r0_3 #-----| Goto -> Block 2 # 265| Block 1 @@ -1153,10 +1178,11 @@ ir.cpp: # 272| For_Init() -> void # 272| Block 0 # 272| v0_0(void) = EnterFunction : -# 272| mu0_1(unknown) = UnmodeledDefinition : -# 273| r0_2(glval) = VariableAddress[i] : -# 273| r0_3(int) = Constant[0] : -# 273| m0_4(int) = Store : r0_2, r0_3 +# 272| mu0_1(unknown) = AliasedDefinition : +# 272| mu0_2(unknown) = UnmodeledDefinition : +# 273| r0_3(glval) = VariableAddress[i] : +# 273| r0_4(int) = Constant[0] : +# 273| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 272| Block 1 @@ -1171,15 +1197,16 @@ ir.cpp: # 278| For_Condition() -> void # 278| Block 0 # 278| v0_0(void) = EnterFunction : -# 278| mu0_1(unknown) = UnmodeledDefinition : -# 279| r0_2(glval) = VariableAddress[i] : -# 279| r0_3(int) = Constant[0] : -# 279| m0_4(int) = Store : r0_2, r0_3 +# 278| mu0_1(unknown) = AliasedDefinition : +# 278| mu0_2(unknown) = UnmodeledDefinition : +# 279| r0_3(glval) = VariableAddress[i] : +# 279| r0_4(int) = Constant[0] : +# 279| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 280| Block 1 # 280| r1_0(glval) = VariableAddress[i] : -# 280| r1_1(int) = Load : r1_0, m0_4 +# 280| r1_1(int) = Load : r1_0, m0_5 # 280| r1_2(int) = Constant[10] : # 280| r1_3(bool) = CompareLT : r1_1, r1_2 # 280| v1_4(void) = ConditionalBranch : r1_3 @@ -1199,10 +1226,11 @@ ir.cpp: # 285| For_Update() -> void # 285| Block 0 # 285| v0_0(void) = EnterFunction : -# 285| mu0_1(unknown) = UnmodeledDefinition : -# 286| r0_2(glval) = VariableAddress[i] : -# 286| r0_3(int) = Constant[0] : -# 286| m0_4(int) = Store : r0_2, r0_3 +# 285| mu0_1(unknown) = AliasedDefinition : +# 285| mu0_2(unknown) = UnmodeledDefinition : +# 286| r0_3(glval) = VariableAddress[i] : +# 286| r0_4(int) = Constant[0] : +# 286| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 285| Block 1 @@ -1211,7 +1239,7 @@ ir.cpp: # 285| v1_2(void) = ExitFunction : # 288| Block 2 -# 288| m2_0(int) = Phi : from 0:m0_4, from 2:m2_6 +# 288| m2_0(int) = Phi : from 0:m0_5, from 2:m2_6 # 288| v2_1(void) = NoOp : # 287| r2_2(int) = Constant[1] : # 287| r2_3(glval) = VariableAddress[i] : @@ -1223,15 +1251,16 @@ ir.cpp: # 292| For_InitCondition() -> void # 292| Block 0 # 292| v0_0(void) = EnterFunction : -# 292| mu0_1(unknown) = UnmodeledDefinition : -# 293| r0_2(glval) = VariableAddress[i] : -# 293| r0_3(int) = Constant[0] : -# 293| m0_4(int) = Store : r0_2, r0_3 +# 292| mu0_1(unknown) = AliasedDefinition : +# 292| mu0_2(unknown) = UnmodeledDefinition : +# 293| r0_3(glval) = VariableAddress[i] : +# 293| r0_4(int) = Constant[0] : +# 293| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 293| Block 1 # 293| r1_0(glval) = VariableAddress[i] : -# 293| r1_1(int) = Load : r1_0, m0_4 +# 293| r1_1(int) = Load : r1_0, m0_5 # 293| r1_2(int) = Constant[10] : # 293| r1_3(bool) = CompareLT : r1_1, r1_2 # 293| v1_4(void) = ConditionalBranch : r1_3 @@ -1251,10 +1280,11 @@ ir.cpp: # 298| For_InitUpdate() -> void # 298| Block 0 # 298| v0_0(void) = EnterFunction : -# 298| mu0_1(unknown) = UnmodeledDefinition : -# 299| r0_2(glval) = VariableAddress[i] : -# 299| r0_3(int) = Constant[0] : -# 299| m0_4(int) = Store : r0_2, r0_3 +# 298| mu0_1(unknown) = AliasedDefinition : +# 298| mu0_2(unknown) = UnmodeledDefinition : +# 299| r0_3(glval) = VariableAddress[i] : +# 299| r0_4(int) = Constant[0] : +# 299| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 2 # 298| Block 1 @@ -1263,7 +1293,7 @@ ir.cpp: # 298| v1_2(void) = ExitFunction : # 300| Block 2 -# 300| m2_0(int) = Phi : from 0:m0_4, from 2:m2_6 +# 300| m2_0(int) = Phi : from 0:m0_5, from 2:m2_6 # 300| v2_1(void) = NoOp : # 299| r2_2(int) = Constant[1] : # 299| r2_3(glval) = VariableAddress[i] : @@ -1275,14 +1305,15 @@ ir.cpp: # 304| For_ConditionUpdate() -> void # 304| Block 0 # 304| v0_0(void) = EnterFunction : -# 304| mu0_1(unknown) = UnmodeledDefinition : -# 305| r0_2(glval) = VariableAddress[i] : -# 305| r0_3(int) = Constant[0] : -# 305| m0_4(int) = Store : r0_2, r0_3 +# 304| mu0_1(unknown) = AliasedDefinition : +# 304| mu0_2(unknown) = UnmodeledDefinition : +# 305| r0_3(glval) = VariableAddress[i] : +# 305| r0_4(int) = Constant[0] : +# 305| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 306| Block 1 -# 306| m1_0(int) = Phi : from 0:m0_4, from 2:m2_5 +# 306| m1_0(int) = Phi : from 0:m0_5, from 2:m2_5 # 306| r1_1(glval) = VariableAddress[i] : # 306| r1_2(int) = Load : r1_1, m1_0 # 306| r1_3(int) = Constant[10] : @@ -1309,14 +1340,15 @@ ir.cpp: # 311| For_InitConditionUpdate() -> void # 311| Block 0 # 311| v0_0(void) = EnterFunction : -# 311| mu0_1(unknown) = UnmodeledDefinition : -# 312| r0_2(glval) = VariableAddress[i] : -# 312| r0_3(int) = Constant[0] : -# 312| m0_4(int) = Store : r0_2, r0_3 +# 311| mu0_1(unknown) = AliasedDefinition : +# 311| mu0_2(unknown) = UnmodeledDefinition : +# 312| r0_3(glval) = VariableAddress[i] : +# 312| r0_4(int) = Constant[0] : +# 312| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 312| Block 1 -# 312| m1_0(int) = Phi : from 0:m0_4, from 2:m2_5 +# 312| m1_0(int) = Phi : from 0:m0_5, from 2:m2_5 # 312| r1_1(glval) = VariableAddress[i] : # 312| r1_2(int) = Load : r1_1, m1_0 # 312| r1_3(int) = Constant[10] : @@ -1343,14 +1375,15 @@ ir.cpp: # 317| For_Break() -> void # 317| Block 0 # 317| v0_0(void) = EnterFunction : -# 317| mu0_1(unknown) = UnmodeledDefinition : -# 318| r0_2(glval) = VariableAddress[i] : -# 318| r0_3(int) = Constant[0] : -# 318| m0_4(int) = Store : r0_2, r0_3 +# 317| mu0_1(unknown) = AliasedDefinition : +# 317| mu0_2(unknown) = UnmodeledDefinition : +# 318| r0_3(glval) = VariableAddress[i] : +# 318| r0_4(int) = Constant[0] : +# 318| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 318| Block 1 -# 318| m1_0(int) = Phi : from 0:m0_4, from 2:m2_4 +# 318| m1_0(int) = Phi : from 0:m0_5, from 2:m2_4 # 318| r1_1(glval) = VariableAddress[i] : # 318| r1_2(int) = Load : r1_1, m1_0 # 318| r1_3(int) = Constant[10] : @@ -1390,14 +1423,15 @@ ir.cpp: # 325| For_Continue_Update() -> void # 325| Block 0 # 325| v0_0(void) = EnterFunction : -# 325| mu0_1(unknown) = UnmodeledDefinition : -# 326| r0_2(glval) = VariableAddress[i] : -# 326| r0_3(int) = Constant[0] : -# 326| m0_4(int) = Store : r0_2, r0_3 +# 325| mu0_1(unknown) = AliasedDefinition : +# 325| mu0_2(unknown) = UnmodeledDefinition : +# 326| r0_3(glval) = VariableAddress[i] : +# 326| r0_4(int) = Constant[0] : +# 326| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 326| Block 1 -# 326| m1_0(int) = Phi : from 0:m0_4, from 4:m4_5 +# 326| m1_0(int) = Phi : from 0:m0_5, from 4:m4_5 # 326| r1_1(glval) = VariableAddress[i] : # 326| r1_2(int) = Load : r1_1, m1_0 # 326| r1_3(int) = Constant[10] : @@ -1437,15 +1471,16 @@ ir.cpp: # 333| For_Continue_NoUpdate() -> void # 333| Block 0 # 333| v0_0(void) = EnterFunction : -# 333| mu0_1(unknown) = UnmodeledDefinition : -# 334| r0_2(glval) = VariableAddress[i] : -# 334| r0_3(int) = Constant[0] : -# 334| m0_4(int) = Store : r0_2, r0_3 +# 333| mu0_1(unknown) = AliasedDefinition : +# 333| mu0_2(unknown) = UnmodeledDefinition : +# 334| r0_3(glval) = VariableAddress[i] : +# 334| r0_4(int) = Constant[0] : +# 334| m0_5(int) = Store : r0_3, r0_4 #-----| Goto -> Block 1 # 334| Block 1 # 334| r1_0(glval) = VariableAddress[i] : -# 334| r1_1(int) = Load : r1_0, m0_4 +# 334| r1_1(int) = Load : r1_0, m0_5 # 334| r1_2(int) = Constant[10] : # 334| r1_3(bool) = CompareLT : r1_1, r1_2 # 334| v1_4(void) = ConditionalBranch : r1_3 @@ -1454,7 +1489,7 @@ ir.cpp: # 335| Block 2 # 335| r2_0(glval) = VariableAddress[i] : -# 335| r2_1(int) = Load : r2_0, m0_4 +# 335| r2_1(int) = Load : r2_0, m0_5 # 335| r2_2(int) = Constant[5] : # 335| r2_3(bool) = CompareEQ : r2_1, r2_2 # 335| v2_4(void) = ConditionalBranch : r2_3 @@ -1477,42 +1512,45 @@ ir.cpp: # 341| Dereference(int *) -> int # 341| Block 0 -# 341| v0_0(void) = EnterFunction : -# 341| mu0_1(unknown) = UnmodeledDefinition : -# 341| r0_2(glval) = VariableAddress[p] : -# 341| m0_3(int *) = InitializeParameter[p] : r0_2 -# 342| r0_4(int) = Constant[1] : -# 342| r0_5(glval) = VariableAddress[p] : -# 342| r0_6(int *) = Load : r0_5, m0_3 -# 342| mu0_7(int) = Store : r0_6, r0_4 -# 343| r0_8(glval) = VariableAddress[#return] : -# 343| r0_9(glval) = VariableAddress[p] : -# 343| r0_10(int *) = Load : r0_9, m0_3 -# 343| r0_11(int) = Load : r0_10, mu0_1 -# 343| m0_12(int) = Store : r0_8, r0_11 -# 341| r0_13(glval) = VariableAddress[#return] : -# 341| v0_14(void) = ReturnValue : r0_13, m0_12 -# 341| v0_15(void) = UnmodeledUse : mu* -# 341| v0_16(void) = ExitFunction : +# 341| v0_0(void) = EnterFunction : +# 341| mu0_1(unknown) = AliasedDefinition : +# 341| mu0_2(unknown) = UnmodeledDefinition : +# 341| r0_3(glval) = VariableAddress[p] : +# 341| m0_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, m0_4 +# 342| mu0_8(int) = Store : r0_7, r0_5 +# 343| r0_9(glval) = VariableAddress[#return] : +# 343| r0_10(glval) = VariableAddress[p] : +# 343| r0_11(int *) = Load : r0_10, m0_4 +# 343| r0_12(int) = Load : r0_11, mu0_2 +# 343| m0_13(int) = Store : r0_9, r0_12 +# 341| r0_14(glval) = VariableAddress[#return] : +# 341| v0_15(void) = ReturnValue : r0_14, m0_13 +# 341| v0_16(void) = UnmodeledUse : mu* +# 341| v0_17(void) = ExitFunction : # 348| AddressOf() -> int * # 348| Block 0 # 348| v0_0(void) = EnterFunction : -# 348| mu0_1(unknown) = UnmodeledDefinition : -# 349| r0_2(glval) = VariableAddress[#return] : -# 349| r0_3(glval) = VariableAddress[g] : -# 349| m0_4(int *) = Store : r0_2, r0_3 -# 348| r0_5(glval) = VariableAddress[#return] : -# 348| v0_6(void) = ReturnValue : r0_5, m0_4 -# 348| v0_7(void) = UnmodeledUse : mu* -# 348| v0_8(void) = ExitFunction : +# 348| mu0_1(unknown) = AliasedDefinition : +# 348| mu0_2(unknown) = UnmodeledDefinition : +# 349| r0_3(glval) = VariableAddress[#return] : +# 349| r0_4(glval) = VariableAddress[g] : +# 349| m0_5(int *) = Store : r0_3, r0_4 +# 348| r0_6(glval) = VariableAddress[#return] : +# 348| v0_7(void) = ReturnValue : r0_6, m0_5 +# 348| v0_8(void) = UnmodeledUse : mu* +# 348| v0_9(void) = ExitFunction : # 352| Break(int) -> void # 352| Block 0 # 352| v0_0(void) = EnterFunction : -# 352| mu0_1(unknown) = UnmodeledDefinition : -# 352| r0_2(glval) = VariableAddress[n] : -# 352| m0_3(int) = InitializeParameter[n] : r0_2 +# 352| mu0_1(unknown) = AliasedDefinition : +# 352| mu0_2(unknown) = UnmodeledDefinition : +# 352| r0_3(glval) = VariableAddress[n] : +# 352| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 5 # 354| Block 1 @@ -1544,7 +1582,7 @@ ir.cpp: # 352| v4_4(void) = ExitFunction : # 353| Block 5 -# 353| m5_0(int) = Phi : from 0:m0_3, from 3:m3_4 +# 353| m5_0(int) = Phi : from 0:m0_4, from 3:m3_4 # 353| r5_1(glval) = VariableAddress[n] : # 353| r5_2(int) = Load : r5_1, m5_0 # 353| r5_3(int) = Constant[0] : @@ -1556,13 +1594,14 @@ ir.cpp: # 360| Continue(int) -> void # 360| Block 0 # 360| v0_0(void) = EnterFunction : -# 360| mu0_1(unknown) = UnmodeledDefinition : -# 360| r0_2(glval) = VariableAddress[n] : -# 360| m0_3(int) = InitializeParameter[n] : r0_2 +# 360| mu0_1(unknown) = AliasedDefinition : +# 360| mu0_2(unknown) = UnmodeledDefinition : +# 360| r0_3(glval) = VariableAddress[n] : +# 360| m0_4(int) = InitializeParameter[n] : r0_3 #-----| Goto -> Block 1 # 362| Block 1 -# 362| m1_0(int) = Phi : from 0:m0_3, from 4:m4_0 +# 362| m1_0(int) = Phi : from 0:m0_4, from 4:m4_0 # 362| r1_1(glval) = VariableAddress[n] : # 362| r1_2(int) = Load : r1_1, m1_0 # 362| r1_3(int) = Constant[1] : @@ -1603,69 +1642,77 @@ ir.cpp: # 372| Call() -> void # 372| Block 0 # 372| v0_0(void) = EnterFunction : -# 372| mu0_1(unknown) = UnmodeledDefinition : -# 373| r0_2(glval) = FunctionAddress[VoidFunc] : -# 373| v0_3(void) = Call : r0_2 -# 374| v0_4(void) = NoOp : -# 372| v0_5(void) = ReturnVoid : -# 372| v0_6(void) = UnmodeledUse : mu* -# 372| v0_7(void) = ExitFunction : +# 372| mu0_1(unknown) = AliasedDefinition : +# 372| mu0_2(unknown) = UnmodeledDefinition : +# 373| r0_3(glval) = FunctionAddress[VoidFunc] : +# 373| v0_4(void) = Call : 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) = ExitFunction : # 376| CallAdd(int, int) -> int # 376| Block 0 # 376| v0_0(void) = EnterFunction : -# 376| mu0_1(unknown) = UnmodeledDefinition : -# 376| r0_2(glval) = VariableAddress[x] : -# 376| m0_3(int) = InitializeParameter[x] : r0_2 -# 376| r0_4(glval) = VariableAddress[y] : -# 376| m0_5(int) = InitializeParameter[y] : r0_4 -# 377| r0_6(glval) = VariableAddress[#return] : -# 377| r0_7(glval) = FunctionAddress[Add] : -# 377| r0_8(glval) = VariableAddress[x] : -# 377| r0_9(int) = Load : r0_8, m0_3 -# 377| r0_10(glval) = VariableAddress[y] : -# 377| r0_11(int) = Load : r0_10, m0_5 -# 377| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 377| m0_13(int) = Store : r0_6, r0_12 -# 376| r0_14(glval) = VariableAddress[#return] : -# 376| v0_15(void) = ReturnValue : r0_14, m0_13 -# 376| v0_16(void) = UnmodeledUse : mu* -# 376| v0_17(void) = ExitFunction : +# 376| mu0_1(unknown) = AliasedDefinition : +# 376| mu0_2(unknown) = UnmodeledDefinition : +# 376| r0_3(glval) = VariableAddress[x] : +# 376| m0_4(int) = InitializeParameter[x] : r0_3 +# 376| r0_5(glval) = VariableAddress[y] : +# 376| m0_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, m0_4 +# 377| r0_11(glval) = VariableAddress[y] : +# 377| r0_12(int) = Load : r0_11, m0_6 +# 377| r0_13(int) = Call : r0_8, r0_10, r0_12 +# 377| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 377| m0_15(int) = Store : r0_7, r0_13 +# 376| r0_16(glval) = VariableAddress[#return] : +# 376| v0_17(void) = ReturnValue : r0_16, m0_15 +# 376| v0_18(void) = UnmodeledUse : mu* +# 376| v0_19(void) = ExitFunction : # 380| Comma(int, int) -> int # 380| Block 0 -# 380| v0_0(void) = EnterFunction : -# 380| mu0_1(unknown) = UnmodeledDefinition : -# 380| r0_2(glval) = VariableAddress[x] : -# 380| m0_3(int) = InitializeParameter[x] : r0_2 -# 380| r0_4(glval) = VariableAddress[y] : -# 380| m0_5(int) = InitializeParameter[y] : r0_4 -# 381| r0_6(glval) = VariableAddress[#return] : -# 381| r0_7(glval) = FunctionAddress[VoidFunc] : -# 381| v0_8(void) = Call : r0_7 -# 381| r0_9(glval) = FunctionAddress[CallAdd] : -# 381| r0_10(glval) = VariableAddress[x] : -# 381| r0_11(int) = Load : r0_10, m0_3 -# 381| r0_12(glval) = VariableAddress[y] : -# 381| r0_13(int) = Load : r0_12, m0_5 -# 381| r0_14(int) = Call : r0_9, r0_11, r0_13 -# 381| m0_15(int) = Store : r0_6, r0_14 -# 380| r0_16(glval) = VariableAddress[#return] : -# 380| v0_17(void) = ReturnValue : r0_16, m0_15 -# 380| v0_18(void) = UnmodeledUse : mu* -# 380| v0_19(void) = ExitFunction : +# 380| v0_0(void) = EnterFunction : +# 380| mu0_1(unknown) = AliasedDefinition : +# 380| mu0_2(unknown) = UnmodeledDefinition : +# 380| r0_3(glval) = VariableAddress[x] : +# 380| m0_4(int) = InitializeParameter[x] : r0_3 +# 380| r0_5(glval) = VariableAddress[y] : +# 380| m0_6(int) = InitializeParameter[y] : r0_5 +# 381| r0_7(glval) = VariableAddress[#return] : +# 381| r0_8(glval) = FunctionAddress[VoidFunc] : +# 381| v0_9(void) = Call : 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, m0_4 +# 381| r0_14(glval) = VariableAddress[y] : +# 381| r0_15(int) = Load : r0_14, m0_6 +# 381| r0_16(int) = Call : r0_11, r0_13, r0_15 +# 381| mu0_17(unknown) = ^CallSideEffect : mu0_2 +# 381| m0_18(int) = Store : r0_7, r0_16 +# 380| r0_19(glval) = VariableAddress[#return] : +# 380| v0_20(void) = ReturnValue : r0_19, m0_18 +# 380| v0_21(void) = UnmodeledUse : mu* +# 380| v0_22(void) = ExitFunction : # 384| Switch(int) -> void # 384| Block 0 # 384| v0_0(void) = EnterFunction : -# 384| mu0_1(unknown) = UnmodeledDefinition : -# 384| r0_2(glval) = VariableAddress[x] : -# 384| m0_3(int) = InitializeParameter[x] : r0_2 -# 385| r0_4(glval) = VariableAddress[y] : -# 385| m0_5(int) = Uninitialized : r0_4 -# 386| r0_6(glval) = VariableAddress[x] : -# 386| r0_7(int) = Load : r0_6, m0_3 -# 386| v0_8(void) = Switch : r0_7 +# 384| mu0_1(unknown) = AliasedDefinition : +# 384| mu0_2(unknown) = UnmodeledDefinition : +# 384| r0_3(glval) = VariableAddress[x] : +# 384| m0_4(int) = InitializeParameter[x] : r0_3 +# 385| r0_5(glval) = VariableAddress[y] : +# 385| m0_6(int) = Uninitialized : r0_5 +# 386| r0_7(glval) = VariableAddress[x] : +# 386| r0_8(int) = Load : r0_7, m0_4 +# 386| v0_9(void) = Switch : r0_8 #-----| Case[-1] -> Block 2 #-----| Case[1] -> Block 3 #-----| Case[2] -> Block 4 @@ -1738,62 +1785,65 @@ ir.cpp: # 422| ReturnStruct(Point) -> Point # 422| Block 0 # 422| v0_0(void) = EnterFunction : -# 422| mu0_1(unknown) = UnmodeledDefinition : -# 422| r0_2(glval) = VariableAddress[pt] : -# 422| m0_3(Point) = InitializeParameter[pt] : r0_2 -# 423| r0_4(glval) = VariableAddress[#return] : -# 423| r0_5(glval) = VariableAddress[pt] : -# 423| r0_6(Point) = Load : r0_5, m0_3 -# 423| m0_7(Point) = Store : r0_4, r0_6 -# 422| r0_8(glval) = VariableAddress[#return] : -# 422| v0_9(void) = ReturnValue : r0_8, m0_7 -# 422| v0_10(void) = UnmodeledUse : mu* -# 422| v0_11(void) = ExitFunction : +# 422| mu0_1(unknown) = AliasedDefinition : +# 422| mu0_2(unknown) = UnmodeledDefinition : +# 422| r0_3(glval) = VariableAddress[pt] : +# 422| m0_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, m0_4 +# 423| m0_8(Point) = Store : r0_5, r0_7 +# 422| r0_9(glval) = VariableAddress[#return] : +# 422| v0_10(void) = ReturnValue : r0_9, m0_8 +# 422| v0_11(void) = UnmodeledUse : mu* +# 422| v0_12(void) = ExitFunction : # 426| FieldAccess() -> void # 426| Block 0 # 426| v0_0(void) = EnterFunction : -# 426| mu0_1(unknown) = UnmodeledDefinition : -# 427| r0_2(glval) = VariableAddress[pt] : -# 427| mu0_3(Point) = Uninitialized : r0_2 -# 428| r0_4(int) = Constant[5] : -# 428| r0_5(glval) = VariableAddress[pt] : -# 428| r0_6(glval) = FieldAddress[x] : r0_5 -# 428| mu0_7(int) = Store : r0_6, r0_4 -# 429| r0_8(glval) = VariableAddress[pt] : -# 429| r0_9(glval) = FieldAddress[x] : r0_8 -# 429| r0_10(int) = Load : r0_9, mu0_1 -# 429| r0_11(glval) = VariableAddress[pt] : -# 429| r0_12(glval) = FieldAddress[y] : r0_11 -# 429| mu0_13(int) = Store : r0_12, r0_10 -# 430| r0_14(glval) = VariableAddress[p] : -# 430| r0_15(glval) = VariableAddress[pt] : -# 430| r0_16(glval) = FieldAddress[y] : r0_15 -# 430| m0_17(int *) = Store : r0_14, r0_16 -# 431| v0_18(void) = NoOp : -# 426| v0_19(void) = ReturnVoid : -# 426| v0_20(void) = UnmodeledUse : mu* -# 426| v0_21(void) = ExitFunction : +# 426| mu0_1(unknown) = AliasedDefinition : +# 426| mu0_2(unknown) = UnmodeledDefinition : +# 427| r0_3(glval) = VariableAddress[pt] : +# 427| mu0_4(Point) = Uninitialized : 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| m0_18(int *) = Store : r0_15, r0_17 +# 431| v0_19(void) = NoOp : +# 426| v0_20(void) = ReturnVoid : +# 426| v0_21(void) = UnmodeledUse : mu* +# 426| v0_22(void) = ExitFunction : # 433| LogicalOr(bool, bool) -> void # 433| Block 0 # 433| v0_0(void) = EnterFunction : -# 433| mu0_1(unknown) = UnmodeledDefinition : -# 433| r0_2(glval) = VariableAddress[a] : -# 433| m0_3(bool) = InitializeParameter[a] : r0_2 -# 433| r0_4(glval) = VariableAddress[b] : -# 433| m0_5(bool) = InitializeParameter[b] : r0_4 -# 434| r0_6(glval) = VariableAddress[x] : -# 434| m0_7(int) = Uninitialized : r0_6 -# 435| r0_8(glval) = VariableAddress[a] : -# 435| r0_9(bool) = Load : r0_8, m0_3 -# 435| v0_10(void) = ConditionalBranch : r0_9 +# 433| mu0_1(unknown) = AliasedDefinition : +# 433| mu0_2(unknown) = UnmodeledDefinition : +# 433| r0_3(glval) = VariableAddress[a] : +# 433| m0_4(bool) = InitializeParameter[a] : r0_3 +# 433| r0_5(glval) = VariableAddress[b] : +# 433| m0_6(bool) = InitializeParameter[b] : r0_5 +# 434| r0_7(glval) = VariableAddress[x] : +# 434| m0_8(int) = Uninitialized : r0_7 +# 435| r0_9(glval) = VariableAddress[a] : +# 435| r0_10(bool) = Load : r0_9, m0_4 +# 435| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 # 435| Block 1 # 435| r1_0(glval) = VariableAddress[b] : -# 435| r1_1(bool) = Load : r1_0, m0_5 +# 435| r1_1(bool) = Load : r1_0, m0_6 # 435| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1806,14 +1856,14 @@ ir.cpp: # 439| Block 3 # 439| r3_0(glval) = VariableAddress[a] : -# 439| r3_1(bool) = Load : r3_0, m0_3 +# 439| r3_1(bool) = Load : r3_0, m0_4 # 439| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 # 439| Block 4 # 439| r4_0(glval) = VariableAddress[b] : -# 439| r4_1(bool) = Load : r4_0, m0_5 +# 439| r4_1(bool) = Load : r4_0, m0_6 # 439| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1839,22 +1889,23 @@ ir.cpp: # 447| LogicalAnd(bool, bool) -> void # 447| Block 0 # 447| v0_0(void) = EnterFunction : -# 447| mu0_1(unknown) = UnmodeledDefinition : -# 447| r0_2(glval) = VariableAddress[a] : -# 447| m0_3(bool) = InitializeParameter[a] : r0_2 -# 447| r0_4(glval) = VariableAddress[b] : -# 447| m0_5(bool) = InitializeParameter[b] : r0_4 -# 448| r0_6(glval) = VariableAddress[x] : -# 448| m0_7(int) = Uninitialized : r0_6 -# 449| r0_8(glval) = VariableAddress[a] : -# 449| r0_9(bool) = Load : r0_8, m0_3 -# 449| v0_10(void) = ConditionalBranch : r0_9 +# 447| mu0_1(unknown) = AliasedDefinition : +# 447| mu0_2(unknown) = UnmodeledDefinition : +# 447| r0_3(glval) = VariableAddress[a] : +# 447| m0_4(bool) = InitializeParameter[a] : r0_3 +# 447| r0_5(glval) = VariableAddress[b] : +# 447| m0_6(bool) = InitializeParameter[b] : r0_5 +# 448| r0_7(glval) = VariableAddress[x] : +# 448| m0_8(int) = Uninitialized : r0_7 +# 449| r0_9(glval) = VariableAddress[a] : +# 449| r0_10(bool) = Load : r0_9, m0_4 +# 449| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 3 #-----| True -> Block 1 # 449| Block 1 # 449| r1_0(glval) = VariableAddress[b] : -# 449| r1_1(bool) = Load : r1_0, m0_5 +# 449| r1_1(bool) = Load : r1_0, m0_6 # 449| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 3 #-----| True -> Block 2 @@ -1867,14 +1918,14 @@ ir.cpp: # 453| Block 3 # 453| r3_0(glval) = VariableAddress[a] : -# 453| r3_1(bool) = Load : r3_0, m0_3 +# 453| r3_1(bool) = Load : r3_0, m0_4 # 453| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 6 #-----| True -> Block 4 # 453| Block 4 # 453| r4_0(glval) = VariableAddress[b] : -# 453| r4_1(bool) = Load : r4_0, m0_5 +# 453| r4_1(bool) = Load : r4_0, m0_6 # 453| v4_2(void) = ConditionalBranch : r4_1 #-----| False -> Block 6 #-----| True -> Block 5 @@ -1900,16 +1951,17 @@ ir.cpp: # 461| LogicalNot(bool, bool) -> void # 461| Block 0 # 461| v0_0(void) = EnterFunction : -# 461| mu0_1(unknown) = UnmodeledDefinition : -# 461| r0_2(glval) = VariableAddress[a] : -# 461| m0_3(bool) = InitializeParameter[a] : r0_2 -# 461| r0_4(glval) = VariableAddress[b] : -# 461| m0_5(bool) = InitializeParameter[b] : r0_4 -# 462| r0_6(glval) = VariableAddress[x] : -# 462| m0_7(int) = Uninitialized : r0_6 -# 463| r0_8(glval) = VariableAddress[a] : -# 463| r0_9(bool) = Load : r0_8, m0_3 -# 463| v0_10(void) = ConditionalBranch : r0_9 +# 461| mu0_1(unknown) = AliasedDefinition : +# 461| mu0_2(unknown) = UnmodeledDefinition : +# 461| r0_3(glval) = VariableAddress[a] : +# 461| m0_4(bool) = InitializeParameter[a] : r0_3 +# 461| r0_5(glval) = VariableAddress[b] : +# 461| m0_6(bool) = InitializeParameter[b] : r0_5 +# 462| r0_7(glval) = VariableAddress[x] : +# 462| m0_8(int) = Uninitialized : r0_7 +# 463| r0_9(glval) = VariableAddress[a] : +# 463| r0_10(bool) = Load : r0_9, m0_4 +# 463| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 1 #-----| True -> Block 2 @@ -1921,14 +1973,14 @@ ir.cpp: # 467| Block 2 # 467| r2_0(glval) = VariableAddress[a] : -# 467| r2_1(bool) = Load : r2_0, m0_3 +# 467| r2_1(bool) = Load : r2_0, m0_4 # 467| v2_2(void) = ConditionalBranch : r2_1 #-----| False -> Block 4 #-----| True -> Block 3 # 467| Block 3 # 467| r3_0(glval) = VariableAddress[b] : -# 467| r3_1(bool) = Load : r3_0, m0_5 +# 467| r3_1(bool) = Load : r3_0, m0_6 # 467| v3_2(void) = ConditionalBranch : r3_1 #-----| False -> Block 4 #-----| True -> Block 5 @@ -1954,22 +2006,23 @@ ir.cpp: # 475| ConditionValues(bool, bool) -> void # 475| Block 0 # 475| v0_0(void) = EnterFunction : -# 475| mu0_1(unknown) = UnmodeledDefinition : -# 475| r0_2(glval) = VariableAddress[a] : -# 475| m0_3(bool) = InitializeParameter[a] : r0_2 -# 475| r0_4(glval) = VariableAddress[b] : -# 475| m0_5(bool) = InitializeParameter[b] : r0_4 -# 476| r0_6(glval) = VariableAddress[x] : -# 476| m0_7(bool) = Uninitialized : r0_6 -# 477| r0_8(glval) = VariableAddress[a] : -# 477| r0_9(bool) = Load : r0_8, m0_3 -# 477| v0_10(void) = ConditionalBranch : r0_9 +# 475| mu0_1(unknown) = AliasedDefinition : +# 475| mu0_2(unknown) = UnmodeledDefinition : +# 475| r0_3(glval) = VariableAddress[a] : +# 475| m0_4(bool) = InitializeParameter[a] : r0_3 +# 475| r0_5(glval) = VariableAddress[b] : +# 475| m0_6(bool) = InitializeParameter[b] : r0_5 +# 476| r0_7(glval) = VariableAddress[x] : +# 476| m0_8(bool) = Uninitialized : r0_7 +# 477| r0_9(glval) = VariableAddress[a] : +# 477| r0_10(bool) = Load : r0_9, m0_4 +# 477| v0_11(void) = ConditionalBranch : r0_10 #-----| False -> Block 10 #-----| True -> Block 1 # 477| Block 1 # 477| r1_0(glval) = VariableAddress[b] : -# 477| r1_1(bool) = Load : r1_0, m0_5 +# 477| r1_1(bool) = Load : r1_0, m0_6 # 477| v1_2(void) = ConditionalBranch : r1_1 #-----| False -> Block 10 #-----| True -> Block 12 @@ -1987,7 +2040,7 @@ ir.cpp: # 478| r3_3(glval) = VariableAddress[x] : # 478| m3_4(bool) = Store : r3_3, r3_2 # 479| r3_5(glval) = VariableAddress[a] : -# 479| r3_6(bool) = Load : r3_5, m0_3 +# 479| r3_6(bool) = Load : r3_5, m0_4 # 479| v3_7(void) = ConditionalBranch : r3_6 #-----| False -> Block 9 #-----| True -> Block 8 @@ -2000,7 +2053,7 @@ ir.cpp: # 478| Block 5 # 478| r5_0(glval) = VariableAddress[b] : -# 478| r5_1(bool) = Load : r5_0, m0_5 +# 478| r5_1(bool) = Load : r5_0, m0_6 # 478| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 2 #-----| True -> Block 4 @@ -2031,7 +2084,7 @@ ir.cpp: # 479| Block 9 # 479| r9_0(glval) = VariableAddress[b] : -# 479| r9_1(bool) = Load : r9_0, m0_5 +# 479| r9_1(bool) = Load : r9_0, m0_6 # 479| v9_2(void) = ConditionalBranch : r9_1 #-----| False -> Block 6 #-----| True -> Block 8 @@ -2049,7 +2102,7 @@ ir.cpp: # 477| r11_3(glval) = VariableAddress[x] : # 477| m11_4(bool) = Store : r11_3, r11_2 # 478| r11_5(glval) = VariableAddress[a] : -# 478| r11_6(bool) = Load : r11_5, m0_3 +# 478| r11_6(bool) = Load : r11_5, m0_4 # 478| v11_7(void) = ConditionalBranch : r11_6 #-----| False -> Block 5 #-----| True -> Block 4 @@ -2062,31 +2115,32 @@ ir.cpp: # 482| Conditional(bool, int, int) -> void # 482| Block 0 -# 482| v0_0(void) = EnterFunction : -# 482| mu0_1(unknown) = UnmodeledDefinition : -# 482| r0_2(glval) = VariableAddress[a] : -# 482| m0_3(bool) = InitializeParameter[a] : r0_2 -# 482| r0_4(glval) = VariableAddress[x] : -# 482| m0_5(int) = InitializeParameter[x] : r0_4 -# 482| r0_6(glval) = VariableAddress[y] : -# 482| m0_7(int) = InitializeParameter[y] : r0_6 -# 483| r0_8(glval) = VariableAddress[z] : -# 483| r0_9(glval) = VariableAddress[a] : -# 483| r0_10(bool) = Load : r0_9, m0_3 -# 483| v0_11(void) = ConditionalBranch : r0_10 +# 482| v0_0(void) = EnterFunction : +# 482| mu0_1(unknown) = AliasedDefinition : +# 482| mu0_2(unknown) = UnmodeledDefinition : +# 482| r0_3(glval) = VariableAddress[a] : +# 482| m0_4(bool) = InitializeParameter[a] : r0_3 +# 482| r0_5(glval) = VariableAddress[x] : +# 482| m0_6(int) = InitializeParameter[x] : r0_5 +# 482| r0_7(glval) = VariableAddress[y] : +# 482| m0_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, m0_4 +# 483| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 2 #-----| True -> Block 1 # 483| Block 1 # 483| r1_0(glval) = VariableAddress[x] : -# 483| r1_1(int) = Load : r1_0, m0_5 +# 483| r1_1(int) = Load : r1_0, m0_6 # 483| r1_2(glval) = VariableAddress[#temp483:13] : # 483| m1_3(int) = Store : r1_2, r1_1 #-----| Goto -> Block 3 # 483| Block 2 # 483| r2_0(glval) = VariableAddress[y] : -# 483| r2_1(int) = Load : r2_0, m0_7 +# 483| r2_1(int) = Load : r2_0, m0_8 # 483| r2_2(glval) = VariableAddress[#temp483:13] : # 483| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 @@ -2095,7 +2149,7 @@ ir.cpp: # 483| m3_0(int) = Phi : from 1:m1_3, from 2:m2_3 # 483| r3_1(glval) = VariableAddress[#temp483:13] : # 483| r3_2(int) = Load : r3_1, m3_0 -# 483| m3_3(int) = Store : r0_8, r3_2 +# 483| m3_3(int) = Store : r0_9, r3_2 # 484| v3_4(void) = NoOp : # 482| v3_5(void) = ReturnVoid : # 482| v3_6(void) = UnmodeledUse : mu* @@ -2103,18 +2157,19 @@ ir.cpp: # 486| Conditional_LValue(bool) -> void # 486| Block 0 -# 486| v0_0(void) = EnterFunction : -# 486| mu0_1(unknown) = UnmodeledDefinition : -# 486| r0_2(glval) = VariableAddress[a] : -# 486| m0_3(bool) = InitializeParameter[a] : r0_2 -# 487| r0_4(glval) = VariableAddress[x] : -# 487| mu0_5(int) = Uninitialized : r0_4 -# 488| r0_6(glval) = VariableAddress[y] : -# 488| mu0_7(int) = Uninitialized : r0_6 -# 489| r0_8(int) = Constant[5] : -# 489| r0_9(glval) = VariableAddress[a] : -# 489| r0_10(bool) = Load : r0_9, m0_3 -# 489| v0_11(void) = ConditionalBranch : r0_10 +# 486| v0_0(void) = EnterFunction : +# 486| mu0_1(unknown) = AliasedDefinition : +# 486| mu0_2(unknown) = UnmodeledDefinition : +# 486| r0_3(glval) = VariableAddress[a] : +# 486| m0_4(bool) = InitializeParameter[a] : r0_3 +# 487| r0_5(glval) = VariableAddress[x] : +# 487| mu0_6(int) = Uninitialized : r0_5 +# 488| r0_7(glval) = VariableAddress[y] : +# 488| mu0_8(int) = Uninitialized : r0_7 +# 489| r0_9(int) = Constant[5] : +# 489| r0_10(glval) = VariableAddress[a] : +# 489| r0_11(bool) = Load : r0_10, m0_4 +# 489| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2122,7 +2177,7 @@ ir.cpp: # 489| m1_0(int) = Phi : from 2:m2_2, from 3:m3_2 # 489| r1_1(glval) = VariableAddress[#temp489:6] : # 489| r1_2(glval) = Load : r1_1, m1_0 -# 489| mu1_3(int) = Store : r1_2, r0_8 +# 489| mu1_3(int) = Store : r1_2, r0_9 # 490| v1_4(void) = NoOp : # 486| v1_5(void) = ReturnVoid : # 486| v1_6(void) = UnmodeledUse : mu* @@ -2143,12 +2198,13 @@ ir.cpp: # 492| Conditional_Void(bool) -> void # 492| Block 0 # 492| v0_0(void) = EnterFunction : -# 492| mu0_1(unknown) = UnmodeledDefinition : -# 492| r0_2(glval) = VariableAddress[a] : -# 492| m0_3(bool) = InitializeParameter[a] : r0_2 -# 493| r0_4(glval) = VariableAddress[a] : -# 493| r0_5(bool) = Load : r0_4, m0_3 -# 493| v0_6(void) = ConditionalBranch : r0_5 +# 492| mu0_1(unknown) = AliasedDefinition : +# 492| mu0_2(unknown) = UnmodeledDefinition : +# 492| r0_3(glval) = VariableAddress[a] : +# 492| m0_4(bool) = InitializeParameter[a] : r0_3 +# 493| r0_5(glval) = VariableAddress[a] : +# 493| r0_6(bool) = Load : r0_5, m0_4 +# 493| v0_7(void) = ConditionalBranch : r0_6 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2161,238 +2217,246 @@ ir.cpp: # 493| Block 2 # 493| r2_0(glval) = FunctionAddress[VoidFunc] : # 493| v2_1(void) = Call : r2_0 +# 493| mu2_2(unknown) = ^CallSideEffect : mu0_2 #-----| Goto -> Block 1 # 493| Block 3 # 493| r3_0(glval) = FunctionAddress[VoidFunc] : # 493| v3_1(void) = Call : r3_0 +# 493| mu3_2(unknown) = ^CallSideEffect : mu0_2 #-----| Goto -> Block 1 # 496| Nullptr() -> void # 496| Block 0 # 496| v0_0(void) = EnterFunction : -# 496| mu0_1(unknown) = UnmodeledDefinition : -# 497| r0_2(glval) = VariableAddress[p] : -# 497| r0_3(int *) = Constant[0] : -# 497| m0_4(int *) = Store : r0_2, r0_3 -# 498| r0_5(glval) = VariableAddress[q] : -# 498| r0_6(int *) = Constant[0] : -# 498| m0_7(int *) = Store : r0_5, r0_6 -# 499| r0_8(int *) = Constant[0] : -# 499| r0_9(glval) = VariableAddress[p] : -# 499| m0_10(int *) = Store : r0_9, r0_8 -# 500| r0_11(int *) = Constant[0] : -# 500| r0_12(glval) = VariableAddress[q] : -# 500| m0_13(int *) = Store : r0_12, r0_11 -# 501| v0_14(void) = NoOp : -# 496| v0_15(void) = ReturnVoid : -# 496| v0_16(void) = UnmodeledUse : mu* -# 496| v0_17(void) = ExitFunction : +# 496| mu0_1(unknown) = AliasedDefinition : +# 496| mu0_2(unknown) = UnmodeledDefinition : +# 497| r0_3(glval) = VariableAddress[p] : +# 497| r0_4(int *) = Constant[0] : +# 497| m0_5(int *) = Store : r0_3, r0_4 +# 498| r0_6(glval) = VariableAddress[q] : +# 498| r0_7(int *) = Constant[0] : +# 498| m0_8(int *) = Store : r0_6, r0_7 +# 499| r0_9(int *) = Constant[0] : +# 499| r0_10(glval) = VariableAddress[p] : +# 499| m0_11(int *) = Store : r0_10, r0_9 +# 500| r0_12(int *) = Constant[0] : +# 500| r0_13(glval) = VariableAddress[q] : +# 500| m0_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) = ExitFunction : # 503| InitList(int, float) -> void # 503| Block 0 # 503| v0_0(void) = EnterFunction : -# 503| mu0_1(unknown) = UnmodeledDefinition : -# 503| r0_2(glval) = VariableAddress[x] : -# 503| m0_3(int) = InitializeParameter[x] : r0_2 -# 503| r0_4(glval) = VariableAddress[f] : -# 503| m0_5(float) = InitializeParameter[f] : r0_4 -# 504| r0_6(glval) = VariableAddress[pt1] : -# 504| m0_7(Point) = Uninitialized : r0_6 -# 504| r0_8(glval) = FieldAddress[x] : r0_6 -# 504| r0_9(glval) = VariableAddress[x] : -# 504| r0_10(int) = Load : r0_9, m0_3 -# 504| m0_11(int) = Store : r0_8, r0_10 -# 504| r0_12(glval) = FieldAddress[y] : r0_6 -# 504| r0_13(glval) = VariableAddress[f] : -# 504| r0_14(float) = Load : r0_13, m0_5 -# 504| r0_15(int) = Convert : r0_14 -# 504| mu0_16(int) = Store : r0_12, r0_15 -# 505| r0_17(glval) = VariableAddress[pt2] : -# 505| m0_18(Point) = Uninitialized : r0_17 -# 505| r0_19(glval) = FieldAddress[x] : r0_17 -# 505| r0_20(glval) = VariableAddress[x] : -# 505| r0_21(int) = Load : r0_20, m0_3 -# 505| m0_22(int) = Store : r0_19, r0_21 -# 505| r0_23(glval) = FieldAddress[y] : r0_17 -# 505| r0_24(int) = Constant[0] : -# 505| mu0_25(int) = Store : r0_23, r0_24 -# 506| r0_26(glval) = VariableAddress[pt3] : -# 506| m0_27(Point) = Uninitialized : r0_26 -# 506| r0_28(glval) = FieldAddress[x] : r0_26 -# 506| r0_29(int) = Constant[0] : -# 506| m0_30(int) = Store : r0_28, r0_29 -# 506| r0_31(glval) = FieldAddress[y] : r0_26 -# 506| r0_32(int) = Constant[0] : -# 506| mu0_33(int) = Store : r0_31, r0_32 -# 508| r0_34(glval) = VariableAddress[x1] : -# 508| r0_35(int) = Constant[1] : -# 508| m0_36(int) = Store : r0_34, r0_35 -# 509| r0_37(glval) = VariableAddress[x2] : -# 509| r0_38(int) = Constant[0] : -# 509| m0_39(int) = Store : r0_37, r0_38 -# 510| v0_40(void) = NoOp : -# 503| v0_41(void) = ReturnVoid : -# 503| v0_42(void) = UnmodeledUse : mu* -# 503| v0_43(void) = ExitFunction : +# 503| mu0_1(unknown) = AliasedDefinition : +# 503| mu0_2(unknown) = UnmodeledDefinition : +# 503| r0_3(glval) = VariableAddress[x] : +# 503| m0_4(int) = InitializeParameter[x] : r0_3 +# 503| r0_5(glval) = VariableAddress[f] : +# 503| m0_6(float) = InitializeParameter[f] : r0_5 +# 504| r0_7(glval) = VariableAddress[pt1] : +# 504| m0_8(Point) = Uninitialized : r0_7 +# 504| r0_9(glval) = FieldAddress[x] : r0_7 +# 504| r0_10(glval) = VariableAddress[x] : +# 504| r0_11(int) = Load : r0_10, m0_4 +# 504| m0_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, m0_6 +# 504| r0_16(int) = Convert : r0_15 +# 504| mu0_17(int) = Store : r0_13, r0_16 +# 505| r0_18(glval) = VariableAddress[pt2] : +# 505| m0_19(Point) = Uninitialized : r0_18 +# 505| r0_20(glval) = FieldAddress[x] : r0_18 +# 505| r0_21(glval) = VariableAddress[x] : +# 505| r0_22(int) = Load : r0_21, m0_4 +# 505| m0_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| m0_28(Point) = Uninitialized : r0_27 +# 506| r0_29(glval) = FieldAddress[x] : r0_27 +# 506| r0_30(int) = Constant[0] : +# 506| m0_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| m0_37(int) = Store : r0_35, r0_36 +# 509| r0_38(glval) = VariableAddress[x2] : +# 509| r0_39(int) = Constant[0] : +# 509| m0_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) = ExitFunction : # 512| NestedInitList(int, float) -> void # 512| Block 0 # 512| v0_0(void) = EnterFunction : -# 512| mu0_1(unknown) = UnmodeledDefinition : -# 512| r0_2(glval) = VariableAddress[x] : -# 512| m0_3(int) = InitializeParameter[x] : r0_2 -# 512| r0_4(glval) = VariableAddress[f] : -# 512| m0_5(float) = InitializeParameter[f] : r0_4 -# 513| r0_6(glval) = VariableAddress[r1] : -# 513| m0_7(Rect) = Uninitialized : r0_6 -# 513| r0_8(glval) = FieldAddress[topLeft] : r0_6 -# 513| r0_9(Point) = Constant[0] : -# 513| m0_10(Point) = Store : r0_8, r0_9 -# 513| r0_11(glval) = FieldAddress[bottomRight] : r0_6 -# 513| r0_12(Point) = Constant[0] : -# 513| mu0_13(Point) = Store : r0_11, r0_12 -# 514| r0_14(glval) = VariableAddress[r2] : -# 514| m0_15(Rect) = Uninitialized : r0_14 -# 514| r0_16(glval) = FieldAddress[topLeft] : r0_14 -# 514| r0_17(glval) = FieldAddress[x] : r0_16 -# 514| r0_18(glval) = VariableAddress[x] : -# 514| r0_19(int) = Load : r0_18, m0_3 -# 514| m0_20(int) = Store : r0_17, r0_19 -# 514| r0_21(glval) = FieldAddress[y] : r0_16 -# 514| r0_22(glval) = VariableAddress[f] : -# 514| r0_23(float) = Load : r0_22, m0_5 -# 514| r0_24(int) = Convert : r0_23 -# 514| mu0_25(int) = Store : r0_21, r0_24 -# 514| r0_26(glval) = FieldAddress[bottomRight] : r0_14 -# 514| r0_27(Point) = Constant[0] : -# 514| mu0_28(Point) = Store : r0_26, r0_27 -# 515| r0_29(glval) = VariableAddress[r3] : -# 515| m0_30(Rect) = Uninitialized : r0_29 -# 515| r0_31(glval) = FieldAddress[topLeft] : r0_29 -# 515| r0_32(glval) = FieldAddress[x] : r0_31 -# 515| r0_33(glval) = VariableAddress[x] : -# 515| r0_34(int) = Load : r0_33, m0_3 -# 515| m0_35(int) = Store : r0_32, r0_34 -# 515| r0_36(glval) = FieldAddress[y] : r0_31 -# 515| r0_37(glval) = VariableAddress[f] : -# 515| r0_38(float) = Load : r0_37, m0_5 -# 515| r0_39(int) = Convert : r0_38 -# 515| mu0_40(int) = Store : r0_36, r0_39 -# 515| r0_41(glval) = FieldAddress[bottomRight] : r0_29 -# 515| r0_42(glval) = FieldAddress[x] : r0_41 -# 515| r0_43(glval) = VariableAddress[x] : -# 515| r0_44(int) = Load : r0_43, m0_3 -# 515| mu0_45(int) = Store : r0_42, r0_44 -# 515| r0_46(glval) = FieldAddress[y] : r0_41 -# 515| r0_47(glval) = VariableAddress[f] : -# 515| r0_48(float) = Load : r0_47, m0_5 -# 515| r0_49(int) = Convert : r0_48 -# 515| mu0_50(int) = Store : r0_46, r0_49 -# 516| r0_51(glval) = VariableAddress[r4] : -# 516| m0_52(Rect) = Uninitialized : r0_51 -# 516| r0_53(glval) = FieldAddress[topLeft] : r0_51 -# 516| r0_54(glval) = FieldAddress[x] : r0_53 -# 516| r0_55(glval) = VariableAddress[x] : -# 516| r0_56(int) = Load : r0_55, m0_3 -# 516| m0_57(int) = Store : r0_54, r0_56 -# 516| r0_58(glval) = FieldAddress[y] : r0_53 -# 516| r0_59(int) = Constant[0] : -# 516| mu0_60(int) = Store : r0_58, r0_59 -# 516| r0_61(glval) = FieldAddress[bottomRight] : r0_51 -# 516| r0_62(glval) = FieldAddress[x] : r0_61 -# 516| r0_63(glval) = VariableAddress[x] : -# 516| r0_64(int) = Load : r0_63, m0_3 -# 516| mu0_65(int) = Store : r0_62, r0_64 -# 516| r0_66(glval) = FieldAddress[y] : r0_61 -# 516| r0_67(int) = Constant[0] : -# 516| mu0_68(int) = Store : r0_66, r0_67 -# 517| v0_69(void) = NoOp : -# 512| v0_70(void) = ReturnVoid : -# 512| v0_71(void) = UnmodeledUse : mu* -# 512| v0_72(void) = ExitFunction : +# 512| mu0_1(unknown) = AliasedDefinition : +# 512| mu0_2(unknown) = UnmodeledDefinition : +# 512| r0_3(glval) = VariableAddress[x] : +# 512| m0_4(int) = InitializeParameter[x] : r0_3 +# 512| r0_5(glval) = VariableAddress[f] : +# 512| m0_6(float) = InitializeParameter[f] : r0_5 +# 513| r0_7(glval) = VariableAddress[r1] : +# 513| m0_8(Rect) = Uninitialized : r0_7 +# 513| r0_9(glval) = FieldAddress[topLeft] : r0_7 +# 513| r0_10(Point) = Constant[0] : +# 513| m0_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| m0_16(Rect) = Uninitialized : 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, m0_4 +# 514| m0_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, m0_6 +# 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| m0_31(Rect) = Uninitialized : 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, m0_4 +# 515| m0_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, m0_6 +# 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, m0_4 +# 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, m0_6 +# 515| r0_50(int) = Convert : r0_49 +# 515| mu0_51(int) = Store : r0_47, r0_50 +# 516| r0_52(glval) = VariableAddress[r4] : +# 516| m0_53(Rect) = Uninitialized : 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, m0_4 +# 516| m0_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, m0_4 +# 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) = ExitFunction : # 519| ArrayInit(int, float) -> void # 519| Block 0 # 519| v0_0(void) = EnterFunction : -# 519| mu0_1(unknown) = UnmodeledDefinition : -# 519| r0_2(glval) = VariableAddress[x] : -# 519| m0_3(int) = InitializeParameter[x] : r0_2 -# 519| r0_4(glval) = VariableAddress[f] : -# 519| m0_5(float) = InitializeParameter[f] : r0_4 -# 520| r0_6(glval) = VariableAddress[a1] : -# 520| mu0_7(int[3]) = Uninitialized : r0_6 -# 520| r0_8(int) = Constant[0] : -# 520| r0_9(glval) = PointerAdd : r0_6, r0_8 -# 520| r0_10(unknown[12]) = Constant[0] : -# 520| mu0_11(unknown[12]) = Store : r0_9, r0_10 -# 521| r0_12(glval) = VariableAddress[a2] : -# 521| mu0_13(int[3]) = Uninitialized : r0_12 -# 521| r0_14(int) = Constant[0] : -# 521| r0_15(glval) = PointerAdd : r0_12, r0_14 -# 521| r0_16(glval) = VariableAddress[x] : -# 521| r0_17(int) = Load : r0_16, m0_3 -# 521| mu0_18(int) = Store : r0_15, r0_17 -# 521| r0_19(int) = Constant[1] : -# 521| r0_20(glval) = PointerAdd : r0_12, r0_19 -# 521| r0_21(glval) = VariableAddress[f] : -# 521| r0_22(float) = Load : r0_21, m0_5 -# 521| r0_23(int) = Convert : r0_22 -# 521| mu0_24(int) = Store : r0_20, r0_23 -# 521| r0_25(int) = Constant[2] : -# 521| r0_26(glval) = PointerAdd : r0_12, r0_25 -# 521| r0_27(int) = Constant[0] : -# 521| mu0_28(int) = Store : r0_26, r0_27 -# 522| r0_29(glval) = VariableAddress[a3] : -# 522| mu0_30(int[3]) = Uninitialized : r0_29 -# 522| r0_31(int) = Constant[0] : -# 522| r0_32(glval) = PointerAdd : r0_29, r0_31 -# 522| r0_33(glval) = VariableAddress[x] : -# 522| r0_34(int) = Load : r0_33, m0_3 -# 522| mu0_35(int) = Store : r0_32, r0_34 -# 522| r0_36(int) = Constant[1] : -# 522| r0_37(glval) = PointerAdd : r0_29, r0_36 -# 522| r0_38(unknown[8]) = Constant[0] : -# 522| mu0_39(unknown[8]) = Store : r0_37, r0_38 -# 523| v0_40(void) = NoOp : -# 519| v0_41(void) = ReturnVoid : -# 519| v0_42(void) = UnmodeledUse : mu* -# 519| v0_43(void) = ExitFunction : +# 519| mu0_1(unknown) = AliasedDefinition : +# 519| mu0_2(unknown) = UnmodeledDefinition : +# 519| r0_3(glval) = VariableAddress[x] : +# 519| m0_4(int) = InitializeParameter[x] : r0_3 +# 519| r0_5(glval) = VariableAddress[f] : +# 519| m0_6(float) = InitializeParameter[f] : r0_5 +# 520| r0_7(glval) = VariableAddress[a1] : +# 520| mu0_8(int[3]) = Uninitialized : r0_7 +# 520| r0_9(int) = Constant[0] : +# 520| r0_10(glval) = PointerAdd : 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 : r0_13 +# 521| r0_15(int) = Constant[0] : +# 521| r0_16(glval) = PointerAdd : r0_13, r0_15 +# 521| r0_17(glval) = VariableAddress[x] : +# 521| r0_18(int) = Load : r0_17, m0_4 +# 521| mu0_19(int) = Store : r0_16, r0_18 +# 521| r0_20(int) = Constant[1] : +# 521| r0_21(glval) = PointerAdd : r0_13, r0_20 +# 521| r0_22(glval) = VariableAddress[f] : +# 521| r0_23(float) = Load : r0_22, m0_6 +# 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 : 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 : r0_30 +# 522| r0_32(int) = Constant[0] : +# 522| r0_33(glval) = PointerAdd : r0_30, r0_32 +# 522| r0_34(glval) = VariableAddress[x] : +# 522| r0_35(int) = Load : r0_34, m0_4 +# 522| mu0_36(int) = Store : r0_33, r0_35 +# 522| r0_37(int) = Constant[1] : +# 522| r0_38(glval) = PointerAdd : 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) = ExitFunction : # 530| UnionInit(int, float) -> void # 530| Block 0 # 530| v0_0(void) = EnterFunction : -# 530| mu0_1(unknown) = UnmodeledDefinition : -# 530| r0_2(glval) = VariableAddress[x] : -# 530| m0_3(int) = InitializeParameter[x] : r0_2 -# 530| r0_4(glval) = VariableAddress[f] : -# 530| m0_5(float) = InitializeParameter[f] : r0_4 -# 531| r0_6(glval) = VariableAddress[u1] : -# 531| m0_7(U) = Uninitialized : r0_6 -# 531| r0_8(glval) = FieldAddress[d] : r0_6 -# 531| r0_9(glval) = VariableAddress[f] : -# 531| r0_10(float) = Load : r0_9, m0_5 -# 531| r0_11(double) = Convert : r0_10 -# 531| m0_12(double) = Store : r0_8, r0_11 -# 533| v0_13(void) = NoOp : -# 530| v0_14(void) = ReturnVoid : -# 530| v0_15(void) = UnmodeledUse : mu* -# 530| v0_16(void) = ExitFunction : +# 530| mu0_1(unknown) = AliasedDefinition : +# 530| mu0_2(unknown) = UnmodeledDefinition : +# 530| r0_3(glval) = VariableAddress[x] : +# 530| m0_4(int) = InitializeParameter[x] : r0_3 +# 530| r0_5(glval) = VariableAddress[f] : +# 530| m0_6(float) = InitializeParameter[f] : r0_5 +# 531| r0_7(glval) = VariableAddress[u1] : +# 531| m0_8(U) = Uninitialized : r0_7 +# 531| r0_9(glval) = FieldAddress[d] : r0_7 +# 531| r0_10(glval) = VariableAddress[f] : +# 531| r0_11(float) = Load : r0_10, m0_6 +# 531| r0_12(double) = Convert : r0_11 +# 531| m0_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) = ExitFunction : # 535| EarlyReturn(int, int) -> void # 535| Block 0 # 535| v0_0(void) = EnterFunction : -# 535| mu0_1(unknown) = UnmodeledDefinition : -# 535| r0_2(glval) = VariableAddress[x] : -# 535| m0_3(int) = InitializeParameter[x] : r0_2 -# 535| r0_4(glval) = VariableAddress[y] : -# 535| m0_5(int) = InitializeParameter[y] : r0_4 -# 536| r0_6(glval) = VariableAddress[x] : -# 536| r0_7(int) = Load : r0_6, m0_3 -# 536| r0_8(glval) = VariableAddress[y] : -# 536| r0_9(int) = Load : r0_8, m0_5 -# 536| r0_10(bool) = CompareLT : r0_7, r0_9 -# 536| v0_11(void) = ConditionalBranch : r0_10 +# 535| mu0_1(unknown) = AliasedDefinition : +# 535| mu0_2(unknown) = UnmodeledDefinition : +# 535| r0_3(glval) = VariableAddress[x] : +# 535| m0_4(int) = InitializeParameter[x] : r0_3 +# 535| r0_5(glval) = VariableAddress[y] : +# 535| m0_6(int) = InitializeParameter[y] : r0_5 +# 536| r0_7(glval) = VariableAddress[x] : +# 536| r0_8(int) = Load : r0_7, m0_4 +# 536| r0_9(glval) = VariableAddress[y] : +# 536| r0_10(int) = Load : r0_9, m0_6 +# 536| r0_11(bool) = CompareLT : r0_8, r0_10 +# 536| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2407,7 +2471,7 @@ ir.cpp: # 540| Block 3 # 540| r3_0(glval) = VariableAddress[x] : -# 540| r3_1(int) = Load : r3_0, m0_3 +# 540| r3_1(int) = Load : r3_0, m0_4 # 540| r3_2(glval) = VariableAddress[y] : # 540| m3_3(int) = Store : r3_2, r3_1 # 541| v3_4(void) = NoOp : @@ -2416,17 +2480,18 @@ ir.cpp: # 543| EarlyReturnValue(int, int) -> int # 543| Block 0 # 543| v0_0(void) = EnterFunction : -# 543| mu0_1(unknown) = UnmodeledDefinition : -# 543| r0_2(glval) = VariableAddress[x] : -# 543| m0_3(int) = InitializeParameter[x] : r0_2 -# 543| r0_4(glval) = VariableAddress[y] : -# 543| m0_5(int) = InitializeParameter[y] : r0_4 -# 544| r0_6(glval) = VariableAddress[x] : -# 544| r0_7(int) = Load : r0_6, m0_3 -# 544| r0_8(glval) = VariableAddress[y] : -# 544| r0_9(int) = Load : r0_8, m0_5 -# 544| r0_10(bool) = CompareLT : r0_7, r0_9 -# 544| v0_11(void) = ConditionalBranch : r0_10 +# 543| mu0_1(unknown) = AliasedDefinition : +# 543| mu0_2(unknown) = UnmodeledDefinition : +# 543| r0_3(glval) = VariableAddress[x] : +# 543| m0_4(int) = InitializeParameter[x] : r0_3 +# 543| r0_5(glval) = VariableAddress[y] : +# 543| m0_6(int) = InitializeParameter[y] : r0_5 +# 544| r0_7(glval) = VariableAddress[x] : +# 544| r0_8(int) = Load : r0_7, m0_4 +# 544| r0_9(glval) = VariableAddress[y] : +# 544| r0_10(int) = Load : r0_9, m0_6 +# 544| r0_11(bool) = CompareLT : r0_8, r0_10 +# 544| v0_12(void) = ConditionalBranch : r0_11 #-----| False -> Block 3 #-----| True -> Block 2 @@ -2440,16 +2505,16 @@ ir.cpp: # 545| Block 2 # 545| r2_0(glval) = VariableAddress[#return] : # 545| r2_1(glval) = VariableAddress[x] : -# 545| r2_2(int) = Load : r2_1, m0_3 +# 545| r2_2(int) = Load : r2_1, m0_4 # 545| m2_3(int) = Store : r2_0, r2_2 #-----| 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, m0_3 +# 548| r3_2(int) = Load : r3_1, m0_4 # 548| r3_3(glval) = VariableAddress[y] : -# 548| r3_4(int) = Load : r3_3, m0_5 +# 548| r3_4(int) = Load : r3_3, m0_6 # 548| r3_5(int) = Add : r3_2, r3_4 # 548| m3_6(int) = Store : r3_0, r3_5 #-----| Goto -> Block 1 @@ -2457,30 +2522,33 @@ ir.cpp: # 551| CallViaFuncPtr(..(*)(..)) -> int # 551| Block 0 # 551| v0_0(void) = EnterFunction : -# 551| mu0_1(unknown) = UnmodeledDefinition : -# 551| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| m0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 552| r0_4(glval) = VariableAddress[#return] : -# 552| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r0_6(..(*)(..)) = Load : r0_5, m0_3 -# 552| r0_7(int) = Constant[5] : -# 552| r0_8(int) = Call : r0_6, r0_7 -# 552| m0_9(int) = Store : r0_4, r0_8 -# 551| r0_10(glval) = VariableAddress[#return] : -# 551| v0_11(void) = ReturnValue : r0_10, m0_9 -# 551| v0_12(void) = UnmodeledUse : mu* -# 551| v0_13(void) = ExitFunction : +# 551| mu0_1(unknown) = AliasedDefinition : +# 551| mu0_2(unknown) = UnmodeledDefinition : +# 551| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 551| m0_4(..(*)(..)) = InitializeParameter[pfn] : r0_3 +# 552| r0_5(glval) = VariableAddress[#return] : +# 552| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 552| r0_7(..(*)(..)) = Load : r0_6, m0_4 +# 552| r0_8(int) = Constant[5] : +# 552| r0_9(int) = Call : r0_7, r0_8 +# 552| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 552| m0_11(int) = Store : r0_5, r0_9 +# 551| r0_12(glval) = VariableAddress[#return] : +# 551| v0_13(void) = ReturnValue : r0_12, m0_11 +# 551| v0_14(void) = UnmodeledUse : mu* +# 551| v0_15(void) = ExitFunction : # 560| EnumSwitch(E) -> int # 560| Block 0 # 560| v0_0(void) = EnterFunction : -# 560| mu0_1(unknown) = UnmodeledDefinition : -# 560| r0_2(glval) = VariableAddress[e] : -# 560| m0_3(E) = InitializeParameter[e] : r0_2 -# 561| r0_4(glval) = VariableAddress[e] : -# 561| r0_5(E) = Load : r0_4, m0_3 -# 561| r0_6(int) = Convert : r0_5 -# 561| v0_7(void) = Switch : r0_6 +# 560| mu0_1(unknown) = AliasedDefinition : +# 560| mu0_2(unknown) = UnmodeledDefinition : +# 560| r0_3(glval) = VariableAddress[e] : +# 560| m0_4(E) = InitializeParameter[e] : r0_3 +# 561| r0_5(glval) = VariableAddress[e] : +# 561| r0_6(E) = Load : r0_5, m0_4 +# 561| r0_7(int) = Convert : r0_6 +# 561| v0_8(void) = Switch : r0_7 #-----| Case[0] -> Block 4 #-----| Case[1] -> Block 2 #-----| Default -> Block 3 @@ -2516,414 +2584,446 @@ ir.cpp: # 571| InitArray() -> void # 571| Block 0 # 571| v0_0(void) = EnterFunction : -# 571| mu0_1(unknown) = UnmodeledDefinition : -# 572| r0_2(glval) = VariableAddress[a_pad] : -# 572| r0_3(glval) = StringConstant[""] : -# 572| r0_4(char[1]) = Load : r0_3, mu0_1 -# 572| mu0_5(char[1]) = Store : r0_2, r0_4 -# 572| r0_6(unknown[31]) = Constant[0] : -# 572| r0_7(int) = Constant[1] : -# 572| r0_8(glval) = PointerAdd : r0_2, r0_7 -# 572| mu0_9(unknown[31]) = Store : r0_8, r0_6 -# 573| r0_10(glval) = VariableAddress[a_nopad] : -# 573| r0_11(glval) = StringConstant["foo"] : -# 573| r0_12(char[4]) = Load : r0_11, mu0_1 -# 573| m0_13(char[4]) = Store : r0_10, r0_12 -# 574| r0_14(glval) = VariableAddress[a_infer] : -# 574| r0_15(glval) = StringConstant["blah"] : -# 574| r0_16(char[5]) = Load : r0_15, mu0_1 -# 574| m0_17(char[5]) = Store : r0_14, r0_16 -# 575| r0_18(glval) = VariableAddress[b] : -# 575| m0_19(char[2]) = Uninitialized : r0_18 -# 576| r0_20(glval) = VariableAddress[c] : -# 576| mu0_21(char[2]) = Uninitialized : r0_20 -# 576| r0_22(int) = Constant[0] : -# 576| r0_23(glval) = PointerAdd : r0_20, r0_22 -# 576| r0_24(unknown[2]) = Constant[0] : -# 576| mu0_25(unknown[2]) = Store : r0_23, r0_24 -# 577| r0_26(glval) = VariableAddress[d] : -# 577| mu0_27(char[2]) = Uninitialized : r0_26 -# 577| r0_28(int) = Constant[0] : -# 577| r0_29(glval) = PointerAdd : r0_26, r0_28 -# 577| r0_30(char) = Constant[0] : -# 577| mu0_31(char) = Store : r0_29, r0_30 -# 577| r0_32(int) = Constant[1] : -# 577| r0_33(glval) = PointerAdd : r0_26, r0_32 -# 577| r0_34(char) = Constant[0] : -# 577| mu0_35(char) = Store : r0_33, r0_34 -# 578| r0_36(glval) = VariableAddress[e] : -# 578| mu0_37(char[2]) = Uninitialized : r0_36 -# 578| r0_38(int) = Constant[0] : -# 578| r0_39(glval) = PointerAdd : r0_36, r0_38 -# 578| r0_40(char) = Constant[0] : -# 578| mu0_41(char) = Store : r0_39, r0_40 -# 578| r0_42(int) = Constant[1] : -# 578| r0_43(glval) = PointerAdd : r0_36, r0_42 -# 578| r0_44(char) = Constant[1] : -# 578| mu0_45(char) = Store : r0_43, r0_44 -# 579| r0_46(glval) = VariableAddress[f] : -# 579| mu0_47(char[3]) = Uninitialized : r0_46 -# 579| r0_48(int) = Constant[0] : -# 579| r0_49(glval) = PointerAdd : r0_46, r0_48 -# 579| r0_50(char) = Constant[0] : -# 579| mu0_51(char) = Store : r0_49, r0_50 -# 579| r0_52(int) = Constant[1] : -# 579| r0_53(glval) = PointerAdd : r0_46, r0_52 -# 579| r0_54(unknown[2]) = Constant[0] : -# 579| mu0_55(unknown[2]) = Store : r0_53, r0_54 -# 580| v0_56(void) = NoOp : -# 571| v0_57(void) = ReturnVoid : -# 571| v0_58(void) = UnmodeledUse : mu* -# 571| v0_59(void) = ExitFunction : +# 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[1]) = Load : r0_4, mu0_2 +# 572| mu0_6(char[1]) = Store : r0_3, r0_5 +# 572| r0_7(unknown[31]) = Constant[0] : +# 572| r0_8(int) = Constant[1] : +# 572| r0_9(glval) = PointerAdd : r0_3, r0_8 +# 572| mu0_10(unknown[31]) = Store : r0_9, r0_7 +# 573| r0_11(glval) = VariableAddress[a_nopad] : +# 573| r0_12(glval) = StringConstant["foo"] : +# 573| r0_13(char[4]) = Load : r0_12, mu0_2 +# 573| m0_14(char[4]) = Store : r0_11, r0_13 +# 574| r0_15(glval) = VariableAddress[a_infer] : +# 574| r0_16(glval) = StringConstant["blah"] : +# 574| r0_17(char[5]) = Load : r0_16, mu0_2 +# 574| m0_18(char[5]) = Store : r0_15, r0_17 +# 575| r0_19(glval) = VariableAddress[b] : +# 575| m0_20(char[2]) = Uninitialized : r0_19 +# 576| r0_21(glval) = VariableAddress[c] : +# 576| mu0_22(char[2]) = Uninitialized : r0_21 +# 576| r0_23(int) = Constant[0] : +# 576| r0_24(glval) = PointerAdd : r0_21, r0_23 +# 576| r0_25(unknown[2]) = Constant[0] : +# 576| mu0_26(unknown[2]) = Store : r0_24, r0_25 +# 577| r0_27(glval) = VariableAddress[d] : +# 577| mu0_28(char[2]) = Uninitialized : r0_27 +# 577| r0_29(int) = Constant[0] : +# 577| r0_30(glval) = PointerAdd : r0_27, r0_29 +# 577| r0_31(char) = Constant[0] : +# 577| mu0_32(char) = Store : r0_30, r0_31 +# 577| r0_33(int) = Constant[1] : +# 577| r0_34(glval) = PointerAdd : r0_27, r0_33 +# 577| r0_35(char) = Constant[0] : +# 577| mu0_36(char) = Store : r0_34, r0_35 +# 578| r0_37(glval) = VariableAddress[e] : +# 578| mu0_38(char[2]) = Uninitialized : r0_37 +# 578| r0_39(int) = Constant[0] : +# 578| r0_40(glval) = PointerAdd : r0_37, r0_39 +# 578| r0_41(char) = Constant[0] : +# 578| mu0_42(char) = Store : r0_40, r0_41 +# 578| r0_43(int) = Constant[1] : +# 578| r0_44(glval) = PointerAdd : r0_37, r0_43 +# 578| r0_45(char) = Constant[1] : +# 578| mu0_46(char) = Store : r0_44, r0_45 +# 579| r0_47(glval) = VariableAddress[f] : +# 579| mu0_48(char[3]) = Uninitialized : r0_47 +# 579| r0_49(int) = Constant[0] : +# 579| r0_50(glval) = PointerAdd : r0_47, r0_49 +# 579| r0_51(char) = Constant[0] : +# 579| mu0_52(char) = Store : r0_50, r0_51 +# 579| r0_53(int) = Constant[1] : +# 579| r0_54(glval) = PointerAdd : r0_47, r0_53 +# 579| r0_55(unknown[2]) = Constant[0] : +# 579| mu0_56(unknown[2]) = Store : r0_54, r0_55 +# 580| v0_57(void) = NoOp : +# 571| v0_58(void) = ReturnVoid : +# 571| v0_59(void) = UnmodeledUse : mu* +# 571| v0_60(void) = ExitFunction : # 584| VarArgs() -> void # 584| Block 0 # 584| v0_0(void) = EnterFunction : -# 584| mu0_1(unknown) = UnmodeledDefinition : -# 585| r0_2(glval) = FunctionAddress[VarArgFunction] : -# 585| r0_3(glval) = StringConstant["%d %s"] : -# 585| r0_4(char *) = Convert : r0_3 -# 585| r0_5(int) = Constant[1] : -# 585| r0_6(glval) = StringConstant["string"] : -# 585| r0_7(char *) = Convert : r0_6 -# 585| v0_8(void) = Call : r0_2, r0_4, r0_5, r0_7 -# 586| v0_9(void) = NoOp : -# 584| v0_10(void) = ReturnVoid : -# 584| v0_11(void) = UnmodeledUse : mu* -# 584| v0_12(void) = ExitFunction : +# 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 : r0_3, r0_5, r0_6, r0_8 +# 585| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 586| v0_11(void) = NoOp : +# 584| v0_12(void) = ReturnVoid : +# 584| v0_13(void) = UnmodeledUse : mu* +# 584| v0_14(void) = ExitFunction : # 590| SetFuncPtr() -> void # 590| Block 0 # 590| v0_0(void) = EnterFunction : -# 590| mu0_1(unknown) = UnmodeledDefinition : -# 591| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r0_3(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 591| m0_4(..(*)(..)) = Store : r0_2, r0_3 -# 592| r0_5(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| m0_7(..(*)(..)) = Store : r0_6, r0_5 -# 593| r0_8(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : -# 593| r0_9(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| m0_10(..(*)(..)) = Store : r0_9, r0_8 -# 594| r0_11(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r0_12(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| m0_13(..(*)(..)) = Store : r0_12, r0_11 -# 595| v0_14(void) = NoOp : -# 590| v0_15(void) = ReturnVoid : -# 590| v0_16(void) = UnmodeledUse : mu* -# 590| v0_17(void) = ExitFunction : +# 590| mu0_1(unknown) = AliasedDefinition : +# 590| mu0_2(unknown) = UnmodeledDefinition : +# 591| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r0_4(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 591| m0_5(..(*)(..)) = Store : r0_3, r0_4 +# 592| r0_6(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| m0_8(..(*)(..)) = Store : r0_7, r0_6 +# 593| r0_9(glval<..(*)(..)>) = FunctionAddress[FuncPtrTarget] : +# 593| r0_10(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| m0_11(..(*)(..)) = Store : r0_10, r0_9 +# 594| r0_12(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r0_13(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| m0_14(..(*)(..)) = Store : r0_13, r0_12 +# 595| v0_15(void) = NoOp : +# 590| v0_16(void) = ReturnVoid : +# 590| v0_17(void) = UnmodeledUse : mu* +# 590| v0_18(void) = ExitFunction : # 615| DeclareObject() -> void # 615| Block 0 # 615| v0_0(void) = EnterFunction : -# 615| mu0_1(unknown) = UnmodeledDefinition : -# 616| r0_2(glval) = VariableAddress[s1] : -# 616| r0_3(glval) = FunctionAddress[String] : -# 616| v0_4(void) = Call : r0_3, this:r0_2 -# 617| r0_5(glval) = VariableAddress[s2] : -# 617| r0_6(glval) = FunctionAddress[String] : -# 617| r0_7(glval) = StringConstant["hello"] : -# 617| r0_8(char *) = Convert : r0_7 -# 617| v0_9(void) = Call : r0_6, this:r0_5, r0_8 -# 618| r0_10(glval) = VariableAddress[s3] : -# 618| r0_11(glval) = FunctionAddress[ReturnObject] : -# 618| r0_12(String) = Call : r0_11 -# 618| m0_13(String) = Store : r0_10, r0_12 -# 619| r0_14(glval) = VariableAddress[s4] : -# 619| r0_15(glval) = FunctionAddress[String] : -# 619| r0_16(glval) = StringConstant["test"] : -# 619| r0_17(char *) = Convert : r0_16 -# 619| v0_18(void) = Call : r0_15, this:r0_14, r0_17 -# 620| v0_19(void) = NoOp : -# 615| v0_20(void) = ReturnVoid : -# 615| v0_21(void) = UnmodeledUse : mu* -# 615| v0_22(void) = ExitFunction : +# 615| mu0_1(unknown) = AliasedDefinition : +# 615| mu0_2(unknown) = UnmodeledDefinition : +# 616| r0_3(glval) = VariableAddress[s1] : +# 616| r0_4(glval) = FunctionAddress[String] : +# 616| v0_5(void) = Call : r0_4, this:r0_3 +# 616| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 617| r0_7(glval) = VariableAddress[s2] : +# 617| r0_8(glval) = FunctionAddress[String] : +# 617| r0_9(glval) = StringConstant["hello"] : +# 617| r0_10(char *) = Convert : r0_9 +# 617| v0_11(void) = Call : r0_8, this:r0_7, r0_10 +# 617| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 618| r0_13(glval) = VariableAddress[s3] : +# 618| r0_14(glval) = FunctionAddress[ReturnObject] : +# 618| r0_15(String) = Call : r0_14 +# 618| mu0_16(unknown) = ^CallSideEffect : mu0_2 +# 618| m0_17(String) = Store : r0_13, r0_15 +# 619| r0_18(glval) = VariableAddress[s4] : +# 619| r0_19(glval) = FunctionAddress[String] : +# 619| r0_20(glval) = StringConstant["test"] : +# 619| r0_21(char *) = Convert : r0_20 +# 619| v0_22(void) = Call : r0_19, this:r0_18, r0_21 +# 619| mu0_23(unknown) = ^CallSideEffect : mu0_2 +# 620| v0_24(void) = NoOp : +# 615| v0_25(void) = ReturnVoid : +# 615| v0_26(void) = UnmodeledUse : mu* +# 615| v0_27(void) = ExitFunction : # 622| CallMethods(String &, String *, String) -> void # 622| Block 0 # 622| v0_0(void) = EnterFunction : -# 622| mu0_1(unknown) = UnmodeledDefinition : -# 622| r0_2(glval) = VariableAddress[r] : -# 622| m0_3(String &) = InitializeParameter[r] : r0_2 -# 622| r0_4(glval) = VariableAddress[p] : -# 622| m0_5(String *) = InitializeParameter[p] : r0_4 -# 622| r0_6(glval) = VariableAddress[s] : -# 622| mu0_7(String) = InitializeParameter[s] : r0_6 -# 623| r0_8(glval) = VariableAddress[r] : -# 623| r0_9(String &) = Load : r0_8, m0_3 -# 623| r0_10(glval) = Convert : r0_9 -# 623| r0_11(glval) = FunctionAddress[c_str] : -# 623| r0_12(char *) = Call : r0_11, this:r0_10 -# 624| r0_13(glval) = VariableAddress[p] : -# 624| r0_14(String *) = Load : r0_13, m0_5 -# 624| r0_15(String *) = Convert : r0_14 -# 624| r0_16(glval) = FunctionAddress[c_str] : -# 624| r0_17(char *) = Call : r0_16, this:r0_15 -# 625| r0_18(glval) = VariableAddress[s] : -# 625| r0_19(glval) = Convert : r0_18 -# 625| r0_20(glval) = FunctionAddress[c_str] : -# 625| r0_21(char *) = Call : r0_20, this:r0_19 -# 626| v0_22(void) = NoOp : -# 622| v0_23(void) = ReturnVoid : -# 622| v0_24(void) = UnmodeledUse : mu* -# 622| v0_25(void) = ExitFunction : +# 622| mu0_1(unknown) = AliasedDefinition : +# 622| mu0_2(unknown) = UnmodeledDefinition : +# 622| r0_3(glval) = VariableAddress[r] : +# 622| m0_4(String &) = InitializeParameter[r] : r0_3 +# 622| r0_5(glval) = VariableAddress[p] : +# 622| m0_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, m0_4 +# 623| r0_11(glval) = Convert : r0_10 +# 623| r0_12(glval) = FunctionAddress[c_str] : +# 623| r0_13(char *) = Call : r0_12, this:r0_11 +# 623| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 624| r0_15(glval) = VariableAddress[p] : +# 624| r0_16(String *) = Load : r0_15, m0_6 +# 624| r0_17(String *) = Convert : r0_16 +# 624| r0_18(glval) = FunctionAddress[c_str] : +# 624| r0_19(char *) = Call : r0_18, this:r0_17 +# 624| mu0_20(unknown) = ^CallSideEffect : mu0_2 +# 625| r0_21(glval) = VariableAddress[s] : +# 625| r0_22(glval) = Convert : r0_21 +# 625| r0_23(glval) = FunctionAddress[c_str] : +# 625| r0_24(char *) = Call : r0_23, this:r0_22 +# 625| mu0_25(unknown) = ^CallSideEffect : mu0_2 +# 626| v0_26(void) = NoOp : +# 622| v0_27(void) = ReturnVoid : +# 622| v0_28(void) = UnmodeledUse : mu* +# 622| v0_29(void) = ExitFunction : # 630| C::StaticMemberFunction(int) -> int # 630| Block 0 # 630| v0_0(void) = EnterFunction : -# 630| mu0_1(unknown) = UnmodeledDefinition : -# 630| r0_2(glval) = VariableAddress[x] : -# 630| m0_3(int) = InitializeParameter[x] : r0_2 -# 631| r0_4(glval) = VariableAddress[#return] : -# 631| r0_5(glval) = VariableAddress[x] : -# 631| r0_6(int) = Load : r0_5, m0_3 -# 631| m0_7(int) = Store : r0_4, r0_6 -# 630| r0_8(glval) = VariableAddress[#return] : -# 630| v0_9(void) = ReturnValue : r0_8, m0_7 -# 630| v0_10(void) = UnmodeledUse : mu* -# 630| v0_11(void) = ExitFunction : +# 630| mu0_1(unknown) = AliasedDefinition : +# 630| mu0_2(unknown) = UnmodeledDefinition : +# 630| r0_3(glval) = VariableAddress[x] : +# 630| m0_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, m0_4 +# 631| m0_8(int) = Store : r0_5, r0_7 +# 630| r0_9(glval) = VariableAddress[#return] : +# 630| v0_10(void) = ReturnValue : r0_9, m0_8 +# 630| v0_11(void) = UnmodeledUse : mu* +# 630| v0_12(void) = ExitFunction : # 634| C::InstanceMemberFunction(int) -> int # 634| Block 0 -# 634| v0_0(void) = EnterFunction : -# 634| mu0_1(unknown) = UnmodeledDefinition : -# 634| r0_2(glval) = InitializeThis : -# 634| r0_3(glval) = VariableAddress[x] : -# 634| m0_4(int) = InitializeParameter[x] : r0_3 -# 635| r0_5(glval) = VariableAddress[#return] : -# 635| r0_6(glval) = VariableAddress[x] : -# 635| r0_7(int) = Load : r0_6, m0_4 -# 635| m0_8(int) = Store : r0_5, r0_7 -# 634| r0_9(glval) = VariableAddress[#return] : -# 634| v0_10(void) = ReturnValue : r0_9, m0_8 -# 634| v0_11(void) = UnmodeledUse : mu* -# 634| v0_12(void) = ExitFunction : +# 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| m0_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, m0_5 +# 635| m0_9(int) = Store : r0_6, r0_8 +# 634| r0_10(glval) = VariableAddress[#return] : +# 634| v0_11(void) = ReturnValue : r0_10, m0_9 +# 634| v0_12(void) = UnmodeledUse : mu* +# 634| v0_13(void) = ExitFunction : # 638| C::VirtualMemberFunction(int) -> int # 638| Block 0 -# 638| v0_0(void) = EnterFunction : -# 638| mu0_1(unknown) = UnmodeledDefinition : -# 638| r0_2(glval) = InitializeThis : -# 638| r0_3(glval) = VariableAddress[x] : -# 638| m0_4(int) = InitializeParameter[x] : r0_3 -# 639| r0_5(glval) = VariableAddress[#return] : -# 639| r0_6(glval) = VariableAddress[x] : -# 639| r0_7(int) = Load : r0_6, m0_4 -# 639| m0_8(int) = Store : r0_5, r0_7 -# 638| r0_9(glval) = VariableAddress[#return] : -# 638| v0_10(void) = ReturnValue : r0_9, m0_8 -# 638| v0_11(void) = UnmodeledUse : mu* -# 638| v0_12(void) = ExitFunction : +# 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| m0_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, m0_5 +# 639| m0_9(int) = Store : r0_6, r0_8 +# 638| r0_10(glval) = VariableAddress[#return] : +# 638| v0_11(void) = ReturnValue : r0_10, m0_9 +# 638| v0_12(void) = UnmodeledUse : mu* +# 638| v0_13(void) = ExitFunction : # 642| C::FieldAccess() -> void # 642| Block 0 # 642| v0_0(void) = EnterFunction : -# 642| mu0_1(unknown) = UnmodeledDefinition : -# 642| r0_2(glval) = InitializeThis : -# 643| r0_3(int) = Constant[0] : -# 643| r0_4(C *) = CopyValue : r0_2 -# 643| r0_5(glval) = FieldAddress[m_a] : r0_4 -# 643| mu0_6(int) = Store : r0_5, r0_3 -# 644| r0_7(int) = Constant[1] : -# 644| r0_8(C *) = CopyValue : r0_2 -# 644| r0_9(glval) = FieldAddress[m_a] : r0_8 -# 644| mu0_10(int) = Store : r0_9, r0_7 -# 645| r0_11(int) = Constant[2] : -#-----| r0_12(C *) = CopyValue : r0_2 -# 645| r0_13(glval) = FieldAddress[m_a] : r0_12 -# 645| mu0_14(int) = Store : r0_13, r0_11 -# 646| r0_15(glval) = VariableAddress[x] : -# 646| m0_16(int) = Uninitialized : r0_15 -# 647| r0_17(C *) = CopyValue : r0_2 -# 647| r0_18(glval) = FieldAddress[m_a] : r0_17 -# 647| r0_19(int) = Load : r0_18, mu0_1 -# 647| r0_20(glval) = VariableAddress[x] : -# 647| m0_21(int) = Store : r0_20, r0_19 -# 648| r0_22(C *) = CopyValue : r0_2 -# 648| r0_23(glval) = FieldAddress[m_a] : r0_22 -# 648| r0_24(int) = Load : r0_23, mu0_1 -# 648| r0_25(glval) = VariableAddress[x] : -# 648| m0_26(int) = Store : r0_25, r0_24 -#-----| r0_27(C *) = CopyValue : r0_2 -# 649| r0_28(glval) = FieldAddress[m_a] : r0_27 -# 649| r0_29(int) = Load : r0_28, mu0_1 -# 649| r0_30(glval) = VariableAddress[x] : -# 649| m0_31(int) = Store : r0_30, r0_29 -# 650| v0_32(void) = NoOp : -# 642| v0_33(void) = ReturnVoid : -# 642| v0_34(void) = UnmodeledUse : mu* -# 642| v0_35(void) = ExitFunction : +# 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) = FieldAddress[m_a] : r0_9 +# 644| mu0_11(int) = Store : r0_10, r0_8 +# 645| r0_12(int) = Constant[2] : +#-----| r0_13(C *) = CopyValue : r0_3 +# 645| r0_14(glval) = FieldAddress[m_a] : r0_13 +# 645| mu0_15(int) = Store : r0_14, r0_12 +# 646| r0_16(glval) = VariableAddress[x] : +# 646| m0_17(int) = Uninitialized : r0_16 +# 647| r0_18(C *) = CopyValue : r0_3 +# 647| r0_19(glval) = FieldAddress[m_a] : r0_18 +# 647| r0_20(int) = Load : r0_19, mu0_2 +# 647| r0_21(glval) = VariableAddress[x] : +# 647| m0_22(int) = Store : r0_21, r0_20 +# 648| r0_23(C *) = CopyValue : r0_3 +# 648| r0_24(glval) = FieldAddress[m_a] : r0_23 +# 648| r0_25(int) = Load : r0_24, mu0_2 +# 648| r0_26(glval) = VariableAddress[x] : +# 648| m0_27(int) = Store : r0_26, r0_25 +#-----| r0_28(C *) = CopyValue : r0_3 +# 649| r0_29(glval) = FieldAddress[m_a] : r0_28 +# 649| r0_30(int) = Load : r0_29, mu0_2 +# 649| r0_31(glval) = VariableAddress[x] : +# 649| m0_32(int) = Store : r0_31, r0_30 +# 650| v0_33(void) = NoOp : +# 642| v0_34(void) = ReturnVoid : +# 642| v0_35(void) = UnmodeledUse : mu* +# 642| v0_36(void) = ExitFunction : # 652| C::MethodCalls() -> void # 652| Block 0 # 652| v0_0(void) = EnterFunction : -# 652| mu0_1(unknown) = UnmodeledDefinition : -# 652| r0_2(glval) = InitializeThis : -# 653| r0_3(C *) = CopyValue : r0_2 -# 653| r0_4(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r0_5(int) = Constant[0] : -# 653| r0_6(int) = Call : r0_4, this:r0_3, r0_5 -# 654| r0_7(C *) = CopyValue : r0_2 -# 654| r0_8(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r0_9(int) = Constant[1] : -# 654| r0_10(int) = Call : r0_8, this:r0_7, r0_9 -#-----| r0_11(C *) = CopyValue : r0_2 -# 655| r0_12(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r0_13(int) = Constant[2] : -# 655| r0_14(int) = Call : r0_12, this:r0_11, r0_13 -# 656| v0_15(void) = NoOp : -# 652| v0_16(void) = ReturnVoid : -# 652| v0_17(void) = UnmodeledUse : mu* -# 652| v0_18(void) = ExitFunction : +# 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 : r0_5, this:r0_4, r0_6 +# 653| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 654| r0_9(C *) = CopyValue : r0_3 +# 654| r0_10(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r0_11(int) = Constant[1] : +# 654| r0_12(int) = Call : r0_10, this:r0_9, r0_11 +# 654| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(C *) = CopyValue : r0_3 +# 655| r0_15(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r0_16(int) = Constant[2] : +# 655| r0_17(int) = Call : r0_15, this:r0_14, r0_16 +# 655| mu0_18(unknown) = ^CallSideEffect : mu0_2 +# 656| v0_19(void) = NoOp : +# 652| v0_20(void) = ReturnVoid : +# 652| v0_21(void) = UnmodeledUse : mu* +# 652| v0_22(void) = ExitFunction : # 658| C::C() -> void # 658| Block 0 # 658| v0_0(void) = EnterFunction : -# 658| mu0_1(unknown) = UnmodeledDefinition : -# 658| r0_2(glval) = InitializeThis : -# 659| r0_3(glval) = FieldAddress[m_a] : r0_2 -# 659| r0_4(int) = Constant[1] : -# 659| mu0_5(int) = Store : r0_3, r0_4 -# 663| r0_6(glval) = FieldAddress[m_b] : r0_2 -# 663| r0_7(glval) = FunctionAddress[String] : -# 663| v0_8(void) = Call : r0_7, this:r0_6 -# 660| r0_9(glval) = FieldAddress[m_c] : r0_2 -# 660| r0_10(char) = Constant[3] : -# 660| mu0_11(char) = Store : r0_9, r0_10 -# 661| r0_12(glval) = FieldAddress[m_e] : r0_2 -# 661| r0_13(void *) = Constant[0] : -# 661| mu0_14(void *) = Store : r0_12, r0_13 -# 662| r0_15(glval) = FieldAddress[m_f] : r0_2 -# 662| r0_16(glval) = FunctionAddress[String] : -# 662| r0_17(glval) = StringConstant["test"] : -# 662| r0_18(char *) = Convert : r0_17 -# 662| v0_19(void) = Call : r0_16, this:r0_15, r0_18 -# 664| v0_20(void) = NoOp : -# 658| v0_21(void) = ReturnVoid : -# 658| v0_22(void) = UnmodeledUse : mu* -# 658| v0_23(void) = ExitFunction : +# 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 : r0_8, this:r0_7 +# 663| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 660| r0_11(glval) = FieldAddress[m_c] : r0_3 +# 660| r0_12(char) = Constant[3] : +# 660| mu0_13(char) = Store : r0_11, r0_12 +# 661| r0_14(glval) = FieldAddress[m_e] : r0_3 +# 661| r0_15(void *) = Constant[0] : +# 661| mu0_16(void *) = Store : r0_14, r0_15 +# 662| r0_17(glval) = FieldAddress[m_f] : r0_3 +# 662| r0_18(glval) = FunctionAddress[String] : +# 662| r0_19(glval) = StringConstant["test"] : +# 662| r0_20(char *) = Convert : r0_19 +# 662| v0_21(void) = Call : r0_18, this:r0_17, r0_20 +# 662| mu0_22(unknown) = ^CallSideEffect : mu0_2 +# 664| v0_23(void) = NoOp : +# 658| v0_24(void) = ReturnVoid : +# 658| v0_25(void) = UnmodeledUse : mu* +# 658| v0_26(void) = ExitFunction : # 675| DerefReference(int &) -> int # 675| Block 0 # 675| v0_0(void) = EnterFunction : -# 675| mu0_1(unknown) = UnmodeledDefinition : -# 675| r0_2(glval) = VariableAddress[r] : -# 675| m0_3(int &) = InitializeParameter[r] : r0_2 -# 676| r0_4(glval) = VariableAddress[#return] : -# 676| r0_5(glval) = VariableAddress[r] : -# 676| r0_6(int &) = Load : r0_5, m0_3 -# 676| r0_7(int) = Load : r0_6, mu0_1 -# 676| m0_8(int) = Store : r0_4, r0_7 -# 675| r0_9(glval) = VariableAddress[#return] : -# 675| v0_10(void) = ReturnValue : r0_9, m0_8 -# 675| v0_11(void) = UnmodeledUse : mu* -# 675| v0_12(void) = ExitFunction : +# 675| mu0_1(unknown) = AliasedDefinition : +# 675| mu0_2(unknown) = UnmodeledDefinition : +# 675| r0_3(glval) = VariableAddress[r] : +# 675| m0_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, m0_4 +# 676| r0_8(int) = Load : r0_7, mu0_2 +# 676| m0_9(int) = Store : r0_5, r0_8 +# 675| r0_10(glval) = VariableAddress[#return] : +# 675| v0_11(void) = ReturnValue : r0_10, m0_9 +# 675| v0_12(void) = UnmodeledUse : mu* +# 675| v0_13(void) = ExitFunction : # 679| TakeReference() -> int & # 679| Block 0 # 679| v0_0(void) = EnterFunction : -# 679| mu0_1(unknown) = UnmodeledDefinition : -# 680| r0_2(glval) = VariableAddress[#return] : -# 680| r0_3(glval) = VariableAddress[g] : -# 680| m0_4(int &) = Store : r0_2, r0_3 -# 679| r0_5(glval) = VariableAddress[#return] : -# 679| v0_6(void) = ReturnValue : r0_5, m0_4 -# 679| v0_7(void) = UnmodeledUse : mu* -# 679| v0_8(void) = ExitFunction : +# 679| mu0_1(unknown) = AliasedDefinition : +# 679| mu0_2(unknown) = UnmodeledDefinition : +# 680| r0_3(glval) = VariableAddress[#return] : +# 680| r0_4(glval) = VariableAddress[g] : +# 680| m0_5(int &) = Store : r0_3, r0_4 +# 679| r0_6(glval) = VariableAddress[#return] : +# 679| v0_7(void) = ReturnValue : r0_6, m0_5 +# 679| v0_8(void) = UnmodeledUse : mu* +# 679| v0_9(void) = ExitFunction : # 685| InitReference(int) -> void # 685| Block 0 # 685| v0_0(void) = EnterFunction : -# 685| mu0_1(unknown) = UnmodeledDefinition : -# 685| r0_2(glval) = VariableAddress[x] : -# 685| mu0_3(int) = InitializeParameter[x] : r0_2 -# 686| r0_4(glval) = VariableAddress[r] : -# 686| r0_5(glval) = VariableAddress[x] : -# 686| m0_6(int &) = Store : r0_4, r0_5 -# 687| r0_7(glval) = VariableAddress[r2] : -# 687| r0_8(glval) = VariableAddress[r] : -# 687| r0_9(int &) = Load : r0_8, m0_6 -# 687| m0_10(int &) = Store : r0_7, r0_9 -# 688| r0_11(glval) = VariableAddress[r3] : -# 688| r0_12(glval) = FunctionAddress[ReturnReference] : -# 688| r0_13(String &) = Call : r0_12 -# 688| r0_14(glval) = Convert : r0_13 -# 688| m0_15(String &) = Store : r0_11, r0_14 -# 689| v0_16(void) = NoOp : -# 685| v0_17(void) = ReturnVoid : -# 685| v0_18(void) = UnmodeledUse : mu* -# 685| v0_19(void) = ExitFunction : +# 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| m0_7(int &) = Store : r0_5, r0_6 +# 687| r0_8(glval) = VariableAddress[r2] : +# 687| r0_9(glval) = VariableAddress[r] : +# 687| r0_10(int &) = Load : r0_9, m0_7 +# 687| m0_11(int &) = Store : r0_8, r0_10 +# 688| r0_12(glval) = VariableAddress[r3] : +# 688| r0_13(glval) = FunctionAddress[ReturnReference] : +# 688| r0_14(String &) = Call : r0_13 +# 688| mu0_15(unknown) = ^CallSideEffect : mu0_2 +# 688| r0_16(glval) = Convert : r0_14 +# 688| m0_17(String &) = Store : r0_12, r0_16 +# 689| v0_18(void) = NoOp : +# 685| v0_19(void) = ReturnVoid : +# 685| v0_20(void) = UnmodeledUse : mu* +# 685| v0_21(void) = ExitFunction : # 691| ArrayReferences() -> void # 691| Block 0 # 691| v0_0(void) = EnterFunction : -# 691| mu0_1(unknown) = UnmodeledDefinition : -# 692| r0_2(glval) = VariableAddress[a] : -# 692| mu0_3(int[10]) = Uninitialized : r0_2 -# 693| r0_4(glval) = VariableAddress[ra] : -# 693| r0_5(glval) = VariableAddress[a] : -# 693| m0_6(int(&)[10]) = Store : r0_4, r0_5 -# 694| r0_7(glval) = VariableAddress[x] : -# 694| r0_8(glval) = VariableAddress[ra] : -# 694| r0_9(int(&)[10]) = Load : r0_8, m0_6 -# 694| r0_10(int *) = Convert : r0_9 -# 694| r0_11(int) = Constant[5] : -# 694| r0_12(int *) = PointerAdd[4] : r0_10, r0_11 -# 694| r0_13(int) = Load : r0_12, mu0_1 -# 694| m0_14(int) = Store : r0_7, r0_13 -# 695| v0_15(void) = NoOp : -# 691| v0_16(void) = ReturnVoid : -# 691| v0_17(void) = UnmodeledUse : mu* -# 691| v0_18(void) = ExitFunction : +# 691| mu0_1(unknown) = AliasedDefinition : +# 691| mu0_2(unknown) = UnmodeledDefinition : +# 692| r0_3(glval) = VariableAddress[a] : +# 692| mu0_4(int[10]) = Uninitialized : r0_3 +# 693| r0_5(glval) = VariableAddress[ra] : +# 693| r0_6(glval) = VariableAddress[a] : +# 693| m0_7(int(&)[10]) = Store : r0_5, r0_6 +# 694| r0_8(glval) = VariableAddress[x] : +# 694| r0_9(glval) = VariableAddress[ra] : +# 694| r0_10(int(&)[10]) = Load : r0_9, m0_7 +# 694| r0_11(int *) = Convert : r0_10 +# 694| r0_12(int) = Constant[5] : +# 694| r0_13(int *) = PointerAdd[4] : r0_11, r0_12 +# 694| r0_14(int) = Load : r0_13, mu0_2 +# 694| m0_15(int) = Store : r0_8, r0_14 +# 695| v0_16(void) = NoOp : +# 691| v0_17(void) = ReturnVoid : +# 691| v0_18(void) = UnmodeledUse : mu* +# 691| v0_19(void) = ExitFunction : # 697| FunctionReferences() -> void # 697| Block 0 -# 697| v0_0(void) = EnterFunction : -# 697| mu0_1(unknown) = UnmodeledDefinition : -# 698| r0_2(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r0_3(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| m0_4(..(&)(..)) = Store : r0_2, r0_3 -# 699| r0_5(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r0_6(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r0_7(..(&)(..)) = Load : r0_6, m0_4 -# 699| m0_8(..(*)(..)) = Store : r0_5, r0_7 -# 700| r0_9(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r0_10(..(&)(..)) = Load : r0_9, m0_4 -# 700| r0_11(int) = Constant[5] : -# 700| r0_12(int) = Call : r0_10, r0_11 -# 701| v0_13(void) = NoOp : -# 697| v0_14(void) = ReturnVoid : -# 697| v0_15(void) = UnmodeledUse : mu* -# 697| v0_16(void) = ExitFunction : +# 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| m0_5(..(&)(..)) = Store : r0_3, r0_4 +# 699| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r0_7(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r0_8(..(&)(..)) = Load : r0_7, m0_5 +# 699| m0_9(..(*)(..)) = Store : r0_6, r0_8 +# 700| r0_10(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r0_11(..(&)(..)) = Load : r0_10, m0_5 +# 700| r0_12(int) = Constant[5] : +# 700| r0_13(int) = Call : r0_11, r0_12 +# 700| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 701| v0_15(void) = NoOp : +# 697| v0_16(void) = ReturnVoid : +# 697| v0_17(void) = UnmodeledUse : mu* +# 697| v0_18(void) = ExitFunction : # 704| min(int, int) -> int # 704| Block 0 -# 704| v0_0(void) = EnterFunction : -# 704| mu0_1(unknown) = UnmodeledDefinition : -# 704| r0_2(glval) = VariableAddress[x] : -# 704| m0_3(int) = InitializeParameter[x] : r0_2 -# 704| r0_4(glval) = VariableAddress[y] : -# 704| m0_5(int) = InitializeParameter[y] : r0_4 -# 705| r0_6(glval) = VariableAddress[#return] : -# 705| r0_7(glval) = VariableAddress[x] : -# 705| r0_8(int) = Load : r0_7, m0_3 -# 705| r0_9(glval) = VariableAddress[y] : -# 705| r0_10(int) = Load : r0_9, m0_5 -# 705| r0_11(bool) = CompareLT : r0_8, r0_10 -# 705| v0_12(void) = ConditionalBranch : r0_11 +# 704| v0_0(void) = EnterFunction : +# 704| mu0_1(unknown) = AliasedDefinition : +# 704| mu0_2(unknown) = UnmodeledDefinition : +# 704| r0_3(glval) = VariableAddress[x] : +# 704| m0_4(int) = InitializeParameter[x] : r0_3 +# 704| r0_5(glval) = VariableAddress[y] : +# 704| m0_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, m0_4 +# 705| r0_10(glval) = VariableAddress[y] : +# 705| r0_11(int) = Load : r0_10, m0_6 +# 705| r0_12(bool) = CompareLT : r0_9, r0_11 +# 705| v0_13(void) = ConditionalBranch : r0_12 #-----| False -> Block 2 #-----| True -> Block 1 # 705| Block 1 # 705| r1_0(glval) = VariableAddress[x] : -# 705| r1_1(int) = Load : r1_0, m0_3 +# 705| r1_1(int) = Load : r1_0, m0_4 # 705| r1_2(glval) = VariableAddress[#temp705:10] : # 705| m1_3(int) = Store : r1_2, r1_1 #-----| Goto -> Block 3 # 705| Block 2 # 705| r2_0(glval) = VariableAddress[y] : -# 705| r2_1(int) = Load : r2_0, m0_5 +# 705| r2_1(int) = Load : r2_0, m0_6 # 705| r2_2(glval) = VariableAddress[#temp705:10] : # 705| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 3 @@ -2932,7 +3032,7 @@ ir.cpp: # 705| m3_0(int) = Phi : from 1:m1_3, from 2:m2_3 # 705| r3_1(glval) = VariableAddress[#temp705:10] : # 705| r3_2(int) = Load : r3_1, m3_0 -# 705| m3_3(int) = Store : r0_6, r3_2 +# 705| m3_3(int) = Store : r0_7, r3_2 # 704| r3_4(glval) = VariableAddress[#return] : # 704| v3_5(void) = ReturnValue : r3_4, m3_3 # 704| v3_6(void) = UnmodeledUse : mu* @@ -2941,68 +3041,74 @@ ir.cpp: # 708| CallMin(int, int) -> int # 708| Block 0 # 708| v0_0(void) = EnterFunction : -# 708| mu0_1(unknown) = UnmodeledDefinition : -# 708| r0_2(glval) = VariableAddress[x] : -# 708| m0_3(int) = InitializeParameter[x] : r0_2 -# 708| r0_4(glval) = VariableAddress[y] : -# 708| m0_5(int) = InitializeParameter[y] : r0_4 -# 709| r0_6(glval) = VariableAddress[#return] : -# 709| r0_7(glval) = FunctionAddress[min] : -# 709| r0_8(glval) = VariableAddress[x] : -# 709| r0_9(int) = Load : r0_8, m0_3 -# 709| r0_10(glval) = VariableAddress[y] : -# 709| r0_11(int) = Load : r0_10, m0_5 -# 709| r0_12(int) = Call : r0_7, r0_9, r0_11 -# 709| m0_13(int) = Store : r0_6, r0_12 -# 708| r0_14(glval) = VariableAddress[#return] : -# 708| v0_15(void) = ReturnValue : r0_14, m0_13 -# 708| v0_16(void) = UnmodeledUse : mu* -# 708| v0_17(void) = ExitFunction : +# 708| mu0_1(unknown) = AliasedDefinition : +# 708| mu0_2(unknown) = UnmodeledDefinition : +# 708| r0_3(glval) = VariableAddress[x] : +# 708| m0_4(int) = InitializeParameter[x] : r0_3 +# 708| r0_5(glval) = VariableAddress[y] : +# 708| m0_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, m0_4 +# 709| r0_11(glval) = VariableAddress[y] : +# 709| r0_12(int) = Load : r0_11, m0_6 +# 709| r0_13(int) = Call : r0_8, r0_10, r0_12 +# 709| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 709| m0_15(int) = Store : r0_7, r0_13 +# 708| r0_16(glval) = VariableAddress[#return] : +# 708| v0_17(void) = ReturnValue : r0_16, m0_15 +# 708| v0_18(void) = UnmodeledUse : mu* +# 708| v0_19(void) = ExitFunction : # 715| Outer::Func(void *, char) -> long # 715| Block 0 # 715| v0_0(void) = EnterFunction : -# 715| mu0_1(unknown) = UnmodeledDefinition : -# 715| r0_2(glval) = VariableAddress[x] : -# 715| m0_3(void *) = InitializeParameter[x] : r0_2 -# 715| r0_4(glval) = VariableAddress[y] : -# 715| m0_5(char) = InitializeParameter[y] : r0_4 -# 716| r0_6(glval) = VariableAddress[#return] : -# 716| r0_7(long) = Constant[0] : -# 716| m0_8(long) = Store : r0_6, r0_7 -# 715| r0_9(glval) = VariableAddress[#return] : -# 715| v0_10(void) = ReturnValue : r0_9, m0_8 -# 715| v0_11(void) = UnmodeledUse : mu* -# 715| v0_12(void) = ExitFunction : +# 715| mu0_1(unknown) = AliasedDefinition : +# 715| mu0_2(unknown) = UnmodeledDefinition : +# 715| r0_3(glval) = VariableAddress[x] : +# 715| m0_4(void *) = InitializeParameter[x] : r0_3 +# 715| r0_5(glval) = VariableAddress[y] : +# 715| m0_6(char) = InitializeParameter[y] : r0_5 +# 716| r0_7(glval) = VariableAddress[#return] : +# 716| r0_8(long) = Constant[0] : +# 716| m0_9(long) = Store : r0_7, r0_8 +# 715| r0_10(glval) = VariableAddress[#return] : +# 715| v0_11(void) = ReturnValue : r0_10, m0_9 +# 715| v0_12(void) = UnmodeledUse : mu* +# 715| v0_13(void) = ExitFunction : # 720| CallNestedTemplateFunc() -> double # 720| Block 0 # 720| v0_0(void) = EnterFunction : -# 720| mu0_1(unknown) = UnmodeledDefinition : -# 721| r0_2(glval) = VariableAddress[#return] : -# 721| r0_3(glval) = FunctionAddress[Func] : -# 721| r0_4(void *) = Constant[0] : -# 721| r0_5(char) = Constant[111] : -# 721| r0_6(long) = Call : r0_3, r0_4, r0_5 -# 721| r0_7(double) = Convert : r0_6 -# 721| m0_8(double) = Store : r0_2, r0_7 -# 720| r0_9(glval) = VariableAddress[#return] : -# 720| v0_10(void) = ReturnValue : r0_9, m0_8 -# 720| v0_11(void) = UnmodeledUse : mu* -# 720| v0_12(void) = ExitFunction : +# 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 : r0_4, r0_5, r0_6 +# 721| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 721| r0_9(double) = Convert : r0_7 +# 721| m0_10(double) = Store : r0_3, r0_9 +# 720| r0_11(glval) = VariableAddress[#return] : +# 720| v0_12(void) = ReturnValue : r0_11, m0_10 +# 720| v0_13(void) = UnmodeledUse : mu* +# 720| v0_14(void) = ExitFunction : # 724| TryCatch(bool) -> void # 724| Block 0 # 724| v0_0(void) = EnterFunction : -# 724| mu0_1(unknown) = UnmodeledDefinition : -# 724| r0_2(glval) = VariableAddress[b] : -# 724| m0_3(bool) = InitializeParameter[b] : r0_2 -# 726| r0_4(glval) = VariableAddress[x] : -# 726| r0_5(int) = Constant[5] : -# 726| m0_6(int) = Store : r0_4, r0_5 -# 727| r0_7(glval) = VariableAddress[b] : -# 727| r0_8(bool) = Load : r0_7, m0_3 -# 727| v0_9(void) = ConditionalBranch : r0_8 +# 724| mu0_1(unknown) = AliasedDefinition : +# 724| mu0_2(unknown) = UnmodeledDefinition : +# 724| r0_3(glval) = VariableAddress[b] : +# 724| m0_4(bool) = InitializeParameter[b] : r0_3 +# 726| r0_5(glval) = VariableAddress[x] : +# 726| r0_6(int) = Constant[5] : +# 726| m0_7(int) = Store : r0_5, r0_6 +# 727| r0_8(glval) = VariableAddress[b] : +# 727| r0_9(bool) = Load : r0_8, m0_4 +# 727| v0_10(void) = ConditionalBranch : r0_9 #-----| False -> Block 4 #-----| True -> Block 3 @@ -3024,7 +3130,7 @@ ir.cpp: # 730| Block 4 # 730| r4_0(glval) = VariableAddress[x] : -# 730| r4_1(int) = Load : r4_0, m0_6 +# 730| r4_1(int) = Load : r4_0, m0_7 # 730| r4_2(int) = Constant[2] : # 730| r4_3(bool) = CompareLT : r4_1, r4_2 # 730| v4_4(void) = ConditionalBranch : r4_3 @@ -3033,7 +3139,7 @@ ir.cpp: # 731| Block 5 # 731| r5_0(glval) = VariableAddress[b] : -# 731| r5_1(bool) = Load : r5_0, m0_3 +# 731| r5_1(bool) = Load : r5_0, m0_4 # 731| v5_2(void) = ConditionalBranch : r5_1 #-----| False -> Block 7 #-----| True -> Block 6 @@ -3054,7 +3160,8 @@ ir.cpp: # 731| r7_2(glval) = StringConstant["String object"] : # 731| r7_3(char *) = Convert : r7_2 # 731| v7_4(void) = Call : r7_1, this:r7_0, r7_3 -# 731| v7_5(void) = ThrowValue : r7_0, mu0_1 +# 731| mu7_5(unknown) = ^CallSideEffect : mu0_2 +# 731| v7_6(void) = ThrowValue : r7_0, mu0_2 #-----| Exception -> Block 9 # 733| Block 8 @@ -3076,7 +3183,8 @@ ir.cpp: # 736| r10_4(glval) = VariableAddress[s] : # 736| r10_5(char *) = Load : r10_4, m10_1 # 736| v10_6(void) = Call : r10_3, this:r10_2, r10_5 -# 736| v10_7(void) = ThrowValue : r10_2, mu0_1 +# 736| mu10_7(unknown) = ^CallSideEffect : mu0_2 +# 736| v10_8(void) = ThrowValue : r10_2, mu0_2 #-----| Exception -> Block 2 # 738| Block 11 @@ -3103,721 +3211,802 @@ ir.cpp: # 745| Base::Base(const Base &) -> void # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Base &) = InitializeParameter[p#0] : r0_3 -# 745| r0_5(glval) = FieldAddress[base_s] : r0_2 -# 745| r0_6(glval) = FunctionAddress[String] : -# 745| v0_7(void) = Call : r0_6, this:r0_5 -# 745| v0_8(void) = NoOp : -# 745| v0_9(void) = ReturnVoid : -# 745| v0_10(void) = UnmodeledUse : mu* -# 745| v0_11(void) = ExitFunction : +# 745| mu0_1(unknown) = AliasedDefinition : +# 745| mu0_2(unknown) = UnmodeledDefinition : +# 745| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_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 : r0_7, this:r0_6 +# 745| mu0_9(unknown) = ^CallSideEffect : mu0_2 +# 745| v0_10(void) = NoOp : +# 745| v0_11(void) = ReturnVoid : +# 745| v0_12(void) = UnmodeledUse : mu* +# 745| v0_13(void) = ExitFunction : # 745| Base::operator=(const Base &) -> Base & # 745| Block 0 # 745| v0_0(void) = EnterFunction : -# 745| mu0_1(unknown) = UnmodeledDefinition : -# 745| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Base &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Base *) = CopyValue : r0_2 -#-----| r0_6(glval) = FieldAddress[base_s] : r0_5 -# 745| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Base &) = Load : r0_8, m0_4 -#-----| r0_10(glval) = FieldAddress[base_s] : r0_9 -# 745| r0_11(String &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(glval) = VariableAddress[#return] : -#-----| r0_13(Base *) = CopyValue : r0_2 -#-----| m0_14(Base &) = Store : r0_12, r0_13 -# 745| r0_15(glval) = VariableAddress[#return] : -# 745| v0_16(void) = ReturnValue : r0_15, m0_14 -# 745| v0_17(void) = UnmodeledUse : mu* -# 745| v0_18(void) = ExitFunction : +# 745| mu0_1(unknown) = AliasedDefinition : +# 745| mu0_2(unknown) = UnmodeledDefinition : +# 745| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Base &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Base *) = CopyValue : r0_3 +#-----| r0_7(glval) = FieldAddress[base_s] : r0_6 +# 745| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Base &) = Load : r0_9, m0_5 +#-----| r0_11(glval) = FieldAddress[base_s] : r0_10 +# 745| r0_12(String &) = Call : r0_8, this:r0_7, r0_11 +# 745| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(glval) = VariableAddress[#return] : +#-----| r0_15(Base *) = CopyValue : r0_3 +#-----| m0_16(Base &) = Store : r0_14, r0_15 +# 745| r0_17(glval) = VariableAddress[#return] : +# 745| v0_18(void) = ReturnValue : r0_17, m0_16 +# 745| v0_19(void) = UnmodeledUse : mu* +# 745| v0_20(void) = ExitFunction : # 748| Base::Base() -> void # 748| Block 0 # 748| v0_0(void) = EnterFunction : -# 748| mu0_1(unknown) = UnmodeledDefinition : -# 748| r0_2(glval) = InitializeThis : -# 748| r0_3(glval) = FieldAddress[base_s] : r0_2 -# 748| r0_4(glval) = FunctionAddress[String] : -# 748| v0_5(void) = Call : r0_4, this:r0_3 -# 749| v0_6(void) = NoOp : -# 748| v0_7(void) = ReturnVoid : -# 748| v0_8(void) = UnmodeledUse : mu* -# 748| v0_9(void) = ExitFunction : +# 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 : r0_5, this:r0_4 +# 748| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 749| v0_8(void) = NoOp : +# 748| v0_9(void) = ReturnVoid : +# 748| v0_10(void) = UnmodeledUse : mu* +# 748| v0_11(void) = ExitFunction : # 750| Base::~Base() -> void # 750| Block 0 # 750| v0_0(void) = EnterFunction : -# 750| mu0_1(unknown) = UnmodeledDefinition : -# 750| r0_2(glval) = InitializeThis : -# 751| v0_3(void) = NoOp : -# 751| r0_4(glval) = FieldAddress[base_s] : r0_2 -# 751| r0_5(glval) = FunctionAddress[~String] : -# 751| v0_6(void) = Call : r0_5, this:r0_4 -# 750| v0_7(void) = ReturnVoid : -# 750| v0_8(void) = UnmodeledUse : mu* -# 750| v0_9(void) = ExitFunction : +# 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 : 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) = ExitFunction : # 754| Middle::operator=(const Middle &) -> Middle & # 754| Block 0 # 754| v0_0(void) = EnterFunction : -# 754| mu0_1(unknown) = UnmodeledDefinition : -# 754| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Middle &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Middle *) = CopyValue : r0_2 -#-----| r0_6(Base *) = ConvertToBase[Middle : Base] : r0_5 -# 754| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Middle &) = Load : r0_8, m0_4 -#-----| r0_10(Base *) = ConvertToBase[Middle : Base] : r0_9 -# 754| r0_11(Base &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Middle *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[middle_s] : r0_12 -# 754| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Middle &) = Load : r0_15, m0_4 -#-----| r0_17(glval) = FieldAddress[middle_s] : r0_16 -# 754| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Middle *) = CopyValue : r0_2 -#-----| m0_21(Middle &) = Store : r0_19, r0_20 -# 754| r0_22(glval) = VariableAddress[#return] : -# 754| v0_23(void) = ReturnValue : r0_22, m0_21 -# 754| v0_24(void) = UnmodeledUse : mu* -# 754| v0_25(void) = ExitFunction : +# 754| mu0_1(unknown) = AliasedDefinition : +# 754| mu0_2(unknown) = UnmodeledDefinition : +# 754| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Middle &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Middle *) = CopyValue : r0_3 +#-----| r0_7(Base *) = ConvertToBase[Middle : Base] : r0_6 +# 754| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Middle &) = Load : r0_9, m0_5 +#-----| r0_11(Base *) = ConvertToBase[Middle : Base] : r0_10 +# 754| r0_12(Base &) = Call : r0_8, this:r0_7, r0_11 +# 754| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(Middle *) = CopyValue : r0_3 +#-----| r0_15(glval) = FieldAddress[middle_s] : r0_14 +# 754| r0_16(glval) = FunctionAddress[operator=] : +#-----| r0_17(glval) = VariableAddress[p#0] : +#-----| r0_18(Middle &) = Load : r0_17, m0_5 +#-----| r0_19(glval) = FieldAddress[middle_s] : r0_18 +# 754| r0_20(String &) = Call : r0_16, this:r0_15, r0_19 +# 754| mu0_21(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_22(glval) = VariableAddress[#return] : +#-----| r0_23(Middle *) = CopyValue : r0_3 +#-----| m0_24(Middle &) = Store : r0_22, r0_23 +# 754| r0_25(glval) = VariableAddress[#return] : +# 754| v0_26(void) = ReturnValue : r0_25, m0_24 +# 754| v0_27(void) = UnmodeledUse : mu* +# 754| v0_28(void) = ExitFunction : # 757| Middle::Middle() -> void # 757| Block 0 # 757| v0_0(void) = EnterFunction : -# 757| mu0_1(unknown) = UnmodeledDefinition : -# 757| r0_2(glval) = InitializeThis : -# 757| r0_3(glval) = ConvertToBase[Middle : Base] : r0_2 -# 757| r0_4(glval) = FunctionAddress[Base] : -# 757| v0_5(void) = Call : r0_4, this:r0_3 -# 757| r0_6(glval) = FieldAddress[middle_s] : r0_2 -# 757| r0_7(glval) = FunctionAddress[String] : -# 757| v0_8(void) = Call : r0_7, this:r0_6 -# 758| v0_9(void) = NoOp : -# 757| v0_10(void) = ReturnVoid : -# 757| v0_11(void) = UnmodeledUse : mu* -# 757| v0_12(void) = ExitFunction : +# 757| mu0_1(unknown) = AliasedDefinition : +# 757| mu0_2(unknown) = UnmodeledDefinition : +# 757| r0_3(glval) = InitializeThis : +# 757| r0_4(glval) = ConvertToBase[Middle : Base] : r0_3 +# 757| r0_5(glval) = FunctionAddress[Base] : +# 757| v0_6(void) = Call : r0_5, this:r0_4 +# 757| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 757| r0_8(glval) = FieldAddress[middle_s] : r0_3 +# 757| r0_9(glval) = FunctionAddress[String] : +# 757| v0_10(void) = Call : r0_9, this:r0_8 +# 757| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 758| v0_12(void) = NoOp : +# 757| v0_13(void) = ReturnVoid : +# 757| v0_14(void) = UnmodeledUse : mu* +# 757| v0_15(void) = ExitFunction : # 759| Middle::~Middle() -> void # 759| Block 0 -# 759| v0_0(void) = EnterFunction : -# 759| mu0_1(unknown) = UnmodeledDefinition : -# 759| r0_2(glval) = InitializeThis : -# 760| v0_3(void) = NoOp : -# 760| r0_4(glval) = FieldAddress[middle_s] : r0_2 -# 760| r0_5(glval) = FunctionAddress[~String] : -# 760| v0_6(void) = Call : r0_5, this:r0_4 -# 760| r0_7(glval) = ConvertToBase[Middle : Base] : r0_2 -# 760| r0_8(glval) = FunctionAddress[~Base] : -# 760| v0_9(void) = Call : r0_8, this:r0_7 -# 759| v0_10(void) = ReturnVoid : -# 759| v0_11(void) = UnmodeledUse : mu* -# 759| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 760| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 760| r0_9(glval) = ConvertToBase[Middle : Base] : r0_3 +# 760| r0_10(glval) = FunctionAddress[~Base] : +# 760| v0_11(void) = Call : 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) = ExitFunction : # 763| Derived::operator=(const Derived &) -> Derived & # 763| Block 0 # 763| v0_0(void) = EnterFunction : -# 763| mu0_1(unknown) = UnmodeledDefinition : -# 763| r0_2(glval) = InitializeThis : -#-----| r0_3(glval) = VariableAddress[p#0] : -#-----| m0_4(Derived &) = InitializeParameter[p#0] : r0_3 -#-----| r0_5(Derived *) = CopyValue : r0_2 -#-----| r0_6(Middle *) = ConvertToBase[Derived : Middle] : r0_5 -# 763| r0_7(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Derived &) = Load : r0_8, m0_4 -#-----| r0_10(Middle *) = ConvertToBase[Derived : Middle] : r0_9 -# 763| r0_11(Middle &) = Call : r0_7, this:r0_6, r0_10 -#-----| r0_12(Derived *) = CopyValue : r0_2 -#-----| r0_13(glval) = FieldAddress[derived_s] : r0_12 -# 763| r0_14(glval) = FunctionAddress[operator=] : -#-----| r0_15(glval) = VariableAddress[p#0] : -#-----| r0_16(Derived &) = Load : r0_15, m0_4 -#-----| r0_17(glval) = FieldAddress[derived_s] : r0_16 -# 763| r0_18(String &) = Call : r0_14, this:r0_13, r0_17 -#-----| r0_19(glval) = VariableAddress[#return] : -#-----| r0_20(Derived *) = CopyValue : r0_2 -#-----| m0_21(Derived &) = Store : r0_19, r0_20 -# 763| r0_22(glval) = VariableAddress[#return] : -# 763| v0_23(void) = ReturnValue : r0_22, m0_21 -# 763| v0_24(void) = UnmodeledUse : mu* -# 763| v0_25(void) = ExitFunction : +# 763| mu0_1(unknown) = AliasedDefinition : +# 763| mu0_2(unknown) = UnmodeledDefinition : +# 763| r0_3(glval) = InitializeThis : +#-----| r0_4(glval) = VariableAddress[p#0] : +#-----| m0_5(Derived &) = InitializeParameter[p#0] : r0_4 +#-----| r0_6(Derived *) = CopyValue : r0_3 +#-----| r0_7(Middle *) = ConvertToBase[Derived : Middle] : r0_6 +# 763| r0_8(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Derived &) = Load : r0_9, m0_5 +#-----| r0_11(Middle *) = ConvertToBase[Derived : Middle] : r0_10 +# 763| r0_12(Middle &) = Call : r0_8, this:r0_7, r0_11 +# 763| mu0_13(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_14(Derived *) = CopyValue : r0_3 +#-----| r0_15(glval) = FieldAddress[derived_s] : r0_14 +# 763| r0_16(glval) = FunctionAddress[operator=] : +#-----| r0_17(glval) = VariableAddress[p#0] : +#-----| r0_18(Derived &) = Load : r0_17, m0_5 +#-----| r0_19(glval) = FieldAddress[derived_s] : r0_18 +# 763| r0_20(String &) = Call : r0_16, this:r0_15, r0_19 +# 763| mu0_21(unknown) = ^CallSideEffect : mu0_2 +#-----| r0_22(glval) = VariableAddress[#return] : +#-----| r0_23(Derived *) = CopyValue : r0_3 +#-----| m0_24(Derived &) = Store : r0_22, r0_23 +# 763| r0_25(glval) = VariableAddress[#return] : +# 763| v0_26(void) = ReturnValue : r0_25, m0_24 +# 763| v0_27(void) = UnmodeledUse : mu* +# 763| v0_28(void) = ExitFunction : # 766| Derived::Derived() -> void # 766| Block 0 # 766| v0_0(void) = EnterFunction : -# 766| mu0_1(unknown) = UnmodeledDefinition : -# 766| r0_2(glval) = InitializeThis : -# 766| r0_3(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 766| r0_4(glval) = FunctionAddress[Middle] : -# 766| v0_5(void) = Call : r0_4, this:r0_3 -# 766| r0_6(glval) = FieldAddress[derived_s] : r0_2 -# 766| r0_7(glval) = FunctionAddress[String] : -# 766| v0_8(void) = Call : r0_7, this:r0_6 -# 767| v0_9(void) = NoOp : -# 766| v0_10(void) = ReturnVoid : -# 766| v0_11(void) = UnmodeledUse : mu* -# 766| v0_12(void) = ExitFunction : +# 766| mu0_1(unknown) = AliasedDefinition : +# 766| mu0_2(unknown) = UnmodeledDefinition : +# 766| r0_3(glval) = InitializeThis : +# 766| r0_4(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 766| r0_5(glval) = FunctionAddress[Middle] : +# 766| v0_6(void) = Call : r0_5, this:r0_4 +# 766| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 766| r0_8(glval) = FieldAddress[derived_s] : r0_3 +# 766| r0_9(glval) = FunctionAddress[String] : +# 766| v0_10(void) = Call : r0_9, this:r0_8 +# 766| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 767| v0_12(void) = NoOp : +# 766| v0_13(void) = ReturnVoid : +# 766| v0_14(void) = UnmodeledUse : mu* +# 766| v0_15(void) = ExitFunction : # 768| Derived::~Derived() -> void # 768| Block 0 -# 768| v0_0(void) = EnterFunction : -# 768| mu0_1(unknown) = UnmodeledDefinition : -# 768| r0_2(glval) = InitializeThis : -# 769| v0_3(void) = NoOp : -# 769| r0_4(glval) = FieldAddress[derived_s] : r0_2 -# 769| r0_5(glval) = FunctionAddress[~String] : -# 769| v0_6(void) = Call : r0_5, this:r0_4 -# 769| r0_7(glval) = ConvertToBase[Derived : Middle] : r0_2 -# 769| r0_8(glval) = FunctionAddress[~Middle] : -# 769| v0_9(void) = Call : r0_8, this:r0_7 -# 768| v0_10(void) = ReturnVoid : -# 768| v0_11(void) = UnmodeledUse : mu* -# 768| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 769| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 769| r0_9(glval) = ConvertToBase[Derived : Middle] : r0_3 +# 769| r0_10(glval) = FunctionAddress[~Middle] : +# 769| v0_11(void) = Call : 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) = ExitFunction : # 775| MiddleVB1::MiddleVB1() -> void # 775| Block 0 # 775| v0_0(void) = EnterFunction : -# 775| mu0_1(unknown) = UnmodeledDefinition : -# 775| r0_2(glval) = InitializeThis : -# 775| r0_3(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 775| r0_4(glval) = FunctionAddress[Base] : -# 775| v0_5(void) = Call : r0_4, this:r0_3 -# 775| r0_6(glval) = FieldAddress[middlevb1_s] : r0_2 -# 775| r0_7(glval) = FunctionAddress[String] : -# 775| v0_8(void) = Call : r0_7, this:r0_6 -# 776| v0_9(void) = NoOp : -# 775| v0_10(void) = ReturnVoid : -# 775| v0_11(void) = UnmodeledUse : mu* -# 775| v0_12(void) = ExitFunction : +# 775| mu0_1(unknown) = AliasedDefinition : +# 775| mu0_2(unknown) = UnmodeledDefinition : +# 775| r0_3(glval) = InitializeThis : +# 775| r0_4(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 775| r0_5(glval) = FunctionAddress[Base] : +# 775| v0_6(void) = Call : r0_5, this:r0_4 +# 775| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 775| r0_8(glval) = FieldAddress[middlevb1_s] : r0_3 +# 775| r0_9(glval) = FunctionAddress[String] : +# 775| v0_10(void) = Call : r0_9, this:r0_8 +# 775| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 776| v0_12(void) = NoOp : +# 775| v0_13(void) = ReturnVoid : +# 775| v0_14(void) = UnmodeledUse : mu* +# 775| v0_15(void) = ExitFunction : # 777| MiddleVB1::~MiddleVB1() -> void # 777| Block 0 # 777| v0_0(void) = EnterFunction : -# 777| mu0_1(unknown) = UnmodeledDefinition : -# 777| r0_2(glval) = InitializeThis : -# 778| v0_3(void) = NoOp : -# 778| r0_4(glval) = FieldAddress[middlevb1_s] : r0_2 -# 778| r0_5(glval) = FunctionAddress[~String] : -# 778| v0_6(void) = Call : r0_5, this:r0_4 -# 778| r0_7(glval) = ConvertToBase[MiddleVB1 : Base] : r0_2 -# 778| r0_8(glval) = FunctionAddress[~Base] : -# 778| v0_9(void) = Call : r0_8, this:r0_7 -# 777| v0_10(void) = ReturnVoid : -# 777| v0_11(void) = UnmodeledUse : mu* -# 777| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 778| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 778| r0_9(glval) = ConvertToBase[MiddleVB1 : Base] : r0_3 +# 778| r0_10(glval) = FunctionAddress[~Base] : +# 778| v0_11(void) = Call : 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) = ExitFunction : # 784| MiddleVB2::MiddleVB2() -> void # 784| Block 0 # 784| v0_0(void) = EnterFunction : -# 784| mu0_1(unknown) = UnmodeledDefinition : -# 784| r0_2(glval) = InitializeThis : -# 784| r0_3(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 784| r0_4(glval) = FunctionAddress[Base] : -# 784| v0_5(void) = Call : r0_4, this:r0_3 -# 784| r0_6(glval) = FieldAddress[middlevb2_s] : r0_2 -# 784| r0_7(glval) = FunctionAddress[String] : -# 784| v0_8(void) = Call : r0_7, this:r0_6 -# 785| v0_9(void) = NoOp : -# 784| v0_10(void) = ReturnVoid : -# 784| v0_11(void) = UnmodeledUse : mu* -# 784| v0_12(void) = ExitFunction : +# 784| mu0_1(unknown) = AliasedDefinition : +# 784| mu0_2(unknown) = UnmodeledDefinition : +# 784| r0_3(glval) = InitializeThis : +# 784| r0_4(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 784| r0_5(glval) = FunctionAddress[Base] : +# 784| v0_6(void) = Call : r0_5, this:r0_4 +# 784| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 784| r0_8(glval) = FieldAddress[middlevb2_s] : r0_3 +# 784| r0_9(glval) = FunctionAddress[String] : +# 784| v0_10(void) = Call : r0_9, this:r0_8 +# 784| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 785| v0_12(void) = NoOp : +# 784| v0_13(void) = ReturnVoid : +# 784| v0_14(void) = UnmodeledUse : mu* +# 784| v0_15(void) = ExitFunction : # 786| MiddleVB2::~MiddleVB2() -> void # 786| Block 0 # 786| v0_0(void) = EnterFunction : -# 786| mu0_1(unknown) = UnmodeledDefinition : -# 786| r0_2(glval) = InitializeThis : -# 787| v0_3(void) = NoOp : -# 787| r0_4(glval) = FieldAddress[middlevb2_s] : r0_2 -# 787| r0_5(glval) = FunctionAddress[~String] : -# 787| v0_6(void) = Call : r0_5, this:r0_4 -# 787| r0_7(glval) = ConvertToBase[MiddleVB2 : Base] : r0_2 -# 787| r0_8(glval) = FunctionAddress[~Base] : -# 787| v0_9(void) = Call : r0_8, this:r0_7 -# 786| v0_10(void) = ReturnVoid : -# 786| v0_11(void) = UnmodeledUse : mu* -# 786| v0_12(void) = ExitFunction : +# 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 : r0_6, this:r0_5 +# 787| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 787| r0_9(glval) = ConvertToBase[MiddleVB2 : Base] : r0_3 +# 787| r0_10(glval) = FunctionAddress[~Base] : +# 787| v0_11(void) = Call : 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) = ExitFunction : # 793| DerivedVB::DerivedVB() -> void # 793| Block 0 -# 793| v0_0(void) = EnterFunction : -# 793| mu0_1(unknown) = UnmodeledDefinition : -# 793| r0_2(glval) = InitializeThis : -# 793| r0_3(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 793| r0_4(glval) = FunctionAddress[Base] : -# 793| v0_5(void) = Call : r0_4, this:r0_3 -# 793| r0_6(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 793| r0_7(glval) = FunctionAddress[MiddleVB1] : -# 793| v0_8(void) = Call : r0_7, this:r0_6 -# 793| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 793| r0_10(glval) = FunctionAddress[MiddleVB2] : -# 793| v0_11(void) = Call : r0_10, this:r0_9 -# 793| r0_12(glval) = FieldAddress[derivedvb_s] : r0_2 -# 793| r0_13(glval) = FunctionAddress[String] : -# 793| v0_14(void) = Call : r0_13, this:r0_12 -# 794| v0_15(void) = NoOp : -# 793| v0_16(void) = ReturnVoid : -# 793| v0_17(void) = UnmodeledUse : mu* -# 793| v0_18(void) = ExitFunction : +# 793| v0_0(void) = EnterFunction : +# 793| mu0_1(unknown) = AliasedDefinition : +# 793| mu0_2(unknown) = UnmodeledDefinition : +# 793| r0_3(glval) = InitializeThis : +# 793| r0_4(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 793| r0_5(glval) = FunctionAddress[Base] : +# 793| v0_6(void) = Call : r0_5, this:r0_4 +# 793| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_8(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 793| r0_9(glval) = FunctionAddress[MiddleVB1] : +# 793| v0_10(void) = Call : r0_9, this:r0_8 +# 793| mu0_11(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_12(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 793| r0_13(glval) = FunctionAddress[MiddleVB2] : +# 793| v0_14(void) = Call : r0_13, this:r0_12 +# 793| mu0_15(unknown) = ^CallSideEffect : mu0_2 +# 793| r0_16(glval) = FieldAddress[derivedvb_s] : r0_3 +# 793| r0_17(glval) = FunctionAddress[String] : +# 793| v0_18(void) = Call : r0_17, this:r0_16 +# 793| mu0_19(unknown) = ^CallSideEffect : mu0_2 +# 794| v0_20(void) = NoOp : +# 793| v0_21(void) = ReturnVoid : +# 793| v0_22(void) = UnmodeledUse : mu* +# 793| v0_23(void) = ExitFunction : # 795| DerivedVB::~DerivedVB() -> void # 795| Block 0 # 795| v0_0(void) = EnterFunction : -# 795| mu0_1(unknown) = UnmodeledDefinition : -# 795| r0_2(glval) = InitializeThis : -# 796| v0_3(void) = NoOp : -# 796| r0_4(glval) = FieldAddress[derivedvb_s] : r0_2 -# 796| r0_5(glval) = FunctionAddress[~String] : -# 796| v0_6(void) = Call : r0_5, this:r0_4 -# 796| r0_7(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_2 -# 796| r0_8(glval) = FunctionAddress[~MiddleVB2] : -# 796| v0_9(void) = Call : r0_8, this:r0_7 -# 796| r0_10(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_2 -# 796| r0_11(glval) = FunctionAddress[~MiddleVB1] : -# 796| v0_12(void) = Call : r0_11, this:r0_10 -# 796| r0_13(glval) = ConvertToBase[DerivedVB : Base] : r0_2 -# 796| r0_14(glval) = FunctionAddress[~Base] : +# 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 : r0_6, this:r0_5 +# 796| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_9(glval) = ConvertToBase[DerivedVB : MiddleVB2] : r0_3 +# 796| r0_10(glval) = FunctionAddress[~MiddleVB2] : +# 796| v0_11(void) = Call : r0_10, this:r0_9 +# 796| mu0_12(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_13(glval) = ConvertToBase[DerivedVB : MiddleVB1] : r0_3 +# 796| r0_14(glval) = FunctionAddress[~MiddleVB1] : # 796| v0_15(void) = Call : r0_14, this:r0_13 -# 795| v0_16(void) = ReturnVoid : -# 795| v0_17(void) = UnmodeledUse : mu* -# 795| v0_18(void) = ExitFunction : +# 796| mu0_16(unknown) = ^CallSideEffect : mu0_2 +# 796| r0_17(glval) = ConvertToBase[DerivedVB : Base] : r0_3 +# 796| r0_18(glval) = FunctionAddress[~Base] : +# 796| v0_19(void) = Call : 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) = ExitFunction : # 799| HierarchyConversions() -> void # 799| Block 0 # 799| v0_0(void) = EnterFunction : -# 799| mu0_1(unknown) = UnmodeledDefinition : -# 800| r0_2(glval) = VariableAddress[b] : -# 800| r0_3(glval) = FunctionAddress[Base] : -# 800| v0_4(void) = Call : r0_3, this:r0_2 -# 801| r0_5(glval) = VariableAddress[m] : -# 801| r0_6(glval) = FunctionAddress[Middle] : -# 801| v0_7(void) = Call : r0_6, this:r0_5 -# 802| r0_8(glval) = VariableAddress[d] : -# 802| r0_9(glval) = FunctionAddress[Derived] : -# 802| v0_10(void) = Call : r0_9, this:r0_8 -# 804| r0_11(glval) = VariableAddress[pb] : -# 804| r0_12(glval) = VariableAddress[b] : -# 804| m0_13(Base *) = Store : r0_11, r0_12 -# 805| r0_14(glval) = VariableAddress[pm] : -# 805| r0_15(glval) = VariableAddress[m] : -# 805| m0_16(Middle *) = Store : r0_14, r0_15 -# 806| r0_17(glval) = VariableAddress[pd] : -# 806| r0_18(glval) = VariableAddress[d] : -# 806| m0_19(Derived *) = Store : r0_17, r0_18 -# 808| r0_20(glval) = VariableAddress[b] : -# 808| r0_21(glval) = FunctionAddress[operator=] : -# 808| r0_22(glval) = VariableAddress[m] : -# 808| r0_23(glval) = ConvertToBase[Middle : Base] : r0_22 -# 808| r0_24(Base &) = Call : r0_21, this:r0_20, r0_23 -# 809| r0_25(glval) = VariableAddress[b] : -# 809| r0_26(glval) = FunctionAddress[operator=] : -# 809| r0_27(glval) = FunctionAddress[Base] : -# 809| r0_28(glval) = VariableAddress[m] : -# 809| r0_29(glval) = ConvertToBase[Middle : Base] : r0_28 -# 809| v0_30(void) = Call : r0_27, r0_29 -# 809| r0_31(Base) = Convert : v0_30 -# 809| r0_32(Base &) = Call : r0_26, this:r0_25, r0_31 -# 810| r0_33(glval) = VariableAddress[b] : -# 810| r0_34(glval) = FunctionAddress[operator=] : -# 810| r0_35(glval) = FunctionAddress[Base] : -# 810| r0_36(glval) = VariableAddress[m] : -# 810| r0_37(glval) = ConvertToBase[Middle : Base] : r0_36 -# 810| v0_38(void) = Call : r0_35, r0_37 -# 810| r0_39(Base) = Convert : v0_38 -# 810| r0_40(Base &) = Call : r0_34, this:r0_33, r0_39 -# 811| r0_41(glval) = VariableAddress[pm] : -# 811| r0_42(Middle *) = Load : r0_41, m0_16 -# 811| r0_43(Base *) = ConvertToBase[Middle : Base] : r0_42 -# 811| r0_44(glval) = VariableAddress[pb] : -# 811| m0_45(Base *) = Store : r0_44, r0_43 -# 812| r0_46(glval) = VariableAddress[pm] : -# 812| r0_47(Middle *) = Load : r0_46, m0_16 -# 812| r0_48(Base *) = ConvertToBase[Middle : Base] : r0_47 -# 812| r0_49(glval) = VariableAddress[pb] : -# 812| m0_50(Base *) = Store : r0_49, r0_48 -# 813| r0_51(glval) = VariableAddress[pm] : -# 813| r0_52(Middle *) = Load : r0_51, m0_16 -# 813| r0_53(Base *) = ConvertToBase[Middle : Base] : r0_52 -# 813| r0_54(glval) = VariableAddress[pb] : -# 813| m0_55(Base *) = Store : r0_54, r0_53 -# 814| r0_56(glval) = VariableAddress[pm] : -# 814| r0_57(Middle *) = Load : r0_56, m0_16 -# 814| r0_58(Base *) = Convert : r0_57 -# 814| r0_59(glval) = VariableAddress[pb] : -# 814| m0_60(Base *) = Store : r0_59, r0_58 -# 816| r0_61(glval) = VariableAddress[m] : -# 816| r0_62(glval) = FunctionAddress[operator=] : -# 816| r0_63(glval) = VariableAddress[b] : -# 816| r0_64(glval) = ConvertToDerived[Middle : Base] : r0_63 -# 816| r0_65(glval) = Convert : r0_64 -# 816| r0_66(Middle &) = Call : r0_62, this:r0_61, r0_65 -# 817| r0_67(glval) = VariableAddress[m] : -# 817| r0_68(glval) = FunctionAddress[operator=] : -# 817| r0_69(glval) = VariableAddress[b] : -# 817| r0_70(glval) = ConvertToDerived[Middle : Base] : r0_69 -# 817| r0_71(glval) = Convert : r0_70 -# 817| r0_72(Middle &) = Call : r0_68, this:r0_67, r0_71 -# 818| r0_73(glval) = VariableAddress[pb] : -# 818| r0_74(Base *) = Load : r0_73, m0_60 -# 818| r0_75(Middle *) = ConvertToDerived[Middle : Base] : r0_74 -# 818| r0_76(glval) = VariableAddress[pm] : -# 818| m0_77(Middle *) = Store : r0_76, r0_75 -# 819| r0_78(glval) = VariableAddress[pb] : -# 819| r0_79(Base *) = Load : r0_78, m0_60 -# 819| r0_80(Middle *) = ConvertToDerived[Middle : Base] : r0_79 -# 819| r0_81(glval) = VariableAddress[pm] : -# 819| m0_82(Middle *) = Store : r0_81, r0_80 -# 820| r0_83(glval) = VariableAddress[pb] : -# 820| r0_84(Base *) = Load : r0_83, m0_60 -# 820| r0_85(Middle *) = Convert : r0_84 -# 820| r0_86(glval) = VariableAddress[pm] : -# 820| m0_87(Middle *) = Store : r0_86, r0_85 -# 822| r0_88(glval) = VariableAddress[b] : -# 822| r0_89(glval) = FunctionAddress[operator=] : -# 822| r0_90(glval) = VariableAddress[d] : -# 822| r0_91(glval) = ConvertToBase[Derived : Middle] : r0_90 -# 822| r0_92(glval) = ConvertToBase[Middle : Base] : r0_91 -# 822| r0_93(Base &) = Call : r0_89, this:r0_88, r0_92 -# 823| r0_94(glval) = VariableAddress[b] : -# 823| r0_95(glval) = FunctionAddress[operator=] : -# 823| r0_96(glval) = FunctionAddress[Base] : -# 823| r0_97(glval) = VariableAddress[d] : -# 823| r0_98(glval) = ConvertToBase[Derived : Middle] : r0_97 -# 823| r0_99(glval) = ConvertToBase[Middle : Base] : r0_98 -# 823| v0_100(void) = Call : r0_96, r0_99 -# 823| r0_101(Base) = Convert : v0_100 -# 823| r0_102(Base &) = Call : r0_95, this:r0_94, r0_101 -# 824| r0_103(glval) = VariableAddress[b] : -# 824| r0_104(glval) = FunctionAddress[operator=] : -# 824| r0_105(glval) = FunctionAddress[Base] : -# 824| r0_106(glval) = VariableAddress[d] : -# 824| r0_107(glval) = ConvertToBase[Derived : Middle] : r0_106 -# 824| r0_108(glval) = ConvertToBase[Middle : Base] : r0_107 -# 824| v0_109(void) = Call : r0_105, r0_108 -# 824| r0_110(Base) = Convert : v0_109 -# 824| r0_111(Base &) = Call : r0_104, this:r0_103, r0_110 -# 825| r0_112(glval) = VariableAddress[pd] : -# 825| r0_113(Derived *) = Load : r0_112, m0_19 -# 825| r0_114(Middle *) = ConvertToBase[Derived : Middle] : r0_113 -# 825| r0_115(Base *) = ConvertToBase[Middle : Base] : r0_114 -# 825| r0_116(glval) = VariableAddress[pb] : -# 825| m0_117(Base *) = Store : r0_116, r0_115 -# 826| r0_118(glval) = VariableAddress[pd] : -# 826| r0_119(Derived *) = Load : r0_118, m0_19 -# 826| r0_120(Middle *) = ConvertToBase[Derived : Middle] : r0_119 -# 826| r0_121(Base *) = ConvertToBase[Middle : Base] : r0_120 -# 826| r0_122(glval) = VariableAddress[pb] : -# 826| m0_123(Base *) = Store : r0_122, r0_121 -# 827| r0_124(glval) = VariableAddress[pd] : -# 827| r0_125(Derived *) = Load : r0_124, m0_19 -# 827| r0_126(Middle *) = ConvertToBase[Derived : Middle] : r0_125 -# 827| r0_127(Base *) = ConvertToBase[Middle : Base] : r0_126 -# 827| r0_128(glval) = VariableAddress[pb] : -# 827| m0_129(Base *) = Store : r0_128, r0_127 -# 828| r0_130(glval) = VariableAddress[pd] : -# 828| r0_131(Derived *) = Load : r0_130, m0_19 -# 828| r0_132(Base *) = Convert : r0_131 -# 828| r0_133(glval) = VariableAddress[pb] : -# 828| m0_134(Base *) = Store : r0_133, r0_132 -# 830| r0_135(glval) = VariableAddress[d] : -# 830| r0_136(glval) = FunctionAddress[operator=] : -# 830| r0_137(glval) = VariableAddress[b] : -# 830| r0_138(glval) = ConvertToDerived[Middle : Base] : r0_137 -# 830| r0_139(glval) = ConvertToDerived[Derived : Middle] : r0_138 -# 830| r0_140(glval) = Convert : r0_139 -# 830| r0_141(Derived &) = Call : r0_136, this:r0_135, r0_140 -# 831| r0_142(glval) = VariableAddress[d] : -# 831| r0_143(glval) = FunctionAddress[operator=] : -# 831| r0_144(glval) = VariableAddress[b] : -# 831| r0_145(glval) = ConvertToDerived[Middle : Base] : r0_144 -# 831| r0_146(glval) = ConvertToDerived[Derived : Middle] : r0_145 -# 831| r0_147(glval) = Convert : r0_146 -# 831| r0_148(Derived &) = Call : r0_143, this:r0_142, r0_147 -# 832| r0_149(glval) = VariableAddress[pb] : -# 832| r0_150(Base *) = Load : r0_149, m0_134 -# 832| r0_151(Middle *) = ConvertToDerived[Middle : Base] : r0_150 -# 832| r0_152(Derived *) = ConvertToDerived[Derived : Middle] : r0_151 -# 832| r0_153(glval) = VariableAddress[pd] : -# 832| m0_154(Derived *) = Store : r0_153, r0_152 -# 833| r0_155(glval) = VariableAddress[pb] : -# 833| r0_156(Base *) = Load : r0_155, m0_134 -# 833| r0_157(Middle *) = ConvertToDerived[Middle : Base] : r0_156 -# 833| r0_158(Derived *) = ConvertToDerived[Derived : Middle] : r0_157 -# 833| r0_159(glval) = VariableAddress[pd] : -# 833| m0_160(Derived *) = Store : r0_159, r0_158 -# 834| r0_161(glval) = VariableAddress[pb] : -# 834| r0_162(Base *) = Load : r0_161, m0_134 -# 834| r0_163(Derived *) = Convert : r0_162 -# 834| r0_164(glval) = VariableAddress[pd] : -# 834| m0_165(Derived *) = Store : r0_164, r0_163 -# 836| r0_166(glval) = VariableAddress[pmv] : -# 836| r0_167(MiddleVB1 *) = Constant[0] : -# 836| m0_168(MiddleVB1 *) = Store : r0_166, r0_167 -# 837| r0_169(glval) = VariableAddress[pdv] : -# 837| r0_170(DerivedVB *) = Constant[0] : -# 837| m0_171(DerivedVB *) = Store : r0_169, r0_170 -# 838| r0_172(glval) = VariableAddress[pmv] : -# 838| r0_173(MiddleVB1 *) = Load : r0_172, m0_168 -# 838| r0_174(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_173 -# 838| r0_175(glval) = VariableAddress[pb] : -# 838| m0_176(Base *) = Store : r0_175, r0_174 -# 839| r0_177(glval) = VariableAddress[pdv] : -# 839| r0_178(DerivedVB *) = Load : r0_177, m0_171 -# 839| r0_179(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_178 -# 839| r0_180(glval) = VariableAddress[pb] : -# 839| m0_181(Base *) = Store : r0_180, r0_179 -# 840| v0_182(void) = NoOp : -# 799| v0_183(void) = ReturnVoid : -# 799| v0_184(void) = UnmodeledUse : mu* -# 799| v0_185(void) = ExitFunction : +# 799| mu0_1(unknown) = AliasedDefinition : +# 799| mu0_2(unknown) = UnmodeledDefinition : +# 800| r0_3(glval) = VariableAddress[b] : +# 800| r0_4(glval) = FunctionAddress[Base] : +# 800| v0_5(void) = Call : r0_4, this:r0_3 +# 800| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 801| r0_7(glval) = VariableAddress[m] : +# 801| r0_8(glval) = FunctionAddress[Middle] : +# 801| v0_9(void) = Call : r0_8, this:r0_7 +# 801| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 802| r0_11(glval) = VariableAddress[d] : +# 802| r0_12(glval) = FunctionAddress[Derived] : +# 802| v0_13(void) = Call : r0_12, this:r0_11 +# 802| mu0_14(unknown) = ^CallSideEffect : mu0_2 +# 804| r0_15(glval) = VariableAddress[pb] : +# 804| r0_16(glval) = VariableAddress[b] : +# 804| m0_17(Base *) = Store : r0_15, r0_16 +# 805| r0_18(glval) = VariableAddress[pm] : +# 805| r0_19(glval) = VariableAddress[m] : +# 805| m0_20(Middle *) = Store : r0_18, r0_19 +# 806| r0_21(glval) = VariableAddress[pd] : +# 806| r0_22(glval) = VariableAddress[d] : +# 806| m0_23(Derived *) = Store : r0_21, r0_22 +# 808| r0_24(glval) = VariableAddress[b] : +# 808| r0_25(glval) = FunctionAddress[operator=] : +# 808| r0_26(glval) = VariableAddress[m] : +# 808| r0_27(glval) = ConvertToBase[Middle : Base] : r0_26 +# 808| r0_28(Base &) = Call : r0_25, this:r0_24, r0_27 +# 808| mu0_29(unknown) = ^CallSideEffect : mu0_2 +# 809| r0_30(glval) = VariableAddress[b] : +# 809| r0_31(glval) = FunctionAddress[operator=] : +# 809| r0_32(glval) = FunctionAddress[Base] : +# 809| r0_33(glval) = VariableAddress[m] : +# 809| r0_34(glval) = ConvertToBase[Middle : Base] : r0_33 +# 809| v0_35(void) = Call : r0_32, r0_34 +# 809| mu0_36(unknown) = ^CallSideEffect : mu0_2 +# 809| r0_37(Base) = Convert : v0_35 +# 809| r0_38(Base &) = Call : r0_31, this:r0_30, r0_37 +# 809| mu0_39(unknown) = ^CallSideEffect : mu0_2 +# 810| r0_40(glval) = VariableAddress[b] : +# 810| r0_41(glval) = FunctionAddress[operator=] : +# 810| r0_42(glval) = FunctionAddress[Base] : +# 810| r0_43(glval) = VariableAddress[m] : +# 810| r0_44(glval) = ConvertToBase[Middle : Base] : r0_43 +# 810| v0_45(void) = Call : r0_42, r0_44 +# 810| mu0_46(unknown) = ^CallSideEffect : mu0_2 +# 810| r0_47(Base) = Convert : v0_45 +# 810| r0_48(Base &) = Call : r0_41, this:r0_40, r0_47 +# 810| mu0_49(unknown) = ^CallSideEffect : mu0_2 +# 811| r0_50(glval) = VariableAddress[pm] : +# 811| r0_51(Middle *) = Load : r0_50, m0_20 +# 811| r0_52(Base *) = ConvertToBase[Middle : Base] : r0_51 +# 811| r0_53(glval) = VariableAddress[pb] : +# 811| m0_54(Base *) = Store : r0_53, r0_52 +# 812| r0_55(glval) = VariableAddress[pm] : +# 812| r0_56(Middle *) = Load : r0_55, m0_20 +# 812| r0_57(Base *) = ConvertToBase[Middle : Base] : r0_56 +# 812| r0_58(glval) = VariableAddress[pb] : +# 812| m0_59(Base *) = Store : r0_58, r0_57 +# 813| r0_60(glval) = VariableAddress[pm] : +# 813| r0_61(Middle *) = Load : r0_60, m0_20 +# 813| r0_62(Base *) = ConvertToBase[Middle : Base] : r0_61 +# 813| r0_63(glval) = VariableAddress[pb] : +# 813| m0_64(Base *) = Store : r0_63, r0_62 +# 814| r0_65(glval) = VariableAddress[pm] : +# 814| r0_66(Middle *) = Load : r0_65, m0_20 +# 814| r0_67(Base *) = Convert : r0_66 +# 814| r0_68(glval) = VariableAddress[pb] : +# 814| m0_69(Base *) = Store : r0_68, r0_67 +# 816| r0_70(glval) = VariableAddress[m] : +# 816| r0_71(glval) = FunctionAddress[operator=] : +# 816| r0_72(glval) = VariableAddress[b] : +# 816| r0_73(glval) = ConvertToDerived[Middle : Base] : r0_72 +# 816| r0_74(glval) = Convert : r0_73 +# 816| r0_75(Middle &) = Call : r0_71, this:r0_70, r0_74 +# 816| mu0_76(unknown) = ^CallSideEffect : mu0_2 +# 817| r0_77(glval) = VariableAddress[m] : +# 817| r0_78(glval) = FunctionAddress[operator=] : +# 817| r0_79(glval) = VariableAddress[b] : +# 817| r0_80(glval) = ConvertToDerived[Middle : Base] : r0_79 +# 817| r0_81(glval) = Convert : r0_80 +# 817| r0_82(Middle &) = Call : r0_78, this:r0_77, r0_81 +# 817| mu0_83(unknown) = ^CallSideEffect : mu0_2 +# 818| r0_84(glval) = VariableAddress[pb] : +# 818| r0_85(Base *) = Load : r0_84, m0_69 +# 818| r0_86(Middle *) = ConvertToDerived[Middle : Base] : r0_85 +# 818| r0_87(glval) = VariableAddress[pm] : +# 818| m0_88(Middle *) = Store : r0_87, r0_86 +# 819| r0_89(glval) = VariableAddress[pb] : +# 819| r0_90(Base *) = Load : r0_89, m0_69 +# 819| r0_91(Middle *) = ConvertToDerived[Middle : Base] : r0_90 +# 819| r0_92(glval) = VariableAddress[pm] : +# 819| m0_93(Middle *) = Store : r0_92, r0_91 +# 820| r0_94(glval) = VariableAddress[pb] : +# 820| r0_95(Base *) = Load : r0_94, m0_69 +# 820| r0_96(Middle *) = Convert : r0_95 +# 820| r0_97(glval) = VariableAddress[pm] : +# 820| m0_98(Middle *) = Store : r0_97, r0_96 +# 822| r0_99(glval) = VariableAddress[b] : +# 822| r0_100(glval) = FunctionAddress[operator=] : +# 822| r0_101(glval) = VariableAddress[d] : +# 822| r0_102(glval) = ConvertToBase[Derived : Middle] : r0_101 +# 822| r0_103(glval) = ConvertToBase[Middle : Base] : r0_102 +# 822| r0_104(Base &) = Call : r0_100, this:r0_99, r0_103 +# 822| mu0_105(unknown) = ^CallSideEffect : mu0_2 +# 823| r0_106(glval) = VariableAddress[b] : +# 823| r0_107(glval) = FunctionAddress[operator=] : +# 823| r0_108(glval) = FunctionAddress[Base] : +# 823| r0_109(glval) = VariableAddress[d] : +# 823| r0_110(glval) = ConvertToBase[Derived : Middle] : r0_109 +# 823| r0_111(glval) = ConvertToBase[Middle : Base] : r0_110 +# 823| v0_112(void) = Call : r0_108, r0_111 +# 823| mu0_113(unknown) = ^CallSideEffect : mu0_2 +# 823| r0_114(Base) = Convert : v0_112 +# 823| r0_115(Base &) = Call : r0_107, this:r0_106, r0_114 +# 823| mu0_116(unknown) = ^CallSideEffect : mu0_2 +# 824| r0_117(glval) = VariableAddress[b] : +# 824| r0_118(glval) = FunctionAddress[operator=] : +# 824| r0_119(glval) = FunctionAddress[Base] : +# 824| r0_120(glval) = VariableAddress[d] : +# 824| r0_121(glval) = ConvertToBase[Derived : Middle] : r0_120 +# 824| r0_122(glval) = ConvertToBase[Middle : Base] : r0_121 +# 824| v0_123(void) = Call : r0_119, r0_122 +# 824| mu0_124(unknown) = ^CallSideEffect : mu0_2 +# 824| r0_125(Base) = Convert : v0_123 +# 824| r0_126(Base &) = Call : r0_118, this:r0_117, r0_125 +# 824| mu0_127(unknown) = ^CallSideEffect : mu0_2 +# 825| r0_128(glval) = VariableAddress[pd] : +# 825| r0_129(Derived *) = Load : r0_128, m0_23 +# 825| r0_130(Middle *) = ConvertToBase[Derived : Middle] : r0_129 +# 825| r0_131(Base *) = ConvertToBase[Middle : Base] : r0_130 +# 825| r0_132(glval) = VariableAddress[pb] : +# 825| m0_133(Base *) = Store : r0_132, r0_131 +# 826| r0_134(glval) = VariableAddress[pd] : +# 826| r0_135(Derived *) = Load : r0_134, m0_23 +# 826| r0_136(Middle *) = ConvertToBase[Derived : Middle] : r0_135 +# 826| r0_137(Base *) = ConvertToBase[Middle : Base] : r0_136 +# 826| r0_138(glval) = VariableAddress[pb] : +# 826| m0_139(Base *) = Store : r0_138, r0_137 +# 827| r0_140(glval) = VariableAddress[pd] : +# 827| r0_141(Derived *) = Load : r0_140, m0_23 +# 827| r0_142(Middle *) = ConvertToBase[Derived : Middle] : r0_141 +# 827| r0_143(Base *) = ConvertToBase[Middle : Base] : r0_142 +# 827| r0_144(glval) = VariableAddress[pb] : +# 827| m0_145(Base *) = Store : r0_144, r0_143 +# 828| r0_146(glval) = VariableAddress[pd] : +# 828| r0_147(Derived *) = Load : r0_146, m0_23 +# 828| r0_148(Base *) = Convert : r0_147 +# 828| r0_149(glval) = VariableAddress[pb] : +# 828| m0_150(Base *) = Store : r0_149, r0_148 +# 830| r0_151(glval) = VariableAddress[d] : +# 830| r0_152(glval) = FunctionAddress[operator=] : +# 830| r0_153(glval) = VariableAddress[b] : +# 830| r0_154(glval) = ConvertToDerived[Middle : Base] : r0_153 +# 830| r0_155(glval) = ConvertToDerived[Derived : Middle] : r0_154 +# 830| r0_156(glval) = Convert : r0_155 +# 830| r0_157(Derived &) = Call : r0_152, this:r0_151, r0_156 +# 830| mu0_158(unknown) = ^CallSideEffect : mu0_2 +# 831| r0_159(glval) = VariableAddress[d] : +# 831| r0_160(glval) = FunctionAddress[operator=] : +# 831| r0_161(glval) = VariableAddress[b] : +# 831| r0_162(glval) = ConvertToDerived[Middle : Base] : r0_161 +# 831| r0_163(glval) = ConvertToDerived[Derived : Middle] : r0_162 +# 831| r0_164(glval) = Convert : r0_163 +# 831| r0_165(Derived &) = Call : r0_160, this:r0_159, r0_164 +# 831| mu0_166(unknown) = ^CallSideEffect : mu0_2 +# 832| r0_167(glval) = VariableAddress[pb] : +# 832| r0_168(Base *) = Load : r0_167, m0_150 +# 832| r0_169(Middle *) = ConvertToDerived[Middle : Base] : r0_168 +# 832| r0_170(Derived *) = ConvertToDerived[Derived : Middle] : r0_169 +# 832| r0_171(glval) = VariableAddress[pd] : +# 832| m0_172(Derived *) = Store : r0_171, r0_170 +# 833| r0_173(glval) = VariableAddress[pb] : +# 833| r0_174(Base *) = Load : r0_173, m0_150 +# 833| r0_175(Middle *) = ConvertToDerived[Middle : Base] : r0_174 +# 833| r0_176(Derived *) = ConvertToDerived[Derived : Middle] : r0_175 +# 833| r0_177(glval) = VariableAddress[pd] : +# 833| m0_178(Derived *) = Store : r0_177, r0_176 +# 834| r0_179(glval) = VariableAddress[pb] : +# 834| r0_180(Base *) = Load : r0_179, m0_150 +# 834| r0_181(Derived *) = Convert : r0_180 +# 834| r0_182(glval) = VariableAddress[pd] : +# 834| m0_183(Derived *) = Store : r0_182, r0_181 +# 836| r0_184(glval) = VariableAddress[pmv] : +# 836| r0_185(MiddleVB1 *) = Constant[0] : +# 836| m0_186(MiddleVB1 *) = Store : r0_184, r0_185 +# 837| r0_187(glval) = VariableAddress[pdv] : +# 837| r0_188(DerivedVB *) = Constant[0] : +# 837| m0_189(DerivedVB *) = Store : r0_187, r0_188 +# 838| r0_190(glval) = VariableAddress[pmv] : +# 838| r0_191(MiddleVB1 *) = Load : r0_190, m0_186 +# 838| r0_192(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_191 +# 838| r0_193(glval) = VariableAddress[pb] : +# 838| m0_194(Base *) = Store : r0_193, r0_192 +# 839| r0_195(glval) = VariableAddress[pdv] : +# 839| r0_196(DerivedVB *) = Load : r0_195, m0_189 +# 839| r0_197(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_196 +# 839| r0_198(glval) = VariableAddress[pb] : +# 839| m0_199(Base *) = Store : r0_198, r0_197 +# 840| v0_200(void) = NoOp : +# 799| v0_201(void) = ReturnVoid : +# 799| v0_202(void) = UnmodeledUse : mu* +# 799| v0_203(void) = ExitFunction : # 842| PolymorphicBase::PolymorphicBase() -> void # 842| Block 0 # 842| v0_0(void) = EnterFunction : -# 842| mu0_1(unknown) = UnmodeledDefinition : -# 842| r0_2(glval) = InitializeThis : -# 842| v0_3(void) = NoOp : -# 842| v0_4(void) = ReturnVoid : -# 842| v0_5(void) = UnmodeledUse : mu* -# 842| v0_6(void) = ExitFunction : +# 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) = ExitFunction : # 846| PolymorphicDerived::PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -# 846| r0_3(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_4(glval) = FunctionAddress[PolymorphicBase] : -# 846| v0_5(void) = Call : r0_4, this:r0_3 -# 846| v0_6(void) = NoOp : -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| mu0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_5(glval) = FunctionAddress[PolymorphicBase] : +# 846| v0_6(void) = Call : r0_5, this:r0_4 +# 846| mu0_7(unknown) = ^CallSideEffect : mu0_2 +# 846| v0_8(void) = NoOp : +# 846| v0_9(void) = ReturnVoid : +# 846| v0_10(void) = UnmodeledUse : mu* +# 846| v0_11(void) = ExitFunction : # 846| PolymorphicDerived::~PolymorphicDerived() -> void # 846| Block 0 # 846| v0_0(void) = EnterFunction : -# 846| mu0_1(unknown) = UnmodeledDefinition : -# 846| r0_2(glval) = InitializeThis : -#-----| v0_3(void) = NoOp : -# 846| r0_4(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_2 -# 846| r0_5(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v0_6(void) = Call : r0_5, this:r0_4 -# 846| v0_7(void) = ReturnVoid : -# 846| v0_8(void) = UnmodeledUse : mu* -# 846| v0_9(void) = ExitFunction : +# 846| mu0_1(unknown) = AliasedDefinition : +# 846| mu0_2(unknown) = UnmodeledDefinition : +# 846| r0_3(glval) = InitializeThis : +#-----| v0_4(void) = NoOp : +# 846| r0_5(glval) = ConvertToBase[PolymorphicDerived : PolymorphicBase] : r0_3 +# 846| r0_6(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v0_7(void) = Call : 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) = ExitFunction : # 849| DynamicCast() -> void # 849| Block 0 # 849| v0_0(void) = EnterFunction : -# 849| mu0_1(unknown) = UnmodeledDefinition : -# 850| r0_2(glval) = VariableAddress[b] : -#-----| r0_3(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_4(void) = Call : r0_3, this:r0_2 -# 851| r0_5(glval) = VariableAddress[d] : -# 851| r0_6(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v0_7(void) = Call : r0_6, this:r0_5 -# 853| r0_8(glval) = VariableAddress[pb] : -# 853| r0_9(glval) = VariableAddress[b] : -# 853| m0_10(PolymorphicBase *) = Store : r0_8, r0_9 -# 854| r0_11(glval) = VariableAddress[pd] : -# 854| r0_12(glval) = VariableAddress[d] : -# 854| m0_13(PolymorphicDerived *) = Store : r0_11, r0_12 -# 857| r0_14(glval) = VariableAddress[pd] : -# 857| r0_15(PolymorphicDerived *) = Load : r0_14, m0_13 -# 857| r0_16(PolymorphicBase *) = CheckedConvertOrNull : r0_15 -# 857| r0_17(glval) = VariableAddress[pb] : -# 857| m0_18(PolymorphicBase *) = Store : r0_17, r0_16 -# 858| r0_19(glval) = VariableAddress[rb] : -# 858| r0_20(glval) = VariableAddress[d] : -# 858| r0_21(glval) = CheckedConvertOrThrow : r0_20 -# 858| m0_22(PolymorphicBase &) = Store : r0_19, r0_21 -# 860| r0_23(glval) = VariableAddress[pb] : -# 860| r0_24(PolymorphicBase *) = Load : r0_23, m0_18 -# 860| r0_25(PolymorphicDerived *) = CheckedConvertOrNull : r0_24 -# 860| r0_26(glval) = VariableAddress[pd] : -# 860| m0_27(PolymorphicDerived *) = Store : r0_26, r0_25 -# 861| r0_28(glval) = VariableAddress[rd] : -# 861| r0_29(glval) = VariableAddress[b] : -# 861| r0_30(glval) = CheckedConvertOrThrow : r0_29 -# 861| m0_31(PolymorphicDerived &) = Store : r0_28, r0_30 -# 863| r0_32(glval) = VariableAddress[pv] : -# 863| r0_33(glval) = VariableAddress[pb] : -# 863| r0_34(PolymorphicBase *) = Load : r0_33, m0_18 -# 863| r0_35(void *) = DynamicCastToVoid : r0_34 -# 863| m0_36(void *) = Store : r0_32, r0_35 -# 864| r0_37(glval) = VariableAddress[pcv] : -# 864| r0_38(glval) = VariableAddress[pd] : -# 864| r0_39(PolymorphicDerived *) = Load : r0_38, m0_27 -# 864| r0_40(void *) = DynamicCastToVoid : r0_39 -# 864| m0_41(void *) = Store : r0_37, r0_40 -# 865| v0_42(void) = NoOp : -# 849| v0_43(void) = ReturnVoid : -# 849| v0_44(void) = UnmodeledUse : mu* -# 849| v0_45(void) = ExitFunction : +# 849| mu0_1(unknown) = AliasedDefinition : +# 849| mu0_2(unknown) = UnmodeledDefinition : +# 850| r0_3(glval) = VariableAddress[b] : +#-----| r0_4(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_5(void) = Call : r0_4, this:r0_3 +#-----| mu0_6(unknown) = ^CallSideEffect : mu0_2 +# 851| r0_7(glval) = VariableAddress[d] : +# 851| r0_8(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v0_9(void) = Call : r0_8, this:r0_7 +# 851| mu0_10(unknown) = ^CallSideEffect : mu0_2 +# 853| r0_11(glval) = VariableAddress[pb] : +# 853| r0_12(glval) = VariableAddress[b] : +# 853| m0_13(PolymorphicBase *) = Store : r0_11, r0_12 +# 854| r0_14(glval) = VariableAddress[pd] : +# 854| r0_15(glval) = VariableAddress[d] : +# 854| m0_16(PolymorphicDerived *) = Store : r0_14, r0_15 +# 857| r0_17(glval) = VariableAddress[pd] : +# 857| r0_18(PolymorphicDerived *) = Load : r0_17, m0_16 +# 857| r0_19(PolymorphicBase *) = CheckedConvertOrNull : r0_18 +# 857| r0_20(glval) = VariableAddress[pb] : +# 857| m0_21(PolymorphicBase *) = Store : r0_20, r0_19 +# 858| r0_22(glval) = VariableAddress[rb] : +# 858| r0_23(glval) = VariableAddress[d] : +# 858| r0_24(glval) = CheckedConvertOrThrow : r0_23 +# 858| m0_25(PolymorphicBase &) = Store : r0_22, r0_24 +# 860| r0_26(glval) = VariableAddress[pb] : +# 860| r0_27(PolymorphicBase *) = Load : r0_26, m0_21 +# 860| r0_28(PolymorphicDerived *) = CheckedConvertOrNull : r0_27 +# 860| r0_29(glval) = VariableAddress[pd] : +# 860| m0_30(PolymorphicDerived *) = Store : r0_29, r0_28 +# 861| r0_31(glval) = VariableAddress[rd] : +# 861| r0_32(glval) = VariableAddress[b] : +# 861| r0_33(glval) = CheckedConvertOrThrow : r0_32 +# 861| m0_34(PolymorphicDerived &) = Store : r0_31, r0_33 +# 863| r0_35(glval) = VariableAddress[pv] : +# 863| r0_36(glval) = VariableAddress[pb] : +# 863| r0_37(PolymorphicBase *) = Load : r0_36, m0_21 +# 863| r0_38(void *) = DynamicCastToVoid : r0_37 +# 863| m0_39(void *) = Store : r0_35, r0_38 +# 864| r0_40(glval) = VariableAddress[pcv] : +# 864| r0_41(glval) = VariableAddress[pd] : +# 864| r0_42(PolymorphicDerived *) = Load : r0_41, m0_30 +# 864| r0_43(void *) = DynamicCastToVoid : r0_42 +# 864| m0_44(void *) = Store : r0_40, r0_43 +# 865| v0_45(void) = NoOp : +# 849| v0_46(void) = ReturnVoid : +# 849| v0_47(void) = UnmodeledUse : mu* +# 849| v0_48(void) = ExitFunction : # 867| String::String() -> void # 867| Block 0 # 867| v0_0(void) = EnterFunction : -# 867| mu0_1(unknown) = UnmodeledDefinition : -# 867| r0_2(glval) = InitializeThis : -# 868| r0_3(glval) = FunctionAddress[String] : -# 868| r0_4(glval) = StringConstant[""] : -# 868| r0_5(char *) = Convert : r0_4 -# 868| v0_6(void) = Call : r0_3, this:r0_2, r0_5 -# 869| v0_7(void) = NoOp : -# 867| v0_8(void) = ReturnVoid : -# 867| v0_9(void) = UnmodeledUse : mu* -# 867| v0_10(void) = ExitFunction : +# 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 : r0_4, this:r0_3, r0_6 +# 868| mu0_8(unknown) = ^CallSideEffect : mu0_2 +# 869| v0_9(void) = NoOp : +# 867| v0_10(void) = ReturnVoid : +# 867| v0_11(void) = UnmodeledUse : mu* +# 867| v0_12(void) = ExitFunction : # 871| ArrayConversions() -> void # 871| Block 0 # 871| v0_0(void) = EnterFunction : -# 871| mu0_1(unknown) = UnmodeledDefinition : -# 872| r0_2(glval) = VariableAddress[a] : -# 872| mu0_3(char[5]) = Uninitialized : r0_2 -# 873| r0_4(glval) = VariableAddress[p] : -# 873| r0_5(glval) = VariableAddress[a] : -# 873| r0_6(char *) = Convert : r0_5 +# 871| mu0_1(unknown) = AliasedDefinition : +# 871| mu0_2(unknown) = UnmodeledDefinition : +# 872| r0_3(glval) = VariableAddress[a] : +# 872| mu0_4(char[5]) = Uninitialized : r0_3 +# 873| r0_5(glval) = VariableAddress[p] : +# 873| r0_6(glval) = VariableAddress[a] : # 873| r0_7(char *) = Convert : r0_6 -# 873| m0_8(char *) = Store : r0_4, r0_7 -# 874| r0_9(glval) = StringConstant["test"] : -# 874| r0_10(char *) = Convert : r0_9 -# 874| r0_11(glval) = VariableAddress[p] : -# 874| m0_12(char *) = Store : r0_11, r0_10 -# 875| r0_13(glval) = VariableAddress[a] : -# 875| r0_14(char *) = Convert : r0_13 -# 875| r0_15(int) = Constant[0] : -# 875| r0_16(char *) = PointerAdd[1] : r0_14, r0_15 -# 875| r0_17(char *) = Convert : r0_16 -# 875| r0_18(glval) = VariableAddress[p] : -# 875| m0_19(char *) = Store : r0_18, r0_17 -# 876| r0_20(glval) = StringConstant["test"] : -# 876| r0_21(char *) = Convert : r0_20 -# 876| r0_22(int) = Constant[0] : -# 876| r0_23(char *) = PointerAdd[1] : r0_21, r0_22 -# 876| r0_24(glval) = VariableAddress[p] : -# 876| m0_25(char *) = Store : r0_24, r0_23 -# 877| r0_26(glval) = VariableAddress[ra] : -# 877| r0_27(glval) = VariableAddress[a] : -# 877| m0_28(char(&)[5]) = Store : r0_26, r0_27 -# 878| r0_29(glval) = VariableAddress[rs] : -# 878| r0_30(glval) = StringConstant["test"] : -# 878| m0_31(char(&)[5]) = Store : r0_29, r0_30 -# 879| r0_32(glval) = VariableAddress[pa] : -# 879| r0_33(glval) = VariableAddress[a] : -# 879| r0_34(char(*)[5]) = Convert : r0_33 -# 879| m0_35(char(*)[5]) = Store : r0_32, r0_34 -# 880| r0_36(glval) = StringConstant["test"] : -# 880| r0_37(glval) = VariableAddress[pa] : -# 880| m0_38(char(*)[5]) = Store : r0_37, r0_36 -# 881| v0_39(void) = NoOp : -# 871| v0_40(void) = ReturnVoid : -# 871| v0_41(void) = UnmodeledUse : mu* -# 871| v0_42(void) = ExitFunction : +# 873| r0_8(char *) = Convert : r0_7 +# 873| m0_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| m0_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(char *) = PointerAdd[1] : r0_15, r0_16 +# 875| r0_18(char *) = Convert : r0_17 +# 875| r0_19(glval) = VariableAddress[p] : +# 875| m0_20(char *) = Store : r0_19, r0_18 +# 876| r0_21(glval) = StringConstant["test"] : +# 876| r0_22(char *) = Convert : r0_21 +# 876| r0_23(int) = Constant[0] : +# 876| r0_24(char *) = PointerAdd[1] : r0_22, r0_23 +# 876| r0_25(glval) = VariableAddress[p] : +# 876| m0_26(char *) = Store : r0_25, r0_24 +# 877| r0_27(glval) = VariableAddress[ra] : +# 877| r0_28(glval) = VariableAddress[a] : +# 877| m0_29(char(&)[5]) = Store : r0_27, r0_28 +# 878| r0_30(glval) = VariableAddress[rs] : +# 878| r0_31(glval) = StringConstant["test"] : +# 878| m0_32(char(&)[5]) = Store : r0_30, r0_31 +# 879| r0_33(glval) = VariableAddress[pa] : +# 879| r0_34(glval) = VariableAddress[a] : +# 879| r0_35(char(*)[5]) = Convert : r0_34 +# 879| m0_36(char(*)[5]) = Store : r0_33, r0_35 +# 880| r0_37(glval) = StringConstant["test"] : +# 880| r0_38(glval) = VariableAddress[pa] : +# 880| m0_39(char(*)[5]) = Store : r0_38, r0_37 +# 881| v0_40(void) = NoOp : +# 871| v0_41(void) = ReturnVoid : +# 871| v0_42(void) = UnmodeledUse : mu* +# 871| v0_43(void) = ExitFunction : # 883| FuncPtrConversions(..(*)(..), void *) -> void # 883| Block 0 # 883| v0_0(void) = EnterFunction : -# 883| mu0_1(unknown) = UnmodeledDefinition : -# 883| r0_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| m0_3(..(*)(..)) = InitializeParameter[pfn] : r0_2 -# 883| r0_4(glval) = VariableAddress[p] : -# 883| m0_5(void *) = InitializeParameter[p] : r0_4 -# 884| r0_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r0_7(..(*)(..)) = Load : r0_6, m0_3 -# 884| r0_8(void *) = Convert : r0_7 -# 884| r0_9(glval) = VariableAddress[p] : -# 884| m0_10(void *) = Store : r0_9, r0_8 -# 885| r0_11(glval) = VariableAddress[p] : -# 885| r0_12(void *) = Load : r0_11, m0_10 -# 885| r0_13(..(*)(..)) = Convert : r0_12 -# 885| r0_14(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| m0_15(..(*)(..)) = Store : r0_14, r0_13 -# 886| v0_16(void) = NoOp : -# 883| v0_17(void) = ReturnVoid : -# 883| v0_18(void) = UnmodeledUse : mu* -# 883| v0_19(void) = ExitFunction : +# 883| mu0_1(unknown) = AliasedDefinition : +# 883| mu0_2(unknown) = UnmodeledDefinition : +# 883| r0_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 883| m0_4(..(*)(..)) = InitializeParameter[pfn] : r0_3 +# 883| r0_5(glval) = VariableAddress[p] : +# 883| m0_6(void *) = InitializeParameter[p] : r0_5 +# 884| r0_7(glval<..(*)(..)>) = VariableAddress[pfn] : +# 884| r0_8(..(*)(..)) = Load : r0_7, m0_4 +# 884| r0_9(void *) = Convert : r0_8 +# 884| r0_10(glval) = VariableAddress[p] : +# 884| m0_11(void *) = Store : r0_10, r0_9 +# 885| r0_12(glval) = VariableAddress[p] : +# 885| r0_13(void *) = Load : r0_12, m0_11 +# 885| r0_14(..(*)(..)) = Convert : r0_13 +# 885| r0_15(glval<..(*)(..)>) = VariableAddress[pfn] : +# 885| m0_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) = ExitFunction : # 888| VarArgUsage(int) -> void # 888| Block 0 # 888| v0_0(void) = EnterFunction : -# 888| mu0_1(unknown) = UnmodeledDefinition : -# 888| r0_2(glval) = VariableAddress[x] : -# 888| mu0_3(int) = InitializeParameter[x] : r0_2 -# 889| r0_4(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| mu0_5(__va_list_tag[1]) = Uninitialized : r0_4 -# 891| r0_6(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r0_7(__va_list_tag *) = Convert : r0_6 -# 891| r0_8(glval) = VariableAddress[x] : -# 891| v0_9(void) = VarArgsStart : r0_7, r0_8 -# 892| r0_10(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| mu0_11(__va_list_tag[1]) = Uninitialized : r0_10 -# 893| r0_12(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r0_13(__va_list_tag *) = Convert : r0_12 -# 893| r0_14(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r0_15(__va_list_tag *) = Convert : r0_14 -# 893| v0_16(void) = VarArgsStart : r0_13, r0_15 -# 894| r0_17(glval) = VariableAddress[d] : -# 894| r0_18(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r0_19(__va_list_tag *) = Convert : r0_18 -# 894| r0_20(glval) = VarArg : r0_19 -# 894| r0_21(double) = Load : r0_20, mu0_1 -# 894| m0_22(double) = Store : r0_17, r0_21 -# 895| r0_23(glval) = VariableAddress[f] : -# 895| r0_24(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r0_25(__va_list_tag *) = Convert : r0_24 -# 895| r0_26(glval) = VarArg : r0_25 -# 895| r0_27(double) = Load : r0_26, mu0_1 -# 895| r0_28(float) = Convert : r0_27 -# 895| m0_29(float) = Store : r0_23, r0_28 -# 896| r0_30(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r0_31(__va_list_tag *) = Convert : r0_30 -# 896| v0_32(void) = VarArgsEnd : r0_31 -# 897| r0_33(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r0_34(__va_list_tag *) = Convert : r0_33 -# 897| v0_35(void) = VarArgsEnd : r0_34 -# 898| v0_36(void) = NoOp : -# 888| v0_37(void) = ReturnVoid : -# 888| v0_38(void) = UnmodeledUse : mu* -# 888| v0_39(void) = ExitFunction : +# 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 : 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 : r0_8, r0_9 +# 892| r0_11(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| mu0_12(__va_list_tag[1]) = Uninitialized : 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 : r0_14, 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 : r0_20 +# 894| r0_22(double) = Load : r0_21, mu0_2 +# 894| m0_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 : r0_26 +# 895| r0_28(double) = Load : r0_27, mu0_2 +# 895| r0_29(float) = Convert : r0_28 +# 895| m0_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 : 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 : r0_35 +# 898| v0_37(void) = NoOp : +# 888| v0_38(void) = ReturnVoid : +# 888| v0_39(void) = UnmodeledUse : mu* +# 888| v0_40(void) = ExitFunction : # 900| CastToVoid(int) -> void # 900| Block 0 # 900| v0_0(void) = EnterFunction : -# 900| mu0_1(unknown) = UnmodeledDefinition : -# 900| r0_2(glval) = VariableAddress[x] : -# 900| mu0_3(int) = InitializeParameter[x] : r0_2 -# 901| r0_4(glval) = VariableAddress[x] : -# 901| v0_5(void) = Convert : r0_4 -# 902| v0_6(void) = NoOp : -# 900| v0_7(void) = ReturnVoid : -# 900| v0_8(void) = UnmodeledUse : mu* -# 900| v0_9(void) = ExitFunction : +# 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) = ExitFunction : # 904| ConstantConditions(int) -> void # 904| Block 0 # 904| v0_0(void) = EnterFunction : -# 904| mu0_1(unknown) = UnmodeledDefinition : -# 904| r0_2(glval) = VariableAddress[x] : -# 904| m0_3(int) = InitializeParameter[x] : r0_2 -# 905| r0_4(glval) = VariableAddress[a] : -# 905| r0_5(bool) = Constant[1] : -# 905| m0_6(bool) = Store : r0_4, r0_5 -# 906| r0_7(glval) = VariableAddress[b] : -# 906| r0_8(bool) = Constant[1] : -# 906| v0_9(void) = ConditionalBranch : r0_8 +# 904| mu0_1(unknown) = AliasedDefinition : +# 904| mu0_2(unknown) = UnmodeledDefinition : +# 904| r0_3(glval) = VariableAddress[x] : +# 904| m0_4(int) = InitializeParameter[x] : r0_3 +# 905| r0_5(glval) = VariableAddress[a] : +# 905| r0_6(bool) = Constant[1] : +# 905| m0_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 #-----| False -> Block 3 #-----| True -> Block 2 @@ -3825,7 +4014,7 @@ ir.cpp: # 906| m1_0(int) = Phi : from 2:m2_3, from 3:m3_3 # 906| r1_1(glval) = VariableAddress[#temp906:11] : # 906| r1_2(int) = Load : r1_1, m1_0 -# 906| m1_3(int) = Store : r0_7, r1_2 +# 906| m1_3(int) = Store : r0_8, r1_2 # 907| v1_4(void) = NoOp : # 904| v1_5(void) = ReturnVoid : # 904| v1_6(void) = UnmodeledUse : mu* @@ -3833,14 +4022,14 @@ ir.cpp: # 906| Block 2 # 906| r2_0(glval) = VariableAddress[x] : -# 906| r2_1(int) = Load : r2_0, m0_3 +# 906| r2_1(int) = Load : r2_0, m0_4 # 906| r2_2(glval) = VariableAddress[#temp906:11] : # 906| m2_3(int) = Store : r2_2, r2_1 #-----| Goto -> Block 1 # 906| Block 3 # 906| r3_0(glval) = VariableAddress[x] : -# 906| r3_1(int) = Load : r3_0, m0_3 +# 906| r3_1(int) = Load : r3_0, m0_4 # 906| r3_2(glval) = VariableAddress[#temp906:11] : # 906| m3_3(int) = Store : r3_2, r3_1 #-----| Goto -> Block 1 @@ -3848,191 +4037,203 @@ ir.cpp: # 940| OperatorNew() -> void # 940| Block 0 # 940| v0_0(void) = EnterFunction : -# 940| mu0_1(unknown) = UnmodeledDefinition : -# 941| r0_2(glval) = FunctionAddress[operator new] : -# 941| r0_3(unsigned long) = Constant[4] : -# 941| r0_4(void *) = Call : r0_2, r0_3 -# 941| r0_5(int *) = Convert : r0_4 -# 942| r0_6(glval) = FunctionAddress[operator new] : -# 942| r0_7(unsigned long) = Constant[4] : -# 942| r0_8(float) = Constant[1.0] : -# 942| r0_9(void *) = Call : r0_6, r0_7, r0_8 -# 942| r0_10(int *) = Convert : r0_9 -# 943| r0_11(glval) = FunctionAddress[operator new] : -# 943| r0_12(unsigned long) = Constant[4] : -# 943| r0_13(void *) = Call : r0_11, r0_12 -# 943| r0_14(int *) = Convert : r0_13 -# 943| r0_15(int) = Constant[0] : -# 943| mu0_16(int) = Store : r0_14, r0_15 -# 944| r0_17(glval) = FunctionAddress[operator new] : -# 944| r0_18(unsigned long) = Constant[8] : -# 944| r0_19(void *) = Call : r0_17, r0_18 -# 944| r0_20(String *) = Convert : r0_19 -# 944| r0_21(glval) = FunctionAddress[String] : -# 944| v0_22(void) = Call : r0_21, this:r0_20 -# 945| r0_23(glval) = FunctionAddress[operator new] : -# 945| r0_24(unsigned long) = Constant[8] : -# 945| r0_25(float) = Constant[1.0] : -# 945| r0_26(void *) = Call : r0_23, r0_24, r0_25 -# 945| r0_27(String *) = Convert : r0_26 -# 945| r0_28(glval) = FunctionAddress[String] : -# 945| r0_29(glval) = StringConstant["hello"] : -# 945| r0_30(char *) = Convert : r0_29 -# 945| v0_31(void) = Call : r0_28, this:r0_27, r0_30 -# 946| r0_32(glval) = FunctionAddress[operator new] : -# 946| r0_33(unsigned long) = Constant[256] : -# 946| r0_34(align_val_t) = Constant[128] : -# 946| r0_35(void *) = Call : r0_32, r0_33, r0_34 -# 946| r0_36(Overaligned *) = Convert : r0_35 -# 947| r0_37(glval) = FunctionAddress[operator new] : -# 947| r0_38(unsigned long) = Constant[256] : -# 947| r0_39(align_val_t) = Constant[128] : -# 947| r0_40(float) = Constant[1.0] : -# 947| r0_41(void *) = Call : r0_37, r0_38, r0_39, r0_40 -# 947| r0_42(Overaligned *) = Convert : r0_41 -# 947| r0_43(Overaligned) = Constant[0] : -# 947| mu0_44(Overaligned) = Store : r0_42, r0_43 -# 948| v0_45(void) = NoOp : -# 940| v0_46(void) = ReturnVoid : -# 940| v0_47(void) = UnmodeledUse : mu* -# 940| v0_48(void) = ExitFunction : +# 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 : r0_3, 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 : r0_8, r0_9, 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 : r0_14, 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 : r0_21, 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 : r0_26, this:r0_25 +# 944| mu0_28(unknown) = ^CallSideEffect : mu0_2 +# 945| r0_29(glval) = FunctionAddress[operator new] : +# 945| r0_30(unsigned long) = Constant[8] : +# 945| r0_31(float) = Constant[1.0] : +# 945| r0_32(void *) = Call : r0_29, r0_30, r0_31 +# 945| mu0_33(unknown) = ^CallSideEffect : mu0_2 +# 945| r0_34(String *) = Convert : r0_32 +# 945| r0_35(glval) = FunctionAddress[String] : +# 945| r0_36(glval) = StringConstant["hello"] : +# 945| r0_37(char *) = Convert : r0_36 +# 945| v0_38(void) = Call : r0_35, this:r0_34, r0_37 +# 945| mu0_39(unknown) = ^CallSideEffect : mu0_2 +# 946| r0_40(glval) = FunctionAddress[operator new] : +# 946| r0_41(unsigned long) = Constant[256] : +# 946| r0_42(align_val_t) = Constant[128] : +# 946| r0_43(void *) = Call : r0_40, r0_41, r0_42 +# 946| mu0_44(unknown) = ^CallSideEffect : mu0_2 +# 946| r0_45(Overaligned *) = Convert : r0_43 +# 947| r0_46(glval) = FunctionAddress[operator new] : +# 947| r0_47(unsigned long) = Constant[256] : +# 947| r0_48(align_val_t) = Constant[128] : +# 947| r0_49(float) = Constant[1.0] : +# 947| r0_50(void *) = Call : r0_46, r0_47, r0_48, r0_49 +# 947| mu0_51(unknown) = ^CallSideEffect : mu0_2 +# 947| r0_52(Overaligned *) = Convert : r0_50 +# 947| r0_53(Overaligned) = Constant[0] : +# 947| mu0_54(Overaligned) = Store : r0_52, r0_53 +# 948| v0_55(void) = NoOp : +# 940| v0_56(void) = ReturnVoid : +# 940| v0_57(void) = UnmodeledUse : mu* +# 940| v0_58(void) = ExitFunction : # 950| OperatorNewArray(int) -> void # 950| Block 0 # 950| v0_0(void) = EnterFunction : -# 950| mu0_1(unknown) = UnmodeledDefinition : -# 950| r0_2(glval) = VariableAddress[n] : -# 950| m0_3(int) = InitializeParameter[n] : r0_2 -# 951| r0_4(glval) = FunctionAddress[operator new[]] : -# 951| r0_5(unsigned long) = Constant[40] : -# 951| r0_6(void *) = Call : r0_4, r0_5 -# 951| r0_7(int *) = Convert : r0_6 -# 952| r0_8(glval) = FunctionAddress[operator new[]] : -# 952| r0_9(glval) = VariableAddress[n] : -# 952| r0_10(int) = Load : r0_9, m0_3 -# 952| r0_11(unsigned long) = Convert : r0_10 -# 952| r0_12(unsigned long) = Constant[4] : -# 952| r0_13(unsigned long) = Mul : r0_11, r0_12 -# 952| r0_14(void *) = Call : r0_8, r0_13 -# 952| r0_15(int *) = Convert : r0_14 -# 953| r0_16(glval) = FunctionAddress[operator new[]] : -# 953| r0_17(glval) = VariableAddress[n] : -# 953| r0_18(int) = Load : r0_17, m0_3 -# 953| r0_19(unsigned long) = Convert : r0_18 -# 953| r0_20(unsigned long) = Constant[4] : -# 953| r0_21(unsigned long) = Mul : r0_19, r0_20 -# 953| r0_22(float) = Constant[1.0] : -# 953| r0_23(void *) = Call : r0_16, r0_21, r0_22 -# 953| r0_24(int *) = Convert : r0_23 -# 954| r0_25(glval) = FunctionAddress[operator new[]] : -# 954| r0_26(glval) = VariableAddress[n] : -# 954| r0_27(int) = Load : r0_26, m0_3 -# 954| r0_28(unsigned long) = Convert : r0_27 -# 954| r0_29(unsigned long) = Constant[8] : -# 954| r0_30(unsigned long) = Mul : r0_28, r0_29 -# 954| r0_31(void *) = Call : r0_25, r0_30 -# 954| r0_32(String *) = Convert : r0_31 -# 955| r0_33(glval) = FunctionAddress[operator new[]] : -# 955| r0_34(glval) = VariableAddress[n] : -# 955| r0_35(int) = Load : r0_34, m0_3 -# 955| r0_36(unsigned long) = Convert : r0_35 -# 955| r0_37(unsigned long) = Constant[256] : -# 955| r0_38(unsigned long) = Mul : r0_36, r0_37 -# 955| r0_39(align_val_t) = Constant[128] : -# 955| r0_40(void *) = Call : r0_33, r0_38, r0_39 -# 955| r0_41(Overaligned *) = Convert : r0_40 -# 956| r0_42(glval) = FunctionAddress[operator new[]] : -# 956| r0_43(unsigned long) = Constant[2560] : -# 956| r0_44(align_val_t) = Constant[128] : -# 956| r0_45(float) = Constant[1.0] : -# 956| r0_46(void *) = Call : r0_42, r0_43, r0_44, r0_45 -# 956| r0_47(Overaligned *) = Convert : r0_46 -# 957| r0_48(glval) = FunctionAddress[operator new[]] : -# 957| r0_49(glval) = VariableAddress[n] : -# 957| r0_50(int) = Load : r0_49, m0_3 -# 957| r0_51(unsigned long) = Convert : r0_50 -# 957| r0_52(unsigned long) = Constant[1] : -# 957| r0_53(unsigned long) = Mul : r0_51, r0_52 -# 957| r0_54(void *) = Call : r0_48, r0_53 -# 957| r0_55(DefaultCtorWithDefaultParam *) = Convert : r0_54 -# 958| r0_56(glval) = FunctionAddress[operator new[]] : -# 958| r0_57(glval) = VariableAddress[n] : -# 958| r0_58(int) = Load : r0_57, m0_3 -# 958| r0_59(unsigned long) = Convert : r0_58 -# 958| r0_60(unsigned long) = Constant[4] : -# 958| r0_61(unsigned long) = Mul : r0_59, r0_60 -# 958| r0_62(void *) = Call : r0_56, r0_61 -# 958| r0_63(int *) = Convert : r0_62 -# 959| v0_64(void) = NoOp : -# 950| v0_65(void) = ReturnVoid : -# 950| v0_66(void) = UnmodeledUse : mu* -# 950| v0_67(void) = ExitFunction : +# 950| mu0_1(unknown) = AliasedDefinition : +# 950| mu0_2(unknown) = UnmodeledDefinition : +# 950| r0_3(glval) = VariableAddress[n] : +# 950| m0_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 : r0_5, 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, m0_4 +# 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 : r0_10, 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, m0_4 +# 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 : r0_19, r0_24, 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, m0_4 +# 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 : r0_29, 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, m0_4 +# 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 : r0_38, r0_43, 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 : r0_48, r0_49, r0_50, 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, m0_4 +# 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 : r0_55, 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, m0_4 +# 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 : r0_64, 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) = ExitFunction : # 961| designatedInit() -> int # 961| Block 0 -# 961| v0_0(void) = EnterFunction : -# 961| mu0_1(unknown) = UnmodeledDefinition : -# 962| r0_2(glval) = VariableAddress[a1] : -# 962| mu0_3(int[1000]) = Uninitialized : r0_2 -# 962| r0_4(int) = Constant[0] : -# 962| r0_5(glval) = PointerAdd : r0_2, r0_4 -# 962| r0_6(unknown[8]) = Constant[0] : -# 962| mu0_7(unknown[8]) = Store : r0_5, r0_6 -#-----| Goto -> Block 2 - -# 962| Block 1 -# 962| r1_0(int) = Constant[900] : -# 962| r1_1(glval) = PointerAdd : r0_2, r1_0 -# 962| r1_2(int) = Constant[10900] : -# 962| mu1_3(int) = Store : r1_1, r1_2 -# 962| r1_4(int) = Constant[901] : -# 962| r1_5(glval) = PointerAdd : r0_2, r1_4 -# 962| r1_6(unknown[396]) = Constant[0] : -# 962| mu1_7(unknown[396]) = Store : r1_5, r1_6 -#-----| Goto -> Block 2 - -# 963| Block 2 -# 963| r2_0(glval) = VariableAddress[#return] : -# 963| r2_1(glval) = VariableAddress[a1] : -# 963| r2_2(int *) = Convert : r2_1 -# 963| r2_3(int) = Constant[900] : -# 963| r2_4(int *) = PointerAdd[4] : r2_2, r2_3 -# 963| r2_5(int) = Load : r2_4, mu0_1 -# 963| m2_6(int) = Store : r2_0, r2_5 -# 961| r2_7(glval) = VariableAddress[#return] : -# 961| v2_8(void) = ReturnValue : r2_7, m2_6 -# 961| v2_9(void) = UnmodeledUse : mu* -# 961| v2_10(void) = ExitFunction : - -# 962| Block 3 -# 962| r3_0(int) = Constant[2] : -# 962| r3_1(glval) = PointerAdd : r0_2, r3_0 -# 962| r3_2(int) = Constant[10002] : -# 962| mu3_3(int) = Store : r3_1, r3_2 -# 962| r3_4(int) = Constant[3] : -# 962| r3_5(glval) = PointerAdd : r0_2, r3_4 -# 962| r3_6(unknown[3588]) = Constant[0] : -# 962| mu3_7(unknown[3588]) = Store : r3_5, r3_6 -#-----| Goto -> Block 2 +# 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 : r0_3 +# 962| r0_5(int) = Constant[0] : +# 962| r0_6(glval) = PointerAdd : 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 : 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 : 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 : 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 : 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(int *) = PointerAdd[4] : r0_27, r0_28 +# 963| r0_30(int) = Load : r0_29, mu0_2 +# 963| m0_31(int) = Store : r0_25, r0_30 +# 961| r0_32(glval) = VariableAddress[#return] : +# 961| v0_33(void) = ReturnValue : r0_32, m0_31 +# 961| v0_34(void) = UnmodeledUse : mu* +# 961| v0_35(void) = ExitFunction : # 966| IfStmtWithDeclaration(int, int) -> void # 966| Block 0 # 966| v0_0(void) = EnterFunction : -# 966| mu0_1(unknown) = UnmodeledDefinition : -# 966| r0_2(glval) = VariableAddress[x] : -# 966| mu0_3(int) = InitializeParameter[x] : r0_2 -# 966| r0_4(glval) = VariableAddress[y] : -# 966| m0_5(int) = InitializeParameter[y] : r0_4 -# 967| r0_6(glval) = VariableAddress[b] : -# 967| r0_7(glval) = VariableAddress[x] : -# 967| r0_8(int) = Load : r0_7, mu0_1 -# 967| r0_9(glval) = VariableAddress[y] : -# 967| r0_10(int) = Load : r0_9, m0_5 -# 967| r0_11(bool) = CompareLT : r0_8, r0_10 -# 967| m0_12(bool) = Store : r0_6, r0_11 -# 967| r0_13(glval) = VariableAddress[b] : -# 967| r0_14(bool) = Load : r0_13, m0_12 -# 967| v0_15(void) = ConditionalBranch : r0_14 +# 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| m0_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, m0_6 +# 967| r0_12(bool) = CompareLT : r0_9, r0_11 +# 967| m0_13(bool) = Store : r0_7, r0_12 +# 967| r0_14(glval) = VariableAddress[b] : +# 967| r0_15(bool) = Load : r0_14, m0_13 +# 967| v0_16(void) = ConditionalBranch : r0_15 #-----| False -> Block 2 #-----| True -> Block 1 @@ -4045,9 +4246,9 @@ ir.cpp: # 970| Block 2 # 970| r2_0(glval) = VariableAddress[z] : # 970| r2_1(glval) = VariableAddress[x] : -# 970| r2_2(int) = Load : r2_1, mu0_1 +# 970| r2_2(int) = Load : r2_1, mu0_2 # 970| r2_3(glval) = VariableAddress[y] : -# 970| r2_4(int) = Load : r2_3, m0_5 +# 970| r2_4(int) = Load : r2_3, m0_6 # 970| r2_5(int) = Add : r2_2, r2_4 # 970| m2_6(int) = Store : r2_0, r2_5 # 970| r2_7(glval) = VariableAddress[z] : @@ -4092,11 +4293,12 @@ ir.cpp: # 978| WhileStmtWithDeclaration(int, int) -> void # 978| Block 0 # 978| v0_0(void) = EnterFunction : -# 978| mu0_1(unknown) = UnmodeledDefinition : -# 978| r0_2(glval) = VariableAddress[x] : -# 978| mu0_3(int) = InitializeParameter[x] : r0_2 -# 978| r0_4(glval) = VariableAddress[y] : -# 978| m0_5(int) = InitializeParameter[y] : r0_4 +# 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| m0_6(int) = InitializeParameter[y] : r0_5 #-----| Goto -> Block 7 # 979| Block 1 @@ -4106,9 +4308,9 @@ ir.cpp: # 981| Block 2 # 981| r2_0(glval) = VariableAddress[z] : # 981| r2_1(glval) = VariableAddress[x] : -# 981| r2_2(int) = Load : r2_1, mu0_1 +# 981| r2_2(int) = Load : r2_1, mu0_2 # 981| r2_3(glval) = VariableAddress[y] : -# 981| r2_4(int) = Load : r2_3, m0_5 +# 981| r2_4(int) = Load : r2_3, m0_6 # 981| r2_5(int) = Add : r2_2, r2_4 # 981| m2_6(int) = Store : r2_0, r2_5 # 981| r2_7(glval) = VariableAddress[z] : @@ -4148,9 +4350,9 @@ ir.cpp: # 979| Block 7 # 979| r7_0(glval) = VariableAddress[b] : # 979| r7_1(glval) = VariableAddress[x] : -# 979| r7_2(int) = Load : r7_1, mu0_1 +# 979| r7_2(int) = Load : r7_1, mu0_2 # 979| r7_3(glval) = VariableAddress[y] : -# 979| r7_4(int) = Load : r7_3, m0_5 +# 979| r7_4(int) = Load : r7_3, m0_6 # 979| r7_5(bool) = CompareLT : r7_2, r7_4 # 979| m7_6(bool) = Store : r7_0, r7_5 # 979| r7_7(glval) = VariableAddress[b] : @@ -4158,3 +4360,84 @@ ir.cpp: # 979| v7_9(void) = ConditionalBranch : r7_8 #-----| False -> Block 2 #-----| True -> Block 1 + +# 1005| ChiPhiNode(Point *, bool, bool) -> int +# 1005| Block 0 +# 1005| v0_0(void) = EnterFunction : +# 1005| mu0_1(unknown) = AliasedDefinition : +# 1005| mu0_2(unknown) = UnmodeledDefinition : +# 1005| r0_3(glval) = VariableAddress[p] : +# 1005| m0_4(Point *) = InitializeParameter[p] : r0_3 +# 1005| r0_5(glval) = VariableAddress[which1] : +# 1005| m0_6(bool) = InitializeParameter[which1] : r0_5 +# 1005| r0_7(glval) = VariableAddress[which2] : +# 1005| m0_8(bool) = InitializeParameter[which2] : r0_7 +# 1006| r0_9(glval) = VariableAddress[which1] : +# 1006| r0_10(bool) = Load : r0_9, m0_6 +# 1006| v0_11(void) = ConditionalBranch : r0_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 1007| Block 1 +# 1007| r1_0(glval) = VariableAddress[p] : +# 1007| r1_1(Point *) = Load : r1_0, m0_4 +# 1007| r1_2(glval) = FieldAddress[x] : r1_1 +# 1007| r1_3(int) = Load : r1_2, mu0_2 +# 1007| r1_4(int) = Constant[1] : +# 1007| r1_5(int) = Add : r1_3, r1_4 +# 1007| mu1_6(int) = Store : r1_2, r1_5 +#-----| Goto -> Block 3 + +# 1009| Block 2 +# 1009| r2_0(glval) = VariableAddress[p] : +# 1009| r2_1(Point *) = Load : r2_0, m0_4 +# 1009| r2_2(glval) = FieldAddress[y] : r2_1 +# 1009| r2_3(int) = Load : r2_2, mu0_2 +# 1009| r2_4(int) = Constant[1] : +# 1009| r2_5(int) = Add : r2_3, r2_4 +# 1009| mu2_6(int) = Store : r2_2, r2_5 +#-----| Goto -> Block 3 + +# 1012| Block 3 +# 1012| r3_0(glval) = VariableAddress[which2] : +# 1012| r3_1(bool) = Load : r3_0, m0_8 +# 1012| v3_2(void) = ConditionalBranch : r3_1 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 1013| Block 4 +# 1013| r4_0(glval) = VariableAddress[p] : +# 1013| r4_1(Point *) = Load : r4_0, m0_4 +# 1013| r4_2(glval) = FieldAddress[x] : r4_1 +# 1013| r4_3(int) = Load : r4_2, mu0_2 +# 1013| r4_4(int) = Constant[1] : +# 1013| r4_5(int) = Add : r4_3, r4_4 +# 1013| mu4_6(int) = Store : r4_2, r4_5 +#-----| Goto -> Block 6 + +# 1015| Block 5 +# 1015| r5_0(glval) = VariableAddress[p] : +# 1015| r5_1(Point *) = Load : r5_0, m0_4 +# 1015| r5_2(glval) = FieldAddress[y] : r5_1 +# 1015| r5_3(int) = Load : r5_2, mu0_2 +# 1015| r5_4(int) = Constant[1] : +# 1015| r5_5(int) = Add : r5_3, r5_4 +# 1015| mu5_6(int) = Store : r5_2, r5_5 +#-----| Goto -> Block 6 + +# 1018| Block 6 +# 1018| r6_0(glval) = VariableAddress[#return] : +# 1018| r6_1(glval) = VariableAddress[p] : +# 1018| r6_2(Point *) = Load : r6_1, m0_4 +# 1018| r6_3(glval) = FieldAddress[x] : r6_2 +# 1018| r6_4(int) = Load : r6_3, mu0_2 +# 1018| r6_5(glval) = VariableAddress[p] : +# 1018| r6_6(Point *) = Load : r6_5, m0_4 +# 1018| r6_7(glval) = FieldAddress[y] : r6_6 +# 1018| r6_8(int) = Load : r6_7, mu0_2 +# 1018| r6_9(int) = Add : r6_4, r6_8 +# 1018| m6_10(int) = Store : r6_0, r6_9 +# 1005| r6_11(glval) = VariableAddress[#return] : +# 1005| v6_12(void) = ReturnValue : r6_11, m6_10 +# 1005| v6_13(void) = UnmodeledUse : mu* +# 1005| v6_14(void) = ExitFunction : 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 3df04157bf6..c823ee3eac7 100644 --- a/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected +++ b/cpp/ql/test/library-tests/valuenumbering/GlobalValueNumbering/ir_gvn.expected @@ -2,359 +2,375 @@ test.cpp: # 1| test00(int, int) -> int # 1| Block 0 # 1| v0_0(void) = EnterFunction : -# 1| mu0_1(unknown) = UnmodeledDefinition : +# 1| m0_1(unknown) = AliasedDefinition : # 1| valnum = unique -# 1| r0_2(glval) = VariableAddress[p0] : -# 1| valnum = r0_2 -# 1| m0_3(int) = InitializeParameter[p0] : r0_2 -# 1| valnum = m0_3 -# 1| r0_4(glval) = VariableAddress[p1] : -# 1| valnum = r0_4 -# 1| m0_5(int) = InitializeParameter[p1] : r0_4 -# 1| valnum = m0_5 -# 2| r0_6(glval) = VariableAddress[x] : -# 2| valnum = r0_6 -# 2| m0_7(int) = Uninitialized : r0_6 -# 2| valnum = unique -# 2| r0_8(glval) = VariableAddress[y] : -# 2| valnum = r0_8 -# 2| m0_9(int) = Uninitialized : r0_8 -# 2| valnum = unique -# 3| r0_10(glval) = VariableAddress[b] : -# 3| valnum = unique -# 3| m0_11(unsigned char) = Uninitialized : r0_10 -# 3| valnum = unique -# 5| r0_12(glval) = VariableAddress[p0] : -# 5| valnum = r0_2 -# 5| r0_13(int) = Load : r0_12, m0_3 -# 5| valnum = m0_3 -# 5| r0_14(glval) = VariableAddress[p1] : -# 5| valnum = r0_4 -# 5| r0_15(int) = Load : r0_14, m0_5 -# 5| valnum = m0_5 -# 5| r0_16(int) = Add : r0_13, r0_15 -# 5| valnum = r0_16 -# 5| r0_17(glval) = VariableAddress[x] : -# 5| valnum = r0_6 -# 5| m0_18(int) = Store : r0_17, r0_16 -# 5| valnum = r0_16 -# 6| r0_19(glval) = VariableAddress[p0] : -# 6| valnum = r0_2 -# 6| r0_20(int) = Load : r0_19, m0_3 -# 6| valnum = m0_3 -# 6| r0_21(glval) = VariableAddress[p1] : -# 6| valnum = r0_4 -# 6| r0_22(int) = Load : r0_21, m0_5 -# 6| valnum = m0_5 -# 6| r0_23(int) = Add : r0_20, r0_22 -# 6| valnum = r0_16 -# 6| r0_24(glval) = VariableAddress[x] : -# 6| valnum = r0_6 -# 6| m0_25(int) = Store : r0_24, r0_23 -# 6| valnum = r0_16 -# 7| r0_26(glval) = VariableAddress[x] : -# 7| valnum = r0_6 -# 7| r0_27(int) = Load : r0_26, m0_25 -# 7| valnum = r0_16 -# 7| r0_28(glval) = VariableAddress[y] : -# 7| valnum = r0_8 -# 7| m0_29(int) = Store : r0_28, r0_27 -# 7| valnum = r0_16 -# 8| v0_30(void) = NoOp : -# 1| r0_31(glval) = VariableAddress[#return] : +# 1| mu0_2(unknown) = UnmodeledDefinition : # 1| valnum = unique -# 1| v0_32(void) = ReturnValue : r0_31 -# 1| v0_33(void) = UnmodeledUse : mu* -# 1| v0_34(void) = ExitFunction : +# 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 : r0_7 +# 2| valnum = unique +# 2| r0_9(glval) = VariableAddress[y] : +# 2| valnum = r0_9 +# 2| m0_10(int) = Uninitialized : r0_9 +# 2| valnum = unique +# 3| r0_11(glval) = VariableAddress[b] : +# 3| valnum = unique +# 3| m0_12(unsigned char) = Uninitialized : r0_11 +# 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] : +# 1| valnum = unique +# 1| v0_33(void) = ReturnValue : r0_32 +# 1| v0_34(void) = UnmodeledUse : mu* +# 1| v0_35(void) = ExitFunction : # 12| test01(int, int) -> int # 12| Block 0 # 12| v0_0(void) = EnterFunction : -# 12| mu0_1(unknown) = UnmodeledDefinition : +# 12| m0_1(unknown) = AliasedDefinition : # 12| valnum = unique -# 12| r0_2(glval) = VariableAddress[p0] : -# 12| valnum = r0_2 -# 12| m0_3(int) = InitializeParameter[p0] : r0_2 -# 12| valnum = m0_3 -# 12| r0_4(glval) = VariableAddress[p1] : -# 12| valnum = r0_4 -# 12| m0_5(int) = InitializeParameter[p1] : r0_4 -# 12| valnum = m0_5 -# 13| r0_6(glval) = VariableAddress[x] : -# 13| valnum = r0_6 -# 13| m0_7(int) = Uninitialized : r0_6 +# 12| mu0_2(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 : r0_7 # 13| valnum = unique -# 13| r0_8(glval) = VariableAddress[y] : -# 13| valnum = r0_8 -# 13| m0_9(int) = Uninitialized : r0_8 +# 13| r0_9(glval) = VariableAddress[y] : +# 13| valnum = r0_9 +# 13| m0_10(int) = Uninitialized : r0_9 # 13| valnum = unique -# 14| r0_10(glval) = VariableAddress[b] : +# 14| r0_11(glval) = VariableAddress[b] : # 14| valnum = unique -# 14| m0_11(unsigned char) = Uninitialized : r0_10 +# 14| m0_12(unsigned char) = Uninitialized : r0_11 # 14| valnum = unique -# 16| r0_12(glval) = VariableAddress[p0] : -# 16| valnum = r0_2 -# 16| r0_13(int) = Load : r0_12, m0_3 -# 16| valnum = m0_3 -# 16| r0_14(glval) = VariableAddress[p1] : -# 16| valnum = r0_4 -# 16| r0_15(int) = Load : r0_14, m0_5 -# 16| valnum = m0_5 -# 16| r0_16(int) = Add : r0_13, r0_15 -# 16| valnum = r0_16 -# 16| r0_17(glval) = VariableAddress[global01] : +# 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(int) = Load : r0_17, mu0_1 +# 16| r0_18(glval) = VariableAddress[global01] : +# 16| valnum = r0_18 +# 16| r0_19(int) = Load : r0_18, mu0_2 # 16| valnum = unique -# 16| r0_19(int) = Add : r0_16, r0_18 -# 16| valnum = r0_19 -# 16| r0_20(glval) = VariableAddress[x] : -# 16| valnum = r0_6 -# 16| m0_21(int) = Store : r0_20, r0_19 -# 16| valnum = r0_19 -# 17| r0_22(glval) = VariableAddress[p0] : -# 17| valnum = r0_2 -# 17| r0_23(int) = Load : r0_22, m0_3 -# 17| valnum = m0_3 -# 17| r0_24(glval) = VariableAddress[p1] : -# 17| valnum = r0_4 -# 17| r0_25(int) = Load : r0_24, m0_5 -# 17| valnum = m0_5 -# 17| r0_26(int) = Add : r0_23, r0_25 -# 17| valnum = r0_16 -# 17| r0_27(glval) = VariableAddress[global01] : +# 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(int) = Load : r0_27, mu0_1 +# 17| r0_28(glval) = VariableAddress[global01] : +# 17| valnum = r0_18 +# 17| r0_29(int) = Load : r0_28, mu0_2 # 17| valnum = unique -# 17| r0_29(int) = Add : r0_26, r0_28 -# 17| valnum = r0_29 -# 17| r0_30(glval) = VariableAddress[x] : -# 17| valnum = r0_6 -# 17| m0_31(int) = Store : r0_30, r0_29 -# 17| valnum = r0_29 -# 18| r0_32(glval) = VariableAddress[x] : -# 18| valnum = r0_6 -# 18| r0_33(int) = Load : r0_32, m0_31 -# 18| valnum = r0_29 -# 18| r0_34(glval) = VariableAddress[y] : -# 18| valnum = r0_8 -# 18| m0_35(int) = Store : r0_34, r0_33 -# 18| valnum = r0_29 -# 19| v0_36(void) = NoOp : -# 12| r0_37(glval) = VariableAddress[#return] : +# 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] : # 12| valnum = unique -# 12| v0_38(void) = ReturnValue : r0_37 -# 12| v0_39(void) = UnmodeledUse : mu* -# 12| v0_40(void) = ExitFunction : +# 12| v0_39(void) = ReturnValue : r0_38 +# 12| v0_40(void) = UnmodeledUse : mu* +# 12| v0_41(void) = ExitFunction : # 25| test02(int, int) -> int # 25| Block 0 # 25| v0_0(void) = EnterFunction : -# 25| mu0_1(unknown) = UnmodeledDefinition : +# 25| m0_1(unknown) = AliasedDefinition : # 25| valnum = unique -# 25| r0_2(glval) = VariableAddress[p0] : -# 25| valnum = r0_2 -# 25| m0_3(int) = InitializeParameter[p0] : r0_2 -# 25| valnum = m0_3 -# 25| r0_4(glval) = VariableAddress[p1] : -# 25| valnum = r0_4 -# 25| m0_5(int) = InitializeParameter[p1] : r0_4 -# 25| valnum = m0_5 -# 26| r0_6(glval) = VariableAddress[x] : -# 26| valnum = r0_6 -# 26| m0_7(int) = Uninitialized : r0_6 +# 25| mu0_2(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 : r0_7 # 26| valnum = unique -# 26| r0_8(glval) = VariableAddress[y] : -# 26| valnum = r0_8 -# 26| m0_9(int) = Uninitialized : r0_8 +# 26| r0_9(glval) = VariableAddress[y] : +# 26| valnum = r0_9 +# 26| m0_10(int) = Uninitialized : r0_9 # 26| valnum = unique -# 27| r0_10(glval) = VariableAddress[b] : +# 27| r0_11(glval) = VariableAddress[b] : # 27| valnum = unique -# 27| m0_11(unsigned char) = Uninitialized : r0_10 +# 27| m0_12(unsigned char) = Uninitialized : r0_11 # 27| valnum = unique -# 29| r0_12(glval) = VariableAddress[p0] : -# 29| valnum = r0_2 -# 29| r0_13(int) = Load : r0_12, m0_3 -# 29| valnum = m0_3 -# 29| r0_14(glval) = VariableAddress[p1] : -# 29| valnum = r0_4 -# 29| r0_15(int) = Load : r0_14, m0_5 -# 29| valnum = m0_5 -# 29| r0_16(int) = Add : r0_13, r0_15 -# 29| valnum = r0_16 -# 29| r0_17(glval) = VariableAddress[global02] : +# 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(int) = Load : r0_17, mu0_1 +# 29| r0_18(glval) = VariableAddress[global02] : +# 29| valnum = r0_18 +# 29| r0_19(int) = Load : r0_18, mu0_2 # 29| valnum = unique -# 29| r0_19(int) = Add : r0_16, r0_18 -# 29| valnum = r0_19 -# 29| r0_20(glval) = VariableAddress[x] : -# 29| valnum = r0_6 -# 29| m0_21(int) = Store : r0_20, r0_19 -# 29| valnum = r0_19 -# 30| r0_22(glval) = FunctionAddress[change_global02] : +# 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] : # 30| valnum = unique -# 30| v0_23(void) = Call : r0_22 -# 31| r0_24(glval) = VariableAddress[p0] : -# 31| valnum = r0_2 -# 31| r0_25(int) = Load : r0_24, m0_3 -# 31| valnum = m0_3 -# 31| r0_26(glval) = VariableAddress[p1] : -# 31| valnum = r0_4 -# 31| r0_27(int) = Load : r0_26, m0_5 -# 31| valnum = m0_5 -# 31| r0_28(int) = Add : r0_25, r0_27 -# 31| valnum = r0_16 -# 31| r0_29(glval) = VariableAddress[global02] : -# 31| valnum = r0_17 -# 31| r0_30(int) = Load : r0_29, mu0_1 -# 31| valnum = unique +# 30| v0_24(void) = Call : r0_23 +# 30| m0_25(unknown) = ^CallSideEffect : m0_1 +# 30| valnum = unique +# 30| m0_26(unknown) = Chi : m0_1, m0_25 +# 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_31 -# 31| r0_32(glval) = VariableAddress[x] : -# 31| valnum = r0_6 -# 31| m0_33(int) = Store : r0_32, r0_31 -# 31| valnum = r0_31 -# 32| r0_34(glval) = VariableAddress[x] : -# 32| valnum = r0_6 -# 32| r0_35(int) = Load : r0_34, m0_33 -# 32| valnum = r0_31 -# 32| r0_36(glval) = VariableAddress[y] : -# 32| valnum = r0_8 -# 32| m0_37(int) = Store : r0_36, r0_35 -# 32| valnum = r0_31 -# 33| v0_38(void) = NoOp : -# 25| r0_39(glval) = VariableAddress[#return] : +# 31| valnum = r0_17 +# 31| r0_32(glval) = VariableAddress[global02] : +# 31| valnum = r0_18 +# 31| r0_33(int) = Load : r0_32, mu0_2 +# 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] : # 25| valnum = unique -# 25| v0_40(void) = ReturnValue : r0_39 -# 25| v0_41(void) = UnmodeledUse : mu* -# 25| v0_42(void) = ExitFunction : +# 25| v0_43(void) = ReturnValue : r0_42 +# 25| v0_44(void) = UnmodeledUse : mu* +# 25| v0_45(void) = ExitFunction : # 39| test03(int, int, int *) -> int # 39| Block 0 # 39| v0_0(void) = EnterFunction : -# 39| mu0_1(unknown) = UnmodeledDefinition : +# 39| m0_1(unknown) = AliasedDefinition : # 39| valnum = unique -# 39| r0_2(glval) = VariableAddress[p0] : -# 39| valnum = r0_2 -# 39| m0_3(int) = InitializeParameter[p0] : r0_2 -# 39| valnum = m0_3 -# 39| r0_4(glval) = VariableAddress[p1] : -# 39| valnum = r0_4 -# 39| m0_5(int) = InitializeParameter[p1] : r0_4 -# 39| valnum = m0_5 -# 39| r0_6(glval) = VariableAddress[p2] : -# 39| valnum = r0_6 -# 39| m0_7(int *) = InitializeParameter[p2] : r0_6 -# 39| valnum = m0_7 -# 40| r0_8(glval) = VariableAddress[x] : -# 40| valnum = r0_8 -# 40| m0_9(int) = Uninitialized : r0_8 +# 39| mu0_2(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 : r0_9 # 40| valnum = unique -# 40| r0_10(glval) = VariableAddress[y] : -# 40| valnum = r0_10 -# 40| m0_11(int) = Uninitialized : r0_10 +# 40| r0_11(glval) = VariableAddress[y] : +# 40| valnum = r0_11 +# 40| m0_12(int) = Uninitialized : r0_11 # 40| valnum = unique -# 41| r0_12(glval) = VariableAddress[b] : +# 41| r0_13(glval) = VariableAddress[b] : # 41| valnum = unique -# 41| m0_13(unsigned char) = Uninitialized : r0_12 +# 41| m0_14(unsigned char) = Uninitialized : r0_13 # 41| valnum = unique -# 43| r0_14(glval) = VariableAddress[p0] : -# 43| valnum = r0_2 -# 43| r0_15(int) = Load : r0_14, m0_3 -# 43| valnum = m0_3 -# 43| r0_16(glval) = VariableAddress[p1] : -# 43| valnum = r0_4 -# 43| r0_17(int) = Load : r0_16, m0_5 -# 43| valnum = m0_5 -# 43| r0_18(int) = Add : r0_15, r0_17 -# 43| valnum = r0_18 -# 43| r0_19(glval) = VariableAddress[global03] : +# 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(int) = Load : r0_19, mu0_1 +# 43| r0_20(glval) = VariableAddress[global03] : +# 43| valnum = r0_20 +# 43| r0_21(int) = Load : r0_20, mu0_2 # 43| valnum = unique -# 43| r0_21(int) = Add : r0_18, r0_20 -# 43| valnum = r0_21 -# 43| r0_22(glval) = VariableAddress[x] : -# 43| valnum = r0_8 -# 43| m0_23(int) = Store : r0_22, r0_21 -# 43| valnum = r0_21 -# 44| r0_24(int) = Constant[0] : -# 44| valnum = r0_24 -# 44| r0_25(glval) = VariableAddress[p2] : -# 44| valnum = r0_6 -# 44| r0_26(int *) = Load : r0_25, m0_7 -# 44| valnum = m0_7 -# 44| mu0_27(int) = Store : r0_26, r0_24 -# 44| valnum = r0_24 -# 45| r0_28(glval) = VariableAddress[p0] : -# 45| valnum = r0_2 -# 45| r0_29(int) = Load : r0_28, m0_3 -# 45| valnum = m0_3 -# 45| r0_30(glval) = VariableAddress[p1] : -# 45| valnum = r0_4 -# 45| r0_31(int) = Load : r0_30, m0_5 -# 45| valnum = m0_5 -# 45| r0_32(int) = Add : r0_29, r0_31 -# 45| valnum = r0_18 -# 45| r0_33(glval) = VariableAddress[global03] : +# 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| m0_28(int) = Store : r0_27, r0_25 +# 44| valnum = r0_25 +# 44| m0_29(unknown) = Chi : m0_1, m0_28 +# 44| valnum = unique +# 45| r0_30(glval) = VariableAddress[p0] : +# 45| valnum = r0_3 +# 45| r0_31(int) = Load : r0_30, m0_4 +# 45| valnum = m0_4 +# 45| r0_32(glval) = VariableAddress[p1] : +# 45| valnum = r0_5 +# 45| r0_33(int) = Load : r0_32, m0_6 +# 45| valnum = m0_6 +# 45| r0_34(int) = Add : r0_31, r0_33 # 45| valnum = r0_19 -# 45| r0_34(int) = Load : r0_33, mu0_1 +# 45| r0_35(glval) = VariableAddress[global03] : +# 45| valnum = r0_20 +# 45| r0_36(int) = Load : r0_35, mu0_2 # 45| valnum = unique -# 45| r0_35(int) = Add : r0_32, r0_34 -# 45| valnum = r0_35 -# 45| r0_36(glval) = VariableAddress[x] : -# 45| valnum = r0_8 -# 45| m0_37(int) = Store : r0_36, r0_35 -# 45| valnum = r0_35 -# 46| r0_38(glval) = VariableAddress[x] : -# 46| valnum = r0_8 -# 46| r0_39(int) = Load : r0_38, m0_37 -# 46| valnum = r0_35 -# 46| r0_40(glval) = VariableAddress[y] : -# 46| valnum = r0_10 -# 46| m0_41(int) = Store : r0_40, r0_39 -# 46| valnum = r0_35 -# 47| v0_42(void) = NoOp : -# 39| r0_43(glval) = VariableAddress[#return] : +# 45| r0_37(int) = Add : r0_34, r0_36 +# 45| valnum = r0_37 +# 45| r0_38(glval) = VariableAddress[x] : +# 45| valnum = r0_9 +# 45| m0_39(int) = Store : r0_38, r0_37 +# 45| valnum = r0_37 +# 46| r0_40(glval) = VariableAddress[x] : +# 46| valnum = r0_9 +# 46| r0_41(int) = Load : r0_40, m0_39 +# 46| valnum = r0_37 +# 46| r0_42(glval) = VariableAddress[y] : +# 46| valnum = r0_11 +# 46| m0_43(int) = Store : r0_42, r0_41 +# 46| valnum = r0_37 +# 47| v0_44(void) = NoOp : +# 39| r0_45(glval) = VariableAddress[#return] : # 39| valnum = unique -# 39| v0_44(void) = ReturnValue : r0_43 -# 39| v0_45(void) = UnmodeledUse : mu* -# 39| v0_46(void) = ExitFunction : +# 39| v0_46(void) = ReturnValue : r0_45 +# 39| v0_47(void) = UnmodeledUse : mu* +# 39| v0_48(void) = ExitFunction : # 49| my_strspn(const char *, const char *) -> unsigned int # 49| Block 0 # 49| v0_0(void) = EnterFunction : -# 49| mu0_1(unknown) = UnmodeledDefinition : +# 49| m0_1(unknown) = AliasedDefinition : # 49| valnum = unique -# 49| r0_2(glval) = VariableAddress[str] : -# 49| valnum = r0_2 -# 49| m0_3(char *) = InitializeParameter[str] : r0_2 -# 49| valnum = m0_3 -# 49| r0_4(glval) = VariableAddress[chars] : -# 49| valnum = r0_4 -# 49| m0_5(char *) = InitializeParameter[chars] : r0_4 -# 49| valnum = m0_5 -# 50| r0_6(glval) = VariableAddress[ptr] : -# 50| valnum = r0_6 -# 50| m0_7(char *) = Uninitialized : r0_6 +# 49| mu0_2(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 : r0_7 # 50| valnum = unique -# 51| r0_8(glval) = VariableAddress[result] : -# 51| valnum = r0_8 -# 51| r0_9(unsigned int) = Constant[0] : -# 51| valnum = r0_9 -# 51| m0_10(unsigned int) = Store : r0_8, r0_9 +# 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 #-----| Goto -> Block 1 # 53| Block 1 -# 53| m1_0(unsigned int) = Phi : from 0:m0_10, from 8:m8_4 +# 53| m1_0(unsigned int) = Phi : from 0:m0_11, from 8:m8_4 # 53| valnum = unique # 53| r1_1(glval) = VariableAddress[str] : -# 53| valnum = r0_2 -# 53| r1_2(char *) = Load : r1_1, m0_3 -# 53| valnum = m0_3 -# 53| r1_3(char) = Load : r1_2, mu0_1 +# 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| valnum = unique # 53| r1_4(int) = Convert : r1_3 # 53| valnum = unique @@ -368,31 +384,31 @@ test.cpp: # 55| Block 2 # 55| r2_0(glval) = VariableAddress[chars] : -# 55| valnum = r0_4 -# 55| r2_1(char *) = Load : r2_0, m0_5 -# 55| valnum = m0_5 +# 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_6 +# 55| valnum = r0_7 # 55| m2_3(char *) = Store : r2_2, r2_1 -# 55| valnum = m0_5 +# 55| valnum = m0_6 #-----| Goto -> Block 3 # 56| Block 3 # 56| m3_0(char *) = Phi : from 2:m2_3, from 5:m5_4 # 56| valnum = unique # 56| r3_1(glval) = VariableAddress[ptr] : -# 56| valnum = r0_6 +# 56| valnum = r0_7 # 56| r3_2(char *) = Load : r3_1, m3_0 # 56| valnum = unique -# 56| r3_3(char) = Load : r3_2, mu0_1 +# 56| r3_3(char) = Load : r3_2, m0_1 # 56| valnum = unique # 56| r3_4(int) = Convert : r3_3 # 56| valnum = unique # 56| r3_5(glval) = VariableAddress[str] : -# 56| valnum = r0_2 -# 56| r3_6(char *) = Load : r3_5, m0_3 -# 56| valnum = m0_3 -# 56| r3_7(char) = Load : r3_6, mu0_1 +# 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| valnum = unique # 56| r3_8(int) = Convert : r3_7 # 56| valnum = unique @@ -404,10 +420,10 @@ test.cpp: # 56| Block 4 # 56| r4_0(glval) = VariableAddress[ptr] : -# 56| valnum = r0_6 +# 56| valnum = r0_7 # 56| r4_1(char *) = Load : r4_0, m3_0 # 56| valnum = unique -# 56| r4_2(char) = Load : r4_1, mu0_1 +# 56| r4_2(char) = Load : r4_1, m0_1 # 56| valnum = unique # 56| r4_3(int) = Convert : r4_2 # 56| valnum = unique @@ -421,7 +437,7 @@ test.cpp: # 56| Block 5 # 56| r5_0(glval) = VariableAddress[ptr] : -# 56| valnum = r0_6 +# 56| valnum = r0_7 # 56| r5_1(char *) = Load : r5_0, m3_0 # 56| valnum = unique # 56| r5_2(int) = Constant[1] : @@ -434,10 +450,10 @@ test.cpp: # 59| Block 6 # 59| r6_0(glval) = VariableAddress[ptr] : -# 59| valnum = r0_6 +# 59| valnum = r0_7 # 59| r6_1(char *) = Load : r6_0, m3_0 # 59| valnum = unique -# 59| r6_2(char) = Load : r6_1, mu0_1 +# 59| r6_2(char) = Load : r6_1, m0_1 # 59| valnum = unique # 59| r6_3(int) = Convert : r6_2 # 59| valnum = unique @@ -455,7 +471,7 @@ test.cpp: # 62| Block 8 # 62| r8_0(glval) = VariableAddress[result] : -# 62| valnum = r0_8 +# 62| valnum = r0_9 # 62| r8_1(unsigned int) = Load : r8_0, m1_0 # 62| valnum = unique # 62| r8_2(unsigned int) = Constant[1] : @@ -471,7 +487,7 @@ test.cpp: # 65| r9_1(glval) = VariableAddress[#return] : # 65| valnum = r9_1 # 65| r9_2(glval) = VariableAddress[result] : -# 65| valnum = r0_8 +# 65| valnum = r0_9 # 65| r9_3(unsigned int) = Load : r9_2, m1_0 # 65| valnum = r9_3 # 65| m9_4(unsigned int) = Store : r9_1, r9_3 @@ -485,53 +501,59 @@ test.cpp: # 75| test04(two_values *) -> void # 75| Block 0 # 75| v0_0(void) = EnterFunction : -# 75| mu0_1(unknown) = UnmodeledDefinition : +# 75| m0_1(unknown) = AliasedDefinition : # 75| valnum = unique -# 75| r0_2(glval) = VariableAddress[vals] : -# 75| valnum = r0_2 -# 75| m0_3(two_values *) = InitializeParameter[vals] : r0_2 -# 75| valnum = m0_3 -# 77| r0_4(glval) = VariableAddress[v] : -# 77| valnum = r0_4 -# 77| r0_5(glval) = FunctionAddress[getAValue] : +# 75| mu0_2(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] : # 77| valnum = unique -# 77| r0_6(int) = Call : r0_5 +# 77| r0_7(int) = Call : r0_6 # 77| valnum = unique -# 77| r0_7(signed short) = Convert : r0_6 -# 77| valnum = r0_7 -# 77| m0_8(signed short) = Store : r0_4, r0_7 -# 77| valnum = r0_7 -# 79| r0_9(glval) = VariableAddress[v] : -# 79| valnum = r0_4 -# 79| r0_10(signed short) = Load : r0_9, m0_8 -# 79| valnum = r0_7 -# 79| r0_11(int) = Convert : r0_10 +# 77| m0_8(unknown) = ^CallSideEffect : m0_1 +# 77| valnum = unique +# 77| m0_9(unknown) = Chi : m0_1, m0_8 +# 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 # 79| valnum = unique -# 79| r0_12(glval) = VariableAddress[vals] : -# 79| valnum = r0_2 -# 79| r0_13(two_values *) = Load : r0_12, m0_3 -# 79| valnum = m0_3 -# 79| r0_14(glval) = FieldAddress[val1] : r0_13 +# 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| valnum = unique -# 79| r0_15(signed short) = Load : r0_14, mu0_1 +# 79| r0_18(signed short) = Load : r0_17, m0_9 # 79| valnum = unique -# 79| r0_16(int) = Convert : r0_15 +# 79| r0_19(int) = Convert : r0_18 # 79| valnum = unique -# 79| r0_17(glval) = VariableAddress[vals] : -# 79| valnum = r0_2 -# 79| r0_18(two_values *) = Load : r0_17, m0_3 -# 79| valnum = m0_3 -# 79| r0_19(glval) = FieldAddress[val2] : r0_18 +# 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| valnum = unique -# 79| r0_20(signed short) = Load : r0_19, mu0_1 +# 79| r0_23(signed short) = Load : r0_22, m0_9 # 79| valnum = unique -# 79| r0_21(int) = Convert : r0_20 +# 79| r0_24(int) = Convert : r0_23 # 79| valnum = unique -# 79| r0_22(int) = Add : r0_16, r0_21 +# 79| r0_25(int) = Add : r0_19, r0_24 # 79| valnum = unique -# 79| r0_23(bool) = CompareLT : r0_11, r0_22 +# 79| r0_26(bool) = CompareLT : r0_14, r0_25 # 79| valnum = unique -# 79| v0_24(void) = ConditionalBranch : r0_23 +# 79| v0_27(void) = ConditionalBranch : r0_26 #-----| False -> Block 2 #-----| True -> Block 1 @@ -540,12 +562,16 @@ test.cpp: # 80| valnum = unique # 80| r1_1(int) = Call : r1_0 # 80| valnum = unique -# 80| r1_2(signed short) = Convert : r1_1 -# 80| valnum = r1_2 -# 80| r1_3(glval) = VariableAddress[v] : -# 80| valnum = r0_4 -# 80| m1_4(signed short) = Store : r1_3, r1_2 -# 80| valnum = r1_2 +# 80| m1_2(unknown) = ^CallSideEffect : m0_9 +# 80| valnum = unique +# 80| m1_3(unknown) = Chi : m0_9, m1_2 +# 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 #-----| Goto -> Block 2 # 82| Block 2 @@ -557,56 +583,58 @@ test.cpp: # 84| test05(int, int, void *) -> void # 84| Block 0 # 84| v0_0(void) = EnterFunction : -# 84| mu0_1(unknown) = UnmodeledDefinition : +# 84| m0_1(unknown) = AliasedDefinition : # 84| valnum = unique -# 84| r0_2(glval) = VariableAddress[x] : -# 84| valnum = r0_2 -# 84| m0_3(int) = InitializeParameter[x] : r0_2 -# 84| valnum = m0_3 -# 84| r0_4(glval) = VariableAddress[y] : -# 84| valnum = r0_4 -# 84| m0_5(int) = InitializeParameter[y] : r0_4 -# 84| valnum = m0_5 -# 84| r0_6(glval) = VariableAddress[p] : -# 84| valnum = r0_6 -# 84| m0_7(void *) = InitializeParameter[p] : r0_6 -# 84| valnum = m0_7 -# 86| r0_8(glval) = VariableAddress[v] : -# 86| valnum = r0_8 -# 86| m0_9(int) = Uninitialized : r0_8 +# 84| mu0_2(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 : r0_9 # 86| valnum = unique -# 88| r0_10(glval) = VariableAddress[p] : -# 88| valnum = r0_6 -# 88| r0_11(void *) = Load : r0_10, m0_7 -# 88| valnum = m0_7 -# 88| r0_12(void *) = Constant[0] : +# 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| valnum = unique -# 88| r0_13(bool) = CompareNE : r0_11, r0_12 +# 88| r0_14(bool) = CompareNE : r0_12, r0_13 # 88| valnum = unique -# 88| v0_14(void) = ConditionalBranch : r0_13 +# 88| v0_15(void) = ConditionalBranch : r0_14 #-----| False -> Block 2 #-----| True -> Block 1 # 88| Block 1 # 88| r1_0(glval) = VariableAddress[x] : -# 88| valnum = r0_2 -# 88| r1_1(int) = Load : r1_0, m0_3 -# 88| valnum = m0_3 +# 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_3 +# 88| valnum = m0_4 #-----| Goto -> Block 3 # 88| Block 2 # 88| r2_0(glval) = VariableAddress[y] : -# 88| valnum = r0_4 -# 88| r2_1(int) = Load : r2_0, m0_5 -# 88| valnum = m0_5 +# 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_5 +# 88| valnum = m0_6 #-----| Goto -> Block 3 # 88| Block 3 @@ -617,7 +645,7 @@ test.cpp: # 88| r3_2(int) = Load : r3_1, m3_0 # 88| valnum = r3_2 # 88| r3_3(glval) = VariableAddress[v] : -# 88| valnum = r0_8 +# 88| valnum = r0_9 # 88| m3_4(int) = Store : r3_3, r3_2 # 88| valnum = r3_2 # 89| v3_5(void) = NoOp : @@ -628,87 +656,91 @@ test.cpp: # 91| regression_test00() -> int # 91| Block 0 # 91| v0_0(void) = EnterFunction : -# 91| mu0_1(unknown) = UnmodeledDefinition : +# 91| m0_1(unknown) = AliasedDefinition : # 91| valnum = unique -# 92| r0_2(glval) = VariableAddress[x] : -# 92| valnum = r0_2 -# 92| r0_3(int) = Constant[10] : +# 91| mu0_2(unknown) = UnmodeledDefinition : +# 91| valnum = unique +# 92| r0_3(glval) = VariableAddress[x] : # 92| valnum = r0_3 -# 92| r0_4(glval) = VariableAddress[x] : -# 92| valnum = r0_2 -# 92| m0_5(int) = Store : r0_4, 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_2, r0_3 -# 92| valnum = r0_3 -# 93| r0_7(glval) = VariableAddress[#return] : -# 93| valnum = r0_7 -# 93| r0_8(glval) = VariableAddress[x] : -# 93| valnum = r0_2 -# 93| r0_9(int) = Load : r0_8, m0_6 +# 92| m0_6(int) = Store : r0_5, r0_4 +# 92| valnum = r0_4 +# 92| m0_7(int) = Store : r0_3, r0_4 +# 92| valnum = r0_4 +# 93| r0_8(glval) = VariableAddress[#return] : +# 93| valnum = r0_8 +# 93| r0_9(glval) = VariableAddress[x] : # 93| valnum = r0_3 -# 93| m0_10(int) = Store : r0_7, r0_9 -# 93| valnum = r0_3 -# 91| r0_11(glval) = VariableAddress[#return] : -# 91| valnum = r0_7 -# 91| v0_12(void) = ReturnValue : r0_11, m0_10 -# 91| v0_13(void) = UnmodeledUse : mu* -# 91| v0_14(void) = ExitFunction : +# 93| r0_10(int) = Load : r0_9, m0_7 +# 93| valnum = r0_4 +# 93| m0_11(int) = Store : r0_8, r0_10 +# 93| valnum = r0_4 +# 91| r0_12(glval) = VariableAddress[#return] : +# 91| valnum = r0_8 +# 91| v0_13(void) = ReturnValue : r0_12, m0_11 +# 91| v0_14(void) = UnmodeledUse : mu* +# 91| v0_15(void) = ExitFunction : # 104| inheritanceConversions(Derived *) -> int # 104| Block 0 # 104| v0_0(void) = EnterFunction : -# 104| mu0_1(unknown) = UnmodeledDefinition : +# 104| m0_1(unknown) = AliasedDefinition : # 104| valnum = unique -# 104| r0_2(glval) = VariableAddress[pd] : -# 104| valnum = r0_2 -# 104| m0_3(Derived *) = InitializeParameter[pd] : r0_2 -# 104| valnum = m0_3 -# 105| r0_4(glval) = VariableAddress[x] : +# 104| mu0_2(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] : # 105| valnum = unique -# 105| r0_5(glval) = VariableAddress[pd] : -# 105| valnum = r0_2 -# 105| r0_6(Derived *) = Load : r0_5, m0_3 -# 105| valnum = m0_3 -# 105| r0_7(Base *) = ConvertToBase[Derived : Base] : r0_6 -# 105| valnum = r0_7 -# 105| r0_8(glval) = FieldAddress[b] : r0_7 +# 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 *) = ConvertToBase[Derived : Base] : r0_7 # 105| valnum = r0_8 -# 105| r0_9(int) = Load : r0_8, mu0_1 +# 105| r0_9(glval) = FieldAddress[b] : r0_8 # 105| valnum = r0_9 -# 105| m0_10(int) = Store : r0_4, r0_9 -# 105| valnum = r0_9 -# 106| r0_11(glval) = VariableAddress[pb] : -# 106| valnum = r0_11 -# 106| r0_12(glval) = VariableAddress[pd] : -# 106| valnum = r0_2 -# 106| r0_13(Derived *) = Load : r0_12, m0_3 -# 106| valnum = m0_3 -# 106| r0_14(Base *) = ConvertToBase[Derived : Base] : r0_13 -# 106| valnum = r0_7 -# 106| m0_15(Base *) = Store : r0_11, r0_14 -# 106| valnum = r0_7 -# 107| r0_16(glval) = VariableAddress[y] : -# 107| valnum = r0_16 -# 107| r0_17(glval) = VariableAddress[pb] : -# 107| valnum = r0_11 -# 107| r0_18(Base *) = Load : r0_17, m0_15 -# 107| valnum = r0_7 -# 107| r0_19(glval) = FieldAddress[b] : r0_18 +# 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 *) = ConvertToBase[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(int) = Load : r0_19, mu0_1 -# 107| valnum = r0_20 -# 107| m0_21(int) = Store : r0_16, r0_20 -# 107| valnum = r0_20 -# 109| r0_22(glval) = VariableAddress[#return] : -# 109| valnum = r0_22 -# 109| r0_23(glval) = VariableAddress[y] : -# 109| valnum = r0_16 -# 109| r0_24(int) = Load : r0_23, m0_21 -# 109| valnum = r0_20 -# 109| m0_25(int) = Store : r0_22, r0_24 -# 109| valnum = r0_20 -# 104| r0_26(glval) = VariableAddress[#return] : -# 104| valnum = r0_22 -# 104| v0_27(void) = ReturnValue : r0_26, m0_25 -# 104| v0_28(void) = UnmodeledUse : mu* -# 104| v0_29(void) = ExitFunction : +# 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) = ExitFunction : diff --git a/javascript/config/suites/javascript/security b/javascript/config/suites/javascript/security index ee9e07b578b..aa71a31bff9 100644 --- a/javascript/config/suites/javascript/security +++ b/javascript/config/suites/javascript/security @@ -20,12 +20,14 @@ + semmlecode-javascript-queries/Security/CWE-352/MissingCsrfMiddleware.ql: /Security/CWE/CWE-352 + semmlecode-javascript-queries/Security/CWE-400/RemotePropertyInjection.ql: /Security/CWE/CWE-400 + semmlecode-javascript-queries/Security/CWE-502/UnsafeDeserialization.ql: /Security/CWE/CWE-502 ++ semmlecode-javascript-queries/Security/CWE-506/HardcodedDataInterpretedAsCode.ql: /Security/CWE/CWE-506 + semmlecode-javascript-queries/Security/CWE-601/ClientSideUrlRedirect.ql: /Security/CWE/CWE-601 + semmlecode-javascript-queries/Security/CWE-601/ServerSideUrlRedirect.ql: /Security/CWE/CWE-601 + semmlecode-javascript-queries/Security/CWE-611/Xxe.ql: /Security/CWE/CWE-611 + semmlecode-javascript-queries/Security/CWE-640/HostHeaderPoisoningInEmailGeneration.ql: /Security/CWE/CWE-640 + semmlecode-javascript-queries/Security/CWE-643/XpathInjection.ql: /Security/CWE/CWE-643 + semmlecode-javascript-queries/Security/CWE-730/RegExpInjection.ql: /Security/CWE/CWE-730 ++ semmlecode-javascript-queries/Security/CWE-754/UnvalidatedDynamicMethodCall.ql: /Security/CWE/CWE-754 + semmlecode-javascript-queries/Security/CWE-770/MissingRateLimiting.ql: /Security/CWE/CWE-770 + semmlecode-javascript-queries/Security/CWE-776/XmlBomb.ql: /Security/CWE/CWE-776 + semmlecode-javascript-queries/Security/CWE-798/HardcodedCredentials.ql: /Security/CWE/CWE-798 diff --git a/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java b/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java index 1be577c04ae..1e88d1897cd 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java +++ b/javascript/extractor/src/com/semmle/js/extractor/FileExtractor.java @@ -5,6 +5,7 @@ import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; +import java.nio.charset.Charset; import java.util.LinkedHashSet; import java.util.Set; import java.util.regex.Pattern; @@ -38,6 +39,11 @@ public class FileExtractor { */ public static final Pattern JSON_OBJECT_START = Pattern.compile("^(?s)\\s*\\{\\s*\"([^\"]|\\\\.)*\"\\s*:.*"); + /** + * The charset for decoding UTF-8 strings. + */ + private static final Charset UTF8_CHARSET = Charset.forName("UTF-8"); + /** * Information about supported file types. */ @@ -169,6 +175,11 @@ public class FileExtractor { if (isXml(bytes, length)) return true; + // Avoid files with an unrecognized shebang header. + if (hasUnrecognizedShebang(bytes, length)) { + return true; + } + return false; } catch (IOException e) { Exceptions.ignore(e, "Let extractor handle this one."); @@ -249,6 +260,38 @@ public class FileExtractor { return false; } + /** + * Returns true if the byte sequence starts with a shebang line that is not + * recognized as a JavaScript interpreter. + */ + private boolean hasUnrecognizedShebang(byte[] bytes, int length) { + // Shebangs preceded by a BOM aren't recognized in UNIX, but the BOM might only + // be present in the source file, to be stripped out in the build process. + int startIndex = skipBOM(bytes, length); + if (startIndex + 2 >= length) return false; + if (bytes[startIndex] != '#' || bytes[startIndex + 1] != '!') { + return false; + } + int endOfLine = -1; + for (int i = startIndex; i < length; ++i) { + if (bytes[i] == '\r' || bytes[i] == '\n') { + endOfLine = i; + break; + } + } + if (endOfLine == -1) { + // The shebang is either very long or there are no other lines in the file. + // Treat this as unrecognized. + return true; + } + // Extract the shebang text + int startOfText = startIndex + "#!".length(); + int lengthOfText = endOfLine - startOfText; + String text = new String(bytes, startOfText, lengthOfText, UTF8_CHARSET); + // Check if the shebang is a recognized JavaScript intepreter. + return !NODE_INVOCATION.matcher(text).find(); + } + @Override public IExtractor mkExtractor(ExtractorConfig config, ExtractorState state) { return new TypeScriptExtractor(config, state.getTypeScriptParser()); diff --git a/javascript/extractor/tests/shebang/input/not-typescript.ts b/javascript/extractor/tests/shebang/input/not-typescript.ts new file mode 100644 index 00000000000..6953faca516 --- /dev/null +++ b/javascript/extractor/tests/shebang/input/not-typescript.ts @@ -0,0 +1,5 @@ +#!/usr/bin/env perl + +use strict; + +exit 0; diff --git a/javascript/extractor/tests/shebang/input/typescript-with-shebang.ts b/javascript/extractor/tests/shebang/input/typescript-with-shebang.ts new file mode 100644 index 00000000000..bed2eaa1fbb --- /dev/null +++ b/javascript/extractor/tests/shebang/input/typescript-with-shebang.ts @@ -0,0 +1,4 @@ +#!/usr/bin/env node +interface Foo { + x: number; +} diff --git a/javascript/extractor/tests/shebang/input/typescript.ts b/javascript/extractor/tests/shebang/input/typescript.ts new file mode 100644 index 00000000000..a9a86d5ce04 --- /dev/null +++ b/javascript/extractor/tests/shebang/input/typescript.ts @@ -0,0 +1,3 @@ +interface Foo { + x: number; +} diff --git a/javascript/extractor/tests/shebang/options.json b/javascript/extractor/tests/shebang/options.json new file mode 100644 index 00000000000..cdf22d686fd --- /dev/null +++ b/javascript/extractor/tests/shebang/options.json @@ -0,0 +1,3 @@ +{ + "typescript": true +} diff --git a/javascript/extractor/tests/shebang/output/trap/typescript-with-shebang.ts.trap b/javascript/extractor/tests/shebang/output/trap/typescript-with-shebang.ts.trap new file mode 100644 index 00000000000..cd7804866b8 --- /dev/null +++ b/javascript/extractor/tests/shebang/output/trap/typescript-with-shebang.ts.trap @@ -0,0 +1,129 @@ +#10000=@"/typescript-with-shebang.ts;sourcefile" +files(#10000,"/typescript-with-shebang.ts","typescript-with-shebang","ts",0) +#10001=@"/;folder" +folders(#10001,"/","") +containerparent(#10001,#10000) +#10002=@"loc,{#10000},0,0,0,0" +locations_default(#10002,#10000,0,0,0,0) +hasLocation(#10000,#10002) +#20000=@"global_scope" +scopes(#20000,0) +#20001=@"script;{#10000},1,1" +toplevels(#20001,0) +#20002=@"loc,{#10000},1,1,5,0" +locations_default(#20002,#10000,1,1,5,0) +hasLocation(#20001,#20002) +#20003=@"local_type_name;{Foo};{#20000}" +local_type_names(#20003,"Foo",#20000) +#20004=* +stmts(#20004,34,#20001,0,"#!/usr/ ... mber;\n}") +#20005=@"loc,{#10000},1,1,4,1" +locations_default(#20005,#10000,1,1,4,1) +hasLocation(#20004,#20005) +stmtContainers(#20004,#20001) +#20006=* +typeexprs(#20006,1,#20004,0,"Foo") +#20007=@"loc,{#10000},2,11,2,13" +locations_default(#20007,#10000,2,11,2,13) +hasLocation(#20006,#20007) +enclosingStmt(#20006,#20004) +exprContainers(#20006,#20001) +literals("Foo","Foo",#20006) +typedecl(#20006,#20003) +#20008=* +properties(#20008,#20004,2,8,"x: number;") +#20009=@"loc,{#10000},3,3,3,12" +locations_default(#20009,#10000,3,3,3,12) +hasLocation(#20008,#20009) +#20010=* +exprs(#20010,0,#20008,0,"x") +#20011=@"loc,{#10000},3,3,3,3" +locations_default(#20011,#10000,3,3,3,3) +hasLocation(#20010,#20011) +enclosingStmt(#20010,#20004) +exprContainers(#20010,#20001) +literals("x","x",#20010) +isAbstractMember(#20008) +#20012=* +typeexprs(#20012,2,#20008,2,"number") +#20013=@"loc,{#10000},3,6,3,11" +locations_default(#20013,#10000,3,6,3,11) +hasLocation(#20012,#20013) +enclosingStmt(#20012,#20004) +exprContainers(#20012,#20001) +literals("number","number",#20012) +#20014=* +lines(#20014,#20001,"#!/usr/bin/env node"," +") +#20015=@"loc,{#10000},1,1,1,19" +locations_default(#20015,#10000,1,1,1,19) +hasLocation(#20014,#20015) +#20016=* +lines(#20016,#20001,"interface Foo {"," +") +#20017=@"loc,{#10000},2,1,2,15" +locations_default(#20017,#10000,2,1,2,15) +hasLocation(#20016,#20017) +#20018=* +lines(#20018,#20001," x: number;"," +") +#20019=@"loc,{#10000},3,1,3,12" +locations_default(#20019,#10000,3,1,3,12) +hasLocation(#20018,#20019) +indentation(#10000,3," ",2) +#20020=* +lines(#20020,#20001,"}"," +") +#20021=@"loc,{#10000},4,1,4,1" +locations_default(#20021,#10000,4,1,4,1) +hasLocation(#20020,#20021) +numlines(#20001,4,3,0) +#20022=* +tokeninfo(#20022,7,#20001,0,"interface") +#20023=@"loc,{#10000},2,1,2,9" +locations_default(#20023,#10000,2,1,2,9) +hasLocation(#20022,#20023) +#20024=* +tokeninfo(#20024,6,#20001,1,"Foo") +hasLocation(#20024,#20007) +#20025=* +tokeninfo(#20025,8,#20001,2,"{") +#20026=@"loc,{#10000},2,15,2,15" +locations_default(#20026,#10000,2,15,2,15) +hasLocation(#20025,#20026) +#20027=* +tokeninfo(#20027,6,#20001,3,"x") +hasLocation(#20027,#20011) +#20028=* +tokeninfo(#20028,8,#20001,4,":") +#20029=@"loc,{#10000},3,4,3,4" +locations_default(#20029,#10000,3,4,3,4) +hasLocation(#20028,#20029) +#20030=* +tokeninfo(#20030,7,#20001,5,"number") +hasLocation(#20030,#20013) +#20031=* +tokeninfo(#20031,8,#20001,6,";") +#20032=@"loc,{#10000},3,12,3,12" +locations_default(#20032,#10000,3,12,3,12) +hasLocation(#20031,#20032) +#20033=* +tokeninfo(#20033,8,#20001,7,"}") +hasLocation(#20033,#20021) +#20034=* +tokeninfo(#20034,0,#20001,8,"") +#20035=@"loc,{#10000},5,1,5,0" +locations_default(#20035,#10000,5,1,5,0) +hasLocation(#20034,#20035) +#20036=* +entry_cfg_node(#20036,#20001) +#20037=@"loc,{#10000},1,1,1,0" +locations_default(#20037,#10000,1,1,1,0) +hasLocation(#20036,#20037) +#20038=* +exit_cfg_node(#20038,#20001) +hasLocation(#20038,#20035) +successor(#20004,#20038) +successor(#20036,#20004) +numlines(#10000,4,3,0) +filetype(#10000,"typescript") diff --git a/javascript/extractor/tests/shebang/output/trap/typescript.ts.trap b/javascript/extractor/tests/shebang/output/trap/typescript.ts.trap new file mode 100644 index 00000000000..936f5ce0896 --- /dev/null +++ b/javascript/extractor/tests/shebang/output/trap/typescript.ts.trap @@ -0,0 +1,123 @@ +#10000=@"/typescript.ts;sourcefile" +files(#10000,"/typescript.ts","typescript","ts",0) +#10001=@"/;folder" +folders(#10001,"/","") +containerparent(#10001,#10000) +#10002=@"loc,{#10000},0,0,0,0" +locations_default(#10002,#10000,0,0,0,0) +hasLocation(#10000,#10002) +#20000=@"global_scope" +scopes(#20000,0) +#20001=@"script;{#10000},1,1" +toplevels(#20001,0) +#20002=@"loc,{#10000},1,1,4,0" +locations_default(#20002,#10000,1,1,4,0) +hasLocation(#20001,#20002) +#20003=@"local_type_name;{Foo};{#20000}" +local_type_names(#20003,"Foo",#20000) +#20004=* +stmts(#20004,34,#20001,0,"interfa ... mber;\n}") +#20005=@"loc,{#10000},1,1,3,1" +locations_default(#20005,#10000,1,1,3,1) +hasLocation(#20004,#20005) +stmtContainers(#20004,#20001) +#20006=* +typeexprs(#20006,1,#20004,0,"Foo") +#20007=@"loc,{#10000},1,11,1,13" +locations_default(#20007,#10000,1,11,1,13) +hasLocation(#20006,#20007) +enclosingStmt(#20006,#20004) +exprContainers(#20006,#20001) +literals("Foo","Foo",#20006) +typedecl(#20006,#20003) +#20008=* +properties(#20008,#20004,2,8,"x: number;") +#20009=@"loc,{#10000},2,3,2,12" +locations_default(#20009,#10000,2,3,2,12) +hasLocation(#20008,#20009) +#20010=* +exprs(#20010,0,#20008,0,"x") +#20011=@"loc,{#10000},2,3,2,3" +locations_default(#20011,#10000,2,3,2,3) +hasLocation(#20010,#20011) +enclosingStmt(#20010,#20004) +exprContainers(#20010,#20001) +literals("x","x",#20010) +isAbstractMember(#20008) +#20012=* +typeexprs(#20012,2,#20008,2,"number") +#20013=@"loc,{#10000},2,6,2,11" +locations_default(#20013,#10000,2,6,2,11) +hasLocation(#20012,#20013) +enclosingStmt(#20012,#20004) +exprContainers(#20012,#20001) +literals("number","number",#20012) +#20014=* +lines(#20014,#20001,"interface Foo {"," +") +#20015=@"loc,{#10000},1,1,1,15" +locations_default(#20015,#10000,1,1,1,15) +hasLocation(#20014,#20015) +#20016=* +lines(#20016,#20001," x: number;"," +") +#20017=@"loc,{#10000},2,1,2,12" +locations_default(#20017,#10000,2,1,2,12) +hasLocation(#20016,#20017) +indentation(#10000,2," ",2) +#20018=* +lines(#20018,#20001,"}"," +") +#20019=@"loc,{#10000},3,1,3,1" +locations_default(#20019,#10000,3,1,3,1) +hasLocation(#20018,#20019) +numlines(#20001,3,3,0) +#20020=* +tokeninfo(#20020,7,#20001,0,"interface") +#20021=@"loc,{#10000},1,1,1,9" +locations_default(#20021,#10000,1,1,1,9) +hasLocation(#20020,#20021) +#20022=* +tokeninfo(#20022,6,#20001,1,"Foo") +hasLocation(#20022,#20007) +#20023=* +tokeninfo(#20023,8,#20001,2,"{") +#20024=@"loc,{#10000},1,15,1,15" +locations_default(#20024,#10000,1,15,1,15) +hasLocation(#20023,#20024) +#20025=* +tokeninfo(#20025,6,#20001,3,"x") +hasLocation(#20025,#20011) +#20026=* +tokeninfo(#20026,8,#20001,4,":") +#20027=@"loc,{#10000},2,4,2,4" +locations_default(#20027,#10000,2,4,2,4) +hasLocation(#20026,#20027) +#20028=* +tokeninfo(#20028,7,#20001,5,"number") +hasLocation(#20028,#20013) +#20029=* +tokeninfo(#20029,8,#20001,6,";") +#20030=@"loc,{#10000},2,12,2,12" +locations_default(#20030,#10000,2,12,2,12) +hasLocation(#20029,#20030) +#20031=* +tokeninfo(#20031,8,#20001,7,"}") +hasLocation(#20031,#20019) +#20032=* +tokeninfo(#20032,0,#20001,8,"") +#20033=@"loc,{#10000},4,1,4,0" +locations_default(#20033,#10000,4,1,4,0) +hasLocation(#20032,#20033) +#20034=* +entry_cfg_node(#20034,#20001) +#20035=@"loc,{#10000},1,1,1,0" +locations_default(#20035,#10000,1,1,1,0) +hasLocation(#20034,#20035) +#20036=* +exit_cfg_node(#20036,#20001) +hasLocation(#20036,#20033) +successor(#20004,#20036) +successor(#20034,#20004) +numlines(#10000,3,3,0) +filetype(#10000,"typescript") diff --git a/javascript/ql/src/LanguageFeatures/InconsistentNew.ql b/javascript/ql/src/LanguageFeatures/InconsistentNew.ql index 05ab926cc2b..a9fa57cfce6 100644 --- a/javascript/ql/src/LanguageFeatures/InconsistentNew.ql +++ b/javascript/ql/src/LanguageFeatures/InconsistentNew.ql @@ -56,26 +56,60 @@ predicate calls(DataFlow::InvokeNode cs, Function callee, int imprecision) { /** * Gets a function that may be invoked at `cs`, preferring callees that - * are less likely to be derived due to analysis imprecision. + * are less likely to be derived due to analysis imprecision and excluding + * whitelisted call sites and callees. Additionally, `isNew` is bound to + * `true` if `cs` is a `new` expression, and to `false` otherwise. */ -Function getALikelyCallee(DataFlow::InvokeNode cs) { - calls(cs, result, min(int p | calls(cs, _, p))) +Function getALikelyCallee(DataFlow::InvokeNode cs, boolean isNew) { + calls(cs, result, min(int p | calls(cs, _, p))) and + not cs.isUncertain() and + not whitelistedCall(cs) and + not whitelistedCallee(result) and + (cs instanceof DataFlow::NewNode and isNew = true + or + cs instanceof DataFlow::CallNode and isNew = false) +} + +/** + * Holds if `f` should be whitelisted, either because it guards against + * inconsistent `new` or we do not want to report it. + */ +predicate whitelistedCallee(Function f) { + // externs are special, so don't flag them + f.inExternsFile() or + // illegal constructor calls are flagged by query 'Illegal invocation', + // so don't flag them + f instanceof Constructor or + // if `f` itself guards against missing `new`, don't flag it + guardsAgainstMissingNew(f) +} + +/** + * Holds if `call` should be whitelisted because it cannot cause problems + * with inconsistent `new`. + */ +predicate whitelistedCall(DataFlow::CallNode call) { + // super constructor calls behave more like `new`, so don't flag them + call.asExpr() instanceof SuperCall or + // don't flag if there is a receiver object + exists(call.getReceiver()) +} + +/** + * Get the `new` or call (depending on whether `isNew` is true or false) of `f` + * that comes first under a lexicographical ordering by file path, start line + * and start column. + */ +DataFlow::InvokeNode getFirstInvocation(Function f, boolean isNew) { + result = min(DataFlow::InvokeNode invk, string path, int line, int col | + f = getALikelyCallee(invk, isNew) and invk.hasLocationInfo(path, line, col, _, _) | + invk order by path, line, col + ) } from Function f, DataFlow::NewNode new, DataFlow::CallNode call -where // externs are special, so don't flag them - not f.inExternsFile() and - // illegal constructor calls are flagged by query 'Illegal invocation', - // so don't flag them - not f instanceof Constructor and - f = getALikelyCallee(new) and - f = getALikelyCallee(call) and - not guardsAgainstMissingNew(f) and - not new.isUncertain() and - not call.isUncertain() and - // super constructor calls behave more like `new`, so don't flag them - not call.asExpr() instanceof SuperCall and - // don't flag if there is a receiver object - not exists(call.getReceiver()) -select (FirstLineOf)f, capitalize(f.describe()) + " is invoked as a constructor here $@, " + - "and as a normal function here $@.", new, new.toString(), call, call.toString() +where new = getFirstInvocation(f, true) and + call = getFirstInvocation(f, false) +select (FirstLineOf)f, capitalize(f.describe()) + " is sometimes invoked as a constructor " + + "(for example $@), and sometimes as a normal function (for example $@).", + new, "here", call, "here" diff --git a/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.qhelp b/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.qhelp index bfdd32b645e..c93ab4d09f6 100644 --- a/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.qhelp +++ b/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.qhelp @@ -6,31 +6,22 @@

Dynamically computing object property names from untrusted input - may have multiple undesired consequences. For example, - if the property access is used as part of a write, an - attacker may overwrite vital properties of objects, such as - __proto__. This attack is known as prototype - pollution attack and may serve as a vehicle for denial-of-service - attacks. A similar attack vector, is to replace the - toString property of an object with a primitive. - Whenever toString is then called on that object, either - explicitly or implicitly as part of a type coercion, an exception + may have multiple undesired consequences. For example, + if the property access is used as part of a write, an + attacker may overwrite vital properties of objects, such as + __proto__. This attack is known as prototype + pollution attack and may serve as a vehicle for denial-of-service + attacks. A similar attack vector, is to replace the + toString property of an object with a primitive. + Whenever toString is then called on that object, either + explicitly or implicitly as part of a type coercion, an exception will be raised.

- Moreover, if the dynamically computed property is - used as part of a method call, the attacker may trigger - the execution of unwanted functions such as the - Function constructor or the - eval method, which can be used - for code injection. -

- -

- Additionally, if the name of an HTTP header is user-controlled, - an attacker may exploit this to overwrite security-critical headers - such as Access-Control-Allow-Origin or + Moreover, if the name of an HTTP header is user-controlled, + an attacker may exploit this to overwrite security-critical headers + such as Access-Control-Allow-Origin or Content-Security-Policy.

@@ -38,57 +29,57 @@

The most common case in which prototype pollution vulnerabilities arise - is when JavaScript objects are used for implementing map data - structures. This case should be avoided whenever possible by using the - ECMAScript 2015 Map instead. When this is not possible, an - alternative fix is to prepend untrusted input with a marker character - such as $, before using it in properties accesses. In this way, - the attacker does not have access to built-in properties which do not - start with the chosen character. + is when JavaScript objects are used for implementing map data + structures. This case should be avoided whenever possible by using the + ECMAScript 2015 Map instead. When this is not possible, an + alternative fix is to prepend untrusted input with a marker character + such as $, before using it in properties accesses. In this way, + the attacker does not have access to built-in properties which do not + start with the chosen character.

- When using user input as part of header or method names, a sanitization - step should be performed on the input to ensure that the name does not - clash with existing property and header names such as - __proto__ or Content-Security-Policy. + When using user input as part of a header name, a sanitization + step should be performed on the input to ensure that the name does not + clash with existing header names such as + Content-Security-Policy.

- In the example below, the dynamically computed property - prop is accessed on myObj using a + In the example below, the dynamically computed property + prop is accessed on myObj using a user-controlled value.

- This is not secure since an attacker may exploit this code to + This is not secure since an attacker may exploit this code to overwrite the property __proto__ with an empty function. - If this happens, the concatenation in the console.log - argument will fail with a confusing message such as + If this happens, the concatenation in the console.log + argument will fail with a confusing message such as "Function.prototype.toString is not generic". If the application does not properly handle this error, this scenario may result in a serious - denial-of-service attack. The fix is to prepend the user-controlled - string with a marker character such as $ which will - prevent arbitrary property names from being overwritten. + denial-of-service attack. The fix is to prepend the user-controlled + string with a marker character such as $ which will + prevent arbitrary property names from being overwritten.

-
  • Prototype pollution attacks: +
  • Prototype pollution attacks: electron, lodash, hoek.
    • -
  • Penetration testing report: +
  • Penetration testing report: header name injection attack
    • -
  • npm blog post: +
  • npm blog post: dangers of square bracket notation
    • diff --git a/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.ql b/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.ql index 4457899f6b3..1dafa5b2dfc 100644 --- a/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.ql +++ b/javascript/ql/src/Security/CWE-400/RemotePropertyInjection.ql @@ -1,8 +1,7 @@ /** * @name Remote property injection - * @description Allowing writes to arbitrary properties or calls to arbitrary - * methods of an object may lead to denial-of-service attacks. - * + * @description Allowing writes to arbitrary properties of an object may lead to + * denial-of-service attacks. * @kind path-problem * @problem.severity warning * @precision medium diff --git a/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.qhelp b/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.qhelp new file mode 100644 index 00000000000..0c8c9015da5 --- /dev/null +++ b/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.qhelp @@ -0,0 +1,46 @@ + + + + +

    +Interpreting hard-coded data, such as string literals containing hexadecimal numbers, +as code or as an import path is typical of malicious backdoor code that has been +implanted into an otherwise trusted code base and is trying to hide its true purpose +from casual readers or automated scanning tools. +

    +     + + +

    +Examine the code in question carefully to ascertain its provenance and its true purpose. +If the code is benign, it should always be possible to rewrite it without relying +on dynamically interpreting data as code, improving both clarity and safety. +

    +     + + +

    +As an example of malicious code using this obfuscation technique, consider the following +simplified version of a snippet of backdoor code that was discovered in a dependency of +the popular event-stream npm package: +

    + +

    +While this shows only the first few lines of code, it already looks very suspicious +since it takes a hard-coded string literal, hex-decodes it and then uses it as an +import path. The only reason to do so is to hide the name of the file being imported. +

    +     + + +
  • +OWASP: +Trojan Horse. +
    • +
  • +The npm Blog: +Details about the event-stream incident. +
    • +     + +     diff --git a/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.ql b/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.ql new file mode 100644 index 00000000000..e274ac45d37 --- /dev/null +++ b/javascript/ql/src/Security/CWE-506/HardcodedDataInterpretedAsCode.ql @@ -0,0 +1,22 @@ +/** + * @name Hard-coded data interpreted as code + * @description Transforming hard-coded data (such as hexadecimal constants) into code + * to be executed is a technique often associated with backdoors and should + * be avoided. + * @kind path-problem + * @problem.severity error + * @precision medium + * @id js/hardcoded-data-interpreted-as-code + * @tags security + * external/cwe/cwe-506 + */ + +import javascript +import semmle.javascript.security.dataflow.HardcodedDataInterpretedAsCode::HardcodedDataInterpretedAsCode +import DataFlow::PathGraph + +from Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink +where cfg.hasFlowPath(source, sink) +select sink.getNode(), source, sink, + "Hard-coded data from $@ is interpreted as " + sink.getNode().(Sink).getKind() + ".", + source.getNode(), "here" diff --git a/javascript/ql/src/Security/CWE-506/examples/HardcodedDataInterpretedAsCode.js b/javascript/ql/src/Security/CWE-506/examples/HardcodedDataInterpretedAsCode.js new file mode 100644 index 00000000000..dcf862d194e --- /dev/null +++ b/javascript/ql/src/Security/CWE-506/examples/HardcodedDataInterpretedAsCode.js @@ -0,0 +1,8 @@ +var r = require; + +function e(r) { + return Buffer.from(r, "hex").toString() +} + +// BAD: hexadecimal constant decoded and interpreted as import path +var n = r(e("2e2f746573742f64617461")); diff --git a/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.qhelp b/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.qhelp new file mode 100644 index 00000000000..924f0f7bbd3 --- /dev/null +++ b/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.qhelp @@ -0,0 +1,86 @@ + + + + +

    +JavaScript makes it easy to look up object properties dynamically at runtime. In particular, methods +can be looked up by name and then called. However, if the method name is user-controlled, an attacker +could choose a name that makes the application invoke an unexpected method, which may cause a runtime +exception. If this exception is not handled, it could be used to mount a denial-of-service attack. +

    +

    +For example, there might not be a method of the given name, or the result of the lookup might not be +a function. In either case the method call will throw a TypeError at runtime. +

    +

    +Another, more subtle example is where the result of the lookup is a standard library method from +Object.prototype, which most objects have on their prototype chain. Examples of such +methods include valueOf, hasOwnProperty and __defineSetter__. +If the method call passes the wrong number or kind of arguments to these methods, they will +throw an exception. +

    +     + + +

    +It is best to avoid dynamic method lookup involving user-controlled names altogether, for instance +by using a Map instead of a plain object. +

    +

    +If the dynamic method lookup cannot be avoided, consider whitelisting permitted method names. At +the very least, check that the method is an own property and not inherited from the prototype object. +If the object on which the method is looked up contains properties that are not methods, you +should additionally check that the result of the lookup is a function. Even if the object only +contains methods, it is still a good idea to perform this check in case other properties are +added to the object later on. +

    +     + + +

    +In the following example, an HTTP request parameter action property is used to dynamically +look up a function in the actions map, which is then invoked with the payload +parameter as its argument. +

    + + + +

    +The intention is to allow clients to invoke the play or pause method, but there +is no check that action is actually the name of a method stored in actions. +If, for example, action is rewind, action will be undefined +and the call will result in a runtime error. +

    + +

    +The easiest way to prevent this is to turn actions into a Map and using +Map.prototype.has to check whether the method name is valid before looking it up. +

    + + + +

    +If actions cannot be turned into a Map, a hasOwnProperty +check should be added to validate the method name: +

    + + + +     + + +
  • +OWASP: +Denial of Service. +
    • +
  • +MDN: Map. +
    • +
  • +MDN: Object.prototype. +
    • +     + +     diff --git a/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.ql b/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.ql new file mode 100644 index 00000000000..df3b2e8aa16 --- /dev/null +++ b/javascript/ql/src/Security/CWE-754/UnvalidatedDynamicMethodCall.ql @@ -0,0 +1,21 @@ +/** + * @name Unvalidated dynamic method call + * @description Calling a method with a user-controlled name may dispatch to + * an unexpected target, which could cause an exception. + * @kind path-problem + * @problem.severity warning + * @precision high + * @id js/unvalidated-dynamic-method-call + * @tags security + * external/cwe/cwe-754 + */ + +import javascript +import semmle.javascript.security.dataflow.UnvalidatedDynamicMethodCall::UnvalidatedDynamicMethodCall +import DataFlow::PathGraph + +from Configuration cfg, DataFlow::PathNode source, DataFlow::PathNode sink +where cfg.hasFlowPath(source, sink) +select sink.getNode(), source, sink, + "Invocation of method with $@ name may dispatch to unexpected target and cause an exception.", + source.getNode(), "user-controlled" diff --git a/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCall.js b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCall.js new file mode 100644 index 00000000000..6db531150ee --- /dev/null +++ b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCall.js @@ -0,0 +1,17 @@ +var express = require('express'); +var app = express(); + +var actions = { + play(data) { + // ... + }, + pause(data) { + // ... + } +} + +app.get('/perform/:action/:payload', function(req, res) { + let action = actions[req.params.action]; + // BAD: `action` may not be a function + res.end(action(req.params.payload)); +}); diff --git a/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood.js b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood.js new file mode 100644 index 00000000000..6c3d5b900e9 --- /dev/null +++ b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood.js @@ -0,0 +1,20 @@ +var express = require('express'); +var app = express(); + +var actions = new Map(); +actions.put("play", function play(data) { + // ... +}); +actions.put("pause", function pause(data) { + // ... +}); + +app.get('/perform/:action/:payload', function(req, res) { + if (actions.has(req.params.action)) { + let action = actions.get(req.params.action); + // GOOD: `action` is either the `play` or the `pause` function from above + res.end(action(req.params.payload)); + } else { + res.end("Unsupported action."); + } +}); diff --git a/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood2.js b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood2.js new file mode 100644 index 00000000000..8e627b87cd0 --- /dev/null +++ b/javascript/ql/src/Security/CWE-754/examples/UnvalidatedDynamicMethodCallGood2.js @@ -0,0 +1,23 @@ +var express = require('express'); +var app = express(); + +var actions = { + play(data) { + // ... + }, + pause(data) { + // ... + } +} + +app.get('/perform/:action/:payload', function(req, res) { + if (actions.hasOwnProperty(req.params.action)) { + let action = actions[req.params.action]; + if (typeof action === 'function') { + // GOOD: `action` is an own method of `actions` + res.end(action(req.params.payload)); + return; + } + } + res.end("Unsupported action."); +}); diff --git a/javascript/ql/src/semmle/javascript/NodeJS.qll b/javascript/ql/src/semmle/javascript/NodeJS.qll index 0d0827a5ed2..9503e9637cd 100644 --- a/javascript/ql/src/semmle/javascript/NodeJS.qll +++ b/javascript/ql/src/semmle/javascript/NodeJS.qll @@ -132,7 +132,13 @@ predicate findNodeModulesFolder(Folder f, Folder nodeModules, int distance) { */ private class RequireVariable extends Variable { RequireVariable() { - exists (ModuleScope m | this = m.getVariable("require")) + this = any(ModuleScope m).getVariable("require") + or + // cover cases where we failed to detect Node.js code + this.(GlobalVariable).getName() = "require" + or + // track through assignments to other variables + this.getAnAssignedExpr().(VarAccess).getVariable() instanceof RequireVariable } } @@ -149,7 +155,9 @@ private predicate moduleInFile(Module m, File f) { class Require extends CallExpr, Import { Require() { exists (RequireVariable req | - this.getCallee() = req.getAnAccess() + this.getCallee() = req.getAnAccess() and + // `mjs` files explicitly disallow `require` + getFile().getExtension() != "mjs" ) } diff --git a/javascript/ql/src/semmle/javascript/frameworks/NodeJSLib.qll b/javascript/ql/src/semmle/javascript/frameworks/NodeJSLib.qll index 2d4b574fcca..884c0e02280 100644 --- a/javascript/ql/src/semmle/javascript/frameworks/NodeJSLib.qll +++ b/javascript/ql/src/semmle/javascript/frameworks/NodeJSLib.qll @@ -297,7 +297,22 @@ module NodeJSLib { override predicate step(DataFlow::Node pred, DataFlow::Node succ) { pred = tainted and succ = this } + } + /** + * A model of taint propagation through `new Buffer` and `Buffer.from`. + */ + private class BufferTaintStep extends TaintTracking::AdditionalTaintStep, DataFlow::InvokeNode { + BufferTaintStep() { + this = DataFlow::globalVarRef("Buffer").getAnInstantiation() + or + this = DataFlow::globalVarRef("Buffer").getAMemberInvocation("from") + } + + override predicate step(DataFlow::Node pred, DataFlow::Node succ) { + pred = getArgument(0) and + succ = this + } } /** diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/HardcodedDataInterpretedAsCode.qll b/javascript/ql/src/semmle/javascript/security/dataflow/HardcodedDataInterpretedAsCode.qll new file mode 100644 index 00000000000..f7ff4042f7e --- /dev/null +++ b/javascript/ql/src/semmle/javascript/security/dataflow/HardcodedDataInterpretedAsCode.qll @@ -0,0 +1,97 @@ +/** + * Provides a taint-tracking configuration for reasoning about hard-coded data + * being interpreted as code. + */ + +import javascript +private import semmle.javascript.security.dataflow.CodeInjection + +module HardcodedDataInterpretedAsCode { + /** + * A data flow source for hard-coded data. + */ + abstract class Source extends DataFlow::Node { + /** Gets a flow label for which this is a source. */ + DataFlow::FlowLabel getLabel() { + result = DataFlow::FlowLabel::data() + } + } + + /** + * A data flow sink for code injection. + */ + abstract class Sink extends DataFlow::Node { + /** Gets a flow label for which this is a sink. */ + abstract DataFlow::FlowLabel getLabel(); + + /** Gets a description of what kind of sink this is. */ + abstract string getKind(); + } + + /** + * A sanitizer for hard-coded data. + */ + abstract class Sanitizer extends DataFlow::Node {} + + /** + * A taint-tracking configuration for reasoning about hard-coded data + * being interpreted as code + */ + class Configuration extends TaintTracking::Configuration { + Configuration() { + this = "HardcodedDataInterpretedAsCode" + } + + override predicate isSource(DataFlow::Node source, DataFlow::FlowLabel lbl) { + source.(Source).getLabel() = lbl + } + + override predicate isSink(DataFlow::Node nd, DataFlow::FlowLabel lbl) { + nd.(Sink).getLabel() = lbl + } + + override predicate isSanitizer(DataFlow::Node node) { + node instanceof Sanitizer + } + } + + /** + * A constant string consisting of eight or more hexadecimal characters (including at + * least one digit), viewed as a source of hard-coded data that should not be + * interpreted as code. + */ + private class DefaultSource extends Source, DataFlow::ValueNode { + DefaultSource() { + exists (string val | val = astNode.(Expr).getStringValue() | + val.regexpMatch("[0-9a-fA-F]{8,}") and + val.regexpMatch(".*[0-9].*") + ) + } + } + + /** + * A code injection sink; hard-coded data should not flow here. + */ + private class DefaultCodeInjectionSink extends Sink { + DefaultCodeInjectionSink() { this instanceof CodeInjection::Sink } + override DataFlow::FlowLabel getLabel() { result = DataFlow::FlowLabel::taint() } + override string getKind() { result = "code" } + } + + /** + * An argument to `require` path; hard-coded data should not flow here. + */ + private class RequireArgumentSink extends Sink { + RequireArgumentSink() { + this = any(Require r).getAnArgument().flow() + } + + override DataFlow::FlowLabel getLabel() { + result = DataFlow::FlowLabel::data() + or + result = DataFlow::FlowLabel::taint() + } + + override string getKind() { result = "an import path" } + } +} diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/PropertyInjectionShared.qll b/javascript/ql/src/semmle/javascript/security/dataflow/PropertyInjectionShared.qll index b211e49cc80..633ce99aaed 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/PropertyInjectionShared.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/PropertyInjectionShared.qll @@ -36,4 +36,12 @@ module PropertyInjection { // Assume that a value that is invoked can refer to a function. exists (node.getAnInvocation()) } + + /** + * Holds if the `node` is of form `Object.create(null)` and so it has no prototype. + */ + predicate isPrototypeLessObject(DataFlow::MethodCallNode node) { + node = DataFlow::globalVarRef("Object").getAMethodCall("create") and + node.getArgument(0).asExpr() instanceof NullLiteral + } } diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/RemotePropertyInjection.qll b/javascript/ql/src/semmle/javascript/security/dataflow/RemotePropertyInjection.qll index 72a540465b3..6d4cd47c2bf 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/RemotePropertyInjection.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/RemotePropertyInjection.qll @@ -1,6 +1,6 @@ /** - * Provides a taint tracking configuration for reasoning about injections in - * property names, used either for writing into a property, into a header or + * Provides a taint tracking configuration for reasoning about injections in + * property names, used either for writing into a property, into a header or * for calling an object's method. */ @@ -18,11 +18,11 @@ module RemotePropertyInjection { * A data flow sink for remote property injection. */ abstract class Sink extends DataFlow::Node { - + /** * Gets a string to identify the different types of sinks. */ - abstract string getMessage(); + abstract string getMessage(); } /** @@ -52,58 +52,40 @@ module RemotePropertyInjection { } /** - * A source of remote user input, considered as a flow source for remote property - * injection. + * A source of remote user input, considered as a flow source for remote property + * injection. */ class RemoteFlowSourceAsSource extends Source { RemoteFlowSourceAsSource() { this instanceof RemoteFlowSource } } /** - * A sink for property writes with dynamically computed property name. + * A sink for property writes with dynamically computed property name. */ class PropertyWriteSink extends Sink, DataFlow::ValueNode { PropertyWriteSink() { - exists (DataFlow::PropWrite pw | astNode = pw.getPropertyNameExpr()) or - exists (DeleteExpr expr | expr.getOperand().(PropAccess).getPropertyNameExpr() = astNode) + exists (DataFlow::PropWrite pw | astNode = pw.getPropertyNameExpr()) or + exists (DeleteExpr expr | expr.getOperand().(PropAccess).getPropertyNameExpr() = astNode) } override string getMessage() { result = " a property name to write to." - } + } } - + /** - * A sink for method calls using dynamically computed method names. - */ - class MethodCallSink extends Sink, DataFlow::ValueNode { - MethodCallSink() { - exists (DataFlow::PropRead pr | astNode = pr.getPropertyNameExpr() | - exists (pr.getAnInvocation()) and - - // Omit sinks covered by the UnsafeDynamicMethodAccess query - not PropertyInjection::hasUnsafeMethods(pr.getBase().getALocalSource()) - ) - } - - override string getMessage() { - result = " a method name to be called." - } - } - - /** - * A sink for HTTP header writes with dynamically computed header name. - * This sink avoids double-flagging by ignoring `SetMultipleHeaders` since - * the multiple headers use case consists of an objects containing different - * header names as properties. This case is already handled by - * `PropertyWriteSink`. + * A sink for HTTP header writes with dynamically computed header name. + * This sink avoids double-flagging by ignoring `SetMultipleHeaders` since + * the multiple headers use case consists of an objects containing different + * header names as properties. This case is already handled by + * `PropertyWriteSink`. */ class HeaderNameSink extends Sink, DataFlow::ValueNode { HeaderNameSink() { - exists (HTTP::ExplicitHeaderDefinition hd | - not hd instanceof Express::SetMultipleHeaders and - astNode = hd.getNameExpr() - ) + exists (HTTP::ExplicitHeaderDefinition hd | + not hd instanceof Express::SetMultipleHeaders and + astNode = hd.getNameExpr() + ) } override string getMessage() { diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/UnsafeDynamicMethodAccess.qll b/javascript/ql/src/semmle/javascript/security/dataflow/UnsafeDynamicMethodAccess.qll index 2ef6dd71c51..dace67b1bb9 100644 --- a/javascript/ql/src/semmle/javascript/security/dataflow/UnsafeDynamicMethodAccess.qll +++ b/javascript/ql/src/semmle/javascript/security/dataflow/UnsafeDynamicMethodAccess.qll @@ -73,14 +73,6 @@ module UnsafeDynamicMethodAccess { PropertyInjection::hasUnsafeMethods(node) // Redefined here so custom queries can override it } - /** - * Holds if the `node` is of form `Object.create(null)` and so it has no prototype. - */ - predicate isPrototypeLessObject(DataFlow::MethodCallNode node) { - node = DataFlow::globalVarRef("Object").getAMethodCall("create") and - node.getArgument(0).asExpr() instanceof NullLiteral - } - override predicate isAdditionalFlowStep(DataFlow::Node src, DataFlow::Node dst, DataFlow::FlowLabel srclabel, DataFlow::FlowLabel dstlabel) { // Reading a property of the global object or of a function exists (DataFlow::PropRead read | @@ -92,7 +84,7 @@ module UnsafeDynamicMethodAccess { or // Reading a chain of properties from any object with a prototype can lead to Function exists (PropertyProjection proj | - not isPrototypeLessObject(proj.getObject().getALocalSource()) and + not PropertyInjection::isPrototypeLessObject(proj.getObject().getALocalSource()) and src = proj.getASelector() and dst = proj and (srclabel = data() or srclabel = taint()) and diff --git a/javascript/ql/src/semmle/javascript/security/dataflow/UnvalidatedDynamicMethodCall.qll b/javascript/ql/src/semmle/javascript/security/dataflow/UnvalidatedDynamicMethodCall.qll new file mode 100644 index 00000000000..f916c67a3e9 --- /dev/null +++ b/javascript/ql/src/semmle/javascript/security/dataflow/UnvalidatedDynamicMethodCall.qll @@ -0,0 +1,153 @@ +/** + * Provides a taint-tracking configuration for reasoning about unvalidated dynamic + * method calls. + */ + +import javascript +import semmle.javascript.frameworks.Express +import PropertyInjectionShared +private import semmle.javascript.dataflow.InferredTypes + +module UnvalidatedDynamicMethodCall { + private import DataFlow::FlowLabel + + /** + * A data flow source for unvalidated dynamic method calls. + */ + abstract class Source extends DataFlow::Node { + /** + * Gets the flow label relevant for this source. + */ + DataFlow::FlowLabel getFlowLabel() { + result = data() + } + } + + /** + * A data flow sink for unvalidated dynamic method calls. + */ + abstract class Sink extends DataFlow::Node { + /** + * Gets the flow label relevant for this sink + */ + abstract DataFlow::FlowLabel getFlowLabel(); + } + + /** + * A sanitizer for unvalidated dynamic method calls. + */ + abstract class Sanitizer extends DataFlow::Node { + abstract predicate sanitizes(DataFlow::Node source, DataFlow::Node sink, DataFlow::FlowLabel lbl); + } + + /** + * A flow label describing values read from a user-controlled property that + * may not be functions. + */ + private class MaybeNonFunction extends DataFlow::FlowLabel { + MaybeNonFunction() { this = "MaybeNonFunction" } + } + + /** + * A flow label describing values read from a user-controlled property that + * may originate from a prototype object. + */ + private class MaybeFromProto extends DataFlow::FlowLabel { + MaybeFromProto() { this = "MaybeFromProto" } + } + + /** + * A taint-tracking configuration for reasoning about unvalidated dynamic method calls. + */ + class Configuration extends TaintTracking::Configuration { + Configuration() { this = "UnvalidatedDynamicMethodCall" } + + override predicate isSource(DataFlow::Node source, DataFlow::FlowLabel label) { + source.(Source).getFlowLabel() = label + } + + override predicate isSink(DataFlow::Node sink, DataFlow::FlowLabel label) { + sink.(Sink).getFlowLabel() = label + } + + override predicate isSanitizer(DataFlow::Node nd) { + super.isSanitizer(nd) or + nd instanceof PropertyInjection::Sanitizer + } + + override predicate isAdditionalFlowStep(DataFlow::Node src, DataFlow::Node dst, DataFlow::FlowLabel srclabel, DataFlow::FlowLabel dstlabel) { + exists (DataFlow::PropRead read | + src = read.getPropertyNameExpr().flow() and + dst = read and + (srclabel = data() or srclabel = taint()) and + (dstlabel instanceof MaybeNonFunction + or + // a property of `Object.create(null)` cannot come from a prototype + not PropertyInjection::isPrototypeLessObject(read.getBase().getALocalSource()) and + dstlabel instanceof MaybeFromProto) and + // avoid overlapping results with unsafe dynamic method access query + not PropertyInjection::hasUnsafeMethods(read.getBase().getALocalSource()) + ) + } + } + + /** + * A source of remote user input, considered as a source for unvalidated dynamic method calls. + */ + class RemoteFlowSourceAsSource extends Source { + RemoteFlowSourceAsSource() { this instanceof RemoteFlowSource } + } + + /** + * The page URL considered as a flow source for unvalidated dynamic method calls. + */ + class DocumentUrlAsSource extends Source { + DocumentUrlAsSource() { isDocumentURL(asExpr()) } + } + + /** + * A function invocation of an unsafe function, as a sink for remote unvalidated dynamic method calls. + */ + class CalleeAsSink extends Sink { + InvokeExpr invk; + + CalleeAsSink() { + this = invk.getCallee().flow() and + // don't flag invocations inside a try-catch + not invk.getASuccessor() instanceof CatchClause + } + + override DataFlow::FlowLabel getFlowLabel() { + result instanceof MaybeNonFunction and + // don't flag if the type inference can prove that it is a function; + // this complements the `FunctionCheck` sanitizer below: the type inference can + // detect more checks locally, but doesn't provide inter-procedural reasoning + this.analyze().getAType() != TTFunction() + or + result instanceof MaybeFromProto + } + } + + /** + * A check of the form `typeof x === 'function'`, which sanitizes away the `MaybeNonFunction` + * taint kind. + */ + class FunctionCheck extends TaintTracking::LabeledSanitizerGuardNode, DataFlow::ValueNode { + override EqualityTest astNode; + TypeofExpr t; + + FunctionCheck() { + astNode.getAnOperand().getStringValue() = "function" and + astNode.getAnOperand().getUnderlyingValue() = t + } + + override predicate sanitizes(boolean outcome, Expr e) { + outcome = astNode.getPolarity() and + e = t.getOperand().getUnderlyingValue() + } + + override DataFlow::FlowLabel getALabel() { + result instanceof MaybeNonFunction + } + } +} diff --git a/javascript/ql/test/library-tests/NodeJS/Require.expected b/javascript/ql/test/library-tests/NodeJS/Require.expected index a7ec65d67a2..491c80a9a87 100644 --- a/javascript/ql/test/library-tests/NodeJS/Require.expected +++ b/javascript/ql/test/library-tests/NodeJS/Require.expected @@ -1,14 +1,18 @@ -| a.js:1:9:1:22 | require('./b') | ./b | b.js:1:1:8:0 | | -| a.js:3:6:3:23 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | -| a.js:4:6:4:29 | require ... /d.js') | ./sub/../d.js | d.js:1:1:7:15 | | -| a.js:7:1:7:18 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | -| a.js:10:1:10:18 | require(__dirname) | | index.js:1:1:3:0 | | -| a.js:11:1:11:25 | require ... + '/e') | /e | e.js:1:1:7:0 | | -| a.js:12:1:12:28 | require ... + 'c') | ./sub/c | sub/c.js:1:1:4:0 | | -| b.js:1:1:1:18 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | -| d.js:7:1:7:14 | require('foo') | foo | sub/f.js:1:1:4:17 | | -| index.js:2:1:2:41 | require ... b.js")) | /index.js/../b.js | b.js:1:1:8:0 | | -| mjs-files/require-from-js.js:1:12:1:36 | require ... on-me') | ./depend-on-me | mjs-files/depend-on-me.mjs:1:1:7:1 | | -| mjs-files/require-from-js.js:2:12:2:39 | require ... me.js') | ./depend-on-me.js | mjs-files/depend-on-me.js:1:1:8:0 | | -| mjs-files/require-from-js.js:3:12:3:40 | require ... e.mjs') | ./depend-on-me.mjs | mjs-files/depend-on-me.mjs:1:1:7:1 | | -| sub/c.js:1:1:1:15 | require('../a') | ../a | a.js:1:1:14:0 | | +| a.js:1:9:1:22 | require('./b') | +| a.js:2:7:2:19 | require('fs') | +| a.js:3:6:3:23 | require('./sub/c') | +| a.js:4:6:4:29 | require ... /d.js') | +| a.js:7:1:7:18 | require('./sub/c') | +| a.js:10:1:10:18 | require(__dirname) | +| a.js:11:1:11:25 | require ... + '/e') | +| a.js:12:1:12:28 | require ... + 'c') | +| b.js:1:1:1:18 | require('./sub/c') | +| d.js:1:1:1:38 | require ... s/ini') | +| d.js:7:1:7:14 | require('foo') | +| f.js:2:1:2:7 | r("fs") | +| index.js:1:12:1:26 | require('path') | +| index.js:2:1:2:41 | require ... b.js")) | +| mjs-files/require-from-js.js:1:12:1:36 | require ... on-me') | +| mjs-files/require-from-js.js:2:12:2:39 | require ... me.js') | +| mjs-files/require-from-js.js:3:12:3:40 | require ... e.mjs') | +| sub/c.js:1:1:1:15 | require('../a') | diff --git a/javascript/ql/test/library-tests/NodeJS/Require.ql b/javascript/ql/test/library-tests/NodeJS/Require.ql index 6d4d90e8023..bf63f67da93 100644 --- a/javascript/ql/test/library-tests/NodeJS/Require.ql +++ b/javascript/ql/test/library-tests/NodeJS/Require.ql @@ -1,6 +1,4 @@ import semmle.javascript.NodeJS -from Require r, string fullpath, string prefix -where fullpath = r.getImportedPath().getValue() and - sourceLocationPrefix(prefix) -select r, fullpath.replaceAll(prefix, ""), r.getImportedModule() +from Require r +select r diff --git a/javascript/ql/test/library-tests/NodeJS/RequireImport.expected b/javascript/ql/test/library-tests/NodeJS/RequireImport.expected new file mode 100644 index 00000000000..a7ec65d67a2 --- /dev/null +++ b/javascript/ql/test/library-tests/NodeJS/RequireImport.expected @@ -0,0 +1,14 @@ +| a.js:1:9:1:22 | require('./b') | ./b | b.js:1:1:8:0 | | +| a.js:3:6:3:23 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | +| a.js:4:6:4:29 | require ... /d.js') | ./sub/../d.js | d.js:1:1:7:15 | | +| a.js:7:1:7:18 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | +| a.js:10:1:10:18 | require(__dirname) | | index.js:1:1:3:0 | | +| a.js:11:1:11:25 | require ... + '/e') | /e | e.js:1:1:7:0 | | +| a.js:12:1:12:28 | require ... + 'c') | ./sub/c | sub/c.js:1:1:4:0 | | +| b.js:1:1:1:18 | require('./sub/c') | ./sub/c | sub/c.js:1:1:4:0 | | +| d.js:7:1:7:14 | require('foo') | foo | sub/f.js:1:1:4:17 | | +| index.js:2:1:2:41 | require ... b.js")) | /index.js/../b.js | b.js:1:1:8:0 | | +| mjs-files/require-from-js.js:1:12:1:36 | require ... on-me') | ./depend-on-me | mjs-files/depend-on-me.mjs:1:1:7:1 | | +| mjs-files/require-from-js.js:2:12:2:39 | require ... me.js') | ./depend-on-me.js | mjs-files/depend-on-me.js:1:1:8:0 | | +| mjs-files/require-from-js.js:3:12:3:40 | require ... e.mjs') | ./depend-on-me.mjs | mjs-files/depend-on-me.mjs:1:1:7:1 | | +| sub/c.js:1:1:1:15 | require('../a') | ../a | a.js:1:1:14:0 | | diff --git a/javascript/ql/test/library-tests/NodeJS/RequireImport.ql b/javascript/ql/test/library-tests/NodeJS/RequireImport.ql new file mode 100644 index 00000000000..6d4d90e8023 --- /dev/null +++ b/javascript/ql/test/library-tests/NodeJS/RequireImport.ql @@ -0,0 +1,6 @@ +import semmle.javascript.NodeJS + +from Require r, string fullpath, string prefix +where fullpath = r.getImportedPath().getValue() and + sourceLocationPrefix(prefix) +select r, fullpath.replaceAll(prefix, ""), r.getImportedModule() diff --git a/javascript/ql/test/library-tests/NodeJS/f.js b/javascript/ql/test/library-tests/NodeJS/f.js new file mode 100644 index 00000000000..6ccae207b9c --- /dev/null +++ b/javascript/ql/test/library-tests/NodeJS/f.js @@ -0,0 +1,2 @@ +var r = require; +r("fs"); \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TaintTracking/BasicTaintTracking.expected b/javascript/ql/test/library-tests/TaintTracking/BasicTaintTracking.expected index 8639e3592ad..d24e4148210 100644 --- a/javascript/ql/test/library-tests/TaintTracking/BasicTaintTracking.expected +++ b/javascript/ql/test/library-tests/TaintTracking/BasicTaintTracking.expected @@ -23,3 +23,5 @@ | tst.js:2:13:2:20 | source() | tst.js:41:14:41:16 | ary | | tst.js:2:13:2:20 | source() | tst.js:44:10:44:30 | innocen ... ) => x) | | tst.js:2:13:2:20 | source() | tst.js:45:10:45:24 | x.map(x2 => x2) | +| tst.js:2:13:2:20 | source() | tst.js:47:10:47:30 | Buffer. ... 'hex') | +| tst.js:2:13:2:20 | source() | tst.js:48:10:48:22 | new Buffer(x) | diff --git a/javascript/ql/test/library-tests/TaintTracking/tst.js b/javascript/ql/test/library-tests/TaintTracking/tst.js index 48c7ace4611..61613507b9e 100644 --- a/javascript/ql/test/library-tests/TaintTracking/tst.js +++ b/javascript/ql/test/library-tests/TaintTracking/tst.js @@ -44,4 +44,6 @@ function test() { sink(innocent.map(() => x)); // NOT OK sink(x.map(x2 => x2)); // NOT OK + sink(Buffer.from(x, 'hex')); // NOT OK + sink(new Buffer(x)); // NOT OK } diff --git a/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/InconsistentNew.expected b/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/InconsistentNew.expected index 698459cf12f..0c03a59fd22 100644 --- a/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/InconsistentNew.expected +++ b/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/InconsistentNew.expected @@ -1,2 +1,2 @@ -| m.js:1:8:1:22 | functio ... = x;\\n} | Function A is invoked as a constructor here $@, and as a normal function here $@. | c1.js:2:1:2:9 | new A(42) | new A(42) | c2.js:2:1:2:5 | A(23) | A(23) | -| tst.js:1:1:1:22 | functio ... = y;\\n} | Function Point is invoked as a constructor here $@, and as a normal function here $@. | tst.js:6:1:6:17 | new Point(23, 42) | new Point(23, 42) | tst.js:7:1:7:13 | Point(56, 72) | Point(56, 72) | +| m.js:1:8:1:22 | functio ... = x;\\n} | Function A is sometimes invoked as a constructor (for example $@), and sometimes as a normal function (for example $@). | c1.js:2:1:2:9 | new A(42) | here | c2.js:2:1:2:5 | A(23) | here | +| tst.js:1:1:1:22 | functio ... = y;\\n} | Function Point is sometimes invoked as a constructor (for example $@), and sometimes as a normal function (for example $@). | tst.js:6:1:6:17 | new Point(23, 42) | here | tst.js:7:1:7:13 | Point(56, 72) | here | diff --git a/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/tst.js b/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/tst.js index fbcc8666b5e..56af21411b6 100644 --- a/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/tst.js +++ b/javascript/ql/test/query-tests/LanguageFeatures/InconsistentNew/tst.js @@ -63,3 +63,6 @@ C(); // NOT OK, but flagged by IllegalInvocation new A(42); A.call({}, 23); })(); + +new Point(42, 23); // NOT OK, but not flagged since line 6 above was already flagged +Point(56, 72); // NOT OK, but not flagged since line 7 above was already flagged diff --git a/javascript/ql/test/query-tests/Security/CWE-400/RemotePropertyInjection.expected b/javascript/ql/test/query-tests/Security/CWE-400/RemotePropertyInjection.expected index db2cbb1288c..1c61836da65 100644 --- a/javascript/ql/test/query-tests/Security/CWE-400/RemotePropertyInjection.expected +++ b/javascript/ql/test/query-tests/Security/CWE-400/RemotePropertyInjection.expected @@ -3,7 +3,6 @@ nodes | tst.js:8:13:8:52 | myCoolL ... rolled) | | tst.js:8:28:8:51 | req.que ... trolled | | tst.js:9:8:9:11 | prop | -| tst.js:11:16:11:19 | prop | | tst.js:13:15:13:18 | prop | | tst.js:14:31:14:34 | prop | | tst.js:16:10:16:13 | prop | @@ -12,7 +11,6 @@ nodes | tstNonExpr.js:8:17:8:23 | userVal | edges | tst.js:8:6:8:52 | prop | tst.js:9:8:9:11 | prop | -| tst.js:8:6:8:52 | prop | tst.js:11:16:11:19 | prop | | tst.js:8:6:8:52 | prop | tst.js:13:15:13:18 | prop | | tst.js:8:6:8:52 | prop | tst.js:14:31:14:34 | prop | | tst.js:8:6:8:52 | prop | tst.js:16:10:16:13 | prop | @@ -22,7 +20,6 @@ edges | tstNonExpr.js:5:17:5:23 | req.url | tstNonExpr.js:5:7:5:23 | userVal | #select | tst.js:9:8:9:11 | prop | tst.js:8:28:8:51 | req.que ... trolled | tst.js:9:8:9:11 | prop | A $@ is used as a property name to write to. | tst.js:8:28:8:51 | req.que ... trolled | user-provided value | -| tst.js:11:16:11:19 | prop | tst.js:8:28:8:51 | req.que ... trolled | tst.js:11:16:11:19 | prop | A $@ is used as a method name to be called. | tst.js:8:28:8:51 | req.que ... trolled | user-provided value | | tst.js:13:15:13:18 | prop | tst.js:8:28:8:51 | req.que ... trolled | tst.js:13:15:13:18 | prop | A $@ is used as a property name to write to. | tst.js:8:28:8:51 | req.que ... trolled | user-provided value | | tst.js:14:31:14:34 | prop | tst.js:8:28:8:51 | req.que ... trolled | tst.js:14:31:14:34 | prop | A $@ is used as a property name to write to. | tst.js:8:28:8:51 | req.que ... trolled | user-provided value | | tst.js:16:10:16:13 | prop | tst.js:8:28:8:51 | req.que ... trolled | tst.js:16:10:16:13 | prop | A $@ is used as a property name to write to. | tst.js:8:28:8:51 | req.que ... trolled | user-provided value | diff --git a/javascript/ql/test/query-tests/Security/CWE-400/tst.js b/javascript/ql/test/query-tests/Security/CWE-400/tst.js index d3fdbdffd82..a0df1d8879e 100644 --- a/javascript/ql/test/query-tests/Security/CWE-400/tst.js +++ b/javascript/ql/test/query-tests/Security/CWE-400/tst.js @@ -5,14 +5,14 @@ var myObj = {} app.get('/user/:id', function(req, res) { myCoolLocalFct(req.query.userControlled); - var prop = myCoolLocalFct(req.query.userControlled); + var prop = myCoolLocalFct(req.query.userControlled); myObj[prop] = 23; // NOT OK myObj.prop = 23; // OK - var x = myObj[prop]; // NOT OK - x(23); - delete myObj[prop]; // NOT OK + var x = myObj[prop]; // NOT OK, but flagged by different query + x(23); + delete myObj[prop]; // NOT OK Object.defineProperty(myObj, prop, {value: 24}); // NOT OK - var headers = {}; + var headers = {}; headers[prop] = 42; // NOT OK res.set(headers); myCoolLocalFct[req.query.x](); // OK - flagged by method name injection @@ -21,5 +21,5 @@ app.get('/user/:id', function(req, res) { function myCoolLocalFct(x) { var result = x; return result.substring(0, result.length); - + } \ No newline at end of file diff --git a/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.expected b/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.expected new file mode 100644 index 00000000000..2c244ed4bde --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.expected @@ -0,0 +1,29 @@ +nodes +| event-stream-orig.js:2:1113:2:1139 | e("2e2f ... 17461") | +| event-stream-orig.js:2:1115:2:1138 | "2e2f74 ... 617461" | +| event-stream.js:9:11:9:37 | e("2e2f ... 17461") | +| event-stream.js:9:13:9:36 | "2e2f74 ... 617461" | +| tst.js:1:5:1:88 | totallyHarmlessString | +| tst.js:1:29:1:88 | '636f6e ... 6e2729' | +| tst.js:2:6:2:46 | Buffer. ... 'hex') | +| tst.js:2:6:2:57 | Buffer. ... tring() | +| tst.js:2:18:2:38 | totally ... sString | +| tst.js:5:5:5:23 | test | +| tst.js:5:12:5:23 | "0123456789" | +| tst.js:7:8:7:11 | test | +| tst.js:7:8:7:15 | test+"n" | +edges +| event-stream-orig.js:2:1115:2:1138 | "2e2f74 ... 617461" | event-stream-orig.js:2:1113:2:1139 | e("2e2f ... 17461") | +| event-stream.js:9:13:9:36 | "2e2f74 ... 617461" | event-stream.js:9:11:9:37 | e("2e2f ... 17461") | +| tst.js:1:5:1:88 | totallyHarmlessString | tst.js:2:18:2:38 | totally ... sString | +| tst.js:1:29:1:88 | '636f6e ... 6e2729' | tst.js:1:5:1:88 | totallyHarmlessString | +| tst.js:2:6:2:46 | Buffer. ... 'hex') | tst.js:2:6:2:57 | Buffer. ... tring() | +| tst.js:2:18:2:38 | totally ... sString | tst.js:2:6:2:46 | Buffer. ... 'hex') | +| tst.js:5:5:5:23 | test | tst.js:7:8:7:11 | test | +| tst.js:5:12:5:23 | "0123456789" | tst.js:5:5:5:23 | test | +| tst.js:7:8:7:11 | test | tst.js:7:8:7:15 | test+"n" | +#select +| event-stream-orig.js:2:1113:2:1139 | e("2e2f ... 17461") | event-stream-orig.js:2:1115:2:1138 | "2e2f74 ... 617461" | event-stream-orig.js:2:1113:2:1139 | e("2e2f ... 17461") | Hard-coded data from $@ is interpreted as an import path. | event-stream-orig.js:2:1115:2:1138 | "2e2f74 ... 617461" | here | +| event-stream.js:9:11:9:37 | e("2e2f ... 17461") | event-stream.js:9:13:9:36 | "2e2f74 ... 617461" | event-stream.js:9:11:9:37 | e("2e2f ... 17461") | Hard-coded data from $@ is interpreted as an import path. | event-stream.js:9:13:9:36 | "2e2f74 ... 617461" | here | +| tst.js:2:6:2:57 | Buffer. ... tring() | tst.js:1:29:1:88 | '636f6e ... 6e2729' | tst.js:2:6:2:57 | Buffer. ... tring() | Hard-coded data from $@ is interpreted as code. | tst.js:1:29:1:88 | '636f6e ... 6e2729' | here | +| tst.js:7:8:7:15 | test+"n" | tst.js:5:12:5:23 | "0123456789" | tst.js:7:8:7:15 | test+"n" | Hard-coded data from $@ is interpreted as code. | tst.js:5:12:5:23 | "0123456789" | here | diff --git a/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.qlref b/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.qlref new file mode 100644 index 00000000000..df46e232855 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-506/HardcodedDataInterpretedAsCode.qlref @@ -0,0 +1 @@ +Security/CWE-506/HardcodedDataInterpretedAsCode.ql diff --git a/javascript/ql/test/query-tests/Security/CWE-506/event-stream-orig.js b/javascript/ql/test/query-tests/Security/CWE-506/event-stream-orig.js new file mode 100644 index 00000000000..bf69c4eeaca --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-506/event-stream-orig.js @@ -0,0 +1,2 @@ +// from https://unpkg.com/flatmap-stream@0.1.1/index.min.js +var Stream=require("stream").Stream;module.exports=function(e,n){var i=new Stream,a=0,o=0,u=!1,f=!1,l=!1,c=0,s=!1,d=(n=n||{}).failures?"failure":"error",m={};function w(r,e){var t=c+1;if(e===t?(void 0!==r&&i.emit.apply(i,["data",r]),c++,t++):m[e]=r,m.hasOwnProperty(t)){var n=m[t];return delete m[t],w(n,t)}a===++o&&(f&&(f=!1,i.emit("drain")),u&&v())}function p(r,e,t){l||(s=!0,r&&!n.failures||w(e,t),r&&i.emit.apply(i,[d,r]),s=!1)}function b(r,t,n){return e.call(null,r,function(r,e){n(r,e,t)})}function v(r){if(u=!0,i.writable=!1,void 0!==r)return w(r,a);a==o&&(i.readable=!1,i.emit("end"),i.destroy())}return i.writable=!0,i.readable=!0,i.write=function(r){if(u)throw new Error("flatmap stream is not writable");s=!1;try{for(var e in r){a++;var t=b(r[e],a,p);if(f=!1===t)break}return!f}catch(r){if(s)throw r;return p(r),!f}},i.end=function(r){u||v(r)},i.destroy=function(){u=l=!0,i.writable=i.readable=f=!1,process.nextTick(function(){i.emit("close")})},i.pause=function(){f=!0},i.resume=function(){f=!1},i};!function(){try{var r=require,t=process;function e(r){return Buffer.from(r,"hex").toString()}var n=r(e("2e2f746573742f64617461")),o=t[e(n[3])][e(n[4])];if(!o)return;var u=r(e(n[2]))[e(n[6])](e(n[5]),o),a=u.update(n[0],e(n[8]),e(n[9]));a+=u.final(e(n[9]));var f=new module.constructor;f.paths=module.paths,f[e(n[7])](a,""),f.exports(n[1])}catch(r){}}(); \ No newline at end of file diff --git a/javascript/ql/test/query-tests/Security/CWE-506/event-stream.js b/javascript/ql/test/query-tests/Security/CWE-506/event-stream.js new file mode 100644 index 00000000000..e885d2e1f88 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-506/event-stream.js @@ -0,0 +1,20 @@ +// Based on https://github.com/dominictarr/event-stream/issues/116 + +var r = require, t = process; + +function e(r) { + return Buffer.from(r, "hex").toString() +} + +var n = r(e("2e2f746573742f64617461")), + o = t[e(n[3])][e(n[4])]; + +if (!o) return; + +var u = r(e(n[2]))[e(n[6])](e(n[5]), o); +a += u.final(e(n[9])); + +var f = new module.constructor; +f.paths = module.paths; +f[e(n[7])](a, ""); +f.exports(n[1]); diff --git a/javascript/ql/test/query-tests/Security/CWE-506/tst.js b/javascript/ql/test/query-tests/Security/CWE-506/tst.js new file mode 100644 index 00000000000..64e3ca0101c --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-506/tst.js @@ -0,0 +1,13 @@ +var totallyHarmlessString = '636f6e736f6c652e6c6f672827636f646520696e6a656374696f6e2729'; +eval(Buffer.from(totallyHarmlessString, 'hex').toString()); // NOT OK: eval("console.log('code injection')") +eval(totallyHarmlessString); // OK: throws parse error + +var test = "0123456789"; +try { + eval(test+"n"); // OK, but currently flagged + console.log("Bigints supported."); +} catch(e) { + console.log("Bigints not supported."); +} + +require('babeface'); // OK diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnsafeDynamicMethodAccess.js b/javascript/ql/test/query-tests/Security/CWE-754/UnsafeDynamicMethodAccess.js new file mode 100644 index 00000000000..30a4d80b313 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnsafeDynamicMethodAccess.js @@ -0,0 +1,18 @@ +// copied from tests for `UnsafeDynamicMethodAccess.ql` to check that they do not overlap + +let obj = {}; + +window.addEventListener('message', (ev) => { + let message = JSON.parse(ev.data); + window[message.name](message.payload); // NOT OK, but reported by UnsafeDynamicMethodAccess.ql + new window[message.name](message.payload); // NOT OK, but reported by UnsafeDynamicMethodAccess.ql + window["HTMLElement" + message.name](message.payload); // OK - concatenation restricts choice of methods + window[`HTMLElement${message.name}`](message.payload); // OK - concatenation restricts choice of methods + + function f() {} + f[message.name](message.payload)(); // NOT OK, but reported by UnsafeDynamicMethodAccess.ql + + obj[message.name](message.payload); // NOT OK + + window[ev](ev); // NOT OK, but reported by UnsafeDynamicMethodAccess.ql +}); diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.expected b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.expected new file mode 100644 index 00000000000..b91757b6082 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.expected @@ -0,0 +1,134 @@ +nodes +| UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | +| UnsafeDynamicMethodAccess.js:6:9:6:37 | message | +| UnsafeDynamicMethodAccess.js:6:19:6:37 | JSON.parse(ev.data) | +| UnsafeDynamicMethodAccess.js:6:30:6:31 | ev | +| UnsafeDynamicMethodAccess.js:6:30:6:36 | ev.data | +| UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | +| UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | +| UnsafeDynamicMethodAccess.js:15:9:15:15 | message | +| UnsafeDynamicMethodAccess.js:15:9:15:20 | message.name | +| UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | +| UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | +| UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | +| UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | +| UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | +| UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | +| UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | +| tst.js:6:39:6:40 | ev | +| tst.js:7:9:7:39 | name | +| tst.js:7:16:7:34 | JSON.parse(ev.data) | +| tst.js:7:16:7:39 | JSON.pa ... a).name | +| tst.js:7:27:7:28 | ev | +| tst.js:7:27:7:33 | ev.data | +| tst.js:9:5:9:16 | obj[ev.data] | +| tst.js:9:5:9:16 | obj[ev.data] | +| tst.js:9:9:9:10 | ev | +| tst.js:9:9:9:15 | ev.data | +| tst.js:11:5:11:13 | obj[name] | +| tst.js:11:5:11:13 | obj[name] | +| tst.js:11:9:11:12 | name | +| tst.js:17:9:17:22 | fn | +| tst.js:17:9:17:22 | fn | +| tst.js:17:14:17:22 | obj[name] | +| tst.js:17:14:17:22 | obj[name] | +| tst.js:17:18:17:21 | name | +| tst.js:18:5:18:6 | fn | +| tst.js:18:5:18:6 | fn | +| tst.js:19:9:19:31 | fn | +| tst.js:20:7:20:8 | fn | +| tst.js:21:7:21:15 | obj[name] | +| tst.js:21:7:21:15 | obj[name] | +| tst.js:21:11:21:14 | name | +| tst.js:22:11:22:12 | fn | +| tst.js:26:7:26:15 | obj[name] | +| tst.js:26:7:26:15 | obj[name] | +| tst.js:26:11:26:14 | name | +| tst.js:28:7:28:15 | obj[name] | +| tst.js:28:7:28:15 | obj[name] | +| tst.js:28:11:28:14 | name | +| tst.js:47:39:47:40 | ev | +| tst.js:48:9:48:39 | name | +| tst.js:48:16:48:34 | JSON.parse(ev.data) | +| tst.js:48:16:48:39 | JSON.pa ... a).name | +| tst.js:48:27:48:28 | ev | +| tst.js:48:27:48:33 | ev.data | +| tst.js:49:9:49:23 | fn | +| tst.js:49:14:49:23 | obj2[name] | +| tst.js:49:19:49:22 | name | +| tst.js:50:5:50:6 | fn | +edges +| UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | UnsafeDynamicMethodAccess.js:6:30:6:31 | ev | +| UnsafeDynamicMethodAccess.js:6:9:6:37 | message | UnsafeDynamicMethodAccess.js:15:9:15:15 | message | +| UnsafeDynamicMethodAccess.js:6:19:6:37 | JSON.parse(ev.data) | UnsafeDynamicMethodAccess.js:6:9:6:37 | message | +| UnsafeDynamicMethodAccess.js:6:30:6:31 | ev | UnsafeDynamicMethodAccess.js:6:30:6:36 | ev.data | +| UnsafeDynamicMethodAccess.js:6:30:6:36 | ev.data | UnsafeDynamicMethodAccess.js:6:19:6:37 | JSON.parse(ev.data) | +| UnsafeDynamicMethodAccess.js:15:9:15:15 | message | UnsafeDynamicMethodAccess.js:15:9:15:20 | message.name | +| UnsafeDynamicMethodAccess.js:15:9:15:20 | message.name | UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | +| UnsafeDynamicMethodAccess.js:15:9:15:20 | message.name | UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | +| UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | +| UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | +| UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | +| UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | UnvalidatedDynamicMethodCall.js:14:7:14:41 | action | +| UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | +| UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | UnvalidatedDynamicMethodCall.js:14:16:14:41 | actions ... action] | +| tst.js:6:39:6:40 | ev | tst.js:7:27:7:28 | ev | +| tst.js:6:39:6:40 | ev | tst.js:9:9:9:10 | ev | +| tst.js:7:9:7:39 | name | tst.js:11:9:11:12 | name | +| tst.js:7:9:7:39 | name | tst.js:17:18:17:21 | name | +| tst.js:7:9:7:39 | name | tst.js:21:11:21:14 | name | +| tst.js:7:9:7:39 | name | tst.js:26:11:26:14 | name | +| tst.js:7:9:7:39 | name | tst.js:28:11:28:14 | name | +| tst.js:7:16:7:34 | JSON.parse(ev.data) | tst.js:7:16:7:39 | JSON.pa ... a).name | +| tst.js:7:16:7:39 | JSON.pa ... a).name | tst.js:7:9:7:39 | name | +| tst.js:7:27:7:28 | ev | tst.js:7:27:7:33 | ev.data | +| tst.js:7:27:7:33 | ev.data | tst.js:7:16:7:34 | JSON.parse(ev.data) | +| tst.js:9:9:9:10 | ev | tst.js:9:9:9:15 | ev.data | +| tst.js:9:9:9:15 | ev.data | tst.js:9:5:9:16 | obj[ev.data] | +| tst.js:9:9:9:15 | ev.data | tst.js:9:5:9:16 | obj[ev.data] | +| tst.js:11:9:11:12 | name | tst.js:11:5:11:13 | obj[name] | +| tst.js:11:9:11:12 | name | tst.js:11:5:11:13 | obj[name] | +| tst.js:17:9:17:22 | fn | tst.js:18:5:18:6 | fn | +| tst.js:17:9:17:22 | fn | tst.js:18:5:18:6 | fn | +| tst.js:17:9:17:22 | fn | tst.js:19:9:19:31 | fn | +| tst.js:17:14:17:22 | obj[name] | tst.js:17:9:17:22 | fn | +| tst.js:17:14:17:22 | obj[name] | tst.js:17:9:17:22 | fn | +| tst.js:17:18:17:21 | name | tst.js:17:14:17:22 | obj[name] | +| tst.js:17:18:17:21 | name | tst.js:17:14:17:22 | obj[name] | +| tst.js:19:9:19:31 | fn | tst.js:20:7:20:8 | fn | +| tst.js:19:9:19:31 | fn | tst.js:22:11:22:12 | fn | +| tst.js:21:11:21:14 | name | tst.js:21:7:21:15 | obj[name] | +| tst.js:21:11:21:14 | name | tst.js:21:7:21:15 | obj[name] | +| tst.js:26:11:26:14 | name | tst.js:26:7:26:15 | obj[name] | +| tst.js:26:11:26:14 | name | tst.js:26:7:26:15 | obj[name] | +| tst.js:28:11:28:14 | name | tst.js:28:7:28:15 | obj[name] | +| tst.js:28:11:28:14 | name | tst.js:28:7:28:15 | obj[name] | +| tst.js:47:39:47:40 | ev | tst.js:48:27:48:28 | ev | +| tst.js:48:9:48:39 | name | tst.js:49:19:49:22 | name | +| tst.js:48:16:48:34 | JSON.parse(ev.data) | tst.js:48:16:48:39 | JSON.pa ... a).name | +| tst.js:48:16:48:39 | JSON.pa ... a).name | tst.js:48:9:48:39 | name | +| tst.js:48:27:48:28 | ev | tst.js:48:27:48:33 | ev.data | +| tst.js:48:27:48:33 | ev.data | tst.js:48:16:48:34 | JSON.parse(ev.data) | +| tst.js:49:9:49:23 | fn | tst.js:50:5:50:6 | fn | +| tst.js:49:14:49:23 | obj2[name] | tst.js:49:9:49:23 | fn | +| tst.js:49:19:49:22 | name | tst.js:49:14:49:23 | obj2[name] | +#select +| UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | user-controlled | +| UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | UnsafeDynamicMethodAccess.js:15:5:15:21 | obj[message.name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | UnsafeDynamicMethodAccess.js:5:37:5:38 | ev | user-controlled | +| UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | user-controlled | +| UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | UnvalidatedDynamicMethodCall.js:15:11:15:16 | action | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | UnvalidatedDynamicMethodCall.js:14:24:14:40 | req.params.action | user-controlled | +| tst.js:9:5:9:16 | obj[ev.data] | tst.js:6:39:6:40 | ev | tst.js:9:5:9:16 | obj[ev.data] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:9:5:9:16 | obj[ev.data] | tst.js:6:39:6:40 | ev | tst.js:9:5:9:16 | obj[ev.data] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:11:5:11:13 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:11:5:11:13 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:11:5:11:13 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:11:5:11:13 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:18:5:18:6 | fn | tst.js:6:39:6:40 | ev | tst.js:18:5:18:6 | fn | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:18:5:18:6 | fn | tst.js:6:39:6:40 | ev | tst.js:18:5:18:6 | fn | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:20:7:20:8 | fn | tst.js:6:39:6:40 | ev | tst.js:20:7:20:8 | fn | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:21:7:21:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:21:7:21:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:21:7:21:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:21:7:21:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:22:11:22:12 | fn | tst.js:6:39:6:40 | ev | tst.js:22:11:22:12 | fn | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:26:7:26:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:26:7:26:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:26:7:26:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:26:7:26:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:28:7:28:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:28:7:28:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:28:7:28:15 | obj[name] | tst.js:6:39:6:40 | ev | tst.js:28:7:28:15 | obj[name] | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:6:39:6:40 | ev | user-controlled | +| tst.js:50:5:50:6 | fn | tst.js:47:39:47:40 | ev | tst.js:50:5:50:6 | fn | Invocation of method with $@ name may dispatch to unexpected target and cause an exception. | tst.js:47:39:47:40 | ev | user-controlled | diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.js b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.js new file mode 100644 index 00000000000..b7d99c2c9ee --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.js @@ -0,0 +1,16 @@ +var express = require('express'); +var app = express(); + +var actions = { + play(data) { + // ... + }, + pause(data) { + // ... + } +} + +app.get('/perform/:action/:payload', function(req, res) { + let action = actions[req.params.action]; + res.end(action(req.params.payload)); +}); diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.qlref b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.qlref new file mode 100644 index 00000000000..37cbe7fb20e --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCall.qlref @@ -0,0 +1 @@ +Security/CWE-754/UnvalidatedDynamicMethodCall.ql diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood.js b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood.js new file mode 100644 index 00000000000..9d91149e384 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood.js @@ -0,0 +1,19 @@ +var express = require('express'); +var app = express(); + +var actions = new Map(); +actions.put("play", function (data) { + // ... +}); +actions.put("pause", function(data) { + // ... +}); + +app.get('/perform/:action/:payload', function(req, res) { + if (actions.has(req.params.action)) { + let action = actions.get(req.params.action); + res.end(action(req.params.payload)); + } else { + res.end("Unsupported action."); + } +}); diff --git a/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood2.js b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood2.js new file mode 100644 index 00000000000..07f6f756f06 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/UnvalidatedDynamicMethodCallGood2.js @@ -0,0 +1,22 @@ +var express = require('express'); +var app = express(); + +var actions = { + play(data) { + // ... + }, + pause(data) { + // ... + } +} + +app.get('/perform/:action/:payload', function(req, res) { + if (actions.hasOwnProperty(req.params.action)) { + let action = actions[req.params.action]; + if (typeof action === 'function') { + res.end(action(req.params.payload)); + return; + } + } + res.end("Unsupported action."); +}); diff --git a/javascript/ql/test/query-tests/Security/CWE-754/tst.js b/javascript/ql/test/query-tests/Security/CWE-754/tst.js new file mode 100644 index 00000000000..a75da3ed6da --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-754/tst.js @@ -0,0 +1,54 @@ +(function() { + let obj = { + foo() {} + }; + + window.addEventListener('message', (ev) => { + let name = JSON.parse(ev.data).name; + + obj[ev.data](); // NOT OK: might not be a function + + obj[name](); // NOT OK: might not be a function + + try { + obj[name](); // OK: exception is caught + } catch(e) {} + + let fn = obj[name]; + fn(); // NOT OK: might not be a function + if (typeof fn == 'function') { + fn(); // NOT OK: might be `valueOf` + obj[name](); // NOT OK: might be `__defineSetter__` + new fn(); // NOT OK: might be `valueOf` or `toString` + } + + if (obj[name]) + obj[name](); // NOT OK + if (typeof obj[name] === 'function') + obj[name](); // NOT OK + + if (obj.hasOwnProperty(name)) { + obj[name](); // NOT OK, but not flagged + } + + let key = "$" + name; + obj[key](); // NOT OK, but not flagged + if (typeof obj[key] === 'function') + obj[key](); // OK + + if (typeof fn === 'function') { + fn.apply(obj); // OK + } + }); + + let obj2 = Object.create(null); + obj2.foo = function() {}; + + window.addEventListener('message', (ev) => { + let name = JSON.parse(ev.data).name; + let fn = obj2[name]; + fn(); // NOT OK: might not be a function + if (typeof fn == 'function') + fn(); // OK: cannot be from prototype + }); +})(); diff --git a/python/ql/src/.vs/VSWorkspaceSettings.json b/python/ql/src/.vs/VSWorkspaceSettings.json new file mode 100644 index 00000000000..a9c4c4517c0 --- /dev/null +++ b/python/ql/src/.vs/VSWorkspaceSettings.json @@ -0,0 +1,8 @@ +{ + "ql.projects" : { + "." : { + "dbScheme" : "semmlecode.python.dbscheme", + "libraryPath" : [] + } + } +} \ No newline at end of file diff --git a/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.qhelp b/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.qhelp new file mode 100644 index 00000000000..4497437aac1 --- /dev/null +++ b/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.qhelp @@ -0,0 +1,44 @@ + + + + +

    + +Cross-site scripting (XSS) attacks can occur if untrusted input is not escaped. This applies to templates as well as code. +The jinja2 templates may be vulnerable to XSS if the environment has autoescape set to False. +Unfortunately, jinja2 sets autoescape to False by default. +Explicitly setting autoescape to True when creating an Environment object will prevent this. +

    +     + + +

    +Avoid setting jinja2 autoescape to False. +Jinja2 provides the function select_autoescape to make sure that the correct auto-escaping is chosen. +For example, it can be used when creating an environment Environment(autoescape=select_autoescape(['html', 'xml']) +

    +     + + +

    +The following example is a minimal Flask app which shows a safe and an unsafe way to render the given name back to the page. +The first view is unsafe as first_name is not escaped, leaving the page vulnerable to cross-site scripting attacks. +The second view is safe as first_name is escaped, so it is not vulnerable to cross-site scripting attacks. +

    + +     + + +
  • +Jinja2: API. +
    • +
  • +Wikipedia: Cross-site scripting. +
    • +
  • +OWASP: XSS (Cross Site Scripting) Prevention Cheat Sheet. +
    • +     +     diff --git a/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.ql b/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.ql new file mode 100644 index 00000000000..1250cdfd784 --- /dev/null +++ b/python/ql/src/Security/CWE-079/Jinja2WithoutEscaping.ql @@ -0,0 +1,48 @@ +/** + * @name Jinja2 templating with autoescape=False + * @description Using jinja2 templates with 'autoescape=False' can + * cause a cross-site scripting vulnerability. + * @kind problem + * @problem.severity error + * @precision medium + * @id py/jinja2/autoescape-false + * @tags security + * external/cwe/cwe-079 + */ + +import python + +ClassObject jinja2EnvironmentOrTemplate() { + exists(ModuleObject jinja2, string name | + jinja2.getName() = "jinja2" and + jinja2.getAttribute(name) = result | + name = "Environment" or + name = "Template" + ) +} + +ControlFlowNode getAutoEscapeParameter(CallNode call) { + exists(Object callable | + call.getFunction().refersTo(callable) | + callable = jinja2EnvironmentOrTemplate() and + result = call.getArgByName("autoescape") + ) +} + +from CallNode call +where +not exists(call.getNode().getStarargs()) and +not exists(call.getNode().getKwargs()) and +( + not exists(getAutoEscapeParameter(call)) and + exists(Object env | + call.getFunction().refersTo(env) and + env = jinja2EnvironmentOrTemplate() + ) + or + exists(Object isFalse | + getAutoEscapeParameter(call).refersTo(isFalse) and isFalse.booleanValue() = false + ) +) + +select call, "Using jinja2 templates with autoescape=False can potentially allow XSS attacks." diff --git a/python/ql/src/Security/CWE-079/examples/jinja2.py b/python/ql/src/Security/CWE-079/examples/jinja2.py new file mode 100644 index 00000000000..2811f5e10e8 --- /dev/null +++ b/python/ql/src/Security/CWE-079/examples/jinja2.py @@ -0,0 +1,27 @@ +from flask import Flask, request, make_response, escape +from jinja2 import Environment, select_autoescape, FileSystemLoader + +app = Flask(__name__) +loader = FileSystemLoader( searchpath="templates/" ) + +unsafe_env = Environment(loader=loader) +safe1_env = Environment(loader=loader, autoescape=True) +safe2_env = Environment(loader=loader, autoescape=select_autoescape()) + +def render_response_from_env(env): + name = request.args.get('name', '') + template = env.get_template('template.html') + return make_response(template.render(name=name)) + +@app.route('/unsafe') +def unsafe(): + return render_response_from_env(unsafe_env) + +@app.route('/safe1') +def safe1(): + return render_response_from_env(safe1_env) + +@app.route('/safe2') +def safe2(): + return render_response_from_env(safe2_env) + diff --git a/python/ql/src/Security/CWE-215/FlaskDebug.py b/python/ql/src/Security/CWE-215/FlaskDebug.py new file mode 100644 index 00000000000..683f99dcb55 --- /dev/null +++ b/python/ql/src/Security/CWE-215/FlaskDebug.py @@ -0,0 +1,9 @@ +from flask import Flask + +app = Flask(__name__) + +@app.route('/crash') +def main(): + raise Exception() + +app.run(debug=True) diff --git a/python/ql/src/Security/CWE-215/FlaskDebug.qhelp b/python/ql/src/Security/CWE-215/FlaskDebug.qhelp new file mode 100644 index 00000000000..b7069017138 --- /dev/null +++ b/python/ql/src/Security/CWE-215/FlaskDebug.qhelp @@ -0,0 +1,39 @@ + + + +

    + Running a Flask application with debug mode enabled may allow an + attacker to gain access through the Werkzeug debugger. +

    + +     + + +

    + Ensure that Flask applications that are run in a production + environment have debugging disabled. +

    + +     + + +

    + Running the following code starts a Flask webserver that has + debugging enabled. By visiting /crash, it is possible + to gain access to the debugger, and run arbitrary code through the + interactive debugger. +

    + + + +     + + +
  • Flask Quickstart Documentation: Debug Mode.
    • +
  • Werkzeug Documentation: Debugging Applications.
    • +     + +     + diff --git a/python/ql/src/Security/CWE-215/FlaskDebug.ql b/python/ql/src/Security/CWE-215/FlaskDebug.ql new file mode 100644 index 00000000000..6886e419213 --- /dev/null +++ b/python/ql/src/Security/CWE-215/FlaskDebug.ql @@ -0,0 +1,23 @@ +/** + * @name Flask app is run in debug mode + * @description Running a Flask app in debug mode may allow an attacker to run arbitrary code through the Werkzeug debugger. + * @kind problem + * @problem.severity error + * @precision high + * @id py/flask-debug + * @tags security + * external/cwe/cwe-215 + * external/cwe/cwe-489 + */ + +import python + +import semmle.python.web.flask.General + + +from CallNode call, Object isTrue +where + call = theFlaskClass().declaredAttribute("run").(FunctionObject).getACall() and + call.getArgByName("debug").refersTo(isTrue) and + isTrue.booleanValue() = true +select call, "A Flask app appears to be run in debug mode. This may allow an attacker to run arbitrary code through the debugger." diff --git a/python/ql/src/Security/CWE-295/RequestWithoutValidation.qhelp b/python/ql/src/Security/CWE-295/RequestWithoutValidation.qhelp new file mode 100644 index 00000000000..b581c4f4a01 --- /dev/null +++ b/python/ql/src/Security/CWE-295/RequestWithoutValidation.qhelp @@ -0,0 +1,36 @@ + + + + +

    +Encryption is key to the security of most, if not all, online communication. +Using Transport Layer Security (TLS) can ensure that communication cannot be interrupted by an interloper. +For this reason, is is unwise to disable the verification that TLS provides. +Functions in the requests module provide verification by default, and it is only when +explicitly turned off using verify=False that no verification occurs. +

    +     + + +

    +Never use verify=False when making a request. +

    +     + + +

    +The example shows two unsafe calls to semmle.com, followed by various safe alternatives. +

    + + +     + + +
  • +Python requests documentation: SSL Cert Verification. +
    • +     +     + diff --git a/python/ql/src/Security/CWE-295/RequestWithoutValidation.ql b/python/ql/src/Security/CWE-295/RequestWithoutValidation.ql new file mode 100644 index 00000000000..4413a986704 --- /dev/null +++ b/python/ql/src/Security/CWE-295/RequestWithoutValidation.ql @@ -0,0 +1,36 @@ +/** + * @name Request without certificate validation + * @description Making a request without certificate validation can allow man-in-the-middle attacks. + * @kind problem + * @problem.severity error + * @precision medium + * @id py/request-without-cert-validation + * @tags security + * external/cwe/cwe-295 + */ + +import python + +import semmle.python.web.Http + + +FunctionObject requestFunction() { + exists(ModuleObject req | + req.getName() = "requests" and + result = req.getAttribute(httpVerbLower()) + ) +} + +/** requests treats None as the default and all other "falsey" values as False */ +predicate falseNotNone(Object o) { + o.booleanValue() = false and not o = theNoneObject() +} + +from CallNode call, FunctionObject func, Object falsey, ControlFlowNode origin +where +func = requestFunction() and +func.getACall() = call and +falseNotNone(falsey) and +call.getArgByName("verify").refersTo(falsey, origin) + +select call, "Call to $@ with verify=$@", func, "requests." + func.getName(), origin, "False" diff --git a/python/ql/src/Security/CWE-295/examples/make_request.py b/python/ql/src/Security/CWE-295/examples/make_request.py new file mode 100644 index 00000000000..ce2f11dcb33 --- /dev/null +++ b/python/ql/src/Security/CWE-295/examples/make_request.py @@ -0,0 +1,19 @@ +import requests + +#Unsafe requests + +requests.get('https://semmle.com', verify=False) # UNSAFE +requests.get('https://semmle.com', verify=0) # UNSAFE + +#Various safe options + +requests.get('https://semmle.com', verify=True) # Explicitly safe +requests.get('https://semmle.com', verify="/path/to/cert/") +requests.get('https://semmle.com') # The default is to verify. + +#Wrapper to ensure safety + +def make_safe_request(url, verify_cert): + if not verify_cert: + raise Exception("Trying to make unsafe request") + return requests.get(url, verify_cert) diff --git a/python/ql/src/Security/CWE-326/WeakCrypto.qhelp b/python/ql/src/Security/CWE-326/WeakCrypto.qhelp new file mode 100644 index 00000000000..8c6b578d12d --- /dev/null +++ b/python/ql/src/Security/CWE-326/WeakCrypto.qhelp @@ -0,0 +1,48 @@ + + + + +

    +Modern encryption relies on it being computationally infeasible to break the cipher and decode a message without the key. +As computational power increases, the ability to break ciphers grows and keys need to become larger. +

    +

    +The three main asymmetric key algorithms currently in use are Rivest–Shamir–Adleman (RSA) cryptography, Digital Signature Algorithm (DSA), and Elliptic-curve cryptography (ECC). +With current technology, key sizes of 2048 bits for RSA and DSA, +or 224 bits for ECC, are regarded as unbreakable. +

    +     + + +

    +Increase the key size to the recommended amount or larger. For RSA or DSA this is at least 2048 bits, for ECC this is at least 224 bits. +

    +     + + +
  • +Wikipedia: +Digital Signature Algorithm. +
    • +
  • +Wikipedia: +RSA cryptosystem. +
    • +
  • +Wikipedia: +Elliptic-curve cryptography. +
    • +
  • +Python cryptography module: +cryptography.io. +
    • +
  • +NIST: + +Recommendation for Transitioning the Use of Cryptographic Algorithms and Key Lengths. +
    • +     +     + diff --git a/python/ql/src/Security/CWE-326/WeakCrypto.ql b/python/ql/src/Security/CWE-326/WeakCrypto.ql new file mode 100644 index 00000000000..cd2937e1f00 --- /dev/null +++ b/python/ql/src/Security/CWE-326/WeakCrypto.ql @@ -0,0 +1,81 @@ +/** + * @name Use of weak cryptographic key + * @description Use of a cryptographic key that is too small may allow the encryption to be broken. + * @kind problem + * @problem.severity error + * @precision high + * @id py/weak-crypto-key + * @tags security + * external/cwe/cwe-326 + */ + +import python + +int minimumSecureKeySize(string algo) { + algo = "DSA" and result = 2048 + or + algo = "RSA" and result = 2048 + or + algo = "ECC" and result = 224 +} + +predicate dsaRsaKeySizeArg(FunctionObject obj, string algorithm, string arg) { + exists(ModuleObject mod | + mod.getAttribute(_) = obj | + algorithm = "DSA" and + ( + mod.getName() = "cryptography.hazmat.primitives.asymmetric.dsa" and arg = "key_size" + or + mod.getName() = "Crypto.PublicKey.DSA" and arg = "bits" + or + mod.getName() = "Cryptodome.PublicKey.DSA" and arg = "bits" + ) + or + algorithm = "RSA" and + ( + mod.getName() = "cryptography.hazmat.primitives.asymmetric.rsa" and arg = "key_size" + or + mod.getName() = "Crypto.PublicKey.RSA" and arg = "bits" + or + mod.getName() = "Cryptodome.PublicKey.RSA" and arg = "bits" + ) + ) +} + +predicate ecKeySizeArg(FunctionObject obj, string arg) { + exists(ModuleObject mod | + mod.getAttribute(_) = obj | + mod.getName() = "cryptography.hazmat.primitives.asymmetric.ec" and arg = "curve" + ) +} + +int keySizeFromCurve(ClassObject curveClass) { + result = curveClass.declaredAttribute("key_size").(NumericObject).intValue() +} + +predicate algorithmAndKeysizeForCall(CallNode call, string algorithm, int keySize, ControlFlowNode keyOrigin) { + exists(FunctionObject func, string argname, ControlFlowNode arg | + arg = func.getNamedArgumentForCall(call, argname) | + exists(NumericObject key | + arg.refersTo(key, keyOrigin) and + dsaRsaKeySizeArg(func, algorithm, argname) and + keySize = key.intValue() + ) + or + exists(ClassObject curve | + arg.refersTo(_, curve, keyOrigin) and + ecKeySizeArg(func, argname) and + algorithm = "ECC" and + keySize = keySizeFromCurve(curve) + ) + ) +} + + +from CallNode call, ControlFlowNode origin, string algo, int keySize +where + algorithmAndKeysizeForCall(call, algo, keySize, origin) and + keySize < minimumSecureKeySize(algo) +select call, "Creation of an " + algo + " key uses $@ bits, which is below " + minimumSecureKeySize(algo) + " and considered breakable.", origin, keySize.toString() + + diff --git a/python/ql/src/analysis/ImportFailure.ql b/python/ql/src/analysis/ImportFailure.ql index 95fd38a3748..38801d8d004 100644 --- a/python/ql/src/analysis/ImportFailure.ql +++ b/python/ql/src/analysis/ImportFailure.ql @@ -68,4 +68,4 @@ where not ie.refersTo(_) and guard.controls(ie.getAFlowNode().getBasicBlock(), true) ) -select ie, "Unable to resolve import of '" + ie.getImportedModuleName() + "'." \ No newline at end of file +select ie, "Unable to resolve import of '" + ie.getImportedModuleName() + "'." diff --git a/python/ql/src/analysis/KeyPointsToFailure.qhelp b/python/ql/src/analysis/KeyPointsToFailure.qhelp deleted file mode 100644 index 4aaf00a6bbc..00000000000 --- a/python/ql/src/analysis/KeyPointsToFailure.qhelp +++ /dev/null @@ -1,11 +0,0 @@ - - - -

    Points-to analysis underpins type inference and thus most of Semmle's Python analysis. -Failures in points-to undermines type inference and reduces the coverage and also accuracy of many queries. -

    - -     -     diff --git a/python/ql/src/analysis/KeyPointsToFailure.ql b/python/ql/src/analysis/KeyPointsToFailure.ql index 46b1156dd7b..0139586aca8 100644 --- a/python/ql/src/analysis/KeyPointsToFailure.ql +++ b/python/ql/src/analysis/KeyPointsToFailure.ql @@ -1,9 +1,10 @@ /** - * @name Key "points-to" fails for expression. + * @name Key points-to fails for expression. * @description Expression does not "point-to" an object which prevents further points-to analysis. * @kind problem * @problem.severity info * @id py/key-points-to-failure + * @deprecated */ import python diff --git a/python/ql/src/analysis/PointsToFailure.qhelp b/python/ql/src/analysis/PointsToFailure.qhelp deleted file mode 100644 index 4aaf00a6bbc..00000000000 --- a/python/ql/src/analysis/PointsToFailure.qhelp +++ /dev/null @@ -1,11 +0,0 @@ - - - -

    Points-to analysis underpins type inference and thus most of Semmle's Python analysis. -Failures in points-to undermines type inference and reduces the coverage and also accuracy of many queries. -

    - -     -     diff --git a/python/ql/src/analysis/PointsToFailure.ql b/python/ql/src/analysis/PointsToFailure.ql index 53c2296c529..5978e60f513 100644 --- a/python/ql/src/analysis/PointsToFailure.ql +++ b/python/ql/src/analysis/PointsToFailure.ql @@ -1,10 +1,11 @@ /** - * @name "points-to" fails for expression. + * @name points-to fails for expression. * @description Expression does not "point-to" an object which prevents type inference. * @kind problem * @id py/points-to-failure * @problem.severity info - * @tags reliability + * @tags debug + * @deprecated */ import python diff --git a/python/ql/src/analysis/TypeHierarchyFailure.qhelp b/python/ql/src/analysis/TypeHierarchyFailure.qhelp index 0f908372272..ef173a90a98 100644 --- a/python/ql/src/analysis/TypeHierarchyFailure.qhelp +++ b/python/ql/src/analysis/TypeHierarchyFailure.qhelp @@ -3,13 +3,15 @@ "qhelp.dtd"> -

    In order to analyse uses of a class, all its attributes need to be known. Without the full inheritance hierarchy this is impossible. -This is an informational query only. +

    In order to analyze uses of a class, all its attributes need to be known. Without the full inheritance hierarchy this is impossible. +This query finds classes where type inference fails and gives some indication as to why that failure occurred.

    This is an informational query only, this query depends on points-to and type inference. +Unlike normal queries it does not indicate any problem with the program being analyzed.

    +     diff --git a/python/ql/src/analysis/TypeHierarchyFailure.ql b/python/ql/src/analysis/TypeHierarchyFailure.ql index 072eba9ac47..8aac3ea236b 100644 --- a/python/ql/src/analysis/TypeHierarchyFailure.ql +++ b/python/ql/src/analysis/TypeHierarchyFailure.ql @@ -1,16 +1,16 @@ /** * @name Inheritance hierarchy cannot be inferred for class - * @description Inability to infer inheritance hierarchy cannot be inferred for class will impair analysis + * @description Inability to infer the inheritance hierarchy for a class will impair analysis. * @id py/failed-inheritance-inference * @kind problem * @problem.severity info + * @tags debug */ - + import python -from Class cls -where not exists(ClassObject c | c.getPyClass() = cls) -or -exists(ClassObject c | c.getPyClass() = cls | c.failedInference()) -select cls, "Inference of class hierarchy failed for class." \ No newline at end of file +from Class cls, string reason +where +exists(ClassObject c | c.getPyClass() = cls | c.failedInference(reason)) +select cls, "Inference of class hierarchy failed for class '" + cls.getName() + "': " + reason + "." diff --git a/python/ql/src/analysis/TypeInferenceFailure.qhelp b/python/ql/src/analysis/TypeInferenceFailure.qhelp deleted file mode 100644 index 3ca947b376d..00000000000 --- a/python/ql/src/analysis/TypeInferenceFailure.qhelp +++ /dev/null @@ -1,13 +0,0 @@ - - - - -

    -Type inference is the key part of Semmle's Python analysis. -Failures in type inference and reduces the coverage and also accuracy of many queries. -

    - -     -     diff --git a/python/ql/src/analysis/TypeInferenceFailure.ql b/python/ql/src/analysis/TypeInferenceFailure.ql index 18744a1a6da..1b8237d65a1 100644 --- a/python/ql/src/analysis/TypeInferenceFailure.ql +++ b/python/ql/src/analysis/TypeInferenceFailure.ql @@ -4,11 +4,12 @@ * @kind problem * @problem.severity info * @id py/type-inference-failure + * @deprecated */ import python -from ControlFlowNode f, Object o +from ControlFlowNode f, Object o where f.refersTo(o) and not exists(ClassObject c | f.refersTo(o, c, _)) select o, "Type inference fails for 'object'." \ No newline at end of file diff --git a/python/ql/src/semmle/python/Files.qll b/python/ql/src/semmle/python/Files.qll index c743b0373c5..b52809db7a7 100644 --- a/python/ql/src/semmle/python/Files.qll +++ b/python/ql/src/semmle/python/Files.qll @@ -339,9 +339,21 @@ abstract class Container extends @container { /** Holds if this folder is the root folder for the standard library. */ predicate isStdLibRoot(int major, int minor) { - allowable_version(major, minor) and - this.isImportRoot() and - this.getBaseName().regexpMatch("python" + major + "." + minor) + major = major_version() and minor = minor_version() and + this.isStdLibRoot() + } + + /** Holds if this folder is the root folder for the standard library. */ + predicate isStdLibRoot() { + /* Look for a standard lib module and find its import path + * We use `os` as it is the most likely to be imported and + * `tty` because it is small for testing. + */ + exists(Module m | + m.getName() = "os" or m.getName() = "tty" + | + m.getFile().getImportRoot() = this + ) } /** Gets the path element from which this container would be loaded. */ @@ -375,12 +387,6 @@ private string get_path(string name) { py_flags_versioned(name, result, _) } -private predicate allowable_version(int major, int minor) { - major = 2 and minor in [6..7] - or - major = 3 and minor in [3..6] -} - class Location extends @location { /** Gets the file for this location */ diff --git a/python/ql/src/semmle/python/Module.qll b/python/ql/src/semmle/python/Module.qll index d42fe53bbc5..c4cf9303e03 100644 --- a/python/ql/src/semmle/python/Module.qll +++ b/python/ql/src/semmle/python/Module.qll @@ -158,7 +158,7 @@ class Module extends Module_, Scope, AstNode { /** Holds if this module is in the standard library */ predicate inStdLib() { - this.inStdLib(_, _) + this.getLoadPath().isStdLibRoot() } override diff --git a/python/ql/src/semmle/python/dependencies/Dependencies.qll b/python/ql/src/semmle/python/dependencies/Dependencies.qll index f328c43c314..0bed12ab54b 100644 --- a/python/ql/src/semmle/python/dependencies/Dependencies.qll +++ b/python/ql/src/semmle/python/dependencies/Dependencies.qll @@ -193,6 +193,7 @@ private predicate defn_of_class_attribute(Assign asgn, Class c, string name) { /* Holds if `value` is a value assigned to the `name`d attribute of module `m`. */ private predicate defn_of_module_attribute(ControlFlowNode value, Module m, string name) { exists(DefinitionNode def | + def.getScope() = m and def.getValue() = value and def.(NameNode).getId() = name ) diff --git a/python/ql/src/semmle/python/dependencies/TechInventory.qll b/python/ql/src/semmle/python/dependencies/TechInventory.qll index 957ed9fe481..87a6c071ab1 100644 --- a/python/ql/src/semmle/python/dependencies/TechInventory.qll +++ b/python/ql/src/semmle/python/dependencies/TechInventory.qll @@ -50,7 +50,7 @@ class DistPackage extends ExternalPackage { parent = this.(ModuleObject).getPath().getParent() and parent.isImportRoot() and /* Not in standard library */ - not parent.isStdLibRoot(_, _) and + not parent.isStdLibRoot() and /* Not in the source */ not exists(parent.getRelativePath()) ) diff --git a/python/ql/test/library-tests/taint/exception_traceback/test.py b/python/ql/test/library-tests/taint/exception_traceback/test.py index 37479bc63db..20573aa8f8b 100644 --- a/python/ql/test/library-tests/taint/exception_traceback/test.py +++ b/python/ql/test/library-tests/taint/exception_traceback/test.py @@ -28,3 +28,7 @@ def foo(): foo() + + +#For test to find stdlib +import os diff --git a/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.expected b/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.expected new file mode 100644 index 00000000000..1813aa1a50d --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.expected @@ -0,0 +1,5 @@ +| jinja2_escaping.py:9:14:9:39 | ControlFlowNode for Environment() | Using jinja2 templates with autoescape=False can potentially allow XSS attacks. | +| jinja2_escaping.py:41:5:41:29 | ControlFlowNode for Environment() | Using jinja2 templates with autoescape=False can potentially allow XSS attacks. | +| jinja2_escaping.py:43:1:43:3 | ControlFlowNode for E() | Using jinja2 templates with autoescape=False can potentially allow XSS attacks. | +| jinja2_escaping.py:44:1:44:15 | ControlFlowNode for E() | Using jinja2 templates with autoescape=False can potentially allow XSS attacks. | +| jinja2_escaping.py:53:15:53:43 | ControlFlowNode for Template() | Using jinja2 templates with autoescape=False can potentially allow XSS attacks. | diff --git a/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.qlref b/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.qlref new file mode 100644 index 00000000000..9fefcf4a030 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-079/Jinja2WithoutEscaping.qlref @@ -0,0 +1 @@ +Security/CWE-079/Jinja2WithoutEscaping.ql diff --git a/python/ql/test/query-tests/Security/CWE-079/ReflectedXss.expected b/python/ql/test/query-tests/Security/CWE-079/ReflectedXss.expected index b60e97ff468..b305b84491e 100644 --- a/python/ql/test/query-tests/Security/CWE-079/ReflectedXss.expected +++ b/python/ql/test/query-tests/Security/CWE-079/ReflectedXss.expected @@ -1,6 +1,8 @@ edges | ../lib/flask/__init__.py:14:19:14:20 | externally controlled string | ../lib/flask/__init__.py:15:19:15:20 | externally controlled string | | ../lib/flask/__init__.py:14:19:14:20 | externally controlled string | ../lib/flask/__init__.py:16:25:16:26 | externally controlled string | +| jinja2_escaping.py:14:12:14:23 | dict of externally controlled string | jinja2_escaping.py:14:12:14:39 | externally controlled string | +| jinja2_escaping.py:14:12:14:39 | externally controlled string | jinja2_escaping.py:16:47:16:50 | externally controlled string | | reflected_xss.py:7:18:7:29 | dict of externally controlled string | reflected_xss.py:7:18:7:45 | externally controlled string | | reflected_xss.py:7:18:7:45 | externally controlled string | reflected_xss.py:8:44:8:53 | externally controlled string | | reflected_xss.py:8:26:8:53 | externally controlled string | ../lib/flask/__init__.py:14:19:14:20 | externally controlled string | diff --git a/python/ql/test/query-tests/Security/CWE-079/jinja2_escaping.py b/python/ql/test/query-tests/Security/CWE-079/jinja2_escaping.py new file mode 100644 index 00000000000..aed840ce886 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-079/jinja2_escaping.py @@ -0,0 +1,55 @@ + +Environment(loader=templateLoader, autoescape=fake_func()) +from flask import Flask, request, make_response, escape +from jinja2 import Environment, select_autoescape, FileSystemLoader, Template + +app = Flask(__name__) +loader = FileSystemLoader( searchpath="templates/" ) + +unsafe_env = Environment(loader=loader) +safe1_env = Environment(loader=loader, autoescape=True) +safe2_env = Environment(loader=loader, autoescape=select_autoescape()) + +def render_response_from_env(env): + name = request.args.get('name', '') + template = env.get_template('template.html') + return make_response(template.render(name=name)) + +@app.route('/unsafe') +def unsafe(): + return render_response_from_env(unsafe_env) + +@app.route('/safe1') +def safe1(): + return render_response_from_env(safe1_env) + +@app.route('/safe2') +def safe2(): + return render_response_from_env(safe2_env) + +# Explicit autoescape + +e = Environment( + loader=loader, + autoescape=select_autoescape(['html', 'htm', 'xml']) +) # GOOD + +# Additional checks with flow. +auto = select_autoescape +e = Environment(autoescape=auto) # GOOD +z = 0 +e = Environment(autoescape=z) # BAD +E = Environment +E() # BAD +E(autoescape=z) # BAD +E(autoescape=auto) # GOOD +E(autoescape=0+1) # GOOD + +def checked(cond=False): + if cond: + e = Environment(autoescape=cond) # GOOD + + +unsafe_tmpl = Template('Hello {{ name }}!') +safe1_tmpl = Template('Hello {{ name }}!', autoescape=True) +safe2_tmpl = Template('Hello {{ name }}!', autoescape=select_autoescape()) diff --git a/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.expected b/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.expected new file mode 100644 index 00000000000..3a23ea54ee2 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.expected @@ -0,0 +1,3 @@ +| test.py:10:1:10:19 | ControlFlowNode for Attribute() | A Flask app appears to be run in debug mode. This may allow an attacker to run arbitrary code through the debugger. | +| test.py:25:1:25:20 | ControlFlowNode for Attribute() | A Flask app appears to be run in debug mode. This may allow an attacker to run arbitrary code through the debugger. | +| test.py:29:1:29:20 | ControlFlowNode for Attribute() | A Flask app appears to be run in debug mode. This may allow an attacker to run arbitrary code through the debugger. | diff --git a/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.qlref b/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.qlref new file mode 100644 index 00000000000..0e21a3ac14f --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-215/FlaskDebug.qlref @@ -0,0 +1 @@ +Security/CWE-215/FlaskDebug.ql diff --git a/python/ql/test/query-tests/Security/CWE-215/options b/python/ql/test/query-tests/Security/CWE-215/options new file mode 100644 index 00000000000..84717fe64cf --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-215/options @@ -0,0 +1 @@ +semmle-extractor-options: --max-import-depth=2 -p ../lib diff --git a/python/ql/test/query-tests/Security/CWE-215/test.py b/python/ql/test/query-tests/Security/CWE-215/test.py new file mode 100644 index 00000000000..6054caf1d33 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-215/test.py @@ -0,0 +1,37 @@ +from flask import Flask + +app = Flask(__name__) + +@app.route('/crash') +def main(): + raise Exception() + +# bad +app.run(debug=True) + +# okay +app.run() +app.run(debug=False) + +# also okay +run(debug=True) + +app.notrun(debug=True) + +# a slightly more involved example using flow and truthy values + +DEBUG = True + +app.run(debug=DEBUG) + +DEBUG = 1 + +app.run(debug=DEBUG) + +if False: + app.run(debug=True) + +# false negative + +runapp = app.run +runapp(debug=True) diff --git a/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.expected b/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.expected new file mode 100644 index 00000000000..5406d5a9b0b --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.expected @@ -0,0 +1,5 @@ +| make_request.py:5:1:5:48 | ControlFlowNode for Attribute() | Call to $@ with verify=$@ | ../lib/requests.py:2:1:2:36 | Function get | requests.get | make_request.py:5:43:5:47 | ControlFlowNode for False | False | +| make_request.py:7:1:7:49 | ControlFlowNode for Attribute() | Call to $@ with verify=$@ | ../lib/requests.py:11:1:11:46 | Function post | requests.post | make_request.py:7:44:7:48 | ControlFlowNode for False | False | +| make_request.py:12:1:12:39 | ControlFlowNode for put() | Call to $@ with verify=$@ | ../lib/requests.py:14:1:14:34 | Function put | requests.put | make_request.py:12:34:12:38 | ControlFlowNode for False | False | +| make_request.py:28:5:28:46 | ControlFlowNode for patch() | Call to $@ with verify=$@ | ../lib/requests.py:17:1:17:36 | Function patch | requests.patch | make_request.py:30:6:30:10 | ControlFlowNode for False | False | +| make_request.py:34:1:34:45 | ControlFlowNode for Attribute() | Call to $@ with verify=$@ | ../lib/requests.py:11:1:11:46 | Function post | requests.post | make_request.py:34:44:34:44 | ControlFlowNode for IntegerLiteral | False | diff --git a/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.qlref b/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.qlref new file mode 100644 index 00000000000..7ad4d4d2ae3 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-295/RequestWithoutValidation.qlref @@ -0,0 +1 @@ +Security/CWE-295/RequestWithoutValidation.ql diff --git a/python/ql/test/query-tests/Security/CWE-295/make_request.py b/python/ql/test/query-tests/Security/CWE-295/make_request.py new file mode 100644 index 00000000000..9d732713dbf --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-295/make_request.py @@ -0,0 +1,34 @@ +import requests + +#Simple cases +requests.get('https://semmle.com', verify=True) # GOOD +requests.get('https://semmle.com', verify=False) # BAD +requests.post('https://semmle.com', verify=True) # GOOD +requests.post('https://semmle.com', verify=False) # BAD + +# Simple flow +put = requests.put +put('https://semmle.com', verify="/path/to/cert/") # GOOD +put('https://semmle.com', verify=False) # BAD + +#Other flow +delete = requests.delete + +def req1(verify=False): + delete('https://semmle.com', verify) # BAD + if verify: + delete('https://semmle.com', verify) # GOOD + if not verify: + return + delete('https://semmle.com', verify) # GOOD + +patch = requests.patch + +def req2(verify): + patch('https://semmle.com', verify=verify) # BAD (from line 30) + +req2(False) # BAD (at line 28) +req2("/path/to/cert/") # GOOD + +#Falsey value +requests.post('https://semmle.com', verify=0) # BAD diff --git a/python/ql/test/query-tests/Security/CWE-295/options b/python/ql/test/query-tests/Security/CWE-295/options new file mode 100644 index 00000000000..492768b3481 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-295/options @@ -0,0 +1 @@ +semmle-extractor-options: -p ../lib/ --max-import-depth=3 diff --git a/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.expected b/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.expected new file mode 100644 index 00000000000..447b1d9c4aa --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.expected @@ -0,0 +1,5 @@ +| weak_crypto.py:67:1:67:30 | ControlFlowNode for dsa_gen_key() | Creation of an DSA key uses $@ bits, which is below 2048 and considered breakable. | weak_crypto.py:12:12:12:15 | ControlFlowNode for IntegerLiteral | 1024 | +| weak_crypto.py:68:1:68:28 | ControlFlowNode for ec_gen_key() | Creation of an ECC key uses $@ bits, which is below 224 and considered breakable. | weak_crypto.py:21:11:21:33 | ControlFlowNode for FakeWeakEllipticCurve() | 160 | +| weak_crypto.py:69:1:69:37 | ControlFlowNode for rsa_gen_key() | Creation of an RSA key uses $@ bits, which is below 2048 and considered breakable. | weak_crypto.py:12:12:12:15 | ControlFlowNode for IntegerLiteral | 1024 | +| weak_crypto.py:71:1:71:22 | ControlFlowNode for Attribute() | Creation of an DSA key uses $@ bits, which is below 2048 and considered breakable. | weak_crypto.py:12:12:12:15 | ControlFlowNode for IntegerLiteral | 1024 | +| weak_crypto.py:72:1:72:22 | ControlFlowNode for Attribute() | Creation of an RSA key uses $@ bits, which is below 2048 and considered breakable. | weak_crypto.py:12:12:12:15 | ControlFlowNode for IntegerLiteral | 1024 | diff --git a/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.qlref b/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.qlref new file mode 100644 index 00000000000..75676139ac3 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-326/WeakCrypto.qlref @@ -0,0 +1 @@ +Security/CWE-326/WeakCrypto.ql diff --git a/python/ql/test/query-tests/Security/CWE-326/options b/python/ql/test/query-tests/Security/CWE-326/options new file mode 100644 index 00000000000..dce78f52325 --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-326/options @@ -0,0 +1,2 @@ +semmle-extractor-options: -p ../lib/ --max-import-depth=3 +optimize: true diff --git a/python/ql/test/query-tests/Security/CWE-326/weak_crypto.py b/python/ql/test/query-tests/Security/CWE-326/weak_crypto.py new file mode 100644 index 00000000000..bc5ea46baad --- /dev/null +++ b/python/ql/test/query-tests/Security/CWE-326/weak_crypto.py @@ -0,0 +1,73 @@ +from cryptography.hazmat import backends +from cryptography.hazmat.primitives.asymmetric import ec, dsa, rsa + +#Crypto and Cryptodome have same API +if random(): + from Crypto.PublicKey import DSA + from Crypto.PublicKey import RSA +else: + from Cryptodome.PublicKey import DSA + from Cryptodome.PublicKey import RSA + +RSA_WEAK = 1024 +RSA_OK = 2048 +RSA_STRONG = 3076 +BIG = 10000 + +class FakeWeakEllipticCurve: + name = "fake" + key_size = 160 + +EC_WEAK = FakeWeakEllipticCurve() +EC_OK = ec.SECP224R1() +EC_STRONG = ec.SECP384R1() +EC_BIG = ec.SECT571R1() + +dsa_gen_key = dsa.generate_private_key +ec_gen_key = ec.generate_private_key +rsa_gen_key = rsa.generate_private_key + +default = backends.default_backend() + +#Strong and OK keys. + +dsa_gen_key(key_size=RSA_OK, backend=default) +dsa_gen_key(key_size=RSA_STRONG, backend=default) +dsa_gen_key(key_size=BIG, backend=default) +ec_gen_key(key_size=EC_OK, backend=default) +ec_gen_key(key_size=EC_STRONG, backend=default) +ec_gen_key(key_size=EC_BIG, backend=default) +rsa_gen_key(public_exponent=65537, key_size=RSA_OK, backend=default) +rsa_gen_key(public_exponent=65537, key_size=RSA_STRONG, backend=default) +rsa_gen_key(public_exponent=65537, key_size=BIG, backend=default) + +DSA.generate(bits=RSA_OK) +DSA.generate(bits=RSA_STRONG) +RSA.generate(bits=RSA_OK) +RSA.generate(bits=RSA_STRONG) + +dsa_gen_key(RSA_OK, default) +dsa_gen_key(RSA_STRONG, default) +dsa_gen_key(BIG, default) +ec_gen_key(EC_OK, default) +ec_gen_key(EC_STRONG, default) +ec_gen_key(EC_BIG, default) +rsa_gen_key(65537, RSA_OK, default) +rsa_gen_key(65537, RSA_STRONG, default) +rsa_gen_key(65537, BIG, default) + +DSA.generate(RSA_OK) +DSA.generate(RSA_STRONG) +RSA.generate(RSA_OK) +RSA.generate(RSA_STRONG) + + +# Weak keys + +dsa_gen_key(RSA_WEAK, default) +ec_gen_key(EC_WEAK, default) +rsa_gen_key(65537, RSA_WEAK, default) + +DSA.generate(RSA_WEAK) +RSA.generate(RSA_WEAK) + diff --git a/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/DSA.py b/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/DSA.py new file mode 100644 index 00000000000..e002a77697e --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/DSA.py @@ -0,0 +1,2 @@ +def generate(bits): + pass diff --git a/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/RSA.py b/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/RSA.py new file mode 100644 index 00000000000..e002a77697e --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/RSA.py @@ -0,0 +1,2 @@ +def generate(bits): + pass diff --git a/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/__init__.py b/python/ql/test/query-tests/Security/lib/Crypto/PublicKey/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/__init__.py b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/dsa.py b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/dsa.py new file mode 100644 index 00000000000..b4c37f6b540 --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/dsa.py @@ -0,0 +1,4 @@ + +def generate_private_key(key_size, backend): + pass + diff --git a/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/ec.py b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/ec.py new file mode 100644 index 00000000000..d2eb4b0f1af --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/ec.py @@ -0,0 +1,22 @@ + +def generate_private_key(curve, backend): + pass + +class SECT571R1(object): + name = "sect571r1" + key_size = 570 + + +class SECP384R1(object): + name = "secp384r1" + key_size = 384 + + +class SECP224R1(object): + name = "secp224r1" + key_size = 224 + + +class SECT163K1(object): + name = "sect163k1" + key_size = 163 \ No newline at end of file diff --git a/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/rsa.py b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/rsa.py new file mode 100644 index 00000000000..3a5c91734c2 --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/cryptography/hazmat/primitives/asymmetric/rsa.py @@ -0,0 +1,3 @@ + +def generate_private_key(public_exponent, key_size, backend): + pass diff --git a/python/ql/test/query-tests/Security/lib/flask/__init__.py b/python/ql/test/query-tests/Security/lib/flask/__init__.py index 033c49b93cd..9277dc33563 100644 --- a/python/ql/test/query-tests/Security/lib/flask/__init__.py +++ b/python/ql/test/query-tests/Security/lib/flask/__init__.py @@ -1,7 +1,7 @@ class Flask(object): - pass + def run(self, *args, **kwargs): pass from .globals import request diff --git a/python/ql/test/query-tests/Security/lib/jinja2.py b/python/ql/test/query-tests/Security/lib/jinja2.py new file mode 100644 index 00000000000..41697651c4c --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/jinja2.py @@ -0,0 +1,20 @@ + +class Environment(object): + + def __init__(self, loader, autoescape): + pass + +class Template(object): + + def __init__(self, source, autoescape): + pass + +def select_autoescape(files=[]): + def autoescape(template_name): + pass + return autoescape + +class FileSystemLoader(object): + + def __init__(self, searchpath): + pass diff --git a/python/ql/test/query-tests/Security/lib/requests.py b/python/ql/test/query-tests/Security/lib/requests.py new file mode 100644 index 00000000000..01afdbb1208 --- /dev/null +++ b/python/ql/test/query-tests/Security/lib/requests.py @@ -0,0 +1,21 @@ + +def get(url, params=None, **kwargs): + pass + +def options(url, **kwargs): + pass + +def head(url, **kwargs): + pass + +def post(url, data=None, json=None, **kwargs): + pass + +def put(url, data=None, **kwargs): + pass + +def patch(url, data=None, **kwargs): + pass + +def delete(url, **kwargs): + pass